diff --git a/content/llm-full.txt b/content/llm-full.txt
new file mode 100644
index 0000000000..ad838ee14f
--- /dev/null
+++ b/content/llm-full.txt
@@ -0,0 +1,418284 @@
+---
+description: An overview of Redis APIs for developers and operators
+hideListLinks: true
+linkTitle: APIs
+title: APIs
+type: develop
+---
+
+Redis provides a number of APIs for developers and operators. The following sections provide you easy access to the client API, the several programmability APIs, the RESTFul management APIs and the Kubernetes resource defintions.
+
+## APIs for Developers
+
+### Client API
+
+Redis comes with a wide range of commands that help you to develop real-time applications. You can find a complete overview of the Redis commands here:
+
+- [Redis commands]({{< relref "/commands/" >}})
+
+As a developer, you will likely use one of our supported client libraries for connecting and executing commands.
+
+- [Connect with Redis clients introduction]({{< relref "/develop/clients" >}})
+
+### Programmability APIs
+
+The existing Redis commands cover most use cases, but if low latency is a critical requirement, you might need to extend Redis' server-side functionality.
+
+Lua scripts have been available since early versions of Redis. With Lua, the script is provided by the client and cached on the server side, which implies the risk that different clients might use a different script version.
+
+- [Redis Lua API reference]({{< relref "/develop/interact/programmability/lua-api" >}})
+- [Scripting with Lua introduction]({{< relref "/develop/interact/programmability/eval-intro" >}})
+
+The Redis functions feature, which became available in Redis 7, supersedes the use of Lua in prior versions of Redis. The client is still responsible for invoking the execution, but unlike the previous Lua scripts, functions can now be replicated and persisted.
+
+- [Functions and scripting in Redis 7 and beyond]({{< relref "/develop/interact/programmability/functions-intro" >}})
+
+If none of the previous methods fulfills your needs, then you can extend the functionality of Redis with new commands using the Redis Modules API. 
+
+- [Redis Modules API introduction]({{< relref "/develop/reference/modules/" >}})
+- [Redis Modules API reference]({{< relref "/develop/reference/modules/modules-api-ref" >}})
+
+## APIs for Operators
+
+### Redis Cloud API
+Redis Cloud is a fully managed Database as a Service offering and the fastest way to deploy Redis at scale. You can programmatically manage your databases, accounts, access, and credentials using the Redis Cloud REST API.
+
+- [Redis Cloud REST API introduction]({{< relref "/operate/rc/api/" >}})
+- [Redis Cloud REST API examples]({{< relref "/operate/rc/api/examples/" >}})
+- [Redis Cloud REST API reference]({{< relref "/operate/rc/api/api-reference" >}})
+
+
+### Redis Enterprise Software API
+If you have installed Redis Enterprise Software, you can automate operations with the Redis Enterprise REST API.
+
+- [Redis Enterprise Software REST API introduction]({{< relref "/operate/rs/references/rest-api/" >}})
+- [Redis Enterprise Software REST API requests]({{< relref "/operate/rs/references/rest-api/requests/" >}})
+- [Redis Enterprise Software REST API objects]({{< relref "/operate/rs/references/rest-api/objects/" >}})
+
+
+### Redis Enterprise for Kubernetes API
+
+If you need to install Redis Enterprise on Kubernetes, then you can use the [Redis Enterprise for Kubernetes Operators]({{< relref "/operate/Kubernetes/" >}}). You can find the resource definitions here:
+
+- [Redis Enterprise Cluster API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}})
+- [Redis Enterprise Database API]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api">}})
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Discover the differences between `ioredis` and `node-redis`.
+linkTitle: Migrate from ioredis
+title: Migrate from ioredis
+weight: 6
+---
+
+Redis previously recommended the [`ioredis`](https://github.com/redis/ioredis)
+client library for development with [Node.js](https://nodejs.org/en),
+but this library is now deprecated in favor of
+[`node-redis`]({{< relref "/develop/clients/nodejs" >}}). 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.
+
+### Connection
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+| [Initial connection](#initial-connection) | Happens when you create a client instance | Requires you to call a method on the client instance |
+| [Reconnection after a connection is lost](#reconnection) | Automatic by default | Manual by default |
+| [Connection events](#connection-events) | Emits `connect`, `ready`, `error`, and `close` events | Emits `connect`, `ready`, `error`, `end`, and `reconnecting` events |
+
+### Command handling
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+| [Command case](#command-case) | Lowercase only (eg, `hset`) | Uppercase or camel case (eg, `HSET` or `hSet`) |
+| [Command argument handling](#command-argument-handling) | Argument objects flattened and items passed directly | Argument objects parsed to generate correct argument list |
+| [Asynchronous command result handling](#async-result) | Callbacks and Promises | Promises only |
+| [Arbitrary command execution](#arbitrary-command-execution) | Uses the `call()` method | Uses the `sendCommand()` method |
+
+### Techniques
+
+| Feature | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+| [Pipelining](#pipelining) | Automatic, or with `pipeline()` command | Automatic, or with `multi()` command |
+| [Scan iteration](#scan-iteration) | Uses `scanStream()`, etc | Uses `scanIterator()`, etc |
+| [Subscribing to channels](#subscribing-to-channels) | Uses `client.on('message', ...)` event | Uses `subscribe(...)` command |
+
+### Specific commands
+
+| Command | `ioredis` | `node-redis` |
+| :-- | :-- | :-- |
+| [`SETNX`](#setnx-command) | Supported explicitly | Supported as an option for `SET` |
+| [`HMSET`](#hmset-command) | Supported explicitly | Supported with standard `HSET` functionality |
+| [`CONFIG`](#config-command) | Supported explicitly | Supported with separate `configGet()`, `configSet()`, etc |co
+
+## Details
+
+The sections below explain the points of comparison between `ioredis` and
+`node-redis` in more detail.
+
+### Initial connection
+
+`ioredis` makes the connection to the Redis server when you create an instance
+of the client object:
+
+```js
+const client = require('ioredis');
+
+// Connects to localhost:6379 on instantiation.
+const client = new Redis();
+```
+
+`node-redis` requires you to call the `connect()` method on the client object
+to make the connection:
+
+```js
+import { createClient } from 'redis';
+
+const client = await createClient();
+await client.connect(); // Requires explicit connection.
+```
+
+### Reconnection after a connection is lost {#reconnection}
+
+`ioredis` automatically attempts to reconnect if the connection
+was lost due to an error. By default, `node-redis` doesn't attempt
+to reconnect, but you can enable a custom reconnection strategy
+when you create the client object. See
+[Reconnect after disconnection]({{< relref "/develop/clients/nodejs/connect#reconnect-after-disconnection" >}})
+for more information.
+
+### Connection events
+
+The `connect`, `ready`, `error`, and `close` events that `ioredis` emits
+are equivalent to the `connect`, `ready`, `error`, and `end` events
+in `node-redis`, but `node-redis` also emits a `reconnecting` event.
+See [Connection events]({{< relref "/develop/clients/nodejs/connect#connection-events" >}})
+for more information.
+
+### Command case
+
+Command methods in `ioredis` are always lowercase. With `node-redis`, you can
+use uppercase or camel case versions of the method names.
+
+```js
+// ioredis
+client.hset('key', 'field', 'value');
+
+// node-redis
+client.HSET('key', 'field', 'value');
+
+// ...or
+client.hSet('key', 'field', 'value');
+```
+
+### Command argument handling
+
+`ioredis` parses command arguments to strings and then passes them to
+the server, in a similar way to [`redis-cli`]({{< relref "/develop/tools/cli" >}}).
+
+```js
+// Equivalent to the command line `SET key 100 EX 10`.
+client.set('key', 100, 'EX', 10);
+```
+
+Arrays passed as arguments are flattened into individual elements and
+objects are flattened into sequential key-value pairs:
+
+```js
+// These commands are all equivalent.
+client.hset('user' {
+    name: 'Bob',
+    age: 20,
+    description: 'I am a programmer',
+});
+
+client.hset('user', ['name', 'Bob', 'age', 20, 'description', 'I am a programmer']);
+
+client.hset('user', 'name', 'Bob', 'age', 20, 'description', 'I am a programmer');
+```
+
+`node-redis` uses predefined formats for command arguments. These include specific
+classes for commmand options that generally don't correspond to the syntax
+of the CLI command. Internally, `node-redis` constructs the correct command using
+the method arguments you pass:
+
+```js
+// Equivalent to the command line `SET bike:5 bike EX 10`.
+client.set('bike:5', 'bike', {EX: 10});
+```
+
+### Asynchronous command result handling {#async-result}
+
+All commands for both `ioredis` and `node-redis` are executed
+asynchronously. `ioredis` supports both callbacks and
+[`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+return values to respond to command results:
+
+```js
+// Callback
+client.get('mykey', (err, result) => {
+  if (err) {
+    console.error(err);
+  } else {
+    console.log(result);
+  }
+});
+
+// Promise
+client.get('mykey').then(
+    (result) => {
+        console.log(result);
+    },
+    (err) => {
+        console.error(err);
+    }
+);
+```
+
+`node-redis` supports only `Promise` objects for results, so
+you must always use a `then()` handler or the
+[`await`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await)
+operator to receive them.
+
+### Arbitrary command execution
+
+`ioredis` lets you issue arbitrary commands in a similar format to
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) using the `call()`
+command:
+
+```js
+await client.call('JSON.SET', 'doc', "$", '{"f1": {"a":1}, "f2":{"a":2}}');
+```
+
+In `node-redis`, you can get the same effect outside a transaction using `sendCommand()`:
+
+```js
+await client.sendCommand(['hset', 'hash2', 'number', '3']);
+```
+
+Within a transaction, use `addCommand()` to include arbitrary commands. Note that
+you can freely mix `addCommand()` calls with standard commands in the same
+transaction:
+
+```js
+const responses = await client.multi()
+  .addCommand(['hset', 'hash3', 'number', '4'])
+  .hGet('hash3', 'number')
+  .exec();
+```
+
+### Pipelining
+
+Both `ioredis` and `node-redis` will pipeline commands automatically if
+they are executed in the same "tick" of the
+[event loop](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick#what-is-the-event-loop)
+(see
+[Execute a pipeline]({{< relref "/develop/clients/nodejs/transpipe#execute-a-pipeline" >}})
+for more information).
+
+You can also create a pipeline with explicit commands in both clients.
+With `ioredis`, you use the `pipeline()` command with a chain of
+commands, ending with `exec()` to run the pipeline:
+
+```js
+// ioredis example
+client.pipeline()
+    .set('foo', '1')
+    .get('foo')
+    .set('foo', '2')
+    .incr('foo')
+    .get('foo')
+    .exec(function (err, results) {
+      // Handle results or errors.
+    });
+```
+
+For `node-redis`, the approach is similar, except that you call the `multi()`
+command to start the pipeline and `execAsPipeline()` to run it:
+
+```js
+client.multi()
+    .set('seat:3', '#3')
+    .set('seat:4', '#4')
+    .set('seat:5', '#5')
+    .execAsPipeline()
+    .then((results) => {
+        // Handle array of results.
+    },
+    (err) => {
+        // Handle errors.
+    });
+```
+
+### Scan iteration
+
+`ioredis` supports the `scanStream()` method to create a readable stream
+from the set of keys returned by the [`SCAN`]({{< relref "/commands/scan" >}})
+command:
+
+```js
+const client = new Redis();
+// Create a readable stream (object mode)
+const stream = client.scanStream();
+stream.on('data', (resultKeys) => {
+  // `resultKeys` is an array of strings representing key names.
+  // Note that resultKeys may contain 0 keys, and that it will sometimes
+  // contain duplicates due to SCAN's implementation in Redis.
+  for (let i = 0; i < resultKeys.length; i++) {
+    console.log(resultKeys[i]);
+  }
+});
+stream.on('end', () => {
+  console.log('all keys have been visited');
+});
+```
+
+You can also use the similar `hscanStream()`, `sscanStream()`, and
+`zscanStream()` to iterate over the items of a hash, set, or sorted set,
+respectively.
+
+`node-redis` handles scan iteration using the `scanIterator()` method
+(and the corresponding `hscanIterator()`, `sscanIterator()`, and
+`zscanIterator()` methods). These return a collection object for
+each page scanned by the cursor (this can be helpful to improve
+efficiency using [`MGET`]({{< relref "/commands/mget" >}}) and
+other multi-key commands):
+
+```js
+for await (const keys of client.scanIterator()) {
+  const values = await client.mGet(keys);
+  // Process values...
+}
+```
+
+### Subscribing to channels
+
+`ioredis` reports incoming pub/sub messages with a `message`
+event on the client object (see
+[Publish/subscribe]({{< relref "/develop/interact/pubsub" >}}) for more
+information about messages):
+
+```js
+client.on('message', (channel, message) => {
+   console.log(Received message from ${channel}: ${message});
+});
+```
+
+With `node-redis`, you use the `subscribe()` command to register the
+message callback. Also, when you use a connection to subscribe, that
+connection can't issue any other commands, so you must create a
+dedicated connection for the subscription. Use the `client.duplicate()`
+method to create a new connection with the same settings as the original:
+
+```js
+const subscriber = client.duplicate();
+await subscriber.connect();
+
+await subscriber.subscribe('channel', (message) => {
+   console.log(Received message: ${message});
+});
+```
+
+### `SETNX` command
+
+`ioredis` implements the  [`SETNX`]({{< relref "/commands/setnx" >}})
+command with an explicit method:
+
+```js
+client.setnx('bike:1', 'bike');
+```
+
+`node-redis` doesn't provide a `SETNX` method but implements the same
+functionality with the `NX` option to the [`SET`]({{< relref "/commands/set" >}})
+command:
+
+```js
+await client.set('bike:1', 'bike', {'NX': true});
+```
+
+### `HMSET` command
+
+The [`HMSET`]({{< relref "/commands/hmset" >}}) command has been deprecated
+since Redis v4.0.0, but it is still supported by `ioredis`. With `node-redis`
+you should use the [`HSET`]({{< relref "/commands/hset" >}}) command with
+multiple key-value pairs. See the [`HSET`]({{< relref "/commands/hset" >}})
+command page for more information.
+
+### `CONFIG` command
+
+`ioredis` supports a `config()` method to set or get server configuration
+options:
+
+```js
+client.config('SET', 'notify-keyspace-events', 'KEA');
+```
+
+`node-redis` doesn't have a `config()` method, but instead supports the
+standard commands [`configSet()`]({{< relref "/commands/config-set" >}}),
+[`configGet()`]({{< relref "/commands/config-get" >}}),
+[`configResetStat()`]({{< relref "/commands/config-resetstat" >}}), and
+[`configRewrite`]({{< relref "/commands/config-rewrite" >}}):
+
+```js
+await client.configSet('maxclients', '2000');
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 4
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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](https://nodejs.org/en/learn/asynchronous-work/event-loop-timers-and-nexttick#what-is-the-event-loop).
+You can ensure that commands happen in the same tick very easily by including them in a
+[`Promise.all()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/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.
+
+```js
+await Promise.all([
+  client.set('seat:0', '#0'),
+  client.set('seat:1', '#1'),
+  client.set('seat:2', '#2'),
+]).then((results) =>{
+    console.log(results);
+    // >>> ['OK', 'OK', 'OK']
+});
+
+await Promise.all([
+    client.get('seat:0'),
+    client.get('seat:1'),
+    client.get('seat:2'),
+]).then((results) =>{
+    console.log(results);
+    // >>> ['#0', '#1', '#2']
+});
+```
+
+You can also create a pipeline object using the
+[`multi()`]({{< relref "/commands/multi" >}}) method
+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
+`execAsPipeline()` method on the pipeline object. Again, the
+`then(...)` callback is optional.
+
+```js
+await client.multi()
+    .set('seat:3', '#3')
+    .set('seat:4', '#4')
+    .set('seat:5', '#5')
+    .execAsPipeline()
+    .then((results) => {
+        console.log(results);
+        // >>> ['OK', 'OK', 'OK']
+    });
+```
+
+The two approaches are almost equivalent, but they have different behavior
+when the connection is lost during the execution of the pipeline. After
+the connection is re-established, a `Promise.all()` pipeline will
+continue execution from the point where the interruption happened,
+but a `multi()` pipeline will discard any remaining commands that
+didn't execute.
+
+## Execute a transaction
+
+A transaction works in a similar way to a pipeline. Create a
+transaction object with the `multi()` command, call command methods
+on that object, and then call the transaction object's 
+`exec()` method to execute it.
+
+```js
+const [res1, res2, res3] = await client.multi()
+    .incrBy("counter:1", 1)
+    .incrBy("counter:2", 2)
+    .incrBy("counter:3", 3)
+    .exec();
+
+console.log(res1); // >>> 1
+console.log(res2); // >>> 2
+console.log(res3); // >>> 3
+```
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The code below reads a string
+that represents a `PATH` variable for a command shell, then appends a new
+command path to the string before attempting to write it back. If the watched
+key is modified by another client before writing, the transaction aborts.
+Note that you should call read-only commands for the watched keys synchronously on
+the usual `client` object but you still call commands for the transaction on the
+transaction object created with `multi()`.
+
+For production usage, you would generally call code like the following in
+a loop to retry it until it succeeds or else report or log the failure.
+
+```js
+// Set initial value of `shellpath`.
+client.set('shellpath', '/usr/syscmds/');
+
+// Watch the key we are about to update.
+await client.watch('shellpath');
+
+const currentPath = await client.get('shellpath');
+const newPath = currentPath + ':/usr/mycmds/';
+
+// Attempt to write the watched key.
+await client.multi()    
+    .set('shellpath', newPath)
+    .exec()
+    .then((result) => {
+        // This is called when the pipeline executes
+        // successfully.
+        console.log(result);
+    }, (err) => {
+        // This is called when a watched key was changed.
+        // Handle the error here.
+        console.log(err);
+    });
+
+const updatedPath = await client.get('shellpath');
+console.log(updatedPath);
+// >>> /usr/syscmds/:/usr/mycmds/
+```
+
+In an environment where multiple concurrent requests are sharing a connection
+(such as a web server), you must use a connection pool to get an isolated connection,
+as shown below:
+
+```js
+import { createClientPool } from 'redis';
+
+const pool = await createClientPool()
+  .on('error', err => console.error('Redis Client Pool Error', err));
+
+try {
+  await pool.execute(async client => {
+    await client.watch('key');
+
+    const multi = client.multi()
+      .ping()
+      .get('key');
+
+    if (Math.random() > 0.5) {
+      await client.watch('another-key');
+      multi.set('another-key', await client.get('another-key') / 2);
+    }
+
+    return multi.exec();
+  });
+} catch (err) {
+  if (err instanceof WatchError) {
+    // the transaction aborted
+  }
+}
+```
+
+This is important because the server tracks the state of the WATCH on a
+per-connection basis, and concurrent WATCH and MULTI/EXEC calls on the same
+connection will interfere with one another. See
+[`RedisClientPool`](https://github.com/redis/node-redis/blob/master/docs/pool.md)
+for more information.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 3
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}) 
+reference page for more information).
+
+Vector fields can store *text embeddings*, which are AI-generated vector
+representations of text content. The
+[vector distance]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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`](https://www.npmjs.com/package/@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](#differences-with-json-documents).
+
+## Initialize
+
+Install the required dependencies:
+
+1. Install [`node-redis`]({{< relref "/develop/clients/nodejs" >}}) if you haven't already.
+2. Install `@xenova/transformers`:
+
+```bash
+npm install @xenova/transformers
+```
+
+In your JavaScript source file, import the required classes:
+
+```js
+import * as transformers from '@xenova/transformers';
+import {
+    VectorAlgorithms,
+    createClient,
+    SCHEMA_FIELD_TYPE,
+} from 'redis';
+```
+
+The `@xenova/transformers` module handles embedding models. This example uses the
+[`all-distilroberta-v1`](https://huggingface.co/sentence-transformers/all-distilroberta-v1)
+model, which:
+- Generates 768-dimensional vectors
+- Truncates input to 128 tokens
+- Uses word piece tokenization (see [Word piece tokenization](https://huggingface.co/learn/nlp-course/en/chapter6/6)
+  at the [Hugging Face](https://huggingface.co/) docs for details)
+
+The `pipe` function generates embeddings. The `pipeOptions` object specifies how to generate sentence embeddings from token embeddings (see the
+[`all-distilroberta-v1`](https://huggingface.co/sentence-transformers/all-distilroberta-v1)
+documentation for details):
+
+```js
+let pipe = await transformers.pipeline(
+    'feature-extraction', 'Xenova/all-distilroberta-v1'
+);
+
+const pipeOptions = {
+    pooling: 'mean',
+    normalize: true,
+};
+```
+
+## Create the index
+
+First, connect to Redis and remove any existing index named `vector_idx`:
+
+```js
+const client = createClient({url: 'redis://localhost:6379'});
+await client.connect();
+
+try { 
+    await client.ft.dropIndex('vector_idx'); 
+} catch (e) {
+    // Index doesn't exist, which is fine
+}
+```
+
+Next, create the index with the following schema:
+-   `content`: Text field for the content to index
+-   `genre`: [Tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+    field representing the text's genre
+-   `embedding`: [Vector]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}})
+    field with:
+    -   [HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}})
+        indexing
+    -   [L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+        distance metric
+    -   Float32 values
+    -   768 dimensions (matching the embedding model)
+
+```js
+await client.ft.create('vector_idx', {
+    'content': {
+        type: SchemaFieldTypes.TEXT,
+    },
+    'genre': {
+        type: SchemaFieldTypes.TAG,
+    },
+    'embedding': {
+        type: SchemaFieldTypes.VECTOR,
+        TYPE: 'FLOAT32',
+        ALGORITHM: VectorAlgorithms.HNSW,
+        DISTANCE_METRIC: 'L2',
+        DIM: 768,
+    }
+}, {
+    ON: 'HASH',
+    PREFIX: 'doc:'
+});
+```
+
+## Add data
+
+Add data objects to the index using `hSet()`. The index automatically processes objects with the `doc:` prefix.
+
+For each document:
+1. Generate an embedding using the `pipe()` function and `pipeOptions`
+2. Convert the embedding to a binary string using `Buffer.from()`
+3. Store the document with `hSet()`
+
+Use `Promise.all()` to batch the commands and reduce network round trips:
+
+```js
+const sentence1 = 'That is a very happy person';
+const doc1 = {
+    'content': sentence1, 
+    'genre': 'persons', 
+    'embedding': Buffer.from(
+        (await pipe(sentence1, pipeOptions)).data.buffer
+    ),
+};
+
+const sentence2 = 'That is a happy dog';
+const doc2 = {
+    'content': sentence2, 
+    'genre': 'pets', 
+    'embedding': Buffer.from(
+        (await pipe(sentence2, pipeOptions)).data.buffer
+    )
+};
+
+const sentence3 = 'Today is a sunny day';
+const doc3 = {
+    'content': sentence3, 
+    'genre': 'weather', 
+    'embedding': Buffer.from(
+        (await pipe(sentence3, pipeOptions)).data.buffer
+    )
+};
+
+await Promise.all([
+    client.hSet('doc:1', doc1),
+    client.hSet('doc:2', doc2),
+    client.hSet('doc:3', doc3)
+]);
+```
+
+## Run a query
+
+To query the index:
+1. Generate an embedding for your query text
+2. Pass the embedding as a parameter to the search
+3. Redis calculates vector distances and ranks results
+
+The query returns an array of document objects. Each object contains:
+- `id`: The document's key
+- `value`: An object with fields specified in the `RETURN` option
+
+```js
+const similar = await client.ft.search(
+    'vector_idx',
+    '*=>[KNN 3 @embedding $B AS score]',
+    {
+        'PARAMS': {
+            B: Buffer.from(
+                (await pipe('That is a happy person', pipeOptions)).data.buffer
+            ),
+        },
+        'RETURN': ['score', 'content'],
+        'DIALECT': '2'
+    },
+);
+
+for (const doc of similar.documents) {
+    console.log(`${doc.id}: '${doc.value.content}', Score: ${doc.value.score}`);
+}
+
+await client.quit();
+```
+
+The first run may take longer as it downloads the model data. The output shows results ordered by score (vector distance), with lower scores indicating greater similarity:
+
+```
+doc:1: 'That is a very happy person', Score: 0.127055495977
+doc:2: 'That is a happy dog', Score: 0.836842417717
+doc:3: 'Today is a sunny day', Score: 1.50889515877
+```
+
+## Differences with JSON documents
+
+JSON documents support richer data modeling with nested fields. Key differences from hash documents:
+
+1. Use paths in the schema to identify fields
+2. Declare aliases for paths using the `AS` option
+3. Set `ON` to `JSON` when creating the index
+4. Use arrays instead of binary strings for vectors
+5. Use `json.set()` instead of `hSet()`
+
+Create the index with path aliases:
+
+```js
+await client.ft.create('vector_json_idx', {
+    '$.content': {
+        type: SchemaFieldTypes.TEXT,
+        AS: 'content',
+    },
+    '$.genre': {
+        type: SchemaFieldTypes.TAG,
+        AS: 'genre',
+    },
+    '$.embedding': {
+        type: SchemaFieldTypes.VECTOR,
+        TYPE: 'FLOAT32',
+        ALGORITHM: VectorAlgorithms.HNSW,
+        DISTANCE_METRIC: 'L2',
+        DIM: 768,
+        AS: 'embedding',
+    }
+}, {
+    ON: 'JSON',
+    PREFIX: 'jdoc:'
+});
+```
+
+Add data using `json.set()`. Convert the `Float32Array` to a standard JavaScript array using the spread operator:
+
+```js
+const jSentence1 = 'That is a very happy person';
+const jdoc1 = {
+    'content': jSentence1,
+    'genre': 'persons',
+    'embedding': [...(await pipe(jSentence1, pipeOptions)).data],
+};
+
+const jSentence2 = 'That is a happy dog';
+const jdoc2 = {
+    'content': jSentence2,
+    'genre': 'pets',
+    'embedding': [...(await pipe(jSentence2, pipeOptions)).data],
+};
+
+const jSentence3 = 'Today is a sunny day';
+const jdoc3 = {
+    'content': jSentence3,
+    'genre': 'weather',
+    'embedding': [...(await pipe(jSentence3, pipeOptions)).data],
+};
+
+await Promise.all([
+    client.json.set('jdoc:1', '$', jdoc1),
+    client.json.set('jdoc:2', '$', jdoc2),
+    client.json.set('jdoc:3', '$', jdoc3)
+]);
+```
+
+Query JSON documents using the same syntax, but note that the vector parameter must still be a binary string:
+
+```js
+const jsons = await client.ft.search(
+    'vector_json_idx',
+    '*=>[KNN 3 @embedding $B AS score]',
+    {
+        "PARAMS": {
+            B: Buffer.from(
+                (await pipe('That is a happy person', pipeOptions)).data.buffer
+            ),
+        },
+        'RETURN': ['score', 'content'],
+        'DIALECT': '2'
+    },
+);
+```
+
+The results are identical to the hash document query, except for the `jdoc:` prefix:
+
+```
+jdoc:1: 'That is a very happy person', Score: 0.127055495977
+jdoc:2: 'That is a happy dog', Score: 0.836842417717
+jdoc:3: 'Today is a sunny day', Score: 1.50889515877
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about indexing options, distance metrics, and query format.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Node.js application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 2
+---
+
+## Basic connection
+
+Connect to localhost on port 6379. 
+
+```js
+import { createClient } from 'redis';
+
+const client = createClient();
+
+client.on('error', err => console.log('Redis Client Error', err));
+
+await client.connect();
+```
+
+Store and retrieve a simple string.
+
+```js
+await client.set('key', 'value');
+const value = await client.get('key');
+```
+
+Store and retrieve a map.
+
+```js
+await client.hSet('user-session:123', {
+    name: 'John',
+    surname: 'Smith',
+    company: 'Redis',
+    age: 29
+})
+
+let userSession = await client.hGetAll('user-session:123');
+console.log(JSON.stringify(userSession, null, 2));
+/*
+{
+  "surname": "Smith",
+  "name": "John",
+  "company": "Redis",
+  "age": "29"
+}
+ */
+```
+
+To connect to a different host or port, use a connection string in the format `redis[s]://[[username][:password]@][host][:port][/db-number]`:
+
+```js
+createClient({
+  url: 'redis://alice:foobared@awesome.redis.server:6380'
+});
+```
+To check if the client is connected and ready to send commands, use `client.isReady`, which returns a Boolean. `client.isOpen` is also available. This returns `true` when the client's underlying socket is open, and `false` when it isn't (for example, when the client is still connecting or reconnecting after a network error).
+
+## Connect to a Redis cluster
+
+To connect to a Redis cluster, use `createCluster`.
+
+```js
+import { createCluster } from 'redis';
+
+const cluster = createCluster({
+    rootNodes: [
+        {
+            url: 'redis://127.0.0.1:16379'
+        },
+        {
+            url: 'redis://127.0.0.1:16380'
+        },
+        // ...
+    ]
+});
+
+cluster.on('error', (err) => console.log('Redis Cluster Error', err));
+
+await cluster.connect();
+
+await cluster.set('foo', 'bar');
+const value = await cluster.get('foo');
+console.log(value); // returns 'bar'
+
+await cluster.close();
+```
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+```js
+const client = createClient({
+    username: 'default', // use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+    password: 'secret', // use your password here
+    socket: {
+        host: 'my-redis.cloud.redislabs.com',
+        port: 6379,
+        tls: true,
+        key: readFileSync('./redis_user_private.key'),
+        cert: readFileSync('./redis_user.crt'),
+        ca: [readFileSync('./redis_ca.pem')]
+    }
+});
+
+client.on('error', (err) => console.log('Redis Client Error', err));
+
+await client.connect();
+
+await client.set('foo', 'bar');
+const value = await client.get('foo');
+console.log(value) // returns 'bar'
+
+await client.destroy();
+```
+
+You can also use discrete parameters and UNIX sockets. Details can be found in the [client configuration guide](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md).
+
+## Reconnect after disconnection
+
+`node-redis` can attempt to reconnect automatically when
+the connection to the server is lost. By default, it will retry
+the connection using an
+[exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff)
+strategy with some random "jitter" added to avoid multiple
+clients retrying in sync with each other.
+
+You can also set the
+`socket.reconnectionStrategy` field in the configuration to decide
+whether to try to reconnect and how to approach it. Choose one of the following values for
+`socket.reconnectionStrategy`:
+
+-   `false`: (Default) Don't attempt to reconnect.
+-   `number`: Wait for this number of milliseconds and then attempt to reconnect.
+-   `<function>`: Use a custom
+    function to decide how to handle reconnection.
+
+The custom function has the following signature:
+
+```js
+(retries: number, cause: Error) => false | number | Error
+```
+
+It is called before each attempt to reconnect, with the `retries`
+indicating how many attempts have been made so far. The `cause` parameter is an
+[`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+object with information about how the connection was lost. The return value
+from the function can be any of the following:
+
+-   `false`: Don't attempt to reconnect.
+-   `number`: Wait this number of milliseconds and then try again.
+-   `Error`: Same as `false`, but lets you supply extra information about why
+    no attempt was made to reconnect.
+
+The example below shows a `reconnectionStrategy` function that implements a
+custom exponential backoff strategy:
+
+```js
+createClient({
+  socket: {
+    reconnectStrategy: retries => {
+        // Generate a random jitter between 0 – 100 ms:
+        const jitter = Math.floor(Math.random() * 100);
+
+        // Delay is an exponential backoff, (2^retries) * 50 ms, with a
+        // maximum value of 3000 ms:
+        const delay = Math.min(Math.pow(2, retries) * 50, 3000);
+
+        return delay + jitter;
+    }
+  }
+});
+```
+
+## Connection events
+
+The client object emits the following
+[events](https://developer.mozilla.org/en-US/docs/Web/API/Event) that are
+related to connection:
+
+-   `connect`: (No parameters) The client is about to start connecting to the server.
+-   `ready`: (No parameters) The client has connected and is ready to use.
+-   `end`: (No parameters) The client has been intentionally closed using `client.quit()`.
+-   `error`: An error has occurred, which is described by the
+    [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+    parameter. This is usually a network issue such as "Socket closed unexpectedly".
+-   `reconnecting`: (No parameters) The client is about to try reconnecting after the
+    connection was lost due to an error.
+-   `sharded-channel-moved`: The cluster slot of a subscribed
+    [sharded pub/sub channel]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}})
+    has been moved to another shard. Note that when you use a
+    [`RedisCluster`](#connect-to-a-redis-cluster) connection, this event is automatically
+    handled for you. See
+    [`sharded-channel-moved` event](https://github.com/redis/node-redis/blob/master/docs/pub-sub.md#sharded-channel-moved-event) for more information.
+
+Use code like the following to respond to these events:
+
+```js
+client.on('error', error => {
+    console.error(`Redis client error:`, error);
+});
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis Query Engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 2
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+or another Redis server available. Also install the
+[`node-redis`]({{< relref "/develop/clients/nodejs" >}}) client library if you
+haven't already done so.
+
+Add the following dependencies:
+
+```js
+import {
+    createClient,
+    SCHEMA_FIELD_TYPE,
+    FT_AGGREGATE_GROUP_BY_REDUCERS,
+    FT_AGGREGATE_STEPS,
+} from 'redis';
+```
+
+## Create data
+
+Create some test data to add to your database. The example data shown
+below is compatible with both JSON and hash objects.
+
+```js
+const user1 = {
+    name: 'Paul John',
+    email: 'paul.john@example.com',
+    age: 42,
+    city: 'London'
+};
+
+const user2 = {
+    name: 'Eden Zamir',
+    email: 'eden.zamir@example.com',
+    age: 29,
+    city: 'Tel Aviv'
+};
+
+const user3 = {
+    name: 'Paul Zamir',
+    email: 'paul.zamir@example.com',
+    age: 35,
+    city: 'Tel Aviv'
+};
+```
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/nodejs/connect" >}})
+to learn more about the available connection options.
+
+```js
+const client = await createClient();
+await client.connect();
+```
+
+Create an index. In this example, only JSON documents with the key prefix `user:` are indexed. For more information, see [Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}).
+
+```js
+await client.ft.create('idx:users', {
+    '$.name': {
+        type: SchemaFieldTypes.TEXT,
+        AS: 'name'
+    },
+    '$.city': {
+        type: SchemaFieldTypes.TEXT,
+        AS: 'city'
+    },
+    '$.age': {
+        type: SchemaFieldTypes.NUMERIC,
+        AS: 'age'
+    }
+}, {
+    ON: 'JSON',
+    PREFIX: 'user:'
+});
+```
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them. Note that placing
+the commands in a `Promise.all()` call is an easy way to create a
+[pipeline]({{< relref "/develop/clients/nodejs/transpipe" >}}),
+which is more efficient than sending the commands individually.
+
+```js
+const [user1Reply, user2Reply, user3Reply] = await Promise.all([
+    client.json.set('user:1', '$', user1),
+    client.json.set('user:2', '$', user2),
+    client.json.set('user:3', '$', user3)
+]);
+```
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+```js
+let findPaulResult = await client.ft.search('idx:users', 'Paul @age:[30 40]');
+
+console.log(findPaulResult.total); // >>> 1
+
+findPaulResult.documents.forEach(doc => {
+    console.log(`ID: ${doc.id}, name: ${doc.value.name}, age: ${doc.value.age}`);
+});
+```
+
+Specify query options to return only the `city` field:
+
+```js
+let citiesResult = await client.ft.search('idx:users', '*',{
+    RETURN: 'city'
+});
+
+console.log(citiesResult.total); // >>> 3
+
+citiesResult.documents.forEach(cityDoc => {
+    console.log(cityDoc.value);
+});
+```
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+```js
+let aggResult = await client.ft.aggregate('idx:users', '*', {
+    STEPS: [{
+        type: AggregateSteps.GROUPBY,
+        properties: '@city',
+        REDUCE: [{
+            type: AggregateGroupByReducers.COUNT,
+            AS: 'count'
+        }]
+    }]
+});
+
+console.log(aggResult.total); // >>> 2
+
+aggResult.results.forEach(result => {
+    console.log(`${result.city} - ${result.count}`);
+});
+```
+
+Finally, close the connection to Redis.
+
+```js
+await client.quit();
+```
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must use `HASH` for the `ON` option
+when you create the index. The code below shows these changes with
+a new index called `hash-idx:users`, which is otherwise the same as
+the `idx:users` index used for JSON documents in the previous examples.
+
+```js
+await client.ft.create('hash-idx:users', {
+    'name': {
+        type: SchemaFieldTypes.TEXT
+    },
+    'city': {
+        type: SchemaFieldTypes.TEXT
+    },
+    'age': {
+        type: SchemaFieldTypes.NUMERIC
+    }
+}, {
+    ON: 'HASH',
+    PREFIX: 'huser:'
+});
+```
+
+You use [`hSet()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`json.set()`]({{< relref "/commands/json.set" >}}),
+but the same flat `userX` objects work equally well with either
+hash or JSON:
+
+```js
+const [huser1Reply, huser2Reply, huser3Reply] = await Promise.all([
+    client.hSet('huser:1', user1),
+    client.hSet('huser:2', user2),
+    client.hSet('huser:3', user3)
+]);
+```
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The format of the result is
+also the same:
+
+```js
+let findPaulHashResult = await client.ft.search(
+    'hash-idx:users', 'Paul @age:[30 40]'
+);
+
+console.log(findPaulHashResult.total); // >>> 1
+
+findPaulHashResult.documents.forEach(doc => {
+    console.log(`ID: ${doc.id}, name: ${doc.value.name}, age: ${doc.value.age}`);
+});
+// >>> ID: huser:3, name: Paul Zamir, age: 35
+```
+
+## More information
+
+See the [Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+aliases: /develop/connect/clients/nodejs
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Node.js/JavaScript application to a Redis database
+linkTitle: node-redis (JavaScript)
+title: node-redis guide (JavaScript)
+weight: 4
+---
+
+[node-redis](https://github.com/redis/node-redis) is the Redis client for Node.js/JavaScript.
+The sections below explain how to install `node-redis` and connect your application
+to a Redis database.
+
+`node-redis` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+You can also access Redis with an object-mapping client interface. See
+[RedisOM for Node.js]({{< relref "/integrate/redisom-for-node-js" >}})
+for more information.
+
+## Install
+
+To install node-redis, run:
+
+```bash
+npm install redis
+```
+
+## Connect and test
+
+Connect to localhost on port 6379. 
+
+```js
+import { createClient } from 'redis';
+
+const client = createClient();
+
+client.on('error', err => console.log('Redis Client Error', err));
+
+await client.connect();
+```
+
+Store and retrieve a simple string.
+
+```js
+await client.set('key', 'value');
+const value = await client.get('key');
+```
+
+Store and retrieve a map.
+
+```js
+await client.hSet('user-session:123', {
+    name: 'John',
+    surname: 'Smith',
+    company: 'Redis',
+    age: 29
+})
+
+let userSession = await client.hGetAll('user-session:123');
+console.log(JSON.stringify(userSession, null, 2));
+/*
+{
+  "surname": "Smith",
+  "name": "John",
+  "company": "Redis",
+  "age": "29"
+}
+ */
+```
+
+To connect to a different host or port, use a connection string in the format `redis[s]://[[username][:password]@][host][:port][/db-number]`:
+
+```js
+createClient({
+  url: 'redis://alice:foobared@awesome.redis.server:6380'
+});
+```
+To check if the client is connected and ready to send commands, use `client.isReady`, which returns a Boolean. `client.isOpen` is also available. This returns `true` when the client's underlying socket is open, and `false` when it isn't (for example, when the client is still connecting or reconnecting after a network error).
+
+## More information
+
+The [`node-redis` website](https://redis.js.org/) has more examples.
+The [Github repository](https://github.com/redis/node-redis) also has useful
+information, including a guide to the
+[connection configuration options](https://github.com/redis/node-redis/blob/master/docs/client-configuration.md) you can use.
+
+See also the other pages in this section for more information and examples:
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get your Node.js app ready for production
+linkTitle: Production usage
+title: Production usage
+weight: 5
+---
+
+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.
+
+{{< checklist "nodeprodlist" >}}
+    {{< checklist-item "#handling-errors" >}}Handling errors{{< /checklist-item >}}
+    {{< checklist-item "#handling-reconnections" >}}Handling reconnections{{< /checklist-item >}}
+    {{< checklist-item "#timeouts" >}}Timeouts{{< /checklist-item >}}
+{{< /checklist >}}
+
+## Recommendations
+
+### Handling errors
+
+Node-Redis provides [multiple events to handle various scenarios](https://github.com/redis/node-redis?tab=readme-ov-file#events), among which the most critical is the `error` event.
+
+This event is triggered whenever an error occurs within the client.
+
+It is crucial to listen for error events.
+
+If a client does not register at least one error listener and an error occurs, the system will throw that error, potentially causing the Node.js process to exit unexpectedly.
+See [the EventEmitter docs](https://nodejs.org/api/events.html#events_error_events) for more details.
+
+```typescript
+const client = createClient({
+  // ... client options
+});
+// Always ensure there's a listener for errors in the client to prevent process crashes due to unhandled errors
+client.on('error', error => {
+    console.error(`Redis client error:`, error);
+});
+```
+
+### Handling reconnections
+
+When the socket closes unexpectedly (without calling the `quit()` or `disconnect()` methods),
+the client can automatically restore the connection.  A simple
+[exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff) strategy
+for reconnection is enabled by default, but you can replace this with your
+own custom strategy. See
+[Reconnect after disconnection]({{< relref "/develop/clients/nodejs/connect#reconnect-after-disconnection" >}})
+for more information.
+
+### Timeouts
+
+To set a timeout for a connection, use the `connectTimeout` option:
+```typescript
+const client = createClient({
+  socket: {
+    // setting a 10-second timeout  
+    connectTimeout: 10000 // in milliseconds
+  }
+});
+client.on('error', error => console.error('Redis client error:', error));
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 4
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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.
+
+The main difference with the pipeline commands is that their return
+values contain a valid result only after the pipeline has finished executing.
+You can access the result using the `Val()` method instead of
+`Result()` (note that errors are reported by the `Exec()` method rather
+than by the individual commands).
+
+{{< clients-example pipe_trans_tutorial basic_pipe Go >}}
+{{< /clients-example >}}
+
+You can also create a pipeline using the `Pipelined()` method.
+This executes pipeline commands in a callback function that you
+provide and calls `Exec()` automatically after it returns:
+
+{{< clients-example pipe_trans_tutorial basic_pipe_pipelined Go >}}
+{{< /clients-example >}}
+
+## Execute a transaction
+
+A transaction works in a similar way to a pipeline. Create a
+transaction object with the `TxPipeline()` method, call command methods
+on that object, and then call the transaction object's 
+`Exec()` method to execute it. You can access the results
+from commands in the transaction after it completes using the
+`Val()` method.
+
+{{< clients-example pipe_trans_tutorial basic_trans Go >}}
+{{< /clients-example >}}
+
+There is also a `TxPipelined()` method that works in a similar way
+to `Pipelined()`, described above:
+
+{{< clients-example pipe_trans_tutorial basic_trans_txpipelined Go >}}
+{{< /clients-example >}}
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The code below reads a string
+that represents a `PATH` variable for a command shell, then appends a new
+command path to the string before attempting to write it back. If the watched
+key is modified by another client before writing, the transaction aborts.
+The `Watch()` method receives a callback function where you execute the
+commands you want to watch. In the body of this callback, you can execute
+read-only commands before the transaction using the usual client object
+(called `rdb` in our examples) and receive an immediate result. Start the
+transaction itself by calling `TxPipeline()` or `TxPipelined()` on the
+`Tx` object passed to the callback. `Watch()` also receives one or more
+`string` parameters after the callback that represent the keys you want
+to watch.
+
+For production usage, you would generally call code like the following in
+a loop to retry it until it succeeds or else report or log the failure:
+
+{{< clients-example pipe_trans_tutorial trans_watch Go >}}
+{{< /clients-example >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 3
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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.
+
+In the example below, we use the
+[`huggingfaceembedder`](https://pkg.go.dev/github.com/henomis/lingoose@v0.3.0/embedder/huggingface)
+package from the [`LinGoose`](https://pkg.go.dev/github.com/henomis/lingoose@v0.3.0)
+framework 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](#differences-with-json-documents).
+
+## Initialize
+
+Start a new Go module with the following command:
+
+```bash 
+go mod init vecexample
+```
+
+Then, in your module folder, install
+[`go-redis`]({{< relref "/develop/clients/go" >}})
+and the 
+[`huggingfaceembedder`](https://pkg.go.dev/github.com/henomis/lingoose@v0.3.0/embedder/huggingface)
+package:
+
+```bash
+go get github.com/redis/go-redis/v9
+go get github.com/henomis/lingoose/embedder/huggingface
+```
+
+Add the following imports to your module's main program file:
+
+```go
+package main
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"math"
+
+	huggingfaceembedder "github.com/henomis/lingoose/embedder/huggingface"
+	"github.com/redis/go-redis/v9"
+)
+```
+
+You must also create a [HuggingFace account](https://huggingface.co/join)
+and add a new access token to use the embedding model. See the
+[HuggingFace](https://huggingface.co/docs/hub/en/security-tokens)
+docs to learn how to create and manage access tokens. Note that the
+account and the `all-MiniLM-L6-v2` model that we will use to produce
+the embeddings for this example are both available for free.
+
+## Add a helper function
+
+The `huggingfaceembedder` model outputs the embeddings as a
+`[]float32` array. If you are storing your documents as
+[hash]({{< relref "/develop/data-types/hashes" >}}) objects, then you
+must convert this array to a `byte` string before adding it as a hash field.
+The function shown below uses Go's [`binary`](https://pkg.go.dev/encoding/binary)
+package to produce the `byte` string:
+
+```go
+func floatsToBytes(fs []float32) []byte {
+	buf := make([]byte, len(fs)*4)
+
+	for i, f := range fs {
+		u := math.Float32bits(f)
+		binary.NativeEndian.PutUint32(buf[i*4:], u)
+	}
+
+	return buf
+}
+```
+
+Note that if you are using [JSON]({{< relref "/develop/data-types/json" >}})
+objects to store your documents instead of hashes, then you should store
+the `[]float32` array directly without first converting it to a `byte`
+string (see [Differences with JSON documents](#differences-with-json-documents)
+below).
+
+## Create the index
+
+In the `main()` function, connect to Redis and delete any index previously
+created with the name `vector_idx`:
+
+```go
+ctx := context.Background()
+rdb := redis.NewClient(&redis.Options{
+    Addr:     "localhost:6379",
+    Password: "", // no password docs
+    DB:       0,  // use default DB
+    Protocol: 2,
+})
+
+rdb.FTDropIndexWithArgs(ctx,
+    "vector_idx",
+    &redis.FTDropIndexOptions{
+        DeleteDocs: true,
+    },
+)
+```
+
+Next, create the index.
+The schema in the example below specifies hash objects for storage and includes
+three fields: the text content to index, a
+[tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+field to represent the "genre" of the text, and the embedding vector generated from
+the original text content. The `embedding` field specifies
+[HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) 
+indexing, the
+[L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+vector distance metric, `Float32` values to represent the vector's components,
+and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
+
+```go
+_, err := rdb.FTCreate(ctx,
+    "vector_idx",
+    &redis.FTCreateOptions{
+        OnHash: true,
+        Prefix: []any{"doc:"},
+    },
+    &redis.FieldSchema{
+        FieldName: "content",
+        FieldType: redis.SearchFieldTypeText,
+    },
+    &redis.FieldSchema{
+        FieldName: "genre",
+        FieldType: redis.SearchFieldTypeTag,
+    },
+    &redis.FieldSchema{
+        FieldName: "embedding",
+        FieldType: redis.SearchFieldTypeVector,
+        VectorArgs: &redis.FTVectorArgs{
+            HNSWOptions: &redis.FTHNSWOptions{
+                Dim:            384,
+                DistanceMetric: "L2",
+                Type:           "FLOAT32",
+            },
+        },
+    },
+).Result()
+
+if err != nil {
+    panic(err)
+}
+```
+
+## Create an embedder instance
+
+You need an instance of the `huggingfaceembedder` class to
+generate the embeddings. Use the code below to create an
+instance that uses the `sentence-transformers/all-MiniLM-L6-v2`
+model, passing your HuggingFace access token to the `WithToken()`
+method.
+
+```go
+hf := huggingfaceembedder.New().
+		WithToken("<your-access-token>").
+		WithModel("sentence-transformers/all-MiniLM-L6-v2")
+```
+
+## Add data
+
+You can now supply the data objects, which will be indexed automatically
+when you add them with [`HSet()`]({{< relref "/commands/hset" >}}), as long as
+you use the `doc:` prefix specified in the index definition.
+
+Use the `Embed()` method of `huggingfacetransformer`
+as shown below to create the embeddings that represent the `content` fields.
+This method takes an array of strings and outputs a corresponding
+array of `Embedding` objects.
+Use the `ToFloat32()` method of `Embedding` to produce the array of float
+values that we need, and use the `floatsToBytes()` function we defined
+above to convert this array to a `byte` string.
+
+```go
+sentences := []string{
+    "That is a very happy person",
+    "That is a happy dog",
+    "Today is a sunny day",
+}
+
+tags := []string{
+    "persons", "pets", "weather",
+}
+
+embeddings, err := hf.Embed(ctx, sentences)
+
+if err != nil {
+    panic(err)
+}
+
+for i, emb := range embeddings {
+    buffer := floatsToBytes(emb.ToFloat32())
+
+    if err != nil {
+        panic(err)
+    }
+
+    _, err = rdb.HSet(ctx,
+        fmt.Sprintf("doc:%v", i),
+        map[string]any{
+            "content":   sentences[i],
+            "genre":     tags[i],
+            "embedding": buffer,
+        },
+    ).Result()
+
+    if err != nil {
+        panic(err)
+    }
+}
+```
+
+## Run a query
+
+After you have created the index and added the data, you are ready to run a query.
+To do this, you must create another embedding vector from your chosen query
+text. Redis calculates the similarity between the query vector and each
+embedding vector in the index as it runs the query. It then ranks the
+results in order of this numeric similarity value.
+
+The code below creates the query embedding using `Embed()`, as with
+the indexing, and passes it as a parameter when the query executes
+(see
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about using query parameters with embeddings).
+
+```go
+queryEmbedding, err := hf.Embed(ctx, []string{
+    "That is a happy person",
+})
+
+if err != nil {
+    panic(err)
+}
+
+buffer := floatsToBytes(queryEmbedding[0].ToFloat32())
+
+if err != nil {
+    panic(err)
+}
+
+results, err := rdb.FTSearchWithArgs(ctx,
+    "vector_idx",
+    "*=>[KNN 3 @embedding $vec AS vector_distance]",
+    &redis.FTSearchOptions{
+        Return: []redis.FTSearchReturn{
+            {FieldName: "vector_distance"},
+            {FieldName: "content"},
+        },
+        DialectVersion: 2,
+        Params: map[string]any{
+            "vec": buffer,
+        },
+    },
+).Result()
+
+if err != nil {
+    panic(err)
+}
+
+for _, doc := range results.Docs {
+    fmt.Printf(
+        "ID: %v, Distance:%v, Content:'%v'\n",
+        doc.ID, doc.Fields["vector_distance"], doc.Fields["content"],
+    )
+}
+```
+
+The code is now ready to run, but note that it may take a while to complete when
+you run it for the first time (which happens because `huggingfacetransformer`
+must download the `all-MiniLM-L6-v2` model data before it can
+generate the embeddings). When you run the code, it outputs the following text:
+
+```
+ID: doc:0, Distance:0.114169843495, Content:'That is a very happy person'
+ID: doc:1, Distance:0.610845327377, Content:'That is a happy dog'
+ID: doc:2, Distance:1.48624765873, Content:'Today is a sunny day'
+```
+
+The results are ordered according to the value of the `vector_distance`
+field, with the lowest distance indicating the greatest similarity to the query.
+As you would expect, the result for `doc:0` with the content text *"That is a very happy person"*
+is the result that is most similar in meaning to the query text
+*"That is a happy person"*.
+
+## Differences with JSON documents
+
+Indexing JSON documents is similar to hash indexing, but there are some
+important differences. JSON allows much richer data modelling with nested fields, so
+you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+to identify each field you want to index. However, you can declare a short alias for each
+of these paths (using the `As` option) to avoid typing it in full for
+every query. Also, you must set `OnJSON` to `true` when you create the index.
+
+The code below shows these differences, but the index is otherwise very similar to
+the one created previously for hashes:
+
+```go
+_, err = rdb.FTCreate(ctx,
+    "vector_json_idx",
+    &redis.FTCreateOptions{
+        OnJSON: true,
+        Prefix: []any{"jdoc:"},
+    },
+    &redis.FieldSchema{
+        FieldName: "$.content",
+        As:        "content",
+        FieldType: redis.SearchFieldTypeText,
+    },
+    &redis.FieldSchema{
+        FieldName: "$.genre",
+        As:        "genre",
+        FieldType: redis.SearchFieldTypeTag,
+    },
+    &redis.FieldSchema{
+        FieldName: "$.embedding",
+        As:        "embedding",
+        FieldType: redis.SearchFieldTypeVector,
+        VectorArgs: &redis.FTVectorArgs{
+            HNSWOptions: &redis.FTHNSWOptions{
+                Dim:            384,
+                DistanceMetric: "L2",
+                Type:           "FLOAT32",
+            },
+        },
+    },
+).Result()
+```
+
+Use [`JSONSet()`]({{< relref "/commands/json.set" >}}) to add the data
+instead of [`HSet()`]({{< relref "/commands/hset" >}}). The maps
+that specify the fields have the same structure as the ones used for `HSet()`.
+
+An important difference with JSON indexing is that the vectors are
+specified using lists instead of binary strings. The loop below is similar
+to the one used previously to add the hash data, but it doesn't use the
+`floatsToBytes()` function to encode the `float32` array.
+
+```go
+for i, emb := range embeddings {
+    _, err = rdb.JSONSet(ctx,
+        fmt.Sprintf("jdoc:%v", i),
+        "$",
+        map[string]any{
+            "content":   sentences[i],
+            "genre":     tags[i],
+            "embedding": emb.ToFloat32(),
+        },
+    ).Result()
+
+    if err != nil {
+        panic(err)
+    }
+}
+```
+
+The query is almost identical to the one for the hash documents. This
+demonstrates how the right choice of aliases for the JSON paths can
+save you having to write complex queries. An important thing to notice
+is that the vector parameter for the query is still specified as a
+binary string (using the `floatsToBytes()` method), even though the data for
+the `embedding` field of the JSON was specified as an array.
+
+```go
+jsonQueryEmbedding, err := hf.Embed(ctx, []string{
+    "That is a happy person",
+})
+
+if err != nil {
+    panic(err)
+}
+
+jsonBuffer := floatsToBytes(jsonQueryEmbedding[0].ToFloat32())
+
+jsonResults, err := rdb.FTSearchWithArgs(ctx,
+    "vector_json_idx",
+    "*=>[KNN 3 @embedding $vec AS vector_distance]",
+    &redis.FTSearchOptions{
+        Return: []redis.FTSearchReturn{
+            {FieldName: "vector_distance"},
+            {FieldName: "content"},
+        },
+        DialectVersion: 2,
+        Params: map[string]any{
+            "vec": jsonBuffer,
+        },
+    },
+).Result()
+```
+
+Apart from the `jdoc:` prefixes for the keys, the result from the JSON
+query is the same as for hash:
+
+```
+ID: jdoc:0, Distance:0.114169843495, Content:'That is a very happy person'
+ID: jdoc:1, Distance:0.610845327377, Content:'That is a happy dog'
+ID: jdoc:2, Distance:1.48624765873, Content:'Today is a sunny day'
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about the indexing options, distance metrics, and query format
+for vectors.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Go application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 1
+---
+
+## Basic connection
+
+The following example shows the simplest way to connect to a Redis server:
+
+```go
+import (
+	"context"
+	"fmt"
+	"github.com/redis/go-redis/v9"
+)
+
+func main() {    
+    client := redis.NewClient(&redis.Options{
+        Addr:	  "localhost:6379",
+        Password: "", // No password set
+        DB:		  0,  // Use default DB
+        Protocol: 2,  // Connection protocol
+    })
+}
+```
+
+You can also connect using a connection string:
+
+```go
+opt, err := redis.ParseURL("redis://<user>:<pass>@localhost:6379/<db>")
+if err != nil {
+	panic(err)
+}
+
+client := redis.NewClient(opt)
+```
+
+After connecting, you can test the connection by  storing and retrieving
+a simple [string]({{< relref "/develop/data-types/strings" >}}):
+
+```go
+ctx := context.Background()
+
+err := client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```
+
+## Connect to a Redis cluster
+
+To connect to a Redis cluster, use `NewClusterClient()`. You can specify
+one or more cluster endpoints with the `Addrs` option:
+
+```go
+client := redis.NewClusterClient(&redis.ClusterOptions{
+    Addrs: []string{":16379", ":16380", ":16381", ":16382", ":16383", ":16384"},
+
+    // To route commands by latency or randomly, enable one of the following.
+    //RouteByLatency: true,
+    //RouteRandomly: true,
+})
+```
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the
+[Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+Establish a secure connection with your Redis database:
+
+```go
+// Load client cert
+cert, err := tls.LoadX509KeyPair("redis_user.crt", "redis_user_private.key")
+if err != nil {
+    log.Fatal(err)
+}
+
+// Load CA cert
+caCert, err := os.ReadFile("redis_ca.pem")
+if err != nil {
+    log.Fatal(err)
+}
+caCertPool := x509.NewCertPool()
+caCertPool.AppendCertsFromPEM(caCert)
+
+client := redis.NewClient(&redis.Options{
+    Addr:     "my-redis.cloud.redislabs.com:6379",
+    Username: "default", // use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+    Password: "secret", // use your Redis password
+    TLSConfig: &tls.Config{
+        MinVersion:   tls.VersionTLS12,
+        Certificates: []tls.Certificate{cert},
+        RootCAs:      caCertPool,
+    },
+})
+
+//send SET command
+err = client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+//send GET command and print the value
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis query engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 2
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+or another Redis server available. Also install the
+[`go-redis`]({{< relref "/develop/clients/go" >}}) client library if you
+haven't already done so.
+
+Add the following dependencies:
+
+{{< clients-example go_home_json import >}}
+{{< /clients-example >}}
+
+## Create data
+
+Create some test data to add to your database. The example data shown
+below is compatible with both JSON and hash objects.
+
+{{< clients-example go_home_json create_data >}}
+{{< /clients-example >}}
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/go/connect" >}})
+to learn more about the available connection options.
+
+{{< clients-example go_home_json connect >}}
+{{< /clients-example >}}
+
+{{< note >}}The connection options in the example specify
+[RESP2]({{< relref "/develop/reference/protocol-spec" >}}) in the `Protocol`
+field. We recommend that you use RESP2 for Redis query engine operations in `go-redis`
+because some of the response structures for the default RESP3 are currently
+incomplete and so you must handle the "raw" responses in your own code.
+
+If you do want to use RESP3, you should set the `UnstableResp3` option when
+you connect:
+
+```go
+rdb := redis.NewClient(&redis.Options{
+    UnstableResp3: true,
+    // Other options...
+})
+```
+
+You must also access command results using the `RawResult()` and `RawVal()` methods
+rather than the usual `Result()` and `Val()`:
+
+```go
+res1, err := client.FTSearchWithArgs(
+    ctx, "txt", "foo bar", &redis.FTSearchOptions{},
+).RawResult()
+val1 := client.FTSearchWithArgs(
+    ctx, "txt", "foo bar", &redis.FTSearchOptions{},
+).RawVal()
+```
+{{< /note >}}
+
+Use the code below to create a search index. The `FTCreateOptions` parameter enables
+indexing only for JSON objects where the key has a `user:` prefix.
+The
+[schema]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for the index has three fields for the user's name, age, and city.
+The `FieldName` field of the `FieldSchema` struct specifies a
+[JSON path]({{< relref "/develop/data-types/json/path" >}})
+that identifies which data field to index. Use the `As` struct field
+to provide an alias for the JSON path expression. You can use
+the alias in queries as a short and intuitive way to refer to the
+expression, instead of typing it in full:
+
+{{< clients-example go_home_json make_index >}}
+{{< /clients-example >}}
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them:
+
+{{< clients-example go_home_json add_data >}}
+{{< /clients-example >}}
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+{{< clients-example go_home_json query1 >}}
+{{< /clients-example >}}
+
+Specify query options to return only the `city` field:
+
+{{< clients-example go_home_json query2 >}}
+{{< /clients-example >}}
+
+You can also use the same query with the `CountOnly` option
+enabled to get the number of documents found without
+returning the documents themselves.
+
+{{< clients-example go_home_json query2count_only >}}
+{{< /clients-example >}}
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+{{< clients-example go_home_json query3 >}}
+{{< /clients-example >}}
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must set `OnHash` to `true` in the `FTCreateOptions`
+object when you create the index. The code below shows these changes with
+a new index called `hash-idx:users`, which is otherwise the same as
+the `idx:users` index used for JSON documents in the previous examples.
+
+{{< clients-example go_home_json make_hash_index >}}
+{{< /clients-example >}}
+
+You use [`HSet()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`JSONSet()`]({{< relref "/commands/json.set" >}}),
+but the same flat `userX` maps work equally well with either
+hash or JSON:
+
+{{< clients-example go_home_json add_hash_data >}}
+{{< /clients-example >}}
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The format of the result is
+almost the same except that the fields are returned directly in the
+`Document` object map of the result (for JSON, the fields are all enclosed
+in a string under the key "$"):
+
+{{< clients-example go_home_json query1_hash >}}
+{{< /clients-example >}}
+
+## More information
+
+See the [Redis query engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+aliases: /develop/connect/clients/go
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Go application to a Redis database
+linkTitle: go-redis (Go)
+title: go-redis guide (Go)
+weight: 7
+---
+
+[`go-redis`](https://github.com/redis/go-redis) is the [Go](https://go.dev/) client for Redis.
+The sections below explain how to install `go-redis` and connect your application to a Redis database.
+
+`go-redis` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+## Install
+
+`go-redis` supports the last two Go versions. You can only use it from within
+a Go module, so you must initialize a Go module before you start, or add your code to
+an existing module:
+
+```
+go mod init github.com/my/repo
+```
+
+Use the `go get` command to install `go-redis/v9`:
+
+```
+go get github.com/redis/go-redis/v9
+```
+
+## Connect
+
+The following example shows the simplest way to connect to a Redis server:
+
+```go
+import (
+	"context"
+	"fmt"
+	"github.com/redis/go-redis/v9"
+)
+
+func main() {    
+    client := redis.NewClient(&redis.Options{
+        Addr:	  "localhost:6379",
+        Password: "", // No password set
+        DB:		  0,  // Use default DB
+        Protocol: 2,  // Connection protocol
+    })
+}
+```
+
+You can also connect using a connection string:
+
+```go
+opt, err := redis.ParseURL("redis://<user>:<pass>@localhost:6379/<db>")
+if err != nil {
+	panic(err)
+}
+
+client := redis.NewClient(opt)
+```
+
+After connecting, you can test the connection by  storing and retrieving
+a simple [string]({{< relref "/develop/data-types/strings" >}}):
+
+```go
+ctx := context.Background()
+
+err := client.Set(ctx, "foo", "bar", 0).Err()
+if err != nil {
+    panic(err)
+}
+
+val, err := client.Get(ctx, "foo").Result()
+if err != nil {
+    panic(err)
+}
+fmt.Println("foo", val)
+```
+
+You can also easily store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}}):
+
+```go
+hashFields := []string{
+    "model", "Deimos",
+    "brand", "Ergonom",
+    "type", "Enduro bikes",
+    "price", "4972",
+}
+
+res1, err := client.HSet(ctx, "bike:1", hashFields).Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res1) // >>> 4
+
+res2, err := client.HGet(ctx, "bike:1", "model").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res2) // >>> Deimos
+
+res3, err := client.HGet(ctx, "bike:1", "price").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res3) // >>> 4972
+
+res4, err := client.HGetAll(ctx, "bike:1").Result()
+
+if err != nil {
+    panic(err)
+}
+
+fmt.Println(res4)
+// >>> map[brand:Ergonom model:Deimos price:4972 type:Enduro bikes]
+ ```
+
+ Use
+ [struct tags](https://stackoverflow.com/questions/10858787/what-are-the-uses-for-struct-tags-in-go)
+ of the form `redis:"<field-name>"` with the `Scan()` method to parse fields from
+ a hash directly into corresponding struct fields:
+
+ ```go
+type BikeInfo struct {
+    Model string `redis:"model"`
+    Brand string `redis:"brand"`
+    Type  string `redis:"type"`
+    Price int    `redis:"price"`
+}
+
+var res4a BikeInfo
+err = client.HGetAll(ctx, "bike:1").Scan(&res4a)
+
+if 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
+ ```
+
+## Observability
+
+`go-redis` supports [OpenTelemetry](https://opentelemetry.io/) instrumentation.
+to monitor performance and trace the execution of Redis commands.
+For example, the following code instruments Redis commands to collect traces, logs, and metrics:
+
+```go
+import (
+    "github.com/redis/go-redis/v9"
+    "github.com/redis/go-redis/extra/redisotel/v9"
+)
+
+client := redis.NewClient(&redis.Options{...})
+
+// Enable tracing instrumentation.
+if err := redisotel.InstrumentTracing(client); err != nil {
+	panic(err)
+}
+
+// Enable metrics instrumentation.
+if err := redisotel.InstrumentMetrics(client); err != nil {
+	panic(err)
+}
+```
+
+See the `go-redis` [GitHub repo](https://github.com/redis/go-redis/blob/master/example/otel/README.md).
+for more OpenTelemetry examples.
+
+## More information
+
+See the other pages in this section for more information and examples.
+Further examples are available at the [`go-redis`](https://redis.uptrace.dev/guide/) website
+and the [GitHub repository](https://github.com/redis/go-redis).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Java application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 2
+---
+
+Start by creating a connection to your Redis server. There are many ways to achieve this using Lettuce. Here are a few.
+
+## Basic connection
+
+```java
+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`. 
+
+```java
+import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
+
+//...
+try (RedisClusterClient clusterClient = RedisClusterClient.create(redisURI)) {    
+    StatefulRedisClusterConnection<String, String> connection = clusterClient.connect();
+        
+    //...
+    
+    connection.close();    
+}
+```
+
+Learn more about Cluster connections and how to configure them in [the reference guide](https://redis.github.io/lettuce/ha-sharding/#redis-cluster).
+
+## Asynchronous connection
+
+```java
+package org.example;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+
+import io.lettuce.core.*;
+import io.lettuce.core.api.async.RedisAsyncCommands;
+import io.lettuce.core.api.StatefulRedisConnection;
+
+public class Async {
+  public static void main(String[] args) {
+    RedisClient redisClient = RedisClient.create("redis://localhost:6379");
+
+    try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
+      RedisAsyncCommands<String, String> asyncCommands = connection.async();
+
+      // Asynchronously store & retrieve a simple string
+      asyncCommands.set("foo", "bar").get();
+      System.out.println(asyncCommands.get("foo").get()); // prints bar
+
+      // Asynchronously store key-value pairs in a hash directly
+      Map<String, String> hash = new HashMap<>();
+      hash.put("name", "John");
+      hash.put("surname", "Smith");
+      hash.put("company", "Redis");
+      hash.put("age", "29");
+      asyncCommands.hset("user-session:123", hash).get();
+
+      System.out.println(asyncCommands.hgetall("user-session:123").get());
+      // Prints: {name=John, surname=Smith, company=Redis, age=29}
+    } catch (ExecutionException | InterruptedException e) {
+      throw new RuntimeException(e);
+    } finally {
+      redisClient.shutdown();
+    }
+  }
+}
+```
+
+Learn more about asynchronous Lettuce API in [the reference guide](https://redis.github.io/lettuce/#asynchronous-api).
+
+## Reactive connection
+
+```java
+package org.example;
+import java.util.*;
+import io.lettuce.core.*;
+import io.lettuce.core.api.reactive.RedisReactiveCommands;
+import io.lettuce.core.api.StatefulRedisConnection;
+
+public class Main {
+  public static void main(String[] args) {
+    RedisClient redisClient = RedisClient.create("redis://localhost:6379");
+
+    try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
+      RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();
+
+      // Reactively store & retrieve a simple string
+      reactiveCommands.set("foo", "bar").block();
+      reactiveCommands.get("foo").doOnNext(System.out::println).block(); // prints bar
+
+      // Reactively store key-value pairs in a hash directly
+      Map<String, String> hash = new HashMap<>();
+      hash.put("name", "John");
+      hash.put("surname", "Smith");
+      hash.put("company", "Redis");
+      hash.put("age", "29");
+
+      reactiveCommands.hset("user-session:124", hash).then(
+              reactiveCommands.hgetall("user-session:124")
+                  .collectMap(KeyValue::getKey, KeyValue::getValue).doOnNext(System.out::println))
+          .block();
+      // Prints: {surname=Smith, name=John, company=Redis, age=29}
+
+    } finally {
+      redisClient.shutdown();
+    }
+  }
+}
+```
+
+Learn more about reactive Lettuce API in [the reference guide](https://redis.github.io/lettuce/#reactive-api).
+
+## Connect to a Redis cluster
+
+```java
+import io.lettuce.core.RedisURI;
+import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
+import io.lettuce.core.cluster.api.async.RedisAdvancedClusterAsyncCommands;
+
+// ...
+
+RedisURI redisUri = RedisURI.Builder.redis("localhost").withPassword("authentication").build();
+
+RedisClusterClient clusterClient = RedisClusterClient.create(redisUri);
+StatefulRedisClusterConnection<String, String> connection = clusterClient.connect();
+RedisAdvancedClusterAsyncCommands<String, String> commands = connection.async();
+
+// ...
+
+connection.close();
+clusterClient.shutdown();
+```
+
+### TLS connection
+
+When you deploy your application, use TLS and follow the [Redis security guidelines]({{< relref "/operate/oss_and_stack/management/security/" >}}).
+
+```java
+RedisURI redisUri = RedisURI.Builder.redis("localhost")
+                                 .withSsl(true)
+                                 .withPassword("secret!") // use your Redis password
+                                 .build();
+
+RedisClient client = RedisClient.create(redisUri);
+```
+
+## Connection Management in Lettuce
+
+Lettuce uses `ClientResources` for efficient management of shared resources like event loop groups and thread pools.
+For connection pooling, Lettuce leverages `RedisClient` or `RedisClusterClient`, which can handle multiple concurrent connections efficiently.
+
+## Connection pooling
+
+A typical approach with Lettuce is to create a single `RedisClient` instance and reuse it to establish connections to your Redis server(s).
+These connections are multiplexed; that is, multiple commands can be run concurrently over a single or a small set of connections, making explicit pooling less practical.
+See
+[Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+for more information.
+
+Lettuce provides pool config to be used with Lettuce asynchronous connection methods.
+
+```java
+package org.example;
+import io.lettuce.core.RedisClient;
+import io.lettuce.core.RedisURI;
+import io.lettuce.core.TransactionResult;
+import io.lettuce.core.api.StatefulRedisConnection;
+import io.lettuce.core.api.async.RedisAsyncCommands;
+import io.lettuce.core.codec.StringCodec;
+import io.lettuce.core.support.*;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+public class Pool {
+  public static void main(String[] args) {
+    RedisClient client = RedisClient.create();
+
+    String host = "localhost";
+    int port = 6379;
+
+    CompletionStage<BoundedAsyncPool<StatefulRedisConnection<String, String>>> poolFuture
+        = AsyncConnectionPoolSupport.createBoundedObjectPoolAsync(
+            () -> client.connectAsync(StringCodec.UTF8, RedisURI.create(host, port)),
+            BoundedPoolConfig.create());
+
+    // await poolFuture initialization to avoid NoSuchElementException: Pool exhausted when starting your application
+    AsyncPool<StatefulRedisConnection<String, String>> pool = poolFuture.toCompletableFuture()
+        .join();
+
+    // execute work
+    CompletableFuture<TransactionResult> transactionResult = pool.acquire()
+        .thenCompose(connection -> {
+
+          RedisAsyncCommands<String, String> async = connection.async();
+
+          async.multi();
+          async.set("key", "value");
+          async.set("key2", "value2");
+          System.out.println("Executed commands in pipeline");
+          return async.exec().whenComplete((s, throwable) -> pool.release(connection));
+        });
+    transactionResult.join();
+
+    // terminating
+    pool.closeAsync();
+
+    // after pool completion
+    client.shutdownAsync();
+  }
+}
+```
+
+In this setup, `LettuceConnectionFactory` is a custom class you would need to implement, adhering to Apache Commons Pool's `PooledObjectFactory` interface, to manage lifecycle events of pooled `StatefulRedisConnection` objects.
+---
+aliases: /develop/connect/clients/java/lettuce
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Lettuce application to a Redis database
+linkTitle: Lettuce (Java)
+title: Lettuce guide (Java)
+weight: 6
+---
+
+[Lettuce](https://github.com/redis/lettuce/tree/main/src/main) is an advanced Java client for Redis
+that supports synchronous, asynchronous, and reactive connections.
+If you only need synchronous connections then you may find the other Java client
+[Jedis]({{< relref "/develop/clients/jedis" >}}) easier to use.
+
+The sections below explain how to install `Lettuce` and connect your application
+to a Redis database.
+
+`Lettuce` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+## Install
+
+To include Lettuce as a dependency in your application, edit the appropriate dependency file as shown below.
+
+If you use Maven, add the following dependency to your `pom.xml`:
+
+```xml
+<dependency>
+    <groupId>io.lettuce</groupId>
+    <artifactId>lettuce-core</artifactId>
+    <version>6.3.2.RELEASE</version> <!-- Check for the latest version on Maven Central -->
+</dependency>
+```
+
+If you use Gradle, include this line in your `build.gradle` file:
+
+```
+dependencies {
+    compileOnly 'io.lettuce:lettuce-core:6.3.2.RELEASE'
+}
+```
+
+If you wish to use the JAR files directly, download the latest Lettuce and, optionally, Apache Commons Pool2 JAR files from Maven Central or any other Maven repository.
+
+To build from source, see the instructions on the [Lettuce source code GitHub repo](https://github.com/lettuce-io/lettuce-core).
+
+## Connect and test
+
+Connect to a local server using the following code. This example
+also stores and retrieves a simple string value to test the connection.
+
+```java
+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)
+                .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();
+    }
+}
+```
+
+## More information
+
+The [Lettuce reference guide](https://redis.github.io/lettuce/) has more examples
+and an API reference. You may also be interested in the
+[Project Reactor](https://projectreactor.io/) library that Lettuce uses.
+
+See also the other pages in this section for more information and examples:
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get your Lettuce app ready for production
+linkTitle: Production usage
+title: Production usage
+weight: 3
+---
+
+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.
+
+{{< checklist "lettuceprodlist" >}}
+    {{< checklist-item "#timeouts" >}}Timeouts{{< /checklist-item >}}
+    {{< checklist-item "#cluster-topology-refresh">}}Cluster topology refresh{{< /checklist-item >}}
+    {{< checklist-item "#dns-cache-and-redis" >}}DNS cache and Redis{{< /checklist-item >}}
+    {{< checklist-item "#exception-handling" >}}Exception handling{{< /checklist-item >}}
+{{< /checklist >}}
+
+## Recommendations
+
+The sections below offer recommendations for your production environment. Some
+of them may not apply to your particular use case.
+
+## Timeouts
+
+Lettuce provides timeouts for many operations, such as command execution, SSL handshake, and Sentinel discovery. By default, Lettuce uses a global timeout value of 60 seconds for these operations, but you can override the global timeout value with individual timeout values for each operation.
+
+{{% alert title="Tip" color="warning" %}}
+Choosing suitable timeout values is crucial for your application's performance and stability and is specific to each environment.
+Configuring timeouts is only necessary if you have issues with the default values. 
+In some cases, the defaults are based on environment-specific settings (e.g., operating system settings), while in other cases, they are built into the Lettuce driver. 
+For more details on setting specific timeouts, see the [Lettuce reference guide](https://redis.github.io/lettuce/).
+{{% /alert  %}}
+
+### Prerequisites
+
+To set TCP-level timeouts, you need to ensure you have one of [Netty Native Transports](https://netty.io/wiki/native-transports.html) installed. The most common one is `netty-transport-native-epoll`, which is used for Linux systems. You can add it to your project by including the following dependency in your `pom.xml` file:
+
+```xml
+<dependency>
+    <groupId>io.netty</groupId>
+    <artifactId>netty-transport-native-epoll</artifactId>
+    <version>${netty.version}</version> <!-- e.g., 4.1.118.Final -->
+    <classifier>linux-x86_64</classifier>
+</dependency>
+```
+
+Once you have the native transport dependency, you can verify that by using the following code:
+
+```java
+logger.info("Lettuce epool is available: {}", EpollProvider.isAvailable());
+```
+
+If the snippet above returns `false`, you need to enable debugging logging for `io.lettuce.core` and `io.netty` to see why the native transport is not available.
+
+For more information on using Netty Native Transport, see the [Lettuce reference guide](https://redis.github.io/lettuce/advanced-usage/#native-transports).
+
+### Setting timeouts
+
+Below is an example of setting socket-level timeouts. The `TCP_USER_TIMEOUT` setting is useful for scenarios where the server stops responding without acknowledging the last request, while the `KEEPALIVE` setting is good for detecting dead connections where there is no traffic between the client and the server.
+
+```java
+RedisURI redisURI = RedisURI.Builder
+        .redis("localhost")
+        // set the global default from the default 60 seconds to 30 seconds
+        .withTimeout(Duration.ofSeconds(30)) 
+        .build();
+
+try (RedisClient client = RedisClient.create(redisURI)) {
+    // or set specific timeouts for things such as the TCP_USER_TIMEOUT and TCP_KEEPALIVE
+
+    // A good general rule of thumb is to follow the rule
+    // TCP_USER_TIMEOUT = TCP_KEEP_IDLE+TCP_KEEPINTVL * TCP_KEEPCNT
+    // in this case, 20 = 5 + 5 * 3
+
+    SocketOptions.TcpUserTimeoutOptions tcpUserTimeout = SocketOptions.TcpUserTimeoutOptions.builder()
+            .tcpUserTimeout(Duration.ofSeconds(20))
+            .enable().build();
+
+    SocketOptions.KeepAliveOptions keepAliveOptions = SocketOptions.KeepAliveOptions.builder()
+            .interval(Duration.ofSeconds(5))
+            .idle(Duration.ofSeconds(5))
+            .count(3).enable().build();
+
+    SocketOptions socketOptions = SocketOptions.builder()
+            .tcpUserTimeout(tcpUserTimeout)
+            .keepAlive(keepAliveOptions)
+            .build();
+
+    client.setOptions(ClientOptions.builder()
+            .socketOptions(socketOptions)
+            .build());
+
+    StatefulRedisConnection<String, String> connection = client.connect();
+    System.out.println(connection.sync().ping());
+}
+```
+
+## Cluster topology refresh
+
+The Redis Cluster configuration is dynamic and can change at runtime. 
+New nodes may be added, and the primary node for a specific slot can shift.
+Lettuce automatically handles [MOVED]({{< relref "/operate/oss_and_stack/reference/cluster-spec#moved-redirection" >}}) and [ASK]({{< relref "/operate/oss_and_stack/reference/cluster-spec#ask-redirection" >}}) redirects, but to enhance your application's resilience, you should enable adaptive topology refreshing:
+
+```java
+RedisURI redisURI = RedisURI.Builder
+        .redis("localhost")
+        // set the global default from the default 60 seconds to 30 seconds
+        .withTimeout(Duration.ofSeconds(30)) 
+        .build();
+        
+// Create a RedisClusterClient with adaptive topology refresh
+try (RedisClusterClient clusterClient = RedisClusterClient.create(redisURI)) {
+    // Enable TCP keep-alive and TCP user timeout just like in the standalone example
+    SocketOptions.TcpUserTimeoutOptions tcpUserTimeout = SocketOptions.TcpUserTimeoutOptions.builder()
+            .tcpUserTimeout(Duration.ofSeconds(20))
+            .enable()
+            .build();
+
+    SocketOptions.KeepAliveOptions keepAliveOptions = SocketOptions.KeepAliveOptions.builder()
+            .interval(Duration.ofSeconds(5))
+            .idle(Duration.ofSeconds(5))
+            .count(3)
+            .enable()
+            .build();
+
+    SocketOptions socketOptions = SocketOptions.builder()
+            .tcpUserTimeout(tcpUserTimeout)
+            .keepAlive(keepAliveOptions)
+            .build();
+
+    // Enable adaptive topology refresh
+    // Configure adaptive topology refresh options
+    ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
+            .enableAllAdaptiveRefreshTriggers()
+            .adaptiveRefreshTriggersTimeout(Duration.ofSeconds(30))
+            .build();
+    
+    ClusterClientOptions options = ClusterClientOptions.builder()
+            .topologyRefreshOptions(topologyRefreshOptions)
+            .socketOptions(socketOptions).build();
+
+    clusterClient.setOptions(options);
+
+    StatefulRedisClusterConnection<String, String> connection = clusterClient.connect();
+    System.out.println(connection.sync().ping());
+    connection.close();
+}
+```
+Learn more about topology refresh configuration settings in [the reference guide](https://redis.github.io/lettuce/ha-sharding/#redis-cluster).
+
+
+## DNS cache and Redis
+
+When you connect to a Redis server with multiple endpoints, such as [Redis Enterprise Active-Active](https://redis.com/redis-enterprise/technology/active-active-geo-distribution/), you *must*
+disable the JVM's DNS cache. If a server node or proxy fails, the IP address for any database
+affected by the failure will change. When this happens, your app will keep
+trying to use the stale IP address if DNS caching is enabled.
+
+Use the following code to disable the DNS cache:
+
+```java
+java.security.Security.setProperty("networkaddress.cache.ttl","0");
+java.security.Security.setProperty("networkaddress.cache.negative.ttl", "0");
+```
+
+## Exception handling
+
+Redis handles many errors using return values from commands, but there
+are also situations where exceptions can be thrown. In production code,
+you should handle exceptions as they occur.
+
+See the Error handling sections of the
+[Lettuce async](https://redis.github.io/lettuce/user-guide/async-api/#error-handling) and
+[Lettuce reactive](https://redis.github.io/lettuce/user-guide/reactive-api/#error-handling)
+API guides to learn more about handling exceptions.
+---
+aliases: /develop/connect/clients/pools-and-muxing
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Manage Redis connections efficiently
+linkTitle: Pooling/multiplexing
+title: Connection pools and multiplexing
+weight: 40
+---
+
+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`]({{< relref "/develop/clients/redis-py" >}}),
+[`jedis`]({{< relref "/develop/clients/jedis" >}}), and
+[`go-redis`]({{< relref "/develop/clients/go" >}}) clients support
+connection pooling, while
+[`NRedisStack`]({{< relref "/develop/clients/dotnet" >}})
+supports multiplexing.
+[`Lettuce`]({{< relref "/develop/clients/lettuce" >}})
+supports both approaches.
+
+## Connection pooling
+
+When you initialize a connection pool, the client opens a small number
+of connections and adds them to the pool.
+
+{{< image filename="/images/dev/connect/pool-and-mux/ConnPoolInit.drawio.svg" >}}
+
+Each time you "open" a connection
+from the pool, the client returns one of these existing
+connections and notes the fact that it is in use.
+
+{{< image filename="/images/dev/connect/pool-and-mux/ConnPoolInUse.drawio.svg" >}}
+
+When you later "close"
+the connection, the client puts it back into the pool of available
+connections without actually closing it.
+
+{{< image filename="/images/dev/connect/pool-and-mux/ConnPoolDiscon.drawio.svg" >}}
+
+If all connections in the pool are in use but the app needs more, then
+the client can simply open new connections as necessary. In this way, the client
+eventually finds the right number of connections to satisfy your
+app's demands.
+
+## Multiplexing
+
+Instead of pooling several connections, a multiplexer keeps a
+single connection open and uses it for all traffic between the
+client and the server. The "connections" returned to your code are
+used to identify where to send the response data from your commands.
+
+{{< image filename="/images/dev/connect/pool-and-mux/ConnMux.drawio.svg" >}}
+
+Note that it is not a problem if the multiplexer receives several commands close
+together in time. When this happens, the multiplexer can often combine the commands into a
+[pipeline]({{< relref "/develop/use/pipelining" >}}), which
+improves efficiency.
+
+Multiplexing offers high efficiency but works transparently without requiring
+any special code to enable it in your app. The main disadvantage of multiplexing compared to
+connection pooling is that it can't support the blocking "pop" commands (such as
+[`BLPOP`]({{< relref "/commands/blpop" >}})) since these would stall the
+connection for all callers.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Construct commands and send them to the Redis server.
+linkTitle: Issue commands
+title: Issue commands
+weight: 5
+---
+
+Unlike the other [client libraries]({{< relref "/develop/clients" >}}),
+`hiredis` doesn't provide an extensive API to construct the many different
+Redis [commands]({{< relref "/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:
+
+```c
+void *redisCommand(redisContext *c, const char *format, ...);
+```
+
+This function receives a `redisContext` pointer and a pointer
+to a string containing the command (see
+[Connect]({{< relref "/develop/clients/hiredis/connect" >}})
+to learn how to obtain the context pointer). The command text is the
+same as the equivalent [`redis-cli`]({{< relref "/develop/tools/cli" >}})
+command. For example, to issue the command:
+
+```
+SET foo bar
+```
+
+you would use the following command with an existing `redisContext* c`:
+
+```c
+redisReply *reply = redisCommand(c, "SET foo bar");
+```
+
+See the [Command reference]({{< relref "/commands" >}}) for examples
+of CLI commands that you can use with `hiredis`. Most code examples
+in other sections of the docs also have a CLI tab showing
+command sequences that are equivalent to the code.
+
+The command string is interpreted in a similar way to the format
+string for `printf()`, so you can easily interpolate string values from
+your code into the command with the `%s` format specifier:
+
+```c
+char *myKeyNumber = "1";
+char *myValue = "Hello";
+
+// This issues the command 'SET key:1 Hello'.
+redisReply *reply = redisCommand(c, "SET key:%s %s", myKeyNumber, myValue);
+```
+
+You may need to include binary data in the command (for example, to store
+[vector embeddings]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}})
+in fields of a [hash]({{< relref "/develop/data-types/hashes" >}})) object.
+To do this, use the `%b` format specifier and pass a pointer to the
+data buffer, followed by a `size_t` value indicating its length in bytes.
+As the example below shows, you can freely mix `%s` and `%b` specifiers
+in the same format string. Also, you can use the sequence `%%` to
+denote a literal percent sign, but the other `printf()` specifiers,
+such as `%d`, are not supported.
+
+```c
+char *entryNumber = "1";
+char *embedding = "<binary data>";
+char *url = "https://redis.io/";
+size_t embLength = 13;
+
+redisReply *reply = redisCommand(c,
+    "HSET entry:%s embedding %b  url %s",
+    entryNumber,
+    embedding, embLength,
+    url
+);
+```
+
+The `redisCommand()` function has a variant called `redisCommandArgv()`:
+
+```c
+void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
+```
+
+This doesn't take a format string but instead builds the command from an array
+of strings passed in the `argv` parameter.
+
+Use the `argc` value to
+specify the length of this array and the `argvlen` array to specify
+the lengths of each of the strings in the array. If you pass `NULL`
+for `argvlen` then the function will attempt to use `strlen()` to
+get the length of each string. However, this will not work if any of
+the strings contains binary data, so you should pass `argvlen`
+explicitly in this case. The example below shows how to use
+`redisCommandArgv()` with a simple command:
+
+```c
+const char *argv[3] = { "SET", "greeting", "hello"};
+int argc = 3;
+const size_t argvlen[] = {3, 8, 5};
+
+redisReply *reply = redisCommandArgv(c, argc, argv, argvlen);
+```
+
+## Construct asynchronous commands
+
+Use the `redisAsyncCommand()` and `redisAsyncCommandArgv()`
+functions to send commands to the server asynchronously:
+
+```c
+#include <hiredis/async.h>
+    .
+    .
+    .
+int redisAsyncCommand(
+  redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
+  const char *format, ...);
+int redisAsyncCommandArgv(
+  redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
+  int argc, const char **argv, const size_t *argvlen);
+```
+
+These work the same way as `redisCommand()` and `redisCommandArgv()`
+(see [Construct synchronous commands](#construct-synchronous-commands)
+above) but they have two extra parameters. The first is a pointer to
+a optional callback function and the second is a pointer to your own
+custom data, which will be passed to the callback when it
+executes. Pass `NULL` for both of these pointers if you don't need
+to use them.
+
+The callback has the following signature:
+
+```c
+void(redisAsyncContext *c, void *reply, void *privdata);
+```
+
+The first parameter is the asynchronous connection context and
+the second is a pointer to the reply object. Use a cast to
+`(redisReply *)` to access the reply in the usual way (see 
+[Handle command replies]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+for a full description of `redisReply`). The last parameter
+is the custom data pointer that you supplied during the
+`redisAsyncCommand()` call. This is passed to your function
+without any modification.
+
+The example below shows how you can use `redisAsyncCommand()` with
+or without a reply callback:
+
+```c
+// The callback expects the key for the data in the `privdata`
+// custom data parameter.
+void getCallback(redisAsyncContext *c, void *r, void *privdata) {
+    redisReply *reply = r;
+    char *key = privdata;
+
+    if (reply == NULL) {
+        if (c->errstr) {
+            printf("errstr: %s\n", c->errstr);
+        }
+        return;
+    }
+
+    printf("Key: %s, value: %s\n", key, reply->str);
+
+    /* Disconnect after receiving the reply to GET */
+    redisAsyncDisconnect(c);
+}
+    .
+    .
+    .
+
+// Key and string value to pass to `SET`.
+char *key = "testkey";
+char *value = "testvalue";
+
+// We aren't interested in the simple status reply for
+// `SET`, so use NULL for the callback and custom data
+// pointers.
+redisAsyncCommand(c, NULL, NULL, "SET %s %s", key, value);
+
+// The reply from `GET` is essential, so set a callback
+// to retrieve it. Also, pass the key to the callback
+// as the custom data.
+redisAsyncCommand(c, getCallback, key, "GET %s", key);
+```
+
+Note that you should normally disconnect asynchronously from a
+callback when you have finished using the connection.
+Use `redisAsyncDisconnect()` to disconnect gracefully, letting
+pending commands execute and activate their callbacks.
+Use `redisAsyncFree()` to disconnect immediately. If you do this then
+any pending callbacks from commands that have already executed will be
+called with a `NULL` reply pointer.
+
+## Command replies
+
+The information in the `redisReply` object has several formats,
+and the format for a particular reply depends on the command that generated it.
+See
+[Handle replies]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+to learn about the different reply formats and how to use them.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Handle command replies with `hiredis`.
+linkTitle: Handle command replies
+title: Handle command replies
+weight: 10
+---
+
+The `redisCommand()` and `redisCommandArgv()` functions return
+a pointer to a `redisReply` object when you issue a command (see
+[Issue commands]({{< relref "/develop/clients/hiredis/issue-commands" >}})
+for more information). This type supports all
+reply formats defined in the
+[RESP2 and RESP3]({{< relref "/develop/reference/protocol-spec#resp-protocol-description" >}})
+protocols, so its content varies greatly between calls.
+
+A simple example is the status response returned by the [`SET`]({{< relref "/commands/set" >}})
+command. The code below shows how to get this from the `redisReply`
+object:
+
+```c
+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.
+
+For `SET`, a successful call will simply return an "OK" string that you
+can access with the `reply->str` field. The code in the example prints
+this to the console, but you should check for the specific value to ensure
+the command executed correctly.
+
+The `redisCommand()` call allocates memory for the reply, so you should
+always free it using `freeReplyObject()` when you have finished using
+the reply. If you want to reuse the reply variable then it is wise to
+set it to `NULL` after you free it, so that you don't accidentally use
+the stale pointer later.
+
+## Reply formats
+
+The Redis
+[`RESP`]({{< relref "/develop/reference/protocol-spec#resp-protocol-description" >}})
+protocols support several different reply formats for commands.
+
+You can find the reply format for a command at the end of its
+reference page in the RESP2/RESP3 Reply section (for example, the
+[`INCRBY`]({{< relref "/commands/incrby" >}}) page shows that the
+command has an integer result). You can also determine the format
+using the `type` field of the reply object. This contains a
+different integer value for each type. The `hiredis.h` header file
+defines constants for all of these integer values (for example `REDIS_REPLY_STRING`).
+
+The `redisReply` struct has several fields to contain different
+types of replies, with different fields being set depending on
+the value of the `type` field. The table below shows the type
+constants, the corresponding reply type, and the fields you can
+use to access the reply value:
+
+| Constant | Type | Relevant fields of `redisReply` | RESP protocol |
+| :- | :- |:- | :- |
+| `REDIS_REPLY_STATUS` | [Simple string]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) | `reply->str`: the string value (`char*`)<br/> `reply->len`: the string length (`size_t`) | 2, 3 |
+| `REDIS_REPLY_ERROR` | [Simple error]({{< relref "/develop/reference/protocol-spec#simple-errors" >}}) | `reply->str`: the string value (`char*`)<br/> `reply->len`: the string length (`size_t`) | 2, 3 |
+| `REDIS_REPLY_INTEGER` | [Integer]({{< relref "/develop/reference/protocol-spec#integers" >}}) | `reply->integer`: the integer value (`long long`)| 2, 3 |
+| `REDIS_REPLY_NIL` | [Null]({{< relref "/develop/reference/protocol-spec#nulls" >}}) | No data | 2, 3 |
+| `REDIS_REPLY_STRING` | [Bulk string]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}) |`reply->str`: the string value (`char*`)<br/> `reply->len`: the string length (`size_t`) | 2, 3 |
+| `REDIS_REPLY_ARRAY` | [Array]({{< relref "/develop/reference/protocol-spec#arrays" >}}) | `reply->elements`: number of elements (`size_t`)<br/> `reply->element`: array elements (`redisReply`) | 2, 3 |
+| `REDIS_REPLY_DOUBLE` | [Double]({{< relref "/develop/reference/protocol-spec#doubles" >}}) | `reply->str`: double value as string (`char*`)<br/> `reply->len`: the string length (`size_t`) | 3 |
+| `REDIS_REPLY_BOOL` | [Boolean]({{< relref "/develop/reference/protocol-spec#booleans" >}}) | `reply->integer`: the boolean value, 0 or 1 (`long long`) | 3 |
+| `REDIS_REPLY_MAP` | [Map]({{< relref "/develop/reference/protocol-spec#maps" >}}) | `reply->elements`: number of elements (`size_t`)<br/> `reply->element`: array elements (`redisReply`) | 3 |
+| `REDIS_REPLY_SET` | [Set]({{< relref "/develop/reference/protocol-spec#sets" >}}) | `reply->elements`: number of elements (`size_t`)<br/> `reply->element`: array elements (`redisReply`) | 3 |
+| `REDIS_REPLY_PUSH` | [Push]({{< relref "/develop/reference/protocol-spec#pushes" >}}) | `reply->elements`: number of elements (`size_t`)<br/> `reply->element`: array elements (`redisReply`) | 3 |
+| `REDIS_REPLY_BIGNUM` | [Big number]({{< relref "/develop/reference/protocol-spec#big-numbers" >}}) | `reply->str`: number value as string (`char*`)<br/> `reply->len`: the string length (`size_t`) | 3 |
+| `REDIS_REPLY_VERB` | [Verbatim string]({{< relref "/develop/reference/protocol-spec#verbatim-strings" >}}) |`reply->str`: the string value (`char*`)<br/> `reply->len`: the string length (`size_t`)<br/> `reply->vtype`: content type (`char[3]`) | 3 |
+
+## Reply format processing examples
+
+The sections below explain how to process specific reply types in
+more detail.
+
+### Integers
+
+The `REDIS_REPLY_INTEGER` and `REDIS_REPLY_BOOL` reply types both
+contain values in `reply->integer`. However, `REDIS_REPLY_BOOL` is
+rarely used. Even when the command essentially returns a boolean value,
+the reply is usually reported as an integer. 
+
+```c
+// Add some values to a set.
+redisReply *reply = redisCommand(c, "SADD items bread milk peas");
+
+if (reply->type == REDIS_REPLY_INTEGER) {
+    // Report status.
+    printf("Integer reply\n");
+    printf("Number added: %lld\n", reply->integer);
+    // >>> Number added: 3
+}
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "SISMEMBER items bread");
+
+// This also gives an integer reply but you should interpret
+// it as a boolean value.
+if (reply->type == REDIS_REPLY_INTEGER) {
+    // Respond to boolean integer value.
+    printf("Integer reply\n");
+    
+    if (reply->integer == 0) {
+        printf("Items set has no member 'bread'\n");
+    } else {
+        printf("'Bread' is a member of items set\n");
+    }
+    // >>> 'Bread' is a member of items set
+}
+
+freeReplyObject(reply);
+reply = NULL;
+```
+
+### Strings
+
+The `REDIS_REPLY_STATUS`, `REDIS_REPLY_ERROR`, `REDIS_REPLY_STRING`,
+`REDIS_REPLY_DOUBLE`, `REDIS_REPLY_BIGNUM`, and `REDIS_REPLY_VERB`
+are all returned as strings, with the main difference lying in how
+you interpret them. For all these types, the string value is
+returned in `reply->str` and the length of the string is in
+`reply->len`. The example below shows some of the possibilities.
+
+```c
+// Set a numeric value in a string.
+reply = redisCommand(c, "SET number 1.5");
+
+// This gives a status reply.
+if (reply->type == REDIS_REPLY_STATUS) {
+    // Report status.
+    printf("Status reply\n");
+    printf("Reply: %s\n", reply->str); // >>> Reply: OK
+}
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+// Attempt to interpret the key as a hash.
+reply = redisCommand(c, "HGET number field1");
+
+// This gives an error reply.
+if (reply->type == REDIS_REPLY_ERROR) {
+    // Report the error.
+    printf("Error reply\n");
+    printf("Reply: %s\n", reply->str);
+    // >>> Reply: WRONGTYPE Operation against a key holding the wrong kind of value
+}
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "GET number");
+
+// This gives a simple string reply.
+if (reply->type == REDIS_REPLY_STRING) {
+    // Display the string.
+    printf("Simple string reply\n");
+    printf("Reply: %s\n", reply->str); // >>> Reply: 1.5
+}
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "ZADD prices 1.75 bread 5.99 beer");
+
+// This gives an integer reply.
+if (reply->type == REDIS_REPLY_INTEGER) {
+    // Display the integer.
+    printf("Integer reply\n");
+    printf("Number added: %lld\n", reply->integer);
+    // >>> Number added: 2
+}
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "ZSCORE prices bread");
+
+// This gives a string reply with RESP2 and a double reply
+// with RESP3, but you handle it the same way in either case.
+if (reply->type == REDIS_REPLY_STRING) {
+    printf("String reply\n");
+    
+    char *endptr; // Not used.
+    double price = strtod(reply->str, &endptr);
+    double discounted = price * 0.75;
+    printf("Discounted price: %.2f\n", discounted);
+    // >>> Discounted price: 1.31
+}
+
+freeReplyObject(reply);
+reply = NULL;
+```
+
+### Arrays and maps
+
+Arrays (reply type `REDIS_REPLY_ARRAY`) and maps (reply type `REDIS_REPLY_MAP`)
+are returned by commands that retrieve several values at the
+same time. For both types, the number of elements in the reply is contained in
+`reply->elements` and the pointer to the array itself is is `reply->element`.
+Each item in the array is of type `redisReply`. The array elements
+are typically simple types rather than arrays or maps.
+
+The example below shows how to get the items from a
+[list]({{< relref "/develop/data-types/lists" >}}):
+
+```c
+reply = redisCommand(c, "RPUSH things thing0 thing1 thing2 thing3");
+
+printf("Added %lld items\n", reply->integer);
+// >>> Added 4 items
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "LRANGE things 0 -1");
+
+for (int i = 0; i < reply->elements; ++i) {
+    if (reply->element[i]->type == REDIS_REPLY_STRING) {
+        printf("List item %d: %s\n", i, reply->element[i]->str);
+    }
+}
+// >>> List item 0: thing0
+// >>> List item 1: thing1
+// >>> List item 2: thing2
+// >>> List item 3: thing3
+```
+
+A map is essentially the same as an array but it has the extra
+guarantee that the items will be listed in key-value pairs.
+The example below shows how to get all the fields from a
+[hash]({{< relref "/develop/data-types/hashes" >}}) using
+[`HGETALL`]({{< relref "/commands/hgetall" >}}):
+
+```c
+const char *hashCommand[] = {
+    "HSET", "details",
+    "name", "Mr Benn",
+    "address", "52 Festive Road",
+    "hobbies", "Cosplay"
+};
+
+reply = redisCommandArgv(c, 8, hashCommand, NULL);
+
+printf("Added %lld fields\n", reply->integer);
+// >>> Added 3 fields
+
+freeReplyObject(reply);
+reply = NULL;
+
+
+reply = redisCommand(c, "HGETALL details");
+
+// This gives an array reply with RESP2 and a map reply with
+// RESP3, but you handle it the same way in either case.
+if (reply->type == REDIS_REPLY_ARRAY) {        
+    for (int i = 0; i < reply->elements; i += 2) {
+        char *key = reply->element[i]->str;
+        char *value = reply->element[i + 1]->str;
+        printf("Key: %s, value: %s\n", key, value);
+    }
+    // >>> Key: name, value: Mr Benn
+    // >>> Key: address, value: 52 Festive Road
+    // >>> Key: hobbies, value: Cosplay
+}
+```
+
+## Handling errors
+
+When a command executes successfully, the `err` field of the context
+object will be set to zero. If a command fails, it will return either
+`NULL` or `REDIS_ERR`, depending on which function and command you used. When
+this happens, `context->err` will contain an error code
+
+-   `REDIS_ERR_IO`: There was an I/O error while creating the connection,
+    or while trying to write or read data. Whenever `context->err` contains
+    `REDIS_ERR_IO`, you can use the features of the standard library file
+    [`errno.h`](https://en.wikipedia.org/wiki/Errno.h) to find out more
+    information about the error.
+-   `REDIS_ERR_EOF`: The server closed the connection which resulted in an empty read.
+-   `REDIS_ERR_PROTOCOL`: There was an error while parsing the
+    [RESP protocol]({{< relref "/develop/reference/protocol-spec" >}}).
+-   `REDIS_ERR_OTHER`: Any other error. Currently, it is only used when the connection
+    hostname can't be resolved.
+
+The context object also has an `errstr` field that contains a descriptive error message.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 20
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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.
+
+There is also an input buffer that receives replies from
+commands. If you call `redisGetReply()` when the input buffer is empty,
+it will first send any commands that are queued in the output buffer and
+then wait for replies to arrive in the input buffer. It will then return
+the first reply only.
+
+If you then make subsequent `redisGetReply()` calls, they will
+find the input buffer is not empty, but still has replies
+queued from previous commands. In this case, `redisGetReply()`
+will just remove and return replies from the input buffer
+until it is empty again.
+
+The example below shows how to use `redisAppendCommand()`
+and `redisGetReply()` together:
+
+```c
+redisAppendCommand(c, "SET fruit:0 Apple");
+redisAppendCommand(c, "SET fruit:1 Banana");
+redisAppendCommand(c, "SET fruit:2 Cherry");
+
+redisAppendCommand(c, "GET fruit:0");
+redisAppendCommand(c, "GET fruit:1");
+redisAppendCommand(c, "GET fruit:2");
+
+
+redisReply *reply;
+
+// Iterate once for each of the six commands in the
+// pipeline.
+for (int i = 0; i < 6; ++i) {
+    redisGetReply(c, (void**) &reply);
+
+    // If an error occurs, the context object will
+    // contain an error code and/or an error string.
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("Error: %s", c->errstr);
+    } else {
+        printf("%s\n", reply->str);
+    }
+
+    freeReplyObject(reply);
+}
+// >>> OK
+// >>> OK
+// >>> OK
+// >>> Apple
+// >>> Banana
+// >>> Cherry
+```
+
+`redisAppendCommand()` has the same call signature as `redisCommand()` except that
+it doesn't return a `redisReply`. There is also a `redisAppendCommandArgv()`
+function that is analogous to `redisCommandArgv()` (see
+[Issue commands]({{< relref "/develop/clients/hiredis/issue-commands" >}})
+for more information).
+
+`redisGetReply()` receives the usual
+context pointer and a pointer to a `redisReply` pointer (which you
+must cast to `void**`). After `redisGetReply()` returns,
+the reply pointer will point to the `redisReply` object returned by
+the queued command (see
+[Handle command replies]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+for more information). 
+
+Call `redisGetReply()` once for each command that you added to the pipeline.
+You should check for errors after each call and free each reply object
+when you have finished processing it, as in the example above.
+
+## Transactions
+
+`hiredis` doesn't provide any special API to handle transactions, but
+you can implement them yourself using the [`MULTI`]({{< relref "/commands/multi" >}}),
+[`EXEC`]({{< relref "/commands/exec" >}}), and [`WATCH`]({{< relref "/commands/watch" >}})
+commands as you would from [`redis-cli`]({{< relref "/develop/tools/cli" >}}).
+See [Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect to the server with `hiredis`.
+linkTitle: Connect
+title: Connect
+weight: 1
+---
+
+## 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.
+
+```c
+#include <stdio.h>
+
+#include <hiredis/hiredis.h>
+    .
+    .
+    .
+
+// The `redisContext` type represents the connection
+// to the Redis server. Here, we connect to the
+// default host and port.
+redisContext *c = redisConnect("127.0.0.1", 6379);
+
+// Check if the context is null or if a specific
+// error occurred.
+if (c == NULL || c->err) {
+    if (c != NULL) {
+        printf("Error: %s\n", c->errstr);
+        // handle error
+    } else {
+        printf("Can't allocate redis context\n");
+    }
+
+    exit(1);
+}
+
+// Set a string key.
+redisReply *reply = redisCommand(c, "SET foo bar");
+printf("Reply: %s\n", reply->str); // >>> Reply: OK
+freeReplyObject(reply);
+
+// Get the key we have just stored.
+reply = redisCommand(c, "GET foo");
+printf("Reply: %s\n", reply->str); // >>> Reply: bar
+freeReplyObject(reply);
+
+// Close the connection.
+redisFree(c);
+```
+
+## Asynchronous connection
+
+You can also connect to Redis using an asynchronous API.
+The `redisAsyncConnect()` call that creates the context is
+similar to the synchronous function `redisConnect()`, but it returns the
+context object immediately before the connection is complete.
+It lets you supply callbacks to respond when a connection is successful
+or to handle any errors that may occur.
+
+The following code creates an asynchronous connection and
+sets the context callbacks. Note that you must also include the
+`async.h` header to access the asynchronous API.
+
+```c
+#include <stdio.h>
+
+#include <hiredis/hiredis.h>
+#include <hiredis/async.h>
+    .
+    .
+    .
+
+redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+
+if (c->err) {
+    printf("Error: %s\n", c->errstr);
+    return 1;
+}
+
+// Set callbacks to respond to successful or unsuccessful
+// connection and disconnection.
+redisAsyncSetConnectCallback(c, connectCallback);
+redisAsyncSetDisconnectCallback(c, disconnectCallback);
+
+char *key = "testkey";
+char *value = "testvalue";
+
+// Status reply is ignored.
+redisAsyncCommand(c, NULL, NULL, "SET %s %s", key, value);
+
+// Reply handled by `getCallback()` function.
+redisAsyncCommand(c, getCallback, key, "GET %s", key);
+```
+
+The callback functions have a simple signature that receives
+the context object and a status code. See
+[Handling errors]({{< relref "/develop/clients/hiredis/handle-replies#handling-errors" >}})
+for a list of the possible status codes.
+
+```c
+void connectCallback(const redisAsyncContext *c, int status) {
+    if (status != REDIS_OK) {
+        printf("Error: %s\n", c->errstr);
+        return;
+    }
+    printf("Connected...\n");
+}
+
+void disconnectCallback(const redisAsyncContext *c, int status) {
+    if (status != REDIS_OK) {
+        printf("Error: %s\n", c->errstr);
+        return;
+    }
+    printf("Disconnected...\n");
+}
+```
+
+Use the `redisAsyncCommand()` function to issue Redis commands
+with an asynchronous connection. This is similar to the equivalent
+synchronous function `redisCommand()` but also lets you supply a callback
+and a custom data pointer to process the response to the command. See
+[Construct asynchronous commands]({{< relref "/develop/clients/hiredis/issue-commands#construct-asynchronous-commands" >}}) for more
+information.
+
+Note that you should normally disconnect asynchronously from a
+callback when you have finished using the connection.
+Use `redisAsyncDisconnect()` to disconnect gracefully, letting
+pending commands execute and activate their callbacks.
+Use `redisAsyncFree()` to disconnect immediately. If you do this then
+any pending callbacks from commands that have already executed will be
+called with a `NULL` reply pointer.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Use `hiredis` in conjunction with the `libevent` framework.
+linkTitle: libevent integration
+title: Integrate hiredis with a libevent app
+weight: 60
+---
+
+The [`libevent`](https://libevent.org/) 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](https://libevent.org/) 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.
+
+When you have downloaded `libevent`, follow the instructions in the
+`README` file to compile and install the library.
+
+## Create a simple app
+
+For a real project, you would build your code with a makefile, but for
+this simple test, you can just place it in a file called `main.c` and
+build it with the following command (assuming you used `make install` to
+install the `libhiredis` and `libevent` libraries):
+
+```bash
+cc main.c -L/usr/local/lib -lhiredis -levent
+```
+
+See [Build and install]({{< relref "/develop/clients/hiredis#build-and-install" >}})
+to learn how to build `hiredis`, if you have not already done so.
+
+Now, add the following code in `main.c`. An explanation follows the
+code example:
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <hiredis/hiredis.h>
+#include <hiredis/async.h>
+#include <hiredis/adapters/libevent.h>
+
+// Callback for the `GET` command. 
+void getCallback(redisAsyncContext *c, void *r, void *privdata) {
+    redisReply *reply = r;
+    char *key = privdata;
+
+    if (reply == NULL) {
+        if (c->errstr) {
+            printf("errstr: %s\n", c->errstr);
+        }
+        return;
+    }
+
+    printf("Key: %s, value: %s\n", key, reply->str);
+
+    /* Disconnect after receiving the reply to GET */
+    redisAsyncDisconnect(c);
+}
+
+// Callback to respond to successful or unsuccessful connection.
+void connectCallback(const redisAsyncContext *c, int status) {
+    if (status != REDIS_OK) {
+        printf("Error: %s\n", c->errstr);
+        return;
+    }
+    printf("Connected...\n");
+}
+
+// Callback to respond to intentional or unexpected disconnection.
+void disconnectCallback(const redisAsyncContext *c, int status) {
+    if (status != REDIS_OK) {
+        printf("Error: %s\n", c->errstr);
+        return;
+    }
+    printf("Disconnected...\n");
+}
+
+
+int main (int argc, char **argv) {
+#ifndef _WIN32
+    signal(SIGPIPE, SIG_IGN);
+#endif
+
+    // Create the libevent `event_base` object to track all
+    // events.
+    struct event_base *base = event_base_new();
+
+    redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+
+    if (c->err) {
+        printf("Error: %s\n", c->errstr);
+        return 1;
+    }
+
+    // Use the Redis libevent adapter to attach the Redis connection
+    // to the libevent main loop.
+    redisLibeventAttach(c,base);
+    
+    redisAsyncSetConnectCallback(c, connectCallback);
+    redisAsyncSetDisconnectCallback(c, disconnectCallback);
+    
+    char *key = "testkey";
+    char *value = "testvalue";
+
+    redisAsyncCommand(c, NULL, NULL, "SET %s %s", key, value);
+    redisAsyncCommand(c, getCallback, key, "GET %s", key);
+    
+    // Run the event loop.
+    event_base_dispatch(base);
+
+    return 0;
+}
+```
+
+The code calls
+[`event_base_new()`](https://libevent.org/doc/event_8h.html#af34c025430d445427a2a5661082405c3)
+to initialize the core
+[`event_base`](https://libevent.org/doc/structevent__base.html)
+object that manages the event loop. It then creates a standard
+[asynchronous connection]({{< relref "/develop/clients/hiredis/connect#asynchronous-connection" >}})
+to Redis and uses the `libevent` adapter function `redisLibeventAttach()` to
+attach the connection to the event loop.
+
+After setting the [connection callbacks]({{< relref "/develop/clients/hiredis/connect#asynchronous-connection" >}}), the code issues two asynchronous
+Redis commands (see
+[Construct asynchronous commands]({{< relref "/develop/clients/hiredis/issue-commands#construct-asynchronous-commands" >}})
+for more information).
+The final step is to call
+[`event_base_dispatch()`](https://libevent.org/doc/event_8h.html#a19d60cb72a1af398247f40e92cf07056)
+to start the event loop. This will wait for the commands to be processed and
+then exit when the Redis connection is closed in the `getCallback()` function.
+
+## Run the code
+
+If you compile and run the code, you will see the following output,
+showing that the callbacks executed correctly:
+
+```
+Connected...
+Key: testkey, value: testvalue
+Disconnected...
+```
+
+You can use the
+[`KEYS`]({{< relref "/commands/keys" >}}) command from
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) or
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) to check
+that the "testkey" string key was added to the Redis database.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Integrate hiredis with C++ and external frameworks.
+linkTitle: Integration guides
+title: Integration guides
+weight: 50
+---
+
+`hiredis` is compatible with C++ and the library source includes a set of
+[adapters](https://github.com/redis/hiredis/tree/master/adapters)
+to help you use it in conjunction with C and C++ libraries and frameworks.
+The pages in this section explain how to integrate `hiredis` into
+your app.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Use `hiredis` in conjunction with the Qt app framework.
+linkTitle: Qt integration
+title: Integrate hiredis with a Qt app
+weight: 50
+---
+
+[Qt](https://www.qt.io/) 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](https://www.qt.io/download-dev) 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](https://doc.qt.io/qtcreator/)
+docs for an extensive set of examples and tutorials.
+
+## Create a simple app
+
+We will use a simple console app to demonstrate how to connect
+to Redis from Qt. Create the app project in Qt Creator using the
+**File > New Project** command. The generated source code is a
+single C++ file, called `main.cpp`, that uses a
+[`QCoreApplication`](https://doc.qt.io/qt-6/qcoreapplication.html)
+object to handle the main event loop. Although it will compile and run,
+it doesn't do anything useful at this stage.
+
+## Add `hiredis` files
+
+Build `hiredis` if you have not already done so (see
+[Build and install]({{< relref "/develop/clients/hiredis#build-and-install" >}})
+for more information).
+
+You should also make the `libhiredis` library available to the project. For example,
+if you have used the default option of [`cmake`](https://cmake.org/) as the project
+build tool and you have installed the `.dylib` or `.so` file for `hiredis` in `/usr/local/lib`,
+you should add the following lines to the `CMakeLists.txt` file:
+
+```
+add_library(hiredis SHARED IMPORTED)
+set_property(TARGET hiredis PROPERTY
+             IMPORTED_LOCATION "/usr/local/lib/libhiredis.dylib")
+```
+
+You should also modify the `target_link_libraries` directive to include
+`hiredis`:
+
+```
+target_link_libraries(ConsoleTest Qt${QT_VERSION_MAJOR}::Core hiredis)
+```
+
+## Add code to access Redis
+
+You can add a class using the **Add new** context menu
+on the project folder in Qt Creator. The sections below give
+examples of the code you should add to this class to
+connect to Redis. The code is separated into header and
+implementation files.
+
+### Header file
+
+The header file for a class called `RedisExample` is shown below.
+An explanation follows the code.
+
+```c++
+// redisexample.h
+
+#ifndef REDISEXAMPLE_H
+#define REDISEXAMPLE_H
+
+#include <QObject>
+
+#include <hiredis/hiredis.h>
+#include <hiredis/async.h>
+#include <hiredis/adapters/qt.h>
+
+
+class RedisExample : public QObject
+{
+    Q_OBJECT
+
+public:
+    // Constructor
+    RedisExample(const char *keyForRedis, const char *valueForRedis, QObject *parent = 0)
+        :QObject(parent), m_key(keyForRedis), m_value(valueForRedis) {}
+
+public slots:
+    // Slot method to hold the code that connects to Redis and issues
+    // commands.
+    void run();
+
+signals:
+    // Signal to indicate that our code has finished executing.
+    void finished();
+
+public:
+    // Method to close the Redis connection and signal that we've
+    // finished.
+    void finish();
+
+private:
+    const char *m_key;          // Key for Redis string.
+    const char *m_value;        // Value for Redis string.
+    redisAsyncContext *m_ctx;   // Redis connection context.
+    RedisQtAdapter m_adapter;   // Adapter to let `hiredis` work with Qt.
+};
+
+#endif // REDISEXAMPLE_H
+```
+
+[`QObject`](https://doc.qt.io/qt-6/qobject.html) is a key Qt class that
+implements the [Object model](https://doc.qt.io/qt-6/object.html) for
+communication between objects. When you create your class in Qt Creator,
+you can specify that you want it to be a subclass of `QObject` (this will
+add the appropriate header files and include the `Q_OBJECT` macro in the
+class declaration).
+
+The `QObject` communication model uses some instance methods as *signals*
+to report events and others as *slots* to act as callbacks that process the
+events (see [Signals and slots](https://doc.qt.io/qt-6/signalsandslots.html)
+for an introduction). The Qt [meta-object compiler](https://doc.qt.io/qt-6/moc.html)
+recognizes the non-standard C++ access specifiers `signals:` and `slots:`  in the
+class declaration and adds extra code for them during compilation to enable
+the communication mechanism.
+
+In our class, there is a `run()` slot that will implement the code to access Redis.
+The code eventually emits a `finished()` signal when it is complete to indicate that
+the app should exit.
+
+Our simple example code just sets and gets a Redis
+[string]({{< relref "/develop/data-types/strings" >}}) key. The class contains
+private attributes for the key and value (following the Qt `m_xxx` naming convention
+for class members). These are set by the constructor along with a call to the
+`QObject` constructor. The other attributes represent the connection context for
+Redis (which should generally be
+[asynchronous]({{< relref "/develop/clients/hiredis/connect#asynchronous-connection" >}})
+for a Qt app) and an adapter object that `hiredis` uses to integrate with Qt.
+
+### Implementation file
+
+The file that implements the methods declared in the header is shown
+below. A full explanation follows the code.
+
+```c++
+// redisexample.cpp
+
+#include <iostream>
+
+#include "redisexample.h"
+
+
+void RedisExample::finish() {
+    // Disconnect gracefully.
+    redisAsyncDisconnect(m_ctx);
+
+    // Emit the `finished()` signal to indicate that the
+    // execution is complete.
+    emit finished();
+}
+
+
+// Callback used by our `GET` command in the `run()` method.
+void getCallback(redisAsyncContext *, void * r, void * privdata) {
+
+    // Cast data pointers to their appropriate types.
+    redisReply *reply = static_cast<redisReply *>(r);
+    RedisExample *ex = static_cast<RedisExample *>(privdata);
+
+    if (reply == nullptr || ex == nullptr) {
+        return;
+    }
+
+    std::cout << "Value: " << reply->str << std::endl;
+
+    // Close the Redis connection and quit the app.
+    ex->finish();
+}
+
+
+void RedisExample::run() {
+    // Open the connection to Redis.
+    m_ctx = redisAsyncConnect("localhost", 6379);
+
+    if (m_ctx->err) {
+        std::cout << "Error: " << m_ctx->errstr << std::endl;
+        finish();
+    }
+
+    // Configure the connection to work with Qt.
+    m_adapter.setContext(m_ctx);
+
+    // Issue some simple commands. For the `GET` command, pass a
+    // callback function and a pointer to this object instance
+    // so that we can access the object's members from the callback.
+    redisAsyncCommand(m_ctx, NULL, NULL, "SET %s %s", m_key, m_value);
+    redisAsyncCommand(m_ctx, getCallback, this, "GET %s", m_key);
+}
+```
+
+The code that accesses Redis is in the `run()` method (recall that this
+implements a Qt slot that will be called in response to a signal). The
+code connects to Redis and stores the connection context pointer in the
+`m_ctx` attribute of the class instance. The call to `m_adapter.setContext()`
+initializes the Qt support for the context. Note that we need an
+asynchronous connection for Qt. See
+[Asynchronous connection]({{< relref "/develop/clients/hiredis/connect#asynchronous-connection" >}})
+for more information.
+
+The code then issues two Redis commands to [`SET`]({{< relref "/commands/set" >}})
+the string key and value that were supplied using the class's constructor. We are
+not interested in the response returned by this command, but we are interested in the
+response from the [`GET`]({{< relref "/commands/get" >}}) command that follows it.
+Because the commands are asynchronous, we need to set a callback to handle
+the `GET` response when it arrives. In the `redisAsyncCommand()` call, we pass
+a pointer to our `getCallback()` function and also pass a pointer to the
+`RedisExample` instance. This is a custom data field that will simply
+be passed on to the callback when it executes (see 
+[Construct asynchronous commands]({{< relref "/develop/clients/hiredis/issue-commands#construct-asynchronous-commands" >}})
+for more information).
+
+The code in the `getCallback()` function starts by casting the reply pointer
+parameter to [`redisReply`]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+and the custom data pointer to `RedisExample`. Here, the example just prints
+the reply string to the console, but you can process it in any way you like.
+You can add methods to your class and call them within the callback using the
+custom data pointer passed during the `redisAsyncCommand()` call. Here, we
+simply use the pointer to call the `finish()` method.
+
+The `finish()` method calls
+`redisAsyncDisconnect()` to close the connection and then uses the
+Qt signalling mechanism to emit the `finished()` signal. You may need to
+process several commands with a particular connection context, but you should
+close it from a callback when you have finished using it.
+
+### Main program
+
+To access the `RedisExample` class, you should use code like the
+following in the `main()` function defined in `main.cpp`:
+
+```c++
+#include <QCoreApplication>
+#include <QTimer>
+
+#include "redisexample.h"
+
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication app(argc, argv);
+
+    // Instance of our object.
+    RedisExample r("url", "https://redis.io/");
+
+    // Call the `run()` slot on our `RedisExample` instance to
+    // run our Redis commands. 
+    QTimer::singleShot(0, &r, SLOT(run()));
+
+    // Set up a communication connection between our `finished()`
+    // signal and the application's `quit()` slot.
+    QObject::connect(&r, SIGNAL(finished()), &app, SLOT(quit()));
+
+    // Start the app's main event loop.
+    return app.exec();
+}
+```
+
+This creates the [`QCoreApplication`](https://doc.qt.io/qt-6/qcoreapplication.html)
+instance that manages the main event loop for a console app. It
+then creates the instance of `RedisExample` with the key ("url") and
+value ("https://redis.io/") for our Redis string.
+
+The two lines below set up the `QObject` communication mechanism
+for the app. The call to
+[`QTimer::singleShot()`](https://doc.qt.io/qt-6/qtimer.html#singleShot-2)
+activates the `run()`
+slot method on our `RedisExample` instance. The 
+[`QObject::connect()`](https://doc.qt.io/qt-6/qobject.html#connect-5)
+call creates a communication link between the `finished()` signal of
+out `RedisExample` instance and the `quit()` slot of our
+`QCoreApplication` instance. This quits the application event loop and
+exits the app when the `finished()` signal is emitted by the
+`RedisExample` object. This happens when the `finish()` method is called
+at the end of the `GET` command callback.
+
+## Run the code
+
+When you have added the code, you can run it from the **Build** menu of
+Qt Creator or from the toolbar at the left hand side of the window.
+Assuming the connection to Redis succeeds, it will print the message
+`Value: https://redis.io/` and quit. You can use the
+[`KEYS`]({{< relref "/commands/keys" >}}) command from
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) or
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) to check
+that the "url" string key was added to the Redis database.
+
+## Key information
+
+There are many ways you could use Redis with a Qt app, but our example
+demonstrates some techniques that are broadly useful:
+
+-   Use the `QObject` communication mechanism to simplify your code.
+-   Use the `hiredis` asynchronous API. Add a `RedisQtAdapter` instance
+    to your code and ensure you call its `setContext()` method to
+    initialize it before issuing Redis commands.
+-   Place all code and data you need to interact with Redis
+    (including the connection context) in a single
+    class or ensure it is available from a class via pointers and
+    Qt signals. Pass a pointer to an instance of your class in the
+    custom data parameter when you issue a Redis command with
+    `redisAsyncCommand()` and use this to process the reply or
+    issue more commands from the callback.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your C application to a Redis database.
+linkTitle: hiredis (C)
+title: hiredis guide (C)
+weight: 9
+---
+
+[`hiredis`](https://github.com/redis/hiredis) is the
+[C language](https://en.wikipedia.org/wiki/C_(programming_language))
+client for Redis.
+The sections below explain how to install `hiredis` and connect your application
+to a Redis database.
+
+`hiredis` requires a running Redis or [Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) server. See [Getting started]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis installation instructions.
+
+## Build and install
+
+Clone or download the `hiredis` source from the [Github repository](https://github.com/redis/hiredis).
+Then, in a terminal, go into the `hiredis` folder and run the `make` command to build
+the dynamically-loaded library for `hiredis` (this has the name `libhiredis.dylib` on
+MacOS and `libhiredis.so` on Linux). You can copy this library to your
+project folder or run `sudo make install` to install it to `/usr/local/lib`.
+
+## Connect and test
+
+The code in the example below connects to the server, stores and retrieves
+a string key using [`SET`]({{< relref "/commands/set" >}}) and
+[`GET`]({{< relref "/commands/get" >}}), and then finally closes the
+connection. An explanation of the code follows the example.
+
+```c
+#include <stdio.h>
+
+#include <hiredis/hiredis.h>
+
+int main() {
+    // The `redisContext` type represents the connection
+    // to the Redis server. Here, we connect to the
+    // default host and port.
+    redisContext *c = redisConnect("127.0.0.1", 6379);
+
+    // Check if the context is null or if a specific
+    // error occurred.
+    if (c == NULL || c->err) {
+        if (c != NULL) {
+            printf("Error: %s\n", c->errstr);
+            // handle error
+        } else {
+            printf("Can't allocate redis context\n");
+        }
+
+        exit(1);
+    }
+
+    // Set a string key.
+    redisReply *reply = redisCommand(c, "SET foo bar");
+    printf("Reply: %s\n", reply->str); // >>> Reply: OK
+    freeReplyObject(reply);
+
+    // Get the key we have just stored.
+    reply = redisCommand(c, "GET foo");
+    printf("Reply: %s\n", reply->str); // >>> Reply: bar
+    freeReplyObject(reply);
+
+    // Close the connection.
+    redisFree(c);
+}
+```
+
+For a real project, you would build your code with a makefile, but for
+this simple test, you can just place it in a file called `main.c` and
+build it with the following command. (If you didn't install `hiredis`
+using `make install`, then you should also use the `-I` option to
+specify the folder that contains the `hiredis` headers.)
+
+```bash
+cc main.c -L/usr/local/lib -lhiredis
+```
+
+The default executable filename is `a.out`. If you run this file from
+the terminal, you should see the following output:
+
+```
+% ./a.out                             
+Reply: OK
+Reply: bar
+```
+
+The code first uses `redisConnect()` to open the connection for
+all subsequent commands to use. See
+[Connect]({{< relref "/develop/clients/hiredis/connect" >}}) for
+more information about connecting to Redis.
+
+The `redisCommand()` function
+issues commands to the server, each of which returns a
+`redisReply` pointer. Here, the reply is a string, which you can
+access using the `str` field of the reply. The `redisCommand()`
+call allocates memory for the reply, so you should free this
+with `freeReplyObject()` when you have finished using it.
+See [Issue commands]({{< relref "/develop/clients/hiredis/issue-commands" >}})
+and [Handle replies]({{< relref "/develop/clients/hiredis/handle-replies" >}})
+for more information.
+
+Finally, you should close the connection to Redis with a
+call to `redisFree()`. This is not strictly necessary
+for this short test program, but real-world code will typically
+open and use many connections. You must free them after using them
+to prevent errors.
+
+## More information
+
+The [`hiredis`](https://github.com/redis/hiredis) Github repository contains
+examples and details that may be useful if you are using `hiredis` to
+implement a higher-level client for another programming language. There are
+also examples showing how to use `hiredis` adapter headers to integrate with
+various event handling frameworks.
+
+See the other pages in this section for more information and examples.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 30
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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.
+
+The example below uses the [HuggingFace](https://huggingface.co/) model
+[`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
+to generate the 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](#differences-with-json-documents).
+
+## Initialize
+
+You can use the [TransformersPHP](https://transformers.codewithkyrian.com/)
+library to create the vector embeddings. Install the library with the following
+command:
+
+```bash
+composer require codewithkyrian/transformers
+```
+
+## Import dependencies
+
+Import the following classes and function in your source file:
+
+```php
+<?php
+
+require 'vendor/autoload.php';
+
+// TransformersPHP
+use function Codewithkyrian\Transformers\Pipelines\pipeline;
+
+// Redis client and query engine classes.
+use Predis\Client;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SearchArguments;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+use Predis\Command\Argument\Search\SchemaFields\TagField;
+use Predis\Command\Argument\Search\SchemaFields\VectorField;
+```
+
+## Create a tokenizer instance
+
+The code below shows how to use the
+[`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
+tokenizer to generate the embeddings. The vectors that represent the
+embeddings have 384 dimensions, regardless of the length of the input
+text. Here, the `pipeline()` call creates the `$extractor` function that
+generates embeddings from text:
+
+```php
+$extractor = pipeline('embeddings', 'Xenova/all-MiniLM-L6-v2');
+```
+
+## Create the index
+
+Connect to Redis and delete any index previously created with the
+name `vector_idx`. (The
+[`ftdropindex()`]({{< relref "/commands/ft.dropindex" >}})
+call throws an exception if the index doesn't already exist, which is
+why you need the `try...catch` block.)
+
+```php
+ $client = new Predis\Client([
+    'host' => 'localhost',
+    'port' => 6379,
+]);
+
+try {
+    $client->ftdropindex("vector_idx");
+} catch (Exception $e){}
+```
+
+Next, create the index.
+The schema in the example below includes three fields: the text content to index, a
+[tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+field to represent the "genre" of the text, and the embedding vector generated from
+the original text content. The `embedding` field specifies
+[HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) 
+indexing, the
+[L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+vector distance metric, `Float32` values to represent the vector's components,
+and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
+
+The `CreateArguments` parameter to [`ftcreate()`]({{< relref "/commands/ft.create" >}})
+specifies hash objects for storage and a prefix `doc:` that identifies the hash objects
+to index.
+
+```php
+$schema = [
+    new TextField("content"),
+    new TagField("genre"),
+    new VectorField(
+        "embedding",
+        "HNSW",
+        [
+            "TYPE", "FLOAT32",
+            "DIM", 384,
+            "DISTANCE_METRIC", "L2"
+        ]
+    )   
+];
+
+$client->ftcreate("vector_idx", $schema,
+    (new CreateArguments())
+        ->on('HASH')
+        ->prefix(["doc:"])
+);
+```
+
+## Add data
+
+You can now supply the data objects, which will be indexed automatically
+when you add them with [`hmset()`]({{< relref "/commands/hset" >}}), as long as
+you use the `doc:` prefix specified in the index definition.
+
+Use the `$extractor()` function as shown below to create the embedding that
+represents the `content` field. Note that `$extractor()` can generate multiple
+embeddings from multiple strings parameters at once, so it returns an array of
+embedding vectors. Here, there is only one embedding in the returned array.
+The `normalize:` and `pooling:` named parameters relate to details
+of the embedding model (see the
+[`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
+page for more information).
+
+To add an embedding as a field of a hash object, you must encode the
+vector array as a binary string. The built-in
+[`pack()`](https://www.php.net/manual/en/function.pack.php) function is a convenient
+way to do this in PHP, using the `g*` format specifier to denote a packed
+array of `float` values. Note that if you are using
+[JSON]({{< relref "/develop/data-types/json" >}})
+objects to store your documents instead of hashes, then you should store
+the `float` array directly without first converting it to a binary
+string (see [Differences with JSON documents](#differences-with-json-documents)
+below).
+
+```php
+$content = "That is a very happy person";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->hmset("doc:0",[
+    "content" => $content,
+    "genre" => "persons",
+    "embedding" => pack('g*', ...$emb[0])
+]);
+
+$content = "That is a happy dog";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->hmset("doc:1",[
+    "content" => $content,
+    "genre" => "pets",
+    "embedding" => pack('g*', ...$emb[0])
+]);
+
+$content = "Today is a sunny day";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->hmset("doc:2",[
+    "content" => $content,
+    "genre" => "weather",
+    "embedding" => pack('g*', ...$emb[0])
+]);
+```
+
+## Run a query
+
+After you have created the index and added the data, you are ready to run a query.
+To do this, you must create another embedding vector from your chosen query
+text. Redis calculates the vector distance between the query vector and each
+embedding vector in the index as it runs the query. You can request the results to be
+sorted to rank them in order of ascending distance.
+
+The code below creates the query embedding using the `$extractor()` function, as with
+the indexing, and passes it as a parameter when the query executes (see
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about using query parameters with embeddings).
+The query is a
+[K nearest neighbors (KNN)]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#knn-vector-search" >}})
+search that sorts the results in order of vector distance from the query vector.
+
+The results are returned as an array with the number of results in the
+first element. The remaining elements are alternating pairs with the
+key of the returned document (for example, `doc:0`) first, followed by an array containing
+the fields you requested (again as alternating key-value pairs).
+
+```php
+$queryText = "That is a happy person";
+$queryEmb = $extractor($queryText, normalize: true, pooling: 'mean');
+
+$result = $client->ftsearch(
+    "vector_idx",
+    '*=>[KNN 3 @embedding $vec AS vector_distance]',
+    new SearchArguments()
+        ->addReturn(1, "vector_distance")
+        ->dialect("2")
+        ->params([
+            "vec", pack('g*', ...$queryEmb[0])
+        ])
+        ->sortBy("vector_distance")
+);
+
+$numResults = $result[0];
+echo "Number of results: $numResults" . PHP_EOL;
+// >>> Number of results: 3
+
+for ($i = 1; $i < ($numResults * 2 + 1); $i += 2) {
+    $key = $result[$i];
+    echo "Key: $key" . PHP_EOL;
+    $fields = $result[$i + 1];
+    echo "Field: {$fields[0]}, Value: {$fields[1]}" . PHP_EOL; 
+}        
+// >>> Key: doc:0
+// >>> Field: vector_distance, Value: 3.76152896881
+// >>> Key: doc:1
+// >>> Field: vector_distance, Value: 18.6544265747
+// >>> Key: doc:2
+// >>> Field: vector_distance, Value: 44.6189727783
+```
+
+Assuming you have added the code from the steps above to your source file,
+it is now ready to run, but note that it may take a while to complete when
+you run it for the first time (which happens because the tokenizer must download the
+`all-MiniLM-L6-v2` model data before it can
+generate the embeddings). When you run the code, it outputs the following result text:
+
+```
+Number of results: 3
+Key: doc:0
+Field: vector_distance, Value: 3.76152896881
+Key: doc:1
+Field: vector_distance, Value: 18.6544265747
+Key: doc:2
+Field: vector_distance, Value: 44.6189727783
+```
+
+Note that the results are ordered according to the value of the `distance`
+field, with the lowest distance indicating the greatest similarity to the query.
+As you would expect, the text *"That is a very happy person"* (from the `doc:0`
+document)
+is the result judged to be most similar in meaning to the query text
+*"That is a happy person"*.
+
+## Differences with JSON documents
+
+Indexing JSON documents is similar to hash indexing, but there are some
+important differences. JSON allows much richer data modeling with nested fields, so
+you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+to identify each field you want to index. However, you can declare a short alias for each
+of these paths to avoid typing it in full for
+every query. Also, you must specify `JSON` with the `on()` option when you create the index.
+
+The code below shows these differences, but the index is otherwise very similar to
+the one created previously for hashes:
+
+```php
+$jsonSchema = [
+    new TextField("$.content", "content"),
+    new TagField("$.genre", "genre"),
+    new VectorField(
+        "$.embedding",
+        "HNSW",
+        [
+            "TYPE", "FLOAT32",
+            "DIM", 384,
+            "DISTANCE_METRIC", "L2"
+        ],
+        "embedding",
+    )   
+];
+
+$client->ftcreate("vector_json_idx", $jsonSchema,
+    (new CreateArguments())
+        ->on('JSON')
+        ->prefix(["jdoc:"])
+);
+```
+
+Use [`jsonset()`]({{< relref "/commands/json.set" >}}) to add the data
+instead of [`hmset()`]({{< relref "/commands/hset" >}}). The arrays
+that specify the fields have roughly the same structure as the ones used for
+`hmset()` but you should use the standard library function
+[`json_encode()`](https://www.php.net/manual/en/function.json-encode.php)
+to generate a JSON string representation of the array.
+
+An important difference with JSON indexing is that the vectors are
+specified using arrays instead of binary strings. Simply add the
+embedding as an array field without using the `pack()` function as you
+would with a hash.
+
+```php
+$content = "That is a very happy person";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->jsonset("jdoc:0", "$",
+    json_encode(
+        [
+            "content" => $content,
+            "genre" => "persons",
+            "embedding" => $emb[0]
+        ],
+        JSON_THROW_ON_ERROR
+    )
+);
+
+$content = "That is a happy dog";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->jsonset("jdoc:1","$", 
+    json_encode(
+        [
+            "content" => $content,
+            "genre" => "pets",
+            "embedding" => $emb[0]
+        ],
+        JSON_THROW_ON_ERROR
+    )
+);
+
+$content = "Today is a sunny day";
+$emb = $extractor($content, normalize: true, pooling: 'mean');
+
+$client->jsonset("jdoc:2", "$",
+    json_encode(
+        [
+            "content" => $content,
+            "genre" => "weather",
+            "embedding" => $emb[0]
+        ],
+        JSON_THROW_ON_ERROR
+    )
+);
+```
+
+The query is almost identical to the one for the hash documents. This
+demonstrates how the right choice of aliases for the JSON paths can
+save you having to write complex queries. An important thing to notice
+is that the vector parameter for the query is still specified as a
+binary string (using the `pack()` function), even though the data for
+the `embedding` field of the JSON was specified as an array.
+
+```php
+$queryText = "That is a happy person";
+$queryEmb = $extractor($queryText, normalize: true, pooling: 'mean');
+
+$result = $client->ftsearch(
+    "vector_json_idx",
+    '*=>[KNN 3 @embedding $vec AS vector_distance]',
+    new SearchArguments()
+        ->addReturn(1, "vector_distance")
+        ->dialect("2")
+        ->params([
+            "vec", pack('g*', ...$queryEmb[0])
+        ])
+        ->sortBy("vector_distance")
+);
+```
+
+Apart from the `jdoc:` prefixes for the keys, the result from the JSON
+query is the same as for hash:
+
+```
+Number of results: 3
+Key: jdoc:0
+Field: vector_distance, Value: 3.76152896881
+Key: jdoc:1
+Field: vector_distance, Value: 18.6544265747
+Key: jdoc:2
+Field: vector_distance, Value: 44.6189727783
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about the indexing options, distance metrics, and query format
+for vectors.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your PHP application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 10
+---
+
+## Basic connection
+
+Connect to a locally-running server on the standard port (6379)
+with the following code:
+
+```php
+<?php
+
+require 'vendor/autoload.php';
+
+use Predis\Client as PredisClient;
+
+$r = new PredisClient([
+                'scheme'   => 'tcp',
+                'host'     => '127.0.0.1',
+                'port'     => 6379,
+                'password' => '',
+                'database' => 0,
+            ]);
+```
+
+Store and retrieve a simple string to test the connection:
+
+```php
+echo $r->set('foo', 'bar'), PHP_EOL;
+// >>> OK
+
+echo $r->get('foo'), PHP_EOL;
+// >>> bar
+```
+
+Store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}})
+object:
+
+```php
+$r->hset('user-session:123', 'name', 'John');
+$r->hset('user-session:123', 'surname', 'Smith');
+$r->hset('user-session:123', 'company', 'Redis');
+$r->hset('user-session:123', 'age', 29);
+
+echo var_export($r->hgetall('user-session:123')), PHP_EOL;
+/* >>>
+array (
+  'name' => 'John',
+  'surname' => 'Smith',
+  'company' => 'Redis',
+  'age' => '29',
+)
+*/
+```
+
+## Connect to a Redis cluster
+
+To connect to a Redis cluster, specify one or more of the nodes in
+the `clusterNodes` parameter and set `'cluster'=>'redis'` in
+`options`:
+
+```php
+$clusterNodes = [
+    'tcp://127.0.0.1:30001', // Node 1
+    'tcp://127.0.0.1:30002', // Node 2
+    'tcp://127.0.0.1:30003', // Node 3
+];
+$options    = ['cluster' => 'redis'];
+
+// Create a Predis client for the cluster
+$rc = new PredisClient($clusterNodes, $options);
+
+echo $rc->cluster('nodes'), PHP_EOL;
+/* >>>
+d8773e888e92d015b7c52fc66798fd6815afefec 127.0.0.1:30004@40004 slave cde97d1f7dce13e9253ace5cafd3fb0aa67cda63 0 1730713764217 1 connected
+58fe1346de4c425d60db24e9b153926fbde0d174 127.0.0.1:30002@40002 master - 0 1730713763361 2 connected 5461-10922
+015ecc8148a05377dda22f19921d16efcdd6d678 127.0.0.1:30006@40006 slave c019b75d8b52e83e7e52724eccc716ac553f71d6 0 1730713764218 3 connected
+aca365963a72642e6ae0c9503aabf3be5c260806 127.0.0.1:30005@40005 slave 58fe1346de4c425d60db24e9b153926fbde0d174 0 1730713763363 2 connected
+c019b75d8b52e83e7e52724eccc716ac553f71d6 127.0.0.1:30003@40003 myself,master - 0 1730713764000 3 connected 10923-16383
+cde97d1f7dce13e9253ace5cafd3fb0aa67cda63 127.0.0.1:30001@40001 master - 0 1730713764113 1 connected 0-5460
+*/
+
+echo $rc->set('foo', 'bar'), PHP_EOL;
+// >>> OK
+echo $rc->get('foo'), PHP_EOL;
+// >>> bar
+```
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the
+[Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}})
+guidelines.
+
+Use the following commands to generate the client certificate and private key:
+
+```bash
+openssl genrsa -out redis_user_private.key 2048
+openssl req -new -key redis_user_private.key -out redis_user.csr
+openssl x509 -req -days 365 -in redis_user.csr -signkey redis_user_private.key -out redis_user.crt
+```
+
+If you have the [Redis source folder](https://github.com/redis/redis) available,
+you can also generate the certificate and private key with these commands:
+
+```bash
+./utils/gen-test-certs.sh
+./src/redis-server --tls-port 6380 --port 0 --tls-cert-file ./tests/tls/redis.crt --tls-key-file ./tests/tls/redis.key --tls-ca-cert-file ./tests/tls/ca.crt
+```
+
+Pass this information during connection using the `ssl` section of `options`:
+
+```php
+$options = [
+    'scheme' => 'tls', // Use 'tls' for SSL connections
+    'host' => '127.0.0.1', // Redis server hostname
+    'port' => 6379, // Redis server port
+    'username' => 'default', // Redis username
+    'password' => '', // Redis password
+    'options' => [
+        'ssl' => [
+            'verify_peer' => true, // Verify the server's SSL certificate
+            'cafile' => './redis_ca.pem', // Path to CA certificate
+            'local_cert' => './redis_user.crt', // Path to client certificate
+            'local_pk' => './redis_user_private.key', // Path to client private key
+        ],
+    ],
+];
+
+$tlsConnection = new PredisClient($options);
+
+echo $tlsConnection->set('foo', 'bar'), PHP_EOL;
+// >>> OK
+echo $tlsConnection->get('foo'), PHP_EOL;
+// >>> bar
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis query engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 20
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+or another Redis server available. Also install the
+[`Predis`]({{< relref "/develop/clients/php" >}}) client library if you
+haven't already done so.
+
+Add the following dependencies:
+
+```php
+<?php
+
+require 'vendor/autoload.php';
+
+use Predis\Client as PredisClient;
+
+use Predis\Command\Argument\Search\AggregateArguments;
+use Predis\Command\Argument\Search\CreateArguments;
+use Predis\Command\Argument\Search\SearchArguments;
+use Predis\Command\Argument\Search\SchemaFields\NumericField;
+use Predis\Command\Argument\Search\SchemaFields\TextField;
+use Predis\Command\Argument\Search\SchemaFields\TagField;
+use Predis\Command\Argument\Search\SchemaFields\VectorField;
+```
+
+## Create data
+
+Create some test data to add to your database:
+
+```php
+$user1 = json_encode([
+    'name' => 'Paul John',
+    'email' => 'paul.john@example.com',
+    'age' => 42,
+    'city' => 'London',
+], JSON_THROW_ON_ERROR);
+
+$user2 = json_encode([
+    'name' => 'Eden Zamir',
+    'email' => 'eden.zamir@example.com',
+    'age' => 29,
+    'city' => 'Tel Aviv',
+], JSON_THROW_ON_ERROR);
+
+$user3 = json_encode([
+    'name' => 'Paul Zamir',
+    'email' => 'paul.zamir@example.com',
+    'age' => 35,
+    'city' => 'Tel Aviv',
+], JSON_THROW_ON_ERROR);
+```
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/php/connect" >}})
+to learn more about the available connection options.
+
+```php
+$r = new PredisClient([
+                'scheme'   => 'tcp',
+                'host'     => '127.0.0.1',
+                'port'     => 6379,
+                'password' => '',
+                'database' => 0,
+            ]);
+```
+
+Create an
+[index]({{< relref "/develop/interact/search-and-query/indexing" >}}).
+In this example, only JSON documents with the key prefix `user:` are indexed.
+For more information, see
+[Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}).
+
+```php
+$schema = [
+    new TextField('$.name', 'name'),
+    new TagField('$.city', 'city'),
+    new NumericField('$.age', "age"),
+];
+
+try {
+$r->ftCreate("idx:users", $schema,
+    (new CreateArguments())
+        ->on('JSON')
+        ->prefix(["user:"]));
+}
+catch (Exception $e) {
+    echo $e->getMessage(), PHP_EOL;
+}
+```
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them:
+
+```php
+$r->jsonset('user:1', '$', $user1);
+$r->jsonset('user:2', '$', $user2);
+$r->jsonset('user:3', '$', $user3);
+```
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+```php
+$res = $r->ftSearch("idx:users", "Paul @age:[30 40]");
+echo json_encode($res), PHP_EOL;
+// >>> [1,"user:3",["$","{\"name\":\"Paul Zamir\",\"email\":\"paul.zamir@example.com\",\"age\":35,\"city\":\"London\"}"]]
+```
+
+Specify query options to return only the `city` field:
+
+```php
+$arguments = new SearchArguments();
+$arguments->addReturn(3, '$.city', true, 'thecity');
+$arguments->dialect(2);
+$arguments->limit(0, 5);
+
+$res = $r->ftSearch("idx:users", "Paul", $arguments);
+
+echo json_encode($res), PHP_EOL;
+// >>> [2,"user:1",["thecity","London"],"user:3",["thecity","Tel Aviv"]]
+```
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+```php
+$ftAggregateArguments = (new AggregateArguments())
+->groupBy('@city')
+->reduce('COUNT', true, 'count');
+
+$res = $r->ftAggregate('idx:users', '*', $ftAggregateArguments);
+echo json_encode($res), PHP_EOL;
+// >>> [2,["city","London","count","1"],["city","Tel Aviv","count","2"]]
+```
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must use `HASH` for the `On()` option
+when you create the index. The code below shows these changes with
+a new index called `hash-idx:users`, which is otherwise the same as
+the `idx:users` index used for JSON documents in the previous examples.
+
+```php
+$hashSchema = [
+    new TextField('name'),
+    new TagField('city'),
+    new NumericField('age'),
+];
+
+try {
+$r->ftCreate("hash-idx:users", $hashSchema,
+    (new CreateArguments())
+        ->on('HASH')
+        ->prefix(["huser:"]));
+}
+catch (Exception $e) {
+    echo $e->getMessage(), PHP_EOL;
+}
+```
+
+You use [`hmset()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`jsonset()`]({{< relref "/commands/json.set" >}}).
+Supply the fields as an array directly, without using
+[`json_encode()`](https://www.php.net/manual/en/function.json-encode.php).
+
+```php
+$r->hmset('huser:1', [
+    'name' => 'Paul John',
+    'email' => 'paul.john@example.com',
+    'age' => 42,
+    'city' => 'London',
+]);
+
+$r->hmset('huser:2', [
+    'name' => 'Eden Zamir',
+    'email' => 'eden.zamir@example.com',
+    'age' => 29,
+    'city' => 'Tel Aviv',
+]);
+
+$r->hmset('huser:3', [
+    'name' => 'Paul Zamir',
+    'email' => 'paul.zamir@example.com',
+    'age' => 35,
+    'city' => 'Tel Aviv',
+]);
+```
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The format of the result is
+almost the same except that the fields are returned directly in the
+result array rather than in a JSON string with `$` as its key:
+
+```php
+$res = $r->ftSearch("hash-idx:users", "Paul @age:[30 40]");
+echo json_encode($res), PHP_EOL;
+// >>> [1,"huser:3",["age","35","city","Tel Aviv","email","paul.zamir@example.com","name","Paul Zamir"]]
+```
+
+## More information
+
+See the [Redis query engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+aliases: /develop/connect/clients/php
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your PHP application to a Redis database
+linkTitle: Predis (PHP)
+title: Predis guide (PHP)
+weight: 8
+---
+
+[`Predis`](https://github.com/predis/predis) is the recommended [PHP](https://php.net/)
+client for Redis. 
+The sections below explain how to install `Predis` and connect your application to a Redis database.
+
+{{< note >}}Although we provide basic documentation for `Predis`, it is a third-party
+client library and is not developed or supported directly by Redis.
+{{< /note >}}
+
+`Predis` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+## Install
+
+Use [Composer](https://getcomposer.org/) to install the `Predis` library
+with the following command line:
+
+```bash
+composer require predis/predis
+```
+
+## Connect and test
+
+Connect to a locally-running server on the standard port (6379)
+with the following code:
+
+```php
+<?php
+
+require 'vendor/autoload.php';
+
+use Predis\Client as PredisClient;
+
+$r = new PredisClient([
+                'scheme'   => 'tcp',
+                'host'     => '127.0.0.1',
+                'port'     => 6379,
+                'password' => '',
+                'database' => 0,
+            ]);
+```
+
+Store and retrieve a simple string to test the connection:
+
+```php
+echo $r->set('foo', 'bar'), PHP_EOL;
+// >>> OK
+
+echo $r->get('foo'), PHP_EOL;
+// >>> bar
+```
+
+Store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}})
+object:
+
+```php
+$r->hset('user-session:123', 'name', 'John');
+$r->hset('user-session:123', 'surname', 'Smith');
+$r->hset('user-session:123', 'company', 'Redis');
+$r->hset('user-session:123', 'age', 29);
+
+echo var_export($r->hgetall('user-session:123')), PHP_EOL;
+/* >>>
+array (
+  'name' => 'John',
+  'surname' => 'Smith',
+  'company' => 'Redis',
+  'age' => '29',
+)
+*/
+```
+
+## More information
+
+The [Predis wiki on Github](https://github.com/predis/predis/wiki) has
+information about the different connection options you can use.
+
+See also the pages in this section for more information and examples:
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 50
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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.
+
+{{< clients-example pipe_trans_tutorial basic_pipe "C#" >}}
+{{< /clients-example >}}
+
+## Execute a transaction
+
+A transaction works in a similar way to a pipeline. Create an
+instance of the `Transaction` class, call async command methods
+on that object, and then call the transaction object's 
+`Execute()` method to execute it.
+
+{{< clients-example pipe_trans_tutorial basic_trans "C#" >}}
+{{< /clients-example >}}
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The approach to optimistic locking that other clients use
+(adding the [`WATCH`]({{< relref "/commands/watch" >}}) command
+explicitly to a transaction) doesn't work well with the
+[multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+system that `NRedisStack` uses.
+Instead, `NRedisStack` relies on conditional execution of commands
+to get a similar effect.
+
+Use the `AddCondition()` method to abort a transaction if a particular
+condition doesn't hold throughout its execution. If the transaction
+does abort then the `Execute()` method returns a `false` value,
+but otherwise returns `true`.
+
+For example, the `KeyNotExists` condition aborts the transaction
+if a specified key exists or is added by another client while the
+transaction executes:
+
+{{< clients-example pipe_trans_tutorial trans_watch "C#" >}}
+{{< /clients-example >}}
+
+You can also use a `When` condition on certain individual commands to
+specify that they only execute when a certain condition holds
+(for example, the command does not change an existing key).
+See
+[Conditional execution]({{< relref "/develop/clients/dotnet/condexec" >}})
+for a full description of transaction and command conditions.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 40
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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.
+
+In the example below, we use [Microsoft.ML](https://dotnet.microsoft.com/en-us/apps/ai/ml-dotnet)
+to generate the vector embeddings to store and index with Redis Query Engine.
+We also show how to adapt the code to use
+[Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/embeddings?tabs=csharp)
+for the embeddings. The code is first demonstrated for hash documents with a
+separate section to explain the
+[differences with JSON documents](#differences-with-json-documents).
+
+## Initialize
+
+The example is probably easiest to follow if you start with a new
+console app, which you can create using the following command:
+
+```bash
+dotnet new console -n VecQueryExample
+```
+
+In the app's project folder, add
+[`NRedisStack`]({{< relref "/develop/clients/dotnet" >}}`):
+
+```bash
+dotnet add package NRedisStack
+```
+
+Then, add the `Microsoft.ML` package.
+
+```bash
+dotnet add package Microsoft.ML
+```
+
+If you want to try the optional
+[Azure embedding](#generate-an-embedding-from-azure-openai)
+described below, you should also add `Azure.AI.OpenAI`:
+
+```
+dotnet add package Azure.AI.OpenAI --prerelease
+```
+
+## Import dependencies
+
+Add the following imports to your source file:
+
+```csharp
+// Redis connection and Query Engine.
+using NRedisStack.RedisStackCommands;
+using StackExchange.Redis;
+using NRedisStack.Search;
+using static NRedisStack.Search.Schema;
+using NRedisStack.Search.Literals.Enums;
+
+// Text embeddings.
+using Microsoft.ML;
+using Microsoft.ML.Transforms.Text;
+```
+
+If you are using the Azure embeddings, also add:
+
+```csharp
+// Azure embeddings.
+using Azure;
+using Azure.AI.OpenAI;
+```
+
+## Define a function to obtain the embedding model
+
+{{< note >}}Ignore this step if you are using an Azure OpenAI
+embedding model.
+{{< /note >}}
+
+A few steps are involved in initializing the embedding model
+(known as a `PredictionEngine`, in Microsoft terminology), so
+we declare a function to contain those steps together.
+(See the Microsoft.ML docs for more information about the
+[`ApplyWordEmbedding`](https://learn.microsoft.com/en-us/dotnet/api/microsoft.ml.textcatalog.applywordembedding?view=ml-dotnet)
+method, including example code.)
+
+Note that we use two classes, `TextData` and `TransformedTextData`, to
+specify the `PredictionEngine` model. C# syntax requires us to place these
+classes after the main code in a console app source file. The section
+[Declare `TextData` and `TransformedTextData`](#declare-textdata-and-transformedtextdata)
+below shows how to declare them.
+
+```csharp
+static PredictionEngine<TextData, TransformedTextData> GetPredictionEngine(){
+    // Create a new ML context, for ML.NET operations. It can be used for
+    // exception tracking and logging, as well as the source of randomness.
+    var mlContext = new MLContext();
+
+    // Create an empty list as the dataset
+    var emptySamples = new List<TextData>();
+
+    // Convert sample list to an empty IDataView.
+    var emptyDataView = mlContext.Data.LoadFromEnumerable(emptySamples);
+
+    // A pipeline for converting text into a 150-dimension embedding vector
+    var textPipeline = mlContext.Transforms.Text.NormalizeText("Text")
+        .Append(mlContext.Transforms.Text.TokenizeIntoWords("Tokens",
+            "Text"))
+        .Append(mlContext.Transforms.Text.ApplyWordEmbedding("Features",
+            "Tokens", WordEmbeddingEstimator.PretrainedModelKind
+            .SentimentSpecificWordEmbedding));
+
+    // Fit to data.
+    var textTransformer = textPipeline.Fit(emptyDataView);
+
+    // Create the prediction engine to get the embedding vector from the input text/string.
+    var predictionEngine = mlContext.Model.CreatePredictionEngine<TextData,
+        TransformedTextData>(textTransformer);
+
+    return predictionEngine;
+}
+```
+
+## Define a function to generate an embedding
+
+{{< note >}}Ignore this step if you are using an Azure OpenAI
+embedding model.
+{{< /note >}}
+
+Our embedding model represents the vectors as an array of `float` values,
+but when you store vectors in a Redis hash object, you must encode the vector
+array as a `byte` string. To simplify this, we declare a
+`GetEmbedding()` function that applies the `PredictionEngine` model described
+[above](#define-a-function-to-obtain-the-embedding-model), and
+then encodes the returned `float` array as a `byte` string. If you are
+storing your documents as JSON objects instead of hashes, then you should
+use the `float` array for the embedding directly, without first converting
+it to a `byte` string (see [Differences with JSON documents](#differences-with-json-documents)
+below).
+
+
+```csharp
+static byte[] GetEmbedding(
+    PredictionEngine<TextData, TransformedTextData> model, string sentence
+)
+{
+    // Call the prediction API to convert the text into embedding vector.
+    var data = new TextData()
+    {
+        Text = sentence
+    };
+
+    var prediction = model.Predict(data);
+
+    // Convert prediction.Features to a binary blob
+    float[] floatArray = Array.ConvertAll(prediction.Features, x => (float)x);
+    byte[] byteArray = new byte[floatArray.Length * sizeof(float)];
+    Buffer.BlockCopy(floatArray, 0, byteArray, 0, byteArray.Length);
+
+    return byteArray;
+}
+```
+
+## Generate an embedding from Azure OpenAI
+
+{{< note >}}Ignore this step if you are using a Microsoft.ML
+embedding model.
+{{< /note >}}
+
+Azure OpenAI can be a convenient way to access an embedding model, because
+you don't need to manage and scale the server infrastructure yourself.
+
+You can create an Azure OpenAI service and deployment to serve embeddings of
+whatever type you need. Select your region, note the service endpoint and key,
+and add them where you see placeholders in the function below.
+See
+[Learn how to generate embeddings with Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/embeddings?tabs=csharp)
+for more information.
+
+```csharp
+private static byte[] GetEmbeddingFromAzure(string sentence){
+	Uri oaiEndpoint = new ("your-azure-openai-endpoint”);
+	string oaiKey = "your-openai-key";
+
+	AzureKeyCredential credentials = new (oaiKey);
+	OpenAIClient openAIClient = new (oaiEndpoint, credentials);
+
+	EmbeddingsOptions embeddingOptions = new() {
+    	     DeploymentName = "your-deployment-name",
+    	     Input = { sentence },
+	};
+
+	// Generate the vector embedding
+	var returnValue = openAIClient.GetEmbeddings(embeddingOptions);
+
+	// Convert the array of floats to binary blob
+	float[] floatArray = Array.ConvertAll(returnValue.Value.Data[0].Embedding.ToArray(), x => (float)x);
+	byte[] byteArray = new byte[floatArray.Length * sizeof(float)];
+	Buffer.BlockCopy(floatArray, 0, byteArray, 0, byteArray.Length);
+	return byteArray;
+}
+```
+
+## Create the index
+
+Connect to Redis and delete any index previously created with the
+name `vector_idx`. (The `DropIndex()` call throws an exception if
+the index doesn't already exist, which is why you need the
+`try...catch` block.)
+
+```csharp
+var muxer = ConnectionMultiplexer.Connect("localhost:6379");
+var db = muxer.GetDatabase();
+
+try { db.FT().DropIndex("vector_idx");} catch {}
+```
+
+Next, create the index.
+The schema in the example below includes three fields: the text content to index, a
+[tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+field to represent the "genre" of the text, and the embedding vector generated from
+the original text content. The `embedding` field specifies
+[HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) 
+indexing, the
+[L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+vector distance metric, `Float32` values to represent the vector's components,
+and 150 dimensions, as required by our embedding model.
+
+The `FTCreateParams` object specifies hash objects for storage and a
+prefix `doc:` that identifies the hash objects we want to index.
+
+```csharp
+var schema = new Schema()
+    .AddTextField(new FieldName("content", "content"))
+    .AddTagField(new FieldName("genre", "genre"))
+    .AddVectorField("embedding", VectorField.VectorAlgo.HNSW,
+        new Dictionary<string, object>()
+        {
+            ["TYPE"] = "FLOAT32",
+            ["DIM"] = "150",
+            ["DISTANCE_METRIC"] = "L2"
+        }
+    );
+
+db.FT().Create(
+    "vector_idx",
+    new FTCreateParams()
+        .On(IndexDataType.HASH)
+        .Prefix("doc:"),
+    schema
+);
+```
+
+## Add data
+
+You can now supply the data objects, which will be indexed automatically
+when you add them with [`HashSet()`]({{< relref "/commands/hset" >}}), as long as
+you use the `doc:` prefix specified in the index definition.
+
+Firstly, create an instance of the `PredictionEngine` model using our
+`GetPredictionEngine()` function.
+You can then pass this to the `GetEmbedding()` function
+to create the embedding that represents the `content` field, as shown below .
+
+(If you are using an Azure OpenAI model for the embeddings, then
+use `GetEmbeddingFromAzure()` instead of `GetEmbedding()`, and note that
+the `PredictionModel` is managed by the server, so you don't need to create
+an instance yourself.)
+
+```csharp
+var predEngine = GetPredictionEngine();
+
+var sentence1 = "That is a very happy person";
+
+HashEntry[] doc1 = {
+    new("content", sentence1),
+    new("genre", "persons"),
+    new("embedding", GetEmbedding(predEngine, sentence1))
+};
+
+db.HashSet("doc:1", doc1);
+
+var sentence2 = "That is a happy dog";
+
+HashEntry[] doc2 = {
+    new("content", sentence2),
+    new("genre", "pets"),
+    new("embedding", GetEmbedding(predEngine, sentence2))
+};
+
+db.HashSet("doc:2", doc2);
+
+var sentence3 = "Today is a sunny day";
+
+HashEntry[] doc3 = {
+    new("content", sentence3),
+    new("genre", "weather"),
+    new("embedding", GetEmbedding(predEngine, sentence3))
+};
+
+db.HashSet("doc:3", doc3);
+```
+
+## Run a query
+
+After you have created the index and added the data, you are ready to run a query.
+To do this, you must create another embedding vector from your chosen query
+text. Redis calculates the vector distance between the query vector and each
+embedding vector in the index as it runs the query. We can request the results to be
+sorted to rank them in order of ascending distance.
+
+The code below creates the query embedding using the `GetEmbedding()` method, as with
+the indexing, and passes it as a parameter when the query executes (see
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about using query parameters with embeddings).
+The query is a
+[K nearest neighbors (KNN)]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#knn-vector-search" >}})
+search that sorts the results in order of vector distance from the query vector.
+
+(As before, replace `GetEmbedding()` with `GetEmbeddingFromAzure()` if you are using
+Azure OpenAI.)
+
+```csharp
+var res = db.FT().Search("vector_idx",
+    new Query("*=>[KNN 3 @embedding $query_vec AS score]")
+    .AddParam("query_vec", GetEmbedding(predEngine, "That is a happy person"))
+    .ReturnFields(
+        new FieldName("content", "content"),
+        new FieldName("score", "score")
+    )
+    .SetSortBy("score")
+    .Dialect(2));
+
+foreach (var doc in res.Documents) {
+    var props = doc.GetProperties();
+    var propText = string.Join(
+        ", ",
+        props.Select(p => $"{p.Key}: '{p.Value}'")
+    );
+
+    Console.WriteLine(
+        $"ID: {doc.Id}, Properties: [\n  {propText}\n]"
+    );
+}
+```
+
+## Declare `TextData` and `TransformedTextData`
+
+{{< note >}}Ignore this step if you are using an Azure OpenAI
+embedding model.
+{{< /note >}}
+
+As we noted in the section above about the
+[embedding model](#define-a-function-to-obtain-the-embedding-model),
+we must declare two very simple classes at the end of the source
+file. These are required because the API that generates the model
+expects classes with named fields for the input `string` and output 
+`float` array.
+
+```csharp
+class TextData
+{
+    public string Text { get; set; }
+}
+
+class TransformedTextData : TextData
+{
+    public float[] Features { get; set; }
+}
+```
+
+## Run the code
+
+Assuming you have added the code from the steps above to your source file,
+it is now ready to run, but note that it may take a while to complete when
+you run it for the first time (which happens because the tokenizer must download the
+embedding model data before it can generate the embeddings). When you run the code,
+it outputs the following result text:
+
+```
+ID: doc:1, Properties: [
+  score: '4.30777168274', content: 'That is a very happy person'
+]
+ID: doc:2, Properties: [
+  score: '25.9752807617', content: 'That is a happy dog'
+]
+ID: doc:3, Properties: [
+  score: '68.8638000488', content: 'Today is a sunny day'
+]
+```
+
+The results are ordered according to the value of the `score`
+field, which represents the vector distance here. The lowest distance indicates
+the greatest similarity to the query.
+As you would expect, the result for `doc:1` with the content text
+*"That is a very happy person"*
+is the result that is most similar in meaning to the query text
+*"That is a happy person"*.
+
+## Differences with JSON documents
+
+Indexing JSON documents is similar to hash indexing, but there are some
+important differences. JSON allows much richer data modeling with nested fields, so
+you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+to identify each field you want to index. However, you can declare a short alias for each
+of these paths to avoid typing it in full for
+every query. Also, you must specify `IndexType.JSON` with the `On()` option when you
+create the index.
+
+The code below shows these differences, but the index is otherwise very similar to
+the one created previously for hashes:
+
+```cs
+var jsonSchema = new Schema()
+    .AddTextField(new FieldName("$.content", "content"))
+    .AddTagField(new FieldName("$.genre", "genre"))
+    .AddVectorField(
+        new FieldName("$.embedding", "embedding"),
+        VectorField.VectorAlgo.HNSW,
+        new Dictionary<string, object>()
+        {
+            ["TYPE"] = "FLOAT32",
+            ["DIM"] = "150",
+            ["DISTANCE_METRIC"] = "L2"
+        }
+    );
+
+
+db.FT().Create(
+    "vector_json_idx",
+    new FTCreateParams()
+        .On(IndexDataType.JSON)
+        .Prefix("jdoc:"),
+    jsonSchema
+);
+```
+
+An important difference with JSON indexing is that the vectors are
+specified using arrays of `float` instead of binary strings. This requires a modification
+to the `GetEmbedding()` function declared in
+[Define a function to generate an embedding](#define-a-function-to-generate-an-embedding)
+above:
+
+```cs
+static float[] GetFloatEmbedding(
+    PredictionEngine<TextData, TransformedTextData> model, string sentence
+)
+{
+    // Call the prediction API to convert the text into embedding vector.
+    var data = new TextData()
+    {
+        Text = sentence
+    };
+
+    var prediction = model.Predict(data);
+
+    float[] floatArray = Array.ConvertAll(prediction.Features, x => (float)x);
+    return floatArray;
+}
+```
+
+You should make a similar modification to the `GetEmbeddingFromAzure()` function
+if you are using Azure OpenAI with JSON.
+
+Use [`JSON().set()`]({{< relref "/commands/json.set" >}}) to add the data
+instead of [`HashSet()`]({{< relref "/commands/hset" >}}):
+
+```cs
+var jSentence1 = "That is a very happy person";
+
+var jdoc1 = new {
+    content = jSentence1,
+    genre = "persons",
+    embedding = GetFloatEmbedding(predEngine, jSentence1),
+};
+
+db.JSON().Set("jdoc:1", "$", jdoc1);
+
+var jSentence2 = "That is a happy dog";
+
+var jdoc2 = new {
+    content = jSentence2,
+    genre = "pets",
+    embedding = GetFloatEmbedding(predEngine, jSentence2),
+};
+
+db.JSON().Set("jdoc:2", "$", jdoc2);
+
+var jSentence3 = "Today is a sunny day";
+
+var jdoc3 = new {
+    content = jSentence3,
+    genre = "weather",
+    embedding = GetFloatEmbedding(predEngine, jSentence3),
+};
+
+db.JSON().Set("jdoc:3", "$", jdoc3);
+```
+
+The query is almost identical to the one for the hash documents. This
+demonstrates how the right choice of aliases for the JSON paths can
+save you having to write complex queries. The only significant difference is
+that the `FieldName` objects created for the `ReturnFields()` option must
+include the JSON path for the field.
+
+An important thing to notice
+is that the vector parameter for the query is still specified as a
+binary string (using the `GetEmbedding()` method), even though the data for
+the `embedding` field of the JSON was specified as a `float` array.
+
+```cs
+var jRes = db.FT().Search("vector_json_idx",
+    new Query("*=>[KNN 3 @embedding $query_vec AS score]")
+    .AddParam("query_vec", GetEmbedding(predEngine, "That is a happy person"))
+    .ReturnFields(
+        new FieldName("$.content", "content"),
+        new FieldName("$.score", "score")
+    )
+    .SetSortBy("score")
+    .Dialect(2));
+
+foreach (var doc in jRes.Documents) {
+    var props = doc.GetProperties();
+    var propText = string.Join(
+        ", ",
+        props.Select(p => $"{p.Key}: '{p.Value}'")
+    );
+
+    Console.WriteLine(
+        $"ID: {doc.Id}, Properties: [\n  {propText}\n]"
+    );
+}
+```
+
+Apart from the `jdoc:` prefixes for the keys, the result from the JSON
+query is the same as for hash:
+
+```
+ID: jdoc:1, Properties: [
+  score: '4.30777168274', content: 'That is a very happy person'
+]
+ID: jdoc:2, Properties: [
+  score: '25.9752807617', content: 'That is a happy dog'
+]
+ID: jdoc:3, Properties: [
+  score: '68.8638000488', content: 'Today is a sunny day'
+]
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about the indexing options, distance metrics, and query format
+for vectors.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your .NET application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 20
+---
+
+## 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:
+
+```csharp
+using NRedisStack;
+using NRedisStack.RedisStackCommands;
+using StackExchange.Redis;
+
+ConfigurationOptions conf = new ConfigurationOptions {
+    EndPoints = { "localhost:6379" },
+    User = "yourUsername",
+    Password = "yourPassword"
+};
+
+ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(conf);
+IDatabase db = redis.GetDatabase();
+
+db.StringSet("foo", "bar");
+Console.WriteLine(db.StringGet("foo")); // prints bar
+```
+
+## Connect to a Redis cluster
+
+The basic connection will use the
+[Cluster API]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api" >}})
+if it is available without any special configuration. However, if you know
+the addresses and ports of several cluster nodes, you can specify them all
+during connection in the `Endpoints` parameter:
+
+```csharp
+ConfigurationOptions options = new ConfigurationOptions
+{
+    //list of available nodes of the cluster along with the endpoint port.
+    EndPoints = {
+        { "localhost", 16379 },
+        { "localhost", 16380 },
+        // ...
+    },            
+};
+
+ConnectionMultiplexer cluster = ConnectionMultiplexer.Connect(options);
+IDatabase db = cluster.GetDatabase();
+
+db.StringSet("foo", "bar");
+Console.WriteLine(db.StringGet("foo")); // prints bar
+```
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+Before connecting your application to the TLS-enabled Redis server, ensure that your certificates and private keys are in the correct format.
+
+To convert user certificate and private key from the PEM format to `pfx`, use this command:
+
+```bash
+openssl pkcs12 -inkey redis_user_private.key -in redis_user.crt -export -out redis.pfx
+```
+
+Enter password to protect your `pfx` file.
+
+Establish a secure connection with your Redis database using this snippet.
+
+```csharp
+ConfigurationOptions options = new ConfigurationOptions
+{
+    EndPoints = { { "my-redis.cloud.redislabs.com", 6379 } },
+    User = "default",  // use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+    Password = "secret", // use your Redis password
+    Ssl = true,
+    SslProtocols = System.Security.Authentication.SslProtocols.Tls12                
+};
+
+options.CertificateSelection += delegate
+{
+    return new X509Certificate2("redis.pfx", "secret"); // use the password you specified for pfx file
+};
+options.CertificateValidation += ValidateServerCertificate;
+
+bool ValidateServerCertificate(
+        object sender,
+        X509Certificate? certificate,
+        X509Chain? chain,
+        SslPolicyErrors sslPolicyErrors)
+{
+    if (certificate == null) {
+        return false;       
+    }
+
+    var ca = new X509Certificate2("redis_ca.pem");
+    bool verdict = (certificate.Issuer == ca.Subject);
+    if (verdict) {
+        return true;
+    }
+    Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
+    return false;
+}
+
+ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect(options);   
+            
+//Creation of the connection to the DB
+IDatabase conn = muxer.GetDatabase();
+
+//send SET command
+conn.StringSet("foo", "bar");
+
+//send GET command and print the value
+Console.WriteLine(conn.StringGet("foo"));   
+```
+
+## Multiplexing
+
+Although example code typically works with a single connection,
+real-world code often uses multiple connections at the same time.
+Opening and closing connections repeatedly is inefficient, so it is best
+to manage open connections carefully to avoid this.
+
+Several other
+Redis client libraries use *connection pools* to reuse a set of open
+connections efficiently. NRedisStack uses a different approach called
+*multiplexing*, which sends all client commands and responses over a
+single connection. NRedisStack manages multiplexing for you automatically.
+This gives high performance without requiring any extra coding.
+See
+[Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+for more information.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis query engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 30
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack" >}})
+or another Redis server available. Also install the
+[`NRedisStack`]({{< relref "/develop/clients/dotnet" >}}) client library if you
+haven't already done so. 
+
+Add the following dependencies:
+
+{{< clients-example cs_home_json import >}}
+{{< /clients-example >}}
+
+## Create data
+
+Create some test data to add to the database:
+
+{{< clients-example cs_home_json create_data >}}
+{{< /clients-example >}}
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/dotnet/connect" >}})
+to learn more about the available connection options.
+
+{{< clients-example cs_home_json connect >}}
+{{< /clients-example >}}
+
+Create an index. In this example, only JSON documents with the key prefix `user:` are indexed. For more information, see [Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}).
+
+{{< clients-example cs_home_json make_index >}}
+{{< /clients-example >}}
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them:
+
+{{< clients-example cs_home_json add_data >}}
+{{< /clients-example >}}
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+{{< clients-example cs_home_json query1 >}}
+{{< /clients-example >}}
+
+Specify query options to return only the `city` field:
+
+{{< clients-example cs_home_json query2 >}}
+{{< /clients-example >}}
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+{{< clients-example cs_home_json query3 >}}
+{{< /clients-example >}}
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must set the `On` option to `IndexDataType.HASH`
+in the `FTCreateParams` object when you create the index. The code below shows
+these changes with a new index called `hash-idx:users`, which is otherwise the
+same as the `idx:users` index used for JSON documents in the previous examples.
+
+{{< clients-example cs_home_json make_hash_index >}}
+{{< /clients-example >}}
+
+You use [`HashSet()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`JSON.Set()`]({{< relref "/commands/json.set" >}}).
+Also, you must add the fields as key-value pairs instead of combining them
+into a single object.
+
+{{< clients-example cs_home_json add_hash_data >}}
+{{< /clients-example >}}
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The format of the result is
+almost the same except that the fields are returned directly in the
+`Document` object of the result (for JSON, the fields are all enclosed
+in a string under the key `json`):
+
+{{< clients-example cs_home_json query1_hash >}}
+{{< /clients-example >}}
+
+## More information
+
+See the [Redis query engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how `NRedisStack` uses conditional execution
+linkTitle: Conditional execution
+title: Conditional execution
+weight: 60
+---
+
+Most Redis client libraries use transactions with the
+[`WATCH`]({{< relref "/commands/watch" >}}) command as the main way to prevent
+two clients writing to the same key at once (see [Transactions]({{< relref "/develop/interact/transactions" >}}) for more information). Unfortunately, this approach is
+difficult to use explicitly in `NRedisStack`. Its
+[multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}}) 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.
+
+## `When` conditions
+
+Several commands have variants that only execute if the key they change
+already exists (or alternatively, if it doesn't already exist). For
+example, the [`SET`]({{< relref "/commands/set" >}}) command has the
+variants [`SETEX`]({{< relref "/commands/setex" >}}) (set when the key exists),
+and [`SETNX`]({{< relref "/commands/setnx" >}}) (set when the key doesn't exist).
+
+Instead of providing the different variants of these commands, `NRedisStack`
+lets you add a `When` condition to the basic command to access its variants.
+The following example demonstrates this for the
+[`HashSet()`]({{< relref "/commands/hset" >}}) command.
+
+<!-- < clients-example pipe_trans_tutorial when_condition "C#" >}}
+< /clients-example >}} -->
+
+```csharp
+bool resp7 = db.HashSet("Details", "SerialNumber", "12345");
+Console.WriteLine(resp7); // >>> true
+
+db.HashSet("Details", "SerialNumber", "12345A", When.NotExists);
+string resp8 = db.HashGet("Details", "SerialNumber");
+Console.WriteLine(resp8); // >>> 12345
+
+db.HashSet("Details", "SerialNumber", "12345A");
+string resp9 = db.HashGet("Details", "SerialNumber");
+Console.WriteLine(resp9); // >>> 12345A
+```
+
+The available conditions are `When.Exists`, `When.NotExists`, and the default
+`When.Always`.
+
+## Transaction conditions
+
+`NRedisStack` also supports a more extensive set of conditions that you
+can add to transactions. They are implemented internally using
+[`WATCH`]({{< relref "/commands/watch" >}}) commands in a way that is
+guaranteed to be safe, without interactions between different clients.
+Although conditions don't provide exactly the same behavior as
+explicit `WATCH` commands, they are convenient to use and execute
+efficiently.
+
+The example below shows how to use the `AddCondition()` method on
+a transaction to let it run only if a specified hash key does not
+already exist. See
+[Pipelines and transactions]({{< relref "/develop/clients/dotnet/transpipe" >}})
+for more information about transactions.
+
+<!--< clients-example pipe_trans_tutorial trans_watch "C#" >}}
+< /clients-example >}} -->
+
+```csharp
+var watchedTrans = new Transaction(db);
+
+watchedTrans.AddCondition(Condition.KeyNotExists("customer:39182"));
+
+watchedTrans.Db.HashSetAsync(
+    "customer:39182",
+    new HashEntry[]{
+        new HashEntry("name", "David"),
+        new HashEntry("age", "27")
+    }
+);
+
+bool succeeded = watchedTrans.Execute();
+Console.WriteLine(succeeded); // >>> true
+```
+
+The table below describes the full set of conditions you can add to
+a transaction. Note that you can add more than one condition to the
+same transaction if necessary.
+
+| Condition | Description |
+| :-- | :-- |
+| `HashEqual` | Enforces that the given hash-field must have the specified value. |
+| `HashExists` | Enforces that the given hash-field must exist. |
+| `HashNotEqual` | Enforces that the given hash-field must not have the specified value. |
+| `HashNotExists` | Enforces that the given hash-field must not exist. |
+| `KeyExists` | Enforces that the given key must exist. |
+| `KeyNotExists` | Enforces that the given key must not exist. |
+| `ListIndexEqual` | Enforces that the given list index must have the specified value. |
+| `ListIndexExists` | Enforces that the given list index must exist. |
+| `ListIndexNotEqual` | Enforces that the given list index must not have the specified value. |
+| `ListIndexNotExists` | Enforces that the given list index must not exist. |
+| `StringEqual` | Enforces that the given key must have the specified value. |
+| `StringNotEqual` | Enforces that the given key must not have the specified value. |
+| `HashLengthEqual` | Enforces that the given hash length is a certain value. |
+| `HashLengthLessThan` | Enforces that the given hash length is less than a certain value. |
+| `HashLengthGreaterThan` | Enforces that the given hash length is greater than a certain value. |
+| `StringLengthEqual` | Enforces that the given string length is a certain value. |
+| `StringLengthLessThan` | Enforces that the given string length is less than a certain value. |
+| `StringLengthGreaterThan` | Enforces that the given string length is greater than a certain value. |
+| `ListLengthEqual` | Enforces that the given list length is a certain value. |
+| `ListLengthLessThan` | Enforces that the given list length is less than a certain value. |
+| `ListLengthGreaterThan` | Enforces that the given list length is greater than a certain value. |
+| `SetLengthEqual` | Enforces that the given set cardinality is a certain value. |
+| `SetLengthLessThan` | Enforces that the given set cardinality is less than a certain value. |
+| `SetLengthGreaterThan` | Enforces that the given set cardinality is greater than a certain value. |
+| `SetContains` | Enforces that the given set contains a certain member. |
+| `SetNotContains` | Enforces that the given set does not contain a certain member. |
+| `SortedSetLengthEqual` | Enforces that the given sorted set cardinality is a certain value. |
+| `SortedSetLengthEqual` | Enforces that the given sorted set contains a certain number of members with scores in the given range. |
+| `SortedSetLengthLessThan` | Enforces that the given sorted set cardinality is less than a certain value. |
+| `SortedSetLengthLessThan` | Enforces that the given sorted set contains less than a certain number of members with scores in the given range. |
+| `SortedSetLengthGreaterThan` | Enforces that the given sorted set cardinality is greater than a certain value. |
+| `SortedSetLengthGreaterThan` | Enforces that the given sorted set contains more than a certain number of members with scores in the given range. |
+| `SortedSetContains` | Enforces that the given sorted set contains a certain member. |
+| `SortedSetNotContains` | Enforces that the given sorted set does not contain a certain member. |
+| `SortedSetEqual` | Enforces that the given sorted set member must have the specified score. |
+| `SortedSetNotEqual` | Enforces that the given sorted set member must not have the specified score. |
+| `SortedSetScoreExists` | Enforces that the given sorted set must have the given score. |
+| `SortedSetScoreNotExists` | Enforces that the given sorted set must not have the given score. |
+| `SortedSetScoreExists` | Enforces that the given sorted set must have the specified count of the given score. |
+| `SortedSetScoreNotExists` | Enforces that the given sorted set must not have the specified count of the given score. |
+| `StreamLengthEqual` | Enforces that the given stream length is a certain value. |
+| `StreamLengthLessThan` | Enforces that the given stream length is less than a certain value. |
+| `StreamLengthGreaterThan` | Enforces that the given stream length is greater than a certain value. |
+---
+aliases: /develop/connect/clients/dotnet
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your .NET application to a Redis database
+linkTitle: NRedisStack (C#/.NET)
+title: NRedisStack guide (C#/.NET)
+weight: 3
+---
+
+[NRedisStack](https://github.com/redis/NRedisStack) is the .NET client for Redis.
+The sections below explain how to install `NRedisStack` and connect your application
+to a Redis database.
+
+`NRedisStack` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+You can also access Redis with an object-mapping client interface. See
+[Redis OM for .NET]({{< relref "/integrate/redisom-for-net" >}})
+for more information.
+
+## Install
+
+Using the `dotnet` CLI, run:
+
+```bash
+dotnet add package NRedisStack
+```
+
+## Connect and test
+
+Connect to localhost on port 6379.
+
+```csharp
+using NRedisStack;
+using NRedisStack.RedisStackCommands;
+using StackExchange.Redis;
+//...
+ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
+IDatabase db = redis.GetDatabase();
+```
+
+You can test the connection by storing and retrieving a simple string.
+
+```csharp
+db.StringSet("foo", "bar");
+Console.WriteLine(db.StringGet("foo")); // prints bar
+```
+
+Store and retrieve a HashMap.
+
+```csharp
+var hash = new HashEntry[] { 
+    new HashEntry("name", "John"), 
+    new HashEntry("surname", "Smith"),
+    new HashEntry("company", "Redis"),
+    new HashEntry("age", "29"),
+    };
+db.HashSet("user-session:123", hash);
+
+var hashFields = db.HashGetAll("user-session:123");
+Console.WriteLine(String.Join("; ", hashFields));
+// Prints: 
+// name: John; surname: Smith; company: Redis; age: 29
+```
+## Redis Open Source modules
+
+To access Redis Open Source capabilities, use the appropriate interface like this:
+
+```
+IBloomCommands bf = db.BF();
+ICuckooCommands cf = db.CF();
+ICmsCommands cms = db.CMS();
+IGraphCommands graph = db.GRAPH();
+ITopKCommands topk = db.TOPK();
+ITdigestCommands tdigest = db.TDIGEST();
+ISearchCommands ft = db.FT();
+IJsonCommands json = db.JSON();
+ITimeSeriesCommands ts = db.TS();
+```
+
+## More information
+
+See the other pages in this section for more information and examples.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get your NRedisStack app ready for production
+linkTitle: Production usage
+title: Production usage
+weight: 70
+---
+
+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.
+
+{{< checklist "dotnetprodlist" >}}
+    {{< checklist-item "#event-handling" >}}Event handling{{< /checklist-item >}}
+    {{< checklist-item "#timeouts" >}}Timeouts{{< /checklist-item >}}
+    {{< checklist-item "#exception-handling" >}}Exception handling{{< /checklist-item >}}
+{{< /checklist >}}
+
+## Recommendations
+
+The sections below offer recommendations for your production environment. Some
+of them may not apply to your particular use case.
+
+### Event handling
+
+The `ConnectionMultiplexer` class publishes several different types of
+[events](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/events/)
+for situations such as configuration changes and connection failures.
+Use these events to record server activity in a log, which you can then use
+to monitor performance and diagnose problems when they occur.
+See
+the StackExchange.Redis
+[Events](https://stackexchange.github.io/StackExchange.Redis/Events)
+page for the full list of events.
+
+#### Server notification events
+
+Some servers (such as Azure Cache for Redis) send notification events shortly
+before scheduled maintenance is due to happen. You can use code like the
+following to respond to these events (see the 
+[StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/ServerMaintenanceEvent)
+docs for the full list of supported events). For example, you could
+inform users who try to connect that service is temporarily unavailable
+rather than letting them run into errors.
+
+```cs
+using NRedisStack;
+using StackExchange.Redis;
+
+ConnectionMultiplexer muxer = ConnectionMultiplexer.Connect("localhost:6379");
+
+muxer.ServerMaintenanceEvent += (object sender, ServerMaintenanceEvent e) => {
+    // Identify the event and respond to it here.
+    Console.WriteLine($"Maintenance event: {e.RawMessage}");
+};
+```
+
+### Timeouts
+
+If a network or server error occurs while your code is opening a
+connection or issuing a command, it can end up hanging indefinitely.
+To prevent this, `NRedisStack` sets timeouts for socket
+reads and writes and for opening connections.
+
+By default, the timeout is five seconds for all operations, but
+you can set the time (in milliseconds) separately for connections
+and commands using the `ConnectTimeout`, `SyncTimeout`, and
+`AsyncTimeout` configuration options:
+
+```cs
+var muxer = ConnectionMultiplexer.Connect(new ConfigurationOptions {
+    ConnectTimeout = 1000,  // 1 second timeout for connections.
+    SyncTimeout = 2000,     // 2 seconds for synchronous commands.
+    AsyncTimeout = 3000     // 3 seconds for asynchronous commands.
+        .
+        .
+});
+
+var db = muxer.GetDatabase();
+```
+
+The default timeouts are a good starting point, but you may be able
+to improve performance by adjusting the values to suit your use case.
+
+### Exception handling
+
+Redis handles many errors using return values from commands, but there
+are also situations where exceptions can be thrown. In production code,
+you should handle exceptions as they occur. The list below describes some
+the most common Redis exceptions:
+
+- `RedisConnectionException`: Thrown when a connection attempt fails.
+- `RedisTimeoutException`: Thrown when a command times out.
+- `RedisCommandException`: Thrown when you issue an invalid command.
+- `RedisServerException`: Thrown when you attempt an invalid operation
+  (for example, trying to access a
+  [stream entry]({{< relref "/develop/data-types/streams#entry-ids" >}})
+  using an invalid ID).
+---
+aliases: /develop/connect/om-clients
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Object-Mapper libraries for Redis Open Source
+linkTitle: Object mapping
+stack: true
+title: Object-Mapper libraries
+weight: 20
+---
+
+Redis OM (pronounced *REDiss OHM*) is a library that provides object mapping for Redis. With the help of Redis OM, you can map Redis data types, specifically Hashes and JSON documents, to objects of your preferred programming language or framework. Redis OM relies on the JSON and Redis Query Engine features of Redis Open Source, allowing you to search and/or query for objects. 
+
+You can use Redis OM with the following four programming languages:
+
+* [Python]({{< relref "/integrate/redisom-for-python" >}})
+* [C#/.NET]({{< relref "/integrate/redisom-for-net" >}})
+* [Node.js]({{< relref "/integrate/redisom-for-node-js" >}})
+* [Java/Spring]({{< relref "/integrate/redisom-for-java" >}})
+---
+aliases: /develop/connect/clients/client-side-caching
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Server-assisted, client-side caching in Redis
+linkTitle: Client-side caching
+title: Client-side caching introduction
+weight: 30
+---
+
+*Client-side caching* reduces network traffic between
+a Redis client and the server, which generally improves performance.
+
+By default, an [application server](https://en.wikipedia.org/wiki/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:
+
+{{< image filename="images/csc/CSCNoCache.drawio.svg" >}}
+
+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:
+
+{{< image filename="images/csc/CSCWithCache.drawio.svg" >}}
+
+Accessing the cache is much faster than communicating with the database over the
+network and it reduces network traffic. Client-side caching reduces
+the load on the database server, so you may be able to run it using less hardware
+resources.
+
+As with other forms of [caching](https://en.wikipedia.org/wiki/Cache_(computing)),
+client-side caching works well in the very common use case where a small subset of the data
+is accessed much more frequently than the rest of the data (according
+to the [Pareto principle](https://en.wikipedia.org/wiki/Pareto_principle)).
+
+## Updating the cache when the data changes {#tracking}
+
+All caching systems must implement a scheme to update data in the cache
+when the corresponding data changes in the main database. Redis uses an
+approach called *tracking*.
+
+When client-side caching is enabled, the Redis server remembers or *tracks* the set of keys
+that each client connection has previously read. This includes cases where the client
+reads data directly, as with the [`GET`]({{< relref "/commands/get" >}})
+command, and also where the server calculates values from the stored data,
+as with [`STRLEN`]({{< relref "/commands/strlen" >}}). When any client
+writes new data to a tracked key, the server sends an invalidation message
+to all clients that have accessed that key previously. This message warns
+the clients that their cached copies of the data are no longer valid and the clients
+will evict the stale data in response. Next time a client reads from
+the same key, it will access the database directly and refresh its cache
+with the updated data.
+
+{{< note >}}If any connection from a client gets disconnected (including
+one from a connection pool), then the client will flush all keys from the
+client-side cache. Caching then resumes for subsequent reads from the
+connections that are still active.
+{{< /note >}}
+
+The sequence diagram below shows how two clients might interact as they
+access and update the same key:
+
+{{< image filename="images/csc/CSCSeqDiagram.drawio.svg" >}}
+
+## Which client libraries support client-side caching?
+
+The following client libraries support CSC from the stated version onwards:
+
+| Client | Version |
+| :-- | :-- |
+| [`redis-py`]({{< relref "/develop/clients/redis-py/connect#connect-using-client-side-caching" >}}) | v5.1.0 |
+| [`Jedis`]({{< relref "/develop/clients/jedis/connect#connect-using-client-side-caching" >}}) | v5.2.0 |
+
+## Which commands can cache data?
+
+All read-only commands (with the `@read`
+[ACL category]({{< relref "/operate/oss_and_stack/management/security/acl" >}}))
+will use cached data, except for the following:
+
+-   Any commands for the
+    [probabilistic]({{< relref "/develop/data-types/probabilistic" >}}) and
+    [time series]({{< relref "/develop/data-types/timeseries" >}}) data types.
+    These types are designed to be updated frequently, which means that caching
+    has little or no benefit.
+-   Non-deterministic commands such as [`HRANDFIELD`]({{< relref "/commands/hrandfield" >}}),
+    [`HSCAN`]({{< relref "/commands/hscan" >}}),
+    and [`ZRANDMEMBER`]({{< relref "/commands/zrandmember" >}}). By design, these commands
+    give different results each time they are called.
+-   Redis Query Engine commands (with the `FT.*` prefix), such as
+    [`FT.SEARCH`]({{< relref "commands/ft.search" >}}).
+
+You can use the [`MONITOR`]({{< relref "/commands/monitor" >}}) command to
+check the server's behavior when you are using client-side caching. Because `MONITOR` only
+reports activity from the server, you should find the first cacheable
+access to a key causes a response from the server. However, subsequent
+accesses are satisfied by the cache, and so `MONITOR` should report no
+server activity if client-side caching is working correctly.
+
+## What data gets cached for a command?
+
+Broadly speaking, the data from the specific response to a command invocation
+gets cached after it is used for the first time. Subsets of that data
+or values calculated from it are retrieved from the server as usual and
+then cached separately. For example:
+
+-   The whole string retrieved by [`GET`]({{< relref "/commands/get" >}})
+    is added to the cache. Parts of the same string retrieved by
+    [`SUBSTR`]({{< relref "/commands/substr" >}}) are calculated on the
+    server the first time and then cached separately from the original
+    string.
+-   Using [`GETBIT`]({{< relref "/commands/getbit" >}}) or
+    [`BITFIELD`]({{< relref "/commands/bitfield" >}}) on a string
+    caches the returned values separately from the original string.
+-   For composite data types accessed by keys
+    ([hash]({{< relref "/develop/data-types/hashes" >}}),
+    [JSON]({{< relref "/develop/data-types/json" >}}),
+    [set]({{< relref "/develop/data-types/sets" >}}), and
+    [sorted set]({{< relref "/develop/data-types/sorted-sets" >}})),
+    the whole object is cached separately from the individual fields.
+    So the results of `JSON.GET mykey $` and `JSON.GET mykey $.myfield` create
+    separate entries in the cache.
+-   Ranges from [lists]({{< relref "/develop/data-types/lists" >}}),
+    [streams]({{< relref "/develop/data-types/streams" >}}),
+    and [sorted sets]({{< relref "/develop/data-types/sorted-sets" >}})
+    are cached separately from the object they form a part of. Likewise,
+    subsets returned by [`SINTER`]({{< relref "/commands/sinter" >}}) and
+    [`SDIFF`]({{< relref "/commands/sdiff" >}}) create separate cache entries.
+-   For multi-key read commands such as [`MGET`]({{< relref "/commands/mget" >}}),
+    the ordering of the keys is significant. For example `MGET name:1 name:2` is
+    cached separately from `MGET name:2 name:1` because the server returns the
+    values in the order you specify.
+-   Boolean or numeric values calculated from data types (for example 
+    [`SISMEMBER`]({{< relref "/commands/sismember" >}})) and
+    [`LLEN`]({{< relref "/commands/llen" >}}) are cached separately from the
+    object they refer to.
+
+## Usage recommendations
+
+Like any caching system, client-side caching has some limitations:
+
+-   The cache has only a limited amount of memory available. When the limit
+    is reached, the client must *evict* potentially useful items from the
+    cache to make room for new ones.
+-   Cache misses, tracking, and invalidation messages always add a slight
+    performance penalty.
+
+Below are some guidelines to help you use client-side caching efficiently, within these
+limitations:
+
+-   **Use a separate connection for data that is not cache-friendly**:
+    Caching gives the most benefit
+    for keys that are read frequently and updated infrequently. However, you
+    may also have data, such as counters and scoreboards, that receives frequent
+    updates. In cases like this, the performance overhead of the invalidation
+    messages can be greater than the savings made by caching. Avoid this problem
+    by using a separate connection *without* client-side caching for any data that is
+    not cache-friendly.
+-   **Estimate how many items you can cache**: The client libraries let you
+    specify the maximum number of items you want to hold in the cache. You
+    can calculate an estimate for this number by dividing the 
+    maximum desired size of the
+    cache in memory by the average size of the items you want to store
+    (use the [`MEMORY USAGE`]({{< relref "/commands/memory-usage" >}})
+    command to get the memory footprint of a key). For example, if you had
+    10MB (or 10485760 bytes) available for the cache, and the average
+    size of an item was 80 bytes, you could fit approximately
+    10485760 / 80 = 131072 items in the cache. Monitor memory usage
+    on your server with a realistic test load to adjust your estimate
+    up or down.
+
+    ## Reference
+
+    The Redis server implements extra features for client-side caching that are not used by
+    the main Redis clients, but may be useful for custom clients and other
+    advanced applications. See
+    [Client-side caching reference]({{< relref "/develop/reference/client-side-caching" >}})
+    for a full technical guide to all the options available for client-side caching.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 50
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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 `execute()`
+method on the pipeline object. This method returns a list that contains
+the results from all the commands in order.
+
+Note that the command methods for a pipeline always return the original
+pipeline object, so you can "chain" several commands together, as the
+example below shows:
+
+{{< clients-example pipe_trans_tutorial basic_pipe Python >}}
+{{< /clients-example >}}
+
+## Execute a transaction
+
+A pipeline actually executes as a transaction by default (that is to say,
+all commands are executed in an uninterrupted sequence). However, if you
+need to switch this behavior off, you can set the `transaction` parameter
+to `False` when you create the pipeline:
+
+```python
+pipe = r.pipeline(transaction=False)
+```
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The example below shows how to repeatedly attempt a transaction with a watched
+key until it succeeds. The code reads a string
+that represents a `PATH` variable for a command shell, then appends a new
+command path to the string before attempting to write it back. If the watched
+key is modified by another client before writing, the transaction aborts
+with a `WatchError` exception, and the loop executes again for another attempt.
+Otherwise, the loop terminates successfully.
+
+{{< clients-example pipe_trans_tutorial trans_watch Python >}}
+{{< /clients-example >}}
+
+Because this is a common pattern, the library includes a convenience
+method called `transaction()` that handles the code to watch keys,
+execute the transaction, and retry if necessary. Pass
+`transaction()` a function that implements your main transaction code,
+and also pass the keys you want to watch. The example below implements
+the same basic transaction as the previous example but this time
+using `transaction()`. Note that `transaction()` can't add the `multi()`
+call automatically, so you must still place this correctly in your
+transaction function.
+
+{{< clients-example pipe_trans_tutorial watch_conv_method Python >}}
+{{< /clients-example >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Iterate through results from `SCAN`, `HSCAN`, etc.
+linkTitle: Scan iteration
+title: Scan iteration
+weight: 60
+---
+
+Redis has a small family of related commands that retrieve
+keys and, in some cases, their associated values:
+
+-   [`SCAN`]({{< relref "/commands/scan" >}}) retrieves keys
+    from the main Redis keyspace.
+-   [`HSCAN`]({{< relref "/commands/hscan" >}}) retrieves keys and optionally,
+    their values from a
+    [hash]({{< relref "/develop/data-types/hashes" >}}) object.
+-   [`SSCAN`]({{< relref "/commands/sscan" >}}) retrieves keys from a
+    [set]({{< relref "/develop/data-types/sets" >}}) object.
+-   [`ZSCAN`]({{< relref "/commands/zscan" >}}) retrieves keys and their score values from a
+    [sorted set]({{< relref "/develop/data-types/sorted-sets" >}}) 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](https://docs.python.org/3/glossary.html#term-iterable).
+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](https://docs.python.org/3/glossary.html#term-sequence).
+
+Each of the commands has its own equivalent iterator. The following example shows
+how to use a `SCAN` iterator on the Redis keyspace. Note that, as with the `SCAN`
+command, the results are not sorted into any particular order, . Also, you
+can pass `match`, `count`, and `_type` parameters to `scan_iter()` to constrain
+the set of keys it returns (see the [`SCAN`]({{< relref "/commands/scan" >}})
+command page for examples). 
+
+```py
+import redis
+
+r = redis.Redis(decode_responses=True)
+
+r.set("key:1", "a")
+r.set("key:2", "b")
+r.set("key:3", "c")
+r.set("key:4", "d")
+r.set("key:5", "e")
+
+for key in r.scan_iter():
+    print(f"Key: {key}, value: {r.get(key)}")
+# >>> Key: key:1, value: a
+# >>> Key: key:4, value: d
+# >>> Key: key:3, value: c
+# >>> Key: key:2, value: b
+# >>> Key: key:5, value: e
+```
+
+The iterators for the other commands are also named with `_iter()` after
+the name of the basic command (`hscan_iter()`, `sscan_iter()`, and `zscan_iter()`).
+They work in a similar way to `scan_iter()` except that you must pass a
+key to identify the object you want to scan. The example below shows how to
+iterate through the items in a sorted set using `zscan_iter()`.
+
+```py
+r.zadd("battles", mapping={
+    "hastings": 1066,
+    "agincourt": 1415,
+    "trafalgar": 1805,
+    "somme": 1916,
+})
+
+for item in r.zscan_iter("battles"):
+    print(f"Key: {item[0]}, value: {int(item[1])}")
+# >>> Key: hastings, value: 1066
+# >>> Key: agincourt, value: 1415
+# >>> Key: trafalgar, value: 1805
+# >>> Key: somme, value: 1916
+```
+
+Note that in this case, the item returned by the iterator is a
+[tuple](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)
+with two elements for the key and score. By default, `hscan_iter()`
+also returns a 2-tuple for the key and value, but you can
+pass a value of `True` for the `no_values` parameter to retrieve just
+the keys:
+
+```py
+r.hset("details", mapping={
+    "name": "Mr Benn",
+    "address": "52 Festive Road",
+    "hobbies": "Cosplay"
+})
+
+for key in r.hscan_iter("details", no_values=True):
+    print(f"Key: {key}, value: {r.hget("details", key)}")
+# >>> Key: name, value: Mr Benn
+# >>> Key: address, value: 52 Festive Road
+# >>> Key: hobbies, value: Cosplay
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 40
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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.
+
+The example below uses the
+[`sentence-transformers`](https://pypi.org/project/sentence-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](#differences-with-json-documents).
+
+## Initialize
+
+Install [`redis-py`]({{< relref "/develop/clients/redis-py" >}}) if you
+have not already done so. Also, install `sentence-transformers` with the
+following command:
+
+```bash
+pip install sentence-transformers
+```
+
+In a new Python source file, start by importing the required classes:
+
+```python
+from sentence_transformers import SentenceTransformer
+from redis.commands.search.query import Query
+from redis.commands.search.field import TextField, TagField, VectorField
+from redis.commands.search.indexDefinition import IndexDefinition, IndexType
+from redis.commands.json.path import Path
+
+import numpy as np
+import redis
+```
+
+The first of these imports is the
+`SentenceTransformer` class, which generates an embedding from a section of text.
+Here, we create an instance of `SentenceTransformer` that uses the
+[`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
+model for the embeddings. This model generates vectors with 384 dimensions, regardless
+of the length of the input text, but note that the input is truncated to 256
+tokens (see
+[Word piece tokenization](https://huggingface.co/learn/nlp-course/en/chapter6/6)
+at the [Hugging Face](https://huggingface.co/) docs to learn more about the way tokens
+are related to the original text).
+
+```python
+model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+```
+
+## Create the index
+
+Connect to Redis and delete any index previously created with the
+name `vector_idx`. (The `dropindex()` call throws an exception if
+the index doesn't already exist, which is why you need the
+`try: except:` block.)
+
+```python
+r = redis.Redis(decode_responses=True)
+
+try:
+    r.ft("vector_idx").dropindex(True)
+except redis.exceptions.ResponseError:
+    pass
+```
+
+Next, create the index.
+The schema in the example below specifies hash objects for storage and includes
+three fields: the text content to index, a
+[tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+field to represent the "genre" of the text, and the embedding vector generated from
+the original text content. The `embedding` field specifies
+[HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) 
+indexing, the
+[L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+vector distance metric, `Float32` values to represent the vector's components,
+and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
+
+```python
+schema = (
+    TextField("content"),
+    TagField("genre"),
+    VectorField("embedding", "HNSW", {
+        "TYPE": "FLOAT32",
+        "DIM": 384,
+        "DISTANCE_METRIC":"L2"
+    })
+)
+
+r.ft("vector_idx").create_index(
+    schema,
+    definition=IndexDefinition(
+        prefix=["doc:"], index_type=IndexType.HASH
+    )
+)
+```
+
+## Add data
+
+You can now supply the data objects, which will be indexed automatically
+when you add them with [`hset()`]({{< relref "/commands/hset" >}}), as long as
+you use the `doc:` prefix specified in the index definition.
+
+Use the `model.encode()` method of `SentenceTransformer`
+as shown below to create the embedding that represents the `content` field.
+The `astype()` option that follows the `model.encode()` call specifies that
+we want a vector of `float32` values. The `tobytes()` option encodes the
+vector components together as a single binary string.
+Use the binary string representation when you are indexing hashes
+or running a query (but use a list of `float` for
+[JSON documents](#differences-with-json-documents)).
+
+```python
+content = "That is a very happy person"
+
+r.hset("doc:0", mapping={
+    "content": content,
+    "genre": "persons",
+    "embedding": model.encode(content).astype(np.float32).tobytes(),
+})
+
+content = "That is a happy dog"
+
+r.hset("doc:1", mapping={
+    "content": content,
+    "genre": "pets",
+    "embedding": model.encode(content).astype(np.float32).tobytes(),
+})
+
+content = "Today is a sunny day"
+
+r.hset("doc:2", mapping={
+    "content": content,
+    "genre": "weather",
+    "embedding": model.encode(content).astype(np.float32).tobytes(),
+})
+```
+
+## Run a query
+
+After you have created the index and added the data, you are ready to run a query.
+To do this, you must create another embedding vector from your chosen query
+text. Redis calculates the similarity between the query vector and each
+embedding vector in the index as it runs the query. It then ranks the
+results in order of this numeric similarity value.
+
+The code below creates the query embedding using `model.encode()`, as with
+the indexing, and passes it as a parameter when the query executes
+(see
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about using query parameters with embeddings).
+
+```python
+q = Query(
+    "*=>[KNN 3 @embedding $vec AS vector_distance]"
+).return_field("score").dialect(2)
+
+query_text = "That is a happy person"
+
+res = r.ft("vector_idx").search(
+    q, query_params={
+        "vec": model.encode(query_text).astype(np.float32).tobytes()
+    }
+)
+
+print(res)
+```
+
+The code is now ready to run, but note that it may take a while to complete when
+you run it for the first time (which happens because RedisVL must download the
+`all-MiniLM-L6-v2` model data before it can
+generate the embeddings). When you run the code, it outputs the following result
+object (slightly formatted here for clarity):
+
+```Python
+Result{
+    3 total,
+    docs: [
+        Document {
+            'id': 'doc:0',
+            'payload': None,
+            'vector_distance': '0.114169985056',
+            'content': 'That is a very happy person'
+        },
+        Document {
+            'id': 'doc:1',
+            'payload': None,
+            'vector_distance': '0.610845386982',
+            'content': 'That is a happy dog'
+        },
+        Document {
+            'id': 'doc:2',
+            'payload': None,
+            'vector_distance': '1.48624813557',
+            'content': 'Today is a sunny day'
+        }
+    ]
+}
+```
+
+Note that the results are ordered according to the value of the `vector_distance`
+field, with the lowest distance indicating the greatest similarity to the query.
+As you would expect, the result for `doc:0` with the content text *"That is a very happy person"*
+is the result that is most similar in meaning to the query text
+*"That is a happy person"*.
+
+## Differences with JSON documents
+
+Indexing JSON documents is similar to hash indexing, but there are some
+important differences. JSON allows much richer data modelling with nested fields, so
+you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+to identify each field you want to index. However, you can declare a short alias for each
+of these paths (using the `as_name` keyword argument) to avoid typing it in full for
+every query. Also, you must specify `IndexType.JSON` when you create the index.
+
+The code below shows these differences, but the index is otherwise very similar to
+the one created previously for hashes:
+
+```py
+schema = (
+    TextField("$.content", as_name="content"),
+    TagField("$.genre", as_name="genre"),
+    VectorField(
+        "$.embedding", "HNSW", {
+            "TYPE": "FLOAT32",
+            "DIM": 384,
+            "DISTANCE_METRIC": "L2"
+        },
+        as_name="embedding"
+    )
+)
+
+r.ft("vector_json_idx").create_index(
+    schema,
+    definition=IndexDefinition(
+        prefix=["jdoc:"], index_type=IndexType.JSON
+    )
+)
+```
+
+Use [`json().set()`]({{< relref "/commands/json.set" >}}) to add the data
+instead of [`hset()`]({{< relref "/commands/hset" >}}). The dictionaries
+that specify the fields have the same structure as the ones used for `hset()`
+but `json().set()` receives them in a positional argument instead of 
+the `mapping` keyword argument.
+
+An important difference with JSON indexing is that the vectors are
+specified using lists instead of binary strings. Generate the list
+using the `tolist()` method instead of `tobytes()` as you would with a
+hash.
+
+```py
+content = "That is a very happy person"
+
+r.json().set("jdoc:0", Path.root_path(), {
+    "content": content,
+    "genre": "persons",
+    "embedding": model.encode(content).astype(np.float32).tolist(),
+})
+
+content = "That is a happy dog"
+
+r.json().set("jdoc:1", Path.root_path(), {
+    "content": content,
+    "genre": "pets",
+    "embedding": model.encode(content).astype(np.float32).tolist(),
+})
+
+content = "Today is a sunny day"
+
+r.json().set("jdoc:2", Path.root_path(), {
+    "content": content,
+    "genre": "weather",
+    "embedding": model.encode(content).astype(np.float32).tolist(),
+})
+```
+
+The query is almost identical to the one for the hash documents. This
+demonstrates how the right choice of aliases for the JSON paths can
+save you having to write complex queries. An important thing to notice
+is that the vector parameter for the query is still specified as a
+binary string (using the `tobytes()` method), even though the data for
+the `embedding` field of the JSON was specified as a list.
+
+```py
+q = Query(
+    "*=>[KNN 3 @embedding $vec AS vector_distance]"
+).return_field("vector_distance").return_field("content").dialect(2)
+
+query_text = "That is a happy person"
+
+res = r.ft("vector_json_idx").search(
+    q, query_params={
+        "vec": model.encode(query_text).astype(np.float32).tobytes()
+    }
+)
+```
+
+Apart from the `jdoc:` prefixes for the keys, the result from the JSON
+query is the same as for hash:
+
+```
+Result{
+    3 total,
+    docs: [
+        Document {
+            'id': 'jdoc:0',
+            'payload': None,
+            'vector_distance': '0.114169985056',
+            'content': 'That is a very happy person'
+        },
+            .
+            .
+            .
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about the indexing options, distance metrics, and query format
+for vectors.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Python application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 20
+---
+
+## 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](https://redis.readthedocs.io/en/stable/examples.html).
+
+```python
+r = redis.Redis(host='localhost', port=6379, decode_responses=True)
+```
+
+Store and retrieve a simple string.
+
+```python
+r.set('foo', 'bar')
+# True
+r.get('foo')
+# bar
+```
+
+Store and retrieve a dict.
+
+```python
+r.hset('user-session:123', mapping={
+    'name': 'John',
+    "surname": 'Smith',
+    "company": 'Redis',
+    "age": 29
+})
+# True
+
+r.hgetall('user-session:123')
+# {'surname': 'Smith', 'name': 'John', 'company': 'Redis', 'age': '29'}
+```
+
+## Connect to a Redis cluster
+
+To connect to a Redis cluster, use `RedisCluster`.
+
+```python
+from redis.cluster import RedisCluster
+
+rc = RedisCluster(host='localhost', port=16379)
+
+print(rc.get_nodes())
+# [[host=127.0.0.1,port=16379,name=127.0.0.1:16379,server_type=primary,redis_connection=Redis<ConnectionPool<Connection<host=127.0.0.1,port=16379,db=0>>>], ...
+
+rc.set('foo', 'bar')
+# True
+
+rc.get('foo')
+# b'bar'
+```
+For more information, see [redis-py Clustering](https://redis-py.readthedocs.io/en/stable/clustering.html).
+
+## Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+```python
+import redis
+
+r = redis.Redis(
+    host="my-redis.cloud.redislabs.com", port=6379,
+    username="default", # use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+    password="secret", # use your Redis password
+    ssl=True,
+    ssl_certfile="./redis_user.crt",
+    ssl_keyfile="./redis_user_private.key",
+    ssl_ca_certs="./redis_ca.pem",
+)
+r.set('foo', 'bar')
+# True
+
+r.get('foo')
+# b'bar'
+```
+For more information, see [redis-py TLS examples](https://redis-py.readthedocs.io/en/stable/examples/ssl_connection_examples.html).
+
+## Connect using client-side caching
+
+Client-side caching is a technique to reduce network traffic between
+the client and server, resulting in better performance. See
+[Client-side caching introduction]({{< relref "/develop/clients/client-side-caching" >}})
+for more information about how client-side caching works and how to use it effectively.
+
+To enable client-side caching, add some extra parameters when you connect
+to the server:
+
+-   `protocol`: (Required) You must pass a value of `3` here because
+    client-side caching requires the [RESP3]({{< relref "/develop/reference/protocol-spec#resp-versions" >}})
+    protocol.
+-   `cache_config`: (Required) Pass `cache_config=CacheConfig()` here to enable client-side caching.
+
+The example below shows the simplest client-side caching connection to the default host and port,
+`localhost:6379`.
+All of the connection variants described above accept these parameters, so you can
+use client-side caching with a connection pool or a cluster connection in exactly the same way.
+
+{{< note >}}Client-side caching requires redis-py v5.1.0 or later.
+To maximize compatibility with all Redis products, client-side caching
+is supported by Redis v7.4 or later.
+
+The [Redis server products]({{< relref "/operate" >}}) support
+[opt-in/opt-out]({{< relref "/develop/reference/client-side-caching#opt-in-and-opt-out-caching" >}}) mode
+and [broadcasting mode]({{< relref "/develop/reference/client-side-caching#broadcasting-mode" >}})
+for CSC, but these modes are not currently implemented by `redis-py`.
+{{< /note >}}
+
+```python
+import redis
+from redis.cache import CacheConfig
+
+r = redis.Redis(
+    protocol=3,
+    cache_config=CacheConfig(),
+    decode_responses=True
+)
+
+r.set("city", "New York")
+cityNameAttempt1 = r.get("city")    # Retrieved from Redis server and cached
+cityNameAttempt2 = r.get("city")    # Retrieved from cache
+```
+
+You can see the cache working if you connect to the same Redis database
+with [`redis-cli`]({{< relref "/develop/tools/cli" >}}) and run the
+[`MONITOR`]({{< relref "/commands/monitor" >}}) command. If you run the
+code above with the `cache_config` line commented out, you should see
+the following in the CLI among the output from `MONITOR`:
+
+```
+1723109720.268903 [...] "SET" "city" "New York"
+1723109720.269681 [...] "GET" "city"
+1723109720.270205 [...] "GET" "city"
+```
+
+The server responds to both `get("city")` calls.
+If you run the code again with `cache_config` uncommented, you will see
+
+```
+1723110248.712663 [...] "SET" "city" "New York"
+1723110248.713607 [...] "GET" "city"
+```
+
+The first `get("city")` call contacted the server but the second
+call was satisfied by the cache.
+
+### Removing items from the cache
+
+You can remove individual keys from the cache with the
+`delete_by_redis_keys()` method. This removes all cached items associated
+with the keys, so all results from multi-key commands (such as
+[`MGET`]({{< relref "/commands/mget" >}})) and composite data structures
+(such as [hashes]({{< relref "/develop/data-types/hashes" >}})) will be
+cleared at once. The example below shows the effect of removing a single
+key from the cache:
+
+```python
+r.hget("person:1", "name") # Read from the server
+r.hget("person:1", "name") # Read from the cache
+
+r.hget("person:2", "name") # Read from the server
+r.hget("person:2", "name") # Read from the cache
+
+cache = r.get_cache()
+cache.delete_by_redis_keys(["person:1"])
+
+r.hget("person:1", "name") # Read from the server
+r.hget("person:1", "name") # Read from the cache
+
+r.hget("person:2", "name") # Still read from the cache
+```
+
+You can also clear all cached items using the `flush()`
+method:
+
+```python
+r.hget("person:1", "name") # Read from the server
+r.hget("person:1", "name") # Read from the cache
+
+r.hget("person:2", "name") # Read from the cache
+r.hget("person:2", "name") # Read from the cache
+
+cache = r.get_cache()
+cache.flush()
+
+r.hget("person:1", "name") # Read from the server
+r.hget("person:1", "name") # Read from the cache
+
+r.hget("person:2", "name") # Read from the server
+r.hget("person:2", "name") # Read from the cache
+```
+
+The client will also flush the cache automatically
+if any connection (including one from a connection pool)
+is disconnected.
+
+## Connect with a connection pool
+
+For production usage, you should use a connection pool to manage
+connections rather than opening and closing connections individually.
+A connection pool maintains several open connections and reuses them
+efficiently. When you open a connection from a pool, the pool allocates
+one of its open connections. When you subsequently close the same connection,
+it is not actually closed but simply returned to the pool for reuse.
+This avoids the overhead of repeated connecting and disconnecting.
+See
+[Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+for more information.
+
+Use the following code to connect with a connection pool:
+
+```python
+import redis
+
+pool = redis.ConnectionPool().from_url("redis://localhost")
+r1 = redis.Redis().from_pool(pool)
+r2 = redis.Redis().from_pool(pool)
+r3 = redis.Redis().from_pool(pool)
+
+r1.set("wind:1", "Hurricane")
+r2.set("wind:2", "Tornado")
+r3.set("wind:3", "Mistral")
+
+r1.close()
+r2.close()
+r3.close()
+
+pool.close()
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis query engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 30
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+or another Redis server available. Also install the
+[`redis-py`]({{< relref "/develop/clients/redis-py" >}}) client library if you
+haven't already done so.
+
+Add the following dependencies. All of them are applicable to both JSON and hash,
+except for the `Path` class, which is specific to JSON (see
+[Path]({{< relref "/develop/data-types/json/path" >}}) for a description of the
+JSON path syntax).
+
+{{< clients-example py_home_json import >}}
+{{< /clients-example >}}
+
+## Create data
+
+Create some test data to add to your database. The example data shown
+below is compatible with both JSON and hash objects.
+
+{{< clients-example py_home_json create_data >}}
+{{< /clients-example >}}
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/redis-py/connect" >}})
+to learn more about the available connection options.
+
+{{< clients-example py_home_json connect >}}
+{{< /clients-example >}}
+
+Create an index for the JSON data. The code below specifies that only JSON documents with
+the key prefix `user:` are indexed. For more information, see
+[Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}).
+
+{{< clients-example py_home_json make_index >}}
+{{< /clients-example >}}
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them:
+
+{{< clients-example py_home_json add_data >}}
+{{< /clients-example >}}
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+{{< clients-example py_home_json query1 >}}
+{{< /clients-example >}}
+
+Specify query options to return only the `city` field:
+
+{{< clients-example py_home_json query2 >}}
+{{< /clients-example >}}
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+{{< clients-example py_home_json query3 >}}
+{{< /clients-example >}}
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must use `HASH` for the `IndexType`
+when you create the index. The code below shows these changes with
+a new index called `hash-idx:users`, which is otherwise the same as
+the `idx:users` index used for JSON documents in the previous examples.
+
+{{< clients-example py_home_json make_hash_index >}}
+{{< /clients-example >}}
+
+You use [`hset()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`json().set()`]({{< relref "/commands/json.set" >}}),
+but the same flat `userX` dictionaries work equally well with either
+hash or JSON:
+
+{{< clients-example py_home_json add_hash_data >}}
+{{< /clients-example >}}
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The format of the result is
+almost the same except that the fields are returned directly in the
+result `Document` object instead of in an enclosing `json` dictionary:
+
+{{< clients-example py_home_json query1_hash >}}
+{{< /clients-example >}}
+
+## More information
+
+See the [Redis query engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Index and query embeddings with Redis vector sets
+linkTitle: Vector set embeddings
+title: Vector set embeddings
+weight: 40
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+bannerChildren: true
+---
+
+A Redis [vector set]({{< relref "/develop/data-types/vector-sets" >}}) 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]({{< relref "/develop/ai" >}}) to learn more about text
+embeddings). The example below shows how to use the
+[`sentence-transformers`](https://pypi.org/project/sentence-transformers/)
+library to generate vector embeddings and then
+store and retrieve them using a vector set with `redis-py`.
+
+## Initialize
+
+Start by installing the preview version of `redis-py` with the following
+command:
+
+```bash
+pip install redis==6.0.0b2
+```
+
+Also, install `sentence-transformers`:
+
+```bash
+pip install sentence-transformers
+```
+
+In a new Python file, import the required classes:
+
+```python
+from sentence_transformers import SentenceTransformer
+
+import redis
+import numpy as np
+```
+
+The first of these imports is the
+`SentenceTransformer` class, which generates an embedding from a section of text.
+This example uses an instance of `SentenceTransformer` with the
+[`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2)
+model for the embeddings. This model generates vectors with 384 dimensions, regardless
+of the length of the input text, but note that the input is truncated to 256
+tokens (see
+[Word piece tokenization](https://huggingface.co/learn/nlp-course/en/chapter6/6)
+at the [Hugging Face](https://huggingface.co/) docs to learn more about the way tokens
+are related to the original text).
+
+```python
+model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+```
+
+## Create the data
+
+The example data is contained a dictionary with some brief
+descriptions of famous people:
+
+```python
+peopleData = {
+    "Marie Curie": {
+        "born": 1867, "died": 1934,
+        "description": """
+        Polish-French chemist and physicist. The only person ever to win
+        two Nobel prizes for two different sciences.
+        """
+    },
+    "Linus Pauling": {
+        "born": 1901, "died": 1994,
+        "description": """
+        American chemist and peace activist. One of only two people to win two
+        Nobel prizes in different fields (chemistry and peace).
+        """
+    },
+    "Freddie Mercury": {
+        "born": 1946, "died": 1991,
+        "description": """
+        British musician, best known as the lead singer of the rock band
+        Queen.
+        """
+    },
+    "Marie Fredriksson": {
+        "born": 1958, "died": 2019,
+        "description": """
+        Swedish multi-instrumentalist, mainly known as the lead singer and
+        keyboardist of the band Roxette.
+        """
+    },
+    "Paul Erdos": {
+        "born": 1913, "died": 1996,
+        "description": """
+        Hungarian mathematician, known for his eccentric personality almost
+        as much as his contributions to many different fields of mathematics.
+        """
+    },
+    "Maryam Mirzakhani": {
+        "born": 1977, "died": 2017,
+        "description": """
+        Iranian mathematician. The first woman ever to win the Fields medal
+        for her contributions to mathematics.
+        """
+    },
+    "Masako Natsume": {
+        "born": 1957, "died": 1985,
+        "description": """
+        Japanese actress. She was very famous in Japan but was primarily
+        known elsewhere in the world for her portrayal of Tripitaka in the
+        TV series Monkey.
+        """
+    },
+    "Chaim Topol": {
+        "born": 1935, "died": 2023,
+        "description": """
+        Israeli actor and singer, usually credited simply as 'Topol'. He was
+        best known for his many appearances as Tevye in the musical Fiddler
+        on the Roof.
+        """
+    }
+}
+```
+
+## Add the data to a vector set
+
+The next step is to connect to Redis and add the data to a new vector set.
+
+The code below uses the dictionary's
+[`items()`](https://docs.python.org/3/library/stdtypes.html#dict.items)
+view to iterate through all the key-value pairs and add corresponding
+elements to a vector set called `famousPeople`.
+
+Use the
+[`encode()`](https://sbert.net/docs/package_reference/sentence_transformer/SentenceTransformer.html#sentence_transformers.SentenceTransformer.encode)
+method of `SentenceTransformer` to generate the
+embedding as an array of `float32` values. The `tobytes()` method converts
+the array to a byte string that you can pass to the
+[`vadd()`]({{< relref "/commands/vadd" >}}) command to set the embedding.
+Note that `vadd()` can also accept a list of `float` values to set the
+vector, but the byte string format is more compact and saves a little
+transmission time. If you later use
+[`vemb()`]({{< relref "/commands/vemb" >}}) to retrieve the embedding,
+it will return the vector as an array rather than the original byte
+string (note that this is different from the behavior of byte strings in
+[hash vector indexing]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}})).
+
+The call to `vadd()` also adds the `born` and `died` values from the
+original dictionary as attribute data. You can access this during a query
+or by using the [`vgetattr()`]({{< relref "/commands/vgetattr" >}}) method.
+
+```py
+r = redis.Redis(decode_responses=True)
+
+for name, details in peopleData.items():
+    emb = model.encode(details["description"]).astype(np.float32).tobytes()
+
+    r.vset().vadd(
+        "famousPeople",
+        emb,
+        name,
+        attributes={
+            "born": details["born"],
+            "died": details["died"]
+        }
+    )
+```
+
+## Query the vector set
+
+You can now query the data in the set. The basic approach is to use the
+`encode()` method to generate another embedding vector for the query text.
+(This is the same method used to add the elements to the set.) Then, pass
+the query vector to [`vsim()`]({{< relref "/commands/vsim" >}}) to return elements
+of the set, ranked in order of similarity to the query.
+
+Start with a simple query for "actors":
+
+```py
+query_value = "actors"
+
+actors_results = r.vset().vsim(
+    "famousPeople",
+    model.encode(query_value).astype(np.float32).tobytes(),
+)
+
+print(f"'actors': {actors_results}")
+```
+
+This returns the following list of elements (formatted slightly for clarity):
+
+```
+'actors': ['Masako Natsume', 'Chaim Topol', 'Linus Pauling',
+'Marie Fredriksson', 'Maryam Mirzakhani', 'Marie Curie',
+'Freddie Mercury', 'Paul Erdos']
+```
+
+The first two people in the list are the two actors, as expected, but none of the
+people from Linus Pauling onward was especially well-known for acting (and there certainly
+isn't any information about that in the short description text).
+As it stands, the search attempts to rank all the elements in the set, based
+on the information contained in the embedding model.
+You can use the `count` parameter of `vsim()` to limit the list of elements
+to just the most relevant few items:
+
+```py
+query_value = "actors"
+
+two_actors_results = r.vset().vsim(
+    "famousPeople",
+    model.encode(query_value).astype(np.float32).tobytes(),
+    count=2
+)
+
+print(f"'actors (2)': {two_actors_results}")
+# >>> 'actors (2)': ['Masako Natsume', 'Chaim Topol']
+```
+
+The reason for using text embeddings rather than simple text search
+is that the embeddings represent semantic information. This allows a query
+to find elements with a similar meaning even if the text is
+different. For example, the word "entertainer" doesn't appear in any of the
+descriptions but if you use it as a query, the actors and musicians are ranked
+highest in the results list:
+
+```py
+query_value = "entertainer"
+
+entertainer_results = r.vset().vsim(
+    "famousPeople",
+    model.encode(query_value).astype(np.float32).tobytes()
+)
+
+print(f"'entertainer': {entertainer_results}")
+# >>> 'entertainer': ['Chaim Topol', 'Freddie Mercury',
+# >>> 'Marie Fredriksson', 'Masako Natsume', 'Linus Pauling',
+# 'Paul Erdos', 'Maryam Mirzakhani', 'Marie Curie']
+```
+
+Similarly, if you use "science" as a query, you get the following results:
+
+```
+'science': ['Marie Curie', 'Linus Pauling', 'Maryam Mirzakhani',
+'Paul Erdos', 'Marie Fredriksson', 'Freddie Mercury', 'Masako Natsume',
+'Chaim Topol']
+```
+
+The scientists are ranked highest but they are then followed by the
+mathematicians. This seems reasonable given the connection between mathematics
+and science.
+
+You can also use
+[filter expressions]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+with `vsim()` to restrict the search further. For example,
+repeat the "science" query, but this time limit the results to people
+who died before the year 2000:
+
+```py
+query_value = "science"
+
+science2000_results = r.vset().vsim(
+    "famousPeople",
+    model.encode(query_value).astype(np.float32).tobytes(),
+    filter=".died < 2000"
+)
+
+print(f"'science2000': {science2000_results}")
+# >>> 'science2000': ['Marie Curie', 'Linus Pauling',
+# 'Paul Erdos', 'Freddie Mercury', 'Masako Natsume']
+```
+
+Note that the boolean filter expression is applied to items in the list
+before the vector distance calculation is performed. Items that don't
+pass the filter test are removed from the results completely, rather
+than just reduced in rank. This can help to improve the performance of the
+search because there is no need to calculate the vector distance for
+elements that have already been filtered out of the search.
+
+## More information
+
+See the [vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+docs for more information and code examples. See the
+[Redis for AI]({{< relref "/develop/ai" >}}) section for more details
+about text embeddings and other AI techniques you can use with Redis.
+
+You may also be interested in
+[vector search]({{< relref "/develop/clients/redis-py/vecsearch" >}}).
+This is a feature of the
+[Redis query engine]({{< relref "/develop/interact/search-and-query" >}})
+that lets you retrieve
+[JSON]({{< relref "/develop/data-types/json" >}}) and
+[hash]({{< relref "/develop/data-types/hashes" >}}) documents based on
+vector data stored in their fields.
+---
+aliases: /develop/connect/clients/python/redis-py
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Python application to a Redis database
+linkTitle: redis-py (Python)
+title: redis-py guide (Python)
+weight: 1
+---
+
+[redis-py](https://github.com/redis/redis-py) is the Python client for Redis. 
+The sections below explain how to install `redis-py` and connect your application
+to a Redis database.
+
+`redis-py` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+You can also access Redis with an object-mapping client interface. See
+[RedisOM for Python]({{< relref "/integrate/redisom-for-python" >}})
+for more information.
+
+## Install
+
+To install `redis-py`, enter:
+
+```bash
+pip install redis
+```
+
+For faster performance, install Redis with [`hiredis`](https://github.com/redis/hiredis) support. This provides a compiled response parser, and for most cases requires zero code changes. By default, if `hiredis` >= 1.0 is available, `redis-py` attempts to use it for response parsing.
+
+{{% alert title="Note" %}}
+The Python `distutils` packaging scheme is no longer part of Python 3.12 and greater. If you're having difficulties getting `redis-py` installed in a Python 3.12 environment, consider updating to a recent release of `redis-py`.
+{{% /alert %}}
+
+```bash
+pip install redis[hiredis]
+```
+
+## Connect and test
+
+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](https://redis.readthedocs.io/en/stable/examples.html).
+
+```python
+r = redis.Redis(host='localhost', port=6379, decode_responses=True)
+```
+
+Store and retrieve a simple string.
+
+```python
+r.set('foo', 'bar')
+# True
+r.get('foo')
+# bar
+```
+
+Store and retrieve a dict.
+
+```python
+r.hset('user-session:123', mapping={
+    'name': 'John',
+    "surname": 'Smith',
+    "company": 'Redis',
+    "age": 29
+})
+# True
+
+r.hgetall('user-session:123')
+# {'surname': 'Smith', 'name': 'John', 'company': 'Redis', 'age': '29'}
+```
+
+
+
+## More information
+
+The [`redis-py`](https://redis.readthedocs.io/en/stable/index.html) website
+has a [command reference](https://redis.readthedocs.io/en/stable/commands.html)
+and some [tutorials](https://redis.readthedocs.io/en/stable/examples.html) for
+various tasks. There are also some examples in the
+[GitHub repository](https://github.com/redis/redis-py) for `redis-py`.
+ 
+See also the other pages in this section for more information and examples:---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get your `redis-py` app ready for production
+linkTitle: Production usage
+title: Production usage
+weight: 70
+---
+
+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.
+
+{{< checklist "pyprodlist" >}}
+    {{< checklist-item "#client-side-caching" >}}Client-side caching{{< /checklist-item >}}
+    {{< checklist-item "#retries" >}}Retries{{< /checklist-item >}}
+    {{< checklist-item "#health-checks" >}}Health checks{{< /checklist-item >}}
+    {{< checklist-item "#exception-handling" >}}Exception handling{{< /checklist-item >}}
+{{< /checklist >}}
+
+## Recommendations
+
+The sections below offer recommendations for your production environment. Some
+of them may not apply to your particular use case.
+
+### Client-side caching
+
+[Client-side caching]({{< relref "/develop/clients/client-side-caching" >}})
+involves storing the results from read-only commands in a local cache. If the
+same command is executed again later, the results can be obtained from the cache,
+without contacting the server. This improves command execution time on the client,
+while also reducing network traffic and server load. See
+[Connect using client-side caching]({{< relref "/develop/clients/redis-py/connect#connect-using-client-side-caching" >}})
+for more information and example code.
+
+### Retries
+
+Redis connections and commands can often fail due to transient problems,
+such as temporary network outages or timeouts. When this happens,
+the operation will generally succeed after a few attempts, despite
+failing the first time.
+
+`redis-py` can retry commands automatically when
+errors occur. From version 6.0.0 onwards, the default behavior is to
+attempt a failed command three times.
+The timing between successive attempts is calculated using
+[exponential backoff](https://en.wikipedia.org/wiki/Exponential_backoff)
+with some random "jitter" added to avoid two or more connections retrying
+commands in sync with each other.
+
+You can override the default behavior using an instance of the `Retry` class to
+specify the number of times to retry after a failure along with your
+own choice of backoff strategy.
+Pass the `Retry` object in the `retry` parameter when you connect.
+For example, the connection in the code below uses an exponential backoff strategy
+(without jitter) that will make eight repeated attempts after a failure:
+
+```py
+from redis.backoff import ExponentialBackoff
+from redis.retry import Retry
+
+# Run 8 retries with exponential backoff strategy.
+retry = Retry(ExponentialBackoff(), 8)
+
+r = Redis(
+  retry=retry,
+    .
+    .
+)
+```
+
+A retry is triggered when a command throws any exception
+listed in the `supported_errors` attribute of the `Retry` class.
+By default, the list only includes `ConnectionError` and `TimeoutError`,
+but you can set your own choice of exceptions when you create the
+instance:
+
+```py
+# Only retry after a `TimeoutError`.
+retry = Retry(ExponentialBackoff(), 3, supported_errors=(TimeoutError,))
+```
+
+You can also add extra exceptions to the default list using the `retry_on_error`
+parameter when you connect:
+
+```py
+# Add `BusyLoadingError` to the default list of exceptions.
+from redis.exceptions import (
+   BusyLoadingError,
+)
+    .
+    .
+
+r = Redis(
+  retry=retry,
+  retry_on_error=[BusyLoadingError],
+    .
+    .
+)
+```
+
+For a connection to a Redis cluster, you can specify a `retry` instance,
+but the list of exceptions is not configurable and is always set
+to `TimeoutError`, `ConnectionError`, and `ClusterDownError`.
+
+### Health checks
+
+If your code doesn't access the Redis server continuously then it
+might be useful to make a "health check" periodically (perhaps once
+every few seconds) to verify that the connection is working.
+Set the `health_check_interval` parameter during
+a connection (with either `Redis` or `ConnectionPool`) to specify
+an integer number of seconds. If the connection remains idle for
+longer than this interval, it will automatically issue a
+[`PING`]({{< relref "/commands/ping" >}}) command and check the
+response before continuing with any client commands.
+
+```py
+# Issue a health check if the connection is idle for longer
+# than three seconds.
+r = Redis(
+  health_check_interval = 3,
+    .
+    .
+)
+```
+
+Health checks help to detect problems as soon as possible without
+waiting for a user to report them. Note that health checks, like
+other commands, will be [retried](#retries) using the strategy
+that you specified for the connection.
+
+### Exception handling
+
+Redis handles many errors using return values from commands, but there
+are also situations where exceptions can be thrown. In production code,
+you should handle exceptions wherever they can occur. 
+
+Import the exceptions you need to check from the `redis.exceptions`
+module. The list below describes some of the most common exceptions.
+
+- `ConnectionError`: Thrown when a connection attempt fails
+  (for example, when connection parameters are invalid or the server
+  is unavailable) and sometimes when a [health check](#health-checks)
+  fails. There is also a subclass, `AuthenticationError`, specifically
+  for authentication failures.
+- `ResponseError`: Thrown when you attempt an operation that has no valid
+  response. Examples include executing a command on the wrong type of key
+  (as when you try an
+  ['LPUSH']({{< relref "/develop/data-types/lists#automatic-creation-and-removal-of-keys" >}})
+  command on a string key), creating an
+  [index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+  with a name that already exists, and using an invalid ID for a
+  [stream entry]({{< relref "/develop/data-types/streams/#entry-ids" >}}).
+- `TimeoutError`: Thrown when a timeout persistently happens for a command,
+  despite any [retries](#retries).
+- `WatchError`: Thrown when a
+  [watched key]({{< relref "/develop/clients/redis-py/transpipe#watch-keys-for-changes" >}}) is
+  modified during a transaction.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use Redis pipelines and transactions
+linkTitle: Pipelines/transactions
+title: Pipelines and transactions
+weight: 5
+---
+
+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]({{< relref "/develop/use/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]({{< relref "/develop/interact/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.
+
+The main difference with the pipeline commands is that they return
+`Response<Type>` objects, where `Type` is the return type of the
+standard command method. A `Response` object contains a valid result
+only after the pipeline has finished executing. You can access the
+result using the `Response` object's `get()` method.
+
+{{< clients-example pipe_trans_tutorial basic_pipe Java-Sync >}}
+{{< /clients-example >}}
+
+## Execute a transaction
+
+A transaction works in a similar way to a pipeline. Create a
+transaction object with the `multi()` command, call command methods
+on that object, and then call the transaction object's 
+`exec()` method to execute it. You can access the results
+from commands in the transaction using `Response` objects, as
+you would with a pipeline. However, the `exec()` method also
+returns a `List<Object>` value that contains all the result
+values in the order the commands were executed (see
+[Watch keys for changes](#watch-keys-for-changes) below for
+an example that uses the results list).
+
+{{< clients-example pipe_trans_tutorial basic_trans Java-Sync >}}
+{{< /clients-example >}}
+
+## Watch keys for changes
+
+Redis supports *optimistic locking* to avoid inconsistent updates
+to different keys. The basic idea is to watch for changes to any
+keys that you use in a transaction while you are are processing the
+updates. If the watched keys do change, you must restart the updates
+with the latest data from the keys. See
+[Transactions]({{< relref "/develop/interact/transactions" >}})
+for more information about optimistic locking.
+
+The code below reads a string
+that represents a `PATH` variable for a command shell, then appends a new
+command path to the string before attempting to write it back. If the watched
+key is modified by another client before writing, the transaction aborts.
+Note that you should call read-only commands for the watched keys synchronously on
+the usual client object (called `jedis` in our examples) but you still call commands
+for the transaction on the transaction object.
+
+For production usage, you would generally call code like the following in
+a loop to retry it until it succeeds or else report or log the failure.
+
+{{< clients-example pipe_trans_tutorial trans_watch Java-Sync >}}
+{{< /clients-example >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to index and query vector embeddings with Redis
+linkTitle: Index and query vectors
+title: Index and query vectors
+weight: 3
+---
+
+[Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you index vector fields in [hash]({{< relref "/develop/data-types/hashes" >}})
+or [JSON]({{< relref "/develop/data-types/json" >}}) objects (see the
+[Vectors]({{< relref "/develop/interact/search-and-query/advanced-concepts/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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+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.
+
+In the example below, we use the [HuggingFace](https://huggingface.co/) model
+[`all-mpnet-base-v2`](https://huggingface.co/sentence-transformers/all-mpnet-base-v2)
+to generate the 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](#differences-with-json-documents).
+
+## Initialize
+
+If you are using [Maven](https://maven.apache.org/), add the following
+dependencies to your `pom.xml` file:
+
+```xml
+<dependency>
+    <groupId>redis.clients</groupId>
+    <artifactId>jedis</artifactId>
+    <version>5.2.0</version>
+</dependency>
+<dependency>
+    <groupId>ai.djl.huggingface</groupId>
+    <artifactId>tokenizers</artifactId>
+    <version>0.24.0</version>
+</dependency>
+```
+
+If you are using [Gradle](https://gradle.org/), add the following
+dependencies to your `build.gradle` file:
+
+```bash
+implementation 'redis.clients:jedis:5.2.0'
+implementation 'ai.djl.huggingface:tokenizers:0.24.0'
+```
+
+## Import dependencies
+
+Import the following classes in your source file:
+
+```java
+// Jedis client and query engine classes.
+import redis.clients.jedis.UnifiedJedis;
+import redis.clients.jedis.search.*;
+import redis.clients.jedis.search.schemafields.*;
+import redis.clients.jedis.search.schemafields.VectorField.VectorAlgorithm;
+import redis.clients.jedis.exceptions.JedisDataException;
+
+// Data manipulation.
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Map;
+import java.util.List;
+import org.json.JSONObject;
+
+// Tokenizer to generate the vector embeddings.
+import ai.djl.huggingface.tokenizers.HuggingFaceTokenizer;
+```
+
+## Define a helper method
+
+Our embedding model represents the vectors as an array of `long` integer values,
+but Redis Query Engine expects the vector components to be `float` values.
+Also, when you store vectors in a hash object, you must encode the vector
+array as a `byte` string. To simplify this situation, we declare a helper
+method `longsToFloatsByteString()` that takes the `long` array that the
+embedding model returns, converts it to an array of `float` values, and
+then encodes the `float` array as a `byte` string:
+
+```java
+public static byte[] longsToFloatsByteString(long[] input) {
+    float[] floats = new float[input.length];
+    for (int i = 0; i < input.length; i++) {
+        floats[i] = input[i];
+    }
+
+    byte[] bytes = new byte[Float.BYTES * floats.length];
+    ByteBuffer
+        .wrap(bytes)
+        .order(ByteOrder.LITTLE_ENDIAN)
+        .asFloatBuffer()
+        .put(floats);
+    return bytes;
+}
+```
+
+## Create a tokenizer instance
+
+We will use the
+[`all-mpnet-base-v2`](https://huggingface.co/sentence-transformers/all-mpnet-base-v2)
+tokenizer to generate the embeddings. The vectors that represent the
+embeddings have 768 components, regardless of the length of the input
+text.
+
+```java
+HuggingFaceTokenizer sentenceTokenizer = HuggingFaceTokenizer.newInstance(
+    "sentence-transformers/all-mpnet-base-v2",
+    Map.of("maxLength", "768",  "modelMaxLength", "768")
+);
+```
+
+## Create the index
+
+Connect to Redis and delete any index previously created with the
+name `vector_idx`. (The `ftDropIndex()` call throws an exception if
+the index doesn't already exist, which is why you need the
+`try...catch` block.)
+
+```java
+UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+
+try {jedis.ftDropIndex("vector_idx");} catch (JedisDataException j){}
+```
+
+Next, we create the index.
+The schema in the example below includes three fields: the text content to index, a
+[tag]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+field to represent the "genre" of the text, and the embedding vector generated from
+the original text content. The `embedding` field specifies
+[HNSW]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) 
+indexing, the
+[L2]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#distance-metrics" >}})
+vector distance metric, `Float32` values to represent the vector's components,
+and 768 dimensions, as required by the `all-mpnet-base-v2` embedding model.
+
+The `FTCreateParams` object specifies hash objects for storage and a
+prefix `doc:` that identifies the hash objects we want to index.
+
+```java
+SchemaField[] schema = {
+    TextField.of("content"),
+    TagField.of("genre"),
+    VectorField.builder()
+        .fieldName("embedding")
+        .algorithm(VectorAlgorithm.HNSW)
+        .attributes(
+            Map.of(
+                "TYPE", "FLOAT32",
+                "DIM", 768,
+                "DISTANCE_METRIC", "L2"
+            )
+        )
+        .build()
+};
+
+jedis.ftCreate("vector_idx",
+    FTCreateParams.createParams()
+        .addPrefix("doc:")
+        .on(IndexDataType.HASH),
+        schema
+);
+```
+
+## Add data
+
+You can now supply the data objects, which will be indexed automatically
+when you add them with [`hset()`]({{< relref "/commands/hset" >}}), as long as
+you use the `doc:` prefix specified in the index definition.
+
+Use the `encode()` method of the `sentenceTokenizer` object
+as shown below to create the embedding that represents the `content` field.
+The `getIds()` method that follows `encode()` obtains the vector
+of `long` values which we then convert to a `float` array stored as a `byte`
+string using our helper method. Use the `byte` string representation when you are
+indexing hash objects (as we are here), but use an array of `float` for
+JSON objects (see [Differences with JSON objects](#differences-with-json-documents)
+below). Note that when we set the `embedding` field, we must use an overload
+of `hset()` that requires `byte` arrays for each of the key, the field name, and
+the value, which is why we include the `getBytes()` calls on the strings.
+
+```java
+String sentence1 = "That is a very happy person";
+jedis.hset("doc:1", Map.of("content", sentence1, "genre", "persons"));
+jedis.hset(
+    "doc:1".getBytes(),
+    "embedding".getBytes(),
+    longsToFloatsByteString(sentenceTokenizer.encode(sentence1).getIds())
+);
+
+String sentence2 = "That is a happy dog";
+jedis.hset("doc:2", Map.of("content", sentence2, "genre", "pets"));
+jedis.hset(
+    "doc:2".getBytes(),
+    "embedding".getBytes(),
+    longsToFloatsByteString(sentenceTokenizer.encode(sentence2).getIds())
+);
+
+String sentence3 = "Today is a sunny day";
+jedis.hset("doc:3", Map.of("content", sentence3, "genre", "weather"));
+jedis.hset(
+    "doc:3".getBytes(),
+    "embedding".getBytes(),
+    longsToFloatsByteString(sentenceTokenizer.encode(sentence3).getIds())
+);
+```
+
+## Run a query
+
+After you have created the index and added the data, you are ready to run a query.
+To do this, you must create another embedding vector from your chosen query
+text. Redis calculates the vector distance between the query vector and each
+embedding vector in the index as it runs the query. We can request the results to be
+sorted to rank them in order of ascending distance.
+
+The code below creates the query embedding using the `encode()` method, as with
+the indexing, and passes it as a parameter when the query executes (see
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about using query parameters with embeddings).
+The query is a
+[K nearest neighbors (KNN)]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors#knn-vector-search" >}})
+search that sorts the results in order of vector distance from the query vector.
+
+```java
+String sentence = "That is a happy person";
+
+int K = 3;
+Query q = new Query("*=>[KNN $K @embedding $BLOB AS distance]")
+                .returnFields("content", "distance")
+                .addParam("K", K)
+                .addParam(
+                    "BLOB",
+                    longsToFloatsByteString(
+                        sentenceTokenizer.encode(sentence)..getIds()
+                    )
+                )
+                .setSortBy("distance", true)
+                .dialect(2);
+
+List<Document> docs = jedis.ftSearch("vector_idx", q).getDocuments();
+
+for (Document doc: docs) {
+    System.out.println(
+        String.format(
+            "ID: %s, Distance: %s, Content: %s",
+            doc.getId(),
+            doc.get("distance"),
+            doc.get("content")
+        )
+    );
+}
+```
+
+Assuming you have added the code from the steps above to your source file,
+it is now ready to run, but note that it may take a while to complete when
+you run it for the first time (which happens because the tokenizer must download the
+`all-mpnet-base-v2` model data before it can
+generate the embeddings). When you run the code, it outputs the following result text:
+
+```
+Results:
+ID: doc:2, Distance: 1411344, Content: That is a happy dog
+ID: doc:1, Distance: 9301635, Content: That is a very happy person
+ID: doc:3, Distance: 67178800, Content: Today is a sunny day
+```
+
+Note that the results are ordered according to the value of the `distance`
+field, with the lowest distance indicating the greatest similarity to the query.
+For this model, the text *"That is a happy dog"*
+is the result judged to be most similar in meaning to the query text
+*"That is a happy person"*.
+
+## Differences with JSON documents
+
+Indexing JSON documents is similar to hash indexing, but there are some
+important differences. JSON allows much richer data modeling with nested fields, so
+you must supply a [path]({{< relref "/develop/data-types/json/path" >}}) in the schema
+to identify each field you want to index. However, you can declare a short alias for each
+of these paths (using the `as()` option) to avoid typing it in full for
+every query. Also, you must specify `IndexDataType.JSON` when you create the index.
+
+The code below shows these differences, but the index is otherwise very similar to
+the one created previously for hashes:
+
+```java
+SchemaField[] jsonSchema = {
+    TextField.of("$.content").as("content"),
+    TagField.of("$.genre").as("genre"),
+    VectorField.builder()
+        .fieldName("$.embedding").as("embedding")
+        .algorithm(VectorAlgorithm.HNSW)
+        .attributes(
+            Map.of(
+                "TYPE", "FLOAT32",
+                "DIM", 768,
+                "DISTANCE_METRIC", "L2"
+            )
+        )
+        .build()
+};
+
+jedis.ftCreate("vector_json_idx",
+    FTCreateParams.createParams()
+        .addPrefix("jdoc:")
+        .on(IndexDataType.JSON),
+        jsonSchema
+);
+```
+
+An important difference with JSON indexing is that the vectors are
+specified using arrays of `float` instead of binary strings. This requires
+a modified version of the `longsToFloatsByteString()` method
+used previously:
+
+```java
+public static float[] longArrayToFloatArray(long[] input) {
+    float[] floats = new float[input.length];
+    for (int i = 0; i < input.length; i++) {
+        floats[i] = input[i];
+    }
+    return floats;
+}
+```
+
+Use [`jsonSet()`]({{< relref "/commands/json.set" >}}) to add the data
+instead of [`hset()`]({{< relref "/commands/hset" >}}). Use instances
+of `JSONObject` to supply the data instead of `Map`, as you would for
+hash objects.
+
+```java
+String jSentence1 = "That is a very happy person";
+
+JSONObject jdoc1 = new JSONObject()
+        .put("content", jSentence1)
+        .put("genre", "persons")
+        .put(
+            "embedding",
+            longArrayToFloatArray(
+                sentenceTokenizer.encode(jSentence1).getIds()
+            )
+        );
+
+jedis.jsonSet("jdoc:1", Path2.ROOT_PATH, jdoc1);
+
+String jSentence2 = "That is a happy dog";
+
+JSONObject jdoc2 = new JSONObject()
+        .put("content", jSentence2)
+        .put("genre", "pets")
+        .put(
+            "embedding",
+            longArrayToFloatArray(
+                sentenceTokenizer.encode(jSentence2).getIds()
+            )
+        );
+
+jedis.jsonSet("jdoc:2", Path2.ROOT_PATH, jdoc2);
+
+String jSentence3 = "Today is a sunny day";
+
+JSONObject jdoc3 = new JSONObject()
+        .put("content", jSentence3)
+        .put("genre", "weather")
+        .put(
+            "embedding",
+            longArrayToFloatArray(
+                sentenceTokenizer.encode(jSentence3).getIds()
+            )
+        );
+
+jedis.jsonSet("jdoc:3", Path2.ROOT_PATH, jdoc3);
+```
+
+The query is almost identical to the one for the hash documents. This
+demonstrates how the right choice of aliases for the JSON paths can
+save you having to write complex queries. An important thing to notice
+is that the vector parameter for the query is still specified as a
+binary string (using the `longsToFloatsByteString()` method), even though
+the data for the `embedding` field of the JSON was specified as an array.
+
+```java
+String jSentence = "That is a happy person";
+
+int jK = 3;
+Query jq = new Query("*=>[KNN $K @embedding $BLOB AS distance]").
+                    returnFields("content", "distance").
+                    addParam("K", jK).
+                    addParam(
+                        "BLOB",
+                        longsToFloatsByteString(
+                            sentenceTokenizer.encode(jSentence).getIds()
+                        )
+                    )
+                    .setSortBy("distance", true)
+                    .dialect(2);
+
+// Execute the query
+List<Document> jDocs = jedis
+        .ftSearch("vector_json_idx", jq)
+        .getDocuments();
+
+```
+
+Apart from the `jdoc:` prefixes for the keys, the result from the JSON
+query is the same as for hash:
+
+```
+Results:
+ID: jdoc:2, Distance: 1411344, Content: That is a happy dog
+ID: jdoc:1, Distance: 9301635, Content: That is a very happy person
+ID: jdoc:3, Distance: 67178800, Content: Today is a sunny day
+```
+
+## Learn more
+
+See
+[Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+for more information about the indexing options, distance metrics, and query format
+for vectors.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Java application to a Redis database
+linkTitle: Connect
+title: Connect to the server
+weight: 2
+---
+
+## Basic connection
+
+The following code opens a basic connection to a local Redis server:
+
+```java
+package org.example;
+import redis.clients.jedis.UnifiedJedis;
+
+public class Main {
+    public static void main(String[] args) {
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+
+        // Code that interacts with Redis...
+
+        jedis.close();
+    }
+}
+```
+
+After you have connected, you can check the connection by storing and
+retrieving a simple string value:
+
+```java
+...
+
+String res1 = jedis.set("bike:1", "Deimos");
+System.out.println(res1); // OK
+
+String res2 = jedis.get("bike:1");
+System.out.println(res2); // Deimos
+
+...
+```
+
+### Connect to a Redis cluster
+
+To connect to a Redis cluster, use `JedisCluster`. 
+
+```java
+import redis.clients.jedis.JedisCluster;
+import redis.clients.jedis.HostAndPort;
+
+//...
+
+Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
+jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7379));
+jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7380));
+JedisCluster jedis = new JedisCluster(jedisClusterNodes);
+```
+
+### Connect to your production Redis with TLS
+
+When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines.
+
+Before connecting your application to the TLS-enabled Redis server, ensure that your certificates and private keys are in the correct format.
+
+To convert user certificate and private key from the PEM format to `pkcs12`, use this command:
+
+```
+openssl pkcs12 -export -in ./redis_user.crt -inkey ./redis_user_private.key -out redis-user-keystore.p12 -name "redis"
+```
+
+Enter password to protect your `pkcs12` file.
+
+Convert the server (CA) certificate to the JKS format using the [keytool](https://docs.oracle.com/en/java/javase/12/tools/keytool.html) shipped with JDK.
+
+```
+keytool -importcert -keystore truststore.jks \ 
+  -storepass REPLACE_WITH_YOUR_PASSWORD \
+  -file redis_ca.pem
+```
+
+Establish a secure connection with your Redis database using this snippet.
+
+```java
+package org.example;
+
+import redis.clients.jedis.*;
+
+import javax.net.ssl.*;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+
+public class Main {
+
+    public static void main(String[] args) throws GeneralSecurityException, IOException {
+        HostAndPort address = new HostAndPort("my-redis-instance.cloud.redislabs.com", 6379);
+
+        SSLSocketFactory sslFactory = createSslSocketFactory(
+                "./truststore.jks",
+                "secret!", // use the password you specified for keytool command
+                "./redis-user-keystore.p12",
+                "secret!" // use the password you specified for openssl command
+        );
+
+        JedisClientConfig config = DefaultJedisClientConfig.builder()
+                .ssl(true).sslSocketFactory(sslFactory)
+                .user("default") // use your Redis user. More info https://redis.io/docs/latest/operate/oss_and_stack/management/security/acl/
+                .password("secret!") // use your Redis password
+                .build();
+
+        JedisPooled jedis = new JedisPooled(address, config);
+        jedis.set("foo", "bar");
+        System.out.println(jedis.get("foo")); // prints bar
+    }
+
+    private static SSLSocketFactory createSslSocketFactory(
+            String caCertPath, String caCertPassword, String userCertPath, String userCertPassword)
+            throws IOException, GeneralSecurityException {
+
+        KeyStore keyStore = KeyStore.getInstance("pkcs12");
+        keyStore.load(new FileInputStream(userCertPath), userCertPassword.toCharArray());
+
+        KeyStore trustStore = KeyStore.getInstance("jks");
+        trustStore.load(new FileInputStream(caCertPath), caCertPassword.toCharArray());
+
+        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("X509");
+        trustManagerFactory.init(trustStore);
+
+        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX");
+        keyManagerFactory.init(keyStore, userCertPassword.toCharArray());
+
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
+
+        return sslContext.getSocketFactory();
+    }
+}
+```
+
+## Connect using client-side caching
+
+Client-side caching is a technique to reduce network traffic between
+the client and server, resulting in better performance. See
+[Client-side caching introduction]({{< relref "/develop/clients/client-side-caching" >}})
+for more information about how client-side caching works and how to use it effectively.
+
+To enable client-side caching, specify the
+[RESP3]({{< relref "/develop/reference/protocol-spec#resp-versions" >}})
+protocol and pass a cache configuration object during the connection.
+
+The example below shows the simplest client-side caching connection to the default host and port,
+`localhost:6379`.
+All of the connection variants described above accept these parameters, so you can
+use client-side caching with a connection pool or a cluster connection in exactly the same way.
+
+{{< note >}}Client-side caching requires Jedis v5.2.0 or later.
+To maximize compatibility with all Redis products, client-side caching
+is supported by Redis v7.4 or later.
+
+The [Redis server products]({{< relref "/operate" >}}) support
+[opt-in/opt-out]({{< relref "/develop/reference/client-side-caching#opt-in-and-opt-out-caching" >}}) mode
+and [broadcasting mode]({{< relref "/develop/reference/client-side-caching#broadcasting-mode" >}})
+for CSC, but these modes are not currently implemented by Jedis.
+{{< /note >}}
+
+```java
+HostAndPort endpoint = new HostAndPort("localhost", 6379);
+
+DefaultJedisClientConfig config = DefaultJedisClientConfig
+    .builder()
+    .password("secretPassword")
+    .protocol(RedisProtocol.RESP3)
+    .build();
+
+CacheConfig cacheConfig = CacheConfig.builder().maxSize(1000).build();
+
+UnifiedJedis client = new UnifiedJedis(endpoint, config, cacheConfig);
+```
+
+Once you have connected, the usual Redis commands will work transparently
+with the cache:
+
+```java
+client.set("city", "New York");
+client.get("city");     // Retrieved from Redis server and cached
+client.get("city");     // Retrieved from cache
+```
+
+You can see the cache working if you connect to the same Redis database
+with [`redis-cli`]({{< relref "/develop/tools/cli" >}}) and run the
+[`MONITOR`]({{< relref "/commands/monitor" >}}) command. If you run the
+code above but without passing `cacheConfig` during the connection,
+you should see the following in the CLI among the output from `MONITOR`:
+
+```
+1723109720.268903 [...] "SET" "city" "New York"
+1723109720.269681 [...] "GET" "city"
+1723109720.270205 [...] "GET" "city"
+```
+
+The server responds to both `get("city")` calls.
+If you run the code with `cacheConfig` added in again, you will see
+
+```
+1723110248.712663 [...] "SET" "city" "New York"
+1723110248.713607 [...] "GET" "city"
+```
+
+The first `get("city")` call contacted the server, but the second
+call was satisfied by the cache.
+
+### Removing items from the cache
+
+You can remove individual keys from the cache with the
+`deleteByRedisKey()` method of the cache object. This removes all cached items associated
+with each specified key, so all results from multi-key commands (such as
+[`MGET`]({{< relref "/commands/mget" >}})) and composite data structures
+(such as [hashes]({{< relref "/develop/data-types/hashes" >}})) will be
+cleared at once. The example below shows the effect of removing a single
+key from the cache:
+
+```java
+client.hget("person:1", "name");    // Read from the server
+client.hget("person:1", "name");    // Read from the cache
+
+client.hget("person:2", "name");    // Read from the server
+client.hget("person:2", "name");    // Read from the cache
+
+Cache myCache = client.getCache();
+myCache.deleteByRedisKey("person:1");
+
+client.hget("person:1", "name");    // Read from the server
+client.hget("person:1", "name");    // Read from the cache
+
+client.hget("person:2", "name");    // Still read from the cache
+```
+
+You can also clear all cached items using the `flush()`
+method:
+
+```java
+client.hget("person:1", "name");    // Read from the server
+client.hget("person:1", "name");    // Read from the cache
+
+client.hget("person:2", "name");    // Read from the server
+client.hget("person:2", "name");    // Read from the cache
+
+Cache myCache = client.getCache();
+myCache.flush();
+
+client.hget("person:1", "name");    // Read from the server
+client.hget("person:1", "name");    // Read from the cache
+
+client.hget("person:2", "name");    // Read from the server
+client.hget("person:2", "name");    // Read from the cache
+```
+
+The client will also flush the cache automatically
+if any connection (including one from a connection pool)
+is disconnected.
+
+## Connect with a connection pool
+
+For production usage, you should use a connection pool to manage
+connections rather than opening and closing connections individually.
+A connection pool maintains several open connections and reuses them
+efficiently. When you open a connection from a pool, the pool allocates
+one of its open connections. When you subsequently close the same connection,
+it is not actually closed but simply returned to the pool for reuse.
+This avoids the overhead of repeated connecting and disconnecting.
+See
+[Connection pools and multiplexing]({{< relref "/develop/clients/pools-and-muxing" >}})
+for more information.
+
+Use the following code to connect with a connection pool:
+
+```java
+package org.example;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+
+public class Main {
+    public static void main(String[] args) {
+        JedisPool pool = new JedisPool("localhost", 6379);
+
+        try (Jedis jedis = pool.getResource()) {
+            // Store & Retrieve a simple string
+            jedis.set("foo", "bar");
+            System.out.println(jedis.get("foo")); // prints bar
+            
+            // Store & Retrieve a HashMap
+            Map<String, String> hash = new HashMap<>();;
+            hash.put("name", "John");
+            hash.put("surname", "Smith");
+            hash.put("company", "Redis");
+            hash.put("age", "29");
+            jedis.hset("user-session:123", hash);
+            System.out.println(jedis.hgetAll("user-session:123"));
+            // Prints: {name=John, surname=Smith, company=Redis, age=29}
+        }
+    }
+}
+```
+
+Because adding a `try-with-resources` block for each command can be cumbersome, consider using `JedisPooled` as an easier way to pool connections. `JedisPooled`, added in Jedis version 4.0.0, provides capabilities similar to `JedisPool` but with a more straightforward API.
+
+```java
+import redis.clients.jedis.JedisPooled;
+
+//...
+
+JedisPooled jedis = new JedisPooled("localhost", 6379);
+jedis.set("foo", "bar");
+System.out.println(jedis.get("foo")); // prints "bar"
+```
+
+A connection pool holds a specified number of connections, creates more connections when necessary, and terminates them when they are no longer needed.
+
+Here is a simplified connection lifecycle in a pool:
+
+1. A connection is requested from the pool.
+2. A connection is served:
+   - An idle connection is served when non-active connections are available, or 
+   - A new connection is created when the number of connections is under `maxTotal`. 
+3. The connection becomes active.
+4. The connection is released back to the pool.
+5. The connection is marked as stale. 
+6. The connection is kept idle for `minEvictableIdleTime`. 
+7. The connection becomes evictable if the number of connections is greater than `minIdle`. 
+8. The connection is ready to be closed.
+
+It's important to configure the connection pool correctly. 
+Use `GenericObjectPoolConfig` from [Apache Commons Pool2](https://commons.apache.org/proper/commons-pool/apidocs/org/apache/commons/pool2/impl/GenericObjectPoolConfig.html).
+
+```java
+ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
+// maximum active connections in the pool,
+// tune this according to your needs and application type
+// default is 8
+poolConfig.setMaxTotal(8);
+
+// maximum idle connections in the pool, default is 8
+poolConfig.setMaxIdle(8);
+// minimum idle connections in the pool, default 0
+poolConfig.setMinIdle(0);
+
+// Enables waiting for a connection to become available.
+poolConfig.setBlockWhenExhausted(true);
+// The maximum number of seconds to wait for a connection to become available
+poolConfig.setMaxWait(Duration.ofSeconds(1));
+
+// Enables sending a PING command periodically while the connection is idle.
+poolConfig.setTestWhileIdle(true);
+// controls the period between checks for idle connections in the pool
+poolConfig.setTimeBetweenEvictionRuns(Duration.ofSeconds(1));
+
+// JedisPooled does all hard work on fetching and releasing connection to the pool
+// to prevent connection starvation
+JedisPooled jedis = new JedisPooled(poolConfig, "localhost", 6379);
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the Redis query engine with JSON and hash documents.
+linkTitle: Index and query documents
+title: Index and query documents
+weight: 2
+---
+
+This example shows how to create a
+[search index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+for [JSON]({{< relref "/develop/data-types/json" >}}) documents and
+run queries against the index. It then goes on to show the slight differences
+in the equivalent code for [hash]({{< relref "/develop/data-types/hashes" >}})
+documents.
+
+## Initialize
+
+Make sure that you have [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}})
+or another Redis server available. Also install the
+[Jedis]({{< relref "/develop/clients/jedis" >}}) client library if you
+haven't already done so.
+
+Add the following dependencies. All of them are applicable to both JSON and hash,
+except for the `Path` and `JSONObject` classes, which are specific to JSON (see
+[Path]({{< relref "/develop/data-types/json/path" >}}) for a description of the
+JSON path syntax).
+
+{{< clients-example java_home_json import >}}
+{{< /clients-example >}}
+
+## Create data
+
+Create some test data to add to the database:
+
+{{< clients-example java_home_json create_data >}}
+{{< /clients-example >}}
+
+## Add the index
+
+Connect to your Redis database. The code below shows the most
+basic connection but see
+[Connect to the server]({{< relref "/develop/clients/jedis/connect" >}})
+to learn more about the available connection options.
+
+{{< clients-example java_home_json connect >}}
+{{< /clients-example >}}
+
+Create an index. In this example, only JSON documents with the key prefix `user:` are indexed. For more information, see [Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}).
+
+{{< clients-example java_home_json make_index >}}
+{{< /clients-example >}}
+
+## Add the data
+
+Add the three sets of user data to the database as
+[JSON]({{< relref "/develop/data-types/json" >}}) objects.
+If you use keys with the `user:` prefix then Redis will index the
+objects automatically as you add them:
+
+{{< clients-example java_home_json add_data >}}
+{{< /clients-example >}}
+
+## Query the data
+
+You can now use the index to search the JSON objects. The
+[query]({{< relref "/develop/interact/search-and-query/query" >}})
+below searches for objects that have the text "Paul" in any field
+and have an `age` value in the range 30 to 40:
+
+{{< clients-example java_home_json query1 >}}
+{{< /clients-example >}}
+
+Specify query options to return only the `city` field:
+
+{{< clients-example java_home_json query2 >}}
+{{< /clients-example >}}
+
+Use an
+[aggregation query]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})
+to count all users in each city.
+
+{{< clients-example java_home_json query3 >}}
+{{< /clients-example >}}
+
+## Differences with hash documents
+
+Indexing for hash documents is very similar to JSON indexing but you
+need to specify some slightly different options.
+
+When you create the schema for a hash index, you don't need to
+add aliases for the fields, since you use the basic names to access
+the fields anyway. Also, you must use `IndexDataType.HASH` for the `On()`
+option of `FTCreateParams` when you create the index. The code below shows these
+changes with a new index called `hash-idx:users`, which is otherwise the same as
+the `idx:users` index used for JSON documents in the previous examples.
+
+{{< clients-example java_home_json make_hash_index >}}
+{{< /clients-example >}}
+
+Use [`hset()`]({{< relref "/commands/hset" >}}) to add the hash
+documents instead of [`jsonSet()`]({{< relref "/commands/json.set" >}}).
+
+{{< clients-example java_home_json add_hash_data >}}
+{{< /clients-example >}}
+
+The query commands work the same here for hash as they do for JSON (but
+the name of the hash index is different). The results are returned in 
+a `List` of `Document` objects, as with JSON:
+
+{{< clients-example java_home_json query1_hash >}}
+{{< /clients-example >}}
+
+## More information
+
+See the [Redis query engine]({{< relref "/develop/interact/search-and-query" >}}) docs
+for a full description of all query features with examples.
+---
+aliases: /develop/connect/clients/java/jedis
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Java application to a Redis database
+linkTitle: Jedis (Java)
+title: Jedis guide (Java)
+weight: 5
+---
+
+[Jedis](https://github.com/redis/jedis) is a synchronous Java client for Redis.
+Use [Lettuce]({{< relref "/develop/clients/lettuce" >}}) if you need
+a more advanced Java client that also supports asynchronous and reactive connections.
+The sections below explain how to install `Jedis` and connect your application
+to a Redis database.
+
+`Jedis` requires a running Redis server. See [here]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis Open Source installation instructions.
+
+## Install
+
+To include `Jedis` as a dependency in your application, edit the dependency file, as follows.
+
+* If you use **Maven**:   
+
+  ```xml
+  <dependency>
+      <groupId>redis.clients</groupId>
+      <artifactId>jedis</artifactId>
+      <version>5.2.0</version>
+  </dependency>
+  ```
+
+* If you use **Gradle**: 
+
+  ```
+  repositories {
+      mavenCentral()
+  }
+  //...
+  dependencies {
+      implementation 'redis.clients:jedis:5.2.0'
+      //...
+  }
+  ```
+
+* If you use the JAR files, download the latest Jedis and Apache Commons Pool2 JAR files from [Maven Central](https://central.sonatype.com/) or any other Maven repository.
+
+* Build from [source](https://github.com/redis/jedis)
+
+
+## Connect and test
+
+The following code opens a basic connection to a local Redis server:
+
+```java
+package org.example;
+import redis.clients.jedis.UnifiedJedis;
+
+public class Main {
+    public static void main(String[] args) {
+        UnifiedJedis jedis = new UnifiedJedis("redis://localhost:6379");
+
+        // Code that interacts with Redis...
+
+        jedis.close();
+    }
+}
+```
+
+After you have connected, you can check the connection by storing and
+retrieving a simple string value:
+
+```java
+...
+
+String res1 = jedis.set("bike:1", "Deimos");
+System.out.println(res1); // OK
+
+String res2 = jedis.get("bike:1");
+System.out.println(res2); // Deimos
+
+...
+```
+
+## More information
+
+`Jedis` has a complete [API reference](https://www.javadoc.io/doc/redis.clients/jedis/latest/index.html) available on [javadoc.io/](https://javadoc.io/).
+The `Jedis` [GitHub repository](https://github.com/redis/jedis) also has useful docs
+and examples including a page about handling
+[failover with Jedis](https://github.com/redis/jedis/blob/master/docs/failover.md)
+
+See also the other pages in this section for more information and examples:
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get your Jedis app ready for production
+linkTitle: Production usage
+title: Production usage
+weight: 6
+---
+
+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.
+
+{{< checklist "prodlist" >}}
+    {{< checklist-item "#connection-pooling" >}}Connection pooling{{< /checklist-item >}}
+    {{< checklist-item "#client-side-caching" >}}Client-side caching{{< /checklist-item >}}
+    {{< checklist-item "#timeouts" >}}Timeouts{{< /checklist-item >}}
+    {{< checklist-item "#health-checks" >}}Health checks{{< /checklist-item >}}
+    {{< checklist-item "#exception-handling" >}}Exception handling{{< /checklist-item >}}
+    {{< checklist-item "#dns-cache-and-redis" >}}DNS cache and Redis{{< /checklist-item >}}
+{{< /checklist >}}
+
+## Recommendations
+
+The sections below offer recommendations for your production environment. Some
+of them may not apply to your particular use case.
+
+### Connection pooling
+
+Example code often opens a connection at the start, demonstrates a feature,
+and then closes the connection at the end. However, production code
+typically uses connections many times intermittently. Repeatedly opening
+and closing connections has a performance overhead.
+
+Use [connection pooling]({{< relref "/develop/clients/pools-and-muxing" >}})
+to avoid the overhead of opening and closing connections without having to
+write your own code to cache and reuse open connections. See
+[Connect with a connection pool]({{< relref "/develop/clients/jedis/connect#connect-with-a-connection-pool" >}})
+to learn how to use this technique with Jedis.
+
+### Client-side caching
+
+[Client-side caching]({{< relref "/develop/clients/client-side-caching" >}})
+involves storing the results from read-only commands in a local cache. If the
+same command is executed again later, the results can be obtained from the cache,
+without contacting the server. This improves command execution time on the client,
+while also reducing network traffic and server load. See
+[Connect using client-side caching]({{< relref "/develop/clients/jedis/connect#connect-using-client-side-caching" >}})
+for more information and example code.
+
+### Timeouts
+
+If a network or server error occurs while your code is opening a
+connection or issuing a command, it can end up hanging indefinitely.
+You can prevent this from happening by setting timeouts for socket
+reads and writes and for opening connections.
+
+To set a timeout for a connection, use the `JedisPooled` or `JedisPool` constructor with the `timeout` parameter, or use `JedisClientConfig` with the `socketTimeout` and `connectionTimeout` parameters.
+(The socket timeout is the maximum time allowed for reading or writing data while executing a
+command. The connection timeout is the maximum time allowed for establishing a new connection.)
+
+```java
+HostAndPort hostAndPort = new HostAndPort("localhost", 6379);
+
+JedisPooled jedisWithTimeout = new JedisPooled(hostAndPort,
+    DefaultJedisClientConfig.builder()
+        .socketTimeoutMillis(5000)  // set timeout to 5 seconds
+        .connectionTimeoutMillis(5000) // set connection timeout to 5 seconds
+        .build(),
+    poolConfig
+);
+```
+
+### Health checks
+
+If your code doesn't access the Redis server continuously then it
+might be useful to make a "health check" periodically (perhaps once
+every few seconds). You can do this using a simple
+[`PING`]({{< relref "/commands/ping" >}}) command:
+
+```java
+try (Jedis jedis = jedisPool.getResource()) {
+  if (! "PONG".equals(jedis.ping())) {
+    // Report problem.
+  }
+}
+```
+
+Health checks help to detect problems as soon as possible without
+waiting for a user to report them.
+
+### Exception handling
+
+Redis handles many errors using return values from commands, but there
+are also situations where exceptions can be thrown. In production code,
+you should handle exceptions as they occur.
+
+The Jedis exception hierarchy is rooted on `JedisException`, which implements
+`RuntimeException`. All exceptions in the hierarchy are therefore unchecked
+exceptions.
+
+```
+JedisException
+├── JedisDataException
+│   ├── JedisRedirectionException
+│   │   ├── JedisMovedDataException
+│   │   └── JedisAskDataException
+│   ├── AbortedTransactionException
+│   ├── JedisAccessControlException
+│   └── JedisNoScriptException
+├── JedisClusterException
+│   ├── JedisClusterOperationException
+│   ├── JedisConnectionException
+│   └── JedisValidationException
+└── InvalidURIException
+```
+
+#### General exceptions
+
+In general, Jedis can throw the following exceptions while executing commands:
+
+- `JedisConnectionException` - when the connection to Redis is lost or closed unexpectedly. Configure failover to handle this exception automatically with Resilience4J and the built-in Jedis failover mechanism.  
+- `JedisAccessControlException` - when the user does not have the permission to execute the command or the user ID and/or password are incorrect.
+- `JedisDataException` - when there is a problem with the data being sent to or received from the Redis server. Usually, the error message will contain more information about the failed command.
+- `JedisException` - this exception is a catch-all exception that can be thrown for any other unexpected errors.
+
+Conditions when `JedisException` can be thrown:
+- Bad return from a health check with the [`PING`]({{< relref "/commands/ping" >}}) command
+- Failure during SHUTDOWN
+- Pub/Sub failure when issuing commands (disconnect)
+- Any unknown server messages
+- Sentinel: can connect to sentinel but master is not monitored or all Sentinels are down.
+- MULTI or DISCARD command failed 
+- Shard commands key hash check failed or no Reachable Shards
+- Retry deadline exceeded/number of attempts (Retry Command Executor)
+- POOL - pool exhausted, error adding idle objects, returning broken resources to the pool
+
+All the Jedis exceptions are runtime exceptions and in most cases irrecoverable, so in general bubble up to the API capturing the error message.
+
+### DNS cache and Redis
+
+When you connect to a Redis server with multiple endpoints, such as [Redis Enterprise Active-Active](https://redis.com/redis-enterprise/technology/active-active-geo-distribution/), you *must*
+disable the JVM's DNS cache. If a server node or proxy fails, the IP address for any database
+affected by the failure will change. When this happens, your app will keep
+trying to use the stale IP address if DNS caching is enabled.
+
+Use the following code to disable the DNS cache:
+
+```java
+java.security.Security.setProperty("networkaddress.cache.ttl","0");
+java.security.Security.setProperty("networkaddress.cache.negative.ttl", "0");
+```
+---
+aliases: /develop/connect/clients/python/redis-vl
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect your Python vector application to a Redis vector database
+linkTitle: RedisVL (Python)
+title: Redis vector library guide (Python)
+weight: 2
+---
+
+See the [RedisVL Guide]({{< relref "/integrate/redisvl" >}}) for more information.---
+aliases: /develop/connect/clients
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+hideListLinks: true
+description: Connect your application to a Redis database and try an example
+linkTitle: Client APIs
+title: Connect with Redis client API libraries
+weight: 30
+---
+
+Use the Redis client libraries to connect to Redis servers from
+your own code. We document the following client libraries
+for seven main languages:
+
+| Language | Client name | Docs | Supported |
+| :-- | :-- | :-- | :-- |
+| [Python](https://www.python.org/) | [`redis-py`](https://github.com/redis/redis-py) |[`redis-py` guide]({{< relref "/develop/clients/redis-py" >}}) | Yes |
+| [Python](https://www.python.org/) | [`RedisVL`](https://github.com/redis/redis-vl-python) |[RedisVL guide]({{< relref "/integrate/redisvl" >}}) | Yes 
+| [C#/.NET](https://learn.microsoft.com/en-us/dotnet/csharp/) | [`NRedisStack`](https://github.com/redis/NRedisStack) |[`NRedisStack` guide]({{< relref "/develop/clients/dotnet" >}}) | Yes |
+| [JavaScript](https://nodejs.org/en) | [`node-redis`](https://github.com/redis/node-redis) | [`node-redis` guide]({{< relref "/develop/clients/nodejs" >}}) | Yes |
+| [Java](https://www.java.com/en/) | [`Jedis`](https://github.com/redis/jedis) | [`Jedis` guide]({{< relref "/develop/clients/jedis" >}}) |  Yes |
+| [Java](https://www.java.com/en/) | [`Lettuce`](https://github.com/redis/lettuce) | [`Lettuce` guide]({{< relref "/develop/clients/lettuce" >}}) | Yes |
+| [Go](https://go.dev/) | [`go-redis`](https://github.com/redis/go-redis) | [`go-redis` guide]({{< relref "/develop/clients/go" >}}) | Yes |
+| [PHP](https://www.php.net/)| [`Predis`](https://github.com/predis/predis) | [`Predis` guide]({{< relref "/develop/clients/php" >}}) | No |
+| [C](https://en.wikipedia.org/wiki/C_(programming_language)) | [`hiredis`](https://github.com/redis/hiredis) | [`hiredis` guide]({{< relref "/develop/clients/hiredis" >}}) | Yes |
+
+We also provide several higher-level
+[object mapping (OM)]({{< relref "/develop/clients/om-clients" >}})
+libraries for [Python]({{< relref "/integrate/redisom-for-python" >}}),
+[C#/.NET]({{< relref "/integrate/redisom-for-net" >}}),
+[Node.js]({{< relref "/integrate/redisom-for-node-js" >}}), and
+[Java/Spring]({{< relref "/integrate/redisom-for-java" >}}).
+
+## Community-supported clients
+
+The table below shows the recommended third-party client libraries for languages that
+Redis does not document directly:
+
+| Language | Client name | Github | Docs |
+| :-- | :-- | :-- | :-- |
+| [C++](https://en.wikipedia.org/wiki/C%2B%2B) | Boost.Redis | https://github.com/boostorg/redis | https://www.boost.org/doc/libs/develop/libs/redis/doc/html/index.html |
+| [Dart](https://dart.dev/) | redis_dart_link | https://github.com/toolsetlink/redis_dart_link | https://github.com/toolsetlink/redis_dart_link |
+| [PHP](https://www.php.net/) | PhpRedis extension | https://github.com/phpredis/phpredis | https://github.com/phpredis/phpredis/blob/develop/README.md |
+| [Ruby](https://www.ruby-lang.org/en/) | redis-rb | https://github.com/redis/redis-rb | https://rubydoc.info/gems/redis |
+| [Rust](https://www.rust-lang.org/) | redis-rs | https://github.com/redis-rs/redis-rs | https://docs.rs/redis/latest/redis/ |
+
+
+## Requirements
+
+You will need access to a Redis server to use these libraries.
+You can experiment with a local installation of Redis Open Source
+(see [Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack/" >}})) or with a free trial of [Redis Cloud]({{< relref "/operate/rc" >}}).
+To interact with a Redis server without writing code, use the
+[Redis CLI]({{< relref "/develop/tools/cli" >}}) and
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) tools.
+---
+title: Redis 7.2
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rcw
+description: What's new in Redis 7.2
+linkTitle: What's new in Redis 7.2
+weight: 20
+---
+
+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.
+
+### Streamlined data manipulation in JSON
+JSON now includes two new commands for improved data handling:
+
+- `JSON.MERGE`: Merges a given JSON value into matching paths, allowing more flexible updates.
+- `JSON.MSET`: Sets or updates multiple JSON values simultaneously based on specified key-path-value triplets, improving efficiency when handling structured data.
+
+## Improvements
+
+### Existing data structures
+Significant performance improvements have been made across Redis data types. Sorted sets, commonly used for gaming leaderboards, now see performance improvements ranging from [30% to 100%](https://redis.io/blog/introducing-redis-7-2/#:~:text=We%20made%20Redis%20more%20powerful%20for%20developers).
+
+Additionally, Redis stream consumer tracking has been enhanced to provide better visibility into consumer activity, and blocked stream commands now return a distinct error when the target key no longer exists.
+
+### Redis Query Engine improvements
+The Redis Query Engine has received several updates, including optimized `SORT BY` operations and the addition of a new `FORMAT` response in RESP3, improving both efficiency and readability.
+
+### Script execution enhancemets
+Client-side tracking now monitors actual keys read during script execution, improving key usage tracking accuracy. Additionally, blocked commands will re-evaluate security checks before execution, ensuring compliance with updated permissions. Standardized ACL failure messages and error codes now provide clearer error handling.
+
+### Client and replication enhancements
+TLS-based replication now supports Server Name Indication (SNI) to improve compatibility with secure deployments. The `HELLO` command behavior has also been refined to modify client state only upon successful execution, ensuring more predictable client behavior.
+
+## Changes
+
+### Breaking changes
+Redis 7.2 introduces several backward-incompatible changes. Lua scripts no longer support the `print()` function, blocking of `PFCOUNT` and `PUBLISH` in read-only scripts, and time sampling freezing during command execution. Error handling updates include case changes in error responses, new behavior for `ZPOPMIN/ZPOPMAX` with `count 0`, and adjustments to `XCLAIM/XAUTOCLAIM`. ACL changes affect command categorization and key access permissions, while command introspection now includes per-subcommand statistics. Redis now allows certain `CONFIG` commands during loading and tracks statistics only when commands are executed.
+
+For more details, see [Redis 7.2 Breaking Changes](https://redis.io/docs/latest/embeds/r7.2-breaking-changes/).
+
+### Expired keys are now deleted from replica indexes
+Expired keys are now deleted from Redis Query Engine replica indexes, ensuring that queries return an empty array rather than `nil` when the data no longer exists.
+
+### Other changes
+Redis Stack 7.2 no longer includes Graph capabilities. For more details, refer to the [RedisGraph End-of-Life Announcement](https://redis.io/blog/redisgraph-eol/#:~:text=After%20January%2031%2C%202025%2C%20RedisGraph,subscriptions%20until%20January%2031%2C%202024.).
+
+## Component versions
+The Redis version 7.2 includes the following components:
+
+- [Redis 7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)
+- [Search 2.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes/)
+- [JSON 2.6](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes/)
+- [Time series 1.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes/)
+- [Bloom 2.6](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes/)
+---
+title: Redis 6.2
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: What's new in Redis 6.2
+linkTitle: What's new in Redis 6.2
+weight: 30
+---
+
+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.
+
+## New features
+
+### Multi-value indexing and querying
+Redis now supports indexing and querying multi-value attributes across all field types, including `TEXT`, `TAG`, `NUMERIC`, `GEO`, and `VECTOR`. Developers can define JSONPath expressions leading to arrays or multiple scalar values, overcoming the previous limitation of indexing only single scalar attributes.
+
+### Wildcard query support
+The Redis Query Engine now enables suffix and infix wildcard searches for `TEXT` and `TAG` fields. This enhancement provides greater flexibility in data retrieval and filtering.
+
+### t-digest: a new probabilistic data structure for quantile estimation
+Redis introduces t-digest, an advanced probabilistic data structure that efficiently estimates quantiles in large datasets or continuous data streams. This is particularly beneficial for analytics and monitoring applications where quantile calculations are required.
+
+### Retrieve aggregation results for ongoing time series buckets
+A new feature allows users to retrieve the latest, still-open time series buckets during compaction.
+
+### Time-weighted average aggregator for time series
+Redis now includes a time-weighted average aggregator, improving accuracy in average-over-time calculations. This feature is especially valuable for time series data with irregular sampling intervals.
+
+### Gap-filling for time series data
+To improve time series analytics, Redis introduces gap-filling capabilities. This feature allows interpolation of missing values or repetition of the last known value for empty time buckets, ensuring continuity in time series analysis.
+
+## Improvements
+### Existing data structures
+Redis 6.2 introduces over 25 new commands, fulfilling long-standing community requests. Notably:
+
+- The long-awaited `ZUNION` and `ZINTER` commands now allow direct retrieval of results, unlike `ZUNIONSTORE` and `ZINTERSTORE`, which store results in a key.
+- Redis streams enhancements include:
+  - Support for exclusive range queries, providing finer control over data retrieval.
+  - The ability to filter pending messages based on idle time, improving message management.
+  - A new mechanism to automatically claim pending messages from a stream consumer group, transferring ownership of messages that have exceeded their idle timeout to a new consumer without requiring manual acknowledgment.
+
+## Component versions
+The Redis version 6.2 is built from the following component versions:
+
+- [Redis 6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES)
+- [Search 2.6](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes/)
+- [JSON 2.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes/)
+- [Time series 1.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes/)
+- [Bloom 2.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes/)
+- [Graph 2.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes/)
+---
+title: Redis 8.0
+alwaysopen: false
+aliases:
+- /develop/whats-new/8-0-rc-1/
+categories:
+- docs
+- operate
+- rs
+- rc
+description: What's new in Redis 8 in Redis Open Source
+linkTitle: What's new in Redis 8.0
+weight: 5
+---
+
+## Highlights
+
+- **Name change**: Redis Community Edition is now **Redis Open Source**
+- **License options**:
+  - Redis Source Available License 2.0 (RSALv2)
+  - Server Side Public License v1 (SSPLv1)
+  - GNU Affero General Public License (AGPLv3)
+
+- **Integrated modules** now part of core:  
+  - JSON
+  - Probabilistic: Bloom, Cuckoo, Count-min sketch, Top-K, and t-digest  
+  - Time Series
+  - [Vector sets (preview)]({{< relref "/develop/data-types/vector-sets/" >}})  
+  - [Redis Query Engine]({{< relref "/develop/interact/#search-and-query" >}}) with horizontal & vertical scaling  
+  - All components available in Redis binary distributions  
+  - New config file: `redis-full.conf` for full component loading
+
+## New Commands
+
+- **Hash with expiration support**:  
+  - `HGETDEL` – get and delete hash field  
+  - `HGETEX`, `HSETEX` – get/set hash fields with expiration  
+- **Field TTL & expiration (7.4+)**:  
+  - `HEXPIRE`, `HPEXPIRE`, `HEXPIREAT`, `HPEXPIREAT`  
+  - `HPERSIST`, `HEXPIRETIME`, `HPEXPIRETIME`, `HTTL`, `HPTTL`  
+- **Other command additions**:  
+  - `XREAD +` – read latest stream entry  
+  - `HSCAN NOVALUES` – scan hash field names only  
+  - `SORT` in cluster mode with `BY` and `GET`  
+  - `CLIENT KILL MAXAGE`  
+  - Lua: `os.clock()` now available  
+  - `SPUBLISH` in `MULTI/EXEC` transactions on replicas  
+  - [Vector set command group (preview)]({{< relref "/commands/?group=vector_set" >}})
+
+## Internal Architecture
+
+- **I/O threading overhaul**: read+write threading for higher throughput  
+- **Replication**: improved mechanism with AOF offset support  
+- **Over 30 performance optimizations**:  
+  - Optimized: `GET`, `EXISTS`, `LRANGE`, `HSET`, `XREAD`, `SCAN`, `ZADD`, `ZUNION`, `PFCOUNT`, `HSCAN`, and more  
+  - Improved latency, memory, and CPU utilization
+
+## Security
+
+- CVE-2024-46981: Lua RCE  
+- CVE-2024-51741: ACL DoS  
+- CVE-2024-31449, 31227, 31228: DoS in Lua/ACLs
+
+## Packaging
+
+Redis 8 in Redis Open Source is available in the following distributions:
+
+- [Docker](https://hub.docker.com/_/redis)
+- APT
+- RPM
+- Snap
+- Homebrew
+- Pre-built binaries
+- [Source code](https://github.com/redis/redis/releases/tag/8.0-rc1)
+
+## Observability
+
+- New `INFO` sections:  
+  - `KEYSIZES`, `Threads`  
+  - Hash expiration stats  
+  - Client buffer disconnection counters  
+  - Dictionary memory rehashing  
+  - Script eviction stats
+
+## Upgrades & Support
+
+- Supports upgrade from:  
+  - Redis 7.x with or without modules  
+  - Redis Stack 7.2 and 7.4  
+- Supported operating systems:  
+  - Ubuntu 20.04 / 22.04 / 24.04  
+  - Debian 11 / 12  
+  - macOS 13–15  
+  - Rocky/Alma Linux 8.10 / 9.5
+---
+title: Redis feature sets
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Highlights of what's new for Redis feature sets
+linkTitle: Redis feature sets
+weight: 40
+---
+
+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.0| See [here]({{< relref "/develop/whats-new/8-0" >}})|
+| **Feature set version:** 7.4<br /><br />**Component versions:**<br />[Redis 7.4]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce/redisce-7.4-release-notes.md">}})<br />[Search 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[JSON 2.8]({{<relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md">}})<br />[Time series 1.12]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md">}})<br />[Bloom 2.8]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md">}}) | **Hash**: <br>- [Expiration of individual hash fields]({{<relref "/develop/data-types/hashes#field-expiration">}}). <br> **Streams**: <br>- To start reading from the last stream message, use [`XREAD`]({{<relref "/commands/xread">}}) with the new ID value `+`.<br> **Time series**: <br>Insertion-filter for close samples. <br> **JSON**: <br>- A fix to not duplicate `AOF` commands multiple times in [`JSON.MSET`]({{< relref "commands/json.mset/" >}}). <br> **Probabilistic**: <br>- Returns an error if [`CMS.MERGE`]({{< relref "commands/cms.merge/" >}}) results in an overflow or underflow. <br> **Redis Query Engine**: <br>- New `BFLOAT16` and `FLOAT16` vector data types, reducing memory consumed by vectors while preserving accuracy. <br>- Support for indexing empty and missing values and enhanced developer experience for queries with exact matching capabilities. <br>- You can match `TAG` fields without needing to escape special characters. <br>- 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<br /><br />**Component versions:**<br />[Redis 7.2](https://raw.githubusercontent.com/redis/redis/7.2/00-RELEASENOTES)<br />[Search 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[JSON 2.6]({{<relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md">}})<br />[Time series 1.10]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md">}})<br />[Bloom 2.6]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md">}})<br />[Gears 2.0](https://github.com/RedisGears/RedisGears/releases) | - Performance and resource utilization improvements, including significant memory and speed optimizations for lists, sets, and sorted sets.<br />**JSON**:<br />- New JSON commands: [`JSON.MERGE`]({{< relref "commands/json.merge/" >}}) and [`JSON.MSET`]({{< relref "commands/json.mset/" >}}).<br />**Redis Query Engine:**<br />- [Geo polygon search]({{< relref "commands/ft.search/#examples" >}}).<br>**Compatibility changes**:<br>- Redis 7.2 uses a new format (version 11) for RDB files, which is incompatible with older versions.<br />- Redis feature set 7.2 does not include [graph capabilities](https://redis.io/blog/redisgraph-eol/). |
+| **Feature set version:** 6.2<br /><br />**Component versions:**<br />[Redis 6.2](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES)<br />[Search 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[JSON 2.4]({{<relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md">}})<br />[Time series 1.8]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md">}})<br />[Bloom 2.4]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md">}})<br />[Graph 2.10]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md">}}) | **Time series**:<br />- Time series gap filling.<br />**JSON**:<br />- Improved JSON path parser.<br />**Probabilistic:**<br />- New probabilistic data structure t-digest.<br />**Redis Query Engine:**<br />- Wildcard queries for `TEXT` and `TAG`.<br />- Suffix search.<br />- Multi-value indexing and queries.<br />**Graph**:<br />- New pathfinding algorithms for graphs. |
+
+---
+title: Redis 7.4
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: What's new in Redis 7.4
+linkTitle: What's new in Redis 7.4
+weight: 10
+---
+
+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.
+
+### New memory-efficient data types for AI workloads
+With the growing demand for AI applications, Redis 7.4 introduces `BFLOAT16` and `FLOAT16` data types. These new types reduce memory usage by up to 47% and lower latency by as much as 59% under load, making them ideal for storing and processing vector embeddings in AI-powered applications, including vector databases and Retrieval Augmented Generation (RAG) systems.
+
+### Time series optimization with insertion filters
+Redis 7.4 introduces insertion filters for time series data, allowing sensors to ignore new measurements when the differences in time or value are minimal. This feature helps reduce the size of time series data and boosts efficiency.
+
+## Improvements
+
+### Simplified secondary indexing
+The Redis Query Engine now offers a more straightforward approach to secondary indexing with the addition of the `TAG` index type. Querying tags with special characters (like `@` and `.`) is easier, as it no longer requires escaping; simply wrap query terms in double quotes. The update also includes improved handling of empty and missing fields, making the data model more flexible. Geospatial search has been enhanced with new operators, such as `INTERSECT` and `DISJOIN`, and memory usage reporting for indexes has been improved.
+
+## Changes
+
+### Behavior changes
+Redis 7.4 includes behavior changes such as using jemalloc instead of libc for allocating Lua VM code. This adjustment reduces memory fragmentation and improves performance. Additionally, the `ACL LOAD` command has been modified to ensure that only clients with affected user configurations are disconnected, reducing unnecessary disruptions.
+
+## Component versions
+The Redis version 7.4 includes the following components:
+
+- [Redis 7.4](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce/redisce-7.4-release-notes/)
+- [Search 2.10](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes/)
+- [JSON 2.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes/)
+- [Time series 1.12](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes/)
+- [Bloom 2.8](https://redis.io/docs/latest/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes/)
+---
+title: What's new?
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: High-level description of important updates to the Develop section
+linkTitle: What's new?
+hideListLinks: true
+weight: 10
+---
+## Q1 2025 (January - March) Updates
+
+### Tools
+
+- Redis Insight [v2.66 release notes]({{< relref "/develop/tools/insight/release-notes/v.2.66.0.md" >}})
+- Updated CLI output samples for [`bigkeys`, `memkeys`, `keystats`]({{< relref "/develop/tools/cli.md" >}})
+
+---
+
+### Redis AI & Vectors
+
+- Expanded vector examples:
+  - [Python]({{< relref "/develop/clients/redis-py/vecsearch.md" >}})
+  - [Node.js]({{< relref "/develop/clients/nodejs/vecsearch.md" >}})
+  - [Java (Jedis)]({{< relref "/develop/clients/jedis/vecsearch.md" >}})
+  - [Go]({{< relref "/develop/clients/go/vecsearch.md" >}})
+  - [.NET]({{< relref "/develop/clients/dotnet/vecsearch.md" >}})
+- Updated AI integrations:
+  - [AI overview]({{< relref "/develop/ai/index.md" >}})
+  - [RAG intro]({{< relref "/develop/get-started/rag.md" >}})
+  - [Redis in AI]({{< relref "/develop/get-started/redis-in-ai.md" >}})
+
+---
+
+### Data Types
+
+- TimeSeries:
+  - [`COMPACTION_POLICY`]({{< relref "/develop/data-types/timeseries/configuration.md" >}})
+  - [Client-side caching update]({{< relref "/develop/clients/client-side-caching.md" >}})
+- JSON:
+  - [Active memory defragmentation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/commands.md" >}})
+- Probabilistic:
+  - [Bloom filter]({{< relref "/develop/data-types/probabilistic/bloom-filter.md" >}})
+  - [Count-min sketch]({{< relref "/develop/data-types/probabilistic/count-min-sketch.md" >}})
+  - [Top-K]({{< relref "/develop/data-types/probabilistic/top-k.md" >}})
+  - [Cuckoo filter]({{< relref "/develop/data-types/probabilistic/cuckoo-filter.md" >}})
+
+---
+
+### Commands & API Docs
+
+- Pages updated for format and accuracy:
+  - [ACL SETUSER]({{< relref "/commands/acl-setuser/index.md" >}})
+  - [JSON.GET]({{< relref "/commands/json.get/index.md" >}})
+  - [TS.ADD]({{< relref "/commands/ts.add/index.md" >}})
+  - [SCAN]({{< relref "/commands/scan/index.md" >}})
+  - [SORT]({{< relref "/commands/sort/index.md" >}})
+- RESP3 reply types documented in [Hiredis command page]({{< relref "/develop/clients/hiredis/issue-commands.md" >}})
+- [CSC behavior clarified]({{< relref "/develop/clients/client-side-caching.md" >}})
+
+---
+
+### Search & Query
+
+- Best practices:
+  - [Dev-to-prod guide]({{< relref "/develop/interact/search-and-query/best-practices/dev-to-prod-best-practices.md" >}})
+  - [Scalable queries]({{< relref "/develop/interact/search-and-query/best-practices/scalable-query-best-practices.md" >}})
+  - [Index lifecycle]({{< relref "/develop/interact/search-and-query/best-practices/index-mgmt-best-practices.md" >}})
+- New/updated topics:
+  - [Autocomplete]({{< relref "/develop/interact/search-and-query/advanced-concepts/autocomplete.md" >}})
+  - [Escaping & tokenization]({{< relref "/develop/interact/search-and-query/advanced-concepts/escaping.md" >}})
+  - [Geo indexing]({{< relref "/develop/interact/search-and-query/indexing/geoindex.md" >}})
+  - [Sorting, scoring, stemming]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting.md" >}})
+
+---
+
+### Client Libraries
+
+#### Go
+- [Trans/pipe examples]({{< relref "/develop/clients/go/transpipe.md" >}})
+- [JSON queries]({{< relref "/develop/clients/go/queryjson.md" >}})
+
+#### .NET
+- [Vector search]({{< relref "/develop/clients/dotnet/vecsearch.md" >}})
+- [Trans/pipe usage]({{< relref "/develop/clients/dotnet/transpipe.md" >}})
+- [JSON queries]({{< relref "/develop/clients/dotnet/queryjson.md" >}})
+
+#### Java (Jedis)
+- [Vector search]({{< relref "/develop/clients/jedis/vecsearch.md" >}})
+- [Trans/pipe usage]({{< relref "/develop/clients/jedis/transpipe.md" >}})
+
+#### Node.js
+- [Vector queries]({{< relref "/develop/clients/nodejs/vecsearch.md" >}})
+- [Trans/pipe examples]({{< relref "/develop/clients/nodejs/transpipe.md" >}})
+- [JSON queries]({{< relref "/develop/clients/nodejs/queryjson.md" >}})
+
+#### Redis-py
+- [ScanIter usage]({{< relref "/develop/clients/redis-py/scaniter.md" >}})
+- [Vector search]({{< relref "/develop/clients/redis-py/vecsearch.md" >}})
+- [Trans/pipe usage]({{< relref "/develop/clients/redis-py/transpipe.md" >}})
+- [JSON queries]({{< relref "/develop/clients/redis-py/queryjson.md" >}})
+
+#### Lettuce
+- [Cluster connection]({{< relref "/develop/clients/lettuce/connect.md" >}})
+- [Production usage]({{< relref "/develop/clients/lettuce/produsage.md" >}})
+
+#### Hiredis
+- Full client guide:
+  - [Overview]({{< relref "/develop/clients/hiredis/_index.md" >}})
+  - [Connect]({{< relref "/develop/clients/hiredis/connect.md" >}})
+  - [Issue commands]({{< relref "/develop/clients/hiredis/issue-commands.md" >}})
+  - [Handle replies]({{< relref "/develop/clients/hiredis/handle-replies.md" >}})
+  - [Transactions and pipelines]({{< relref "/develop/clients/hiredis/transpipe.md" >}})
+
+
+
+## Q4 2024 (October - December) Updates
+
+* Updated the RESP3 specification document to include the [attribute type]({{< relref "/develop/reference/protocol-spec#attributes" >}}).
+* Updates to the [key eviction]({{< relref "/develop/reference/eviction" >}}) page.
+* Updates to the Redis Insight page related to its new Redis Query Engine auto-completion [feature]({{< relref "/develop/tools/insight#workbench">}}).
+* Restructured and added testable connection examples to the [client pages]({{< relref "/develop/clients" >}}).
+* Added [Redis Open Source]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce" >}}) and [Redis Stack]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisstack" >}}) release notes.
+* Added new [Redis for AI]({{< relref "/develop/ai" >}}) page.
+* Added new [Predis (PHP client library)]({{< relref "/develop/clients/php" >}}) page.
+
+## Q3 2024 (July - September) Updates
+
+* Updated the [RAG with Redis quick start guide]({{< relref "/develop/get-started/rag" >}}).
+* Updates for [Redis Open Source version 7.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce" >}}).
+* Added new [Redis Insight debugging]({{< relref "/develop/tools/insight/debugging" >}}) page.
+* Completed a major re-write/restructuring of the [vector indexing page]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+* Added new [client-side caching page]({{< relref "/develop/clients/client-side-caching" >}}).
+* Added new documentation for the [RDI in Redis Insight feature]({{< relref "/develop/tools/insight/rdi-connector" >}}).
+* Added new documentation for the [Redis for VS Code feature]({{< relref "/develop/tools/redis-for-vscode/" >}}).
+* Added multi-language code examples to the Redis Query Engine [query]({{< relref "/develop/interact/search-and-query/query">}}) pages.
+* Added client-side caching information to the [supported clients]({{< relref "/develop/clients/client-side-caching#which-client-libraries-support-client-side-caching" >}}) pages.
+* Numerous changes to the [Redis client content]({{< relref "/develop/clients" >}}).
+---
+aliases: /develop/connect/cli
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Overview of redis-cli, the Redis command line interface'
+linkTitle: CLI
+title: Redis CLI
+weight: 1
+---
+
+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.
+
+## Command line usage
+
+To run a Redis command and return a standard output at the terminal, include the command to execute as separate arguments of `redis-cli`:
+
+    $ redis-cli INCR mycounter
+    (integer) 7
+
+The reply of the command is "7". Since Redis replies are typed (strings, arrays, integers, nil, errors, etc.), you see the type of the reply between parentheses. This additional information may not be ideal when the output of `redis-cli` must be used as input of another command or redirected into a file.
+
+`redis-cli` only shows additional information for human readability when it detects the standard output is a tty, or terminal. For all other outputs it will auto-enable the *raw output mode*, as in the following example:
+
+    $ redis-cli INCR mycounter > /tmp/output.txt
+    $ cat /tmp/output.txt
+    8
+
+Note that `(integer)` is omitted from the output because `redis-cli` detects
+the output is no longer written to the terminal. You can force raw output
+even on the terminal with the `--raw` option:
+
+    $ redis-cli --raw INCR mycounter
+    9
+
+You can force human readable output when writing to a file or in
+pipe to other commands by using `--no-raw`.
+
+## String quoting and escaping
+
+When `redis-cli` parses a command, whitespace characters automatically delimit the arguments.
+In interactive mode, a newline sends the command for parsing and execution.
+To input string values that contain whitespaces or non-printable characters, you can use quoted and escaped strings.
+
+Quoted string values are enclosed in double (`"`) or single (`'`) quotation marks.
+Escape sequences are used to put nonprintable characters in character and string literals.
+
+An escape sequence contains a backslash (`\`) symbol followed by one of the escape sequence characters.
+
+Doubly-quoted strings support the following escape sequences:
+
+* `\"` - double-quote
+* `\n` - newline
+* `\r` - carriage return
+* `\t` - horizontal tab
+* `\b` - backspace
+* `\a` - alert
+* `\\` - backslash
+* `\xhh` - any ASCII character represented by a hexadecimal number (_hh_)
+
+Single quotes assume the string is literal, and allow only the following escape sequences:
+* `\'` - single quote
+* `\\` - backslash
+
+For example, to return `Hello World` on two lines:
+
+```
+127.0.0.1:6379> SET mykey "Hello\nWorld"
+OK
+127.0.0.1:6379> GET mykey
+Hello
+World
+```
+
+When you input strings that contain single or double quotes, as you might in passwords, for example, escape the string, like so: 
+
+```
+127.0.0.1:6379> AUTH some_admin_user ">^8T>6Na{u|jp>+v\"55\@_;OU(OR]7mbAYGqsfyu48(j'%hQH7;v*f1H${*gD(Se'"
+ ```
+
+## Host, port, password, and database
+
+By default, `redis-cli` connects to the server at the address 127.0.0.1 with port 6379.
+You can change the port using several command line options. To specify a different host name or an IP address, use the `-h` option. In order to set a different port, use `-p`.
+
+    $ redis-cli -h redis15.localnet.org -p 6390 PING
+    PONG
+
+If your instance is password protected, the `-a <password>` option will
+perform authentication saving the need of explicitly using the [`AUTH`]({{< relref "/commands/auth" >}}) command:
+
+    $ redis-cli -a myUnguessablePazzzzzword123 PING
+    PONG
+
+**NOTE:** For security reasons, provide the password to `redis-cli` automatically via the
+`REDISCLI_AUTH` environment variable.
+
+Finally, it's possible to send a command that operates on a database number
+other than the default number zero by using the `-n <dbnum>` option:
+
+    $ redis-cli FLUSHALL
+    OK
+    $ redis-cli -n 1 INCR a
+    (integer) 1
+    $ redis-cli -n 1 INCR a
+    (integer) 2
+    $ redis-cli -n 2 INCR a
+    (integer) 1
+
+Some or all of this information can also be provided by using the `-u <uri>`
+option and the URI pattern `redis://user:password@host:port/dbnum`:
+
+    $ redis-cli -u redis://LJenkins:p%40ssw0rd@redis-16379.hosted.com:16379/0 PING
+    PONG
+
+**NOTE:**
+User, password and dbnum are optional.
+For authentication without a username, use username `default`.
+For TLS, use the scheme `rediss`.
+
+You can use the `-4` or `-6` argument to set a preference for IPv4 or IPv6, respectively, for DNS lookups.
+
+## SSL/TLS
+
+By default, `redis-cli` uses a plain TCP connection to connect to Redis.
+You may enable SSL/TLS using the `--tls` option, along with `--cacert` or
+`--cacertdir` to configure a trusted root certificate bundle or directory.
+
+If the target server requires authentication using a client side certificate,
+you can specify a certificate and a corresponding private key using `--cert` and
+`--key`.
+
+## Get input from other programs
+
+There are two ways you can use `redis-cli` in order to receive input from other
+commands via the standard input. One is to use the target payload as the last argument
+from *stdin*. For example, in order to set the Redis key `net_services`
+to the content of the file `/etc/services` from a local file system, use the `-x`
+option:
+
+    $ redis-cli -x SET net_services < /etc/services
+    OK
+    $ redis-cli GETRANGE net_services 0 50
+    "#\n# Network services, Internet style\n#\n# Note that "
+
+In the first line of the above session, `redis-cli` was executed with the `-x` option and a file was redirected to the CLI's
+standard input as the value to satisfy the `SET net_services` command phrase. This is useful for scripting.
+
+A different approach is to feed `redis-cli` a sequence of commands written in a
+text file:
+
+    $ cat /tmp/commands.txt
+    SET item:3374 100
+    INCR item:3374
+    APPEND item:3374 xxx
+    GET item:3374
+    $ cat /tmp/commands.txt | redis-cli
+    OK
+    (integer) 101
+    (integer) 6
+    "101xxx"
+
+All the commands in `commands.txt` are executed consecutively by
+`redis-cli` as if they were typed by the user in interactive mode. Strings can be
+quoted inside the file if needed, so that it's possible to have single
+arguments with spaces, newlines, or other special characters:
+
+    $ cat /tmp/commands.txt
+    SET arg_example "This is a single argument"
+    STRLEN arg_example
+    $ cat /tmp/commands.txt | redis-cli
+    OK
+    (integer) 25
+
+## Continuously run the same command
+
+It is possible to execute a single command a specified number of times
+with a user-selected pause between executions. This is useful in
+different contexts - for example when we want to continuously monitor some
+key content or [`INFO`]({{< relref "/commands/info" >}}) field output, or when we want to simulate some
+recurring write event, such as pushing a new item into a list every 5 seconds.
+
+This feature is controlled by two options: `-r <count>` and `-i <delay>`.
+The `-r` option states how many times to run a command and `-i` sets
+the delay between the different command calls in seconds (with the ability
+to specify values such as 0.1 to represent 100 milliseconds).
+
+By default the interval (or delay) is set to 0, so commands are just executed
+ASAP:
+
+    $ redis-cli -r 5 INCR counter_value
+    (integer) 1
+    (integer) 2
+    (integer) 3
+    (integer) 4
+    (integer) 5
+
+To run the same command indefinitely, use `-1` as the count value.
+To monitor over time the RSS memory size it's possible to use the following command:
+
+    $ redis-cli -r -1 -i 1 INFO | grep rss_human
+    used_memory_rss_human:2.71M
+    used_memory_rss_human:2.73M
+    used_memory_rss_human:2.73M
+    used_memory_rss_human:2.73M
+    ... a new line will be printed each second ...
+
+## Mass insertion of data using `redis-cli`
+
+Mass insertion using `redis-cli` is covered in a separate page as it is a
+worthwhile topic itself. Please refer to our [mass insertion guide]({{< relref "/develop/use/patterns/bulk-loading" >}}).
+
+## CSV output
+
+A CSV (Comma Separated Values) output feature exists within `redis-cli` to export data from Redis to an external program.  
+
+    $ redis-cli LPUSH mylist a b c d
+    (integer) 4
+    $ redis-cli --csv LRANGE mylist 0 -1
+    "d","c","b","a"
+
+Note that the `--csv` flag will only work on a single command, not the entirety of a DB as an export.
+
+## Run Lua scripts
+
+The `redis-cli` has extensive support for using the debugging facility
+of Lua scripting, available with Redis 3.2 onwards. For this feature, refer to the [Redis Lua debugger documentation]({{< relref "/develop/interact/programmability/lua-debugging" >}}).
+
+Even without using the debugger, `redis-cli` can be used to
+run scripts from a file as an argument:
+
+    $ cat /tmp/script.lua
+    return redis.call('SET',KEYS[1],ARGV[1])
+    $ redis-cli --eval /tmp/script.lua location:hastings:temp , 23
+    OK
+
+The Redis [`EVAL`]({{< relref "/commands/eval" >}}) command takes the list of keys the script uses, and the
+other non key arguments, as different arrays. When calling [`EVAL`]({{< relref "/commands/eval" >}}) you
+provide the number of keys as a number. 
+
+When calling `redis-cli` with the `--eval` option above, there is no need to specify the number of keys
+explicitly. Instead it uses the convention of separating keys and arguments
+with a comma. This is why in the above call you see `location:hastings:temp , 23` as arguments.
+
+So `location:hastings:temp` will populate the [`KEYS`]({{< relref "/commands/keys" >}}) array, and `23` the `ARGV` array.
+
+The `--eval` option is useful when writing simple scripts. For more
+complex work, the Lua debugger is recommended. It is possible to mix the two approaches, since the debugger can also execute scripts from an external file.
+
+## Interactive mode
+
+We have explored how to use the Redis CLI as a command line program.
+This is useful for scripts and certain types of testing, however most
+people will spend the majority of time in `redis-cli` using its interactive
+mode.
+
+In interactive mode the user types Redis commands at the prompt. The command
+is sent to the server, processed, and the reply is parsed back and rendered
+into a simpler form to read.
+
+Nothing special is needed for running the `redis-cli` in interactive mode -
+just execute it without any arguments
+
+    $ redis-cli
+    127.0.0.1:6379> PING
+    PONG
+
+The string `127.0.0.1:6379>` is the prompt. It displays the connected Redis server instance's hostname and port.
+
+The prompt updates as the connected server changes or when operating on a database different from the database number zero:
+
+    127.0.0.1:6379> SELECT 2
+    OK
+    127.0.0.1:6379[2]> DBSIZE
+    (integer) 1
+    127.0.0.1:6379[2]> SELECT 0
+    OK
+    127.0.0.1:6379> DBSIZE
+    (integer) 503
+
+### Handle connections and reconnections
+
+Using the `CONNECT` command in interactive mode makes it possible to connect
+to a different instance, by specifying the *hostname* and *port* we want
+to connect to:
+
+    127.0.0.1:6379> CONNECT metal 6379
+    metal:6379> PING
+    PONG
+
+As you can see the prompt changes accordingly when connecting to a different server instance.
+If a connection is attempted to an instance that is unreachable, the `redis-cli` goes into disconnected
+mode and attempts to reconnect with each new command:
+
+    127.0.0.1:6379> CONNECT 127.0.0.1 9999
+    Could not connect to Redis at 127.0.0.1:9999: Connection refused
+    not connected> PING
+    Could not connect to Redis at 127.0.0.1:9999: Connection refused
+    not connected> PING
+    Could not connect to Redis at 127.0.0.1:9999: Connection refused
+
+Generally after a disconnection is detected, `redis-cli` always attempts to
+reconnect transparently; if the attempt fails, it shows the error and
+enters the disconnected state. The following is an example of disconnection
+and reconnection:
+
+    127.0.0.1:6379> INFO SERVER
+    Could not connect to Redis at 127.0.0.1:6379: Connection refused
+    not connected> PING
+    PONG
+    127.0.0.1:6379> 
+    (now we are connected again)
+
+When a reconnection is performed, `redis-cli` automatically re-selects the
+last database number selected. However, all other states about the
+connection is lost, such as within a MULTI/EXEC transaction:
+
+    $ redis-cli
+    127.0.0.1:6379> MULTI
+    OK
+    127.0.0.1:6379> PING
+    QUEUED
+
+    ( here the server is manually restarted )
+
+    127.0.0.1:6379> EXEC
+    (error) ERR EXEC without MULTI
+
+This is usually not an issue when using the `redis-cli` in interactive mode for
+testing, but this limitation should be known.
+
+Use the `-t <timeout>` option to specify server timeout in seconds.
+
+### Editing, history, completion and hints
+
+Because `redis-cli` uses the
+[linenoise line editing library](http://github.com/antirez/linenoise), it
+always has line editing capabilities, without depending on `libreadline` or
+other optional libraries.
+
+Command execution history can be accessed in order to avoid retyping commands by pressing the arrow keys (up and down).
+The history is preserved between restarts of the CLI, in a file named
+`.rediscli_history` inside the user home directory, as specified
+by the `HOME` environment variable. It is possible to use a different
+history filename by setting the `REDISCLI_HISTFILE` environment variable,
+and disable it by setting it to `/dev/null`.
+
+The `redis-cli` client is also able to perform command-name completion by pressing the TAB
+key, as in the following example:
+
+    127.0.0.1:6379> Z<TAB>
+    127.0.0.1:6379> ZADD<TAB>
+    127.0.0.1:6379> ZCARD<TAB>
+
+Once Redis command name has been entered at the prompt, the `redis-cli` will display
+syntax hints. Like command history, this behavior can be turned on and off via the `redis-cli` preferences.
+
+Reverse history searches, such as `CTRL-R` in terminals, is supported.
+
+### Preferences
+
+There are two ways to customize `redis-cli` behavior. The file `.redisclirc`
+in the home directory is loaded by the CLI on startup. You can override the
+file's default location by setting the `REDISCLI_RCFILE` environment variable to
+an alternative path. Preferences can also be set during a CLI session, in which 
+case they will last only the duration of the session.
+
+To set preferences, use the special `:set` command. The following preferences
+can be set, either by typing the command in the CLI or adding it to the
+`.redisclirc` file:
+
+* `:set hints` - enables syntax hints
+* `:set nohints` - disables syntax hints
+
+### Run the same command N times
+
+It is possible to run the same command multiple times in interactive mode by prefixing the command
+name by a number:
+
+    127.0.0.1:6379> 5 INCR mycounter
+    (integer) 1
+    (integer) 2
+    (integer) 3
+    (integer) 4
+    (integer) 5
+
+### Show online help for Redis commands
+
+`redis-cli` provides online help for most Redis [commands]({{< relref "/commands" >}}), using the `HELP` command. The command can be used
+in two forms:
+
+* `HELP @<category>` shows all the commands about a given category. The
+categories are: 
+    - `@generic`
+    - `@string`
+    - `@list`
+    - `@set`
+    - `@sorted_set`
+    - `@hash`
+    - `@pubsub`
+    - `@transactions`
+    - `@connection`
+    - `@server`
+    - `@scripting`
+    - `@hyperloglog`
+    - `@cluster`
+    - `@geo`
+    - `@stream`
+* `HELP <commandname>` shows specific help for the command given as argument.
+
+For example in order to show help for the [`PFADD`]({{< relref "/commands/pfadd" >}}) command, use:
+
+    127.0.0.1:6379> HELP PFADD
+
+    PFADD key element [element ...]
+    summary: Adds the specified elements to the specified HyperLogLog.
+    since: 2.8.9
+
+Note that `HELP` supports TAB completion as well.
+
+### Clear the terminal screen
+
+Using the `CLEAR` command in interactive mode clears the terminal's screen.
+
+## Special modes of operation
+
+So far we saw two main modes of `redis-cli`.
+
+* Command line execution of Redis commands.
+* Interactive "REPL" usage.
+
+The CLI performs other auxiliary tasks related to Redis that
+are explained in the next sections:
+
+* Monitoring tool to show continuous stats about a Redis server.
+* Scanning a Redis database for very large keys.
+* Key space scanner with pattern matching.
+* Acting as a [Pub/Sub]({{< relref "/develop/interact/pubsub" >}}) client to subscribe to channels.
+* Monitoring the commands executed into a Redis instance.
+* Checking the [latency]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}}) of a Redis server in different ways.
+* Checking the scheduler latency of the local computer.
+* Transferring RDB backups from a remote Redis server locally.
+* Acting as a Redis replica for showing what a replica receives.
+* Simulating [LRU]({{< relref "/develop/reference/eviction" >}}) workloads for showing stats about keys hits.
+* A client for the Lua debugger.
+
+### Continuous stats mode
+
+Continuous stats mode is probably one of the lesser known yet very useful features of `redis-cli` to monitor Redis instances in real time. To enable this mode, the `--stat` option is used.
+The output is very clear about the behavior of the CLI in this mode:
+
+    $ redis-cli --stat
+    ------- data ------ --------------------- load -------------------- - child -
+    keys       mem      clients blocked requests            connections
+    506        1015.00K 1       0       24 (+0)             7
+    506        1015.00K 1       0       25 (+1)             7
+    506        3.40M    51      0       60461 (+60436)      57
+    506        3.40M    51      0       146425 (+85964)     107
+    507        3.40M    51      0       233844 (+87419)     157
+    507        3.40M    51      0       321715 (+87871)     207
+    508        3.40M    51      0       408642 (+86927)     257
+    508        3.40M    51      0       497038 (+88396)     257
+
+In this mode a new line is printed every second with useful information and differences of request values between old data points. Memory usage, client connection counts, and various other statistics about the connected Redis database can be easily understood with this auxiliary `redis-cli` tool.
+
+The `-i <interval>` option in this case works as a modifier in order to
+change the frequency at which new lines are emitted. The default is one
+second.
+
+## Scan for big keys and memory usage
+
+### Big keys
+
+In this special mode, `redis-cli` works as a key space analyzer. It scans the
+dataset for big keys, but also provides information about the data types
+that the data set consists of. This mode is enabled with the `--bigkeys` option,
+and produces verbose output:
+
+```
+$ redis-cli --bigkeys
+
+# Scanning the entire keyspace to find biggest keys as well as
+# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
+# per 100 SCAN commands (not usually needed).
+
+100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+Keys sampled: 55
+
+-------- summary -------
+
+Total key length in bytes is 495 (avg len 9.00)
+
+Biggest   list found "bikes:finished" has 1 items
+Biggest string found "all_bikes" has 36 bytes
+Biggest   hash found "bike:1:stats" has 3 fields
+Biggest stream found "race:france" has 4 entries
+Biggest    set found "bikes:racing:france" has 3 members
+Biggest   zset found "racer_scores" has 8 members
+
+1 lists with 1 items (01.82% of keys, avg size 1.00)
+16 strings with 149 bytes (29.09% of keys, avg size 9.31)
+1 MBbloomCFs with 0 ? (01.82% of keys, avg size 0.00)
+1 hashs with 3 fields (01.82% of keys, avg size 3.00)
+3 streams with 8 entries (05.45% of keys, avg size 2.67)
+2 TDIS-TYPEs with 0 ? (03.64% of keys, avg size 0.00)
+1 TopK-TYPEs with 0 ? (01.82% of keys, avg size 0.00)
+2 sets with 5 members (03.64% of keys, avg size 2.50)
+1 CMSk-TYPEs with 0 ? (01.82% of keys, avg size 0.00)
+2 zsets with 11 members (03.64% of keys, avg size 5.50)
+25 ReJSON-RLs with 0 ? (45.45% of keys, avg size 0.00)
+```
+
+In the first part of the output, each new key larger than the previous larger
+key (of the same type) encountered is reported. The summary section
+provides general stats about the data inside the Redis instance.
+
+The program uses the [`SCAN`]({{< relref "/commands/scan" >}}) command, so it can be executed against a busy
+server without impacting the operations, however the `-i` option can be
+used in order to throttle the scanning process of the specified fraction
+of second for each [`SCAN`]({{< relref "/commands/scan" >}}) command. 
+
+For example, `-i 0.01` will slow down the program execution considerably, but will also reduce the load on the server
+to a negligible amount.
+
+Note that the summary also reports in a cleaner form the biggest keys found
+for each time. The initial output is just to provide some interesting info
+ASAP if running against a very large data set.
+
+The `--bigkeys` option now works on cluster replicas.
+
+### Memory usage
+
+Similar to the `--bigkeys` option, `--memkeys` allows you to scan the entire keyspace to find biggest keys as well as
+the average sizes per key type.
+
+```
+$ redis-cli --memkeys
+
+# Scanning the entire keyspace to find biggest keys as well as
+# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
+# per 100 SCAN commands (not usually needed).
+
+100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+Keys sampled: 55
+
+-------- summary -------
+
+Total key length in bytes is 495 (avg len 9.00)
+
+Biggest   list found "bikes:finished" has 104 bytes
+Biggest string found "all_bikes" has 120 bytes
+Biggest MBbloomCF found "bikes:models" has 1048680 bytes
+Biggest   hash found "bike:1:stats" has 104 bytes
+Biggest stream found "race:italy" has 7172 bytes
+Biggest TDIS-TYPE found "bikes:sales" has 9832 bytes
+Biggest TopK-TYPE found "bikes:keywords" has 114256 bytes
+Biggest    set found "bikes:racing:france" has 120 bytes
+Biggest CMSk-TYPE found "bikes:profit" has 144056 bytes
+Biggest   zset found "racer_scores" has 168 bytes
+Biggest ReJSON-RL found "bikes:inventory" has 4865 bytes
+
+1 lists with 104 bytes (01.82% of keys, avg size 104.00)
+16 strings with 1360 bytes (29.09% of keys, avg size 85.00)
+1 MBbloomCFs with 1048680 bytes (01.82% of keys, avg size 1048680.00)
+1 hashs with 104 bytes (01.82% of keys, avg size 104.00)
+3 streams with 16960 bytes (05.45% of keys, avg size 5653.33)
+2 TDIS-TYPEs with 19648 bytes (03.64% of keys, avg size 9824.00)
+1 TopK-TYPEs with 114256 bytes (01.82% of keys, avg size 114256.00)
+2 sets with 208 bytes (03.64% of keys, avg size 104.00)
+1 CMSk-TYPEs with 144056 bytes (01.82% of keys, avg size 144056.00)
+2 zsets with 304 bytes (03.64% of keys, avg size 152.00)
+25 ReJSON-RLs with 15748 bytes (45.45% of keys, avg size 629.92)
+```
+
+The `--memkeys` option now works on cluster replicas.
+
+### Combine `--bigkeys` and `--memkeys`
+
+You can use the `--keystats` and `--keystats-samples` options to combine `--memkeys` and `--bigkeys` with additional distribution data.
+
+```
+$ redis-cli --keystats
+
+# Scanning the entire keyspace to find the biggest keys and distribution information.
+# Use -i 0.1 to sleep 0.1 sec per 100 SCAN commands (not usually needed).
+# Use --cursor <n> to start the scan at the cursor <n> (usually after a Ctrl-C).
+# Use --top <n> to display <n> top key sizes (default is 10).
+# Ctrl-C to stop the scan.
+
+100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+Keys sampled: 55
+Keys size:    1.30M
+
+--- Top 10 key sizes ---
+  1    1.00M MBbloomCF  "bikes:models"
+  2  140.68K CMSk-TYPE  "bikes:profit"
+  3  111.58K TopK-TYPE  "bikes:keywords"
+  4    9.60K TDIS-TYPE  "bikes:sales"
+  5    9.59K TDIS-TYPE  "racer_ages"
+  6    7.00K stream     "race:italy"
+  7    4.92K stream     "race:france"
+  8    4.75K ReJSON-RL  "bikes:inventory"
+  9    4.64K stream     "race:usa"
+ 10    1.26K ReJSON-RL  "bicycle:7"
+
+--- Top size per type ---
+list       bikes:finished is 104B
+string     all_bikes is 120B
+MBbloomCF  bikes:models is 1.00M
+hash       bike:1:stats is 104B
+stream     race:italy is 7.00K
+TDIS-TYPE  bikes:sales is 9.60K
+TopK-TYPE  bikes:keywords is 111.58K
+set        bikes:racing:france is 120B
+CMSk-TYPE  bikes:profit is 140.68K
+zset       racer_scores is 168B
+ReJSON-RL  bikes:inventory is 4.75K
+
+--- Top length and cardinality per type ---
+list       bikes:finished has 1 items
+string     all_bikes has 36B
+hash       bike:1:stats has 3 fields
+stream     race:france has 4 entries
+set        bikes:racing:france has 3 members
+zset       racer_scores has 8 members
+
+Key size Percentile Total keys
+-------- ---------- -----------
+     64B    0.0000%           3
+    239B   50.0000%          28
+    763B   75.0000%          42
+   4.92K   87.5000%          49
+   9.60K   93.7500%          52
+ 140.69K   96.8750%          54
+   1.00M  100.0000%          55
+Note: 0.01% size precision, Mean: 24.17K, StdDeviation: 138.12K
+
+Key name length Percentile Total keys
+--------------- ---------- -----------
+            19B  100.0000%          55
+Total key length is 495B (9B avg)
+
+Type        Total keys  Keys % Tot size Avg size  Total length/card Avg ln/card
+--------- ------------ ------- -------- -------- ------------------ -----------
+list                 1   1.82%     104B     104B            1 items        1.00
+string              16  29.09%    1.33K      85B               149B          9B
+MBbloomCF            1   1.82%    1.00M    1.00M                 -           - 
+hash                 1   1.82%     104B     104B           3 fields        3.00
+stream               3   5.45%   16.56K    5.52K          8 entries        2.67
+TDIS-TYPE            2   3.64%   19.19K    9.59K                 -           - 
+TopK-TYPE            1   1.82%  111.58K  111.58K                 -           - 
+set                  2   3.64%     208B     104B          5 members        2.50
+CMSk-TYPE            1   1.82%  140.68K  140.68K                 -           - 
+zset                 2   3.64%     304B     152B         11 members        5.50
+ReJSON-RL           25  45.45%   15.38K     629B                 -           - 
+```
+
+## Get a list of keys
+
+It is also possible to scan the key space, again in a way that does not
+block the Redis server (which does happen when you use a command
+like `KEYS *`), and print all the key names, or filter them for specific
+patterns. This mode, like the `--bigkeys` option, uses the [`SCAN`]({{< relref "/commands/scan" >}}) command,
+so keys may be reported multiple times if the dataset is changing, but no
+key would ever be missing, if that key was present since the start of the
+iteration. Because of the command that it uses this option is called `--scan`.
+
+    $ redis-cli --scan | head -10
+    key-419
+    key-71
+    key-236
+    key-50
+    key-38
+    key-458
+    key-453
+    key-499
+    key-446
+    key-371
+
+Note that `head -10` is used in order to print only the first ten lines of the
+output.
+
+Scanning is able to use the underlying pattern matching capability of
+the [`SCAN`]({{< relref "/commands/scan" >}}) command with the `--pattern` option.
+
+    $ redis-cli --scan --pattern '*-11*'
+    key-114
+    key-117
+    key-118
+    key-113
+    key-115
+    key-112
+    key-119
+    key-11
+    key-111
+    key-110
+    key-116
+
+Piping the output through the `wc` command can be used to count specific
+kind of objects, by key name:
+
+    $ redis-cli --scan --pattern 'user:*' | wc -l
+    3829433
+
+You can use `-i 0.01` to add a delay between calls to the [`SCAN`]({{< relref "/commands/scan" >}}) command.
+This will make the command slower but will significantly reduce load on the server.
+
+## Pub/sub mode
+
+The CLI is able to publish messages in Redis Pub/Sub channels using
+the [`PUBLISH`]({{< relref "/commands/publish" >}}) command. Subscribing to channels in order to receive
+messages is different - the terminal is blocked and waits for
+messages, so this is implemented as a special mode in `redis-cli`. Unlike
+other special modes this mode is not enabled by using a special option,
+but simply by using the [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}) or [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}}) command, which are available in
+interactive or command mode:
+
+    $ redis-cli PSUBSCRIBE '*'
+    Reading messages... (press Ctrl-C to quit)
+    1) "PSUBSCRIBE"
+    2) "*"
+    3) (integer) 1
+
+The *reading messages* message shows that we entered Pub/Sub mode.
+When another client publishes some message in some channel, such as with the command `redis-cli PUBLISH mychannel mymessage`, the CLI in Pub/Sub mode will show something such as:
+
+    1) "pmessage"
+    2) "*"
+    3) "mychannel"
+    4) "mymessage"
+
+This is very useful for debugging Pub/Sub issues.
+To exit the Pub/Sub mode just process `CTRL-C`.
+
+## Monitor commands executed in Redis
+
+Similarly to the Pub/Sub mode, the monitoring mode is entered automatically
+once you use the [`MONITOR`]({{< relref "/commands/monitor" >}}) command. All commands received by the active Redis instance will be printed to the standard output:
+
+    $ redis-cli MONITOR
+    OK
+    1460100081.165665 [0 127.0.0.1:51706] "set" "shipment:8000736522714:status" "sorting"
+    1460100083.053365 [0 127.0.0.1:51707] "get" "shipment:8000736522714:status"
+
+Note that it is possible to pipe the output, so you can monitor
+for specific patterns using tools such as `grep`.
+
+## Monitor the latency of Redis instances
+
+Redis is often used in contexts where latency is very critical. Latency
+involves multiple moving parts within the application, from the client library
+to the network stack, to the Redis instance itself.
+
+The `redis-cli` has multiple facilities for studying the latency of a Redis
+instance and understanding the latency's maximum, average and distribution.
+
+The basic latency-checking tool is the `--latency` option. Using this
+option the CLI runs a loop where the [`PING`]({{< relref "/commands/ping" >}}) command is sent to the Redis
+instance and the time to receive a reply is measured. This happens 100
+times per second, and stats are updated in a real time in the console:
+
+    $ redis-cli --latency
+    min: 0, max: 1, avg: 0.19 (427 samples)
+
+The stats are provided in milliseconds. Usually, the average latency of
+a very fast instance tends to be overestimated a bit because of the
+latency due to the kernel scheduler of the system running `redis-cli`
+itself, so the average latency of 0.19 above may easily be 0.01 or less.
+However this is usually not a big problem, since most developers are interested in
+events of a few milliseconds or more.
+
+Sometimes it is useful to study how the maximum and average latencies
+evolve during time. The `--latency-history` option is used for that
+purpose: it works exactly like `--latency`, but every 15 seconds (by
+default) a new sampling session is started from scratch:
+
+    $ redis-cli --latency-history
+    min: 0, max: 1, avg: 0.14 (1314 samples) -- 15.01 seconds range
+    min: 0, max: 1, avg: 0.18 (1299 samples) -- 15.00 seconds range
+    min: 0, max: 1, avg: 0.20 (113 samples)^C
+
+Sampling sessions' length can be changed with the `-i <interval>` option.
+
+The most advanced latency study tool, but also the most complex to
+interpret for non-experienced users, is the ability to use color terminals
+to show a spectrum of latencies. You'll see a colored output that indicates the
+different percentages of samples, and different ASCII characters that indicate
+different latency figures. This mode is enabled using the `--latency-dist`
+option:
+
+    $ redis-cli --latency-dist
+    (output not displayed, requires a color terminal, try it!)
+
+There is another pretty unusual latency tool implemented inside `redis-cli`.
+It does not check the latency of a Redis instance, but the latency of the
+computer running `redis-cli`. This latency is intrinsic to the kernel scheduler, 
+the hypervisor in case of virtualized instances, and so forth.
+
+Redis calls it *intrinsic latency* because it's mostly opaque to the programmer.
+If the Redis instance has high latency regardless of all the obvious things
+that may be the source cause, it's worth to check what's the best your system
+can do by running `redis-cli` in this special mode directly in the system you
+are running Redis servers on.
+
+By measuring the intrinsic latency, you know that this is the baseline,
+and Redis cannot outdo your system. In order to run the CLI
+in this mode, use the `--intrinsic-latency <test-time>`. Note that the test time is in seconds and dictates how long the test should run.
+
+    $ ./redis-cli --intrinsic-latency 5
+    Max latency so far: 1 microseconds.
+    Max latency so far: 7 microseconds.
+    Max latency so far: 9 microseconds.
+    Max latency so far: 11 microseconds.
+    Max latency so far: 13 microseconds.
+    Max latency so far: 15 microseconds.
+    Max latency so far: 34 microseconds.
+    Max latency so far: 82 microseconds.
+    Max latency so far: 586 microseconds.
+    Max latency so far: 739 microseconds.
+
+    65433042 total runs (avg latency: 0.0764 microseconds / 764.14 nanoseconds per run).
+    Worst run took 9671x longer than the average latency.
+
+IMPORTANT: this command must be executed on the computer that runs the Redis server instance, not on a different host. It does not connect to a Redis instance and performs the test locally.
+
+In the above case, the system cannot do better than 739 microseconds of worst
+case latency, so one can expect certain queries to occasionally run less than 1 millisecond.
+
+## Remote backups of RDB files
+
+During a Redis replication's first synchronization, the primary and the replica
+exchange the whole data set in the form of an RDB file. This feature is exploited
+by `redis-cli` in order to provide a remote backup facility that allows a
+transfer of an RDB file from any Redis instance to the local computer running
+`redis-cli`. To use this mode, call the CLI with the `--rdb <dest-filename>`
+option:
+
+    $ redis-cli --rdb /tmp/dump.rdb
+    SYNC sent to master, writing 13256 bytes to '/tmp/dump.rdb'
+    Transfer finished with success.
+
+This is a simple but effective way to ensure disaster recovery
+RDB backups exist of your Redis instance. When using this options in
+scripts or `cron` jobs, make sure to check the return value of the command.
+If it is non zero, an error occurred as in the following example:
+
+    $ redis-cli --rdb /tmp/dump.rdb
+    SYNC with master failed: -ERR Can't SYNC while not connected with my master
+    $ echo $?
+    1
+
+## Replica mode
+
+The replica mode of the CLI is an advanced feature useful for
+Redis developers and for debugging operations.
+It allows for the inspection of the content a primary sends to its replicas in the replication
+stream in order to propagate the writes to its replicas. The option
+name is simply `--replica`. The following is a working example:
+
+    $ redis-cli --replica
+    SYNC with master, discarding 13256 bytes of bulk transfer...
+    SYNC done. Logging commands from master.
+    "PING"
+    "SELECT","0"
+    "SET","last_name","Enigk"
+    "PING"
+    "INCR","mycounter"
+
+The command begins by discarding the RDB file of the first synchronization
+and then logs each command received in CSV format.
+
+If you think some of the commands are not replicated correctly in your replicas
+this is a good way to check what's happening, and also useful information
+in order to improve the bug report.
+
+## Perform an LRU simulation
+
+Redis is often used as a cache with [LRU eviction]({{< relref "/develop/reference/eviction" >}}).
+Depending on the number of keys and the amount of memory allocated for the
+cache (specified via the `maxmemory` directive), the amount of cache hits
+and misses will change. Sometimes, simulating the rate of hits is very
+useful to correctly provision your cache.
+
+The `redis-cli` has a special mode where it performs a simulation of GET and SET
+operations, using an 80-20% power law distribution in the requests pattern.
+This means that 20% of keys will be requested 80% of times, which is a
+common distribution in caching scenarios.
+
+Theoretically, given the distribution of the requests and the Redis memory
+overhead, it should be possible to compute the hit rate analytically
+with a mathematical formula. However, Redis can be configured with
+different LRU settings (number of samples) and LRU's implementation, which
+is approximated in Redis, changes a lot between different versions. Similarly
+the amount of memory per key may change between versions. That is why this
+tool was built: its main motivation was for testing the quality of Redis' LRU
+implementation, but now is also useful for testing how a given version
+behaves with the settings originally intended for deployment.
+
+To use this mode, specify the amount of keys in the test and configure a sensible `maxmemory` setting as a first attempt.
+
+IMPORTANT NOTE: Configuring the `maxmemory` setting in the Redis configuration
+is crucial: if there is no cap to the maximum memory usage, the hit will
+eventually be 100% since all the keys can be stored in memory. If too many keys are specified with maximum memory, eventually all of the computer RAM will be used. It is also needed to configure an appropriate
+*maxmemory policy*; most of the time `allkeys-lru` is selected.
+
+In the following example there is a configured a memory limit of 100MB and an LRU
+simulation using 10 million keys.
+
+WARNING: the test uses pipelining and will stress the server, don't use it
+with production instances.
+
+    $ ./redis-cli --lru-test 10000000
+    156000 Gets/sec | Hits: 4552 (2.92%) | Misses: 151448 (97.08%)
+    153750 Gets/sec | Hits: 12906 (8.39%) | Misses: 140844 (91.61%)
+    159250 Gets/sec | Hits: 21811 (13.70%) | Misses: 137439 (86.30%)
+    151000 Gets/sec | Hits: 27615 (18.29%) | Misses: 123385 (81.71%)
+    145000 Gets/sec | Hits: 32791 (22.61%) | Misses: 112209 (77.39%)
+    157750 Gets/sec | Hits: 42178 (26.74%) | Misses: 115572 (73.26%)
+    154500 Gets/sec | Hits: 47418 (30.69%) | Misses: 107082 (69.31%)
+    151250 Gets/sec | Hits: 51636 (34.14%) | Misses: 99614 (65.86%)
+
+The program shows stats every second. In the first seconds the cache starts to be populated. The misses rate later stabilizes into the actual figure that can be expected:
+
+    120750 Gets/sec | Hits: 48774 (40.39%) | Misses: 71976 (59.61%)
+    122500 Gets/sec | Hits: 49052 (40.04%) | Misses: 73448 (59.96%)
+    127000 Gets/sec | Hits: 50870 (40.06%) | Misses: 76130 (59.94%)
+    124250 Gets/sec | Hits: 50147 (40.36%) | Misses: 74103 (59.64%)
+
+A miss rate of 59% may not be acceptable for certain use cases therefor
+100MB of memory is not enough. Observe an example using a half gigabyte of memory. After several
+minutes the output stabilizes to the following figures:
+
+    140000 Gets/sec | Hits: 135376 (96.70%) | Misses: 4624 (3.30%)
+    141250 Gets/sec | Hits: 136523 (96.65%) | Misses: 4727 (3.35%)
+    140250 Gets/sec | Hits: 135457 (96.58%) | Misses: 4793 (3.42%)
+    140500 Gets/sec | Hits: 135947 (96.76%) | Misses: 4553 (3.24%)
+
+With 500MB there is sufficient space for the key quantity (10 million) and distribution (80-20 style).
+---
+aliases: /develop/connect/insight/copilot-faq
+categories:
+- docs
+- operate
+- redisinsight
+linkTitle: Redis Copilot FAQ
+title: Redis Copilot FAQ
+weight: 3
+---
+
+## 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). 
+
+### How does Redis Copilot work?
+Redis Copilot is powered by the [OpenAI API](https://platform.openai.com/docs/overview) platform. When it needs to provide context-aware assistance, such as within the **my data** chat in Redis Insight, Redis Copilot will use data from your connected database. Some of that data, such as indexing schemas and sample keys, may be transmitted to the Redis Copilot backend and OpenAI for processing.
+
+### What kind of tasks can Redis Copilot perform?
+
+Currently, Redis Copilot provides two primary features: a general chatbot and a context-aware data chatbot.
+
+**General chatbot**: the knowledge-based chatbot serves as an interactive and dynamic documentation interface to simplify the learning process. You can ask specific questions about Redis commands, concepts, and products, and get responses on the fly. The general chatbot is also available in our public docs.
+
+**My data chatbot**: the context-aware chatbot available in Redis Insight lets you construct search queries using everyday language rather than requiring specific programming syntax. This feature lets you query and explore data easily and interactively without extensive technical knowledge.
+
+### How do I get started with Redis Copilot in Redis Insight?
+
+The Redis Copilot instance within our public documentation is free for anyone to use and is available now to answer general questions about Redis.
+
+The Redis Copilot instance that is embedded in Redis Insight is gradually being rolled out to the user base. Once you are granted access to Redis Copilot in the app, you need to sign in with your Redis Cloud account before you can start using it. If you don’t have an account with Redis Cloud yet, it will be automatically created when you sign in at no extra cost to you. 
+
+## Data and Privacy
+
+### What data does Redis Copilot have access to in my database?
+
+Redis Copilot will have access to any relevant data stored in your database to provide context-aware assistance.
+However, this only impacts the **my data** chat in Redis Insight.
+
+### Will OpenAI use my data to train their models? 
+
+OpenAI states that the data provided via OpenAI API is not used for training. Please see the [OpenAI API data privacy page](https://openai.com/api-data-privacy) for the latest information.
+
+### What are the Redis Copilot terms? 
+
+Redis Copilot terms apply to your use of or access to Redis Copilot. They set out what you can expect from Redis Copilot concerning its capabilities and limitations and how Redis Copilot handles your data.
+
+## Feedback
+
+### How can I provide feedback or report a bug?
+
+Redis Copilot is released as Beta in Redis Insight. We welcome your feedback and bug reports. You can submit them through the feedback form available in the [Redis Insight GitHub repository](https://github.com/RedisInsight/RedisInsight).
+
+
+---
+Title: RedisInsight v1.5, May 2020 
+linkTitle: v1.5 (May 2020)
+date: 2020-05-12 00:00:00 +0000
+description: New tool for RedisGears, Multi-line query builder and improved suppport of Redis 6 ACLs
+weight: 95
+---
+
+This is the General Availability Release of RedisInsight 1.5 (v1.5.0)!
+
+### Headlines
+
+- Added beta support for [RedisGears module](https://oss.redislabs.com/redisgears/)
+- Added multi-line query editing for RediSearch, RedisGraph and Timeseries
+- Improved support of Redis 6 ACLs
+
+### Full details:
+
+- Features
+    - Core:
+        - Improved support for Redis 6 managing ACL permissions for each different capabilities
+    - Gears:
+        - Beta support for [Redis Gears module](https://oss.redislabs.com/redisgears/)
+            - Explore the latest executed functions and analyze the results or errors
+            - Manage registered functions and get execution summary
+            - Code, build and execute functions
+    - RediSearch:
+        - Multi-line for building queries
+    - RedisGraph:
+        - Multi-line for building queries
+    - Timeseries:
+        - Multi-line for building queries
+
+- Bug Fixes:
+    - Configuration:
+        - Fixed issue not showing the list of modules
+    - Search:
+        - Fixed issue preventing users to see all documents matching a search query
+        - Fixed issue with retrieving the search indexes in case of large database
+---
+Title: Redis Insight v2.60.0, October 2024
+linkTitle: v2.60.0 (October 2024)
+date: 2024-10-30 00:00:00 +0000
+description: Redis Insight v2.60
+weight: 1
+
+---
+## 2.60 (October 2024)
+This is the General Availability (GA) release of Redis Insight 2.60.
+
+### Highlights
+- Advanced and schema-aware command auto-complete for [Redis Query Engine](https://redis.io/docs/latest/develop/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=release_notes) is now available in Workbench, enabling faster and more accurate query building with smart suggestions for indexes, schemas, and expressions.
+- Support for adding multiple elements to the head or tail of lists, for both new or existing keys.
+- Multiple UI enhancements for clarity and ease of use when editing Redis Data Integration (RDI) jobs.
+
+### Details
+
+**Features and improvements**
+- [#3553](https://github.com/RedisInsight/RedisInsight/pull/3553), [#3647](https://github.com/RedisInsight/RedisInsight/pull/3647), [#3669](https://github.com/RedisInsight/RedisInsight/pull/3669) Advanced, schema-aware auto-complete for [Redis Query Engine](https://redis.io/docs/latest/develop/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=release_notes) in Workbench. Enjoy faster query building with context-sensitive suggestions that recognize indexes, schemas, and fields based on your current query. Start typing any [Redis Query Engine](https://redis.io/docs/latest/commands/?group=search) command in Workbench to try this feature. 
+- [#3891](https://github.com/RedisInsight/RedisInsight/pull/3891) Allows to easily push multiple elements to the head or tail of list data types, whether creating new or updating existing lists.
+- [#3891](https://github.com/RedisInsight/RedisInsight/pull/3891) UX/UI enhancements to provide more details about Redis Data Integration (RDI) job transformation and output results in the dry-run section.
+- [#3981](https://github.com/RedisInsight/RedisInsight/pull/3981) Removes confirmation prompts for template insertions in Redis Data Integration jobs, simplifying a workflow.
+- [#3827](https://github.com/RedisInsight/RedisInsight/pull/3827) Provides easy-to-understand metrics of network input/output by automatically converting units in Browser Overview.
+- [#3982](https://github.com/RedisInsight/RedisInsight/pull/3982), [#3975](https://github.com/RedisInsight/RedisInsight/pull/3975), [#3941](https://github.com/RedisInsight/RedisInsight/pull/3941) Various vulnerabilities have been fixed.
+---
+Title: Redis Insight v2.56.0, September 2024
+linkTitle: v2.56.0 (September 2024)
+date: 2024-09-09 00:00:00 +0000
+description: Redis Insight v2.56
+weight: 1
+
+---
+## 2.56 (September 2024)
+This is the General Availability (GA) release of Redis Insight 2.56.
+
+### Highlights
+- Seamlessly sign in to your Redis Cloud account using the new [SAML single sign-on](https://redis.io/docs/latest/operate/rc/security/access-control/saml-sso/) feature, now available alongside existing social logins via Google and GitHub. This integration lets you connect to all your Redis Cloud databases in several clicks.
+- Start your Redis journey faster with a sample data set automatically loaded for new free Redis Cloud databases created directly within Redis Insight.
+- Focus on what matters most:
+  - Hide or show [TTL for individual hash fields](https://redis.io/docs/latest/develop/data-types/hashes/?utm_source=redisinsight&utm_medium=release_notes&utm_campaign=2.52#field-expiration) to create a cleaner, more efficient workspace.
+  - Enhanced vector data representation with updated 32-bit and 64-bit vector formatters in the Browser.
+  - UX optimizations to make it easier and more intuitive to connect to your [Redis Data Integration (RDI)](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) instance within Redis Insight.
+
+
+### Details
+
+**Features and improvements**
+- [#3727](https://github.com/RedisInsight/RedisInsight/pull/3727) Seamlessly sign in to your Redis Cloud account using the new [SAML single sign-on](https://redis.io/docs/latest/operate/rc/security/access-control/saml-sso/) feature, now available alongside existing social logins via Google and GitHub. This integration lets you connect to all your Redis Cloud databases in several clicks. Before setting up SAML in Redis Cloud, you must first [verify domain ownership](https://redis.io/docs/latest/operate/rc/security/access-control/saml-sso/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) for any domains associated with your SAML setup. Note that integration with Redis Cloud is currently available only in the desktop version of Redis Insight.
+- [#3659](https://github.com/RedisInsight/RedisInsight/pull/3659) Start your Redis journey faster with a sample data set automatically loaded for new free Redis Cloud databases created directly within Redis Insight. This feature ensures a smoother setup process, allowing you to dive into your data immediately.
+- [#3624](https://github.com/RedisInsight/RedisInsight/pull/3624) The ability to hide or show [TTL for individual hash fields](https://redis.io/docs/latest/develop/data-types/hashes/?utm_source=redisinsight&utm_medium=release_notes&utm_campaign=2.52#field-expiration) to create a cleaner, more efficient workspace. This optimization complements the highly requested hash field expiration feature introduced in the [first release candidate of Redis 7.4](https://github.com/redis-stack/redis-stack/releases/tag/v7.4.0-v0).
+- [#3701](https://github.com/RedisInsight/RedisInsight/pull/3701) Enhanced vector data representation with updated 32-bit and 64-bit vector formatters in the Browser. These changes ensure that vector formatters are applied only to data containing unprintable values when converted to UTF-8, providing a clearer and more accurate view of your data.
+- [#3714](https://github.com/RedisInsight/RedisInsight/pull/3714) UX optimizations to make it easier and more intuitive to connect to your [Redis Data Integration (RDI)](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) instance within Redis Insight.
+- [#3665](https://github.com/RedisInsight/RedisInsight/pull/3665) A new timestamp formatter in the Browser to improve data readability. This formatter converts timestamps in hash fields to a human-readable format, making it easier to interpret results, validate and optimize queries, and inspect indexed data when using the [Redis Query Engine](https://redis.io/docs/latest/develop/interact/search-and-query/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes).
+- [#3730](https://github.com/RedisInsight/RedisInsight/pull/3730) Date and time format customization to make the data more intuitive in Redis Insight. This flexibility helps match your local time zone or standardize it to UTC for better alignment in time-critical operations across global teams.
+---
+Title: RedisInsight v1.11, Oct 2021
+linkTitle: v1.11 (Oct 2021)
+date: 2021-10-17 00:00:00 +0000
+description: RedisInsight v1.11.0
+weight: 89
+---
+
+## 1.11.1 (January 2022)
+
+This is the maintenance release of RedisInsight 1.11 (v1.11.1)!
+
+### Fixes:
+
+- Core:
+  - Fixed a warning about `urllib` version deprecation.
+  - ACL errors are now show in pretty format while in edit database screen.
+  - Fixed unnecessary warning about segment when there's no internet connection.
+- RediSearch:
+  - Fix index tool support for `v2.2.5`.
+- Bulk actions:
+  - Added support for cross-slot bulk action execution.
+  - Fixed a bug where there's a failure when a malformed UTF-8 characters are present in the key.
+- Memory Analysis:
+  - Added support for `quicklist2` data type.
+- Cluster Management:
+  - Generic errors are also displayed in the tool. This is helpful when connected to a vendor provided redis with custom exceptions.
+
+## 1.11.0
+
+This is the General Availability Release of RedisInsight 1.11 (v1.11.0)!
+
+### Headlines:
+- Added beta support for [RedisAI](https://oss.redis.com/redisai/)
+- Fixed the issue with empty fields for Hash objects.
+
+### Full Details:
+- Core:
+  - Fixed a bug where editing cluster returns error.
+  - Fixed broken redis links.
+- Browser
+  - Check Hash value for `emptiness`
+- RedisGraph:
+  - Added support for point datatype.
+  - Fixed a bug where returning relationships without their respective nodes leads to infinite loading
+- RediSearch:
+  - Fixed a bug where a malformed unicode string in redisearch doesn't produce results.
+- RedisTimeseries:
+  - Added support for `TS.REVRANGE` and `TS.MREVRANGE` commands.
+---
+Title: RedisInsight v1.9, January 2021
+linkTitle: v1.9 (Jan 2021)
+date: 2020-01-15 00:00:00 +0000
+description: RedisInsight v1.9.0
+weight: 91
+---
+
+## 1.9.0 (January 2021)
+
+This is the General Availability Release of RedisInsight 1.9 (v1.9.0)!
+
+### Headlines:
+
+- RedisGraph tools is getting improved with better UX and new interactions capabilities
+- Adding the ability to configure a database, by just using its direct URL to auto fill all required fields
+- CLI is now providing ability to configure your favorite key-bindings between Emacs or Vim
+
+### Full Details:
+
+- Core:
+    - Support for configuration of Redis where the number of databases goes over the default 16.
+    - Ability to add a Redis database using a shareable URL.
+- RedisGraph
+    - UX improvements for large queries: fixed long pause while results are being rendered.
+    - Made various improvements to interactions with the graph visualization:
+    - Selected node's size increased to make it easier to distinguish.
+    - Zoom via mouse wheel.
+    - Double click to zoom in.
+    - Double right-click to zoom out.
+    - Keyboard shortcuts to zoom.
+    - Center on node on fetching direct neighbours.
+    - Halo masking indirect edges on selected node.
+    - Button to reset view: center entire graph.
+    - Button to center on the selected node.
+    - New zoom buttons
+- CLI
+    - Basic navigation key-bindings for Emacs and Vim.
+    - UX improvements: the inputs and other controls are now disabled and a message is shown while the command is executing.
+---
+Title: RedisInsight v2.40.0, December 2023
+linkTitle: v2.40.0 (December 2023)
+date: 2023-12-27 00:00:00 +0000
+description: RedisInsight v2.40
+weight: 1
+---
+## 2.40 (December 2023)
+This is the General Availability (GA) release of RedisInsight 2.40.
+
+### Highlights
+- To simplify in-app provisioning of a free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_40) database to use with RedisInsight interactive tutorials, the recommended cloud vendor and region are now preselected 
+- Optimizations when uploading large text files with the list of Redis commands, available under bulk actions in Browser
+
+### Details
+
+**Features and improvements**
+- [#2879](https://github.com/RedisInsight/RedisInsight/pull/2879) UX improvements to simplify in-app provisioning of a free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_40) database. Create a new database with a preselected cloud vendor and region by using the recommended sign-up settings. You can manage your database by signing in to the [Redis Cloud console](https://cloud.redis.io/#/databases?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_40)
+- [#2851](https://github.com/RedisInsight/RedisInsight/pull/2851) See plan, cloud vendor, and region details after successfully provisioning your free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_40) database
+- [#2882](https://github.com/RedisInsight/RedisInsight/pull/2882) Optimizations when uploading large text files with the list of Redis commands, available under bulk actions in Browser
+- [#2808](https://github.com/RedisInsight/RedisInsight/pull/2808) Enhanced security measurement to no longer display existing passwords for Redis Sentinel in plain text
+- [#2875](https://github.com/RedisInsight/RedisInsight/pull/2875) Increased performance when resizing the key list and key details in the Tree view, ensuring a smoother user experience
+- [#2866](https://github.com/RedisInsight/RedisInsight/pull/2866) Support for hyphens in [node host names](https://github.com/RedisInsight/RedisInsight/issues/2865)
+
+**Bugs**
+- [#2868](https://github.com/RedisInsight/RedisInsight/pull/2868) Prevent [unintentional data overwrites](https://github.com/RedisInsight/RedisInsight/issues/2791) by disabling both manual and automatic refreshing of key values while editing in the Browser
+---
+Title: RedisInsight v1.8, November 2020
+linkTitle: v1.8 (Nov 2020)
+date: 2020-11-11 00:00:00 +0000
+description: RedisInsight v1.8.0
+weight: 92
+---
+
+## 1.8.3 (January 2021)
+
+This is a maintenance release of RedisInsight 1.8 (v1.8.3)!
+
+This fixes the crash on MacOS Big Sur (11.1) for the MacOS package.
+RedisInsight is supported on Mac hardware with Intel chips, but not for Mac hardware with the Apple M1 (ARM) chip.
+
+## 1.8.2 (24 December 2020)
+
+This is the maintenance release of RedisInsight 1.8 (v1.8.2)!
+
+### Fixes:
+
+- Browser:
+    - Improved handling of large strings, lists, hashes, sets and sorted sets.
+    - Better error message when loading a key's value fails.
+    - More robust handling of Java serialized objects - malformed Java serialized objects are now displayed as binary strings.
+    - Increased the default width of the key selector.
+- Memory Analysis:
+    - Fixed crash on databases with modules that store auxiliary module data in the RDB (RediSearch 2, RedisGears, etc.).
+    - Fix integer overflow which results in the size of large keys not being reported properly.
+    - Add Streams statistics to the charts shown in the Memory Analysis Overview tool.
+    - Better error message when online analysis fails due to both the `SYNC` and `DUMP` commands being unavailable.
+
+## 1.8.1 (17 December 2020)
+
+Maintenance release for RedisInsight 1.8 including bug fixes and enhancements.
+
+### Important Note:
+
+We'd love to learn more how you are using RedisInsight. Now we have a user survey in the application, but you can also get to it [here](https://www.surveymonkey.com/r/ZZVR2ZG). 
+
+### Fixes:
+
+- Core:
+    - Fixed placeholder page for modules which was not appearing on desktop packagings of RedisInsight.
+    - Fixed error in handling disconnection to databases on desktop packaging of RedisInsight.
+    - Fixed auto-fill-on-URL-paste when adding Redis databases.
+    - Fixed add database form: scroll to error message if adding a database fails.
+    - Fixed typo in Settings page.
+- CLI:
+    - Fixed on the repeat command option which was not properly cleared when the command was changed.
+
+## 1.8.0 (November 2020)
+
+This is the General Availability Release of RedisInsight 1.8 (v1.8.0)!
+
+### Important Note:
+We'd love to learn more how you are using RedisInsight. We introduce a user survey, you'll see it in the application, but it's happening [here](https://www.surveymonkey.com/r/ZZVR2ZG). 
+
+
+### Headlines:
+
+- Guided experience to get started with RedisInsight, add a database and experiment with modules
+- CLI now supports "help" commands and lets you repeat commands
+- Ability to provide your CA Certificate and skip-verify option for TLS authentications
+- Ability to display RediSearch indices summary
+- Adding a database is getting simpler by auto-filling all database information from the Redis connection URL
+- New environment variables for configuring HOST, PORT and application LOG LEVEL
+- Support for RedisJSON on Redis Cluster
+
+
+### Full Details:
+
+- Core:
+    - New welcome page when no databases are configured
+    - New information pages for each modules, when they are not configured
+    - New environment variables for configuring HOST, PORT and application LOG LEVEL
+    - Ability to add a CA Certificate and skip-verify for TLS authentications
+    - Added auto-filling database details from Redis Connection URL
+- Browser:
+    - Added error message when trying to visualize large keys
+    - Fixed issue when copying key with " character
+- RedisGraph, RediSearch, RedisTimeseries:
+    - Added ability to copy commands with a button click
+- RedisSearch:
+    - Display the selected Index's Summary
+- RedisGraph:
+    - Added ability to persist nodes display choices between queries
+- ReJSON:
+    - Support for RedisJSON on Redis Cluster
+- ClientList:
+    - Sort clients by type
+- CLI:
+    - Added support for the `help` command in CLI
+    - Added ability to repeat commands multiple times with increments
+    - Added the ability to close the Hint window
+    - Added stream command assists
+- Profiler:
+    - Fixed issue with TLS databases
+---
+Title: RedisInsight v1.10, March 2021
+linkTitle: v1.10 (Mar 2021)
+date: 2021-03-08 00:00:00 +0000
+description: RedisInsight v1.10.0
+weight: 90
+---
+
+## 1.10.1 (April 2021)
+
+This is the maintenance release of RedisInsight 1.10 (v1.10.1)!
+
+### Fixes:
+
+- Core:
+  - Fixed a bug where launching RedisInsight on macOS mojave (10.14.6) would log out the user.
+  - Fixed two major container vulnerability. (CVE-2021-24031, CVE-2021-24032 and CVE-2020-36242)
+  - Select existing installation path on upgrades in Windows.
+- CLI:
+  - Added support for RAW mode (`--raw` in `redis-cli`).
+- Browser:
+  - Fixed a bug where a number in redis string datatype is treated as a JSON .
+  -  RedisJSON - Distinguish between empty and collapsed objects/arrays.
+- Streams:
+  - Added ability to configure auto refresh interval.
+- RedisTimeseries:
+  - Charts now support milliseconds.
+  - Added ability to configure auto refresh interval.
+- RedisGraph:
+  - Properly detect module in Redis Enterprise
+  - Large queries that are truncated in the query card is provided with a tooltip that displays the query on hover.
+  - Properly render boolean data types in the objects.
+- Bulk actions:
+  - Fixed a bug where preview returns duplicate dry run commands.
+
+
+## 1.10.0 (March 2021)
+
+This is the General Availability (GA) Release of RedisInsight 1.10 (v1.10.0)!
+
+### Headlines:
+- Improvements to the way the Browser tool displays "special" strings.
+- UX improvements to the RedisGraph tool.
+- Ability to configure the slowlog threshold from within the Slowlog tool.
+
+### Full Details:
+- Overview:
+    - The connection details of the Redis database are now displayed.
+    - A message is displayed to indicate a cluster with no replicas instead of an empty table.
+    - Fixed a bug where the memory usage chart would display an incorrect graph when the memory usage changes rapidly.
+- Browser:
+    - Pretty-print "special" strings (like JSON, Java serialized object, Python pickle objects, etc.) once the entire value is loaded.
+    - Pretty-print "special" strings (like JSON, Java serialized object, Python pickle objects, etc.) inside container types like Hashes, Sets and Sorted Sets.
+    - Allow sorting the members of a sorted set by score.
+    - Refresh button for the key list.
+    - Delete a key by pressing the "Delete" key.
+    - All keys are now visible by default, i.e, the data type filters are disabled by default.
+    - Fixed bug where switching logical databases did not work correctly sometimes.
+    - Fixed bug where adding a field to a hash with an empty value crashes the UI.
+    - Fixed bug where setting TTL to -1 does not effectively delete the key.
+    - Added tooltip explaining how to use the logical database selector along with a submit button.
+- Streams:
+    - Refresh button for the list of streams.
+- RedisGraph:
+    - Node size is now dependent on the number of direct relationships.
+    - Added support for pasting the full `GRAPH.QUERY` command into the query textbox.
+- RediSearch:
+    - Fixed bug where the application fails to execute queries on indices starting with/enclosed within single-quotes.
+- Bulk Actions:
+    - Improved support for operations on a large number of keys.
+- Slowlog:
+    - Allow configuring the slowlog threshold from within the tool for non-cluster databases.
+---
+Title: RedisInsight v2.16.0, December 2022
+linkTitle: v2.16.0 (Dec 2022)
+date: 2022-12-28 00:00:00 +0000
+description: RedisInsight v2.16.0
+weight: 2
+---
+## 2.16.0 (December 2022)
+This is the General Availability (GA) release of RedisInsight 2.16.
+
+### Highlights
+- Bulk import database connections from a file
+- Navigation enhancements for the Tree view
+- Pre-populated host, port, and database alias in the form when adding a new Redis database
+
+
+### Details
+**Features and improvements**
+- [#1492](https://github.com/RedisInsight/RedisInsight/pull/1492), [#1497](https://github.com/RedisInsight/RedisInsight/pull/1497), [#1500](https://github.com/RedisInsight/RedisInsight/pull/1500), [#1502](https://github.com/RedisInsight/RedisInsight/pull/1502) Migrate your database connections from other Redis GUIs, including RESP.app, with the new feature to bulk import database connections from a file.
+- [#1506](https://github.com/RedisInsight/RedisInsight/pull/1506) Pre-populated host (127.0.0.1), port (6379, or 26379 for [Sentinel](https://redis.io/docs/management/sentinel/) connection type), and database alias in the form when adding a new Redis database
+- [#1473](https://github.com/RedisInsight/RedisInsight/pull/1473) **Browser** view is renamed **List** view to avoid confusion with the Browser tool
+- [#1464](https://github.com/RedisInsight/RedisInsight/pull/1464) Navigation enhancements for the Tree view, covering cases when filters are applied, the list of keys is refreshed or the view is switched to the Tree view
+- [#1481](https://github.com/RedisInsight/RedisInsight/pull/1481), [#1482](https://github.com/RedisInsight/RedisInsight/pull/1482), [#1489](https://github.com/RedisInsight/RedisInsight/pull/1489) Indication of new database connections that have been manually added, auto-discovered or imported, but not opened yet
+- [#1499](https://github.com/RedisInsight/RedisInsight/pull/1499) Display values of [JSON](https://redis.io/docs/stack/json/) keys when [JSON.DEBUG MEMORY](https://redis.io/commands/json.debug-memory/) is not available
+
+**Bugs**
+- [#1514](https://github.com/RedisInsight/RedisInsight/pull/1514) Scan the database even when the [DBSIZE](https://redis.io/commands/dbsize/) returns 0
+---
+Title: RedisInsight v2.20.0, February 2023
+linkTitle: v2.20.0 (Feb 2023)
+date: 2023-02-28 00:00:00 +0000
+description: RedisInsight v2.20.0
+weight: 1
+---
+## 2.20.0 (February 2023)
+This is the General Availability (GA) release of RedisInsight 2.20.
+
+### Highlights
+- Visualizations of [search](https://redis.io/docs/stack/search/) and [graph](https://redis.io/docs/stack/graph/) execution plans in Workbench
+- Guided walkthrough of RedisInsight tools and capabilities for new users
+- Bulk export database connections to a file
+- Upload values of [RedisJSON](https://redis.io/docs/stack/json/) from a file for new keys in Browser
+- Visualizations of [CLIENT LIST](https://redis.io/commands/client-list/) in Workbench
+- See filters previously used in Browser
+
+### Details
+**Features and improvements**
+- [#1629](https://github.com/RedisInsight/RedisInsight/pull/1629), [#1739](https://github.com/RedisInsight/RedisInsight/pull/1739), [#1740](https://github.com/RedisInsight/RedisInsight/pull/1740), [#1781](https://github.com/RedisInsight/RedisInsight/pull/1781) Investigate and optimize your [search](https://redis.io/docs/stack/search/) and [graph](https://redis.io/docs/stack/graph/) queries with new visualizations of execution plans in Workbench. Visualizations are supported for [FT.EXPLAIN](https://redis.io/commands/ft.explain/),[FT.PROFILE](https://redis.io/commands/ft.profile/), [GRAPH.EXPLAIN](https://redis.io/commands/graph.explain/), and [GRAPH.PROFILE](https://redis.io/commands/graph.profile/).
+- [#1698](https://github.com/RedisInsight/RedisInsight/pull/1698) Explore RedisInsight's tools and capabilities with a new walkthrough when you start RedisInsight for the first time.
+- [#1631](https://github.com/RedisInsight/RedisInsight/pull/1631), [#1632](https://github.com/RedisInsight/RedisInsight/pull/1632) Migrate your database connections to another RedisInsight instance by performing a bulk export of database connections to a file.
+- [#1741](https://github.com/RedisInsight/RedisInsight/pull/1741) Upload [RedisJSON](https://redis.io/docs/stack/json/) values from a file for new keys in Browser.
+- [#1653](https://github.com/RedisInsight/RedisInsight/pull/1653) Analyze client connections using new Workbench visualizations for [CLIENT LIST](https://redis.io/commands/client-list/).
+- [#1625](https://github.com/RedisInsight/RedisInsight/pull/1625) Quickly set filters previously used in Browser by selecting them from the list of recently used filters.
+- [#1713](https://github.com/RedisInsight/RedisInsight/pull/1713) See your new Redis keys added in Browser without a need to refresh the list of keys.
+- [#1681](https://github.com/RedisInsight/RedisInsight/pull/1681), [#1692](https://github.com/RedisInsight/RedisInsight/pull/1692), [#1693](https://github.com/RedisInsight/RedisInsight/pull/1693) Avoid the timeout connection errors by configuring the connection timeout for databases added manually via host and port.
+- [#1696](https://github.com/RedisInsight/RedisInsight/pull/1696), [#1703](https://github.com/RedisInsight/RedisInsight/pull/1703) Test the database connection before adding the database.
+- [#1689](https://github.com/RedisInsight/RedisInsight/pull/1689) Update the port of an existing database connection instead of adding a new one.
+- [#1731](https://github.com/RedisInsight/RedisInsight/pull/1731) Use database indexes based on [INFO keyspace](https://redis.io/commands/info/).
+
+**Bugs**
+- [#1678](https://github.com/RedisInsight/RedisInsight/pull/1678) Prevent crashes when SSH is set up on Linux.
+- [#1697](https://github.com/RedisInsight/RedisInsight/pull/1697) Prevent crashes when working with [Redis streams](https://redis.io/docs/data-types/streams) with large IDs.
+---
+Title: RedisInsight v2.36.0, October 2023
+linkTitle: v2.36.0 (October 2023)
+date: 2023-10-26 00:00:00 +0000
+description: RedisInsight v2.36
+weight: 1
+---
+## 2.36 (October 2023)
+This is the General Availability (GA) release of RedisInsight 2.36.
+
+### Highlights
+ 
+- Optimizations for efficient handling of big [Redis strings](https://redis.io/docs/data-types/strings/): choose to either view the string value for up to a maximum of 5,000 characters or download the data fully as a file if it exceeds the limit
+- Improved security measurement to no longer display in plain text existing database passwords, SSH passwords, passphrases, and private keys
+ 
+### Details
+ 
+**Features and improvements**
+- [#2685](https://github.com/RedisInsight/RedisInsight/pull/2685), [#2686](https://github.com/RedisInsight/RedisInsight/pull/2686) Added optimizations for working with big [Redis strings](https://redis.io/docs/data-types/strings/). Users can now choose to either view the data up to a maximum of 5,000 characters or download it in a file fully if it exceeds the limit.
+- [#2647](https://github.com/RedisInsight/RedisInsight/pull/2647) Improved security measurement to no longer expose the existing database passwords, SSH passwords, passphrases, and private keys in plain text
+- [#2631](https://github.com/RedisInsight/RedisInsight/pull/2631) Added proactive notification to restart the application when a new version becomes available
+- [#2705](https://github.com/RedisInsight/RedisInsight/pull/2705) Basic support in the [search index](https://redis.io/docs/interact/search-and-query/) creation form (in Browser) to enable [geo polygon](https://redis.io/commands/ft.create/#:~:text=Vector%20Fields.-,GEOSHAPE,-%2D%20Allows%20polygon%20queries) search
+- [#2681](https://github.com/RedisInsight/RedisInsight/pull/2681) Updated the Pickle formatter to [support](https://github.com/RedisInsight/RedisInsight/issues/2260) Pickle protocol 5
+ 
+**Bugs**
+- [#2675](https://github.com/RedisInsight/RedisInsight/pull/2675) Show the "Scan more" control until the cursor returned by the server is 0 to fix [cases](https://github.com/RedisInsight/RedisInsight/issues/2618) when not all keys are displayed.
+---
+Title: RedisInsight v1.4, April 2020 
+linkTitle: v1.4 (Apr 2020)
+date: 2020-04-29 00:00:00 +0000
+description: Redis 6 ACLs support, improved CLI and full screen support in Graph, TimeSeries and RedisSearch
+weight: 96
+---
+
+This is the General Availability Release of RedisInsight 1.4 (v1.4.0)!
+
+### Headlines
+
+- Support for Redis 6, Redis Enterprise 6 and ACLs
+- Improve CLI capabilities with removed command restrictions
+- Full screen support in Graph, TimeSeries and RediSearch
+
+### Full details:
+
+- Features
+    - Core:
+        - Added support for Redis 6 + RE6 and authentication using ACL
+        - Added Full screen support for Graph, TimeSeries and RediSearch.  
+        - Improved UI consistency (colors and styles) in Graph and Timeseries
+    - CLI:
+        - Removed the command restrictions, unless a command is specifically blacklisted.
+        - Command responses are displayed in exactly the same way as in `redis-cli`
+    - RedisGraph:
+        - Optimized performances when getting nodes relationships (edges) from user's queries
+    - Stream:
+        - Improved UX when defining the timing range of events to be filtered
+
+- Bug Fixes:
+    - Core:
+        - Fixed issue when connecting to Redis Enterprise with a password using a special character
+    - Stream:
+        - Fixed ability to properly visualize all events
+
+### Known issues
+
+- Core:
+    - Authentication to Redis 6 OSS in cluster mode is not supported yet
+- CLI:
+    - Blocking commands are not supported
+    - Commands which return non-standard streaming responses are not supported: `MONITOR, SUBSCRIBE, PSUBSCRIBE, SYNC, PSYNC, SCRIPT DEBUG`
+---
+Title: Redis Insight v2.50.0, May 2024
+linkTitle: v2.50.0 (May 2024)
+date: 2024-05-30 00:00:00 +0000
+description: Redis Insight v2.50
+weight: 1
+
+---
+## 2.50 (May 2024)
+This is the General Availability (GA) release of Redis Insight 2.50.
+
+### Highlights
+- New tutorial exploring several common Redis use cases with paired-up sample data that will get you started quicker with your empty database.
+- Performance and UX enhancements for the JSON data structure for smoother data rendering and interaction in the Browser.
+
+### Details
+
+**Features and improvements**
+- [#3402](https://github.com/RedisInsight/RedisInsight/pull/3402) New tutorial exploring several common Redis use cases with paired-up sample data that will get you started quicker with your empty database.
+- [#3251](https://github.com/RedisInsight/RedisInsight/pull/3251) UX enhancements for the JSON data structure in the Browser to prevent collapsing the entire structure when updating a JSON value. Includes performance optimizations for loading JSON documents containing numerous objects.
+- [#3161](https://github.com/RedisInsight/RedisInsight/pull/3161), [#3171](https://github.com/RedisInsight/RedisInsight/pull/3171) Added a quick access button to sign in to your Redis Cloud account from anywhere within Redis Insight, to import existing databases or create a new account with a free database. Integration with your Redis Cloud account is currently available only in the desktop Redis Insight version.
+- [#3349](https://github.com/RedisInsight/RedisInsight/pull/3349) Changed the sorting order in the Tree view to lexicographical.
+---
+Title: RedisInsight v2.46.0, March 2024
+linkTitle: v2.46.0 (March 2024)
+date: 2024-03-28 00:00:00 +0000
+description: RedisInsight v2.46
+weight: 1
+---
+## 2.46 (March 2024)
+This is the General Availability (GA) release of RedisInsight 2.46.
+
+### Highlights
+- New formatters for 32-bit and 64-bit vector embeddings for a more human-readable representation in the Browser
+- Cleaner layout on the main page with quick access to JSON and search & query tutorials and Redis Cloud in-app sign-up
+
+
+### Details
+
+**Features and improvements**
+- [#2843](https://github.com/RedisInsight/RedisInsight/pull/2843), [#3185](https://github.com/RedisInsight/RedisInsight/pull/3185) Adding new formatters for 32-bit and 64-bit vector embeddings to visualize them as arrays in Browser for a simpler and more intuitive representation.
+- [#3069](https://github.com/RedisInsight/RedisInsight/pull/3069) UX enhancements in the database list page for an improved user experience, leading to a cleaner layout and easier navigation.
+- [#3151](https://github.com/RedisInsight/RedisInsight/pull/3151) Launch RedisInsight with the previously used window size.
+
+**Bugs**
+- [#3152](https://github.com/RedisInsight/RedisInsight/pull/3152), [#3156](https://github.com/RedisInsight/RedisInsight/pull/3156) A fix to [support the * wildcard](https://github.com/RedisInsight/RedisInsight/issues/3146) in Stream IDs.
+- [#3174](https://github.com/RedisInsight/RedisInsight/pull/3174) Display invalid JSONs as unformatted values when a JSON view is set in Workbench results.
+---
+Title: RedisInsight v1.3, March 2020
+linkTitle: v1.3 (Mar 2020)
+date: 2020-03-30 00:00:00 +0000
+description: Auto-discovery of Redis Cloud databases, visualising paths in RedisGraph
+weight: 97
+---
+
+## RedisInsight v1.3.1 release notes (April 2020)
+
+This is the maintenance release of RedisInsight 1.3 (v1.3.1).
+
+Update urgency: Medium
+
+### Headlines
+
+- Fixed support for connecting to Redis database on TLS-enabled hosts with SNI enforcement.
+
+### Details
+
+- Bug Fixes:
+    - Core:
+        - Fixed support for connecting to Redis database on TLS-enabled hosts with SNI enforcement.
+    - Memory Analysis
+        - Fixed wrong display of table columns in Memory Analyzer view.
+    - Browser
+        - Fixed bug where the TTL on string and RedisJSON keys was being reset on edit.
+    - Configuration:
+        - Fixed freezing/flashing on refreshing configuration.
+    - CLI
+        - Fixed minor visual bug in inline command documentation.
+    - Security
+        - Updated frontend dependencies that had developed security vulnerabilities.
+
+## RedisInsight v1.3.0 release notes (March 2020)
+
+This is the General Availability release of RedisInsight 1.3 (v1.3.0)!
+
+### Headlines
+
+- The Windows installer is now signed with a Microsoft Authenticode certificate.
+- Auto-Discovery of databases for Redis Cloud Pro.
+- Visualising paths in RedisGraph
+
+### Details
+
+- Features:
+    - Security:
+        - The Windows installer now signed with a Microsoft Authenticode certificate
+    - Core:
+        - Auto-Discovery for Redis Cloud Pro: Redis Cloud Pro subscribers can automatically add
+          their cloud databases with just a few clicks
+        - Support for editing the connection details of an added database
+        - Better support for Sentinel-monitored databases with different passwords for the sentinel instance(s) and database
+        - UI improvements to the add database form
+        - Added a button in the top-right menu to reach the online documentation with one click
+    - RedisGraph:
+        - Added support for visualising queries that use [path functions](https://oss.redislabs.com/redisgraph/commands/#path-functions)
+    - Memory Analysis:
+        - Added support for [virtual hosted-style](https://docs.aws.amazon.com/AmazonS3/latest/dev/VirtualHosting.html#virtual-hosted-style-access) S3 paths for Offline Analysis
+    - Browser:
+        - Added tooltip to make it easier to view the name of long keys
+
+- Bug Fixes:
+    - Core:
+        - Fixed fonts that were being loaded from the Internet, causing jarring visual changes on slow connections
+    - RedisGraph:
+        - Improved rendering of Array records
+        - Removed `GRAPH.EXPLAIN` calls for now until we have execution plan visualisation
+---
+Title: Redis Insight v2.66.0, January 2025
+linkTitle: v2.66.0 (January 2025)
+date: 2025-01-30 00:00:00 +0000
+description: Redis Insight v2.66
+weight: 1
+
+---
+## 2.66 (January 2025)
+This is the General Availability (GA) release of Redis Insight 2.66.
+
+### Highlights
+- Switch between Redis databases and [Redis Data Integration](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) (RDI) instances without returning to the database or RDI endpoint list.
+- Improved performance in Browser when handling nested JSON data, along with the option to hide key size and TTL for a more efficient navigation.
+
+### Details
+
+**Features and improvements**
+- [#4258](https://github.com/RedisInsight/RedisInsight/pull/4258) Improved navigation allows seamless switching between Redis databases and [Redis Data Integration](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) (RDI) instances without returning to the database or endpoint list.
+- [#4315](https://github.com/RedisInsight/RedisInsight/pull/4315) Improved performance when working with nested JSON data types in Browser.
+- [#4290](https://github.com/RedisInsight/RedisInsight/pull/4290) Added an option to hide key size and TTL in Browser to optimize space. Hiding key size can also help avoid performance issues when working with large keys.
+- [#4268](https://github.com/RedisInsight/RedisInsight/pull/4268) Enhanced UX for adding Redis databases, now displaying information in multiple tabs.
+- [#4228](https://github.com/RedisInsight/RedisInsight/pull/4228) Added the ability to customize the refresh interval or stop refreshing database overview metrics, allowing to change the frequency or avoid seeing the `INFO` command in Profiler.
+- [#4255](https://github.com/RedisInsight/RedisInsight/pull/4255) Updated Brotli decompression to use brotli-wasm.
+
+**Bugs**
+- [#4304](https://github.com/RedisInsight/RedisInsight/pull/4304) Resolved the [application startup error](https://github.com/RedisInsight/RedisInsight/issues/3871) on Ubuntu 24.04 caused by a space in the application name.
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | Bjxu9UFPpWhz29prFqRsKDNlF4LZaTUJgAvBBI/FNQ9rBncFGGOb5m59wY3dXIYAG6+VB6F9U9ylffv31IDszw== |
+| Linux AppImage | T6y4xd4BVs1skNAOWkFpWkcov0288qIh2dXHo7gofDw99ow6phV3LzcaasHLT5F+TdlbfcjB8aGVJMx1qEIaBw== |
+| Linux Debian| WaMsSd6qKvw5x6ALLLPTnFoWMX/qVZafVJ3SJAUr8IYoGksnNlU1huUr9q/ftlwP00y2zYac7EZBbl2Z/bOppQ== |
+| MacOS Intel | 4x7vG7nTt3s4+kQ6WSuhrtigRa2XZ9Q6UiR1WCb/vROAL/X5GjmFvv4jBPIxZC1w6Z46pNzS+IhLcI4oHVSyAw== |
+| MacOS Apple silicon | x8wlgNy4dadKV3tcn8uJh/ksvEMnBYaCPvlxlfwcMjNwXNoSBQ+tK6kgJSONGgLVUqtQe1pfTbzqBsqkEAxquw== |
+---
+Title: RedisInsight v2.26.0, May 2023
+linkTitle: v2.26.0 (May 2023)
+date: 2023-05-31 00:00:00 +0000
+description: RedisInsight v2.26
+weight: 1
+---
+## 2.26 (May 2023)
+This is the General Availability (GA) release of RedisInsight 2.26.
+
+### Highlights
+- Introducing Insights (Beta): a new right-side panel that displays contextualised database recommendations for optimizing performance and memory usage. The list of recommendations gets updated as you interact with your database. Check out the paired-up tutorials to learn about the recommended feature and vote to provide feedback. This functionality is being rolled out gradually to the user base.
+- Support for bulk data upload in custom tutorials: quickly upload sample datasets from your custom RedisInsight tutorials to share your Redis expertise with your team and the wider community.
+
+### Details
+
+**Features and improvements**
+- [#1847](https://github.com/RedisInsight/RedisInsight/pull/1847), [#1901](https://github.com/RedisInsight/RedisInsight/pull/1901), [#1957](https://github.com/RedisInsight/RedisInsight/pull/1957), [#1972](https://github.com/RedisInsight/RedisInsight/pull/1972) Launching Insights (Beta): a new right-side panel that displays contextualised database recommendations for optimizing performance and memory usage. The list of recommendations gets updated in real-time as you interact with your database taking into account database configuration, user actions and accessed data. Consult the paired-up tutorials to learn more about the recommended feature. This functionality is being rolled out gradually to the user base in order to allow the RedisInsight team to learn and adjust the recommendations. Provide feedback directly in the app or the [GitHub repository](https://github.com/RedisInsight/RedisInsight/issues). 
+- [#2019](https://github.com/RedisInsight/RedisInsight/pull/2019) Quickly upload sample data sets in bulk from your custom RedisInsight tutorials to share your Redis expertise with your team and the wider community. Use a text file with the list of Redis commands and follow our simple [instructions](https://github.com/RedisInsight/Tutorials) to include example data sets in your custom RedisInsight tutorials
+- [#2010](https://github.com/RedisInsight/RedisInsight/pull/2010), [#2012](https://github.com/RedisInsight/RedisInsight/pull/2012), [#2013](https://github.com/RedisInsight/RedisInsight/pull/2013) Optimized the logic when filtering per data type in Browser to avoid unnecessary [TYPE](https://redis.io/commands/type/) commands
+
+**Bugs**
+- [#2014](https://github.com/RedisInsight/RedisInsight/pull/2014) Display the actual command processing time in Workbench when results are grouped
+---
+Title: RedisInsight v2.6.0, July 2022
+linkTitle: v2.6.0 (July 2022)
+date: 2022-07-25 00:00:00 +0000
+description: RedisInsight v2.6.0
+weight: 8
+---
+
+## 2.6.0 (July 2022)
+This is the General Availability (GA) release of RedisInsight 2.6.0
+
+### Headlines:
+- Bulk actions: Delete the keys in bulk based on the filters set in Browser or Tree view
+- Multiline support for key values in Browser and Tree View: Click the key value to see it in full
+- [Pipeline](https://redis.io/docs/manual/pipelining/) support in Workbench: Batch Redis commands in Workbench to optimize round-trip times
+- In-app notifications: Receive messages about important changes, updates, or announcements inside the application. Notifications are always available in the Notification center, and can be displayed with or without preview.
+
+### Details
+**Features and improvements:**
+- [#890](https://github.com/RedisInsight/RedisInsight/pull/890), [#883](https://github.com/RedisInsight/RedisInsight/pull/883), [#875](https://github.com/RedisInsight/RedisInsight/pull/875) Delete keys in bulk from your Redis database in Browser and Tree view based on filters you set by key name or data type.
+- [#878](https://github.com/RedisInsight/RedisInsight/pull/878) Multiline support for key values in Browser and Tree View: Select the truncated value to expand the row and see the full value, select again to collapse it.
+- [#837](https://github.com/RedisInsight/RedisInsight/pull/837), [#838](https://github.com/RedisInsight/RedisInsight/pull/838) Added [pipeline](https://redis.io/docs/manual/pipelining/) support for commands run in Workbench to optimize round-trip times. Default number of commands sent in a pipeline is 5, and is configurable in Settings > Advanced. 
+- [#862](https://github.com/RedisInsight/RedisInsight/pull/862), [#840](https://github.com/RedisInsight/RedisInsight/pull/840) Added in-app notifications to inform you about any important changes, updates, or announcements. Notifications are always available in the Notification center, and can be displayed with or without preview.
+- [#830](https://github.com/RedisInsight/RedisInsight/pull/830) To more easily explore and work with stream data, always display stream entry ID and controls to remove the Stream entry regardless of the number of fields.
+- [#928](https://github.com/RedisInsight/RedisInsight/pull/928) Remember the sorting on the list of databases.
+
+**Bugs fixed:**
+- [#932](https://github.com/RedisInsight/RedisInsight/pull/932) Refresh the JSON value in Browser/Tree view.
+---
+Title: RedisInsight v2.30.0, July 2023
+linkTitle: v2.30.0 (July 2023)
+date: 2023-07-27 00:00:00 +0000
+description: RedisInsight v2.30
+weight: 1
+---
+## 2.30 (July 2023)
+This is the General Availability (GA) release of RedisInsight 2.30.
+
+### Highlights
+Introducing support for [triggers and functions](https://github.com/RedisGears/RedisGears/) that bring application logic closer to your data and give Redis powerful features for event-driven data processing
+
+### Details
+
+**Features and improvements**
+
+[#2247](https://github.com/RedisInsight/RedisInsight/pull/2247), [#2249](https://github.com/RedisInsight/RedisInsight/pull/2249), [#2273](https://github.com/RedisInsight/RedisInsight/pull/2273), [#2279](https://github.com/RedisInsight/RedisInsight/pull/2279) Support for [triggers and functions](https://github.com/RedisGears/RedisGears/) that add the capability to execute server-side functions triggered by events or data operations to:
+ - Speed up applications by running the application logic where the data lives
+ - Eliminate the need to maintain the same code across different applications by moving application functionality inside the Redis database
+ - Maintain consistent data when applications react to any keyspace change
+ - Improve code resiliency by backing up and replicating triggers and functions along with the database
+
+Triggers and functions work with a JavaScript engine, which lets you take advantage of JavaScript’s vast ecosystem of libraries and frameworks and modern, expressive syntax.
+---
+Title: RedisInsight v1.2, January 2020
+linkTitle: v1.2 (Jan 2020)
+date: 2020-01-27 00:00:00 +0000
+description: TLS Client side authentication support and stability improvements
+weight: 98
+---
+## RedisInsight v1.2.2 release notes
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.2.
+
+### Details
+
+- Bug Fixes:
+    - Core:
+        - This releases fixes the possible __false positive__ malware issues flagged by certain antivirus vendors introduced by [pyinstaller](https://github.com/pyinstaller/pyinstaller/issues/4633) which was reported on [reddit](https://www.reddit.com/r/redis/comments/f1qapz/redisinsight_cotains_malware/).
+
+## RedisInsight v1.2.1 release notes
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.2.
+
+### Details
+
+- Enhancements:
+    - Core:
+        - Upgrade notifications: When you open RedisInsight, a notification is shown if a new version is available.
+    - RediSearch:
+        - Support for [RediSearch 1.6](https://github.com/RediSearch/RediSearch/releases/tag/v1.6.7).
+- Minor Bug Fixes:
+    - RedisTimeSeries:
+        - Time was interpreted as seconds instead of milliseconds as ([Issue 332](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/332))
+
+## RedisInsight v1.2.0 release notes
+
+### Headlines
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+- Added support for Client side TLS authentication.
+- Resolved bug which caused blank pages at startup.
+
+### Details
+
+- New features:
+    - Core:
+        - Added support for Redis databases that require TLS client authentication (as in Redis Enterprise)
+    - RedisTimeseries:
+        - Initial `auto-updating` functionality when the query's end timestamp is `+`
+- Minor Enhancements:
+    - Core:
+        - Check whether the port is available before starting.
+        - Made `localhost` the default host instead of `0.0.0.0`.
+        - Improved logging during startup.
+    - RedisGraph:
+        - Fixed height of query cards.
+    - RediSearch:
+        - Add support for zero-length and whitespace-only index names.
+- Bug Fixes:
+    - Core:
+        - Moved server to another thread instead of a separate process.
+        In certain situations, the server process was being orphaned after the main process died. This resulted in a several issues, of which the "blank page issue" was the most common. Now that the server process is in a thread instead of a process, the server is not left running when the process exits.
+    - RediSearch:
+        - Fixed several bugs in the display of summarized results in the table view.
+    - Browser:
+        - Better handling of unsupported values - link to other tools that support it or show better error message.
+        - Fixed UI issues when the screen size is varied to provide better responsiveness.
+---
+Title: RedisInsight v2.0, Nov 2021
+linkTitle: v2.0 (Nov 2021)
+date: 2021-11-23 00:00:00 +0000
+description: RedisInsight v2.0.2
+weight: 12
+---
+
+## 2.0.6 (April 2022)
+This is the General Availability (GA) release of RedisInsight 2.0.6
+
+### Headlines:
+- SNI support - added SNI support to indicate a hostname in the TLS handshake
+- Save Profiler logs into a file - now you can save and download Profiler logs into a .TXT file
+- Customize delimiters in Tree view - added support for custom delimiters in Tree view
+- Support for node grouping and pulsing in RedisGraph visualizations in Workbench
+
+### Details
+**Features and improvements:**
+- [#548](https://github.com/RedisInsight/RedisInsight/pull/548), [#542](https://github.com/RedisInsight/RedisInsight/pull/542) Added SNI support - use the "Add Database Manually" form to see the new "Use SNI" option under the TLS section to specify the server name and connect to your Redis Database
+- [#521](https://github.com/RedisInsight/RedisInsight/pull/521/files) Added an option to save Profiler logs. Enable saving before starting the Profiler to save the logs into a .TXT file and download it to analyze them outside of the application
+- [#496](https://github.com/RedisInsight/RedisInsight/pull/496) Now you can specify your own delimiters to work with namespaces in the Tree view, default delimiter is colon (':')
+- [#473](https://github.com/RedisInsight/RedisInsight/pull/473) Added a link to GitHub repository of RedisInsight to quickly find and access it - you can see the icon below the "Settings"
+- [#586](https://github.com/RedisInsight/RedisInsight/pull/586) Added support for node grouping and pulsing in the visualisations for RedisGraph in Workbench
+- [#455](https://github.com/RedisInsight/RedisInsight/pull/455) Limited the movement of the special editor with Cypher highlights to Workbench Editor area (to work with it, just type in RedisGraph commands in Workbench)
+- [#462](https://github.com/RedisInsight/RedisInsight/pull/462) Provided additional information about database indexes in the form to add a database using host and port
+- [#489](https://github.com/RedisInsight/RedisInsight/pull/489) Reworked user experience with filters per key type and key name in Browser 
+- [#535](https://github.com/RedisInsight/RedisInsight/pull/535) Added highlights of timestamps and improved text wrapping in Profiler
+
+
+### Bug fixes:
+- [#581](https://github.com/RedisInsight/RedisInsight/pull/581) Fixed the issue with displaying keys in multi-shard databases
+- [#576](https://github.com/RedisInsight/RedisInsight/pull/576) Fixed encoding in Workbench
+
+
+
+## 2.0.5 (March 2022, GA)
+
+This is the General Availability (GA) release of RedisInsight 2.0.
+
+### Headlines
+
+* **Tree view** - A new view of the keys in Browser, which automatically groups keys scanned in your database into folders based on key namespaces. Now you can navigate through and analyze your list of keys quicker by opening only folders with namespaces you want.
+* **Support for Apple M1 (arm64)** - You can download it [here](https://redis.com/redis-enterprise/redis-insight/#insight-form).
+* **Added auto-discovery of local databases** - RedisInsight will automatically find and add your local databases when you open the application for the first time.
+* **A dedicated Editor for Cypher syntax** - Workbench supports autocomplete and highlighting of Cypher syntax for RedisGraph queries. 
+
+### Details
+
+- You can switch to the Tree view in Browser to see all the keys grouped into folders according to their namespaces. Note that we use the colon (:) as a default separator, and it is not customizable yet.
+- Added support for Apple M1 (arm64).
+- Added a mechanism to auto-discover local databases based on the following parameters:
+  - The mechanism only triggers when you open the application for the first time.
+  - The database has standalone connection type.
+  - The database uses the default username and requires no password or TLS certificates.
+- Added new built-in guides in Workbench for additional capabilities.
+- Added tutorials in Workbench for Redis Stack databases that describe common use cases for Redis capabilities.
+- Added a new dedicated Editor to Workbench with support for Cypher syntax autocomplete and highlighting. Use the "Shift+Space" shortcut inside of the quotes for your query to open the dedicated Editor.
+- Show modules uploaded to databases in the list of databases.
+- Added support for returning to the previous command in Workbench Editor. Use arrow up when your cursor is at the beginning of the first row to return to the previous command. Note: there is no support for the reverse direction yet, so use it with caution.
+
+If you installed RedisInsight-preview before, this folder will still exist at the following path:
+* For MacOs: <usersHomeDir>/.redisinsight-preview
+* For Windows: C:/Users/{Username}/.redisinsight-preview
+* For Linux: <usersHomeDir>/.redisinsight-preview
+
+## 2.0.4 (February 2022)
+
+This is the maintenance release of RedisInsight Preview 2.0 (v2.0.4)!
+
+### Headlines
+
+- Fixes to the issues found
+- Profiler
+  - Added RedisInsight Profiler, which uses the MONITOR command to analyze every command sent to the redis instance in real-time.
+- Workbench:
+  - Added support for RedisGears and RedisBloom on the intelligent Redis command auto-complete.
+  - Keep command results previously received in the Workbench.
+  - Support for repeating commands.
+- CLI:
+  - Added support for RedisGears and RedisBloom on the intelligent Redis command auto-complete.
+  - Support for repeating commands.
+- Command Helper:
+  - Added information about RedisGears and RedisBloom Redis commands.
+
+### Details
+
+- Profiler
+  - Added RedisInsight Profiler, which uses the MONITOR command to analyze every command sent to the redis instance in real-time. Note: Running the MONITOR command is dangerous to the performance of your production server, so run it reasonably and remember to stop the Profiler. 
+- Workbench:
+  - Added support for RedisGears and RedisBloom on the intelligent Redis command auto-complete, so the list of similar commands and their arguments are displayed when you start typing any RedisGears or RedisBloom commands.
+  - Keep command results (up to 1MB) previously received in the Workbench, so they are available even after you restart the application. 
+  - Connect Workbench to the database index selected when adding a database.
+  - To repeat any command in Workbench, just enter any integer and then a Redis command with arguments.
+- CLI:
+  - Added support for RedisGears and RedisBloom on the intelligent Redis command auto-complete, so hints with arguments are displayed when you enter any RedisGears or RedisBloom commands
+  - CLI is by default connected to the database index selected when adding a database. Added displaying of the database index connected.
+  - To repeat any command in CLI, just enter any integer and then a Redis command with arguments.
+- Command Helper:
+  - Added information about RedisGears and RedisBloom Redis commands.
+- Core:
+  - Fixed an issue with displaying parameter values in the Overview when no information is received for these parameters.
+
+
+## 2.0.3 (December 2021)
+
+This is the maintenance release of RedisInsight Preview 2.0 (v2.0.3).
+
+### Headlines
+
+- Workbench:
+  - Added indications of commands
+  - New hints with the list of command arguments
+  - Reworked navigation for the built-in guides
+- Help Center:
+  - Added a page with list of supported keyboard shortcuts
+- Core:
+  - Uncoupled Command Helper from CLI
+  - Renamed `ZSET` to Sorted Set
+
+### Details
+
+- Browser:
+  - Changed the format of TTL in the list of keys
+- CLI:
+  - Fixed a bug with `FT.CREATE` command that rendered the window blank
+- Workbench:
+  - Fixed a bug to avoid executing the Redis command one more time when the view of results is changed
+  - Added a new information message when there are no results to display
+  - Added indications of commands (currently, not clickable) in Editor area to point out the lines where commands start
+  - Added new hints in Editor to display the list of command arguments with the following keyboard shortcuts:
+    - Ctrl+Shift+Space for Windows and Linux
+    - ⌘ ⇧ Space for Mac
+  - Added support for remembering the state (expanded or collapsed) for left side panel in Workbench
+  - Reworked navigation for the built-in guides
+  - Changed icons for default and custom plugins
+- Command Helper:
+  - Changed titles of command groups to make them consistent with redis.io
+- Help Center:
+  - Added a page with supported keyboard shortcuts
+- Core:
+  - Reworked logic to open CLI and Command Helper, added an option to open Command Helper without a need to open CLI
+  - Changed fonts and colors across the application to enhance readability
+  - Renamed `ZSET` to Sorted Set
+  - Added description of RedisGears and RedisBloom commands to hints in CLI, Command Helper, and Workbench
+  - Added support for automatic updates to the list of commands and their description in CLI, Command Helper, and Workbench
+
+## 2.0.2 (November 2021)
+
+This is the public preview release of RedisInsight 2.0 (v2.0.2).
+
+RedisInsight 2.0 is a complete product rewrite based on a new tech stack. This version contains a number of must-have and most-used capabilities from previous releases, plus a number of differentiators and delights.
+
+RedisInsight-preview 2.0 can be installed along with the current GA (1.11) version of RedisInsight with no issues.
+
+### Headlines
+
+- Developed using a new tech stack based on Electron, Elastic UI, and Monaco Editor
+- Introducing Workbench - advanced command line interface with intelligent command auto-complete and complex data visualizations
+- Ability to write and render your own data visualizations within Workbench
+- Built-in click-through Redis guides available
+- Support for Light and Dark themes
+- Enhanced user experience with Browser
+
+### Details
+
+- Core:
+  - Enhanced user experience with the list of databases:
+    - View, sort and edit databases added
+    - Multiple deletion of databases
+  - Ability to connect to Redis Standalone, Redis Cluster and Redis Sentinel
+  - Auto discovery of databases managed by Redis Enterprise, Redis Cloud (Flexible), and Redis Sentinel
+  - Support for Redis OSS Cluster API
+  - Support for TLS connection
+  - Works with Microsoft Azure (official support upcoming)
+- Workbench:
+  - Advanced command-line interface that lets you run commands against your Redis server 
+  - Workbench editor allows comments, multi-line formatting and multi-command execution
+  - Intelligent Redis command auto-complete and syntax highlighting with support for [RediSearch](https://oss.redis.com/redisearch/), [RedisJSON](https://oss.redis.com/redisjson/), [RedisGraph](https://oss.redis.com/redisgraph/), [RedisTimeSeries](https://oss.redis.com/redistimeseries/), [RedisGears]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions" >}}), [RedisAI](https://oss.redis.com/redisai/), [RedisBloom](https://oss.redis.com/redisbloom/)
+  - Allows rendering custom data visualization per Redis command using externally developed plugins
+- Browser:
+  - Browse, filter and visualize key-value Redis data structures
+    - Visual cues per data type
+    - Quick view of size and ttl in the main browser view
+    - Ability to filter by pattern and/or data type
+    - Ability to change the number of keys to scan through during filtering
+  - CRUD support for Lists, Hashes, Strings, Sets, Sorted Sets
+    - Search within the data structure (except for Strings)
+  - CRUD support for [RedisJSON](https://oss.redis.com/redisjson/)
+- Database overview:
+  - A number of metrics always on display within the database workspace
+    - Metrics updated every 5 second
+    - CPU, number of keys, commands/sec, network input, network output, total memory, number of connected clients
+  - Enabled modules per Redis server listed
+- CLI:
+  - Command-line interface with enhanced type-ahead command help
+  - Embedded command helper where you can filter and search for Redis commands
+- RediSearch:
+  - Tabular visualizations within Workbench of [RediSearch](https://oss.redis.com/redisearch/) index queries and aggregations (support for FT.INFO, FT.SEARCH and FT.AGGREGATE)
+- Custom plugins:
+  - Ability to build your own visualization plugins to be rendered within Workbench
+  - [Documentation](https://github.com/redisinsight/redisinsight) on how to develop custom plugins and a reference example are provided
+- Built-in guides:
+  - Built-in click-through guides for Redis capabilities
+  - Added a guide on Document Capabilities within Redis
+- User interface (UI):
+  - Light/dark themes available
+  - Colour palette adjusted to the highest level of [Web content accessibility guidelines](https://www.w3.org/WAI/standards-guidelines/wcag/)
+- Data encryption:
+  - Optional ability to encrypt sensitive data such as connection certificates and passwords
+---
+Title: RedisInsight v2.10.0, September 2022
+linkTitle: v2.10.0 (Sept 2022)
+date: 2022-09-29 00:00:00 +0000
+description: RedisInsight v2.10.0
+weight: 5
+---
+## 2.10.0 (September 2022)
+This is the General Availability (GA) release of RedisInsight 2.10.
+
+### Highlights
+- Formatters: Additional support for values of keys with Protobuf, Binary, PHP unserialize (view and edit serialized PHP values as JSON), and Java serialized objects, save formatters selected when viewing other keys
+- New overview for cluster databases displays memory and key allocation as well as database information per shards
+- Configure Workbench to persist the Editor after commands have been run and group the results
+- Complete an optional user survey
+
+### Details
+**Features and improvements**
+- [#1159](https://github.com/RedisInsight/RedisInsight/pull/1159), [#1160](https://github.com/RedisInsight/RedisInsight/pull/1160), [#1068](https://github.com/RedisInsight/RedisInsight/pull/1068), [#1071](https://github.com/RedisInsight/RedisInsight/pull/1071), [#1095](https://github.com/RedisInsight/RedisInsight/pull/1095), [#1097](https://github.com/RedisInsight/RedisInsight/pull/1097), [#1098](https://github.com/RedisInsight/RedisInsight/pull/1098) A dedicated **Analysis Tools** page displays memory and key allocation in cluster databases as well as database information per shards
+- [#1017](https://github.com/RedisInsight/RedisInsight/pull/1017), [#1025](https://github.com/RedisInsight/RedisInsight/pull/1025), [#1029](https://github.com/RedisInsight/RedisInsight/pull/1029), [#1059](https://github.com/RedisInsight/RedisInsight/pull/1059), [#1092](https://github.com/RedisInsight/RedisInsight/pull/1092) Added support for additional data formats in Browser/Tree view, including Protobuf, Binary, Pickle, PHP unserialize (view and edit serialized PHP values as JSON), and Java serialized objects
+- [#1130](https://github.com/RedisInsight/RedisInsight/pull/1130) Save formatters selected when viewing other keys
+- [#1177](https://github.com/RedisInsight/RedisInsight/pull/1177) Add a validation when edited value is not valid in the selected format in Browser/Tree view
+- [#1048](https://github.com/RedisInsight/RedisInsight/pull/1048) Configure Workbench to persist the Editor after commands have been run
+- [#1119](https://github.com/RedisInsight/RedisInsight/pull/1119) Pipeline mode configuration for Workbench moved to Settings > Workbench
+- [#1149](https://github.com/RedisInsight/RedisInsight/pull/1149) Save Workbench space by grouping results 
+- [#1162](https://github.com/RedisInsight/RedisInsight/pull/1162) Complete an optional user survey
+- [#1037](https://github.com/RedisInsight/RedisInsight/pull/1037) Added tooltip to display long fields in [Redis Streams](https://redis.io/docs/data-types/streams/) 
+- [#1202](https://github.com/RedisInsight/RedisInsight/pull/1202) Removed format validations from the admin username in the Redis Enterprise Cluster autodiscovery process
+
+**Bugs**
+- [#1180](https://github.com/RedisInsight/RedisInsight/pull/1180) Fix to display full values for truncated TTL in munutes
+- [#1197](https://github.com/RedisInsight/RedisInsight/pull/1197) Workbench is now available even when encryption failed
+- [#1176](https://github.com/RedisInsight/RedisInsight/pull/1176) Save the refresh value in Browser/Tree view
+- [#1101](https://github.com/RedisInsight/RedisInsight/pull/1101) Fixed an issue when key names are not displayed 
+---
+Title: Redis Insight v2.68.0, April 2025
+linkTitle: v2.68.0 (April 2025)
+date: 2025-04-01 00:00:00 +0000
+description: Redis Insight v2.68
+weight: 1
+
+---
+## 2.68 (April 2025)
+This is the General Availability (GA) release of Redis Insight 2.68.
+
+### Highlights
+- You can now test the connectivity to your source database when setting up a [Redis Data Integration](https://redis.io/docs/latest/integrate/redis-data-integration/) (RDI) data pipeline in Redis Insight. This will help ensure that RDI can connect to the source database and keep your Redis cache updated with changes from the source database.
+- Configure database connections via environment variables or a JSON file, allowing for centralized and efficient configuration management. This is specifically useful for automated deployments.
+
+### Details
+
+**Features and improvements**
+- [#4368](https://github.com/RedisInsight/RedisInsight/pull/4368), [#4389](https://github.com/RedisInsight/RedisInsight/pull/4389) You can now test the connectivity to your source database when setting up a [Redis Data Integration](https://redis.io/docs/latest/integrate/redis-data-integration/) (RDI) data pipeline in Redis Insight. This will help ensure that RDI can connect to the source database and keep your Redis cache updated with changes from the source database.
+- [#308](https://github.com/redislabsdev/RedisInsight-Cloud/pull/308) Configure database connections via environment variables or a JSON file, allowing for centralized and efficient configuration management. This is specifically useful for automated deployments. See [here](https://redis.io/docs/latest/operate/redisinsight/configuration/) for more details.
+- [#4428](https://github.com/RedisInsight/RedisInsight/pull/4428) Added an environment variable to disable the ability to manage database connections (adding, editing, or deleting) in Redis Insight. This provides enhanced security and configuration control in scenarios where preventing changes to database connections is necessary. See [here](https://redis.io/docs/latest/operate/redisinsight/configuration/) for more details.
+- [#4377](https://github.com/RedisInsight/RedisInsight/pull/4377), [#4383](https://github.com/RedisInsight/RedisInsight/pull/4383) Allows connecting to databases without requiring credentials for dangerous commands. In this mode, certain features, such as database statistics, are hidden.
+- [#4427](https://github.com/RedisInsight/RedisInsight/pull/4427) Added the ability to download a file containing all keys deleted through bulk actions, which helps in tracking changes.
+- [#4335](https://github.com/RedisInsight/RedisInsight/pull/4335) [Redis Data Integration](https://redis.io/docs/latest/integrate/redis-data-integration/) deployment errors are now stored in a file instead of being displayed in error messages, improving space efficiency.
+- [#4374](https://github.com/RedisInsight/RedisInsight/pull/4374) Improved connection errors for clustered databases by adding detailed information to help with troubleshooting.
+- [#4358](https://github.com/RedisInsight/RedisInsight/pull/4358) Added a setting to manually enforce standalone mode for clustered database connections instead of automatic clustered mode.
+- [#4418](https://github.com/RedisInsight/RedisInsight/pull/4418) An ability to see key names in HEX format, useful for non-ASCII characters or debugging. To switch from Unicode to HEX, open the "Decompression & Formatters" tab while adding or editing a database connection.
+- [#4401](https://github.com/RedisInsight/RedisInsight/pull/4401) Added an option to close key details for unsupported data types in the Browser to free up space.
+- [#4296](https://github.com/RedisInsight/RedisInsight/pull/4296) When working with JSON data types, Redis Insight now uses [JSONPath ($) syntax](https://redis.io/docs/latest/develop/data-types/json/path/).
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | 50YAPT59n2cLQu+P7kvc+kT+FxnW67pV53F1xz/C1IfgjmycgWpemycosbooQdLvXWPK4GLgk/NOnoZMI/15Lg== |
+| Linux AppImage | QbI7V8jCCVPum4jdd1W8CEOqT+iFzwUTrt9tVbu9Kpv81Pub27aIJve3kWDdXWyvxHPUlUOsBHIo/uHIzdFJPw== |
+| Linux Debian| V0/W8RclF6q0uT6uBR/lDNMt+OXqm7xmkSYf9vd8xCe4mGWUQBHiACX/aIgWs8l3Na5AQCNSJLrHnDXWiDD9Fw== |
+| MacOS Intel | j3bdEX0rvxPGBUMZ6hD9aD+C/WTR1bOZT+lekJqujkDnRSPMZS5syGfkd1cQfx8QSnM10qYBO4RCH0Ew0m3g0A== |
+| MacOS Apple silicon | iKOsvtOLOMcAvlbxL1LJI+45DgJxc+VIe9mVdoJZaNtMPCTAdxBX07GcvVVGfJOE8MdomsKrN8S2yYek7L6YLQ== |
+---
+Title: RedisInsight v2.8.0, August 2022
+linkTitle: v2.8.0 (Aug 2022)
+date: 2022-08-23 00:00:00 +0000
+description: RedisInsight v2.8.0
+weight: 6
+---
+## 2.8.0 (August 2022)
+This is the General Availability (GA) release of RedisInsight 2.8.0
+
+### Headlines
+- Formatters: See formatted key values in JSON, MessagePack, Hex, Unicode, or ASCII in Browser/Tree view for an improved experience of working with different data formats. 
+- Clone existing database connection or connection details: Clone the database connection you previously added to have the same one, but with a different database index, username, or password.
+- Raw mode in Workbench: Added support for the raw mode in Workbench results
+
+### Details
+**Features and improvements**
+- [#978](https://github.com/RedisInsight/RedisInsight/pull/978), [#959](https://github.com/RedisInsight/RedisInsight/pull/959), [#984](https://github.com/RedisInsight/RedisInsight/pull/984), [#996](https://github.com/RedisInsight/RedisInsight/pull/996), [#992](https://github.com/RedisInsight/RedisInsight/pull/992), [#1030](https://github.com/RedisInsight/RedisInsight/pull/1030) Added support for different data formats in Browser/Tree view, including JSON, MessagePack, Hex, and ASCII. If selected, formatter is applied to the entire key value and is available for any data type supported in Browser/Tree view. If any non-printable characters are detected, data editing is available only in Workbench and CLI to avoid data loss.
+- [#955](https://github.com/RedisInsight/RedisInsight/pull/965) Quickly clone a database connection to have the same one, but with a different database index, username, or password. Open a database connection in the edit mode, request to clone it, and make the changes needed. The original database connection remains the same.
+- [#1012](https://github.com/RedisInsight/RedisInsight/pull/1012) Added support for the raw mode (--raw) in Workbench. Enable it to see the results of commands executed in the raw mode.
+- [#987](https://github.com/RedisInsight/RedisInsight/pull/987) [DBSIZE](https://redis.io/commands/dbsize/) command is no longer required to connect to a database.
+- [#971](https://github.com/RedisInsight/RedisInsight/pull/971) Updated icon for the [RediSearch](https://redis.io/docs/stack/search/) Light module.
+- [#1011](https://github.com/RedisInsight/RedisInsight/pull/1011) Enhanced navigation in the Command Helper allowing you to return to previous actions.
+
+**Bugs fixed**
+- [#1009](https://github.com/RedisInsight/RedisInsight/pull/1009) Fixed an [error](https://github.com/RedisInsight/RedisInsight/issues/804) on automatic discovery of Sentinel databases.
+- [#978](https://github.com/RedisInsight/RedisInsight/pull/978) Work with [non-printable characters](https://github.com/RedisInsight/RedisInsight/issues/873). To avoid data loss, when non-printable characters are detected, key and value are editable in Workbench and CLI only.
+---
+Title: RedisInsight v2.44.0, February 2024
+linkTitle: v2.44.0 (February 2024)
+date: 2024-02-29 00:00:00 +0000
+description: RedisInsight v2.44
+weight: 1
+---
+## 2.44 (February 2024)
+This is the General Availability (GA) release of RedisInsight 2.44.
+
+### Highlights
+- Added support for SSH tunneling for clustered databases, unblocking some users who want to migrate from RESP.app to RedisInsight.
+- UX optimizations in the Browser layout to make it easier to leverage [search and query](https://redis.io/docs/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=redisinsight_release_notes) indexes.
+
+### Details
+
+**Features and improvements**
+- [#2711](https://github.com/RedisInsight/RedisInsight/pull/2711), [#3040](https://github.com/RedisInsight/RedisInsight/pull/3040) Connect to your clustered Redis database via SSH tunnel using a password or private key in PEM format.
+- [#3030](https://github.com/RedisInsight/RedisInsight/pull/3030), [#3070](https://github.com/RedisInsight/RedisInsight/pull/3070) UX optimizations in the Browser layout to enlarge the "Filter by Key" input field in the Browser and optimize the display of long [search and query](https://redis.io/docs/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=redisinsight_release_notes) indexes.
+- [#3033](https://github.com/RedisInsight/RedisInsight/pull/3033), [#3036](https://github.com/RedisInsight/RedisInsight/pull/3036) Various improvements for custom [tutorials](https://github.com/RedisInsight/Tutorials), including visual highlighting of Redis code blocks and strengthening security measures for bulk data uploads by providing an option to download and preview the list of commands for upload.
+- [#3010](https://github.com/RedisInsight/RedisInsight/pull/3010) Enhancements to prevent authentication errors caused by [certain special characters](https://github.com/RedisInsight/RedisInsight/issues/3019) in database passwords. 
+
+**Bugs**
+- [#3029](https://github.com/RedisInsight/RedisInsight/pull/3029) A fix for cases when autofill [prevents](https://github.com/RedisInsight/RedisInsight/issues/3026) the form to auto-discover Redis Enterprise Cluster database from being submitted.
+---
+Title: Redis Insight v2.52.0, June 2024
+linkTitle: v2.52.0 (June 2024)
+date: 2024-06-26 00:00:00 +0000
+description: Redis Insight v2.52
+weight: 1
+
+---
+## 2.52 (June 2024)
+This is the General Availability (GA) release of Redis Insight 2.52.
+
+### Highlights
+- Redis Insight now supports [setting expiration for individual hash fields](https://redis.io/docs/latest/develop/data-types/hashes/?utm_source=redisinsight&utm_medium=release_notes&utm_campaign=2.52#field-expiration), a highly requested feature available in the [first release candidate of Redis 7.4](https://github.com/redis-stack/redis-stack/releases/tag/v7.4.0-rc1)
+- Learn how to leverage Redis for Retrieval Augmented Generation (RAG) use cases via a new built-in Redis Insight tutorial
+
+### Details
+
+**Features and improvements**
+- [#3470](https://github.com/RedisInsight/RedisInsight/pull/3470) Redis Insight now supports [setting expiration for individual hash fields](https://redis.io/docs/latest/develop/data-types/hashes/?utm_source=redisinsight&utm_medium=release_notes&utm_campaign=2.52#field-expiration) through intuitive Browser controls. The hash field expiration is a highly requested feature available in the [first release candidate of Redis 7.4](https://github.com/redis-stack/redis-stack/releases/tag/v7.4.0-rc1).
+- [#60](https://github.com/RedisInsight/Tutorials/pull/60) Redis, with its high performance and versatile data structures, is an excellent choice for implementing Retrieval Augmented Generation (RAG). Our new built-in tutorial provides an overview of how Redis can be leveraged in a RAG use case. To get started, open the "Insights" panel in the top right corner and try the new tutorial.
+- [#3447](https://github.com/RedisInsight/RedisInsight/pull/3447), [#3483](https://github.com/RedisInsight/RedisInsight/pull/3483) UX optimizations for displaying the values of keys in the Browser. The new layout includes controls for editing key values that appear only when you hover over them, optimizing the use of space and providing a cleaner interface.
+- [#3231](https://github.com/RedisInsight/RedisInsight/pull/3231) Support for applying the JSON formatting in Browser for values of keys with float numbers that contain 10 or more decimal places.
+- [#3492](https://github.com/RedisInsight/RedisInsight/pull/3492) Increased the slot refresh timeout to 5000 milliseconds to enhance connection stability for clustered databases. This adjustment helps avoid scenarios where a connection is terminated before the acknowledgment of a successful connection establishment is received.
+
+**Bugs**
+- [#3490](https://github.com/RedisInsight/RedisInsight/pull/3490) Fix for an issue related to adding a JSON field to a key that already contains many fields.
+---
+Title: Redis Insight v2.64.0, December 2024
+linkTitle: v2.64.0 (December 2024)
+date: 2024-12-19 00:00:00 +0000
+description: Redis Insight v2.64
+weight: 1
+
+---
+## 2.64 (December 2024)
+This is the General Availability (GA) release of Redis Insight 2.64.
+
+### Highlights 
+- Improved the database connections list and simplified the connection form, delivering a cleaner, more intuitive UI for improved focus.
+- New in-app reminders to prevent your free Redis Cloud database from being deleted due to inactivity, ensuring you can make the most of it to test your ideas.
+
+### Details
+
+**Features and improvements**
+- [#4088](https://github.com/RedisInsight/RedisInsight/pull/4088), [#4078](https://github.com/RedisInsight/RedisInsight/pull/4078), [#4094](https://github.com/RedisInsight/RedisInsight/pull/4094) Improved the database connections list and simplified the connection form, delivering a cleaner, more intuitive UI for improved focus.
+- [#4189](https://github.com/RedisInsight/RedisInsight/pull/4189), [#4191](https://github.com/RedisInsight/RedisInsight/pull/4191) New in-app reminders notify you before your free Redis Cloud database is deleted due to inactivity, ensuring you can make the most of it to test your ideas.
+- [#4204](https://github.com/RedisInsight/RedisInsight/pull/4204), [#4196](https://github.com/RedisInsight/RedisInsight/pull/4196), [#4202](https://github.com/RedisInsight/RedisInsight/pull/4202) Various vulnerabilities have been fixed.
+
+**Bugs**
+- [#4194](https://github.com/RedisInsight/RedisInsight/pull/4194) Resolved an [issue](https://github.com/RedisInsight/RedisInsight/issues/4186) where modifying a JSON value inadvertently converted strings into numbers.
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | iYZbKsFtz/Ua4qeBdeHIRtZRiA1I50R3yY1t3VUD2cn94EpZLR5Xz3lK3yRxA85PxJaHjrWljyGliZv0OX0KBg== |
+| Linux AppImage | ToEFW8wVLI8oFoc/puzf2Cwoff8gBTsIxEsGjQRZq5D5BgrE3muxtuEQto3J2RiRbadGAZx6AZPh75WVJ0DKRw== |
+| Linux Debian| /k6jgfzDSRJ0yWmbtxpD5WG2i9wGUZ4r2AexDz6rUOLyZMqQPJUKEKuonprFvHZp+PUW/EtSWc436IFykBVmsQ== |
+| MacOS Intel | PrbRc+ju0UKxr4huP7Xl9Sq0fH0XaxUtydW86rAYepEAADUADsAYV2lB8gO7Ohs9ukJ7mXBEU7OJWRqJGLhxHg== |
+| MacOS Apple silicon | E6kTbnkoW3eji/v7WVrnwqlEKk444+hxiFqt56r8J+zAHhmX9dlNd7y37xdJlQ82FZ9QOIIMsN5Z0N+bgRisuw== |
+---
+Title: Redis Insight v2.48.0, April 2024
+linkTitle: v2.48.0 (April 2024)
+date: 2024-04-10 00:00:00 +0000
+description: Redis Insight v2.48
+weight: 1
+
+---
+## 2.48 (April 2024)
+This is the General Availability (GA) release of Redis Insight 2.48.
+
+### Highlights
+- New look, equally fast.
+- Learn Redis faster by uploading sample data and a concise tutorial for empty databases.
+- Enhance the security and scalability when running Redis Insight on Docker behind a proxy by adding support for the static proxy subpath.
+
+
+### Details
+
+**Features and improvements**
+- [#3233](https://github.com/RedisInsight/RedisInsight/pull/3233) New look, equally fast. We've refreshed our Redis Insight app to align with our new brand look.
+- [#3224](https://github.com/RedisInsight/RedisInsight/pull/3224) Jumpstart your Redis journey by uploading sample data with JSON and basic data structures for empty databases. To upload the sample data, navigate to the Browser screen for your empty database and initiate the upload process with just a click.
+- [#2711](https://github.com/RedisInsight/RedisInsight/pull/2711) Enhance the security and scalability by running Redis Insight on Docker [behind a proxy](https://github.com/RedisInsight/RedisInsight-reverse-proxy) using the newly added support for the static proxy subpath. Use the `RIPROXYPATH` environment variable to configure the subpath proxy path.
+---
+Title: RedisInsight v1.1, December 2019 
+linkTitle: v1.1 (Dec 2019)
+date: 2019-12-27 03:49:29 +0000
+description: Stability improvements and other fixes
+weight: 99
+---
+## RedisInsight v1.1.0 release notes (December 2019)
+
+### Headlines
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+### Details
+
+- Minor Enhancements:
+    - Core:
+        - Enable mouse wheel support inside the `querycard`.
+    - Browser:
+        - Enable enter key press for adding keys in browser
+    - RediSearch:
+        - Disable HIGHLIGHT markup in JSON view.
+    - Browser:
+        - Improve error message when database is unreachable
+        - Add a reload/refresh button to refresh the value of a key
+        - Enable enter key press for adding keys in browser
+        - Improve error message for unsupported value types
+- Bug Fixes:
+    - RedisGraph:
+        - Fix initial node placement in the view.
+        - Fix initial zoom with respect to the number of nodes in the result.
+    - Other minor fixes.
+---
+Title: Redis Insight v2.64.1, December 2024
+linkTitle: v2.64.1 (December 2024)
+date: 2024-12-27 00:00:00 +0000
+description: Redis Insight v2.64.1
+weight: 1
+
+---
+## 2.64.1 (December 2024)
+This is a maintenance release for Redis Insight 2.64.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Details
+
+- [#4236](https://github.com/RedisInsight/RedisInsight/pull/4236) Reverts the change to use JSONPath ($) by default rather than (.). These changes could cause issues with shards in Redis Enterprise Active-Active databases.
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | hIK4qrC50Gd4jZnpHnwRIIVyDWtOfvfFID9nv8xfdcDgf4LvJcGLa9zVYkbfvwUv+aEaaBCohJJZMIGFC6iYHQ== |
+| Linux AppImage | ll999oWjvKppawlYBPN6phGNa+mDiWmefIvkbQNAd7JPZFbHTYuLFWMWo4F1NrnZlr6vnPF6awbu7ubbiZL0HA== |
+| Linux Debian| 4MKHfmmapfhxXUln0X+rpFXzm2dH6IPj2BIwlNRPQDGhpQ5flzOtLlV1iNGm9xqennZUv+hx+cVQodzPIj8FTw== |
+| MacOS Intel | 5FkllEVCbD9M1fYww7N6XT3Qknl5tWrkHKWQWGhjkUiR/nZ89u+A84UzynB5H/lzBCFwUWJidfGJ4akrX2J7Hg== |
+| MacOS Apple silicon | 2gWxZqGlAo0RyQKa0h8puyXMkIg1vF/Gobd9vS9DNWZMr3aYJojALx6f7pfknBoL7MDmZI29Mohtx4mnQPbjGQ== |
+---
+Title: RedisInsight v1.0, November 2019
+linkTitle: v1.0 (Nov 2019)
+date: 2019-10-01 03:49:29 +0000
+description: The initial release after Redis acquired RDBTools
+weight: 100
+---
+
+## RedisInsight v1.0.0 release notes (November 2019)
+
+This is the initial release after [Redis acquired RDBTools](https://www.redislabs.com/blog/redisinsight-gui/).
+---
+Title: RedisInsight v2.32.0, August 2023
+linkTitle: v2.32.0 (August 2023)
+date: 2023-08-31 00:00:00 +0000
+description: RedisInsight v2.32
+weight: 1
+---
+## 2.32 (August 2023)
+This is the General Availability (GA) release of RedisInsight 2.32.
+
+### Highlights
+- Easily provision a free database to use with the RedisInsight interactive tutorials to learn, among others, how to leverage Vector Similarity Search for your AI use cases or discover the power of the native JSON data structure supporting structured querying and full-text search. Take advantage of the in-app social sign-up to [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) to quickly provision a free database with [Redis Stack’s capabilities](https://redis.io/docs/about/about-stack/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32). Try the [latest 7.2](https://redis.com/blog/introducing-redis-7-2/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) release which delivers the new [Triggers and Functions](https://redis.com/blog/introducing-triggers-and-functions/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) feature, allowing you to execute server-side functions written in JavaScript that are either triggered by a keyspace change, by a stream entry arrival, or by explicitly calling them, empowering developers to build and maintain real-time applications by moving business logic closer to the data, ensuring a lower latency whilst delivering the best developer experience.
+- Select a custom installation directory on Windows OS for when multi-user access to the app is required.
+
+ 
+### Details
+ 
+**Features and improvements**
+ 
+- [#2270](https://github.com/RedisInsight/RedisInsight/pull/2270), [#2271](https://github.com/RedisInsight/RedisInsight/pull/2271), [#2437](https://github.com/RedisInsight/RedisInsight/pull/2437) Added the ability to quickly provision a free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) database via in-app social signup (Google or GitHub). Use the database with the RedisInsight interactive tutorials or try the [latest 7.2](https://redis.com/blog/introducing-redis-7-2/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) release which delivers the new [Triggers and Functions](https://redis.com/blog/introducing-triggers-and-functions/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_32) feature. To quickly create and automatically add a free Redis Cloud database to RedisInsight, click the "Try Redis Cloud" banner in the list of database connections page and follow the steps.
+- [#2455](https://github.com/RedisInsight/RedisInsight/pull/2455) Select a custom installation directory on Windows OS
+- [#2373](https://github.com/RedisInsight/RedisInsight/pull/2373), [#2387](https://github.com/RedisInsight/RedisInsight/pull/2387) Delete all command results in Workbench at once
+- [#2458](https://github.com/RedisInsight/RedisInsight/pull/2458) Added in-app hints in Browser and Workbench to get started with RedisInsight interactive tutorials
+- [#2422](https://github.com/RedisInsight/RedisInsight/pull/2422) Ignore the empty lines in files when uploading data in bulk
+- [#2470](https://github.com/RedisInsight/RedisInsight/pull/2470) Preset the header containing the engine, the API version and the library name in the JavaScript file when creating a new library within the [Triggers and Functions](https://redis.com/blog/introducing-triggers-and-functions/?utm_source=redisinsight&utm_medium=main&utm_campaign=main) tool
+---
+Title: RedisInsight v2.4.0, June 2022
+linkTitle: v2.4.0 (June 2022)
+date: 2022-06-27 00:00:00 +0000
+description: RedisInsight v2.4.0
+weight: 9
+---
+
+## 2.4.0 (June 2022)
+This is the General Availability (GA) release of RedisInsight 2.4.0
+
+### Headlines:
+- Pub/Sub: Added support for [Redis pub/sub](https://redis.io/docs/manual/pubsub/) enabling subscription to channels and posting messages to channels.
+- Consumer groups: Added support for [streams consumer groups](https://redis.io/docs/manual/data-types/streams/#consumer-groups) enabling provision of different subsets of messages from the same stream to many clients for inspection and processing.
+- Database search: Search the list of databases added to RedisInsight to quickly find the required database.
+
+
+### Details
+**Features and improvements:**
+- [#760](https://github.com/RedisInsight/RedisInsight/pull/760), [#737](https://github.com/RedisInsight/RedisInsight/pull/737), [#773](https://github.com/RedisInsight/RedisInsight/pull/773) Added support for [Redis pub/sub](https://redis.io/docs/manual/pubsub/) enabling subscription to channels and posting messages to channels. Currently does not support sharded channels.
+- [#717](https://github.com/RedisInsight/RedisInsight/pull/717), [#683](https://github.com/RedisInsight/RedisInsight/pull/683), [#684](https://github.com/RedisInsight/RedisInsight/pull/684), [#688](https://github.com/RedisInsight/RedisInsight/pull/688), [#720](https://github.com/RedisInsight/RedisInsight/pull/720), Added support for [streams consumer groups](https://redis.io/docs/manual/data-types/streams/#consumer-groups) to manage different groups and consumers for the same stream, explicit acknowledgment of processed items, ability to inspect the pending items, claiming of unprocessed messages, and coherent history visibility for each single client.
+- [#754](https://github.com/RedisInsight/RedisInsight/pull/754) New **All Relationship** toggle for RedisGraph visualizations in **Workbench**. Enable it to see all relationships between your nodes.
+- [#788](https://github.com/RedisInsight/RedisInsight/pull/788) Quickly search the list of databases added to RedisInsight per database alias, host:port, or the last connection to find the database needed.
+- [#788](https://github.com/RedisInsight/RedisInsight/pull/788) Overview displays the number of keys per the logical database connected if this number is not equal to the total number in the database.
+
+**Bugs Fixed:**
+- [#774](https://github.com/RedisInsight/RedisInsight/pull/774) Fixed cases when not all parameters are received in Overview.
+- [#810](https://github.com/RedisInsight/RedisInsight/pull/810) Display several streams values with the same timestamp.
+---
+Title: RedisInsight v2.24.0, April 2023
+linkTitle: v2.24.0 (Apr 2023)
+date: 2023-04-27 00:00:00 +0000
+description: RedisInsight v2.24
+weight: 1
+---
+## 2.24 (April 2023)
+This is the General Availability (GA) release of RedisInsight 2.24.
+
+### Highlights
+- Bulk data upload: Upload the list of Redis commands from a text file using the new bulk action in the Browser tool. Use the bulk data upload with custom RedisInsight tutorials to quickly load your sample dataset.
+- Support for images in custom tutorials: showcase your Redis expertise with your team and the wider community by building shareable RedisInsight tutorials.
+- JSON formatter support for the [JSON.GET](https://redis.io/commands/json.get/), [JSON.MGET](https://redis.io/commands/json.mget/), and [GET](https://redis.io/commands/get/) command output in Workbench.
+- Added Brotli and PHP GZcompress to the list of supported decompression formats to view your data in a human-readable format. 
+
+### Details
+
+**Features and improvements**
+- [#1930](https://github.com/RedisInsight/RedisInsight/pull/1930), [#1961](https://github.com/RedisInsight/RedisInsight/pull/1961) Upload the list of Redis commands from a text file using the new bulk action in the Browser tool. Use the bulk data upload with custom RedisInsight tutorials to quickly load your sample dataset.
+- [#1936](https://github.com/RedisInsight/RedisInsight/pull/1936), [#1939](https://github.com/RedisInsight/RedisInsight/pull/1939) Added support for images in custom tutorials, available in Workbench. Showcase your Redis expertise with your team and the wider community by building shareable tutorials. Use markdown syntax described in our [instructions](https://github.com/RedisInsight/Tutorials) to build tutorials.
+- [#1946](https://github.com/RedisInsight/RedisInsight/pull/1946) See the output of [JSON.GET](https://redis.io/commands/json.get/), [JSON.MGET](https://redis.io/commands/json.mget/), and [GET](https://redis.io/commands/get/) formatted as JSON in Workbench.
+- [#1876](https://github.com/RedisInsight/RedisInsight/pull/1876) Ability to directly delete a key in the Browser list of keys without having to view its values.
+- [#1889](https://github.com/RedisInsight/RedisInsight/pull/1889), [#1900](https://github.com/RedisInsight/RedisInsight/pull/1900) Added Brotli and PHP GZcompress to the list of supported decompression formats to view your data in a human-readable format. Decompression format is configurable when adding a database connection.
+- [#1886](https://github.com/RedisInsight/RedisInsight/pull/1886) Enhanced command syntax in CLI, Workbench, and Command Helper to align with [command documentation](https://redis.io/commands/).
+- [#1975](https://github.com/RedisInsight/RedisInsight/pull/1975) [Renamed](https://github.com/RedisInsight/RedisInsight/issues/1902) the "Display On System Tray" to "Show in Menu Bar" on macOS.
+
+**Bugs**
+- [#1990](https://github.com/RedisInsight/RedisInsight/pull/1990) Keep the previously specified SNI parameters when a database connection is edited.
+- [#1999](https://github.com/RedisInsight/RedisInsight/pull/1999) Keep the previously set database index when a database connection is edited.
+---
+Title: RedisInsight v2.12.0, October 2022
+linkTitle: v2.12.0 (Oct 2022)
+date: 2022-09-29 00:00:00 +0000
+description: RedisInsight v2.12.0
+weight: 4
+---
+## 2.12.0 (October 2022)
+This is the General Availability (GA) release of RedisInsight 2.12.
+
+### Highlights
+- Database Analysis: Get insights and optimize the usage and performance of your Redis or Redis Stack based on the overview of the memory and data type distribution, big or complicated keys, and namespaces used
+- Faster initial loading of the list of keys in Browser and Tree views
+- Performance optimizations for large results in Workbench
+
+### Details
+**Features and improvements**
+- [#1207](https://github.com/RedisInsight/RedisInsight/pull/1207), [#1222](https://github.com/RedisInsight/RedisInsight/pull/1222), [#1295](https://github.com/RedisInsight/RedisInsight/pull/1295), [#1159](https://github.com/RedisInsight/RedisInsight/pull/1159), [#1231](https://github.com/RedisInsight/RedisInsight/pull/1231), [#1155](https://github.com/RedisInsight/RedisInsight/pull/1155) Get insights and optimize the usage and performance of your Redis or Redis Stack with Database Analysis. Navigate to Analysis Tools and scan up to 10,000 keys in the database to see the summary of memory allocation and the number of keys per Redis data type, memory likely to be freed over time, top 15 key namespaces, and the biggest keys found. You can extrapolate results based on the total number of keys or see the exact results for the number of keys scanned. 
+- [#1280](https://github.com/RedisInsight/RedisInsight/pull/1280) Speed up the initial load of the key list in Browser and Tree views
+- [#1285](https://github.com/RedisInsight/RedisInsight/pull/1285) Support for infinite floating point numbers in sorted sets
+- [#1290](https://github.com/RedisInsight/RedisInsight/pull/1290) Performance optimizations to process large results of Redis commands in Workbench
+
+**Bugs**
+- [#1293](https://github.com/RedisInsight/RedisInsight/pull/1293) Fixed Workbench visualizations in Redis Stack
+---
+Title: RedisInsight v1.14, may 2023
+linkTitle: v1.14 (May 2023)
+date: 2023-05-02 00:00:00 +0000
+description: RedisInsight v1.14.0
+weight: 5
+---
+
+## 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](https://redis.com/redis-enterprise/redis-insight/) or install it from an app store.
+
+This is the maintenance release of RedisInsight 1.14 (v1.14.0).
+
+## Headlines
+- Export connections to RedisInsight v2.
+
+## Details
+
+### Core
+  - Added support for exporting database connections to easily migrate them to RedisInsight v2 by bulk exporting to a file.
+  - Fixed Prompt verification bug for Sentinel instances.
+
+### Memory analysis
+  - Added support for `setlistpack` and `streamlistpack3` Redis 7 encoding types parsing.
+---
+Title: RedisInsight v2.28.0, June 2023
+linkTitle: v2.28.0 (June 2023)
+date: 2023-06-28 00:00:00 +0000
+description: RedisInsight v2.28
+weight: 1
+---
+## 2.28 (June 2023)
+This is the General Availability (GA) release of RedisInsight 2.28.
+
+### Highlights
+- Quickly and conveniently add [Redis Cloud](https://redis.com/redis-enterprise-cloud/overview/) databases that belong to fixed subscriptions using the auto-discovery tool
+- UX optimizations in Browser for an improved experience when performing [full-text search and queries](https://redis.io/docs/stack/search/), filtering, and bulk actions.
+- Support for a monospaced font in [JSON](https://redis.io/docs/stack/json/) key types
+
+### Details
+
+**Features and improvements**
+- [#2198](https://github.com/RedisInsight/RedisInsight/pull/2198), [#2207](https://github.com/RedisInsight/RedisInsight/pull/2207) Automatically discover and add [Redis Cloud](https://redis.com/redis-enterprise-cloud/overview/) databases that belong to fixed subscriptions using the `Redis Cloud` option on the form to auto-discover databases.
+- [#2146](https://github.com/RedisInsight/RedisInsight/pull/2146),[#2161](https://github.com/RedisInsight/RedisInsight/pull/2161) Added UX optimizations in the Browser layout to improve the experience when performing [full-text search and queries](https://redis.io/docs/stack/search/), filtering, and bulk actions.
+- [#2200](https://github.com/RedisInsight/RedisInsight/pull/2200) Changed to a monospaced font in [JSON](https://redis.io/docs/stack/json/) key types, and JSON formatters in Browser and Workbench.
+- [#2204](https://github.com/RedisInsight/RedisInsight/pull/2204) Re-bind default RedisInsight port from 5001 to 5530 to avoid conflicts with other applications
+- [#2120](https://github.com/RedisInsight/RedisInsight/pull/2120) Added the ability to investigate the commands processed by Redis or Redis Stack server without the need to stop Profiler when a new record appears.
+- [#2186](https://github.com/RedisInsight/RedisInsight/pull/2186) Unified the RedisInsight icon with other macOS applications.
+
+
+**Bugs**
+- [#2154](https://github.com/RedisInsight/RedisInsight/pull/2154) Display `(integer) 0` instead of `nil` in [ZRANK](https://redis.io/commands/zrank/) results in Workbench
+---
+Title: RedisInsight v2.2.0, May 2022
+linkTitle: v2.2.0 (May 2022)
+date: 2022-05-26 00:00:00 +0000
+description: RedisInsight v2.2.0
+weight: 10
+---
+
+## 2.2.0 (May 2022)
+This is the General Availability (GA) release of RedisInsight 2.2.0
+
+### Headlines:
+- SlowLog: New tool based on results of the [Slowlog](https://redis.io/commands/slowlog/) command to analyze slow operations in Redis instances
+- Streams: Added support for [Redis Streams](https://redis.io/docs/manual/data-types/streams/)
+- Open the list of keys or key details in full screen
+- Automatically refresh the list of keys and key values with a timer
+
+
+### Details
+**Features and improvements:**
+- [#621](https://github.com/RedisInsight/RedisInsight/pull/621) , [#645](https://github.com/RedisInsight/RedisInsight/pull/645) , [#649](https://github.com/RedisInsight/RedisInsight/pull/649) Added SlowLog, a tool that displays the list of logs captured by the [Slowlog](https://redis.io/commands/slowlog/) command to analyze all commands that exceed a specified runtime, which helps in troubleshooting performance issues. Specify both the runtime and the maximum length of SlowLog (which are server configurations) to configure the list of commands logged and set the auto-refresh interval to automatically update the list of commands displayed.
+- [#597](https://github.com/RedisInsight/RedisInsight/pull/597) , [#598](https://github.com/RedisInsight/RedisInsight/pull/598), [#601](https://github.com/RedisInsight/RedisInsight/pull/601) , [#603](https://github.com/RedisInsight/RedisInsight/pull/603) , [#608](https://github.com/RedisInsight/RedisInsight/pull/608) , [#613](https://github.com/RedisInsight/RedisInsight/pull/613) , [#614](https://github.com/RedisInsight/RedisInsight/pull/614) , [#632](https://github.com/RedisInsight/RedisInsight/pull/632) Support for [Redis Streams](https://redis.io/docs/manual/data-types/streams/), including creation and deletion of Streams, addition and deletion of entries, and filtration of entries per timestamp. [Consumer groups](https://redis.io/docs/manual/data-types/streams/#consumer-groups) will be added in a future release.
+- [#643](https://github.com/RedisInsight/RedisInsight/pull/643) List of keys or key details are supported in full screen mode. To open the key list in full screen, close the key details. To open key details in full screen, use the new **Full Screen** control in key details section.
+- [#633](https://github.com/RedisInsight/RedisInsight/pull/633) Automatically refresh the list of keys and key values with a timer. To do so, enable the **Auto Refresh** mode by clicking the control next to the **Refresh** button and set the refresh rate.
+- [#634](https://github.com/RedisInsight/RedisInsight/pull/634) Removed the max value limitation in the **Database Index** field of the form for adding a new database.
+
+**Bugs Fixed:**
+- [#656](https://github.com/RedisInsight/RedisInsight/pull/656) Binary key names will not trigger errors in databases with enabled OSS Cluster API. Data type, TTL, and size of such keys are displayed in the list of keys in all Redis instances. Key details are currently not available.
+---
+Title: Redis Insight v2.62.0, November 2024
+linkTitle: v2.62.0 (November 2024)
+date: 2024-11-27 00:00:00 +0000
+description: Redis Insight v2.62
+weight: 1
+
+---
+## 2.62 (November 2024)
+This is the General Availability (GA) release of Redis Insight 2.62.
+
+### Highlights 
+- Support for multiple key name delimiters in Tree View, allowing more flexible browsing for databases with diverse key structures.
+- Remain authenticated to [Redis Copilot](https://redis.io/docs/latest/develop/tools/insight/?utm_source=redisinsight&utm_medium=main&utm_campaign=tutorials#:~:text=for%20more%20information.-,Redis%20Copilot,-Redis%20Copilot%20is), even after reopening Redis Insight, for seamless and uninterrupted access with daily use.
+
+### Details
+
+**Features and improvements**
+- [#4090](https://github.com/RedisInsight/RedisInsight/pull/4090) Added support for multiple key name delimiters in Tree View, enabling more flexible browsing of databases with varied key name patterns.
+- [#3957](https://github.com/RedisInsight/RedisInsight/pull/3957) Remain authenticated to [Redis Copilot](https://redis.io/docs/latest/develop/tools/insight/?utm_source=redisinsight&utm_medium=main&utm_campaign=tutorials#:~:text=for%20more%20information.-,Redis%20Copilot,-Redis%20Copilot%20is), even after reopening Redis Insight, for seamless and uninterrupted access with daily use.
+- [#3988](https://github.com/RedisInsight/RedisInsight/pull/3988), [#4059](https://github.com/RedisInsight/RedisInsight/pull/4059) Enhanced both the Java and PHP serialized formatters: the Java formatter now supports date and time data, while the PHP formatter includes UTF-8 encoding for better handling of special characters and multi-language data.
+- [#4081](https://github.com/RedisInsight/RedisInsight/pull/4081) Introduced a unique theme key name with a proxy path prefix to prevent conflicts when multiple instances run on the same origin.
+- [#2970](https://github.com/RedisInsight/RedisInsight/pull/4107) Upgraded to Electron 33.2.0 for enhanced security and compatibility with modern web standards.
+
+**Bugs**
+- [#4089](https://github.com/RedisInsight/RedisInsight/pull/4089) Resolved an issue where large integers in JSON keys were being rounded, ensuring data integrity.
+
+**SHA-256 Checksums**
+| Package | SHA-256 |
+|--|--|
+| Windows | ibZ5kn0GSdrbnfHRWC1lDdKozn6YllcGIrDhmLEnt2K1rjgjL2kGKvbtfq9QEkumgGwk2a9zTjr0u5zztGHriQ== |
+| Linux AppImage | bM6lbyeAHFX/f0sBehu9a9ifHsDvX8o/2qn91sdtyiRcIU+f31+Ch7K4NI4v226rgj6LvkFDWDNq6VQ4pyLAPA== |
+| Linux Debian| ilD86T/+8gEgrZg8MS8Niv/8g54FPeEn1nZrUI6DA7KTl3owqzqD0npb8fdAdL6YtSRbSBUK2fXPQ6GRXWZ/GA== |
+| MacOS Intel | pSy3CvRfVIT3O7BXUPMUoONRaZCOA1965tF9T19gZ1NnUn9YkjWlNXdniQHZ4ALKbpC2q62ygt39xF6O52LxAw== |
+| MacOS Apple silicon | uoz6I6MO4/j8UJo7eNje3dz4rx1KKj6mum/vXb2882fYPD/lK1cG0Q0OZu/lbxuk0xgzXfWv0MhMTIVVV+EADg== |
+---
+Title: RedisInsight v1.7, September 2020
+linkTitle: v1.7 (Sep 2020)
+date: 2020-09-10 00:00:00 +0000
+description: RediSearch 2.0 support and stability improvements
+weight: 93
+---
+
+## 1.7.1 (October 2020)
+
+Maintenance release for RedisInsight 1.7 including bug fixes and enhancements.
+
+### Headlines:
+
+- Core:
+    - New public health-check API to make monitoring deployments easier.
+    - Display progress information during memory analysis.
+
+### Full details:
+
+Enhancements and bug fixes
+- Core:
+    - Fixed support for TLS in Redis Cluster databases.
+    - Application name is properly capitalized on MacOSX.
+    - Fixed update notifications on Docker - Now links to Docker Hub page and provides instructions for updating.
+- Memory Analysis:
+    - Information about the current stage of analysis is now displayed while the analysis runs.
+    - Fixed issue with running Memory Analysis on MacOSX (related to system OpenSSL libraries).
+- Browser:
+    - Visual improvements to key details view to improve the experience working with long key names.
+- CLI:
+    - Improvements for Redis Cluster databases - Controls to target specific nodes, all nodes, only masters/replicas, etc.
+- Streams:
+    - Fixed consumer groups functionality on Redis Cluster databases.
+- Telemetry:
+    - Report specific modules even when the `MODULE LIST` command is not available.
+
+## 1.7.0 (September 2020)
+
+### Headlines:
+
+- Support for [RediSearch 2.0](https://redislabs.com/blog/introducing-redisearch-2-0/)
+
+### Full Details:
+
+- Core:
+    - Added explanation of the supported subscription types for Redis Cloud database auto-discovery.
+    - Fixed a bug where upgrading from some previous versions would give an error on startup.
+    - Use a non-root group by default for the RedisInsight Docker container.
+- Memory Analysis:
+    - Improved UI for offline analysis via RDB file stored in S3.
+    - Fixed bug where using RDB stored in S3 sub-folder would fail.
+- Browser:
+    - Improved support for searching members of large collections (hashes, sets and sorted sets).
+- Streams:
+    - Improved UX for the handle to resize key selector.
+- RediSearch:
+    - Fixed support for Redis Cloud Essentials databases.
+- RedisGraph:
+    - Fixed an issue where localstorage is filled with unnecessary data.
+- Analytics:
+    - Reporting the subscription type for auto-discovered Redis Cloud databases.
+---
+Title: RedisInsight v2.22.1, March 2023
+linkTitle: v2.22.1 (Mar 2023)
+date: 2023-03-30 00:00:00 +0000
+description: RedisInsight v2.22.1
+weight: 1
+---
+## 2.22.1 (March 2023)
+This is the General Availability (GA) release of RedisInsight 2.22.
+
+### Highlights
+- Share your Redis expertise with your team and the wider community by building custom RedisInsight tutorials. Use our [instructions](https://github.com/RedisInsight/Tutorials) to describe your implementations of Redis for other users to follow and interact with in the context of a connected Redis database
+- Take a quick tour of RedisInsight to discover how it can enhance your development experience when building with Redis or Redis Stack
+- Select from a list of supported decompression formats to view your data in a human-readable format
+
+
+### Details
+**Features and improvements**
+- [#1782](https://github.com/RedisInsight/RedisInsight/pull/1782), [#1813](https://github.com/RedisInsight/RedisInsight/pull/1813) Share your Redis expertise with your team and the wider community by building custom RedisInsight tutorials. The tutorials use markdown and are easy to write. They are an ideal way to describe practical implementations of Redis so users can follow and interact with commands in the context of an already connected Redis database. Check out these [instructions](https://github.com/RedisInsight/Tutorials) to start creating your own tutorials. Let the community discover your content by labeling your GitHub repository with [redis-tutorials](https://github.com/topics/redis-tutorials)
+- [#1834](https://github.com/RedisInsight/RedisInsight/pull/1834) Take a quick tour of RedisInsight to discover how it can enhance your development experience. To start the tour, in the left-side navigation, open the Help Center (above the Settings icon), reset the onboarding and open the Browser page
+- [#1742](https://github.com/RedisInsight/RedisInsight/pull/1742), [#1753](https://github.com/RedisInsight/RedisInsight/pull/1753), [#1755](https://github.com/RedisInsight/RedisInsight/pull/1755), [#1762](https://github.com/RedisInsight/RedisInsight/pull/1762) Configure one of the following data decompression formats when adding a database connection to view your data in a human-readable format: GZIP, LZ4, ZSTD, SNAPPY
+- [#1787](https://github.com/RedisInsight/RedisInsight/pull/1787) Added UX improvements to the search by values of keys feature in Browser: Enable the search box after the index is selected
+
+**Bugs**
+- [#1808](https://github.com/RedisInsight/RedisInsight/pull/1808) Prevent errors when running Docker RedisInsight on Safari Version 16.2
+- [#1835](https://github.com/RedisInsight/RedisInsight/pull/1835) Display total memory and total keys for replicas in Sentinel
+---
+Title: Redis Insight v2.58.0, October 2024
+linkTitle: v2.58.0 (October 2024)
+date: 2024-10-01 00:00:00 +0000
+description: Redis Insight v2.58
+weight: 1
+
+---
+## 2.58 (October 2024)
+This is the General Availability (GA) release of Redis Insight 2.58.
+
+### Highlights
+- Added functionality to start, stop, and reset [Redis Data Integration](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) pipelines directly in the app, simplifying management and enhancing control
+- Introduced support for subscribing to specific Pub/Sub channel - a [highly requested feature](https://github.com/RedisInsight/RedisInsight/issues/1671)
+- Ability to delete previously added CA and Client certificates to keep them updated
+
+### Details
+
+**Features and improvements**
+- [#3843](https://github.com/RedisInsight/RedisInsight/pull/3843) Redis Insight now supports starting, stopping, and resetting [Redis Data Integration](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) (RDI) pipelines. Use RDI version 1.2.9 or later to seamlessly stop or resume processing new data. You can also reset an RDI pipeline to take a new snapshot of the data, process it, and continue tracking changes. To get started, navigate to the "Redis Data Integration" tab on the database list page and add or connect to your RDI endpoint.
+- [#3832](https://github.com/RedisInsight/RedisInsight/pull/3832) Added support for a [highly requested feature](https://github.com/RedisInsight/RedisInsight/issues/1671) to subscribe to specific Pub/Sub channels. On the Pub/Sub page, you can now subscribe to multiple channels or patterns by entering them as a space delimited list.
+- [#3796](https://github.com/RedisInsight/RedisInsight/pull/3796) Ability to delete previously added CA and Client certificates to keep them up-to-date.
+
+**Bugs**
+- [#3840](https://github.com/RedisInsight/RedisInsight/pull/3840) [Saved](https://github.com/RedisInsight/RedisInsight/issues/3833) SNI and SSH connection information for newly added database connections.
+- [#3828](https://github.com/RedisInsight/RedisInsight/pull/3828) Fixed an issue to [display multiple hash fields](https://github.com/RedisInsight/RedisInsight/issues/3826) when expanding a hash value.
+---
+Title: RedisInsight v2.42.0, January 2024
+linkTitle: v2.42.0 (January 2024)
+date: 2024-01-30 00:00:00 +0000
+description: RedisInsight v2.42
+weight: 1
+---
+## 2.42 (January 2024)
+This is the General Availability (GA) release of RedisInsight 2.42.
+
+### Highlights
+- Introducing a new dedicated developer enablement area! Explore Redis capabilities and learn how to use the native JSON data structure for structured querying and full-text search, including vector similarity search for AI use cases, and more. Browse the tutorials offline or use the in-app provisioning of a free Redis Cloud database to try them interactively.
+- RedisInsight is now available on Docker. Check out our [Docker repository](https://hub.docker.com/repository/docker/redis/redisinsight/general) if that’s your preferred platform. 
+
+
+### Details
+
+**Features and improvements**
+- [#2724](https://github.com/RedisInsight/RedisInsight/pull/2724), [#2752](https://github.com/RedisInsight/RedisInsight/pull/2752), [#2965](https://github.com/RedisInsight/RedisInsight/pull/2965) Introducing a dedicated developer enablement area. Dive into interactive tutorials and level up your Redis game even without a database connected. Start exploring tutorials by clicking on the "Insights" button located in the top-right corner. Because interactive tutorials can alter data in your database, avoid running them in a production environment. For an optimal tutorial experience, create a free [Redis Cloud](https://redis.com/try-free/?utm_source=redisinsight&utm_medium=main&utm_campaign=redisinsight_release_notes) database.
+- [#2972](https://github.com/RedisInsight/RedisInsight/pull/2972), [#2811](https://github.com/RedisInsight/RedisInsight/pull/2811) The long-awaited Docker build is now available. Check out our [Docker repository](https://hub.docker.com/repository/docker/redis/redisinsight/general) if that’s your preferred platform.
+- [#2857](https://github.com/RedisInsight/RedisInsight/pull/2857) Empty Browser and Workbench pages are aligned with the new interactive tutorials.
+- [#2940](https://github.com/RedisInsight/RedisInsight/pull/2940) Recommendations have been renamed to Tips.
+- [#2970](https://github.com/RedisInsight/RedisInsight/pull/2970) A critical vulnerability has been fixed.
+---
+Title: RedisInsight v1.13, Aug 2022
+linkTitle: v1.13 (Aug 2022)
+date: 2022-08-24 00:00:00 +0000
+description: RedisInsight v1.13.0
+weight: 7
+---
+
+## 1.13.1 (November 2022)
+
+This is the maintenance release of RedisInsight 1.13 (v1.13.1).
+
+### Fixes:
+- Core:
+  - Fixed container vulnerabilities.
+  - Prevented healthcheck API from overloading RedisInsight DB. Earlier, a separate session was created for each healthcheck hit, which overloaded the database with too many session tokens. Now, healtcheck API doesn't create any session tokens.
+  - Get Sentinel host using IP field.
+- Memory Analysis:
+  - Added support for `hashlistpack`, `zsetlistpack`, `quicklist2` and `streamlistpack2`, encoding types.
+
+
+## 1.13.0 (August 2022)
+
+This is the General Availability Release of RedisInsight 1.13 (v1.13.0).
+
+
+## Headlines
+- Subpath Proxy Support
+
+## Details
+
+### Core
+- Subpath Proxy support: RedisInsight can now be proxied behind a subpath
+- Added trusted origins environment variable to set trusted origins
+- Fixed major container vulnerabilities
+- Added proxy notification that displays when such an environment is found
+### RediSearch
+- Fixed index information
+### Profiler
+- Added support for IPv6 clients
+### Memory Analyzer
+- Fixed Lua recommendation
+
+
+---
+Title: Redis Insight v2.54.0, August 2024
+linkTitle: v2.54.0 (August 2024)
+date: 2024-08-06 00:00:00 +0000
+description: Redis Insight v2.54
+weight: 1
+
+---
+## 2.54 (August 2024)
+This is the General Availability (GA) release of Redis Insight 2.54.
+
+### Highlights
+Support for [Redis Data Integration (RDI)](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) - a powerful tool designed to seamlessly synchronize data from your existing database to Redis in near real-time. RDI establishes a data streaming pipeline that mirrors data from your existing database to Redis Software, so if a record is added or updated, those changes automatically flow into Redis. This no-code solution enables seamless data integration and faster data access so you can build real-time apps at any scale. And now you can seamlessly create, validate, deploy, and monitor your data pipelines directly from Redis Insight.
+
+### Details
+
+**Features and improvements**
+- [#2839](https://github.com/RedisInsight/RedisInsight/pull/2839), [#2853](https://github.com/RedisInsight/RedisInsight/pull/2853), [#3101](https://github.com/RedisInsight/RedisInsight/pull/3101) Redis Insight now comes with the support for [Redis Data Integration (RDI)](https://redis.io/data-integration/?utm_source=redisinsight&utm_medium=repository&utm_campaign=release_notes) - a powerful tool designed to seamlessly synchronize data from your existing database to Redis in near real-time. RDI establishes a data streaming pipeline that mirrors data from your existing database to Redis Software, so if a record is added or updated, those changes automatically flow into Redis. This no-code solution enables seamless data integration and faster data access so you can build real-time apps at any scale. Use RDI version 1.2.7 or later to seamlessly create, validate, deploy, and monitor your data pipelines within Redis Insight. To get started, switch to the "Redis Data Integration" tab on the page with the list of Redis databases and add your RDI endpoint to Redis Insight.
+
+**Bugs**
+- [#3577](https://github.com/RedisInsight/RedisInsight/pull/3577) Show [information about OSS cluster](https://github.com/RedisInsight/RedisInsight/issues/3157) when connected using TLS.
+- [#3575](https://github.com/RedisInsight/RedisInsight/pull/3575) Return [results instead of an empty list](https://github.com/RedisInsight/RedisInsight/issues/3465) for commands written in lowercase.
+- [#3613](https://github.com/RedisInsight/RedisInsight/pull/3613) Prevent repetitive buffer overflow by avoiding the resending of unfulfilled commands.
+---
+Title: RedisInsight v2.14.0, November 2022
+linkTitle: v2.14.0 (Nov 2022)
+date: 2022-11-28 00:00:00 +0000
+description: RedisInsight v2.14.0
+weight: 3
+---
+## 2.14.0 (November 2022)
+This is the General Availability (GA) release of RedisInsight 2.14.
+
+### Highlights
+- Support for [search capabilities](https://redis.io/docs/stack/search/) in Browser: Create secondary index via dedicated form, run queries and full-text search in Browser or Tree views
+- Ability to resize the column width of key values when displaying hashes, lists, and sorted sets
+- Command processing time displayed as part of the result in Workbench
+
+
+### Details
+**Features and improvements**
+- [#1345](https://github.com/RedisInsight/RedisInsight/pull/1345), [#1346](https://github.com/RedisInsight/RedisInsight/pull/1346), [#1376](https://github.com/RedisInsight/RedisInsight/pull/1376) Added support for [search capabilities](https://redis.io/docs/stack/search/) in Browser tool. Create secondary index of your data using a dedicated form. Conveniently run your queries and full-text search against the preselected index and display results in Browser or Tree views. 
+- [#1385](https://github.com/RedisInsight/RedisInsight/pull/1385) Resize the column width of key values when displaying hashes, lists, and sorted sets
+- [#1354](https://github.com/RedisInsight/RedisInsight/pull/1407) Do not scroll to the end of results when double-clicking a command output in CLI
+- [#1347](https://github.com/RedisInsight/RedisInsight/pull/1347) Display command processing time as part of the result in Workbench (time taken to process the command by both RedisInsight backend and Redis)
+- [#1351](https://github.com/RedisInsight/RedisInsight/pull/1351) Display the namespaces section in the Database analysis report when no namespaces were found
+---
+Title: RedisInsight v1.12, May 2022
+linkTitle: v1.12 (May 2022)
+date: 2022-05-24 00:00:00 +0000
+description: RedisInsight v1.12.0
+weight: 11
+---
+
+## 1.12.1 (July 2022)
+
+This is the maintenance release of RedisInsight 1.12 (v1.12.1)!
+
+### Critical Bug Fix:
+- Core:
+  - When you add or remove a Redis Enterprise Software or Redis Cloud database in RedisInsight v1 that has the RediSearch module loaded, all hashes within that database are deleted.
+
+### Fixes:
+- Core:
+  - Added curl command to container.
+  - Fixed container vulnerabilities (CVE-2022-1292, CVE-2022-2068).
+- RediSearch:
+  - Fixed index info to report correct information for RediSearch v2.
+- Profiling:
+  - Added support for profiling module commands.
+  - Added support for viewing information of clients that use IPv6 addresses.
+- RedisGraph:
+  - Added support for `RO_QUERY` only mode. RedisGraph now responds to the `RO_QUERY` command.
+
+## 1.12.0 (May 2022)
+
+This is the General Availability Release of RedisInsight 1.12 (v1.12.0)!
+
+## Headlines:
+- [Authenticate database users](https://docs.redis.com/latest/ri/using-redisinsight/auth-database/): Ask for database username and password
+- Support for `GRAPH.RO_QUERY` command in RedisGraph tool.
+- Support for variable CPU in RedisAI tool.
+
+## Full Details
+
+### Core
+- [Authenticate database users](https://docs.redis.com/latest/ri/using-redisinsight/auth-database/): Ask for database username and password
+  - If enabled, each time a user attempts to open a database previously added to RedisInsight, a form to enter username and password is displayed. This form displays also if a user is idle for a configurable amount of time.
+- Fix major container vulnerabilities.
+- Decrease Docker image size by discarding unnecessary contents.
+- Streams
+  - Fix slowdown and crash while loading large streams data.
+  - Use UTC time for stream id timestamp.
+- Graph
+  - Allow scanning for more keys.
+  - Add support for `GRAPH.RO_QUERY` command.
+- Browser
+  - Fix **Delete key** dialog box that displays when no key is selected.
+- RedisAI
+  - Add support for variable CPU number.
+---
+Title: RedisInsight v2.38.0, November 2023
+linkTitle: v2.38.0 (November 2023)
+date: 2023-11-29 00:00:00 +0000
+description: RedisInsight v2.38
+weight: 1
+---
+## 2.38 (November 2023)
+This is the General Availability (GA) release of RedisInsight 2.38.
+
+### Highlights
+- Major UX improvements and space optimization for a cleaner and more organized Tree view, ensuring easier namespace navigation and faster key browsing. Additionally, in Tree view, you can now sort your Redis key names alphabetically.
+- Renamed the application from RedisInsight v2 to simply RedisInsight
+
+### Details
+
+**Features and improvements**
+
+- [#2706](https://github.com/RedisInsight/RedisInsight/pull/2706), [#2783](https://github.com/RedisInsight/RedisInsight/pull/2783) Major UX improvements and space optimization for a cleaner and more organized Tree view. This includes consolidating the display of namespaces and keys in a dedicated section and omitting namespace information from key names in the list of keys. In addition, the Tree view introduces a new option to alphabetically sort Redis key names.
+- [#2751](https://github.com/RedisInsight/RedisInsight/pull/2751) Renamed the application from RedisInsight v2 to simply RedisInsight
+- [#2799](https://github.com/RedisInsight/RedisInsight/pull/2799) Automatically make three retries to establish or re-establish a database connection if an error occurs
+
+**Bugs**
+- [#2793](https://github.com/RedisInsight/RedisInsight/pull/2793) [Do not require](https://github.com/RedisInsight/RedisInsight/issues/2765) an SSH password or passphrase
+- [#2794](https://github.com/RedisInsight/RedisInsight/pull/2794) Prevent [potential crashes](https://github.com/RedisInsight/RedisInsight/issues/2763) caused by using parentheses in usernames on the Windows operating system
+- [#2797](https://github.com/RedisInsight/RedisInsight/pull/2797) Avoid initiating a bulk deletion or Profiler after the operating system resumes from sleep mode
+---
+Title: RedisInsight v2.18.0, January 2023
+linkTitle: v2.18.0 (Jan 2023)
+date: 2023-01-31 00:00:00 +0000
+description: RedisInsight v2.18.0
+weight: 1
+---
+## 2.18.0 (January 2023)
+This is the General Availability (GA) release of RedisInsight 2.18.
+
+### Highlights
+- Support for SSH tunnel to connect to your Redis database
+- Ability to switch between database indexes while connected to your database
+- Recommendations on how to optimize the usage of your database
+
+### Details
+**Features and improvements**
+- [#1567](https://github.com/RedisInsight/RedisInsight/pull/1567), [#1576](https://github.com/RedisInsight/RedisInsight/pull/1576), [#1577](https://github.com/RedisInsight/RedisInsight/pull/1577) Connect to your Redis database via SSH tunnel using a password or private key in PEM format.
+- [#1540](https://github.com/RedisInsight/RedisInsight/pull/1540), [#1608](https://github.com/RedisInsight/RedisInsight/pull/1608) Switch between database indexes while connected to your database in Browser, Workbench, and Database Analysis.
+- [#1457](https://github.com/RedisInsight/RedisInsight/pull/1457), [#1465](https://github.com/RedisInsight/RedisInsight/pull/1465), [#1590](https://github.com/RedisInsight/RedisInsight/pull/1590) Run Database Analysis to generate recommendations on how to save memory and optimize the usage of your database. These recommendations are based on industry standards and Redis best practices. Upvote or downvote recommendations in terms of their usefulness. 
+- [#1598](https://github.com/RedisInsight/RedisInsight/pull/1598) Check and highlight the [JSON](https://redis.io/docs/stack/json/) syntax using new [Monaco Editor](https://microsoft.github.io/monaco-editor/).
+- [#1583](https://github.com/RedisInsight/RedisInsight/pull/1583) Click a pencil icon to make changes to database aliases.
+- [#1579](https://github.com/RedisInsight/RedisInsight/pull/1579) Increase the database password length limitation to 10,000.
+---
+aliases: /develop/connect/insight/release-notes
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description:
+linkTitle: Release notes
+title: Redis Insight release notes
+weight: 7
+hideListLinks: true
+---
+
+Here are the most recent changes for Redis Insight:
+
+{{< table-children columnNames="Version (Date),Release notes" columnSources="LinkTitle,Title" enableLinks="Title" >}}
+---
+Title: RedisInsight v1.6, June 2020 
+linkTitle: v1.6 (June 2020)
+date: 2020-06-10 00:00:00 +0000
+description: Rootless Docker container, Copy keys in Browser and Stream UX improvements
+weight: 94
+---
+
+## 1.6.3 (July 2020)
+
+Maintenance release for RedisInsight 1.6 including bug fixes and enhancements.
+
+### Headlines:
+
+- Mac application is now getting notarized which simplifies the installation process on OS X
+- Fixed the resize of the keys explorer allowing to see long keys
+- Fixed filtering of keys in the browser with the filter capability in the browser
+
+### Full details:
+
+Enhancements and bug fixes
+  - Core:
+    - Mac application is properly signed and notarized on Apple services.
+  - Browser:
+    - Fixed resizing the key explorer allows to see more characters of long keys.
+    - Asynchronous loading of keys in large databases (discovered keys are actionable while search continues).
+    - Improved performance for exact key searches (when search pattern is not using *).
+    - Improved UI showing the progress of scanning the keys in the database.
+    - Fixed filtering the keys by data structures could be  to wrong.
+    - Fixed behavior of EXISTS and TYPE command when those have ACL restrictions.
+    - Fixed behavior when keys matching filters have ACL restrictions.
+    - Improved “Stop Scan” button behavior to respond immediately.
+    - Added visual indicator to show that by default, the browser is filtering out inner keys from modules.
+
+## 1.6.2 (30 June 2020)
+
+Maintenance release for RedisInsight 1.6 including bug fixes and enhancements.
+
+### Headlines:
+
+- Performance improvements to Profiler tool for TLS-enabled databases.
+- Bugfix: Feedback button was not visible.
+
+### Full details:
+
+- Enhancements and bug fixes
+  - Core:
+      - Bugfix: Feedback button was not visible.
+  - Profiler:
+      - The native code implementation of the profiling logic was updated to add full support for TLS connections to Redis.
+  - Graph:
+      - Updated to use a newer version of the Ogma graph visualization library.
+  - Analytics:
+      - Bugfix: Report the OS/platform correctly.
+
+## 1.6.1 (24 June 2020)
+
+Maintenance release for RedisInsight 1.6 including bug fixes and enhancements.
+
+### Headlines:
+
+- Improved support for Redis 6 ACLs with Cluster and Sentinel databases
+- Added support for Redis Cluster in RedisGraph tool
+- UX improvements for RedisGraph tool
+- Enriched captured usage events
+
+### Full details:
+
+- Enhancements and bug fixes
+  - Core:
+    - Improved support for Redis 6 ACLs with Cluster and Sentinel databases
+    - Added events capturing usage of RedisInsight
+  - Graph:
+    - Add support for Redis Cluster
+    - Added option to configure labels to be displayed in graph's nodes (right-click on the node)
+    - Added ability to submit query with 'ctrl + enter' in single line mode
+  - TimeSeries:
+    - Added ability to submit query with 'ctrl + enter' in single line mode
+  - RediSearch:
+    - Added ability to submit query with 'ctrl + enter' in single line mode
+    - Better handling of long index names in index selector dropdown
+    - Fixed bug with pagination on queries with whitespace in the query string
+  - Gears:
+    - Added button to remove an execution from executed functions list
+    - Added option to get rid of the warning message when executing a function 
+    - Fixed error message when it's impossible to visualize the graph
+  - Streams:
+    - Added persistence of user's selected stream columns when switching pages
+
+## 1.6.0 (11 June 2020)
+
+This is the General Availability Release of RedisInsight 1.6!
+
+### Headlines:
+
+- RedisInsight docker container is now rootless being compliant with best practices for containers
+- The Browser gets improved to allow quick copy of keys and resizing of the key explorer
+- Streams is now allowing to sort entries by timestamp, active/unactive live streaming of entries and keep persisted user's selection of fields to save context when switching between streams or other tools of RedisInsight. 
+- New telemetry system allowing to capture tools usage and updated privacy settings
+
+### Full details:
+
+- Features
+  - Core:
+    - Improved docker container by making it rootless
+    - Added visual indicator to show configured user when connecting to Redis 6 using ACLs
+    - Improved navigation to application's settings
+  - Browser:
+    - Added ability to resize the Key explorer panel
+    - Added options to easily copy keys
+    - Added ability to filter out the inner keys
+  - Streams: 
+    - Added persisting selected fields to be displayed to save context when switching to another stream or tool of RedisInsight 
+    - Added ability to sort entries "ascending" or "descending" based on the timestamp
+    - Added ability to active/unactive the live streaming of events 
+    - Updated timestamp font family for consistency
+  - CLI:
+    - Added ACL commands hints and summary info in CLI
+
+- Bug Fixes:
+  - Core:
+    - Fixed issue fetching data from Redis Cloud and replica enabled
+  - Browser:
+    - Fixed issue not shown field named "key" in hash keys
+    - Fixed wrong number of database's keys being displayed
+    - Fixed error when trying to view a Java serialized object
+  - Stream:
+    - Fixed issue with live streaming of entries
+    - Fixed UI when no entries are present in a stream
+  - Bulk Actions:
+    - Fixed responsiveness of the UI
+  - RedisGears:
+    - Fixed focus on editor and display of requirements
+---
+Title: RedisInsight v2.34.0, September 2023
+linkTitle: v2.34.0 (September 2023)
+date: 2023-09-28 00:00:00 +0000
+description: RedisInsight v2.34
+weight: 1
+---
+## 2.34 (September 2023)
+This is the General Availability (GA) release of RedisInsight 2.34.
+
+### Highlights
+- UX improvements to simplify the in-app provisioning and usage of a free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_34) database with RedisInsight interactive tutorials. This will allow you to learn easily, among other things, how to leverage the native JSON data structure supporting structured querying and full-text search, including vector similarity search for your AI use cases
+- Ability to refresh the list of [search indexes](https://redis.io/docs/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=main) displayed in Browser
+- Set the color theme to follow the local system preferences
+
+### Details
+
+**Features and improvements** 
+- [#2585](https://github.com/RedisInsight/RedisInsight/pull/2585) UX improvements to simplify the in-app provisioning and usage of a free [Redis Cloud](https://redis.com/comparisons/oss-vs-enterprise/?utm_source=redisinsight&utm_medium=rel_notes&utm_campaign=2_34) database with RedisInsight interactive tutorials. To provision a new database, click the "Try Redis Cloud" banner in the list of database connections page and follow the steps
+- [#2606](https://github.com/RedisInsight/RedisInsight/pull/2606) Ability to refresh the list of [search indexes](https://redis.io/docs/interact/search-and-query/?utm_source=redisinsight&utm_medium=main&utm_campaign=main) displayed in Browser
+- [#2593](https://github.com/RedisInsight/RedisInsight/pull/2593) UX optimizations to improve the back navigation to the list of databases, including for small resolutions
+- [#2599](https://github.com/RedisInsight/RedisInsight/pull/2599) Added an option to set the color theme to follow the local system preferences
+- [#2563](https://github.com/RedisInsight/RedisInsight/pull/2563) Load a new library from the Functions tab within the [Triggers and Functions](https://redis.com/blog/introducing-triggers-and-functions/?utm_source=redisinsight&utm_medium=main&utm_campaign=main) tool
+- [#2496](https://github.com/RedisInsight/RedisInsight/pull/2496) Set milliseconds as a default unit in Slow Log
+
+**Bugs**
+- [#2587](https://github.com/RedisInsight/RedisInsight/pull/2587) Display detailed [errors](https://github.com/RedisInsight/RedisInsight/issues/2562) in transactions run via CLI or Workbench
+---
+aliases: /develop/connect/insight/tutorials/insight-stream-consumer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to manage streams and consumer groups in Redis Insight
+linkTitle: Streams
+title: Manage streams and consumer groups in Redis Insight
+weight: 5
+---
+
+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]({{< relref "/develop/data-types/streams" >}}). 
+
+In this topic, you will learn how to add and work with streams as well as consumer groups in Redis Insight.
+
+Here's a stream that models temperature and humidity sensors. Processes interacting with the stream perform one of two roles: _consumer_ and _producer_. 
+The point of a stream is that it's not going to end, so you cannot capture whole datasets and do some processing on them. 
+ 
+In this stream, sensors are considered _producers_, which broadcast data. 
+A _consumer_ reads from the stream and does some work on it. 
+For example, if the temperature is above a certain threshold, it puts a message out to turn on the air conditioner in that unit or notify the maintenance.
+
+<img src="../images/stream.png">
+
+
+It is possible to have multiple consumers doing different jobs, one measuring humidity, and another taking temperature measurements over periods of time. 
+Redis stores a copy of the entire dataset in memory, which is a finite resource.
+To avoid runaway data, streams can be trimmed when you add something to them. 
+When adding to a stream with [`XADD`]({{< relref "/commands/xadd" >}}), you can optionally specify that the stream should be trimmed to a specific or approximate number of the newest entries, or to only include entries whose ID is higher than the ID specified.
+You can also manage the storage required for streaming data using key expiry.  For example, by writing each day's data to its own stream in Redis and expiring each stream's key after a period of time, say a week.
+An ID can be any number, but each new entry in the stream must have an ID whose value is higher than the last ID added to the stream.
+
+## Adding new entries 
+
+Use [`XADD`]({{< relref "/commands/xadd" >}}) with `*` for the ID to have Redis automatically generate a new ID for you consisting of a millisecond precision timestamp, a dash and a sequence number.  For example `1656416957625-0`.  Then supply the field names and values to store in the new stream entry.
+
+There are a couple of ways of retrieving things. You can retrieve entries by time range or you could ask for everything that's happened since a timestamp or ID that you specify. Using a single command you can ask for anything from 10:30 until 11:15 am on a given day.
+
+## Consumer groups
+
+A more realistic use case would be a system with many temperature sensors whose data Redis puts in a stream, records the time they arrive, and orders them. 
+
+<img src="../images/consumer.png">
+
+On the right side we have two consumers that read the stream. One of them is alerting if the temperature is over a certain number and texting the maintenance crew that they need to do something, and the other is a data warehouse that is taking the data and putting it into a database. 
+
+They run independently of each other. 
+Up in the right, we have another sort of task. 
+Let's assume that alerting and data warehouse are really fast. 
+You get a message whether the temperature is larger than a specific value, which might take a millisecond. 
+And alerting can keep up with the data flow. 
+One way you can scale consumers is _consumer groups_, which allows multiple instances of the same consumer or same code to work as a team to process the stream.
+
+## Managing streams in Redis Insight
+
+You can add a stream in Redis Insight in two ways: create a new stream or add to an existing stream.
+
+To create a stream, start by selecting the key type (stream). 
+You cannot set time to live (TTL) because it cannot be put on a message in a stream; it can only be done on a Redis key. Name the stream _mystream_. 
+Then, set the *Entry ID* to `*` to default to timestamp. 
+If you have your own ID generation strategy, enter the next ID from your sequence. Remember that the ID must be higher than the ID of any other entry in the stream.
+ 
+Then, enter fields and values using + to add more than one (for example, name and location). 
+Now you have a stream that appears in the **Streams** view and you can continue adding fields and values to it.
+
+Redis Insight runs read commands for you so you can see the stream entries in the **Streams** view. 
+And the **Consumer Groups** view shows each consumers in a given consumer group and the last time Redis allocated a message, what the ID of it was and how many times that process has happened, and whether a consumer has you have told Redis that you are finished working with that task using the [`XACK`]({{< relref "/commands/xack" >}}) command.
+
+## Monitor temperature and humidity from sensors in Redis Insight
+
+This example shows how to bring an existing stream into Redis Insight and work with it.
+
+### Setup
+
+1. Install [Redis Insight](https://redis.com/redis-enterprise/redis-insight/?_ga=2.48624486.1318387955.1655817244-1963545967.1655260674#insight-form).
+2. Download and install [Node.js](https://nodejs.org/en/download/) (LTS version).
+3. Install [Redis]({{< relref "/operate/oss_and_stack/install" >}}). In Docker, check that Redis is running locally on the default port 6379 (with no password set). 
+4. Clone the [code repository](https://github.com/redis-developer/introducing-redis-talk) for this example. 
+See the [README](https://github.com/redis-developer/introducing-redis-talk/tree/main/streams) for more information about this example and installation tips.
+5. On your command-line, navigate to the folder containing the code repository and install the Node.js package manager (npm). 
+
+ {{< highlight bash >}}
+ npm install
+ {{< / highlight >}}
+
+### Run the producer
+
+To start the producer, which will add a new entry to the stream every few seconds, enter:
+
+{{< highlight bash >}}
+npm run producer
+
+> streams@1.0.0 producer
+> node producer.js
+
+Starting producer...
+Adding reading for location: 62, temperature: 40.3, humidity: 36.5
+Added as 1632771056648-0
+Adding reading for location: 96, temperature: 15.4, humidity: 70
+Added as 1632771059039-0
+...
+{{< / highlight >}}
+
+The producer runs indefinitely. 
+Select `Ctrl+C` to stop it. 
+You can start multiple instances of the producer if you want to add entries to the stream faster.
+
+### Run the consumer
+
+To start the consumer, which reads from the stream every few seconds, enter:
+
+{{< highlight bash >}}
+npm run consumer
+
+> streams@1.0.0 consumer
+> node consumer.js
+
+Starting consumer...
+Resuming from ID 1632744741693-0
+Reading stream...
+Received entry 1632771056648-0:
+[ 'location', '62', 'temp', '40.3', 'humidity', '36.5' ]
+Finished working with entry 1632771056648-0
+Reading stream...
+Received entry 1632771059039-0:
+[ 'location', '96', 'temp', '15.4', 'humidity', '70' ]
+{{< / highlight >}}
+
+The consumer stores the last entry ID that it read in a Redis string at the key `consumer:lastid`. It uses this string to pick up from where it left off after it is restarted. Try this out by stopping it with `Ctrl+C` and restarting it.
+
+Once the consumer has processed every entry in the stream, it will wait indefinitely for instances of the producer to add more:
+
+{{< highlight bash >}}
+Reading stream...
+No new entries since entry 1632771060229-0.
+Reading stream...
+No new entries since entry 1632771060229-0.
+Reading stream...
+{{< / highlight >}}
+
+Stop it using `Ctrl+C`.
+
+### Run a consumer group
+
+A consumer group consists of multiple consumer instances working together. Redis manages allocation of entries read from the stream to members of a consumer group. A consumer in a group will receive a subset of the entries, with the group as a whole receiving all of them. When working in a consumer group, a consumer process must acknowledge receipt/processing of each entry.
+
+Using multiple terminal windows, start three instances of the consumer group consumer, giving each a unique name:
+
+{{< highlight bash >}}
+npm run consumergroup consumer1
+
+> streams@1.0.0 consumergroup
+> node consumer_group.js -- "consumer1"
+
+Starting consumer consumer1...
+Consumer group temphumidity_consumers exists, not created.
+Reading stream...
+Received entry 1632771059039-0:
+[ 'location', '96', 'temp', '15.4', 'humidity', '70' ]
+Acknowledged processing of entry 1632771059039-0.
+Reading stream...
+{{< / highlight >}}
+
+In a second terminal:
+
+{{< highlight bash >}}
+npm run consumergroup consumer2
+{{< / highlight >}}
+
+And in a third:
+
+{{< highlight bash >}}
+npm run consumergroup consumer3
+{{< / highlight >}}
+
+The consumers will run indefinitely, waiting for new messages to be added to the stream by a producer instance when they have collectively consumed the entire stream. 
+Note that in this model, each consumer instance does not receive all of the entries from the stream, but the three members of the group each receive a subset.
+
+### View the stream in Redis Insight
+
+1. Launch Redis Insight.
+2. Select `localhost:6379`
+3. Select **STREAM**. Optionally, select full screen from the upper right corner to expand the view.
+
+<img src="../images/insight_streams.png">
+
+
+You can now toggle between **Stream** and **Consumer Groups** views to see your data. 
+As mentioned earlier in this topic, a stream is an append-only log so you can't modify the contents of an entry, but you can delete an entire entry. 
+A case when that's useful is in the event of a so-called _poison-pill message_ that can cause consumers to crash. You can physically remove such messages in the **Streams** view or use the [`XDEL`]({{< relref "/commands/xdel" >}}) command at the command-line interface (CLI).
+
+You can continue interacting with your stream at the CLI. For example, to get the current length of a stream, use the [`XLEN`]({{< relref "/commands/xlen" >}}) command:
+
+{{< highlight bash >}}
+XLEN ingest:temphumidity
+{{< / highlight >}}
+
+Use streams for auditing and processing events in banking, gaming, supply chain, IoT, social media, and so on.
+
+## Related topics
+
+- [Redis Streams]({{< relref "/develop/data-types/streams" >}})
+- [Introducing Redis Streams with Redis Insight, node.js, and Python](https://www.youtube.com/watch?v=q2UOkQmIo9Q) (video)---
+aliases: /develop/connect/insight/debugging
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis Insight debugging information
+linkTitle: Debugging information
+stack: true
+title: Redis Insight debugging information
+weight: 6
+---
+
+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.
+
+### 1. Launch Redis Insight in debug mode
+
+Run the following command to launch Redis Insight in debug mode to investigate connection issues:
+
+* **Windows**:
+
+    `cmd /C “set DEBUG=ioredis* && ".\Redis Insight.exe"”`
+
+* **macOS** (from the Applications folder):
+
+    `DEBUG=ioredis* open "Redis Insight.app"`
+
+* **Linux**:
+
+    `DEBUG=ioredis* "redis insight"`
+
+### 2. Investigate logs
+
+You can review the Redis Insight log files (files with a `.log` extension) to get detailed information about system issues.
+These are the locations on supported platforms:
+
+- **Docker**: In the `/data/logs` directory *inside the container*.
+- **macOS**: In the `/Users/<your-username>/.redis-insight` directory.
+- **Windows**: In the `C:\Users\<your-username>\.redis-insight` directory.
+- **Linux**: In the `/home/<your-username>/.redis-insight` directory.
+
+## Other issues
+### To debug issues other than connectivity
+
+* **Windows**:
+
+    `cmd /C “set DEBUG=* && ".\Redis Insight.exe"”`
+
+* **macOS** (from the Applications folder):
+
+    `DEBUG=* open "Redis Insight.app"`
+
+* **Linux**:
+
+    `DEBUG=* "redis insight"`
+
+### Get detailed Redis Insight logs
+
+* **Windows**:
+
+    `cmd /C “set STDOUT_LOGGER=true && set LOG_LEVEL=debug && set LOGGER_OMIT_DATA=false && ".\Redis Insight.exe"”`
+
+* **macOS** (from the Applications folder):
+
+    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false open "Redis Insight.app"`
+
+* **Linux**:
+
+    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false "redis insight"`
+
+    Note: if you use LOGGER_OMIT_DATA=false, logs may contain sensitive data.
+
+### To log everything
+* **Windows**:
+
+    `cmd /C “set STDOUT_LOGGER=true && set LOG_LEVEL=debug && set LOGGER_OMIT_DATA=false && set DEBUG=* && ".\Redis Insight.exe"”`
+
+* **macOS** (from the Applications folder):
+
+    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false DEBUG=* open "Redis Insight.app"`
+
+* **Linux**:
+
+    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false DEBUG=* "redis insight"`
+
+    Note: if you use LOGGER_OMIT_DATA=false or DEBUG=*, logs may contain sensitive data.---
+aliases: /develop/connect/insight/rdi-connector
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect to RDI from Redis Insight, configure pipelines, and more.
+linkTitle: RDI in Redis Insight
+stack: true
+title: RDI in Redis Insight
+weight: 4
+---
+
+Redis Data Integration (RDI) and its [ingest pipeline capability]({{< relref "/integrate/redis-data-integration" >}}) 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]({{< relref "/integrate/redis-data-integration/architecture" >}}).
+
+As of version `2.54.0`, Redis Insight includes RDI connectivity, which allows you to connect to [RDI management planes]({{< relref "/integrate/redis-data-integration/architecture" >}}#how-rdi-is-deployed), create, test, and deploy [RDI pipelines]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}), and view RDI statistics.
+
+## Connect
+
+Open Redis Insight, click on the **Redis Data Integration** tab, and then click on one of the two **+ Add RDI Endpoint** buttons as shown below.
+
+<img src="../images/ri-rdi-add-endpoint1.png">
+
+Enter your RDI server details in the provided dialog. The **RDI Alias** field can be any name you choose and it will be used as the primary name in the **RDI Instances** list view.
+
+<img src="../images/ri-rdi-add-endpoint2.png">
+
+You'll receive notification if your connection is successful.
+
+<img src="../images/ri-rdi-endpoint-added.png">
+
+## Create, test, and deploy RDI pipelines
+
+Begin by clicking the alias of your newly configured RDI endpoint in the **RDI Instances** view (for example, **Test connection** in the above image). You'll see the following dialog in the center of the screen.
+
+<img src="../images/ri-rdi-pl-start.png">
+
+Choose from the following options:
+
+- **Download from server** - Download an existing pipeline from your RDI configuration.
+- **Upload from file** - Upload YAML pipeline files from your local computer in zip format.
+- **Create new pipeline** - Use Redis Insight's built-in editors to create a new pipeline either from scratch or using one of the built-in templates.
+
+Each of these menu options will be described in more detail in subsequent sections.
+
+There are also equivalent buttons at the top of the editor pane for the first two of these functions.
+
+<img src="../images/ri-rdi-pl-editor-minibuttons.png">
+
+If you'd rather start with an empty configuration, exit the dialog, which will leave you in the **Configuration file** editor where you can begin editing the configuration component of your pipeline; the `config.yaml` file.
+
+### Download a pipeline from your RDI configuration
+
+Click the **Download from server** button in the **Start with your pipeline** dialog to download a previously defined pipeline from your RDI configuration. The downloaded pipeline will be displayed in the **Pipeline management** pane. As shown below, each pipeline consists of a configuration file (`config.yaml`) and zero or more `job` YAML files. The configuration file will be displayed in the center editor panel.
+
+<img src="../images/ri-rdi-pl-dl.png">
+
+### Upload a pipeline from your local machine
+
+Click the **Upload from file** button in the **Start with your pipeline** dialog to upload your configuration and job YAML files from your local machine. The files must be stored in a zip file that has the following structure.
+
+```
+├── config.yaml
+└── jobs
+    └── job1.yaml
+```
+
+The `config.yaml` file, your configuration YAML file, is required. The `jobs` directory can be empty, as job pipelines are not required, but the empty directory must exist in the zip file. Otherwise, the `jobs` folder might contain one or more job YAML files.
+
+### Create a new configuration file using the built-in editor
+
+Click the **Create new pipeline** button in the **Start with your pipeline** dialog to create a new pipeline using the built-in editors. After doing so, you'll enter the **Configuration file** editor and you'll see an open **Select a template** dialog in the upper right-hand corner of the editor.
+
+<img src="../images/ri-rdi-pl-editor-dlg.png">
+
+Make your selections in the provided fields:
+
+- **Pipeline type** is set to **Ingest** by default.
+- **Database type** has six options:
+  - mongodb
+  - cassandra
+  - mysql
+  - oracle
+  - postgresql
+  - sqlserver
+
+{{< note >}}
+The options listed in the above menus depend on the capabilities of your RDI configuration.
+{{< /note >}}
+
+After you make your selections and click **Apply**, Redis Insight will populate the editor window with an appropriate template. To start from scratch, click **Cancel**.
+
+See the [RDI documentation]({{< relref "/integrate/redis-data-integration/reference/config-yaml-reference" >}}) for information about required fields.
+
+<img src="../images/ri-rdi-pl-editor-template.png">
+
+### Test your target database connection
+
+After you've created your **Target database configuration**, you can test the connection using the **Test Connection** button in the bottom right of the editor pane. A new panel will open to the right containing the test results as shown below.
+
+<img src="../images/ri-rdi-pl-test-cxn.png">
+
+### Create a new transformation job file using the built-in editor
+
+In the **Pipeline Management** pane, click the `+` next to the **Jobs** folder and enter a name for the new transformation job.
+Next, click the job name you just created.
+This will take you to the job editor with the template selection menu open. Make your selection and click **Apply**. Redis Insight will populate the editor window with an appropriate template. To start from scratch, click **Cancel**.
+
+{{< note >}}
+The options listed in the above menu depend on the capabilities of your RDI configuration.
+{{< /note >}}
+
+The [RDI documentation]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples" >}}) has several examples of transformation jobs that can help get you started. Note: RDI uses a very specific YAML format for job files. See [here]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}#job-files) for more information.
+
+<img src="../images/ri-rdi-job-editor-template.png">
+
+## Use the built-in editors
+
+The Redis Insight pipeline file editors are context-aware. They provide auto-completion, syntax highlighting, and error detection for:
+
+- YAML files in the configuration and job file editors
+- JMESPath and SQL function snippets in a dedicated editor. To open the JMESPath and SQL editor, click the **SQL and JMESPathEditor** button as shown above. A new editor window will open in the lower half of the screen.
+
+If you decided to write your own configuration pipeline without using a template, you would see auto-completion prompts such as the one shown below.
+
+<img src="../images/ri-rdi-pl-editor-autoc.png">
+
+While this isn't a replacement for the RDI documentation, it can help speed you along after you have basic familiarity with the building blocks of RDI pipeline files.
+
+Redis Insight will also highlight any errors as shown below.
+
+<img src="../images/ri-rdi-pl-editor-errs.png">
+
+Here's an example showing the SQL and JMESPath editor pane. Note the toggle in the bottom left corner of this editor pane. Clicking it allows you to select from:
+
+- SQLite functions
+- JMESPath
+
+After constructing your SQLite or JMESPath code, copy it to the main editor window. Here's a [reference]({{< relref "/integrate/redis-data-integration/reference/jmespath-custom-functions" >}}) to the supported JMESPath extension functions and expressions that you can use in your job files.
+
+<img src="../images/ri-rdi-pl-editor-sql-minie.png">
+
+{{< warning >}}
+Any changes you make in the editors will be lost if you exit Redis Insight without saving your work. To save any changes you made to your pipeline files, deploy them to your RDI server (see below) or download the modified files as a zip file to your local disk using the **Download** button in the top right of the RDI window. Redis Insight will prepend a green circle on unsaved/undeployed files.
+
+<img src="../images/ri-rdi-pl-unsaved.png">
+{{< /warning >}}
+
+## Dry run transformation job pipelines
+
+After you've created a transformation job pipeline, you can execute a dry run on the RDI server. To do that, click on **Dry Run** in the lower right side of the editor pane. A new **Test transformation logic** panel will open to the side. There are two vertically-stacked panes: **Input** and **Results**. In the **Input** section, enter JSON data that will trigger the transformation. Any results will be displayed in the **Results** section.
+
+There are two tabs in the **Results** section:
+
+1. **Transformations** - this is where you'll see JSON output from your dry run.
+1. **Output** - (not shown) this is where you'll see the Redis commands that would have been run in a real scenario.
+
+Here's an example.
+
+<img src="../images/ri-rdi-pl-dryrun.png">
+
+## Deploy pipelines and add target DB to Redis Insight
+
+If you're satisfied with your configuration and transformation job pipelines, you can deploy them to the RDI management plane. Click the **Deploy Pipeline** button to proceed.
+
+After your pipelines have been deployed, you can add the RDI target Redis database defined in your `config.yaml` file to Redis Insight.
+Doing so will allow you to monitor key creation from your RDI pipeline over time.
+
+## View RDI statistics
+
+You can view various statistics for your RDI deployment. To do so, click  the **Pipeline Status** menu button in the left side menu panel.
+
+<img src="../images/ri-rdi-stats-view.png">
+
+Each statistics section is either static or refreshed automatically at a particular interval that you set.
+The first section, **Processing performance information** is set by default to refresh every 5 seconds.
+The other sections are static and need to be refreshed manually by pressing the refresh button at the top right of each section.
+You can also set up automatic refresh for the other sections.
+
+To set up automatic refresh for one or more statistics sections, click on the downward arrow at the end of the **Last refresh** line.
+Then enable the **Auto Refresh** setting and set your desired refresh interval in seconds. This is shown in the previous image.
+---
+aliases: /develop/connect/insight
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Visualize and optimize Redis data, connect to RDI, and more.
+hideListLinks: true
+linkTitle: Redis Insight
+stack: true
+title: Redis Insight
+weight: 1
+---
+
+[![Discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/QUkjSsk)
+[![Github](https://img.shields.io/static/v1?label=&message=repository&color=5961FF&logo=github)](https://github.com/redisinsight/redisinsight/)
+
+Redis Insight is a powerful tool for visualizing and optimizing data in Redis, making real-time application development easier and more fun than ever before. Redis Insight lets you do both GUI- and CLI-based interactions in a fully-featured desktop GUI client.
+
+### Installation and release notes
+
+* See [these pages]({{< relref "/operate/redisinsight/install" >}}) for installation information.
+
+* [Redis Insight Release Notes](https://github.com/Redis-Insight/Redis-Insight/releases)
+
+## Overview
+
+### Connection management
+
+* Automatically discover and add your local Redis databases (that use standalone connection type and do not require authentication).
+* Discover your databases in Redis Enterprise Cluster and databases with Flexible plans in Redis Cloud.
+* Use a form to enter your connection details and add any Redis database running anywhere (including Redis Open Source cluster or sentinel).
+* Connect to a Redis Data Integration (RDI) management plane, create, test, and deploy RDI pipelines, and view RDI statistics.
+
+<img src="images/Databases.png">
+
+{{< note >}}
+When you add a Redis database for a particular user using the `username` and `password` fields, that user must be able to run the `INFO` command. See the [access control list (ACL) documentation]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) for more information.
+{{< /note >}}
+
+### 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 Redis Insight as well as within the Redis public documentation.
+
+Currently, Redis Copilot provides two primary features: a general chatbot and a context-aware data chatbot.
+
+**General chatbot**: the knowledge-based chatbot serves as an interactive and dynamic documentation interface to simplify the learning process. You can ask specific questions about Redis commands, concepts, and products, and get responses on the fly. The general chatbot is also available in our public docs.
+
+**My data chatbot**: the context-aware chatbot available in Redis Insight lets you construct search queries using everyday language rather than requiring specific programming syntax. This feature lets you query and explore data easily and interactively without extensive technical knowledge.
+
+Here's an example of using Redis Copilot to search data using a simple, natural language prompt.
+
+<img src="images/copilot-example.png">
+
+See the [Redis Insight Copilot FAQ]({{< relref "/develop/tools/insight/copilot-faq" >}}) for more information.
+
+### RDI in Redis Insight
+
+Redis Insight includes Redis Data Integration (RDI) connectivity, which allows you to connect to an RDI management plane, and create, test, and deploy RDI pipelines. Read more about this feature [here]({{< relref "/develop/tools/insight/rdi-connector" >}}).
+
+### Browser
+
+Browse, filter and visualize your key-value Redis data structures.
+* [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) support for lists, hashes, strings, sets, sorted sets, and streams 
+* CRUD support for [JSON]({{< relref "/develop/data-types/json/" >}})
+* Group keys according to their namespaces
+
+  <img src="images/Browser.png">
+
+* View, validate, and manage your key values in a human-readable format using formatters that prettify and highlight data in different formats (for example, Unicode, JSON, MessagePack, HEX, and ASCII) in the Browser tool.
+
+  <img src="images/data_formatting.png">
+
+### Profiler
+
+Analyze every command sent to Redis in real time.
+
+<img src="images/Profiler.png">
+
+### CLI
+
+The CLI is accessible at any time within the application. 
+* Employs integrated help to deliver intuitive assistance
+* Use together with a convenient command helper that lets you search and read on Redis commands.
+
+<img src="images/CLI.png">
+
+### Workbench
+
+Workbench is an advanced command line interface with intelligent command auto-complete and complex data visualization support.
+* Built-in guides: you can conveniently discover Redis and Redis Open Source features using the built-in guides.
+* Command auto-complete support for all features in Redis and Redis Open Source.
+* Advanced, schema-aware auto-complete for Redis Query Engine, which provides for faster query building with context-sensitive suggestions that recognize indexes, schemas, and fields based on your current query. Start typing any Redis Query Engine command in to try this feature. See below for an example of an in-progress `FT.SEARCH` command.
+
+<img src="images/Workbench_Search.png">
+
+Workbench also includes:
+
+* Visualizations of your indexes, queries, and aggregations.
+* Visualizations of your [time series]({{< relref "/develop/data-types/timeseries/" >}}) data.
+
+  <img src="images/Workbench_TimeSeries.png">
+
+## Tools
+
+### Database analysis
+
+Use the database analysis tool to optimize the performance and memory usage of your Redis database. Check data type distribution and memory allocation and review the summary of key expiration time and memory to be freed over time. Inspect the top keys and namespaces sorted by consumed memory or key length and count of keys, respectively. Capture and track the changes in your database by viewing historical analysis reports. Next figure shows a sample database analysis report.
+
+{{< note >}}
+The database analysis tool will only analyze up to 10,000 keys. If more than 10,000 keys are present, the tool will attempt to use extrapolation in its analysis.
+{{< /note >}}
+
+<img src="images/database_analysis.png">
+
+### Redis Streams support
+
+Create and manage streams by adding, removing, and filtering entries per timestamp. To see and work with new entries, enable and customize the automatic refresh rate.
+
+View and manage the list of consumer groups. See existing consumers in a given consumer name as well as the last messages delivered to them. Inspect the list of pending messages, explicitly acknowledge the processed items, or claim unprocessed messages via Redis Insight.
+
+<img src="images/streams.png">
+
+### Search features
+
+If you're using the indexing, querying, or full-text search features of Redis Open Source, Redis Insight provides UI controls to quickly and conveniently run search queries against a preselected index. You can also create a secondary index of your data in a dedicated pane.
+
+<img src="images/search.png">
+
+### Bulk actions
+
+Easily and quickly delete multiple keys of the same type and/or with the same key name pattern in bulk. To do so, in the List or Tree view, set filters per key type or key names and open the Bulk Actions section. The section displays a summary of all the keys with the expected number of keys that will be deleted based on the set filters.
+
+When the bulk deletion is completed, Redis Insight displays the results of this operation with the number of keys processed and the time taken to delete the keys in bulk.
+Use bulk deletion to optimize the usage of your database based on the results from the Redis database analysis.
+
+<img src="images/bulk_actions.png">
+
+### Slow Log
+
+The Slow Log tool displays the list of logs captured by the SLOWLOG command to analyze all commands that exceed a specified runtime, which helps with troubleshooting performance issues. Specify both the runtime and the maximum length of Slowlog (which are server configurations) to configure the list of commands logged and set the auto-refresh interval to automatically update the list of commands displayed.
+
+<img src="images/slowlog.png">
+
+## Plugins
+
+With Redis Insight you can now also extend the core functionality by building your own data visualizations. See our [plugin documentation](https://github.com/Redis-Insight/Redis-Insight/wiki/Plugin-Documentation) for more information.
+
+## Telemetry
+
+Redis Insight includes an opt-in telemetry system. This help us improve the developer experience of the app. We value your privacy; all collected data is anonymized.
+
+## Log files
+
+You can review the Redis Insight log files (files with a `.log` extension) to get detailed information about system issues.
+These are the locations on supported platforms:
+
+- **Docker**: In the `/data/logs` directory *inside the container*.
+- **Mac**: In the `/Users/<your-username>/.redis-insight` directory.
+- **Windows**: In the `C:\Users\<your-username>\.redis-insight` directory.
+- **Linux**: In the `/home/<your-username>/.redis-insight` directory.
+
+{{< note >}}
+You can install Redis Insight on operating systems that are not officially supported, but it may not behave as expected.
+{{< /note >}}
+
+## Redis Insight API (only for Docker)
+
+If you are running Redis Insight from [Docker]({{< relref "/operate/redisinsight/install/install-on-docker" >}}),
+you can access the API from `http://localhost:5540/api/docs`.
+
+## Feedback
+
+To provide your feedback, [open a ticket in our Redis Insight repository](https://github.com/Redis-Insight/Redis-Insight/issues/new).
+
+## License 
+
+Redis Insight is licensed under [SSPL](https://github.com/Redis-Insight/Redis-Insight/blob/main/LICENSE) license.
+---
+Title: Redis for VS Code v1.2.0, December 2024
+linkTitle: v1.2.0 (December 2024)
+date: 2024-12-19 00:00:00 +0000
+description: Redis for VS Code v1.2
+weight: 99
+---
+
+## 1.2.0 (December 2024)
+
+This is the General Availability (GA) release of Redis for VS Code 1.2.
+
+### Headlines
+* Work with keys across multiple database indexes, which are automatically discovered and displayed in the database list.
+* Support for adding multiple elements to the head or tail of Redis lists, for both new and existing keys.
+* Auto-refresh the list of keys and key values with a customizable timer.
+* Delete and update previously added CA and client certificates to keep them updated.
+
+### Details
+
+- [#223](https://github.com/RedisInsight/Redis-for-VS-Code/pull/223) Work with keys across multiple database indexes. Database indexes with keys are automatically discovered and displayed in the database list. 
+- [#207](https://github.com/RedisInsight/Redis-for-VS-Code/pull/207) Support for adding multiple elements to the head or tail of Redis lists for new and existing key.
+- [#226](https://github.com/RedisInsight/Redis-for-VS-Code/pull/226) Auto-refresh the list of keys and key values with a customizable timer. To do so, enable the Auto-refresh mode by clicking the control next to the Refresh button and setting the refresh rate.
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Ability to delete previously added CA and Client certificates to keep them up-to-date.
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Enhanced both the Java and PHP serialized formatters: the Java formatter now supports date and time data, while the PHP formatter includes UTF-8 encoding for better handling of special characters and multi-language data.
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Keep databases and the list of keys [expanded](https://github.com/RedisInsight/Redis-for-VS-Code/issues/217) after navigating away.
+- [#226](https://github.com/RedisInsight/Redis-for-VS-Code/pull/226) New users can optionally encrypt sensitive data, such as connection certificates and passwords. Existing users can enable encryption by deleting the ~/.redis-for-vscode/redisinsight.db file and re-adding their database connections.
+
+**Bugs**
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Resolved an issue where large integers in JSON keys were being rounded, ensuring data integrity.
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Saved SNI and SSH connection information for newly added database connections.
+- [#224](https://github.com/RedisInsight/Redis-for-VS-Code/pull/224) Fixed an issue to display multiple hash fields when expanding a hash value.
+
+### Get started with Redis for VS Code
+Install the extension from the [Visual Studio Code Marketplace](https://marketplace.visualstudio.com/items?itemName=redis.redis-for-vscode) to use it.
+---
+Title: Redis for VS Code v1.0.0, September 2024
+linkTitle: v1.0.0 (September 2024)
+date: 2024-09-06 00:00:00 +0000
+description: Redis for VS Code v1.0
+weight: 99
+---
+
+## 1.0.0 (September 2024)
+
+This is the first release of Redis for VS Code.
+
+Redis for VS Code is the official Visual Studio Code extension that provides an intuitive and efficient GUI for Redis databases, developed by Redis.
+
+### Headlines
+
+* Universal Redis Support: Connect to any Redis instance, including Redis Open Source, Redis Cloud, Redis Software, and Redis on Azure Cache.
+
+* Advanced Connectivity: Supports TLS certificates and SSH tunnels, with an option for automatic data decompression for GZIP, SNAPPY, Brotli, and more.
+
+* Data types: Supports strings, hashes, lists, sets, sorted sets, and JSON.
+
+* Human-readable data representation: Offers formatters like ASCII, JSON, Binary, Hex, 32-bit, and 64-bit vectors, and others.
+
+* Integrated Redis CLI: Leverage Redis CLI with syntax preview as you type commands.
+
+### Details
+
+- Database connections:
+
+  - Connect to any Redis instance, including Redis Open Source, Redis Cloud, Redis Software, and Redis on Azure Cache.
+
+  - View, edit, and manage your Redis database connections.
+
+  - Supports TLS connections and SSH tunnels for secure access.
+
+  - Automatically handle data compressed with GZIP, LZ4, SNAPPY, ZSTD, Brotli, or PHP GZCompress.
+
+  - Choose and work with a specific logical database within your Redis instance.
+
+- Redis data structures:
+
+  - Use an intuitive tree view interface to browse, filter, and visualize Redis key-value data structures.
+
+  -  Perform create, read, update, and delete operations on the following Redis data types:
+
+    - Strings
+
+    - Hashes
+
+    - Lists
+
+    - Sets
+
+    - Sorted sets
+
+    - JSON
+
+- View your data in multiple human-readable formats, including Unicode, ASCII, Binary, HEX, JSON, Msgpack, Pickle, Protobuf, PHP serialized, Java serialized, and Vector (32 and 64-bit).
+
+ - Sort by key names and apply filters by pattern or data type for quick and precise data access.
+
+ - Conduct detailed searches within fields in hashes, indexes in lists, and members in sets and sorted sets.
+
+- Redis CLI:
+
+  - Access a built-in Redis CLI with improved type-ahead command suggestions, helping you execute commands accurately and efficiently.
+
+### Get started with Redis for VS Code
+
+This repository contains the source code for the Redis for VS Code extension.
+
+Install the extension from the [Visual Studio Code Marketplace](https://marketplace.visualstudio.com/items?itemName=redis.redis-for-vscode) to use it.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description:
+linkTitle: Release notes
+title: Redis for VS Code release notes
+weight: 7
+hideListLinks: true
+---
+
+Here are the most recent changes for Redis for VS Code:
+
+{{< table-children columnNames="Version (Date),Release notes" columnSources="LinkTitle,Title" enableLinks="Title" >}}---
+aliases: /develop/connect/redis-for-vscode
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Connect to Redis from Visual Studio Code.
+hideListLinks: true
+linkTitle: Redis for VS Code
+stack: true
+title: Redis for VS Code
+weight: 5
+---
+
+Redis for VS Code is an extension that allows you to connect to your Redis databases from within Microsoft Visual Studio Code.
+After connecting to a database, you can view, add, modify, and delete keys, and interact with your Redis databases using a Redis Insight like UI and also a built-in CLI interface.
+The following data types are supported:
+
+- [Hash]({{< relref "/develop/data-types/hashes" >}})
+- [List]({{< relref "/develop/data-types/lists" >}})
+- [Set]({{< relref "/develop/data-types/sets" >}})
+- [Sorted Set]({{< relref "/develop/data-types/sorted-sets" >}})
+- [String]({{< relref "/develop/data-types/strings" >}})
+- [JSON]({{< relref "/develop/data-types/json" >}})
+
+## Install the Redis for VS Code extension
+
+Open VS Code and click on the **Extensions** menu button. In the **Search Extensions in Marketplace** field, type "Redis for VS Code" and press the `enter` or `return` key. There may be more than one option shown, so be sure to click on the extension published by Redis. The correct extension is shown below. Click on the **Install** to install the extension.
+
+{{< image filename="images/dev/connect/vscode/vscode-install1.png" >}}
+
+Once installed, check the **Auto Update** button to allow VS Code to install future revisions of the extension automatically.
+
+{{< image filename="images/dev/connect/vscode/vscode-install2.png" >}}
+
+After installing the extension, your VS Code menu will look similar to the following.
+
+{{< image filename="images/dev/connect/vscode/vscode-menu.png" >}}
+
+## Connect to Redis databases {#connect-db}
+
+Click on the Redis mark (the cursive **R**) in the VS Code menu to begin connecting a Redis database to VS Code. If you do not currently have access to a Redis database, consider giving Redis Cloud a try. [It's free](https://redis.io/try-free/).
+
+{{< image filename="images/dev/connect/vscode/vscode-initial.png" >}}
+
+Click on the **+ Connect database** button. A dialog will display in the main pane. In the image shown below, all the options have been checked to show the available details for each connection. These connection details are similar to those accessible from [`redis-cli`]({{< relref "/develop/tools/cli" >}}).
+
+{{< note >}}
+In the first release of Redis for VS Code, there is no way to change the logical database after you have selected it. If you need to connect to a different logical database, you need to add a separate database connection.
+{{< /note >}}
+
+{{< image filename="images/dev/connect/vscode/vscode-add-menu.png" >}}
+
+After filling out the necessary fields, click on the **Add Redis database** button. The pane on the left side, where you would normally see the Explorer view, shows your database connections.
+
+{{< image filename="images/dev/connect/vscode/vscode-cnx-view.png" >}}
+
+{{< note >}}
+Local databases, excluding OSS cluster databases, with default usernames and no passwords will automatically be added to your list of database connections.
+{{< /note >}}
+
+### Connection tools
+
+Several tools are displayed for each open connection.
+
+{{< image filename="images/dev/connect/vscode/vscode-cnx-tools.png" >}}
+
+Left to right, they are:
+
+- Refresh connection, which retrieves fresh data from the connected Redis database.
+- Edit connection, which shows a dialog similar to the one described in [Connect to Redis Databases](#connect-db) above.
+- Delete connection.
+- Open CLI. See [CLI tool](#cli) below for more information.
+- Sort keys, either ascending or descending.
+- Filter keys by key name or pattern, and by key type.
+- Add a new key by type: Hash, List, Set, Sorted Set, String, or JSON.
+
+## Key view
+
+Here's what you'll see when there are no keys in your database (the image on the left) and when keys are present (the image on the right).
+
+{{< image filename="images/dev/connect/vscode/vscode-key-view-w-wo-keys.png" >}}
+
+Redis for VS Code will automatically group the keys based on the one available setting, **Delimiter to separate namespaces**, which you can view by clicking on the gear icon in the top-right of the left side pane. Click on the current value to change it. The default setting is the colon (`:`) character.
+
+{{< image filename="images/dev/connect/vscode/vscode-settings.png" >}}
+
+Click on a key to display its contents.
+
+{{< image filename="images/dev/connect/vscode/vscode-key-view.png" >}}
+
+### Key editing tools
+
+There are several editing tools that you can use to edit key data. Each data type has its own editing capabilities. The following examples show edits to JSON data. Note that changes to keys are immediately written to the server.
+
+- **Rename**. Click on the key name field to change the name.
+
+{{< image filename="images/dev/connect/vscode/vscode-edit-name.png" >}}
+
+- **Set time-to-live (TTL)**. Click on the **TTL** field to set the duration in seconds.
+
+{{< image filename="images/dev/connect/vscode/vscode-edit-ttl.png" >}}
+
+- **Delete**. Click on the trash can icons to delete the entire key (highlighted in red) or portions of a key (highlighted in yellow).
+
+{{< image filename="images/dev/connect/vscode/vscode-edit-del.png" >}}
+
+- **Add to key**. Click on the `+` button next to the closing bracket (shown highlighted in green above) to add a new component to a key. 
+
+{{< image filename="images/dev/connect/vscode/vscode-edit-add.png" >}}
+
+- **Refresh**. Click on the refresh icon (the circular arrow) to retrieve fresh data from the server. In the examples below, refresh was clicked (the image on the left) and the key now has a new field called "test" that was added by another Redis client (the image on the right).
+
+{{< image filename="images/dev/connect/vscode/vscode-recycle-before-after.png" >}}
+
+For strings, hashes, lists, sets, and sorted sets, the extension supports numerous value formatters (highlighted in red in the image below). They are:
+
+- Unicode
+- ASCII
+- Binary (blob)
+- HEX
+- JSON
+- Msgpack
+- Pickle
+- Protobuf
+- PHP serialized
+- Java serialized
+- 32-bit vector
+- 64-bit vector
+
+{{< image filename="images/dev/connect/vscode/vscode-edit-value-formatters.png" >}}
+
+Also for Hash keys, you can set per-field TTLs (highlighted in yellow in the image above), a new feature added to Redis Open Source 7.4.
+
+## CLI tool {#cli}
+
+The connection tool with the boxed `>_` icon opens a Redis CLI window in the **REDIS CLI** tab at the bottom of the primary pane.
+
+{{< image filename="images/dev/connect/vscode/vscode-cli.png" >}}
+
+The CLI interface works just like the [`redis-cli`]({{< relref "/develop/tools/cli" >}}) command.
+---
+categories:
+aliases: 
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Tools to interact with a Redis server
+linkTitle: Client tools
+hideListLinks: true
+title: Client tools
+weight: 25
+---
+
+You can use several tools to connect to a Redis server, to
+manage it and interact with the data:
+
+* The [`redis-cli`](#redis-command-line-interface-cli) command line tool
+* [Redis Insight](#redis-insight) (a graphical user interface tool)
+* The Redis [VSCode extension](#redis-vscode-extension)
+
+## Redis command line interface (CLI)
+
+The [Redis command line interface]({{< relref "/develop/tools/cli" >}}) (also known as `redis-cli`) is a terminal program that sends commands to and reads replies from the Redis server. It has the following two main modes: 
+
+1. An interactive Read Eval Print Loop (REPL) mode where the user types Redis commands and receives replies.
+2. A command mode where `redis-cli` is executed with additional arguments, and the reply is printed to the standard output.
+
+## Redis Insight
+
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) combines a graphical user interface with Redis CLI to let you work with any Redis deployment. You can visually browse and interact with data, take advantage of diagnostic tools, learn by example, and much more. Best of all, Redis Insight is free.
+
+## Redis VSCode extension
+
+[Redis for VS Code]({{< relref "/develop/tools/redis-for-vscode" >}})
+is an extension that allows you to connect to your Redis databases from within Microsoft Visual Studio Code. After connecting to a database, you can view, add, modify, and delete keys, and interact with your Redis databases using a Redis Insight like UI and also a built-in CLI interface.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to the Redis Geospatial data type
+
+  '
+linkTitle: Geospatial
+title: Redis geospatial
+weight: 80
+---
+
+Redis geospatial indexes let you store coordinates and search for them.
+This data structure is useful for finding nearby points within a given radius or bounding box.
+
+{{< note >}}Take care not to confuse the Geospatial data type with the
+[Geospatial]({{< relref "/develop/interact/search-and-query/advanced-concepts/geo" >}})
+features in [Redis Query Engine]({{< relref "/develop/interact/search-and-query" >}}).
+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.
+{{< /note >}}
+
+## Basic commands
+
+* [`GEOADD`]({{< relref "/commands/geoadd" >}}) adds a location to a given geospatial index (note that longitude comes before latitude with this command).
+* [`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) returns locations with a given radius or a bounding box.
+
+See the [complete list of geospatial index commands]({{< relref "/commands/" >}}?group=geo).
+
+
+## Examples
+
+Suppose you're building a mobile app that lets you find all of the bike rental stations closest to your current location.
+
+Add several locations to a geospatial index:
+{{< clients-example geo_tutorial geoadd >}}
+> GEOADD bikes:rentable -122.27652 37.805186 station:1
+(integer) 1
+> GEOADD bikes:rentable -122.2674626 37.8062344 station:2
+(integer) 1
+> GEOADD bikes:rentable -122.2469854 37.8104049 station:3
+(integer) 1
+{{< /clients-example >}}
+
+Find all locations within a 5 kilometer radius of a given location, and return the distance to each location:
+{{< clients-example geo_tutorial geosearch >}}
+> GEOSEARCH bikes:rentable FROMLONLAT -122.2612767 37.7936847 BYRADIUS 5 km WITHDIST
+1) 1) "station:1"
+   2) "1.8523"
+2) 1) "station:2"
+   2) "1.4979"
+3) 1) "station:3"
+   2) "2.2441"
+{{< /clients-example >}}
+
+## Learn more
+
+* [Redis Geospatial Explained](https://www.youtube.com/watch?v=qftiVQraxmI) introduces geospatial indexes by showing you how to build a map of local park attractions.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) covers Redis geospatial indexes in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis sorted sets
+
+  '
+linkTitle: Sorted sets
+title: Redis sorted sets
+weight: 50
+---
+
+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.
+
+However while elements inside sets are not ordered, every element in
+a sorted set is associated with a floating point value, called *the score*
+(this is why the type is also similar to a hash, since every element
+is mapped to a value).
+
+Moreover, elements in a sorted set are *taken in order* (so they are not
+ordered on request, order is a peculiarity of the data structure used to
+represent sorted sets). They are ordered according to the following rule:
+
+* If B and A are two elements with a different score, then A > B if A.score is > B.score.
+* If B and A have exactly the same score, then A > B if the A string is lexicographically greater than the B string. B and A strings can't be equal since sorted sets only have unique elements.
+
+Let's start with a simple example, we'll add all our racers and the score they got in the first race:
+
+{{< clients-example ss_tutorial zadd >}}
+> ZADD racer_scores 10 "Norem"
+(integer) 1
+> ZADD racer_scores 12 "Castilla"
+(integer) 1
+> ZADD racer_scores 8 "Sam-Bodden" 10 "Royce" 6 "Ford" 14 "Prickett"
+(integer) 4
+{{< /clients-example >}}
+
+
+As you can see [`ZADD`]({{< relref "/commands/zadd" >}}) is similar to [`SADD`]({{< relref "/commands/sadd" >}}), but takes one additional argument
+(placed before the element to be added) which is the score.
+[`ZADD`]({{< relref "/commands/zadd" >}}) is also variadic, so you are free to specify multiple score-value
+pairs, as shown in the example above.
+
+With sorted sets it is trivial to return a list of racers sorted by their
+score because actually *they are already sorted*.
+
+Implementation note: Sorted sets are implemented via a
+dual-ported data structure containing both a skip list and a hash table, so
+every time we add an element Redis performs an O(log(N)) operation. That's
+good, so when we ask for sorted elements, Redis does not have to do any work at
+all, it's already sorted. Note that the [`ZRANGE`]({{< relref "/commands/zrange" >}}) order is low to high, while the [`ZREVRANGE`]({{< relref "/commands/zrevrange" >}}) order is high to low:
+
+{{< clients-example ss_tutorial zrange >}}
+> ZRANGE racer_scores 0 -1
+1) "Ford"
+2) "Sam-Bodden"
+3) "Norem"
+4) "Royce"
+5) "Castilla"
+6) "Prickett"
+> ZREVRANGE racer_scores 0 -1
+1) "Prickett"
+2) "Castilla"
+3) "Royce"
+4) "Norem"
+5) "Sam-Bodden"
+6) "Ford"
+{{< /clients-example >}}
+
+Note: 0 and -1 means from element index 0 to the last element (-1 works
+here just as it does in the case of the [`LRANGE`]({{< relref "/commands/lrange" >}}) command).
+
+It is possible to return scores as well, using the `WITHSCORES` argument:
+
+{{< clients-example ss_tutorial zrange_withscores >}}
+> ZRANGE racer_scores 0 -1 withscores
+ 1) "Ford"
+ 2) "6"
+ 3) "Sam-Bodden"
+ 4) "8"
+ 5) "Norem"
+ 6) "10"
+ 7) "Royce"
+ 8) "10"
+ 9) "Castilla"
+10) "12"
+11) "Prickett"
+12) "14"
+{{< /clients-example >}}
+
+### Operating on ranges
+
+Sorted sets are more powerful than this. They can operate on ranges.
+Let's get all the racers with 10 or fewer points. We
+use the [`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}}) command to do it:
+
+{{< clients-example ss_tutorial zrangebyscore >}}
+> ZRANGEBYSCORE racer_scores -inf 10
+1) "Ford"
+2) "Sam-Bodden"
+3) "Norem"
+4) "Royce"
+{{< /clients-example >}}
+
+We asked Redis to return all the elements with a score between negative
+infinity and 10 (both extremes are included).
+
+To remove an element we'd simply call [`ZREM`]({{< relref "/commands/zrem" >}}) with the racer's name. 
+It's also possible to remove ranges of elements. Let's remove racer Castilla along with all
+the racers with strictly fewer than 10 points:
+
+{{< clients-example ss_tutorial zremrangebyscore >}}
+> ZREM racer_scores "Castilla"
+(integer) 1
+> ZREMRANGEBYSCORE racer_scores -inf 9
+(integer) 2
+> ZRANGE racer_scores 0 -1
+1) "Norem"
+2) "Royce"
+3) "Prickett"
+{{< /clients-example >}}
+
+[`ZREMRANGEBYSCORE`]({{< relref "/commands/zremrangebyscore" >}}) is perhaps not the best command name,
+but it can be very useful, and returns the number of removed elements.
+
+Another extremely useful operation defined for sorted set elements
+is the get-rank operation. It is possible to ask what is the
+position of an element in the set of ordered elements. 
+The [`ZREVRANK`]({{< relref "/commands/zrevrank" >}}) command is also available in order to get the rank, considering
+the elements sorted in a descending way.
+
+{{< clients-example ss_tutorial zrank >}}
+> ZRANK racer_scores "Norem"
+(integer) 0
+> ZREVRANK racer_scores "Norem"
+(integer) 3
+{{< /clients-example >}}
+
+### Lexicographical scores
+
+In version Redis 2.8, a new feature was introduced that allows
+getting ranges lexicographically, assuming elements in a sorted set are all
+inserted with the same identical score (elements are compared with the C
+`memcmp` function, so it is guaranteed that there is no collation, and every
+Redis instance will reply with the same output).
+
+The main commands to operate with lexicographical ranges are [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}),
+[`ZREVRANGEBYLEX`]({{< relref "/commands/zrevrangebylex" >}}), [`ZREMRANGEBYLEX`]({{< relref "/commands/zremrangebylex" >}}) and [`ZLEXCOUNT`]({{< relref "/commands/zlexcount" >}}).
+
+For example, let's add again our list of famous racers, but this time
+using a score of zero for all the elements. We'll see that because of the sorted sets ordering rules, they are already sorted lexicographically. Using [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) we can ask for lexicographical ranges:
+
+{{< clients-example ss_tutorial zadd_lex >}}
+> ZADD racer_scores 0 "Norem" 0 "Sam-Bodden" 0 "Royce" 0 "Castilla" 0 "Prickett" 0 "Ford"
+(integer) 3
+> ZRANGE racer_scores 0 -1
+1) "Castilla"
+2) "Ford"
+3) "Norem"
+4) "Prickett"
+5) "Royce"
+6) "Sam-Bodden"
+> ZRANGEBYLEX racer_scores [A [L
+1) "Castilla"
+2) "Ford"
+{{< /clients-example >}}
+
+Ranges can be inclusive or exclusive (depending on the first character),
+also string infinite and minus infinite are specified respectively with
+the `+` and `-` strings. See the documentation for more information.
+
+This feature is important because it allows us to use sorted sets as a generic
+index. For example, if you want to index elements by a 128-bit unsigned
+integer argument, all you need to do is to add elements into a sorted
+set with the same score (for example 0) but with a 16 byte prefix
+consisting of **the 128 bit number in big endian**. Since numbers in big
+endian, when ordered lexicographically (in raw bytes order) are actually
+ordered numerically as well, you can ask for ranges in the 128 bit space,
+and get the element's value discarding the prefix
+
+Updating the score: leaderboards
+---
+
+Just a final note about sorted sets before switching to the next topic.
+Sorted sets' scores can be updated at any time. Just calling [`ZADD`]({{< relref "/commands/zadd" >}}) against
+an element already included in the sorted set will update its score
+(and position) with O(log(N)) time complexity.  As such, sorted sets are suitable
+when there are tons of updates.
+
+Because of this characteristic a common use case is leaderboards.
+The typical application is a Facebook game where you combine the ability to
+take users sorted by their high score, plus the get-rank operation, in order
+to show the top-N users, and the user rank in the leader board (e.g., "you are
+the #4932 best score here").
+
+## Examples
+
+* There are two ways we can use a sorted set to represent a leaderboard. If we know a racer's new score, we can update it directly via the [`ZADD`]({{< relref "/commands/zadd" >}}) command. However, if we want to add points to an existing score, we can use the [`ZINCRBY`]({{< relref "/commands/zincrby" >}}) command.
+{{< clients-example ss_tutorial leaderboard >}}
+> ZADD racer_scores 100 "Wood"
+(integer) 1
+> ZADD racer_scores 100 "Henshaw"
+(integer) 1
+> ZADD racer_scores 150 "Henshaw"
+(integer) 0
+> ZINCRBY racer_scores 50 "Wood"
+"150"
+> ZINCRBY racer_scores 50 "Henshaw"
+"200"
+{{< /clients-example >}}
+
+You'll see that [`ZADD`]({{< relref "/commands/zadd" >}}) returns 0 when the member already exists (the score is updated), while [`ZINCRBY`]({{< relref "/commands/zincrby" >}}) returns the new score. The score for racer Henshaw went from 100, was changed to 150 with no regard for what score was there before, and then was incremented by 50 to 200.
+
+## Basic commands
+
+* [`ZADD`]({{< relref "/commands/zadd" >}}) adds a new member and associated score to a sorted set. If the member already exists, the score is updated.
+* [`ZRANGE`]({{< relref "/commands/zrange" >}}) returns members of a sorted set, sorted within a given range.
+* [`ZRANK`]({{< relref "/commands/zrank" >}}) returns the rank of the provided member, assuming the sorted is in ascending order.
+* [`ZREVRANK`]({{< relref "/commands/zrevrank" >}}) returns the rank of the provided member, assuming the sorted set is in descending order.
+ 
+See the [complete list of sorted set commands]({{< relref "/commands/" >}}?group=sorted-set).
+
+## Performance
+
+Most sorted set operations are O(log(n)), where _n_ is the number of members.
+
+Exercise some caution when running the [`ZRANGE`]({{< relref "/commands/zrange" >}}) command with large returns values (e.g., in the tens of thousands or more).
+This command's time complexity is O(log(n) + m), where _m_ is the number of results returned. 
+
+## Alternatives
+
+Redis sorted sets are sometimes used for indexing other Redis data structures.
+If you need to index and query your data, consider the [JSON]({{< relref "/develop/data-types/json/" >}}) data type and the [Redis Query Engine]({{< relref "/develop/interact/search-and-query/" >}}) features.
+
+## Learn more
+
+* [Redis Sorted Sets Explained](https://www.youtube.com/watch?v=MUKlxdBQZ7g) is an entertaining introduction to sorted sets in Redis.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) explores Redis sorted sets in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis bitmaps
+
+  '
+linkTitle: Bitmaps
+title: Redis bitmaps
+weight: 120
+---
+
+Bitmaps are not an actual data type, but a set of bit-oriented operations
+defined on the String type which is treated like a bit vector.
+Since strings are binary safe blobs and their maximum length is 512 MB,
+they are suitable to set up to 2^32 different bits.
+
+You can perform bitwise operations on one or more strings.
+Some examples of bitmap use cases include:
+
+* Efficient set representations for cases where the members of a set correspond to the integers 0-N.
+* Object permissions, where each bit represents a particular permission, similar to the way that file systems store permissions.
+
+## Basic commands
+
+* [`SETBIT`]({{< relref "/commands/setbit" >}}) sets a bit at the provided offset to 0 or 1.
+* [`GETBIT`]({{< relref "/commands/getbit" >}}) returns the value of a bit at a given offset.
+
+See the [complete list of bitmap commands]({{< relref "/commands/" >}}?group=bitmap).
+
+
+## Example
+
+Suppose you have 1000 cyclists racing through the country-side, with sensors on their bikes labeled 0-999.
+You want to quickly determine whether a given sensor has pinged a tracking server within the hour to check in on a rider. 
+
+You can represent this scenario using a bitmap whose key references the current hour.
+
+* Rider 123 pings the server on January 1, 2024 within the 00:00 hour. You can then confirm that rider 123 pinged the server. You can also check to see if rider 456 has pinged the server for that same hour.
+
+{{< clients-example bitmap_tutorial ping >}}
+> SETBIT pings:2024-01-01-00:00 123 1
+(integer) 0
+> GETBIT pings:2024-01-01-00:00 123
+1
+> GETBIT pings:2024-01-01-00:00 456
+0
+{{< /clients-example >}}
+
+
+## Bit Operations
+
+Bit operations are divided into two groups: constant-time single bit
+operations, like setting a bit to 1 or 0, or getting its value, and
+operations on groups of bits, for example counting the number of set
+bits in a given range of bits (e.g., population counting).
+
+One of the biggest advantages of bitmaps is that they often provide
+extreme space savings when storing information. For example in a system
+where different users are represented by incremental user IDs, it is possible
+to remember a single bit information (for example, knowing whether
+a user wants to receive a newsletter) of 4 billion users using just 512 MB of memory.
+
+The [`SETBIT`]({{< relref "/commands/setbit" >}}) command takes as its first argument the bit number, and as its second
+argument the value to set the bit to, which is 1 or 0. The command
+automatically enlarges the string if the addressed bit is outside the
+current string length.
+
+[`GETBIT`]({{< relref "/commands/getbit" >}}) just returns the value of the bit at the specified index.
+Out of range bits (addressing a bit that is outside the length of the string
+stored into the target key) are always considered to be zero.
+
+There are three commands operating on group of bits:
+
+1. [`BITOP`]({{< relref "/commands/bitop" >}}) performs bit-wise operations between different strings. The provided operations are AND, OR, XOR and NOT.
+2. [`BITCOUNT`]({{< relref "/commands/bitcount" >}}) performs population counting, reporting the number of bits set to 1.
+3. [`BITPOS`]({{< relref "/commands/bitpos" >}}) finds the first bit having the specified value of 0 or 1.
+
+Both [`BITPOS`]({{< relref "/commands/bitpos" >}}) and [`BITCOUNT`]({{< relref "/commands/bitcount" >}}) are able to operate with byte ranges of the
+string, instead of running for the whole length of the string. We can trivially see the number of bits that have been set in a bitmap.
+
+{{< clients-example bitmap_tutorial bitcount >}}
+> BITCOUNT pings:2024-01-01-00:00
+(integer) 1
+{{< /clients-example >}}
+
+For example imagine you want to know the longest streak of daily visits of
+your web site users. You start counting days starting from zero, that is the
+day you made your web site public, and set a bit with [`SETBIT`]({{< relref "/commands/setbit" >}}) every time
+the user visits the web site. As a bit index you simply take the current unix
+time, subtract the initial offset, and divide by the number of seconds in a day
+(normally, 3600\*24).
+
+This way for each user you have a small string containing the visit
+information for each day. With [`BITCOUNT`]({{< relref "/commands/bitcount" >}}) it is possible to easily get
+the number of days a given user visited the web site, while with
+a few [`BITPOS`]({{< relref "/commands/bitpos" >}}) calls, or simply fetching and analyzing the bitmap client-side,
+it is possible to easily compute the longest streak.
+
+Bitmaps are trivial to split into multiple keys, for example for
+the sake of sharding the data set and because in general it is better to
+avoid working with huge keys. To split a bitmap across different keys
+instead of setting all the bits into a key, a trivial strategy is just
+to store M bits per key and obtain the key name with `bit-number/M` and
+the Nth bit to address inside the key with `bit-number MOD M`.
+
+
+
+## Performance
+
+[`SETBIT`]({{< relref "/commands/setbit" >}}) and [`GETBIT`]({{< relref "/commands/getbit" >}}) are O(1).
+[`BITOP`]({{< relref "/commands/bitop" >}}) is O(n), where _n_ is the length of the longest string in the comparison.
+
+## Learn more
+
+* [Redis Bitmaps Explained](https://www.youtube.com/watch?v=oj8LdJQjhJo) teaches you how to use bitmaps for map exploration in an online game. 
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) covers Redis bitmaps in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Time Series Client Libraries
+
+  '
+linkTitle: Clients
+title: Clients
+weight: 5
+---
+
+The table below shows the client libraries that support Redis time series:
+
+| Language | Client |
+| :-- | :-- |
+| Python | [redis-py]({{< relref "/develop/clients/redis-py" >}}) |
+| JavaScript | [node-redis]({{< relref "/develop/clients/nodejs" >}}) |
+| Java | [Jedis]({{< relref "/develop/clients/jedis" >}}) |
+| C#/.NET | [NRedisStack]({{< relref "/develop/clients/dotnet" >}}) |
+| Go | [redistimeseries-go](https://github.com/RedisTimeSeries/redistimeseries-go/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Quick Start Guide to Time Series
+linkTitle: Quickstart
+title: Quickstart
+weight: 2
+---
+
+## Setup
+
+You can get Redis Time Series setup in the cloud, in a Docker container, or on your own machine.
+
+### Redis Cloud
+
+Redis Time Series are available on all Redis Cloud managed services, including a completely free managed database up to 30MB.
+
+[Get started here](https://redislabs.com/try-free/)
+
+
+### Docker
+To quickly try out Redis Time Series, launch an instance of Redis Open Source using docker:
+```sh
+docker run -p 6379:6379 -it --rm redis/redis:latest
+```
+
+### Download and running binaries
+
+First download the pre-compiled version from the [Redis download center](https://redis.io/downloads).
+
+Next, run Redis with RedisTimeSeries:
+
+```
+$ redis-server --loadmodule /path/to/module/redistimeseries.so
+```
+
+### Build and Run it yourself
+
+You can also build and run RedisTimeSeries on your own machine.
+
+Major Linux distributions as well as macOS are supported.
+
+#### Requirements
+
+First, clone the RedisTimeSeries repository from git:
+
+```
+git clone --recursive https://github.com/RedisTimeSeries/RedisTimeSeries.git
+```
+
+Then, to install required build artifacts, invoke the following:
+
+```
+cd RedisTimeSeries
+make setup
+```
+Or you can install required dependencies manually listed in [system-setup.py](https://github.com/RedisTimeSeries/RedisTimeSeries/blob/master/sbin/system-setup.py).
+
+If ```make``` is not yet available, the following commands are equivalent:
+
+```
+./deps/readies/bin/getpy3
+./system-setup.py
+```
+
+Note that ```system-setup.py``` **will install various packages on your system** using the native package manager and pip. This requires root permissions (i.e. sudo) on Linux.
+
+If you prefer to avoid that, you can:
+
+* Review system-setup.py and install packages manually,
+* Utilize a Python virtual environment,
+* Use Docker with the ```--volume``` option to create an isolated build environment.
+
+#### Build
+
+```bash
+make build
+```
+
+Binary artifacts are placed under the ```bin``` directory.
+
+#### Run
+
+In your redis-server run: `loadmodule bin/redistimeseries.so`
+
+For more information about modules, go to the [redis official documentation]({{< relref "/develop/reference/modules/" >}}).
+
+## Give it a try with `redis-cli`
+
+After you setup RedisTimeSeries, you can interact with it using redis-cli.
+
+```sh
+$ redis-cli
+127.0.0.1:6379> TS.CREATE sensor1
+OK
+```
+
+
+## Creating a timeseries
+A new timeseries can be created with the [`TS.CREATE`]({{< relref "commands/ts.create/" >}}) command; for example, to create a timeseries named `sensor1` run the following:
+
+```
+TS.CREATE sensor1
+```
+
+You can prevent your timeseries growing indefinitely by setting a maximum age for samples compared to the last event time (in milliseconds) with the `RETENTION` option. The default value for retention is `0`, which means the series will not be trimmed.
+
+```
+TS.CREATE sensor1 RETENTION 2678400000
+```
+This will create a timeseries called `sensor1` and trim it to values of up to one month.
+
+
+## Adding data points
+For adding new data points to a timeseries we use the [`TS.ADD`]({{< relref "commands/ts.add/" >}}) command:
+
+```
+TS.ADD key timestamp value
+```
+
+The `timestamp` argument is the UNIX timestamp of the sample in milliseconds and `value` is the numeric data value of the sample.
+
+Example:
+```
+TS.ADD sensor1 1626434637914 26
+```
+
+To **add a datapoint with the current timestamp** you can use a `*` instead of a specific timestamp:
+
+```
+TS.ADD sensor1 * 26
+```
+
+You can **append data points to multiple timeseries** at the same time with the [`TS.MADD`]({{< relref "commands/ts.madd/" >}}) command:
+```
+TS.MADD key timestamp value [key timestamp value ...]
+```
+
+
+## Deleting data points
+Data points between two timestamps (inclusive) can be deleted with the [`TS.DEL`]({{< relref "commands/ts.del/" >}}) command:
+```
+TS.DEL key fromTimestamp toTimestamp
+```
+Example:
+```
+TS.DEL sensor1 1000 2000
+```
+
+To delete a single timestamp, use it as both the "from" and "to" timestamp:
+```
+TS.DEL sensor1 1000 1000
+```
+
+**Note:** When a sample is deleted, the data in all downsampled timeseries will be recalculated for the specific bucket. If part of the bucket has already been removed though, because it's outside of the retention period, we won't be able to recalculate the full bucket, so in those cases we will refuse the delete operation.
+
+
+## Labels
+Labels are key-value metadata we attach to data points, allowing us to group and filter. They can be either string or numeric values and are added to a timeseries on creation:
+
+```
+TS.CREATE sensor1 LABELS region east
+```
+
+
+
+## Compaction
+Another useful feature of Redis Time Series is compacting data by creating a rule for compaction ([`TS.CREATERULE`]({{< relref "commands/ts.createrule/" >}})). For example, if you have collected more than one billion data points in a day, you could aggregate the data by every minute in order to downsample it, thereby reducing the dataset size to 24 * 60 = 1,440 data points. You can choose one of the many available aggregation types in order to aggregate multiple data points from a certain minute into a single one. The currently supported aggregation types are: `avg, sum, min, max, range, count, first, last, std.p, std.s, var.p, var.s and twa`.
+
+It's important to point out that there is no data rewriting on the original timeseries; the compaction happens in a new series, while the original one stays the same. In order to prevent the original timeseries from growing indefinitely, you can use the retention option, which will trim it down to a certain period of time.
+
+**NOTE:** You need to create the destination (the compacted) timeseries before creating the rule.
+
+```
+TS.CREATERULE sourceKey destKey AGGREGATION aggregationType bucketDuration
+```
+
+Example:
+
+```
+TS.CREATE sensor1_compacted  # Create the destination timeseries first
+TS.CREATERULE sensor1 sensor1_compacted AGGREGATION avg 60000   # Create the rule
+```
+
+With this creation rule, datapoints added to the `sensor1` timeseries will be grouped into buckets of 60 seconds (60000ms), averaged, and saved in the `sensor1_compacted` timeseries.
+
+
+## Filtering
+You can filter your time series by value, timestamp and labels:
+
+### Filtering by label
+You can retrieve datapoints from multiple timeseries in the same query, and the way to do this is by using label filters. For example:
+
+```
+TS.MRANGE - + FILTER area_id=32
+```
+
+This query will show data from all sensors (timeseries) that have a label of `area_id` with a value of `32`. The results will be grouped by timeseries.
+
+Or we can also use the [`TS.MGET`]({{< relref "commands/ts.mget/" >}}) command to get the last sample that matches the specific filter:
+
+```
+TS.MGET FILTER area_id=32
+```
+
+### Filtering by value
+We can filter by value across a single or multiple timeseries:
+
+```
+TS.RANGE sensor1 - + FILTER_BY_VALUE 25 30
+```
+This command will return all data points whose value sits between 25 and 30, inclusive.
+
+To achieve the same filtering on multiple series we have to combine the filtering by value with filtering by label:
+
+```
+TS.MRANGE - +  FILTER_BY_VALUE 20 30 FILTER region=east
+```
+
+### Filtering by timestamp
+To retrieve the datapoints for specific timestamps on one or multiple timeseries we can use the `FILTER_BY_TS` argument:
+
+Filter on one timeseries:
+```
+TS.RANGE sensor1 - + FILTER_BY_TS 1626435230501 1626443276598
+```
+
+Filter on multiple timeseries:
+```
+TS.MRANGE - +  FILTER_BY_TS 1626435230501 1626443276598 FILTER region=east
+```
+
+
+## Aggregation
+It's possible to combine values of one or more timeseries by leveraging aggregation functions:
+```
+TS.RANGE ... AGGREGATION aggType bucketDuration...
+```
+
+For example, to find the average temperature per hour in our `sensor1` series we could run:
+```
+TS.RANGE sensor1 - + + AGGREGATION avg 3600000
+```
+
+To achieve the same across multiple sensors from the area with id of 32 we would run:
+```
+TS.MRANGE - + AGGREGATION avg 3600000 FILTER area_id=32
+```
+
+### Aggregation bucket alignment
+When doing aggregations, the aggregation buckets will be aligned to 0 as so:
+```
+TS.RANGE sensor3 10 70 + AGGREGATION min 25
+```
+
+```
+Value:        |      (1000)     (2000)     (3000)     (4000)     (5000)     (6000)     (7000)
+Timestamp:    |-------|10|-------|20|-------|30|-------|40|-------|50|-------|60|-------|70|--->
+
+Bucket(25ms): |_________________________||_________________________||___________________________|
+                           V                          V                           V
+                  min(1000, 2000)=1000      min(3000, 4000)=3000     min(5000, 6000, 7000)=5000
+```
+
+And we will get the following datapoints: 1000, 3000, 5000.
+
+You can choose to align the buckets to the start or end of the queried interval as so:
+```
+TS.RANGE sensor3 10 70 + AGGREGATION min 25 ALIGN start
+```
+
+```
+Value:        |      (1000)     (2000)     (3000)     (4000)     (5000)     (6000)     (7000)
+Timestamp:    |-------|10|-------|20|-------|30|-------|40|-------|50|-------|60|-------|70|--->
+
+Bucket(25ms):          |__________________________||_________________________||___________________________|
+                                    V                          V                           V
+                        min(1000, 2000, 3000)=1000      min(4000, 5000)=4000     min(6000, 7000)=6000
+```
+The result array will contain the following datapoints: 1000, 4000 and 6000
+
+
+### Aggregation across timeseries
+
+By default, results of multiple timeseries will be grouped by timeseries, but (since v1.6) you can use the `GROUPBY` and `REDUCE` options to group them by label and apply an additional aggregation.
+
+To find minimum temperature per region, for example, we can run:
+
+```
+TS.MRANGE - + FILTER region=(east,west) GROUPBY region REDUCE min
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Time series use cases
+
+  '
+linkTitle: Use cases
+title: Use cases
+weight: 5
+---
+
+**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)**
+
+Redis Time Series can be used to track environmental measurements such as the number of daily sunshine hours and hourly rainfall depth, over a period of many years. Seasonally, you can measure average rainfall depth, average daily temperature, and the maximum number of sunny hours per day, for example. Watch the increase of the maximum daily temperature over the years. Predict the expected temperature and rainfall depth in a specific location for a particular week of the year.
+
+Multiple time series can be collected, each for a different location. By utilizing secondary indexes, measurements can be aggregated over given geographical regions (e.g., minimal and maximal daily temperature in Europe) or over locations with specific attributes (e.g., average rainfall depth in mountainous regions).
+
+Example metrics include: 
+
+- Rain (cm)
+- Temperature (C)
+- Sunny periods (h)
+
+**Analysis of the atmosphere (environment)**
+
+The atmospheric concentration of CO2 is more important than ever before. Use TimeSeries to track average, maximum and minimum CO2 level per season and average yearly CO2 over the last decades. Example metrics include:
+
+- Concentration of CO2 (ppm)
+- Location
+
+**Flight data recording (sensor data and IoT)**
+
+Planes have a multitude of sensors. This sensor data is stored in a black box and also shared with external systems. TimeSeries can help you reconstruct the sequence of events over time, optimize operations and maintenance intervals, improve safety, and provide feedback to the equipment manufacturers about the part quality. Example metrics include:
+
+- Altitude
+- Flight path
+- Engine temperature
+- Level of vibrations
+- Pressure
+
+**Ship logbooks (sensor data and IoT)**
+
+It's very common to keep track of ship voyages via (digital) logbooks. Use TimeSeries to calculate optimal routes using these metrics:
+
+- Wind (km/h)
+- Ocean conditions (classes)
+- Speed (knots)
+- Location (long, lat)
+
+**Connected car (sensor data and IoT)**
+
+Modern cars are exposing several metrics via a standard interface. Use TimeSeries to correlate average fuel consumption with the tire pressure, figure out how long to keep a car in the fleet, determine optimal maintenance intervals, and calculate tax savings by type of the road (taxable vs. nontaxable roads). Example metrics include:
+
+- Acceleration
+- Location (long, lat)
+- Fuel level (liter)
+- Distances (km)
+- Speed (km/h)
+- Tire pressure
+- Distance until next maintenance check
+
+**Smart metering (sensor data and IoT)**
+
+Modern houses and facilities gather details about energy consumption/production. Use Redis Time Series to aggregate billing based on monthly consumption. Optimize the network by redirecting the energy delivery relative to the fluctuations in need. Provide recommendations on how to improve the energy consumption behavior. Example metrics include:
+
+- Consumption per location
+- Produced amount of electrical energy per location
+
+**Quality of service (telecom)**
+
+Mobile phone usage is increasing, producing a natural growth that just correlates to the increasing number of cellphones. However, there might also be spikes that correlate with specific events (for example, more messages around world championships). 
+
+Telecom providers need to ensure that they are providing the necessary infrastructure to deliver the right quality of service. This includes using mini towers for short-term peaks. Use TimeSeries to correlate traffic peaks to specific events, load balance traffic over several towers or mini towers, and predictively plan the infrastructure. Metrics include the amount of traffic per tower.
+
+**Stock trading (finance)**
+
+Stock trading is highly automated today. Algorithms, and not just human beings, are trading, from the amount of bids and asks for the trading of a stock to the extreme volumes of trades per second (millions of ops per second). Computer-driven trading requires millisecond response times. It's necessary to keep a lot of data points within a very short period of time (for example, price fluctuations per second within a minute). In addition, the long-term history needs to be kept to make statements about trends or for regulatory purposes.  
+
+Use Redis Time Series to identify correlations between the trading behavior and other events (for example, social network posts). Discover a developing market. Detect anomalies to discover insider trades. Example metrics include:
+
+- Exact time and order of a trade by itself
+- Type of the event (trade/bid)
+- The stock price---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis time series support multiple configuration parameters.
+linkTitle: Configuration
+title: Configuration Parameters
+weight: 3
+---
+## 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:
+
+- Pass them as command-line arguments following the `loadmodule` argument when starting `redis-server`:
+
+  `redis-server --loadmodule ./{modulename}.so [OPT VAL]...`
+
+- Add them as arguments to the `loadmodule` directive in your configuration file (for example, `redis.conf`):
+
+  `loadmodule ./{modulename}.so [OPT VAL]...`
+
+- Use the `MODULE LOAD path [arg [arg ...]]` command.
+
+- Use the `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ....]]` command.
+
+Starting with Redis 8.0, most time series configuration parameters are runtime parameters.
+While you can set runtime parameters at load time, using the Redis `CONFIG` command is easier and works the same way as with Redis runtime configuration parameters.
+
+This means:
+
+- `CONFIG SET parameter value [parameter value ...] `
+
+  Set one or more configuration parameters.
+
+- `CONFIG GET parameter [parameter ...]`
+
+  Read the current value of one of more parameters.
+
+- `CONFIG REWRITE`
+
+  Rewrite your Redis configuration file (for example, the `redis.conf` file) to reflect the configuration changes.
+
+Starting with Redis 8.0, you can specify time series configuration parameters directly in your Redis configuration file the same way you would for Redis configuration parameters.
+
+Once a value is set with `CONFIG SET` or added manually to your configuration file, it will overwrite values set with `--loadmodule`, `loadmodule`, `MODULE LOAD`, or `MODULE LOADEX`.
+
+In a cluster, you must run `CONFIG SET` and `CONFIG REWRITE` on each node separately.
+
+In Redis 8.0, new names for the time series configuration parameters were introduced to align the naming with the Redis configuration parameters.
+You must use the new names when using the `CONFIG` command.
+
+## Time series configuration parameters
+
+| Parameter name<br />(version < 8.0) | Parameter name<br />(version &#8805; 8.0) | Run-time | Redis<br />Software | Redis<br />Cloud |
+| :------- | :------- | :------- | :------- | :------- |
+| CHUNK_SIZE_BYTES     | [ts-chunk-size-bytes](#chunk_size_bytes--ts-chunk-size-bytes)    | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| COMPACTION_POLICY    | [ts-compaction-policy](#compaction_policy--ts-compaction-policy) | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| DUPLICATE_POLICY     | [ts-duplicate-policy](#duplicate_policy--ts-duplicate-policy)    | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| RETENTION_POLICY     | [ts-retention-policy](#retention_policy--ts-retention-policy)    | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| ENCODING             | [ts-encoding](#encoding--ts-encoding)                            | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| IGNORE_MAX_TIME_DIFF | [ts-ignore-max-time-diff](#ignore_max_time_diff--ts-ignore-max-time-diff-and-ignore_max_val_diff--ts-ignore-max-val-diff) | :white_check_mark:   |||
+| IGNORE_MAX_VAL_DIFF  | [ts-ignore-max-val-diff](#ignore_max_time_diff--ts-ignore-max-time-diff-and-ignore_max_val_diff--ts-ignore-max-val-diff)  | :white_check_mark:   |||
+| NUM_THREADS          | [ts-num-threads](#num_threads--ts-num-threads)                   | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Not Supported">&#x274c; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| [OSS_GLOBAL_PASSWORD](#oss_global_password)  | Deprecated in v8.0                       | :white_check_mark:   |||
+
+---
+
+### CHUNK_SIZE_BYTES / ts-chunk-size-bytes
+
+The initial allocation size, in bytes, for the data part of each new chunk. Actual chunks may consume more memory.
+Changing this value does not affect existing chunks.
+
+Type: integer
+
+Valid range: `[48 .. 1048576]`; must be a multiple of 8
+
+#### Precedence order
+
+Because the chunk size can be provided at different levels, the actual precedence of the chunk size is:
+
+1. Key-level policy, as set with [`TS.CREATE`]({{< relref "/commands/ts.create/" >}})'s and [`TS.ALTER`]({{< relref "/commands/ts.alter/" >}})'s `CHUNK_SIZE` optional argument.
+1. The `ts-chunk-size-bytes` configuration parameter.
+1. The hard-coded default: `4096`
+
+#### Example
+
+Set the default chunk size to 1024 bytes:
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so CHUNK_SIZE_BYTES 1024
+```
+
+Version >= 8.0:
+
+```
+redis> CONFIG SET ts-chunk-size-bytes 1024
+```
+
+### COMPACTION_POLICY / ts-compaction-policy
+
+Default compaction rules for newly created keys with [`TS.ADD`]({{< relref "/commands/ts.add/" >}}), [`TS.INCRBY`]({{< relref "/commands/ts.incrby/" >}}), and  [`TS.DECRBY`]({{< relref "/commands/ts.decrby/" >}}).
+
+Type: string
+
+Note that this configuration parameter does not affect keys you create with [`TS.CREATE`]({{< relref "commands/ts.create/" >}}). To understand why, consider the following scenario: Suppose you define a default compaction policy but then want to manually create an additional compaction rule (using [`TS.CREATERULE`]({{< relref "commands/ts.createrule/" >}})), which requires you to first create an empty destination key (using `TS.CREATE`). This approach creates a problem: the default compaction policy would cause Redis to automatically create undesired compactions for the destination key.
+
+Each rule is separated by a semicolon (`;`), the rule consists of multiple fields that are separated by a colon (`:`):
+
+* Aggregation type: One of the following:
+
+  | Aggregator | Description                                                      |
+  | ---------- | ---------------------------------------------------------------- |
+  | `avg`      | Arithmetic mean of all values                                    |
+  | `sum`      | Sum of all values                                                |
+  | `min`      | Minimum value                                                    |
+  | `max`      | Maximum value                                                    |
+  | `range`    | Difference between the highest and the lowest value              |
+  | `count`    | Number of values                                                 |
+  | `first`    | The value with the lowest timestamp in the bucket                |
+  | `last`     | The value with the highest timestamp in the bucket               |
+  | `std.p`    | Population standard deviation of the values                      |
+  | `std.s`    | Sample standard deviation of the values                          |
+  | `var.p`    | Population variance of the values                                |
+  | `var.s`    | Sample variance of the values                                    |
+  | `twa`      | Time-weighted average of all values (since v1.8)                 |
+
+* Duration of each time bucket - number and the time representation (Example for one minute: `1M`, `60s`, or `60000m`)
+
+    * m - millisecond
+    * s - seconds
+    * M - minute
+    * h - hour
+    * d - day
+
+* Retention time - number and the time representation (Example for one minute: `1M`, `60s`, or `60000m`)
+
+    * m - millisecond
+    * s - seconds
+    * M - minute
+    * h - hour
+    * d - day
+    
+  `0m`, `0s`, `0M`, `0h`, or `0d` means no expiration.
+
+* (Since v1.8):
+
+  Optional: Time bucket alignment - number and the time representation (Example for one minute: `1M`, `60s`, or `60000m`)
+
+    * m - millisecond
+    * s - seconds
+    * M - minute
+    * h - hour
+    * d - day
+
+  Ensure that there is a bucket that starts at exactly _alignTimestamp_ after the Epoch and align all other buckets accordingly. Default value: 0 (aligned with the Epoch). Example: if _bucketDuration_ is 24 hours, setting _alignTimestamp_ to `6h` (6 hours after the Epoch) will ensure that each bucket’s timeframe is [06:00 .. 06:00).
+
+{{% warning %}}
+In a clustered environment, if you set this configuration parameter, you must use [hash tags]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}#hash-tags) for all time series key names. This ensures that Redis will create each compaction in the same hash slot as its source key. If you don't, the system may fail to compact the data without displaying any error messages.
+{{% /warning %}}
+
+When a compaction policy is defined, compaction rules are created automatically for newly created time series, and the compaction key name would be:
+  
+* If the time bucket alignment is 0:
+
+   _key_agg_dur_ where _key_ is the key of the source time series, _agg_ is the aggregator (in uppercase), and _dur_ is the bucket duration in milliseconds. Example: `key_SUM_60000`.
+     
+* If the time bucket alignment is not 0:
+
+   _key_agg_dur_aln_ where _key_ is the key of the source time series, _agg_ is the aggregator (in uppercase), _dur_ is the bucket duration in milliseconds, and _aln_ is the time bucket alignment in milliseconds. Example: `key_SUM_60000_1000`.
+
+#### Precedence order
+
+1. The `ts-compaction-policy` configuration parameter.
+1. No compaction rules.
+
+#### Example rules
+
+- `max:1M:1h` - Aggregate using `max` over one-minute windows and retain the last hour
+- `twa:1d:0m:360M` - Aggregate daily [06:00 .. 06:00) using `twa`; no expiration
+
+#### Example
+
+Set a compaction policy composed of 5 compaction rules:
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so COMPACTION_POLICY max:1m:1h;min:10s:5d:10d;last:5M:10m;avg:2h:10d;avg:3d:100d
+```
+
+Version >= 8.0:
+
+```
+redis> CONFIG SET ts-compaction-policy max:1m:1h;min:10s:5d:10d;last:5M:10m;avg:2h:10d;avg:3d:100d
+```
+
+### DUPLICATE_POLICY / ts-duplicate-policy
+
+The default policy for handling insertion ([`TS.ADD`]({{< relref "/commands/ts.add/" >}}) and [`TS.MADD`]({{< relref "/commands/ts.madd/" >}})) of multiple samples with identical timestamps, with one of the following values:
+
+  | policy     | description                                                      |
+  | ---------- | ---------------------------------------------------------------- |
+  | `BLOCK`    | Ignore any newly reported value and reply with an error          |
+  | `FIRST`    | Ignore any newly reported value                                  |
+  | `LAST`     | Override with the newly reported value                           |
+  | `MIN`      | Only override if the value is lower than the existing value      |
+  | `MAX`      | Only override if the value is higher than the existing value     |
+  | `SUM`      | If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. |
+
+The default value is applied to each new time series upon its creation.
+
+Type: string
+
+#### Precedence order
+
+Because the duplication policy can be provided at different levels, the actual precedence of the duplication policy is:
+
+1. [`TS.ADD`]({{< relref "/commands/ts.add/" >}})'s `ON_DUPLICATE_POLICY` optional argument.
+1. Key-level policy, as set with [`TS.CREATE`]({{< relref "/commands/ts.create/" >}})'s and [`TS.ALTER`]({{< relref "/commands/ts.alter/" >}})'s `DUPLICATE_POLICY` optional argument.
+1. The `ts-duplicate-policy` configuration parameter.
+1. The hard-coded default: `BLOCK`
+
+### RETENTION_POLICY / ts-retention-policy
+
+The default retention period, in milliseconds, for newly created keys.
+
+The retention period is the maximum age of samples compared to the highest reported timestamp, per key. Samples are expired based solely on the difference between their timestamps and the timestamps passed to subsequent [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), and [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}}) calls.
+
+Type: integer
+
+Valid range: `[0 .. 9,223,372,036,854,775,807]`
+
+The value `0` means no expiration.
+
+When both `COMPACTION_POLICY` / `ts-compaction-policy` and `RETENTION_POLICY` / `ts-retention-policy` are specified, the retention of newly created compactions is according to the retention time specified in `COMPACTION_POLICY` / `ts-compaction-policy`.
+
+#### Precedence order
+
+Because the retention can be provided at different levels, the actual precedence of the retention is:
+
+1. Key-level retention, as set with [`TS.CREATE`]({{< relref "/commands/ts.create/" >}})'s and [`TS.ALTER`]({{< relref "/commands/ts.alter/" >}})'s `RETENTION` optional argument.
+1. The `ts-retention-policy` configuration parameter.
+1. No retention.
+
+#### Example
+
+Set the default retention to 300 days:
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so RETENTION_POLICY 25920000000
+```
+
+Version >= 8.0:
+
+```
+redis> CONFIG SET ts-retention-policy 25920000000
+```
+
+### ENCODING / ts-encoding
+
+Note: Before v1.6 this configuration parameter was named `CHUNK_TYPE`.
+
+Default chunk encoding for automatically created compactions when [ts-compaction-policy](#ts-compaction-policy) is configured.
+
+Type: string
+
+Valid values: `COMPRESSED`, `UNCOMPRESSED`
+
+#### Precedence order
+
+1. The `ts-encoding` configuration parameter.
+1. The hard-coded default: `COMPRESSED`
+
+#### Example
+
+Set the default encoding to `UNCOMPRESSED`:
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so ENCODING UNCOMPRESSED
+```
+
+Version >= 8.0:
+
+```
+redis> CONFIG SET ts-encoding UNCOMPRESSED
+```
+
+### IGNORE_MAX_TIME_DIFF / ts-ignore-max-time-diff and IGNORE_MAX_VAL_DIFF / ts-ignore-max-val-diff
+
+Default values for newly created keys.
+
+Types:
+- `ts-ignore-max-time-diff`: integer
+- `ts-ignore-max-val-diff`: double
+
+Valid ranges:
+- `ts-ignore-max-time-diff`: `[0 .. 9,223,372,036,854,775,807]`
+- `ts-ignore-max-val-diff`: `[0 .. 1.7976931348623157e+308]`
+
+Many sensors report data periodically. Often, the difference between the measured value and the previous measured value is negligible and related to random noise or to measurement accuracy limitations. In such situations it may be preferable not to add the new measurement to the time series.
+
+A new sample is considered a duplicate and is ignored if the following conditions are met:
+
+1. The time series is not a compaction.
+1. The time series' `ts-duplicate-policy` is `LAST`.
+1. The sample is added in-order (`timestamp ≥ max_timestamp`).
+1. The difference of the current timestamp from the previous timestamp (`timestamp - max_timestamp`) is less than or equal to `ts-ignore-max-time-diff`.
+1. The absolute value difference of the current value from the value at the previous maximum timestamp (`abs(value - value_at_max_timestamp`) is less than or equal to `ts-ignore-max-val-diff`.
+
+where `max_timestamp` is the timestamp of the sample with the largest timestamp in the time series, and `value_at_max_timestamp` is the value at `max_timestamp`.
+
+#### Precedence order
+
+1. The `ts-ignore-max-time-diff` and `ts-ignore-max-val-diff` configuration parameters.
+1. The hard-coded defaults: `0` and `0.0`.
+
+#### Example
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so IGNORE_MAX_TIME_DIFF 10 IGNORE_MAX_VAL_DIFF 0.1
+```
+
+Version >= 8.0:
+
+```
+redis> CONFIG SET ts-ignore-max-time-diff 10 ts-ignore-max-val-diff 0.1
+```
+
+### NUM_THREADS / ts-num-threads
+
+The maximum number of per-shard threads for cross-key queries when using cluster mode ([`TS.MRANGE`]({{< relref "/commands/ts.mrange/" >}}), [`TS.MREVRANGE`]({{< relref "/commands/ts.mrevrange/" >}}), [`TS.MGET`]({{< relref "/commands/ts.mget/" >}}), and [`TS.QUERYINDEX`]({{< relref "/commands/ts.queryindex/" >}})). The value must be equal to or greater than `1`. Note that increasing this value may either increase or decrease the performance!
+
+Type: integer
+
+Valid range: `[1..16]`
+
+Redis Open Source default: `3`
+
+Redis Software default: Set by plan, and automatically updates when you change your plan.
+
+Redis Cloud defaults:
+- Flexible & Annual: Set by plan
+- Free & Fixed: `1`
+
+#### Example
+
+Version < 8.0:
+
+```
+$ redis-server --loadmodule ./redistimeseries.so NUM_THREADS 3
+```
+
+Version >= 8.0:
+
+```
+redis> redis-server --loadmodule ./redistimeseries.so ts-num-threads 3
+```
+
+### OSS_GLOBAL_PASSWORD
+
+Prior to version 8.0, when using time series in a cluster, you had to set the `OSS_GLOBAL_PASSWORD` configuration parameter on all cluster nodes. As of version 8.0, Redis no longer uses this parameter and ignores it if present. Redis now uses a new shared secret mechanism to send internal commands between cluster nodes.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Developing RedisTimeSeries
+
+  '
+linkTitle: Development
+title: Development
+weight: 4
+---
+
+Developing RedisTimeSeries involves setting up the development environment (which can be either Linux-based or macOS-based), building the RedisTimeSeries module, running tests and benchmarks, and debugging both the RedisTimeSeries module and its tests.
+
+## Cloning the git repository
+By invoking the following command, the RedisTimeSeries module and its submodules are cloned:
+```sh
+git clone --recursive https://github.com/RedisTimeSeries/RedisTimeSeries.git
+```
+## Working in an isolated environment
+There are several reasons to develop in an isolated environment, like keeping your workstation clean, and developing for a different Linux distribution.
+The most general option for an isolated environment is a virtual machine (it's very easy to set one up using [Vagrant](https://www.vagrantup.com)).
+Docker is even a more agile solution, as it offers an almost instant solution:
+```
+ts=$(docker run -d -it -v $PWD:/build debian:bullseye bash)
+docker exec -it $ts bash
+```
+Then, from within the container, `cd /build` and go on as usual.
+In this mode, all installations remain in the scope of the Docker container.
+Upon exiting the container, you can either re-invoke the container with the above `docker exec` or commit the state of the container to an image and re-invoke it on a later stage:
+
+```
+docker commit $ts ts1
+docker stop $ts
+ts=$(docker run -d -it -v $PWD:/build ts1 bash)
+docker exec -it $ts bash
+```
+
+## Installing prerequisites
+To build and test RedisTimeSeries you needs to install several packages, depending on the underlying OS. Currently, we support the Ubuntu/Debian, CentOS, Fedora, and macOS.
+
+If you have `gnu make` installed, you can execute
+```
+cd RedisTimeSeries
+make setup
+```
+Alternatively, just invoke the following:
+```
+cd RedisTimeSeries
+git submodule update --init --recursive    
+./deps/readies/bin/getpy3
+./system-setup.py
+```
+Note that `system-setup.py` **will install various packages on your system** using the native package manager and pip. This requires root permissions (i.e. `sudo`) on Linux.
+
+If you prefer to avoid that, you can:
+
+* Review `system-setup.py` and install packages manually,
+* Use an isolated environment like explained above,
+* Utilize a Python virtual environment, as Python installations known to be sensitive when not used in isolation.
+
+## Installing Redis
+As a rule of thumb, you're better off running the latest Redis version.
+
+If your OS has a Redis package, you can install it using the OS package manager.
+
+Otherwise, you can invoke `./deps/readies/bin/getredis`.
+
+## Getting help
+`make help` provides a quick summary of the development features.
+
+## Building from source
+`make` will build RedisTimeSeries.
+
+Build artifacts are placed into `bin/linux-x64-release` (or similar, according to your platform and build options).
+
+Use `make clean` to remove built artifacts. `make clean ALL=1` will remove the entire binary artifacts directory.
+
+## Running Redis with RedisTimeSeries
+The following will run `redis` and load the RedisTimeSeries module.
+```
+make run
+```
+You can open `redis-cli` in another terminal to interact with it.
+
+## Running tests
+The module includes a basic set of unit tests and integration tests:
+* C unit tests, located in `src/tests`, run by `make unit_tests`.
+* Python integration tests (enabled by RLTest), located in `tests/flow`, run by `make flow_tests`.
+
+One can run all tests by invoking `make test`.
+A single test can be run using the `TEST` parameter, e.g. `make flow_test TEST=file:name`.
+
+## Debugging
+To build for debugging (enabling symbolic information and disabling optimization), run `make DEBUG=1`.
+You can the use `make run DEBUG=1` to invoke `gdb`.
+In addition to the usual way to set breakpoints in `gdb`, it is possible to use the `BB` macro to set a breakpoint inside the RedisTimeSeries code. It will only have an effect when running under `gdb`.
+
+Similarly, Python tests in a single-test mode, one can set a breakpoint by using the `BB()` function inside a test. This will invoke `pudb`.
+
+The two methods can be combined: one can set a breakpoint within a flow test, and when reached, connect `gdb` to a `redis-server` process to debug the module. 
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Out-of-order / backfilled ingestion performance considerations
+
+  '
+linkTitle: Out-of-order / backfilled ingestion performance considerations
+title: Out-of-order / backfilled ingestion performance considerations
+weight: 5
+---
+
+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](https://redislabs.com/blog/redistimeseries-ga-making-4th-dimension-truly-immersive/)). 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. 
+
+
+Ingest performance is critical for us, which pushed  us to assess and be transparent about the impact of the out-of-order backfilled ratio on our overall high-performance TSDB.
+
+
+To do so, we created a Go benchmark client that enabled us to control key factors that dictate overall system performance, like the out-of-order ratio, the compression of the series, the number of concurrent clients used, and command pipelining. For the full benchmark-driver configuration details and parameters, please refer to this [GitHub link](https://github.com/RedisTimeSeries/redistimeseries-ooo-benchmark).
+
+
+Furthermore, all benchmark variations were run on Amazon Web Services instances, provisioned through our benchmark-testing infrastructure. Both the benchmarking client and database servers were running on separate c5.9xlarge instances. The tests were executed on a single-shard setup, with RedisTimeSeries version 1.4.
+
+
+Below you can see the correlation between achievable ops/sec and out-of-order ratio for both compressed and uncompressed chunks.
+
+
+## Compressed chunks out-of-order/backfilled impact analysis
+
+With compressed chunks, given that a single out-of-order datapoint implies the full decompression from double delta of the entire chunk, you should expect higher overheads in out-of-order writes. 
+
+As a rule of thumb, to increase out-of-order compressed performance, reduce the chunk size as much as possible. Smaller chunks imply less computation on double-delta decompression and thus less overall impact, with the drawback of smaller compression ratio.
+
+The graphs and tables below make these key points:
+
+- If the database receives 1% of out-of-order samples with our current default chunk size in bytes (4096) the overall impact on the ingestion rate should be 10%.
+
+- At larger out-of-order percentages, like 5%, 10%, or even 25%, the overall impact should be between 35% to 75% fewer ops/sec. At this level of out-of-order percentages, you should really consider reducing the chunk size.
+
+- We've observed a maximum 95% drop in the achievable ops/sec even at 99% out-of-order ingestion. (Again, reducing the chunk size can cut the impact in half.)
+
+<img src="images/compressed-overall-ops-sec-vs-out-of-order-percentage.png" alt="compressed-overall-ops-sec-vs-out-of-order-percentage"/>
+
+<img src="images/compressed-overall-p50-lat-vs-out-of-order-percentage.png" alt="compressed-overall-p50-lat-vs-out-of-order-percentage"/>
+
+<img src="images/compressed-out-of-order-overhead-table.png" alt="compressed-out-of-order-overhead-table"/>
+
+## Uncompressed chunks out-of-order/backfilled impact analysis
+
+As visible on the charts and tables below, the chunk size does not affect the overall out-of-order impact on ingestion (meaning that if I have a chunk size of 256 bytes and a chunk size of 4096 bytes, the expected impact that out-of-order ingestion is the same—as it should be). 
+Apart from that, we can observe the following key take-aways:
+
+- If the database receives 1% of out-of-order samples, the overall impact in ingestion rate should be low or even unmeasurable.
+
+- At higher out-of-order percentages, like  5%, 10%, or even 25%, the overall impact should be 5% to 19% fewer ops/sec.
+
+- We've observed a maximum 45% drop in the achievable ops/sec, even at 99% out-of-order ingestion.
+
+<img src="images/uncompressed-overall-ops-sec-vs-out-of-order-percentage.png" alt="uncompressed-overall-ops-sec-vs-out-of-order-percentage"/>
+
+<img src="images/uncompressed-overall-p50-lat-vs-out-of-order-percentage.png" alt="uncompressed-overall-p50-lat-vs-out-of-order-percentage"/>
+
+<img src="images/uncompressed-out-of-order-overhead-table.png" alt="uncompressed-out-of-order-overhead-table"/>---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Reference
+
+  '
+linkTitle: Reference
+title: Reference
+weight: 5
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Ingest and query time series data with Redis
+linkTitle: Time series
+stack: true
+title: Time series
+weight: 150
+---
+
+[![Discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/KExRgMb)
+[![Github](https://img.shields.io/static/v1?label=&message=repository&color=5961FF&logo=github)](https://github.com/RedisTimeSeries/RedisTimeSeries/)
+
+The Redis time series structure lets you store and query timestamped data points.
+
+Redis time series is available in Redis Open Source, Redis Software, and Redis Cloud.
+See
+[Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) or
+[Install Redis Enterprise]({{< relref "/operate/rs/installing-upgrading/install" >}})
+for full installation instructions.
+
+## Features
+* High volume inserts, low latency reads
+* Query by start time and end-time
+* Aggregated queries (min, max, avg, sum, range, count, first, last, STD.P, STD.S, Var.P, Var.S, twa) for any time bucket
+* Configurable maximum retention period
+* Compaction for automatically updated aggregated timeseries
+* Secondary indexing for time series entries. Each time series has labels (field value pairs) which will allows to query by labels
+
+## Client libraries
+
+Official and community client libraries in Python, Java, JavaScript, Ruby, Go, C#, Rust, and PHP. 
+
+See the [clients page](clients) for the full list.
+
+## Using with other metrics tools
+
+In the [RedisTimeSeries](https://github.com/RedisTimeSeries) GitHub organization you can
+find projects that help you integrate RedisTimeSeries with other tools, including:
+
+1. [Prometheus](https://github.com/RedisTimeSeries/prometheus-redistimeseries-adapter), read/write adapter to use RedisTimeSeries as backend db.
+2. [Grafana 7.1+](https://github.com/RedisTimeSeries/grafana-redis-datasource), using the [Redis Data Source](https://redislabs.com/blog/introducing-the-redis-data-source-plug-in-for-grafana/).
+3. [Telegraf](https://github.com/influxdata/telegraf). Download the plugin from [InfluxData](https://portal.influxdata.com/downloads/). 
+4. StatsD, Graphite exports using graphite protocol.
+
+## Memory model
+
+A time series is a linked list of memory chunks. Each chunk has a predefined size of samples. Each sample is a 128-bit tuple: 64 bits for the timestamp and 64 bits for the value.
+
+## Forum
+
+Got questions? Feel free to ask at the [RedisTimeSeries mailing list](https://forum.redislabs.com/c/modules/redistimeseries).
+
+## License
+RedisTimeSeries is licensed under the [Redis Source Available License 2.0 (RSALv2)](https://redis.com/legal/rsalv2-agreement) or the [Server Side Public License v1 (SSPLv1)](https://www.mongodb.com/licensing/server-side-public-license).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis strings
+
+  '
+linkTitle: Strings
+title: Redis Strings
+weight: 10
+---
+
+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.
+
+{{< clients-example set_tutorial set_get >}}
+    > SET bike:1 Deimos
+    OK
+    > GET bike:1
+    "Deimos"
+{{< /clients-example >}}
+
+As you can see using the [`SET`]({{< relref "/commands/set" >}}) and the [`GET`]({{< relref "/commands/get" >}}) commands are the way we set
+and retrieve a string value. Note that [`SET`]({{< relref "/commands/set" >}}) will replace any existing value
+already stored into the key, in the case that the key already exists, even if
+the key is associated with a non-string value. So [`SET`]({{< relref "/commands/set" >}}) performs an assignment.
+
+Values can be strings (including binary data) of every kind, for instance you
+can store a jpeg image inside a value. A value can't be bigger than 512 MB.
+
+The [`SET`]({{< relref "/commands/set" >}}) command has interesting options, that are provided as additional
+arguments. For example, I may ask [`SET`]({{< relref "/commands/set" >}}) to fail if the key already exists,
+or the opposite, that it only succeed if the key already exists:
+
+{{< clients-example set_tutorial setnx_xx >}}
+    > set bike:1 bike nx
+    (nil)
+    > set bike:1 bike xx
+    OK
+{{< /clients-example >}}
+
+There are a number of other commands for operating on strings. For example
+the [`GETSET`]({{< relref "/commands/getset" >}}) command sets a key to a new value, returning the old value as the
+result. You can use this command, for example, if you have a
+system that increments a Redis key using [`INCR`]({{< relref "/commands/incr" >}})
+every time your web site receives a new visitor. You may want to collect this
+information once every hour, without losing a single increment.
+You can [`GETSET`]({{< relref "/commands/getset" >}}) the key, assigning it the new value of "0" and reading the
+old value back.
+
+The ability to set or retrieve the value of multiple keys in a single
+command is also useful for reduced latency. For this reason there are
+the [`MSET`]({{< relref "/commands/mset" >}}) and [`MGET`]({{< relref "/commands/mget" >}}) commands:
+
+{{< clients-example set_tutorial mset >}}
+    > mset bike:1 "Deimos" bike:2 "Ares" bike:3 "Vanth"
+    OK
+    > mget bike:1 bike:2 bike:3
+    1) "Deimos"
+    2) "Ares"
+    3) "Vanth"
+{{< /clients-example >}}
+
+When [`MGET`]({{< relref "/commands/mget" >}}) is used, Redis returns an array of values.
+
+### Strings as counters
+Even if strings are the basic values of Redis, there are interesting operations
+you can perform with them. For instance, one is atomic increment:
+
+{{< clients-example set_tutorial incr >}}
+    > set total_crashes 0
+    OK
+    > incr total_crashes
+    (integer) 1
+    > incrby total_crashes 10
+    (integer) 11
+{{< /clients-example >}}
+
+The [`INCR`]({{< relref "/commands/incr" >}}) command parses the string value as an integer,
+increments it by one, and finally sets the obtained value as the new value.
+There are other similar commands like [`INCRBY`]({{< relref "/commands/incrby" >}}),
+[`DECR`]({{< relref "/commands/decr" >}}) and [`DECRBY`]({{< relref "/commands/decrby" >}}). Internally it's
+always the same command, acting in a slightly different way.
+
+What does it mean that INCR is atomic?
+That even multiple clients issuing INCR against
+the same key will never enter into a race condition. For instance, it will never
+happen that client 1 reads "10", client 2 reads "10" at the same time, both
+increment to 11, and set the new value to 11. The final value will always be
+12 and the read-increment-set operation is performed while all the other
+clients are not executing a command at the same time.
+
+
+## Limits
+
+By default, a single Redis string can be a maximum of 512 MB.
+
+## Basic commands
+
+### Getting and setting Strings
+
+* [`SET`]({{< relref "/commands/set" >}}) stores a string value.
+* [`SETNX`]({{< relref "/commands/setnx" >}}) stores a string value only if the key doesn't already exist. Useful for implementing locks.
+* [`GET`]({{< relref "/commands/get" >}}) retrieves a string value.
+* [`MGET`]({{< relref "/commands/mget" >}}) retrieves multiple string values in a single operation.
+
+### Managing counters
+
+* [`INCR`]({{< relref "/commands/incr" >}}) atomically increments counters stored at a given key by 1.
+* [`INCRBY`]({{< relref "/commands/incrby" >}}) atomically increments (and decrements when passing a negative number) counters stored at a given key.
+* Another command exists for floating point counters: [`INCRBYFLOAT`]({{< relref "/commands/incrbyfloat" >}}).
+
+### Bitwise operations
+
+To perform bitwise operations on a string, see the [bitmaps data type]({{< relref "/develop/data-types/bitmaps" >}}) docs.
+
+See the [complete list of string commands]({{< relref "/commands/" >}}?group=string).
+
+## Performance
+
+Most string operations are O(1), which means they're highly efficient.
+However, be careful with the [`SUBSTR`]({{< relref "/commands/substr" >}}), [`GETRANGE`]({{< relref "/commands/getrange" >}}), and [`SETRANGE`]({{< relref "/commands/setrange" >}}) commands, which can be O(n).
+These random-access string commands may cause performance issues when dealing with large strings.
+
+## Alternatives
+
+If you're storing structured data as a serialized string, you may also want to consider Redis [hashes]({{< relref "/develop/data-types/hashes" >}}) or [JSON]({{< relref "/develop/data-types/json/" >}}).
+
+## Learn more
+
+* [Redis Strings Explained](https://www.youtube.com/watch?v=7CUt4yWeRQE) is a short, comprehensive video explainer on Redis strings.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) covers Redis strings in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis hashes
+
+  '
+linkTitle: Hashes
+title: Redis hashes
+weight: 40
+---
+
+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.
+
+{{< clients-example hash_tutorial set_get_all >}}
+> 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"
+
+{{< /clients-example >}}
+
+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.
+
+The command [`HSET`]({{< relref "/commands/hset" >}}) sets multiple fields of the hash, while [`HGET`]({{< relref "/commands/hget" >}}) retrieves
+a single field. [`HMGET`]({{< relref "/commands/hmget" >}}) is similar to [`HGET`]({{< relref "/commands/hget" >}}) but returns an array of values:
+
+{{< clients-example hash_tutorial hmget >}}
+> HMGET bike:1 model price no-such-field
+1) "Deimos"
+2) "4972"
+3) (nil)
+{{< /clients-example >}}
+
+There are commands that are able to perform operations on individual fields
+as well, like [`HINCRBY`]({{< relref "/commands/hincrby" >}}):
+
+{{< clients-example hash_tutorial hincrby >}}
+> HINCRBY bike:1 price 100
+(integer) 5072
+> HINCRBY bike:1 price -100
+(integer) 4972
+{{< /clients-example >}}
+
+You can find the [full list of hash commands in the documentation]({{< relref "/commands#hash" >}}).
+
+It is worth noting that small hashes (i.e., a few elements with small values) are
+encoded in special way in memory that make them very memory efficient.
+
+## Basic commands
+
+* [`HSET`]({{< relref "/commands/hset" >}}): sets the value of one or more fields on a hash.
+* [`HGET`]({{< relref "/commands/hget" >}}): returns the value at a given field.
+* [`HMGET`]({{< relref "/commands/hmget" >}}): returns the values at one or more given fields.
+* [`HINCRBY`]({{< relref "/commands/hincrby" >}}): increments the value at a given field by the integer provided.
+
+See the [complete list of hash commands]({{< relref "/commands/" >}}?group=hash).
+
+## Examples
+
+* Store counters for the number of times bike:1 has been ridden, has crashed, or has changed owners:
+{{< clients-example hash_tutorial incrby_get_mget >}}
+> HINCRBY bike:1:stats rides 1
+(integer) 1
+> HINCRBY bike:1:stats rides 1
+(integer) 2
+> HINCRBY bike:1:stats rides 1
+(integer) 3
+> HINCRBY bike:1:stats crashes 1
+(integer) 1
+> HINCRBY bike:1:stats owners 1
+(integer) 1
+> HGET bike:1:stats rides
+"3"
+> HMGET bike:1:stats owners crashes
+1) "1"
+2) "1"
+{{< /clients-example >}}
+
+## Field expiration
+
+New in Redis Open Source 7.4 is the ability to specify an expiration time or a time-to-live (TTL) value for individual hash fields.
+This capability is comparable to [key expiration]({{< relref "/develop/use/keyspace#key-expiration" >}}) and includes a number of similar commands.
+
+Use the following commands to set either an exact expiration time or a TTL value for specific fields:
+
+* [`HEXPIRE`]({{< relref "/commands/hexpire" >}}): set the remaining TTL in seconds.
+* [`HPEXPIRE`]({{< relref "/commands/hpexpire" >}}): set the remaining TTL in milliseconds.
+* [`HEXPIREAT`]({{< relref "/commands/hexpireat" >}}): set the expiration time to a timestamp[^1] specified in seconds.
+* [`HPEXPIREAT`]({{< relref "/commands/hpexpireat" >}}): set the expiration time to a timestamp specified in milliseconds.
+
+[^1]: all timestamps are specified in seconds or milliseconds since the [Unix epoch](https://en.wikipedia.org/wiki/Unix_time).
+
+Use the following commands to retrieve either the exact time when or the remaining TTL until specific fields will expire:
+
+* [`HEXPIRETIME`]({{< relref "/commands/hexpiretime" >}}): get the expiration time as a timestamp in seconds.
+* [`HPEXPIRETIME`]({{< relref "/commands/hpexpiretime" >}}): get the expiration time as a timestamp in milliseconds.
+* [`HTTL`]({{< relref "/commands/httl" >}}): get the remaining TTL in seconds.
+* [`HPTTL`]({{< relref "/commands/hpttl" >}}): get the remaining TTL in milliseconds.
+
+Use the following command to remove the expiration of specific fields:
+
+* [`HPERSIST`]({{< relref "/commands/hpersist" >}}): remove the expiration.
+
+### Common field expiration use cases
+
+1. **Event Tracking**: Use a hash key to store events from the last hour. Set each event's TTL to one hour. Use `HLEN` to count events from the past hour.
+
+1. **Fraud Detection**: Create a hash with hourly counters for events. Set each field's TTL to 48 hours. Query the hash to get the number of events per hour for the last 48 hours.
+
+1. **Customer Session Management**: Store customer data in hash keys. Create a new hash key for each session and add a session field to the customer’s hash key. Expire both the session key and the session field in the customer’s hash key automatically when the session expires.
+
+1. **Active Session Tracking**: Store all active sessions in a hash key. Set each session's TTL to expire automatically after inactivity. Use `HLEN` to count active sessions.
+
+### Field expiration examples
+
+Support for hash field expiration in the official client libraries is not yet available, but you can test hash field expiration now with beta versions of the [Python (redis-py)](https://github.com/redis/redis-py) and [Java (Jedis)](https://github.com/redis/jedis) client libraries.
+
+Following are some Python examples that demonstrate how to use field expiration.
+
+Consider a hash data set for storing sensor data that has the following structure:
+
+```python
+event = {
+    'air_quality': 256,
+    'battery_level':89
+}
+
+r.hset('sensor:sensor1', mapping=event)
+```
+
+In the examples below, you will likely need to refresh the `sensor:sensor1` key after its fields expire.
+
+Set and retrieve the TTL for multiple fields in a hash:
+
+```python
+# set the TTL for two hash fields to 60 seconds
+r.hexpire('sensor:sensor1', 60, 'air_quality', 'battery_level')
+ttl = r.httl('sensor:sensor1', 'air_quality', 'battery_level')
+print(ttl)
+# prints [60, 60]
+```
+
+Set and retrieve a hash field's TTL in milliseconds:
+
+```python
+# set the TTL of the 'air_quality' field in milliseconds
+r.hpexpire('sensor:sensor1', 60000, 'air_quality')
+# and retrieve it
+pttl = r.hpttl('sensor:sensor1', 'air_quality')
+print(pttl)
+# prints [59994] # your actual value may vary
+```
+
+Set and retrieve a hash field’s expiration timestamp:
+
+```python
+# set the expiration of 'air_quality' to now + 24 hours
+# (similar to setting the TTL to 24 hours)
+r.hexpireat('sensor:sensor1', 
+    datetime.now() + timedelta(hours=24), 
+    'air_quality')
+# and retrieve it
+expire_time = r.hexpiretime('sensor:sensor1', 'air_quality')
+print(expire_time)
+# prints [1717668041] # your actual value may vary
+```
+
+## Performance
+
+Most Redis hash commands are O(1).
+
+A few commands, such as [`HKEYS`]({{< relref "/commands/hkeys" >}}), [`HVALS`]({{< relref "/commands/hvals" >}}), [`HGETALL`]({{< relref "/commands/hgetall" >}}), and most of the expiration-related commands, are O(n), where _n_ is the number of field-value pairs.
+
+## Limits
+
+Every hash can store up to 4,294,967,295 (2^32 - 1) field-value pairs.
+In practice, your hashes are limited only by the overall memory on the VMs hosting your Redis deployment.
+
+## Learn more
+
+* [Redis Hashes Explained](https://www.youtube.com/watch?v=-KdITaRkQ-U) is a short, comprehensive video explainer covering Redis hashes.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) covers Redis hashes in detail.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'HyperLogLog is a probabilistic data structure that estimates the cardinality
+  of a set.
+
+  '
+linkTitle: HyperLogLog
+title: HyperLogLog
+weight: 1
+---
+
+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.
+
+HLLs in Redis, while technically a different data structure, are encoded
+as a Redis string, so you can call [`GET`]({{< relref "/commands/get" >}}) to serialize a HLL, and [`SET`]({{< relref "/commands/set" >}})
+to deserialize it back to the server.
+
+Conceptually the HLL API is like using Sets to do the same task. You would
+[`SADD`]({{< relref "/commands/sadd" >}}) every observed element into a set, and would use [`SCARD`]({{< relref "/commands/scard" >}}) to check the
+number of elements inside the set, which are unique since [`SADD`]({{< relref "/commands/sadd" >}}) will not
+re-add an existing element.
+
+While you don't really *add items* into an HLL, because the data structure
+only contains a state that does not include actual elements, the API is the
+same:
+
+* Every time you see a new element, you add it to the count with [`PFADD`]({{< relref "/commands/pfadd" >}}).
+* When you want to retrieve the current approximation of unique elements added using the [`PFADD`]({{< relref "/commands/pfadd" >}}) command, you can use the [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) command. If you need to merge two different HLLs, the [`PFMERGE`]({{< relref "/commands/pfmerge" >}}) command is available. Since HLLs provide approximate counts of unique elements, the result of the merge will give you an approximation of the number of unique elements across both source HLLs.
+
+{{< clients-example hll_tutorial pfadd >}}
+> PFADD bikes Hyperion Deimos Phoebe Quaoar
+(integer) 1
+> PFCOUNT bikes
+(integer) 4
+> PFADD commuter_bikes Salacia Mimas Quaoar
+(integer) 1
+> PFMERGE all_bikes bikes commuter_bikes
+OK
+> PFCOUNT all_bikes
+(integer) 6
+{{< /clients-example >}}
+
+Some examples of use cases for this data structure is counting unique queries
+performed by users in a search form every day, number of unique visitors to a web page and other similar cases.
+
+Redis is also able to perform the union of HLLs, please check the
+[full documentation]({{< relref "/commands#hyperloglog" >}}) for more information.
+
+## Use cases
+
+**Anonymous unique visits of a web page (SaaS, analytics tools)** 
+
+This application answers these questions: 
+
+- How many unique visits has this page had on this day? 
+- How many unique users have played this song? 
+- How many unique users have viewed this video? 
+
+{{% alert title="Note" color="warning" %}}
+ 
+Storing the IP address or any other kind of personal identifier is against the law in some countries, which makes it impossible to get unique visitor statistics on your website.
+
+{{% /alert %}}
+
+One HyperLogLog is created per page (video/song) per period, and every IP/identifier is added to it on every visit.
+
+## Basic commands
+
+* [`PFADD`]({{< relref "/commands/pfadd" >}}) adds an item to a HyperLogLog.
+* [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) returns an estimate of the number of items in the set.
+* [`PFMERGE`]({{< relref "/commands/pfmerge" >}}) combines two or more HyperLogLogs into one.
+
+See the [complete list of HyperLogLog commands]({{< relref "/commands/" >}}?group=hyperloglog).
+
+## Performance
+
+Writing ([`PFADD`]({{< relref "/commands/pfadd" >}})) to and reading from ([`PFCOUNT`]({{< relref "/commands/pfcount" >}})) the HyperLogLog is done in constant time and space.
+Merging HLLs is O(n), where _n_ is the number of sketches.
+
+## Limits
+
+The HyperLogLog can estimate the cardinality of sets with up to 18,446,744,073,709,551,616 (2^64) members.
+
+## Learn more
+
+* [Redis new data structure: the HyperLogLog](http://antirez.com/news/75) has a lot of details about the data structure and its implementation in Redis.
+* [Redis HyperLogLog Explained](https://www.youtube.com/watch?v=MunL8nnwscQ) shows you how to use Redis HyperLogLog data structures to build a traffic heat map.
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Bloom filters are a probabilistic data structure that checks for presence
+  of an item in a set
+linkTitle: Bloom filter
+stack: true
+title: Bloom filter
+weight: 10
+---
+
+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.
+
+## Use cases
+
+**Financial fraud detection (finance)**
+
+This application answers the question, "Has the user paid from this location before?", thus checking for suspicious activity in their users' shopping habits.
+ 
+Use one Bloom filter per user, checked for every transaction. Provide an extremely fast response (local latency). Replicate in different regions in case the user moves. Prevent decreasing performance with scale.  
+
+Using the Redis Bloom filter for this type of application provides these benefits: 
+
+- Fast transaction completion 
+- Decreased possibility for transaction to break in case of network partitions (connection needs to be kept open for a shorter time) 
+- Extra layer of security for both credit card owners and retailers
+
+Other questions a Bloom filter can help answer in the finance industry are: 
+
+- Has the user ever made purchases in this category of products/services? 
+- Do I need to skip some security steps when the user is buying with a vetted online shop (big retailers like Amazon, Apple app store...)? 
+- Has this credit card been reported as lost/stolen? An additional benefit of using a Bloom filter in the last case is that financial organizations can exchange their lists of stolen/blocked credit card numbers without revealing the numbers themselves. 
+
+**Ad placement (retail, advertising)**
+
+This application answers these questions: 
+
+- Has the user already seen this ad? 
+- Has the user already bought this product?
+
+Use a Bloom filter for every user, storing all bought products. The recommendation engine suggests a new product and checks if the product is in the user's Bloom filter. 
+
+- If no, the ad is shown to the user and is added to the Bloom filter. 
+- If yes, the process restarts and repeats until it finds a product that is not present in the filter. 
+
+Using the Redis Bloom filter for this type of application provides these benefits: 
+
+- Cost efficient way to a customized near real-time experience 
+- No need to invest in expensive infrastructure  
+
+**Check if a username is taken (SaaS, content publishing platforms)** 
+
+This application answers this question: Has this username/email/domain name/slug already been used?
+ 
+Use a Bloom filter for every username that has signed up. A new user types in the desired username. The app checks if the username exists in the Bloom filter. 
+
+- If no, the user is created and the username is added to the Bloom filter. 
+- If yes, the app can decide to either check the main database or reject the username. 
+
+The query time stays the same at scale. 
+
+Using the Redis Bloom filter for this type of application provides these benefits: 
+
+- Very fast and efficient way to do a common operation 
+- No need to invest in expensive infrastructure  
+
+## Example
+
+Consider a bike manufacturer that makes a million different kinds of bikes and you'd like to avoid using a duplicate model name in new models. A Bloom filter can be used to detect duplicates. In the example that follows,  you'll create a filter with space for a million entries and with a 0.1% error rate. Add one model name and check if it exists. Then add multiple model names and check if they exist.
+
+
+{{< clients-example bf_tutorial bloom >}}
+> BF.RESERVE bikes:models 0.001 1000000
+OK
+> BF.ADD bikes:models "Smoky Mountain Striker"
+(integer) 1
+> BF.EXISTS bikes:models "Smoky Mountain Striker"
+(integer) 1
+> BF.MADD bikes:models "Rocky Mountain Racer" "Cloudy City Cruiser" "Windy City Wippet"
+1) (integer) 1
+2) (integer) 1
+3) (integer) 1
+> BF.MEXISTS bikes:models "Rocky Mountain Racer" "Cloudy City Cruiser" "Windy City Wippet"
+1) (integer) 1
+2) (integer) 1
+3) (integer) 1
+{{< /clients-example >}}
+
+Note: there is always a chance that even with just a few items, there could be a false positive, meaning an item could "exist" even though it has not been explicitly added to the Bloom filter. For a more in depth understanding of the probabilistic nature of a Bloom filter, check out the blog posts linked at the bottom of this page.
+
+## Reserving Bloom filters
+With the Redis Bloom filter, most of the sizing work is done for you: 
+
+```
+BF.RESERVE {key} {error_rate} {capacity} [EXPANSION expansion] [NONSCALING]
+```
+
+#### 1. False positives rate (`error_rate`)
+The rate is a decimal value between 0 and 1. For example, for a desired false positive rate of 0.1% (1 in 1000), error_rate should be set to 0.001.
+
+#### 2. Expected capacity (`capacity`)
+This is the number of items you expect having in your filter in total and is trivial when you have a static set but it becomes more challenging when your set grows over time. It's important to get the number right because if you **oversize** - you'll end up wasting memory. If you **undersize**, the filter will fill up and a new one will have to be stacked on top of it (sub-filter stacking). In the cases when a filter consists of multiple sub-filters stacked on top of each other latency for adds stays the same, but the latency for presence checks increases. The reason for this is the way the checks work: a regular check would first be performed on the top (latest) filter and if a negative answer is returned the next one is checked and so on. That's where the added latency comes from.
+
+#### 3. Scaling (`EXPANSION`)
+Adding an item to a Bloom filter never fails due to the data structure "filling up". Instead, the error rate starts to grow. To keep the error close to the one set on filter initialization, the Bloom filter will auto-scale, meaning, when capacity is reached, an additional sub-filter will be created.  
+ The size of the new sub-filter is the size of the last sub-filter multiplied by `EXPANSION`. If the number of items to be stored in the filter is unknown, we recommend that you use an expansion of 2 or more to reduce the number of sub-filters. Otherwise, we recommend that you use an expansion of 1 to reduce memory consumption. The default expansion value is 2. 
+ 
+ The filter will keep adding more hash functions for every new sub-filter in order to keep your desired error rate. 
+
+Maybe you're wondering "Why would I create a smaller filter with a high expansion rate if I know I'm going to scale anyway?"; the answer is: for cases where you need to keep many filters (let's say a filter per user, or per product) and most of them will stay small, but some with more activity will have to scale. 
+
+#### 4. `NONSCALING`
+If you know you're not going to scale use the `NONSCALING` flag because that way the filter will use one hash function less. Just remember that if you ever do reach the initially assigned capacity - your error rate will start to grow.
+
+
+### Total size of a Bloom filter
+The actual memory used by a Bloom filter is a function of the chosen error rate:
+
+The optimal number of hash functions is `ceil(-ln(error_rate) / ln(2))`.
+
+The required number of bits per item, given the desired `error_rate` and the optimal number of hash functions, is `-ln(error_rate) / ln(2)^2`. Hence, the required number of bits in the filter is `capacity * -ln(error_rate) / ln(2)^2`.
+
+* **1%**    error rate requires  7 hash functions and  9.585 bits per item.
+* **0.1%**  error rate requires 10 hash functions and 14.378 bits per item.
+* **0.01%** error rate requires 14 hash functions and 19.170 bits per item.
+
+Just as a comparison, when using a Redis set for membership testing the memory needed is:
+
+```
+memory_with_sets = capacity*(192b + value)
+```
+
+For a set of IP addresses, for example, we would have around 40 bytes (320 bits) per item - considerably higher than the 19.170 bits we need for a Bloom filter with a 0.01% false positives rate.
+
+
+## Bloom vs. Cuckoo filters
+Bloom filters typically exhibit better performance and scalability when inserting
+items (so if you're often adding items to your dataset, then a Bloom filter may be ideal).
+Cuckoo filters are quicker on check operations and also allow deletions.
+
+
+## Performance
+
+Insertion in a Bloom filter is O(K), where `k` is the number of hash functions. 
+
+Checking for an item is O(K) or O(K*n) for stacked filters, where n is the number of stacked filters.
+
+
+## Academic sources
+- [Space/Time Trade-offs in Hash Coding with Allowable Errors](http://www.dragonwins.com/domains/getteched/bbc/literature/Bloom70.pdf) by Burton H. Bloom.
+- [Scalable Bloom Filters](https://gsd.di.uminho.pt/members/cbm/ps/dbloom.pdf)
+
+## References
+### Webinars
+1. [Probabilistic Data Structures - The most useful thing in Redis you probably aren't using](https://youtu.be/dq-0xagF7v8?t=102)
+
+### Blog posts
+1. [RedisBloom Quick Start Tutorial](https://docs.redis.com/latest/modules/redisbloom/redisbloom-quickstart/)
+1. [Developing with Bloom Filters](https://redis.io/blog/bloom-filter/)
+1. [RedisBloom on Redis Enterprise](https://redis.com/redis-enterprise/redis-bloom/)
+1. [Probably and No: Redis, RedisBloom, and Bloom Filters](https://redis.com/blog/redis-redisbloom-bloom-filters/)
+1. [RedisBloom – Bloom Filter Datatype for Redis](https://redis.com/blog/rebloom-bloom-filter-datatype-redis/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Count-min sketch is a probabilistic data structure that estimates the
+  frequency of an element in a data stream.
+linkTitle: Count-min sketch
+stack: true
+title: Count-min sketch
+weight: 60
+---
+
+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.
+
+## Use cases
+
+**Products (retail, online shops)** 
+
+This application answers this question: What was the sales volume (on a certain day) for a product? 
+
+Use one Count-Min sketch created per day (period). Every product sale goes into the CMS. The CMS give reasonably accurate results for the products that contribute the most toward the sales. Products with low percentage of the total sales are ignored. 
+
+## Examples
+Assume you select an error rate of 0.1% (0.001) with a certainty of 99.8% (0.998). This means you have an error probability of 0.02% (0.002). Your sketch strives to keep the error within 0.1% of the total count of all elements you've added. There's a 0.02% chance the error might exceed this—like when an element below the threshold overlaps with one above it. When you add a few items to the CMS and evaluate their frequency, remember that in such a small sample, collisions are rare, as seen with other probabilistic data structures.
+
+{{< clients-example cms_tutorial cms >}}
+> CMS.INITBYPROB bikes:profit 0.001 0.002
+OK
+> CMS.INCRBY bikes:profit "Smokey Mountain Striker" 100
+(integer) 100
+> CMS.INCRBY bikes:profit "Rocky Mountain Racer" 200 "Cloudy City Cruiser" 150
+1) (integer) 200
+2) (integer) 150
+> CMS.QUERY bikes:profit "Smokey Mountain Striker" "Rocky Mountain Racer" "Cloudy City Cruiser" "Terrible Bike Name"
+1) (integer) 100
+2) (integer) 200
+3) (integer) 150
+4) (integer) 0
+> CMS.INFO bikes:profit
+1) width
+2) (integer) 2000
+3) depth
+4) (integer) 9
+5) count
+6) (integer) 450
+{{< /clients-example >}}
+
+##### Example 1:
+If we had a uniform distribution of 1000 elements where each has a count of around 500 the threshold would be 500: 
+
+```
+threshold = error * total_count  = 0.001 * (1000*500) = 500
+```
+
+This shows that a CMS is maybe not the best data structure to count frequency of a uniformly distributed stream.
+Let's try decreasing the error to 0.01%:
+
+```
+threshold = error * total_count  = 0.0001 * (1000*500) = 100
+```
+This threshold looks more acceptable already, but it means we will need a bigger sketch width `w = 2/error = 20 000` and consequently - more memory.
+
+##### Example 2:
+In another example let's imagine a normal (gaussian) distribution where we have 1000 elements, out of which 800 will have a summed count of 400K (with an average count of 500) and 200 elements will have a much higher summed count of 1.6M (with an average count of 8000), making them the heavy hitters (elephant flow). The threshold after "populating" the sketch with all the 1000 elements would be:
+
+```
+threshold = error * total_count = 0.001 * 2M = 2000
+```
+
+This threshold seems to be sitting comfortably between the 2 average counts 500 and 8000 so the initial chosen error rate should be working well for this case.
+
+
+## Sizing
+
+Even though the Count-Min sketch is similar to Bloom filter in many ways, its sizing is considerably more complex. The initialisation command receives only two sizing parameters, but you have to understand them thoroughly if you want to have a usable sketch.
+
+```
+CMS.INITBYPROB key error probability
+```
+
+### 1. Error
+
+The `error` parameter will determine the width `w` of your sketch and the probability will determine the number of hash functions (depth `d`). The error rate we choose will determine the threshold above which we can trust the result from the sketch. The correlation is:
+```
+threshold = error * total_count 
+```
+or
+```
+error = threshold/total_count
+```
+
+where `total_count` is the sum of the count of all elements that can be obtained from the `count` key of the result of the [`CMS.INFO`]({{< relref "commands/cms.info/" >}}) command and is of course dynamic - it changes with every new increment in the sketch. At creation time you can approximate the `total_count` ratio as a product of the average count you'll be expecting in the sketch and the average number of elements.
+
+Since the threshold is a function of the total count in the filter it's very important to note that it will grow as  the count grows, but knowing the total count we can always dynamically calculate the threshold. If a result is below it - it can be discarded.
+
+  
+### 2. Probability
+  
+`probability` in this data structure represents the chance of an element that has a count below the threshold to collide with elements that had a count above the threshold on all sketches/depths thus returning a min-count of a frequently occurring element instead of its own.
+
+
+
+## Performance
+Adding, updating and querying for elements in a CMS has a time complexity O(1).
+
+
+## Academic sources
+- [An Improved Data Stream Summary: The Count-Min Sketch and its Applications](http://dimacs.rutgers.edu/~graham/pubs/papers/cm-full.pdf)
+
+## References
+- [Count-Min Sketch: The Art and Science of Estimating Stuff](https://redis.com/blog/count-min-sketch-the-art-and-science-of-estimating-stuff/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: t-digest is a probabilistic data structure that allows you to estimate
+  the percentile of a data stream.
+linkTitle: t-digest
+stack: true
+title: t-digest
+weight: 40
+---
+
+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.
+
+t-digest can also be used to estimate other values related to percentiles, like trimmed means.   
+
+> A **trimmed mean** is the mean value from the sketch, excluding observation values outside the low and high cutoff percentiles. For example, a 0.1 trimmed mean is the mean value of the sketch, excluding the lowest 10% and the highest 10% of the values.
+
+## Use cases
+
+**Hardware/software monitoring**
+
+You measure your online server response latency, and you like to query:
+
+- What are the 50th, 90th, and 99th percentiles of the measured latencies?
+
+- Which fraction of the measured latencies are less than 25 milliseconds?
+
+- What is the mean latency, ignoring outliers? or What is the mean latency between the 10th and the 90th percentile?
+
+**Online gaming**
+
+Millions of people are playing a game on your online gaming platform, and you want to give the following information to each player?
+
+- Your score is better than x percent of the game sessions played.
+
+- There were about y game sessions where people scored larger than you.
+
+- To have a better score than 90% of the games played, your score should be z.
+
+**Network traffic monitoring**
+
+You measure the IP packets transferred over your network each second and try to detect denial-of-service attacks by asking:
+
+- Does the number of packets in the last second exceed 99% of previously observed values?
+
+- How many packets do I expect to see under _normal_ network conditions? 
+(Answer: between x and y, where x represents the 1st percentile and y represents the 99th percentile).
+
+**Predictive maintenance**
+
+- Was the measured parameter (noise level, current consumption, etc.) irregular? (not within the [1st percentile...99th percentile] range)?
+
+- To which values should I set my alerts?
+
+
+## Examples
+
+In the following example, you'll create a t-digest with a compression of 100 and add items to it. The `COMPRESSION` argument is used to specify the tradeoff between accuracy and memory consumption. The default value is 100. Higher values mean more accuracy. Note: unlike some of the other probabilistic data structures, the [`TDIGEST.ADD`]({{< relref "commands/tdigest.add/" >}}) command will not create a new structure if the key does not exist.
+
+{{< clients-example tdigest_tutorial tdig_start >}}
+> TDIGEST.CREATE bikes:sales COMPRESSION 100
+OK
+> TDIGEST.ADD bikes:sales 21
+OK
+> TDIGEST.ADD bikes:sales 150 95 75 34
+OK
+{{< /clients-example >}}
+
+
+You can repeat calling [TDIGEST.ADD]({{< relref "commands/tdigest.add" >}}) whenever new observations are available
+
+#### Estimating fractions or ranks by values
+
+Another helpful feature in t-digest is CDF (definition of rank) which gives us the fraction of observations smaller or equal to a certain value. This command is very useful to answer questions like "*What's the percentage of observations with a value lower or equal to X*".
+
+>More precisely, [`TDIGEST.CDF`]({{< relref "commands/tdigest.cdf/" >}}) will return the estimated fraction of observations in the sketch that are smaller than X plus half the number of observations that are equal to X. We can also use the [`TDIGEST.RANK`]({{< relref "commands/tdigest.rank/" >}}) command, which is very similar. Instead of returning a fraction, it returns the ----estimated---- rank of a value. The [`TDIGEST.RANK`]({{< relref "commands/tdigest.rank/" >}}) command is also variadic, meaning you can use a single command to retrieve estimations for one or more values.
+
+Here's an example. Given a set of biker's ages, you can ask a question like "What's the percentage of bike racers that are younger than 50 years?"
+
+{{< clients-example tdigest_tutorial tdig_cdf >}}
+> TDIGEST.CREATE racer_ages
+OK
+> TDIGEST.ADD racer_ages 45.88 44.2 58.03 19.76 39.84 69.28 50.97 25.41 19.27 85.71 42.63
+OK
+> TDIGEST.CDF racer_ages 50
+1) "0.63636363636363635"
+> TDIGEST.RANK racer_ages 50
+1) (integer) 7
+> TDIGEST.RANK racer_ages 50 40
+1) (integer) 7
+2) (integer) 4
+{{< /clients-example >}}
+
+
+And lastly, `TDIGEST.REVRANK key value...` is similar to [TDIGEST.RANK]({{< relref "commands/tdigest.rank" >}}), but returns, for each input value, an estimation of the number of (observations larger than a given value + half the observations equal to the given value).
+
+
+#### Estimating values by fractions or ranks
+
+`TDIGEST.QUANTILE key fraction...` returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations. `TDIGEST.BYRANK key rank...` returns, for each input rank, an estimation of the value (floating point) with that rank.
+
+{{< clients-example tdigest_tutorial tdig_quant >}}
+> TDIGEST.QUANTILE racer_ages .5
+1) "44.200000000000003"
+> TDIGEST.BYRANK racer_ages 4
+1) "42.630000000000003"
+{{< /clients-example >}}
+
+`TDIGEST.BYREVRANK key rank...` returns, for each input **reverse rank**, an estimation of the **value** (floating point) with that reverse rank.
+
+#### Estimating trimmed mean
+
+Use `TDIGEST.TRIMMED_MEAN key lowFraction highFraction` to retrieve an estimation of the mean value between the specified fractions.
+
+This is especially useful for calculating the average value ignoring outliers. For example - calculating the average value between the 20th percentile and the 80th percentile.
+
+#### Merging sketches
+
+Sometimes it is useful to merge sketches. For example, suppose we measure latencies for 3 servers, and we want to calculate the 90%, 95%, and 99% latencies for all the servers combined.
+
+`TDIGEST.MERGE destKey numKeys sourceKey... [COMPRESSION compression] [OVERRIDE]` merges multiple sketches into a single sketch.
+
+If `destKey` does not exist - a new sketch is created.
+
+If `destKey` is an existing sketch, its values are merged with the values of the source keys. To override the destination key contents, use `OVERRIDE`.
+
+#### Retrieving sketch information
+
+Use [`TDIGEST.MIN`]({{< relref "commands/tdigest.min/" >}}) and [`TDIGEST.MAX`]({{< relref "commands/tdigest.max/" >}}) to retrieve the minimal and maximal values in the sketch, respectively.
+
+{{< clients-example tdigest_tutorial tdig_min >}}
+> TDIGEST.MIN racer_ages
+"19.27"
+> TDIGEST.MAX racer_ages
+"85.709999999999994"
+{{< /clients-example >}}
+
+Both return `nan` when the sketch is empty.
+
+Both commands return accurate results and are equivalent to `TDIGEST.BYRANK racer_ages 0` and `TDIGEST.BYREVRANK racer_ages 0`, respectively.
+
+Use `TDIGEST.INFO racer_ages` to retrieve some additional information about the sketch.
+
+#### Resetting a sketch
+
+{{< clients-example tdigest_tutorial tdig_reset >}}
+> TDIGEST.RESET racer_ages
+OK
+{{< /clients-example >}}
+
+## Academic sources
+- [The _t_-digest: Efficient estimates of distributions](https://www.sciencedirect.com/science/article/pii/S2665963820300403)
+
+## References
+- [t-digest: A New Probabilistic Data Structure in Redis Stack](https://redis.com/blog/t-digest-in-redis-stack/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis probabilistic data structures support multiple configuration parameters.
+linkTitle: Configuration
+title: Configuration Parameters
+weight: 100
+---
+{{< note >}}
+As of Redis 8 in Redis Open Source (Redis 8), configuration parameters for the probabilistic data structures are now set in the following ways:
+* At load time via your `redis.conf` file.
+* At run time (where applicable) using the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command.
+
+Also, Redis 8 persists probabilistic configuration parameters just like any other configuration parameters (e.g., using the [`CONFIG REWRITE`]({{< relref "/commands/config-rewrite/" >}}) command).
+{{< /note >}}
+
+
+## Redis probabilistic data structure configuration parameters
+
+The following table summarizes which Bloom filter configuration parameters can be set at run-time, and compatibility with Redis Software and Redis Cloud.
+
+| Parameter name<br />(version < 8.0) | Parameter name<br />(version &#8805; 8.0) | Run-time | Redis<br />Software | Redis<br />Cloud |
+| :------- | :------- | :------- | :------- | :------- |
+| ERROR_RATE         | [bf-error-rate](#bf-error-rate)             | :white_check_mark: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+|                    | [bf-expansion-factor](#bf-expansion-factor) | :white_check_mark: |||
+| INITIAL_SIZE       | [bf-initial-size](#bf-initial-size)         | :white_check_mark: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+
+The following table summarizes which Cuckoo filter configuration parameters can be set at run-time, and compatibility with Redis Software and Redis Cloud.
+
+| Parameter name<br />(version < 8.0) | Parameter name<br />(version &#8805; 8.0) | Run-time | Redis<br />Software | Redis<br />Cloud |
+| :------- | :------- | :------- | :------- | :------- |
+|                    | [cf-bucket-size](#cf-bucket-size)           | :white_check_mark: |||
+|                    | [cf-initial-size](#cf-initial-size)         | :white_check_mark: |||
+|                    | [cf-expansion-factor](#cf-expansion-factor) | :white_check_mark: |||
+| CF_MAX_EXPANSIONS  | [cf-max-expansions](#cf-max-expansions)     | :white_check_mark: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+|                    | [cf-max-iterations](#cf-max-iterations)     | :white_check_mark: |||
+
+{{< note >}}
+Parameter names for Redis Open Source versions < 8.0, while deprecated, will still be supported in Redis 8.
+{{< /note >}}
+
+---
+
+{{< warning >}}
+A filter should always be sized for the expected capacity and the desired error rate.
+Using the `INSERT` family commands with the default values should be used in cases where many small filters exist and the expectation is most will remain at around the default sizes.
+Not optimizing a filter for its intended use will result in degradation of performance and memory efficiency.
+{{< /warning >}}
+
+## Default parameters for Bloom filters
+
+### bf-error-rate
+
+Default false positive rate for Bloom filters.
+
+Type: double
+
+Valid range: `(0 .. 1)`. Though the valid range is `(0 .. 1)` (corresponding to `> 0%` to `< 100%` false positive rate), any value greater than `0.25` is treated as `0.25`.
+
+Default: `0.01`
+
+### bf-expansion-factor
+
+Added in v8.0.0.
+
+Expansion factor for Bloom filters.
+
+Type: integer
+
+Valid range: `[0 .. 32768]`.
+
+Default: `2`
+
+### bf-initial-size
+
+Initial capacity for Bloom filters.
+
+Type: integer
+
+Valid range: `[1 .. 1048576]`
+
+Default: `100`
+
+## Default parameters for Cuckoo filters
+
+### cf-bucket-size
+
+Added in v8.0.0.
+
+The number of items in each Cuckoo filter bucket.
+
+Type: integer
+
+Valid range: `[1 .. 255]`
+
+Default: `2`
+
+### cf-initial-size
+
+Added in v8.0.0.
+
+Cuckoo filter initial capacity.
+
+Type: integer
+
+Valid range: `[2*cf-bucket-size .. 1048576]`
+
+Default: `1024`
+
+### cf-expansion-factor
+
+Added in v8.0.0.
+
+Expansion factor for Cuckoo filters.
+
+Type: integer
+
+Valid range: `[0 .. 32768]`
+
+Default: `1`
+
+### cf-max-expansions
+
+The maximum number of expansions for Cuckoo filters.
+
+Type: integer
+
+Valid range: `[1 .. 65535]`
+
+Default: `32`
+
+### cf-max-iterations
+
+Added in v8.0.0
+
+The maximum number of iterations for Cuckoo filters.
+
+Type: integer
+
+Valid range: `[1 .. 65535]`
+
+Default: `20`
+
+## Setting configuration parameters on module load (deprecated)
+
+These methods are deprecated beginning with Redis 8.
+
+Setting configuration parameters at load-time is done by appending arguments after the `--loadmodule` argument when starting a server from the command line or after the `loadmodule` directive in a Redis config file. For example:
+
+In [redis.conf]({{< relref "/operate/oss_and_stack/management/config" >}}):
+
+```sh
+loadmodule ./redisbloom.so [OPT VAL]...
+```
+
+From the [Redis CLI]({{< relref "/develop/tools/cli" >}}), using the [MODULE LOAD]({{< relref "/commands/module-load" >}}) command:
+
+```
+127.0.0.6379> MODULE LOAD redisbloom.so [OPT VAL]...
+```
+
+From the command line:
+
+```sh
+$ redis-server --loadmodule ./redisbloom.so [OPT VAL]...
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Top-K is a probabilistic data structure that allows you to find the most
+  frequent items in a data stream.
+linkTitle: Top-K
+stack: true
+title: Top-K
+weight: 50
+---
+
+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?
+ 
+There is, indeed, some overlap with the functionality of Count-Min Sketch, but the two data structures have their differences and should be applied for different use cases. 
+
+The Redis Open Source implementation of Top-K is based on the [HeavyKeepers](https://www.usenix.org/conference/atc18/presentation/gong) algorithm presented by Junzhi Gong et al. It discards some older approaches like "count-all" and "admit-all-count-some" in favour of a "**count-with-exponential-decay**" strategy which is biased against mouse (small) flows and has a limited impact on elephant (large) flows. This implementation uses two data structures in tandem: a hash table that holds the probabilistic counts (much like the Count-Min Sketch), and a min heap that holds the `K` items with the highest counts. This ensures high accuracy with shorter execution times than previous probabilistic algorithms allowed, while keeping memory utilization to a fraction of what is typically required by a Sorted Set. It has the additional benefit of being able to get real time notifications when elements are added or removed from the Top K list. 
+
+## Use case
+
+**Trending hashtags (social media platforms, news distribution networks)** 
+
+This application answers these questions: 
+
+- What are the K hashtags people have mentioned the most in the last X hours? 
+- What are the K news with highest read/view count today? 
+
+Data flow is the incoming social media posts from which you parse out the different hashtags. 
+
+The [`TOPK.LIST`]({{< relref "commands/topk.list/" >}}) command has a time complexity of `O(K*log(k))` so if `K` is small, there is no need to keep a separate set or sorted set of all the hashtags. You can query directly from the Top K itself. 
+
+## Example
+
+This example will show you how to track key words used "bike" when shopping online; e.g., "bike store" and "bike handlebars". Proceed as follows.
+​
+* Use [`TOPK.RESERVE`]({{< relref "commands/topk.reserve/" >}}) to initialize a top K sketch with specific parameters. Note: the `width`, `depth`, and `decay_constant` parameters can be omitted, as they will be set to the default values 7, 8, and 0.9, respectively, if not present.
+​
+ ```
+ > TOPK.RESERVE key k width depth decay_constant
+ ```
+ 
+ * Use [`TOPK.ADD`]({{< relref "commands/topk.add/" >}}) to add items to the sketch. As you can see, multiple items can be added at the same time. If an item is returned when adding additional items, it means that item was demoted out of the min heap of the top items, below it will mean the returned item is no longer in the top 5, otherwise `nil` is returned. This allows dynamic heavy-hitter detection of items being entered or expelled from top K list.
+​
+In the example below, "pedals" displaces "handlebars", which is returned after "pedals" is added. Also note that the addition of both "store" and "seat" a second time don't return anything, as they're already in the top K.
+ 
+ * Use [`TOPK.LIST`]({{< relref "commands/topk.list/" >}}) to list the items entered thus far.
+​
+ * Use [`TOPK.QUERY`]({{< relref "commands/topk.query/" >}}) to see if an item is on the top K list. Just like [`TOPK.ADD`]({{< relref "commands/topk.add/" >}}) multiple items can be queried at the same time.
+{{< clients-example topk_tutorial topk >}}
+> TOPK.RESERVE bikes:keywords 5 2000 7 0.925
+OK
+> TOPK.ADD bikes:keywords store seat handlebars handles pedals tires store seat
+1) (nil)
+2) (nil)
+3) (nil)
+4) (nil)
+5) (nil)
+6) handlebars
+7) (nil)
+8) (nil)
+> TOPK.LIST bikes:keywords
+1) store
+2) seat
+3) pedals
+4) tires
+5) handles
+> TOPK.QUERY bikes:keywords store handlebars
+1) (integer) 1
+2) (integer) 0
+{{< /clients-example >}}
+
+## Sizing
+
+Choosing the size for a Top K sketch is relatively easy, because the only two parameters you need to set are a direct function of the number of elements (K) you want to keep in your list.
+
+If you start by knowing your desired `k` you can easily derive the width and depth:
+
+```
+width = k*log(k)
+depth =  log(k)  # but a minimum of 5
+```
+
+For the `decay_constant` you can use the value `0.9` which has been found as optimal in many cases, but you can experiment with different values and find what works best for your use case.
+
+## Performance
+Insertion in a top-k has time complexity of O(K + depth) ≈ O(K) and lookup has time complexity of O(K), where K is the number of top elements to be kept in the list and depth is the number of hash functions used.
+
+
+## Academic sources
+- [HeavyKeeper: An Accurate Algorithm for Finding Top-k Elephant Flows.](https://yangtonghome.github.io/uploads/HeavyKeeper_ToN.pdf)
+
+## References
+- [Meet Top-K: an Awesome Probabilistic Addition to RedisBloom](https://redis.com/blog/meet-top-k-awesome-probabilistic-addition-redisbloom/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Cuckoo filters are a probabilistic data structure that checks for presence
+  of an element in a set
+linkTitle: Cuckoo filter
+stack: true
+title: Cuckoo filter
+weight: 20
+---
+
+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.
+
+
+## Use cases
+
+**Targeted ad campaigns (advertising, retail)** 
+
+This application answers this question: Has the user signed up for this campaign yet?
+
+Use a Cuckoo filter for every campaign, populated with targeted users' ids. On every visit, the user id is checked against one of the Cuckoo filters. 
+
+- If yes, the user has not signed up for campaign. Show the ad.
+- If the user clicks ad and signs up, remove the user id from that Cuckoo filter. 
+- If no, the user has signed up for that campaign. Try the next ad/Cuckoo filter. 
+ 
+**Discount code/coupon validation (retail, online shops)** 
+
+This application answers this question: Has this discount code/coupon been used yet?
+
+Use a Cuckoo filter populated with all discount codes/coupons. On every try, the entered code is checked against the filter. 
+
+- If no, the coupon is not valid. 
+- If yes, the coupon can be valid. Check the main database. If valid, remove from Cuckoo filter as `used`.
+
+Note> In addition to these two cases, Cuckoo filters serve very well all the Bloom filter use cases.
+
+## Examples
+
+> You'll learn how to create an empty cuckoo filter with an initial capacity for 1,000 items, add items, check their existence, and remove them. Even though the [`CF.ADD`]({{< relref "commands/cf.add/" >}}) command can create a new filter if one isn't present, it might not be optimally sized for your needs. It's better to use the [`CF.RESERVE`]({{< relref "commands/cf.reserve/" >}}) command to set up a filter with your preferred capacity.
+
+{{< clients-example cuckoo_tutorial cuckoo >}}
+> CF.RESERVE bikes:models 1000000
+OK
+> CF.ADD bikes:models "Smoky Mountain Striker"
+(integer) 1
+> CF.EXISTS bikes:models "Smoky Mountain Striker"
+(integer) 1
+> CF.EXISTS bikes:models "Terrible Bike Name"
+(integer) 0
+> CF.DEL bikes:models "Smoky Mountain Striker"
+(integer) 1
+{{< /clients-example >}}
+
+## Bloom vs. Cuckoo filters
+Bloom filters typically exhibit better performance and scalability when inserting
+items (so if you're often adding items to your dataset, then a Bloom filter may be ideal).
+Cuckoo filters are quicker on check operations and also allow deletions.
+
+## Sizing Cuckoo filters
+
+These are the main parameters and features of a cuckoo filter:
+
+- `p` target false positive rate  
+- `f` fingerprint length in bits
+- `α` fill rate or load factor (0≤α≤1)
+- `b` number of entries per bucket
+- `m` number of buckets
+- `n` number of items
+- `C` average bits per item
+
+Let's start by remembering that a cuckoo filter bucket can have multiple entries (where each entry stores one fingerprint). If we end up having all entries occupied with a fingerprint then we won't have empty slots to save new elements and the filter will be declared full, that's why we should always maintain a certain percentage of our cuckoo filter free.  
+As a result of this the "real" memory cost of an item should include that overhead in addition to the fingerprint size. If `α` is the load factor (fingerprint size / total filter size) and `f` is the number of bits in an entry the amortised space cost `f/α bits`.
+
+When you initialise a new filter you are asked to choose its capacity and bucket size. 
+
+```
+CF.RESERVE {key} {capacity} [BUCKETSIZE bucketSize] [MAXITERATIONS maxIterations]
+[EXPANSION expansion]
+``` 
+
+### Choosing the capacity  (`capacity`)
+
+The capacity of a Cuckoo filter is calculated as
+
+```
+capacity = n*f/α
+```
+where `n` is the number of elements you expect to have in your filter, `f` is the fingerprint length in bits which is set to `8` and `α` is the fill factor. So in order to get your filter capacity you must first choose a fill factor. The fill factor will determine the density of your data and of course the memory. 
+The capacity will be rounded up to the next "power of two (2<sup>n</sup>)" number.
+
+> Please note that inserting repeated items in a cuckoo filter will try to add them multiple times causing your filter to fill up
+
+Because of how Cuckoo Filters work, the filter is likely to declare itself full before capacity is reached and therefore fill rate will likely never reach 100%.
+
+
+### Choosing the bucket size (`BUCKETSIZE`)
+Number of items in each bucket. A higher bucket size value improves the fill rate but also causes a higher error rate and slightly slower performance.
+
+```
+error_rate = (buckets * hash_functions)/2^fingerprint_size = (buckets*2)/256
+```
+
+When bucket size of 1 is used the fill rate is 55% and false positive error rate is 2/256 ≈ 0.78% **which is the minimal false positive rate you can achieve**. Larger buckets increase the error rate linearly but improve the fill rate of the filter. For example, a bucket size of 3 yields a 2.34% error rate and an 80% fill rate. Bucket size of 4 yields a 3.12% error rate and a 95% fill rate. 
+
+### Choosing the scaling factor (`EXPANSION`)
+
+When the filter self-declares itself full, it will auto-expand by generating additional sub-filters at the cost of reduced performance and increased error rate. The new sub-filter is created with size of the previous sub-filter multiplied by `EXPANSION` (chosen on filter creation). Like bucket size, additional sub-filters grow the error rate linearly (the compound error is a sum of all subfilters' errors). The size of the new sub-filter is the size of the last sub-filter multiplied by expansion and this is something very important to keep in mind. If you know you'll have to scale at some point it's better to choose a higher expansion value. The default is 1.
+
+Maybe you're wondering "Why would I create a smaller filter with a high expansion rate if I know I'm going to scale anyway?"; the answer is: for cases where you need to keep many filters (let's say a filter per user, or per product) and most of them will stay small, but some with more activity will have to scale. 
+
+The expansion factor will be rounded up to the next "power of two (2<sup>n</sup>)" number.
+
+### Choosing the maximum number of iterations (`MAXITERATIONS`)
+`MAXITERATIONS` dictates the number of attempts to find a slot for the incoming fingerprint. Once the filter gets full, a high MAXITERATIONS value will slow down insertions. The default value is 20.
+
+### Interesting facts: 
+- Unused capacity in prior sub-filters is automatically used when possible. 
+- The filter can grow up to 32 times. 
+- You can delete items to stay within filter limits instead of rebuilding
+- Adding the same element multiple times will create multiple entries, thus filling up your filter.
+
+
+## Performance
+Adding an element to a Cuckoo filter has a time complexity of O(1).
+
+Similarly, checking for an element and deleting an element also has a time complexity of O(1).
+
+
+
+## Academic sources
+- [Cuckoo Filter: Practically Better Than Bloom](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Probabilistic data structures in Redis
+linkTitle: Probabilistic
+title: Probabilistic
+weight: 140
+---
+
+*Probabilistic data structures* give approximations of statistics such as
+counts, frequencies, and rankings rather than precise values.
+The advantage of using approximations is that they are adequate for
+many common purposes but are much more efficient to calculate. They
+sometimes have other advantages too, such as obfuscating times, locations,
+and other sensitive data.
+
+Probabilistic data structures are available as part of Redis Open Source and they are available in Redis Software and Redis Cloud.
+See
+[Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) or
+[Install Redis Enterprise]({{< relref "/operate/rs/installing-upgrading/install" >}})
+for full installation instructions.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis sets
+
+  '
+linkTitle: Sets
+title: Redis sets
+weight: 30
+---
+
+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`]({{< relref "/commands/sadd" >}}) adds a new member to a set.
+* [`SREM`]({{< relref "/commands/srem" >}}) removes the specified member from the set.
+* [`SISMEMBER`]({{< relref "/commands/sismember" >}}) tests a string for set membership.
+* [`SINTER`]({{< relref "/commands/sinter" >}}) returns the set of members that two or more sets have in common (i.e., the intersection).
+* [`SCARD`]({{< relref "/commands/scard" >}}) returns the size (a.k.a. cardinality) of a set.
+
+See the [complete list of set commands]({{< relref "/commands/" >}}?group=set).
+
+## Examples
+
+* Store the sets of bikes racing in France and the USA. Note that 
+if you add a member that already exists, it will be ignored. 
+{{< clients-example sets_tutorial sadd >}}
+> SADD bikes:racing:france bike:1
+(integer) 1
+> SADD bikes:racing:france bike:1
+(integer) 0
+> SADD bikes:racing:france bike:2 bike:3
+(integer) 2
+> SADD bikes:racing:usa bike:1 bike:4
+(integer) 2
+{{< /clients-example >}}
+
+* Check whether bike:1 or bike:2 are racing in the US.
+{{< clients-example sets_tutorial sismember >}}
+> SISMEMBER bikes:racing:usa bike:1
+(integer) 1
+> SISMEMBER bikes:racing:usa bike:2
+(integer) 0
+{{< /clients-example >}}
+
+* Which bikes are competing in both races?
+{{< clients-example sets_tutorial sinter >}}
+> SINTER bikes:racing:france bikes:racing:usa
+1) "bike:1"
+{{< /clients-example >}}
+
+* How many bikes are racing in France?
+{{< clients-example sets_tutorial scard >}}
+> SCARD bikes:racing:france
+(integer) 3
+{{< /clients-example >}}
+## Tutorial
+
+The [`SADD`]({{< relref "/commands/sadd" >}}) command adds new elements to a set. It's also possible
+to do a number of other operations against sets like testing if a given element
+already exists, performing the intersection, union or difference between
+multiple sets, and so forth.
+
+{{< clients-example sets_tutorial sadd_smembers >}}
+> SADD bikes:racing:france bike:1 bike:2 bike:3
+(integer) 3
+> SMEMBERS bikes:racing:france
+1) bike:3
+2) bike:1
+3) bike:2
+{{< /clients-example >}}
+
+Here I've added three elements to my set and told Redis to return all the
+elements. There is no order guarantee with a set. Redis is free to return the
+elements in any order at every call.
+
+Redis has commands to test for set membership. These commands can be used on single as well as multiple items:
+
+{{< clients-example sets_tutorial smismember >}}
+> SISMEMBER bikes:racing:france bike:1
+(integer) 1
+> SMISMEMBER bikes:racing:france bike:2 bike:3 bike:4
+1) (integer) 1
+2) (integer) 1
+3) (integer) 0
+{{< /clients-example >}}
+
+We can also find the difference between two sets. For instance, we may want
+to know which bikes are racing in France but not in the USA:
+
+{{< clients-example sets_tutorial sdiff >}}
+> SADD bikes:racing:usa bike:1 bike:4
+(integer) 2
+> SDIFF bikes:racing:france bikes:racing:usa
+1) "bike:3"
+2) "bike:2"
+{{< /clients-example >}}
+
+There are other non trivial operations that are still easy to implement
+using the right Redis commands. For instance we may want a list of all the
+bikes racing in France, the USA, and some other races. We can do this using
+the [`SINTER`]({{< relref "/commands/sinter" >}}) command, which performs the intersection between different
+sets. In addition to intersection you can also perform
+unions, difference, and more. For example 
+if we add a third race we can see some of these commands in action:
+
+{{< clients-example sets_tutorial multisets >}}
+> SADD bikes:racing:france bike:1 bike:2 bike:3
+(integer) 3
+> SADD bikes:racing:usa bike:1 bike:4
+(integer) 2
+> SADD bikes:racing:italy bike:1 bike:2 bike:3 bike:4
+(integer) 4
+> SINTER bikes:racing:france bikes:racing:usa bikes:racing:italy
+1) "bike:1"
+> SUNION bikes:racing:france bikes:racing:usa bikes:racing:italy
+1) "bike:2"
+2) "bike:1"
+3) "bike:4"
+4) "bike:3"
+> SDIFF bikes:racing:france bikes:racing:usa bikes:racing:italy
+(empty array)
+> SDIFF bikes:racing:france bikes:racing:usa
+1) "bike:3"
+2) "bike:2"
+> SDIFF bikes:racing:usa bikes:racing:france
+1) "bike:4"
+{{< /clients-example >}}
+
+You'll note that the [`SDIFF`]({{< relref "/commands/sdiff" >}}) command returns an empty array when the
+difference between all sets is empty. You'll also note that the order of sets
+passed to [`SDIFF`]({{< relref "/commands/sdiff" >}}) matters, since the difference is not commutative.
+
+When you want to remove items from a set, you can use the [`SREM`]({{< relref "/commands/srem" >}}) command to
+remove one or more items from a set, or you can use the [`SPOP`]({{< relref "/commands/spop" >}}) command to
+remove a random item from a set. You can also _return_ a random item from a
+set without removing it using the [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}) command:
+
+{{< clients-example sets_tutorial srem >}}
+> SADD bikes:racing:france bike:1 bike:2 bike:3 bike:4 bike:5
+(integer) 5
+> SREM bikes:racing:france bike:1
+(integer) 1
+> SPOP bikes:racing:france
+"bike:3"
+> SMEMBERS bikes:racing:france
+1) "bike:2"
+2) "bike:4"
+3) "bike:5"
+> SRANDMEMBER bikes:racing:france
+"bike:2"
+{{< /clients-example >}}
+
+## Limits
+
+The max size of a Redis set is 2^32 - 1 (4,294,967,295) members.
+
+## Performance
+
+Most set operations, including adding, removing, and checking whether an item is a set member, are O(1).
+This means that they're highly efficient.
+However, for large sets with hundreds of thousands of members or more, you should exercise caution when running the [`SMEMBERS`]({{< relref "/commands/smembers" >}}) command.
+This command is O(n) and returns the entire set in a single response. 
+As an alternative, consider the [`SSCAN`]({{< relref "/commands/sscan" >}}), which lets you retrieve all members of a set iteratively.
+
+## Alternatives
+
+Sets membership checks on large datasets (or on streaming data) can use a lot of memory.
+If you're concerned about memory usage and don't need perfect precision, consider a [Bloom filter or Cuckoo filter]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}}) as an alternative to a set.
+
+Redis sets are frequently used as a kind of index.
+If you need to index and query your data, consider the [JSON]({{< relref "/develop/data-types/json/" >}}) data type and the [Redis Query Engine]({{< relref "/develop/interact/search-and-query/" >}}) features.
+
+## Learn more
+
+* [Redis Sets Explained](https://www.youtube.com/watch?v=PKdCppSNTGQ) and [Redis Sets Elaborated](https://www.youtube.com/watch?v=aRw5ME_5kMY) are two short but thorough video explainers covering Redis sets.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) explores Redis sets in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis streams
+
+  '
+linkTitle: Streams
+title: Redis Streams
+weight: 60
+---
+
+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 streams support several trimming strategies (to prevent streams from growing unbounded) and more than one consumption strategy (see [`XREAD`]({{< relref "/commands/xread" >}}), [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), and [`XRANGE`]({{< relref "/commands/xrange" >}})).
+
+## Basic commands
+* [`XADD`]({{< relref "/commands/xadd" >}}) adds a new entry to a stream.
+* [`XREAD`]({{< relref "/commands/xread" >}}) reads one or more entries, starting at a given position and moving forward in time.
+* [`XRANGE`]({{< relref "/commands/xrange" >}}) returns a range of entries between two supplied entry IDs.
+* [`XLEN`]({{< relref "/commands/xlen" >}}) returns the length of a stream.
+ 
+See the [complete list of stream commands]({{< relref "/commands/" >}}?group=stream).
+
+
+## Examples
+
+* When our racers pass a checkpoint, we add a stream entry for each racer that includes the racer's name, speed, position, and location ID:
+{{< clients-example stream_tutorial xadd >}}
+> XADD race:france * rider Castilla speed 30.2 position 1 location_id 1
+"1692632086370-0"
+> XADD race:france * rider Norem speed 28.8 position 3 location_id 1
+"1692632094485-0"
+> XADD race:france * rider Prickett speed 29.7 position 2 location_id 1
+"1692632102976-0"
+{{< /clients-example >}}
+
+* Read two stream entries starting at ID `1692632086370-0`:
+{{< clients-example stream_tutorial xrange >}}
+> XRANGE race:france 1692632086370-0 + COUNT 2
+1) 1) "1692632086370-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "30.2"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "1"
+2) 1) "1692632094485-0"
+   2) 1) "rider"
+      2) "Norem"
+      3) "speed"
+      4) "28.8"
+      5) "position"
+      6) "3"
+      7) "location_id"
+      8) "1"
+{{< /clients-example >}}
+
+* Read up to 100 new stream entries, starting at the end of the stream, and block for up to 300 ms if no entries are being written:
+{{< clients-example stream_tutorial xread_block >}}
+> XREAD COUNT 100 BLOCK 300 STREAMS race:france $
+(nil)
+{{< /clients-example >}}
+
+## Performance
+
+Adding an entry to a stream is O(1).
+Accessing any single entry is O(n), where _n_ is the length of the ID.
+Since stream IDs are typically short and of a fixed length, this effectively reduces to a constant time lookup.
+For details on why, note that streams are implemented as [radix trees](https://en.wikipedia.org/wiki/Radix_tree).
+
+Simply put, Redis streams provide highly efficient inserts and reads.
+See each command's time complexity for the details.
+
+
+## Streams basics
+
+Streams are an append-only data structure. The fundamental write command, called [`XADD`]({{< relref "/commands/xadd" >}}), appends a new entry to the specified stream.
+
+Each stream entry consists of one or more field-value pairs, somewhat like a dictionary or a Redis hash:
+
+{{< clients-example stream_tutorial xadd_2 >}}
+> XADD race:france * rider Castilla speed 29.9 position 1 location_id 2
+"1692632147973-0"
+{{< /clients-example >}}
+
+The above call to the [`XADD`]({{< relref "/commands/xadd" >}}) command adds an entry `rider: Castilla, speed: 29.9, position: 1, location_id: 2` to the stream at key `race:france`, using an auto-generated entry ID, which is the one returned by the command, specifically `1692632147973-0`. It gets as its first argument the key name `race:france`, the second argument is the entry ID that identifies every entry inside a stream. However, in this case, we passed `*` because we want the server to generate a new ID for us. Every new ID will be monotonically increasing, so in more simple terms, every new entry added will have a higher ID compared to all the past entries. Auto-generation of IDs by the server is almost always what you want, and the reasons for specifying an ID explicitly are very rare. We'll talk more about this later. The fact that each Stream entry has an ID is another similarity with log files, where line numbers, or the byte offset inside the file, can be used in order to identify a given entry. Returning back at our [`XADD`]({{< relref "/commands/xadd" >}}) example, after the key name and ID, the next arguments are the field-value pairs composing our stream entry.
+
+It is possible to get the number of items inside a Stream just using the [`XLEN`]({{< relref "/commands/xlen" >}}) command:
+
+{{< clients-example stream_tutorial xlen >}}
+> XLEN race:france
+(integer) 4
+{{< /clients-example >}}
+
+### Entry IDs
+
+The entry ID returned by the [`XADD`]({{< relref "/commands/xadd" >}}) command, and identifying univocally each entry inside a given stream, is composed of two parts:
+
+```
+<millisecondsTime>-<sequenceNumber>
+```
+
+The milliseconds time part is actually the local time in the local Redis node generating the stream ID, however if the current milliseconds time happens to be smaller than the previous entry time, then the previous entry time is used instead, so if a clock jumps backward the monotonically incrementing ID property still holds. The sequence number is used for entries created in the same millisecond. Since the sequence number is 64 bit wide, in practical terms there is no limit to the number of entries that can be generated within the same millisecond.
+
+The format of such IDs may look strange at first, and the gentle reader may wonder why the time is part of the ID. The reason is that Redis streams support range queries by ID. Because the ID is related to the time the entry is generated, this gives the ability to query for time ranges basically for free. We will see this soon while covering the [`XRANGE`]({{< relref "/commands/xrange" >}}) command.
+
+If for some reason the user needs incremental IDs that are not related to time but are actually associated to another external system ID, as previously mentioned, the [`XADD`]({{< relref "/commands/xadd" >}}) command can take an explicit ID instead of the `*` wildcard ID that triggers auto-generation, like in the following examples:
+
+{{< clients-example stream_tutorial xadd_id >}}
+> XADD race:usa 0-1 racer Castilla
+0-1
+> XADD race:usa 0-2 racer Norem
+0-2
+{{< /clients-example >}}
+
+Note that in this case, the minimum ID is 0-1 and that the command will not accept an ID equal or smaller than a previous one:
+
+{{< clients-example stream_tutorial xadd_bad_id >}}
+> XADD race:usa 0-1 racer Prickett
+(error) ERR The ID specified in XADD is equal or smaller than the target stream top item
+{{< /clients-example >}}
+
+If you're running Redis 7 or later, you can also provide an explicit ID consisting of the milliseconds part only. In this case, the sequence portion of the ID will be automatically generated. To do this, use the syntax below:
+
+{{< clients-example stream_tutorial xadd_7 >}}
+> XADD race:usa 0-* racer Prickett
+0-3
+{{< /clients-example >}}
+
+## Getting data from Streams
+
+Now we are finally able to append entries in our stream via [`XADD`]({{< relref "/commands/xadd" >}}). However, while appending data to a stream is quite obvious, the way streams can be queried in order to extract data is not so obvious. If we continue with the analogy of the log file, one obvious way is to mimic what we normally do with the Unix command `tail -f`, that is, we may start to listen in order to get the new messages that are appended to the stream. Note that unlike the blocking list operations of Redis, where a given element will reach a single client which is blocking in a *pop style* operation like [`BLPOP`]({{< relref "/commands/blpop" >}}), with streams we want multiple consumers to see the new messages appended to the stream (the same way many `tail -f` processes can see what is added to a log). Using the traditional terminology we want the streams to be able to *fan out* messages to multiple clients.
+
+However, this is just one potential access mode. We could also see a stream in quite a different way: not as a messaging system, but as a *time series store*. In this case, maybe it's also useful to get the new messages appended, but another natural query mode is to get messages by ranges of time, or alternatively to iterate the messages using a cursor to incrementally check all the history. This is definitely another useful access mode.
+
+Finally, if we see a stream from the point of view of consumers, we may want to access the stream in yet another way, that is, as a stream of messages that can be partitioned to multiple consumers that are processing such messages, so that groups of consumers can only see a subset of the messages arriving in a single stream. In this way, it is possible to scale the message processing across different consumers, without single consumers having to process all the messages: each consumer will just get different messages to process. This is basically what Kafka (TM) does with consumer groups. Reading messages via consumer groups is yet another interesting mode of reading from a Redis Stream.
+
+Redis Streams support all three of the query modes described above via different commands. The next sections will show them all, starting from the simplest and most direct to use: range queries.
+
+### Querying by range: XRANGE and XREVRANGE
+
+To query the stream by range we are only required to specify two IDs, *start* and *end*. The range returned will include the elements having start or end as ID, so the range is inclusive. The two special IDs `-` and `+` respectively mean the smallest and the greatest ID possible.
+
+{{< clients-example stream_tutorial xrange_all >}}
+> XRANGE race:france - +
+1) 1) "1692632086370-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "30.2"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "1"
+2) 1) "1692632094485-0"
+   2) 1) "rider"
+      2) "Norem"
+      3) "speed"
+      4) "28.8"
+      5) "position"
+      6) "3"
+      7) "location_id"
+      8) "1"
+3) 1) "1692632102976-0"
+   2) 1) "rider"
+      2) "Prickett"
+      3) "speed"
+      4) "29.7"
+      5) "position"
+      6) "2"
+      7) "location_id"
+      8) "1"
+4) 1) "1692632147973-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "29.9"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "2"
+{{< /clients-example >}}
+
+Each entry returned is an array of two items: the ID and the list of field-value pairs. We already said that the entry IDs have a relation with the time, because the part at the left of the `-` character is the Unix time in milliseconds of the local node that created the stream entry, at the moment the entry was created (however note that streams are replicated with fully specified [`XADD`]({{< relref "/commands/xadd" >}}) commands, so the replicas will have identical IDs to the master). This means that I could query a range of time using [`XRANGE`]({{< relref "/commands/xrange" >}}). In order to do so, however, I may want to omit the sequence part of the ID: if omitted, in the start of the range it will be assumed to be 0, while in the end part it will be assumed to be the maximum sequence number available. This way, querying using just two milliseconds Unix times, we get all the entries that were generated in that range of time, in an inclusive way. For instance, if I want to query a two milliseconds period I could use:
+
+{{< clients-example stream_tutorial xrange_time >}}
+> XRANGE race:france 1692632086369 1692632086371
+1) 1) "1692632086370-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "30.2"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "1"
+{{< /clients-example >}}
+
+I have only a single entry in this range. However in real data sets, I could query for ranges of hours, or there could be many items in just two milliseconds, and the result returned could be huge. For this reason, [`XRANGE`]({{< relref "/commands/xrange" >}}) supports an optional **COUNT** option at the end. By specifying a count, I can just get the first *N* items. If I want more, I can get the last ID returned, increment the sequence part by one, and query again. Let's see this in the following example. Let's assume that the stream `race:france` was populated with 4 items. To start my iteration, getting 2 items per command, I start with the full range, but with a count of 2.
+
+{{< clients-example stream_tutorial xrange_step_1 >}}
+> XRANGE race:france - + COUNT 2
+1) 1) "1692632086370-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "30.2"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "1"
+2) 1) "1692632094485-0"
+   2) 1) "rider"
+      2) "Norem"
+      3) "speed"
+      4) "28.8"
+      5) "position"
+      6) "3"
+      7) "location_id"
+      8) "1"
+{{< /clients-example >}}
+
+To continue the iteration with the next two items, I have to pick the last ID returned, that is `1692632094485-0`, and add the prefix `(` to it. The resulting exclusive range interval, that is `(1692632094485-0` in this case, can now be used as the new *start* argument for the next [`XRANGE`]({{< relref "/commands/xrange" >}}) call:
+
+{{< clients-example stream_tutorial xrange_step_2 >}}
+> XRANGE race:france (1692632094485-0 + COUNT 2
+1) 1) "1692632102976-0"
+   2) 1) "rider"
+      2) "Prickett"
+      3) "speed"
+      4) "29.7"
+      5) "position"
+      6) "2"
+      7) "location_id"
+      8) "1"
+2) 1) "1692632147973-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "29.9"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "2"
+{{< /clients-example >}}
+
+Now that we've retrieved 4 items out of a stream that only had 4 entries in it, if we try to retrieve more items, we'll get an empty array:
+
+{{< clients-example stream_tutorial xrange_empty >}}
+> XRANGE race:france (1692632147973-0 + COUNT 2
+(empty array)
+{{< /clients-example >}}
+
+Since [`XRANGE`]({{< relref "/commands/xrange" >}}) complexity is *O(log(N))* to seek, and then *O(M)* to return M elements, with a small count the command has a logarithmic time complexity, which means that each step of the iteration is fast. So [`XRANGE`]({{< relref "/commands/xrange" >}}) is also the de facto *streams iterator* and does not require an **XSCAN** command.
+
+The command [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}) is the equivalent of [`XRANGE`]({{< relref "/commands/xrange" >}}) but returning the elements in inverted order, so a practical use for [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}) is to check what is the last item in a Stream:
+
+{{< clients-example stream_tutorial xrevrange >}}
+> XREVRANGE race:france + - COUNT 1
+1) 1) "1692632147973-0"
+   2) 1) "rider"
+      2) "Castilla"
+      3) "speed"
+      4) "29.9"
+      5) "position"
+      6) "1"
+      7) "location_id"
+      8) "2"
+{{< /clients-example >}}
+
+Note that the [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}) command takes the *start* and *stop* arguments in reverse order.
+
+## Listening for new items with XREAD
+
+When we do not want to access items by a range in a stream, usually what we want instead is to *subscribe* to new items arriving to the stream. This concept may appear related to Redis Pub/Sub, where you subscribe to a channel, or to Redis blocking lists, where you wait for a key to get new elements to fetch, but there are fundamental differences in the way you consume a stream:
+
+1. A stream can have multiple clients (consumers) waiting for data. Every new item, by default, will be delivered to *every consumer* that is waiting for data in a given stream. This behavior is different than blocking lists, where each consumer will get a different element. However, the ability to *fan out* to multiple consumers is similar to Pub/Sub.
+2. While in Pub/Sub messages are *fire and forget* and are never stored anyway, and while when using blocking lists, when a message is received by the client it is *popped* (effectively removed) from the list, streams work in a fundamentally different way. All the messages are appended in the stream indefinitely (unless the user explicitly asks to delete entries): different consumers will know what is a new message from its point of view by remembering the ID of the last message received.
+3. Streams Consumer Groups provide a level of control that Pub/Sub or blocking lists cannot achieve, with different groups for the same stream, explicit acknowledgment of processed items, ability to inspect the pending items, claiming of unprocessed messages, and coherent history visibility for each single client, that is only able to see its private past history of messages.
+
+The command that provides the ability to listen for new messages arriving into a stream is called [`XREAD`]({{< relref "/commands/xread" >}}). It's a bit more complex than [`XRANGE`]({{< relref "/commands/xrange" >}}), so we'll start showing simple forms, and later the whole command layout will be provided.
+
+{{< clients-example stream_tutorial xread >}}
+> XREAD COUNT 2 STREAMS race:france 0
+1) 1) "race:france"
+   2) 1) 1) "1692632086370-0"
+         2) 1) "rider"
+            2) "Castilla"
+            3) "speed"
+            4) "30.2"
+            5) "position"
+            6) "1"
+            7) "location_id"
+            8) "1"
+      2) 1) "1692632094485-0"
+         2) 1) "rider"
+            2) "Norem"
+            3) "speed"
+            4) "28.8"
+            5) "position"
+            6) "3"
+            7) "location_id"
+            8) "1"
+{{< /clients-example >}}
+
+The above is the non-blocking form of [`XREAD`]({{< relref "/commands/xread" >}}). Note that the **COUNT** option is not mandatory, in fact the only mandatory option of the command is the **STREAMS** option, that specifies a list of keys together with the corresponding maximum ID already seen for each stream by the calling consumer, so that the command will provide the client only with messages with an ID greater than the one we specified.
+
+In the above command we wrote `STREAMS race:france 0` so we want all the messages in the Stream `race:france` having an ID greater than `0-0`. As you can see in the example above, the command returns the key name, because actually it is possible to call this command with more than one key to read from different streams at the same time. I could write, for instance: `STREAMS race:france race:italy 0 0`. Note how after the **STREAMS** option we need to provide the key names, and later the IDs. For this reason, the **STREAMS** option must always be the last option.
+Any other options must come before the **STREAMS** option.
+
+Apart from the fact that [`XREAD`]({{< relref "/commands/xread" >}}) can access multiple streams at once, and that we are able to specify the last ID we own to just get newer messages, in this simple form the command is not doing something so different compared to [`XRANGE`]({{< relref "/commands/xrange" >}}). However, the interesting part is that we can turn [`XREAD`]({{< relref "/commands/xread" >}}) into a *blocking command* easily, by specifying the **BLOCK** argument:
+
+```
+> XREAD BLOCK 0 STREAMS race:france $
+```
+
+Note that in the example above, other than removing **COUNT**, I specified the new **BLOCK** option with a timeout of 0 milliseconds (that means to never timeout). Moreover, instead of passing a normal ID for the stream `mystream` I passed the special ID `$`. This special ID means that [`XREAD`]({{< relref "/commands/xread" >}}) should use as last ID the maximum ID already stored in the stream `mystream`, so that we will receive only *new* messages, starting from the time we started listening. This is similar to the `tail -f` Unix command in some way.
+
+Note that when the **BLOCK** option is used, we do not have to use the special ID `$`. We can use any valid ID. If the command is able to serve our request immediately without blocking, it will do so, otherwise it will block. Normally if we want to consume the stream starting from new entries, we start with the ID `$`, and after that we continue using the ID of the last message received to make the next call, and so forth.
+
+The blocking form of [`XREAD`]({{< relref "/commands/xread" >}}) is also able to listen to multiple Streams, just by specifying multiple key names. If the request can be served synchronously because there is at least one stream with elements greater than the corresponding ID we specified, it returns with the results. Otherwise, the command will block and will return the items of the first stream which gets new data (according to the specified ID).
+
+Similarly to blocking list operations, blocking stream reads are *fair* from the point of view of clients waiting for data, since the semantics is FIFO style. The first client that blocked for a given stream will be the first to be unblocked when new items are available.
+
+[`XREAD`]({{< relref "/commands/xread" >}}) has no other options than **COUNT** and **BLOCK**, so it's a pretty basic command with a specific purpose to attach consumers to one or multiple streams. More powerful features to consume streams are available using the consumer groups API, however reading via consumer groups is implemented by a different command called [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), covered in the next section of this guide.
+
+## Consumer groups
+
+When the task at hand is to consume the same stream from different clients, then [`XREAD`]({{< relref "/commands/xread" >}}) already offers a way to *fan-out* to N clients, potentially also using replicas in order to provide more read scalability. However in certain problems what we want to do is not to provide the same stream of messages to many clients, but to provide a *different subset* of messages from the same stream to many clients. An obvious case where this is useful is that of messages which are slow to process: the ability to have N different workers that will receive different parts of the stream allows us to scale message processing, by routing different messages to different workers that are ready to do more work.
+
+In practical terms, if we imagine having three consumers C1, C2, C3, and a stream that contains the messages 1, 2, 3, 4, 5, 6, 7 then what we want is to serve the messages according to the following diagram:
+
+```
+1 -> C1
+2 -> C2
+3 -> C3
+4 -> C1
+5 -> C2
+6 -> C3
+7 -> C1
+```
+
+In order to achieve this, Redis uses a concept called *consumer groups*. It is very important to understand that Redis consumer groups have nothing to do, from an implementation standpoint, with Kafka (TM) consumer groups. Yet they are similar in functionality, so I decided to keep Kafka's (TM) terminology, as it originally popularized this idea.
+
+A consumer group is like a *pseudo consumer* that gets data from a stream, and actually serves multiple consumers, providing certain guarantees:
+
+1. Each message is served to a different consumer so that it is not possible that the same message will be delivered to multiple consumers.
+2. Consumers are identified, within a consumer group, by a name, which is a case-sensitive string that the clients implementing consumers must choose. This means that even after a disconnect, the stream consumer group retains all the state, since the client will claim again to be the same consumer. However, this also means that it is up to the client to provide a unique identifier.
+3. Each consumer group has the concept of the *first ID never consumed* so that, when a consumer asks for new messages, it can provide just messages that were not previously delivered.
+4. Consuming a message, however, requires an explicit acknowledgment using a specific command. Redis interprets the acknowledgment as: this message was correctly processed so it can be evicted from the consumer group.
+5. A consumer group tracks all the messages that are currently pending, that is, messages that were delivered to some consumer of the consumer group, but are yet to be acknowledged as processed. Thanks to this feature, when accessing the message history of a stream, each consumer *will only see messages that were delivered to it*.
+
+In a way, a consumer group can be imagined as some *amount of state* about a stream:
+
+```
++----------------------------------------+
+| consumer_group_name: mygroup           |
+| consumer_group_stream: somekey         |
+| last_delivered_id: 1292309234234-92    |
+|                                        |
+| consumers:                             |
+|    "consumer-1" with pending messages  |
+|       1292309234234-4                  |
+|       1292309234232-8                  |
+|    "consumer-42" with pending messages |
+|       ... (and so forth)               |
++----------------------------------------+
+```
+
+If you see this from this point of view, it is very simple to understand what a consumer group can do, how it is able to just provide consumers with their history of pending messages, and how consumers asking for new messages will just be served with message IDs greater than `last_delivered_id`. At the same time, if you look at the consumer group as an auxiliary data structure for Redis streams, it is obvious that a single stream can have multiple consumer groups, that have a different set of consumers. Actually, it is even possible for the same stream to have clients reading without consumer groups via [`XREAD`]({{< relref "/commands/xread" >}}), and clients reading via [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) in different consumer groups.
+
+Now it's time to zoom in to see the fundamental consumer group commands. They are the following:
+
+* [`XGROUP`]({{< relref "/commands/xgroup" >}}) is used in order to create, destroy and manage consumer groups.
+* [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) is used to read from a stream via a consumer group.
+* [`XACK`]({{< relref "/commands/xack" >}}) is the command that allows a consumer to mark a pending message as correctly processed.
+
+## Creating a consumer group
+
+Assuming I have a key `race:france` of type stream already existing, in order to create a consumer group I just need to do the following:
+
+{{< clients-example stream_tutorial xgroup_create >}}
+> XGROUP CREATE race:france france_riders $
+OK
+{{< /clients-example >}}
+
+As you can see in the command above when creating the consumer group we have to specify an ID, which in the example is just `$`. This is needed because the consumer group, among the other states, must have an idea about what message to serve next at the first consumer connecting, that is, what was the *last message ID* when the group was just created. If we provide `$` as we did, then only new messages arriving in the stream from now on will be provided to the consumers in the group. If we specify `0` instead the consumer group will consume *all* the messages in the stream history to start with. Of course, you can specify any other valid ID. What you know is that the consumer group will start delivering messages that are greater than the ID you specify. Because `$` means the current greatest ID in the stream, specifying `$` will have the effect of consuming only new messages.
+
+[`XGROUP CREATE`]({{< relref "/commands/xgroup-create" >}}) also supports creating the stream automatically, if it doesn't exist, using the optional `MKSTREAM` subcommand as the last argument:
+
+{{< clients-example stream_tutorial xgroup_create_mkstream >}}
+> XGROUP CREATE race:italy italy_riders $ MKSTREAM
+OK
+{{< /clients-example >}}
+
+Now that the consumer group is created we can immediately try to read messages via the consumer group using the [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) command. We'll read from consumers, that we will call Alice and Bob, to see how the system will return different messages to Alice or Bob.
+
+[`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) is very similar to [`XREAD`]({{< relref "/commands/xread" >}}) and provides the same **BLOCK** option, otherwise it is a synchronous command. However there is a *mandatory* option that must be always specified, which is **GROUP** and has two arguments: the name of the consumer group, and the name of the consumer that is attempting to read. The option **COUNT** is also supported and is identical to the one in [`XREAD`]({{< relref "/commands/xread" >}}).
+
+We'll add riders to the race:italy stream and try reading something using the consumer group:
+Note: *here rider is the field name, and the name is the associated value. Remember that stream items are small dictionaries.*
+
+{{< clients-example stream_tutorial xgroup_read >}}
+> XADD race:italy * rider Castilla
+"1692632639151-0"
+> XADD race:italy * rider Royce
+"1692632647899-0"
+> XADD race:italy * rider Sam-Bodden
+"1692632662819-0"
+> XADD race:italy * rider Prickett
+"1692632670501-0"
+> XADD race:italy * rider Norem
+"1692632678249-0"
+> XREADGROUP GROUP italy_riders Alice COUNT 1 STREAMS race:italy >
+1) 1) "race:italy"
+   2) 1) 1) "1692632639151-0"
+         2) 1) "rider"
+            2) "Castilla"
+{{< /clients-example >}}
+
+[`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) replies are just like [`XREAD`]({{< relref "/commands/xread" >}}) replies. Note however the `GROUP <group-name> <consumer-name>` provided above. It states that I want to read from the stream using the consumer group `mygroup` and I'm the consumer `Alice`. Every time a consumer performs an operation with a consumer group, it must specify its name, uniquely identifying this consumer inside the group.
+
+There is another very important detail in the command line above, after the mandatory **STREAMS** option the ID requested for the key `mystream` is the special ID `>`. This special ID is only valid in the context of consumer groups, and it means: **messages never delivered to other consumers so far**.
+
+This is almost always what you want, however it is also possible to specify a real ID, such as `0` or any other valid ID, in this case, however, what happens is that we request from [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) to just provide us with the **history of pending messages**, and in such case, will never see new messages in the group. So basically [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) has the following behavior based on the ID we specify:
+
+* If the ID is the special ID `>` then the command will return only new messages never delivered to other consumers so far, and as a side effect, will update the consumer group's *last ID*.
+* If the ID is any other valid numerical ID, then the command will let us access our *history of pending messages*. That is, the set of messages that were delivered to this specified consumer (identified by the provided name), and never acknowledged so far with [`XACK`]({{< relref "/commands/xack" >}}).
+
+We can test this behavior immediately specifying an ID of 0, without any **COUNT** option: we'll just see the only pending message, that is, the one about Castilla:
+
+{{< clients-example stream_tutorial xgroup_read_id >}}
+> XREADGROUP GROUP italy_riders Alice STREAMS race:italy 0
+1) 1) "race:italy"
+   2) 1) 1) "1692632639151-0"
+         2) 1) "rider"
+            2) "Castilla"
+{{< /clients-example >}}
+
+However, if we acknowledge the message as processed, it will no longer be part of the pending messages history, so the system will no longer report anything:
+
+{{< clients-example stream_tutorial xack >}}
+> XACK race:italy italy_riders 1692632639151-0
+(integer) 1
+> XREADGROUP GROUP italy_riders Alice STREAMS race:italy 0
+1) 1) "race:italy"
+   2) (empty array)
+{{< /clients-example >}}
+
+Don't worry if you yet don't know how [`XACK`]({{< relref "/commands/xack" >}}) works, the idea is just that processed messages are no longer part of the history that we can access.
+
+Now it's Bob's turn to read something:
+
+{{< clients-example stream_tutorial xgroup_read_bob >}}
+> XREADGROUP GROUP italy_riders Bob COUNT 2 STREAMS race:italy >
+1) 1) "race:italy"
+   2) 1) 1) "1692632647899-0"
+         2) 1) "rider"
+            2) "Royce"
+      2) 1) "1692632662819-0"
+         2) 1) "rider"
+            2) "Sam-Bodden"
+{{< /clients-example >}}
+
+Bob asked for a maximum of two messages and is reading via the same group `mygroup`. So what happens is that Redis reports just *new* messages. As you can see the "Castilla" message is not delivered, since it was already delivered to Alice, so Bob gets Royce and Sam-Bodden and so forth.
+
+This way Alice, Bob, and any other consumer in the group, are able to read different messages from the same stream, to read their history of yet to process messages, or to mark messages as processed. This allows creating different topologies and semantics for consuming messages from a stream.
+
+There are a few things to keep in mind:
+
+* Consumers are auto-created the first time they are mentioned, no need for explicit creation.
+* Even with [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) you can read from multiple keys at the same time, however for this to work, you need to create a consumer group with the same name in every stream. This is not a common need, but it is worth mentioning that the feature is technically available.
+* [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) is a *write command* because even if it reads from the stream, the consumer group is modified as a side effect of reading, so it can only be called on master instances.
+
+An example of a consumer implementation, using consumer groups, written in the Ruby language could be the following. The Ruby code is aimed to be readable by virtually any experienced programmer, even if they do not know Ruby:
+
+```ruby
+require 'redis'
+
+if ARGV.length == 0
+    puts "Please specify a consumer name"
+    exit 1
+end
+
+ConsumerName = ARGV[0]
+GroupName = "mygroup"
+r = Redis.new
+
+def process_message(id,msg)
+    puts "[#{ConsumerName}] #{id} = #{msg.inspect}"
+end
+
+$lastid = '0-0'
+
+puts "Consumer #{ConsumerName} starting..."
+check_backlog = true
+while true
+    # Pick the ID based on the iteration: the first time we want to
+    # read our pending messages, in case we crashed and are recovering.
+    # Once we consumed our history, we can start getting new messages.
+    if check_backlog
+        myid = $lastid
+    else
+        myid = '>'
+    end
+
+    items = r.xreadgroup('GROUP',GroupName,ConsumerName,'BLOCK','2000','COUNT','10','STREAMS',:my_stream_key,myid)
+
+    if items == nil
+        puts "Timeout!"
+        next
+    end
+
+    # If we receive an empty reply, it means we were consuming our history
+    # and that the history is now empty. Let's start to consume new messages.
+    check_backlog = false if items[0][1].length == 0
+
+    items[0][1].each{|i|
+        id,fields = i
+
+        # Process the message
+        process_message(id,fields)
+
+        # Acknowledge the message as processed
+        r.xack(:my_stream_key,GroupName,id)
+
+        $lastid = id
+    }
+end
+```
+
+As you can see the idea here is to start by consuming the history, that is, our list of pending messages. This is useful because the consumer may have crashed before, so in the event of a restart we want to re-read messages that were delivered to us without getting acknowledged. Note that we might process a message multiple times or one time (at least in the case of consumer failures, but there are also the limits of Redis persistence and replication involved, see the specific section about this topic).
+
+Once the history was consumed, and we get an empty list of messages, we can switch to using the `>` special ID in order to consume new messages.
+
+## Recovering from permanent failures
+
+The example above allows us to write consumers that participate in the same consumer group, each taking a subset of messages to process, and when recovering from failures re-reading the pending messages that were delivered just to them. However in the real world consumers may permanently fail and never recover. What happens to the pending messages of the consumer that never recovers after stopping for any reason?
+
+Redis consumer groups offer a feature that is used in these situations in order to *claim* the pending messages of a given consumer so that such messages will change ownership and will be re-assigned to a different consumer. The feature is very explicit. A consumer has to inspect the list of pending messages, and will have to claim specific messages using a special command, otherwise the server will leave the messages pending forever and assigned to the old consumer. In this way different applications can choose if to use such a feature or not, and exactly how to use it.
+
+The first step of this process is just a command that provides observability of pending entries in the consumer group and is called [`XPENDING`]({{< relref "/commands/xpending" >}}).
+This is a read-only command which is always safe to call and will not change ownership of any message.
+In its simplest form, the command is called with two arguments, which are the name of the stream and the name of the consumer group.
+
+{{< clients-example stream_tutorial xpending >}}
+> XPENDING race:italy italy_riders
+1) (integer) 2
+2) "1692632647899-0"
+3) "1692632662819-0"
+4) 1) 1) "Bob"
+      2) "2"
+{{< /clients-example >}}
+
+When called in this way, the command outputs the total number of pending messages in the consumer group (two in this case), the lower and higher message ID among the pending messages, and finally a list of consumers and the number of pending messages they have.
+We have only Bob with two pending messages because the single message that Alice requested was acknowledged using [`XACK`]({{< relref "/commands/xack" >}}).
+
+We can ask for more information by giving more arguments to [`XPENDING`]({{< relref "/commands/xpending" >}}), because the full command signature is the following:
+
+```
+XPENDING <key> <groupname> [[IDLE <min-idle-time>] <start-id> <end-id> <count> [<consumer-name>]]
+```
+
+By providing a start and end ID (that can be just `-` and `+` as in [`XRANGE`]({{< relref "/commands/xrange" >}})) and a count to control the amount of information returned by the command, we are able to know more about the pending messages. The optional final argument, the consumer name, is used if we want to limit the output to just messages pending for a given consumer, but won't use this feature in the following example.
+
+{{< clients-example stream_tutorial xpending_plus_minus >}}
+> XPENDING race:italy italy_riders - + 10
+1) 1) "1692632647899-0"
+   2) "Bob"
+   3) (integer) 74642
+   4) (integer) 1
+2) 1) "1692632662819-0"
+   2) "Bob"
+   3) (integer) 74642
+   4) (integer) 1
+{{< /clients-example >}}
+
+Now we have the details for each message: the ID, the consumer name, the *idle time* in milliseconds, which is how many milliseconds have passed since the last time the message was delivered to some consumer, and finally the number of times that a given message was delivered.
+We have two messages from Bob, and they are idle for 60000+ milliseconds, about a minute.
+
+Note that nobody prevents us from checking what the first message content was by just using [`XRANGE`]({{< relref "/commands/xrange" >}}).
+
+{{< clients-example stream_tutorial xrange_pending >}}
+> XRANGE race:italy 1692632647899-0 1692632647899-0
+1) 1) "1692632647899-0"
+   2) 1) "rider"
+      2) "Royce"
+{{< /clients-example >}}
+
+We have just to repeat the same ID twice in the arguments. Now that we have some ideas, Alice may decide that after 1 minute of not processing messages, Bob will probably not recover quickly, and it's time to *claim* such messages and resume the processing in place of Bob. To do so, we use the [`XCLAIM`]({{< relref "/commands/xclaim" >}}) command.
+
+This command is very complex and full of options in its full form, since it is used for replication of consumer groups changes, but we'll use just the arguments that we need normally. In this case it is as simple as:
+
+```
+XCLAIM <key> <group> <consumer> <min-idle-time> <ID-1> <ID-2> ... <ID-N>
+```
+
+Basically we say, for this specific key and group, I want that the message IDs specified will change ownership, and will be assigned to the specified consumer name `<consumer>`. However, we also provide a minimum idle time, so that the operation will only work if the idle time of the mentioned messages is greater than the specified idle time. This is useful because maybe two clients are retrying to claim a message at the same time:
+
+```
+Client 1: XCLAIM race:italy italy_riders Alice 60000 1692632647899-0
+Client 2: XCLAIM race:italy italy_riders Lora 60000 1692632647899-0
+```
+
+However, as a side effect, claiming a message will reset its idle time and will increment its number of deliveries counter, so the second client will fail claiming it. In this way we avoid trivial re-processing of messages (even if in the general case you cannot obtain exactly once processing).
+
+This is the result of the command execution:
+
+{{< clients-example stream_tutorial xclaim >}}
+> XCLAIM race:italy italy_riders Alice 60000 1692632647899-0
+1) 1) "1692632647899-0"
+   2) 1) "rider"
+      2) "Royce"
+{{< /clients-example >}}
+
+The message was successfully claimed by Alice, who can now process the message and acknowledge it, and move things forward even if the original consumer is not recovering.
+
+It is clear from the example above that as a side effect of successfully claiming a given message, the [`XCLAIM`]({{< relref "/commands/xclaim" >}}) command also returns it. However this is not mandatory. The **JUSTID** option can be used in order to return just the IDs of the message successfully claimed. This is useful if you want to reduce the bandwidth used between the client and the server (and also the performance of the command) and you are not interested in the message because your consumer is implemented in a way that it will rescan the history of pending messages from time to time.
+
+Claiming may also be implemented by a separate process: one that just checks the list of pending messages, and assigns idle messages to consumers that appear to be active. Active consumers can be obtained using one of the observability features of Redis streams. This is the topic of the next section.
+
+## Automatic claiming
+
+The [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) command, added in Redis 6.2, implements the claiming process that we've described above.
+[`XPENDING`]({{< relref "/commands/xpending" >}}) and [`XCLAIM`]({{< relref "/commands/xclaim" >}}) provide the basic building blocks for different types of recovery mechanisms.
+This command optimizes the generic process by having Redis manage it and offers a simple solution for most recovery needs.
+
+[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) identifies idle pending messages and transfers ownership of them to a consumer.
+The command's signature looks like this:
+
+```
+XAUTOCLAIM <key> <group> <consumer> <min-idle-time> <start> [COUNT count] [JUSTID]
+```
+
+So, in the example above, I could have used automatic claiming to claim a single message like this:
+
+{{< clients-example stream_tutorial xautoclaim >}}
+> XAUTOCLAIM race:italy italy_riders Alice 60000 0-0 COUNT 1
+1) "0-0"
+2) 1) 1) "1692632662819-0"
+      2) 1) "rider"
+         2) "Sam-Bodden"
+{{< /clients-example >}}
+
+Like [`XCLAIM`]({{< relref "/commands/xclaim" >}}), the command replies with an array of the claimed messages, but it also returns a stream ID that allows iterating the pending entries.
+The stream ID is a cursor, and I can use it in my next call to continue in claiming idle pending messages:
+
+{{< clients-example stream_tutorial xautoclaim_cursor >}}
+> XAUTOCLAIM race:italy italy_riders Lora 60000 (1692632662819-0 COUNT 1
+1) "1692632662819-0"
+2) 1) 1) "1692632647899-0"
+      2) 1) "rider"
+         2) "Royce"
+{{< /clients-example >}}
+
+When [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) returns the "0-0" stream ID as a cursor, that means that it reached the end of the consumer group pending entries list.
+That doesn't mean that there are no new idle pending messages, so the process continues by calling [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) from the beginning of the stream.
+
+## Claiming and the delivery counter
+
+The counter that you observe in the [`XPENDING`]({{< relref "/commands/xpending" >}}) output is the number of deliveries of each message. The counter is incremented in two ways: when a message is successfully claimed via [`XCLAIM`]({{< relref "/commands/xclaim" >}}) or when an [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) call is used in order to access the history of pending messages.
+
+When there are failures, it is normal that messages will be delivered multiple times, but eventually they usually get processed and acknowledged. However there might be a problem processing some specific message, because it is corrupted or crafted in a way that triggers a bug in the processing code. In such a case what happens is that consumers will continuously fail to process this particular message. Because we have the counter of the delivery attempts, we can use that counter to detect messages that for some reason are not processable. So once the deliveries counter reaches a given large number that you chose, it is probably wiser to put such messages in another stream and send a notification to the system administrator. This is basically the way that Redis Streams implements the *dead letter* concept.
+
+## Streams observability
+
+Messaging systems that lack observability are very hard to work with. Not knowing who is consuming messages, what messages are pending, the set of consumer groups active in a given stream, makes everything opaque. For this reason, Redis Streams and consumer groups have different ways to observe what is happening. We already covered [`XPENDING`]({{< relref "/commands/xpending" >}}), which allows us to inspect the list of messages that are under processing at a given moment, together with their idle time and number of deliveries.
+
+However we may want to do more than that, and the [`XINFO`]({{< relref "/commands/xinfo" >}}) command is an observability interface that can be used with sub-commands in order to get information about streams or consumer groups.
+
+This command uses subcommands in order to show different information about the status of the stream and its consumer groups. For instance **XINFO STREAM <key>** reports information about the stream itself.
+
+{{< clients-example stream_tutorial xinfo >}}
+> XINFO STREAM race:italy
+ 1) "length"
+ 2) (integer) 5
+ 3) "radix-tree-keys"
+ 4) (integer) 1
+ 5) "radix-tree-nodes"
+ 6) (integer) 2
+ 7) "last-generated-id"
+ 8) "1692632678249-0"
+ 9) "groups"
+10) (integer) 1
+11) "first-entry"
+12) 1) "1692632639151-0"
+    2) 1) "rider"
+       2) "Castilla"
+13) "last-entry"
+14) 1) "1692632678249-0"
+    2) 1) "rider"
+       2) "Norem"
+{{< /clients-example >}}
+
+The output shows information about how the stream is encoded internally, and also shows the first and last message in the stream. Another piece of information available is the number of consumer groups associated with this stream. We can dig further asking for more information about the consumer groups.
+
+{{< clients-example stream_tutorial xinfo_groups >}}
+> XINFO GROUPS race:italy
+1) 1) "name"
+   2) "italy_riders"
+   3) "consumers"
+   4) (integer) 3
+   5) "pending"
+   6) (integer) 2
+   7) "last-delivered-id"
+   8) "1692632662819-0"
+{{< /clients-example >}}
+
+As you can see in this and in the previous output, the [`XINFO`]({{< relref "/commands/xinfo" >}}) command outputs a sequence of field-value items. Because it is an observability command this allows the human user to immediately understand what information is reported, and allows the command to report more information in the future by adding more fields without breaking compatibility with older clients. Other commands that must be more bandwidth efficient, like [`XPENDING`]({{< relref "/commands/xpending" >}}), just report the information without the field names.
+
+The output of the example above, where the **GROUPS** subcommand is used, should be clear observing the field names. We can check in more detail the state of a specific consumer group by checking the consumers that are registered in the group.
+
+{{< clients-example stream_tutorial xinfo_consumers >}}
+> XINFO CONSUMERS race:italy italy_riders
+1) 1) "name"
+   2) "Alice"
+   3) "pending"
+   4) (integer) 1
+   5) "idle"
+   6) (integer) 177546
+2) 1) "name"
+   2) "Bob"
+   3) "pending"
+   4) (integer) 0
+   5) "idle"
+   6) (integer) 424686
+3) 1) "name"
+   2) "Lora"
+   3) "pending"
+   4) (integer) 1
+   5) "idle"
+   6) (integer) 72241
+{{< /clients-example >}}
+
+In case you do not remember the syntax of the command, just ask the command itself for help:
+
+```
+> XINFO HELP
+1) XINFO <subcommand> [<arg> [value] [opt] ...]. Subcommands are:
+2) CONSUMERS <key> <groupname>
+3)     Show consumers of <groupname>.
+4) GROUPS <key>
+5)     Show the stream consumer groups.
+6) STREAM <key> [FULL [COUNT <count>]
+7)     Show information about the stream.
+8) HELP
+9)     Prints this help.
+```
+
+## Differences with Kafka (TM) partitions
+
+Consumer groups in Redis streams may resemble in some way Kafka (TM) partitioning-based consumer groups, however note that Redis streams are, in practical terms, very different. The partitions are only *logical* and the messages are just put into a single Redis key, so the way the different clients are served is based on who is ready to process new messages, and not from which partition clients are reading. For instance, if the consumer C3 at some point fails permanently, Redis will continue to serve C1 and C2 all the new messages arriving, as if now there are only two *logical* partitions.
+
+Similarly, if a given consumer is much faster at processing messages than the other consumers, this consumer will receive proportionally more messages in the same unit of time. This is possible since Redis tracks all the unacknowledged messages explicitly, and remembers who received which message and the ID of the first message never delivered to any consumer.
+
+However, this also means that in Redis if you really want to partition messages in the same stream into multiple Redis instances, you have to use multiple keys and some sharding system such as Redis Cluster or some other application-specific sharding system. A single Redis stream is not automatically partitioned to multiple instances.
+
+We could say that schematically the following is true:
+
+* If you use 1 stream -> 1 consumer, you are processing messages in order.
+* If you use N streams with N consumers, so that only a given consumer hits a subset of the N streams, you can scale the above model of 1 stream -> 1 consumer.
+* If you use 1 stream -> N consumers, you are load balancing to N consumers, however in that case, messages about the same logical item may be consumed out of order, because a given consumer may process message 3 faster than another consumer is processing message 4.
+
+So basically Kafka partitions are more similar to using N different Redis keys, while Redis consumer groups are a server-side load balancing system of messages from a given stream to N different consumers.
+
+## Capped Streams
+
+Many applications do not want to collect data into a stream forever. Sometimes it is useful to have at maximum a given number of items inside a stream, other times once a given size is reached, it is useful to move data from Redis to a storage which is not in memory and not as fast but suited to store the history for, potentially, decades to come. Redis streams have some support for this. One is the **MAXLEN** option of the [`XADD`]({{< relref "/commands/xadd" >}}) command. This option is very simple to use:
+
+{{< clients-example stream_tutorial maxlen >}}
+> XADD race:italy MAXLEN 2 * rider Jones
+"1692633189161-0"
+> XADD race:italy MAXLEN 2 * rider Wood
+"1692633198206-0"
+> XADD race:italy MAXLEN 2 * rider Henshaw
+"1692633208557-0"
+> XLEN race:italy
+(integer) 2
+> XRANGE race:italy - +
+1) 1) "1692633198206-0"
+   2) 1) "rider"
+      2) "Wood"
+2) 1) "1692633208557-0"
+   2) 1) "rider"
+      2) "Henshaw"
+{{< /clients-example >}}
+
+Using **MAXLEN** the old entries are automatically evicted when the specified length is reached, so that the stream is left at a constant size. There is currently no option to tell the stream to just retain items that are not older than a given period, because such command, in order to run consistently, would potentially block for a long time in order to evict items. Imagine for example what happens if there is an insertion spike, then a long pause, and another insertion, all with the same maximum time. The stream would block to evict the data that became too old during the pause. So it is up to the user to do some planning and understand what is the maximum stream length desired. Moreover, while the length of the stream is proportional to the memory used, trimming by time is less simple to control and anticipate: it depends on the insertion rate which often changes over time (and when it does not change, then to just trim by size is trivial).
+
+However trimming with **MAXLEN** can be expensive: streams are represented by macro nodes into a radix tree, in order to be very memory efficient. Altering the single macro node, consisting of a few tens of elements, is not optimal. So it's possible to use the command in the following special form:
+
+```
+XADD race:italy MAXLEN ~ 1000 * ... entry fields here ...
+```
+
+The `~` argument between the **MAXLEN** option and the actual count means, I don't really need this to be exactly 1000 items. It can be 1000 or 1010 or 1030, just make sure to save at least 1000 items. With this argument, the trimming is performed only when we can remove a whole node. This makes it much more efficient, and it is usually what you want. You'll note here that the client libraries have various implementations of this. For example, the Python client defaults to approximate and has to be explicitly set to a true length.
+
+There is also the [`XTRIM`]({{< relref "/commands/xtrim" >}}) command, which performs something very similar to what the **MAXLEN** option does above, except that it can be run by itself:
+
+{{< clients-example stream_tutorial xtrim >}}
+> XTRIM race:italy MAXLEN 10
+(integer) 0
+{{< /clients-example >}}
+
+Or, as for the [`XADD`]({{< relref "/commands/xadd" >}}) option:
+
+{{< clients-example stream_tutorial xtrim2 >}}
+> XTRIM mystream MAXLEN ~ 10
+(integer) 0
+{{< /clients-example >}}
+
+However, [`XTRIM`]({{< relref "/commands/xtrim" >}}) is designed to accept different trimming strategies. Another trimming strategy is **MINID**, that evicts entries with IDs lower than the one specified.
+
+As [`XTRIM`]({{< relref "/commands/xtrim" >}}) is an explicit command, the user is expected to know about the possible shortcomings of different trimming strategies.
+
+Another useful eviction strategy that may be added to [`XTRIM`]({{< relref "/commands/xtrim" >}}) in the future, is to remove by a range of IDs to ease use of [`XRANGE`]({{< relref "/commands/xrange" >}}) and [`XTRIM`]({{< relref "/commands/xtrim" >}}) to move data from Redis to other storage systems if needed.
+
+## Special IDs in the streams API
+
+You may have noticed that there are several special IDs that can be used in the Redis API. Here is a short recap, so that they can make more sense in the future.
+
+The first two special IDs are `-` and `+`, and are used in range queries with the [`XRANGE`]({{< relref "/commands/xrange" >}}) command. Those two IDs respectively mean the smallest ID possible (that is basically `0-1`) and the greatest ID possible (that is `18446744073709551615-18446744073709551615`). As you can see it is a lot cleaner to write `-` and `+` instead of those numbers.
+
+Then there are APIs where we want to say, the ID of the item with the greatest ID inside the stream. This is what `$` means. So for instance if I want only new entries with [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) I use this ID to signify I already have all the existing entries, but not the new ones that will be inserted in the future. Similarly when I create or set the ID of a consumer group, I can set the last delivered item to `$` in order to just deliver new entries to the consumers in the group.
+
+As you can see `$` does not mean `+`, they are two different things, as `+` is the greatest ID possible in every possible stream, while `$` is the greatest ID in a given stream containing given entries. Moreover APIs will usually only understand `+` or `$`, yet it was useful to avoid loading a given symbol with multiple meanings.
+
+Another special ID is `>`, that is a special meaning only related to consumer groups and only when the [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) command is used. This special ID means that we want only entries that were never delivered to other consumers so far. So basically the `>` ID is the *last delivered ID* of a consumer group.
+
+Finally the special ID `*`, that can be used only with the [`XADD`]({{< relref "/commands/xadd" >}}) command, means to auto select an ID for us for the new entry.
+
+So we have `-`, `+`, `$`, `>` and `*`, and all have a different meaning, and most of the time, can be used in different contexts.
+
+## Persistence, replication and message safety
+
+A Stream, like any other Redis data structure, is asynchronously replicated to replicas and persisted into AOF and RDB files. However what may not be so obvious is that also the consumer groups full state is propagated to AOF, RDB and replicas, so if a message is pending in the master, also the replica will have the same information. Similarly, after a restart, the AOF will restore the consumer groups' state.
+
+However note that Redis streams and consumer groups are persisted and replicated using the Redis default replication, so:
+
+* AOF must be used with a strong fsync policy if persistence of messages is important in your application.
+* By default the asynchronous replication will not guarantee that [`XADD`]({{< relref "/commands/xadd" >}}) commands or consumer groups state changes are replicated: after a failover something can be missing depending on the ability of replicas to receive the data from the master.
+* The [`WAIT`]({{< relref "/commands/wait" >}}) command may be used in order to force the propagation of the changes to a set of replicas. However note that while this makes it very unlikely that data is lost, the Redis failover process as operated by Sentinel or Redis Cluster performs only a *best effort* check to failover to the replica which is the most updated, and under certain specific failure conditions may promote a replica that lacks some data.
+
+So when designing an application using Redis streams and consumer groups, make sure to understand the semantical properties your application should have during failures, and configure things accordingly, evaluating whether it is safe enough for your use case.
+
+## Removing single items from a stream
+
+Streams also have a special command for removing items from the middle of a stream, just by ID. Normally for an append only data structure this may look like an odd feature, but it is actually useful for applications involving, for instance, privacy regulations. The command is called [`XDEL`]({{< relref "/commands/xdel" >}}) and receives the name of the stream followed by the IDs to delete:
+
+{{< clients-example stream_tutorial xdel >}}
+> XRANGE race:italy - + COUNT 2
+1) 1) "1692633198206-0"
+   2) 1) "rider"
+      2) "Wood"
+2) 1) "1692633208557-0"
+   2) 1) "rider"
+      2) "Henshaw"
+> XDEL race:italy 1692633208557-0
+(integer) 1
+> XRANGE race:italy - + COUNT 2
+1) 1) "1692633198206-0"
+   2) 1) "rider"
+      2) "Wood"
+{{< /clients-example >}}
+
+However in the current implementation, memory is not really reclaimed until a macro node is completely empty, so you should not abuse this feature.
+
+## Zero length streams
+
+A difference between streams and other Redis data structures is that when the other data structures no longer have any elements, as a side effect of calling commands that remove elements, the key itself will be removed. So for instance, a sorted set will be completely removed when a call to [`ZREM`]({{< relref "/commands/zrem" >}}) will remove the last element in the sorted set. Streams, on the other hand, are allowed to stay at zero elements, both as a result of using a **MAXLEN** option with a count of zero ([`XADD`]({{< relref "/commands/xadd" >}}) and [`XTRIM`]({{< relref "/commands/xtrim" >}}) commands), or because [`XDEL`]({{< relref "/commands/xdel" >}}) was called.
+
+The reason why such an asymmetry exists is because Streams may have associated consumer groups, and we do not want to lose the state that the consumer groups defined just because there are no longer any items in the stream. Currently the stream is not deleted even when it has no associated consumer groups.
+
+## Total latency of consuming a message
+
+Non blocking stream commands like [`XRANGE`]({{< relref "/commands/xrange" >}}) and [`XREAD`]({{< relref "/commands/xread" >}}) or [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) without the BLOCK option are served synchronously like any other Redis command, so to discuss latency of such commands is meaningless: it is more interesting to check the time complexity of the commands in the Redis documentation. It should be enough to say that stream commands are at least as fast as sorted set commands when extracting ranges, and that [`XADD`]({{< relref "/commands/xadd" >}}) is very fast and can easily insert from half a million to one million items per second in an average machine if pipelining is used.
+
+However latency becomes an interesting parameter if we want to understand the delay of processing a message, in the context of blocking consumers in a consumer group, from the moment the message is produced via [`XADD`]({{< relref "/commands/xadd" >}}), to the moment the message is obtained by the consumer because [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) returned with the message.
+
+## How serving blocked consumers works
+
+Before providing the results of performed tests, it is interesting to understand what model Redis uses in order to route stream messages (and in general actually how any blocking operation waiting for data is managed).
+
+* The blocked client is referenced in a hash table that maps keys for which there is at least one blocking consumer, to a list of consumers that are waiting for such key. This way, given a key that received data, we can resolve all the clients that are waiting for such data.
+* When a write happens, in this case when the [`XADD`]({{< relref "/commands/xadd" >}}) command is called, it calls the `signalKeyAsReady()` function. This function will put the key into a list of keys that need to be processed, because such keys may have new data for blocked consumers. Note that such *ready keys* will be processed later, so in the course of the same event loop cycle, it is possible that the key will receive other writes.
+* Finally, before returning into the event loop, the *ready keys* are finally processed. For each key the list of clients waiting for data is scanned, and if applicable, such clients will receive the new data that arrived. In the case of streams the data is the messages in the applicable range requested by the consumer.
+
+As you can see, basically, before returning to the event loop both the client calling [`XADD`]({{< relref "/commands/xadd" >}}) and the clients blocked to consume messages, will have their reply in the output buffers, so the caller of [`XADD`]({{< relref "/commands/xadd" >}}) should receive the reply from Redis at about the same time the consumers will receive the new messages.
+
+This model is *push-based*, since adding data to the consumers buffers will be performed directly by the action of calling [`XADD`]({{< relref "/commands/xadd" >}}), so the latency tends to be quite predictable.
+
+## Latency tests results
+
+In order to check these latency characteristics a test was performed using multiple instances of Ruby programs pushing messages having as an additional field the computer millisecond time, and Ruby programs reading the messages from the consumer group and processing them. The message processing step consisted of comparing the current computer time with the message timestamp, in order to understand the total latency.
+
+Results obtained:
+
+```
+Processed between 0 and 1 ms -> 74.11%
+Processed between 1 and 2 ms -> 25.80%
+Processed between 2 and 3 ms -> 0.06%
+Processed between 3 and 4 ms -> 0.01%
+Processed between 4 and 5 ms -> 0.02%
+```
+
+So 99.9% of requests have a latency <= 2 milliseconds, with the outliers that remain still very close to the average.
+
+Adding a few million unacknowledged messages to the stream does not change the gist of the benchmark, with most queries still processed with very short latency.
+
+A few remarks:
+
+* Here we processed up to 10k messages per iteration, this means that the `COUNT` parameter of [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) was set to 10000. This adds a lot of latency but is needed in order to allow the slow consumers to be able to keep with the message flow. So you can expect a real world latency that is a lot smaller.
+* The system used for this benchmark is very slow compared to today's standards.
+
+
+
+
+## Learn more
+
+* The [Redis Streams Tutorial]({{< relref "/develop/data-types/streams" >}}) explains Redis streams with many examples.
+* [Redis Streams Explained](https://www.youtube.com/watch?v=Z8qcpXyMAiA) is an entertaining introduction to streams in Redis.
+* [Redis University's RU202](https://university.redis.com/courses/ru202/) is a free, online course dedicated to Redis Streams.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis lists
+
+  '
+linkTitle: Lists
+title: Redis lists
+weight: 20
+---
+
+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`]({{< relref "/commands/lpush" >}}) adds a new element to the head of a list; [`RPUSH`]({{< relref "/commands/rpush" >}}) adds to the tail.
+* [`LPOP`]({{< relref "/commands/lpop" >}}) removes and returns an element from the head of a list; [`RPOP`]({{< relref "/commands/rpop" >}}) does the same but from the tails of a list. 
+* [`LLEN`]({{< relref "/commands/llen" >}}) returns the length of a list.
+* [`LMOVE`]({{< relref "/commands/lmove" >}}) atomically moves elements from one list to another.
+* [`LRANGE`]({{< relref "/commands/lrange" >}}) extracts a range of elements from a list.
+* [`LTRIM`]({{< relref "/commands/ltrim" >}}) reduces a list to the specified range of elements.
+
+### Blocking commands
+
+Lists support several blocking commands.
+For example:
+
+* [`BLPOP`]({{< relref "/commands/blpop" >}}) removes and returns an element from the head of a list.
+  If the list is empty, the command blocks until an element becomes available or until the specified timeout is reached.
+* [`BLMOVE`]({{< relref "/commands/blmove" >}}) atomically moves elements from a source list to a target list.
+  If the source list is empty, the command will block until a new element becomes available.
+
+See the [complete series of list commands]({{< relref "/commands/" >}}?group=list).
+
+## Examples
+
+* Treat a list like a queue (first in, first out):
+{{< clients-example list_tutorial queue >}}
+> LPUSH bikes:repairs bike:1
+(integer) 1
+> LPUSH bikes:repairs bike:2
+(integer) 2
+> RPOP bikes:repairs
+"bike:1"
+> RPOP bikes:repairs
+"bike:2"
+{{< /clients-example >}}
+
+* Treat a list like a stack (first in, last out):
+{{< clients-example list_tutorial stack >}}
+> LPUSH bikes:repairs bike:1
+(integer) 1
+> LPUSH bikes:repairs bike:2
+(integer) 2
+> LPOP bikes:repairs
+"bike:2"
+> LPOP bikes:repairs
+"bike:1"
+{{< /clients-example >}}
+
+* Check the length of a list:
+{{< clients-example list_tutorial llen >}}
+> LLEN bikes:repairs
+(integer) 0
+{{< /clients-example >}}
+
+* Atomically pop an element from one list and push to another:
+{{< clients-example list_tutorial lmove_lrange >}}
+> LPUSH bikes:repairs bike:1
+(integer) 1
+> LPUSH bikes:repairs bike:2
+(integer) 2
+> LMOVE bikes:repairs bikes:finished LEFT LEFT
+"bike:2"
+> LRANGE bikes:repairs 0 -1
+1) "bike:1"
+> LRANGE bikes:finished 0 -1
+1) "bike:2"
+{{< /clients-example >}}
+
+* To limit the length of a list you can call [`LTRIM`]({{< relref "/commands/ltrim" >}}):
+{{< clients-example list_tutorial ltrim.1 >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3 bike:4 bike:5
+(integer) 5
+> LTRIM bikes:repairs 0 2
+OK
+> LRANGE bikes:repairs 0 -1
+1) "bike:1"
+2) "bike:2"
+3) "bike:3"
+{{< /clients-example >}}
+
+### What are Lists?
+To explain the List data type it's better to start with a little bit of theory,
+as the term *List* is often used in an improper way by information technology
+folks. For instance "Python Lists" are not what the name may suggest (Linked
+Lists), but rather Arrays (the same data type is called Array in
+Ruby actually).
+
+From a very general point of view a List is just a sequence of ordered
+elements: 10,20,1,2,3 is a list. But the properties of a List implemented using
+an Array are very different from the properties of a List implemented using a
+*Linked List*.
+
+Redis lists are implemented via Linked Lists. This means that even if you have
+millions of elements inside a list, the operation of adding a new element in
+the head or in the tail of the list is performed *in constant time*. The speed of adding a
+new element with the [`LPUSH`]({{< relref "/commands/lpush" >}}) command to the head of a list with ten
+elements is the same as adding an element to the head of list with 10
+million elements.
+
+What's the downside? Accessing an element *by index* is very fast in lists
+implemented with an Array (constant time indexed access) and not so fast in
+lists implemented by linked lists (where the operation requires an amount of
+work proportional to the index of the accessed element).
+
+Redis Lists are implemented with linked lists because for a database system it
+is crucial to be able to add elements to a very long list in a very fast way.
+Another strong advantage, as you'll see in a moment, is that Redis Lists can be
+taken at constant length in constant time.
+
+When fast access to the middle of a large collection of elements is important,
+there is a different data structure that can be used, called sorted sets.
+Sorted sets are covered in the [Sorted sets]({{< relref "/develop/data-types/sorted-sets" >}}) tutorial page.
+
+### First steps with Redis Lists
+
+The [`LPUSH`]({{< relref "/commands/lpush" >}}) command adds a new element into a list, on the
+left (at the head), while the [`RPUSH`]({{< relref "/commands/rpush" >}}) command adds a new
+element into a list, on the right (at the tail). Finally the
+[`LRANGE`]({{< relref "/commands/lrange" >}}) command extracts ranges of elements from lists:
+
+{{< clients-example list_tutorial lpush_rpush >}}
+> RPUSH bikes:repairs bike:1
+(integer) 1
+> RPUSH bikes:repairs bike:2
+(integer) 2
+> LPUSH bikes:repairs bike:important_bike
+(integer) 3
+> LRANGE bikes:repairs 0 -1
+1) "bike:important_bike"
+2) "bike:1"
+3) "bike:2"
+{{< /clients-example >}}
+
+Note that [`LRANGE`]({{< relref "/commands/lrange" >}}) takes two indexes, the first and the last
+element of the range to return. Both the indexes can be negative, telling Redis
+to start counting from the end: so -1 is the last element, -2 is the
+penultimate element of the list, and so forth.
+
+As you can see [`RPUSH`]({{< relref "/commands/rpush" >}}) appended the elements on the right of the list, while
+the final [`LPUSH`]({{< relref "/commands/lpush" >}}) appended the element on the left.
+
+Both commands are *variadic commands*, meaning that you are free to push
+multiple elements into a list in a single call:
+
+{{< clients-example list_tutorial variadic >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3
+(integer) 3
+> LPUSH bikes:repairs bike:important_bike bike:very_important_bike
+> LRANGE bikes:repairs 0 -1
+1) "bike:very_important_bike"
+2) "bike:important_bike"
+3) "bike:1"
+4) "bike:2"
+5) "bike:3"
+{{< /clients-example >}}
+
+An important operation defined on Redis lists is the ability to *pop elements*.
+Popping elements is the operation of both retrieving the element from the list,
+and eliminating it from the list, at the same time. You can pop elements
+from left and right, similarly to how you can push elements in both sides
+of the list. We'll add three elements and pop three elements, so at the end of this
+sequence of commands the list is empty and there are no more elements to
+pop:
+
+{{< clients-example list_tutorial lpop_rpop >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3
+(integer) 3
+> RPOP bikes:repairs
+"bike:3"
+> LPOP bikes:repairs
+"bike:1"
+> RPOP bikes:repairs
+"bike:2"
+> RPOP bikes:repairs
+(nil)
+{{< /clients-example >}}
+
+Redis returned a NULL value to signal that there are no elements in the
+list.
+
+### Common use cases for lists
+
+Lists are useful for a number of tasks, two very representative use cases
+are the following:
+
+* Remember the latest updates posted by users into a social network.
+* Communication between processes, using a consumer-producer pattern where the producer pushes items into a list, and a consumer (usually a *worker*) consumes those items and executes actions. Redis has special list commands to make this use case both more reliable and efficient.
+
+For example both the popular Ruby libraries [resque](https://github.com/resque/resque) and
+[sidekiq](https://github.com/mperham/sidekiq) use Redis lists under the hood in order to
+implement background jobs.
+
+The popular Twitter social network [takes the latest tweets](http://www.infoq.com/presentations/Real-Time-Delivery-Twitter)
+posted by users into Redis lists.
+
+To describe a common use case step by step, imagine your home page shows the latest
+photos published in a photo sharing social network and you want to speedup access.
+
+* Every time a user posts a new photo, we add its ID into a list with [`LPUSH`]({{< relref "/commands/lpush" >}}).
+* When users visit the home page, we use `LRANGE 0 9` in order to get the latest 10 posted items.
+
+### Capped lists
+
+In many use cases we just want to use lists to store the *latest items*,
+whatever they are: social network updates, logs, or anything else.
+
+Redis allows us to use lists as a capped collection, only remembering the latest
+N items and discarding all the oldest items using the [`LTRIM`]({{< relref "/commands/ltrim" >}}) command.
+
+The [`LTRIM`]({{< relref "/commands/ltrim" >}}) command is similar to [`LRANGE`]({{< relref "/commands/lrange" >}}), but **instead of displaying the
+specified range of elements** it sets this range as the new list value. All
+the elements outside the given range are removed.
+
+For example, if you're adding bikes on the end of a list of repairs, but only
+want to worry about the 3 that have been on the list the longest:
+
+{{< clients-example list_tutorial ltrim >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3 bike:4 bike:5
+(integer) 5
+> LTRIM bikes:repairs 0 2
+OK
+> LRANGE bikes:repairs 0 -1
+1) "bike:1"
+2) "bike:2"
+3) "bike:3"
+{{< /clients-example >}}
+
+The above [`LTRIM`]({{< relref "/commands/ltrim" >}}) command tells Redis to keep just list elements from index
+0 to 2, everything else will be discarded. This allows for a very simple but
+useful pattern: doing a List push operation + a List trim operation together 
+to add a new element and discard elements exceeding a limit. Using 
+[`LTRIM`]({{< relref "/commands/ltrim" >}}) with negative indexes can then be used to keep only the 3 most recently added:
+
+{{< clients-example list_tutorial ltrim_end_of_list >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3 bike:4 bike:5
+(integer) 5
+> LTRIM bikes:repairs -3 -1
+OK
+> LRANGE bikes:repairs 0 -1
+1) "bike:3"
+2) "bike:4"
+3) "bike:5"
+{{< /clients-example >}}
+
+The above combination adds new elements and keeps only the 3
+newest elements into the list. With [`LRANGE`]({{< relref "/commands/lrange" >}}) you can access the top items
+without any need to remember very old data.
+
+Note: while [`LRANGE`]({{< relref "/commands/lrange" >}}) is technically an O(N) command, accessing small ranges
+towards the head or the tail of the list is a constant time operation.
+
+Blocking operations on lists
+---
+
+Lists have a special feature that make them suitable to implement queues,
+and in general as a building block for inter process communication systems:
+blocking operations.
+
+Imagine you want to push items into a list with one process, and use
+a different process in order to actually do some kind of work with those
+items. This is the usual producer / consumer setup, and can be implemented
+in the following simple way:
+
+* To push items into the list, producers call [`LPUSH`]({{< relref "/commands/lpush" >}}).
+* To extract / process items from the list, consumers call [`RPOP`]({{< relref "/commands/rpop" >}}).
+
+However it is possible that sometimes the list is empty and there is nothing
+to process, so [`RPOP`]({{< relref "/commands/rpop" >}}) just returns NULL. In this case a consumer is forced to wait
+some time and retry again with [`RPOP`]({{< relref "/commands/rpop" >}}). This is called *polling*, and is not
+a good idea in this context because it has several drawbacks:
+
+1. Forces Redis and clients to process useless commands (all the requests when the list is empty will get no actual work done, they'll just return NULL).
+2. Adds a delay to the processing of items, since after a worker receives a NULL, it waits some time. To make the delay smaller, we could wait less between calls to [`RPOP`]({{< relref "/commands/rpop" >}}), with the effect of amplifying problem number 1, i.e. more useless calls to Redis.
+
+So Redis implements commands called [`BRPOP`]({{< relref "/commands/brpop" >}}) and [`BLPOP`]({{< relref "/commands/blpop" >}}) which are versions
+of [`RPOP`]({{< relref "/commands/rpop" >}}) and [`LPOP`]({{< relref "/commands/lpop" >}}) able to block if the list is empty: they'll return to
+the caller only when a new element is added to the list, or when a user-specified
+timeout is reached.
+
+This is an example of a [`BRPOP`]({{< relref "/commands/brpop" >}}) call we could use in the worker:
+
+{{< clients-example list_tutorial brpop >}}
+> RPUSH bikes:repairs bike:1 bike:2
+(integer) 2
+> BRPOP bikes:repairs 1
+1) "bikes:repairs"
+2) "bike:2"
+> BRPOP bikes:repairs 1
+1) "bikes:repairs"
+2) "bike:1"
+> BRPOP bikes:repairs 1
+(nil)
+(2.01s)
+{{< /clients-example >}}
+
+It means: "wait for elements in the list `bikes:repairs`, but return if after 1 second
+no element is available".
+
+Note that you can use 0 as timeout to wait for elements forever, and you can
+also specify multiple lists and not just one, in order to wait on multiple
+lists at the same time, and get notified when the first list receives an
+element.
+
+A few things to note about [`BRPOP`]({{< relref "/commands/brpop" >}}):
+
+1. Clients are served in an ordered way: the first client that blocked waiting for a list, is served first when an element is pushed by some other client, and so forth.
+2. The return value is different compared to [`RPOP`]({{< relref "/commands/rpop" >}}): it is a two-element array since it also includes the name of the key, because [`BRPOP`]({{< relref "/commands/brpop" >}}) and [`BLPOP`]({{< relref "/commands/blpop" >}}) are able to block waiting for elements from multiple lists.
+3. If the timeout is reached, NULL is returned.
+
+There are more things you should know about lists and blocking ops. We
+suggest that you read more on the following:
+
+* It is possible to build safer queues or rotating queues using [`LMOVE`]({{< relref "/commands/lmove" >}}).
+* There is also a blocking variant of the command, called [`BLMOVE`]({{< relref "/commands/blmove" >}}).
+
+## Automatic creation and removal of keys
+
+So far in our examples we never had to create empty lists before pushing
+elements, or removing empty lists when they no longer have elements inside.
+It is Redis' responsibility to delete keys when lists are left empty, or to create
+an empty list if the key does not exist and we are trying to add elements
+to it, for example, with [`LPUSH`]({{< relref "/commands/lpush" >}}).
+
+This is not specific to lists, it applies to all the Redis data types
+composed of multiple elements -- Streams, Sets, Sorted Sets and Hashes.
+
+Basically we can summarize the behavior with three rules:
+
+1. When we add an element to an aggregate data type, if the target key does not exist, an empty aggregate data type is created before adding the element.
+2. When we remove elements from an aggregate data type, if the value remains empty, the key is automatically destroyed. The Stream data type is the only exception to this rule.
+3. Calling a read-only command such as [`LLEN`]({{< relref "/commands/llen" >}}) (which returns the length of the list), or a write command removing elements, with an empty key, always produces the same result as if the key is holding an empty aggregate type of the type the command expects to find.
+
+Examples of rule 1:
+
+{{< clients-example list_tutorial rule_1 >}}
+> DEL new_bikes
+(integer) 0
+> LPUSH new_bikes bike:1 bike:2 bike:3
+(integer) 3
+{{< /clients-example >}}
+
+However we can't perform operations against the wrong type if the key exists:
+
+{{< clients-example list_tutorial rule_1.1 >}}
+> SET new_bikes bike:1
+OK
+> TYPE new_bikes
+string
+> LPUSH new_bikes bike:2 bike:3
+(error) WRONGTYPE Operation against a key holding the wrong kind of value
+{{< /clients-example >}}
+
+Example of rule 2:
+
+{{< clients-example list_tutorial rule_2 >}}
+> RPUSH bikes:repairs bike:1 bike:2 bike:3
+(integer) 3
+> EXISTS bikes:repairs
+(integer) 1
+> LPOP bikes:repairs
+"bike:3"
+> LPOP bikes:repairs
+"bike:2"
+> LPOP bikes:repairs
+"bike:1"
+> EXISTS bikes:repairs
+(integer) 0
+{{< /clients-example >}}
+
+The key no longer exists after all the elements are popped.
+
+Example of rule 3:
+
+{{< clients-example list_tutorial rule_3 >}}
+> DEL bikes:repairs
+(integer) 0
+> LLEN bikes:repairs
+(integer) 0
+> LPOP bikes:repairs
+(nil)
+{{< /clients-example >}}
+
+
+## Limits
+
+The max length of a Redis list is 2^32 - 1 (4,294,967,295) elements.
+
+
+## Performance
+
+List operations that access its head or tail are O(1), which means they're highly efficient.
+However, commands that manipulate elements within a list are usually O(n).
+Examples of these include [`LINDEX`]({{< relref "/commands/lindex" >}}), [`LINSERT`]({{< relref "/commands/linsert" >}}), and [`LSET`]({{< relref "/commands/lset" >}}).
+Exercise caution when running these commands, mainly when operating on large lists.
+
+## Alternatives
+
+Consider [Redis streams]({{< relref "/develop/data-types/streams" >}}) as an alternative to lists when you need to store and process an indeterminate series of events.
+
+## Learn more
+
+* [Redis Lists Explained](https://www.youtube.com/watch?v=PB5SeOkkxQc) is a short, comprehensive video explainer on Redis lists.
+* [Redis University's RU101](https://university.redis.com/courses/ru101/) covers Redis lists in detail.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Debugging memory consumption
+linkTitle: Memory Usage
+title: Redis JSON RAM Usage
+weight: 6
+---
+
+{{< 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.
+{{< /note >}}
+
+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 JSON stores JSON values as binary data after deserialization. This representation is often more
+expensive, size-wise, than the serialized form. All JSON values occupy at least 8 bytes (on 64-bit architectures) because each is represented as a thin wrapper around a pointer. The type information is stored in the lower bits of the pointer, which are guaranteed to be zero due to alignment restrictions. This allows those bits to be repurposed to store some auxiliary data.
+
+For some types of JSON values, 8 bytes is all that’s needed. Nulls and booleans don’t require any additional storage. Small integers are stored in static memory because they’re frequently used, so they also use only the initial 8 bytes. Similarly, empty strings, arrays, and objects don’t require any bookkeeping. Instead, they point to static instances of a _null_ string, array, or object. Here are some examples that use the [JSON.DEBUG MEMORY]({{< relref "/commands/json.debug-memory" >}}) command to report on memory consumption:
+
+```
+127.0.0.1:6379> JSON.SET boolean . 'true'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY boolean
+(integer) 8
+
+127.0.0.1:6379> JSON.SET null . null
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY null
+(integer) 8
+
+127.0.0.1:6379> JSON.SET emptystring . '""'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY emptystring
+(integer) 8
+
+127.0.0.1:6379> JSON.SET emptyarr . '[]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY emptyarr
+(integer) 8
+
+127.0.0.1:6379> JSON.SET emptyobj . '{}'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY emptyobj
+(integer) 8
+```
+
+This RAM requirement is the same for all scalar values, but strings require additional space
+depending on their length. For example, a 3-character string will use 3 additional bytes:
+
+```
+127.0.0.1:6379> JSON.SET foo . '"bar"'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY foo
+(integer) 11
+```
+
+In the following four examples, each array requires 56 bytes. This breaks down as:
+- 8 bytes for the initial array value pointer
+- 16 bytes of metadata: 8 bytes for the allocated capacity and 8 bytes for the point-in-time size of the array
+- 32 bytes for the array. The initial capacity of an array is 4. Therefore, the calculation is `4 * 8` bytes
+
+```
+127.0.0.1:6379> JSON.SET arr . '[""]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY arr
+(integer) 56
+```
+
+```
+127.0.0.1:6379> JSON.SET arr . '["", ""]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY arr
+(integer) 56
+```
+
+```
+127.0.0.1:6379> JSON.SET arr . '["", "", ""]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY arr
+(integer) 56
+```
+
+```
+127.0.0.1:6379> JSON.SET arr . '["", "", "", ""]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY arr
+(integer) 56
+```
+
+Once the current capacity is insufficient to fit a new value, the array reallocates to double its capacity. An array with 5 elements will have a capacity of 8, therefore consuming `8 + 16 + 8 * 8 = 88` bytes.
+
+```
+127.0.0.1:6379> JSON.SET arr . '["", "", "", "", ""]'
+OK
+127.0.0.1:6379> JSON.DEBUG MEMORY arr
+(integer) 88
+```
+
+Because reallocation operations can be expensive, Redis grows JSON arrays geometrically rather than linearly. This approach spreads the cost across many insertions.
+
+This table gives the size (in bytes) of a few of the test files from the [module repo](https://github.com/RedisJSON/RedisJSON/tree/master/tests/files), stored using
+JSON. The _MessagePack_ column is for reference purposes and reflects the length of the value when stored using [MessagePack](https://msgpack.org/index.html).
+
+| File                                    | File size | Redis JSON | MessagePack |
+| --------------------------------------- | --------- | ---------- | ----------- |
+| /tests/files/pass-100.json              | 381       | 1069       | 140         |
+| /tests/files/pass-jsonsl-1.json         | 1387      | 2190       | 757         |
+| /tests/files/pass-json-parser-0000.json | 3718      | 5469       | 2393        |
+| /tests/files/pass-jsonsl-yahoo2.json    | 22466     | 26901      | 16869       |
+| /tests/files/pass-jsonsl-yelp.json      | 46333     | 57513      | 35529       |
+
+> Note: In the current version, deleting values from containers **does not** free the container's
+allocated memory.
+
+## JSON string reuse mechanism
+
+Redis uses a global string reuse mechanism to reduce memory usage. When a string value appears multiple times, either within the same JSON document
+or across different documents on the same node, Redis stores only a single copy of that string and uses references to it.
+This approach is especially efficient when many documents share similar structures.
+
+However, the `JSON.DEBUG MEMORY` command reports memory usage as if each string instance is stored independently, even when it's actually reused.
+For example, the document `{"foo": ["foo", "foo"]}` reuses the string `"foo"` internally, but the reported memory usage counts the string three times: once for the key and once for each array element.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Access specific elements within a JSON document
+linkTitle: Path
+title: Path
+weight: 3
+---
+
+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](http://goessner.net/articles/JsonPath/).
+
+JSON supports two query syntaxes: [JSONPath syntax](#jsonpath-syntax) and the [legacy path syntax](#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.
+
+The returned value is a JSON string with a top-level array of JSON serialized strings. 
+And if multi-paths are used, the return value is a JSON string with a top-level object with values that are arrays of serialized JSON values.
+
+## JSONPath support
+
+RedisJSON v2.0 introduced [JSONPath](http://goessner.net/articles/JsonPath/) support. It follows the syntax described by Goessner in his [article](http://goessner.net/articles/JsonPath/).
+
+A JSONPath query can resolve to several locations in a JSON document. In this case, the JSON commands apply the operation to every possible location. This is a major improvement over [legacy path](#legacy-path-syntax) queries, which only operate on the first path.
+
+Notice that the structure of the command response often differs when using JSONPath. See the [Commands]({{< relref "/commands/" >}}?group=json) page for more details.
+
+The new syntax supports bracket notation, which allows the use of special characters like colon ":" or whitespace in key names.
+
+If you want to include double quotes in a query from the CLI, enclose the JSONPath within single quotes. For example:
+
+```bash
+JSON.GET store '$.inventory["mountain_bikes"]'
+```
+
+## JSONPath syntax
+
+The following JSONPath syntax table was adapted from Goessner's [path syntax comparison](https://goessner.net/articles/JsonPath/index.html#e2).
+
+| Syntax&nbsp;element | Description |
+|----------------|-------------|
+| $ | The root (outermost JSON element), starts the path. |
+| . or [] | Selects a child element. |
+| .. | Recursively descends through the JSON document. |
+| * | Wildcard, returns all elements. |
+| [] | Subscript operator, accesses an array element. |
+| [,] | Union, selects multiple elements. |
+| [start\:end\:step] | Array slice where *start*, *end*, and *step* are index values. You can omit values from the slice (for example, `[3:]`, `[:8:2]`) to use the default values: *start* defaults to the first index, *end* defaults to the last index, and *step* defaults to `1`. Use `[*]` or `[:]` to select all elements. |
+| ?() | Filters a JSON object or array. Supports comparison operators <nobr>(`==`, `!=`, `<`, `<=`, `>`, `>=`, `=~`)</nobr>, logical operators <nobr>(`&&`, `\|\|`)</nobr>, and parenthesis <nobr>(`(`, `)`)</nobr>. |
+| () | Script expression. |
+| @ | The current element, used in filter or script expressions. |
+
+## JSONPath examples
+
+The following JSONPath examples use this JSON document, which stores details about items in a store's inventory:
+
+```json
+{
+    "inventory": {
+        "mountain_bikes": [
+            {
+                "id": "bike:1",
+                "model": "Phoebe",
+                "description": "This is a mid-travel trail slayer that is a fantastic daily driver or one bike quiver. The Shimano Claris 8-speed groupset gives plenty of gear range to tackle hills and there\u2019s room for mudguards and a rack too.  This is the bike for the rider who wants trail manners with low fuss ownership.",
+                "price": 1920,
+                "specs": {"material": "carbon", "weight": 13.1},
+                "colors": ["black", "silver"],
+            },
+            {
+                "id": "bike:2",
+                "model": "Quaoar",
+                "description": "Redesigned for the 2020 model year, this bike impressed our testers and is the best all-around trail bike we've ever tested. The Shimano gear system effectively does away with an external cassette, so is super low maintenance in terms of wear and tear. All in all it's an impressive package for the price, making it very competitive.",
+                "price": 2072,
+                "specs": {"material": "aluminium", "weight": 7.9},
+                "colors": ["black", "white"],
+            },
+            {
+                "id": "bike:3",
+                "model": "Weywot",
+                "description": "This bike gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. A set of powerful Shimano hydraulic disc brakes provide ample stopping ability. If you're after a budget option, this is one of the best bikes you could get.",
+                "price": 3264,
+                "specs": {"material": "alloy", "weight": 13.8},
+            },
+        ],
+        "commuter_bikes": [
+            {
+                "id": "bike:4",
+                "model": "Salacia",
+                "description": "This bike is a great option for anyone who just wants a bike to get about on With a slick-shifting Claris gears from Shimano\u2019s, this is a bike which doesn\u2019t break the bank and delivers craved performance.  It\u2019s for the rider who wants both efficiency and capability.",
+                "price": 1475,
+                "specs": {"material": "aluminium", "weight": 16.6},
+                "colors": ["black", "silver"],
+            },
+            {
+                "id": "bike:5",
+                "model": "Mimas",
+                "description": "A real joy to ride, this bike got very high scores in last years Bike of the year report. The carefully crafted 50-34 tooth chainset and 11-32 tooth cassette give an easy-on-the-legs bottom gear for climbing, and the high-quality Vittoria Zaffiro tires give balance and grip.It includes a low-step frame , our memory foam seat, bump-resistant shocks and conveniently placed thumb throttle. Put it all together and you get a bike that helps redefine what can be done for this price.",
+                "price": 3941,
+                "specs": {"material": "alloy", "weight": 11.6},
+            },
+        ],
+    }
+}
+```
+
+First, create the JSON document in your database:
+
+{{< clients-example json_tutorial set_bikes >}}
+JSON.SET bikes:inventory $ '{ "inventory": { "mountain_bikes": [ { "id": "bike:1", "model": "Phoebe", "description": "This is a mid-travel trail slayer that is a fantastic daily driver or one bike quiver. The Shimano Claris 8-speed groupset gives plenty of gear range to tackle hills and there\'s room for mudguards and a rack too. This is the bike for the rider who wants trail manners with low fuss ownership.", "price": 1920, "specs": {"material": "carbon", "weight": 13.1}, "colors": ["black", "silver"] }, { "id": "bike:2", "model": "Quaoar", "description": "Redesigned for the 2020 model year, this bike impressed our testers and is the best all-around trail bike we\'ve ever tested. The Shimano gear system effectively does away with an external cassette, so is super low maintenance in terms of wear and tear. All in all it\'s an impressive package for the price, making it very competitive.", "price": 2072, "specs": {"material": "aluminium", "weight": 7.9}, "colors": ["black", "white"] }, { "id": "bike:3", "model": "Weywot", "description": "This bike gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. A set of powerful Shimano hydraulic disc brakes provide ample stopping ability. If you\'re after a budget option, this is one of the best bikes you could get.", "price": 3264, "specs": {"material": "alloy", "weight": 13.8} } ], "commuter_bikes": [ { "id": "bike:4", "model": "Salacia", "description": "This bike is a great option for anyone who just wants a bike to get about on With a slick-shifting Claris gears from Shimano\'s, this is a bike which doesn\'t break the bank and delivers craved performance. It\'s for the rider who wants both efficiency and capability.", "price": 1475, "specs": {"material": "aluminium", "weight": 16.6}, "colors": ["black", "silver"] }, { "id": "bike:5", "model": "Mimas", "description": "A real joy to ride, this bike got very high scores in last years Bike of the year report. The carefully crafted 50-34 tooth chainset and 11-32 tooth cassette give an easy-on-the-legs bottom gear for climbing, and the high-quality Vittoria Zaffiro tires give balance and grip.It includes a low-step frame , our memory foam seat, bump-resistant shocks and conveniently placed thumb throttle. Put it all together and you get a bike that helps redefine what can be done for this price.", "price": 3941, "specs": {"material": "alloy", "weight": 11.6} } ] }}'
+{{< /clients-example >}}
+
+### Access examples
+
+The following examples use the [`JSON.GET`]({{< relref "commands/json.get/" >}}) command to retrieve data from various paths in the JSON document.
+
+You can use the wildcard operator `*` to return a list of all items in the inventory:
+
+{{< clients-example json_tutorial get_bikes >}}
+JSON.GET bikes:inventory $.inventory.*
+"[[{\"id\":\"bike:1\",\"model\":\"Phoebe\",\"description\":\"This is a mid-travel trail slayer...
+{{< /clients-example >}}
+
+For some queries, multiple paths can produce the same results. For example, the following paths return the names of all mountain bikes:
+
+{{< clients-example json_tutorial get_mtnbikes >}}
+> JSON.GET bikes:inventory $.inventory.mountain_bikes[*].model
+"[\"Phoebe\",\"Quaoar\",\"Weywot\"]"
+> JSON.GET bikes:inventory '$.inventory["mountain_bikes"][*].model'
+"[\"Phoebe\",\"Quaoar\",\"Weywot\"]"
+> JSON.GET bikes:inventory '$..mountain_bikes[*].model'
+"[\"Phoebe\",\"Quaoar\",\"Weywot\"]"
+{{< /clients-example >}}
+
+The recursive descent operator `..` can retrieve a field from multiple sections of a JSON document. The following example returns the names of all inventory items:
+
+{{< clients-example json_tutorial get_models >}}
+> JSON.GET bikes:inventory $..model
+"[\"Phoebe\",\"Quaoar\",\"Weywot\",\"Salacia\",\"Mimas\"]"
+{{< /clients-example >}}
+
+You can use an array slice to select a range of elements from an array. This example returns the names of the first 2 mountain bikes:
+
+{{< clients-example json_tutorial get2mtnbikes >}}
+> JSON.GET bikes:inventory $..mountain_bikes[0:2].model
+"[\"Phoebe\",\"Quaoar\"]"
+{{< /clients-example >}}
+
+Filter expressions `?()` let you select JSON elements based on certain conditions. You can use comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`, and starting with version v2.4.2, also `=~`), logical operators (`&&`, `||`), and parenthesis (`(`, `)`) within these expressions. A filter expression can be applied on an array or on an object, iterating over all the **elements** in the array or all the **values** in the object, retrieving only the ones that match the filter condition. 
+
+Paths within the filter condition use the dot notation with either `@` to denote the current array element or the current object value, or `$` to denote the top-level element. For example, use `@.key_name` to refer to a nested value and `$.top_level_key_name` to refer to a top-level value.
+
+From version v2.4.2 onward, you can use the comparison operator `=~` to match a path of a string value on the left side against a regular expression pattern on the right side. For more information, see the [supported regular expression syntax docs](https://docs.rs/regex/latest/regex/#syntax).
+
+Non-string values do not match. A match can only occur when the left side is a path of a string value and the right side is either a hard-coded string, or a path of a string value. See [examples](#json-filter-examples) below.
+
+The regex match is partial, meaning a regex pattern like `"foo"` matches a string such as `"barefoots"`.
+To make the match exact, use the regex pattern `"^foo$"`.
+
+Other JSONPath engines may use regex patterns between slashes (for example, `/foo/`),
+and their match is exact. They can perform partial matches using a regex pattern such
+as `/.*foo.*/`.
+
+### Filter examples
+
+In the following example, the filter only returns mountain bikes with a price less than 3000 and
+a weight less than 10:
+
+{{< clients-example json_tutorial filter1 >}}
+> JSON.GET bikes:inventory '$..mountain_bikes[?(@.price < 3000 && @.specs.weight < 10)]'
+"[{\"id\":\"bike:2\",\"model\":\"Quaoar\",\"description\":\"Redesigned for the 2020 model year...
+{{< /clients-example >}}
+
+This example filters the inventory for the model names of bikes made from alloy:
+
+{{< clients-example json_tutorial filter2 >}}
+> JSON.GET bikes:inventory '$..[?(@.specs.material == "alloy")].model'
+"[\"Weywot\",\"Mimas\"]"
+{{< /clients-example >}}
+
+This example, valid from version v2.4.2 onwards, filters only bikes whose material begins with
+"al-" using regex match. Note that this match is case-insensitive because of the prefix `(?i)` in
+the regular expression pattern `"(?i)al"`:
+
+{{< clients-example json_tutorial filter3 >}}
+JSON.GET bikes:inventory '$..[?(@.specs.material =~ "(?i)al")].model'
+"[\"Quaoar\",\"Weywot\",\"Salacia\",\"Mimas\"]"
+{{< /clients-example >}}
+
+You can also specify a regex pattern using a property from the JSON object itself.
+For example, we can add a string property named `regex_pat` to each mountain bike,
+with the value `"(?i)al"` to match the material, as in the previous example. We
+can then match `regex_pat` against the bike's material: 
+
+{{< clients-example json_tutorial filter4 >}}
+> JSON.SET bikes:inventory $.inventory.mountain_bikes[0].regex_pat '"(?i)al"'
+OK
+> JSON.SET bikes:inventory $.inventory.mountain_bikes[1].regex_pat '"(?i)al"'
+OK
+> JSON.SET bikes:inventory $.inventory.mountain_bikes[2].regex_pat '"(?i)al"'
+OK
+> JSON.GET bikes:inventory '$.inventory.mountain_bikes[?(@.specs.material =~ @.regex_pat)].model'
+"[\"Quaoar\",\"Weywot\"]"
+{{< /clients-example >}}
+
+### Update examples
+
+You can also use JSONPath queries when you want to update specific sections of a JSON document.
+
+For example, you can pass a JSONPath to the [`JSON.SET`]({{< relref "commands/json.set/" >}}) command to update a specific field. This example changes the price of the first item in the headphones list:
+
+{{< clients-example json_tutorial update_bikes >}}
+> JSON.GET bikes:inventory $..price
+"[1920,2072,3264,1475,3941]"
+> JSON.NUMINCRBY bikes:inventory $..price -100
+"[1820,1972,3164,1375,3841]"
+> JSON.NUMINCRBY bikes:inventory $..price 100
+"[1920,2072,3264,1475,3941]"
+{{< /clients-example >}}
+
+You can use filter expressions to update only JSON elements that match certain conditions. The following example sets the price of any bike to 1500 if its price is already less than 2000:
+
+{{< clients-example json_tutorial update_filters1 >}}
+> JSON.SET bikes:inventory '$.inventory.*[?(@.price<2000)].price' 1500
+OK
+> JSON.GET bikes:inventory $..price
+"[1500,2072,3264,1500,3941]"
+{{< /clients-example >}}
+
+JSONPath queries also work with other JSON commands that accept a path as an argument. For example, you can add a new color option for a set of headphones with [`JSON.ARRAPPEND`]({{< relref "commands/json.arrappend/" >}}):
+
+{{< clients-example json_tutorial update_filters2 >}}
+> JSON.ARRAPPEND bikes:inventory '$.inventory.*[?(@.price<2000)].colors' '"pink"'
+1) (integer) 3
+2) (integer) 3
+127.0.0.1:6379> JSON.GET bikes:inventory $..[*].colors
+"[[\"black\",\"silver\",\"pink\"],[\"black\",\"white\"],[\"black\",\"silver\",\"pink\"]]"
+{{< /clients-example >}}
+
+## Legacy path syntax
+
+RedisJSON v1 had the following path implementation. JSON v2 still supports this legacy path in addition to JSONPath.
+
+Paths always begin at the root of a Redis JSON value. The root is denoted by a period character (`.`). For paths that reference the root's children, it is optional to prefix the path with the root.
+
+Redis JSON supports both dot notation and bracket notation for object key access. The following paths refer to _headphones_, which is a child of _inventory_ under the root:
+
+*   `.inventory.headphones`
+*   `inventory["headphones"]`
+*   `['inventory']["headphones"]`
+
+To access an array element, enclose its index within a pair of square brackets. The index is 0-based, with 0 being the first element of the array, 1 being the next element, and so on. You can use negative offsets to access elements starting from the end of the array. For example, -1 is the last element in the array, -2 is the second to last element, and so on.
+
+### JSON key names and path compatibility
+
+By definition, a JSON key can be any valid JSON string. Paths, on the other hand, are traditionally based on JavaScript's (and Java's) variable naming conventions.
+
+Although JSON can store objects that contain arbitrary key names, you can only use a legacy path to access these keys if they conform to these naming syntax rules:
+
+1.  Names must begin with a letter, a dollar sign (`$`), or an underscore (`_`) character
+2.  Names can contain letters, digits, dollar signs, and underscores
+3.  Names are case-sensitive
+
+## Time complexity of path evaluation
+
+The time complexity of searching (navigating to) an element in the path is calculated from:
+
+1. Child level - every level along the path adds an additional search
+2. Key search - O(N)<sup>&#8224;</sup>, where N is the number of keys in the parent object
+3. Array search - O(1)
+
+This means that the overall time complexity of searching a path is _O(N*M)_, where N is the depth and M is the number of parent object keys.
+
+<sup>&#8224;</sup> While this is acceptable for objects where N is small, access can be optimized for larger objects.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'JSON use cases
+
+  '
+linkTitle: Use cases
+title: Use cases
+weight: 4
+---
+
+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.
+
+**Atomic partial updates**
+
+JSON allows you to atomically run operations like incrementing a value, adding, or removing elements from an array, append strings, and so on. To do the same with a serialized object, you have to retrieve and then reserialize the entire object, which can be expensive and also lack atomicity.
+
+**Indexing and querying**
+
+When you store JSON objects as Redis strings, there's no good way to query those objects. On the other hand, storing these objects as JSON using Redis Open Source lets you index and query them. This capability is provided by the Redis Query Engine.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Notes on JSON debugging, testing and documentation.'
+linkTitle: Developer notes
+title: Developer notes
+weight: 7
+---
+
+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:
+```sh
+git clone --recursive https://github.com/RedisJSON/RedisJSON.git
+```
+## Working in an isolated environment
+There are several reasons to use an isolated environment for development, like keeping your workstation clean and developing for a different Linux distribution.
+
+You can use a virtual machine as an isolated development environment. To set one up, you can use [Vagrant](https://www.vagrantup.com) or Docker.
+
+To set up a virtual machine with Docker:
+
+```
+rejson=$(docker run -d -it -v $PWD:/build debian:bullseye bash)
+docker exec -it $rejson bash
+```
+Then run ```cd /build``` from within the container.
+
+In this mode, all installations remain in the scope of the Docker container.
+After you exit the container, you can either restart it with the previous ```docker exec``` command or save the state of the container to an image and resume it at a later time:
+
+```
+docker commit $rejson redisjson1
+docker stop $rejson
+rejson=$(docker run -d -it -v $PWD:/build redisjson1 bash)
+docker exec -it $rejson bash
+```
+
+You can replace `debian:bullseye` with your OS of choice. If you use the same OS as your host machine, you can run the RedisJSON binary on your host after it is built.
+
+## Installing prerequisites
+
+To build and test RedisJSON one needs to install several packages, depending on the underlying OS. Currently, we support the Ubuntu/Debian, CentOS, Fedora, and macOS.
+
+Enter the `RedisJSON` directory and run:
+
+```sh
+$ ./sbin/setup
+```
+
+**This will install various packages on your system** using the native package manager and pip. It will invoke `sudo` on its own, prompting for permission.
+
+If you prefer to avoid that, you can:
+
+* Review `system-setup.py` and install packages manually,
+* Use `system-setup.py --nop` to display installation commands without executing them,
+* Use an isolated environment like explained above,
+* Use a Python virtual environment, as Python installations are known to be sensitive when not used in isolation: `python -m virtualenv venv; . ./venv/bin/activate`
+
+## Installing Redis
+Generally, it is best to run the latest Redis version.
+
+If your OS has a Redis 6.x package, you can install it using the OS package manager.
+
+Otherwise, you can invoke
+```sh
+$ ./deps/readies/bin/getredis
+```
+
+## Getting help
+```make help``` provides a quick summary of the development features:
+
+```
+make setup         # install prerequisites
+
+make build
+  DEBUG=1          # build debug variant
+  SAN=type         # build with LLVM sanitizer (type=address|memory|leak|thread)
+  VALGRIND|VG=1    # build for testing with Valgrind
+make clean         # remove binary files
+  ALL=1            # remove binary directories
+
+make all           # build all libraries and packages
+
+make test          # run both cargo and python tests
+make cargo_test    # run inbuilt rust unit tests
+make pytest        # run flow tests using RLTest
+  TEST=file:name     # run test matching `name` from `file`
+  TEST_ARGS="..."    # RLTest arguments
+  QUICK=1            # run only general tests
+  GEN=1              # run general tests on a standalone Redis topology
+  AOF=1              # run AOF persistency tests on a standalone Redis topology
+  SLAVES=1           # run replication tests on standalone Redis topology
+  CLUSTER=1          # run general tests on a Redis Open Source Cluster topology
+  VALGRIND|VG=1      # run specified tests with Valgrind
+  VERBOSE=1          # display more RLTest-related information
+
+make pack          # build package (RAMP file)
+make upload-artifacts   # copy snapshot packages to S3
+  OSNICK=nick             # copy snapshots for specific OSNICK
+make upload-release     # copy release packages to S3
+
+common options for upload operations:
+  STAGING=1             # copy to staging lab area (for validation)
+  FORCE=1               # allow operation outside CI environment
+  VERBOSE=1             # show more details
+  NOP=1                 # do not copy, just print commands
+
+make coverage      # perform coverage analysis
+make show-cov      # show coverage analysis results (implies COV=1)
+make upload-cov    # upload coverage analysis results to codecov.io (implies COV=1)
+
+make docker        # build for specific Linux distribution
+  OSNICK=nick        # Linux distribution to build for
+  REDIS_VER=ver      # use Redis version `ver`
+  TEST=1             # test after build
+  PACK=1             # create packages
+  ARTIFACTS=1        # copy artifacts from docker image
+  PUBLISH=1          # publish (i.e. docker push) after build
+
+make sanbox        # create container for CLang Sanitizer tests
+```
+
+## Building from source
+Run ```make build``` to build RedisJSON.
+
+Notes:
+
+* Binary files are placed under `target/release/`, according to platform and build variant.
+
+* RedisJSON uses [Cargo](https://github.com/rust-lang/cargo) as its build system. ```make build``` will invoke both Cargo and the subsequent `make` command that's required to complete the build.
+
+Use ```make clean``` to remove built artifacts. ```make clean ALL=1``` will remove the entire bin subdirectory.
+
+## Running tests
+There are several sets of unit tests:
+* Rust tests, integrated in the source code, run by ```make cargo_test```.
+* Python tests (enabled by RLTest), located in ```tests/pytests```, run by ```make pytest```.
+
+You can run all tests with ```make test```.
+To run only specific tests, use the ```TEST``` parameter. For example, run ```make test TEST=regex```.
+
+You can run the module's tests against an "embedded" disposable Redis instance or against an instance
+you provide. To use the "embedded" mode, you must include the `redis-server` executable in your `PATH`.
+
+You can override the spawning of the embedded server by specifying a Redis port via the `REDIS_PORT`
+environment variable, e.g.:
+
+```bash
+$ # use an existing local Redis instance for testing the module
+$ REDIS_PORT=6379 make test
+```
+
+## Debugging
+To include debugging information, you need to set the [`DEBUG`]({{< relref "/commands/debug" >}}) environment variable before you compile RedisJSON. For example, run `export DEBUG=1`.
+
+You can add breakpoints to Python tests in single-test mode. To set a breakpoint, call the ```BB()``` function inside a test.
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: JSON RESP2 to RESP3 replies reference for client developers
+linkTitle: RESP3 migration guide
+title: Guide for migrating from RESP2 to RESP3 replies
+weight: 6
+---
+
+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](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html). `Array<a>` denotes an [array](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#arrays) where the type of elements is known, but the number of elements is not.
+
+| Command                                                                                                                                                 | RESP2                                                                                                                                                                                            | RESP3                                                                                                                                                                                                               |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| All JSON commands                                                                                                                                       | **Default value of optional `path` argument**: `.`                                                                                                                                               | **Default value of optional `path` argument:** `$`                                                                                                                                                                  |
+| JSON.ARRAPPEND<br/>JSON.ARRINDEX<br/>JSON.ARRINSERT<br/>JSON.ARRLEN<br/>JSON.ARRTRIM<br/>JSON.OBJLEN<br/>JSON.STRAPPEND<br/>JSON.STRLEN<br/>JSON.TOGGLE | *`$`-based path argument:* <br/> Reply: Array\<BulkString &#124; null> <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: BulkString                                                       | *`$`-based path argument:*&nbsp; <br/> Reply: Array\<number &#124; null> <br/><br/> *`.`-based path argument :* <br/> Reply: number                                                                                 |
+| JSON.GET                                                                                                                                                | Reply: JSON encoded string  <br/> Example: <br/> ```> JSON.SET k $ "[1,2,3]"```<br/> ```> JSON.GET k```<br/>```"[1,2,3]"```                                                                      | Reply: JSON encoded string with a top-level array  <br/> Example: <br/> ```> JSON.SET k $ "[1,2,3]"```<br/> ```> JSON.GET k```<br/>```"[[1,2,3]]"```                                                                |
+| JSON.NUMINCRBY<br/>JSON.NUMMULTBY                                                                                                                       | *`$`-based path argument:* <br/> Reply: JSON-encoded BulkString &#124; null <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: BulkString &#124; null &#124; error                         | *`$`-based path argument:* <br/> Reply: Array\<number &#124;  null> &#124; error <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: number &#124;  null &#124; error                                          |
+| JSON.OBJKEYS                                                                                                                                            | *`$`-based path argument:* <br/> Reply: Array\<Array\<BulkString\>> <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: Array\<BulkString>                                                  | *`$`-based path argument:* <br/> Reply: Array\<Array\<BulkString\>> <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: Array\<BulkString>                                                                     |
+| JSON.TYPE                                                                                                                                               | *`$`-based path argument:* <br/> Reply: Array\<BulkString\> <br/> Example: <br />```> JSON.TYPE k $```<br />```1) "array"``` <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: BulkString | *`$`-based path argument:* <br/> Reply: Array\<Array\<BulkString\>> <br/> Example: <br />```> JSON.TYPE k $```<br />```1) 1) "array"``` <br/><br/> *`.`-based path argument :*&nbsp;<br/> Reply: Array\<BulkString> |
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Performance benchmarks
+
+  '
+linkTitle: Performance
+title: Performance
+weight: 5
+---
+
+To get an early sense of what Redis JSON is capable of, you can test it with `redis-benchmark` just like
+any other Redis command. However, in order to have more control over the tests, we'll use a 
+a tool written in Go called _ReJSONBenchmark_ that we expect to release in the near future.
+
+The following figures were obtained from an AWS EC2 c4.8xlarge instance that ran both the Redis
+server as well the as the benchmarking tool. Connections to the server are via the networking stack.
+All tests are non-pipelined.
+
+> NOTE: The results below are measured using the preview version of Redis JSON, which is still very much unoptimized.
+
+## Redis JSON baseline
+
+### A smallish object
+
+We test a JSON value that, while purely synthetic, is interesting. The test subject is
+[/tests/files/pass-100.json](https://github.com/RedisLabsModules/redisjson/blob/master/tests/files/pass-100.json),
+who weighs in at 380 bytes and is nested. We first test SETting it, then GETting it using several
+different paths:
+
+![ReJSONBenchmark pass-100.json](images/bench_pass_100.png)
+
+![ReJSONBenchmark pass-100.json percentiles](images/bench_pass_100_p.png)
+
+### A bigger array
+
+Moving on to bigger values, we use the 1.4 kB array in
+[/tests/files/pass-jsonsl-1.json](https://github.com/RedisLabsModules/redisjson/blob/master/tests/files/pass-jsonsl-1.json):
+
+
+![ReJSONBenchmark pass-jsonsl-1.json](images/bench_pass_jsonsl_1.png)
+
+![ReJSONBenchmark pass-jsonsl-1.json percentiles](images/bench_pass_jsonsl_1_p.png)
+
+### A largish object
+
+More of the same to wrap up, now we'll take on a behemoth of no less than 3.5 kB as given by
+[/tests/files/pass-json-parser-0000.json](https://github.com/RedisLabsModules/redisjson/blob/master/tests/files/pass-json-parser-0000.json):
+
+![ReJSONBenchmark pass-json-parser-0000.json](images/bench_pass_json_parser_0000.png)
+
+![ReJSONBenchmark pass-json-parser-0000.json percentiles](images/bench_pass_json_parser_0000_p.png)
+
+### Number operations
+
+Last but not least, some adding and multiplying:
+
+![ReJSONBenchmark number operations](images/bench_numbers.png)
+
+![ReJSONBenchmark number operations percentiles](images/bench_numbers_p.png)
+
+### Baseline
+
+To establish a baseline, we'll use the Redis [`PING`]({{< relref "/commands/ping" >}}) command.
+First, lets see what `redis-benchmark` reports:
+
+```
+~$ redis/src/redis-benchmark -n 1000000 ping
+====== ping ======
+  1000000 requests completed in 7.11 seconds
+  50 parallel clients
+  3 bytes payload
+  keep alive: 1
+
+99.99% <= 1 milliseconds
+100.00% <= 1 milliseconds
+140587.66 requests per second
+```
+
+ReJSONBenchmark's concurrency is configurable, so we'll test a few settings to find a good one. Here
+are the results, which indicate that 16 workers yield the best throughput:
+
+![ReJSONBenchmark PING](images/bench_ping.png)
+
+![ReJSONBenchmark PING percentiles](images/bench_ping_p.png)
+
+Note how our benchmarking tool does slightly worse in PINGing - producing only 116K ops, compared to
+`redis-cli`'s 140K.
+
+### The empty string
+
+Another JSON benchmark is that of setting and getting an empty string - a value that's only two
+bytes long (i.e. `""`). Granted, that's not very useful, but it teaches us something about the basic
+performance of the module:
+
+![ReJSONBenchmark empty string](images/bench_empty_string.png)
+
+![ReJSONBenchmark empty string percentiles](images/bench_empty_string_p.png)
+
+## Comparison vs. server-side Lua scripting
+
+We compare the JSON performance of Redis Open Source with the Redis embedded Lua engine. For this purpose, we use the Lua
+scripts at [/benchmarks/lua](https://github.com/RedisLabsModules/redisjson/tree/master/benchmarks/lua).
+These scripts provide JSON's GET and SET functionality on values stored in JSON or MessagePack
+formats. Each of the different operations (set root, get root, set path and get path) is executed
+with each "engine" on objects of varying sizes. 
+
+### Setting and getting the root
+
+Storing raw JSON performs best in this test, but that isn't really surprising as all it does is
+serve unprocessed strings. While you can and should use Redis for caching opaque data, and JSON
+"blobs" are just one example, this does not allow any updates other than these of the entire value.
+
+A more meaningful comparison therefore is between JSON and the MessagePack variant, since both
+process the incoming JSON value before actually storing it. While the rates and latencies of these 
+two behave in a very similar way, the absolute measurements suggest that Redis JSON's performance may be
+further improved.
+
+![VS. Lua set root](images/bench_lua_set_root.png)
+
+![VS. Lua set root latency](images/bench_lua_set_root_l.png)
+
+![VS. Lua get root](images/bench_lua_get_root.png)
+
+![VS. Lua get root latency](images/bench_lua_get_root_l.png)
+
+### Setting and getting parts of objects
+
+This test shows why Redis JSON exists. Not only does it outperform the Lua variants, it retains constant
+rates and latencies regardless the object's overall size. There's no magic here - JSON keeps the
+value deserialized so that accessing parts of it is a relatively inexpensive operation. In deep contrast
+are both raw JSON as well as MessagePack, which require decoding the entire object before anything can
+be done with it (a process that becomes more expensive the larger the object is).
+
+![VS. Lua set path to scalar](images/bench_lua_set_path.png)
+
+![VS. Lua set path to scalar latency](images/bench_lua_set_path_l.png)
+
+![VS. Lua get scalar from path](images/bench_lua_get_path.png)
+
+![VS. Lua get scalar from path latency](images/bench_lua_get_path_l.png)
+
+### Even more charts
+
+These charts are more of the same but independent for each file (value):
+
+![VS. Lua pass-100.json rate](images/bench_lua_pass_100.png)
+
+![VS. Lua pass-100.json average latency](images/bench_lua_pass_100_l.png)
+
+![VS. Lua pass-jsonsl-1.json rate](images/bench_lua_pass_jsonsl_1.png)
+
+![VS. Lua pass-jsonsl-1.json average latency](images/bench_lua_pass_jsonsl_1_l.png)
+
+![VS. Lua pass-json-parser-0000.json rate](images/bench_lua_pass_json_parser_0000.png)
+
+![VS. Lua pass-json-parser-0000.json latency](images/bench_lua_pass_json_parser_0000_l.png)
+
+![VS. Lua pass-jsonsl-yahoo2.json rate](images/bench_lua_pass_jsonsl_yahoo2.png)
+
+![VS. Lua pass-jsonsl-yahoo2.json latency](images/bench_lua_pass_jsonsl_yahoo2_l.png)
+
+![VS. Lua pass-jsonsl-yelp.json rate](images/bench_lua_pass_jsonsl_yelp.png)
+
+![VS. Lua pass-jsonsl-yelp.json latency](images/bench_lua_pass_jsonsl_yelp_l.png)
+
+## Raw results
+
+The following are the raw results from the benchmark in CSV format.
+
+### JSON results
+
+```
+title,concurrency,rate,average latency,50.00%-tile,90.00%-tile,95.00%-tile,99.00%-tile,99.50%-tile,100.00%-tile
+[ping],1,22128.12,0.04,0.04,0.04,0.05,0.05,0.05,1.83
+[ping],2,54641.13,0.04,0.03,0.05,0.05,0.06,0.07,2.14
+[ping],4,76000.18,0.05,0.05,0.07,0.07,0.09,0.10,2.10
+[ping],8,106750.99,0.07,0.07,0.10,0.11,0.14,0.16,2.99
+[ping],12,111297.33,0.11,0.10,0.15,0.16,0.20,0.22,6.81
+[ping],16,116292.19,0.14,0.13,0.19,0.21,0.27,0.33,7.50
+[ping],20,110622.82,0.18,0.17,0.24,0.27,0.38,0.47,12.21
+[ping],24,107468.51,0.22,0.20,0.31,0.38,0.58,0.71,13.86
+[ping],28,102827.35,0.27,0.25,0.38,0.44,0.66,0.79,12.87
+[ping],32,105733.51,0.30,0.28,0.42,0.50,0.79,0.97,10.56
+[ping],36,102046.43,0.35,0.33,0.48,0.56,0.90,1.13,14.66
+JSON.SET {key} . {empty string size: 2 B},16,80276.63,0.20,0.18,0.28,0.32,0.41,0.45,6.48
+JSON.GET {key} .,16,92191.23,0.17,0.16,0.24,0.27,0.34,0.38,9.80
+JSON.SET {key} . {pass-100.json size: 380 B},16,41512.77,0.38,0.35,0.50,0.62,0.81,0.86,9.56
+JSON.GET {key} .,16,48374.10,0.33,0.29,0.47,0.56,0.72,0.79,9.36
+JSON.GET {key} sclr,16,94801.23,0.17,0.15,0.24,0.27,0.35,0.39,13.21
+JSON.SET {key} sclr 1,16,82032.08,0.19,0.18,0.27,0.31,0.40,0.44,8.97
+JSON.GET {key} sub_doc,16,81633.51,0.19,0.18,0.27,0.32,0.43,0.49,9.88
+JSON.GET {key} sub_doc.sclr,16,95052.35,0.17,0.15,0.24,0.27,0.35,0.39,7.39
+JSON.GET {key} array_of_docs,16,68223.05,0.23,0.22,0.29,0.31,0.44,0.50,8.84
+JSON.GET {key} array_of_docs[1],16,76390.57,0.21,0.19,0.30,0.34,0.44,0.49,9.99
+JSON.GET {key} array_of_docs[1].sclr,16,90202.13,0.18,0.16,0.25,0.29,0.36,0.39,7.87
+JSON.SET {key} . {pass-jsonsl-1.json size: 1.4 kB},16,16117.11,0.99,0.91,1.22,1.55,2.17,2.35,9.27
+JSON.GET {key} .,16,15193.51,1.05,0.94,1.41,1.75,2.33,2.42,7.19
+JSON.GET {key} [0],16,78198.90,0.20,0.19,0.29,0.33,0.42,0.47,10.87
+"JSON.SET {key} [0] ""foo""",16,80156.90,0.20,0.18,0.28,0.32,0.40,0.44,12.03
+JSON.GET {key} [7],16,99013.98,0.16,0.15,0.23,0.26,0.34,0.38,7.67
+JSON.GET {key} [8].zero,16,90562.19,0.17,0.16,0.25,0.28,0.35,0.38,7.03
+JSON.SET {key} . {pass-json-parser-0000.json size: 3.5 kB},16,14239.25,1.12,1.06,1.21,1.48,2.35,2.59,11.91
+JSON.GET {key} .,16,8366.31,1.91,1.86,2.00,2.04,2.92,3.51,12.92
+"JSON.GET {key} [""web-app""].servlet",16,9339.90,1.71,1.68,1.74,1.78,2.68,3.26,10.47
+"JSON.GET {key} [""web-app""].servlet[0]",16,13374.88,1.19,1.07,1.54,1.95,2.69,2.82,12.15
+"JSON.GET {key} [""web-app""].servlet[0][""servlet-name""]",16,81267.36,0.20,0.18,0.28,0.31,0.38,0.42,9.67
+"JSON.SET {key} [""web-app""].servlet[0][""servlet-name""] ""bar""",16,79955.04,0.20,0.18,0.27,0.33,0.42,0.46,6.72
+JSON.SET {key} . {pass-jsonsl.yahoo2-json size: 18 kB},16,3394.07,4.71,4.62,4.72,4.79,7.35,9.03,17.78
+JSON.GET {key} .,16,891.46,17.92,17.33,17.56,20.12,31.77,42.87,66.64
+JSON.SET {key} ResultSet.totalResultsAvailable 1,16,75513.03,0.21,0.19,0.30,0.34,0.42,0.46,9.21
+JSON.GET {key} ResultSet.totalResultsAvailable,16,91202.84,0.17,0.16,0.24,0.28,0.35,0.38,5.30
+JSON.SET {key} . {pass-jsonsl-yelp.json size: 40 kB},16,1624.86,9.84,9.67,9.86,9.94,15.86,19.36,31.94
+JSON.GET {key} .,16,442.55,36.08,35.62,37.78,38.14,55.23,81.33,88.40
+JSON.SET {key} message.code 1,16,77677.25,0.20,0.19,0.28,0.33,0.42,0.45,11.07
+JSON.GET {key} message.code,16,89206.61,0.18,0.16,0.25,0.28,0.36,0.39,8.60
+[JSON.SET num . 0],16,84498.21,0.19,0.17,0.26,0.30,0.39,0.43,8.08
+[JSON.NUMINCRBY num . 1],16,78640.20,0.20,0.18,0.28,0.33,0.44,0.48,11.05
+[JSON.NUMMULTBY num . 2],16,77170.85,0.21,0.19,0.28,0.33,0.43,0.47,6.85
+```
+
+### Lua using cjson
+
+```
+json-set-root.lua empty string,16,86817.84,0.18,0.17,0.26,0.31,0.39,0.42,9.36
+json-get-root.lua,16,90795.08,0.17,0.16,0.25,0.28,0.36,0.39,8.75
+json-set-root.lua pass-100.json,16,84190.26,0.19,0.17,0.27,0.30,0.38,0.41,12.00
+json-get-root.lua,16,87170.45,0.18,0.17,0.26,0.29,0.38,0.45,9.81
+json-get-path.lua sclr,16,54556.80,0.29,0.28,0.35,0.38,0.57,0.64,7.53
+json-set-path.lua sclr 1,16,35907.30,0.44,0.42,0.53,0.67,0.93,1.00,8.57
+json-get-path.lua sub_doc,16,51158.84,0.31,0.30,0.36,0.39,0.50,0.62,7.22
+json-get-path.lua sub_doc sclr,16,51054.47,0.31,0.29,0.39,0.47,0.66,0.74,7.43
+json-get-path.lua array_of_docs,16,39103.77,0.41,0.37,0.57,0.68,0.87,0.94,8.02
+json-get-path.lua array_of_docs 1,16,45811.31,0.35,0.32,0.45,0.56,0.77,0.83,8.17
+json-get-path.lua array_of_docs 1 sclr,16,47346.83,0.34,0.31,0.44,0.54,0.72,0.79,8.07
+json-set-root.lua pass-jsonsl-1.json,16,82100.90,0.19,0.18,0.28,0.31,0.39,0.43,12.43
+json-get-root.lua,16,77922.14,0.20,0.18,0.30,0.34,0.66,0.86,8.71
+json-get-path.lua 0,16,38162.83,0.42,0.40,0.49,0.59,0.88,0.96,6.16
+"json-set-path.lua 0 ""foo""",16,21205.52,0.75,0.70,0.84,1.07,1.60,1.74,5.77
+json-get-path.lua 7,16,37254.89,0.43,0.39,0.55,0.69,0.92,0.98,10.24
+json-get-path.lua 8 zero,16,33772.43,0.47,0.43,0.63,0.77,1.01,1.09,7.89
+json-set-root.lua pass-json-parser-0000.json,16,76314.18,0.21,0.19,0.29,0.33,0.41,0.44,8.16
+json-get-root.lua,16,65177.87,0.24,0.21,0.35,0.42,0.89,1.01,9.02
+json-get-path.lua web-app servlet,16,15938.62,1.00,0.88,1.45,1.71,2.11,2.20,8.07
+json-get-path.lua web-app servlet 0,16,19469.27,0.82,0.78,0.90,1.07,1.67,1.84,7.59
+json-get-path.lua web-app servlet 0 servlet-name,16,24694.26,0.65,0.63,0.71,0.74,1.07,1.31,8.60
+"json-set-path.lua web-app servlet 0 servlet-name ""bar""",16,16555.74,0.96,0.92,1.05,1.25,1.98,2.20,9.08
+json-set-root.lua pass-jsonsl-yahoo2.json,16,47544.65,0.33,0.31,0.41,0.47,0.59,0.64,10.52
+json-get-root.lua,16,25369.92,0.63,0.57,0.91,1.05,1.37,1.56,9.95
+json-set-path.lua ResultSet totalResultsAvailable 1,16,5077.32,3.15,3.09,3.20,3.24,5.12,6.26,14.98
+json-get-path.lua ResultSet totalResultsAvailable,16,7652.56,2.09,2.05,2.13,2.17,3.23,3.95,9.65
+json-set-root.lua pass-jsonsl-yelp.json,16,29575.20,0.54,0.52,0.64,0.75,0.94,1.00,12.66
+json-get-root.lua,16,18424.29,0.87,0.84,1.25,1.40,1.82,1.95,7.35
+json-set-path.lua message code 1,16,2251.07,7.10,6.98,7.14,7.22,11.00,12.79,21.14
+json-get-path.lua message code,16,3380.72,4.73,4.44,5.03,6.82,10.28,11.06,14.93
+```
+
+### Lua using cmsgpack
+
+```
+msgpack-set-root.lua empty string,16,82592.66,0.19,0.18,0.27,0.31,0.38,0.42,10.18
+msgpack-get-root.lua,16,89561.41,0.18,0.16,0.25,0.29,0.37,0.40,9.52
+msgpack-set-root.lua pass-100.json,16,44326.47,0.36,0.34,0.43,0.54,0.78,0.86,6.45
+msgpack-get-root.lua,16,41036.58,0.39,0.36,0.51,0.62,0.84,0.91,7.21
+msgpack-get-path.lua sclr,16,55845.56,0.28,0.26,0.36,0.44,0.64,0.70,11.29
+msgpack-set-path.lua sclr 1,16,43608.26,0.37,0.34,0.47,0.58,0.78,0.85,10.27
+msgpack-get-path.lua sub_doc,16,50153.07,0.32,0.29,0.41,0.50,0.69,0.75,8.56
+msgpack-get-path.lua sub_doc sclr,16,54016.35,0.29,0.27,0.38,0.46,0.62,0.67,6.38
+msgpack-get-path.lua array_of_docs,16,45394.79,0.35,0.32,0.45,0.56,0.78,0.85,11.88
+msgpack-get-path.lua array_of_docs 1,16,48336.48,0.33,0.30,0.42,0.52,0.71,0.76,7.69
+msgpack-get-path.lua array_of_docs 1 sclr,16,53689.41,0.30,0.27,0.38,0.46,0.64,0.69,11.16
+msgpack-set-root.lua pass-jsonsl-1.json,16,28956.94,0.55,0.51,0.65,0.82,1.17,1.26,8.39
+msgpack-get-root.lua,16,26045.44,0.61,0.58,0.68,0.83,1.28,1.42,8.56
+"msgpack-set-path.lua 0 ""foo""",16,29813.56,0.53,0.49,0.67,0.83,1.15,1.22,6.82
+msgpack-get-path.lua 0,16,44827.58,0.36,0.32,0.48,0.58,0.76,0.81,9.19
+msgpack-get-path.lua 7,16,47529.14,0.33,0.31,0.42,0.53,0.73,0.79,7.47
+msgpack-get-path.lua 8 zero,16,44442.72,0.36,0.33,0.45,0.56,0.77,0.85,8.11
+msgpack-set-root.lua pass-json-parser-0000.json,16,19585.82,0.81,0.78,0.85,1.05,1.66,1.86,4.33
+msgpack-get-root.lua,16,19014.08,0.84,0.73,1.23,1.45,1.76,1.84,13.52
+msgpack-get-path.lua web-app servlet,16,18992.61,0.84,0.73,1.23,1.45,1.75,1.82,8.19
+msgpack-get-path.lua web-app servlet 0,16,24328.78,0.66,0.64,0.73,0.77,1.15,1.34,8.81
+msgpack-get-path.lua web-app servlet 0 servlet-name,16,31012.81,0.51,0.49,0.57,0.65,1.02,1.13,8.11
+"msgpack-set-path.lua web-app servlet 0 servlet-name ""bar""",16,20388.54,0.78,0.73,0.88,1.08,1.63,1.78,7.22
+msgpack-set-root.lua pass-jsonsl-yahoo2.json,16,5597.60,2.85,2.81,2.89,2.94,4.57,5.59,10.19
+msgpack-get-root.lua,16,6585.01,2.43,2.39,2.52,2.66,3.76,4.80,10.59
+msgpack-set-path.lua ResultSet totalResultsAvailable 1,16,6666.95,2.40,2.35,2.43,2.47,3.78,4.59,12.08
+msgpack-get-path.lua ResultSet totalResultsAvailable,16,10733.03,1.49,1.45,1.60,1.66,2.36,2.93,13.15
+msgpack-set-root-lua pass-jsonsl-yelp.json,16,2291.53,6.97,6.87,7.01,7.12,10.54,12.89,21.75
+msgpack-get-root.lua,16,2889.59,5.53,5.45,5.71,5.86,8.80,10.48,25.55
+msgpack-set-path.lua message code 1,16,2847.85,5.61,5.44,5.56,6.01,10.58,11.90,16.91
+msgpack-get-path.lua message code,16,5030.95,3.18,3.07,3.24,3.57,6.08,6.92,12.44
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: JSON support for Redis
+linkTitle: JSON
+stack: true
+title: JSON
+weight: 11
+---
+
+[![Discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/QUkjSsk)
+[![Github](https://img.shields.io/static/v1?label=&message=repository&color=5961FF&logo=github)](https://github.com/RedisJSON/RedisJSON/)
+
+The JSON capability of Redis Open Source provides JavaScript Object Notation (JSON) support for Redis. It lets you store, update, and retrieve JSON values in a Redis database, similar to any other Redis data type. Redis JSON also works seamlessly with the [Redis Query Engine]({{< relref "/develop/interact/search-and-query/" >}}) to let you [index and query JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}}).
+
+## Primary features
+
+* Full support for the JSON standard
+* A [JSONPath](http://goessner.net/articles/JsonPath/) syntax for selecting/updating elements inside documents (see [JSONPath syntax]({{< relref "/develop/data-types/json/path#jsonpath-syntax" >}}))
+* Documents stored as binary data in a tree structure, allowing fast access to sub-elements
+* Typed atomic operations for all JSON value types
+
+## Use Redis with JSON
+
+The first JSON command to try is [`JSON.SET`]({{< relref "commands/json.set/" >}}), which sets a Redis key with a JSON value. [`JSON.SET`]({{< relref "commands/json.set/" >}}) accepts all JSON value types. This example creates a JSON string:
+
+{{< clients-example json_tutorial set_get >}}
+> JSON.SET bike $ '"Hyperion"'
+OK
+> JSON.GET bike $
+"[\"Hyperion\"]"
+> JSON.TYPE bike $
+1) "string"
+{{< /clients-example >}}
+
+Note how the commands include the dollar sign character `$`. This is the [path]({{< relref "/develop/data-types/json/path" >}}) to the value in the JSON document (in this case it just means the root).
+
+Here are a few more string operations. [`JSON.STRLEN`]({{< relref "commands/json.strlen/" >}}) tells you the length of the string, and you can append another string to it with [`JSON.STRAPPEND`]({{< relref "commands/json.strappend/" >}}).
+
+{{< clients-example json_tutorial str>}}
+> JSON.STRLEN bike $
+1) (integer) 8
+> JSON.STRAPPEND bike $ '" (Enduro bikes)"'
+1) (integer) 23
+> JSON.GET bike $
+"[\"Hyperion (Enduro bikes)\"]"
+{{< /clients-example >}}
+
+Numbers can be [incremented]({{< relref "commands/json.numincrby/" >}}) and [multiplied]({{< relref "commands/json.nummultby/" >}}):
+
+{{< clients-example json_tutorial num >}}
+> JSON.SET crashes $ 0
+OK
+> JSON.NUMINCRBY crashes $ 1
+"[1]"
+> JSON.NUMINCRBY crashes $ 1.5
+"[2.5]"
+> JSON.NUMINCRBY crashes $ -0.75
+"[1.75]"
+> JSON.NUMMULTBY crashes $ 24
+"[42]"
+{{< /clients-example >}}
+
+Here's a more interesting example that includes JSON arrays and objects:
+
+{{< clients-example json_tutorial arr >}}
+> JSON.SET newbike $ '["Deimos", {"crashes": 0}, null]'
+OK
+> JSON.GET newbike $
+"[[\"Deimos\",{\"crashes\":0},null]]"
+> JSON.GET newbike $[1].crashes
+"[0]"
+> JSON.DEL newbike $[-1]
+(integer) 1
+> JSON.GET newbike $
+"[[\"Deimos\",{\"crashes\":0}]]"
+{{< /clients-example >}}
+
+The [`JSON.DEL`]({{< relref "commands/json.del/" >}}) command deletes any JSON value you specify with the `path` parameter.
+
+You can manipulate arrays with a dedicated subset of JSON commands:
+
+{{< clients-example json_tutorial arr2 >}}
+> JSON.SET riders $ []
+OK
+> JSON.ARRAPPEND riders $ '"Norem"'
+1) (integer) 1
+> JSON.GET riders $
+"[[\"Norem\"]]"
+> JSON.ARRINSERT riders $ 1 '"Prickett"' '"Royce"' '"Castilla"'
+1) (integer) 4
+> JSON.GET riders $
+"[[\"Norem\",\"Prickett\",\"Royce\",\"Castilla\"]]"
+> JSON.ARRTRIM riders $ 1 1
+1) (integer) 1
+> JSON.GET riders $
+"[[\"Prickett\"]]"
+> JSON.ARRPOP riders $
+1) "\"Prickett\""
+> JSON.ARRPOP riders $
+1) (nil)
+{{< /clients-example >}}
+
+JSON objects also have their own commands:
+
+{{< clients-example json_tutorial obj >}}
+> JSON.SET bike:1 $ '{"model": "Deimos", "brand": "Ergonom", "price": 4972}'
+OK
+> JSON.OBJLEN bike:1 $
+1) (integer) 3
+> JSON.OBJKEYS bike:1 $
+1) 1) "model"
+   2) "brand"
+   3) "price"
+{{< /clients-example >}}
+
+## Format CLI output
+
+The CLI has a raw output mode that lets you add formatting to the output from
+[`JSON.GET`]({{< relref "commands/json.get/" >}}) to make
+it more readable. To use this, run `redis-cli` with the `--raw` option
+and include formatting keywords such as `INDENT`, `NEWLINE`, and `SPACE`
+with [`JSON.GET`]({{< relref "commands/json.get/" >}}):
+
+```bash
+$ redis-cli --raw
+> JSON.GET obj INDENT "\t" NEWLINE "\n" SPACE " " $
+[
+	{
+		"name": "Leonard Cohen",
+		"lastSeen": 1478476800,
+		"loggedOut": true
+	}
+]
+```
+
+## Enable Redis JSON
+
+The Redis JSON data type is part of Redis Open Source and it is also available in Redis Software and Redis Cloud.
+See
+[Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) or
+[Install Redis Enterprise]({{< relref "/operate/rs/installing-upgrading/install" >}})
+for full installation instructions.
+
+## Limitation
+
+A JSON value passed to a command can have a depth of up to 128. If you pass to a command a JSON value that contains an object or an array with a nesting level of more than 128, the command returns an error.
+
+## Further information
+
+Read the other pages in this section to learn more about Redis JSON
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Combine Redis JSON and the Redis Query Engine to index and search JSON documents
+linkTitle: Index/Search
+title: Index/Search JSON documents
+weight: 2
+---
+
+In addition to storing JSON documents, you can also index them using the [Redis Query Engine]({{< relref "/develop/interact/search-and-query/" >}}) feature. This enables full-text search capabilities and document retrieval based on their content.
+
+To use these features, install [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}}).
+
+See the [tutorial]({{< relref "/develop/interact/search-and-query/indexing/" >}}) to learn how to search and query your JSON.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to Redis bitfields
+
+  '
+linkTitle: Bitfields
+title: Redis bitfields
+weight: 130
+---
+
+Redis bitfields let you set, increment, and get integer values of arbitrary bit length.
+For example, you can operate on anything from unsigned 1-bit integers to signed 63-bit integers.
+
+These values are stored using binary-encoded Redis strings.
+Bitfields support atomic read, write and increment operations, making them a good choice for managing counters and similar numerical values.
+
+
+## Basic commands
+
+* [`BITFIELD`]({{< relref "/commands/bitfield" >}}) atomically sets, increments and reads one or more values.
+* [`BITFIELD_RO`]({{< relref "/commands/bitfield_ro" >}}) is a read-only variant of [`BITFIELD`]({{< relref "/commands/bitfield" >}}).
+
+## Example
+
+Suppose you want to maintain two metrics for various bicycles: the current price and the number of owners over time. You can represent these counters with a 32-bit wide bitfield for each bike.
+
+* Bike 1 initially costs 1,000 (counter in offset 0) and has never had an owner. After being sold, it's now considered used and the price instantly drops to reflect its new condition, and it now has an owner (offset 1). After quite some time, the bike becomes a classic. The original owner sells it for a profit, so the price goes up and the number of owners does as well.Finally, you can look at the bike's current price and number of owners.
+
+{{< clients-example bitfield_tutorial bf >}}
+> BITFIELD bike:1:stats SET u32 #0 1000
+1) (integer) 0
+> BITFIELD bike:1:stats INCRBY u32 #0 -50 INCRBY u32 #1 1
+1) (integer) 950
+2) (integer) 1
+> BITFIELD bike:1:stats INCRBY u32 #0 500 INCRBY u32 #1 1
+1) (integer) 1450
+2) (integer) 2
+> BITFIELD bike:1:stats GET u32 #0 GET u32 #1
+1) (integer) 1450
+2) (integer) 2
+{{< /clients-example >}}
+
+
+## Performance
+
+[`BITFIELD`]({{< relref "/commands/bitfield" >}}) is O(n), where _n_ is the number of counters accessed.
+---
+categories:
+- docs
+- develop
+- stack
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Scale Redis vector sets to handle larger data sets and workloads
+linkTitle: Scalability
+title: Scalability
+weight: 20
+---
+
+## 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.
+
+### Example strategy
+
+You can shard data using a consistent hash:
+
+```python
+key_index = crc32(item) % 3
+key = f"vset:{key_index}"
+```
+
+Then add elements into different keys:
+
+```bash
+VADD vset:0 VALUES 3 0.1 0.2 0.3 item1
+VADD vset:1 VALUES 3 0.4 0.5 0.6 item2
+```
+
+To run a similarity search across all shards, send [`VSIM`]({{< relref "/commands/vsim" >}}) commands to each key and then merge the results client-side:
+
+```bash
+VSIM vset:0 VALUES ... WITHSCORES
+VSIM vset:1 VALUES ... WITHSCORES
+VSIM vset:2 VALUES ... WITHSCORES
+```
+
+Then combine and sort the results by score.
+
+## Key properties
+
+- Write operations ([`VADD`]({{< relref "/commands/vadd" >}}), [`VREM`]({{< relref "/commands/vrem" >}})) scale linearly—you can insert in parallel across instances.
+- Read operations ([`VSIM`]({{< relref "/commands/vsim" >}})) do not scale linearly—you must query all shards for a full result set.
+- Smaller vector sets yield faster queries, so distributing them helps reduce query time per node.
+- Merging results client-side keeps logic simple and doesn't add server-side overhead.
+
+## Availability benefits
+
+This sharding model also improves fault tolerance:
+
+- If one instance is down, you can still retrieve partial results from others.
+- Use timeouts and partial fallbacks to increase resilience.
+
+## Latency considerations
+
+To avoid additive latency across N instances:
+
+- Send queries to all shards in parallel.
+- Wait for the slowest response.
+
+This makes total latency close to the worst-case shard time, not the sum of all times.
+
+## Summary
+
+| Goal                      | Approach                                          |
+|---------------------------|---------------------------------------------------|
+| Scale inserts             | Split data across keys and instances              |
+| Scale reads               | Query all shards and merge results                |
+| High availability         | Accept partial results when some shards fail      |
+| Maintain performance      | Use smaller shards for faster per-node traversal  |
+
+## See also
+
+- [Performance]({{< relref "/develop/data-types/vector-sets/performance" >}})
+- [Filtered search]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+- [Memory usage]({{< relref "/develop/data-types/vector-sets/memory" >}})
+---
+categories:
+- docs
+- develop
+- stack
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Diagnose and debug issues when working with Redis vector sets
+linkTitle: Troubleshooting
+title: Troubleshooting
+weight: 30
+---
+
+## 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.
+
+## Low recall or missing results
+
+If [`VSIM`]({{< relref "/commands/vsim" >}}) doesn't return expected items:
+
+- Increase the `EF` parameter:
+
+  ```bash
+  VSIM myset VALUES 3 ... COUNT 10 EF 1000
+  ```
+
+- Check quantization mode. Binary quantization (`BIN`) trades accuracy for speed.
+- Use `TRUTH` to compare results against a linear scan:
+
+  ```bash
+  VSIM myset VALUES 3 ... COUNT 10 TRUTH
+  ```
+
+  This gives you the most accurate results for validation, but it's slow.
+
+## Filtering issues
+
+Filters silently exclude items if:
+
+- A field is missing from the element’s attributes
+- The JSON is invalid
+- A type doesn’t match the expression (for example, `.rating > 8` when `.rating` is a string)
+
+Try retrieving the attributes with [`VGETATTR`]({{< relref "/commands/vgetattr" >}}):
+
+```bash
+VGETATTR myset myelement
+```
+
+Double-check field names, JSON validity, and value types.
+
+## Unexpected memory usage
+
+Memory issues may arise from:
+
+- Large vectors (use `REDUCE` to project down)
+- High `M` values inflating link graphs
+- Large or deeply nested JSON attributes
+- Storing raw `FP32` vectors (`NOQUANT`)
+
+Use default `Q8` quantization and compact attributes to save space.
+
+## Inspecting the graph
+
+Use [`VLINKS`]({{< relref "/commands/vlinks" >}}) to examine a node’s connections:
+
+```bash
+VLINKS myset myelement WITHSCORES
+```
+
+- Helps you verify whether isolated or weakly connected nodes exist.
+- Useful for explaining poor recall.
+
+## Deletion spikes
+
+Large sets deleted using the `DEL` command can briefly spike latency as Redis reclaims memory and rebuilds HNSW linkages.
+
+## Replication quirks
+
+- `VADD` with `REDUCE` does not replicate the random projection matrix.
+- Replicas will produce different projected vectors for the same inputs.
+
+This doesn't affect similarity searches but does affect [`VEMB`]({{< relref "/commands/vemb" >}}) output.
+
+## Summary
+
+| Symptom                          | Try this                                                  |
+|----------------------------------|-----------------------------------------------------------|
+| Poor recall                      | Use higher `EF`, check quantization, use `TRUTH`          |
+| Filters exclude too much         | Validate attributes with `VGETATTR`, simplify expressions |
+| Memory spikes                    | Use `REDUCE`, `Q8`, smaller `M`, compact JSON             |
+| Replication mismatch with REDUCE | Avoid relying on projected vectors from replicas          |
+
+## See also
+
+- [Filtered Search]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+- [Memory Usage]({{< relref "/develop/data-types/vector-sets/memory" >}})
+- [Performance]({{< relref "/develop/data-types/vector-sets/performance" >}})
+---
+categories:
+- docs
+- develop
+- stack
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Use filter expressions to refine vector similarity results with Redis vector sets
+linkTitle: Filter expressions
+title: Filter expressions
+weight: 10
+---
+
+## 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`]({{< relref "/commands/vsim" >}}) queries.
+
+This allows queries such as:
+
+```bash
+VSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.year >= 1980 and .rating > 7'
+```
+
+## Assigning attributes
+
+You can associate attributes when adding a new vector using the `SETATTR` argument:
+
+```bash
+VADD vset VALUES 3 1 1 1 a SETATTR '{"year": 1950}'
+```
+
+Or update them later with the [`VSETATTR`]({{< relref "/commands/vsetattr" >}}) command:
+
+```bash
+VSETATTR vset a '{"year": 1960}'
+```
+
+You can retrieve attributes with the [`VGETATTR`]({{< relref "/commands/vgetattr" >}}) command:
+
+```bash
+VGETATTR vset a
+```
+
+## Filtering during similarity search
+
+To filter by attributes, pass the `FILTER` option to the [`VSIM`]({{< relref "/commands/vsim" >}}) command:
+
+```bash
+VSIM vset VALUES 3 0 0 0 FILTER '.year > 1950'
+```
+
+This returns only elements that match both the vector similarity and the filter expression.
+
+## Expression syntax
+
+Expressions support familiar JavaScript-like syntax:
+
+- Arithmetic: `+`, `-`, `*`, `/`, `%`, `**`
+- Comparison: `==`, `!=`, `>`, `<`, `>=`, `<=`
+- Logical: `and`, `or`, `not` (or `&&`, `||`, `!`)
+- Containment: `in`
+- Grouping: Parentheses `()`
+
+Use dot notation to access attribute fields, for example, `.year`, `.rating`.
+
+> Only top-level fields are supported (for example, `.genre`, but not `.movie.genre`).
+
+## Supported data types
+
+- Numbers
+- Strings
+- Booleans (converted to 1 or 0)
+- Arrays (for `in`)
+
+If a field is missing or invalid, the element is skipped without error.
+
+## FILTER-EF
+
+The `FILTER-EF` option controls how many candidate nodes the engine inspects to find enough filtered results. The defaults is `COUNT * 100`.
+
+```bash
+VSIM vset VALUES 3 0 0 0 COUNT 10 FILTER '.year > 2000' FILTER-EF 500
+```
+
+- Use a higher value for rare filters.
+- Use `FILTER-EF 0` to scan as many as needed to fulfill the request.
+- The engine will stop early if enough high-quality results are found.
+
+## Examples
+
+```bash
+# Filter by year range
+VSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.year >= 1980 and .year < 1990'
+
+# Filter by genre and rating
+VSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.genre == "action" and .rating > 8.0'
+
+# Use IN with array
+VSIM movies VALUES 3 0.5 0.8 0.2 FILTER '.director in ["Spielberg", "Nolan"]'
+
+# Math and logic
+VSIM movies VALUES 3 0.5 0.8 0.2 FILTER '(.year - 2000) ** 2 < 100 and .rating / 2 > 4'
+```
+
+## Tips
+
+- Missing attributes are treated as non-matching.
+- Use `FILTER-EF` to tune recall vs performance.
+- Combine multiple attributes for fine-grained filtering.
+
+## See also
+
+- [VSIM]({{< relref "/commands/vsim" >}})
+- [VADD]({{< relref "/commands/vadd" >}})
+- [VSETATTR]({{< relref "/commands/vsetattr" >}})
+- [VGETATTR]({{< relref "/commands/vgetattr" >}})---
+categories:
+- docs
+- develop
+- stack
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how Redis vector sets behave under load and how to optimize for speed and recall
+linkTitle: Performance
+title: Performance
+weight: 15
+---
+
+## Query performance
+
+Vector similarity queries using the [`VSIM`]({{< relref "/commands/vsim" >}}) are threaded by default. Redis uses up to 32 threads to process these queries in parallel.
+
+- `VSIM` performance scales nearly linearly with available CPU cores.
+- Expect ~50,000 similarity queries per second for a 3M-item set with 300-dim vectors using int8 quantization.
+- Performance depends heavily on the `EF` parameter:
+  - Higher `EF` improves recall, but slows down search.
+  - Lower `EF` returns faster results with reduced accuracy.
+
+## Insertion performance
+
+Inserting vectors with the [`VADD`]({{< relref "/commands/vadd" >}}) command is more computationally expensive than querying:
+
+- Insertion is single-threaded by default.
+- Use the `CAS` option to offload candidate graph search to a background thread.
+- Expect a few thousand insertions per second on a single node.
+
+## Quantization effects
+
+Quantization greatly impacts both speed and memory:
+
+- `Q8` (default): 4x smaller than `FP32`, high recall, high speed
+- `BIN` (binary): 32x smaller than `FP32`, lower recall, fastest search
+- `NOQUANT` (`FP32`): Full precision, slower performance, highest memory use
+
+Use the quantization mode that best fits your tradeoff between precision and efficiency.
+The examples below show how the different modes affect a simple vector.
+Note that even with `NOQUANT` mode, the values change slightly,
+due to floating point rounding.
+
+{{< clients-example vecset_tutorial add_quant >}}
+> VADD quantSetQ8 VALUES 2 1.262185 1.958231 quantElement Q8
+(integer) 1
+> VEMB quantSetQ8 quantElement
+1) "1.2643694877624512"
+2) "1.958230972290039"
+
+> VADD quantSetNoQ VALUES 2 1.262185 1.958231 quantElement NOQUANT
+(integer) 1
+> VEMB quantSetNoQ quantElement
+1) "1.262184977531433"
+2) "1.958230972290039"
+
+> VADD quantSetBin VALUES 2 1.262185 1.958231 quantElement BIN
+(integer) 1
+> VEMB quantSetBin quantElement
+1) "1"
+2) "1"
+{{< /clients-example >}}
+
+## Deletion performance
+
+Deleting large vector sets using the [`DEL`]({{< relref "/commands/del" >}}) can cause latency spikes:
+
+- Redis must unlink and restructure many graph nodes.
+- Latency is most noticeable when deleting millions of elements.
+
+## Save and load performance
+
+Vector sets save and load the full HNSW graph structure:
+
+- When reloading from disk is fast and there's no need to rebuild the graph.
+
+Example: A 3M vector set with 300 components loads in ~15 seconds.
+
+## Summary of tuning tips
+
+| Factor     | Effect on performance               | Tip                                            |
+|------------|-------------------------------------|------------------------------------------------|
+| `EF`       | Slower queries but higher recall    | Start low (for example, 200) and tune upward           |
+| `M`        | More memory per node, better recall | Use defaults unless recall is too low          |
+| Quant type | Binary is fastest, `FP32` is slowest| Use `Q8` or `BIN` unless full precision needed |
+| `CAS`      | Faster insertions with threading    | Use when high write throughput is needed       |
+
+## See also
+
+- [Memory usage]({{< relref "/develop/data-types/vector-sets/memory" >}})
+- [Scalability]({{< relref "/develop/data-types/vector-sets/scalability" >}})
+- [Filtered search]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+---
+categories:
+- docs
+- develop
+- stack
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to optimize memory consumption in Redis vector sets
+linkTitle: Memory optimization
+title: Memory optimization
+weight: 25
+---
+
+## 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.
+
+## Quantization modes
+
+Vector sets support three quantization levels:
+
+| Mode       | Memory usage  | Recall | Notes                           |
+|------------|---------------|--------|---------------------------------|
+| `Q8`       | 4x smaller    | High   | Default, fast and accurate      |
+| `BIN`      | 32x smaller   | Lower  | Fastest, best for coarse search |
+| `NOQUANT`  | Full size     | Highest| Best precision, slowest         |
+
+Use `Q8` unless your use case demands either ultra-precision (use `NOQUANT`) or ultra-efficiency (use `BIN`).
+
+## Graph structure memory
+
+HNSW graphs store multiple connections per node. Each node:
+
+- Has an average of `M * 2 + M * 0.33` pointers (default M = 16).
+- Stores pointers using 8 bytes each.
+- Allocates ~1.33 layers per node.
+
+> A single node with M = 64 may consume ~1 KB in links alone.
+
+To reduce memory:
+
+- Lower `M` to shrink per-node connections.
+- Avoid unnecessarily large values for `M` unless recall needs to be improved.
+
+## Attribute and label size
+
+Each node stores:
+
+- A string label (element name)
+- Optional JSON attribute string
+
+Tips:
+
+- Use short, fixed-length strings for labels.
+- Keep attribute JSON minimal and flat. For example, use `{"year":2020}` instead of nested data.
+
+## Vector dimension
+
+High-dimensional vectors increase storage:
+
+- 300 components at `FP32` = 1200 bytes/vector
+- 300 components at `Q8` = 300 bytes/vector
+
+You can reduce this using the `REDUCE` option during [`VADD`]({{< relref "/commands/vadd" >}}), which applies [random projection](https://en.wikipedia.org/wiki/Random_projection):
+
+{{< clients-example vecset_tutorial add_reduce >}}
+>VADD setNotReduced VALUES 300 ... element
+(integer) 1
+> VDIM setNotReduced
+(integer) 300
+
+>VADD setReduced REDUCE 100 VALUES 300 ... element
+(integer) 1
+> VDIM setReduced
+(integer) 100
+{{< /clients-example >}}
+
+This projects a 300-dimensional vector into 100 dimensions, reducing size and improving speed at the cost of some recall.
+
+## Summary
+
+| Strategy            | Effect                                   |
+|---------------------|------------------------------------------|
+| Use `Q8`            | Best tradeoff for most use cases         |
+| Use `BIN`           | Minimal memory, fastest search           |
+| Lower `M`           | Shrinks HNSW link graph size             |
+| Reduce dimensions   | Cuts memory per vector                   |
+| Minimize JSON       | Smaller attributes, less memory per node |
+
+## See also
+
+- [Performance]({{< relref "/develop/data-types/vector-sets/performance" >}})
+- [Scalability]({{< relref "/develop/data-types/vector-sets/scalability" >}})
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Introduction to Redis vector sets
+linkTitle: Vector sets
+title: Redis vector sets
+weight: 55
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+bannerChildren: true
+---
+
+Vector sets are a data type similar to sorted sets, but instead of a score, vector set elements have a string representation of a vector.
+Vector sets allow you to add items to a set, and then either:
+
+* retrieve a subset of items that are the most similar to a specified vector, or
+* retrieve a subset of items that are the most similar to the vector of an element that is already part of the vector set.
+
+Vector sets also provide for optional [filtered search]({{< relref "/develop/data-types/vector-sets/filtered-search" >}}). You can associate attributes with all or some elements in a vector set, and then use the `FILTER` option of the [`VSIM`]({{< relref "/commands/vsim" >}}) command to retrieve items similar to a given vector while applying simple mathematical filters to those attributes. Here's a sample filter: `".year > 1950"`.
+
+The following commands are available for vector sets:
+
+- [VADD]({{< relref "/commands/vadd" >}}) - add an element to a vector set, creating a new set if it didn't already exist.
+- [VCARD]({{< relref "/commands/vcard" >}}) - retrieve the number of elements in a vector set.
+- [VDIM]({{< relref "/commands/vdim" >}}) - retrieve the dimension of the vectors in a vector set.
+- [VEMB]({{< relref "/commands/vemb" >}}) - retrieve the approximate vector associated with a vector set element.
+- [VGETATTR]({{< relref "/commands/vgetattr" >}}) - retrieve the attributes of a vector set element.
+- [VINFO]({{< relref "/commands/vinfo" >}}) - retrieve metadata and internal details about a vector set, including size, dimensions, quantization type, and graph structure.
+- [VLINKS]({{< relref "/commands/vlinks" >}}) - retrieve the neighbors of a specified element in a vector set; the connections for each layer of the HNSW graph.
+- [VRANDMEMBER]({{< relref "/commands/vrandmember" >}}) - retrieve random elements of a vector set.
+- [VREM]({{< relref "/commands/vrem" >}}) - remove an element from a vector set.
+- [VSETATTR]({{< relref "/commands/vsetattr" >}}) - set or replace attributes on a vector set element.
+- [VSIM]({{< relref "/commands/vsim" >}}) - retrieve elements similar to a given vector or element with optional filtering.
+
+## Examples
+
+The following examples give an overview of how to use vector sets. For clarity,
+we will use a set of two-dimensional vectors that represent points in the
+Cartesian coordinate plane. However, in real use cases, the vectors will typically
+represent *text embeddings* and have hundreds of dimensions. See
+[Redis for AI]({{< relref "/develop/ai" >}}) for more information about using text
+embeddings.
+
+The points we will use are A: (1.0, 1.0), B: (-1.0, -1.0), C: (-1.0, 1.0), D: (1.0. -1.0), and
+E: (1.0, 0), shown in the diagram below.
+
+{{<image filename="images/vecsets/VecSetExamplePoints.drawio.svg" alt="Example points on the coordinate plane." width="400px">}}
+
+### Basic operations
+
+Start by adding the point vectors to a set called `points` using
+[`VADD`]({{< relref "/commands/vadd" >}}). This also creates the vector set object.
+The [`TYPE`]({{< relref "/commands/type" >}}) command returns a type of `vectorset`
+for this object.
+
+{{< clients-example vecset_tutorial vadd >}}
+> VADD points VALUES 2 1.0 1.0 pt:A
+(integer) 1
+> VADD points VALUES 2 -1.0 -1.0 pt:B
+(integer) 1
+> VADD points VALUES 2 -1.0 1.0 pt:C
+(integer) 1
+> VADD points VALUES 2 1.0 -1.0 pt:D
+(integer) 1
+> VADD points VALUES 2 1.0 0 pt:E
+(integer) 1
+> TYPE points
+vectorset
+{{< /clients-example >}}
+
+
+Get the number of elements in the set (also known as the *cardinality* of the set)
+using [`VCARD`]({{< relref "/commands/vcard" >}}) and the number of dimensions of
+the vectors using [`VDIM`]({{< relref "/commands/vdim" >}}):
+
+{{< clients-example vecset_tutorial vcardvdim >}}
+> VCARD points
+(integer) 5
+> VDIM points
+(integer) 2
+{{< /clients-example >}}
+
+Get the coordinate values from the elements using [`VEMB`]({{< relref "/commands/vemb" >}}).
+Note that the values will not typically be the exact values you supplied when you added
+the vector because
+[quantization]({{< relref "/develop/data-types/vector-sets/performance#quantization-effects" >}})
+is applied to improve performance.
+
+{{< clients-example vecset_tutorial vemb >}}
+> VEMB points pt:A
+1) "0.9999999403953552"
+2) "0.9999999403953552"
+9> VEMB points pt:B
+1) "-0.9999999403953552"
+2) "-0.9999999403953552"
+> VEMB points pt:C
+1) "-0.9999999403953552"
+2) "0.9999999403953552"
+> VEMB points pt:D
+1) "0.9999999403953552"
+2) "-0.9999999403953552"
+> VEMB points pt:E
+1) "1"
+2) "0"
+{{< /clients-example >}}
+
+Set and retrieve an element's JSON attribute data using
+[`VSETATTR`]({{< relref "/commands/vsetattr" >}})
+and [`VGETATTR`]({{< relref "/commands/vgetattr" >}}). You can also pass an empty string
+to `VSETATTR` to delete the attribute data:
+
+{{< clients-example vecset_tutorial attr >}}
+> VSETATTR points pt:A "{\"name\": \"Point A\", \"description\": \"First point added\"}" 
+(integer) 1
+> VGETATTR points pt:A
+"{\"name\": \"Point A\", \"description\": \"First point added\"}"
+> VSETATTR points pt:A "" 
+(integer) 1
+> VGETATTR points pt:A
+(nil)
+{{< /clients-example >}}
+
+Remove an unwanted element with [`VREM`]({{< relref "/commands/vrem" >}})
+
+{{< clients-example vecset_tutorial vrem >}}
+> VADD points VALUES 2 0 0 pt:F
+(integer) 1
+127.0.0.1:6379> VCARD points
+(integer) 6
+127.0.0.1:6379> VREM points pt:F
+(integer) 1
+127.0.0.1:6379> VCARD points
+(integer) 5
+{{< /clients-example >}}
+
+### Vector similarity search
+
+Use [`VSIM`]({{< relref "/commands/vsim" >}}) to rank the points in order of their vector distance from a sample point:
+
+{{< clients-example vecset_tutorial vsim_basic >}}
+> VSIM points values 2 0.9 0.1
+1) "pt:E"
+2) "pt:A"
+3) "pt:D"
+4) "pt:C"
+5) "pt:B"
+{{< /clients-example >}}
+
+Find the four elements that are closest to point A and show their distance "scores":
+
+{{< clients-example vecset_tutorial vsim_options >}}
+> VSIM points ELE pt:A WITHSCORES COUNT 4
+1) "pt:A"
+2) "1"
+3) "pt:E"
+4) "0.8535534143447876"
+5) "pt:C"
+6) "0.5"
+7) "pt:D"
+8) "0.5"
+{{< /clients-example >}}
+
+Add some JSON attributes and use
+[filter expressions]({{< relref "/develop/data-types/vector-sets/filtered-search" >}})
+to include them in the search:
+
+{{< clients-example vecset_tutorial vsim_filter >}}
+> VSETATTR points pt:A "{\"size\":\"large\",\"price\": 18.99}"
+(integer) 1
+> VSETATTR points pt:B "{\"size\":\"large\",\"price\": 35.99}"
+(integer) 1
+> VSETATTR points pt:C "{\"size\":\"large\",\"price\": 25.99}"
+(integer) 1
+> VSETATTR points pt:D "{\"size\":\"small\",\"price\": 21.00}"
+(integer) 1
+> VSETATTR points pt:E "{\"size\":\"small\",\"price\": 17.75}"
+(integer) 1
+
+# Return elements in order of distance from point A whose
+# `size` attribute is `large`.
+> VSIM points ELE pt:A FILTER '.size == "large"'
+1) "pt:A"
+2) "pt:C"
+3) "pt:B"
+
+# Return elements in order of distance from point A whose size is
+# `large` and whose price is greater than 20.00.
+> VSIM points ELE pt:A FILTER '.size == "large" && .price > 20.00'
+1) "pt:C"
+2) "pt:B"
+{{< /clients-example >}}
+
+## More information
+
+See the other pages in this section to learn more about the features
+and performance parameters of vector sets.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Overview of data types supported by Redis
+linkTitle: Understand data types
+title: Understand Redis data types
+hideListLinks: true
+weight: 35
+---
+
+Redis is a data structure server.
+At its core, Redis provides a collection of native data types that help you solve a wide variety of problems, from [caching]({{< relref "/develop/data-types/strings" >}}) to
+[queuing]({{< relref "/develop/data-types/lists" >}}) to
+[event processing]({{< relref "/develop/data-types/streams" >}}).
+Below is a short description of each data type, with links to broader overviews and command references.
+Each overview includes a comprehensive tutorial with code samples.
+
+## Data types
+
+[Redis Open Source]({{< relref "/operate/oss_and_stack" >}})
+implements the following data types:
+
+- [String](#strings)
+- [Hash](#hashes)
+- [List](#lists)
+- [Set](#sets)
+- [Sorted set](#sorted-sets)
+- [Vector set](#vector-sets)
+- [Stream](#streams)
+- [Bitmap](#bitmaps)
+- [Bitfield](#bitfields)
+- [Geospatial](#geospatial-indexes)
+- [JSON](#json)
+- [Probabilistic data types](#probabilistic-data-types)
+- [Time series](#time-series)
+
+### Strings 
+
+[Redis strings]({{< relref "/develop/data-types/strings" >}}) are the most basic Redis data type, representing a sequence of bytes.
+For more information, see:
+
+* [Overview of Redis strings]({{< relref "/develop/data-types/strings" >}})
+* [Redis string command reference]({{< relref "/commands/" >}}?group=string)
+
+### Lists
+
+[Redis lists]({{< relref "/develop/data-types/lists" >}}) are lists of strings sorted by insertion order.
+For more information, see:
+
+* [Overview of Redis lists]({{< relref "/develop/data-types/lists" >}})
+* [Redis list command reference]({{< relref "/commands/" >}}?group=list)
+
+### Sets
+
+[Redis sets]({{< relref "/develop/data-types/sets" >}}) are unordered collections of unique strings that act like the sets from your favorite programming language (for example, [Java HashSets](https://docs.oracle.com/javase/7/docs/api/java/util/HashSet.html), [Python sets](https://docs.python.org/3.10/library/stdtypes.html#set-types-set-frozenset), and so on).
+With a Redis set, you can add, remove, and test for existence in O(1) time (in other words, regardless of the number of set elements).
+For more information, see:
+
+* [Overview of Redis sets]({{< relref "/develop/data-types/sets" >}})
+* [Redis set command reference]({{< relref "/commands/" >}}?group=set)
+
+### Hashes
+
+[Redis hashes]({{< relref "/develop/data-types/hashes" >}}) are record types modeled as collections of field-value pairs.
+As such, Redis hashes resemble [Python dictionaries](https://docs.python.org/3/tutorial/datastructures.html#dictionaries), [Java HashMaps](https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html), and [Ruby hashes](https://ruby-doc.org/core-3.1.2/Hash.html).
+For more information, see:
+
+* [Overview of Redis hashes]({{< relref "/develop/data-types/hashes" >}})
+* [Redis hashes command reference]({{< relref "/commands/" >}}?group=hash)
+
+### Sorted sets
+
+[Redis sorted sets]({{< relref "/develop/data-types/sorted-sets" >}}) are collections of unique strings that maintain order by each string's associated score.
+For more information, see:
+
+* [Overview of Redis sorted sets]({{< relref "/develop/data-types/sorted-sets" >}})
+* [Redis sorted set command reference]({{< relref "/commands/" >}}?group=sorted-set)
+
+### Vector sets
+
+[Redis vector sets]({{< relref "/develop/data-types/vector-sets" >}}) are a specialized data type designed for managing high-dimensional vector data, enabling fast and efficient vector similarity search within Redis. Vector sets are optimized for use cases involving machine learning, recommendation systems, and semantic search, where each vector represents a data point in multi-dimensional space. Vector sets supports the [HNSW](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world) (hierarchical navigable small world) algorithm, allowing you to store, index, and query vectors based on the cosine similarity metric. With vector sets, Redis provides native support for hybrid search, combining vector similarity with structured [filters]({{< relref "/develop/data-types/vector-sets/filtered-search" >}}).
+For more information, see:
+
+* [Overview of Redis vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+* [Redis vector set command reference]({{< relref "/commands/" >}}?group=vector_set)
+
+### Streams
+
+A [Redis stream]({{< relref "/develop/data-types/streams" >}}) is a data structure that acts like an append-only log.
+Streams help record events in the order they occur and then syndicate them for processing.
+For more information, see:
+
+* [Overview of Redis Streams]({{< relref "/develop/data-types/streams" >}})
+* [Redis Streams command reference]({{< relref "/commands/" >}}?group=stream)
+
+### Geospatial indexes
+
+[Redis geospatial indexes]({{< relref "/develop/data-types/geospatial" >}}) are useful for finding locations within a given geographic radius or bounding box.
+For more information, see:
+
+* [Overview of Redis geospatial indexes]({{< relref "/develop/data-types/geospatial" >}})
+* [Redis geospatial indexes command reference]({{< relref "/commands/" >}}?group=geo)
+
+### Bitmaps
+
+[Redis bitmaps]({{< relref "/develop/data-types/bitmaps" >}}) let you perform bitwise operations on strings. 
+For more information, see:
+
+* [Overview of Redis bitmaps]({{< relref "/develop/data-types/bitmaps" >}})
+* [Redis bitmap command reference]({{< relref "/commands/" >}}?group=bitmap)
+
+### Bitfields
+
+[Redis bitfields]({{< relref "/develop/data-types/bitfields" >}}) efficiently encode multiple counters in a string value.
+Bitfields provide atomic get, set, and increment operations and support different overflow policies.
+For more information, see:
+
+* [Overview of Redis bitfields]({{< relref "/develop/data-types/bitfields" >}})
+* The [`BITFIELD`]({{< relref "/commands/bitfield" >}}) command.
+
+### JSON
+
+[Redis JSON]({{< relref "/develop/data-types/json" >}}) provides
+structured, hierarchical arrays and key-value objects that match
+the popular [JSON](https://www.json.org/json-en.html) text file
+format. You can import JSON text into Redis objects and access,
+modify, and query individual data elements.
+For more information, see:
+
+- [Overview of Redis JSON]({{< relref "/develop/data-types/json" >}})
+- [JSON command reference]({{< relref "/commands" >}}?group=json)
+
+### Probabilistic data types
+
+These data types let you gather and calculate statistics in a way
+that is approximate but highly efficient. The following types are
+available:
+
+- [HyperLogLog](#hyperloglog)
+- [Bloom filter](#bloom-filter)
+- [Cuckoo filter](#cuckoo-filter)
+- [t-digest](#t-digest)
+- [Top-K](#top-k)
+- [Count-min sketch](#count-min-sketch)
+
+### HyperLogLog
+
+The [Redis HyperLogLog]({{< relref "/develop/data-types/probabilistic/hyperloglogs" >}}) data structures provide probabilistic estimates of the cardinality (i.e., number of elements) of large sets. For more information, see:
+
+* [Overview of Redis HyperLogLog]({{< relref "/develop/data-types/probabilistic/hyperloglogs" >}})
+* [Redis HyperLogLog command reference]({{< relref "/commands/" >}}?group=hyperloglog)
+
+### Bloom filter
+
+[Redis Bloom filters]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}})
+let you check for the presence or absence of an element in a set. For more
+information, see:
+
+- [Overview of Redis Bloom filters]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}})
+- [Bloom filter command reference]({{< relref "/commands" >}}?group=bf)
+
+### Cuckoo filter
+
+[Redis Cuckoo filters]({{< relref "/develop/data-types/probabilistic/cuckoo-filter" >}})
+let you check for the presence or absence of an element in a set. They are similar to
+[Bloom filters](#bloom-filter) but with slightly different trade-offs between features
+and performance. For more information, see:
+
+- [Overview of Redis Cuckoo filters]({{< relref "/develop/data-types/probabilistic/cuckoo-filter" >}})
+- [Cuckoo filter command reference]({{< relref "/commands" >}}?group=cf)
+
+### t-digest
+
+[Redis t-digest]({{< relref "/develop/data-types/probabilistic/t-digest" >}})
+structures estimate percentiles from a stream of data values. For more
+information, see:
+
+- [Redis t-digest overview]({{< relref "/develop/data-types/probabilistic/t-digest" >}})
+- [t-digest command reference]({{< relref "/commands" >}}?group=tdigest)
+
+### Top-K
+
+[Redis Top-K]({{< relref "/develop/data-types/probabilistic/top-k" >}})
+structures estimate the ranking of a data point within a stream of values.
+For more information, see:
+
+- [Redis Top-K overview]({{< relref "/develop/data-types/probabilistic/top-k" >}})
+- [Top-K command reference]({{< relref "/commands" >}}?group=topk)
+
+### Count-min sketch
+
+[Redis Count-min sketch]({{< relref "/develop/data-types/probabilistic/count-min-sketch" >}})
+estimate the frequency of a data point within a stream of values.
+For more information, see:
+
+- [Redis Count-min sketch overview]({{< relref "/develop/data-types/probabilistic/count-min-sketch" >}})
+- [Count-min sketch command reference]({{< relref "/commands" >}}?group=cms)
+
+## Time series
+
+[Redis time series]({{< relref "/develop/data-types/timeseries" >}})
+structures let you store and query timestamped data points.
+For more information, see:
+
+- [Redis time series overview]({{< relref "/develop/data-types/timeseries" >}})
+- [Count-min sketch command reference]({{< relref "/commands" >}}?group=timeseries)
+
+## Adding extensions
+
+To extend the features provided by the included data types, use one of these options:
+
+1. Write your own custom [server-side functions in Lua]({{< relref "/develop/interact/programmability/" >}}).
+1. Write your own Redis module using the [modules API]({{< relref "/develop/reference/modules/" >}}) or check out the [community-supported modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/" >}}).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn several Redis patterns by building a Twitter clone
+linkTitle: Patterns example
+title: Redis patterns example
+weight: 20
+---
+
+This article describes the design and implementation of a [very simple Twitter clone](https://github.com/antirez/retwis) 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.
+
+Note: the original version of this article was written in 2009 when Redis was
+released. It was not exactly clear at that time that the Redis data model was
+suitable to write entire applications. Now after 5 years there are many cases of
+applications using Redis as their main store, so the goal of the article today
+is to be a tutorial for Redis newcomers. You'll learn how to design a simple
+data layout using Redis, and how to apply different data structures.
+
+Our Twitter clone, called [Retwis](https://github.com/antirez/retwis), is structurally simple, has very good performance, and can be distributed among any number of web and Redis servers with little efforts. [View the Retwis source code](https://github.com/antirez/retwis).
+
+I used PHP for the example because of its universal readability. The same (or better) results can be obtained using Ruby, Python, Erlang, and so on.
+A few clones exist (however not all the clones use the same data layout as the
+current version of this tutorial, so please, stick with the official PHP
+implementation for the sake of following the article better).
+
+* [Retwis-RB](https://github.com/danlucraft/retwis-rb) is a port of Retwis to Ruby and Sinatra written by Daniel Lucraft.
+* [Retwis-J](https://docs.spring.io/spring-data/data-keyvalue/examples/retwisj/current/) is a port of Retwis to Java, using the Spring Data Framework, written by [Costin Leau](http://twitter.com/costinl). Its source code can be found on [GitHub](https://github.com/SpringSource/spring-data-keyvalue-examples), and there is comprehensive documentation available at [springsource.org](http://j.mp/eo6z6I).
+
+What is a key-value store?
+---
+The essence of a key-value store is the ability to store some data, called a _value_, inside a key. The value can be retrieved later only if we know the specific key it was stored in. There is no direct way to search for a key by value. In some sense, it is like a very large hash/dictionary, but it is persistent, i.e. when your application ends, the data doesn't go away. So, for example, I can use the command [`SET`]({{< relref "/commands/set" >}}) to store the value *bar* in the key *foo*:
+
+    SET foo bar
+
+Redis stores data permanently, so if I later ask "_What is the value stored in key foo?_" Redis will reply with *bar*:
+
+    GET foo => bar
+
+Other common operations provided by key-value stores are [`DEL`]({{< relref "/commands/del" >}}), to delete a given key and its associated value, SET-if-not-exists (called [`SETNX`]({{< relref "/commands/setnx" >}}) on Redis), to assign a value to a key only if the key does not already exist, and [`INCR`]({{< relref "/commands/incr" >}}), to atomically increment a number stored in a given key:
+
+    SET foo 10
+    INCR foo => 11
+    INCR foo => 12
+    INCR foo => 13
+
+Atomic operations
+---
+
+There is something special about [`INCR`]({{< relref "/commands/incr" >}}). You may wonder why Redis provides such an operation if we can do it ourselves with a bit of code? After all, it is as simple as:
+
+    x = GET foo
+    x = x + 1
+    SET foo x
+
+The problem is that incrementing this way will work as long as there is only one client working with the key _foo_ at one time. See what happens if two clients are accessing this key at the same time:
+
+    x = GET foo (yields 10)
+    y = GET foo (yields 10)
+    x = x + 1 (x is now 11)
+    y = y + 1 (y is now 11)
+    SET foo x (foo is now 11)
+    SET foo y (foo is now 11)
+
+Something is wrong! We incremented the value two times, but instead of going from 10 to 12, our key holds 11. This is because the increment done with `GET / increment / SET` *is not an atomic operation*. Instead the INCR provided by Redis, Memcached, ..., are atomic implementations, and the server will take care of protecting the key during the time needed to complete the increment in order to prevent simultaneous accesses.
+
+What makes Redis different from other key-value stores is that it provides other operations similar to INCR that can be used to model complex problems. This is why you can use Redis to write whole web applications without using another database like an SQL database, and without going crazy.
+
+Beyond key-value stores: lists
+---
+
+In this section we will see which Redis features we need to build our Twitter clone. The first thing to know is that Redis values can be more than strings. Redis supports Lists, Sets, Hashes, Sorted Sets, Bitmaps, and HyperLogLog types as values, and there are atomic operations to operate on them so we are safe even with multiple accesses to the same key. Let's start with Lists:
+
+    LPUSH mylist a (now mylist holds 'a')
+    LPUSH mylist b (now mylist holds 'b','a')
+    LPUSH mylist c (now mylist holds 'c','b','a')
+
+[`LPUSH`]({{< relref "/commands/lpush" >}}) means _Left Push_, that is, add an element to the left (or to the head) of the list stored in _mylist_. If the key _mylist_ does not exist it is automatically created as an empty list before the PUSH operation. As you can imagine, there is also an [`RPUSH`]({{< relref "/commands/rpush" >}}) operation that adds the element to the right of the list (on the tail). This is very useful for our Twitter clone. User updates can be added to a list stored in `username:updates`, for instance.
+
+There are operations to get data from Lists, of course. For instance, LRANGE returns a range from the list, or the whole list.
+
+    LRANGE mylist 0 1 => c,b
+
+LRANGE uses zero-based indexes - that is the first element is 0, the second 1, and so on. The command arguments are `LRANGE key first-index last-index`. The _last-index_ argument can be negative, with a special meaning: -1 is the last element of the list, -2 the penultimate, and so on. So, to get the whole list use:
+
+    LRANGE mylist 0 -1 => c,b,a
+
+Other important operations are LLEN that returns the number of elements in the list, and LTRIM that is like LRANGE but instead of returning the specified range *trims* the list, so it is like _Get range from mylist, Set this range as new value_ but does so atomically.
+
+The Set data type
+---
+
+Currently we don't use the Set type in this tutorial, but since we use
+Sorted Sets, which are kind of a more capable version of Sets, it is better
+to start introducing Sets first (which are a very useful data structure
+per se), and later Sorted Sets.
+
+There are more data types than just Lists. Redis also supports Sets, which are unsorted collections of elements. It is possible to add, remove, and test for existence of members, and perform the intersection between different Sets. Of course it is possible to get the elements of a Set. Some examples will make it more clear. Keep in mind that [`SADD`]({{< relref "/commands/sadd" >}}) is the _add to set_ operation, [`SREM`]({{< relref "/commands/srem" >}}) is the _remove from set_ operation, [`SISMEMBER`]({{< relref "/commands/sismember" >}}) is the _test if member_ operation, and [`SINTER`]({{< relref "/commands/sinter" >}}) is the _perform intersection_ operation. Other operations are [`SCARD`]({{< relref "/commands/scard" >}}) to get the cardinality (the number of elements) of a Set, and [`SMEMBERS`]({{< relref "/commands/smembers" >}}) to return all the members of a Set.
+
+    SADD myset a
+    SADD myset b
+    SADD myset foo
+    SADD myset bar
+    SCARD myset => 4
+    SMEMBERS myset => bar,a,foo,b
+
+Note that [`SMEMBERS`]({{< relref "/commands/smembers" >}}) does not return the elements in the same order we added them since Sets are *unsorted* collections of elements. When you want to store in order it is better to use Lists instead. Some more operations against Sets:
+
+    SADD mynewset b
+    SADD mynewset foo
+    SADD mynewset hello
+    SINTER myset mynewset => foo,b
+
+[`SINTER`]({{< relref "/commands/sinter" >}}) can return the intersection between Sets but it is not limited to two Sets. You may ask for the intersection of 4,5, or 10000 Sets. Finally let's check how [`SISMEMBER`]({{< relref "/commands/sismember" >}}) works:
+
+    SISMEMBER myset foo => 1
+    SISMEMBER myset notamember => 0
+
+The Sorted Set data type
+---
+
+Sorted Sets are similar to Sets: collection of elements. However in Sorted
+Sets each element is associated with a floating point value, called the
+*element score*. Because of the score, elements inside a Sorted Set are
+ordered, since we can always compare two elements by score (and if the score
+happens to be the same, we compare the two elements as strings).
+
+Like Sets in Sorted Sets it is not possible to add repeated elements, every
+element is unique. However it is possible to update an element's score.
+
+Sorted Set commands are prefixed with `Z`. The following is an example
+of Sorted Sets usage:
+
+    ZADD zset 10 a
+    ZADD zset 5 b
+    ZADD zset 12.55 c
+    ZRANGE zset 0 -1 => b,a,c
+
+In the above example we added a few elements with [`ZADD`]({{< relref "/commands/zadd" >}}), and later retrieved
+the elements with [`ZRANGE`]({{< relref "/commands/zrange" >}}). As you can see the elements are returned in order
+according to their score. In order to check if a given element exists, and
+also to retrieve its score if it exists, we use the [`ZSCORE`]({{< relref "/commands/zscore" >}}) command:
+
+    ZSCORE zset a => 10
+    ZSCORE zset non_existing_element => NULL
+
+Sorted Sets are a very powerful data structure, you can query elements by
+score range, lexicographically, in reverse order, and so forth.
+To know more [please check the Sorted Set sections in the official Redis commands documentation]({{< relref "/commands/#sorted_set" >}}).
+
+The Hash data type
+---
+
+This is the last data structure we use in our program, and is extremely easy
+to grasp since there is an equivalent in almost every programming language out
+there: Hashes. Redis Hashes are basically like Ruby or Python hashes, a
+collection of fields associated with values:
+
+    HMSET myuser name Salvatore surname Sanfilippo country Italy
+    HGET myuser surname => Sanfilippo
+
+[`HMSET`]({{< relref "/commands/hmset" >}}) can be used to set fields in the hash, that can be retrieved with
+[`HGET`]({{< relref "/commands/hget" >}}) later. It is possible to check if a field exists with [`HEXISTS`]({{< relref "/commands/hexists" >}}), or
+to increment a hash field with [`HINCRBY`]({{< relref "/commands/hincrby" >}}) and so forth.
+
+Hashes are the ideal data structure to represent *objects*. For example we
+use Hashes in order to represent Users and Updates in our Twitter clone.
+
+Okay, we just exposed the basics of the Redis main data structures,
+we are ready to start coding!
+
+Prerequisites
+---
+
+If you haven't downloaded the [Retwis source code](https://github.com/antirez/retwis) already please grab it now. It contains a few PHP files, and also a copy of [Predis](https://github.com/nrk/predis), the PHP client library we use in this example.
+
+Another thing you probably want is a working Redis server. Just get the source, build with `make`, run with `./redis-server`, and you're ready to go. No configuration is required at all in order to play with or run Retwis on your computer.
+
+Data layout
+---
+
+When working with a relational database, a database schema must be designed so that we'd know the tables, indexes, and so on that the database will contain. We don't have tables in Redis, so what do we need to design? We need to identify what keys are needed to represent our objects and what kind of values these keys need to hold.
+
+Let's start with Users. We need to represent users, of course, with their username, userid, password, the set of users following a given user, the set of users a given user follows, and so on. The first question is, how should we identify a user? Like in a relational DB, a good solution is to identify different users with different numbers, so we can associate a unique ID with every user. Every other reference to this user will be done by id. Creating unique IDs is very simple to do by using our atomic [`INCR`]({{< relref "/commands/incr" >}}) operation. When we create a new user we can do something like this, assuming the user is called "antirez":
+
+    INCR next_user_id => 1000
+    HMSET user:1000 username antirez password p1pp0
+
+*Note: you should use a hashed password in a real application, for simplicity
+we store the password in clear text.*
+
+We use the `next_user_id` key in order to always get a unique ID for every new user. Then we use this unique ID to name the key holding a Hash with user's data. *This is a common design pattern* with key-values stores! Keep it in mind.
+Besides the fields already defined, we need some more stuff in order to fully define a User. For example, sometimes it can be useful to be able to get the user ID from the username, so every time we add a user, we also populate the `users` key, which is a Hash, with the username as field, and its ID as value.
+
+    HSET users antirez 1000
+
+This may appear strange at first, but remember that we are only able to access data in a direct way, without secondary indexes. It's not possible to tell Redis to return the key that holds a specific value. This is also *our strength*. This new paradigm is forcing us to organize data so that everything is accessible by _primary key_, speaking in relational DB terms.
+
+Followers, following, and updates
+---
+
+There is another central need in our system. A user might have users who follow them, which we'll call their followers. A user might follow other users, which we'll call a following. We have a perfect data structure for this. That is... Sets.
+The uniqueness of Sets elements, and the fact we can test in constant time for
+existence, are two interesting features. However what about also remembering
+the time at which a given user started following another one? In an enhanced
+version of our simple Twitter clone this may be useful, so instead of using
+a simple Set, we use a Sorted Set, using the user ID of the following or follower
+user as element, and the unix time at which the relation between the users
+was created, as our score.
+
+So let's define our keys:
+
+    followers:1000 => Sorted Set of uids of all the followers users
+    following:1000 => Sorted Set of uids of all the following users
+
+We can add new followers with:
+
+    ZADD followers:1000 1401267618 1234 => Add user 1234 with time 1401267618
+
+Another important thing we need is a place where we can add the updates to display in the user's home page. We'll need to access this data in chronological order later, from the most recent update to the oldest, so the perfect kind of data structure for this is a List. Basically every new update will be [`LPUSH`]({{< relref "/commands/lpush" >}})ed in the user updates key, and thanks to [`LRANGE`]({{< relref "/commands/lrange" >}}), we can implement pagination and so on. Note that we use the words _updates_ and _posts_ interchangeably, since updates are actually "little posts" in some way.
+
+    posts:1000 => a List of post ids - every new post is LPUSHed here.
+
+This list is basically the User timeline. We'll push the IDs of her/his own
+posts, and, the IDs of all the posts of created by the following users.
+Basically, we'll implement a write fanout.
+
+Authentication
+---
+
+OK, we have more or less everything about the user except for authentication. We'll handle authentication in a simple but robust way: we don't want to use PHP sessions, as our system must be ready to be distributed among different web servers easily, so we'll keep the whole state in our Redis database. All we need is a random **unguessable** string to set as the cookie of an authenticated user, and a key that will contain the user ID of the client holding the string.
+
+We need two things in order to make this thing work in a robust way.
+First: the current authentication *secret* (the random unguessable string)
+should be part of the User object, so when the user is created we also set
+an `auth` field in its Hash:
+
+    HSET user:1000 auth fea5e81ac8ca77622bed1c2132a021f9
+
+Moreover, we need a way to map authentication secrets to user IDs, so
+we also take an `auths` key, which has as value a Hash type mapping
+authentication secrets to user IDs.
+
+    HSET auths fea5e81ac8ca77622bed1c2132a021f9 1000
+
+In order to authenticate a user we'll do these simple steps (see the `login.php` file in the Retwis source code):
+
+ * Get the username and password via the login form.
+ * Check if the `username` field actually exists in the `users` Hash.
+ * If it exists we have the user id, (i.e. 1000).
+ * Check if user:1000 password matches, if not, return an error message.
+ * Ok authenticated! Set "fea5e81ac8ca77622bed1c2132a021f9" (the value of user:1000 `auth` field) as the "auth" cookie.
+
+This is the actual code:
+
+    include("retwis.php");
+
+    # Form sanity checks
+    if (!gt("username") || !gt("password"))
+        goback("You need to enter both username and password to login.");
+
+    # The form is ok, check if the username is available
+    $username = gt("username");
+    $password = gt("password");
+    $r = redisLink();
+    $userid = $r->hget("users",$username);
+    if (!$userid)
+        goback("Wrong username or password");
+    $realpassword = $r->hget("user:$userid","password");
+    if ($realpassword != $password)
+        goback("Wrong username or password");
+
+    # Username / password OK, set the cookie and redirect to index.php
+    $authsecret = $r->hget("user:$userid","auth");
+    setcookie("auth",$authsecret,time()+3600*24*365);
+    header("Location: index.php");
+
+This happens every time a user logs in, but we also need a function `isLoggedIn` in order to check if a given user is already authenticated or not. These are the logical steps preformed by the `isLoggedIn` function:
+
+ * Get the "auth" cookie from the user. If there is no cookie, the user is not logged in, of course. Let's call the value of the cookie `<authcookie>`.
+ * Check if `<authcookie>` field in the `auths` Hash exists, and what the value (the user ID) is (1000 in the example).
+ * In order for the system to be more robust, also verify that user:1000 auth field also matches.
+ * OK the user is authenticated, and we loaded a bit of information in the `$User` global variable.
+
+The code is simpler than the description, possibly:
+
+    function isLoggedIn() {
+        global $User, $_COOKIE;
+
+        if (isset($User)) return true;
+
+        if (isset($_COOKIE['auth'])) {
+            $r = redisLink();
+            $authcookie = $_COOKIE['auth'];
+            if ($userid = $r->hget("auths",$authcookie)) {
+                if ($r->hget("user:$userid","auth") != $authcookie) return false;
+                loadUserInfo($userid);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function loadUserInfo($userid) {
+        global $User;
+
+        $r = redisLink();
+        $User['id'] = $userid;
+        $User['username'] = $r->hget("user:$userid","username");
+        return true;
+    }
+
+Having `loadUserInfo` as a separate function is overkill for our application, but it's a good approach in a complex application. The only thing that's missing from all the authentication is the logout. What do we do on logout? That's simple, we'll just change the random string in user:1000 `auth` field, remove the old authentication secret from the `auths` Hash, and add the new one.
+
+*Important:* the logout procedure explains why we don't just authenticate the user after looking up the authentication secret in the `auths` Hash, but double check it against user:1000 `auth` field. The true authentication string is the latter, while the `auths` Hash is just an authentication field that may even be volatile, or, if there are bugs in the program or a script gets interrupted, we may even end with multiple entries in the `auths` key pointing to the same user ID. The logout code is the following (`logout.php`):
+
+    include("retwis.php");
+
+    if (!isLoggedIn()) {
+        header("Location: index.php");
+        exit;
+    }
+
+    $r = redisLink();
+    $newauthsecret = getrand();
+    $userid = $User['id'];
+    $oldauthsecret = $r->hget("user:$userid","auth");
+
+    $r->hset("user:$userid","auth",$newauthsecret);
+    $r->hset("auths",$newauthsecret,$userid);
+    $r->hdel("auths",$oldauthsecret);
+
+    header("Location: index.php");
+
+That is just what we described and should be simple to understand.
+
+Updates
+---
+
+Updates, also known as posts, are even simpler. In order to create a new post in the database we do something like this:
+
+    INCR next_post_id => 10343
+    HMSET post:10343 user_id $owner_id time $time body "I'm having fun with Retwis"
+
+As you can see each post is just represented by a Hash with three fields. The ID of the user owning the post, the time at which the post was published, and finally, the body of the post, which is, the actual status message.
+
+After we create a post and we obtain the post ID, we need to LPUSH the ID in the timeline of every user that is following the author of the post, and of course in the list of posts of the author itself (everybody is virtually following herself/himself). This is the file `post.php` that shows how this is performed:
+
+    include("retwis.php");
+
+    if (!isLoggedIn() || !gt("status")) {
+        header("Location:index.php");
+        exit;
+    }
+
+    $r = redisLink();
+    $postid = $r->incr("next_post_id");
+    $status = str_replace("\n"," ",gt("status"));
+    $r->hmset("post:$postid","user_id",$User['id'],"time",time(),"body",$status);
+    $followers = $r->zrange("followers:".$User['id'],0,-1);
+    $followers[] = $User['id']; /* Add the post to our own posts too */
+
+    foreach($followers as $fid) {
+        $r->lpush("posts:$fid",$postid);
+    }
+    # Push the post on the timeline, and trim the timeline to the
+    # newest 1000 elements.
+    $r->lpush("timeline",$postid);
+    $r->ltrim("timeline",0,1000);
+
+    header("Location: index.php");
+
+The core of the function is the `foreach` loop. We use [`ZRANGE`]({{< relref "/commands/zrange" >}}) to get all the followers of the current user, then the loop will [`LPUSH`]({{< relref "/commands/lpush" >}}) the push the post in every follower timeline List.
+
+Note that we also maintain a global timeline for all the posts, so that in the Retwis home page we can show everybody's updates easily. This requires just doing an [`LPUSH`]({{< relref "/commands/lpush" >}}) to the `timeline` List. Let's face it, aren't you starting to think it was a bit strange to have to sort things added in chronological order using `ORDER BY` with SQL? I think so.
+
+There is an interesting thing to notice in the code above: we used a new
+command called [`LTRIM`]({{< relref "/commands/ltrim" >}}) after we perform the [`LPUSH`]({{< relref "/commands/lpush" >}}) operation in the global
+timeline. This is used in order to trim the list to just 1000 elements. The
+global timeline is actually only used in order to show a few posts in the
+home page, there is no need to have the full history of all the posts.
+
+Basically [`LTRIM`]({{< relref "/commands/ltrim" >}}) + [`LPUSH`]({{< relref "/commands/lpush" >}}) is a way to create a *capped collection* in Redis.
+
+Paginating updates
+---
+
+Now it should be pretty clear how we can use [`LRANGE`]({{< relref "/commands/lrange" >}}) in order to get ranges of posts, and render these posts on the screen. The code is simple:
+
+    function showPost($id) {
+        $r = redisLink();
+        $post = $r->hgetall("post:$id");
+        if (empty($post)) return false;
+
+        $userid = $post['user_id'];
+        $username = $r->hget("user:$userid","username");
+        $elapsed = strElapsed($post['time']);
+        $userlink = "<a class=\"username\" href=\"profile.php?u=".urlencode($username)."\">".utf8entities($username)."</a>";
+
+        echo('<div class="post">'.$userlink.' '.utf8entities($post['body'])."<br>");
+        echo('<i>posted '.$elapsed.' ago via web</i></div>');
+        return true;
+    }
+
+    function showUserPosts($userid,$start,$count) {
+        $r = redisLink();
+        $key = ($userid == -1) ? "timeline" : "posts:$userid";
+        $posts = $r->lrange($key,$start,$start+$count);
+        $c = 0;
+        foreach($posts as $p) {
+            if (showPost($p)) $c++;
+            if ($c == $count) break;
+        }
+        return count($posts) == $count+1;
+    }
+
+`showPost` will simply convert and print a Post in HTML while `showUserPosts` gets a range of posts and then passes them to `showPosts`.
+
+*Note: [`LRANGE`]({{< relref "/commands/lrange" >}}) is not very efficient if the list of posts start to be very
+big, and we want to access elements which are in the middle of the list, since Redis Lists are backed by linked lists. If a system is designed for
+deep pagination of million of items, it is better to resort to Sorted Sets
+instead.*
+
+Following users
+---
+
+It is not hard, but we did not yet check how we create following / follower relationships. If user ID 1000 (antirez) wants to follow user ID 5000 (pippo), we need to create both a following and a follower relationship. We just need to [`ZADD`]({{< relref "/commands/zadd" >}}) calls:
+
+        ZADD following:1000 5000
+        ZADD followers:5000 1000
+
+Note the same pattern again and again. In theory with a relational database, the list of following and followers would be contained in a single table with fields like `following_id` and `follower_id`. You can extract the followers or following of every user using an SQL query. With a key-value DB things are a bit different since we need to set both the `1000 is following 5000` and `5000 is followed by 1000` relations. This is the price to pay, but on the other hand accessing the data is simpler and extremely fast. Having these things as separate sets allows us to do interesting stuff. For example, using [`ZINTERSTORE`]({{< relref "/commands/zinterstore" >}}) we can have the intersection of `following` of two different users, so we may add a feature to our Twitter clone so that it is able to tell you very quickly when you visit somebody else's profile, "you and Alice have 34 followers in common", and things like that.
+
+You can find the code that sets or removes a following / follower relation in the `follow.php` file.
+
+Making it horizontally scalable
+---
+
+Gentle reader, if you read till this point you are already a hero. Thank you. Before talking about scaling horizontally it is worth checking performance on a single server. Retwis is *extremely fast*, without any kind of cache. On a very slow and loaded server, an Apache benchmark with 100 parallel clients issuing 100000 requests measured the average pageview to take 5 milliseconds. This means you can serve millions of users every day with just a single Linux box, and this one was monkey ass slow... Imagine the results with more recent hardware.
+
+However you can't go with a single server forever, how do you scale a key-value
+store?
+
+Retwis does not perform any multi-keys operation, so making it scalable is
+simple: you may use client-side sharding, or something like a sharding proxy
+like Twemproxy, or the upcoming Redis Cluster.
+
+To know more about those topics please read
+[our documentation about sharding]({{< relref "/operate/oss_and_stack/management/scaling" >}}). However, the point here
+to stress is that in a key-value store, if you design with care, the data set
+is split among **many independent small keys**. To distribute those keys
+to multiple nodes is more straightforward and predictable compared to using
+a semantically more complex database system.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'A distributed lock pattern with Redis
+
+  '
+linkTitle: Distributed locks
+title: Distributed Locks with Redis
+weight: 1
+---
+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.
+
+This page describes a more canonical algorithm to implement
+distributed locks with Redis. We propose an algorithm, called **Redlock**,
+which implements a DLM which we believe to be safer than the vanilla single
+instance approach. We hope that the community will analyze it, provide
+feedback, and use it as a starting point for the implementations or more
+complex or alternative designs.
+
+## Implementations
+
+Before describing the algorithm, here are a few links to implementations
+already available that can be used for reference.
+
+* [Redlock-rb](https://github.com/antirez/redlock-rb) (Ruby implementation). There is also a [fork of Redlock-rb](https://github.com/leandromoreira/redlock-rb) that adds a gem for easy distribution.
+* [RedisQueuedLocks](https://github.com/0exp/redis_queued_locks) (Ruby implementation).
+* [Redlock-py](https://github.com/SPSCommerce/redlock-py) (Python implementation).
+* [Pottery](https://github.com/brainix/pottery#redlock) (Python implementation).
+* [Aioredlock](https://github.com/joanvila/aioredlock) (Asyncio Python implementation).
+* [RedisMutex](https://github.com/malkusch/lock#redismutex) (PHP implementation with both [Redis extension](https://github.com/phpredis/phpredis) and [Predis library](https://github.com/predis/predis) clients support).
+* [Redlock-php](https://github.com/ronnylt/redlock-php) (PHP implementation).
+* [cheprasov/php-redis-lock](https://github.com/cheprasov/php-redis-lock) (PHP library for locks).
+* [rtckit/react-redlock](https://github.com/rtckit/reactphp-redlock) (Async PHP implementation).
+* [Redsync](https://github.com/go-redsync/redsync) (Go implementation).
+* [Redisson](https://github.com/mrniko/redisson) (Java implementation).
+* [Redis::DistLock](https://github.com/sbertrang/redis-distlock) (Perl implementation).
+* [Redlock-cpp](https://github.com/jacket-code/redlock-cpp) (C++ implementation).
+* [Redis-plus-plus](https://github.com/sewenew/redis-plus-plus/#redlock) (C++ implementation).
+* [Redlock-cs](https://github.com/kidfashion/redlock-cs) (C#/.NET implementation).
+* [RedLock.net](https://github.com/samcook/RedLock.net) (C#/.NET implementation). Includes async and lock extension support.
+* [ScarletLock](https://github.com/psibernetic/scarletlock) (C# .NET implementation with configurable datastore).
+* [Redlock4Net](https://github.com/LiZhenNet/Redlock4Net) (C# .NET implementation).
+* [node-redlock](https://github.com/mike-marcacci/node-redlock) (NodeJS implementation). Includes support for lock extension.
+* [Deno DLM](https://github.com/oslabs-beta/Deno-Redlock) (Deno implementation)
+* [Rslock](https://github.com/hexcowboy/rslock) (Rust implementation). Includes async and lock extension support.
+
+## Safety and Liveness Guarantees
+
+We are going to model our design with just three properties that, from our point of view, are the minimum guarantees needed to use distributed locks in an effective way.
+
+1. Safety property: Mutual exclusion. At any given moment, only one client can hold a lock.
+2. Liveness property A: Deadlock free. Eventually it is always possible to acquire a lock, even if the client that locked a resource crashes or gets partitioned.
+3. Liveness property B: Fault tolerance. As long as the majority of Redis nodes are up, clients are able to acquire and release locks.
+
+## Why Failover-based Implementations Are Not Enough
+
+To understand what we want to improve, let’s analyze the current state of affairs with most Redis-based distributed lock libraries.
+
+The simplest way to use Redis to lock a resource is to create a key in an instance. The key is usually created with a limited time to live, using the Redis expires feature, so that eventually it will get released (property 2 in our list). When the client needs to release the resource, it deletes the key.
+
+Superficially this works well, but there is a problem: this is a single point of failure in our architecture. What happens if the Redis master goes down?
+Well, let’s add a replica! And use it if the master is unavailable. This is unfortunately not viable. By doing so we can’t implement our safety property of mutual exclusion, because Redis replication is asynchronous.
+
+There is a race condition with this model:
+
+1. Client A acquires the lock in the master.
+2. The master crashes before the write to the key is transmitted to the replica.
+3. The replica gets promoted to master.
+4. Client B acquires the lock to the same resource A already holds a lock for. **SAFETY VIOLATION!**
+
+Sometimes it is perfectly fine that, under special circumstances, for example during a failure, multiple clients can hold the lock at the same time.
+If this is the case, you can use your replication based solution. Otherwise we suggest to implement the solution described in this document.
+
+## Correct Implementation with a Single Instance
+
+Before trying to overcome the limitation of the single instance setup described above, let’s check how to do it correctly in this simple case, since this is actually a viable solution in applications where a race condition from time to time is acceptable, and because locking into a single instance is the foundation we’ll use for the distributed algorithm described here.
+
+To acquire the lock, the way to go is the following:
+
+        SET resource_name my_random_value NX PX 30000
+
+The command will set the key only if it does not already exist (`NX` option), with an expire of 30000 milliseconds (`PX` option).
+The key is set to a value “my\_random\_value”. This value must be unique across all clients and all lock requests.
+
+Basically the random value is used in order to release the lock in a safe way, with a script that tells Redis: remove the key only if it exists and the value stored at the key is exactly the one I expect to be. This is accomplished by the following Lua script:
+
+    if redis.call("get",KEYS[1]) == ARGV[1] then
+        return redis.call("del",KEYS[1])
+    else
+        return 0
+    end
+
+This is important in order to avoid removing a lock that was created by another client. For example a client may acquire the lock, get blocked performing some operation for longer than the lock validity time (the time at which the key will expire), and later remove the lock, that was already acquired by some other client.
+Using just [`DEL`]({{< relref "/commands/del" >}}) is not safe as a client may remove another client's lock. With the above script instead every lock is “signed” with a random string, so the lock will be removed only if it is still the one that was set by the client trying to remove it.
+
+What should this random string be? We assume it’s 20 bytes from `/dev/urandom`, but you can find cheaper ways to make it unique enough for your tasks.
+For example a safe pick is to seed RC4 with `/dev/urandom`, and generate a pseudo random stream from that.
+A simpler solution is to use a UNIX timestamp with microsecond precision, concatenating the timestamp with a client ID. It is not as safe, but probably sufficient for most environments.
+
+The "lock validity time" is the time we use as the key's time to live. It is both the auto release time, and the time the client has in order to perform the operation required before another client may be able to acquire the lock again, without technically violating the mutual exclusion guarantee, which is only limited to a given window of time from the moment the lock is acquired.
+
+So now we have a good way to acquire and release the lock. With this system, reasoning about a non-distributed system composed of a single, always available, instance, is safe. Let’s extend the concept to a distributed system where we don’t have such guarantees.
+
+## The Redlock Algorithm
+
+In the distributed version of the algorithm we assume we have N Redis masters. Those nodes are totally independent, so we don’t use replication or any other implicit coordination system. We already described how to acquire and release the lock safely in a single instance. We take for granted that the algorithm will use this method to acquire and release the lock in a single instance. In our examples we set N=5, which is a reasonable value, so we need to run 5 Redis masters on different computers or virtual machines in order to ensure that they’ll fail in a mostly independent way.
+
+In order to acquire the lock, the client performs the following operations:
+
+1. It gets the current time in milliseconds.
+2. It tries to acquire the lock in all the N instances sequentially, using the same key name and random value in all the instances. During step 2, when setting the lock in each instance, the client uses a timeout which is small compared to the total lock auto-release time in order to acquire it. For example if the auto-release time is 10 seconds, the timeout could be in the ~ 5-50 milliseconds range. This prevents the client from remaining blocked for a long time trying to talk with a Redis node which is down: if an instance is not available, we should try to talk with the next instance ASAP.
+3. The client computes how much time elapsed in order to acquire the lock, by subtracting from the current time the timestamp obtained in step 1. If and only if the client was able to acquire the lock in the majority of the instances (at least 3), and the total time elapsed to acquire the lock is less than lock validity time, the lock is considered to be acquired.
+4. If the lock was acquired, its validity time is considered to be the initial validity time minus the time elapsed, as computed in step 3.
+5. If the client failed to acquire the lock for some reason (either it was not able to lock N/2+1 instances or the validity time is negative), it will try to unlock all the instances (even the instances it believed it was not able to lock).
+
+### Is the Algorithm Asynchronous?
+
+The algorithm relies on the assumption that while there is no synchronized clock across the processes, the local time in every process updates at approximately at the same rate, with a small margin of error compared to the auto-release time of the lock. This assumption closely resembles a real-world computer: every computer has a local clock and we can usually rely on different computers to have a clock drift which is small.
+
+At this point we need to better specify our mutual exclusion rule: it is guaranteed only as long as the client holding the lock terminates its work within the lock validity time (as obtained in step 3), minus some time (just a few milliseconds in order to compensate for clock drift between processes).
+
+This paper contains more information about similar systems requiring a bound *clock drift*: [Leases: an efficient fault-tolerant mechanism for distributed file cache consistency](http://dl.acm.org/citation.cfm?id=74870).
+
+### Retry on Failure
+
+When a client is unable to acquire the lock, it should try again after a random delay in order to try to desynchronize multiple clients trying to acquire the lock for the same resource at the same time (this may result in a split brain condition where nobody wins). Also the faster a client tries to acquire the lock in the majority of Redis instances, the smaller the window for a split brain condition (and the need for a retry), so ideally the client should try to send the [`SET`]({{< relref "/commands/set" >}}) commands to the N instances at the same time using multiplexing.
+
+It is worth stressing how important it is for clients that fail to acquire the majority of locks, to release the (partially) acquired locks ASAP, so that there is no need to wait for key expiry in order for the lock to be acquired again (however if a network partition happens and the client is no longer able to communicate with the Redis instances, there is an availability penalty to pay as it waits for key expiration).
+
+### Releasing the Lock
+
+Releasing the lock is simple, and can be performed whether or not the client believes it was able to successfully lock a given instance.
+
+### Safety Arguments
+
+Is the algorithm safe? Let's examine what happens in different scenarios.
+
+To start let’s assume that a client is able to acquire the lock in the majority of instances. All the instances will contain a key with the same time to live. However, the key was set at different times, so the keys will also expire at different times. But if the first key was set at worst at time T1 (the time we sample before contacting the first server) and the last key was set at worst at time T2 (the time we obtained the reply from the last server), we are sure that the first key to expire in the set will exist for at least `MIN_VALIDITY=TTL-(T2-T1)-CLOCK_DRIFT`. All the other keys will expire later, so we are sure that the keys will be simultaneously set for at least this time.
+
+During the time that the majority of keys are set, another client will not be able to acquire the lock, since N/2+1 SET NX operations can’t succeed if N/2+1 keys already exist. So if a lock was acquired, it is not possible to re-acquire it at the same time (violating the mutual exclusion property).
+
+However we want to also make sure that multiple clients trying to acquire the lock at the same time can’t simultaneously succeed.
+
+If a client locked the majority of instances using a time near, or greater, than the lock maximum validity time (the TTL we use for SET basically), it will consider the lock invalid and will unlock the instances, so we only need to consider the case where a client was able to lock the majority of instances in a time which is less than the validity time. In this case for the argument already expressed above, for `MIN_VALIDITY` no client should be able to re-acquire the lock. So multiple clients will be able to lock N/2+1 instances at the same time (with "time" being the end of Step 2) only when the time to lock the majority was greater than the TTL time, making the lock invalid.
+
+### Liveness Arguments
+
+The system liveness is based on three main features:
+
+1. The auto release of the lock (since keys expire): eventually keys are available again to be locked.
+2. The fact that clients, usually, will cooperate removing the locks when the lock was not acquired, or when the lock was acquired and the work terminated, making it likely that we don’t have to wait for keys to expire to re-acquire the lock.
+3. The fact that when a client needs to retry a lock, it waits a time which is comparably greater than the time needed to acquire the majority of locks, in order to probabilistically make split brain conditions during resource contention unlikely.
+
+However, we pay an availability penalty equal to [`TTL`]({{< relref "/commands/ttl" >}}) time on network partitions, so if there are continuous partitions, we can pay this penalty indefinitely.
+This happens every time a client acquires a lock and gets partitioned away before being able to remove the lock.
+
+Basically if there are infinite continuous network partitions, the system may become not available for an infinite amount of time.
+
+### Performance, Crash Recovery and fsync
+
+Many users using Redis as a lock server need high performance in terms of both latency to acquire and release a lock, and number of acquire / release operations that it is possible to perform per second. In order to meet this requirement, the strategy to talk with the N Redis servers to reduce latency is definitely multiplexing (putting the socket in non-blocking mode, send all the commands, and read all the commands later, assuming that the RTT between the client and each instance is similar).
+
+However there is another consideration around persistence if we want to target a crash-recovery system model.
+
+Basically to see the problem here, let’s assume we configure Redis without persistence at all. A client acquires the lock in 3 of 5 instances. One of the instances where the client was able to acquire the lock is restarted, at this point there are again 3 instances that we can lock for the same resource, and another client can lock it again, violating the safety property of exclusivity of lock.
+
+If we enable AOF persistence, things will improve quite a bit. For example we can upgrade a server by sending it a [`SHUTDOWN`]({{< relref "/commands/shutdown" >}}) command and restarting it. Because Redis expires are semantically implemented so that time still elapses when the server is off, all our requirements are fine.
+However everything is fine as long as it is a clean shutdown. What about a power outage? If Redis is configured, as by default, to fsync on disk every second, it is possible that after a restart our key is missing. In theory, if we want to guarantee the lock safety in the face of any kind of instance restart, we need to enable `fsync=always` in the persistence settings. This will affect performance due to the additional sync overhead.
+
+However things are better than they look like at a first glance. Basically,
+the algorithm safety is retained as long as when an instance restarts after a
+crash, it no longer participates to any **currently active** lock.  This means that the
+set of currently active locks when the instance restarts were all obtained
+by locking instances other than the one which is rejoining the system.
+
+To guarantee this we just need to make an instance, after a crash, unavailable
+for at least a bit more than the max [`TTL`]({{< relref "/commands/ttl" >}}) we use.  This is the time needed
+for all the keys about the locks that existed when the instance crashed to
+become invalid and be automatically released.
+
+Using *delayed restarts* it is basically possible to achieve safety even
+without any kind of Redis persistence available, however note that this may
+translate into an availability penalty. For example if a majority of instances
+crash, the system will become globally unavailable for [`TTL`]({{< relref "/commands/ttl" >}}) (here globally means
+that no resource at all will be lockable during this time).
+
+### Making the algorithm more reliable: Extending the lock
+
+If the work performed by clients consists of small steps, it is possible to
+use smaller lock validity times by default, and extend the algorithm implementing
+a lock extension mechanism. Basically the client, if in the middle of the
+computation while the lock validity is approaching a low value, may extend the
+lock by sending a Lua script to all the instances that extends the TTL of the key
+if the key exists and its value is still the random value the client assigned
+when the lock was acquired.
+
+The client should only consider the lock re-acquired if it was able to extend
+the lock into the majority of instances, and within the validity time
+(basically the algorithm to use is very similar to the one used when acquiring
+the lock).
+
+However this does not technically change the algorithm, so the maximum number
+of lock reacquisition attempts should be limited, otherwise one of the liveness
+properties is violated.
+
+### Disclaimer about consistency
+
+Please consider thoroughly reviewing the [Analysis of Redlock](#analysis-of-redlock) section at the end of this page.
+Martin Kleppman's article and antirez's answer to it are very relevant.
+If you are concerned about consistency and correctness, you should pay attention to the following topics:
+
+1. You should implement fencing tokens.
+  This is especially important for processes that can take significant time and applies to any distributed locking system.
+  Extending locks' lifetime is also an option, but don´t assume that a lock is retained as long as the process that had acquired it is alive.
+2. Redis is not using monotonic clock for TTL expiration mechanism.
+  That means that a wall-clock shift may result in a lock being acquired by more than one process.
+  Even though the problem can be mitigated by preventing admins from manually setting the server's time and setting up NTP properly, there's still a chance of this issue occurring in real life and compromising consistency.
+
+## Want to help?
+
+If you are into distributed systems, it would be great to have your opinion / analysis. Also reference implementations in other languages could be great.
+
+Thanks in advance!
+
+## Analysis of Redlock
+---
+
+1. Martin Kleppmann [analyzed Redlock here](http://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html). A counterpoint to this analysis can be [found here](http://antirez.com/news/101).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Writing data in bulk using the Redis protocol
+
+  '
+linkTitle: Bulk loading
+title: Bulk loading
+weight: 1
+---
+
+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.
+
+Only a small percentage of clients support non-blocking I/O, and not all the
+clients are able to parse the replies in an efficient way in order to maximize
+throughput. For all of these reasons the preferred way to mass import data into
+Redis is to generate a text file containing the Redis protocol, in raw format,
+in order to call the commands needed to insert the required data.
+
+For instance if I need to generate a large data set where there are billions
+of keys in the form: `keyN -> ValueN' I will create a file containing the
+following commands in the Redis protocol format:
+
+    SET Key0 Value0
+    SET Key1 Value1
+    ...
+    SET KeyN ValueN
+
+Once this file is created, the remaining action is to feed it to Redis
+as fast as possible. In the past the way to do this was to use the
+`netcat` with the following command:
+
+    (cat data.txt; sleep 10) | nc localhost 6379 > /dev/null
+
+However this is not a very reliable way to perform mass import because netcat
+does not really know when all the data was transferred and can't check for
+errors. In 2.6 or later versions of Redis the `redis-cli` utility
+supports a new mode called **pipe mode** that was designed in order to perform
+bulk loading.
+
+Using the pipe mode the command to run looks like the following:
+
+    cat data.txt | redis-cli --pipe
+
+That will produce an output similar to this:
+
+    All data transferred. Waiting for the last reply...
+    Last reply received from server.
+    errors: 0, replies: 1000000
+
+The redis-cli utility will also make sure to only redirect errors received
+from the Redis instance to the standard output.
+
+### Generating Redis Protocol
+
+The Redis protocol is extremely simple to generate and parse, and is
+[Documented here]({{< relref "/develop/reference/protocol-spec" >}}). However in order to generate protocol for
+the goal of bulk loading you don't need to understand every detail of the
+protocol, but just that every command is represented in the following way:
+
+    *<args><cr><lf>
+    $<len><cr><lf>
+    <arg0><cr><lf>
+    <arg1><cr><lf>
+    ...
+    <argN><cr><lf>
+
+Where `<cr>` means "\r" (or ASCII character 13) and `<lf>` means "\n" (or ASCII character 10).
+
+For instance the command **SET key value** is represented by the following protocol:
+
+    *3<cr><lf>
+    $3<cr><lf>
+    SET<cr><lf>
+    $3<cr><lf>
+    key<cr><lf>
+    $5<cr><lf>
+    value<cr><lf>
+
+Or represented as a quoted string:
+
+    "*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n"
+
+The file you need to generate for bulk loading is just composed of commands
+represented in the above way, one after the other.
+
+The following Ruby function generates valid protocol:
+
+    def gen_redis_proto(*cmd)
+        proto = ""
+        proto << "*"+cmd.length.to_s+"\r\n"
+        cmd.each{|arg|
+            proto << "$"+arg.to_s.bytesize.to_s+"\r\n"
+            proto << arg.to_s+"\r\n"
+        }
+        proto
+    end
+
+    puts gen_redis_proto("SET","mykey","Hello World!").inspect
+
+Using the above function it is possible to easily generate the key value pairs
+in the above example, with this program:
+
+    (0...1000).each{|n|
+        STDOUT.write(gen_redis_proto("SET","Key#{n}","Value#{n}"))
+    }
+
+We can run the program directly in pipe to redis-cli in order to perform our
+first mass import session.
+
+    $ ruby proto.rb | redis-cli --pipe
+    All data transferred. Waiting for the last reply...
+    Last reply received from server.
+    errors: 0, replies: 1000
+
+### How the pipe mode works under the hood
+
+The magic needed inside the pipe mode of redis-cli is to be as fast as netcat
+and still be able to understand when the last reply was sent by the server
+at the same time.
+
+This is obtained in the following way:
+
++ redis-cli --pipe tries to send data as fast as possible to the server.
++ At the same time it reads data when available, trying to parse it.
++ Once there is no more data to read from stdin, it sends a special **ECHO**
+command with a random 20 byte string: we are sure this is the latest command
+sent, and we are sure we can match the reply checking if we receive the same
+20 bytes as a bulk reply.
++ Once this special final command is sent, the code receiving replies starts
+to match replies with these 20 bytes. When the matching reply is reached it
+can exit with success.
+
+Using this trick we don't need to parse the protocol we send to the server
+in order to understand how many commands we are sending, but just the replies.
+
+However while parsing the replies we take a counter of all the replies parsed
+so that at the end we are able to tell the user the amount of commands
+transferred to the server by the mass insert session.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Novel patterns for working with Redis data structures
+linkTitle: Patterns
+title: Redis programming patterns
+weight: 6
+---
+
+The following documents describe some novel development patterns you can use with Redis.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Building secondary indexes in Redis
+linkTitle: Secondary indexing
+title: Secondary indexing
+weight: 1
+---
+
+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.
+
+This document explains how it is possible to create indexes in Redis using the following data structures:
+
+* Hashes and JSON documents, using a variety of field types; used in conjunction with the Redis query engine.
+* Sorted sets to create secondary indexes by ID or other numerical fields.
+* Sorted sets with lexicographical ranges for creating more advanced secondary indexes, composite indexes and graph traversal indexes.
+* Sets for creating random indexes.
+* Lists for creating simple iterable indexes and last N items indexes.
+* Time series with labels.
+
+Implementing and maintaining indexes with Redis is an advanced topic, so most
+users that need to perform complex queries on data should understand if they
+are better served by a relational store. However often, especially in caching
+scenarios, there is the explicit need to store indexed data into Redis in order to speedup common queries which require some form of indexing in order to be executed.
+
+## Hashes and JSON indexes
+
+The Redis query engine provides capabilities to index and query both hash and JSON keys using a variety of field types:
+
+* `TEXT`
+* `TAG`
+* `NUMERIC`
+* `GEO`
+* `VECTOR`
+* `GEOSHAPE`
+
+Once hash or JSON keys have been indexed using the [`FT.CREATE`]({{< relref "commands/ft.create" >}}) command, all keys that use the prefix defined in the index can be queried using the [`FT.SEARCH`]({{< relref "commands/ft.search" >}}) and [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate" >}}) commands.
+
+For more information on creating hash and JSON indexes, see the following pages.
+
+* [Hash indexes]({{< relref "/develop/interact/search-and-query/basic-constructs/schema-definition" >}})
+* [JSON indexes]({{< relref "/develop/interact/search-and-query/indexing" >}})
+
+## Simple numerical indexes with sorted sets
+
+The simplest secondary index you can create with Redis is by using the
+sorted set data type, which is a data structure representing a set of
+elements ordered by a floating point number which is the *score* of
+each element. Elements are ordered from the smallest to the highest score.
+
+Since the score is a double precision float, indexes you can build with
+vanilla sorted sets are limited to things where the indexing field is a number
+within a given range.
+
+The two commands to build these kind of indexes are [`ZADD`]({{< relref "/commands/zadd" >}}) and
+[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYSCORE` argument to respectively add items and retrieve items within a
+specified range.
+
+For instance, it is possible to index a set of person names by their
+age by adding element to a sorted set. The element will be the name of the
+person and the score will be the age.
+
+    ZADD myindex 25 Manuel
+    ZADD myindex 18 Anna
+    ZADD myindex 35 Jon
+    ZADD myindex 67 Helen
+
+In order to retrieve all persons with an age between 20 and 40, the following
+command can be used:
+
+    ZRANGE myindex 20 40 BYSCORE
+    1) "Manuel"
+    2) "Jon"
+
+By using the **WITHSCORES** option of [`ZRANGE`]({{< relref "/commands/zrange" >}}) it is also possible
+to obtain the scores associated with the returned elements.
+
+The [`ZCOUNT`]({{< relref "/commands/zcount" >}}) command can be used in order to retrieve the number of elements
+within a given range, without actually fetching the elements, which is also
+useful, especially given the fact the operation is executed in logarithmic
+time regardless of the size of the range.
+
+Ranges can be inclusive or exclusive, please refer to the [`ZRANGE`]({{< relref "/commands/zrange" >}})
+command documentation for more information.
+
+**Note**: Using the [`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYSCORE` and `REV` arguments, it is possible to query a range in
+reversed order, which is often useful when data is indexed in a given
+direction (ascending or descending) but we want to retrieve information
+the other way around.
+
+### Use object IDs as associated values
+
+In the above example we associated names to ages. However in general we
+may want to index some field of an object which is stored elsewhere.
+Instead of using the sorted set value directly to store the data associated
+with the indexed field, it is possible to store just the ID of the object.
+
+For example I may have Redis hashes representing users. Each user is
+represented by a single key, directly accessible by ID:
+
+    HMSET user:1 id 1 username antirez ctime 1444809424 age 38
+    HMSET user:2 id 2 username maria ctime 1444808132 age 42
+    HMSET user:3 id 3 username jballard ctime 1443246218 age 33
+
+If I want to create an index in order to query users by their age, I
+could do:
+
+    ZADD user.age.index 38 1
+    ZADD user.age.index 42 2
+    ZADD user.age.index 33 3
+
+This time the value associated with the score in the sorted set is the
+ID of the object. So once I query the index with [`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYSCORE` argument, I'll
+also have to retrieve the information I need with [`HGETALL`]({{< relref "/commands/hgetall" >}}) or similar
+commands. The obvious advantage is that objects can change without touching
+the index, as long as we don't change the indexed field.
+
+In the next examples we'll almost always use IDs as values associated with
+the index, since this is usually the more sounding design, with a few
+exceptions.
+
+### Update simple sorted set indexes
+
+Often we index things which change over time. In the above
+example, the age of the user changes every year. In such a case it would
+make sense to use the birth date as index instead of the age itself,
+but there are other cases where we simply want some field to change from
+time to time, and the index to reflect this change.
+
+The [`ZADD`]({{< relref "/commands/zadd" >}}) command makes updating simple indexes a very trivial operation
+since re-adding back an element with a different score and the same value
+will simply update the score and move the element at the right position,
+so if the user `antirez` turned 39 years old, in order to update the
+data in the hash representing the user, and in the index as well, we need
+to execute the following two commands:
+
+    HSET user:1 age 39
+    ZADD user.age.index 39 1
+
+The operation may be wrapped in a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) transaction in order to
+make sure both fields are updated or none.
+
+### Turn multi-dimensional data into linear data
+
+Indexes created with sorted sets are able to index only a single numerical
+value. Because of this you may think it is impossible to index something
+which has multiple dimensions using this kind of indexes, but actually this
+is not always true. If you can efficiently represent something
+multi-dimensional in a linear way, they it is often possible to use a simple
+sorted set for indexing.
+
+For example the [Redis geo indexing API]({{< relref "/commands/geoadd" >}}) uses a sorted
+set to index places by latitude and longitude using a technique called
+[Geo hash](https://en.wikipedia.org/wiki/Geohash). The sorted set score
+represents alternating bits of longitude and latitude, so that we map the
+linear score of a sorted set to many small *squares* in the earth surface.
+By doing an 8+1 style center plus neighborhoods search it is possible to
+retrieve elements by radius.
+
+### Limits of the score
+
+Sorted set elements scores are double precision floats. It means that
+they can represent different decimal or integer values with different
+errors, because they use an exponential representation internally.
+However what is interesting for indexing purposes is that the score is
+always able to represent without any error numbers between -9007199254740992
+and 9007199254740992, which is `-/+ 2^53`.
+
+When representing much larger numbers, you need a different form of indexing
+that is able to index numbers at any precision, called a lexicographical
+index.
+
+## Time series indexes
+
+When you create a new time series using the [`TS.CREATE`]({{< relref "commands/ts.create" >}}) command, you can associate one or more `LABELS` with it. Each label is a name-value pair, where the both name and value are text. Labels serve as a secondary index that allows you to execute queries on groups of time series keys using various time series commands.
+
+See the [time series quickstart guide]({{< relref "/develop/data-types/timeseries/quickstart#labels" >}}) for an example of creating a time series with a label.
+
+The [`TS.MGET`]({{< relref "commands/ts.mget" >}}), [`TS.MRANGE`]({{< relref "commands/ts.mrange" >}}), and [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange" >}}) commands operate on multiple time series based on specified labels or using a label-related filter expression. The [`TS.QUERYINDEX`]({{< relref "commands/ts.queryindex" >}}) command returns all time series keys matching a given label-related filter expression.
+
+## Lexicographical indexes
+
+Redis sorted sets have an interesting property. When elements are added
+with the same score, they are sorted lexicographically, comparing the
+strings as binary data with the `memcmp()` function.
+
+For people that don't know the C language nor the `memcmp` function, what
+it means is that elements with the same score are sorted comparing the
+raw values of their bytes, byte after byte. If the first byte is the same,
+the second is checked and so forth. If the common prefix of two strings is
+the same then the longer string is considered the greater of the two,
+so "foobar" is greater than "foo".
+
+There are commands such as [`ZRANGE`]({{< relref "/commands/zrange" >}}) and [`ZLEXCOUNT`]({{< relref "/commands/zlexcount" >}}) that
+are able to query and count ranges in a lexicographically fashion, assuming
+they are used with sorted sets where all the elements have the same score.
+
+This Redis feature is basically equivalent to a `b-tree` data structure which
+is often used in order to implement indexes with traditional databases.
+As you can guess, because of this, it is possible to use this Redis data
+structure in order to implement pretty fancy indexes.
+
+Before we dive into using lexicographical indexes, let's check how
+sorted sets behave in this special mode of operation. Since we need to
+add elements with the same score, we'll always use the special score of
+zero.
+
+    ZADD myindex 0 baaa
+    ZADD myindex 0 abbb
+    ZADD myindex 0 aaaa
+    ZADD myindex 0 bbbb
+
+Fetching all the elements from the sorted set immediately reveals that they
+are ordered lexicographically.
+
+    ZRANGE myindex 0 -1
+    1) "aaaa"
+    2) "abbb"
+    3) "baaa"
+    4) "bbbb"
+
+Now we can use [`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYLEX` argument in order to perform range queries.
+
+    ZRANGE myindex [a (b BYLEX
+    1) "aaaa"
+    2) "abbb"
+
+Note that in the range queries we prefixed the `min` and `max` elements
+identifying the range with the special characters `[` and `(`.
+This prefixes are mandatory, and they specify if the elements
+of the range are inclusive or exclusive. So the range `[a (b` means give me
+all the elements lexicographically between `a` inclusive and `b` exclusive,
+which are all the elements starting with `a`.
+
+There are also two more special characters indicating the infinitely negative
+string and the infinitely positive string, which are `-` and `+`.
+
+    ZRANGE myindex [b + BYLEX
+    1) "baaa"
+    2) "bbbb"
+
+That's it basically. Let's see how to use these features to build indexes.
+
+### A first example: completion
+
+An interesting application of indexing is completion. Completion is what
+happens when you start typing your query into a search engine: the user
+interface will anticipate what you are likely typing, providing common
+queries that start with the same characters.
+
+A naive approach to completion is to just add every single query we
+get from the user into the index. For example if the user searches `banana`
+we'll just do:
+
+    ZADD myindex 0 banana
+
+And so forth for each search query ever encountered. Then when we want to
+complete the user input, we execute a range query using [`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYLEX` argument.
+Imagine the user is typing "bit" inside the search form, and we want to
+offer possible search keywords starting for "bit". We send Redis a command
+like that:
+
+    ZRANGE myindex "[bit" "[bit\xff" BYLEX
+
+Basically we create a range using the string the user is typing right now
+as start, and the same string plus a trailing byte set to 255, which is `\xff` in the example, as the end of the range. This way we get all the strings that start for the string the user is typing.
+
+Note that we don't want too many items returned, so we may use the **LIMIT** option in order to reduce the number of results.
+
+### Add frequency into the mix
+
+The above approach is a bit naive, because all the user searches are the same
+in this way. In a real system we want to complete strings according to their
+frequency: very popular searches will be proposed with a higher probability
+compared to search strings typed very rarely.
+
+In order to implement something which depends on the frequency, and at the
+same time automatically adapts to future inputs, by purging searches that
+are no longer popular, we can use a very simple *streaming algorithm*.
+
+To start, we modify our index in order to store not just the search term,
+but also the frequency the term is associated with. So instead of just adding
+`banana` we add `banana:1`, where 1 is the frequency.
+
+    ZADD myindex 0 banana:1
+
+We also need logic in order to increment the index if the search term
+already exists in the index, so what we'll actually do is something like
+that:
+
+    ZRANGE myindex "[banana:" + BYLEX LIMIT 0 1
+    1) "banana:1"
+
+This will return the single entry of `banana` if it exists. Then we
+can increment the associated frequency and send the following two
+commands:
+
+    ZREM myindex 0 banana:1
+    ZADD myindex 0 banana:2
+
+Note that because it is possible that there are concurrent updates, the
+above three commands should be send via a [Lua script]({{< relref "/commands/eval" >}})
+instead, so that the Lua script will atomically get the old count and
+re-add the item with incremented score.
+
+So the result will be that, every time a user searches for `banana` we'll
+get our entry updated.
+
+There is more: our goal is to just have items searched very frequently.
+So we need some form of purging. When we actually query the index
+in order to complete the user input, we may see something like that:
+
+    ZRANGE myindex "[banana:" + BYLEX LIMIT 0 10
+    1) "banana:123"
+    2) "banaooo:1"
+    3) "banned user:49"
+    4) "banning:89"
+
+Apparently nobody searches for "banaooo", for example, but the query was
+performed a single time, so we end presenting it to the user.
+
+This is what we can do. Out of the returned items, we pick a random one,
+decrement its score by one, and re-add it with the new score.
+However if the score reaches 0, we simply remove the item from the list.
+You can use much more advanced systems, but the idea is that the index in
+the long run will contain top searches, and if top searches will change over
+the time it will adapt automatically.
+
+A refinement to this algorithm is to pick entries in the list according to
+their weight: the higher the score, the less likely entries are picked
+in order to decrement its score, or evict them.
+
+### Normalize strings for case and accents
+
+In the completion examples we always used lowercase strings. However
+reality is much more complex than that: languages have capitalized names,
+accents, and so forth.
+
+One simple way do deal with this issues is to actually normalize the
+string the user searches. Whatever the user searches for "Banana",
+"BANANA" or "Ba'nana" we may always turn it into "banana".
+
+However sometimes we may like to present the user with the original
+item typed, even if we normalize the string for indexing. In order to
+do this, what we do is to change the format of the index so that instead
+of just storing `term:frequency` we store `normalized:frequency:original`
+like in the following example:
+
+    ZADD myindex 0 banana:273:Banana
+
+Basically we add another field that we'll extract and use only for
+visualization. Ranges will always be computed using the normalized strings
+instead. This is a common trick which has multiple applications.
+
+### Add auxiliary information in the index
+
+When using a sorted set in a direct way, we have two different attributes
+for each object: the score, which we use as an index, and an associated
+value. When using lexicographical indexes instead, the score is always
+set to 0 and basically not used at all. We are left with a single string,
+which is the element itself.
+
+Like we did in the previous completion examples, we are still able to
+store associated data using separators. For example we used the colon in
+order to add the frequency and the original word for completion.
+
+In general we can add any kind of associated value to our indexing key.
+In order to use a lexicographical index to implement a simple key-value store
+we just store the entry as `key:value`:
+
+    ZADD myindex 0 mykey:myvalue
+
+And search for the key with:
+
+    ZRANGE myindex [mykey: + BYLEX LIMIT 0 1
+    1) "mykey:myvalue"
+
+Then we extract the part after the colon to retrieve the value.
+However a problem to solve in this case is collisions. The colon character
+may be part of the key itself, so it must be chosen in order to never
+collide with the key we add.
+
+Since lexicographical ranges in Redis are binary safe you can use any
+byte or any sequence of bytes. However if you receive untrusted user
+input, it is better to use some form of escaping in order to guarantee
+that the separator will never happen to be part of the key.
+
+For example if you use two null bytes as separator `"\0\0"`, you may
+want to always escape null bytes into two bytes sequences in your strings.
+
+### Numerical padding
+
+Lexicographical indexes may look like good only when the problem at hand
+is to index strings. Actually it is very simple to use this kind of index
+in order to perform indexing of arbitrary precision numbers.
+
+In the ASCII character set, digits appear in the order from 0 to 9, so
+if we left-pad numbers with leading zeroes, the result is that comparing
+them as strings will order them by their numerical value.
+
+    ZADD myindex 0 00324823481:foo
+    ZADD myindex 0 12838349234:bar
+    ZADD myindex 0 00000000111:zap
+
+    ZRANGE myindex 0 -1
+    1) "00000000111:zap"
+    2) "00324823481:foo"
+    3) "12838349234:bar"
+
+We effectively created an index using a numerical field which can be as
+big as we want. This also works with floating point numbers of any precision
+by making sure we left pad the numerical part with leading zeroes and the
+decimal part with trailing zeroes like in the following list of numbers:
+
+        01000000000000.11000000000000
+        01000000000000.02200000000000
+        00000002121241.34893482930000
+        00999999999999.00000000000000
+
+### Use numbers in binary form
+
+Storing numbers in decimal may use too much memory. An alternative approach
+is just to store numbers, for example 128 bit integers, directly in their
+binary form. However for this to work, you need to store the numbers in
+*big endian format*, so that the most significant bytes are stored before
+the least significant bytes. This way when Redis compares the strings with
+`memcmp()`, it will effectively sort the numbers by their value.
+
+Keep in mind that data stored in binary format is less observable for
+debugging, harder to parse and export. So it is definitely a trade off.
+
+## Composite indexes
+
+So far we explored ways to index single fields. However we all know that
+SQL stores are able to create indexes using multiple fields. For example
+I may index products in a very large store by room number and price.
+
+I need to run queries in order to retrieve all the products in a given
+room having a given price range. What I can do is to index each product
+in the following way:
+
+    ZADD myindex 0 0056:0028.44:90
+    ZADD myindex 0 0034:0011.00:832
+
+Here the fields are `room:price:product_id`. I used just four digits padding
+in the example for simplicity. The auxiliary data (the product ID) does not
+need any padding.
+
+With an index like that, to get all the products in room 56 having a price
+between 10 and 30 dollars is very easy. We can just run the following
+command:
+
+    ZRANGE myindex [0056:0010.00 [0056:0030.00 BYLEX
+
+The above is called a composed index. Its effectiveness depends on the
+order of the fields and the queries I want to run. For example the above
+index cannot be used efficiently in order to get all the products having
+a specific price range regardless of the room number. However I can use
+the primary key in order to run queries regardless of the price, like
+*give me all the products in room 44*.
+
+Composite indexes are very powerful, and are used in traditional stores
+in order to optimize complex queries. In Redis they could be useful both
+to implement a very fast in-memory Redis index of something stored into
+a traditional data store, or in order to directly index Redis data.
+
+## Update lexicographical indexes
+
+The value of the index in a lexicographical index can get pretty fancy
+and hard or slow to rebuild from what we store about the object. So one
+approach to simplify the handling of the index, at the cost of using more
+memory, is to also take alongside to the sorted set representing the index
+a hash mapping the object ID to the current index value.
+
+So for example, when we index we also add to a hash:
+
+    MULTI
+    ZADD myindex 0 0056:0028.44:90
+    HSET index.content 90 0056:0028.44:90
+    EXEC
+
+This is not always needed, but simplifies the operations of updating
+the index. In order to remove the old information we indexed for the object
+ID 90, regardless of the *current* fields values of the object, we just
+have to retrieve the hash value by object ID and [`ZREM`]({{< relref "/commands/zrem" >}}) it in the sorted
+set view.
+
+## Represent and query graphs using a hexastore
+
+One cool thing about composite indexes is that they are handy in order
+to represent graphs, using a data structure which is called
+[Hexastore](http://www.vldb.org/pvldb/vol1/1453965.pdf).
+
+The hexastore provides a representation for relations between objects,
+formed by a *subject*, a *predicate* and an *object*.
+A simple relation between objects could be:
+
+    antirez is-friend-of matteocollina
+
+In order to represent this relation I can store the following element
+in my lexicographical index:
+
+    ZADD myindex 0 spo:antirez:is-friend-of:matteocollina
+
+Note that I prefixed my item with the string **spo**. It means that
+the item represents a subject,predicate,object relation.
+
+In can add 5 more entries for the same relation, but in a different order:
+
+    ZADD myindex 0 sop:antirez:matteocollina:is-friend-of
+    ZADD myindex 0 ops:matteocollina:is-friend-of:antirez
+    ZADD myindex 0 osp:matteocollina:antirez:is-friend-of
+    ZADD myindex 0 pso:is-friend-of:antirez:matteocollina
+    ZADD myindex 0 pos:is-friend-of:matteocollina:antirez
+
+Now things start to be interesting, and I can query the graph in many
+different ways. For example, who are all the people `antirez`
+*is friend of*?
+
+    ZRANGE myindex "[spo:antirez:is-friend-of:" "[spo:antirez:is-friend-of:\xff" BYLEX
+    1) "spo:antirez:is-friend-of:matteocollina"
+    2) "spo:antirez:is-friend-of:wonderwoman"
+    3) "spo:antirez:is-friend-of:spiderman"
+
+Or, what are all the relationships `antirez` and `matteocollina` have where
+the first is the subject and the second is the object?
+
+    ZRANGE myindex "[sop:antirez:matteocollina:" "[sop:antirez:matteocollina:\xff" BYLEX
+    1) "sop:antirez:matteocollina:is-friend-of"
+    2) "sop:antirez:matteocollina:was-at-conference-with"
+    3) "sop:antirez:matteocollina:talked-with"
+
+By combining different queries, I can ask fancy questions. For example:
+*Who are all my friends that, like beer, live in Barcelona, and matteocollina consider friends as well?*
+To get this information I start with an `spo` query to find all the people
+I'm friend with. Then for each result I get I perform an `spo` query
+to check if they like beer, removing the ones for which I can't find
+this relation. I do it again to filter by city. Finally I perform an `ops`
+query to find, of the list I obtained, who is considered friend by
+matteocollina.
+
+Make sure to check [Matteo Collina's slides about Levelgraph](http://nodejsconfit.levelgraph.io/) in order to better understand these ideas.
+
+## Multi-dimensional indexes
+
+A more complex type of index is an index that allows you to perform queries
+where two or more variables are queried at the same time for specific
+ranges. For example I may have a data set representing persons age and
+salary, and I want to retrieve all the people between 50 and 55 years old
+having a salary between 70000 and 85000.
+
+This query may be performed with a multi column index, but this requires
+us to select the first variable and then scan the second, which means we
+may do a lot more work than needed. It is possible to perform these kinds of
+queries involving multiple variables using different data structures.
+For example, multi-dimensional trees such as *k-d trees* or *r-trees* are
+sometimes used. Here we'll describe a different way to index data into
+multiple dimensions, using a representation trick that allows us to perform
+the query in a very efficient way using Redis lexicographical ranges.
+
+Let's say we have points in the space, which represent our data samples, where `x` and `y` are our coordinates. The max value of both variables is 400.
+
+In the next figure, the blue box represents our query. We want all the points where `x` is between 50 and 100, and where `y` is between 100 and 300.
+
+![Points in the space](2idx_0.png)
+
+In order to represent data that makes these kinds of queries fast to perform,
+we start by padding our numbers with 0. So for example imagine we want to
+add the point 10,25 (x,y) to our index. Given that the maximum range in the
+example is 400 we can just pad to three digits, so we obtain:
+
+    x = 010
+    y = 025
+
+Now what we do is to interleave the digits, taking the leftmost digit
+in x, and the leftmost digit in y, and so forth, in order to create a single
+number:
+
+    001205
+
+This is our index, however in order to more easily reconstruct the original
+representation, if we want (at the cost of space), we may also add the
+original values as additional columns:
+
+    001205:10:25
+
+Now, let's reason about this representation and why it is useful in the
+context of range queries. For example let's take the center of our blue
+box, which is at `x=75` and `y=200`. We can encode this number as we did
+earlier by interleaving the digits, obtaining:
+
+    027050
+
+What happens if we substitute the last two digits respectively with 00 and 99?
+We obtain a range which is lexicographically continuous:
+
+    027000 to 027099
+
+What this maps to is to a square representing all values where the `x`
+variable is between 70 and 79, and the `y` variable is between 200 and 209.
+To identify this specific area, we can write random points in that interval.
+
+![Small area](2idx_1.png)
+
+So the above lexicographic query allows us to easily query for points in
+a specific square in the picture. However the square may be too small for
+the box we are searching, so that too many queries are needed.
+So we can do the same but instead of replacing the last two digits with 00
+and 99, we can do it for the last four digits, obtaining the following
+range:
+
+    020000 029999
+
+This time the range represents all the points where `x` is between 0 and 99
+and `y` is between 200 and 299. Drawing random points in this interval
+shows us this larger area.
+
+![Large area](2idx_2.png)
+
+So now our area is too big for our query, and still our search box is
+not completely included. We need more granularity, but we can easily obtain
+it by representing our numbers in binary form. This time, when we replace
+digits instead of getting squares which are ten times bigger, we get squares
+which are just two times bigger.
+
+Our numbers in binary form, assuming we need just 9 bits for each variable
+(in order to represent numbers up to 400 in value) would be:
+
+    x = 75  -> 001001011
+    y = 200 -> 011001000
+
+So by interleaving digits, our representation in the index would be:
+
+    000111000011001010:75:200
+
+Let's see what are our ranges as we substitute the last 2, 4, 6, 8, ...
+bits with 0s ad 1s in the interleaved representation:
+
+    2 bits: x between 74 and 75, y between 200 and 201 (range=2)
+    4 bits: x between 72 and 75, y between 200 and 203 (range=4)
+    6 bits: x between 72 and 79, y between 200 and 207 (range=8)
+    8 bits: x between 64 and 79, y between 192 and 207 (range=16)
+
+And so forth. Now we have definitely better granularity!
+As you can see substituting N bits from the index gives us
+search boxes of side `2^(N/2)`.
+
+So what we do is check the dimension where our search box is smaller,
+and check the nearest power of two to this number. Our search box
+was 50,100 to 100,300, so it has a width of 50 and a height of 200.
+We take the smaller of the two, 50, and check the nearest power of two
+which is 64. 64 is 2^6, so we would work with indexes obtained replacing
+the latest 12 bits from the interleaved representation (so that we end
+replacing just 6 bits of each variable).
+
+However single squares may not cover all our search, so we may need more.
+What we do is to start with the left bottom corner of our search box,
+which is 50,100, and find the first range by substituting the last 6 bits
+in each number with 0. Then we do the same with the right top corner.
+
+With two trivial nested for loops where we increment only the significant
+bits, we can find all the squares between these two. For each square we
+convert the two numbers into our interleaved representation, and create
+the range using the converted representation as our start, and the same
+representation but with the latest 12 bits turned on as end range.
+
+For each square found we perform our query and get the elements inside,
+removing the elements which are outside our search box.
+
+Turning this into code is simple. Here is a Ruby example:
+
+    def spacequery(x0,y0,x1,y1,exp)
+        bits=exp*2
+        x_start = x0/(2**exp)
+        x_end = x1/(2**exp)
+        y_start = y0/(2**exp)
+        y_end = y1/(2**exp)
+        (x_start..x_end).each{|x|
+            (y_start..y_end).each{|y|
+                x_range_start = x*(2**exp)
+                x_range_end = x_range_start | ((2**exp)-1)
+                y_range_start = y*(2**exp)
+                y_range_end = y_range_start | ((2**exp)-1)
+                puts "#{x},#{y} x from #{x_range_start} to #{x_range_end}, y from #{y_range_start} to #{y_range_end}"
+
+                # Turn it into interleaved form for ZRANGE query.
+                # We assume we need 9 bits for each integer, so the final
+                # interleaved representation will be 18 bits.
+                xbin = x_range_start.to_s(2).rjust(9,'0')
+                ybin = y_range_start.to_s(2).rjust(9,'0')
+                s = xbin.split("").zip(ybin.split("")).flatten.compact.join("")
+                # Now that we have the start of the range, calculate the end
+                # by replacing the specified number of bits from 0 to 1.
+                e = s[0..-(bits+1)]+("1"*bits)
+                puts "ZRANGE myindex [#{s} [#{e} BYLEX"
+            }
+        }
+    end
+
+    spacequery(50,100,100,300,6)
+
+While non immediately trivial this is a very useful indexing strategy that
+in the future may be implemented in Redis in a native way.
+For now, the good thing is that the complexity may be easily encapsulated
+inside a library that can be used in order to perform indexing and queries.
+One example of such library is [Redimension](https://github.com/antirez/redimension), a proof of concept Ruby library which indexes N-dimensional data inside Redis using the technique described here.
+
+## Multi-dimensional indexes with negative or floating point numbers
+
+The simplest way to represent negative values is just to work with unsigned
+integers and represent them using an offset, so that when you index, before
+translating numbers in the indexed representation, you add the absolute value
+of your smaller negative integer.
+
+For floating point numbers, the simplest approach is probably to convert them
+to integers by multiplying the integer for a power of ten proportional to the
+number of digits after the dot you want to retain.
+
+## Non-range indexes
+
+So far we checked indexes which are useful to query by range or by single
+item. However other Redis data structures such as Sets or Lists can be used
+in order to build other kind of indexes. They are very commonly used but
+maybe we don't always realize they are actually a form of indexing.
+
+For instance I can index object IDs into a Set data type in order to use
+the *get random elements* operation via [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}) in order to retrieve
+a set of random objects. Sets can also be used to check for existence when
+all I need is to test if a given item exists or not or has a single boolean
+property or not.
+
+Similarly lists can be used in order to index items into a fixed order.
+I can add all my items into a Redis list and rotate the list with
+[`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}) using the same key name as source and destination. This is useful
+when I want to process a given set of items again and again forever in the
+same order. Think of an RSS feed system that needs to refresh the local copy
+periodically.
+
+Another popular index often used with Redis is a **capped list**, where items
+are added with [`LPUSH`]({{< relref "/commands/lpush" >}}) and trimmed with [`LTRIM`]({{< relref "/commands/ltrim" >}}), in order to create a view
+with just the latest N items encountered, in the same order they were
+seen.
+
+## Index inconsistency
+
+Keeping the index updated may be challenging, in the course of months
+or years it is possible that inconsistencies are added because of software
+bugs, network partitions or other events.
+
+Different strategies could be used. If the index data is outside Redis
+*read repair* can be a solution, where data is fixed in a lazy way when
+it is requested. When we index data which is stored in Redis itself
+the [`SCAN`]({{< relref "/commands/scan" >}}) family of commands can be used in order to verify, update or
+rebuild the index from scratch, incrementally.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to optimize round-trip times by batching Redis commands
+linkTitle: Pipelining
+title: Redis pipelining
+weight: 2
+---
+
+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.
+
+This means that usually a request is accomplished with the following steps:
+
+* The client sends a query to the server, and reads from the socket, usually in a blocking way, for the server response.
+* The server processes the command and sends the response back to the client.
+
+So for instance a four commands sequence is something like this:
+
+ * *Client:* INCR X
+ * *Server:* 1
+ * *Client:* INCR X
+ * *Server:* 2
+ * *Client:* INCR X
+ * *Server:* 3
+ * *Client:* INCR X
+ * *Server:* 4
+
+Clients and Servers are connected via a network link.
+Such a link can be very fast (a loopback interface) or very slow (a connection established over the Internet with many hops between the two hosts).
+Whatever the network latency is, it takes time for the packets to travel from the client to the server, and back from the server to the client to carry the reply.
+
+This time is called RTT (Round Trip Time).
+It's easy to see how this can affect performance when a client needs to perform many requests in a row (for instance adding many elements to the same list, or populating a database with many keys).
+For instance if the RTT time is 250 milliseconds (in the case of a very slow link over the Internet), even if the server is able to process 100k requests per second, we'll be able to process at max four requests per second.
+
+If the interface used is a loopback interface, the RTT is much shorter, typically sub-millisecond, but even this will add up to a lot if you need to perform many writes in a row.
+
+Fortunately there is a way to improve this use case.
+
+## Redis Pipelining
+
+A Request/Response server can be implemented so that it is able to process new requests even if the client hasn't already read the old responses.
+This way it is possible to send *multiple commands* to the server without waiting for the replies at all, and finally read the replies in a single step.
+
+This is called pipelining, and is a technique widely in use for many decades.
+For instance many POP3 protocol implementations already support this feature, dramatically speeding up the process of downloading new emails from the server.
+
+Redis has supported pipelining since its early days, so whatever version you are running, you can use pipelining with Redis.
+This is an example using the raw netcat utility:
+
+```bash 
+$ (printf "PING\r\nPING\r\nPING\r\n"; sleep 1) | nc localhost 6379
++PONG
++PONG
++PONG
+```
+
+This time we don't pay the cost of RTT for every call, but just once for the three commands.
+
+To be explicit, with pipelining the order of operations of our very first example will be the following:
+
+ * *Client:* INCR X
+ * *Client:* INCR X
+ * *Client:* INCR X
+ * *Client:* INCR X
+ * *Server:* 1
+ * *Server:* 2
+ * *Server:* 3
+ * *Server:* 4
+
+> **IMPORTANT NOTE**: While the client sends commands using pipelining, the server will be forced to queue the replies, using memory. So if you need to send a lot of commands with pipelining, it is better to send them as batches each containing a reasonable number, for instance 10k commands, read the replies, and then send another 10k commands again, and so forth. The speed will be nearly the same, but the additional memory used will be at most the amount needed to queue the replies for these 10k commands.
+
+## It's not just a matter of RTT
+
+Pipelining is not just a way to reduce the latency cost associated with the
+round trip time, it actually greatly improves the number of operations
+you can perform per second in a given Redis server.
+This is because without using pipelining, serving each command is very cheap from
+the point of view of accessing the data structures and producing the reply,
+but it is very costly from the point of view of doing the socket I/O. This
+involves calling the `read()` and `write()` syscall, that means going from user
+land to kernel land.
+The context switch is a huge speed penalty.
+
+When pipelining is used, many commands are usually read with a single `read()`
+system call, and multiple replies are delivered with a single `write()` system
+call. Consequently, the number of total queries performed per second
+initially increases almost linearly with longer pipelines, and eventually
+reaches 10 times the baseline obtained without pipelining, as shown in this figure.
+
+![Pipeline size and IOPs](pipeline_iops.png)
+
+## A real world code example
+
+
+In the following benchmark we'll use the Redis Ruby client, supporting pipelining, to test the speed improvement due to pipelining:
+
+```ruby
+require 'rubygems'
+require 'redis'
+
+def bench(descr)
+  start = Time.now
+  yield
+  puts "#{descr} #{Time.now - start} seconds"
+end
+
+def without_pipelining
+  r = Redis.new
+  10_000.times do
+    r.ping
+  end
+end
+
+def with_pipelining
+  r = Redis.new
+  r.pipelined do |rp|
+    10_000.times do
+      rp.ping
+    end
+  end
+end
+
+bench('without pipelining') do
+  without_pipelining
+end
+bench('with pipelining') do
+  with_pipelining
+end
+```
+
+Running the above simple script yields the following figures on my Mac OS X system, running over the loopback interface, where pipelining will provide the smallest improvement as the RTT is already pretty low:
+
+```
+without pipelining 1.185238 seconds
+with pipelining 0.250783 seconds
+```
+As you can see, using pipelining, we improved the transfer by a factor of five.
+
+## Pipelining vs Scripting
+
+Using [Redis scripting]({{< relref "/commands/eval" >}}), available since Redis 2.6, a number of use cases for pipelining can be addressed more efficiently using scripts that perform a lot of the work needed at the server side.
+A big advantage of scripting is that it is able to both read and write data with minimal latency, making operations like *read, compute, write* very fast (pipelining can't help in this scenario since the client needs the reply of the read command before it can call the write command).
+
+Sometimes the application may also want to send [`EVAL`]({{< relref "/commands/eval" >}}) or [`EVALSHA`]({{< relref "/commands/evalsha" >}}) commands in a pipeline. 
+This is entirely possible and Redis explicitly supports it with the [SCRIPT LOAD]({{< relref "/commands/script-load" >}}) command (it guarantees that [`EVALSHA`]({{< relref "/commands/evalsha" >}}) can be called without the risk of failing).
+
+## Appendix: Why are busy loops slow even on the loopback interface?
+
+Even with all the background covered in this page, you may still wonder why
+a Redis benchmark like the following (in pseudo code), is slow even when
+executed in the loopback interface, when the server and the client are running
+in the same physical machine:
+
+```sh
+FOR-ONE-SECOND:
+    Redis.SET("foo","bar")
+END
+```
+
+After all, if both the Redis process and the benchmark are running in the same
+box, isn't it just copying messages in memory from one place to another without
+any actual latency or networking involved?
+
+The reason is that processes in a system are not always running, actually it is
+the kernel scheduler that lets the process run. 
+So, for instance, when the benchmark is allowed to run, it reads the reply from the Redis server (related to the last command executed), and writes a new command.
+The command is now in the loopback interface buffer, but in order to be read by the server, the kernel should schedule the server process (currently blocked in a system call)
+to run, and so forth.
+So in practical terms the loopback interface still involves network-like latency, because of how the kernel scheduler works.
+
+Basically a busy loop benchmark is the silliest thing that can be done when
+metering performances on a networked server. The wise thing is just avoiding
+benchmarking in this way.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Managing keys in Redis: Key expiration, scanning, altering and querying
+  the key space
+
+  '
+linkTitle: Keyspace
+title: Keyspace
+weight: 1
+---
+
+Redis keys are binary safe; this means that you can use any binary sequence as a
+key, from a string like "foo" to the content of a JPEG file.
+The empty string is also a valid key.
+
+A few other rules about keys: 
+
+* Very long keys are not a good idea. For instance a key of 1024 bytes is a bad
+  idea not only memory-wise, but also because the lookup of the key in the
+  dataset may require several costly key-comparisons. Even when the task at hand
+  is to match the existence of a large value, hashing it (for example
+  with SHA1) is a better idea, especially from the perspective of memory
+  and bandwidth.
+* Very short keys are often not a good idea. There is little point in writing
+  "u1000flw" as a key if you can instead write "user:1000:followers".  The latter
+  is more readable and the added space is minor compared to the space used by
+  the key object itself and the value object. While short keys will obviously
+  consume a bit less memory, your job is to find the right balance.
+* Try to stick with a schema. For instance "object-type:id" is a good
+  idea, as in "user:1000". Dots or dashes are often used for multi-word
+  fields, as in "comment:4321:reply.to" or "comment:4321:reply-to".
+* The maximum allowed key size is 512 MB.
+
+## Altering and querying the key space
+
+There are commands that are not defined on particular types, but are useful
+in order to interact with the space of keys, and thus, can be used with
+keys of any type.
+
+For example the [`EXISTS`]({{< relref "/commands/exists" >}}) command returns 1 or 0 to signal if a given key
+exists or not in the database, while the [`DEL`]({{< relref "/commands/del" >}}) command deletes a key
+and associated value, whatever the value is.
+
+    > set mykey hello
+    OK
+    > exists mykey
+    (integer) 1
+    > del mykey
+    (integer) 1
+    > exists mykey
+    (integer) 0
+
+From the examples you can also see how [`DEL`]({{< relref "/commands/del" >}}) itself returns 1 or 0 depending on whether
+the key was removed (it existed) or not (there was no such key with that
+name).
+
+There are many key space related commands, but the above two are the
+essential ones together with the [`TYPE`]({{< relref "/commands/type" >}}) command, which returns the kind
+of value stored at the specified key:
+
+    > set mykey x
+    OK
+    > type mykey
+    string
+    > del mykey
+    (integer) 1
+    > type mykey
+    none
+
+## Key expiration
+
+Before moving on, we should look at an important Redis feature that works regardless of the type of value you're storing: key expiration. Key expiration lets you set a timeout for a key, also known as a "time to live", or "TTL". When the time to live elapses, the key is automatically destroyed. 
+
+A few important notes about key expiration:
+
+* They can be set both using seconds or milliseconds precision.
+* However the expire time resolution is always 1 millisecond.
+* Information about expires are replicated and persisted on disk, the time virtually passes when your Redis server remains stopped (this means that Redis saves the date at which a key will expire).
+
+Use the [`EXPIRE`]({{< relref "/commands/expire" >}}) command to set a key's expiration:
+
+    > set key some-value
+    OK
+    > expire key 5
+    (integer) 1
+    > get key (immediately)
+    "some-value"
+    > get key (after some time)
+    (nil)
+
+The key vanished between the two [`GET`]({{< relref "/commands/get" >}}) calls, since the second call was
+delayed more than 5 seconds. In the example above we used [`EXPIRE`]({{< relref "/commands/expire" >}}) in
+order to set the expire (it can also be used in order to set a different
+expire to a key already having one, like [`PERSIST`]({{< relref "/commands/persist" >}}) can be used in order
+to remove the expire and make the key persistent forever). However we
+can also create keys with expires using other Redis commands. For example
+using [`SET`]({{< relref "/commands/set" >}}) options:
+
+    > set key 100 ex 10
+    OK
+    > ttl key
+    (integer) 9
+
+The example above sets a key with the string value `100`, having an expire
+of ten seconds. Later the [`TTL`]({{< relref "/commands/ttl" >}}) command is called in order to check the
+remaining time to live for the key.
+
+In order to set and check expires in milliseconds, check the [`PEXPIRE`]({{< relref "/commands/pexpire" >}}) and
+the [`PTTL`]({{< relref "/commands/pttl" >}}) commands, and the full list of [`SET`]({{< relref "/commands/set" >}}) options.
+
+## Navigating the keyspace
+
+### Scan
+To incrementally  iterate over the keys in a Redis database in an efficient manner, you can use the [`SCAN`]({{< relref "/commands/scan" >}}) command.
+
+Since [`SCAN`]({{< relref "/commands/scan" >}}) allows for incremental iteration, returning only a small number of elements per call, it can be used in production without the downside of commands like [`KEYS`]({{< relref "/commands/keys" >}}) or [`SMEMBERS`]({{< relref "/commands/smembers" >}}) that may block the server for a long time (even several seconds) when called against big collections of keys or elements.
+
+However while blocking commands like [`SMEMBERS`]({{< relref "/commands/smembers" >}}) are able to provide all the elements that are part of a Set in a given moment.
+The [`SCAN`]({{< relref "/commands/scan" >}}) family of commands only offer limited guarantees about the returned elements since the collection that we incrementally iterate can change during the iteration process.
+
+### Keys
+
+Another way to iterate over the keyspace is to use the [`KEYS`]({{< relref "/commands/keys" >}}) command, but this approach should be used with care, since [`KEYS`]({{< relref "/commands/keys" >}}) will block the Redis server until all keys are returned.
+
+**Warning**: consider [`KEYS`]({{< relref "/commands/keys" >}}) as a command that should only be used in production
+environments with extreme care.
+
+[`KEYS`]({{< relref "/commands/keys" >}}) may ruin performance when it is executed against large databases.
+This command is intended for debugging and special operations, such as changing
+your keyspace layout.
+Don't use [`KEYS`]({{< relref "/commands/keys" >}}) in your regular application code.
+If you're looking for a way to find keys in a subset of your keyspace, consider
+using [`SCAN`]({{< relref "/commands/scan" >}}) or [sets][tdts].
+
+[tdts]: /develop/data-types#sets
+
+Supported glob-style patterns:
+
+* `h?llo` matches `hello`, `hallo` and `hxllo`
+* `h*llo` matches `hllo` and `heeeello`
+* `h[ae]llo` matches `hello` and `hallo,` but not `hillo`
+* `h[^e]llo` matches `hallo`, `hbllo`, ... but not `hello`
+* `h[a-b]llo` matches `hallo` and `hbllo`
+
+Use `\` to escape special characters if you want to match them verbatim.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Monitor changes to Redis keys and values in real time
+
+  '
+linkTitle: Keyspace notifications
+title: Redis keyspace notifications
+weight: 4
+---
+
+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.
+
+### Type of events
+
+Keyspace notifications are implemented by sending two distinct types of events
+for every operation affecting the Redis data space. For instance a [`DEL`]({{< relref "/commands/del" >}})
+operation targeting the key named `mykey` in database `0` will trigger
+the delivering of two messages, exactly equivalent to the following two
+[`PUBLISH`]({{< relref "/commands/publish" >}}) commands:
+
+    PUBLISH __keyspace@0__:mykey del
+    PUBLISH __keyevent@0__:del mykey
+
+The first channel listens to all the events targeting
+the key `mykey` and the other channel listens only to `del` operation
+events on the key `mykey`
+
+The first kind of event, with `keyspace` prefix in the channel is called
+a **Key-space notification**, while the second, with the `keyevent` prefix,
+is called a **Key-event notification**.
+
+In the previous example a `del` event was generated for the key `mykey` resulting
+in two messages:
+
+* The Key-space channel receives as message the name of the event.
+* The Key-event channel receives as message the name of the key.
+
+It is possible to enable only one kind of notification in order to deliver
+just the subset of events we are interested in.
+
+### Configuration
+
+By default keyspace event notifications are disabled because while not
+very sensible the feature uses some CPU power. Notifications are enabled
+using the `notify-keyspace-events` of redis.conf or via the **CONFIG SET**.
+
+Setting the parameter to the empty string disables notifications.
+In order to enable the feature a non-empty string is used, composed of multiple
+characters, where every character has a special meaning according to the
+following table:
+
+    K     Keyspace events, published with __keyspace@<db>__ prefix.
+    E     Keyevent events, published with __keyevent@<db>__ prefix.
+    g     Generic commands (non-type specific) like DEL, EXPIRE, RENAME, ...
+    $     String commands
+    l     List commands
+    s     Set commands
+    h     Hash commands
+    z     Sorted set commands
+    t     Stream commands
+    d     Module key type events
+    x     Expired events (events generated every time a key expires)
+    e     Evicted events (events generated when a key is evicted for maxmemory)
+    m     Key miss events (events generated when a key that doesn't exist is accessed)
+    n     New key events (Note: not included in the 'A' class)
+    A     Alias for "g$lshztxed", so that the "AKE" string means all the events except "m" and "n".
+
+At least `K` or `E` should be present in the string, otherwise no event
+will be delivered regardless of the rest of the string.
+
+For instance to enable just Key-space events for lists, the configuration
+parameter must be set to `Kl`, and so forth.
+
+You can use the string `KEA` to enable most types of events.
+
+### Events generated by different commands
+
+Different commands generate different kind of events according to the following list.
+* [`APPEND`]({{< relref "/commands/append" >}}) generates an `append` event.
+* [`COPY`]({{< relref "/commands/copy" >}}) generates a `copy_to` event.
+* [`DEL`]({{< relref "/commands/del" >}}) generates a `del` event for every deleted key.
+* [`EXPIRE`]({{< relref "/commands/expire" >}}) and all its variants ([`PEXPIRE`]({{< relref "/commands/pexpire" >}}), [`EXPIREAT`]({{< relref "/commands/expireat" >}}), [`PEXPIREAT`]({{< relref "/commands/pexpireat" >}})) generate an `expire` event when called with a positive timeout (or a future timestamp). Note that when these commands are called with a negative timeout value or timestamp in the past, the key is deleted and only a `del` event is generated instead.
+* [`HDEL`]({{< relref "/commands/hdel" >}}) generates a single `hdel` event, and an additional `del` event if the resulting hash is empty and the key is removed.
+* [`HEXPIRE`]({{< relref "/commands/hexpire" >}}) and all its variants ([`HEXPIREAT`]({{< relref "/commands/hpexpireat" >}}), [`HPEXPIRE`]({{< relref "/commands/hpexpire" >}}), [`HPEXPIREAT`]({{< relref "/commands/hpexpireat" >}})) generate `hexpire` events. Furthermore, `hexpired` events are generated when fields expire.
+* [`HINCRBYFLOAT`]({{< relref "/commands/hincrbyfloat" >}}) generates an `hincrbyfloat` event.
+* [`HINCRBY`]({{< relref "/commands/hincrby" >}}) generates an `hincrby` event.
+* [`HPERSIST`]({{< relref "/commands/hpersist" >}}) generates an `hpersist` event.
+* [`HSET`]({{< relref "/commands/hset" >}}), [`HSETNX`]({{< relref "/commands/hsetnx" >}}) and [`HMSET`]({{< relref "/commands/hmset" >}}) all generate a single `hset` event.
+* [`INCRBYFLOAT`]({{< relref "/commands/incrbyfloat" >}}) generates an `incrbyfloat` events.
+* [`INCR`]({{< relref "/commands/incr" >}}), [`DECR`]({{< relref "/commands/decr" >}}), [`INCRBY`]({{< relref "/commands/incrby" >}}), [`DECRBY`]({{< relref "/commands/decrby" >}}) commands all generate `incrby` events.
+* [`LINSERT`]({{< relref "/commands/linsert" >}}) generates an `linsert` event.
+* [`LMOVE`]({{< relref "/commands/lmove" >}}) and [`BLMOVE`]({{< relref "/commands/blmove" >}}) generate an `lpop`/`rpop` event (depending on the wherefrom argument) and an `lpush`/`rpush` event (depending on the whereto argument). In both cases the order is guaranteed (the `lpush`/`rpush` event will always be delivered after the `lpop`/`rpop` event). Additionally a `del` event will be generated if the resulting list is zero length and the key is removed.
+* [`LPOP`]({{< relref "/commands/lpop" >}}) generates an `lpop` event. Additionally a `del` event is generated if the key is removed because the last element from the list was popped.
+* [`LPUSH`]({{< relref "/commands/lpush" >}}) and [`LPUSHX`]({{< relref "/commands/lpushx" >}}) generates a single `lpush` event, even in the variadic case.
+* [`LREM`]({{< relref "/commands/lrem" >}}) generates an `lrem` event, and additionally a `del` event if the resulting list is empty and the key is removed.
+* [`LSET`]({{< relref "/commands/lset" >}}) generates an `lset` event.
+* [`LTRIM`]({{< relref "/commands/ltrim" >}}) generates an `ltrim` event, and additionally a `del` event if the resulting list is empty and the key is removed.
+* [`MIGRATE`]({{< relref "/commands/migrate" >}}) generates a `del` event if the source key is removed.
+* [`MOVE`]({{< relref "/commands/move" >}}) generates two events, a `move_from` event for the source key, and a `move_to` event for the destination key.
+* [`MSET`]({{< relref "/commands/mset" >}}) generates a separate `set` event for every key.
+* [`PERSIST`]({{< relref "/commands/persist" >}}) generates a `persist` event if the expiry time associated with key has been successfully deleted.
+* [`RENAME`]({{< relref "/commands/rename" >}}) generates two events, a `rename_from` event for the source key, and a `rename_to` event for the destination key.
+* [`RESTORE`]({{< relref "/commands/restore" >}}) generates a `restore` event for the key.
+* [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}) and [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}) generate an `rpop` event and an `lpush` event. In both cases the order is guaranteed (the `lpush` event will always be delivered after the `rpop` event). Additionally a `del` event will be generated if the resulting list is zero length and the key is removed.
+* [`RPOP`]({{< relref "/commands/rpop" >}}) generates an `rpop` event. Additionally a `del` event is generated if the key is removed because the last element from the list was popped.
+* [`RPUSH`]({{< relref "/commands/rpush" >}}) and [`RPUSHX`]({{< relref "/commands/rpushx" >}}) generates a single `rpush` event, even in the variadic case.
+* [`SADD`]({{< relref "/commands/sadd" >}}) generates a single `sadd` event, even in the variadic case.
+* [`SETRANGE`]({{< relref "/commands/setrange" >}}) generates a `setrange` event.
+* [`SET`]({{< relref "/commands/set" >}}) and all its variants ([`SETEX`]({{< relref "/commands/setex" >}}), [`SETNX`]({{< relref "/commands/setnx" >}}),[`GETSET`]({{< relref "/commands/getset" >}})) generate `set` events. However [`SETEX`]({{< relref "/commands/setex" >}}) will also generate an `expire` events.
+* [`SINTERSTORE`]({{< relref "/commands/sinterstore" >}}), [`SUNIONSTORE`]({{< relref "/commands/sunionstore" >}}), [`SDIFFSTORE`]({{< relref "/commands/sdiffstore" >}}) generate `sinterstore`, `sunionstore`, `sdiffstore` events respectively. In the special case the resulting set is empty, and the key where the result is stored already exists, a `del` event is generated since the key is removed.
+* [`SMOVE`]({{< relref "/commands/smove" >}}) generates an `srem` event for the source key, and an `sadd` event for the destination key.
+* [`SORT`]({{< relref "/commands/sort" >}}) generates a `sortstore` event when `STORE` is used to set a new key. If the resulting list is empty, and the `STORE` option is used, and there was already an existing key with that name, the result is that the key is deleted, so a `del` event is generated in this condition.
+* [`SPOP`]({{< relref "/commands/spop" >}}) generates an `spop` event, and an additional `del` event if the resulting set is empty and the key is removed.
+* [`SREM`]({{< relref "/commands/srem" >}}) generates a single `srem` event, and an additional `del` event if the resulting set is empty and the key is removed.
+* [`XADD`]({{< relref "/commands/xadd" >}}) generates an `xadd` event, possibly followed an `xtrim` event when used with the `MAXLEN` subcommand.
+* [`XDEL`]({{< relref "/commands/xdel" >}}) generates a single `xdel` event even when multiple entries are deleted.
+* [`XGROUP CREATECONSUMER`]({{< relref "/commands/xgroup-createconsumer" >}}) generates an `xgroup-createconsumer` event.
+* [`XGROUP CREATE`]({{< relref "/commands/xgroup-create" >}}) generates an `xgroup-create` event.
+* [`XGROUP DELCONSUMER`]({{< relref "/commands/xgroup-delconsumer" >}}) generates an `xgroup-delconsumer` event.
+* [`XGROUP DESTROY`]({{< relref "/commands/xgroup-destroy" >}}) generates an `xgroup-destroy` event.
+* [`XGROUP SETID`]({{< relref "/commands/xgroup-setid" >}}) generates an `xgroup-setid` event.
+* [`XSETID`]({{< relref "/commands/xsetid" >}}) generates an `xsetid` event.
+* [`XTRIM`]({{< relref "/commands/xtrim" >}}) generates an `xtrim` event.
+* [`ZADD`]({{< relref "/commands/zadd" >}}) generates a single `zadd` event even when multiple elements are added.
+* [`ZDIFFSTORE`]({{< relref "/commands/zdiffstore" >}}), [`ZINTERSTORE`]({{< relref "/commands/zinterstore" >}}) and [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}) respectively generate `zdiffstore`, `zinterstore` and `zunionstore` events. In the special case the resulting sorted set is empty, and the key where the result is stored already exists, a `del` event is generated since the key is removed.
+* [`ZINCRBY`]({{< relref "/commands/zincrby" >}}) generates a `zincr` event.
+* [`ZREMRANGEBYRANK`]({{< relref "/commands/zremrangebyrank" >}}) generates a single `zrembyrank` event. When the resulting sorted set is empty and the key is generated, an additional `del` event is generated.
+* [`ZREMRANGEBYSCORE`]({{< relref "/commands/zremrangebyscore" >}}) generates a single `zrembyscore` event. When the resulting sorted set is empty and the key is generated, an additional `del` event is generated.
+* [`ZREM`]({{< relref "/commands/zrem" >}}) generates a single `zrem` event even when multiple elements are deleted. When the resulting sorted set is empty and the key is generated, an additional `del` event is generated.
+* Every time a key with a time to live associated is removed from the data set because it expired, an `expired` event is generated.
+* Every time a key is evicted from the data set in order to free memory as a result of the `maxmemory` policy, an `evicted` event is generated.
+* Every time a new key is added to the data set, a `new` event is generated.
+
+**IMPORTANT** all the commands generate events only if the target key is really modified. For instance an [`SREM`]({{< relref "/commands/srem" >}}) deleting a non-existing element from a Set will not actually change the value of the key, so no event will be generated.
+
+If in doubt about how events are generated for a given command, the simplest
+thing to do is to watch yourself:
+
+    $ redis-cli config set notify-keyspace-events KEA
+    $ redis-cli --csv psubscribe '__key*__:*'
+    Reading messages... (press Ctrl-C to quit)
+    "psubscribe","__key*__:*",1
+
+At this point use `redis-cli` in another terminal to send commands to the
+Redis server and watch the events generated:
+
+    "pmessage","__key*__:*","__keyspace@0__:foo","set"
+    "pmessage","__key*__:*","__keyevent@0__:set","foo"
+    ...
+
+### Timing of expired events
+
+Keys with a time to live associated are expired by Redis in two ways:
+
+* When the key is accessed by a command and is found to be expired.
+* Via a background system that looks for expired keys in the background, incrementally, in order to be able to also collect keys that are never accessed.
+
+The `expired` events are generated when a key is accessed and is found to be expired by one of the above systems, as a result there are no guarantees that the Redis server will be able to generate the `expired` event at the time the key time to live reaches the value of zero.
+
+If no command targets the key constantly, and there are many keys with a TTL associated, there can be a significant delay between the time the key time to live drops to zero, and the time the `expired` event is generated.
+
+Expired (`expired`) events are generated when the Redis server deletes the key and not when the time to live theoretically reaches the value of zero.
+
+### Events in a cluster
+
+Every node of a Redis cluster generates events about its own subset of the keyspace as described above. However, unlike regular Pub/Sub communication in a cluster, events' notifications **are not** broadcasted to all nodes. Put differently, keyspace events are node-specific. This means that to receive all keyspace events of a cluster, clients need to subscribe to each of the nodes.
+
+@history
+
+*   `>= 6.0`: Key miss events were added.
+*   `>= 7.0`: Event type `new` added
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: A developer's guide to Redis
+linkTitle: Use Redis
+title: Use Redis
+weight: 50
+---
+---
+Title: Redis for AI documentation
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: An overview of Redis for AI documentation
+linkTitle: Redis for AI
+weight: 40
+---
+Redis stores and indexes vector embeddings that semantically represent unstructured data including text passages, images, videos, or audio. Store vectors and the associated metadata within [hashes]({{< relref "/develop/data-types/hashes" >}}) or [JSON]({{< relref "/develop/data-types/json" >}}) documents for [indexing]({{< relref "/develop/interact/search-and-query/indexing" >}}) and [querying]({{< relref "/develop/interact/search-and-query/query" >}}).
+
+| Vector | RAG | RedisVL |
+| :-- | :-- | :-- |
+| {{<image filename="images/ai-cube.png" alt="AI Redis icon.">}}[Redis vector database quick start guide]({{< relref "/develop/get-started/vector-database" >}}) |{{<image filename="images/ai-brain.png" alt="AI Redis icon.">}} [Retrieval-Augmented Generation quick start guide]({{< relref "/develop/get-started/rag" >}}) | {{<image filename="images/ai-lib.png" alt="AI Redis icon.">}}[Redis vector Python client library documentation]({{< relref "/integrate/redisvl/" >}}) |
+
+#### Overview
+
+This page organized into a few sections depending on what you’re trying to do:
+* **How to's** - The comprehensive reference section for every feature, API, and setting. It’s your source for detailed, technical information to support any level of development.
+* **Concepts** - Explanations of foundational ideas and core principles to help you understand the reason behind the product’s features and design.
+* **Quickstarts** - Short, focused guides to get you started with key features or workflows in minutes. 
+* **Tutorials** - In-depth walkthroughs that dive deeper into specific use cases or processes. These step-by-step guides help you master essential tasks and workflows.
+* **Integrations** - Guides and resources to help you connect and use the product with popular tools, frameworks, or platforms.
+* **Benchmarks** - Performance comparisons and metrics to demonstrate how the product performs under various scenarios. This helps you understand its efficiency and capabilities.
+* **Best practices** - Recommendations and guidelines for maximizing effectiveness and avoiding common pitfalls. This section equips you to use the product effectively and efficiently.
+
+## How to's
+
+1. [**Create a vector index**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#create-a-vector-index" >}}): Redis maintains a secondary index over your data with a defined schema (including vector fields and metadata). Redis supports [`FLAT`]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#flat-index" >}}) and [`HNSW`]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) vector index types.
+1. [**Store and update vectors**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#store-and-update-vectors" >}}): Redis stores vectors and metadata in hashes or JSON objects.
+1. [**Search with vectors**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#search-with-vectors" >}}): Redis supports several advanced querying strategies with vector fields including k-nearest neighbor ([KNN]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#knn-vector-search" >}})), [vector range queries]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#vector-range-queries" >}}), and [metadata filters]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#filters" >}}).
+1. [**Configure vector queries at runtime**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#runtime-query-parameters" >}}). Select the best filter mode to optimize query execution.
+
+#### Learn how to index and query vector embeddings
+* [redis-py (Python)]({{< relref "/develop/clients/redis-py/vecsearch" >}})
+* [NRedisStack (C#/.NET)]({{< relref "/develop/clients/dotnet/vecsearch" >}})
+* [node-redis (JavaScript)]({{< relref "/develop/clients/nodejs/vecsearch" >}}) 
+* [Jedis (Java)]({{< relref "/develop/clients/jedis/vecsearch" >}})
+* [go-redis (Go)]({{< relref "/develop/clients/go/vecsearch" >}}) 
+
+## Concepts 
+
+Learn to perform vector search and use gateways and semantic caching in your AI/ML projects.
+
+| Search | LLM memory | Semantic caching | Semantic routing | AI Gateways |
+| :-- | :-- | :-- | :-- | :-- |
+| {{<image filename="images/ai-search.png" alt="AI Redis icon.">}}[Vector search guide]({{< relref "/develop/interact/search-and-query/query/vector-search" >}}) | {{<image filename="images/ai-LLM-memory.png" alt="LLM memory icon.">}}[Store memory for LLMs](https://redis.io/blog/level-up-rag-apps-with-redis-vector-library/) | {{<image filename="images/ai-brain-2.png" alt="AI Redis icon.">}}[Semantic caching for faster, smarter LLM apps](https://redis.io/blog/what-is-semantic-caching) | {{<image filename="images/ai-semantic-routing.png" alt="Semantic routing icon.">}}[Semantic routing chooses the best tool](https://redis.io/blog/level-up-rag-apps-with-redis-vector-library/) | {{<image filename="images/ai-model.png" alt="AI Redis icon.">}}[Deploy an enhanced gateway with Redis](https://redis.io/blog/ai-gateways-what-are-they-how-can-you-deploy-an-enhanced-gateway-with-redis/) | {{<image filename="images/ai-brain-2.png" alt="AI Redis icon.">}}[Semantic caching for faster, smarter LLM apps](https://redis.io/blog/what-is-semantic-caching) |
+
+## Quickstarts
+
+Quickstarts or recipes are useful when you are trying to build specific functionality. For example, you might want to do RAG with LangChain or set up LLM memory for your AI agent. Get started with the following Redis Python notebooks.
+
+* [The place to start if you are brand new to Redis](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/redis-intro/00_redis_intro.ipynb)
+
+#### Hybrid and vector search
+Vector search retrieves results based on the similarity of high-dimensional numerical embeddings, while hybrid search combines this with traditional keyword or metadata-based filtering for more comprehensive results.
+* [Implementing hybrid search with Redis](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/02_hybrid_search.ipynb)
+* [Vector search with Redis Python client](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/00_redispy.ipynb) 
+* [Vector search with Redis Vector Library](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/01_redisvl.ipynb)
+* [Shows how to convert a float 32 index to float16 or integer data types](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/03_dtype_support.ipynb)
+
+#### RAG  
+Retrieval Augmented Generation (aka RAG) is a technique to enhance the ability of an LLM to respond to user queries. The retrieval part of RAG is supported by a vector database, which can return semantically relevant results to a user’s query, serving as contextual information to augment the generative capabilities of an LLM.
+* [RAG from scratch with the Redis Vector Library](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/01_redisvl.ipynb) 
+* [RAG using Redis and LangChain](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/02_langchain.ipynb) 
+* [RAG using Redis and LlamaIndex](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/03_llamaindex.ipynb) 
+* [Advanced RAG with redisvl](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/04_advanced_redisvl.ipynb) 
+* [RAG using Redis and Nvidia](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/05_nvidia_ai_rag_redis.ipynb) 
+* [Utilize RAGAS framework to evaluate RAG performance](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/06_ragas_evaluation.ipynb)
+* [Vector search with Azure](https://techcommunity.microsoft.com/blog/azuredevcommunityblog/vector-similarity-search-with-azure-cache-for-redis-enterprise/3822059)
+* [RAG with Spring AI](https://redis.io/blog/building-a-rag-application-with-redis-and-spring-ai/)
+* [RAG with Vertex AI](https://github.com/redis-developer/gcp-redis-llm-stack/tree/main)
+* [Notebook for additional tips and techniques to improve RAG quality](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/04_advanced_redisvl.ipynb)
+* [Implement a simple RBAC policy with vector search using Redis](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/07_user_role_based_rag.ipynb) 
+
+#### Agents
+AI agents can act autonomously to plan and execute tasks for the user.
+* [Redis Notebooks for LangGraph](https://github.com/redis-developer/langgraph-redis/tree/main/examples)
+* [Notebook to get started with LangGraph and agents](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/agents/00_langgraph_redis_agentic_rag.ipynb) 
+* [Build a collaborative movie recommendation system using Redis for data storage, CrewAI for agent-based task execution, and LangGraph for workflow management.](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/agents/01_crewai_langgraph_redis.ipynb)
+* [Full-Featured Agent Architecture](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/agents/02_full_featured_agent.ipynb)
+
+#### LLM memory
+LLMs are stateless. To maintain context within a conversation chat sessions must be stored and resent to the LLM. Redis manages the storage and retrieval of chat sessions to maintain context and conversational relevance.
+* [LLM session manager with semantic similarity](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/llm-session-manager/00_llm_session_manager.ipynb) 
+* [Handle multiple simultaneous chats with one instance](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/llm-session-manager/01_multiple_sessions.ipynb)
+
+#### Semantic caching  
+An estimated 31% of LLM queries are potentially redundant. Redis enables semantic caching to help cut down on LLM costs quickly.
+* [Build a semantic cache using the Doc2Cache framework and Llama3.1](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-cache/doc2cache_llama3_1.ipynb) 
+* [Build a semantic cache with Redis and Google Gemini](https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-cache/semantic_caching_gemini.ipynb)
+* [Optimize semantic cache threshold with RedisVL](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-cache/02_semantic_cache_optimization.ipynb)
+
+#### Semantic routing  
+Routing is a simple and effective way of preventing misuses with your AI application or for creating branching logic between data sources etc.
+* [Simple examples of how to build an allow/block list router in addition to a multi-topic router](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-router/00_semantic_routing.ipynb) 
+* [Use RouterThresholdOptimizer from redisvl to setup best router config](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-router/01_routing_optimization.ipynb)
+
+#### Computer vision
+Build a facial recognition system using the Facenet embedding model and RedisVL.
+* [Facial recognition](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/computer-vision/00_facial_recognition_facenet.ipynb)
+
+#### Recommendation systems
+* [Intro content filtering example with redisvl](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/recommendation-systems/00_content_filtering.ipynb) 
+* [Intro collaborative filtering example with redisvl](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/recommendation-systems/01_collaborative_filtering.ipynb)
+* [Intro deep learning two tower example with redisvl](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/recommendation-systems/02_two_towers.ipynb)
+
+#### Feature store
+* [Credit scoring system using Feast with Redis as the online store](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/feature-store/00_feast_credit_score.ipynb)
+
+## Tutorials
+Need a deeper-dive through different use cases and topics?
+
+#### RAG
+* [Agentic RAG](https://github.com/redis-developer/agentic-rag) - A tutorial focused on agentic RAG with LlamaIndex and Amazon Bedrock
+* [RAG on Vertex AI](https://github.com/redis-developer/gcp-redis-llm-stack/tree/main) - A RAG tutorial featuring Redis with Vertex AI
+* [RAG workbench](https://github.com/redis-developer/redis-rag-workbench) - A development playground for exploring RAG techniques with Redis
+* [ArXiv Chat](https://github.com/redis-developer/ArxivChatGuru) - Streamlit demo of RAG over ArXiv documents with Redis & OpenAI
+
+#### Recommendations and search
+* [Recommendation systems w/ NVIDIA Merlin & Redis](https://github.com/redis-developer/redis-nvidia-recsys) - Three examples, each escalating in complexity, showcasing the process of building a realtime recsys with NVIDIA and Redis
+* [Redis product search](https://github.com/redis-developer/redis-product-search) - Build a real-time product search engine using features like full-text search, vector similarity, and real-time data updates
+* [ArXiv Search](https://github.com/redis-developer/redis-arxiv-search) - Full stack implementation of Redis with React FE
+
+## Ecosystem integrations
+
+* [LangGraph & Redis: Build smarter AI agents with memory & persistence](https://redis.io/blog/langgraph-redis-build-smarter-ai-agents-with-memory-persistence/)
+* [Amazon Bedrock setup guide]({{< relref "/integrate/amazon-bedrock/set-up-redis" >}})
+* [LangChain Redis Package: Smarter AI apps with advanced vector storage and faster caching](https://redis.io/blog/langchain-redis-partner-package/)
+* [LlamaIndex integration for Redis as a vector store](https://gpt-index.readthedocs.io/en/latest/examples/vector_stores/RedisIndexDemo.html)
+* [Redis Cloud available on Vercel](https://redis.io/blog/redis-cloud-now-available-on-vercel-marketplace/)
+* [Create a Redis Cloud database with the Vercel integration]({{< relref "/operate/rc/cloud-integrations/vercel" >}})
+* [Building a RAG application with Redis and Spring AI](https://redis.io/blog/building-a-rag-application-with-redis-and-spring-ai/)
+* [Deploy GenAI apps faster with Redis and NVIDIA NIM](https://redis.io/blog/use-redis-with-nvidia-nim-to-deploy-genai-apps-faster/)
+* [Building LLM Applications with Kernel Memory and Redis](https://redis.io/blog/building-llm-applications-with-kernel-memory-and-redis/)
+* [DocArray integration of Redis as a vector database by Jina AI](https://docs.docarray.org/user_guide/storing/index_redis/)
+* [Semantic Kernel: A popular library by Microsoft to integrate LLMs with plugins](https://learn.microsoft.com/en-us/semantic-kernel/concepts/vector-store-connectors/out-of-the-box-connectors/redis-connector?pivots=programming-language-csharp)
+* [LiteLLM integration](https://docs.litellm.ai/docs/caching/all_caches#initialize-cache---in-memory-redis-s3-bucket-redis-semantic-disk-cache-qdrant-semantic)
+
+## Benchmarks
+See how we stack up against the competition.
+* [Redis vector benchmark results](https://redis.io/blog/benchmarking-results-for-vector-databases/)
+* [1 billion vectors](https://redis.io/blog/redis-8-0-m02-the-fastest-redis-ever/)
+
+## Best practices
+See how leaders in the industry are building their RAG apps.
+* [Advanced RAG example](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/04_advanced_redisvl.ipynb)
+* [Get better RAG responses with Ragas](https://redis.io/blog/get-better-rag-responses-with-ragas/)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to use pub/sub channels in Redis
+linkTitle: Pub/sub
+title: Redis Pub/Sub
+weight: 40
+---
+
+[`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}), [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}) and [`PUBLISH`]({{< relref "/commands/publish" >}}) implement the [Publish/Subscribe messaging paradigm](http://en.wikipedia.org/wiki/Publish/subscribe) where (citing Wikipedia) senders (publishers) are not programmed to send their messages to specific receivers (subscribers).
+Rather, published messages are characterized into channels, without knowledge of what (if any) subscribers there may be.
+Subscribers express interest in one or more channels and only receive messages that are of interest, without knowledge of what (if any) publishers there are.
+This decoupling of publishers and subscribers allows for greater scalability and a more dynamic network topology.
+
+For instance, to subscribe to channels "channel11" and "ch:00" the client issues a [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}) providing the names of the channels:
+
+```bash
+SUBSCRIBE channel11 ch:00
+```
+
+Messages sent by other clients to these channels will be pushed by Redis to all the subscribed clients.
+Subscribers receive the messages in the order that the messages are published.
+
+A client subscribed to one or more channels shouldn't issue commands, although it can [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}) and [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}) to and from other channels.
+The replies to subscription and unsubscribing operations are sent in the form of messages so that the client can just read a coherent stream of messages where the first element indicates the type of message.
+The commands that are allowed in the context of a subscribed RESP2 client are:
+
+* [`PING`]({{< relref "/commands/ping" >}})
+* [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}})
+* [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}})
+* [`QUIT`]({{< relref "/commands/quit" >}})
+* [`RESET`]({{< relref "/commands/reset" >}})
+* [`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}})
+* [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}})
+* [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}})
+* [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}})
+
+However, if RESP3 is used (see [`HELLO`]({{< relref "/commands/hello" >}})), a client can issue any commands while in the subscribed state.
+
+Please note that when using `redis-cli`, in subscribed mode commands such as [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}) and [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}) cannot be used because `redis-cli` will not accept any commands and can only quit the mode with `Ctrl-C`.
+
+## Delivery semantics
+
+Redis' Pub/Sub exhibits _at-most-once_ message delivery semantics.
+As the name suggests, it means that a message will be delivered once if at all.
+Once the message is sent by the Redis server, there's no chance of it being sent again.
+If the subscriber is unable to handle the message (for example, due to an error or a network disconnect) the message is forever lost.
+
+If your application requires stronger delivery guarantees, you may want to learn about [Redis Streams]({{< relref "/develop/data-types/streams" >}}).
+Messages in streams are persisted, and support both _at-most-once_ as well as _at-least-once_ delivery semantics.
+
+## Format of pushed messages
+
+A message is an [array-reply]({{< relref "/develop/reference/protocol-spec#array-reply" >}}) with three elements.
+
+The first element is the kind of message:
+
+* `subscribe`: means that we successfully subscribed to the channel given as the second element in the reply.
+  The third argument represents the number of channels we are currently subscribed to.
+
+* `unsubscribe`: means that we successfully unsubscribed from the channel given as second element in the reply.
+  The third argument represents the number of channels we are currently subscribed to.
+  When the last argument is zero, we are no longer subscribed to any channel, and the client can issue any kind of Redis command as we are outside the Pub/Sub state.
+
+* `message`: it is a message received as a result of a [`PUBLISH`]({{< relref "/commands/publish" >}}) command issued by another client.
+  The second element is the name of the originating channel, and the third argument is the actual message payload.
+
+## Database & Scoping
+
+Pub/Sub has no relation to the key space.
+It was made to not interfere with it on any level, including database numbers.
+
+Publishing on db 10, will be heard by a subscriber on db 1.
+
+If you need scoping of some kind, prefix the channels with the name of the environment (test, staging, production...).
+
+## Wire protocol example
+
+```
+SUBSCRIBE first second
+*3
+$9
+subscribe
+$5
+first
+:1
+*3
+$9
+subscribe
+$6
+second
+:2
+```
+
+At this point, from another client we issue a [`PUBLISH`]({{< relref "/commands/publish" >}}) operation against the channel named `second`:
+
+```
+> PUBLISH second Hello
+```
+
+This is what the first client receives:
+
+```
+*3
+$7
+message
+$6
+second
+$5
+Hello
+```
+
+Now the client unsubscribes itself from all the channels using the [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}) command without additional arguments:
+
+```
+UNSUBSCRIBE
+*3
+$11
+unsubscribe
+$6
+second
+:1
+*3
+$11
+unsubscribe
+$5
+first
+:0
+```
+
+## Pattern-matching subscriptions
+
+The Redis Pub/Sub implementation supports pattern matching.
+Clients may subscribe to glob-style patterns to receive all the messages sent to channel names matching a given pattern.
+
+For instance:
+
+```
+PSUBSCRIBE news.*
+```
+
+Will receive all the messages sent to the channel `news.art.figurative`, `news.music.jazz`, etc.
+All the glob-style patterns are valid, so multiple wildcards are supported.
+
+```
+PUNSUBSCRIBE news.*
+```
+
+Will then unsubscribe the client from that pattern.
+No other subscriptions will be affected by this call.
+
+Messages received as a result of pattern matching are sent in a different format:
+
+* The type of the message is `pmessage`: it is a message received as a result from a [`PUBLISH`]({{< relref "/commands/publish" >}}) command issued by another client, matching a pattern-matching subscription. 
+  The second element is the original pattern matched, the third element is the name of the originating channel, and the last element is the actual message payload.
+
+Similarly to [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}) and [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}), [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}}) and [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}) commands are acknowledged by the system sending a message of type `psubscribe` and `punsubscribe` using the same format as the `subscribe` and `unsubscribe` message format.
+
+## Messages matching both a pattern and a channel subscription
+
+A client may receive a single message multiple times if it's subscribed to multiple patterns matching a published message, or if it is subscribed to both patterns and channels matching the message. 
+This is shown by the following example:
+
+```
+SUBSCRIBE foo
+PSUBSCRIBE f*
+```
+
+In the above example, if a message is sent to channel `foo`, the client will receive two messages: one of type `message` and one of type `pmessage`.
+
+## The meaning of the subscription count with pattern matching
+
+In `subscribe`, `unsubscribe`, `psubscribe` and `punsubscribe` message types, the last argument is the count of subscriptions still active. 
+This number is the total number of channels and patterns the client is still subscribed to. 
+So the client will exit the Pub/Sub state only when this count drops to zero as a result of unsubscribing from all the channels and patterns.
+
+## Sharded Pub/Sub
+
+From Redis 7.0, sharded Pub/Sub is introduced in which shard channels are assigned to slots by the same algorithm used to assign keys to slots. 
+A shard message must be sent to a node that owns the slot the shard channel is hashed to. 
+The cluster makes sure the published shard messages are forwarded to all nodes in the shard, so clients can subscribe to a shard channel by connecting to either the master responsible for the slot, or to any of its replicas.
+[`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}}), [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}) and [`SPUBLISH`]({{< relref "/commands/spublish" >}}) are used to implement sharded Pub/Sub.
+
+Sharded Pub/Sub helps to scale the usage of Pub/Sub in cluster mode. 
+It restricts the propagation of messages to be within the shard of a cluster. 
+Hence, the amount of data passing through the cluster bus is limited in comparison to global Pub/Sub where each message propagates to each node in the cluster.
+This allows users to horizontally scale the Pub/Sub usage by adding more shards.
+ 
+## Programming example
+
+Pieter Noordhuis provided a great example using EventMachine and Redis to create [a multi user high performance web chat](https://gist.github.com/pietern/348262).
+
+## Client library implementation hints
+
+Because all the messages received contain the original subscription causing the message delivery (the channel in the case of message type, and the original pattern in the case of pmessage type) client libraries may bind the original subscription to callbacks (that can be anonymous functions, blocks, function pointers), using a hash table.
+
+When a message is received an O(1) lookup can be done to deliver the message to the registered callback.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis Query Engine use cases
+linkTitle: Use cases
+title: Use cases
+weight: 5
+---
+
+**Application search and external secondary index** 
+
+Redis Open Source supports application search, whether the source of record is Redis or another database. In the latter case, you can use Redis as an external secondary index for numeric or full-text data.
+
+**Secondary index for Redis data**
+
+You can represent your data model using Redis hashes and JSON documents. You can then declare secondary indexes to support various queries on your data set. Redis updates indexes automatically whenever a hash or JSON document that matches the indexes is added or updated. 
+
+**Geo-distributed search**
+
+In geo-distributed search, hashes and JSON documents are handled in the usual [active-active manner](https://docs.redis.com/latest/rs/databases/active-active/). The index follows whatever is written in the documents in the database. Create an index on each database, then add synonyms (if used) to each database. 
+
+**Unified search**
+
+You can use Redis to search across several source systems, like file servers, content management systems (CMS), or customer relationship management (CRM) systems. You can process source data in batches using, for example, ETL tools, or as live streams (for example, Kafka or Redis streams). 
+
+**Analytics**
+
+Data often originates from several source systems. Redis can provide a unified view of dimensions and facts. You can query data based on dimensions, group by dimension, and apply aggregations to facts.
+
+{{% alert title="Redis for faceted search" color="warning" %}}
+ 
+Facets are multiple explicit dimensions implemented as tags in the Redis Query Engine. You can query data based on facets using aggregations (`COUNT`, `TOLIST`, `FIRST_VALUE`, and `RANDOM_SAMPLE`).
+
+{{% /alert %}}
+
+**Ephemeral search (retail)**
+
+When the user logs on to the site, the purchase-search history is populated into an index from another datastore. This requires lightweight index creation, index expiry, and quick document indexing.
+
+The application/service creates a temporary and user-specific, full-text index when a user logs in. The application/service has direct access to the user-specific index and the primary datastore. When the user logs out of the service, the index is explicitly removed. Otherwise, the index expires after a while (for example, after the user's session expires). 
+
+Using Redis for this type of application provides these benefits: 
+
+- Search index is only populated when needed. 
+- Only a small portion (for example, 2%) of users are active at the same time. 
+- Users are only active for a short period of time.
+- A small number of documents are indexed, which is very cost effective in comparison to a persistent search index. 
+
+**Real-time inventory (retail)**
+
+In real-time inventory retail, the key question is product availability: "What is available where?" The challenges with such projects are performance and accuracy. Redis allows for real-time searching and aggregations over millions of store/SKU combinations.
+
+You can establish real-time event capture from a legacy inventory system to Redis and then have several inventory services query it. Then, you can use combined queries such as item counts, price ranges, categories, and locations. Take advantage of geo-distributed search (Active-Active) for your remote store locations. 
+
+Using Redis for this type of application provides these benefits: 
+
+- Low-latency queries for downstream consumers like marketing, stores/e-commerce, and fulfillment 
+- Immediate and higher consistency between stores and data-centers 
+- Improved customer experience 
+- Real-time pricing decisions 
+- Less shopping cart abandonment 
+- Less remediation (refund, cancellation) 
+
+**Real-time conversation analysis (telecom)**
+
+Collect, access, store, and utilize communication data in real time. Capture network traffic and store it in a full-text index for the purposes of getting insights into the data.
+
+Gather data using connection information gathering (source IPs, DNS) and conversation data gathering (Wireshark/TShark live capture). Then filter, transform, and store the conversation data in Redis to perform search queries and create custom dashboards for your analyses.
+
+Using Redis for this type of application provides these benefits: 
+
+- Insights into performance issues, security threats, and network faults 
+- Improved service uptime and security 
+
+**Research portal (academia)**
+
+Research portals let users search for articles, research, specifications, past solutions, and data to answer specific questions and take advantage of existing knowledge and history. 
+
+To build such a system, you can use indexes supporting tag queries, numeric range queries, geo-location queries, and full-text search. 
+
+Using Redis for this type of application provides these benefits: 
+
+- Create relevant, personalized search experiences while enforcing internal and regulatory data governance policies 
+- Increased productivity, security, and compliance  ---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use query dialects
+linkTitle: Query dialects
+title: Query dialects
+weight: 5
+---
+
+Redis Open Source currently supports four query dialects for use with the [`FT.SEARCH`]({{< relref "/commands/ft.search/" >}}), [`FT.AGGREGATE`]({{< relref "/commands/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.
+{{< /note >}}
+
+## `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](https://github.com/RediSearch/RediSearch/releases/tag/v2.4.3).
+This dialect is also the default dialect. See below for information about changing the default dialect.
+
+## `DIALECT 2`
+
+Dialect version 2 was introduced in the [2.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.4.3) release to address query parser inconsistencies found in previous versions of Redis. Dialect version 1 remains the default dialect. To use dialect version 2, append `DIALECT 2` to your query command.
+Support for vector search also was introduced in the 2.4 release and requires `DIALECT 2`. See [here]({{< relref "/develop/interact/search-and-query/query/vector-search" >}}) for more details.
+`FT.SEARCH ... DIALECT 2`
+
+It was determined that under certain conditions some query parsing rules did not behave as originally intended.
+Particularly, some queries containing the operators below could return unexpected results.
+
+1. AND, multi-word phrases that imply intersection
+1. `"..."` (exact), `~` (optional), `-` (negation), and `%` (fuzzy)
+1. OR, words separated by the `|` (pipe) character that imply union
+1. wildcard characters
+
+Existing queries that used dialect 1 may behave differently using dialect 2 if they fall into any of the following categories:
+
+1. Your query has a field modifier followed by multiple words. Consider the sample query:
+
+    `@name:James Brown`
+
+    Here, the field modifier `@name` is followed by two words, `James` and `Brown`.
+
+    In `DIALECT 1`, this query would be interpreted as find `James Brown` in the `@name` field.
+    In `DIALECT 2`, this query would be interpreted as find `James` in the `@name` field, and `Brown` in any text field. In other words, it would be interpreted as `(@name:James) Brown`. 
+    In `DIALECT 2`, you could achieve the dialect 1 behavior by updating your query to `@name:(James Brown)`.
+
+1. Your query uses `"..."`, `~`, `-`, and/or `%`. Consider a simple query with negation:
+
+    `-hello world`
+
+    In `DIALECT 1`, this query is interpreted as find values in any field that do not contain `hello` and do not contain `world`; the equivalent of `-(hello world)` or `-hello -world`.
+    In `DIALECT 2`, this query is interpreted as `-hello` and `world` (only `hello` is negated).
+    In `DIALECT 2`, you could achieve the dialect 1 behavior by updating your query to `-(hello world)`.
+
+1. Your query used `|`. Consider the simple query:
+
+    `hello world | "goodbye" moon`
+
+    In `DIALECT 1`, this query is interpreted as searching for `(hello world | "goodbye") moon`.
+    In `DIALECT 2`, this query is interpreted as searching for either `hello world` `"goodbye" moon`.
+
+1. Your query uses a wildcard pattern. Consider the simple query:
+
+    `"w'foo*bar?'"`
+
+    As shown above, you must use double quotes to contain the `w` pattern.
+
+With `DIALECT 2` you can use un-escaped spaces in tag queries, even with stopwords.
+
+{{% alert title=Note %}}
+`DIALECT 2` is required with vector searches.
+{{% /alert %}}
+
+`DIALECT 2` functionality was enhanced in the 2.10 release.
+It introduces support for new comparison operators for `NUMERIC` fields:
+
+* `==` (equal).
+  
+  `FT.SEARCH idx "@numeric==3456" DIALECT 2`
+
+  and
+
+  `FT.SEARCH idx "@numeric:[3456]" DIALECT 2`
+* `!=` (not equal).
+  
+  `FT.SEARCH idx "@numeric!=3456" DIALECT 2`
+* `>` (greater than).
+  
+  `FT.SEARCH idx "@numeric>3456" DIALECT 2`
+* `>=` (greater than or equal).
+  
+  `FT.SEARCH idx "@numeric>=3456" DIALECT 2`
+* `<` (less than).
+  
+  `FT.SEARCH idx "@numeric<3456" DIALECT 2`
+* `<=` (less than or equal).
+  
+  `FT.SEARCH idx "@numeric<=3456" DIALECT 2`
+
+The Dialect version 2 enhancements also introduce simplified syntax for logical operations:
+
+* `|` (or).
+
+  `FT.SEARCH idx "@tag:{3d3586fe-0416-4572-8ce1 | 3d3586fe-0416-6758-4ri8}" DIALECT 2`
+
+  which is equivalent to
+
+  `FT.SEARCH idx "(@tag:{3d3586fe-0416-4572-8ce1} | @tag{3d3586fe-0416-6758-4ri8})" DIALECT 2`
+
+* `<space>` (and).
+
+  `FT.SEARCH idx "(@tag:{3d3586fe-0416-4572-8ce1} @tag{3d3586fe-0416-6758-4ri8})" DIALECT 2`
+
+* `-` (negation).
+
+  `FT.SEARCH idx "(@tag:{3d3586fe-0416-4572-8ce1} -@tag{3d3586fe-0416-6758-4ri8})" DIALECT 2`
+
+* `~` (optional/proximity).
+
+  `FT.SEARCH idx "(@tag:{3d3586fe-0416-4572-8ce1} ~@tag{3d3586fe-0416-6758-4ri8})" DIALECT 2`
+
+## `DIALECT 3` (Deprecated)
+
+Dialect version 3 was introduced in the [2.6](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.3) release. This version introduced support for multi-value indexing and querying of attributes for any attribute type ( [TEXT]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-text" >}}), [TAG]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-tag" >}}), [NUMERIC]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-numeric" >}}), [GEO]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-geo" >}}) and [VECTOR]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-vector" >}})) defined by a [JSONPath]({{< relref "/develop/data-types/json/path" >}}) leading to an array or multiple scalar values. Support for [GEOSHAPE]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}}) queries was also introduced in this dialect.
+
+The primary difference between dialects version 2 and version 3 is that JSON is returned rather than scalars for multi-value attributes. Apart from specifying `DIALECT 3` at the end of a [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command, there are no other syntactic changes. Dialect version 1 remains the default dialect. To use dialect version 3, append `DIALECT 3` to your query command.
+
+`FT.SEARCH ... DIALECT 3`
+
+**Example**
+
+Sample JSON:
+
+```
+{
+  "id": 123,
+  "underlyings": [
+    {
+      "currency": "USD",
+      "spot": 99,
+      "underlier": "AAPL UW"
+    },
+    {
+      "currency": "USD",
+      "spot": 100,
+      "underlier": "NFLX UW"
+    }
+  ]
+}
+```
+
+Create an index:
+
+```
+FT.CREATE js_idx ON JSON PREFIX 1 js: SCHEMA $.underlyings[*].underlier AS und TAG
+```
+
+Now search, with and without `DIALECT 3`.
+
+- With dialect 1 (default):
+
+    ```
+    ft.search js_idx * return 1 und
+      1) (integer) 1
+      2) "js:1"
+      3) 1) "und"
+         2) "AAPL UW"
+    ```
+    
+    Only the first element of the expected two elements is returned.
+
+- With dialect 3:
+
+    ```
+    ft.search js_idx * return 1 und DIALECT 3
+        1) (integer) 1
+        2) "js:1"
+        3) 1) "und"
+           2) "[\"AAPL UW\",\"NFLX UW\"]"
+    ```
+
+    Both elements are returned.
+
+{{% alert title=Note %}}
+DIALECT 3 is required for shape-based (`POINT` or `POLYGON`) geospatial queries.
+{{% /alert %}}
+
+## `DIALECT 4` (Deprecated)
+
+Dialect version 4 was introduced in the [2.8](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4) release. It introduces performance optimizations for sorting operations on [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) and [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}). Apart from specifying `DIALECT 4` at the end of a [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command, there are no other syntactic changes. Dialect version 1 remains the default dialect. To use dialect version 4, append `DIALECT 4` to your query command.
+
+`FT.SEARCH ... DIALECT 4`
+
+Dialect version 4 will improve performance in four different scenarios:
+
+1. **Skip sorter** - applied when there is no sorting to be done. The query can return once it reaches the `LIMIT` of requested results.
+1. **Partial range** - applied when there is a `SORTBY` on a numeric field, either with no filter or with a filter by the same numeric field. Such queries will iterate on a range large enough to satisfy the `LIMIT` of requested results.
+1. **Hybrid** - applied when there is a `SORTBY` on a numeric field in addition to another non-numeric filter. It could be the case that some results will get filtered, leaving too small a range to satisfy any specified `LIMIT`. In such cases, the iterator then is re-wound and additional iterations occur to collect result up to the requested `LIMIT`.
+1. **No optimization** - If there is a sort by score or by a non-numeric field, there is no other option but to retrieve all results and compare their values to the search parameters.
+
+## Use `FT.EXPLAINCLI` to compare dialects
+	
+The [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli/" >}}) command is a powerful tool that provides a window into the inner workings of your queries. It's like a roadmap that details your query's journey from start to finish.
+
+When you run [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli/" >}}), it returns an array representing the execution plan of a complex query. This plan is a step-by-step guide of how Redis interprets your query and how it plans to fetch results. It's a behind-the-scenes look at the process, giving you insights into how the search engine works.
+
+The [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli/" >}}) accepts a `DIALECT` argument, allowing you to execute the query using different dialect versions, allowing you to compare the resulting query plans.
+
+To use [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli/" >}}), you need to provide an index and a query predicate. The index is the name of the index you created using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}), and the query predicate is the same as if you were sending it to [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) or [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}).
+
+Here's an example of how to use [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli/" >}}) to understand differences in dialect versions 1 and 2.
+
+Negation of the intersection between tokens `hello` and `world`:
+
+```FT.EXPLAINCLI idx:dialects "-hello world" DIALECT 1
+1) NOT {
+2)   INTERSECT {
+3)     hello
+4)     world
+5)   }
+6) }
+7)
+```
+
+Intersection of the negation of the token `hello` together with token `world`:
+
+```
+FT.EXPLAINCLI idx:dialects "-hello world" DIALECT 2
+ 1) INTERSECT {
+ 2)   NOT {
+ 3)     hello
+ 4)   }
+ 5)   UNION {
+ 6)     world
+ 7)     +world(expanded)
+ 8)   }
+ 9) }
+10) 
+```
+
+Same result as `DIALECT 1`:
+
+```
+FT.EXPLAINCLI idx:dialects "-(hello world)" DIALECT 2
+1) NOT {
+2)   INTERSECT {
+3)     hello
+4)     world
+5)   }
+6) }
+7) 
+```
+
+{{% alert title=Note %}}
+[`FT.EXPLAIN`]({{< relref "commands/ft.explain/" >}}) doesn't execute the query. It only explains the plan. It's a way to understand how your query is interpreted by the query engine, which can be invaluable when you're trying to optimize your searches.
+{{% /alert %}}
+
+## Change the default dialect
+
+The default dialect is `DIALECT 1`. If you wish to change that, you can do so by using the `DEFAULT_DIALECT` parameter when loading the RediSearch module:
+
+```
+$ redis-server --loadmodule ./redisearch.so DEFAULT_DIALECT 2
+```
+
+You can also change the query dialect on an already running server using the `FT.CONFIG` command:
+
+```
+FT.CONFIG SET DEFAULT_DIALECT 2
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Chinese support for searching and querying in Redis Open Source
+linkTitle: Chinese
+title: Chinese support
+weight: 15
+---
+
+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.
+
+Chinese tokenization is done by scanning the input text and checking every
+character or sequence of characters against a dictionary of predefined terms,
+and determining the most likely match based on the surrounding terms and characters.
+
+Redis makes use of the [Friso](https://github.com/lionsoul2014/friso)
+Chinese tokenization library for this purpose. This is largely transparent to
+the user and often no additional configuration is required.
+
+## Example: using chinese in queries
+
+In pseudo-code:
+
+```
+FT.CREATE idx ON HASH SCHEMA txt TEXT
+HSET docCn txt "Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。[8]"
+FT.SEARCH idx "数据" LANGUAGE chinese HIGHLIGHT SUMMARIZE
+# Outputs:
+# <b>数据</b>?... <b>数据</b>进行写操作。由于完全实现了发布... <b>数据</b>冗余很有帮助。[8...
+```
+
+Using the Python client:
+
+```
+# -*- coding: utf-8 -*-
+
+from redisearch.client import Client, Query
+from redisearch import TextField
+
+client = Client('idx')
+try:
+    client.drop_index()
+except:
+    pass
+
+client.create_index([TextField('txt')])
+
+# Add a document
+client.add_document('docCn1',
+                    txt='Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。[8]',
+                    language='chinese')
+print client.search(Query('数据').summarize().highlight().language('chinese')).docs[0].txt
+# Outputs:
+# <b>数据</b>?... <b>数据</b>进行写操作。由于完全实现了发布... <b>数据</b>冗余很有帮助。[8...
+```
+
+## Using custom dictionaries
+
+If you wish to use a custom dictionary, you can do so at the module level when
+loading the module. The `FRISOINI` setting can point to the location of a
+`friso.ini` file that contains the relevant settings and paths to the dictionary
+files.
+
+Note that there is no default `friso.ini` file location. RediSearch comes with
+its own `friso.ini` and dictionary files, which are compiled into the module
+binary at build-time.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Groupings, projections, and aggregation functions
+linkTitle: Aggregations
+title: Aggregations
+weight: 1
+---
+
+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](https://en.wikipedia.org/wiki/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.
+
+## Core concepts
+
+The basic idea of an aggregate query is this:
+
+* Perform a search query, filtering for records you wish to process.
+* Build a pipeline of operations that transform the results by zero or more sequences of:
+  * **Group and reduce**: grouping by fields in the results, and applying reducer functions to each group.
+  * **Sort**: sort the results based on one or more fields.
+  * **Apply transformations**: apply mathematical and string functions on fields in the pipeline, optionally creating new fields or replacing existing ones.
+  * **Limit**: limit the result, regardless of how the result is sorted.
+  * **Filter**: filter the results (post-query) based on predicates relating to its values.
+
+The pipeline is dynamic and re-entrant, and every operation can be repeated. For example, you can group by property X, sort the top 100 results by group size, then group by property Y and sort the results by some other property, then apply a transformation on the output.
+
+Figure 1: Aggregation Pipeline Example
+
+<img src="../../img/pipeline.png">
+
+## Aggregate request format
+
+The aggregate request's syntax is defined as follows:
+
+```sql
+FT.AGGREGATE
+  {index_name:string}
+  {query_string:string}
+  [VERBATIM]
+  [LOAD {nargs:integer} {property:string} ...]
+  [GROUPBY
+    {nargs:integer} {property:string} ...
+    REDUCE
+      {FUNC:string}
+      {nargs:integer} {arg:string} ...
+      [AS {name:string}]
+    ...
+  ] ...
+  [SORTBY
+    {nargs:integer} {string} ...
+    [MAX {num:integer}] ...
+  ] ...
+  [APPLY
+    {EXPR:string}
+    AS {name:string}
+  ] ...
+  [FILTER {EXPR:string}] ...
+  [LIMIT {offset:integer} {num:integer} ] ...
+  [PARAMS {nargs} {name} {value} ... ]
+```
+
+### Parameters in detail
+
+Parameters that can take a variable number of arguments are expressed in the
+form of `param {nargs} {property_1... property_N}`. The first argument to the
+parameter is the number of arguments following the parameter. This allows
+Redis to avoid a parsing ambiguity in case one of your arguments has the
+name of another parameter. For example, to sort by first name, last name, and
+country, one would specify `SORTBY 6 firstName ASC lastName DESC country ASC`.
+
+* **index_name**: The index the query is executed against.
+
+* **query_string**: The base filtering query that retrieves the documents. It follows the exact same syntax as the search query, including filters, unions, not, optional, etc.
+
+* **LOAD {nargs} {property} ...** : Load document fields from the document HASH objects. This should be avoided as a general rule of thumb. Fields needed for aggregations should be stored as SORTABLE (and optionally UNF to avoid any normalization), where they are available to the aggregation pipeline with very low latency. LOAD hurts the performance of aggregate queries considerably since every processed record needs to execute the equivalent of HMGET against a Redis key, which when executed over millions of keys, amounts to very high processing times.
+The document ID can be loaded using `@__key`.
+
+* **GROUPBY {nargs} {property} ...** : Group the results in the pipeline based on one or more properties. Each group should have at least one reducer (See below), a function that handles the group entries, either counting them or performing multiple aggregate operations (see below).
+
+* **REDUCE {func} {nargs} {arg} ... [AS {name}]**: Reduce the matching results in each group into a single record, using a reduction function. For example, COUNT will count the number of records in the group. See the Reducers section below for more details on available reducers.
+
+    The reducers can have their own property names using the `AS {name}` optional argument. If a name is not given, the resulting name will be the name of the reduce function and the group properties. For example, if a name is not given to COUNT_DISTINCT by property `@foo`, the resulting name will be `count_distinct(@foo)`.
+
+* **SORTBY {nargs} {property} {ASC|DESC} [MAX {num}]**: Sort the pipeline up until the point of SORTBY, using a list of properties. By default, sorting is ascending, but `ASC` or `DESC ` can be added for each property. `nargs` is the number of sorting parameters, including ASC and DESC. for example: `SORTBY 4 @foo ASC @bar DESC`.
+
+    `MAX` is used to optimized sorting, by sorting only for the n-largest elements. Although it is not connected to `LIMIT`, you usually need just `SORTBY … MAX` for common queries.
+
+* **APPLY {expr} AS {name}**: Apply a one-to-one transformation on one or more properties, and either store the result as a new property down the pipeline, or replace any property using this transformation. `expr` is an expression that can be used to perform arithmetic operations on numeric properties, or functions that can be applied on properties depending on their types (see below), or any combination thereof. For example: `APPLY "sqrt(@foo)/log(@bar) + 5" AS baz` will evaluate this expression dynamically for each record in the pipeline and store the result as a new property called baz, that can be referenced by further APPLY / SORTBY / GROUPBY / REDUCE operations down the pipeline.
+
+* **LIMIT {offset} {num}**. Limit the number of results to return just `num` results starting at index `offset` (zero based). AS mentioned above, it is much more efficient to use `SORTBY … MAX` if you are interested in just limiting the output of a sort operation.
+
+     However, limit can be used to limit results without sorting, or for paging the n-largest results as determined by `SORTBY MAX`. For example, getting results 50-100 of the top 100 results is most efficiently expressed as `SORTBY 1 @foo MAX 100 LIMIT 50 50`. Removing the MAX from SORTBY will result in the pipeline sorting all the records and then paging over results 50-100.
+
+* **FILTER {expr}**. Filter the results using predicate expressions relating to values in each result. The expressions are applied post-query and relate to the current state of the pipeline. See FILTER Expressions below for full details.
+
+* **PARAMS {nargs} {name} {value}**. Define one or more value parameters. Each parameter has a name and a value. Parameters can be referenced in the query string by a `$`, followed by the parameter name, e.g., `$user`, and each such reference in the search query to a parameter name is substituted by the corresponding parameter value. For example, with parameter definition `PARAMS 4 lon 29.69465 lat 34.95126`, the expression `@loc:[$lon $lat 10 km]` would be evaluated to `@loc:[29.69465 34.95126 10 km]`. Parameters cannot be referenced in the query string where concrete values are not allowed, such as in field names, e.g., `@loc`
+* 
+## Example
+
+A log of visits to a website might look like the following, each record of which has the following fields/properties:
+
+* **url** (text, sortable)
+* **timestamp** (numeric, sortable) - Unix timestamp of visit entry.
+* **country** (tag, sortable)
+* **user_id** (text, sortable, not indexed)
+
+### Example 1: unique users by hour, ordered chronologically.
+
+The first step is to determine the index name and the filtering query. A filter query of `*` means "get all records":
+
+```
+FT.AGGREGATE myIndex "*"
+```
+
+Next, group the results by hour. The data contains visit times as unix timestamps in second resolution, so you'll need to extract the hour component of the timestamp. To do so, add an APPLY step that strips the sub-hour information from the timestamp and stores is as a new property, `hour`:
+
+```
+FT.AGGREGATE myIndex "*"
+  APPLY "@timestamp - (@timestamp % 3600)" AS hour
+```
+
+Next, group the results by hour and count the distinct user ids in each hour. This is done by a GROUPBY/REDUCE step:
+
+```
+FT.AGGREGATE myIndex "*"
+  APPLY "@timestamp - (@timestamp % 3600)" AS hour
+
+  GROUPBY 1 @hour
+  	REDUCE COUNT_DISTINCT 1 @user_id AS num_users
+```
+
+Next, sort the results by hour, ascending:
+
+```
+FT.AGGREGATE myIndex "*"
+  APPLY "@timestamp - (@timestamp % 3600)" AS hour
+
+  GROUPBY 1 @hour
+  	REDUCE COUNT_DISTINCT 1 @user_id AS num_users
+
+  SORTBY 2 @hour ASC
+```
+
+And as a final step, format the hour as a human readable timestamp. This is done by calling the transformation function `timefmt` that formats Unix timestamps. You can specify a format to be passed to the system's `strftime` function ([see documentation](https://pubs.opengroup.org/onlinepubs/9699919799/functions/strftime.html)), but not specifying one is equivalent to specifying `%FT%TZ` to `strftime`.
+
+```
+FT.AGGREGATE myIndex "*"
+  APPLY "@timestamp - (@timestamp % 3600)" AS hour
+
+  GROUPBY 1 @hour
+  	REDUCE COUNT_DISTINCT 1 @user_id AS num_users
+
+  SORTBY 2 @hour ASC
+
+  APPLY timefmt(@hour) AS hour
+```
+
+### Example 2: Sort visits to a specific URL by day and country:
+
+The next example filters by the url, transforms the timestamp to its day part, and groups by the day and country, counting the number of visits per group, sorting by day ascending and country descending.
+
+```
+FT.AGGREGATE myIndex "@url:\"about.html\""
+    APPLY "@timestamp - (@timestamp % 86400)" AS day
+    GROUPBY 2 @day @country
+    	REDUCE count 0 AS num_visits
+    SORTBY 4 @day ASC @country DESC
+```
+
+## GROUPBY reducers
+
+`GROUPBY` works similarly to SQL `GROUP BY` clauses, and creates groups of results based on one or more properties in each record. For each group, Redis returns the group keys, or the values common to all records in the group, and the results of zero or more `REDUCE` clauses.
+
+Each `GROUPBY` step in the pipeline may be accompanied by zero or more `REDUCE` clauses. Reducers apply an accumulation function to each record in the group and reduces them into a single record representing the group. When the processing is complete, all the records upstream of the `GROUPBY` step emit their reduced record.
+
+For example, the simplest reducer is COUNT, which simply counts the number of records in each group.
+
+If multiple `REDUCE` clauses exist for a single `GROUPBY` step, each reducer works independently on each result and writes its final output once. Each reducer may have its own alias determined using the `AS` optional parameter. If `AS` is not specified, the alias is the reduce function and its parameters, e.g. `count_distinct(foo,bar)`.
+
+### Supported GROUPBY reducers
+
+#### COUNT
+
+**Format**
+
+```
+REDUCE COUNT 0
+```
+
+**Description**
+
+Count the number of records in each group
+
+#### COUNT_DISTINCT
+
+**Format**
+
+````
+REDUCE COUNT_DISTINCT 1 {property}
+````
+
+**Description**
+
+Count the number of distinct values for `property`.
+
+{{% alert title="Note" color="info" %}}
+The reducer creates a hash-set per group, and hashes each record. This can be memory heavy if the groups are big.
+{{% /alert %}}
+
+#### COUNT_DISTINCTISH
+
+**Format**
+
+```
+REDUCE COUNT_DISTINCTISH 1 {property}
+```
+
+**Description**
+
+Same as COUNT_DISTINCT, provides an approximation instead of an exact count, which consumes less memory and CPU for big groups.
+
+{{% alert title="Note" color="info" %}}
+The reducer uses [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) counters per group, at ~3% error rate, and 1024 bytes of constant space  per group. This means it is ideal for a few huge groups and not ideal for many small groups. In the former case, it can be an order of magnitude faster and consume much less memory than COUNT_DISTINCT, but again, it does not fit every use case.
+{{% /alert %}}
+
+#### SUM
+
+**Format**
+
+```
+REDUCE SUM 1 {property}
+```
+
+**Description**
+
+Return the sum of all numeric values of a given property in a group. Non-numeric values in the group are counted as 0.
+
+#### MIN
+
+**Format**
+
+```
+REDUCE MIN 1 {property}
+```
+
+**Description**
+
+Return the minimal value of a property, whether it is a string, number, or NULL.
+
+#### MAX
+
+**Format**
+
+```
+REDUCE MAX 1 {property}
+```
+
+**Description**
+
+Return the maximal value of a property, whether it is a string, number or NULL.
+
+#### AVG
+
+**Format**
+
+```
+REDUCE AVG 1 {property}
+```
+
+**Description**
+
+Return the average value of a numeric property. This is equivalent to reducing by sum and count, and later, applying the ratio of them as an APPLY step.
+
+#### STDDEV
+
+**Format**
+
+```
+REDUCE STDDEV 1 {property}
+```
+
+**Description**
+
+Return the [standard deviation](https://en.wikipedia.org/wiki/Standard_deviation) of a numeric property in the group.
+
+#### QUANTILE
+
+**Format**
+
+```
+REDUCE QUANTILE 2 {property} {quantile}
+```
+
+**Description**
+
+Return the value of a numeric property at a given quantile of the results. Quantile is expressed as a number between 0 and 1. For example, the median can be expressed as the quantile at 0.5, e.g. `REDUCE QUANTILE 2 @foo 0.5 AS median` .
+
+If multiple quantiles are required, just repeat the QUANTILE reducer for each quantile. For example, `REDUCE QUANTILE 2 @foo 0.5 AS median REDUCE QUANTILE 2 @foo 0.99 AS p99`.
+
+#### TOLIST
+
+**Format**
+
+```
+REDUCE TOLIST 1 {property}
+```
+
+**Description**
+
+Merge all distinct values of a given property into a single array.
+
+#### FIRST_VALUE
+
+**Format**
+
+```
+REDUCE FIRST_VALUE {nargs} {property} [BY {property} [ASC|DESC]]
+```
+
+**Description**
+
+Return the first or top value of a given property in the group, optionally by comparing it to another property. For example, you can extract the name of the oldest user in the group:
+
+```
+REDUCE FIRST_VALUE 4 @name BY @age DESC
+```
+
+If no `BY` is specified, the first value encountered in the group is returned.
+
+If you wish to get the top or bottom value in the group sorted by the same value, you are better off using the `MIN/MAX` reducers, but the same effect will be achieved by doing `REDUCE FIRST_VALUE 4 @foo BY @foo DESC`.
+
+#### RANDOM_SAMPLE
+
+**Format**
+
+```
+REDUCE RANDOM_SAMPLE {nargs} {property} {sample_size}
+```
+
+**Description**
+
+Perform a reservoir sampling of the group elements with a given size, and return an array of the sampled items with an even distribution.
+
+## APPLY expressions
+
+`APPLY` performs a one-to-one transformation on one or more properties in each record. It either stores the result as a new property down the pipeline, or replaces any property using this transformation.
+
+The transformations are expressed as a combination of arithmetic expressions and built in functions. Evaluating functions and expressions is recursively nested and can be composed without limit. For example: `sqrt(log(foo) * floor(@bar/baz)) + (3^@qaz % 6)` or simply `@foo/@bar`.
+
+If an expression or a function is applied to values that do not match the expected types, no error is emitted and a NULL value is set as the result.
+
+APPLY steps must have an explicit alias determined by the `AS` parameter.
+
+### Literals inside expressions
+
+* Numbers are expressed as integers or floating point numbers, e.g., `2`, `3.141`, and `-34`. `inf` and `-inf` are acceptable as well.
+* Strings are quoted with either single or double quotes. Single quotes are acceptable inside strings quoted with double quotes and vice versa. Punctuation marks can be escaped with backslashes. e.g. `"foo's bar"` ,`'foo\'s bar'`, `"foo \"bar\""` .
+* Any literal or sub-expression can be wrapped in parentheses to resolve ambiguities of operator precedence.
+
+### Arithmetic operations
+
+For numeric expressions and properties, addition (`+`), subtraction (`-`), multiplication (`*`), division (`/`), modulo (`%`), and power (`^`) are supported. Bitwise logical operators are not supported.
+
+Note that these operators apply only to numeric values and numeric sub-expressions. Any attempt to multiply a string by a number, for instance, will result in a NULL output.
+
+### List of field APPLY functions
+
+| Function | Description                                                  | Example            |
+| -------- | ------------------------------------------------------------ | ------------------ |
+| exists(s)| Checks whether a field exists in a document.                 | `exists(@field)`   |
+
+### List of numeric APPLY functions
+
+| Function | Description                                                  | Example            |
+| -------- | ------------------------------------------------------------ | ------------------ |
+| log(x)   | Return the logarithm of a number, property or subexpression  | `log(@foo)`        |
+| abs(x)   | Return the absolute number of a numeric expression           | `abs(@foo-@bar)`   |
+| ceil(x)  | Round to the smallest value not less than x                  | `ceil(@foo/3.14)`  |
+| floor(x) | Round to largest value not greater than x                    | `floor(@foo/3.14)` |
+| log2(x)  | Return the logarithm of x to base 2                          | `log2(2^@foo)`     |
+| exp(x)   | Return the exponent of x, e.g., `e^x`                        | `exp(@foo)`        |
+| sqrt(x)  | Return the square root of x                                  | `sqrt(@foo)`       |
+
+### List of string APPLY functions
+
+| Function                         |                                                              |                                                          |
+| -------------------------------- | ------------------------------------------------------------ | -------------------------------------------------------- |
+| upper(s)                         | Return the uppercase conversion of s                         | `upper('hello world')`                                   |
+| lower(s)                         | Return the lowercase conversion of s                         | `lower("HELLO WORLD")`                                   |
+| startswith(s1,s2)                | Return `1` if s2 is the prefix of s1, `0` otherwise.         | `startswith(@field, "company")`                          |
+| contains(s1,s2)                  | Return the number of occurrences of s2 in s1, `0` otherwise. If s2 is an empty string, return `length(s1) + 1`.  | `contains(@field, "pa")`                                 |
+| strlen(s)                        | Return the length of s                                       | `strlen(@t)`                                             |
+| substr(s, offset, count)         | Return the substring of s, starting at _offset_ and having _count_ characters. <br />If offset is negative, it represents the distance from the end of the string. <br />If count is -1, it means "the rest of the string starting at offset". | `substr("hello", 0, 3)` <br> `substr("hello", -2, -1)`  |
+| format( fmt, ...)                | Use the arguments following `fmt` to format a string. <br />Currently the only format argument supported is `%s` and it applies to all types of arguments. | `format("Hello, %s, you are %s years old", @name, @age)` |
+| matched_terms([max_terms=100])   | Return the query terms that matched for each record (up to 100), as a list. If a limit is specified, Redis will return the first N matches found, based on query order. | `matched_terms()`                                        |
+| split(s, [sep=","], [strip=" "]) | Split a string by any character in the string sep, and strip any characters in strip. If only s is specified, it is split by commas and spaces are stripped. The output is an array. | split("foo,bar")                                         |
+
+### List of date/time APPLY functions
+
+| Function            | Description                                                  |
+| ------------------- | ------------------------------------------------------------ |
+| timefmt(x, [fmt])      | Return a formatted time string based on a numeric timestamp value x. <br /> See [strftime](https://pubs.opengroup.org/onlinepubs/9699919799/functions/strftime.html) for formatting options. <br />Not specifying `fmt` is equivalent to `%FT%TZ`. |
+| parsetime(timesharing, [fmt]) | The opposite of timefmt() - parse a time format using a given format string |
+| day(timestamp) | Round a Unix timestamp to midnight (00:00) start of the current day. |
+| hour(timestamp) | Round a Unix timestamp to the beginning of the current hour. |
+| minute(timestamp) | Round a Unix timestamp to the beginning of the current minute. |
+| month(timestamp) | Round a unix timestamp to the beginning of the current month. |
+| dayofweek(timestamp) | Convert a Unix timestamp to the day number (Sunday = 0). |
+| dayofmonth(timestamp) | Convert a Unix timestamp to the day of month number (1 .. 31). |
+| dayofyear(timestamp) | Convert a Unix timestamp to the day of year number (0 .. 365). |
+| year(timestamp) | Convert a Unix timestamp to the current year (e.g. 2018). |
+| monthofyear(timestamp) | Convert a Unix timestamp to the current month (0 .. 11). |
+
+### List of geo APPLY functions
+
+| Function | Description                                                  | Example            |
+| -------- | ------------------------------------------------------------ | ------------------ |
+| geodistance(field,field)        | Return distance in meters.    | `geodistance(@field1,@field2)`       |
+| geodistance(field,"lon,lat")    | Return distance in meters.    | `geodistance(@field,"1.2,-3.4")`     |
+| geodistance(field,lon,lat)      | Return distance in meters.    | `geodistance(@field,1.2,-3.4)`       |
+| geodistance("lon,lat",field)    | Return distance in meters.    | `geodistance("1.2,-3.4",@field)`     |
+| geodistance("lon,lat","lon,lat")| Return distance in meters.    | `geodistance("1.2,-3.4","5.6,-7.8")` |
+| geodistance("lon,lat",lon,lat)  | Return distance in meters.    | `geodistance("1.2,-3.4",5.6,-7.8)`   |
+| geodistance(lon,lat,field)      | Return distance in meters.    | `geodistance(1.2,-3.4,@field)`       |
+| geodistance(lon,lat,"lon,lat")  | Return distance in meters.    | `geodistance(1.2,-3.4,"5.6,-7.8")`   |
+| geodistance(lon,lat,lon,lat)    | Return distance in meters.    | `geodistance(1.2,-3.4,5.6,-7.8)`     |
+
+```
+FT.AGGREGATE myIdx "*"  LOAD 1 location  APPLY "geodistance(@location,\"-1.1,2.2\")" AS dist
+```
+
+To retrieve the distance:
+
+```
+FT.AGGREGATE myIdx "*"  LOAD 1 location  APPLY "geodistance(@location,\"-1.1,2.2\")" AS dist
+```
+
+Note: the geo field must be preloaded using `LOAD`.
+
+Results can also be sorted by distance:
+
+```
+FT.AGGREGATE idx "*" LOAD 1 @location FILTER "exists(@location)" APPLY "geodistance(@location,-117.824722,33.68590)" AS dist SORTBY 2 @dist DESC
+```
+
+Note: Make sure no location is missing, otherwise the SORTBY will not return any results.
+Use FILTER to make sure you do the sorting on all valid locations.
+
+## FILTER expressions
+
+FILTER expressions filter the results using predicates relating to values in the result set.
+
+The FILTER expressions are evaluated post-query and relate to the current state of the pipeline. Thus they can be useful to prune the results based on group calculations. Note that the filters are not indexed and will not speed up processing.
+
+Filter expressions follow the syntax of APPLY expressions, with the addition of the conditions `==`, `!=`, `<`, `<=`, `>`, `>=`. Two or more predicates can be combined with logical AND (`&&`) and OR (`||`). A single predicate can be negated with a NOT prefix (`!`).
+
+For example, filtering all results where the user name is 'foo' and the age is less than 20 is expressed as:
+
+```
+FT.AGGREGATE
+  ...
+  FILTER "@name=='foo' && @age < 20"
+  ...
+```
+
+Several filter steps can be added, although at the same stage in the pipeline, it is more efficient to combine several predicates into a single filter step.
+
+## Cursor API
+
+```
+FT.AGGREGATE ... WITHCURSOR [COUNT {read size} MAXIDLE {idle timeout}]
+FT.CURSOR READ {idx} {cid} [COUNT {read size}]
+FT.CURSOR DEL {idx} {cid}
+```
+
+You can use cursors with [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}), with the `WITHCURSOR` keyword. Cursors allow you to
+consume only part of the response, allowing you to fetch additional results as needed.
+This is much quicker than using `LIMIT` with offset, since the query is executed only
+once, and its state is stored on the server.
+
+To use cursors, specify the `WITHCURSOR` keyword in [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}). For example:
+
+```
+FT.AGGREGATE idx * WITHCURSOR
+```
+
+This will return a response of an array with two elements. The first element is
+the actual (partial) result, and the second is the cursor ID. The cursor ID
+can then be fed to [`FT.CURSOR READ`]({{< relref "commands/ft.cursor-read/" >}}) repeatedly until the cursor ID is 0, in
+which case all results have been returned.
+
+To read from an existing cursor, use [`FT.CURSOR READ`]({{< relref "commands/ft.cursor-read/" >}}). For example:
+
+```
+FT.CURSOR READ idx 342459320
+```
+
+Assuming `342459320` is the cursor ID returned from the [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) request, here is an example in pseudo-code:
+
+```
+response, cursor = FT.AGGREGATE "idx" "redis" "WITHCURSOR";
+while (1) {
+  processResponse(response)
+  if (!cursor) {
+    break;
+  }
+  response, cursor = FT.CURSOR read "idx" cursor
+}
+```
+
+Note that even if the cursor is 0, a partial result may still be returned.
+
+### Cursor settings
+
+#### Read size
+
+You can control how many rows are read for each cursor fetch by using the
+`COUNT` parameter. This parameter can be specified both in [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}})
+(immediately after `WITHCURSOR`) or in [`FT.CURSOR READ`]({{< relref "commands/ft.cursor-read/" >}}).
+
+The following example will read 10 rows at a time:
+```
+FT.AGGREGATE idx query WITHCURSOR COUNT 10
+```
+
+You can override this setting by also specifying `COUNT` in `CURSOR READ`. The following example will return at most 50 results:
+
+```
+FT.CURSOR READ idx 342459320 COUNT 50
+```
+
+The default read size is 1000.
+
+#### Timeouts and limits
+
+Because cursors are stateful resources that occupy memory on the server, they
+have a limited lifetime. To safeguard against orphaned/stale cursors,
+cursors have an idle timeout value. If no activity occurs on the cursor before
+the idle timeout, the cursor is deleted. The idle timer resets to 0 whenever
+the cursor is read from using `CURSOR READ`.
+
+The default idle timeout is 300000 milliseconds (or 300 seconds). You can modify
+the idle timeout using the `MAXIDLE` keyword when creating the cursor. Note that
+the value cannot exceed the default 300s.
+
+For example, to set a limit of ten seconds:
+
+```
+FT.AGGREGATE idx query WITHCURSOR MAXIDLE 10000
+```
+
+### Other cursor commands
+
+Cursors can be explicitly deleted using the `CURSOR DEL` command. For example:
+
+```
+FT.CURSOR DEL idx 342459320
+```
+
+Note that cursors are automatically deleted if all their results have been
+returned, or if they have timed out.
+
+All idle cursors can be forcefully purged at the same time using `FT.CURSOR GC idx 0` command.
+By default, Redis uses a lazy throttled approach to garbage collection, which
+collects idle cursors every 500 operations, or every second, whichever is later.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Stop words support
+linkTitle: Stop words
+title: Stop words
+weight: 1
+---
+
+Redis Open Source has a default list of [stop words](https://en.wikipedia.org/wiki/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. 
+
+At the moment, the default stop word list applies to all full-text indexes in all languages and can be overridden manually at index creation time. 
+
+## Default stop word list
+
+The following words are treated as stop words by default: 
+
+```
+ a,    is,    the,   an,   and,  are, as,  at,   be,   but,  by,   for,
+ if,   in,    into,  it,   no,   not, of,  on,   or,   such, that, their,
+ then, there, these, they, this, to,  was, will, with
+```
+
+## Overriding the default stop word list
+
+Stop words for an index can be defined (or disabled completely) on index creation using the `STOPWORDS` argument with the [[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) command.
+
+The format is `STOPWORDS {number} {stopword} ...` where number is the number of stop words given. The `STOPWORDS` argument must come before the `SCHEMA` argument. For example:
+
+```
+FT.CREATE myIndex STOPWORDS 3 foo bar baz SCHEMA title TEXT body TEXT 
+```
+
+## Disable the use of stop words
+
+Disabling stop words completely can be done by passing `STOPWORDS 0` to [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+
+
+## Avoiding stop word detection in search queries
+
+In rare use cases, where queries are very long and are guaranteed by the client application not to contain stop words, it is possible to avoid checking for them when parsing the query. This saves some CPU time and is only worth it if the query has dozens or more terms in it. Using this without verifying that the query doesn't contain stop words might result in empty queries. 
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about phonetic matching capabilities
+linkTitle: Phonetic
+title: Phonetic matching
+weight: 14
+---
+
+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.
+
+Performing a search on `PHONETIC` fields will, by default, also return results for phonetically similar terms. This behavior can be controlled with the [`$phonetic` query attribute]({{< relref "/develop/interact/search-and-query/query/#query-attributes" >}}).
+
+## Phonetic algorithms support
+
+Redis currently supports a single phonetic algorithm, the [Double Metaphone](https://en.wikipedia.org/wiki/Metaphone#Double_Metaphone) (DM). It uses the implementation at the [slacy/double-metaphone GitHub site](https://github.com/slacy/double-metaphone), which provides general support for Latin languages.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Highlighting full-text results
+linkTitle: Highlighting
+title: Highlighting
+weight: 7
+---
+
+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.
+
+### Summarization
+
+```
+FT.SEARCH ...
+    SUMMARIZE [FIELDS {num} {field}] [FRAGS {numFrags}] [LEN {fragLen}] [SEPARATOR {sepStr}]
+```
+
+Summarization will fragment the text into smaller sized snippets, each of which containing the found term(s) and some additional surrounding context.
+
+Redis can perform summarization using the `SUMMARIZE` keyword. If no additional arguments are passed, all returned fields are summarized using built-in defaults.
+
+The `SUMMARIZE` keyword accepts the following arguments:
+
+* **`FIELDS`**: If present, it must be the first argument. This should be followed
+    by the number of fields to summarize, which itself is followed by a list of
+    fields. Each field is summarized. If no `FIELDS` directive is passed,
+    then all returned fields are summarized.
+
+* **`FRAGS`**: The number of fragments to be returned. If not specified, a default is 3.
+
+* **`LEN`**: The number of context words each fragment should contain. Context
+    words surround the found term. A higher value will return a larger block of
+    text. If not specified, the default value is 20.
+
+* **`SEPARATOR`**: The string used to divide individual summary snippets.
+    The default is `... ` which is common among search engines, but you may
+    override this with any other string if you desire to programmatically divide the snippets
+    later on. You may also use a newline sequence, as newlines are stripped from the
+    result body during processing.
+
+### Highlighting
+
+```
+FT.SEARCH ... HIGHLIGHT [FIELDS {num} {field}] [TAGS {openTag} {closeTag}]
+```
+
+Highlighting will surround the found term (and its variants) with a user-defined pair of tags. This may be used to display the matched text in a different typeface using a markup language, or to otherwise make the text appear differently.
+
+Redis performs highlighting using the `HIGHLIGHT` keyword. If no additional arguments are passed, all returned fields are highlighted using built-in defaults.
+
+The `HIGHLIGHT` keyword accepts the following arguments:
+
+* **`FIELDS`**: If present, it must be the first argument. This should be followed
+    by the number of fields to highlight, which itself is followed by a list of
+    fields. Each field present is highlighted. If no `FIELDS` directive is passed,
+    then all returned fields are highlighted.
+    
+* **`TAGS`**: If present, it must be followed by two strings. The first string is prepended
+    to each matched term. The second string is appended to each matched term. If no `TAGS` are
+    specified, a built-in tag pair is prepended and appended to each matched term.
+
+
+#### Field selection
+
+If no specific fields are passed to the `RETURN`, `SUMMARIZE`, or `HIGHLIGHT` keywords, then all of a document's fields are returned. However, if any of these keywords contain a `FIELD` directive, then the `SEARCH` command will only return the sum total of all fields enumerated in any of those directives.
+
+The `RETURN` keyword is treated specially, as it overrides any fields specified in `SUMMARIZE` or `HIGHLIGHT`.
+
+In the command `RETURN 1 foo SUMMARIZE FIELDS 1 bar HIGHLIGHT FIELDS 1 baz`, the fields `foo` is returned as-is, while `bar` and `baz` are not returned, because `RETURN` was specified, but did not include those fields.
+
+In the command `SUMMARIZE FIELDS 1 bar HIGHLIGHT FIELDS 1 baz`, `bar` is returned summarized and `baz` is returned highlighted.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use the autocomplete feature of Redis for efficient prefix-based suggestion retrieval.
+linkTitle: Autocomplete
+title: Autocomplete with Redis
+weight: 1
+---
+
+## Overview
+
+Redis Query Engine provides an autocomplete feature using suggestions that are stored in a [trie-based](https://en.wikipedia.org/wiki/Trie) 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.
+
+This guide covers how to use the [`FT.SUGADD`]({{< relref "/commands/ft.sugadd" >}}), [`FT.SUGGET`]({{< relref "/commands/ft.sugget" >}}), [`FT.SUGDEL`]({{< relref "/commands/ft.sugdel" >}}), and [`FT.SUGLEN`]({{< relref "/commands/ft.suglen" >}}) commands to implement autocomplete, and some examples of how you can use these commands with [`FT.SEARCH`]({{< relref "/commands/ft.search" >}}).
+
+## Add autocomplete suggestions
+
+To add phrases or words to a suggestions dictionary, use the [`FT.SUGADD`]({{< relref "/commands/ft.sugadd" >}}) command.
+You will assign a score to each entry, which determines its ranking in the results.
+
+```
+FT.SUGADD autocomplete "hello world" 100
+FT.SUGADD autocomplete "hello there" 90
+FT.SUGADD autocomplete "help me" 80
+FT.SUGADD autocomplete "hero" 70
+```
+
+Integer scores were used in the above examples, but the scores argument is described as being floating point.
+Integer scores are converted to floating point internally.
+Also, "`autocomplete`" in the above examples is just the name of the key; you can use any key name you wish.
+
+### Optional arguments
+
+The `FT.SUGADD` command can take two optional arguments:
+
+* `INCR`: increments the existing entry of the suggestion by the given score instead of replacing the score. This is useful for updating the dictionary based on user queries in real time.
+* `PAYLOAD`: saves a string with the suggestion, which can be fetched by adding the `WITHPAYLOADS` argument to `FT.SUGGET`.
+
+## Retrieve suggestions
+
+To get autocomplete suggestions for a given prefix, use the [`FT.SUGGET`]({{< relref "/commands/ft.sugget" >}}) command.
+
+```
+redis> FT.SUGGET autocomplete "he"
+1) "hero"
+2) "help me"
+3) "hello world"
+4) "hello there"
+```
+
+If you wish to see the scores, use the `WITHSCORES` option:
+
+```
+redis> FT.SUGGET autocomplete "he" WITHSCORES
+1) "hero"
+2) "40.414520263671875"
+3) "help me"
+4) "32.65986251831055"
+5) "hello world"
+6) "31.62277603149414"
+7) "hello there"
+8) "28.460498809814453"
+```
+
+### Enable fuzzy matching
+
+If you want to allow for small spelling mistakes or typos, use the `FUZZY` option. This option performs a fuzzy prefix search, including prefixes at a [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) of 1 from the provided prefix.
+
+```
+redis> FT.SUGGET autocomplete hell FUZZY
+1) "hello world"
+2) "hello there"
+3) "help me"
+```
+
+### Optional arguments
+
+There are three additional arguments you can use wit `FT.SUGGET`:
+
+* `MAX num`: limits the results to a maximum of `num`. The default for `MAX` is 5.
+* `WITHSCORES`: returns the score of each suggestion.
+* `WITHPAYLOADS`: returns optional payloads saved with the suggestions. If no payload is present for an entry, a `nil` reply is returned.
+    ```
+    redis> FT.SUGADD autocomplete hero 70 PAYLOAD "you're no hero"
+    (integer) 4
+    redis> FT.SUGGET autocomplete "hr" FUZZY WITHPAYLOADS
+    1) "hero"
+    2) "you're no hero"
+    3) "help me"
+    4) (nil)
+    5) "hello world"
+    6) (nil)
+    7) "hello there"
+    8) (nil)
+    ```
+
+## Delete suggestions
+
+To remove a specific suggestion from the dictionary, use the `FT.SUGDEL` command.
+
+```
+redis> FT.SUGDEL autocomplete "help me"
+(integer 1)
+```
+
+After deletion, running `FT.SUGGET autocomplete hell FUZZY` will no longer return "help me".
+
+## Check the number of suggestions
+
+To get a count of the number of entries in a given suggestions dictionary, use the `FT.SUGLEN` command.
+
+```
+redis> FT.SUGLEN autocomplete
+(integer) 3
+```
+
+## Use autocomplete with search
+
+A common approach is to:
+
+1. Use FT.SUGGET to suggest query completions as users type in a text field.
+1. Once the user selects a suggestion, run FT.SEARCH using the selected term to get full search results.
+
+Example workflow
+
+1. Get suggestions for a given user input.
+
+    ```
+    FT.SUGGET autocomplete "hel"
+    ```
+1. Capture the user's selection.
+1. Use the selected suggestion in a full-text search.
+
+    ```
+    FT.SEARCH index "hello world"
+    ```
+
+### When to use autocomplete versus full-text search
+
+* Use `FT.SUGGET` when you need fast, real-time prefix-based suggestion retrieval.
+* Use `FT.SEARCH` when you need document retrieval, filtering, and ranking based on relevance.
+
+## Autocomplete use cases
+
+The autocomplete feature in Redis Query Engine is useful for:
+
+- **Search box suggestions**: providing live suggestions as users type.
+- **Command completion**: offering autocompletion for CLI tools.
+- **Product search**: suggesting product names in e-commerce applications.
+- **Chatbot responses**: recommending common phrases dynamically.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Controlling text tokenization and escaping
+linkTitle: Tokenization
+title: Tokenization
+weight: 4
+---
+
+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.
+
+During a search, the query system also tokenizes the
+query text and then simply compares the tokens from the query against the tokens stored
+for each document. Finding a match like this is much more efficient than pattern-matching on
+the whole text and also lets you use
+[stemming]({{< relref "/develop/interact/search-and-query/advanced-concepts/stemming" >}}) and
+[stop words]({{< relref "/develop/interact/search-and-query/advanced-concepts/stopwords" >}})
+to improve the search even further. See this article about
+[Tokenization](https://queryunderstanding.com/tokenization-c8cdd6aef7ff)
+for a general introduction to the concepts.
+
+Redis uses a very simple tokenizer for documents and a slightly more sophisticated tokenizer for queries. Both allow a degree of control over string escaping and tokenization. 
+
+The sections below describe the rules for tokenizing text fields and queries.
+Note that
+[Tag fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}) 
+are essentially text fields but they use a simpler form of tokenization, as described
+separately in the
+[Tokenization rules for tag fields](#tokenization-rules-for-tag-fields) section.
+
+## Tokenization rules for text fields
+
+1. All punctuation marks and whitespace (besides underscores) separate the document and queries into tokens. For example, any character of `,.<>{}[]"':;!@#$%^&*()-+=~` will break the text into terms, so the text `foo-bar.baz...bag` will be tokenized into `[foo, bar, baz, bag]`
+
+2. Escaping separators in both queries and documents is done by prepending a backslash to any separator. For example, the text `hello\-world hello-world` will be tokenized as `[hello-world, hello, world]`. In most languages you will need an extra backslash to signify an actual backslash when formatting the document or query, so the actual text entered into redis-cli will be `hello\\-world`. 
+
+3. Underscores (`_`) are not used as separators in either document or query, so the text `hello_world` will remain as is after tokenization. 
+
+4. Repeating spaces or punctuation marks are stripped. 
+
+5. Latin characters are converted to lowercase. 
+
+6. A backslash before the first digit will tokenize it as a term. This will translate the `-` sign as NOT, which otherwise would make the number negative. Add a backslash before `.` if you are searching for a float. For example, `-20 -> {-20} vs -\20 -> {NOT{20}}`.
+
+## Tokenization rules for tag fields
+
+[Tag fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}) interpret
+a text field as a list of *tags* delimited by a
+[separator]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags#creating-a-tag-field" >}})
+character (which is a comma "," by
+default). The tokenizer simply splits the text wherever it finds the separator and so most
+punctuation marks and whitespace are valid characters within each tag token. The only
+changes that the tokenizer makes to the tags are:
+
+-   Trimming whitespace at the start and end of the tag. Other whitespace in the tag text is left intact.
+-   Converting Latin alphabet characters to lowercase. You can override this by adding the
+    [`CASESENSITIVE`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#tag-fields" >}}) option in the indexing schema for the tag field.
+
+This means that when you define a tag field, you don't need to escape any characters, except
+in the unusual case where you want leading or trailing spaces to be part of the tag text.
+However, you do need to escape certain characters in a *query* against a tag field. See the
+[Query syntax]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax#tag-filters" >}}) and
+[Exact match]({{< relref "/develop/interact/search-and-query/query/exact-match" >}}) pages for more information about escaping
+and how to use [DIALECT 2]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}), which is required for
+exact match queries involving tags.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Learn how to use query syntax
+
+  '
+linkTitle: Query syntax
+title: Query syntax
+weight: 5
+---
+
+{{< 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]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}})
+for full details of the dialects and the RediSearch versions that introduced them.
+{{< /note >}}
+
+## Basic syntax
+
+You can use simple syntax for complex queries using these rules:
+
+* Exact phrases are wrapped in quotes, for example, `"hello world"`.
+* Multiword phrases are lists of tokens, for example, `foo bar baz`, and imply intersection (AND) of the terms.
+* `OR` unions are expressed with a pipe (`|`) character, for example, `hello|hallo|shalom|hola`. 
+
+   **Notes**:   
+   
+   Consider the differences in parser behavior in example `hello world | "goodbye" moon`:
+   * In DIALECT 1, this query is interpreted as searching for `(hello world | "goodbye") moon`.
+   * In DIALECT 2 or greater, this query is interpreted as searching for either `hello world` **OR** `"goodbye" moon`.
+   
+* `NOT` negation of expressions or subqueries is expressed with a subtraction symbol (`-`), for example, `hello -world`. Purely negative queries such as `-foo` and `-@title:(foo|bar)` are also supported.
+
+   **Notes**:
+   
+   Consider a simple query with negation `-hello world`:
+   * In DIALECT 1, this query is interpreted as "find values in any field that does not contain `hello` **AND** does not contain `world`". The equivalent is `-(hello world)` or `-hello -world`.
+   * In DIALECT 2 or greater, this query is interpreted `as -hello` **AND** `world` (only `hello` is negated).
+   * In DIALECT 2 or greater, to achieve the default behavior of DIALECT 1, update your query to `-(hello world)`.
+  
+* Prefix/infix/suffix matches (all terms starting/containing/ending with a term) are expressed with an asterisk `*`. For performance reasons, a minimum term length is enforced. The default is 2, but it's configurable.
+* In DIALECT 2 or greater, wildcard pattern matches are expressed as `"w'foo*bar?'"`. Note the use of double quotes to contain the _w_ pattern.
+* A special wildcard query that returns all results in the index is just the asterisk `*`. This cannot be combined with other options.
+* As of v2.6.1, `DIALECT 3` returns JSON rather than scalars from multivalue attributes.
+* Selection of specific fields using the syntax `hello @field:world`.
+* Numeric range matches on numeric fields with the syntax `@field:[{min} {max}]`.
+* Georadius matches on geo fields with the syntax `@field:[{lon} {lat} {radius} {m|km|mi|ft}]`.
+* As of 2.6, range queries on vector fields with the syntax `@field:[VECTOR_RANGE {radius} $query_vec]`, where `query_vec` is given as a query parameter.
+* As of v2.4, k-nearest neighbors (KNN) queries on vector fields with or without pre-filtering with the syntax `{filter_query}=>[KNN {num} @field $query_vec]`.
+* Tag field filters with the syntax `@field:{tag | tag | ...}`. See the full documentation on [tags]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}).
+* Optional terms or clauses: `foo ~bar` means bar is optional but documents containing `bar` will rank higher.
+* Fuzzy matching on terms: `%hello%` means all terms with Levenshtein distance of 1 from it. Use multiple pairs of '%' brackets, up to three deep, to increase the Levenshtein distance.
+* An expression in a query can be wrapped in parentheses to disambiguate, for example, `(hello|hella) (world|werld)`.
+* Query attributes can be applied to individual clauses, for example, `(foo bar) => { $weight: 2.0; $slop: 1; $inorder: false; }`.
+* Combinations of the above can be used together, for example, `hello (world|foo) "bar baz" bbbb`.
+
+## Pure negative queries
+
+As of v0.19.3, it is possible to have a query consisting of just a negative expression. For example `-hello` or `-(@title:(foo|bar))`. The results are all the documents not containing the query terms.
+
+{{% alert title="Warning" color="warning" %}}
+Any complex expression can be negated this way, however, caution should be taken here: if a negative expression has little or no results, this is equivalent to traversing and ranking all the documents in the index, which can be slow and cause high CPU consumption.
+{{% /alert %}}
+
+## Field modifiers
+
+You can specify field modifiers in a query, and not just by using the `INFIELDS` global keyword.
+
+To specify which fields the query matches, prepend the expression with the `@` symbol, the field name, and a `:` (colon) symbol, for each expression or subexpression.
+
+If a field modifier precedes multiple words or expressions, it applies only to the adjacent expression with DIALECT 1. With DIALECT 2 or greater, you extend the query to other fields.
+
+Consider this simple query: `@name:James Brown`. Here, the field modifier `@name` is followed by two words: `James` and `Brown`.
+
+* In DIALECT 1, this query would be interpreted as "find `James Brown` in the `@name` field".
+* In DIALECT 2 or greater, this query will be interpreted as "find `James` in the `@name` field **AND** `Brown` in **ANY** text field. In other words, it would be interpreted as `(@name:James) Brown`.
+* In DIALECT 2 or greater, to achieve the default behavior of DIALECT 1, update your query to `@name:(James Brown)`.
+
+If a field modifier precedes an expression in parentheses, it applies only to the expression inside the parentheses. The expression should be valid for the specified field, otherwise it is skipped.
+
+To create complex filtering on several fields, you can combine multiple modifiers. For example, if you have an index of car models, with a vehicle class, country of origin, and engine type, you can search for SUVs made in Korea with hybrid or diesel engines using the following query:
+
+```
+FT.SEARCH cars "@country:korea @engine:(diesel|hybrid) @class:suv"
+```
+
+You can apply multiple modifiers to the same term or grouped terms:
+
+```
+FT.SEARCH idx "@title|body:(hello world) @url|image:mydomain"
+```
+
+Now, you search for documents that have `"hello"` and `"world"` either in the body or the title and the term `mydomain` in their `url` or `image` fields.
+
+## Numeric filters in query
+
+If a field in the schema is defined as NUMERIC, it is possible to use the FILTER argument in the Redis request or filter with it by specifying filtering rules in the query. The syntax is `@field:[{min} {max}]`, for example, `@price:[100 200]`.
+
+### A few notes on numeric predicates
+
+1. It is possible to specify a numeric predicate as the entire query, whereas it is impossible to do it with the `FILTER` argument.
+
+2. It is possible to intersect or union multiple numeric filters in the same query, be it for the same field or different ones.
+
+3. `-inf`, `inf` and `+inf` are acceptable numbers in a range. Therefore, _greater than 100_ is expressed as `[(100 inf]`.
+
+4. Numeric filters are inclusive. Exclusive min or max are expressed with `(` prepended to the number, for example, `[(100 (200]`.
+
+5. It is possible to negate a numeric filter by prepending a `-` sign to the filter. For example, returning a result where price differs from 100 is expressed as: `@title:foo -@price:[100 100]`.
+
+## Tag filters
+
+As of v0.91, you can use a special field type called a
+[_tag field_]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}), with simpler
+[tokenization]({{< relref "/develop/interact/search-and-query/advanced-concepts/escaping#tokenization-rules-for-tag-fields" >}})
+and encoding in the index. You can't access the values in these fields using a general fieldless search. Instead, you use special syntax:
+
+```
+@field:{ tag | tag | ...}
+```
+
+Example:
+
+```
+@cities:{ New York | Los Angeles | Barcelona }
+```
+
+Tags can have multiple words or include other punctuation marks other than the field's separator (`,` by default). The following characters in tags should be escaped with a backslash (`\`): `$`, `{`, `}`, `\`, and `|`.
+
+{{% alert title="Note" color="warning" %}}
+Before RediSearch 2.4, it was also recommended to escape spaces. The reason was that, if a multiword tag included stopwords, a syntax error was returned. So tags, like "to be or not to be" needed be escaped as "to\ be\ or\ not\ to\ be". For good measure, you also could escape all spaces within tags. Starting with RediSearch 2.4, using [`DIALECT 2`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}) or greater you can use spaces in a `tag` query, even with stopwords.
+{{% /alert %}}
+
+Notice that multiple tags in the same clause create a union of documents containing either tags. To create an intersection of documents containing all tags, you should repeat the tag filter several times. For example:
+
+```
+# Return all documents containing all three cities as tags
+@cities:{ New York } @cities:{Los Angeles} @cities:{ Barcelona }
+
+# Now, return all documents containing either city
+@cities:{ New York | Los Angeles | Barcelona }
+```
+
+Tag clauses can be combined into any subclause, used as negative expressions, optional expressions, and so on.
+
+## Geo filters
+
+As of v0.21, it is possible to add geo radius queries directly into the query language with the syntax `@field:[{lon} {lat} {radius} {m|km|mi|ft}]`. This filters the result to a given radius from a lon,lat point, defined in meters, kilometers, miles or feet. See Redis's own [`GEORADIUS`]({{< relref "/commands/georadius" >}}) command for more details.
+
+Radius filters can be added into the query just like numeric filters. For example, in a database of businesses, looking for Chinese restaurants near San Francisco (within a 5km radius) would be expressed as: `chinese restaurant @location:[-122.41 37.77 5 km]`.
+
+## Polygon search
+
+Geospatial databases are essential for managing and analyzing location-based data in a variety of industries. They help organizations make data-driven decisions, optimize operations, and achieve their strategic goals more efficiently. Polygon search extends Redis's geospatial search capabilities to be able to query against a value in a `GEOSHAPE` attribute. This value must follow a ["well-known text"](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) (WKT) representation of geometry. Two such geometries are supported:
+
+- `POINT`, for example `POINT(2 4)`.
+- `POLYGON`, for example `POLYGON((2 2, 2 8, 6 11, 10 8, 10 2, 2 2))`.
+
+There is a new schema field type called `GEOSHAPE`, which can be specified as either:
+
+- `FLAT` for Cartesian X Y coordinates
+- `SPHERICAL` for geographic longitude and latitude coordinates. This is the default coordinate system.
+
+Finally, there's new [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) syntax that allows you to query for polygons that either contain or are within a given geoshape.
+
+`@field:[{WITHIN|CONTAINS} $geometry] PARAMS 2 geometry {geometry}`
+
+Here's an example using two stacked polygons that represent a box contained within a house.
+
+{{< image filename="develop/interact/search-and-query/img/polygons.png" >}}
+
+First, create an index using a `FLAT` `GEOSHAPE`, representing a 2D X Y coordinate system.
+
+`FT.CREATE polygon_idx PREFIX 1 shape: SCHEMA g GEOSHAPE FLAT t TEXT`
+
+Next, create the data structures that represent the geometries in the picture.
+
+```bash
+HSET shape:1 t "this is my house" g "POLYGON((2 2, 2 8, 6 11, 10 8, 10 2, 2 2))"
+HSET shape:2 t "this is a square in my house" g "POLYGON((4 4, 4 6, 6 6, 6 4, 4 4))"
+```
+Finally, use [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) to query the geometries. Note the use of `DIALECT 3`, which is required. Here are a few examples.
+
+Search for a polygon that contains a specified point:
+
+```bash
+FT.SEARCH polygon_idx "@g:[CONTAINS $point]" PARAMS 2 point 'POINT(8 8)' DIALECT 3
+1) (integer) 1
+2) "shape:1"
+3) 1) "t"
+   2) "this is my house"
+   3) "g"
+   4) "POLYGON((2 2, 2 8, 6 11, 10 8, 10 2, 2 2))"
+```
+
+Search for geometries contained in a specified polygon:
+
+```bash
+FT.SEARCH polygon_idx "@g:[WITHIN $poly]" PARAMS 2 poly 'POLYGON((0 0, 0 100, 100 100, 100 0, 0 0))' DIALECT 3
+1) (integer) 2
+2) "shape:2"
+3) 1) "t"
+   2) "this is a square in my house"
+   3) "g"
+   4) "POLYGON((4 4, 4 6, 6 6, 6 4, 4 4))"
+4) "shape:1"
+5) 1) "t"
+   2) "this is my house"
+   3) "g"
+   4) "POLYGON((2 2, 2 8, 6 11, 10 8, 10 2, 2 2))"
+```
+
+Search for a polygon that is not contained in the indexed geometries:
+
+```bash
+FT.SEARCH polygon_idx "@g:[CONTAINS $poly]" PARAMS 2 poly 'POLYGON((14 4, 14 6, 16 6, 16 4, 14 4))' DIALECT 3
+1) (integer) 0
+```
+
+Search for a polygon that is known to be contained within the geometries (the box):
+
+```bash
+FT.SEARCH polygon_idx "@g:[CONTAINS $poly]" PARAMS 2 poly 'POLYGON((4 4, 4 6, 6 6, 6 4, 4 4))' DIALECT 3
+1) (integer) 2
+2) "shape:1"
+3) 1) "t"
+   2) "this is my house"
+   3) "g"
+   4) "POLYGON((2 2, 2 8, 6 11, 10 8, 10 2, 2 2))"
+4) "shape:2"
+5) 1) "t"
+   2) "this is a square in my house"
+   3) "g"
+   4) "POLYGON((4 4, 4 6, 6 6, 6 4, 4 4))"
+```
+
+Note that both the house and box shapes were returned.
+
+{{< alert title="Note" >}}
+GEOSHAPE does not support JSON multi-value or SORTABLE options.
+{{< /alert >}}
+
+For more examples, see the [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) and [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command pages.
+
+## Vector search
+
+You can add vector similarity queries directly into the query language by:
+
+1. Using a **range** query with the syntax of `@vector:[VECTOR_RANGE {radius} $query_vec]`, which filters the results to a given radius from a given query vector. The distance metric derives from the definition of a @vector field in the index schema, for example, Cosine or L2 (as of v2.6.1).
+
+2. Running a k nearest neighbors (KNN) query on a @vector field. The basic syntax is `"*=>[ KNN {num|$num} @vector $query_vec ]"`.
+It is also possible to run a hybrid query on filtered results. A hybrid query allows the user to specify a filter criteria that all results in a KNN query must satisfy. The filter criteria can include any type of field (i.e., indexes created on both vectors and other values, such as TEXT, PHONETIC, NUMERIC, GEO, etc.).
+The general syntax for hybrid query is `{some filter query}=>[ KNN {num|$num} @vector $query_vec]`, where `=>` separates the filter query from the vector KNN query. 
+
+**Examples:**
+
+* Return 10 nearest neighbors entities in which `query_vec` is closest to the vector stored in `@vector_field`: 
+  
+  `*=>[KNN 10 @vector_field $query_vec]`
+
+* Among entities published between 2020 and 2022, return 10 nearest neighbors entities in which `query_vec` is closest to the vector stored in `@vector_field`: 
+
+  `@published_year:[2020 2022]=>[KNN 10 @vector_field $query_vec]`
+
+* Return every entity for which the distance between the vector stored under its @vector_field and `query_vec` is at most 0.5, in terms of the @vector_field distance metric:
+
+  `@vector_field:[VECTOR_RANGE 0.5 $query_vec]`
+
+As of v2.4, the KNN vector search can be used at most once in a query, while, as of v2.6, the vector range filter can be used multiple times in a query. For more information on vector similarity syntax, see [Querying vector fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}), and [Vector search examples]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#vector-search-examples" >}}) sections.
+
+## Prefix matching
+
+When indexes are updated, Redis maintains a dictionary of all terms in the index. This can be used to match all terms starting with a given prefix. Selecting prefix matches is done by appending `*` to a prefix token. For example:
+
+```
+hel* world
+```
+
+Will be expanded to cover `(hello|help|helm|...) world`.
+
+### A few notes on prefix searches
+
+1. As prefixes can be expanded into many terms, use them with caution. The expansion will create a Union operation of all suffixes.
+
+2. As a protective measure to avoid selecting too many terms, blocking Redis, which is single threaded, there are two limitations on prefix matching:
+
+  * Prefixes are limited to 2 letters or more. You can change this number by using the `MINPREFIX` setting on the module command line.
+
+  * The minimum word length to stem is 4 letters or more. You can change this number by using the `MINSTEMLEN` setting on the module command line.
+
+  * Expansion is limited to 200 terms or less. You can change this number by using the `MAXEXPANSIONS` setting on the module command line.
+
+3. Prefix matching fully supports Unicode and is case insensitive.
+
+4. Currently, there is no sorting or bias based on suffix popularity.
+
+## Infix/suffix matching
+
+As of v2.6.0, the dictionary can be used for infix (contains) or suffix queries by appending `*` to the token. For example:
+
+```
+*sun* *ing 
+```
+
+These queries are CPU intensive because they require iteration over the whole dictionary.
+
+{{% alert title="Note" color="warning" %}}
+All notes about prefix searches also apply to infix/suffix queries.
+{{% /alert %}}
+
+### Using a suffix trie
+
+A suffix trie maintains a list of terms that match the suffix. If you add a suffix trie to a field using the `WITHSUFFIXTRIE` keyword, you can create more efficient infix and suffix queries because it eliminates the need to iterate over the whole dictionary. However, the iteration on the union does not change. 
+
+Suffix queries create a union of the list of terms from the suffix term node. Infix queries use the suffix terms as prefixes to the trie and create a union of all terms from all matching nodes.
+
+## Wildcard matching
+
+As of v2.6.0, you can use the dictionary for wildcard matching queries with these parameters.
+
+* `?` - for any single character
+* `*` - for any character repeating zero or more times
+* `\` - for escaping; other special characters are ignored
+
+An example of the syntax is `"w'foo*bar?'"`.
+
+### Using a suffix trie
+
+A suffix trie maintains a list of terms which match the suffix. If you add a suffix trie to a field using the `WITHSUFFIXTRIE` keyword, you can create more efficient wildcard matching queries because it eliminates the need to iterate over the whole dictionary. However, the iteration on the union does not change. 
+
+With a suffix trie, the wildcard pattern is broken into tokens at every `*` character. A heuristic is used to choose the token with the least terms, and each term is matched with the wildcard pattern.
+
+## Fuzzy matching
+
+As of v1.2.0, the dictionary of all terms in the index can also be used to perform [fuzzy matching](https://en.wikipedia.org/wiki/Approximate_string_matching). 
+Fuzzy matches are performed based on [Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) (LD). 
+Fuzzy matching on a term is performed by surrounding the term with '%', for example:
+
+```
+%hello% world
+```
+
+This performs fuzzy matching on `hello` for all terms where LD is 1.
+
+As of v1.4.0, the LD of the fuzzy match can be set by the number of '%' characters surrounding it, so that `%%hello%%` will perform fuzzy matching on 'hello' for all terms where LD is 2.
+
+The maximum LD for fuzzy matching is 3.
+
+## Wildcard queries
+
+As of v1.1.0, you can use a special query to retrieve all the documents in an index. This is meant mostly for the aggregation engine. You can call it by specifying only a single star sign as the query string, in other words, `FT.SEARCH myIndex *`.
+
+You can't combine this with any other filters, field modifiers, or anything inside the query. It is technically possible to use the deprecated `FILTER` and `GEOFILTER` request parameters outside the query string in conjunction with a wildcard, but this makes the wildcard meaningless and only hurts performance.
+
+## Query attributes
+
+As of v1.2.0, you can apply specific query modifying attributes to specific clauses of the query.
+
+The syntax is `(foo bar) => { $attribute: value; $attribute:value; ...}`:
+
+```
+(foo bar) => { $weight: 2.0; $slop: 1; $inorder: true; }
+~(bar baz) => { $weight: 0.5; }
+```
+
+The supported attributes are:
+
+1. **$weight**: determines the weight of the sub-query or token in the overall ranking on the result (default: 1.0).
+2. **$slop**: determines the maximum allowed slop (space between terms) in the query clause (default: 0).
+3. **$inorder**: whether or not the terms in a query clause must appear in the same order as in the query. This is usually set alongside with `$slop` (default: false).
+4. **$phonetic**: whether or not to perform phonetic matching (default: true). Note: setting this attribute to true for fields which were not created as `PHONETIC` will produce an error.
+
+As of v2.6.1, the query attributes syntax supports these additional attributes:
+
+* **$yield_distance_as**: specifies the distance field name, used for later sorting and/or returning, for clauses that yield some distance metric. It is currently supported for vector queries only (both KNN and range).   
+* **vector query params**: pass optional parameters for [vector queries]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#querying-vector-fields" >}}) in key-value format.
+
+## A few query examples
+
+* Simple phrase query - `hello` _AND_ `world`:
+
+        hello world
+
+* Exact phrase query - `hello` _FOLLOWED BY_ `world`:
+
+        "hello world"
+
+* Union - documents containing either `hello` _OR_ `world`:
+
+        hello|world
+
+* Not - documents containing `hello` _BUT NOT_ `world`:
+
+        hello -world
+
+* Intersection of unions:
+
+        (hello|halo) (world|werld)
+
+* Negation of union:
+
+        hello -(world|werld)
+
+* Union inside phrase:
+
+        (barack|barrack) obama
+
+* Optional terms with higher priority to ones containing more matches:
+
+        obama ~barack ~michelle
+
+* Exact phrase in one field, one word in another field:
+
+        @title:"barack obama" @job:president
+
+* Combined _AND_, _OR_ with field specifiers:
+
+        @title:"hello world" @body:(foo bar) @category:(articles|biographies)
+
+* Prefix/infix/suffix queries:
+
+        hello worl*
+
+        hel* *worl
+
+        hello -*worl*
+
+* Wildcard matching queries:
+
+        "w'foo??bar??baz'"
+
+        "w'???????'"
+
+        "w'hello*world'"
+
+* Numeric filtering - products named `tv` with a price range of 200 to 500:
+
+        @name:tv @price:[200 500]
+
+* Numeric filtering - users with age greater than 18:
+
+        @age:[(18 +inf]
+
+## Mapping common SQL predicates to Redis Query Engine
+
+| SQL Condition | Redis Query Engine Equivalent | Comments |
+|---------------|-----------------------|----------|
+| WHERE x='foo' AND y='bar' | @x:foo @y:bar | for less ambiguity use (@x:foo) (@y:bar) |
+| WHERE x='foo' AND y!='bar' | @x:foo -@y:bar |
+| WHERE x='foo' OR y='bar' | (@x:foo)\|(@y:bar) |
+| WHERE x IN ('foo', 'bar','hello world') | @x:(foo\|bar\|"hello world") | quotes mean exact phrase |
+| WHERE y='foo' AND x NOT IN ('foo','bar') | @y:foo (-@x:foo) (-@x:bar) |
+| WHERE x NOT IN ('foo','bar') | -@x:(foo\|bar) |
+| WHERE num BETWEEN 10 AND 20 | @num:[10 20] |
+| WHERE num >= 10 | @num:[10 +inf] |
+| WHERE num > 10 | @num:[(10 +inf] |
+| WHERE num < 10 | @num:[-inf (10] |
+| WHERE num <= 10 | @num:[-inf 10] |
+| WHERE num < 10 OR num > 20 | @num:[-inf (10] \| @num:[(20 +inf] |
+| WHERE name LIKE 'john%' | @name:john* |
+
+## Technical notes
+
+The query parser is built using the Lemon Parser Generator and a Ragel based lexer. You can see the `DIALECT 2` grammar definition [at this git repo](https://github.com/RediSearch/RediSearch/blob/master/src/query_parser/v2/parser.y).
+
+You can also see the [search-default-dialect]({{< relref "/develop/interact/search-and-query/administration/configuration#search-default-dialect" >}}) configuration parameter.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Stemming support
+linkTitle: Stemming
+title: Stemming
+weight: 10
+---
+
+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](#supported-languages)" section below. We hope to include more languages soon (if you need a specific language support, please open an issue).
+
+For further details see the [Snowball Stemmer website](https://snowballstem.org/).
+
+
+## How it works?
+
+Stemming maps different forms of the same word to a common root - "stem" - for example, the English stemmer maps *studied* ,*studies* and *study* to *studi* . So a searching for *studied* would also find documents which only have the other forms.
+
+
+In order to define which language the Stemmer should apply when building the index, you need to specify the `LANGUAGE` parameter for the entire index or for the specific field. For more details check the [FT.CREATE]({{< relref "commands/ft.create" >}}) syntax.
+
+**Create a index with language definition**
+
+Create a index for words in German "`wort:`" with a single `TEXT` field "`wort`"
+
+{{< highlight bash >}}
+redis> FT.CREATE idx:german ON HASH PREFIX 1 "wort:" LANGUAGE GERMAN SCHEMA wort TEXT
+{{< / highlight >}}
+
+**Adding words**
+
+Adding some words with same stem in German, all variations of the word `stück` ( `piece` in english): `stück stücke stuck stucke` => `stuck`
+
+{{< highlight bash >}}
+redis> HSET wort:1 wort stück
+(integer) 1
+redis> HSET wort:2 wort stücke
+(integer) 1
+redis> HSET wort:3 wort stuck
+(integer) 1
+redis> HSET wort:4 wort stucke
+(integer) 1
+{{< / highlight >}}
+
+**Searching for a common stem**
+
+Search for "stuck" (german for "piece"). As of v2.10, it's only necessary to specify the `LANGUAGE` argument when it wasn't specified to create the index being used to search.
+Note the results for words that contains "`ü`" are encoded in UTF-8.
+
+{{< highlight bash >}}
+redis> FT.SEARCH idx:german '@wort:(stuck)' German
+1) (integer) 4
+2) "wort:3"
+3) 1) "wort"
+   2) "stuck"
+4) "wort:4"
+5) 1) "wort"
+   2) "stucke"
+6) "wort:1"
+7) 1) "wort"
+   2) "st\xc3\xbcck"
+8) "wort:2"
+9) 1) "wort"
+   2) "st\xc3\xbccke"
+{{< / highlight >}}
+
+## Supported languages
+
+The following languages are supported and can be passed to the engine when indexing or querying using lowercase:
+
+* arabic
+* armenian
+* danish
+* dutch
+* english
+* finnish
+* french
+* german
+* hungarian
+* italian
+* norwegian
+* portuguese
+* romanian
+* russian
+* serbian
+* spanish
+* swedish
+* tamil
+* turkish
+* yiddish
+* chinese (see below)
+
+## Chinese support
+
+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.
+
+Chinese tokenization is done by scanning the input text and checking every character or sequence of characters against a dictionary of predefined terms and determining the most likely match based on the surrounding terms and characters.
+
+Redis Open Source makes use of the [Friso](https://github.com/lionsoul2014/friso) chinese tokenization library for this purpose. This is largely transparent to the user and often no additional configuration is required.
+
+## Using custom dictionaries
+
+If you wish to use a custom dictionary, you can do so at the module level when loading the module. The `FRISOINI` setting can point to the location of a `friso.ini` file which contains the relevant settings and paths to the dictionary files.
+
+Note that there is no default `friso.ini` file location. RedisSearch comes with its own `friso.ini` and dictionary files that are compiled into the module binary at build-time.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use vector fields and perform vector searches in Redis
+linkTitle: Vectors
+math: true
+title: Vectors
+weight: 14
+---
+
+Redis includes a [high-performance vector database](https://redis.io/blog/benchmarking-results-for-vector-databases/) that lets you perform semantic searches over vector embeddings. You can augment these searches with filtering over text, numerical, geospatial, and tag metadata.
+
+To quickly get started, check out the [Redis vector quickstart guide]({{< relref "develop/get-started/vector-database" >}}) and the [Redis AI Resources](https://github.com/redis-developer/redis-ai-resources) Github repo.
+
+
+## Overview
+
+1. [**Create a vector index**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#create-a-vector-index" >}}): Redis maintains a secondary index over your data with a defined schema (including vector fields and metadata). Redis supports [`FLAT`]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#flat-index" >}}) and [`HNSW`]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#hnsw-index" >}}) vector index types.
+1. [**Store and update vectors**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#store-and-update-vectors" >}}): Redis stores vectors and metadata in hashes or JSON objects.
+1. [**Search with vectors**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#search-with-vectors" >}}): Redis supports several advanced querying strategies with vector fields including k-nearest neighbor ([KNN]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#knn-vector-search" >}})), [vector range queries]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#vector-range-queries" >}}), and [metadata filters]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#filters" >}}).
+1. [**Configure vector queries at runtime**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#runtime-query-params" >}}).
+1. [**Vector search examples**]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#vector-search-examples" >}}): Explore several vector search examples that cover different use cases and techniques.
+
+## Create a vector index
+
+When you define the schema for an index, you can include one or more vector fields as shown below.
+
+**Syntax**
+
+```
+FT.CREATE <index_name>
+  ON <storage_type>
+  PREFIX 1 <key_prefix>
+  SCHEMA ... <field_name> VECTOR <algorithm> <index_attribute_count> <index_attribute_name> <index_attribute_value>
+    [<index_attribute_name> <index_attribute_value> ...]
+```
+
+Refer to the full [indexing]({{< relref "develop/interact/search-and-query/indexing/" >}}) documentation for additional fields, options, and noted limitations.
+
+**Parameters**
+
+| Parameter | Description |
+|:----------|:------------|
+| `index_name`      | Name of the index.  |
+| `storage_type`    | Storage option (`HASH` or `JSON`).  |
+| `prefix` (optional) | Key prefix used to select which keys should be indexed. Defaults to all keys if omitted. |
+| `field_name`      | Name of the vector field.  |
+| `algorithm`       | Vector index algorithm (`FLAT` or `HNSW`).  |
+| `index_attribute_count` | Number of vector field attributes.  |
+| `index_attribute_name`  | Vector field attribute name.  |
+| `index_attribute_value` | Vector field attribute value.  |
+
+### FLAT index
+
+Choose the `FLAT` index when you have small datasets (< 1M vectors) or when perfect search accuracy is more important than search latency.
+
+**Required attributes**
+
+| Attribute          | Description                              |
+|:-------------------|:-----------------------------------------|
+| `TYPE`             | Vector type (`BFLOAT16`, `FLOAT16`, `FLOAT32`, `FLOAT64`). `BFLOAT16` and `FLOAT16` require v2.10 or later.  |
+| `DIM`              | The width, or number of dimensions, of the vector embeddings stored in this field. In other words, the number of floating point elements comprising the vector. `DIM` must be a positive integer. The vector used to query this field must have the exact dimensions as the field itself.  |
+| `DISTANCE_METRIC`  | Distance metric (`L2`, `IP`, `COSINE`).  |
+
+**Example**
+
+```
+FT.CREATE documents
+  ON HASH
+  PREFIX 1 docs:
+  SCHEMA doc_embedding VECTOR FLAT 6
+    TYPE FLOAT32
+    DIM 1536
+    DISTANCE_METRIC COSINE
+```
+In the example above, an index named `documents` is created over hashes with the key prefix `docs:` and a `FLAT` vector field named `doc_embedding` with three index attributes: `TYPE`, `DIM`, and `DISTANCE_METRIC`.
+
+### HNSW index
+
+`HNSW`, or hierarchical navigable small world, is an approximate nearest neighbors algorithm that uses a multi-layered graph to make vector search more scalable.
+- The lowest layer contains all data points, and each higher layer contains a subset, forming a hierarchy.
+- At runtime, the search traverses the graph on each layer from top to bottom, finding the local minima before dropping to the subsequent layer.
+
+Choose the `HNSW` index type when you have larger datasets (> 1M documents) or when search performance and scalability are more important than perfect search accuracy.
+
+**Required attributes**
+
+| Attribute          | Description                              |
+|:-------------------|:-----------------------------------------|
+| `TYPE`             | Vector type (`BFLOAT16`, `FLOAT16`, `FLOAT32`, `FLOAT64`). `BFLOAT16` and `FLOAT16` require v2.10 or later. |
+| `DIM`              | The width, or number of dimensions, of the vector embeddings stored in this field. In other words, the number of floating point elements comprising the vector. `DIM` must be a positive integer. The vector used to query this field must have the exact dimensions as the field itself. |
+| `DISTANCE_METRIC`  | Distance metric (`L2`, `IP`, `COSINE`). |
+
+**Optional attributes**
+
+[`HNSW`](https://arxiv.org/ftp/arxiv/papers/1603/1603.09320.pdf) supports a number of additional parameters to tune
+the accuracy of the queries, while trading off performance.
+
+| Attribute          | Description                                                                                 |
+|:-------------------|:--------------------------------------------------------------------------------------------|
+| `M`                | Max number of outgoing edges (connections) for each node in a graph layer. On layer zero, the max number of connections will be `2 * M`. Higher values increase accuracy, but also increase memory usage and index build time. The default is 16. |
+| `EF_CONSTRUCTION`  | Max number of connected neighbors to consider during graph building. Higher values increase accuracy, but also increase index build time. The default is 200. |
+| `EF_RUNTIME`       | Max top candidates during KNN search. Higher values increase accuracy, but also increase search latency. The default is 10. |
+| `EPSILON`          | Relative factor that sets the boundaries in which a range query may search for candidates. That is, vector candidates whose distance from the query vector is `radius * (1 + EPSILON)` are potentially scanned, allowing more extensive search and more accurate results, at the expense of run time. The default is 0.01. |
+
+**Example**
+
+```
+FT.CREATE documents
+  ON HASH
+  PREFIX 1 docs:
+  SCHEMA doc_embedding VECTOR HNSW 10
+    TYPE FLOAT64
+    DIM 1536
+    DISTANCE_METRIC COSINE
+    M 40
+    EF_CONSTRUCTION 250
+```
+
+In the example above, an index named `documents` is created over hashes with the key prefix `docs:` and an `HNSW` vector field named `doc_embedding` with five index attributes: `TYPE`, `DIM`, `DISTANCE_METRIC`, `M`, and `EF_CONSTRUCTION`.
+
+### Distance metrics
+
+Redis supports three popular distance metrics to measure the degree of similarity between two vectors $u$, $v$ $\in \mathbb{R}^n$, where $n$ is the length of the vectors:
+
+| Distance metric | Description | Mathematical representation |
+|:--------------- |:----------- |:--------------------------- |
+| `L2` | Euclidean distance between two vectors. | $d(u, v) = \sqrt{ \displaystyle\sum_{i=1}^n{(u_i - v_i)^2}}$ |
+| `IP` | Inner product of two vectors. | $d(u, v) = 1 -u\cdot v$ |
+| `COSINE` | Cosine distance of two vectors. | $d(u, v) = 1 -\frac{u \cdot v}{\lVert u \rVert \lVert v  \rVert}$ |
+
+The above metrics calculate distance between two vectors, where the smaller the value is, the closer the two vectors are in the vector space.
+
+## Store and update vectors
+
+On index creation, the `<storage_type>` dictates how vector and metadata are structured and loaded into Redis.
+
+### Hash
+
+Store or update vectors and any metadata in [hashes]({{< relref "develop/data-types/hashes/" >}}) using the [`HSET`]({{< relref "commands/hset/" >}}) command.
+
+**Example**
+
+```
+HSET docs:01 doc_embedding <vector_bytes> category sports
+```
+
+{{% alert title="Tip" color="warning" %}}
+Hash values are stored as binary-safe strings. The value `<vector_bytes>` represents the vector's underlying memory buffer.
+{{% /alert  %}}
+
+A common method for converting vectors to bytes uses the [redis-py](https://redis-py.readthedocs.io/en/stable/examples/search_vector_similarity_examples.html) client library and the Python [NumPy](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.tobytes.html) library.
+
+**Example**
+
+```py
+import numpy as np
+from redis import Redis
+
+redis_client = Redis(host='localhost', port=6379)
+
+# Create a FLOAT32 vector
+vector = np.array([0.34, 0.63, -0.54, -0.69, 0.98, 0.61], dtype=np.float32)
+
+# Convert vector to bytes
+vector_bytes = vector.tobytes()
+
+# Use the Redis client to store the vector bytes and metadata at a specified key
+redis_client.hset('docs:01', mapping = {"vector": vector_bytes, "category": "sports"})
+```
+
+{{% alert title="Tip" color="warning" %}}
+The vector blob size must match the dimension and float type of the vector field specified in the index's schema; otherwise, indexing will fail.
+{{% /alert  %}}
+
+### JSON
+You can store or update vectors and any associated metadata in [JSON]({{< relref "develop/data-types/json/" >}}) using the [`JSON.SET`]({{< relref "commands/json.set/" >}}) command.
+
+To store vectors in Redis as JSON, you store the vector as a JSON array of floats. Note that this differs from vector storage in Redis hashes, which are instead stored as raw bytes.
+
+**Example**
+
+```
+JSON.SET docs:01 $ '{"doc_embedding":[0.34,0.63,-0.54,-0.69,0.98,0.61], "category": "sports"}'
+```
+
+One of the benefits of JSON is schema flexibility. As of v2.6.1, JSON supports multi-value indexing.
+This allows you to index multiple vectors under the same [JSONPath]({{< relref "/develop/data-types/json/path" >}}).
+
+Here are some examples of multi-value indexing with vectors:
+
+**Multi-value indexing example**
+
+```
+JSON.SET docs:01 $ '{"doc_embedding":[[1,2,3,4], [5,6,7,8]]}'
+JSON.SET docs:01 $ '{"chunk1":{"doc_embedding":[1,2,3,4]}, "chunk2":{"doc_embedding":[5,6,7,8]}}'
+```
+
+Additional information and examples are available in the [Indexing JSON documents]({{< relref "develop/interact/search-and-query/indexing/#index-json-arrays-as-vector" >}}) section.
+
+## Search with vectors
+
+You can run vector search queries with the [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) or [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) commands.
+
+To issue a vector search query with `FT.SEARCH`, you must set the `DIALECT` option to >= `2`. See the [dialects documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}) for more information.
+
+### KNN vector search
+
+KNN vector search finds the top k nearest neighbors to a query vector. It has the following syntax:
+
+**Syntax**
+
+```
+FT.SEARCH <index_name>
+  <primary_filter_query>=>[KNN <top_k> @<vector_field> $<vector_blob_param> $<vector_query_params> AS <distance_field>]
+  PARAMS <query_params_count> [$<vector_blob_param> <vector_blob> <query_param_name> <query_param_value> ...]
+  SORTBY <distance_field>
+  DIALECT 2
+```
+**Parameters**
+
+| Parameter         | Description                                                                                       |
+|:------------------|:--------------------------------------------------------------------------------------------------|
+| `index_name`  | Name of the index.  |
+| `primary_filter_query`  | [Filter]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#filters" >}}) criteria. Use `*` when no filters are required.  |
+| `top_k` | Number of nearest neighbors to fetch from the index.  |
+| `vector_field`  | Name of the vector field to search against.  |
+| `vector_blob_param`  | The query vector, passed in as a blob of raw bytes. The blob's byte size must match the vector field's dimensions and type.  |
+| `vector_query_params` (optional) | An optional section for marking one or more vector query parameters passed through the `PARAMS` section. Valid parameters should be provided as key-value pairs. See which [runtime query params]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#runtime-query-params" >}}) are supported for each vector index type.  |
+| `distance_field` (optional) | The optional distance field name used in the response and/or for sorting. By default, the distance field name is `__<vector_field>_score` and it can be used for sorting without using `AS <distance_field>` in the query.  |
+| `vector_query_params_count` | The number of vector query parameters.  |
+| `vector_query_param_name` | The name of the vector query parameter.  |
+| `vector_query_param_value` | The value of the vector query parameter.  |
+
+**Example**
+
+```
+FT.SEARCH documents "*=>[KNN 10 @doc_embedding $BLOB]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" DIALECT 2
+```
+
+**Use query attributes**
+
+Alternatively, as of v2.6, `<vector_query_params>` and `<distance_field>` name can be specified in runtime
+[query attributes]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax" >}}#query-attributes) as shown below.
+
+```
+[KNN <top_k> @<vector_field> $<vector_blob_param>]=>{$yield_distance_as: <distance_field>}
+```
+
+### Vector range queries
+
+Vector range queries allow you to filter the index using a `radius` parameter representing the semantic distance between an input query vector and indexed vector fields. This is useful in scenarios when you don't know exactly how many nearest (`top_k`) neighbors to fetch, but you do know how similar the results should be.
+
+For example, imagine a fraud or anomaly detection scenario where you aren't sure if there are any matches in the vector index. You can issue a vector range query to quickly check if there are any records of interest in the index within the specified radius.
+
+Vector range queries operate slightly different than KNN vector queries:
+- Vector range queries can appear multiple times in a query as filter criteria.
+- Vector range queries can be a part of the `<primary_filter_query>` in KNN vector search.
+
+**Syntax**
+
+```
+FT.SEARCH <index_name>
+  @<vector_field>:[VECTOR_RANGE (<radius> | $<radius_param>) $<vector_blob_param> $<vector_query_params>]
+  PARAMS <vector_query_params_count> [<vector_query_param_name> <vector_query_param_value> ...]
+  SORTBY <distance_field>
+  DIALECT 2
+```
+
+| Parameter         | Description                                                                                       |
+|:------------------|:--------------------------------------------------------------------------------------------------|
+| `index_name`  | Name of the index.  |
+| `vector_field`  | Name of the vector field in the index. |
+| `radius` or `radius_param` | The maximum semantic distance allowed between the query vector and indexed vectors. You can provide the value directly in the query, passed to the `PARAMS` section, or as a query attribute.
+| `vector_blob_param`  | The query vector, passed in as a blob of raw bytes. The blob's byte size must match the vector field's dimensions and type. |
+| `vector_query_params` (optional) | An optional section for marking one or more vector query parameters passed through the `PARAMS` section. Valid parameters should be provided as key-value pairs. See which [runtime query params]({{< relref "develop/interact/search-and-query/advanced-concepts/vectors#runtime-query-params" >}}) are supported for each vector index type.  |
+| `vector_query_params_count` | The number of vector query parameters.  |
+| `vector_query_param_name` | The name of the vector query parameter.  |
+| `vector_query_param_value` | The value of the vector query parameter.  |
+
+
+**Use query attributes**
+
+A vector range query clause can be followed by a query attributes section as follows:
+
+```
+@<vector_field>: [VECTOR_RANGE (<radius> | $<radius_param>) $<vector_blob_param>]=>{$<param>: (<value> |
+    $<value_attribute>); ... }
+```
+
+where the relevant parameters in that case are `$yield_distance_as` and `$epsilon`. Note that there is no default distance field name in range queries.
+
+### Filters
+
+Redis supports vector searches that include filters to narrow the search space based on defined criteria. If your index contains searchable fields (for example, `TEXT`, `TAG`, `NUMERIC`, `GEO`, `GEOSHAPE`, and `VECTOR`), you can perform vector searches with filters.
+
+**Supported filter types**
+
+- [Exact match](https://redis.io/docs/develop/interact/search-and-query/query/exact-match/)
+- [Numeric range](https://redis.io/docs/develop/interact/search-and-query/query/range/)
+- [Full-text](https://redis.io/docs/develop/interact/search-and-query/query/full-text/)
+- [Geospatial](https://redis.io/docs/develop/interact/search-and-query/query/geo-spatial/)
+
+You can also [combine multiple queries](https://redis.io/docs/develop/interact/search-and-query/query/combined/) as a filter.
+
+**Syntax**
+
+Vector search queries with filters follow this basic structure:
+
+```
+FT.SEARCH <index_name> <primary_filter_query>=>[...]
+```
+
+where `<primary_filter_query>` defines document selection and filtering.
+
+**Example**
+
+```
+FT.SEARCH documents "(@title:Sports @year:[2020 2022])=>[KNN 10 @doc_embedding $BLOB]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" DIALECT 2
+```
+
+### How filtering works
+
+Redis uses internal algorithms to optimize the filtering computation for vector search.
+The runtime algorithm is determined by heuristics that aim to minimize query latency based on several factors derived from the query and the index.
+
+**Batches mode**
+
+Batches mode works by paginating through small batches of nearest neighbors from the index:
+- A batch of high-scoring documents from the vector index is retrieved. These documents are yielded only if the `<primary_filter_query>` is satisfied. In other words, the document must contain a similar vector and meet the filter criteria.
+- The iterative procedure terminates when `<top_k>` documents that pass the filter criteria are yielded, or after every vector in the index has been processed.
+- The batch size is determined automatically by heuristics based on `<top_k>` and the ratio between the expected number of documents in the index that pass the `<primary_filter_query>` and the vector index size.
+- The goal is to minimize the total number of batches required to get the `<top_k>` results while preserving the smallest batch size possible. Note that the batch size may change dynamically in each iteration based on the number of results that pass the filter in previous batches.
+
+**Ad-hoc brute force mode** 
+
+- The score of every vector corresponding to a document that passes the filter is computed, and the `<top_k>` results are selected and returned.
+- This approach is preferable when the number of documents passing the `<primary_filter_query>` is relatively small.
+- The results of the KNN query will always be accurate in this mode, even if the underlying vector index algorithm is an approximate one.
+
+The execution mode may switch from batch mode to ad-hoc brute-force mode during the run, based on updated estimations of relevant factors from one batch to another.
+
+
+## Runtime query parameters
+
+### Filter mode
+
+By default, Redis selects the best filter mode to optimize query execution. You can override the auto-selected policy using these optional parameters:
+
+| Parameter        | Description | Options |
+|:-----------------|:------------|:--------|
+| `HYBRID_POLICY`  | Specifies the filter mode to use during vector search with filters (hybrid). | `BATCHES` or `ADHOC_BF` |
+| `BATCH_SIZE`     | A fixed batch size to use in every iteration when the `BATCHES` policy is auto-selected or requested. | Positive integer. |
+
+
+### Index-specific query parameters
+
+**FLAT**
+
+Currently, there are no runtime parameters available for FLAT indexes.
+
+**HNSW**
+
+Optional runtime parameters for HNSW indexes are:
+
+| Parameter       | Description                                                                                               | Default value       |
+|:----------------|:----------------------------------------------------------------------------------------------------------|:--------------------|
+| `EF_RUNTIME`    | The maximum number of top candidates to hold during the KNN search. Higher values lead to more accurate results at the expense of a longer query runtime. | The value passed during index creation. The default is 10. |
+| `EPSILON`       | The relative factor that sets the boundaries for a vector range query. Vector candidates whose distance from the query vector is `radius * (1 + EPSILON)` are potentially scanned, allowing a more extensive search and more accurate results at the expense of runtime. | The value passed during index creation. The default is 0.01. |
+
+
+### Important notes
+
+{{% alert title="Important notes" color="info" %}}
+
+1. When performing a KNN vector search, you specify `<top_k>` nearest neighbors. However, the default Redis query `LIMIT` parameter (used for pagination) is 10. In order to get `<top_k>` returned results, you must also specify `LIMIT 0 <top_k>` in your search command. See examples below.
+
+2. By default, the results are sorted by their document's score. To sort by vector similarity score, use `SORTBY <distance_field>`. See examples below.
+
+3. Depending on your chosen distance metric, the calculated distance between vectors in an index have different bounds. For example, `Cosine` distance is bounded by `2`, while `L2` distance is not bounded. When performing a vector range query, the best practice is to adjust the `<radius>` parameter based on your use case and required recall or precision metrics.
+
+{{% /alert %}}
+
+
+## Vector search examples
+
+Below are a number of examples to help you get started. For more comprehensive walkthroughs, see the [Redis vector quickstart guide]({{< relref "develop/get-started/vector-database" >}}) and the [Redis AI Resources](https://github.com/redis-developer/redis-ai-resources) Github repo.
+
+### KNN vector search examples
+
+Return the 10 nearest neighbor documents for which the `doc_embedding` vector field is the closest to the query vector represented by the following 4-byte blob:
+
+```
+FT.SEARCH documents "*=>[KNN 10 @doc_embedding $BLOB]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY __vector_score DIALECT 2
+```
+
+Return the top 10 nearest neighbors and customize the `K` and `EF_RUNTIME` parameters using query parameters. See the "Optional arguments" section in [FT.SEARCH command]({{< relref "commands/ft.search" >}}). Set the `EF_RUNTIME` value to 150, assuming `doc_embedding` is an `HNSW` index:
+
+```
+FT.SEARCH documents "*=>[KNN $K @doc_embedding $BLOB EF_RUNTIME $EF]" PARAMS 6 BLOB "\x12\xa9\xf5\x6c" K 10 EF 150 DIALECT 2
+```
+
+Assign a custom name to the distance field (`vector_distance`) and then sort using that name:
+
+```
+FT.SEARCH documents "*=>[KNN 10 @doc_embedding $BLOB AS vector_distance]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY vector_distance DIALECT 2
+```
+
+Use [query attributes]({{< relref "develop/interact/search-and-query/advanced-concepts/query_syntax#query-attributes" >}}) syntax to specify optional parameters and the distance field name:
+
+```
+FT.SEARCH documents "*=>[KNN 10 @doc_embedding $BLOB]=>{$EF_RUNTIME: $EF; $YIELD_DISTANCE_AS: vector_distance}" PARAMS 4 EF 150 BLOB "\x12\xa9\xf5\x6c" SORTBY vector_distance DIALECT 2
+```
+
+To explore additional Python vector search examples, review recipes for the [`Redis Python`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/00_redispy.ipynb) client library and the [`Redis Vector Library`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/01_redisvl.ipynb).
+
+### Filter examples
+
+For these examples, assume you created an index named `movies` with records of different movies and their metadata.
+
+Among the movies that have `'Dune'` in the `title` field and `year` between `[2020, 2022]`, return the top 10 nearest neighbors, sorted by `movie_distance`:
+
+```
+FT.SEARCH movies "(@title:Dune @year:[2020 2022])=>[KNN 10 @movie_embedding $BLOB AS movie_distance]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY movie_distance DIALECT 2
+```
+
+Among the movies that have `action` as a category tag, but not `drama`, return the top 10 nearest neighbors, sorted by `movie_distance`:
+
+```
+FT.SEARCH movies "(@category:{action} ~@category:{drama})=>[KNN 10 @doc_embedding $BLOB AS movie_distance]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY movie_distance DIALECT 2
+```
+
+Among the movies that have `drama` or `action` as a category tag, return the top 10 nearest neighbors and explicitly set the filter mode (hybrid policy) to "ad-hoc brute force" rather than it being auto-selected:
+
+```
+FT.SEARCH movies "(@category:{drama | action})=>[KNN 10 @doc_embedding $BLOB HYBRID_POLICY ADHOC_BF]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY __vec_score DIALECT 2
+```
+
+Among the movies that have `action` as a category tag, return the top 10 nearest neighbors and explicitly set the filter mode (hybrid policy) to "batches" and batch size 50 using a query parameter:
+
+```
+FT.SEARCH movies "(@category:{action})=>[KNN 10 @doc_embedding $BLOB HYBRID_POLICY BATCHES BATCH_SIZE $BATCH_SIZE]" PARAMS 4 BLOB "\x12\xa9\xf5\x6c" BATCH_SIZE 50 DIALECT 2
+```
+
+Run the same query as above and use the query attributes syntax to specify optional parameters:
+
+```
+FT.SEARCH movies "(@category:{action})=>[KNN 10 @doc_embedding $BLOB]=>{$HYBRID_POLICY: BATCHES; $BATCH_SIZE: 50}" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" DIALECT 2
+```
+
+To explore additional Python vector search examples, review recipes for the [`Redis Python`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/00_redispy.ipynb) client library and the [`Redis Vector Library`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/01_redisvl.ipynb).
+
+
+### Range query examples
+
+For these examples, assume you created an index named `products` with records of different products and metadata from an ecommerce site.
+
+Return 100 products for which the distance between the `description_vector` field and the specified query vector blob is at most 5:
+
+```
+FT.SEARCH products "@description_vector:[VECTOR_RANGE 5 $BLOB]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" LIMIT 0 100 DIALECT 2
+```
+
+Run the same query as above and set the `EPSILON` parameter to `0.5`, assuming `description_vector` is HNSW index, yield the vector distance between `description_vector` and the query result in a field named `vector_distance`, and sort the results by that distance.
+
+```
+FT.SEARCH products "@description_vector:[VECTOR_RANGE 5 $BLOB]=>{$EPSILON:0.5; $YIELD_DISTANCE_AS: vector_distance}" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY vector_distance LIMIT 0 100 DIALECT 2
+```
+
+Use the vector range query as a filter: return all the documents that contain either `'shirt'` in their `type` tag with their `year` value in the range `[2020, 2022]` or a vector stored in `description_vector` whose distance from the query vector is no more than `0.8`, then sort the results by their vector distance, if it is in the range:
+
+```
+FT.SEARCH products "(@type:{shirt} @year:[2020 2022]) | @description_vector:[VECTOR_RANGE 0.8 $BLOB]=>{$YIELD_DISTANCE_AS: vector_distance}" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY vector_distance DIALECT 2
+```
+
+To explore additional Python vector search examples, review recipes for the [`Redis Python`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/00_redispy.ipynb) client library and the [`Redis Vector Library`](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/01_redisvl.ipynb).
+
+## Memory consumption comparison
+
+Following is a Python+NumPy example of vector sizes for the supported vector types; `BFLOAT16`, `FLOAT16`, `FLOAT32`, and `FLOAT64`.
+
+```python
+import numpy as np
+
+#install ml_dtypes from pip install ml-dtypes
+from ml_dtypes import bfloat16
+
+# random float64 100 dimensions
+double_precision_vec = np.random.rand(100)
+
+# for float64 and float32
+print(f'length of float64 vector: {len(double_precision_vec.tobytes())}') # >>> 800
+print(f'length of float32 vector: {len(double_precision_vec.astype(np.float32).tobytes())}') # >>> 400
+
+# for float16
+np_data_type = np.float16
+half_precision_vec_float16 = double_precision_vec.astype(np_data_type)
+print(f'length of float16 vector: {len(half_precision_vec_float16.tobytes())}') # >>> 200
+
+# for bfloat16
+bfloat_dtype = bfloat16
+half_precision_vec_bfloat16 = double_precision_vec.astype(bfloat_dtype)
+print(f'length of bfloat16 vector: {len(half_precision_vec_bfloat16.tobytes())}') # >>> 200
+```
+
+## Next steps
+
+Vector embeddings and vector search are not new concepts. Many of the largest companies have used
+vectors to represent products in ecommerce catalogs or content in advertising pipelines for well over a decade.
+
+With the emergence of Large Language Models (LLMs) and the proliferation of applications that require advanced information
+retrieval techniques, Redis is well positioned to serve as your high performance query engine for semantic search and more.
+
+Here are some additonal resources that apply vector search for different use cases:
+
+- [Retrieval augmented generation from scratch](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/RAG/01_redisvl.ipynb)
+- [Semantic caching](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-cache/semantic_caching_gemini.ipynb)
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about tag fields
+linkTitle: Tags
+title: Tags
+weight: 6
+---
+
+Tag fields are similar to full-text fields but they interpret the text as a simple
+list of *tags* delimited by a
+[separator](#creating-a-tag-field) character (which is a comma "," by default).
+This limitation means that tag fields can use simpler
+[tokenization]({{< relref "/develop/interact/search-and-query/advanced-concepts/escaping" >}})
+and encoding in the index, which is more efficient than full-text indexing.
+
+The values in tag fields cannot be accessed by general field-less search and can be used only with a special syntax.
+
+The main differences between tag and full-text fields are:
+
+1.  [Tokenization]({{< relref "/develop/interact/search-and-query/advanced-concepts/escaping#tokenization-rules-for-tag-fields" >}})
+    is very simple for tags.
+
+1.  Stemming is not performed on tag indexes.
+
+1.  Tags cannot be found from a general full-text search. If a document has a field called "tags"
+    with the values "foo" and "bar", searching for foo or bar without a special tag modifier (see below) will not return this document.
+
+1.  The index is much simpler and more compressed: frequencies or offset vectors of field flags
+    are not stored. The index contains only document IDs encoded as deltas. This means that an entry in
+    a tag index is usually one or two bytes long. This makes them very memory-efficient and fast.
+
+1.  You can create up to 1024 tag fields per index.
+
+## Creating a tag field
+
+Tag fields can be added to the schema with the following syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} TAG [SEPARATOR {sep}] [CASESENSITIVE]
+```
+
+For hashes, SEPARATOR can be any printable ASCII character; the default is a comma (`,`). For JSON, there is no default separator; you must declare one explicitly if needed.
+
+For example:
+
+```
+JSON.SET key:1 $ '{"colors": "red, orange, yellow"}' 
+FT.CREATE idx on JSON PREFIX 1 key: SCHEMA $.colors AS colors TAG SEPARATOR ","
+
+> FT.SEARCH idx '@colors:{orange}'
+1) "1"
+2) "key:1"
+3) 1) "$"
+   2) "{\"colors\":\"red, orange, yellow\"}"
+```
+
+CASESENSITIVE can be specified to keep the original case.
+
+## Querying tag fields
+
+As mentioned above, just searching for a tag without any modifiers will not retrieve documents
+containing it.
+
+The syntax for matching tags in a query is as follows (the curly braces are part of the syntax):
+
+ ```
+    @<field_name>:{ <tag> | <tag> | ...}
+ ```
+
+For example, this query finds documents with either the tag `hello world` or `foo bar`:
+
+```
+    FT.SEARCH idx "@tags:{ hello world | foo bar }"
+```
+
+Tag clauses can be combined into any sub-clause, used as negative expressions, optional expressions, etc. For example, given the following index:
+
+```
+FT.CREATE idx ON HASH PREFIX 1 test: SCHEMA title TEXT price NUMERIC tags TAG SEPARATOR ";"
+```
+
+You can combine a full-text search on the title field, a numerical range on price, and match either the `foo bar` or `hello world` tag like this:
+
+```
+FT.SEARCH idx "@title:hello @price:[0 100] @tags:{ foo bar | hello world }
+```
+
+Tags support prefix matching with the regular `*` character:
+
+```
+FT.SEARCH idx "@tags:{ hell* }"
+FT.SEARCH idx "@tags:{ hello\\ w* }"
+
+```
+
+## Multiple tags in a single filter
+
+Notice that including multiple tags in the same clause creates a union of all documents that contain any of the included tags. To create an intersection of documents containing all of the given tags, you should repeat the tag filter several times.
+
+For example, imagine an index of travelers, with a tag field for the cities each traveler has visited:
+
+```
+FT.CREATE myIndex ON HASH PREFIX 1 traveler: SCHEMA name TEXT cities TAG
+
+HSET traveler:1 name "John Doe" cities "New York, Barcelona, San Francisco"
+```
+
+For this index, the following query will return all the people who visited at least one of the following cities:
+
+```
+FT.SEARCH myIndex "@cities:{ New York | Los Angeles | Barcelona }"
+```
+
+But the next query will return all people who have visited all three cities:
+
+```
+FT.SEARCH myIndex "@cities:{ New York } @cities:{Los Angeles} @cities:{ Barcelona }"
+```
+
+## Including punctuation and spaces in tags
+
+A tag field can contain any punctuation characters except for the field separator.
+You can use punctuation without escaping when you *define* a tag field,
+but you typically need to escape certain characters when you *query* the field
+because the query syntax itself uses the same characters.
+(See [Query syntax]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax#tag-filters" >}})
+for the full set of characters that require escaping.)
+
+For example, given the following index:
+
+```
+FT.CREATE punctuation ON HASH PREFIX 1 test: SCHEMA tags TAG
+```
+
+You can add tags that contain punctuation like this:
+
+```
+HSET test:1 tags "Andrew's Top 5,Justin's Top 5"
+```
+
+However, when you query for those tags, you must escape the punctuation characters
+with a backslash (`\`). So, querying for the tag `Andrew's Top 5` in
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) looks like this:
+
+```
+FT.SEARCH punctuation "@tags:{ Andrew\\'s Top 5 }"
+```
+
+(Note that you need the double backslash here because the terminal app itself
+uses the backslash as an escape character.
+Programming languages commonly use this convention also.)
+
+You can include spaces in a tag filter without escaping *unless* you are
+using a version of RediSearch earlier than v2.4 or you are using
+[query dialect 1]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-1" >}}).
+See
+[Query syntax]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax#tag-filters" >}})
+for a full explanation.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Learn how to use geospatial fields and perform geospatial queries in Redis
+linkTitle: Geospatial
+math: true
+title: Geospatial
+weight: 14
+---
+
+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]({{< relref "/develop/data-types/geospatial" >}})
+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.
+{{< /note >}}
+
+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.
+
+Redis uses coordinate points to represent geospatial locations.
+You can store individual points but you can also
+use a set of points to define a polygon shape (the shape of a
+town, for example). You can query several types of interactions
+between points and shapes, such as whether a point lies within
+a shape or whether two shapes overlap.
+
+Redis can interpret coordinates either as geographical longitude
+and latitude or as Cartesian coordinates on a flat plane.
+Geographical coordinates are ideal for large real-world locations
+and areas (such as towns and countries). Cartesian coordinates
+are more suitable for smaller areas (such as rooms in a building)
+or for games, simulations, and other artificial scenarios.
+
+## Storing geospatial data
+
+Redis supports two different
+[schema types]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options" >}})
+for geospatial data:
+
+-   [`GEO`](#geo): This uses a simple format where individual geospatial
+    points are specified as numeric longitude-latitude pairs.
+    
+-   [`GEOSHAPE`](#geoshape): [Redis Open Source]({{< relref "/operate/oss_and_stack" >}}) also
+    supports `GEOSHAPE` indexing in v7.2 and later.
+    This uses a subset of the 
+    [Well-Known Text (WKT)](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry)
+    format to specify both points and polygons using either geographical
+    coordinates or Cartesian coordinates. A
+    `GEOSHAPE` field supports more advanced queries than `GEO`,
+    such as checking if one shape overlaps or contains another.
+
+The sections below describe these schema types in more detail.
+
+## `GEO`
+
+A `GEO` index lets you represent geospatial data either as
+a string containing a longitude-latitude pair (for example,
+"-104.991531, 39.742043") or as a JSON array of these
+strings. Note that the longitude value comes first in the
+string.
+
+For example, you could index the `location` fields of the
+the [JSON]({{< relref "/develop/data-types/json" >}}) objects
+shown below as `GEO`:
+
+```json
+{
+    "description": "Navy Blue Slippers",
+    "price": 45.99,
+    "city": "Denver",
+    "location": "-104.991531, 39.742043"
+}
+
+{
+    "description": "Bright Red Boots",
+    "price": 185.75,
+    "city": "Various",
+    "location": [
+        "-104.991531, 39.742043",
+        "-105.0618814,40.5150098"
+    ]
+}
+```
+
+`GEO` fields allow only basic point and radius queries.
+For example, the query below finds products within a 100 mile radius of Colorado Springs
+(Longitude=-104.800644, Latitude=38.846127).
+
+```bash
+FT.SEARCH productidx '@location:[-104.800644 38.846127 100 mi]'
+```
+
+See [Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information about the available query options and see
+[Geospatial indexing]({{< relref "/develop/interact/search-and-query/indexing/geoindex" >}})
+for examples of indexing `GEO` fields.
+
+## `GEOSHAPE`
+
+Fields indexed as `GEOSHAPE` support the `POINT` and `POLYGON` primitives from the
+[Well-Known Text](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry)
+representation of geometry. The `POINT` primitive defines a single point
+in a similar way to a `GEO` field.
+The `geom` field of the example JSON object shown below specifies a point
+(in Cartesian coordinates, using the standard x,y order):
+
+```json
+{
+    "name": "Purple Point",
+    "geom": "POINT (2 2)"
+}
+```
+
+The `POLYGON` primitive can approximate the outline of any shape using a
+sequence of points. Specify the coordinates of the corners in the order they
+occur around the shape (either clockwise or counter-clockwise) and ensure the
+shape is "closed" by making the final coordinate exactly the same as the first.
+
+Note that `POLYGON` requires double parentheses around the coordinate list.
+This is because you can specify additional shapes as a comma-separated list
+that define "holes" within the enclosing polygon. The holes must have the opposite
+winding order to the outer polygon (so, if the outer polygon uses a clockwise winding
+order, the holes must use counter-clockwise).
+The `geom` field of the example JSON object shown below specifies a
+square using Cartesian coordinates in a clockwise winding order:
+
+```json
+{
+    "name": "Green Square",
+    "geom": "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"
+}
+```
+
+The following examples define one `POINT` and three `POLYGON` primitives,
+which are shown in the image below:
+
+```
+POINT (2 2)
+POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))
+POLYGON ((2 2.5, 2 3.5, 3.5 3.5, 3.5 2.5, 2 2.5))
+POLYGON ((3.5 1, 3.75 2, 4 1, 3.5 1))
+```
+
+{{< image filename="/images/dev/rqe/geoshapes.jpg" >}}
+
+You can run various types of queries against a geospatial index. For
+example, the query below returns one primitive that lies within the boundary
+of the green square (from the example above) but omits the square itself:
+
+```bash
+> FT.SEARCH geomidx "(-@name:(Green Square) @geom:[WITHIN $qshape])" PARAMS 2 qshape "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))" RETURN 1 name DIALECT 2
+
+1) (integer) 1
+2) "shape:4"
+3) 1) "name"
+   2) "[\"Purple Point\"]"
+```
+
+There are four query operations that you can use with `GEOSHAPE` fields:
+
+-   `WITHIN`: Find points or shapes that lie entirely within an
+    enclosing shape that you specify in the query.
+-   `CONTAINS`: Find shapes that completely contain the specified point
+    or shape.
+-   `INTERSECTS`: Find shapes whose boundary overlaps another specified
+    shape.
+-   `DISJOINT`: Find shapes whose boundary does not overlap another specified
+    shape.
+
+See
+[Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information about these query types and see
+[Geospatial indexing]({{< relref "/develop/interact/search-and-query/indexing/geoindex" >}})
+for examples of indexing `GEOSHAPE` fields.
+
+## Limitations of geographical coordinates
+
+Planet Earth is actually shaped more like an
+[ellipsoid](https://en.wikipedia.org/wiki/Earth_ellipsoid) than a perfect sphere.
+The spherical coordinate system used by Redis Query Engine is a close
+approximation to the shape of the Earth but not exact. For most practical
+uses of geospatial queries, the approximation works very well, but you
+shouldn't rely on it if you need very precise location data (for example, to track
+the GPS locations of boats in an emergency response system).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Support for sorting query results
+linkTitle: Sorting
+title: Sorting by indexed fields
+weight: 5
+---
+
+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`]({{< relref "commands/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:
+
+```
+FT.CREATE users SCHEMA first_name TEXT last_name TEXT SORTABLE age NUMERIC SORTABLE
+```
+
+The fields `last_name` and `age` are sortable, but `first_name` isn't. This means you can search by either first and/or last name, and sort by last name or age.
+
+### Note on sortable fields
+
+In the current implementation, when declaring a sortable field, its content gets copied into a special location in the index that provides for fast access during sorting. This means that making long fields sortable is very expensive and you should be careful with it.
+
+### Normalization (UNF option)
+
+By default, text fields get normalized and lowercased in a Unicode-safe way when stored for sorting. For example, `America` and `america` are considered equal in terms of sorting.
+
+Using the `UNF` (un-normalized form) argument, it is possible to disable the normalization and keep the original form of the value. Therefore, `America` will come before `america`.
+
+## Specifying SORTBY
+
+If an index includes sortable fields, you can add the `SORTBY` parameter to the search request (outside the query body) to order the results. This overrides the scoring function mechanism, and the two cannot be combined. If `WITHSCORES` is specified together with `SORTBY`, the scores returned are simply the relative position of each result in the result set.
+
+The syntax for `SORTBY` is:
+
+```
+SORTBY {field_name} [ASC|DESC]
+```
+
+* `field_name` must be a sortable field defined in the schema.
+
+* `ASC` means ascending order, `DESC` means descending order.
+
+* The default ordering is `ASC`.
+
+## Example
+
+```
+> FT.CREATE users ON HASH PREFIX 1 "user" SCHEMA first_name TEXT SORTABLE last_name TEXT age NUMERIC SORTABLE
+
+# Add some users
+> HSET user1 first_name "alice" last_name "jones" age 35
+> HSET user2 first_name "bob" last_name "jones" age 36
+
+# Searching while sorting
+
+# Searching by last name and sorting by first name
+> FT.SEARCH users "@last_name:jones" SORTBY first_name DESC
+
+# Searching by both first and last name, and sorting by age
+> FT.SEARCH users "jones" SORTBY age ASC
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details on synonym support with Redis Open Source
+linkTitle: Synonym
+title: Synonym support
+weight: 11
+---
+
+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".
+
+## The synonym search technique
+
+A simple HashMap is used to map between the terms and the group IDs. During index creation, a check is made to see if the current term appears in the synonym map, and if it does, take all the group IDs that the term belongs to.
+
+For each group ID, another record is added to the inverted index called "\~\<id\>" that contains the same information as the term itself. When performing a search, a check is made to see if the searched term appears in the synonym map, and if it does, take all the group IDs the term belongs to. For each group ID, search for "\~\<id\>" and return the combined results. This technique ensures that all the synonyms of a given term will be returned.
+
+## Handling concurrency
+
+Since the indexing is performed in a separate thread, the synonyms map may change during indexing, which in turn may cause data corruption or crashes during indexing or searching. To solve this issue, a read-only copy is created for indexing purposes. The read-only copy is maintained using reference count.
+
+As long as the synonyms map does not change, the original synonym map holds a reference to its read-only copy, so it will not be freed. After the data inside the synonyms map has changed, the synonyms map decreses the reference count of its read only copy. This ensures that when all the indexers are done using the read-only copy, it will automatically be freed. This ensures that the next time an indexer asks for a read-only copy, the synonyms map will create a new copy (containing the new data) and return it.
+
+## Example
+
+```
+# Create an index
+> FT.CREATE idx schema t text
+
+# Create a synonym group 
+> FT.SYNUPDATE idx group1 hello world
+
+# Insert documents
+> HSET foo t hello
+(integer) 1
+> HSET bar t world
+(integer) 1
+
+# Search
+> FT.SEARCH idx hello
+1) (integer) 2
+2) "foo"
+3) 1) "t"
+   2) "hello"
+4) "bar"
+5) 1) "t"
+   2) "world"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Query spelling correction support
+linkTitle: Spellchecking
+title: Spellchecking
+weight: 13
+---
+
+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:
+
+  1. Not a stop word
+  2. Not in the index
+  3. 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.
+
+To obtain the spelling corrections for a query, refer to the documentation of the [`FT.SPELLCHECK`]({{< relref "commands/ft.spellcheck/" >}}) command.
+
+## Custom dictionaries
+
+A dictionary is a set of terms. Dictionaries can be added with terms, have terms deleted from them, and have their entire contents dumped using the [`FT.DICTADD`]({{< relref "commands/ft.dictadd/" >}}), [`FT.DICTDEL`]({{< relref "commands/ft.dictdel/" >}}) and [`FT.DICTDUMP`]({{< relref "commands/ft.dictdump/" >}}) commands, respectively.
+
+Dictionaries can be used to modify the behavior of spelling corrections by including or excluding their contents from potential spelling correction suggestions.
+
+When used for term inclusion, the terms in a dictionary can be provided as spelling suggestions regardless of their occurrence in the index. Scores of suggestions from inclusion dictionaries are always 0. 
+
+Conversely, terms in an exclusion dictionary will never be returned as spelling alternatives.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about query syntax, aggregation, scoring, and other search and
+  query options
+linkTitle: Advanced concepts
+title: Advanced concepts
+weight: 7
+---
+
+Redis Open Source supports the following Redis Query Engine features. This article provides you an overview.
+
+## Indexing features
+
+* Secondary indexing
+* Vector indexing
+* Index on [JSON]({{< relref "/develop/data-types/json/" >}}) documents
+* Full-text indexing of multiple fields in a document
+* Incremental indexing without performance loss
+* Document deletion and updating with index garbage collection
+
+
+## Query features
+
+* Multi-field queries
+* Query on [JSON]({{< relref "/develop/data-types/json/" >}}) documents
+* [Aggregation]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations" >}})
+* Boolean queries with AND, OR, and NOT operators between subqueries
+* Optional query clauses
+* Retrieval of full document contents or only their IDs
+* Exact phrase search and slop-based search
+* Numeric filters and ranges
+* Geo-filtering using Redis [geo commands]({{< relref "/commands/" >}}?group=geo)
+* [Vector search]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}})
+
+
+## Full-text search features
+
+* [Prefix-based searches]({{< relref "/develop/interact/search-and-query/query/#prefix-matching" >}})
+* Field weights
+* [Auto-complete]({{< relref "develop/interact/search-and-query/administration/overview#auto-complete" >}}) and fuzzy prefix suggestions
+* [Stemming]({{< relref "/develop/interact/search-and-query/advanced-concepts/stemming" >}})-based query expansion for [many languages]({{< relref "develop/interact/search-and-query/advanced-concepts/stemming#supported-languages" >}}) using [Snowball](http://snowballstem.org/)
+* Support for custom functions for query expansion and scoring (see [Extensions]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}))
+* Unicode support (UTF-8 input required)
+* Document ranking
+
+## Cluster support
+
+The Redis Query Engine features of Redis Open Source are also available for distributed databases that can scale to billions of documents and hundreds of servers.
+
+## Supported platforms
+Redis Open Source is developed and tested on Linux and macOS on x86_64 CPUs.
+
+Atom CPUs are not supported.
+
+<br/>---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Full-text scoring functions
+linkTitle: Scoring
+title: Scoring documents
+weight: 8
+---
+
+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 very basic 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]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting" >}}). Scoring functions are specified by adding the `SCORER {scorer_name}` argument to a search query.
+
+If you prefer a custom scoring function, it is possible to add more functions using the [extension API]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}).
+
+The following is a list of the pre-bundled scoring functions available in Redis and a short explanation about how they work. Each function is mentioned by registered name, which can be passed as a `SCORER` argument in [`FT.SEARCH`]({{< relref "/commands/ft.search/" >}}).
+
+## TFIDF (default)
+
+Basic [TF-IDF scoring](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) with a few extra features:
+
+1. For each term in each result, the TF-IDF score of that term is calculated to that document. Frequencies are weighted based on field weights that are pre-determined, and each term's frequency is normalized by the highest term frequency in each document.
+
+2. The total TF-IDF for the query term is multiplied by the presumptive document score given on `FT.CREATE` via `SCORE_FIELD`.
+
+3. A penalty is assigned to each result based on "slop" or cumulative distance between the search terms. Exact matches will get no penalty, but matches where the search terms are distant will have their score reduced significantly. For each bigram of consecutive terms, the minimal distance between them is determined. The penalty is the square root of the sum of the distances squared; e.g., `1/sqrt(d(t2-t1)^2 + d(t3-t2)^2 + ...)`.
+
+Given N terms in document D, `T1...Tn`, the resulting score could be described with this Python function:
+
+```py
+def get_score(terms, doc):
+    # the sum of tf-idf
+    score = 0
+
+    # the distance penalty for all terms
+    dist_penalty = 0
+
+    for i, term in enumerate(terms):
+        # tf normalized by maximum frequency
+        tf = doc.freq(term) / doc.max_freq
+
+        # idf is global for the index, and not calculated each time in real life
+        idf = log2(1 + total_docs / docs_with_term(term))
+
+        score += tf*idf
+
+        # sum up the distance penalty
+        if i > 0:
+            dist_penalty += min_distance(term, terms[i-1])**2
+
+    # multiply the score by the document score
+    score *= doc.score
+
+    # divide the score by the root of the cumulative distance
+    if len(terms) > 1:
+        score /= sqrt(dist_penalty)
+
+    return score
+```
+
+## TFIDF.DOCNORM
+
+Identical to the default `TFIDF` scorer, with one important distinction:
+
+Term frequencies are normalized by the length of the document, expressed as the total number of terms. The length is weighted, so that if a document contains two terms, one in a field that has a weight 1 and one in a field with a weight of 5, the total frequency is 6, not 2.
+
+```
+FT.SEARCH myIndex "foo" SCORER TFIDF.DOCNORM
+```
+
+## BM25
+
+A variation on the basic `TFIDF` scorer, see [this Wikipedia article for more info](https://en.wikipedia.org/wiki/Okapi_BM25).
+
+The relevance score for each document is multiplied by the presumptive document score and a penalty is applied based on slop as in `TFIDF`.
+
+```
+FT.SEARCH myIndex "foo" SCORER BM25
+```
+
+## DISMAX
+
+A simple scorer that sums up the frequencies of matched terms. In the case of union clauses, it will give the maximum value of those matches. No other penalties or factors are applied.
+
+It is not a one-to-one implementation of [Solr's DISMAX algorithm](https://wiki.apache.org/solr/DisMax), but it follows it in broad terms.
+
+```
+FT.SEARCH myIndex "foo" SCORER DISMAX
+```
+
+## DOCSCORE
+
+A scoring function that just returns the presumptive score of the document without applying any calculations to it. Since document scores can be updated, this can be useful if you'd like to use an external score and nothing further.
+
+```
+FT.SEARCH myIndex "foo" SCORER DOCSCORE
+```
+
+## HAMMING
+
+Scoring by the inverse Hamming distance between the document's payload and the query payload is performed. Since the nearest neighbors are of interest, the inverse Hamming distance (`1/(1+d)`) is used so that a distance of 0 gives a perfect score of 1 and is the highest rank.
+
+This only works if:
+
+1. The document has a payload.
+2. The query has a payload.
+3. Both are exactly the same length.
+
+Payloads are binary-safe, and having payloads with a length that is a multiple of 64 bits yields slightly faster results.
+
+Example:
+
+```
+> HSET key:1 foo hello payload aaaabbbb
+(integer) 2
+
+> HSET key:2 foo bar payload aaaacccc 
+(integer) 2
+
+> FT.CREATE idx ON HASH PREFIX 1 key: PAYLOAD_FIELD payload SCHEMA foo TEXT
+"OK"
+
+> FT.SEARCH idx "*" PAYLOAD "aaaabbbc" SCORER HAMMING WITHSCORES
+1) "2"
+2) "key:1"
+3) "0.5"
+4) 1) "foo"
+   2) "hello"
+5) "key:2"
+6) "0.25"
+7) 1) "foo"
+   2) "bar"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Available field types and options.
+linkTitle: Field and type options
+title: Field and type options
+weight: 2
+---
+
+
+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.
+
+You can add number fields to a schema in [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) using this syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} NUMERIC [SORTABLE] [NOINDEX]
+```
+
+where:
+
+- `SORTABLE` indicates that the field can be sorted. This is useful for performing range queries and sorting search results based on numeric values.
+- `NOINDEX` indicates that the field is not indexed. This is useful for storing numeric values that you don't want to search for, but that you want to retrieve in search results.
+
+You can search for documents with specific numeric values using the `@<field_name>:[<min> <max>]` query syntax. For example, this query finds documents with a price between 200 and 300:
+
+```
+FT.SEARCH products "@price:[200 300]"
+```
+
+You can also use the following query syntax to perform more complex numeric queries:  
+
+| **Comparison operator** | **Query string**              | **Comment**              |
+|-------------------------|-------------------------------|--------------------------|
+| min &lt;= x &lt;= max   | @field:[min max]              | Fully inclusive range    |
+|                         | "@field>=min @field<=max"     | Fully inclusive range \* |
+| min &lt; x &lt; max     | @field:[(min (max]            | Fully exclusive range    |
+|                         | "@field>min @field<max"       | Fully exclusive range \* |
+|                         |                               |   grouping with a space denotes AND relationship |
+| x >= min                | @field:[min +inf]             | Upper open range         |
+|                         | @field>=min                   | Upper open range \*      |
+| x &lt;= max             | @field:[-inf max]             | Lower open range         |
+|                         | @field<=max                   | Lower open range \*      |
+| x == val                | @field:[val val]              | Equal                    |
+|                         | @field:[val]                  | Equal \*                 |
+|                         | @field==val                   | Equal \*                 |
+| x != val                | -@field:[val val]             | Not equal                |
+|                         | @field!=val                   | Not equal \*             |
+| x == val1 or x == val2  | "@field==val1 \| @field==val2" | Grouping with a bar denotes OR relationship \* |
+
+\* New syntax as of RediSearch v2.10. Requires [`DIALECT 2`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}#dialect-2). 
+
+
+## Geo fields
+
+Geo fields are used to store geographical coordinates such as longitude and latitude. They enable geospatial radius queries, which allow you to implement location-based search functionality in your applications such as finding nearby restaurants, stores, or any other points of interest.
+
+Redis Query Engine also supports [geoshape fields](#geoshape-fields) for more advanced
+geospatial queries. See the
+[Geospatial]({{< relref "/develop/interact/search-and-query/advanced-concepts/geo" >}})
+reference page for an introduction to the format and usage of both schema types.
+
+You can add geo fields to the schema in [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) using this syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} GEO [SORTABLE] [NOINDEX]
+```
+
+Where:
+- `SORTABLE` indicates that the field can be sorted. This is useful for performing range queries and sorting search results based on coordinates.
+- `NOINDEX` indicates that the field is not indexed. This is useful for storing coordinates that you don't want to search for, but that you still want to retrieve in search results.
+
+You can query geo fields using the `@<field_name>:[<lon> <lat> <radius> <unit>]` query syntax. For example, this query finds documents within 1000 kilometers from the point `2.34, 48.86`:
+
+```
+FT.SEARCH cities "@coords:[2.34 48.86 1000 km]"
+```
+
+See
+[Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information and code examples.
+
+## Geoshape fields
+
+Geoshape fields provide more advanced functionality than [Geo](#geo-fields).
+You can use them to represent locations as points but also to define
+shapes and query the interactions between points and shapes (for example,
+to find all points that are contained within an enclosing shape). You can
+also choose between geographical coordinates (on the surface of a sphere)
+or standard Cartesian coordinates. Use geoshape fields for spatial queries
+such as finding all office locations in a specified region or finding
+all rooms in a building that fall within range of a wi-fi router.
+
+See the
+[Geospatial]({{< relref "/develop/interact/search-and-query/advanced-concepts/geo" >}})
+reference page for an introduction to the format and usage of both the
+geoshape and geo schema types.
+
+Add geoshape fields to the schema in
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) using the following syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} GEOSHAPE [FLAT|SPHERICAL] [NOINDEX]
+```
+
+Where:
+-   `FLAT` indicates Cartesian (planar) coordinates.
+-   `SPHERICAL` indicates spherical (geographical) coordinates. This is the
+    default option if you don't specify one explicitly.
+-   `NOINDEX` indicates that the field is not indexed. This is useful for storing
+    coordinates that you don't want to search for, but that you still want to retrieve
+    in search results.
+
+Note that unlike geo fields, geoshape fields don't support the `SORTABLE` option.
+
+Query geoshape fields using the syntax `@<field_name>:[<OPERATION> <shape>]`
+where `<operation>` is one of `WITHIN`, `CONTAINS`, `INTERSECTS`, or `DISJOINT`,
+and `<shape>` is the shape of interest, specified in the
+[Well-known text](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry)
+format. For example, the query below finds shapes that contain the point (2, 2):
+
+```
+FT.SEARCH idx "(@geom:[CONTAINS $qshape])" PARAMS 2 qshape "POINT (2 2)" RETURN 1 name DIALECT 2
+```
+
+See
+[Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information and code examples.
+
+## Vector fields
+
+Vector fields are floating-point vectors that are typically generated by external machine learning models. These vectors represent unstructured data such as text, images, or other complex features. Redis allows you to search for similar vectors using vector search algorithms like cosine similarity, Euclidean distance, and inner product. This enables you to build advanced search applications, recommendation systems, or content similarity analysis.
+
+You can add vector fields to the schema in [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) using this syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} VECTOR {algorithm} {count} [{attribute_name} {attribute_value} ...]
+```
+
+Where:
+
+* `{algorithm}` must be specified and be a supported vector similarity index algorithm. The supported algorithms are:
+
+    - `FLAT`: brute force algorithm.
+    - `HNSW`: hierarchical, navigable, small world algorithm.
+
+    The `{algorithm}` attribute specifies the algorithm to use when searching `k` most similar vectors in the index or filtering vectors by range.
+
+* `{count}` specifies the number of attributes for the index and it must be present. 
+Notice that `{count}` represents the total number of attribute pairs passed in the command. Algorithm parameters should be submitted as named arguments. 
+
+    For example:
+
+    ```
+    FT.CREATE my_idx SCHEMA vec_field VECTOR FLAT 6 TYPE FLOAT32 DIM 128 DISTANCE_METRIC L2
+    ```
+
+    Here, three parameters are passed for the index ([`TYPE`]({{< relref "/commands/type" >}}), `DIM`, `DISTANCE_METRIC`), and `count` is the total number of attributes (6).
+
+* `{attribute_name} {attribute_value}` are algorithm attributes for the creation of the vector index. Every algorithm has its own mandatory and optional attributes.
+
+For more information about vector fields, see [vector fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+
+## Tag fields
+
+Tag fields are used to store textual data that represents a collection of data tags or labels. Tag fields are characterized by their low cardinality, meaning they typically have a limited number of distinct values. Unlike text fields, tag fields are stored as-is without tokenization or stemming. They are useful for organizing and categorizing data, making it easier to filter and retrieve documents based on specific tags.
+
+Tag fields can be added to the schema with the following syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} TAG [SEPARATOR {sep}] [CASESENSITIVE]
+```
+
+where
+
+- `SEPARATOR` defaults to a comma (`,`), and can be any printable ASCII character. It is used to separate tags in the field value. For example, if the field value is `hello,world`, the tags are `hello` and `world`.
+
+- `CASESENSITIVE` indicates that the field is case-sensitive. By default, tag fields are case-insensitive.
+
+You can search for documents with specific tags using the `@<field_name>:{<tag>}` query syntax. For example, this query finds documents with the tag `blue`:
+
+```
+FT.SEARCH idx "@tags:{blue}"
+```
+
+For more information about tag fields, see [Tag Fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}).
+
+## Text fields
+
+Text fields are specifically designed for storing human language text. When indexing text fields, Redis performs several transformations to optimize search capabilities. The text is transformed to lowercase, allowing case-insensitive searches. The data is tokenized, meaning it is split into individual words or tokens, which enables efficient full-text search functionality. Text fields can be weighted to assign different levels of importance to specific fields during search operations. Additionally, text fields can be sorted based on their values, enabling the sorting of search results by relevance or other criteria.
+
+Text fields can be added to the schema with the following syntax:
+
+```
+FT.CREATE ... SCHEMA ... {field_name} TEXT [WEIGHT] [NOSTEM] [PHONETIC {matcher}] [SORTABLE] [NOINDEX] [WITHSUFFIXTRIE]
+```
+
+where
+
+- `WEIGHT` indicates that the field is weighted. This is useful for assigning different levels of importance to specific fields during search operations.
+- `NOSTEM` indicates that the field is not stemmed. This is useful for storing text that you don't want to be tokenized, such as URLs or email addresses.
+- `PHONETIC {matcher}` Declaring a text attribute as `PHONETIC` will perform phonetic matching on it in searches by default. The obligatory matcher argument specifies the phonetic algorithm and language used. The following matchers are supported:
+
+   - `dm:en` - double metaphone for English
+   - `dm:fr` - double metaphone for French
+   - `dm:pt` - double metaphone for Portuguese
+   - `dm:es` - double metaphone for Spanish
+
+    For more information, see [Phonetic Matching]({{< relref "/develop/interact/search-and-query/advanced-concepts/phonetic_matching" >}}).
+- `SORTABLE` indicates that the field can be sorted. This is useful for performing range queries and sorting search results based on text values.
+- `NOINDEX` indicates that the field is not indexed. This is useful for storing text that you don't want to search for, but that you still want to retrieve in search results.
+- `WITHSUFFIXTRIE` indicates that the field will be indexed with a suffix trie. The index will keep a suffix trie with all terms which match the suffix. It is used to optimize `contains (*foo*)` and `suffix (*foo)` queries. Otherwise, a brute-force search on the trie is performed. If a suffix trie exists for some fields, these queries will be disabled for other fields.
+
+You can search for documents with specific text values using the `<term>` or the `@<field_name>:{<term>}` query syntax. Here are a couple of examples:
+
+- Search for a term in every text attribute:
+    ```
+    FT.SEARCH books-idx "wizard"
+    ```
+
+- Search for a term only in the `title` attribute
+    ```
+    FT.SEARCH books-idx "@title:dogs"
+    ```
+
+## Unicode considerations
+
+Redis Query Engine only supports Unicode characters in the [basic multilingual plane](https://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane); U+0000 to U+FFFF. Unicode characters beyond U+FFFF, such as Emojis, are not supported and would not be retrieved by queries including such characters in the following use cases:
+
+* Querying TEXT fields with Prefix/Suffix/Infix
+* Querying TEXT fields with fuzzy
+
+Examples:
+
+```
+redis> FT.CREATE idx SCHEMA tag TAG text TEXT
+OK
+redis> HSET doc:1 tag '😀😁🙂' text '😀😁🙂'
+(integer) 2
+redis> HSET doc:2 tag '😀😁🙂abc' text '😀😁🙂abc'
+(integer) 2
+redis> FT.SEARCH idx '@text:(*😀😁🙂)' NOCONTENT
+1) (integer) 0
+redis> FT.SEARCH idx '@text:(*😀😁🙂*)' NOCONTENT
+1) (integer) 0
+redis> FT.SEARCH idx '@text:(😀😁🙂*)' NOCONTENT
+1) (integer) 0
+
+redis> FT.SEARCH idx '@text:(%😀😁🙃%)' NOCONTENT
+1) (integer) 0
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'How to define the schema of an index.
+
+  '
+linkTitle: Schema definition
+title: Schema definition
+weight: 1
+---
+
+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.
+
+You can learn more about the available field types and options on the [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) page.
+
+## More schema definition examples
+
+##### Index tags with a separator
+
+Index books that have a `categories` attribute, where each category is separated by a `;` character.
+
+```
+FT.CREATE books-idx 
+    ON HASH 
+    PREFIX 1 book:details 
+SCHEMA 
+    title TEXT 
+    categories TAG SEPARATOR ";"
+```
+
+##### Index a single field in multiple ways
+
+Index the `sku` attribute from a hash as both a `TAG` and as `TEXT`:
+
+```
+FT.CREATE idx 
+    ON HASH 
+    PREFIX 1 blog:post: 
+SCHEMA 
+    sku AS sku_text TEXT 
+    sku AS sku_tag TAG SORTABLE
+```
+
+##### Index documents with multiple prefixes
+
+Index two different hashes, one containing author data and one containing book data:
+```
+FT.CREATE author-books-idx 
+    ON HASH 
+    PREFIX 2 author:details: book:details: 
+SCHEMA
+    author_id TAG SORTABLE 
+    author_ids TAG 
+    title TEXT name TEXT
+```
+
+In this example, keys for author data use the key pattern `author:details:<id>`, while keys for book data use the pattern `book:details:<id>`.
+
+##### Only index documents if a field specifies a certain value using `FILTER`
+
+Index authors whose names start with G:
+
+```
+FT.CREATE g-authors-idx 
+    ON HASH 
+    PREFIX 1 author:details 
+    FILTER 'startswith(@name, "G")' 
+SCHEMA 
+    name TEXT
+```
+
+Index only books that have a subtitle:
+
+```
+FT.CREATE subtitled-books-idx
+    ON HASH 
+    PREFIX 1 book:details 
+    FILTER '@subtitle != ""' 
+SCHEMA 
+    title TEXT
+```
+
+##### Index a JSON document using a JSONPath expression
+
+Index a JSON document that has `title` and `categories` fields. The `title` field is indexed as `TEXT` and the `categories` field is indexed as `TAG`.
+
+```
+FT.CREATE idx 
+    ON JSON 
+SCHEMA 
+    $.title AS title TEXT 
+    $.categories AS categories TAG
+```
+
+
+You can learn more about the available field types and options on the [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) page.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Basic constructs for searching and querying Redis data
+linkTitle: Basic constructs
+title: Basic constructs
+weight: 2
+---
+
+You can use Redis Open Source as a powerful search and query engine. It allows you to create indexes and perform efficient queries on structured data, as well as text-based and vector searches on unstructured data.
+
+This section introduces the basic constructs of querying and searching, and explains how to use them to build powerful search capabilities into your applications.
+
+## Documents
+
+A document is the basic unit of information. It can be any hash or JSON data object you want to be able to index and search. Each document is uniquely identifiable by its key name.
+
+## Fields
+
+A document consists of multiple fields, where each field represents a specific attribute or property of the document. Fields can store different types of data, such as strings, numbers, geo-location or even more complex structures like vectors. By indexing these fields, you enable efficient querying and searching based on their values.
+
+Not all documents need to have the same fields. You can include or exclude fields based on the specific requirements of your application or data model.
+
+## Indexing fields
+
+Not all fields are relevant to perform search operations, and indexing all fields may lead to unnecessary overhead. That's why you have the flexibility to choose which fields should be indexed for efficient search operations. By indexing a field, you enable Redis to create an index structure that optimizes search performance on that field.
+
+Fields that are not indexed will not contribute to search results. However, they can still be retrieved as part of the document data when fetching search results.
+
+## Schema
+
+The index structure is defined by a schema. The schema defines how fields are stored and indexed. It specifies the type of each field and other important information.
+
+To create an index, you need to define the schema for your collection. Learn more about how to define the schema on the [schema definition]({{< relref "/develop/interact/search-and-query/basic-constructs/schema-definition" >}}) page.
+
+## Learn more:
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Technical overview of the search and query features of Redis Open Source'
+linkTitle: Technical overview
+title: Technical overview
+weight: 1
+---
+
+## Abstract
+
+Redis Query Engine ("RQE") is a powerful text search and secondary indexing engine that is built on top of Redis Open Source. 
+
+Unlike other Redis search libraries, it does not use the internal data structures of Redis such as sorted sets. Using its own highly optimized data structures and algorithms, it allows for advanced search features, high performance, and a low memory footprint. It can perform simple text searches, as well as complex structured queries, filtering by numeric properties and geographical distances.
+
+RQE supports continuous indexing with no performance degradation, maintaining concurrent loads of querying and indexing. This makes it ideal for searching frequently updated databases without the need for batch indexing and service interrupts. 
+
+The Enterprise version of RQE supports scaling the search engine across many servers, allowing it to easily grow to billions of documents on hundreds of servers. 
+
+All of this is done while taking advantage of Redis's robust architecture and infrastructure. Using Redis's protocol, replication, persistence, and clustering, RQE delivers a powerful yet simple to manage and maintain search and indexing engine that can be used as a standalone database, or to augment existing Redis databases with advanced powerful indexing capabilities.
+
+---
+
+## Main features
+
+* Full-Text indexing of multiple fields in a document, including:
+    * Exact phrase matching.
+    * Stemming in many languages.
+    * Chinese tokenization support.
+    * Prefix queries.
+    * Optional, negative, and union queries.
+* Distributed search on billions of documents.
+* Numeric property indexing.
+* Geographical indexing and radius filters.
+* Incremental indexing without performance loss.
+* A structured query language for advanced queries:
+    * Unions and intersections
+    * Optional and negative queries
+    * Tag filtering
+    * Prefix matching
+* A powerful autocomplete engine with fuzzy matching.
+* Multiple scoring models and sorting by values.
+* Concurrent, low-latency insertion and updates of documents.
+* Concurrent searches allowing long-running queries without blocking Redis.
+* An extension mechanism allowing custom scoring models and query extension.
+* Support for indexing existing Hash objects in Redis databases.
+
+---
+
+## Indexing documents
+
+Redis needs to know how to index documents in order to search effectively. A document may have several fields, each with its own weight. For example, a title is usually more important than the text itself. The engine can also use numeric or geographical fields for filtering. Hence, the first step is to create the index definition, which tells Redis how to treat the documents that will be added. For example, to define an index of products, indexing their title, description, brand, and price fields, the index creation would look like:
+
+```
+FT.CREATE idx PREFIX 1 doc: SCHEMA 
+    title TEXT WEIGHT 5
+    description TEXT 
+    brand TEXT 
+    PRICE numeric
+```
+
+When a document is added to this index, as in the following example, each field of the document is broken into its terms (tokenization), and indexed by marking the index for each of the terms in the index. As a result, the product is added immediately to the index and can now be found in future searches.
+
+```
+HSET doc:1 
+    title "Acme 42 inch LCD TV"
+    description "42 inch brand new Full-HD tv with smart tv capabilities"
+    brand "Acme"
+    price 300
+```
+
+This tells Redis to take the document, break each field into its terms (tokenization), and index it by marking the index for each of the terms in the index as contained in this document. Thus, the product is added immediately to the index and can now be found in future searches.
+
+
+## Searching
+
+Now that the products have been added to our index, searching is very simple:
+
+```
+FT.SEARCH idx "full hd tv"
+```
+
+This will tell Redis to intersect the lists of documents for each term and return all documents containing the three terms. Of course, more complex queries can be performed, and the full syntax of the query language is detailed below. 
+
+## Data structures
+
+Redis uses its own custom data structures and uses Redis' native structures only for storing the actual document content (using Hash objects).
+
+Using specialized data structures allows faster searches and more memory effective storage of index records, utilizing compression techniques like delta encoding. 
+
+These are the data structures Redis uses under the hood:
+
+### Index and document metadata
+
+For each search _index_, there is a root data structure containing the schema, statistics, etc., but most importantly, compact metadata about each document indexed. 
+
+Internally, inside the index, Redis uses delta encoded lists of numeric, incremental, 32-bit document ids. This means that the user given keys or ids for documents, need to be replaced with the internal ids on indexing, and back to the original ids on search. 
+
+For that, Redis saves two tables, mapping the two kinds of ids in two ways (one table uses a compact trie, the other is simply an array where the internal document ID is the array index). On top of that, for each document, its user given presumptive score is stored, along with some status bits and any optional payload attached to the document by the user. 
+
+Accessing the document metadata table is an order of magnitude faster than accessing the hash object where the document is actually saved, so scoring functions that need to access metadata about the document can operate fast enough.
+
+### Inverted index
+
+For each term appearing in at least one document, an inverted index is kept, which is basically a list of all the documents where this term appears. The list is compressed using delta coding, and the document ids are always incrementing. 
+
+For example, when a user indexes the documents "foo", "bar", and "baz", they are assigned incrementing ids, e.g., `1025, 1045, 1080`. When encoding them into the index,  only the first ID is encoded, followed by the deltas between each entry and the previous one, e.g., `1025, 20, 35`. 
+
+Using variable-width encoding, one byte is used to express numbers under 255, two bytes for numbers between 256 and 16,383, and so on. This can compress the index by up to 75%. 
+
+On top of the IDs, the frequency of each term in each document, a bit mask representing the fields in which the term appeared in the document, and a list of the positions in which the term appeared is saved.
+
+The structure of the default search record is as follows. Usually, all the entries are one byte long:
+
+```
++----------------+------------+------------------+-------------+------------------------+
+|  docId_delta   |  frequency | field mask       | offsets len | offset, offset, ....   |
+|  (1-4 bytes)   | (1-2 bytes)| (1-16 bytes)     |  (1-2 bytes)| (1-2 bytes per offset) |
++----------------+------------+------------------+-------------+------------------------+
+```
+
+Optionally, you can choose not to save any one of those attributes besides the ID, degrading the features available to the engine. 
+
+### Numeric index
+
+Numeric properties are indexed in a special data structure that enables filtering by numeric ranges in an efficient way. One could view a numeric value as a term operating just like an inverted index. For example, all the products with the price $100 are in a specific list, which is intersected with the rest of the query. See [query execution engine]({{< relref "develop/interact/search-and-query/administration/design#query-execution-engine" >}}) for more information. 
+
+However, in order to filter by a range of prices, you would have to intersect the query with all the distinct prices within that range, or perform a union query. If the range has many values in it, this becomes highly inefficient. 
+
+To avoid this, numeric entries are grouped, with close values together, in a single range node. These nodes are stored in a binary range tree, which allows the engine to select the relevant nodes and union them together. Each entry in a range node contains a document Id and the actual numeric value for that document. To further optimize, the tree uses an adaptive algorithm to try to merge as many nodes as possible within the same range node. 
+
+### Tag index
+
+Tag indexes are similar to full-text indexes, but use simpler tokenization and encoding in the index. The values in these fields cannot be accessed by general field-less search and can be used only with a special syntax.
+
+The main differences between tag fields and full-text fields are:
+
+1. The tokenization is simpler. The user can determine a separator (defaults to a comma) for multiple tags. Whitespace trimming is done only at the end of tags. Thus, tags can contain spaces, punctuation marks, accents, etc. The only two transformations that are performed are lower-casing (for latin languages only as of now) and whitespace trimming.
+
+2. Tags cannot be found from a general full-text search. If a document has a field called *tags* with the values *foo* and *bar*, searching for foo or bar without a special tag modifier (see below) will not return this document.
+
+3. The index is much simpler and more compressed. Only the document IDs are stored in the index, usually resulting in 1-2 bytes per index entry.
+
+### Geo index
+
+Geo indexes utilize Redis's own geo-indexing capabilities. At query time, the geographical part of the query (a radius filter) is sent to Redis, returning only the ids of documents that are within that radius. Longitude and latitude should be passed as a string `lon,lat`. For example, `1.23,4.56`.
+
+### Autocomplete
+
+The autocomplete engine (see below for a fuller description) uses a compact trie or prefix tree to encode terms and search them by prefix.
+
+## Query language
+
+Simple syntax is supported for complex queries that can be combined together to express complex filtering and matching rules. The query is a text string in the [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) request that is parsed using a complex query processor.
+
+* Multi-word phrases are lists of tokens, e.g., `foo bar baz`, and imply intersection (logical AND) of the terms.
+* Exact phrases are wrapped in quotes, e.g `"hello world"`.
+* OR unions (e.g., `word1 OR word2`), are expressed with a pipe (`|`) character. For example, `hello|hallo|shalom|hola`.
+* NOT negation (e.g., `word1 NOT word2`) of expressions or sub-queries use the dash (`-`) character. For example, `hello -world`. 
+* Prefix matches (all terms starting with a prefix) are expressed with a `*` following a 2-letter or longer prefix.
+* Selection of specific fields using the syntax `@field:hello world`.
+* Numeric Range matches on numeric fields with the syntax `@field:[{min} {max}]`.
+* Geo radius matches on geo fields with the syntax `@field:[{lon} {lat} {radius} {m|km|mi|ft}]`
+* Tag field filters with the syntax `@field:{tag | tag | ...}`. See the [full documentation on tag fields]({{< relref "/develop/interact/search-and-query/query/#tag-filters" >}}).
+* Optional terms or clauses: `foo ~bar` means bar is optional but documents with bar in them will rank higher. 
+
+### Complex query examples
+
+Expressions can be combined together to express complex rules. For example, given a database of products, where each entity has the fields `title`, `brand`, `tags` and `price`, expressing a generic search would be simply:
+
+```
+lcd tv
+```
+
+This would return documents containing these terms in any field. Limiting the search to specific fields (title only in this case) is expressed as:
+
+```
+@title:(lcd tv)
+```
+
+Numeric filters can be combined to filter by price within a given price range:
+
+```
+    @title:(lcd tv) 
+    @price:[100 500.2]
+```
+
+Multiple text fields can be accessed in different query clauses. For example, to select products of multiple brands:
+
+```
+    @title:(lcd tv)
+    @brand:(sony | samsung | lg)
+    @price:[100 500.2]
+```
+
+Tag fields can be used to index multi-term properties without actual full-text tokenization:
+
+```
+    @title:(lcd tv) 
+    @brand:(sony | samsung | lg) 
+    @tags:{42 inch | smart tv} 
+    @price:[100 500.2]
+```
+
+And negative clauses can also be added to filter out plasma and CRT TVs:
+
+```
+    @title:(lcd tv) 
+    @brand:(sony | samsung | lg) 
+    @tags:{42 inch | smart tv} 
+    @price:[100 500.2]
+
+    -@tags:{plasma | crt}
+```
+
+## Scoring model
+
+Redis comes with a few very basic 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 (see below). Scoring functions are specified by adding the `SCORER {scorer_name}` argument to a search request.
+
+If you prefer a custom scoring function, it is possible to add more functions using the [extension API]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}).
+
+These are the pre-bundled scoring functions available in Redis:
+
+* **TFIDF** (default)
+
+    Basic [TF-IDF scoring](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) with document score and proximity boosting factored in.
+
+* **TFIDF.DOCNORM**
+* 
+    Identical to the default TFIDF scorer, with one important distinction:
+
+* **BM25**
+
+    A variation on the basic TF-IDF scorer. See [this Wikipedia article for more information](https://en.wikipedia.org/wiki/Okapi_BM25).
+
+* **DISMAX**
+
+    A simple scorer that sums up the frequencies of the matched terms. In the case of union clauses, it will give the maximum value of those matches.
+
+* **DOCSCORE**
+
+    A scoring function that just returns the presumptive score of the document without applying any calculations to it. Since document scores can be updated, this can be useful if you'd like to use an external score and nothing further.
+
+
+## Sortable fields
+
+It is possible to bypass the scoring function mechanism and order search results by the value of different document properties (fields) directly, even if the sorting field is not used by the query. For example, you can search for first name and sort by the last name. 
+
+When creating the index with [`FT.CREATE`]({{< relref "commands/ft.create/" >}}), you can declare `TEXT`, `TAG`, `NUMERIC`, and `GEO` properties as `SORTABLE`. When a property is sortable, you can later decide to order the results by its values with relatively low latency. When a property is not sortable, it can still be sorted by its values, but may increase latency. For example, the following schema:
+
+```
+FT.CREATE users SCHEMA first_name TEXT last_name TEXT SORTABLE age NUMERIC SORTABLE
+```
+
+Would allow the following query:
+
+```
+FT.SEARCH users "john lennon" SORTBY age DESC
+```
+
+## Result highlighting and summarization
+
+Redis 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. The syntax is as follows:
+
+```
+FT.SEARCH ...
+    SUMMARIZE [FIELDS {num} {field}] [FRAGS {numFrags}] [LEN {fragLen}] [SEPARATOR {separator}]
+    HIGHLIGHT [FIELDS {num} {field}] [TAGS {openTag} {closeTag}]
+
+```
+
+Summarization will fragment the text into smaller sized snippets. Each snippet will contain the found term(s) and some additional surrounding context.
+
+Highlighting will highlight the found term and its variants with a user-defined tag. This may be used to display the matched text in a different typeface using a markup language, or to otherwise make the text appear differently.
+
+## Autocomplete
+
+Another important feature for Redis Open Source is its autocomplete engine. This allows users to create dictionaries of weighted terms, and then query them for completion suggestions to a given user prefix. Completions can have payloads, which are user-provided pieces of data that can be used for display. For example, completing the names of users, it is possible to add extra metadata about users to be displayed.
+
+For example, if a user starts to put the term “lcd tv” into a dictionary, sending the prefix “lc” will return the full term as a result. The dictionary is modeled as a compact trie (prefix tree) with weights, which is traversed to find the top suffixes of a prefix.
+
+Redis also allows fuzzy suggestions, meaning you can get suggestions to prefixes even if the user makes a typo in their prefix. This is enabled using a Levenshtein automaton, allowing efficient searching of the dictionary for all terms within a maximal Levenshtein distance of a term or prefix. Suggestions are then weighted based on both their original score and their distance from the prefix typed by the user. 
+
+However, searching for fuzzy prefixes (especially very short ones) will traverse an enormous number of suggestions. In fact, fuzzy suggestions for any single letter will traverse the entire dictionary, so the recommendation is to use this feature carefully and in full consideration of the performance penalty it incurs. 
+
+The autocomplete engine supports Unicode, allowing for fuzzy matches in non-latin languages as well.
+
+See the [autocomplete page]({{< relref "/develop/interact/search-and-query/advanced-concepts/autocomplete" >}}) for more information and examples.
+
+## Search engine internals
+
+### The Redis module API
+
+RQE is implemented using the [Redis module API]({{< relref "/develop/reference/modules/" >}}) and is loaded into Redis as an extension module at start-up.
+
+Redis modules make it possible to extend Redis's core functionality, implementing new Redis commands, data structures, and capabilities with similar performance to native core Redis itself. Redis modules are dynamic libraries that can be loaded into Redis at start-up or loaded at run-time using the [`MODULE LOAD`]({{< relref "/commands/module-load" >}}) command. Redis exports a C API, in the form of a single C header file called `redismodule.h`. 
+
+While the logic of RQE and its algorithms are mostly independent, and it could be ported quite easily to run as a stand-alone server, it still takes advantage of Redis as a robust infrastructure for a database server. Building on top of Redis means that, by default, modules are afforded:
+
+* A high performance network protocol server
+* Robust replication
+* Highly durable persistence as snapshots of transaction logs
+* Cluster mode
+
+### Query execution engine
+
+Redis uses a high-performance flexible query processing engine that can evaluate very complex queries in real time. 
+
+The above query language is compiled into an execution plan that consists of a tree of index iterators or filters. These can be any of:
+
+* Numeric filter
+* Tag filter
+* Text filter
+* Geo filter
+* Intersection operation (combining 2 or more filters)
+* Union operation (combining 2 or more filters)
+* NOT operation (negating the results of an underlying filter)
+* Optional operation (wrapping an underlying filter in an optional matching filter)
+
+The query parser generates a tree of these filters. For example, a multi-word search would be resolved into an intersect operation of multiple text filters, each traversing an inverted index of a different term. Simple optimizations such as removing redundant layers in the tree are applied.
+
+Each of the filters in the resulting tree evaluates one match at a time. This means that at any given moment, the query processor is busy evaluating and scoring one matching document. This means that very little memory allocation is done at run-time, resulting in higher performance. 
+
+The resulting matching documents are then fed to a post-processing chain of result processors that are responsible for scoring them, extracting the top-N results, loading the documents from storage, and sending them to the client. That chain is dynamic as well, which adapts based on the attributes of the query. For example, a query that only needs to return document ids will not include a stage for loading documents from storage. 
+
+### Concurrent updates and searches
+
+While RQE is extremely fast and uses highly optimized data structures and algorithms, it was facing the same problem with regards to concurrency. Depending on the size of your data set and the cardinality of search queries, queries can take anywhere between a few microseconds to hundreds of milliseconds, or even seconds in extreme cases. When that happens, the entire Redis server process is blocked. 
+
+Think, for example, of a full-text query intersecting the terms "hello" and "world", each with a million entries, and a half-million common intersection points. To perform that query in a millisecond, Redis would have to scan, intersect, and rank each result in one nanosecond, [which is impossible with current hardware](https://gist.github.com/jboner/2841832). The same goes for indexing a 1,000 word document. It blocks Redis entirely for the duration of the query.
+
+RQE uses the Redis Module API's concurrency features to avoid stalling the server for long periods of time. The idea is simple - while Redis itself is single-threaded, a module can run many threads, and any one of those threads can acquire the **Global Lock** when it needs to access Redis data, operate on it, and release it. 
+
+Redis cannot be queried in parallel, as only one thread can acquire the lock, including the Redis main thread, but care is taken to make sure that a long-running query will give other queries time to run by yielding this lock from time to time.
+
+The following design principles were adopted to allow concurrency:
+
+1. RQE has a thread pool for running concurrent search queries. 
+
+2. When a search request arrives, it is passed to the handler, parsed on the main thread, and then a request object is passed to the thread pool via a queue.
+
+3. The thread pool runs a query processing function in its own thread.
+
+4. The function locks the Redis Global lock and starts executing the query.
+
+5. Since the search execution is basically an iterator running in a cycle, the elapsed time is sampled every several iterations (sampling on each iteration would slow things down as it has a cost of its own).
+
+6. If enough time has elapsed, the query processor releases the Global Lock and immediately tries to acquire it again. When the lock is released, the kernel will schedule another thread to run - be it Redis's main thread, or another query thread.
+
+7. When the lock is acquired again, all Redis resources that were held before releasing the lock are re-opened (keys might have been deleted while the thread has been sleeping) and work resumes from the previous state. 
+
+Thus the operating system's scheduler makes sure all query threads get CPU time to run. While one is running the rest wait idly, but since execution is yielded about 5,000 times a second, it creates the effect of concurrency. Fast queries will finish in one go without yielding execution, slow ones will take many iterations to finish, but will allow other queries to run concurrently. 
+
+### Index garbage collection
+
+RQE is optimized for high write, update, and delete throughput. One of the main design choices dictated by this goal is that deleting and updating documents do not actually delete anything from the index: 
+
+1. Deletion simply marks the document deleted in a global document metadata table using a single bit. 
+2. Updating, on the other hand, marks a document as deleted, assigns it a new incremental document ID, and re-indexes the document under a new ID, without performing a comparison of the change. 
+
+What this means, is that index entries belonging to deleted documents are not removed from the index, and can be seen as garbage. Over time, an index with many deletes and updates will contain mostly garbage, both slowing things down and consuming unnecessary memory. 
+
+To overcome this, RQE employs a background garbage collection (GC) mechanism. During normal operation of the index, a special thread randomly samples indexes, traverses them, and looks for garbage. Index sections containing garbage are cleaned and memory is reclaimed. This is done in a non- intrusive way, operating on very small amounts of data per scan, and utilizing Redis's concurrency mechanism (see above) to avoid interrupting searches and indexing. The algorithm also tries to adapt to the state of the index, increasing the GC's frequency if the index contains a lot of garbage, and decreasing it if it doesn't, to the point of hardly scanning if the index does not contain garbage. 
+
+### Extension model
+
+RedisSearch 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 at run-time. Instead, extensions must be written in C (or a language that has an interface with C) and compiled into dynamic libraries that will be loaded at start-up.
+
+There are two kinds of extension APIs at the moment: 
+
+1. **Query expanders**, whose role is to expand query tokens (i.e., stemmers).
+2. **Scoring functions**, whose role is to rank search results at query time.
+
+Extensions are compiled into dynamic libraries and loaded into RQE on initialization of the module. The mechanism is based on the code of Redis's own module system, albeit far simpler.
+
+---
+
+## Scalable distributed search
+
+While RQE is very fast and memory efficient, if an index is big enough, at some point it will be too slow or consume too much memory. It must then be scaled out and partitioned over several machines, each of which will hold a small part of the complete search index.
+
+Traditional clusters map different keys to different shards to achieve this. However, with search indexes this approach is not practical. If each word’s index was mapped to a different shard, it would be necessary to intersect records from different servers for multi-term queries. 
+
+The way to address this challenge is to employ a technique called index partitioning, which is very simple at its core:
+
+* The index is split across many machines/partitions by document ID.
+* Every partition has a complete index of all the documents mapped to it.
+* All shards are queried concurrently and the results from each shard are merged into a single result.
+
+To facilitate this, a new component called a coordinator is added to the cluster. When searching for documents, the coordinator receives the query and sends it to N partitions, each holding a sub-index of 1/N documents. Since we’re only interested in the top K results of all partitions, each partition returns just its own top K results. Then, the N lists of K elements are merged and the top K elements are extracted from the merged list.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about extensions for query expanders and scoring functions
+linkTitle: Extensions
+title: Extend existing search and query features
+weight: 9
+---
+
+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: 
+
+1. **Query expanders**, whose role is to expand query tokens (i.e., stemmers).
+2. **Scoring functions**, whose role is to rank search results at query time.
+
+## Registering and loading extensions
+
+Extensions should be compiled into dynamic library files (e.g., `.so` files), and loaded into the RediSearch module during initialization. 
+
+### Compiling 
+
+    Extensions should be compiled and linked as dynamic libraries. An example Makefile for an extension [can be found here](https://github.com/RediSearch/RediSearch/blob/master/tests/ctests/ext-example/Makefile). 
+
+    That folder also contains an example extension that is used for testing and can be taken as a skeleton for implementing your own extension.
+
+### Loading 
+
+    Loading an extension is done by appending `EXTLOAD {path/to/ext.so}` after the `loadmodule` configuration directive when loading the RediSearch module. For example:
+
+    ```sh
+    $ redis-server --loadmodule ./redisearch.so EXTLOAD ./ext/my_extension.so
+    ```
+
+    This causes the RediSearch module to automatically load the extension and register its expanders and scorers. 
+
+## Initializing an extension
+
+The entry point of an extension is a function with the signature:
+
+```c
+int RS_ExtensionInit(RSExtensionCtx *ctx);
+```
+
+When loading an extension, RediSearch looks for this function and calls it. This function is responsible for registering and initializing the expanders and scorers. 
+
+It should return REDISEARCH_ERR on error or REDISEARCH_OK on success.
+
+### Example init function
+
+```c
+#include <redisearch.h> //must be in the include path
+
+int RS_ExtensionInit(RSExtensionCtx *ctx) {
+
+  /* Register  a scoring function with an alias my_scorer and no special private data and free function */
+  if (ctx->RegisterScoringFunction("my_scorer", MyCustomScorer, NULL, NULL) == REDISEARCH_ERR) {
+    return REDISEARCH_ERR;
+  }
+
+  /* Register a query expander  */
+  if (ctx->RegisterQueryExpander("my_expander", MyExpander, NULL, NULL) ==
+      REDISEARCH_ERR) {
+    return REDISEARCH_ERR;
+  }
+
+  return REDISEARCH_OK;
+}
+```
+
+## Calling your custom functions
+
+When performing a query, you can use your scorers or expanders by specifying the SCORER or EXPANDER arguments with the given alias. For example:
+
+```
+FT.SEARCH my_index "foo bar" EXPANDER my_expander SCORER my_scorer
+```
+
+**NOTE**: Expander and scorer aliases are **case sensitive**.
+
+## The query expander API
+
+Only basic query expansion is supported, one token at a time. An expander can decide to expand any given token with as many tokens it wishes, which will be union-merged in query time.
+
+The API for an expander is the following:
+
+```c
+#include <redisearch.h> //must be in the include path
+
+void MyQueryExpander(RSQueryExpanderCtx *ctx, RSToken *token) {
+    ...
+}
+```
+
+### RSQueryExpanderCtx
+
+`RSQueryExpanderCtx` is a context that contains private data of the extension, and a callback method to expand the query. It is defined as:
+
+```c
+typedef struct RSQueryExpanderCtx {
+
+  /* Opaque query object used internally by the engine, and should not be accessed */
+  struct RSQuery *query;
+
+  /* Opaque query node object used internally by the engine, and should not be accessed */
+  struct RSQueryNode **currentNode;
+
+  /* Private data of the extension, set on extension initialization */
+  void *privdata;
+
+  /* The language of the query, defaults to "english" */
+  const char *language;
+
+  /* ExpandToken allows the user to add an expansion of the token in the query, that will be
+   * union-merged with the given token in query time. str is the expanded string, len is its length,
+   * and flags is a 32 bit flag mask that can be used by the extension to set private information on
+   * the token */
+  void (*ExpandToken)(struct RSQueryExpanderCtx *ctx, const char *str, size_t len,
+                      RSTokenFlags flags);
+
+  /* SetPayload allows the query expander to set GLOBAL payload on the query (not unique per token)
+   */
+  void (*SetPayload)(struct RSQueryExpanderCtx *ctx, RSPayload payload);
+
+} RSQueryExpanderCtx;
+```
+
+### RSToken
+
+`RSToken` represents a single query token to be expanded, and is defined as:
+
+```c
+/* A token in the query. The expanders receive query tokens and can expand the query with more query
+ * tokens */
+typedef struct {
+  /* The token string - which may or may not be NULL terminated */
+  const char *str;
+  /* The token length */
+  size_t len;
+  
+  /* 1 if the token is the result of query expansion */
+  uint8_t expanded:1;
+
+  /* Extension specific token flags that can be examined later by the scoring function */
+  RSTokenFlags flags;
+} RSToken;
+```
+
+## The scoring function API
+
+For the final ranking, the scoring function analyzes each document retrieved by the query, taking into account not only the terms that triggered the document's retrieval but also metadata like its prior score, length, and so on.
+
+Since the scoring function is evaluated for each document, potentially millions of times, and since
+redis is single threaded, it is important that it works as fast as possible and be heavily optimized. 
+
+A scoring function is applied to each potential result for each document and is implemented with the following signature:
+
+```c
+double MyScoringFunction(RSScoringFunctionCtx *ctx, RSIndexResult *res,
+                                    RSDocumentMetadata *dmd, double minScore);
+```
+
+`RSScoringFunctionCtx` is a context that implements some helper methods. 
+
+`RSIndexResult` is the result information containing the document id, frequency, terms, and offsets. 
+
+`RSDocumentMetadata` is an object holding global information about the document, such as its presumptive score. 
+
+`minScore` is the minimal score that will yield a result that is relevant to the search. It can be used to stop processing midway or before or even before it starts.
+
+The return value of the function is a `double` representing the final score of the result. 
+Returning 0 causes the result to be counted, but if there are results with a score greater than 0, they will appear above it. 
+To completely filter out a result and not count it in the totals, the scorer should return the special value `RS_SCORE_FILTEROUT`, which is internally set to negative infinity, or -1/0. 
+
+### RSScoringFunctionCtx
+
+This is an object containing the following members:
+
+* `void *privdata`: a pointer to an object set by the extension on initialization time.
+* `RSPayload payload*`: A Payload object set either by the query expander or the client.
+* `int GetSlop(RSIndexResult *res)*`: A callback method that yields the total minimal distance between the query terms. This can be used to prefer results where the slop is smaller and the terms are nearer to each other.
+
+### RSIndexResult
+
+This is an object holding the information about the current result in the index, which is an aggregate of all the terms that resulted in the current document being considered a valid result. See `redisearch.h` for details.
+
+### RSDocumentMetadata
+
+This is an object describing global information, unrelated to the current query, about the document being evaluated by the scoring function. 
+
+## Example query expander
+
+This example query expander expands each token with the term foo:
+
+```c
+#include <redisearch.h> //must be in the include path
+
+void DummyExpander(RSQueryExpanderCtx *ctx, RSToken *token) {
+    ctx->ExpandToken(ctx, strdup("foo"), strlen("foo"), 0x1337);  
+}
+```
+
+## Example scoring function
+
+This is an actual scoring function, which calculates TF-IDF for the document, multiplies it by the document score, and divides it by the slop:
+
+```c
+#include <redisearch.h> //must be in the include path
+
+double TFIDFScorer(RSScoringFunctionCtx *ctx, RSIndexResult *h, RSDocumentMetadata *dmd,
+                   double minScore) {
+  // no need to evaluate documents with score 0 
+  if (dmd->score == 0) return 0;
+
+  // calculate sum(tf-idf) for each term in the result
+  double tfidf = 0;
+  for (int i = 0; i < h->numRecords; i++) {
+    // take the term frequency and multiply by the term IDF, add that to the total
+    tfidf += (float)h->records[i].freq * (h->records[i].term ? h->records[i].term->idf : 0);
+  }
+  // normalize by the maximal frequency of any term in the document   
+  tfidf /=  (double)dmd->maxFreq;
+
+  // multiply by the document score (between 0 and 1)
+  tfidf *= dmd->score;
+
+  // no need to factor the slop if tfidf is already below minimal score
+  if (tfidf < minScore) {
+    return 0;
+  }
+
+  // get the slop and divide the result by it, making sure we prefer results with closer terms
+  tfidf /= (double)ctx->GetSlop(h);
+  
+  return tfidf;
+}
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: This document describes how documents are added to the index.
+linkTitle: Indexing
+title: Document Indexing
+---
+
+## Components
+
+* `Document` - contains the actual document and its fields.
+* `RSAddDocumentCtx` - the per-document state that is used while it
+  is being indexed. The state is discarded after the indexing is complete.
+* `ForwardIndex` - contains terms found in the document. The forward index
+  is used to write the `InvertedIndex`.
+* `InvertedIndex` - an index that maps terms to occurrences within applicable
+  documents.
+
+##  Architecture
+
+The indexing process begins by creating a new `RSAddDocumentCtx` and adding a
+document to it. Internally, this is divided into several steps.
+
+
+1. Submission
+
+   A `DocumentContext` is created, and is associated with a document (as received)
+   from input. The submission process will also perform some preliminary caching.
+
+2. Preprocessing
+
+   After a document has been submitted, it is preprocessed. Preprocessing performs
+   stateless processing on all document input fields. For text fields, this
+   means tokenizing the document and creating a forward index. The preprocesors
+   will store this information in per-field variables within the `AddDocumentCtx`.
+   This computed result is then written to the persistent index later on during
+   the indexing phase.
+
+   If the document is sufficiently large, the preprocessing is done in a separate
+   thread, which allows concurrent preprocessing and also avoids blocking other
+   threads. If the document is smaller, the preprocessing is done within the main
+   thread, avoiding the overhead of additional context switching.
+   The `SELF_EXC_THRESHOLD` macro contains the threshold for 'sufficiently large'.
+
+   After the document is preprocessed, it is submitted to be indexed.
+
+3. Indexing
+
+   Indexing proper consists of committing the precomputed results of the
+   preprocessing phase. It is done in a single thread, and is in the form
+   of a queue.
+
+   Because documents must be written to the index in the exact order of their
+   document ID assignment, and because the indexing process must also yield to other potential
+   indexing processes, you may end up in a situation where document IDs are written
+   to the index out-of-order. To solve that, the order in which documents
+   are actually written must be well-defined. If there is only one thread writing
+   documents, then this thread will not need to worry about out-of-order IDs
+   while writing.
+
+   Having a single background thread also helps optimize in several areas, as
+   will be seen later on. The basic idea is that when there are a lot of
+   documents queued for the indexing thread, the indexing thread may treat them
+   as batch commands, greatly reducing the number of locks/unlocks of the GIL
+   and the number of times term keys need to be opened and closed.
+
+4. Skipping already indexed documents
+
+   The phases below may operate on more than one document at a time. When a document
+   is fully indexed, it is marked as done. When the thread iterates over the queue
+   it will only perform processing/indexing on items not yet marked as done.
+
+5. Term merging
+
+   Term merging, or forward index merging, is done when there is more than a
+   single document in the queue. The forward index of each document in the queue
+   is scanned, and a larger, master forward index is constructed in its place.
+   Each entry in the forward index contains a reference to the origin document
+   as well as the normal offset/score/frequency information.
+   
+   Creating a master forward index avoids opening common term keys more than once per
+   document.
+
+   If there is only one document within the queue, a master forward index
+   is not created.
+
+   Note that the internal type of the master forward index is not actually
+   `ForwardIndex`.
+
+6. Document ID assignment
+   
+   At this point, the GIL is locked and every document in the queue is assigned
+   a document ID. The assignment is done immediately before writing to the index
+   so as to reduce the number of times the GIL is locked; thus, the GIL is
+   locked only once, right before the index is written.
+
+7. Writing to Indexes
+
+   With the GIL being locked, any pending index data is written to the indexes.
+   This usually involves opening one or more Redis keys, and writing/copying
+   computed data into those keys.
+
+   After this is done, the reply for the given document is sent, and the
+   `AddDocumentCtx` freed.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about garbage collection
+linkTitle: Garbage collection
+title: Garbage collection
+weight: 2
+---
+
+## 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.
+
+You want to optimize the index, but you also don't want to disturb normal operation. This means that optimization or garbage collection should be a background process that's non-intrusive. It only needs to be faster than the deletion rate over a sufficient period of time so that you don't create more garbage than you can collect.
+
+## Garbage collecting a single-term index
+
+A single-term inverted index is an array of blocks, each of which contains an encoded list of records; e.g., a document id delta plus other data depending on the index encoding scheme. When some of these records refer to deleted documents this is called garbage. 
+
+The algorithm is simple: 
+
+0. Create a reader and writer for each block.
+1. Read each block's records one by one.
+2. If no record is invalid, do nothing.
+3. When a garbage record is found, the reader is advanced, but not the writer.
+4. When at least one garbage record is found, the next records are encoded to the writer, recalculating the deltas.
+
+Pseudo code:
+
+```
+foreach index_block as block:
+   
+   reader = new_reader(block)
+   writer = new_write(block)
+   garbage = 0
+   while not reader.end():
+        record = reader.decode_next()
+        if record.is_valid():
+            if garbage != 0:
+                # Write the record at the writer's tip with a newly calculated delta
+                writer.write_record(record)
+            else:
+                writer.advance(record.length)
+        else:
+            garbage += record.length
+```
+
+### GC on numeric indexes
+
+Numeric indexes are a tree of inverted indexes with a special encoding of (docId delta, value). This means the same algorithm can be applied to them, only traversing each inverted index object in the tree.
+
+## FORK GC
+
+Information about FORK GC can be found in this [blog](https://redislabs.com/blog/increased-garbage-collection-performance-redisearch-1-4-1/).
+
+Since v1.6, the FORK GC is the default GC policy and was proven very efficient both in cleaning the index and not reducing query and indexing performance, even for very write-internsive use cases.
+---
+aliases: /develop/interact/search-and-query/basic-constructs/configuration-parameters
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis Query Engine can be tuned through multiple configuration parameters. Some of these parameters can only be set at load-time, while other parameters can be set either at load-time or at run-time.
+linkTitle: Configuration parameters
+title: Configuration parameters
+weight: 1
+---
+{{< note >}}
+As of Redis 8 in Redis Open Source (Redis 8), configuration parameters for the time series data structure are now set in the following ways:
+* At load time via your `redis.conf` file.
+* At run time (where applicable) using the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command.
+
+Also, Redis 8 persists RQE configuration parameters just like any other configuration parameters (e.g., using the [`CONFIG REWRITE`]({{< relref "/commands/config-rewrite/" >}}) command).
+{{< /note >}}
+
+## RQE configuration parameters
+
+The following table summarizes which configuration parameters can be set at run-time, and compatibility with Redis Software and Redis Cloud.
+
+| Parameter name<br />(version < 8.0) | Parameter name<br />(version &#8805; 8.0) | Run-time | Redis<br />Software | Redis<br />Cloud |
+| :------- | :------- | :------- | :------- | :------- |
+| BG_INDEX_SLEEP_GAP                | [search-bg-index-sleep-gap](#search-bg-index-sleep-gap)         | :white_large_square: |||
+| CONCURRENT_WRITE_MODE             | [search-concurrent-write-mode](#search-concurrent-write-mode)   | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| CONN_PER_SHARD                    | [search-conn-per-shard](#search-conn-per-shard)                 | :white_check_mark:   |||
+| CURSOR_MAX_IDLE                   | [search-cursor-max-idle](#search-cursor-max-idle)               | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| CURSOR_READ_SIZE                  | [search-cursor-read-size](#search-cursor-read-size)             | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| CURSOR_REPLY_THRESHOLD            | [search-cursor-reply-threshold](#search-cursor-reply-threshold) | :white_check_mark:   |||
+| DEFAULT_DIALECT                   | [search-default-dialect](#search-default-dialect)               | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| EXTLOAD                           | [search-ext-load](#search-ext-load)                             | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| FORK_GC_CLEAN_THRESHOLD           | [search-fork-gc-clean-threshold](#search-fork-gc-clean-threshold) | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| FORK_GC_RETRY_INTERVAL            | [search-fork-gc-retry-interval](#search-fork-gc-retry-interval) | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| FORK_GC_RUN_INTERVAL              | [search-fork-gc-run-interval](#search-fork-gc-run-interval)     | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| FORKGC_SLEEP_BEFORE_EXIT          | [search-fork-gc-sleep-before-exit](#search-fork-gc-sleep-before-exit) | :white_check_mark: |||
+| FRISOINI                          | [search-friso-ini](#search-friso-ini)                             | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| [GC_POLICY](#gc_policy)           | There is no matching `CONFIG` parameter.                        | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| GCSCANSIZE                        | [search-gc-scan-size](#search-gc-scan-size)                       | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| INDEX_CURSOR_LIMIT                | [search-index-cursor-limit](#search-index-cursor-limit)         | :white_large_square: |||
+| INDEX_THREADS                     | search-index-threads                                            | :white_large_square: |||
+| MAXAGGREGATERESULTS               | [search-max-aggregate-results](#search-max-aggregate-results)   | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MAXDOCTABLESIZE                   | [search-max-doctablesize](#search-max-doctablesize)             | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MAXEXPANSIONS                     | [search-max-expansions](#search-max-expansions)                 | :white_check_mark:   |||
+| MAXPREFIXEXPANSIONS               | [search-max-prefix-expansions](#search-max-prefix-expansions)   | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MAXSEARCHRESULTS                  | [search-max-search-results](#search-max-search-results)           | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MIN_OPERATION_WORKERS             | [search-min-operation-workers](#search-min-operation-workers)   | :white_check_mark:   |||
+| MIN_PHONETIC_TERM_LEN             | [search-min-phonetic-term-len](#search-min-phonetic-term-len)   | :white_check_mark:   |||
+| MINPREFIX                         | [search-min-prefix](#search-min-prefix)                         | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MINSTEMLEN                        | [search-min-stem-len](#search-min-stem-len)                     | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MULTI_TEXT_SLOP                   | [search-multi-text-slop](#search-multi-text-slop)               | :white_large_square: |||
+| NO_MEM_POOLS                      | [search-no-mem-pools](#search-no-mem-pools)                     | :white_large_square: |||
+| NOGC                              | [search-no-gc](#search-no-gc)                                     | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| ON_TIMEOUT                        | [search-on-timeout](#search-on-timeout)                         | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| PARTIAL_INDEXED_DOCS              | [search-partial-indexed-docs](#search-partial-indexed-docs)     | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| RAW_DOCID_ENCODING                | [search-raw-docid-encoding](#search-raw-docid-encoding)         | :white_large_square: |||
+| SEARCH_THREADS                    | [search-threads](#search-threads)                               | :white_large_square: |||
+| TIERED_HNSW_BUFFER_LIMIT          | [search-tiered-hnsw-buffer-limit](#search-tiered-hnsw-buffer-limit) | :white_large_square: |||
+| TIMEOUT                           | [search-timeout](#search-timeout)                               | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| TOPOLOGY_VALIDATION_TIMEOUT       | [search-topology-validation-timeout](#search-topology-validation-timeout) | :white_check_mark: |||
+| UNION_ITERATOR_HEAP               | [search-union-iterator-heap](#search-union-iterator-heap)       | :white_check_mark:   | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| UPGRADE_INDEX                     | [search-upgrade-index](#search-upgrade-index)                   | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| VSS_MAX_RESIZE                    | [search-vss-max-resize](#search-vss-max-resize)                 | :white_check_mark:   |||
+| WORKERS_PRIORITY_BIAS_THRESHOLD   | [search-workers-priority-bias-threshold](#search-workers-priority-bias-threshold) | :white_large_square: |||
+| WORKERS                           | [search-workers](#search-workers)                               | :white_check_mark: |||
+| OSS_GLOBAL_PASSWORD               | Deprecated in v8.0.0. Replace with the `masterauth` password.   | :white_large_square: | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Not supported"><nobr>&#x274c; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> |
+| MT_MODE                           | Deprecated in v8.0.0. Use search-workers.                       | :white_large_square: |||
+| PRIVILEGED_THREADS_NUM            | Deprecated in v8.0.0. Use search-workers-priority-bias-threshold.| :white_large_square: |||
+| WORKER_THREADS                    | Deprecated in v8.0.0. Use search-min-operation-workers.         | :white_large_square: |||
+| SAFEMODE                          | Deprecated in v1.6.0. This is now the default setting.          | :white_large_square: |||
+| FORK_GC_CLEAN_NUMERIC_EMPTY_NODES | Deprecated in v8.0.0.                                           | :white_large_square: |||
+
+{{< note >}}
+Parameter names for Redis Open Source versions < 8.0, while deprecated, will still be supported in Redis 8.
+{{< /note >}}
+
+---
+
+### search-bg-index-sleep-gap
+
+The number of iterations to run while performing background indexing before `usleep(1)` (sleep for 1 microsecond) is called, ensuring that Redis can process other commands.
+
+Type: integer
+
+Valid range: `[1 .. 4294967295]`
+
+Default: `100`
+
+### search-concurrent-write-mode
+
+If enabled, the tokenization of write queries will be performed concurrently.
+
+Type: boolean
+
+Default: `FALSE`
+
+### search-conn-per-shard
+
+The number of connections to each shard in a cluster.
+If `0`, the number of connections is set to `search-workers` + 1.
+
+Type: integer
+
+Valid range: `[0 .. 9,223,372,036,854,775,807]`
+
+Default: `0`
+
+### search-cursor-max-idle
+
+The maximum idle time (in ms) that can be set to the [cursor api]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations#cursor-api" >}}).
+
+Type: integer
+
+Valid range: `[0 .. 9,223,372,036,854,775,807]`
+
+Default: `300000`
+
+### search-cursor-read-size
+
+Type: integer
+
+Default: `1000`
+
+### search-cursor-reply-threshold
+
+The maximum number of replies to accumulate before triggering `_FT.CURSOR READ` on the shards.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `1`
+
+### search-default-dialect
+
+The default
+[DIALECT]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}})
+to be used by [`FT.CREATE`]({{< relref "/commands/ft.create/" >}}), [`FT.AGGREGATE`]({{< relref "/commands/ft.aggregate/" >}}), [`FT.EXPLAIN`]({{< relref "/commands/ft.explain/" >}}), [`FT.EXPLAINCLI`]({{< relref "/commands/ft.explaincli/" >}}), and [`FT.SPELLCHECK`]({{< relref "/commands/ft.spellcheck/" >}}).
+See [Query dialects]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}})
+for more information.
+
+Default: `1`
+
+### search-ext-load
+
+If present, Redis will try to load an extension dynamic library from the specified file path.
+See [Extensions]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}) for details.
+
+Type: string
+
+Default: not set
+
+### search-fork-gc-clean-numeric-empty-nodes
+
+Clean empty nodes from numeric tree.
+
+Type: boolean
+
+Default: `TRUE`
+
+### search-fork-gc-clean-threshold
+
+The fork GC will only start to clean when the number of uncleaned documents exceeds this threshold, otherwise it will skip this run.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `100`
+
+### search-fork-gc-retry-interval
+
+Interval (in seconds) in which Redis will retry to run fork GC in case of a failure.
+This setting can only be combined with the [`search-gc-policy`](#search-gc-policy) `FORK` setting.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `5`
+
+### search-fork-gc-run-interval
+
+Interval (in seconds) between two consecutive fork GC runs.
+This setting can only be combined with the [`search-gc-policy`](#search-gc-policy) `FORK` setting.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `30`
+
+### search-fork-gc-sleep-before-exit
+
+The number of seconds for the fork GC to sleep before exit. This value should always be set to 0 except when testing.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `0`
+
+### search-friso-ini
+
+If present, load the custom Chinese dictionary from the specified path. See [Using custom dictionaries]({{< relref "/develop/interact/search-and-query/advanced-concepts/chinese#using-custom-dictionaries" >}}) for more details.
+
+Type: string
+
+Default: not set
+
+### GC_POLICY
+
+The garbage collection policy. The two supported policies are:
+* FORK: uses a forked thread for garbage collection (v1.4.1 and above). This is the default GC policy since v1.6.1 and is ideal for general purpose workloads.
+* LEGACY: uses a synchronous, in-process fork. This is ideal for read-heavy and append-heavy workloads with very few updates/deletes. Deprecated in v2.6.0.
+
+Note: When `GC_POLICY` is set to `FORK`, it can be combined with the `search-fork-gc-run-interval` and `search-fork-gc-retry-interval` settings. 
+
+Type: string
+
+Valid values: `FORK` or `DEFAULT`
+
+Default: `FORK`
+
+### search-gc-scan-size
+
+The bulk size of the internal GC used for cleaning up indexes.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Redis Open Source default: `100`
+
+Redis Software default: `-1` (unlimited)
+
+Redis Cloud defaults:
+- Flexible & Annual: `-1` (unlimited)
+- Free & Fixed: `10000`
+
+### search-index-cursor-limit
+
+Added in v2.10.8.
+
+The maximum number of cursors that can be opened, per shard, at any given time. Cursors can be opened by the user via [`FT.AGGREGATE WITHCURSOR`]({{< relref "/commands/ft.aggregate/" >}}). Cursors are also opened internally by the RQE for long-running queries. Once `INDEX_CURSOR_LIMIT` is reached, any further attempts to open a cursor will result in an error.
+
+{{% alert title="Notes" color="info" %}}
+* Caution should be used in modifying this parameter.  Every open cursor results in additional memory usage.
+* Cursor usage should be regulated first by use of [`FT.CURSOR DEL`]({{< relref "/commands/ft.cursor-del/" >}}) and/or [`MAXIDLE`]({{< relref "/commands/ft.aggregate/" >}}) prior to modifying `INDEX_CURSOR_LIMIT`
+* See [Cursor API]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations#cursor-api" >}}) for more details.
+{{% /alert %}}
+
+Type: integer
+
+Default: `128`
+
+### search-max-aggregate-results
+
+The maximum number of results to be returned by the `FT.AGGREGATE` command if `LIMIT` is used.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Redis Open Source default: `-1` (unlimited)
+
+Redis Software default: `-1` (unlimited)
+
+Redis Cloud defaults:
+- Flexible & Annual: `-1` (unlimited)
+- Free & Fixed: `10000`
+
+### search-max-doctablesize
+
+The maximum size of the internal hash table used for storing documents. 
+Note: this configuration option doesn't limit the number of documents that can be stored. It only affects the hash table internal array maximum size.
+Decreasing this property can decrease the memory overhead in cases where the index holds a small number of documents that are constantly updated.
+
+Type: integer
+
+Valid range: `[1 .. 18,446,744,073,709,551,615]`
+
+Default: `1000000`
+
+### search-max-expansions
+
+This parameter is an alias for [search-max-prefix-expansions](#search-max-prefix-expansions).
+
+### search-max-prefix-expansions
+
+The maximum number of expansions allowed for query prefixes.
+The maximum number of expansions allowed for query prefixes. Setting it too high can cause performance issues. If `search-max-prefix-expansions` is reached, the query will continue with the first acquired results. The configuration is applicable for all affix queries including prefix, suffix, and infix (contains) queries.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `200`
+
+### search-max-search-results
+
+The maximum number of results to be returned by the `FT.SEARCH` command if `LIMIT` is used. Set it to `-1` to remove the limit.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Redis Open Source default: `1000000`
+
+Redis Software default: `1000000`
+
+Redis Cloud defaults:
+- Flexible & Annual: `1000000`
+- Free & Fixed: `10000`
+
+### search-min-operation-workers
+
+The number of worker threads to use for background tasks when the server is in an operation event.
+
+Type: integer
+
+Valid range: `[0 .. 8192]`
+
+Default: `4`
+
+### search-min-phonetic-term-len
+
+The minimum length of term to be considered for phonetic matching.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `3`
+
+### search-min-prefix
+
+The minimum number of characters allowed for prefix queries (for example, hel*). Setting it to `1` can reduce performance.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `2`
+
+### search-min-stem-len
+
+The minimum word length to stem. Setting it lower than `4` can reduce performance.
+
+Type: integer
+
+Valid range: `[2 .. 4,294,967,295]`
+
+Redis Open Source default: `4`
+
+Redis Software and Redis Cloud default: `2`
+
+### search-multi-text-slop
+
+Set the delta that is used to increase positional offsets between array slots for multi text values.
+This will allow you to control the level of separation between phrases in different array slots; related to the `SLOP` parameter of `FT.SEARCH` command.
+
+Type: integer
+
+Valid range: `[0 .. 4,294,967,295]`
+
+Default: `100`
+
+### search-no-mem-pools
+
+Set RQE to run without memory pools.
+
+Type: boolean
+
+Default: `FALSE`
+
+### search-no-gc
+
+If set to `TRUE`, garbage collection is disabled for all indexes.
+
+Type: boolean
+
+Default: `FALSE`
+
+### search-on-timeout
+
+The response policy for queries that exceed the [`search-timeout`](#search-timeout) setting can be one of the following:
+
+* `RETURN`: this policy will return the top results accumulated by the query until it timed out.
+* `FAIL`: will return an error when the query exceeds the timeout value.
+
+Type: string
+
+Valid values: `RETURN`, `FAIL`
+
+Default: `RETURN`
+
+### search-partial-indexed-docs
+
+Added in v2.0.0.
+
+Enable/disable the Redis command filter. The filter optimizes partial updates of hashes
+and may avoid re-indexing the hash if changed fields are not part of the schema. 
+
+The Redis command filter will be executed upon each Redis command.  Though the filter is
+optimized, this will introduce a small increase in latency on all commands.  
+This configuration is best used with partially indexed documents where the non-indexed fields are updated frequently.
+
+Type: integer
+
+Valid values: `0` (false), `1` (true)
+
+Default: `0`
+
+### search-raw-docid-encoding
+
+Disable compression for DocID inverted indexes to boost CPU performance.
+
+Type: boolean
+
+Default: `FALSE`
+
+### search-threads
+
+Sets the number of search threads in the coordinator thread pool.
+
+Type: integer
+
+### search-tiered-hnsw-buffer-limit
+
+Used for setting the buffer limit threshold for vector tiered HNSW indexes. If Redis is using `WORKERS` for indexing, and the number of vectors waiting in the buffer to be indexed exceeds this limit, new vectors are inserted directly into HNSW.
+
+Type: integer
+
+Valid range: `[0 .. 9,223,372,036,854,775,807]`
+
+Default: `1024`
+
+### search-timeout
+
+The maximum amount of time in milliseconds that a search query is allowed to run. If this time is exceeded, Redis returns the top results accumulated so far, or an error depending on the policy set with [`search-on-timeout`](#search-on-timeout). The timeout can be disabled by setting it to `0`.
+
+{{% alert title="Notes" color="info" %}}
+* `search-timeout` refers to query time only.
+* Parsing the query is not counted towards `search-timeout`.
+* If `search-timeout` was not reached during the search, finalizing operations such as loading document content or reducers continue.
+{{% /alert %}}
+
+Type: integer
+
+Value range: `[1 .. 9,223,372,036,854,775,807]`
+
+Redis Open Source default: `500`
+
+Redis Software default: `500`
+
+Redis Cloud defaults:
+- Flexible & Annual: `500`
+- Free & Fixed: `100`
+
+### search-topology-validation-timeout
+
+Sets the timeout in milliseconds for topology validation. After this timeout, any pending requests will be processed, even if the topology is not fully connected. A value of `0` means no timeout.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `30000`
+
+### search-union-iterator-heap
+
+The minimum number of iterators in a union at which the iterator will switch to a heap based implementation.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `20`
+
+### search-upgrade-index
+
+Relevant only when loading an v1.x RDB file. Specify the argument for upgrading the index.
+This configuration setting is a special configuration option introduced to upgrade indexes from v1.x RQE versions, otherwise known as legacy indexes. This configuration option needs to be given for each legacy index, followed by the index name and all valid options for the index description (also referred to as the `ON` arguments for following hashes) as described on [FT.CREATE]({{< relref "/commands/ft.create/" >}}) command page. 
+
+Type: string
+
+Default: there is no default for index name, and the other arguments have the same defaults as with the [`FT.CREATE`]({{< relref "/commands/ft.create/" >}}) command.
+
+**Example**
+
+```
+search-upgrade-index idx PREFIX 1 tt LANGUAGE french LANGUAGE_FIELD MyLang SCORE 0.5 SCORE_FIELD MyScore
+    PAYLOAD_FIELD MyPayload UPGRADE_INDEX idx1
+```
+
+{{% alert title="Notes" color="info" %}}
+* If the RDB file does not contain a legacy index that's specified in the configuration, a warning message will be added to the log file, and loading will continue.
+* If the RDB file contains a legacy index that wasn't specified in the configuration, loading will fail and the server won't start.
+{{% /alert %}}
+
+### search-vss-max-resize
+
+Added in v2.4.8.
+
+The maximum memory resize (in bytes) for vector indexes.
+The maximum memory resize (in bytes) for vector indexes. This value will override default memory limits if you need to allow for a large [`BLOCK_SIZE`]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors/#creation-attributes-per-algorithm" >}}).
+
+Type: integer
+
+Valid range: `[0 .. 4,294,967,295]`
+
+Default: `0`
+
+### search-workers-priority-bias-threshold
+
+The number of high priority tasks to be executed at any given time by the worker thread pool before executing low priority tasks. After this number of high priority tasks are being executed, the worker thread pool will execute high and low priority tasks alternately.
+
+Type: integer
+
+Valid range: `[1 .. 9,223,372,036,854,775,807]`
+
+Default: `1`
+
+### search-workers
+
+The number of worker threads to use for query processing and background tasks.
+
+Type: integer
+
+Valid range: `[0 .. 8192]`
+
+Default: `0`
+
+## Set configuration parameters at module load-time (deprecated)
+
+These methods are deprecated beginning with Redis 8.
+
+Setting configuration parameters at load-time is done by appending arguments after the `--loadmodule` argument when starting a server from the command line, or after the `loadmodule` directive in a Redis config file. For example:
+
+In [redis.conf]({{< relref "/operate/oss_and_stack/management/config" >}}):
+
+```
+loadmodule ./redisearch.so [OPT VAL]...
+```
+
+From the [Redis CLI]({{< relref "/develop/tools/cli" >}}), using the [MODULE LOAD]({{< relref "/commands/module-load" >}}) command:
+
+```
+127.0.0.6379> MODULE LOAD redisearch.so [OPT VAL]...
+```
+
+From the command line:
+
+```
+$ redis-server --loadmodule ./redisearch.so [OPT VAL]...
+```
+
+## Set configuration parameters at run-time (for supported parameters, deprecated)
+
+These methods are deprecated beginning with Redis 8.
+
+RQE exposes the `FT.CONFIG` endpoint to allow for the setting and retrieval of configuration parameters at run-time.
+
+To set the value of a configuration parameter at run-time (for supported parameters), simply run:
+
+```sh
+FT.CONFIG SET OPT1 VAL1
+```
+
+Similarly, you can retrieve current configuration parameter values using:
+
+```sh
+FT.CONFIG GET OPT1
+FT.CONFIG GET *
+```
+
+Values set using [`FT.CONFIG SET`]({{< relref "/commands/ft.config-set/" >}}) are not persisted after server restart.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Details about design choices and implementations
+
+  '
+linkTitle: Internal design
+title: Internal design
+weight: 1
+---
+
+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).
+
+This feature is simple, yet very powerful. It allows modules to allocate data on Redis string keys, and then get direct pointers to the data allocated by the keys without copying or serializing.
+
+This allows very fast access to huge amounts of memory. From the module's perspective, the string value is exposed simply as `char *`, meaning it can be cast to any data structure.
+
+You simply call `RedisModule_StringTruncate` to resize a memory chunk to the size needed. Then you call `RedisModule_StringDMA` to get direct access to the memory in that key. See [https://github.com/RedisLabs/RedisModulesSDK/blob/master/FUNCTIONS.md#redismodule_stringdma](https://github.com/RedisLabs/RedisModulesSDK/blob/master/FUNCTIONS.md#redismodule_stringdma)
+
+This API is used in the module mainly to encode inverted indexes, and also for other auxiliary data structures.
+
+A generic "Buffer" implementation using DMA strings can be found in [buffer.c](https://github.com/RediSearch/RediSearch/blob/master/src/buffer.c). It automatically resizes the Redis string it uses as raw memory when the capacity needs to grow.
+
+## Inverted index encoding
+
+An [inverted index](https://en.wikipedia.org/wiki/Inverted_index) is the data structure at the heart of all search engines. The idea is simple. For each word or search term, a list of all the documents it appears in is kept. Other data is kept as well, such as term frequency, and the offsets where a term appeared in the document. Offsets are used for exact match type searches, or for ranking of results.
+
+When a search is performed, either a single index is traversed, or the intersection or union of two or more indexes is traversed. Classic Redis implementations of search engines use sorted sets as inverted indexes. This works but has significant memory overhead, and it also does not allow for encoding of offsets, as explained above.
+
+Redis Open Source uses string DMA (see above) to efficiently encode inverted indexes. It combines [delta encoding](https://en.wikipedia.org/wiki/Delta_encoding) and [varint encoding](https://developers.google.com/protocol-buffers/docs/encoding#varints) to encode entries, minimizing space used for indexes, while keeping decompression and traversal efficient.
+
+For each hit (document/word entry), the following items are encoded:
+
+* The document ID as a delta from the previous document.
+* The term frequency, factored by the document's rank (see below).
+* Flags, that can be used to filter only specific fields or other user-defined properties.
+* An offset vector of all the document offsets of the word.
+
+{{% alert title="Note" color="info" %}}
+Document IDs as entered by the user are converted to internal incremental document IDs, that allow delta encoding to be efficient and let the inverted indexes be sorted by document ID.
+{{% /alert %}}
+
+This allows for a single index hit entry to be encoded in as little as 6 bytes. Note: this is the best case. Depending on the number of occurrences of the word in the document, this can get much higher.
+
+To optimize searches, two additional auxiliary data structures are kept in different DMA string keys:
+
+1. **Skip index**: a table of the index offset of 1/50th of the index entries. This allows faster lookup when intersecting inverted indexes, as the entire list doesn't need to be traversed.
+2. **Score index**: In simple single-word searches, there is no real need to traverse all the results, just the top N results the user is interested in. So an auxiliary index of the top 20 or so entries is stored for each term, which are used when applicable.
+
+## Document and result ranking
+
+Each document entered to the engine has a [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) scoring of each word to rank the results.
+
+As an optimization, each inverted index hit is encoded with `TF * Document_rank` as its score, and only IDF is applied during searches. This may change in the future.
+
+On top of that, in the case of intersection queries, the minimal distance between the terms in the query is factored into the ranking. The closest the terms are to each other, the better the result.
+
+When searching, priority queue of the top N results requested is maintained, which are eventually returned, sorted by rank.
+
+## Index ppecs and field weights
+
+When creating an "index" using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}), the user specifies the fields to be indexed and their respective weights. This can be used to give some document fields, like a title, more weight in ranking results.
+
+For example:
+
+```
+FT.CREATE my_index title 10.0 body 1.0 url 2.0
+```
+
+will create an index on fields named title, body, and url, with scores of 10, 1, and 2 respectively.
+
+When documents are indexed, the weights are taken from the saved *index Spec* that is stored in a special Redis key, and only fields that appear in this spec are indexed.
+
+## Query execution engine
+
+A chained-iterator based approach is used as part of query execution, which is similar to [Python generators](https://wiki.python.org/moin/Generators) in concept.
+
+Iterators that yield index hits are chained together. Those can be:
+
+1. **Read Iterators**, reading hits one by one from an inverted index. For example, `hello`.
+2. **Intersect Iterators**, aggregating two or more iterators, yielding only their intersection points. For example, `hello AND world`.
+3. **Exact Intersect Iterators** - same as above, but yielding results only if the intersection is an exact phrase. For example,  `hello NEAR world`.
+4. **Union Iterators** - combining two or more iterators, and yielding a union of their hits. For example,  `hello OR world`.
+
+These are combined based on the query as an execution plan that is evaluated lazily. For example:
+
+```
+hello ==> read("hello")
+
+hello world ==> intersect( read("hello"), read("world") )
+
+"hello world" ==> exact_intersect( read("hello"), read("world") )
+
+"hello world" foo ==> intersect(
+                            exact_intersect(
+                                read("hello"),
+                                read("world")
+                            ),
+                            read("foo")
+                      )
+```
+
+All these iterators are lazily evaluated, entry by entry, with constant memory overhead.
+
+The root iterator is read by the query execution engine and filtered for the top N results contained in it.
+
+## Numeric filters
+
+It's possible to define a field in the index schema as `NUMERIC`, meaning you will be able to limit search results only to those where the given value falls within a specific range. Filtering is done by adding `FILTER` predicates (more than one is supported) to your query. For example:
+
+```
+FT.SEARCH products "hd tv" FILTER price 100 (300
+```
+
+The filter syntax follows the ZRANGEBYSCORE semantics of Redis, meaning `-inf` and `+inf` are supported, and prepending `(` to a number means an exclusive range.
+
+As of release 0.6, the implementation uses a multi-level range tree, saving ranges at multiple resolutions to allow efficient range scanning. Adding numeric filters can accelerate slow queries if the numeric range is small relative to the entire span of the filtered field. For example, a filter on dates focusing on a few days out of years of data can speed a heavy query by an order of magnitude.
+
+## Auto-complete and fuzzy suggestions
+
+Another important feature for searching and querying is auto-completion or suggestion. It allows you to create dictionaries of weighted terms, and then query them for completion suggestions to a given user prefix.  For example, if you put the term “lcd tv” into a dictionary, sending the prefix “lc” will return it as a result. The dictionary is modeled as a compressed trie (prefix tree) with weights, that is traversed to find the top suffixes of a prefix.
+
+Redis Open Source also allows for fuzzy suggestions, meaning you can get suggestions to user prefixes even if the user has a typo in the prefix. This is enabled using a Levenshtein automaton, allowing efficient searching of a dictionary for all terms within a maximal Levenshtein distance of a term or prefix. Suggestions are weighted based on both their original score and their distance from a prefix typed by the user. Only suggestions where the prefix is up to one Levenshtein distance away from the typed prefix are supported for performance reasons.
+
+However, since searching for fuzzy prefixes, especially very short ones, will traverse an enormous amount of suggestions (in fact, fuzzy suggestions for any single letter will traverse the entire dictionary!), it is recommended that you use this feature carefully, and only when considering the performance penalty it incurs. Since Redis is single threaded, blocking it for any amount of time means no other queries can be processed at that time.
+
+To support unicode fuzzy matching, 16-bit runes are used inside the trie and not bytes. This increases memory consumption if the text is purely ASCII, but allows completion with the same level of support to all modern languages. This is done in the following manner:
+
+1. Assume all input to `FT.SUG*` commands is valid UTF-8.
+2. Input strings are converted to 32-bit Unicode, optionally normalizing, case-folding, and removing accents on the way. If the conversion fails it's because the input is not valid UTF-8.
+3. The 32-bit runes are trimmed to 16-bit runes using the lower 16 bits. These can be used for insertion, deletion, and search.
+4. The output of searches is converted back to UTF-8.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis Query Engine Administration
+linkTitle: Administration
+title: Administration
+weight: 9
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Options for indexing geospatial data
+linkTitle: Geospatial
+title: Geospatial indexing
+weight: 3
+---
+
+Redis supports two different
+[schema types]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options" >}})
+for geospatial data:
+
+-   [`GEO`](#geo): This uses a simple format where individual geospatial
+    points are specified as numeric longitude-latitude pairs.
+-   [`GEOSHAPE`](#geoshape): This uses a subset of the 
+    [Well-Known Text (WKT)](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry)
+    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]({{< relref "/develop/interact/search-and-query/advanced-concepts/geo" >}})
+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`:
+
+{{< clients-example geoindex create_geo_idx >}}
+> FT.CREATE productidx ON JSON PREFIX 1 product: SCHEMA $.location AS location GEO
+OK
+{{< /clients-example >}}
+
+If you now add JSON objects with the `product:` prefix and a `location` field,
+they will be added to the index automatically:
+
+{{< clients-example geoindex add_geo_json >}}
+> JSON.SET product:46885 $ '{"description": "Navy Blue Slippers","price": 45.99,"city": "Denver","location": "-104.991531, 39.742043"}'
+OK
+> JSON.SET product:46886 $ '{"description": "Bright Green Socks","price": 25.50,"city": "Fort Collins","location": "-105.0618814,40.5150098"}'
+OK
+{{< /clients-example >}}
+
+The query below finds products within a 100 mile radius of Colorado Springs
+(Longitude=-104.800644, Latitude=38.846127). This returns only the location in
+Denver, but a radius of 200 miles would also include the location in Fort Collins:
+
+{{< clients-example geoindex geo_query >}}
+> FT.SEARCH productidx '@location:[-104.800644 38.846127 100 mi]'
+1) "1"
+2) "product:46885"
+3) 1) "$"
+   2) "{\"description\":\"Navy Blue Slippers\",\"price\":45.99,\"city\":\"Denver\",\"location\":\"-104.991531, 39.742043\"}"
+{{< /clients-example >}}
+
+See [Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information about the available options.
+
+## `GEOSHAPE`
+
+The following command creates an index for JSON objects that include
+geospatial data in a field called `geom`. The `FLAT` option at the end
+of the field definition specifies Cartesian coordinates instead of
+the default spherical geographical coordinates. Use `SPHERICAL` in
+place of `FLAT` to choose the coordinate space explicitly.
+
+{{< clients-example geoindex create_gshape_idx >}}
+> FT.CREATE geomidx ON JSON PREFIX 1 shape: SCHEMA $.name AS name TEXT $.geom AS geom GEOSHAPE FLAT
+OK
+{{< /clients-example >}}
+
+Use the `shape:` prefix for the JSON objects to add them to the index:
+
+{{< clients-example geoindex add_gshape_json >}}
+> JSON.SET shape:1 $ '{"name": "Green Square", "geom": "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"}'
+OK
+> JSON.SET shape:2 $ '{"name": "Red Rectangle", "geom": "POLYGON ((2 2.5, 2 3.5, 3.5 3.5, 3.5 2.5, 2 2.5))"}'
+OK
+> JSON.SET shape:3 $ '{"name": "Blue Triangle", "geom": "POLYGON ((3.5 1, 3.75 2, 4 1, 3.5 1))"}'
+OK
+> JSON.SET shape:4 $ '{"name": "Purple Point", "geom": "POINT (2 2)"}'
+OK
+{{< /clients-example >}}
+
+You can now run various geospatial queries against the index. For
+example, the query below returns any shapes within the boundary
+of the green square but omits the green square itself:
+
+{{< clients-example geoindex gshape_query >}}
+> FT.SEARCH geomidx "(-@name:(Green Square) @geom:[WITHIN $qshape])" PARAMS 2 qshape "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))" RETURN 1 name DIALECT 2
+
+1) (integer) 1
+2) "shape:4"
+3) 1) "name"
+   2) "[\"Purple Point\"]"
+{{< /clients-example >}}
+
+You can also run queries to find whether shapes in the index completely contain
+or overlap each other. See
+[Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+for more information.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to index and search JSON documents
+linkTitle: Indexing
+title: Indexing
+weight: 3
+---
+
+In addition to indexing Redis hashes, Redis Open Source can also index JSON documents.
+
+## Create index with JSON schema
+
+When you create an index with the [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) command, include the `ON JSON` keyword to index any existing and future JSON documents stored in the database.
+
+To define the `SCHEMA`, you can provide [JSONPath]({{< relref "/develop/data-types/json/path" >}}) expressions.
+The result of each JSONPath expression is indexed and associated with a logical name called an `attribute` (previously known as a `field`).
+You can use these attributes in queries.
+
+{{% alert title="Note" color="info" %}}
+Note: `attribute` is optional for [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+{{% /alert %}}
+
+Use the following syntax to create a JSON index:
+
+```sql
+FT.CREATE {index_name} ON JSON SCHEMA {json_path} AS {attribute} {type}
+```
+
+For example, this command creates an index that indexes the name, description, price, and image vector embedding of each JSON document that represents an inventory item:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx ON JSON PREFIX 1 item: SCHEMA $.name AS name TEXT $.description as description TEXT $.price AS price NUMERIC $.embedding AS embedding VECTOR FLAT 6 DIM 4 DISTANCE_METRIC L2 TYPE FLOAT32
+```
+
+See [Index limitations](#index-limitations) for more details about JSON index `SCHEMA` restrictions.
+
+## Add JSON documents
+
+After you create an index, Redis automatically indexes any existing, modified, or newly created JSON documents stored in the database. For existing documents, indexing runs asynchronously in the background, so it can take some time before the document is available. Modified and newly created documents are indexed synchronously, so the document will be available by the time the add or modify command finishes.
+
+You can use any JSON write command, such as [`JSON.SET`]({{< relref "commands/json.set/" >}}) and [`JSON.ARRAPPEND`]({{< relref "commands/json.arrappend/" >}}), to create or modify JSON documents.
+
+The following examples use these JSON documents to represent individual inventory items.
+
+Item 1 JSON document:
+
+```json
+{
+  "name": "Noise-cancelling Bluetooth headphones",
+  "description": "Wireless Bluetooth headphones with noise-cancelling technology",
+  "connection": {
+    "wireless": true,
+    "type": "Bluetooth"
+  },
+  "price": 99.98,
+  "stock": 25,
+  "colors": [
+    "black",
+    "silver"
+  ],
+  "embedding": [0.87, -0.15, 0.55, 0.03]
+}
+```
+
+Item 2 JSON document:
+
+```json
+{
+  "name": "Wireless earbuds",
+  "description": "Wireless Bluetooth in-ear headphones",
+  "connection": {
+    "wireless": true,
+    "type": "Bluetooth"
+  },
+  "price": 64.99,
+  "stock": 17,
+  "colors": [
+    "black",
+    "white"
+  ],
+  "embedding": [-0.7, -0.51, 0.88, 0.14]
+}
+```
+
+Use [`JSON.SET`]({{< relref "commands/json.set/" >}}) to store these documents in the database:
+
+```sql
+127.0.0.1:6379> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"],"embedding":[0.87,-0.15,0.55,0.03]}'
+"OK"
+127.0.0.1:6379> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":64.99,"stock":17,"colors":["black","white"],"embedding":[-0.7,-0.51,0.88,0.14]}'
+"OK"
+```
+
+Because indexing is synchronous in this case, the documents will be available on the index as soon as the [`JSON.SET`]({{< relref "commands/json.set/" >}}) command returns.
+Any subsequent queries that match the indexed content will return the document.
+
+## Search the index
+
+To search the index for JSON documents, use the [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command.
+You can search any attribute defined in the `SCHEMA`.
+
+For example, use this query to search for items with the word "earbuds" in the name:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@name:(earbuds)'
+1) "1"
+2) "item:2"
+3) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"connection\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embedding\":[-0.7,-0.51,0.88,0.14]}"
+```
+
+This query searches for all items that include "bluetooth" and "headphones" in the description:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(bluetooth headphones)'
+1) "2"
+2) "item:1"
+3) 1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"], \"embedding\":[0.87,-0.15,0.55,0.03]}"
+4) "item:2"
+5) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"connection\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embedding\":[-0.7,-0.51,0.88,0.14]}"
+```
+
+Now search for Bluetooth headphones with a price less than 70:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(bluetooth headphones) @price:[0 70]'
+1) "1"
+2) "item:2"
+3) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"connection\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embedding\":[-0.7,-0.51,0.88,0.14]}"
+```
+
+And lastly, search for the Bluetooth headphones that are most similar to an image whose embedding is [1.0, 1.0, 1.0, 1.0]:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(bluetooth headphones)=>[KNN 2 @embedding $blob]' PARAMS 2 blob \x01\x01\x01\x01 DIALECT 2
+1) "2"
+2) "item:1"
+3) 1) "__embedding_score"
+   2) "1.08280003071"
+   1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"embedding\":[0.87,-0.15,0.55,0.03]}"
+2) "item:2"
+3) 1) "__embedding_score"
+   2) "1.54409992695"
+   3) "$"
+   4) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"connection\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embedding\":[-0.7,-0.51,0.88,0.14]}"
+```
+
+For more information about search queries, see [Search query syntax]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax" >}}).
+
+{{% alert title="Note" color="info" %}}
+[`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) queries require `attribute` modifiers. Don't use JSONPath expressions in queries because the query parser doesn't fully support them.
+{{% /alert %}}
+
+## Index JSON arrays as TAG
+
+The preferred method for indexing a JSON field with multivalued terms is using JSON arrays. Each value of the array is indexed, and those values must be scalars. If you want to index string or boolean values as TAGs within a JSON array, use the [JSONPath]({{< relref "/develop/data-types/json/path" >}}) wildcard operator.
+
+To index an item's list of available colors, specify the JSONPath `$.colors.*` in the `SCHEMA` definition during index creation:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx2 ON JSON PREFIX 1 item: SCHEMA $.colors.* AS colors TAG $.name AS name TEXT $.description as description TEXT
+```
+
+Now you can search for silver headphones:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx2 "@colors:{silver} (@name:(headphones)|@description:(headphones))"
+1) "1"
+2) "item:1"
+3) 1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"]}"
+```
+
+## Index JSON arrays as TEXT
+Starting with RediSearch v2.6.0, full text search can be done on an array of strings or on a JSONPath leading to multiple strings.
+
+If you want to index multiple string values as TEXT, use either a JSONPath leading to a single array of strings, or a JSONPath leading to multiple string values, using JSONPath operators such as wildcard, filter, union, array slice, and/or recursive descent.
+
+To index an item's list of available colors, specify the JSONPath `$.colors` in the `SCHEMA` definition during index creation:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx3 ON JSON PREFIX 1 item: SCHEMA $.colors AS colors TEXT $.name AS name TEXT $.description as description TEXT
+```
+
+```sql
+127.0.0.1:6379> JSON.SET item:3 $ '{"name":"True Wireless earbuds","description":"True Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":74.99,"stock":20,"colors":["red","light blue"]}'
+"OK"
+```
+
+Now you can do full text search for light colored headphones:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx3 '@colors:(white|light) (@name|description:(headphones))' RETURN 1 $.colors
+1) (integer) 2
+2) "item:2"
+3) 1) "$.colors"
+   2) "[\"black\",\"white\"]"
+4) "item:3"
+5) 1) "$.colors"
+   2) "[\"red\",\"light blue\"]"
+```
+
+### Limitations
+- When a JSONPath may lead to multiple values and not only to a single array, e.g., when a JSONPath contains wildcards, etc., specifying `SLOP` or `INORDER` in [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) will return an error, since the order of the values matching the JSONPath is not well defined, leading to potentially inconsistent results.
+
+   For example, using a JSONPath such as `$..b[*]` on a JSON value such as
+   ```json
+   {
+      "a": [
+         {"b": ["first first", "first second"]},
+         {"c":
+            {"b": ["second first", "second second"]}},
+         {"b": ["third first", "third second"]}
+      ]
+   }
+   ```
+   may match values in various orderings, depending on the specific implementation of the JSONPath library being used.
+
+   Since `SLOP` and `INORDER` consider relative ordering among the indexed values, and results may change in future releases, an error will be returned.
+
+- When JSONPath leads to multiple values:
+  - String values are indexed
+  - `null` values are skipped
+  - Any other value type will cause an indexing failure
+
+- `SORTBY` only sorts by the first value
+- No `HIGHLIGHT` and `SUMMARIZE` support
+- `RETURN` of a Schema attribute, whose JSONPath leads to multiple values, returns only the first value (as a JSON String)
+- If a JSONPath is specified by the `RETURN`, instead of a Schema attribute, all values are returned (as a JSON String)
+
+### Handling phrases in different array slots:
+
+When indexing, a predefined delta is used to increase positional offsets between array slots for multiple text values. This delta controls the level of separation between phrases in different array slots (related to the `SLOP` parameter of [`FT.SEARCH`]({{< relref "commands/ft.search/" >}})).
+This predefined value is set by the configuration parameter `MULTI_TEXT_SLOP` (at module load-time). The default value is 100.
+
+## Index JSON arrays as NUMERIC
+
+Starting with RediSearch v2.6.1, search can be done on an array of numerical values or on a JSONPath leading to multiple numerical values.
+
+If you want to index multiple numerical values as NUMERIC, use either a JSONPath leading to a single array of numbers, or a JSONPath leading to multiple numbers, using JSONPath operators such as wildcard, filter, union, array slice, and/or recursive descent.
+
+For example, add to the item's list the available `max_level` of volume (in decibels):
+
+```sql
+127.0.0.1:6379> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"], "max_level":[60, 70, 80, 90, 100]}'
+OK
+
+127.0.0.1:6379> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":64.99,"stock":17,"colors":["black","white"], "max_level":[80, 100, 120]}'
+OK
+
+127.0.0.1:6379> JSON.SET item:3 $ '{"name":"True Wireless earbuds","description":"True Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":74.99,"stock":20,"colors":["red","light blue"], "max_level":[90, 100, 110, 120]}'
+OK
+```
+
+To index the `max_level` array, specify the JSONPath `$.max_level` in the `SCHEMA` definition during index creation:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx4 ON JSON PREFIX 1 item: SCHEMA $.max_level AS dB NUMERIC
+OK
+```
+
+You can now search for headphones with specific max volume levels, for example, between 70 and 80 (inclusive), returning items with at least one value in their `max_level` array, which is in the requested range:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx4 '@dB:[70 80]'
+1) (integer) 2
+2) "item:1"
+3) 1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[60,70,80,90,100]}"
+4) "item:2"
+5) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"max_level\":[80,100,120]}"
+```
+
+You can also search for items with all values in a specific range. For example, all values are in the range [90, 120] (inclusive):
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx4 '-@dB:[-inf (90] -@dB:[(120 +inf]'
+1) (integer) 1
+2) "item:3"
+3) 1) "$"
+   2) "{\"name\":\"True Wireless earbuds\",\"description\":\"True Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":74.99,\"stock\":20,\"colors\":[\"red\",\"light blue\"],\"max_level\":[90,100,110,120]}"
+```
+
+### Limitations
+
+When JSONPath leads to multiple numerical values:
+  - Numerical values are indexed
+  - `null` values are skipped
+  - Any other value type will cause an indexing failure
+
+## Index JSON arrays as GEO and GEOSHAPE
+
+You can use `GEO` and `GEOSHAPE` fields to store geospatial data,
+such as geographical locations and geometric shapes. See
+[Geospatial indexing]({{< relref "/develop/interact/search-and-query/indexing/geoindex" >}})
+to learn how to use these schema types and see the
+[Geospatial]({{< relref "/develop/interact/search-and-query/advanced-concepts/geo" >}})
+reference page for an introduction to their format and usage.
+
+## Index JSON arrays as VECTOR
+
+Starting with RediSearch 2.6.0, you can index a JSONPath leading to an array of numeric values as a VECTOR type in the index schema.
+
+For example, assume that your JSON items include an array of vector embeddings, where each vector represents an image of a product. To index these vectors, specify the JSONPath `$.embedding` in the schema definition during index creation:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx5 ON JSON PREFIX 1 item: SCHEMA $.embedding AS embedding VECTOR FLAT 6 DIM 4 DISTANCE_METRIC L2 TYPE FLOAT32
+OK
+127.0.0.1:6379> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","price":99.98,"stock":25,"colors":["black","silver"],"embedding":[0.87,-0.15,0.55,0.03]}'
+OK
+127.0.0.1:6379> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","price":64.99,"stock":17,"colors":["black","white"],"embedding":[-0.7,-0.51,0.88,0.14]}'
+OK
+```
+
+Now you can search for the two headphones that are most similar to the image embedding by using vector search KNN query. (Note that the vector queries are supported as of dialect 2.) For example:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx5 '*=>[KNN 2 @embedding $blob AS dist]' SORTBY dist PARAMS 2 blob \x01\x01\x01\x01 DIALECT 2
+1) (integer) 2
+2) "item:1"
+3) 1) "dist"
+   2) "1.08280003071"
+   3) "$"
+   4) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"embedding\":[0.87,-0.15,0.55,0.03]}"
+4) "item:2"
+5) 1) "dist"
+   2) "1.54409992695"
+   3) "$"
+   4) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embedding\":[-0.7,-0.51,0.88,0.14]}"
+```
+
+If you want to index multiple numeric arrays as VECTOR, use a [JSONPath]({{< relref "/develop/data-types/json/path" >}}) leading to multiple numeric arrays using JSONPath operators such as wildcard, filter, union, array slice, and/or recursive descent.
+
+For example, assume that your JSON items include an array of vector embeddings, where each vector represents a different image of the same product. To index these vectors, specify the JSONPath `$.embeddings[*]` in the schema definition during index creation:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx5 ON JSON PREFIX 1 item: SCHEMA $.embeddings[*] AS embeddings VECTOR FLAT 6 DIM 4 DISTANCE_METRIC L2 TYPE FLOAT32
+OK
+127.0.0.1:6379> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","price":99.98,"stock":25,"colors":["black","silver"],"embeddings":[[0.87,-0.15,0.55,0.03]]}'
+OK
+127.0.0.1:6379> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","price":64.99,"stock":17,"colors":["black","white"],"embeddings":[[-0.7,-0.51,0.88,0.14],[-0.8,-0.15,0.33,-0.01]]}'
+OK
+```
+
+{{% alert title="Important note" color="info" %}}
+Unlike the case with the NUMERIC type, setting a static path such as `$.embedding` in the schema for the VECTOR type does not allow you to index multiple vectors stored under that field. Hence, if you set `$.embedding` as the path to the index schema, specifying an array of vectors in the `embedding` field in your JSON will cause an indexing failure.
+{{% /alert %}}
+
+Now you can search for the two headphones that are most similar to an image embedding by using vector search KNN query. (Note that the vector queries are supported as of dialect 2.) The distance between a document to the query vector is defined as the minimum distance between the query vector to a vector that matches the JSONPath specified in the schema. For example:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx5 '*=>[KNN 2 @embeddings $blob AS dist]' SORTBY dist PARAMS 2 blob \x01\x01\x01\x01 DIALECT 2
+1) (integer) 2
+2) "item:2"
+3) 1) "dist"
+   2) "0.771500051022"
+   3) "$"
+   4) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"],\"embeddings\":[[-0.7,-0.51,0.88,0.14],[-0.8,-0.15,0.33,-0.01]]}"
+4) "item:1"
+5) 1) "dist"
+   2) "1.08280003071"
+   3) "$"
+   4) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"embeddings\":[[0.87,-0.15,0.55,0.03]]}"
+```
+Note that `0.771500051022` is the L2 distance between the query vector and `[-0.8,-0.15,0.33,-0.01]`, which is the second element in the embedding array, and it is lower than the L2 distance between the query vector and `[-0.7,-0.51,0.88,0.14]`, which is the first element in the embedding array.
+
+For more information on vector similarity syntax, see [Vector fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+
+## Index JSON objects
+
+You cannot index JSON objects. If the JSONPath expression returns an object, it will be ignored.
+
+To index the contents of a JSON object, you need to index the individual elements within the object in separate attributes.
+
+For example, to index the `connection` JSON object, define the `$.connection.wireless` and `$.connection.type` fields as separate attributes when you create the index:
+
+```sql
+127.0.0.1:6379> FT.CREATE itemIdx3 ON JSON SCHEMA $.connection.wireless AS wireless TAG $.connection.type AS connectionType TEXT
+"OK"
+```
+
+After you create the new index, you can search for items with the wireless TAG set to `true`:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx3 '@wireless:{true}'
+1) "2"
+2) "item:2"
+3) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"connection\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"]}"
+4) "item:1"
+5) 1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"]}"
+```
+
+You can also search for items with a Bluetooth connection type:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx3 '@connectionType:(bluetooth)'
+1) "2"
+2) "item:1"
+3) 1) "$"
+   2) "{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"]}"
+4) "item:2"
+5) 1) "$"
+   2) "{\"name\":\"Wireless earbuds\",\"description\":\"Wireless Bluetooth in-ear headphones\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":64.99,\"stock\":17,\"colors\":[\"black\",\"white\"]}"
+```
+
+## Field projection
+
+[`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) returns the entire JSON document by default. If you want to limit the returned search results to specific attributes, you can use field projection.
+
+### Return specific attributes
+
+When you run a search query, you can use the `RETURN` keyword to specify which attributes you want to include in the search results. You also need to specify the number of fields to return.
+
+For example, this query only returns the `name` and `price` of each set of headphones:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(headphones)' RETURN 2 name price
+1) "2"
+2) "item:1"
+3) 1) "name"
+   2) "Noise-cancelling Bluetooth headphones"
+   3) "price"
+   4) "99.98"
+4) "item:2"
+5) 1) "name"
+   2) "Wireless earbuds"
+   3) "price"
+   4) "64.99"
+```
+
+### Project with JSONPath
+
+You can use [JSONPath]({{< relref "/develop/data-types/json/path" >}}) expressions in a `RETURN` statement to extract any part of the JSON document, even fields that were not defined in the index `SCHEMA`.
+
+For example, the following query uses the JSONPath expression `$.stock` to return each item's stock in addition to the name and price attributes.
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(headphones)' RETURN 3 name price $.stock
+1) "2"
+2) "item:1"
+3) 1) "name"
+   2) "Noise-cancelling Bluetooth headphones"
+   3) "price"
+   4) "99.98"
+   5) "$.stock"
+   6) "25"
+4) "item:2"
+5) 1) "name"
+   2) "Wireless earbuds"
+   3) "price"
+   4) "64.99"
+   5) "$.stock"
+   6) "17"
+```
+
+Note that the returned property name is the JSONPath expression itself: `"$.stock"`.
+
+You can use the `AS` option to specify an alias for the returned property:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '@description:(headphones)' RETURN 5 name price $.stock AS stock
+1) "2"
+2) "item:1"
+3) 1) "name"
+   2) "Noise-cancelling Bluetooth headphones"
+   3) "price"
+   4) "99.98"
+   5) "stock"
+   6) "25"
+4) "item:2"
+5) 1) "name"
+   2) "Wireless earbuds"
+   3) "price"
+   4) "64.99"
+   5) "stock"
+   6) "17"
+```
+
+This query returns the field as the alias `"stock"` instead of the JSONPath expression `"$.stock"`.
+
+### Highlight search terms
+
+You can [highlight]({{< relref "/develop/interact/search-and-query/advanced-concepts/highlight" >}}) relevant search terms in any indexed `TEXT` attribute.
+
+For [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}), you have to explicitly set which attributes you want highlighted after the `RETURN` and `HIGHLIGHT` parameters.
+
+Use the optional `TAGS` keyword to specify the strings that will surround (or highlight) the matching search terms.
+
+For example, highlight the word "bluetooth" with bold HTML tags in item names and descriptions:
+
+```sql
+127.0.0.1:6379> FT.SEARCH itemIdx '(@name:(bluetooth))|(@description:(bluetooth))' RETURN 3 name description price HIGHLIGHT FIELDS 2 name description TAGS '<b>' '</b>'
+1) "2"
+2) "item:1"
+3) 1) "name"
+   2) "Noise-cancelling <b>Bluetooth</b> headphones"
+   3) "description"
+   4) "Wireless <b>Bluetooth</b> headphones with noise-cancelling technology"
+   5) "price"
+   6) "99.98"
+4) "item:2"
+5) 1) "name"
+   2) "Wireless earbuds"
+   3) "description"
+   4) "Wireless <b>Bluetooth</b> in-ear headphones"
+   5) "price"
+   6) "64.99"
+```
+
+## Aggregate with JSONPath
+
+You can use [aggregation]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations" >}}) to generate statistics or build facet queries.
+
+The `LOAD` option accepts [JSONPath]({{< relref "/develop/data-types/json/path" >}}) expressions. You can use any value in the pipeline, even if the value is not indexed.
+
+This example uses aggregation to calculate a 10% price discount for each item and sorts the items from least expensive to most expensive:
+
+```sql
+127.0.0.1:6379> FT.AGGREGATE itemIdx '*' LOAD 4 name $.price AS originalPrice APPLY '@originalPrice - (@originalPrice * 0.10)' AS salePrice SORTBY 2 @salePrice ASC
+1) "2"
+2) 1) "name"
+   2) "Wireless earbuds"
+   3) "originalPrice"
+   4) "64.99"
+   5) "salePrice"
+   6) "58.491"
+3) 1) "name"
+   2) "Noise-cancelling Bluetooth headphones"
+   3) "originalPrice"
+   4) "99.98"
+   5) "salePrice"
+   6) "89.982"
+```
+
+{{% alert title="Note" color="info" %}}
+[`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) queries require `attribute` modifiers. Don't use JSONPath expressions in queries, except with the `LOAD` option, because the query parser doesn't fully support them.
+{{% /alert %}}
+
+## Index missing or empty values
+As of v2.10, you can search for missing properties, that is, properties that do not exist in a given document, using the `INDEXMISSING` option to `FT.CREATE` in conjunction with the `ismissing` query function with `FT.SEARCH`. You can also search for existing properties with no value (i.e., empty) using the `INDEXEMPTY` option with `FT.CREATE`. Both query types require DIALECT 2. Examples below:
+
+```
+JSON.SET key:1 $ '{"propA": "foo"}'
+JSON.SET key:2 $ '{"propA": "bar", "propB":"abc"}'
+FT.CREATE idx ON JSON PREFIX 1 key: SCHEMA $.propA AS propA TAG $.propB AS propB TAG INDEXMISSING
+
+> FT.SEARCH idx 'ismissing(@propB)' DIALECT 2
+1) "1"
+2) "key:1"
+3) 1) "$"
+   2) "{\"propA\":\"foo\"}"
+```
+
+```
+JSON.SET key:1 $ '{"propA": "foo", "propB":""}'
+JSON.SET key:2 $ '{"propA": "bar", "propB":"abc"}'
+FT.CREATE idx ON JSON PREFIX 1 key: SCHEMA $.propA AS propA TAG $.propB AS propB TAG INDEXEMPTY
+
+> FT.SEARCH idx '@propB:{""}' DIALECT 2
+1) "1"
+2) "key:1"
+3) 1) "$"
+   2) "{\"propA\":\"foo\",\"propB\":\"\"}"
+```
+
+## Index limitations
+
+### Schema mapping
+
+During index creation, you need to map the JSON elements to `SCHEMA` fields as follows:
+
+- Strings as `TEXT`, `TAG`, or `GEO`.
+- Numbers as `NUMERIC`.
+- Booleans as `TAG`.
+- JSON array
+  - Array of strings as `TAG` or `TEXT`.
+  - Array of numbers as `NUMERIC` or `VECTOR`.
+  - Array of geo coordinates as `GEO`.
+  - `null` values in such arrays are ignored.
+- You cannot index JSON objects. Index the individual elements as separate attributes instead.
+- `null` values are ignored.
+
+### Sortable tags
+
+If you create an index for JSON documents with a JSONPath leading to an array or to multiple values, only the first value is considered by the sort.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Query for data based on vector embeddings
+linkTitle: Vector
+title: Vector search
+weight: 5
+---
+
+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]({{< relref "/develop/get-started/vector-database" >}}) 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]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+
+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.
+
+The examples in this article use a schema with the following fields:
+
+| JSON field               | Field alias | Field type  | Description |
+| ------------------------ | ----------- | ----------- | ----------- |
+| `$.description`            | `description` | `TEXT`        | The description of a bicycle as unstructured text |
+| `$.description_embeddings` | `vector`      | `VECTOR`      | The vector that a machine learning model derived from the description text | 
+
+## K-neareast neighbours (KNN)
+
+The Redis command [FT.SEARCH]({{< relref "commands/ft.search" >}}) takes the index name, the query string, and additional query parameters as arguments. You need to pass the number of nearest neighbors, the vector field name, and the vector's binary representation in the following way:
+
+```
+FT.SEARCH index "(*)=>[KNN num_neighbours @field $vector]" PARAMS 2 vector "binary_data" DIALECT 2
+```
+
+Here is a more detailed explanation of this query:
+
+1. **Pre-filter**: The first expression within the round brackets is a filter. It allows you to decide which vectors should be taken into account before the vector search is performed. The expression `(*)` means that all vectors are considered.
+2. **Next step**: The `=>` arrow indicates that the pre-filtering happens before the vector search.
+3. **KNN query**: The expression `[KNN num_neighbours @field $vector]` is a parameterized query expression. A parameter name is indicated by the `$` prefix within the query string.
+4. **Vector binary data**: You need to use the `PARAMS` argument to substitute `$vector` with the binary representation of the vector. The value `2` indicates that `PARAMS` is followed by two arguments, the parameter name `vector` and the parameter value.
+5. **Dialect**: The vector search feature has been available since version two of the query dialect.
+
+You can read more about the `PARAMS` argument in the [FT.SEARCH]({{< relref "commands/ft.search" >}}) command reference.
+
+The following example shows you how to query for three bikes based on their description embeddings, and by using the field alias `vector`. The result is returned in ascending order based on the distance. You can see that the query only returns the fields `__vector_score` and `description`. The field `__vector_score` is present by default. Because you can have multiple vector fields in your schema, the vector score field name depends on the name of the vector field. If you change the field name `@vector` to `@foo`, the score field name changes to `__foo_score`.
+
+{{< clients-example query_vector vector1 >}}
+FT.SEARCH idx:bikes_vss "(*)=>[KNN 3 @vector $query_vector]" PARAMS 2 "query_vector" "Z\xf8\x15:\xf23\xa1\xbfZ\x1dI>\r\xca9..." SORTBY "__vector_score" ASC RETURN 2 "__vector_score" "description" DIALECT 2
+{{< /clients-example >}}
+
+<!-- Python query>
+query = (
+    Query('(*)=>[KNN 3 @vector $query_vector]')
+     .sort_by('__vector_score')
+     .return_fields('__vector_score', 'description')
+     .dialect(2)
+)
+</!-->
+
+{{% alert title="Note" color="warning" %}}
+The binary value of the query vector is significantly shortened in the CLI example above.
+{{% /alert  %}}
+
+
+## Radius
+
+Instead of the number of nearest neighbors, you need to pass the radius along with the index name, the vector field name, and the vector's binary value:
+
+```
+FT.SEARCH index "@field:[VECTOR_RANGE radius $vector]" PARAMS 2 vector "binary_data" DIALECT 2
+```
+
+If you want to sort by distance, then you must yield the distance via the range query parameter `$YIELD_DISTANCE_AS`:
+
+```
+FT.SEARCH index "@field:[VECTOR_RANGE radius $vector]=>{$YIELD_DISTANCE_AS: dist_field}" PARAMS 2 vector "binary_data" SORTBY dist_field DIALECT 2
+```
+
+Here is a more detailed explanation of this query:
+
+1. **Range query**: the syntax of a radius query is very similar to the regular range query, except for the keyword `VECTOR_RANGE`. You can also combine a vector radius query with other queries in the same way as regular range queries.  See [combined queries article]({{< relref "/develop/interact/search-and-query/query/combined" >}}) for more details.
+2. **Additional step**: the `=>` arrow means that the range query is followed by evaluating additional parameters.
+3. **Range query parameters**: parameters such as `$YIELD_DISTANCE_AS` can be found in the [vectors reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+4. **Vector binary data**: you need to use `PARAMS` to pass the binary representation of the vector.
+5. **Dialect**: vector search has been available since version two of the query dialect.
+
+
+{{% alert title="Note" color="warning" %}}
+By default, [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) returns only the first ten results. The [range query article]({{< relref "/develop/interact/search-and-query/query/range" >}}) explains to you how to scroll through the result set.
+{{% /alert  %}}
+
+The example below shows a radius query that returns the description and the distance within a radius of `0.5`. The result is sorted by the distance.
+
+{{< clients-example query_vector vector2 >}}
+FT.SEARCH idx:bikes_vss "@vector:[VECTOR_RANGE 0.5 $query_vector]=>{$YIELD_DISTANCE_AS: vector_dist}" PARAMS 2 "query_vector" "Z\xf8\x15:\xf23\xa1\xbfZ\x1dI>\r\xca9..." SORTBY vector_dist ASC RETURN 2 vector_dist description DIALECT 2
+{{< /clients-example >}}
+
+<!-- Python query>
+query = (
+    Query('@vector:[VECTOR_RANGE 0.5 $query_vector]=>{$YIELD_DISTANCE_AS: vector_dist}')
+     .sort_by('vector_dist')
+     .return_fields('vector_dist', 'description')
+     .dialect(2)
+)
+</!-->---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Perform simple exact match queries
+linkTitle: Exact match
+title: Exact match queries
+weight: 1
+---
+
+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]({{< relref "/develop/get-started/document-database" >}}).
+
+## Numeric field
+
+To perform an exact match query on a numeric field, you need to construct a range query with the same start and end value:
+
+```
+FT.SEARCH index "@field:[value value]"
+
+or
+
+FT.SEARCH index "@field:[value]" DIALECT 2 # requires v2.10
+
+or
+
+FT.SEARCH index "@field==value" DIALECT 2 # requires v2.10
+```
+
+As described in the [article about range queries]({{< relref "/develop/interact/search-and-query/query/range" >}}), you can also use the `FILTER` argument:
+
+```
+FT.SEARCH index "*" FILTER field start end
+```
+
+The following examples show you how to query for bicycles with a price of exactly 270 USD:
+
+{{< clients-example query_em em1 >}}
+> FT.SEARCH idx:bicycle "@price:[270 270]"
+1) (integer) 1
+2) "bicycle:0"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, ...
+
+> FT.SEARCH idx:bicycle "@price:[270]" # requires v2.10
+1) (integer) 1
+2) "bicycle:0"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, ...
+
+> FT.SEARCH idx:bicycle "@price==270" # requires v2.10
+1) (integer) 1
+2) "bicycle:0"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, ...
+
+> FT.SEARCH idx:bicycle "*" FILTER price 270 270
+1) (integer) 1
+2) "bicycle:0"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, ...
+{{< /clients-example >}}
+
+
+## Tag field
+
+A tag is a short sequence of text, for example, "new" or "Los Angeles". 
+
+{{% alert title="Important" color="warning" %}}
+If you need to query for short texts, use a tag query instead of a full-text query. Tag fields are more space-efficient for storing index entries and often lead to lower query complexity for exact match queries.
+{{% /alert  %}}
+
+You can construct a tag query for a single tag in the following way:
+
+```
+FT.SEARCH index "@field:{tag}"
+```
+
+{{% alert title="Note" color="warning" %}}
+The curly brackets are mandatory for tag queries.
+{{% /alert  %}}
+
+This short example shows you how to query for new bicycles:
+
+{{< clients-example query_em em2 >}}
+> FT.SEARCH idx:bicycle "@condition:{new}"
+ 1) (integer) 5
+ 2) "bicycle:0"
+ 3) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))\",\"store_location\":\"-74.0060,40.7128\",\"brand\":\"Velorim\",\"model\":\"Jigger\",\"price\":270,\"description\":\"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\xe2\x80\x99 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\",\"condition\":\"new\"}"
+ 4) "bicycle:5"
+ 5) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((-0.1778 51.5524, 0.0822 51.5524, 0.0822 51.4024, -0.1778 51.4024, -0.1778 51.5524))\",\"store_location\":\"-0.1278,51.5074\",\"brand\":\"Breakout\",\"model\":\"XBN 2.1 Alloy\",\"price\":810,\"description\":\"The XBN 2.1 Alloy is our entry-level road bike \xe2\x80\x93 but that\xe2\x80\x99s not to say that it\xe2\x80\x99s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\xe2\x80\x99s, this is a bike which doesn\xe2\x80\x99t break the bank and delivers craved performance.\",\"condition\":\"new\"}"
+ 6) "bicycle:6"
+ 7) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((2.1767 48.9016, 2.5267 48.9016, 2.5267 48.5516, 2.1767 48.5516, 2.1767 48.9016))\",\"store_location\":\"2.3522,48.8566\",\"brand\":\"ScramBikes\",\"model\":\"WattBike\",\"price\":2300,\"description\":\"The WattBike is the best e-bike for people who still feel young at heart. It has a Bafang 1000W mid-drive system and a 48V 17.5AH Samsung Lithium-Ion battery, allowing you to ride for more than 60 miles on one charge. It\xe2\x80\x99s great for tackling hilly terrain or if you just fancy a more leisurely ride. With three working modes, you can choose between E-bike, assisted bicycle, and normal bike modes.\",\"condition\":\"new\"}"
+ 8) "bicycle:7"
+ 9) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((13.3260 52.5700, 13.6550 52.5700, 13.6550 52.2700, 13.3260 52.2700, 13.3260 52.5700))\",\"store_location\":\"13.4050,52.5200\",\"brand\":\"Peaknetic\",\"model\":\"Secto\",\"price\":430,\"description\":\"If you struggle with stiff fingers or a kinked neck or back after a few minutes on the road, this lightweight, aluminum bike alleviates those issues and allows you to enjoy the ride. From the ergonomic grips to the lumbar-supporting seat position, the Roll Low-Entry offers incredible comfort. The rear-inclined seat tube facilitates stability by allowing you to put a foot on the ground to balance at a stop, and the low step-over frame makes it accessible for all ability and mobility levels. The saddle is very soft, with a wide back to support your hip joints and a cutout in the center to redistribute that pressure. Rim brakes deliver satisfactory braking control, and the wide tires provide a smooth, stable ride on paved roads and gravel. Rack and fender mounts facilitate setting up the Roll Low-Entry as your preferred commuter, and the BMX-like handlebar offers space for mounting a flashlight, bell, or phone holder.\",\"condition\":\"new\"}"
+10) "bicycle:8"
+11) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((1.9450 41.4301, 2.4018 41.4301, 2.4018 41.1987, 1.9450 41.1987, 1.9450 41.4301))\",\"store_location\":\"2.1734, 41.3851\",\"brand\":\"nHill\",\"model\":\"Summit\",\"price\":1200,\"description\":\"This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail in mountains on the weekends or you\xe2\x80\x99re just after a stable, comfortable ride for the bike path, the Summit gives a good value for money.\",\"condition\":\"new\"}"
+{{< /clients-example >}}
+
+Use double quotes and [DIALECT 2]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}#dialect-2) for exact match queries involving tags that contain special characters. As of v2.10, the only character that needs escaping in queries involving double-quoted tags is the double-quote character. Here's an example of using double-quoted tags that contain special characters:
+
+{{< clients-example query_em em3 >}}
+> FT.CREATE idx:email ON JSON PREFIX 1 key: SCHEMA $.email AS email TAG
+OK
+> JSON.SET key:1 $ '{"email": "test@redis.com"}'
+OK
+> FT.SEARCH idx:email '@email:{"test@redis.com"}' DIALECT 2
+1) (integer) 1
+2) "key:1"
+3) 1) "$"
+   2) "{\"email\":\"test@redis.com\"}"
+{{< /clients-example>}}
+
+## Full-text field
+
+A detailed explanation of full-text queries is available in the [full-text queries documentation]({{< relref "/develop/interact/search-and-query/query/full-text" >}}). You can also query for an exact match of a phrase within a text field:
+
+```
+FT.SEARCH index "@field:\"phrase\""
+```
+
+{{% alert title="Important" color="warning" %}}
+The phrase must be wrapped by escaped double quotes for an exact match query.
+
+You can't use a phrase that starts with a [stop word]({{< relref "/develop/interact/search-and-query/advanced-concepts/stopwords" >}}).
+{{% /alert  %}}
+
+Here is an example for finding all bicycles that have a description containing the exact text 'rough terrain':
+
+{{< clients-example query_em em4 >}}
+FT.SEARCH idx:bicycle "@description:\"rough terrain\""
+1) (integer) 1
+2) "bicycle:8"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((1.9450 41.4301, 2.4018 41.4301, 2.4018 41.1987, 1.9450 41.1987, 1.9450 41.4301))\",\"store_location\":\"2.1734, 41.3851\",\"brand\":\"nHill\",\"model\":\"Summit\",\"price\":1200,\"description\":\"This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail in mountains on the weekends or you\xe2\x80\x99re just after a stable, comfortable ride for the bike path, the Summit gives a good value for money.\",\"condition\":\"new\"}"
+{{< /clients-example >}}---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Combine query expressions
+linkTitle: Combined
+title: Combined queries
+weight: 9
+---
+
+A combined query is a combination of several query types, such as:
+
+* [Exact match]({{< relref "/develop/interact/search-and-query/query/exact-match" >}})
+* [Range]({{< relref "/develop/interact/search-and-query/query/range" >}})
+* [Full-text]({{< relref "/develop/interact/search-and-query/query/full-text" >}})
+* [Geospatial]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+* [Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+
+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.
+
+{{% alert title="Note" color="warning" %}}
+The operators are interpreted slightly differently depending on the query dialect used. The default dialect is `DIALECT 1`; see [this article]({{< relref "/develop/interact/search-and-query/administration/configuration#search-default-dialect" >}}) 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]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax" >}}). 
+{{% /alert  %}}
+
+The examples in this article use the following schema:
+
+| Field name    | Field type   |
+| -----------   | ----------   |
+| `description` | `TEXT`       |
+| `condition`   | `TAG`        |
+| `price`       | `NUMERIC`    |
+| `vector`      | `VECTOR`     |
+
+## AND
+
+The binary operator ` ` (space) is used to intersect the results of two or more expressions.
+
+```
+FT.SEARCH index "(expr1) (expr2)"
+```
+
+If you want to perform an intersection based on multiple values within a specific text field, then you should use the following simplified notion:
+
+```
+FT.SEARCH index "@text_field:( value1 value2 ... )"
+```
+
+The following example shows you a query that finds bicycles in new condition and in a price range from 500 USD to 1000 USD:
+
+{{< clients-example query_combined combined1 >}}
+FT.SEARCH idx:bicycle "@price:[500 1000] @condition:{new}"
+{{< /clients-example >}}
+
+You might also be interested in bicycles for kids. The query below shows you how to combine a full-text search with the criteria from the previous query:
+
+{{< clients-example query_combined combined2 >}}
+FT.SEARCH idx:bicycle "kids (@price:[500 1000] @condition:{used})"
+{{< /clients-example >}}
+
+## OR
+
+You can use the binary operator `|` (vertical bar) to perform a union.
+
+```
+FT.SEARCH index "(expr1) | (expr2)"
+```
+
+{{% alert title="Note" color="warning" %}}
+The logical `AND` takes precedence over `OR` when using dialect version two. The expression `expr1 expr2 | expr3 expr4` means `(expr1 expr2) | (expr3 expr4)`. Version one of the query dialect behaves differently. Using parentheses in query strings is advised to ensure the order is clear.
+ {{% /alert  %}}
+
+
+If you want to perform the union based on multiple values within a single tag or text field, then you should use the following simplified notion:
+
+```
+FT.SEARCH index "@text_field:( value1 | value2 | ... )"
+```
+
+```
+FT.SEARCH index "@tag_field:{ value1 | value2 | ... }"
+```
+
+The following query shows you how to find used bicycles that contain either the word 'kids' or 'small':
+
+{{< clients-example query_combined combined3 >}}
+FT.SEARCH idx:bicycle "(kids | small) @condition:{used}"
+{{< /clients-example >}}
+
+The previous query searches across all text fields. The following example shows you how to limit the search to the description field:
+
+{{< clients-example query_combined combined4 >}}
+FT.SEARCH idx:bicycle "@description:(kids | small) @condition:{used}"
+{{< /clients-example >}}
+
+If you want to extend the search to new bicycles, then the below example shows you how to do that:
+
+{{< clients-example query_combined combined5 >}}
+FT.SEARCH idx:bicycle "@description:(kids | small) @condition:{new | used}"
+{{< /clients-example >}}
+
+## NOT
+
+A minus (`-`) in front of a query expression negates the expression.
+
+```
+FT.SEARCH index "-(expr)"
+```
+
+If you want to exclude new bicycles from the search within the previous price range, you can use this query:
+
+{{< clients-example query_combined combined6 >}}
+FT.SEARCH idx:bicycle "@price:[500 1000] -@condition:{new}"
+{{< /clients-example >}}
+
+## Numeric filter
+
+The [FT.SEARCH]({{< relref "commands/ft.search" >}}) command allows you to combine any query expression with a numeric filter.
+
+```
+FT.SEARCH index "expr" FILTER numeric_field start end
+```
+
+Please see the [range query article]({{< relref "/develop/interact/search-and-query/query/range" >}}) to learn more about numeric range queries and such filters.
+
+
+## Pre-filter for a KNN  vector query
+
+You can use a simple or more complex query expression with logical operators as a pre-filter in a KNN vector query. 
+
+```
+FT.SEARCH index "(filter_expr)=>[KNN num_neighbours @field $vector]" PARAMS 2 vector "binary_data" DIALECT 2
+```
+
+Here is an example:
+
+{{< clients-example query_combined combined7 >}}
+FT.SEARCH idx:bikes_vss "(@price:[500 1000] @condition:{new})=>[KNN 3 @vector $query_vector]" PARAMS 2 "query_vector" "Z\xf8\x15:\xf23\xa1\xbfZ\x1dI>\r\xca9..." DIALECT 2
+{{< /clients-example >}}
+
+The [vector search article]({{< relref "/develop/interact/search-and-query/query/vector-search" >}}) provides further details about vector queries in general.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Query based on geographic data
+linkTitle: Geospatial
+title: Geospatial queries
+weight: 4
+---
+
+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`   |
+
+
+{{% alert title="Note" color="warning" %}}
+Redis version 7.2.0 or higher is required to use the `GEOSHAPE` field type.
+{{% /alert  %}}
+
+## Radius
+
+You can construct a radius query by passing the center coordinates (longitude, latitude), the radius, and the distance unit to the [FT.SEARCH]({{< relref "commands/ft.search" >}}) command.
+
+```
+FT.SEARCH index "@geo_field:[lon lat radius unit]"
+```
+
+Allowed units are `m`, `km`, `mi`, and `ft`.
+
+The following query finds all bicycle stores within a radius of 20 miles around London:
+
+{{< clients-example query_geo geo1 >}}
+FT.SEARCH idx:bicycle "@store_location:[-0.1778 51.5524 20 mi]"
+{{< /clients-example >}}
+
+## Shape
+
+The only supported shapes are points and polygons. You can query for polygons or points that either contain or are within a given geometric shape.
+
+```
+FT.SEARCH index "@geo_shape_field:[{WITHIN|CONTAINS|INTERSECTS|DISJOINT} $shape] PARAMS 2 shape "shape_as_wkt" DIALECT 3
+```
+
+Here is a more detailed explanation of this query:
+
+1. **Field name**: you need to replace `geo_shape_field` with the `GEOSHAPE` field's name on which you want to query.
+2. **Spatial operator**: spatial operators define the relationship between the shapes in the database and the shape you are searching for. You can either use `WITHIN`, `CONTAINS`, `INTERSECTS`, or `DISJOINT`. `WITHIN` finds any shape in the database that is inside the given shape. `CONTAINS` queries for any shape that surrounds the given shape. `INTERSECTS` finds any shape that has coordinates in common with the provided shape. `DISJOINT` finds any shapes that have nothing in common with the provided shape. `INTERSECTS` and `DISJOINT` were introduced in v2.10.
+3. **Parameter**: the query refers to a parameter named `shape`. You can use any parameter name here. You need to use the `PARAMS` clause to set the parameter value. The value follows the [well-known text representation of a geometry](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry). Supported types are `POINT(x y)` and `POLYGON((x1 y1, x2 y2, ...))`.
+4. **Dialect**: Shape-based queries have been available since version three of the query dialect.
+
+The following example query verifies if a bicycle is within a pickup zone:
+
+{{< clients-example query_geo geo2 >}}
+FT.SEARCH idx:bicycle "@pickup_zone:[CONTAINS $bike]" PARAMS 2 bike "POINT(-0.1278 51.5074)" DIALECT 3
+{{< /clients-example >}}
+
+If you want to find all pickup zones that are approximately within Europe, then you can use the following query:
+
+{{< clients-example query_geo geo3 >}}
+FT.SEARCH idx:bicycle "@pickup_zone:[WITHIN $europe]" PARAMS 2 europe "POLYGON((-25 35, 40 35, 40 70, -25 70, -25 35))" DIALECT 3
+{{< /clients-example >}}---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Group and aggregate query results
+linkTitle: Aggregation
+title: Aggregation queries
+weight: 10
+---
+
+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]({{< relref "commands/ft.aggregate" >}}) command. For further details, see the [command specification]({{< relref "commands/ft.aggregate" >}}) and the [aggregations reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations" >}}).
+
+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.
+
+```
+FT.AGGREGATE index "query_expr" LOAD n "field_1" .. "field_n" APPLY "function_expr" AS "result_field"
+```
+
+Here is a more detailed explanation of the query syntax:
+
+1. **Query expression**: you can use the same query expressions as you would use with the [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command. You can substitute `query_expr` with any of the expressions explained in the articles of this [query topic]({{< relref "/develop/interact/search-and-query/query/" >}}). Vector search queries are an exception. You can't combine a vector search with an aggregation query.
+2. **Loaded fields**: if field values weren't already loaded into the aggregation pipeline, you can force their presence via the `LOAD` clause. This clause takes the number of fields (`n`), followed by the field names (`"field_1" .. "field_n"`).
+3. **Mapping function**: this mapping function operates on the field values. A specific field is referenced as `@field_name` within the function expression. The result is returned as `result_field`.
+
+The following example shows you how to calculate a discounted price for new bicycles:
+
+{{< clients-example query_agg agg1 >}}
+FT.AGGREGATE idx:bicycle "@condition:{new}" LOAD 2 "__key" "price" APPLY "@price - (@price * 0.1)" AS "discounted"
+{{< /clients-example >}}
+
+The field `__key` is a built-in field. 
+
+The output of this query is:
+
+```
+1) "1"
+2) 1) "__key"
+   1) "bicycle:0"
+   2) "price"
+   3) "270"
+   4) "discounted"
+   5) "243"
+3) 1) "__key"
+   1) "bicycle:5"
+   2) "price"
+   3) "810"
+   4) "discounted"
+   5) "729"
+4) 1) "__key"
+   1) "bicycle:6"
+   2) "price"
+   3) "2300"
+   4) "discounted"
+   5) "2070"
+...
+```
+
+## Grouping with aggregation
+
+The previous example did not group the data. You can group and aggregate data based on one or many criteria in the following way:
+
+```
+FT.AGGREGATE index "query_expr" ...  GROUPBY n "field_1" .. "field_n" REDUCE AGG_FUNC m "@field_param_1" .. "@field_param_m" AS "aggregated_result_field"
+```
+
+Here is an explanation of the additional constructs:
+
+1. **Grouping**: you can group by one or many fields. Each ordered sequence of field values then defines one group. It's also possible to group by values that resulted from a previous `APPLY ... AS`.
+2. **Aggregation**: you must replace `AGG_FUNC` with one of the supported aggregation functions (e.g., `SUM` or `COUNT`). A complete list of functions is available in the [aggregations reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations" >}}). Replace `aggregated_result_field` with a value of your choice.
+
+The following query shows you how to group by the field `condition` and apply a reduction based on the previously derived `price_category`. The expression `@price<1000` causes a bicycle to have the price category `1` if its price is lower than 1000 USD. Otherwise, it has the price category `0`. The output is the number of affordable bicycles grouped by price category.
+
+{{< clients-example query_agg agg2 >}}
+FT.AGGREGATE idx:bicycle "*" LOAD 1 price APPLY "@price<1000" AS price_category GROUPBY 1 @condition REDUCE SUM 1 "@price_category" AS "num_affordable"
+{{< /clients-example >}}
+
+```
+1) "3"
+2) 1) "condition"
+   1) "refurbished"
+   2) "num_affordable"
+   3) "1"
+3) 1) "condition"
+   1) "used"
+   2) "num_affordable"
+   3) "1"
+4) 1) "condition"
+   1) "new"
+   2) "num_affordable"
+   3) "3"
+```
+
+{{% alert title="Note" color="warning" %}}
+You can also create more complex aggregation pipelines with [FT.AGGREGATE]({{< relref "commands/ft.aggregate" >}}). Applying multiple reduction functions under one `GROUPBY` clause is possible. In addition, you can also chain groupings and mix in additional mapping steps (e.g., `GROUPBY ... REDUCE ... APPLY ... GROUPBY ... REDUCE`)
+{{% /alert  %}}
+
+
+## Aggregating without grouping
+
+You can't use an aggregation function outside of a `GROUPBY` clause, but you can construct your pipeline in a way that the aggregation happens on a single group that spans all documents. If your documents don't share a common attribute, you can add it via an extra `APPLY` step.
+
+Here is an example that adds a type attribute `bicycle` to each document before counting all documents with that type:
+
+{{< clients-example query_agg agg3 >}}
+FT.AGGREGATE idx:bicycle "*" APPLY "'bicycle'" AS type GROUPBY 1 @type REDUCE COUNT 0 AS num_total
+{{< /clients-example >}}
+
+The result is:
+
+```
+1) "1"
+2) 1) "type"
+   1) "bicycle"
+   2) "num_total"
+   3) "10"
+```
+
+## Grouping without aggregation
+
+It's sometimes necessary to group your data without applying a mathematical aggregation function. If you need a grouped list of values, then the `TOLIST` function is helpful.
+
+The following example shows how to group all bicycles by `condition`:
+
+{{< clients-example query_agg agg4 >}}
+FT.AGGREGATE idx:bicycle "*" LOAD 1 "__key" GROUPBY 1 "@condition" REDUCE TOLIST 1 "__key" AS bicycles
+{{< /clients-example >}}
+
+The output of this query is:
+
+```
+1) "3"
+2) 1) "condition"
+   1) "refurbished"
+   2) "bicycles"
+   3) 1) "bicycle:9"
+3) 1) "condition"
+   1) "used"
+   2) "bicycles"
+   3) 1) "bicycle:1"
+      1) "bicycle:2"
+      2) "bicycle:3"
+      3) "bicycle:4"
+4) 1) "condition"
+   1) "new"
+   2) "bicycles"
+   3) 1) "bicycle:0"
+      1) "bicycle:5"
+      2) "bicycle:6"
+      3) "bicycle:8"
+      4) "bicycle:7"
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Perform a full-text search
+linkTitle: Full-text
+title: Full-text search
+weight: 3
+---
+
+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]({{< relref "/develop/interact/search-and-query/advanced-concepts/" >}}).
+
+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:
+
+```
+FT.SEARCH index "word"
+```
+
+Instead of searching across all text fields, you might want to limit the search to a specific text field.
+
+```
+FT.SEARCH index "@field: word"
+```
+
+Words that occur very often in natural language, such as `the` or `a` for the English language, aren't indexed and will not return a search result. You can find further details in the [stop words article]({{< relref "/develop/interact/search-and-query/advanced-concepts/stopwords" >}}).
+
+The following example searches for all bicycles that have the word 'kids' in the description:
+
+{{< clients-example query_ft ft1 >}}
+FT.SEARCH idx:bicycle "@description: kids"
+{{< /clients-example >}}
+
+## Phrase
+
+A phrase is a sentence, sentence fragment, or small group of words. You can find further details about how to find exact phrases in the [exact match article]({{< relref "/develop/interact/search-and-query/query/exact-match" >}}).
+
+
+## Word prefix
+
+You can also search for words that match a given prefix.
+
+```
+FT.SEARCH index "prefix*"
+```
+
+```
+FT.SEARCH index "@field: prefix*"
+```
+
+{{% alert title="Important" color="warning" %}}
+The prefix needs to be at least two characters long.
+{{% /alert  %}}
+
+Here is an example that shows you how to search for bicycles with a brand that starts with 'ka':
+
+{{< clients-example query_ft ft2 >}}
+FT.SEARCH idx:bicycle "@model: ka*"
+{{< /clients-example >}}
+
+## Word suffix
+
+Similar to the prefix, it is also possible to search for words that share the same suffix.
+
+```
+FT.SEARCH index "*suffix"
+```
+
+You can also combine prefix- and suffix-based searches within a query expression.
+
+```
+FT.SEARCH index "*infix*"
+```
+
+Here is an example that finds all brands that end with 'bikes':
+
+{{< clients-example query_ft ft3 >}}
+FT.SEARCH idx:bicycle "@brand:*bikes"
+{{< /clients-example >}}
+
+## Fuzzy search
+
+A fuzzy search allows you to find documents with words that approximately match your search term. To perform a fuzzy search, you wrap search terms with pairs of `%` characters. A single pair represents a (Levenshtein) distance of one, two pairs represent a distance of two, and three pairs, the maximum distance, represents a distance of three.
+
+Here is the command that searches across all text fields with a distance of one:
+
+```
+FT.SEARCH index "%word%"
+```
+
+The following example finds all documents that contain a word that has a distance of one to the incorrectly spelled word 'optamized'. You can see that this matches the word 'optimized'.
+
+{{< clients-example query_ft ft4 >}}
+FT.SEARCH idx:bicycle "%optamized%"
+{{< /clients-example >}}
+
+If you want to increase the maximum word distance to two, you can use the following query:
+
+{{< clients-example query_ft ft5 >}}
+FT.SEARCH idx:bicycle "%%optamised%%"
+{{< /clients-example >}}
+
+## Unicode considerations
+
+Redis Query Engine only supports Unicode characters in the [basic multilingual plane](https://en.wikipedia.org/wiki/Plane_(Unicode)#Basic_Multilingual_Plane); U+0000 to U+FFFF. Unicode characters beyond U+FFFF, such as Emojis, are not supported and would not be retrieved by queries including such characters in the following use cases:
+
+* Querying TEXT fields with Prefix/Suffix/Infix
+* Querying TEXT fields with fuzzy
+
+Examples:
+
+```
+redis> FT.CREATE idx SCHEMA tag TAG text TEXT
+OK
+redis> HSET doc:1 tag '😀😁🙂' text '😀😁🙂'
+(integer) 2
+redis> HSET doc:2 tag '😀😁🙂abc' text '😀😁🙂abc'
+(integer) 2
+redis> FT.SEARCH idx '@text:(*😀😁🙂)' NOCONTENT
+1) (integer) 0
+redis> FT.SEARCH idx '@text:(*😀😁🙂*)' NOCONTENT
+1) (integer) 0
+redis> FT.SEARCH idx '@text:(😀😁🙂*)' NOCONTENT
+1) (integer) 0
+
+redis> FT.SEARCH idx '@text:(%😀😁🙃%)' NOCONTENT
+1) (integer) 0
+```---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how to query, search, and aggregate Redis data
+hideListLinks: true
+linkTitle: Query
+title: Query data
+weight: 5
+---
+
+Redis Open Source distinguishes between the [FT.SEARCH]({{< relref "/commands/ft.search" >}}) and [FT.AGGREGATE]({{< relref "/commands/ft.aggregate" >}}) query commands. You should use [FT.SEARCH]({{< relref "/commands/ft.search" >}}) if you want to perform selections and projections only. If you also need to apply mapping functions, group, or aggregate data, use the [FT.AGGREGATE]({{< relref "/commands/ft.aggregate" >}}) command. 
+
+* **Selection**: A selection allows you to return all documents that fulfill specific criteria.
+* **Projection**: Projections are used to return specific fields of the result set. You can also map/project to calculated field values.
+* **Aggregation**: Aggregations collect and summarize data across several fields.
+
+Here is a short SQL comparison using the [bicycle dataset](./data/bicycles.txt):
+
+|Type| SQL | Redis |
+|----------| --- | ----------- |
+| Selection | `SELECT * FROM bicycles WHERE price >= 1000` | `FT.SEARCH idx:bicycle "@price:[1000 +inf]"` |
+| Simple projection | `SELECT id, price FROM bicycles` | `FT.SEARCH idx:bicycle "*" RETURN 2 __key, price` |
+| Calculated projection| `SELECT id, price-price*0.1 AS discounted FROM bicycles`| `FT.AGGREGATE idx:bicycle "*" LOAD 2 __key price APPLY "@price-@price*0.1" AS discounted`| 
+| Aggregation | `SELECT condition, AVG(price) AS avg_price FROM bicycles GROUP BY condition` | `FT.AGGREGATE idx:bicycle "*" GROUPBY 1 @condition REDUCE AVG 1 @price AS avg_price` |
+
+The following articles provide an overview of how to query data with the [FT.SEARCH]({{< relref "commands/ft.search" >}}) command:
+
+* [Exact match queries]({{< relref "/develop/interact/search-and-query/query/exact-match" >}})
+* [Range queries]({{< relref "/develop/interact/search-and-query/query/range" >}})
+* [Full-text search ]({{< relref "/develop/interact/search-and-query/query/full-text" >}})
+* [Geospatial queries]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+* [Vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+* [Combined queries]({{< relref "/develop/interact/search-and-query/query/combined" >}})
+
+You can find further details about aggregation queries with [FT.AGGREGATE]({{< relref "commands/ft.aggregate" >}}) in the following article:
+
+* [Aggregation queries]({{< relref "/develop/interact/search-and-query/query/aggregation" >}})---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Perform numeric range queries
+linkTitle: Range
+title: Range queries
+weight: 2
+---
+
+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.
+
+The values `-inf`, `inf`, and `+inf` are valid values that allow you to define open ranges.
+
+## Result set
+
+An open-range query can lead to a large result set. 
+
+By default, [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) returns only the first ten results. The `LIMIT` argument helps you to scroll through the result set. The `SORTBY` argument ensures that the documents in the result set are returned in the specified order.
+
+```
+FT.SEARCH index "@field:[start end]" SORTBY field LIMIT page_start page_end
+```
+
+You can find further details about using the `LIMIT` and `SORTBY` in the [[`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command reference](/commands/ft.search/).
+
+## Examples
+
+The examples in this section use a schema with the following fields:
+
+| Field name | Field type |
+| ---------- | ---------- |
+| `price` | `NUMERIC` |
+
+The following query finds bicycles within a price range greater than or equal to 500 USD and smaller than or equal to 1000 USD (`500 <= price <= 1000`):
+
+{{< clients-example query_range range1 >}}
+> FT.SEARCH idx:bicycle "@price:[500 1000]"
+1) (integer) 3
+2) "bicycle:2"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-87.6848 41.9331, -87.5748 41.9331, -87.5748 41.8231, -87.6848 41.8231, -87.6848 41.9331))\",\"store_location\":\"-87.6298,41.8781\",\"brand\":\"Nord\",\"model\":\"Chook air 5\",\"price\":815,\"description\":\"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\",\"condition\":\"used\"}"
+4) "bicycle:5"
+5) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-0.1778 51.5524, 0.0822 51.5524, 0.0822 51.4024, -0.1778 51.4024, -0.1778 51.5524))\",\"store_location\":\"-0.1278,51.5074\",\"brand\":\"Breakout\",\"model\":\"XBN 2.1 Alloy\",\"price\":810,\"description\":\"The XBN 2.1 Alloy is our entry-level road bike \xe2\x80\x93 but that\xe2\x80\x99s not to say that it\xe2\x80\x99s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\xe2\x80\x99s, this is a bike which doesn\xe2\x80\x99t break the bank and delivers craved performance.\",\"condition\":\"new\"}"
+6) "bicycle:9"
+7) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((12.4464 42.1028, 12.5464 42.1028, 12.5464 41.7028, 12.4464 41.7028, 12.4464 42.1028))\",\"store_location\":\"12.4964,41.9028\",\"model\":\"ThrillCycle\",\"brand\":\"BikeShind\",\"price\":815,\"description\":\"An artsy,  retro-inspired bicycle that\xe2\x80\x99s as functional as it is pretty: The ThrillCycle steel frame offers a smooth ride. A 9-speed drivetrain has enough gears for coasting in the city, but we wouldn\xe2\x80\x99t suggest taking it to the mountains. Fenders protect you from mud, and a rear basket lets you transport groceries, flowers and books. The ThrillCycle comes with a limited lifetime warranty, so this little guy will last you long past graduation.\",\"condition\":\"refurbished\"}"
+{{< /clients-example >}}
+
+This is semantically equivalent to:
+
+{{< clients-example query_range range2 >}}
+> FT.SEARCH idx:bicycle "*" FILTER price 500 1000
+1) (integer) 3
+2) "bicycle:2"
+3) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-87.6848 41.9331, -87.5748 41.9331, -87.5748 41.8231, -87.6848 41.8231, -87.6848 41.9331))\",\"store_location\":\"-87.6298,41.8781\",\"brand\":\"Nord\",\"model\":\"Chook air 5\",\"price\":815,\"description\":\"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\",\"condition\":\"used\"}"
+4) "bicycle:5"
+5) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((-0.1778 51.5524, 0.0822 51.5524, 0.0822 51.4024, -0.1778 51.4024, -0.1778 51.5524))\",\"store_location\":\"-0.1278,51.5074\",\"brand\":\"Breakout\",\"model\":\"XBN 2.1 Alloy\",\"price\":810,\"description\":\"The XBN 2.1 Alloy is our entry-level road bike \xe2\x80\x93 but that\xe2\x80\x99s not to say that it\xe2\x80\x99s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\xe2\x80\x99s, this is a bike which doesn\xe2\x80\x99t break the bank and delivers craved performance.\",\"condition\":\"new\"}"
+6) "bicycle:9"
+7) 1) "$"
+   2) "{\"pickup_zone\":\"POLYGON((12.4464 42.1028, 12.5464 42.1028, 12.5464 41.7028, 12.4464 41.7028, 12.4464 42.1028))\",\"store_location\":\"12.4964,41.9028\",\"model\":\"ThrillCycle\",\"brand\":\"BikeShind\",\"price\":815,\"description\":\"An artsy,  retro-inspired bicycle that\xe2\x80\x99s as functional as it is pretty: The ThrillCycle steel frame offers a smooth ride. A 9-speed drivetrain has enough gears for coasting in the city, but we wouldn\xe2\x80\x99t suggest taking it to the mountains. Fenders protect you from mud, and a rear basket lets you transport groceries, flowers and books. The ThrillCycle comes with a limited lifetime warranty, so this little guy will last you long past graduation.\",\"condition\":\"refurbished\"}"
+{{< /clients-example >}}
+
+For bicycles with a price greater than 1000 USD (`price > 1000`), you can use:
+
+{{< clients-example query_range range3 >}}
+> FT.SEARCH idx:bicycle "@price:[(1000 +inf]"
+ 1) (integer) 5
+ 2) "bicycle:1"
+ 3) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((-118.2887 34.0972, -118.1987 34.0972, -118.1987 33.9872, -118.2887 33.9872, -118.2887 34.0972))\",\"store_location\":\"-118.2437,34.0522\",\"brand\":\"Bicyk\",\"model\":\"Hillcraft\",\"price\":1200,\"description\":\"Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\\\" wheel bike is just too clumsy coming off a 24\\\" bike. The Hillcraft 26 is just the solution they need!\",\"condition\":\"used\"}"
+ 4) "bicycle:4"
+ 5) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((-122.4644 37.8199, -122.3544 37.8199, -122.3544 37.7099, -122.4644 37.7099, -122.4644 37.8199))\",\"store_location\":\"-122.4194,37.7749\",\"brand\":\"Noka Bikes\",\"model\":\"Kahuna\",\"price\":3200,\"description\":\"Whether you want to try your hand at XC racing or are looking for a lively trail bike that's just as inspiring on the climbs as it is over rougher ground, the Wilder is one heck of a bike built specifically for short women. Both the frames and components have been tweaked to include a women\xe2\x80\x99s saddle, different bars and unique colourway.\",\"condition\":\"used\"}"
+ 6) "bicycle:3"
+ 7) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((-80.2433 25.8067, -80.1333 25.8067, -80.1333 25.6967, -80.2433 25.6967, -80.2433 25.8067))\",\"store_location\":\"-80.1918,25.7617\",\"brand\":\"Eva\",\"model\":\"Eva 291\",\"price\":3400,\"description\":\"The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It\xe2\x80\x99s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!\",\"condition\":\"used\"}"
+ 8) "bicycle:6"
+ 9) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((2.1767 48.9016, 2.5267 48.9016, 2.5267 48.5516, 2.1767 48.5516, 2.1767 48.9016))\",\"store_location\":\"2.3522,48.8566\",\"brand\":\"ScramBikes\",\"model\":\"WattBike\",\"price\":2300,\"description\":\"The WattBike is the best e-bike for people who still feel young at heart. It has a Bafang 1000W mid-drive system and a 48V 17.5AH Samsung Lithium-Ion battery, allowing you to ride for more than 60 miles on one charge. It\xe2\x80\x99s great for tackling hilly terrain or if you just fancy a more leisurely ride. With three working modes, you can choose between E-bike, assisted bicycle, and normal bike modes.\",\"condition\":\"new\"}"
+10) "bicycle:8"
+11) 1) "$"
+    2) "{\"pickup_zone\":\"POLYGON((1.9450 41.4301, 2.4018 41.4301, 2.4018 41.1987, 1.9450 41.1987, 1.9450 41.4301))\",\"store_location\":\"2.1734, 41.3851\",\"brand\":\"nHill\",\"model\":\"Summit\",\"price\":1200,\"description\":\"This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail in mountains on the weekends or you\xe2\x80\x99re just after a stable, comfortable ride for the bike path, the Summit gives a good value for money.\",\"condition\":\"new\"}"
+{{< /clients-example >}}
+
+The example below returns bicycles with a price lower than or equal to 2000 USD (`price <= 2000`) by returning the five cheapest bikes:
+
+{{< clients-example query_range range4 >}}
+> FT.SEARCH idx:bicycle "@price:[-inf 2000]" SORTBY price LIMIT 0 5
+ 1) (integer) 7
+ 2) "bicycle:0"
+ 3) 1) "price"
+    2) "270"
+    3) "$"
+    4) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))\",\"store_location\":\"-74.0060,40.7128\",\"brand\":\"Velorim\",\"model\":\"Jigger\",\"price\":270,\"description\":\"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\xe2\x80\x99 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\",\"condition\":\"new\"}"
+ 4) "bicycle:7"
+ 5) 1) "price"
+    2) "430"
+    3) "$"
+    4) "{\"pickup_zone\":\"POLYGON((13.3260 52.5700, 13.6550 52.5700, 13.6550 52.2700, 13.3260 52.2700, 13.3260 52.5700))\",\"store_location\":\"13.4050,52.5200\",\"brand\":\"Peaknetic\",\"model\":\"Secto\",\"price\":430,\"description\":\"If you struggle with stiff fingers or a kinked neck or back after a few minutes on the road, this lightweight, aluminum bike alleviates those issues and allows you to enjoy the ride. From the ergonomic grips to the lumbar-supporting seat position, the Roll Low-Entry offers incredible comfort. The rear-inclined seat tube facilitates stability by allowing you to put a foot on the ground to balance at a stop, and the low step-over frame makes it accessible for all ability and mobility levels. The saddle is very soft, with a wide back to support your hip joints and a cutout in the center to redistribute that pressure. Rim brakes deliver satisfactory braking control, and the wide tires provide a smooth, stable ride on paved roads and gravel. Rack and fender mounts facilitate setting up the Roll Low-Entry as your preferred commuter, and the BMX-like handlebar offers space for mounting a flashlight, bell, or phone holder.\",\"condition\":\"new\"}"
+ 6) "bicycle:5"
+ 7) 1) "price"
+    2) "810"
+    3) "$"
+    4) "{\"pickup_zone\":\"POLYGON((-0.1778 51.5524, 0.0822 51.5524, 0.0822 51.4024, -0.1778 51.4024, -0.1778 51.5524))\",\"store_location\":\"-0.1278,51.5074\",\"brand\":\"Breakout\",\"model\":\"XBN 2.1 Alloy\",\"price\":810,\"description\":\"The XBN 2.1 Alloy is our entry-level road bike \xe2\x80\x93 but that\xe2\x80\x99s not to say that it\xe2\x80\x99s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\xe2\x80\x99s, this is a bike which doesn\xe2\x80\x99t break the bank and delivers craved performance.\",\"condition\":\"new\"}"
+ 8) "bicycle:2"
+ 9) 1) "price"
+    2) "815"
+    3) "$"
+    4) "{\"pickup_zone\":\"POLYGON((-87.6848 41.9331, -87.5748 41.9331, -87.5748 41.8231, -87.6848 41.8231, -87.6848 41.9331))\",\"store_location\":\"-87.6298,41.8781\",\"brand\":\"Nord\",\"model\":\"Chook air 5\",\"price\":815,\"description\":\"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\",\"condition\":\"used\"}"
+10) "bicycle:9"
+11) 1) "price"
+    2) "815"
+    3) "$"
+    4) "{\"pickup_zone\":\"POLYGON((12.4464 42.1028, 12.5464 42.1028, 12.5464 41.7028, 12.4464 41.7028, 12.4464 42.1028))\",\"store_location\":\"12.4964,41.9028\",\"model\":\"ThrillCycle\",\"brand\":\"BikeShind\",\"price\":815,\"description\":\"An artsy,  retro-inspired bicycle that\xe2\x80\x99s as functional as it is pretty: The ThrillCycle steel frame offers a smooth ride. A 9-speed drivetrain has enough gears for coasting in the city, but we wouldn\xe2\x80\x99t suggest taking it to the mountains. Fenders protect you from mud, and a rear basket lets you transport groceries, flowers and books. The ThrillCycle comes with a limited lifetime warranty, so this little guy will last you long past graduation.\",\"condition\":\"refurbished\"}"
+{{< /clients-example >}}
+
+## Non-numeric range queries
+
+You can learn more about non-numeric range queries, such as [geospatial]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}}) or [vector search]({{< relref "/develop/interact/search-and-query/query/vector-search" >}}) queries, in their dedicated articles.---
+Title: Move from Development to Production with Redis Query Engine
+alwaysopen: false
+categories:
+- docs
+- develop
+- stack
+- oss
+- kubernetes
+- clients
+linkTitle: RQE DEV to PROD
+weight: 2
+---
+
+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]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}), this section highlights the most commonly adjusted parameters for production environments.
+
+### 1. `TIMEOUT`
+
+- Purpose: limits the duration a query is allowed to execute. 
+- Default: 500 milliseconds.
+- Behavior:
+  - Ensures that queries do not monopolize the main Redis thread.
+  - If a query exceeds the `TIMEOUT` value, its outcome is determined by the `ON_TIMEOUT` setting:
+    - `FAIL`: the query will return an error.
+    - `PARTIAL`: this setting will return the top results accumulated by the query until it timed out.
+- Recommendations:
+  - Caution: be mindful when increasing `TIMEOUT`,<!-- especially in environments without QPF,--> as long-running queries can degrade overall system performance.
+ <!-- - With Query Performance Factor (QPF): if QPF (multi-threaded query execution) is enabled, the risks of increasing this value are mitigated, as queries execute against index memory using multiple threads.-->
+
+### 2. `MINPREFIX`
+
+- Purpose: sets the minimum number of characters required for wildcard searches.
+- Default: 2 characters.
+- Behavior:
+  - Queries like `he*` are valid, while `h*` would not meet the threshold.
+- Recommendations:
+  - Lowering this value to 1 can significantly increase result sets, which may lead to degraded performance.
+  - Keep the default unless there is a strong use case for single-character wildcards.
+
+### 3. `MAXPREFIXEXPANSIONS`
+
+- Purpose: Defines the maximum number of expansions for a wildcard query term.
+- Default: 200 expansions.
+- Behavior:
+  - Expansions: when a wildcard query term is processed, Redis generates a list of all possible matches from the index that satisfy the wildcard. For example, the query he* might expand to terms like hello, hero, and heat. Each of these matches is an "expansion."
+  - This parameter limits how many of these expansions Redis will generate and process. If the number of possible matches exceeds the limit, the query may return incomplete results or fail, depending on the query context.
+- Recommendations:
+  - Avoid increasing this parameter excessively, as it can lead to performance bottlenecks during query execution.
+  - If wildcard searches are common, consider optimizing your index to reduce the reliance on large wildcard expansions.
+
+### 4. `DEFAULT_DIALECT`
+
+- Purpose: specifies the default query dialect used by [`FT.SEARCH`]({{< relref "commands/ft.search" >}}) and [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate" >}}) commands.
+- Default: [Dialect 1]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}).
+- Recommendations:
+  - Update the default to [**Dialect 4**]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-4" >}}) for better performance and access to advanced features.
+  - Individual commands can override this parameter if necessary, but setting a higher default ensures consistent performance across queries.
+
+## Testing
+
+### 1. Correctness
+- Run a few test queries and check the results are what you expect.
+- Use the following tools to validate and debug:
+  - Redis CLI: use the [`MONITOR`]({{< relref "commands/monitor" >}}) command or [profiling features]({{< relref "/develop/tools/insight#profiler" >}}) in Redis Insight to analyze commands.
+  - [`FT.PROFILE`]({{< relref "commands/ft.profile" >}}): Provides detailed insights into individual query execution paths, helping identify bottlenecks and inefficiencies.
+
+### 2. Performance
+- Test query performance in a controlled test environment that mirrors production as closely as possible.
+- Use tools like `memtier_benchmark` or custom test applications to simulate load.
+- Network Considerations:
+  - Minimize latency during testing by locating test clients in the same network as the Redis instance.
+  - For Redis Cloud, ensure test machines are in a **VPC-peered environment** with the target Redis database.
+
+## Sizing requirements
+
+Redis Search has resource requirements distinct from general caching use cases. Proper sizing ensures that the system can handle production workloads efficiently.
+
+### Key considerations:
+1. CPU: 
+   - Adequate CPU resources are critical<!--, especially when using QPF-->.
+   - Ensure CPUs are not over-subscribed with search threads and shard processes.
+2. RAM:
+   - Plan for sufficient memory to store the dataset and indexes, plus overhead for operations.
+3. Network:
+   - High throughput and low latency are essential, particularly for applications with demanding query patterns.
+
+### Tools:
+- Use the [Redis Search Sizing Calculator](https://redis.io/redisearch-sizing-calculator/) to estimate resource requirements based on your dataset and workload.
+
+## Demand spikes
+
+Production environments must be sized for peak load scenarios to ensure performance remains acceptable under maximum stress.
+
+### Recommendations:
+1. Plan for Spikes:
+   - If query workloads are expected to vary significantly, ensure the infrastructure can handle peak loads.
+   - Monitor real-world usage patterns and adjust capacity as needed.
+2. Autoscaling:
+   - Consider using autoscaling strategies in cloud environments to dynamically adjust resources based on load.
+
+By following these best practices, you can ensure a smooth and efficient transition from development to production with Redis Open Source and RQE. Proper configuration, rigorous testing, and careful resource planning are critical to delivering a reliable and high-performance Redis deployment.
+---
+Title: Index management best practices for Redis Query Engine
+alwaysopen: false
+categories:
+- docs
+- develop
+- stack
+- oss
+- kubernetes
+- clients
+linkTitle: RQE index management
+weight: 3
+---
+## 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.
+
+This guide outlines best practices for managing RQE indexes throughout their lifecycle. It provides recommendations on:
+
+- Planning and creating indexes to suit your query patterns.
+- Using index aliasing to manage schema updates and minimize downtime.
+- Monitoring and verifying index population to ensure query readiness.
+- Optimizing performance through query profiling and memory management.
+- Maintaining and scaling indexes in both standalone and clustered Redis environments.
+- Versioning, testing, and automating index management.
+
+## Why index management matters
+
+Indexes directly impact query speed and resource consumption.
+Poorly managed indexes can lead to increased memory usage, slower query times, and challenges in maintaining data consistency.
+By following the strategies outlined in this guide, you can:
+
+- Reduce operational overhead.
+- Improve application performance.
+- Ensure smooth transitions during schema changes.
+- Scale efficiently with your growing datasets.
+
+## Plan your indexes strategically
+
+Planning your indexes strategically requires understanding your application’s query patterns and tailoring indexes to match.
+Begin by identifying the types of searches your application performs—such as full-text search, range queries, or geospatial lookups—and the fields involved.
+Categorize fields based on their purpose: searchable fields (e.g., [`TEXT`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#text-fields" >}}) for full-text searches), filterable fields (e.g., [`TAG`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#tag-fields" >}}) for exact match searches), and sortable fields (e.g., [`NUMERIC`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#numeric-fields" >}}) for range queries or sorting).
+Match field types to their intended use and avoid indexing fields that are rarely queried to conserve resources. Here's the list of index types:
+
+- [`TEXT`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#text-fields" >}}): use `TEXT` for free-text searches and set weights if some fields are more important.
+- [`TAG`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#tag-fields" >}}): use `TAG` for categorical data (e.g., product categories) that benefit from exact matching and filtering.
+- [`NUMERIC`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#numeric-fields" >}}): use `NUMERIC` for numeric ranges (e.g., prices, timestamps).
+- [`GEO`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#geo-fields" >}}): use `GEO` for geospatial coordinates (e.g., latitude/longitude).
+- [`GEOSHAPE`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#geoshape-fields" >}}): use `GEOSHAPE` to represent locations as points, but also to define shapes and query the interactions between points and shapes (e.g., to find all points that are contained within an enclosing shape).
+- [`VECTOR`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#vector-fields" >}}): use `VECTOR` for high-dimensional similarity searches.
+
+See [these pages]({{< relref "/develop/interact/search-and-query/query" >}}) for discussions and examples on how best to use these index types.
+
+Next, simulate queries on a sample dataset to identify potential bottlenecks.
+Use tools like [`FT.PROFILE`]({{< relref "commands/ft.profile" >}}) to analyze query execution and refine your schema if needed.
+For example, assign weights to `TEXT` fields for prioritizing results or use the `PREFIX` option of [`FT.CREATE`]({{< relref "commands/ft.create" >}}) to limit indexing to specific key patterns. Note that you can use multiple `PREFIX` clauses when you create an index (see [below](#index-creation))
+After creating the index, validate its performance with real queries and monitor usage with the available tools:
+
+- [`FT.EXPLAIN`]({{< relref "commands/ft.explain" >}}) and [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli" >}}) allow you to see how Redis Query Engine parses a given search query. `FT.EXPLAIN` returns a structured breakdown of the query execution plan, while `FT.EXPLAINCLI` presents a more readable, tree-like format for easier interpretation. These commands are useful for diagnosing query structure and ensuring it aligns with the intended logic.
+- [`FT.INFO`]({{< relref "commands/ft.info" >}}) provides detailed statistics about an index, including the number of indexed documents, memory usage, and configuration settings. It helps in monitoring index growth, assessing memory consumption, and verifying index structure to detect potential inefficiencies.
+- [`FT.PROFILE`]({{< relref "commands/ft.profile" >}}) runs a query while capturing execution details, which helps to reveal query performance bottlenecks. It provides insights into processing time, key accesses, and filter application, making it a crucial tool for fine-tuning complex queries and optimizing search efficiency.
+
+Avoid over-indexing. Indexing every field increases memory usage and can slow down updates.
+Only index the fields that are essential for your planned queries.
+
+## Index creation {#index-creation}
+   - Use the [`FT.CREATE`]({{< relref "commands/ft.create" >}}) command to define an index schema.
+   - Assign weights to `TEXT` fields to prioritize certain fields in full-text search results.
+   - Use the `PREFIX` option to restrict indexing to keys with specific patterns.
+      Using multiple PREFIX clauses when creating an index allows you to index multiple key patterns under a single index. This is useful in several scenarios:
+      - If your Redis database stores different types of entities under distinct key prefixes (e.g., `user:123`, `order:456`), a single index can cover both by specifying multiple prefixes. For example:
+
+          ```bash
+          FT.CREATE my_index ON HASH PREFIX 2 "user:" "order:" SCHEMA name TEXT age NUMERIC status TAG
+          ```
+
+          This approach enables searching across multiple entity types without needing separate indexes.
+
+      - Instead of querying multiple indexes separately, you can search across related data structures using a single query. This is particularly helpful when data structures share common fields, such as searching both customer and vendor records under a unified contacts index.
+
+      - Maintaining multiple indexes for similar data types can be inefficient in terms of memory and query performance. By consolidating data under one index with multiple prefixes, you reduce overhead while still allowing for distinct key organization.
+
+      - If your data model evolves and new key patterns are introduced, using multiple `PREFIX` clauses from the start ensures future compatibility without requiring a full reindexing.
+   - Data loading strategy: load data into Redis before creating an index when working with large datasets. Use the `ON HASH` or `ON JSON` options to match the data structure.
+
+## Index aliasing
+
+Index aliases act as abstracted names for the underlying indexes, enabling applications to reference the alias instead of the actual index name. This approach simplifies schema updates and index management.
+
+There are several use cases for index aliasing, including:
+
+- Schema updates: when updating an index schema, create a new index and associate the same alias with it. This allows a seamless transition without requiring application-level changes.
+- Version control: use aliases to manage different versions of an index. For example, assign the alias products to `products_v1` initially and later to `products_v2` when the schema evolves.
+- Testing and rollback: assign an alias to a test index during staged deployments. If issues arise, quickly switch the alias back to the stable index.
+
+Best practices for aliasing:
+
+- Always create an alias for your indexes during initial setup, even if you don’t anticipate immediate schema changes.
+- Use clear and descriptive alias names to avoid confusion (e.g., `users_current` or `orders_live`).
+- Make sure that an alias points to only one index at a time to maintain predictable query results.
+- Use aliases to provide tenant-specific access. For example, assign tenant-specific aliases like `tenant1_products` and `tenant2_products` to different indexes for isolated query performance.
+
+Tools for managing aliases:
+
+- Assign an alias: [`FT.ALIASADD`]({{< relref "commands/ft.aliasadd" >}}) `my_alias my_index`
+- Update an alias: [`FT.ALIASUPDATE`]({{< relref "commands/ft.aliasupdate" >}}) `my_alias new_index`
+- Remove an alias: [`FT.ALIASDEL`]({{< relref "commands/ft.aliasdel" >}}) `my_alias`
+
+Monitoring and troubleshooting aliases:
+
+- Use the `FT.INFO` command to check which aliases are associated with an index.
+- Make sure your aliases always points to valid indexes and are correctly updated during schema changes.
+
+## Monitor index population
+
+- Use the `FT.INFO` command to monitor the `num_docs` and `indexing` fields, to check that all expected documents are indexed.
+    ```bash
+    FT.INFO my_new_index
+    ```
+- Validate data with sample queries to ensure proper indexing:
+    ```bash
+    FT.SEARCH my_new_index "*"
+    ```
+- Use `FT.PROFILE` to analyze query plans and validate performance:
+
+    ```bash
+    FT.PROFILE my_new_index SEARCH QUERY "your_query"
+    ```
+ - Implement scripts to periodically verify document counts and query results. For example, in Python:
+
+    ```python
+    import re    
+    def check_index_readiness(index_name, expected_docs):
+        r = redis.StrictRedis(host='localhost', port=6379, decode_responses=True)
+        info = r.execute_command('FT.INFO', index_name)
+        num_docs = int(info[info.index('num_docs') + 1])
+        return num_docs >= expected_d    
+    if check_index_readiness('my_new_index', 100000):
+        print("Index is fully populated!")
+    else:
+        print("Index is still populating...")
+    ```
+
+## Monitoring index performance
+
+- Use the `FT.PROFILE` command to analyze query performance and identify bottlenecks.
+- Regularly monitor memory usage with the [`INFO`]({{< relref "commands/info" >}}) `memory` and `FT.INFO` commands to detect growth patterns and optimize resource allocation.
+
+## Index maintenance
+
+- If schema changes are required, create a new index with the updated schema and reassign the alias once the index is ready.
+- Use [Redis key expiration]({{< relref "/develop/use/keyspace#key-expiration" >}}) to automatically remove outdated records and keep indexes lean.
+
+### FT.ALTER vs. aliasing
+
+Use [`FT.ALTER`]({{< relref "commands/ft.alter" >}}) when you need to add new fields to an existing index without rebuilding it, minimizing downtime and resource usage. However, `FT.ALTER` cannot remove or modify existing fields, limiting its flexibility.
+
+Use index aliasing when making schema changes that require reindexing, such as modifying field types or removing fields. In this case, create a new index with the updated schema, populate it, and then use `FT.ALIASUPDATE` to seamlessly switch queries to the new index without disrupting application functionality.
+
+## Scaling and high availability
+
+- In a clustered Redis setup, make sure indexes are designed with key distribution in mind to prevent query inefficiencies.
+- Test how indexes behave under replica promotion to ensure consistent query behavior across nodes.
+
+## Versioning and testing
+
+- When changing schemas, create a new version of the index alongside the old one and migrate data progressively.
+- Test index changes in a staging environment before deploying them to production.
+
+## Cleaning up
+
+- Use the [`FT.DROPINDEX`]({{< relref "commands/ft.dropindex" >}}) command to remove unused indexes and free up memory. Be cautious with the `DD` (Delete Documents) flag to avoid unintended data deletion.
+- Make sure no keys remain that were previously associated with dropped indexes if the data is no longer relevant.
+
+## Documentation and automation
+
+- Document your index configurations to facilitate future maintenance.
+- Use scripts or orchestration tools to automate index creation, monitoring, and cleanup.
+---
+Title: Best practices for Redis Query Engine performance
+alwaysopen: false
+categories:
+- docs
+- develop
+- stack
+- oss
+- kubernetes
+- clients
+linkTitle: RQE performance
+weight: 1
+---
+
+{{< note >}}
+If you're using Redis Software or Redis Cloud, see the [best practices for scalable Redis Query Engine]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/scalable-query-best-practices" >}}) page.
+{{< /note >}}
+
+## Checklist
+Below are some basic steps to ensure good performance of the Redis Query Engine (RQE).
+
+* Create a Redis data model with your query patterns in mind.
+* Ensure the Redis architecture has been sized for the expected load using the [sizing calculator](https://redis.io/redisearch-sizing-calculator/).
+* Provision Redis nodes with sufficient resources (RAM, CPU, network) to support the expected maximum load.
+* Review [`FT.INFO`]({{< relref "commands/ft.info" >}}) and [`FT.PROFILE`]({{< relref "commands/ft.profile" >}}) outputs for anomalies and/or errors.
+* Conduct load testing in a test environment with real-world queries and a load generated by either [memtier_benchmark](https://github.com/redislabs/memtier_benchmark) or a custom load application.
+
+## Indexing considerations
+
+### General
+- Favor [`TAG`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#tag-fields" >}}) over [`NUMERIC`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#numeric-fields" >}}) for use cases that only require matching.
+- Favor [`TAG`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#tag-fields" >}}) over [`TEXT`]({{< relref "/develop/interact/search-and-query/basic-constructs/field-and-type-options#text-fields" >}}) for use cases that don’t require full-text capabilities (pure match).
+
+### Non-threaded search
+- Put only those fields used in your queries in the index.
+- Only make fields [`SORTABLE`]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting" >}}) if they are used in [`SORTBY`]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting#specifying-sortby" >}})
+queries.
+- Use [`DIALECT 2`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}).
+
+### Threaded (query performance factor or QPF) search
+- Put both query fields and any projected fields (`RETURN` or `LOAD`) in the index.
+- Set all fields to `SORTABLE`.
+- Set TAG fields to [UNF]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting#normalization-unf-option" >}}).
+- Optional: Set `TEXT` fields to `NOSTEM` if the use case will support it.
+- Use [`DIALECT 2`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}).
+
+## Query optimization
+
+- Avoid returning large result sets.  Use `CURSOR` or `LIMIT`.
+- Avoid wildcard searches.
+- Avoid projecting all fields (e.g., `LOAD *`). Project only those fields that are part of the index schema.
+- If queries are long-running, enable threading (query performance factor) to reduce contention for the main Redis thread.
+
+## Validate performance (`FT.PROFILE`)
+
+You can analyze [`FT.PROFILE`]({{< relref "commands/ft.profile" >}}) output to gain insights about query execution.
+The following informational items are available for analysis:
+
+- Total execution time
+- Execution time per shard
+- Coordination time (for multi-sharded environments)
+- Breakdown of the query into fundamental components, such as `UNION` and `INTERSECT`
+- Warnings, such as `TIMEOUT`
+
+## Anti-patterns
+
+When designing and querying indexes in RQE, certain practices can hinder performance, scalability, and maintainability. Below are some common anti-patterns to avoid:
+
+- **Large documents**: storing excessively large documents in Redis makes data retrieval slower and increases memory usage. Break data into smaller, focused records whenever possible.
+- **Deeply-nested fields**: retrieving or indexing deeply-nested JSON fields is computationally expensive. Use a flatter schema for better performance.
+- **Large result sets**: fetching unnecessarily large result sets puts a strain on memory and network resources. Limit results to only what is needed.
+- **Wildcarding**: using wildcard patterns indiscriminately in queries can lead to large and inefficient scans, especially if the index size is significant.
+- **Large projections**: including excessive fields in query results increases memory overhead and slows down query execution. Limit projections to essential fields.
+
+The following examples depict an anti-pattern index schema and query, followed by corrected versions designed for scalability with RQE.
+
+### Anti-pattern index schema
+
+The following schema introduces challenges for scalability and performance:
+
+```sh
+FT.CREATE jsonidx:profiles ON JSON PREFIX 1 profiles: 
+          SCHEMA $.tags.* as t NUMERIC SORTABLE 
+                 $.firstName as name TEXT 
+                 $.location as loc GEO
+```
+
+Issues:
+
+- Minimal schema definition: the schema is sparse and lacks fields like `lastName`, `id`, and `version` that might be frequently queried. This results in additional operations to fetch these fields separately, reducing efficiency.
+- Missing `SORTABLE` flag for text fields: sorting operations on unsortable fields require full-text processing, which is slow.
+- Wildcard indexing: `$.tags.*` creates a broad index that can lead to excessive memory usage and reduced query performance.
+
+### Anti-pattern query
+
+The following query is inefficient and not optimized for vertical scaling:
+
+```sh
+FT.AGGREGATE jsonidx:profiles '@t:[1299 1299]' LOAD * LIMIT 0 10
+```
+Issues:
+
+- Wildcard projection (`LOAD *`): retrieving all fields in the result set is inefficient and increases memory usage, especially if the documents are large.
+- Unnecessary fields: fields that aren't required for the current operation are still fetched, slowing down execution.
+- Lack of advanced query syntax: without specifying a query dialect or leveraging features like tagging, the query may perform unnecessary computations.
+
+### Improved index schema
+
+Here’s an optimized schema that adheres to best practices for vertical scaling:
+
+```sh
+FT.CREATE jsonidx:profiles ON JSON PREFIX 1 profiles: 
+          SCHEMA $.tags.* as t NUMERIC SORTABLE 
+                 $.firstName as name TEXT NOSTEM SORTABLE 
+                 $.lastName as lastname TEXT NOSTEM SORTABLE 
+                 $.location as loc GEO SORTABLE 
+                 $.id as id TAG SORTABLE UNF 
+                 $.ver as ver TAG SORTABLE UNF
+```
+
+Improvements:
+
+- `NOSTEM` for text fields: prevents stemming on fields like `firstName` and `lastName` to allow for exact matches (e.g., "Smith" stays "Smith").
+- Expanded schema: adds commonly queried fields like `lastName`, `id`, and `version`, making queries more efficient by reducing the need for post-query data retrieval.
+- `TAG` fields: `id` and `ver` are defined as `TAG` fields to support fast filtering with exact matches.
+- `SORTABLE` for all relevant fields: ensures that sorting operations are efficient without requiring full-text scanning.
+
+You might be wondering why `$.tags.* as t NUMERIC SORTABLE` is acceptable in the improved schema and it wasn't previously.
+The inclusion of `$.tags.*` is acceptable when:
+
+- It has a clear purpose: it is actively used in queries, such as filtering on numeric ranges or matching specific values.
+- Other fields in the schema complement it: these fields reduce over-reliance on `$.tags.*` for all query operations, distributing the load more evenly.
+- Projections and limits are managed carefully: queries that use `$.tags.*` should avoid loading unnecessary fields or returning excessively large result sets.
+
+### Improved query
+
+The following query is better suited for vertical scaling:
+
+```sh
+FT.AGGREGATE jsonidx:profiles '@t:[1299 1299]' 
+                LOAD 6 id t name lastname loc ver 
+                LIMIT 0 10
+                DIALECT 2
+```
+
+Improvements:
+
+- Targeted projection: the `LOAD` clause specifies only essential fields (`id, t, name, lastname, loc, ver`), reducing memory and network overhead.
+- Limited results: the `LIMIT` clause ensures the query retrieves only the first 10 results, avoiding large result sets.
+- [`DIALECT 2`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}): enables the latest RQE syntax and features, ensuring compatibility with modern capabilities.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+description: Redis Query Engine best practices
+linkTitle: Best practices
+title: Best practices
+weight: 8
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Searching and querying Redis data using the Redis Query Engine
+highlighted: true
+linkTitle: Redis Query Engine
+stack: true
+title: Redis Query Engine
+weight: 10
+---
+
+The Redis Query Engine offers an enhanced Redis experience via the following search and query features:
+
+- A rich query language
+- Incremental indexing on JSON and hash documents
+- Vector search
+- Full-text search
+- Geospatial queries
+- Aggregations
+
+You can find a complete list of features in the [reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/" >}}).
+
+The Redis Query Engine features allow you to use Redis as a:
+
+- Document database
+- Vector database
+- Secondary index
+- Search engine
+
+Here are the next steps to get you started:
+
+1. Follow our [quick start guide]({{< relref "/develop/get-started/document-database" >}}) to get some initial hands-on experience.
+1. Learn how to [create an index]({{< relref "/develop/interact/search-and-query/indexing/" >}}).
+1. Learn how to [query your data]({{< relref "/develop/interact/search-and-query/query/" >}}).
+1. [Install Redis Insight]({{< relref "/operate/redisinsight" >}}), connect it to your Redis database, and then use [Redis Copilot]({{< relref "/develop/tools/insight" >}}#redis-copilot) to help you learn how to execute complex queries against your own data using simple, plain language prompts.
+
+
+## Enable the Redis Query Engine
+
+The Redis Query Engine is available in Redis Open Source, Redis Software, and Redis Cloud.
+See
+[Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) or
+[Install Redis Enterprise]({{< relref "/operate/rs/installing-upgrading/install" >}})
+for full installation instructions.
+
+## License and source code
+
+The Redis Query Engine features of Redis are available under the Source Available License 2.0 (RSALv2), the Server Side Public License v1 (SSPLv1), or the GNU Affero General Public License version 3 (AGPLv3). Please read the [license file](https://raw.githubusercontent.com/RediSearch/RediSearch/master/LICENSE.txt) for further details. The source code and the [detailed release notes](https://github.com/RediSearch/RediSearch/releases) are available on [GitHub](https://github.com/RediSearch/RediSearch).
+
+Do you have questions? Feel free to ask at the [RediSearch forum](https://forum.redis.com/c/modules/redisearch/).
+
+<br/>
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Payload support(deprecated)
+linkTitle: Payload
+title: Document payloads
+weight: 12
+---
+
+{{% alert title="Warning" color="warning" %}}
+The payload feature is deprecated in 2.0
+{{% /alert %}}
+    
+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.
+
+Since the scoring functions already have access to the DocumentMetaData, which contains document flags and score, Redis can add custom payloads that can be evaluated in run-time.
+
+Payloads are NOT indexed and are not treated by the engine in any way. They are simply there for the purpose of evaluating them in query time, and optionally retrieving them. They can be JSON objects, strings, or preferably, if you are interested in fast evaluation, some sort of binary encoded data which is fast to decode.
+
+## Evaluating payloads in query time
+
+When implementing a scoring function, the signature of the function exposed is:
+
+```c
+double (*ScoringFunction)(DocumentMetadata *dmd, IndexResult *h);
+```
+
+{{% alert title="Note" color="info" %}}
+Currently, scoring functions cannot be dynamically added, and forking the engine and replacing them is required.
+{{% /alert %}}
+
+DocumentMetaData includes a few fields, one of them being the payload. It wraps a simple byte array with arbitrary length:
+
+```c
+typedef struct  {
+    char *data,
+    uint32_t len;
+} DocumentPayload;
+```
+
+If no payload was set to the document, it is simply NULL. If it is not, you can go ahead and decode it. It is recommended to encode some metadata about the payload inside it, like a leading version number, etc.
+
+## Retrieving payloads from documents
+
+When searching, it is possible to request the document payloads from the engine. 
+
+This is done by adding the keyword `WITHPAYLOADS` to [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}). 
+
+If `WITHPAYLOADS` is set, the payloads follow the document id in the returned result. 
+If `WITHSCORES` is set as well, the payloads follow the scores.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Notes on RediSearch debugging, testing, and documentation
+linkTitle: Developer notes
+title: Developer notes
+weight: 3
+---
+
+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:
+
+```sh
+git clone --recursive https://github.com/RediSearch/RediSearch.git
+```
+
+## Working in an isolated environment
+
+There are several reasons to develop in an isolated environment, like keeping your workstation clean, and developing for a different Linux distribution.
+The most general option for an isolated environment is a virtual machine. It's very easy to set one up using [Vagrant](https://www.vagrantup.com)).
+Docker is even more agile, as it offers an almost instant solution:
+
+```
+search=$(docker run -d -it -v $PWD:/build debian:bullseye bash)
+docker exec -it $search bash
+```
+
+Then, from within the container, `cd /build` and go on as usual.
+
+In this mode, all installations remain in the scope of the Docker container.
+Upon exiting the container, you can either re-invoke it with the above `docker exec` or commit the state of the container to an image and re-invoke it at a later stage:
+
+```
+docker commit $search redisearch1
+docker stop $search
+search=$(docker run -d -it -v $PWD:/build rediseatch1 bash)
+docker exec -it $search bash
+```
+
+You can replace `debian:bullseye` with your choice of OS, with the host OS being the best choice allowing you to run the RediSearch binary on your host after it is built.
+
+## Installing prerequisites
+
+To build and test RediSearch you need to install several packages, depending on the underlying OS. The following OSes are supported:
+- Ubuntu 18.04
+- Ubuntu 20.04
+- Ubuntu 22.04
+- Debian linux 11
+- Rocky linux 8
+- Rocky linux 9
+- Amazon linux 2
+- Mariner 2.0
+- MacOS
+
+To install the prerequisites on your system using a setup script, first enter the `RediSearch` directory and then run:
+
+```
+cd ./install
+./install_script.sh sudo
+./install_boost.sh 1.83.0
+```
+
+Note that this will install various packages on your system using the native package manager (`sudo` is not required in a Docker environment).
+
+If you prefer to avoid that, you can:
+
+* Review the relevant setup scripts under the `./install` directory and install packages manually.
+* Use an isolated environment as explained above.
+
+
+## Installing Redis
+As a rule of thumb, you should run the latest Redis version.
+
+If your OS has a Redis 7.x package, you can install it using the OS package manager.
+
+Otherwise, you can build it from source and install it as described in [redis GitHub page](https://github.com/redis/redis).
+
+## Getting help
+
+```make help``` provides a quick summary of the development features. Following is a partial list that contains  the most common and relevant ones:
+
+```
+make fetch         # download and prepare dependant modules
+
+make build          # compile and link
+  COORD=1             # build coordinator
+  DEBUG=1             # build for debugging
+  NO_TESTS=1          # disable unit tests
+  WHY=1               # explain CMake decisions (in /tmp/cmake-why)
+  FORCE=1             # Force CMake rerun (default)
+  CMAKE_ARGS=...      # extra arguments to CMake
+  VG=1                # build for Valgrind
+  SAN=type            # build with LLVM sanitizer (type=address|memory|leak|thread) 
+  SLOW=1              # do not parallelize build (for diagnostics)
+  GCC=1               # build with GCC (default unless Sanitizer)
+  CLANG=1             # build with CLang
+  STATIC_LIBSTDCXX=0  # link libstdc++ dynamically (default: 1)
+make parsers       # build parsers code (required after chaging files under query_parser dir)
+make clean         # remove build artifacts
+  ALL=1              # remove entire artifacts directory
+
+make run           # run redis with RediSearch
+  COORD=1            # run three local shards with coordinator (assuming the module was built with coordinator support)
+  GDB=1              # invoke using gdb
+
+make test          # run all tests
+  COORD=1            # test coordinator
+  TEST=name          # run specified test
+make pytest        # run python tests (tests/pytests)
+  COORD=1            # test coordinator 
+  TEST=name          # e.g. TEST=test:testSearch
+  RLTEST_ARGS=...    # pass args to RLTest
+  REJSON=1|0|get     # also load JSON module (default: 1)
+  REJSON_PATH=path   # use JSON module at `path`
+  EXT=1              # External (existing) environment
+  GDB=1              # RLTest interactive debugging
+  VG=1               # use Valgrind
+  VG_LEAKS=0         # do not search leaks with Valgrind
+  SAN=type           # use LLVM sanitizer (type=address|memory|leak|thread) 
+make unit-tests    # run unit tests (C and C++)
+  TEST=name          # e.g. TEST=FGCTest.testRemoveLastBlock
+make c_tests       # run C tests (from tests/ctests)
+make cpp_tests     # run C++ tests (from tests/cpptests)
+
+make callgrind     # produce a call graph
+  REDIS_ARGS="args"
+
+make sanbox        # create container with CLang Sanitizer
+```
+
+## Building from source
+
+Run the following from the project root dir:
+
+```make build``` will build RediSearch.
+
+`make build COORD=1` will build Redis Open Source RediSearch Coordinator.
+
+`make build STATIC=1` will build as a static library.
+
+Notes:
+
+* Binary files are placed under `bin`, according to platform and build variant.
+* RediSearch uses [CMake](https://cmake.org) as its build system. ```make build``` will invoke both CMake and the subsequent make command that's required to complete the build.
+
+Use ```make clean``` to remove build artifacts. ```make clean ALL=1``` will remove the entire `bin` subdirectory.
+
+### Diagnosing the build process
+
+`make build` will build in parallel by default.
+
+For the purposes of build diagnosis, `make build SLOW=1 VERBOSE=1` can be used to examine compilation commands.
+
+## Running Redis with RediSearch
+
+The following will run ```redis``` and load the RediSearch module.
+
+```
+make run
+```
+You can open ```redis-cli``` in another terminal to interact with it.
+
+## Running tests
+
+There are several sets of unit tests:
+* C tests, located in ```tests/ctests```, run by ```make c-tests```.
+* C++ tests (enabled by GTest), located in ```tests/cpptests```, run by ```make cpp-tests```.
+* Python tests (enabled by RLTest), located in ```tests/pytests```, run by ```make pytest```.
+
+You can run all tests by invoking ```make test```.
+
+A single test can be run using the ```TEST``` parameter, e.g., ```make test TEST=regex```.
+
+## Debugging
+
+To build for debugging (enabling symbolic information and disabling optimization), run ```make DEBUG=1```.
+You can then use ```make run DEBUG=1``` to invoke ```gdb```.
+In addition to the usual way to set breakpoints in ```gdb```, it is possible to use the ```BB``` macro to set a breakpoint inside the RediSearch code. It will only have an effect when running under ```gdb```.
+
+Similarly, Python tests in a single-test mode, you can set a breakpoint by using the ```BB()``` function inside a test.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Deprecated features
+linkTitle: Deprecated
+title: Deprecated
+weight: 10
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How transactions work in Redis
+linkTitle: Transactions
+title: Transactions
+weight: 30
+---
+
+Redis Transactions allow the execution of a group of commands
+in a single step, they are centered around the commands 
+[`MULTI`]({{< relref "/commands/multi" >}}), [`EXEC`]({{< relref "/commands/exec" >}}), [`DISCARD`]({{< relref "/commands/discard" >}}) and [`WATCH`]({{< relref "/commands/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.
+
+* The [`EXEC`]({{< relref "/commands/exec" >}}) command
+triggers the execution of all the commands in the transaction, so
+if a client loses the connection to the server in the context of a
+transaction before calling the [`EXEC`]({{< relref "/commands/exec" >}}) command none of the operations
+are performed, instead if the [`EXEC`]({{< relref "/commands/exec" >}}) command is called, all the
+operations are performed. When using the
+[append-only file]({{< relref "/operate/oss_and_stack/management/persistence#append-only-file" >}}) Redis makes sure
+to use a single write(2) syscall to write the transaction on disk.
+However if the Redis server crashes or is killed by the system administrator
+in some hard way it is possible that only a partial number of operations
+are registered. Redis will detect this condition at restart, and will exit with an error.
+Using the `redis-check-aof` tool it is possible to fix the
+append only file that will remove the partial transaction so that the
+server can start again.
+
+Starting with version 2.2, Redis allows for an extra guarantee to the
+above two, in the form of optimistic locking in a way very similar to a
+check-and-set (CAS) operation.
+This is documented [later](#cas) on this page.
+
+## Usage
+
+A Redis Transaction is entered using the [`MULTI`]({{< relref "/commands/multi" >}}) command. The command
+always replies with `OK`. At this point the user can issue multiple
+commands. Instead of executing these commands, Redis will queue
+them. All the commands are executed once [`EXEC`]({{< relref "/commands/exec" >}}) is called.
+
+Calling [`DISCARD`]({{< relref "/commands/discard" >}}) instead will flush the transaction queue and will exit
+the transaction.
+
+The following example increments keys `foo` and `bar` atomically.
+
+```
+> MULTI
+OK
+> INCR foo
+QUEUED
+> INCR bar
+QUEUED
+> EXEC
+1) (integer) 1
+2) (integer) 1
+```
+
+As is clear from the session above, [`EXEC`]({{< relref "/commands/exec" >}}) returns an
+array of replies, where every element is the reply of a single command
+in the transaction, in the same order the commands were issued.
+
+When a Redis connection is in the context of a [`MULTI`]({{< relref "/commands/multi" >}}) request,
+all commands will reply with the string `QUEUED` (sent as a Status Reply
+from the point of view of the Redis protocol). A queued command is
+simply scheduled for execution when [`EXEC`]({{< relref "/commands/exec" >}}) is called.
+
+## Errors inside a transaction
+
+During a transaction it is possible to encounter two kind of command errors:
+
+* A command may fail to be queued, so there may be an error before [`EXEC`]({{< relref "/commands/exec" >}}) is called.
+For instance the command may be syntactically wrong (wrong number of arguments,
+wrong command name, ...), or there may be some critical condition like an out of
+memory condition (if the server is configured to have a memory limit using the `maxmemory` directive).
+* A command may fail *after* [`EXEC`]({{< relref "/commands/exec" >}}) is called, for instance since we performed
+an operation against a key with the wrong value (like calling a list operation against a string value).
+
+Starting with Redis 2.6.5, the server will detect an error during the accumulation of commands.
+It will then refuse to execute the transaction returning an error during [`EXEC`]({{< relref "/commands/exec" >}}), discarding the transaction.
+
+> **Note for Redis < 2.6.5:** Prior to Redis 2.6.5 clients needed to detect errors occurring prior to [`EXEC`]({{< relref "/commands/exec" >}}) by checking
+the return value of the queued command: if the command replies with QUEUED it was
+queued correctly, otherwise Redis returns an error.
+If there is an error while queueing a command, most clients
+will abort and discard the transaction. Otherwise, if the client elected to proceed with the transaction
+the [`EXEC`]({{< relref "/commands/exec" >}}) command would execute all commands queued successfully regardless of previous errors.
+
+Errors happening *after* [`EXEC`]({{< relref "/commands/exec" >}}) instead are not handled in a special way:
+all the other commands will be executed even if some command fails during the transaction.
+
+This is more clear on the protocol level. In the following example one
+command will fail when executed even if the syntax is right:
+
+```
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+MULTI
++OK
+SET a abc
++QUEUED
+LPOP a
++QUEUED
+EXEC
+*2
++OK
+-WRONGTYPE Operation against a key holding the wrong kind of value
+```
+
+[`EXEC`]({{< relref "/commands/exec" >}}) returned two-element [bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-string-reply" >}}) where one is an `OK` code and
+the other an error reply. It's up to the client library to find a
+sensible way to provide the error to the user.
+
+It's important to note that
+**even when a command fails, all the other commands in the queue are processed** – Redis will _not_ stop the
+processing of commands.
+
+Another example, again using the wire protocol with `telnet`, shows how
+syntax errors are reported ASAP instead:
+
+```
+MULTI
++OK
+INCR a b c
+-ERR wrong number of arguments for 'incr' command
+```
+
+This time due to the syntax error the bad [`INCR`]({{< relref "/commands/incr" >}}) command is not queued
+at all.
+
+## What about rollbacks?
+
+Redis does not support rollbacks of transactions since supporting rollbacks
+would have a significant impact on the simplicity and performance of Redis.
+
+## Discarding the command queue
+
+[`DISCARD`]({{< relref "/commands/discard" >}}) can be used in order to abort a transaction. In this case, no
+commands are executed and the state of the connection is restored to
+normal.
+
+```
+> SET foo 1
+OK
+> MULTI
+OK
+> INCR foo
+QUEUED
+> DISCARD
+OK
+> GET foo
+"1"
+```
+<a name="cas"></a>
+
+## Optimistic locking using check-and-set
+
+[`WATCH`]({{< relref "/commands/watch" >}}) is used to provide a check-and-set (CAS) behavior to Redis
+transactions.
+
+[`WATCH`]({{< relref "/commands/watch" >}})ed keys are monitored in order to detect changes against them. If
+at least one watched key is modified before the [`EXEC`]({{< relref "/commands/exec" >}}) command, the
+whole transaction aborts, and [`EXEC`]({{< relref "/commands/exec" >}}) returns a [Null reply]({{< relref "/develop/reference/protocol-spec#nil-reply" >}}) to notify that
+the transaction failed.
+
+For example, imagine we have the need to atomically increment the value
+of a key by 1 (let's suppose Redis doesn't have [`INCR`]({{< relref "/commands/incr" >}})).
+
+The first try may be the following:
+
+```
+val = GET mykey
+val = val + 1
+SET mykey $val
+```
+
+This will work reliably only if we have a single client performing the
+operation in a given time. If multiple clients try to increment the key
+at about the same time there will be a race condition. For instance,
+client A and B will read the old value, for instance, 10. The value will
+be incremented to 11 by both the clients, and finally [`SET`]({{< relref "/commands/set" >}}) as the value
+of the key. So the final value will be 11 instead of 12.
+
+Thanks to [`WATCH`]({{< relref "/commands/watch" >}}) we are able to model the problem very well:
+
+```
+WATCH mykey
+val = GET mykey
+val = val + 1
+MULTI
+SET mykey $val
+EXEC
+```
+
+Using the above code, if there are race conditions and another client
+modifies the result of `val` in the time between our call to [`WATCH`]({{< relref "/commands/watch" >}}) and
+our call to [`EXEC`]({{< relref "/commands/exec" >}}), the transaction will fail.
+
+We just have to repeat the operation hoping this time we'll not get a
+new race. This form of locking is called _optimistic locking_.
+In many use cases, multiple clients will be accessing different keys,
+so collisions are unlikely – usually there's no need to repeat the operation.
+
+## WATCH explained
+
+So what is [`WATCH`]({{< relref "/commands/watch" >}}) really about? It is a command that will
+make the [`EXEC`]({{< relref "/commands/exec" >}}) conditional: we are asking Redis to perform
+the transaction only if none of the [`WATCH`]({{< relref "/commands/watch" >}})ed keys were modified. This includes
+modifications made by the client, like write commands, and by Redis itself,
+like expiration or eviction. If keys were modified between when they were
+[`WATCH`]({{< relref "/commands/watch" >}})ed and when the [`EXEC`]({{< relref "/commands/exec" >}}) was received, the entire transaction will be aborted
+instead.
+
+**NOTE**
+* In Redis versions before 6.0.9, an expired key would not cause a transaction
+to be aborted. [More on this](https://github.com/redis/redis/pull/7920)
+* Commands within a transaction won't trigger the [`WATCH`]({{< relref "/commands/watch" >}}) condition since they
+are only queued until the [`EXEC`]({{< relref "/commands/exec" >}}) is sent.
+
+[`WATCH`]({{< relref "/commands/watch" >}}) can be called multiple times. Simply all the [`WATCH`]({{< relref "/commands/watch" >}}) calls will
+have the effects to watch for changes starting from the call, up to
+the moment [`EXEC`]({{< relref "/commands/exec" >}}) is called. You can also send any number of keys to a
+single [`WATCH`]({{< relref "/commands/watch" >}}) call.
+
+When [`EXEC`]({{< relref "/commands/exec" >}}) is called, all keys are [`UNWATCH`]({{< relref "/commands/unwatch" >}})ed, regardless of whether
+the transaction was aborted or not.  Also when a client connection is
+closed, everything gets [`UNWATCH`]({{< relref "/commands/unwatch" >}})ed.
+
+It is also possible to use the [`UNWATCH`]({{< relref "/commands/unwatch" >}}) command (without arguments)
+in order to flush all the watched keys. Sometimes this is useful as we
+optimistically lock a few keys, since possibly we need to perform a
+transaction to alter those keys, but after reading the current content
+of the keys we don't want to proceed.  When this happens we just call
+[`UNWATCH`]({{< relref "/commands/unwatch" >}}) so that the connection can already be used freely for new
+transactions.
+
+### Using WATCH to implement ZPOP
+
+A good example to illustrate how [`WATCH`]({{< relref "/commands/watch" >}}) can be used to create new
+atomic operations otherwise not supported by Redis is to implement ZPOP
+([`ZPOPMIN`]({{< relref "/commands/zpopmin" >}}), [`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) and their blocking variants have only been added
+in version 5.0), that is a command that pops the element with the lower
+score from a sorted set in an atomic way. This is the simplest
+implementation:
+
+```
+WATCH zset
+element = ZRANGE zset 0 0
+MULTI
+ZREM zset element
+EXEC
+```
+
+If [`EXEC`]({{< relref "/commands/exec" >}}) fails (i.e. returns a [Null reply]({{< relref "/develop/reference/protocol-spec#nil-reply" >}})) we just repeat the operation.
+
+## Redis scripting and transactions
+
+Something else to consider for transaction like operations in redis are
+[redis scripts]({{< relref "/commands/eval" >}}) which are transactional. Everything
+you can do with a Redis Transaction, you can also do with a script, and
+usually the script will be both simpler and faster.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'How to interact with data in Redis, including queries, triggered
+  functions, transactions, and pub/sub'
+linkTitle: Interact with data
+title: Interact with data in Redis
+hideListLinks: true
+weight: 40
+---
+
+Redis is useful as a key-value store but also gives you other powerful ways
+to interact with your data:
+
+- [Redis Query Engine](#search-and-query)
+- [Programmability](#programmability)
+- [Transactions](#transactions)
+- [Publish/subscribe](#publishsubscribe)
+
+## Search and query with the Redis Query Engine
+
+The [Redis query engine]({{< relref "/develop/interact/search-and-query" >}})
+lets you retrieve data by content rather than by key. You
+can [index]({{< relref "/develop/interact/search-and-query/indexing" >}})
+the fields of [hash]({{< relref "/develop/data-types/hashes" >}})
+and [JSON]({{< relref "/develop/data-types/json" >}}) objects
+according to their type and then perform sophisticated
+[queries]({{< relref "/develop/interact/search-and-query/query" >}})
+on those fields. For example, you can use queries to find:
+  - matches in
+    [text fields]({{< relref "/develop/interact/search-and-query/query/full-text" >}})
+  - numeric values that fall within a specified
+    [range]({{< relref "/develop/interact/search-and-query/query/range" >}})
+  - [Geospatial]({{< relref "/develop/interact/search-and-query/query/geo-spatial" >}})
+    coordinates that fall within a specified area
+  - [Vector matches]({{< relref "/develop/interact/search-and-query/query/vector-search" >}})
+    against [word embeddings](https://en.wikipedia.org/wiki/Word_embedding) calculated from
+    your text data
+
+## Programmability
+
+Redis has an [interface]({{< relref "/develop/interact/programmability" >}})
+for the [Lua programming language](https://www.lua.org/)
+that lets you store and execute scripts on the server. Use scripts
+to ensure that different clients always update data using the same logic.
+You can also reduce network traffic by reimplementing a sequence of
+related client-side commands as a single server script.
+
+## Transactions
+
+A client will often execute a sequence of commands to make
+a set of related changes to data objects. However, another client could also
+modify the same data object with similar commands in between. This situation can create
+corrupt or inconsistent data.
+
+Use a [transaction]({{< relref "/develop/interact/transactions" >}}) to
+group several commands from a client together as a single unit. The
+commands in the transaction are guaranteed to execute in sequence without
+interruptions from other clients' commands.
+
+You can also use the
+[`WATCH`]({{< relref "/commands/watch" >}}) command to check for changes
+to the keys used in a transaction just before it executes. If the data you
+are watching changes while you construct the transaction then
+execution safely aborts. Use this feature for efficient
+[optimistic concurrency control](https://en.wikipedia.org/wiki/Optimistic_concurrency_control)
+in the common case where data is usually accessed only by one client
+at a time.
+
+## Publish/subscribe
+
+Redis has a [publish/subscribe]({{< relref "/develop/interact/pubsub" >}}) (Pub/sub)
+feature that implements the well-known
+[design pattern](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern)
+of the same name. You can *publish* messages from a particular client
+connection to a channel maintained by the server. Other connections that have
+*subscribed* to the channel will receive the messages in the order you sent them.
+Use pub/sub to share small amounts of data among clients easily and
+efficiently.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Scripting with Redis 7 and beyond
+
+  '
+linkTitle: Functions
+title: Redis functions
+weight: 1
+---
+
+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]({{< relref "/develop/interact/programmability/eval-intro" >}}) in prior versions of Redis.
+
+## Prologue (or, what's wrong with Eval Scripts?)
+
+Prior versions of Redis made scripting available only via the [`EVAL`]({{< relref "/commands/eval" >}}) command, which allows a Lua script to be sent for execution by the server.
+The core use cases for [Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) 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.
+
+Using [`EVAL`]({{< relref "/commands/eval" >}}) requires that the application sends the entire script for execution every time.
+Because this results in network and script compilation overheads, Redis provides an optimization in the form of the [`EVALSHA`]({{< relref "/commands/evalsha" >}}) command. By first calling [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) to obtain the script's SHA1, the application can invoke it repeatedly afterward with its digest alone.
+
+By design, Redis only caches the loaded scripts.
+That means that the script cache can become lost at any time, such as after calling [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}), after restarting the server, or when failing over to a replica.
+The application is responsible for reloading scripts during runtime if any are missing.
+The underlying assumption is that scripts are a part of the application and not maintained by the Redis server.
+
+This approach suits many light-weight scripting use cases, but introduces several difficulties once an application becomes complex and relies more heavily on scripting, namely:
+
+1. All client application instances must maintain a copy of all scripts. That means having some mechanism that applies script updates to all of the application's instances.
+1. Calling cached scripts within the context of a [transaction]({{< relref "/develop/interact/transactions" >}}) increases the probability of the transaction failing because of a missing script. Being more likely to fail makes using cached scripts as building blocks of workflows less attractive.
+1. SHA1 digests are meaningless, making debugging the system extremely hard (e.g., in a [`MONITOR`]({{< relref "/commands/monitor" >}}) session).
+1. When used naively, [`EVAL`]({{< relref "/commands/eval" >}}) promotes an anti-pattern in which scripts the client application renders verbatim scripts instead of responsibly using the [`KEYS` and `ARGV` Lua APIs]({{< relref "develop/interact/programmability/lua-api#runtime-globals" >}}).
+1. Because they are ephemeral, a script can't call another script. This makes sharing and reusing code between scripts nearly impossible, short of client-side preprocessing (see the first point).
+
+To address these needs while avoiding breaking changes to already-established and well-liked ephemeral scripts, Redis v7.0 introduces Redis Functions.
+
+## What are Redis Functions?
+
+Redis functions are an evolutionary step from ephemeral scripting.
+
+Functions provide the same core functionality as scripts but are first-class software artifacts of the database.
+Redis manages functions as an integral part of the database and ensures their availability via data persistence and replication.
+Because functions are part of the database and therefore declared before use, applications aren't required to load them during runtime nor risk aborted transactions.
+An application that uses functions depends only on their APIs rather than on the embedded script logic in the database.
+
+Whereas ephemeral scripts are considered a part of the application's domain, functions extend the database server itself with user-provided logic.
+They can be used to expose a richer API composed of core Redis commands, similar to modules, developed once, loaded at startup, and used repeatedly by various applications / clients.
+Every function has a unique user-defined name, making it much easier to call and trace its execution.
+
+The design of Redis Functions also attempts to demarcate between the programming language used for writing functions and their management by the server.
+Lua, the only language interpreter that Redis presently support as an embedded execution engine, is meant to be simple and easy to learn.
+However, the choice of Lua as a language still presents many Redis users with a challenge.
+
+The Redis Functions feature makes no assumptions about the implementation's language.
+An execution engine that is part of the definition of the function handles running it.
+An engine can theoretically execute functions in any language as long as it respects several rules (such as the ability to terminate an executing function).
+
+Presently, as noted above, Redis ships with a single embedded [Lua 5.1]({{< relref "develop/interact/programmability/lua-api" >}}) engine.
+There are plans to support additional engines in the future.
+Redis functions can use all of Lua's available capabilities to ephemeral scripts,
+with the only exception being the [Redis Lua scripts debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}).
+
+Functions also simplify development by enabling code sharing.
+Every function belongs to a single library, and any given library can consist of multiple functions.
+The library's contents are immutable, and selective updates of its functions aren't allowed.
+Instead, libraries are updated as a whole with all of their functions together in one operation.
+This allows calling functions from other functions within the same library, or sharing code between functions by using a common code in library-internal methods, that can also take language native arguments.
+
+Functions are intended to better support the use case of maintaining a consistent view for data entities through a logical schema, as mentioned above.
+As such, functions are stored alongside the data itself.
+Functions are also persisted to the AOF file and replicated from master to replicas, so they are as durable as the data itself.
+When Redis is used as an ephemeral cache, additional mechanisms (described below) are required to make functions more durable.
+
+Like all other operations in Redis, the execution of a function is atomic.
+A function's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/interact/transactions" >}}).
+These semantics mean that all of the script's effects either have yet to happen or had already happened.
+The blocking semantics of an executed function apply to all connected clients at all times.
+Because running a function blocks the Redis server, functions are meant to finish executing quickly, so you should avoid using long-running functions.
+
+## Loading libraries and functions
+
+Let's explore Redis Functions via some tangible examples and Lua snippets.
+
+At this point, if you're unfamiliar with Lua in general and specifically in Redis, you may benefit from reviewing some of the examples in [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) and [Lua API]({{< relref "develop/interact/programmability/lua-api" >}}) pages for a better grasp of the language.
+
+Every Redis function belongs to a single library that's loaded to Redis.
+Loading a library to the database is done with the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command.
+The command gets the library payload as input,
+the library payload must start with Shebang statement that provides a metadata about the library (like the engine to use and the library name).
+The Shebang format is:
+```
+#!<engine name> name=<library name>
+```
+
+Let's try loading an empty library:
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib\n"
+(error) ERR No functions registered
+```
+
+The error is expected, as there are no functions in the loaded library. Every library needs to include at least one registered function to load successfully.
+A registered function is named and acts as an entry point to the library.
+When the target execution engine handles the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command, it registers the library's functions.
+
+The Lua engine compiles and evaluates the library source code when loaded, and expects functions to be registered by calling the `redis.register_function()` API.
+
+The following snippet demonstrates a simple library registering a single function named _knockknock_, returning a string reply:
+
+```lua
+#!lua name=mylib
+redis.register_function(
+  'knockknock',
+  function() return 'Who\'s there?' end
+)
+```
+
+In the example above, we provide two arguments about the function to Lua's `redis.register_function()` API: its registered name and a callback.
+
+We can load our library and use [`FCALL`]({{< relref "/commands/fcall" >}}) to call the registered function:
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib\nredis.register_function('knockknock', function() return 'Who\\'s there?' end)"
+mylib
+redis> FCALL knockknock 0
+"Who's there?"
+```
+
+Notice that the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command returns the name of the loaded library, this name can later be used [`FUNCTION LIST`]({{< relref "/commands/function-list" >}}) and [`FUNCTION DELETE`]({{< relref "/commands/function-delete" >}}).
+
+We've provided [`FCALL`]({{< relref "/commands/fcall" >}}) with two arguments: the function's registered name and the numeric value `0`. This numeric value indicates the number of key names that follow it (the same way [`EVAL`]({{< relref "/commands/eval" >}}) and [`EVALSHA`]({{< relref "/commands/evalsha" >}}) work).
+
+We'll explain immediately how key names and additional arguments are available to the function. As this simple example doesn't involve keys, we simply use 0 for now.
+
+## Input keys and regular arguments
+
+Before we move to the following example, it is vital to understand the distinction Redis makes between arguments that are names of keys and those that aren't.
+
+While key names in Redis are just strings, unlike any other string values, these represent keys in the database.
+The name of a key is a fundamental concept in Redis and is the basis for operating the Redis Cluster.
+
+**Important:**
+To ensure the correct execution of Redis Functions, both in standalone and clustered deployments, all names of keys that a function accesses must be explicitly provided as input key arguments.
+
+Any input to the function that isn't the name of a key is a regular input argument.
+
+Now, let's pretend that our application stores some of its data in Redis Hashes.
+We want an [`HSET`]({{< relref "/commands/hset" >}})-like way to set and update fields in said Hashes and store the last modification time in a new field named `_last_modified_`.
+We can implement a function to do all that.
+
+Our function will call [`TIME`]({{< relref "/commands/time" >}}) to get the server's clock reading and update the target Hash with the new fields' values and the modification's timestamp.
+The function we'll implement accepts the following input arguments: the Hash's key name and the field-value pairs to update.
+
+The Lua API for Redis Functions makes these inputs accessible as the first and second arguments to the function's callback.
+The callback's first argument is a Lua table populated with all key names inputs to the function.
+Similarly, the callback's second argument consists of all regular arguments.
+
+The following is a possible implementation for our function and its library registration:
+
+```lua
+#!lua name=mylib
+
+local function my_hset(keys, args)
+  local hash = keys[1]
+  local time = redis.call('TIME')[1]
+  return redis.call('HSET', hash, '_last_modified_', time, unpack(args))
+end
+
+redis.register_function('my_hset', my_hset)
+```
+
+If we create a new file named _mylib.lua_ that consists of the library's definition, we can load it like so (without stripping the source code of helpful whitespaces):
+
+```bash
+$ cat mylib.lua | redis-cli -x FUNCTION LOAD REPLACE
+```
+
+We've added the `REPLACE` modifier to the call to [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) to tell Redis that we want to overwrite the existing library definition.
+Otherwise, we would have gotten an error from Redis complaining that the library already exists.
+
+Now that the library's updated code is loaded to Redis, we can proceed and call our function:
+
+```
+redis> FCALL my_hset 1 myhash myfield "some value" another_field "another value"
+(integer) 3
+redis> HGETALL myhash
+1) "_last_modified_"
+2) "1640772721"
+3) "myfield"
+4) "some value"
+5) "another_field"
+6) "another value"
+```
+
+In this case, we had invoked [`FCALL`]({{< relref "/commands/fcall" >}}) with _1_ as the number of key name arguments.
+That means that the function's first input argument is a name of a key (and is therefore included in the callback's `keys` table).
+After that first argument, all following input arguments are considered regular arguments and constitute the `args` table passed to the callback as its second argument.
+
+## Expanding the library
+
+We can add more functions to our library to benefit our application.
+The additional metadata field we've added to the Hash shouldn't be included in responses when accessing the Hash's data.
+On the other hand, we do want to provide the means to obtain the modification timestamp for a given Hash key.
+
+We'll add two new functions to our library to accomplish these objectives:
+
+1. The `my_hgetall` Redis Function will return all fields and their respective values from a given Hash key name, excluding the metadata (i.e., the `_last_modified_` field).
+1. The `my_hlastmodified` Redis Function will return the modification timestamp for a given Hash key name.
+
+The library's source code could look something like the following:
+
+```lua
+#!lua name=mylib
+
+local function my_hset(keys, args)
+  local hash = keys[1]
+  local time = redis.call('TIME')[1]
+  return redis.call('HSET', hash, '_last_modified_', time, unpack(args))
+end
+
+local function my_hgetall(keys, args)
+  redis.setresp(3)
+  local hash = keys[1]
+  local res = redis.call('HGETALL', hash)
+  res['map']['_last_modified_'] = nil
+  return res
+end
+
+local function my_hlastmodified(keys, args)
+  local hash = keys[1]
+  return redis.call('HGET', hash, '_last_modified_')
+end
+
+redis.register_function('my_hset', my_hset)
+redis.register_function('my_hgetall', my_hgetall)
+redis.register_function('my_hlastmodified', my_hlastmodified)
+```
+
+While all of the above should be straightforward, note that the `my_hgetall` also calls [`redis.setresp(3)`]({{< relref "develop/interact/programmability/lua-api#redis.setresp" >}}).
+That means that the function expects [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md) replies after calling `redis.call()`, which, unlike the default RESP2 protocol, provides dictionary (associative arrays) replies.
+Doing so allows the function to delete (or set to `nil` as is the case with Lua tables) specific fields from the reply, and in our case, the `_last_modified_` field.
+
+Assuming you've saved the library's implementation in the _mylib.lua_ file, you can replace it with:
+
+```bash
+$ cat mylib.lua | redis-cli -x FUNCTION LOAD REPLACE
+```
+
+Once loaded, you can call the library's functions with [`FCALL`]({{< relref "/commands/fcall" >}}):
+
+```
+redis> FCALL my_hgetall 1 myhash
+1) "myfield"
+2) "some value"
+3) "another_field"
+4) "another value"
+redis> FCALL my_hlastmodified 1 myhash
+"1640772721"
+```
+
+You can also get the library's details with the [`FUNCTION LIST`]({{< relref "/commands/function-list" >}}) command:
+
+```
+redis> FUNCTION LIST
+1) 1) "library_name"
+   2) "mylib"
+   3) "engine"
+   4) "LUA"
+   5) "functions"
+   6) 1) 1) "name"
+         2) "my_hset"
+         3) "description"
+         4) (nil)
+         5) "flags"
+         6) (empty array)
+      2) 1) "name"
+         2) "my_hgetall"
+         3) "description"
+         4) (nil)
+         5) "flags"
+         6) (empty array)
+      3) 1) "name"
+         2) "my_hlastmodified"
+         3) "description"
+         4) (nil)
+         5) "flags"
+         6) (empty array)
+```
+
+You can see that it is easy to update our library with new capabilities.
+
+## Reusing code in the library
+
+On top of bundling functions together into database-managed software artifacts, libraries also facilitate code sharing.
+We can add to our library an error handling helper function called from other functions.
+The helper function `check_keys()` verifies that the input _keys_ table has a single key.
+Upon success it returns `nil`, otherwise it returns an [error reply]({{< relref "develop/interact/programmability/lua-api#redis.error_reply" >}}).
+
+The updated library's source code would be:
+
+```lua
+#!lua name=mylib
+
+local function check_keys(keys)
+  local error = nil
+  local nkeys = table.getn(keys)
+  if nkeys == 0 then
+    error = 'Hash key name not provided'
+  elseif nkeys > 1 then
+    error = 'Only one key name is allowed'
+  end
+
+  if error ~= nil then
+    redis.log(redis.LOG_WARNING, error);
+    return redis.error_reply(error)
+  end
+  return nil
+end
+
+local function my_hset(keys, args)
+  local error = check_keys(keys)
+  if error ~= nil then
+    return error
+  end
+
+  local hash = keys[1]
+  local time = redis.call('TIME')[1]
+  return redis.call('HSET', hash, '_last_modified_', time, unpack(args))
+end
+
+local function my_hgetall(keys, args)
+  local error = check_keys(keys)
+  if error ~= nil then
+    return error
+  end
+
+  redis.setresp(3)
+  local hash = keys[1]
+  local res = redis.call('HGETALL', hash)
+  res['map']['_last_modified_'] = nil
+  return res
+end
+
+local function my_hlastmodified(keys, args)
+  local error = check_keys(keys)
+  if error ~= nil then
+    return error
+  end
+
+  local hash = keys[1]
+  return redis.call('HGET', keys[1], '_last_modified_')
+end
+
+redis.register_function('my_hset', my_hset)
+redis.register_function('my_hgetall', my_hgetall)
+redis.register_function('my_hlastmodified', my_hlastmodified)
+```
+
+After you've replaced the library in Redis with the above, you can immediately try out the new error handling mechanism:
+
+```
+127.0.0.1:6379> FCALL my_hset 0 myhash nope nope
+(error) Hash key name not provided
+127.0.0.1:6379> FCALL my_hgetall 2 myhash anotherone
+(error) Only one key name is allowed
+```
+
+And your Redis log file should have lines in it that are similar to:
+
+```
+...
+20075:M 1 Jan 2022 16:53:57.688 # Hash key name not provided
+20075:M 1 Jan 2022 16:54:01.309 # Only one key name is allowed
+```
+
+## Functions in cluster
+
+As noted above, Redis automatically handles propagation of loaded functions to replicas.
+In a Redis Cluster, it is also necessary to load functions to all cluster nodes. This is not handled automatically by Redis Cluster, and needs to be handled by the cluster administrator (like module loading, configuration setting, etc.).
+
+As one of the goals of functions is to live separately from the client application, this should not be part of the Redis client library responsibilities. Instead, `redis-cli --cluster-only-masters --cluster call host:port FUNCTION LOAD ...` can be used to execute the load command on all master nodes.
+
+Also, note that `redis-cli --cluster add-node` automatically takes care to propagate the loaded functions from one of the existing nodes to the new node.
+
+## Functions and ephemeral Redis instances
+
+In some cases there may be a need to start a fresh Redis server with a set of functions pre-loaded. Common reasons for that could be:
+
+* Starting Redis in a new environment
+* Re-starting an ephemeral (cache-only) Redis, that uses functions
+
+In such cases, we need to make sure that the pre-loaded functions are available before Redis accepts inbound user connections and commands.
+
+To do that, it is possible to use `redis-cli --functions-rdb` to extract the functions from an existing server. This generates an RDB file that can be loaded by Redis at startup.
+
+## Function flags
+
+Redis needs to have some information about how a function is going to behave when executed, in order to properly enforce resource usage policies and maintain data consistency.
+
+For example, Redis needs to know that a certain function is read-only before permitting it to execute using [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) on a read-only replica.
+
+By default, Redis assumes that all functions may perform arbitrary read or write operations. Function Flags make it possible to declare more specific function behavior at the time of registration. Let's see how this works.
+
+In our previous example, we defined two functions that only read data. We can try executing them using [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) against a read-only replica.
+
+```
+redis > FCALL_RO my_hgetall 1 myhash
+(error) ERR Can not execute a function with write flag using fcall_ro.
+```
+
+Redis returns this error because a function can, in theory, perform both read and write operations on the database.
+As a safeguard and by default, Redis assumes that the function does both, so it blocks its execution.
+The server will reply with this error in the following cases:
+
+1. Executing a function with [`FCALL`]({{< relref "/commands/fcall" >}}) against a read-only replica.
+2. Using [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) to execute a function.
+3. A disk error was detected (Redis is unable to persist so it rejects writes).
+
+In these cases, you can add the `no-writes` flag to the function's registration, disable the safeguard and allow them to run.
+To register a function with flags use the [named arguments]({{< relref "develop/interact/programmability/lua-api#redis.register_function_named_args" >}}) variant of `redis.register_function`.
+
+The updated registration code snippet from the library looks like this:
+
+```lua
+redis.register_function('my_hset', my_hset)
+redis.register_function{
+  function_name='my_hgetall',
+  callback=my_hgetall,
+  flags={ 'no-writes' }
+}
+redis.register_function{
+  function_name='my_hlastmodified',
+  callback=my_hlastmodified,
+  flags={ 'no-writes' }
+}
+```
+
+Once we've replaced the library, Redis allows running both `my_hgetall` and `my_hlastmodified` with [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) against a read-only replica:
+
+```
+redis> FCALL_RO my_hgetall 1 myhash
+1) "myfield"
+2) "some value"
+3) "another_field"
+4) "another value"
+redis> FCALL_RO my_hlastmodified 1 myhash
+"1640772721"
+```
+
+For the complete documentation flags, please refer to [Script flags]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to use the built-in Lua debugger
+linkTitle: Debugging Lua
+title: Debugging Lua scripts in Redis
+weight: 4
+---
+
+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:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/IMvRfStaoyM" frameborder="0" allowfullscreen></iframe>
+
+> Important Note:  please make sure to avoid debugging Lua scripts using your Redis production server.
+Use a development server instead.
+Also note that using the synchronous debugging mode (which is NOT the default) results in the Redis server blocking for all the time the debugging session lasts.
+
+To start a new debugging session using `redis-cli` do the following:
+
+1. Create your script in some file with your preferred editor. Let's assume you are editing your Redis Lua script located at `/tmp/script.lua`.
+2. Start a debugging session with:
+
+    ./redis-cli --ldb --eval /tmp/script.lua
+
+Note that with the `--eval` option of `redis-cli` you can pass key names and arguments to the script, separated by a comma, like in the following example:
+
+```
+./redis-cli --ldb --eval /tmp/script.lua mykey somekey , arg1 arg2
+```
+
+You'll enter a special mode where `redis-cli` no longer accepts its normal
+commands, but instead prints a help screen and passes the unmodified debugging
+commands directly to Redis.
+
+The only commands which are not passed to the Redis debugger are:
+
+* `quit` -- this will terminate the debugging session.
+It's like removing all the breakpoints and using the `continue` debugging command.
+Moreover the command will exit from `redis-cli`.
+* `restart` -- the debugging session will restart from scratch, **reloading the new version of the script from the file**.
+So a normal debugging cycle involves modifying the script after some debugging, and calling `restart` in order to start debugging again with the new script changes.
+* `help` -- this command is passed to the Redis Lua debugger, that will print a list of commands like the following:
+
+```
+lua debugger> help
+Redis Lua debugger help:
+[h]elp               Show this help.
+[s]tep               Run current line and stop again.
+[n]ext               Alias for step.
+[c]ontinue           Run till next breakpoint.
+[l]ist               List source code around current line.
+[l]ist [line]        List source code around [line].
+                     line = 0 means: current position.
+[l]ist [line] [ctx]  In this form [ctx] specifies how many lines
+                     to show before/after [line].
+[w]hole              List all source code. Alias for 'list 1 1000000'.
+[p]rint              Show all the local variables.
+[p]rint <var>        Show the value of the specified variable.
+                     Can also show global vars KEYS and ARGV.
+[b]reak              Show all breakpoints.
+[b]reak <line>       Add a breakpoint to the specified line.
+[b]reak -<line>      Remove breakpoint from the specified line.
+[b]reak 0            Remove all breakpoints.
+[t]race              Show a backtrace.
+[e]val <code>        Execute some Lua code (in a different callframe).
+[r]edis <cmd>        Execute a Redis command.
+[m]axlen [len]       Trim logged Redis replies and Lua var dumps to len.
+                     Specifying zero as <len> means unlimited.
+[a]bort              Stop the execution of the script. In sync
+                     mode dataset changes will be retained.
+
+Debugger functions you can call from Lua scripts:
+redis.debug()        Produce logs in the debugger console.
+redis.breakpoint()   Stop execution as if there was a breakpoint in the
+                     next line of code.
+```
+
+Note that when you start the debugger it will start in **stepping mode**.
+It will stop at the first line of the script that actually does something before executing it.
+
+From this point you usually call `step` in order to execute the line and go to the next line.
+While you step Redis will show all the commands executed by the server like in the following example:
+
+```
+* Stopped at 1, stop reason = step over
+-> 1   redis.call('ping')
+lua debugger> step
+<redis> ping
+<reply> "+PONG"
+* Stopped at 2, stop reason = step over
+```
+
+The `<redis>` and `<reply>` lines show the command executed by the line just
+executed, and the reply from the server. Note that this happens only in stepping mode.
+If you use `continue` in order to execute the script till the next breakpoint, commands will not be dumped on the screen to prevent too much output.
+
+## Termination of the debugging session
+
+
+When the scripts terminates naturally, the debugging session ends and
+`redis-cli` returns in its normal non-debugging mode. You can restart the
+session using the `restart` command as usual.
+
+Another way to stop a debugging session is just interrupting `redis-cli`
+manually by pressing `Ctrl+C`. Note that also any event breaking the
+connection between `redis-cli` and the `redis-server` will interrupt the
+debugging session.
+
+All the forked debugging sessions are terminated when the server is shut
+down.
+
+## Abbreviating debugging commands
+
+Debugging can be a very repetitive task. For this reason every Redis
+debugger command starts with a different character, and you can use the single
+initial character in order to refer to the command.
+
+So for example instead of typing `step` you can just type `s`.
+
+## Breakpoints
+
+Adding and removing breakpoints is trivial as described in the online help.
+Just use `b 1 2 3 4` to add a breakpoint in line 1, 2, 3, 4.
+The command `b 0` removes all the breakpoints. Selected breakpoints can be
+removed using as argument the line where the breakpoint we want to remove is, but prefixed by a minus sign. 
+So for example `b -3` removes the breakpoint from line 3.
+
+Note that adding breakpoints to lines that Lua never executes, like declaration of local variables or comments, will not work.
+The breakpoint will be added but since this part of the script will never be executed, the program will never stop.
+
+## Dynamic breakpoints
+
+Using the `breakpoint` command it is possible to add breakpoints into specific
+lines. However sometimes we want to stop the execution of the program only
+when something special happens. In order to do so, you can use the
+`redis.breakpoint()` function inside your Lua script. When called it simulates
+a breakpoint in the next line that will be executed.
+
+```
+if counter > 10 then redis.breakpoint() end
+```
+This feature is extremely useful when debugging, so that we can avoid
+continuing the script execution manually multiple times until a given condition
+is encountered.
+
+## Synchronous mode
+
+As explained previously, but default LDB uses forked sessions with rollback
+of all the data changes operated by the script while it has being debugged.
+Determinism is usually a good thing to have during debugging, so that successive
+debugging sessions can be started without having to reset the database content
+to its original state.
+
+However for tracking certain bugs, you may want to retain the changes performed
+to the key space by each debugging session. When this is a good idea you
+should start the debugger using a special option, `ldb-sync-mode`, in `redis-cli`.
+
+```
+./redis-cli --ldb-sync-mode --eval /tmp/script.lua
+```
+
+> Note: Redis server will be unreachable during the debugging session in this mode, so use with care.
+
+In this special mode, the `abort` command can stop the script half-way taking the changes operated to the dataset.
+Note that this is different compared to ending the debugging session normally. 
+If you just interrupt `redis-cli` the script will be fully executed and then the session terminated.
+Instead with `abort` you can interrupt the script execution in the middle and start a new debugging session if needed.
+
+## Logging from scripts
+
+The `redis.debug()` command is a powerful debugging facility that can be
+called inside the Redis Lua script in order to log things into the debug
+console:
+
+```
+lua debugger> list
+-> 1   local a = {1,2,3}
+   2   local b = false
+   3   redis.debug(a,b)
+lua debugger> continue
+<debug> line 3: {1; 2; 3}, false
+```
+
+If the script is executed outside of a debugging session, `redis.debug()` has no effects at all.
+Note that the function accepts multiple arguments, that are separated by a comma and a space in the output.
+
+Tables and nested tables are displayed correctly in order to make values simple to observe for the programmer debugging the script.
+
+## Inspecting the program state with `print` and `eval`
+
+
+While the `redis.debug()` function can be used in order to print values
+directly from within the Lua script, often it is useful to observe the local
+variables of a program while stepping or when stopped into a breakpoint.
+
+The `print` command does just that, and performs lookup in the call frames
+starting from the current one back to the previous ones, up to top-level.
+This means that even if we are into a nested function inside a Lua script,
+we can still use `print foo` to look at the value of `foo` in the context
+of the calling function. When called without a variable name, `print` will
+print all variables and their respective values.
+
+The `eval` command executes small pieces of Lua scripts **outside the context of the current call frame** (evaluating inside the context of the current call frame is not possible with the current Lua internals).
+However you can use this command in order to test Lua functions.
+
+```
+lua debugger> e redis.sha1hex('foo')
+<retval> "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
+```
+
+## Debugging clients
+
+LDB uses the client-server model where the Redis server acts as a debugging server that communicates using [RESP]({{< relref "/develop/reference/protocol-spec" >}}). While `redis-cli` is the default debug client, any client can be used for debugging as long as it meets one of the following conditions:
+
+1. The client provides a native interface for setting the debug mode and controlling the debug session.
+2. The client provides an interface for sending arbitrary commands over RESP.
+3. The client allows sending raw messages to the Redis server.
+
+For example, the [Redis plugin](https://redis.com/blog/zerobrane-studio-plugin-for-redis-lua-scripts) for [ZeroBrane Studio](http://studio.zerobrane.com/) integrates with LDB using [redis-lua](https://github.com/nrk/redis-lua). The following Lua code is a simplified example of how the plugin achieves that:
+
+```Lua
+local redis = require 'redis'
+
+-- add LDB's Continue command
+redis.commands['ldbcontinue'] = redis.command('C')
+
+-- script to be debugged
+local script = [[
+  local x, y = tonumber(ARGV[1]), tonumber(ARGV[2])
+  local result = x * y
+  return result
+]]
+
+local client = redis.connect('127.0.0.1', 6379)
+client:script("DEBUG", "YES")
+print(unpack(client:eval(script, 0, 6, 9)))
+client:ldbcontinue()
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Executing Lua in Redis
+
+  '
+linkTitle: Lua scripting
+title: Scripting with Lua
+weight: 2
+---
+
+Redis lets users upload and execute Lua scripts on the server.
+Scripts can employ programmatic control structures and use most of the [commands]({{< relref "/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.
+
+Scripting offers several properties that can be valuable in many cases.
+These include:
+
+* Providing locality by executing logic where data lives. Data locality reduces overall latency and saves networking resources.
+* Blocking semantics that ensure the script's atomic execution.
+* Enabling the composition of simple capabilities that are either missing from Redis or are too niche to be a part of it.
+
+Lua lets you run part of your application logic inside Redis.
+Such scripts can perform conditional updates across multiple keys, possibly combining several different data types atomically.
+
+Scripts are executed in Redis by an embedded execution engine.
+Presently, Redis supports a single scripting engine, the [Lua 5.1](https://www.lua.org/) interpreter.
+Please refer to the [Redis Lua API Reference]({{< relref "develop/interact/programmability/lua-api" >}}) page for complete documentation.
+
+Although the server executes them, Eval scripts are regarded as a part of the client-side application, which is why they're not named, versioned, or persisted.
+So all scripts may need to be reloaded by the application at any time if missing (after a server restart, fail-over to a replica, etc.).
+As of version 7.0, [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) offer an alternative approach to programmability which allow the server itself to be extended with additional programmed logic.
+
+## Getting started
+
+We'll start scripting with Redis by using the [`EVAL`]({{< relref "/commands/eval" >}}) command.
+
+Here's our first example:
+
+```
+> EVAL "return 'Hello, scripting!'" 0
+"Hello, scripting!"
+```
+
+In this example, [`EVAL`]({{< relref "/commands/eval" >}}) takes two arguments.
+The first argument is a string that consists of the script's Lua source code.
+The script doesn't need to include any definitions of Lua function.
+It is just a Lua program that will run in the Redis engine's context.
+
+The second argument is the number of arguments that follow the script's body, starting from the third argument, representing Redis key names.
+In this example, we used the value _0_ because we didn't provide the script with any arguments, whether the names of keys or not.
+
+## Script parameterization
+
+It is possible, although highly ill-advised, to have the application dynamically generate script source code per its needs.
+For example, the application could send these two entirely different, but at the same time perfectly identical scripts:
+
+```
+redis> EVAL "return 'Hello'" 0
+"Hello"
+redis> EVAL "return 'Scripting!'" 0
+"Scripting!"
+```
+
+Although this mode of operation isn't blocked by Redis, it is an anti-pattern due to script cache considerations (more on the topic below).
+Instead of having your application generate subtle variations of the same scripts, you can parametrize them and pass any arguments needed for to execute them.
+
+The following example demonstrates how to achieve the same effects as above, but via parameterization:
+
+```
+redis> EVAL "return ARGV[1]" 0 Hello
+"Hello"
+redis> EVAL "return ARGV[1]" 0 Parameterization!
+"Parameterization!"
+```
+
+At this point, it is essential to understand the distinction Redis makes between input arguments that are names of keys and those that aren't.
+
+While key names in Redis are just strings, unlike any other string values, these represent keys in the database.
+The name of a key is a fundamental concept in Redis and is the basis for operating the Redis Cluster.
+
+**Important:**
+to ensure the correct execution of scripts, both in standalone and clustered deployments, all names of keys that a script accesses must be explicitly provided as input key arguments.
+The script **should only** access keys whose names are given as input arguments.
+Scripts **should never** access keys with programmatically-generated names or based on the contents of data structures stored in the database.
+
+Any input to the function that isn't the name of a key is a regular input argument.
+
+In the example above, both _Hello_ and _Parameterization!_ regular input arguments for the script.
+Because the script doesn't touch any keys, we use the numerical argument _0_ to specify there are no key name arguments.
+The execution context makes arguments available to the script through [_KEYS_]({{< relref "develop/interact/programmability/lua-api#the-keys-global-variable" >}}) and [_ARGV_]({{< relref "develop/interact/programmability/lua-api#the-argv-global-variable" >}}) global runtime variables.
+The _KEYS_ table is pre-populated with all key name arguments provided to the script before its execution, whereas the _ARGV_ table serves a similar purpose but for regular arguments.
+
+The following attempts to demonstrate the distribution of input arguments between the scripts _KEYS_ and _ARGV_ runtime global variables:
+
+
+```
+redis> EVAL "return { KEYS[1], KEYS[2], ARGV[1], ARGV[2], ARGV[3] }" 2 key1 key2 arg1 arg2 arg3
+1) "key1"
+2) "key2"
+3) "arg1"
+4) "arg2"
+5) "arg3"
+```
+
+**Note:**
+as can been seen above, Lua's table arrays are returned as [RESP2 array replies]({{< relref "/develop/reference/protocol-spec#resp-arrays" >}}), so it is likely that your client's library will convert it to the native array data type in your programming language.
+Please refer to the rules that govern [data type conversion]({{< relref "develop/interact/programmability/lua-api#data-type-conversion" >}}) for more pertinent information.
+
+## Interacting with Redis from a script
+
+It is possible to call Redis commands from a Lua script either via [`redis.call()`]({{< relref "develop/interact/programmability/lua-api#redis.call" >}}) or [`redis.pcall()`]({{< relref "develop/interact/programmability/lua-api#redis.pcall" >}}).
+
+The two are nearly identical.
+Both execute a Redis command along with its provided arguments, if these represent a well-formed command.
+However, the difference between the two functions lies in the manner in which runtime errors (such as syntax errors, for example) are handled.
+Errors raised from calling `redis.call()` function are returned directly to the client that had executed it.
+Conversely, errors encountered when calling the `redis.pcall()` function are returned to the script's execution context instead for possible handling.
+
+For example, consider the following:
+
+```
+> EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 foo bar
+OK
+```
+The above script accepts one key name and one value as its input arguments.
+When executed, the script calls the [`SET`]({{< relref "/commands/set" >}}) command to set the input key, _foo_, with the string value "bar".
+
+## Script cache
+
+Until this point, we've used the [`EVAL`]({{< relref "/commands/eval" >}}) command to run our script.
+
+Whenever we call [`EVAL`]({{< relref "/commands/eval" >}}), we also include the script's source code with the request.
+Repeatedly calling [`EVAL`]({{< relref "/commands/eval" >}}) to execute the same set of parameterized scripts, wastes both network bandwidth and also has some overheads in Redis.
+Naturally, saving on network and compute resources is key, so, instead, Redis provides a caching mechanism for scripts.
+
+Every script you execute with [`EVAL`]({{< relref "/commands/eval" >}}) is stored in a dedicated cache that the server keeps.
+The cache's contents are organized by the scripts' SHA1 digest sums, so the SHA1 digest sum of a script uniquely identifies it in the cache.
+You can verify this behavior by running [`EVAL`]({{< relref "/commands/eval" >}}) and calling [`INFO`]({{< relref "/commands/info" >}}) afterward.
+You'll notice that the _used_memory_scripts_eval_ and _number_of_cached_scripts_ metrics grow with every new script that's executed.
+
+As mentioned above, dynamically-generated scripts are an anti-pattern.
+Generating scripts during the application's runtime may, and probably will, exhaust the host's memory resources for caching them.
+Instead, scripts should be as generic as possible and provide customized execution via their arguments.
+
+A script is loaded to the server's cache by calling the [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) command and providing its source code.
+The server doesn't execute the script, but instead just compiles and loads it to the server's cache.
+Once loaded, you can execute the cached script with the SHA1 digest returned from the server.
+
+Here's an example of loading and then executing a cached script:
+
+```
+redis> SCRIPT LOAD "return 'Immabe a cached script'"
+"c664a3bf70bd1d45c4284ffebb65a6f2299bfc9f"
+redis> EVALSHA c664a3bf70bd1d45c4284ffebb65a6f2299bfc9f 0
+"Immabe a cached script"
+```
+
+### Cache volatility
+
+The Redis script cache is **always volatile**.
+It isn't considered as a part of the database and is **not persisted**.
+The cache may be cleared when the server restarts, during fail-over when a replica assumes the master role, or explicitly by [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}).
+That means that cached scripts are ephemeral, and the cache's contents can be lost at any time.
+
+Applications that use scripts should always call [`EVALSHA`]({{< relref "/commands/evalsha" >}}) to execute them.
+The server returns an error if the script's SHA1 digest is not in the cache.
+For example:
+
+```
+redis> EVALSHA ffffffffffffffffffffffffffffffffffffffff 0
+(error) NOSCRIPT No matching script
+```
+
+In this case, the application should first load it with [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) and then call [`EVALSHA`]({{< relref "/commands/evalsha" >}}) once more to run the cached script by its SHA1 sum.
+Most of Redis' clients already provide utility APIs for doing that automatically.
+Please consult your client's documentation regarding the specific details.
+
+### `EVALSHA` in the context of pipelining
+
+Special care should be given executing [`EVALSHA`]({{< relref "/commands/evalsha" >}}) in the context of a [pipelined request]({{< relref "/develop/use/pipelining" >}}).
+The commands in a pipelined request run in the order they are sent, but other clients' commands may be interleaved for execution between these.
+Because of that, the `NOSCRIPT` error can return from a pipelined request but can't be handled.
+
+Therefore, a client library's implementation should revert to using plain [`EVAL`]({{< relref "/commands/eval" >}}) of parameterized in the context of a pipeline.
+
+### Script cache semantics
+
+During normal operation, an application's scripts are meant to stay indefinitely in the cache (that is, until the server is restarted or the cache being flushed).
+The underlying reasoning is that the script cache contents of a well-written application are unlikely to grow continuously.
+Even large applications that use hundreds of cached scripts shouldn't be an issue in terms of cache memory usage. 
+
+The only way to flush the script cache is by explicitly calling the [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}) command.
+Running the command will _completely flush_ the scripts cache, removing all the scripts executed so far.
+Typically, this is only needed when the instance is going to be instantiated for another customer or application in a cloud environment.
+
+Also, as already mentioned, restarting a Redis instance flushes the non-persistent script cache.
+However, from the point of view of the Redis client, there are only two ways to make sure that a Redis instance was not restarted between two different commands:
+
+* The connection we have with the server is persistent and was never closed so far.
+* The client explicitly checks the `run_id` field in the [`INFO`]({{< relref "/commands/info" >}}) command to ensure the server was not restarted and is still the same process.
+
+Practically speaking, it is much simpler for the client to assume that in the context of a given connection, cached scripts are guaranteed to be there unless the administrator explicitly invoked the [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}) command.
+The fact that the user can count on Redis to retain cached scripts is semantically helpful in the context of pipelining.
+
+## The `SCRIPT` command
+
+The Redis [`SCRIPT`]({{< relref "/commands/script" >}}) provides several ways for controlling the scripting subsystem.
+These are:
+
+* [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}): this command is the only way to force Redis to flush the scripts cache.
+  It is most useful in environments where the same Redis instance is reassigned to different uses.
+  It is also helpful for testing client libraries' implementations of the scripting feature.
+
+* [`SCRIPT EXISTS`]({{< relref "/commands/script-exists" >}}): given one or more SHA1 digests as arguments, this command returns an array of _1_'s and _0_'s.
+  _1_ means the specific SHA1 is recognized as a script already present in the scripting cache. _0_'s meaning is that a script with this SHA1 wasn't loaded before (or at least never since the latest call to [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}})).
+
+* `SCRIPT LOAD script`: this command registers the specified script in the Redis script cache. 
+  It is a useful command in all the contexts where we want to ensure that [`EVALSHA`]({{< relref "/commands/evalsha" >}}) doesn't not fail (for instance, in a pipeline or when called from a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/interact/transactions" >}}), without the need to execute the script.
+
+* [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}): this command is the only way to interrupt a long-running script (a.k.a slow script), short of shutting down the server.
+  A script is deemed as slow once its execution's duration exceeds the configured [maximum execution time]({{< relref "/develop/interact/programmability/#maximum-execution-time" >}}) threshold.
+  The [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) command can be used only with scripts that did not modify the dataset during their execution (since stopping a read-only script does not violate the scripting engine's guaranteed atomicity).
+
+* [`SCRIPT DEBUG`]({{< relref "/commands/script-debug" >}}): controls use of the built-in [Redis Lua scripts debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}).
+
+## Script replication
+
+In standalone deployments, a single Redis instance called _master_ manages the entire database.
+A [clustered deployment]({{< relref "/operate/oss_and_stack/management/scaling" >}}) has at least three masters managing the sharded database.
+Redis uses [replication]({{< relref "/operate/oss_and_stack/management/replication" >}}) to maintain one or more replicas, or exact copies, for any given master.
+
+Because scripts can modify the data, Redis ensures all write operations performed by a script are also sent to replicas to maintain consistency.
+There are two conceptual approaches when it comes to script replication:
+
+1. Verbatim replication: the master sends the script's source code to the replicas.
+   Replicas then execute the script and apply the write effects.
+   This mode can save on replication bandwidth in cases where short scripts generate many commands (for example, a _for_ loop).
+   However, this replication mode means that replicas redo the same work done by the master, which is wasteful.
+   More importantly, it also requires [all write scripts to be deterministic](#scripts-with-deterministic-writes).
+1. Effects replication: only the script's data-modifying commands are replicated.
+   Replicas then run the commands without executing any scripts.
+   While potentially lengthier in terms of network traffic, this replication mode is deterministic by definition and therefore doesn't require special consideration.
+
+Verbatim script replication was the only mode supported until Redis 3.2, in which effects replication was added.
+The _lua-replicate-commands_ configuration directive and [`redis.replicate_commands()`]({{< relref "develop/interact/programmability/lua-api#redis.replicate_commands" >}}) Lua API can be used to enable it.
+
+In Redis 5.0, effects replication became the default mode.
+As of Redis 7.0, verbatim replication is no longer supported.
+
+### Replicating commands instead of scripts
+
+Starting with Redis 3.2, it is possible to select an alternative replication method.
+Instead of replicating whole scripts, we can replicate the write commands generated by the script.
+We call this **script effects replication**.
+
+**Note:**
+starting with Redis 5.0, script effects replication is the default mode and does not need to be explicitly enabled.
+
+In this replication mode, while Lua scripts are executed, Redis collects all the commands executed by the Lua scripting engine that actually modify the dataset.
+When the script execution finishes, the sequence of commands that the script generated are wrapped into a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) [transaction]({{< relref "/develop/interact/transactions" >}}) and are sent to the replicas and AOF.
+
+This is useful in several ways depending on the use case:
+
+* When the script is slow to compute, but the effects can be summarized by a few write commands, it is a shame to re-compute the script on the replicas or when reloading the AOF.
+  In this case, it is much better to replicate just the effects of the script.
+* When script effects replication is enabled, the restrictions on non-deterministic functions are removed.
+  You can, for example, use the [`TIME`]({{< relref "/commands/time" >}}) or [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}) commands inside your scripts freely at any place.
+* The Lua PRNG in this mode is seeded randomly on every call.
+
+Unless already enabled by the server's configuration or defaults (before Redis 7.0), you need to issue the following Lua command before the script performs a write:
+
+```lua
+redis.replicate_commands()
+```
+
+The [`redis.replicate_commands()`]({{< relref "develop/interact/programmability/lua-api#redis.replicate_commands" >}}) function returns _true) if script effects replication was enabled;
+otherwise, if the function was called after the script already called a write command,
+it returns _false_, and normal whole script replication is used.
+
+This function is deprecated as of Redis 7.0, and while you can still call it, it will always succeed. 
+
+### Scripts with deterministic writes
+
+**Note:**
+Starting with Redis 5.0, script replication is by default effect-based rather than verbatim.
+In Redis 7.0, verbatim script replication had been removed entirely.
+The following section only applies to versions lower than Redis 7.0 when not using effect-based script replication.
+
+An important part of scripting is writing scripts that only change the database in a deterministic way.
+Scripts executed in a Redis instance are, by default until version 5.0, propagated to replicas and to the AOF file by sending the script itself -- not the resulting commands.
+Since the script will be re-run on the remote host (or when reloading the AOF file), its changes to the database must be reproducible.
+
+The reason for sending the script is that it is often much faster than sending the multiple commands that the script generates.
+If the client is sending many scripts to the master, converting the scripts into individual commands for the replica / AOF would result in too much bandwidth for the replication link or the Append Only File (and also too much CPU since dispatching a command received via the network is a lot more work for Redis compared to dispatching a command invoked by Lua scripts).
+
+Normally replicating scripts instead of the effects of the scripts makes sense, however not in all the cases.
+So starting with Redis 3.2, the scripting engine is able to, alternatively, replicate the sequence of write commands resulting from the script execution, instead of replication the script itself.
+
+In this section, we'll assume that scripts are replicated verbatim by sending the whole script.
+Let's call this replication mode **verbatim scripts replication**.
+
+The main drawback with the *whole scripts replication* approach is that scripts are required to have the following property:
+the script **always must** execute the same Redis _write_ commands with the same arguments given the same input data set.
+Operations performed by the script can't depend on any hidden (non-explicit) information or state that may change as the script execution proceeds or between different executions of the script.
+Nor can it depend on any external input from I/O devices.
+
+Acts such as using the system time, calling Redis commands that return random values (e.g., [`RANDOMKEY`]({{< relref "/commands/randomkey" >}})), or using Lua's random number generator, could result in scripts that will not evaluate consistently.
+
+To enforce the deterministic behavior of scripts, Redis does the following:
+
+* Lua does not export commands to access the system time or other external states.
+* Redis will block the script with an error if a script calls a Redis command able to alter the data set **after** a Redis _random_ command like [`RANDOMKEY`]({{< relref "/commands/randomkey" >}}), [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}), [`TIME`]({{< relref "/commands/time" >}}).
+  That means that read-only scripts that don't modify the dataset can call those commands.
+  Note that a _random command_ does not necessarily mean a command that uses random numbers: any non-deterministic command is considered as a random command (the best example in this regard is the [`TIME`]({{< relref "/commands/time" >}}) command).
+* In Redis version 4.0, commands that may return elements in random order, such as [`SMEMBERS`]({{< relref "/commands/smembers" >}}) (because Redis Sets are _unordered_), exhibit a different behavior when called from Lua,
+and undergo a silent lexicographical sorting filter before returning data to Lua scripts.
+  So `redis.call("SMEMBERS",KEYS[1])` will always return the Set elements in the same order, while the same command invoked by normal clients may return different results even if the key contains exactly the same elements.
+  However, starting with Redis 5.0, this ordering is no longer performed because replicating effects circumvents this type of non-determinism.
+  In general, even when developing for Redis 4.0, never assume that certain commands in Lua will be ordered, but instead rely on the documentation of the original command you call to see the properties it provides.
+* Lua's pseudo-random number generation function `math.random` is modified and always uses the same seed for every execution.
+  This means that calling [`math.random`]({{< relref "develop/interact/programmability/lua-api#runtime-libraries" >}}) will always generate the same sequence of numbers every time a script is executed (unless `math.randomseed` is used).
+
+All that said, you can still use commands that write and random behavior with a simple trick.
+Imagine that you want to write a Redis script that will populate a list with N random integers.
+
+The initial implementation in Ruby could look like this:
+
+```
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+RandomPushScript = <<EOF
+    local i = tonumber(ARGV[1])
+    local res
+    while (i > 0) do
+        res = redis.call('LPUSH',KEYS[1],math.random())
+        i = i-1
+    end
+    return res
+EOF
+
+r.del(:mylist)
+puts r.eval(RandomPushScript,[:mylist],[10,rand(2**32)])
+```
+
+Every time this code runs, the resulting list will have exactly the
+following elements:
+
+```
+redis> LRANGE mylist 0 -1
+ 1) "0.74509509873814"
+ 2) "0.87390407681181"
+ 3) "0.36876626981831"
+ 4) "0.6921941534114"
+ 5) "0.7857992587545"
+ 6) "0.57730350670279"
+ 7) "0.87046522734243"
+ 8) "0.09637165539729"
+ 9) "0.74990198051087"
+10) "0.17082803611217"
+```
+
+To make the script both deterministic and still have it produce different random elements,
+we can add an extra argument to the script that's the seed to Lua's pseudo-random number generator.
+The new script is as follows:
+
+```
+RandomPushScript = <<EOF
+    local i = tonumber(ARGV[1])
+    local res
+    math.randomseed(tonumber(ARGV[2]))
+    while (i > 0) do
+        res = redis.call('LPUSH',KEYS[1],math.random())
+        i = i-1
+    end
+    return res
+EOF
+
+r.del(:mylist)
+puts r.eval(RandomPushScript,1,:mylist,10,rand(2**32))
+```
+
+What we are doing here is sending the seed of the PRNG as one of the arguments.
+The script output will always be the same given the same arguments (our requirement) but we are changing one of the arguments at every invocation,
+generating the random seed client-side.
+The seed will be propagated as one of the arguments both in the replication link and in the Append Only File,
+guaranteeing that the same changes will be generated when the AOF is reloaded or when the replica processes the script.
+
+Note: an important part of this behavior is that the PRNG that Redis implements as `math.random` and `math.randomseed` is guaranteed to have the same output regardless of the architecture of the system running Redis.
+32-bit, 64-bit, big-endian and little-endian systems will all produce the same output.
+
+## Debugging Eval scripts
+
+Starting with Redis 3.2, Redis has support for native Lua debugging.
+The Redis Lua debugger is a remote debugger consisting of a server, which is Redis itself, and a client, which is by default [`redis-cli`]({{< relref "/develop/tools/cli" >}}).
+
+The Lua debugger is described in the [Lua scripts debugging]({{< relref "/develop/interact/programmability/lua-debugging" >}}) section of the Redis documentation.
+
+## Execution under low memory conditions
+
+When memory usage in Redis exceeds the `maxmemory` limit, the first write command encountered in the script that uses additional memory will cause the script to abort (unless [`redis.pcall`]({{< relref "develop/interact/programmability/lua-api#redis.pcall" >}}) was used).
+
+However, an exception to the above is when the script's first write command does not use additional memory, as is the case with  (for example, [`DEL`]({{< relref "/commands/del" >}}) and [`LREM`]({{< relref "/commands/lrem" >}})).
+In this case, Redis will allow all commands in the script to run to ensure atomicity.
+If subsequent writes in the script consume additional memory, Redis' memory usage can exceed the threshold set by the `maxmemory` configuration directive.
+
+Another scenario in which a script can cause memory usage to cross the `maxmemory` threshold is when the execution begins when Redis is slightly below `maxmemory`, so the script's first write command is allowed.
+As the script executes, subsequent write commands consume more memory leading to the server using more RAM than the configured `maxmemory` directive.
+
+In those scenarios, you should consider setting the `maxmemory-policy` configuration directive to any values other than `noeviction`.
+In addition, Lua scripts should be as fast as possible so that eviction can kick in between executions.
+
+Note that you can change this behaviour by using [flags](#eval-flags)
+
+## Eval flags
+
+Normally, when you run an Eval script, the server does not know how it accesses the database.
+By default, Redis assumes that all scripts read and write data.
+However, starting with Redis 7.0, there's a way to declare flags when creating a script in order to tell Redis how it should behave.
+
+The way to do that is by using a Shebang statement on the first line of the script like so:
+
+```
+#!lua flags=no-writes,allow-stale
+local x = redis.call('get','x')
+return x
+```
+
+Note that as soon as Redis sees the `#!` comment, it'll treat the script as if it declares flags, even if no flags are defined,
+it still has a different set of defaults compared to a script without a `#!` line.
+
+Another difference is that scripts without `#!` can run commands that access keys belonging to different cluster hash slots, but ones with `#!` inherit the default flags, so they cannot.
+
+Please refer to [Script flags]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) to learn about the various scripts and the defaults.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Executing Lua in Redis
+
+  '
+linkTitle: Lua API
+title: Redis Lua API reference
+weight: 3
+---
+
+Redis includes an embedded [Lua 5.1](https://www.lua.org/) interpreter.
+The interpreter runs user-defined [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) and [functions]({{< relref "/develop/interact/programmability/functions-intro" >}}). 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.
+
+Scripts should never try to access the Redis server's underlying host systems.
+That includes the file system, network, and any other attempt to perform a system call other than those supported by the API.
+
+Scripts should operate solely on data stored in Redis and data provided as arguments to their execution.
+
+### Global variables and functions
+
+The sandboxed Lua execution context blocks the declaration of global variables and functions.
+The blocking of global variables is in place to ensure that scripts and functions don't attempt to maintain any runtime context other than the data stored in Redis.
+In the (somewhat uncommon) use case that a context needs to be maintain between executions,
+you should store the context in Redis' keyspace.
+
+Redis will return a "Script attempted to create global variable 'my_global_variable" error when trying to execute the following snippet:
+
+```lua
+my_global_variable = 'some value'
+```
+
+And similarly for the following global function declaration:
+
+```lua
+function my_global_function()
+  -- Do something amazing
+end
+```
+
+You'll also get a similar error when your script attempts to access any global variables that are undefined in the runtime's context:
+
+```lua
+-- The following will surely raise an error
+return an_undefined_global_variable
+```
+
+Instead, all variable and function definitions are required to be declared as local.
+To do so, you'll need to prepend the [_local_](https://www.lua.org/manual/5.1/manual.html#2.4.7) keyword to your declarations.
+For example, the following snippet will be considered perfectly valid by Redis:
+
+```lua
+local my_local_variable = 'some value'
+
+local function my_local_function()
+  -- Do something else, but equally amazing
+end
+```
+
+**Note:**
+the sandbox attempts to prevent the use of globals.
+Using Lua's debugging functionality or other approaches such as altering the meta table used for implementing the globals' protection to circumvent the sandbox isn't hard.
+However, it is difficult to circumvent the protection by accident.
+If the user messes with the Lua global state, the consistency of AOF and replication can't be guaranteed.
+In other words, just don't do it.
+
+### Imported Lua modules
+
+Using imported Lua modules is not supported inside the sandboxed execution context.
+The sandboxed execution context prevents the loading modules by disabling Lua's [`require` function](https://www.lua.org/pil/8.1.html).
+
+The only libraries that Redis ships with and that you can use in scripts are listed under the [Runtime libraries](#runtime-libraries) section.
+
+## Runtime globals
+
+While the sandbox prevents users from declaring globals, the execution context is pre-populated with several of these.
+
+### The _redis_ singleton
+
+The _redis_ singleton is an object instance that's accessible from all scripts.
+It provides the API to interact with Redis from scripts.
+Its description follows [below](#redis_object).
+
+### The _KEYS_ global variable {#the-keys-global-variable}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: no
+
+**Important:**
+to ensure the correct execution of scripts, both in standalone and clustered deployments, all names of keys that a function accesses must be explicitly provided as input key arguments.
+The script **should only** access keys whose names are given as input arguments.
+Scripts **should never** access keys with programmatically-generated names or based on the contents of data structures stored in the database.
+
+The _KEYS_ global variable is available only for [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+It is pre-populated with all key name input arguments.
+
+### The _ARGV_ global variable {#the-argv-global-variable}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: no
+
+The _ARGV_ global variable is available only in [ephemeral scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+It is pre-populated with all regular input arguments.
+
+## _redis_ object {#redis_object}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+The Redis Lua execution context always provides a singleton instance of an object named _redis_.
+The _redis_ instance enables the script to interact with the Redis server that's running it.
+Following is the API provided by the _redis_ object instance.
+
+### `redis.call(command [,arg...])` {#redis.call}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+The `redis.call()` function calls a given Redis command and returns its reply.
+Its inputs are the command and arguments, and once called, it executes the command in Redis and returns the reply.
+
+For example, we can call the [`ECHO`]({{< relref "/commands/echo" >}}) command from a script and return its reply like so:
+
+```lua
+return redis.call('ECHO', 'Echo, echo... eco... o...')
+```
+
+If and when `redis.call()` triggers a runtime exception, the raw exception is raised back to the user as an error, automatically.
+Therefore, attempting to execute the following ephemeral script will fail and generate a runtime exception because [`ECHO`]({{< relref "/commands/echo" >}}) accepts exactly one argument:
+
+```lua
+redis> EVAL "return redis.call('ECHO', 'Echo,', 'echo... ', 'eco... ', 'o...')" 0
+(error) ERR Wrong number of args calling Redis command from script script: b0345693f4b77517a711221050e76d24ae60b7f7, on @user_script:1.
+```
+
+Note that the call can fail due to various reasons, see [Execution under low memory conditions]({{< relref "/develop/interact/programmability/eval-intro#execution-under-low-memory-conditions" >}}) and [Script flags](#script_flags)
+
+To handle Redis runtime errors use `redis.pcall()` instead.
+
+### `redis.pcall(command [,arg...])` {#redis.pcall}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This function enables handling runtime errors raised by the Redis server.
+The `redis.pcall()` function  behaves exactly like [`redis.call()`](#redis.call), except that it:
+
+* Always returns a reply.
+* Never throws a runtime exception, and returns in its stead a [`redis.error_reply`](#redis.error_reply) in case that a runtime exception is thrown by the server.
+
+The following demonstrates how to use `redis.pcall()` to intercept and handle runtime exceptions from within the context of an ephemeral script.
+
+```lua
+local reply = redis.pcall('ECHO', unpack(ARGV))
+if reply['err'] ~= nil then
+  -- Handle the error sometime, but for now just log it
+  redis.log(redis.LOG_WARNING, reply['err'])
+  reply['err'] = 'ERR Something is wrong, but no worries, everything is under control'
+end
+return reply
+```
+
+Evaluating this script with more than one argument will return:
+
+```
+redis> EVAL "..." 0 hello world
+(error) ERR Something is wrong, but no worries, everything is under control
+```
+
+### `redis.error_reply(x)` {#redis.error_reply}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This is a helper function that returns an [error reply]({{< relref "develop/reference/protocol-spec/#simple-errors" >}}).
+The helper accepts a single string argument and returns a Lua table with the _err_ field set to that string.
+
+The outcome of the following code is that _error1_ and _error2_ are identical for all intents and purposes:
+
+```lua
+local text = 'ERR My very special error'
+local reply1 = { err = text }
+local reply2 = redis.error_reply(text)
+```
+
+Therefore, both forms are valid as means for returning an error reply from scripts:
+
+```
+redis> EVAL "return { err = 'ERR My very special table error' }" 0
+(error) ERR My very special table error
+redis> EVAL "return redis.error_reply('ERR My very special reply error')" 0
+(error) ERR My very special reply error
+```
+
+For returning Redis status replies refer to [`redis.status_reply()`](#redis.status_reply).
+Refer to the [Data type conversion](#data-type-conversion) for returning other response types.
+
+**Note:**
+By convention, Redis uses the first word of an error string as a unique error code for specific errors or `ERR` for general-purpose errors.
+Scripts are advised to follow this convention, as shown in the example above, but this is not mandatory.
+
+### `redis.status_reply(x)` {#redis.status_reply}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This is a helper function that returns a [simple string reply]({{< relref "develop/reference/protocol-spec#simple-strings" >}}).
+"OK" is an example of a standard Redis status reply.
+The Lua API represents status replies as tables with a single field, _ok_, set with a simple status string.
+
+The outcome of the following code is that _status1_ and _status2_ are identical for all intents and purposes:
+
+```lua
+local text = 'Frosty'
+local status1 = { ok = text }
+local status2 = redis.status_reply(text)
+```
+
+Therefore, both forms are valid as means for returning status replies from scripts:
+
+```
+redis> EVAL "return { ok = 'TICK' }" 0
+TICK
+redis> EVAL "return redis.status_reply('TOCK')" 0
+TOCK
+```
+
+For returning Redis error replies refer to [`redis.error_reply()`](#redis.error_reply).
+Refer to the [Data type conversion](#data-type-conversion) for returning other response types.
+
+### `redis.sha1hex(x)` {#redis.sha1hex}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This function returns the SHA1 hexadecimal digest of its single string argument.
+
+You can, for example, obtain the empty string's SHA1 digest:
+
+```
+redis> EVAL "return redis.sha1hex('')" 0
+"da39a3ee5e6b4b0d3255bfef95601890afd80709"
+```
+
+### `redis.log(level, message)` {#redis.log}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This function writes to the Redis server log.
+
+It expects two input arguments: the log level and a message.
+The message is a string to write to the log file.
+Log level can be on of these:
+
+* `redis.LOG_DEBUG`
+* `redis.LOG_VERBOSE`
+* `redis.LOG_NOTICE`
+* `redis.LOG_WARNING`
+
+These levels map to the server's log levels.
+The log only records messages equal or greater in level than the server's `loglevel` configuration directive.
+
+The following snippet:
+
+```lua
+redis.log(redis.LOG_WARNING, 'Something is terribly wrong')
+```
+
+will produce a line similar to the following in your server's log:
+
+```
+[32343] 22 Mar 15:21:39 # Something is terribly wrong
+```
+
+### `redis.setresp(x)` {#redis.setresp}
+
+* Since version: 6.0.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This function allows the executing script to switch between [Redis Serialization Protocol (RESP)]({{< relref "/develop/reference/protocol-spec" >}}) versions for the replies returned by [`redis.call()`](#redis.call) and [`redis.pcall()`](#redis.pcall).
+It expects a single numerical argument as the protocol's version.
+The default protocol version is _2_, but it can be switched to version _3_.
+
+Here's an example of switching to RESP3 replies:
+
+```lua
+redis.setresp(3)
+```
+
+Please refer to the [Data type conversion](#data-type-conversion) for more information about type conversions.
+
+### `redis.set_repl(x)` {#redis.set_repl}
+
+* Since version: 3.2.0
+* Available in scripts: yes
+* Available in functions: no
+
+**Note:**
+this feature is only available when script effects replication is employed.
+Calling it when using verbatim script replication will result in an error.
+As of Redis version 2.6.0, scripts were replicated verbatim, meaning that the scripts' source code was sent for execution by replicas and stored in the AOF.
+An alternative replication mode added in version 3.2.0 allows replicating only the scripts' effects.
+As of Redis version 7.0, script replication is no longer supported, and the only replication mode available is script effects replication.
+
+**Warning:**
+this is an advanced feature. Misuse can cause damage by violating the contract that binds the Redis master, its replicas, and AOF contents to hold the same logical content.
+
+This function allows a script to assert control over how its effects are propagated to replicas and the AOF afterward.
+A script's effects are the Redis write commands that it calls.
+
+By default, all write commands that a script executes are replicated.
+Sometimes, however, better control over this behavior can be helpful.
+This can be the case, for example, when storing intermediate values in the master alone.
+
+Consider a script that intersects two sets and stores the result in a temporary key with [`SUNIONSTORE`]({{< relref "/commands/sunionstore" >}}).
+It then picks five random elements ([`SRANDMEMBER`]({{< relref "/commands/srandmember" >}})) from the intersection and stores ([`SADD`]({{< relref "/commands/sadd" >}})) them in another set.
+Finally, before returning, it deletes the temporary key that stores the intersection of the two source sets.
+
+In this case, only the new set with its five randomly-chosen elements needs to be replicated.
+Replicating the [`SUNIONSTORE`]({{< relref "/commands/sunionstore" >}}) command and the [`DEL`]({{< relref "/commands/del" >}})ition of the temporary key is unnecessary and wasteful.
+
+The `redis.set_repl()` function instructs the server how to treat subsequent write commands in terms of replication.
+It accepts a single input argument that only be one of the following:
+
+* `redis.REPL_ALL`: replicates the effects to the AOF and replicas.
+* `redis.REPL_AOF`: replicates the effects to the AOF alone.
+* `redis.REPL_REPLICA`: replicates the effects to the replicas alone.
+* `redis.REPL_SLAVE`: same as `REPL_REPLICA`, maintained for backward compatibility.
+* `redis.REPL_NONE`: disables effect replication entirely.
+
+By default, the scripting engine is initialized to the `redis.REPL_ALL` setting when a script begins its execution.
+You can call the `redis.set_repl()` function at any time during the script's execution to switch between the different replication modes.
+
+A simple example follows:
+
+```lua
+redis.replicate_commands() -- Enable effects replication in versions lower than Redis v7.0
+redis.call('SET', KEYS[1], ARGV[1])
+redis.set_repl(redis.REPL_NONE)
+redis.call('SET', KEYS[2], ARGV[2])
+redis.set_repl(redis.REPL_ALL)
+redis.call('SET', KEYS[3], ARGV[3])
+```
+
+If you run this script by calling `EVAL "..." 3 A B C 1 2 3`, the result will be that only the keys _A_ and _C_ are created on the replicas and AOF.
+
+### `redis.replicate_commands()` {#redis.replicate_commands}
+
+* Since version: 3.2.0
+* Until version: 7.0.0
+* Available in scripts: yes
+* Available in functions: no
+
+This function switches the script's replication mode from verbatim replication to effects replication.
+You can use it to override the default verbatim script replication mode used by Redis until version 7.0.
+
+**Note:**
+as of Redis v7.0, verbatim script replication is no longer supported.
+The default, and only script replication mode supported, is script effects' replication.
+For more information, please refer to [`Replicating commands instead of scripts`]({{< relref "/develop/interact/programmability/eval-intro#replicating-commands-instead-of-scripts" >}})
+
+### `redis.breakpoint()` {#redis.breakpoint}
+
+* Since version: 3.2.0
+* Available in scripts: yes
+* Available in functions: no
+
+This function triggers a breakpoint when using the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}).
+
+### `redis.debug(x)` {#redis.debug}
+
+* Since version: 3.2.0
+* Available in scripts: yes
+* Available in functions: no
+
+This function prints its argument in the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}) console.
+
+### `redis.acl_check_cmd(command [,arg...])` {#redis.acl_check_cmd}
+
+* Since version: 7.0.0
+* Available in scripts: yes
+* Available in functions: yes
+
+This function is used for checking if the current user running the script has [ACL]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) permissions to execute the given command with the given arguments.
+
+The return value is a boolean `true` in case the current user has permissions to execute the command (via a call to [redis.call](#redis.call) or [redis.pcall](#redis.pcall)) or `false` in case they don't.
+
+The function will raise an error if the passed command or its arguments are invalid.
+
+### `redis.register_function` {#redis.register_function}
+
+* Since version: 7.0.0
+* Available in scripts: no
+* Available in functions: yes
+
+This function is only available from the context of the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command.
+When called, it registers a function to the loaded library.
+The function can be called either with positional or named arguments.
+
+#### positional arguments: `redis.register_function(name, callback)` {#redis.register_function_pos_args}
+The first argument to `redis.register_function` is a Lua string representing the function name.
+The second argument to `redis.register_function` is a Lua function.
+
+Usage example:
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib\n redis.register_function('noop', function() end)"
+```
+
+#### Named arguments:  `redis.register_function{function_name=name, callback=callback, flags={flag1, flag2, ..}, description=description}` {#redis.register_function_named_args}
+
+The named arguments variant accepts the following arguments:
+
+* _function\_name_: the function's name.
+* _callback_: the function's callback.
+* _flags_: an array of strings, each a function flag (optional).
+* _description_: function's description (optional).
+
+Both _function\_name_ and _callback_ are mandatory.
+
+Usage example:
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib\n redis.register_function{function_name='noop', callback=function() end, flags={ 'no-writes' }, description='Does nothing'}"
+```
+
+#### Script flags {#script_flags}
+
+**Important:**
+Use script flags with care, which may negatively impact if misused.
+Note that the default for Eval scripts are different than the default for functions that are mentioned below, see [Eval Flags]({{< relref "develop/interact/programmability/eval-intro#eval-flags" >}})
+
+When you register a function or load an Eval script, the server does not know how it accesses the database.
+By default, Redis assumes that all scripts read and write data.
+This results in the following behavior:
+
+1. They can read and write data.
+1. They can run in cluster mode, and are not able to run commands accessing keys of different hash slots.
+1. Execution against a stale replica is denied to avoid inconsistent reads.
+1. Execution under low memory is denied to avoid exceeding the configured threshold.
+
+You can use the following flags and instruct the server to treat the scripts' execution differently:
+
+* `no-writes`: this flag indicates that the script only reads data but never writes.
+
+    By default, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) against read-only replicas, as they may attempt to perform writes.
+    Similarly, the server will not allow calling scripts with [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) / [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}).
+    Lastly, when data persistence is at risk due to a disk error, execution is blocked as well.
+
+    Using this flag allows executing the script:
+    1. With [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) / [`EVAL_RO`]({{< relref "/commands/eval_ro" >}})
+    2. On read-only replicas.
+    3. Even if there's a disk error (Redis is unable to persist so it rejects writes).
+    4. When over the memory limit since it implies the script doesn't increase memory consumption (see `allow-oom` below)
+
+    However, note that the server will return an error if the script attempts to call a write command.
+    Also note that currently [`PUBLISH`]({{< relref "/commands/publish" >}}), [`SPUBLISH`]({{< relref "/commands/spublish" >}}) and [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) are also considered write commands in scripts, because they could attempt to propagate commands to replicas and AOF file.
+
+    For more information please refer to [Read-only scripts]({{< relref "develop/interact/programmability/#read-only_scripts" >}})
+
+* `allow-oom`: use this flag to allow a script to execute when the server is out of memory (OOM).
+
+    Unless used, Redis will deny the execution of flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) when in an OOM state.
+    Furthermore, when you use this flag, the script can call any Redis command, including commands that aren't usually allowed in this state.
+    Specifying `no-writes` or using [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) / [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}) also implies the script can run in OOM state (without specifying `allow-oom`)
+
+* `allow-stale`: a flag that enables running the flagged scripts (Functions and Eval scripts with [shebang]({{< relref "/develop/interact/programmability/eval-intro#eval-flags" >}})) against a stale replica when the `replica-serve-stale-data` config is set to `no` .
+
+    Redis can be set to prevent data consistency problems from using old data by having stale replicas return a runtime error.
+    For scripts that do not access the data, this flag can be set to allow stale Redis replicas to run the script.
+    Note however that the script will still be unable to execute any command that accesses stale data.
+
+* `no-cluster`: the flag causes the script to return an error in Redis cluster mode.
+
+    Redis allows scripts to be executed both in standalone and cluster modes.
+    Setting this flag prevents executing the script against nodes in the cluster.
+
+* `allow-cross-slot-keys`: The flag that allows a script to access keys from multiple slots.
+
+    Redis typically prevents any single command from accessing keys that hash to multiple slots.
+    This flag allows scripts to break this rule and access keys within the script that access multiple slots.
+    Declared keys to the script are still always required to hash to a single slot.
+    Accessing keys from multiple slots is discouraged as applications should be designed to only access keys from a single slot at a time, allowing slots to move between Redis servers.
+    
+    This flag has no effect when cluster mode is disabled.
+
+Please refer to [Function Flags]({{< relref "develop/interact/programmability/functions-intro#function-flags" >}}) and [Eval Flags]({{< relref "develop/interact/programmability/eval-intro#eval-flags" >}}) for a detailed example.
+
+### `redis.REDIS_VERSION` {#redis.redis_version}
+
+* Since version: 7.0.0
+* Available in scripts: yes
+* Available in functions: yes
+
+Returns the current Redis server version as a Lua string.
+The reply's format is `MM.mm.PP`, where:
+
+* **MM:** is the major version.
+* **mm:** is the minor version.
+* **PP:** is the patch level.
+
+### `redis.REDIS_VERSION_NUM` {#redis.redis_version_num}
+
+* Since version: 7.0.0
+* Available in scripts: yes
+* Available in functions: yes
+
+Returns the current Redis server version as a number.
+The reply is a hexadecimal value structured as `0x00MMmmPP`, where:
+
+* **MM:** is the major version.
+* **mm:** is the minor version.
+* **PP:** is the patch level.
+
+## Data type conversion
+
+Unless a runtime exception is raised, `redis.call()` and `redis.pcall()` return the reply from the executed command to the Lua script.
+Redis' replies from these functions are converted automatically into Lua's native data types.
+
+Similarly, when a Lua script returns a reply with the `return` keyword,
+that reply is automatically converted to Redis' protocol.
+
+Put differently; there's a one-to-one mapping between Redis' replies and Lua's data types and a one-to-one mapping between Lua's data types and the [Redis Protocol]({{< relref "/develop/reference/protocol-spec" >}}) data types.
+The underlying design is such that if a Redis type is converted into a Lua type and converted back into a Redis type, the result is the same as the initial value.
+
+Type conversion from Redis protocol replies (i.e., the replies from `redis.call()` and `redis.pcall()`) to Lua data types depends on the Redis Serialization Protocol version used by the script.
+The default protocol version during script executions is RESP2.
+The script may switch the replies' protocol versions by calling the `redis.setresp()` function.
+
+Type conversion from a script's returned Lua data type depends on the user's choice of protocol (see the [`HELLO`]({{< relref "/commands/hello" >}}) command).
+
+The following sections describe the type conversion rules between Lua and Redis per the protocol's version.
+
+### RESP2 to Lua type conversion
+
+The following type conversion rules apply to the execution's context by default as well as after calling `redis.setresp(2)`:
+
+* [RESP2 integer reply]({{< relref "develop/reference/protocol-spec#integers" >}}) -> Lua number
+* [RESP2 bulk string reply]({{< relref "develop/reference/protocol-spec#bulk-strings" >}}) -> Lua string
+* [RESP2 array reply]({{< relref "develop/reference/protocol-spec#arrays" >}}) -> Lua table (may have other Redis data types nested)
+* [RESP2 status reply]({{< relref "develop/reference/protocol-spec#simple-strings" >}}) -> Lua table with a single _ok_ field containing the status string
+* [RESP2 error reply]({{< relref "develop/reference/protocol-spec#simple-errors" >}}) -> Lua table with a single _err_ field containing the error string
+* [RESP2 null bulk reply]({{< relref "develop/reference/protocol-spec#bulk-strings" >}}) and [RESP2 null multi-bulk reply]({{< relref "develop/reference/protocol-spec#arrays" >}}) -> Lua false boolean type
+
+## Lua to RESP2 type conversion
+
+The following type conversion rules apply by default as well as after the user had called `HELLO 2`:
+
+* Lua number -> [RESP2 integer reply]({{< relref "develop/reference/protocol-spec#integers" >}}) (the number is converted into an integer)
+* Lua string -> [RESP2 bulk string reply]({{< relref "develop/reference/protocol-spec#bulk-strings" >}})
+* Lua table (indexed, non-associative array) -> [RESP2 array reply]({{< relref "develop/reference/protocol-spec#arrays" >}}) (truncated at the first Lua `nil` value encountered in the table, if any)
+* Lua table with a single _ok_ field -> [RESP2 status reply]({{< relref "develop/reference/protocol-spec#simple-strings" >}})
+* Lua table with a single _err_ field -> [RESP2 error reply]({{< relref "develop/reference/protocol-spec#simple-errors" >}})
+* Lua boolean false -> [RESP2 null bulk reply]({{< relref "develop/reference/protocol-spec#bulk-strings" >}})
+
+There is an additional Lua-to-Redis conversion rule that has no corresponding Redis-to-Lua conversion rule:
+
+* Lua Boolean `true` -> [RESP2 integer reply]({{< relref "develop/reference/protocol-spec#integers" >}}) with value of 1.
+
+There are three additional rules to note about converting Lua to Redis data types:
+
+* Lua has a single numerical type, Lua numbers. 
+  There is no distinction between integers and floats.
+  So we always convert Lua numbers into integer replies, removing the decimal part of the number, if any.
+  **If you want to return a Lua float, it should be returned as a string**,
+  exactly like Redis itself does (see, for instance, the [`ZSCORE`]({{< relref "/commands/zscore" >}}) command).
+* There's [no simple way to have nils inside Lua arrays](http://www.lua.org/pil/19.1.html) due 
+  to Lua's table semantics.
+  Therefore, when Redis converts a Lua array to RESP, the conversion stops when it encounters a Lua `nil` value.
+* When a Lua table is an associative array that contains keys and their respective values, the converted Redis reply will **not** include them.
+
+Lua to RESP2 type conversion examples:
+
+```
+redis> EVAL "return 10" 0
+(integer) 10
+
+redis> EVAL "return { 1, 2, { 3, 'Hello World!' } }" 0
+1) (integer) 1
+2) (integer) 2
+3) 1) (integer) 3
+   1) "Hello World!"
+
+redis> EVAL "return redis.call('get','foo')" 0
+"bar"
+```
+
+The last example demonstrates receiving and returning the exact return value of `redis.call()` (or `redis.pcall()`) in Lua as it would be returned if the command had been called directly.
+
+The following example shows how floats and arrays that cont nils and keys are handled:
+
+```
+redis> EVAL "return { 1, 2, 3.3333, somekey = 'somevalue', 'foo', nil , 'bar' }" 0
+1) (integer) 1
+2) (integer) 2
+3) (integer) 3
+4) "foo"
+```
+
+As you can see, the float value of _3.333_ gets converted to an integer _3_, the _somekey_ key and its value are omitted, and the string "bar" isn't returned as there is a `nil` value that precedes it.
+
+### RESP3 to Lua type conversion
+
+[RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md) is a newer version of the [Redis Serialization Protocol]({{< relref "/develop/reference/protocol-spec" >}}).
+It is available as an opt-in choice as of Redis v6.0.
+
+An executing script may call the [`redis.setresp`](#redis.setresp) function during its execution and switch the protocol version that's used for returning replies from Redis' commands (that can be invoked via [`redis.call()`](#redis.call) or [`redis.pcall()`](#redis.pcall)).
+
+Once Redis' replies are in RESP3 protocol, all of the [RESP2 to Lua conversion](#resp2-to-lua-type-conversion) rules apply, with the following additions:
+
+* [RESP3 map reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#map-type) -> Lua table with a single _map_ field containing a Lua table representing the fields and values of the map.
+* [RESP set reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#set-reply) -> Lua table with a single _set_ field containing a Lua table representing the elements of the set as fields, each with the Lua Boolean value of `true`.
+* [RESP3 null](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#null-reply) -> Lua `nil`.
+* [RESP3 true reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#boolean-reply) -> Lua true boolean value.
+* [RESP3 false reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#boolean-reply) -> Lua false boolean value.
+* [RESP3 double reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#double-type) -> Lua table with a single _double_ field containing a Lua number representing the double value.
+* [RESP3 big number reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#big-number-type) -> Lua table with a single _big_number_ field containing a Lua string representing the big number value.
+* [Redis verbatim string reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#verbatim-string-type) -> Lua table with a single _verbatim_string_ field containing a Lua table with two fields, _string_ and _format_, representing the verbatim string and its format, respectively.
+
+**Note:**
+the RESP3 [big number](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#big-number-type) and [verbatim strings](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#verbatim-string-type) replies are only supported as of Redis v7.0 and greater. 
+Also, presently, RESP3's [attributes](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#attribute-type), [streamed strings](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#streamed-strings) and [streamed aggregate data types](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#streamed-aggregate-data-types) are not supported by the Redis Lua API.
+
+### Lua to RESP3 type conversion
+
+Regardless of the script's choice of protocol version set for replies with the [`redis.setresp()` function] when it calls `redis.call()` or `redis.pcall()`, the user may opt-in to using RESP3 (with the `HELLO 3` command) for the connection.
+Although the default protocol for incoming client connections is RESP2, the script should honor the user's preference and return adequately-typed RESP3 replies, so the following rules apply on top of those specified in the [Lua to RESP2 type conversion](#lua-to-resp2-type-conversion) section when that is the case.
+
+* Lua Boolean -> [RESP3 Boolean reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#boolean-reply) (note that this is a change compared to the RESP2, in which returning a Boolean Lua `true` returned the number 1 to the Redis client, and returning a `false` used to return a `null`.
+* Lua table with a single _map_ field set to an associative Lua table -> [RESP3 map reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#map-type).
+* Lua table with a single _set_ field set to an associative Lua table -> [RESP3 set reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#set-type). Values can be set to anything and are discarded anyway.
+* Lua table with a single _double_ field to an associative Lua table -> [RESP3 double reply](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#double-type).
+* Lua nil -> [RESP3 null](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md#null-reply).
+
+However, if the connection is set use the RESP2 protocol, and even if the script replies with RESP3-typed responses, Redis will automatically perform a RESP3 to RESP2 conversion of the reply as is the case for regular commands.
+That means, for example, that returning the RESP3 map type to a RESP2 connection will result in the reply being converted to a flat RESP2 array that consists of alternating field names and their values, rather than a RESP3 map.
+
+## Additional notes about scripting
+
+### Using `SELECT` inside scripts
+
+You can call the [`SELECT`]({{< relref "/commands/select" >}}) command from your Lua scripts, like you can with any normal client connection.
+However, one subtle aspect of the behavior changed between Redis versions 2.8.11 and 2.8.12.
+Prior to Redis version 2.8.12, the database selected by the Lua script was *set as the current database* for the client connection that had called it.
+As of Redis version 2.8.12, the database selected by the Lua script only affects the execution context of the script, and does not modify the database that's selected by the client calling the script.
+This semantic change between patch level releases was required since the old behavior was inherently incompatible with Redis' replication and introduced bugs.
+
+## Runtime libraries
+
+The Redis Lua runtime context always comes with several pre-imported libraries.
+
+The following [standard Lua libraries](https://www.lua.org/manual/5.1/manual.html#5) are available to use:
+
+* The [_String Manipulation (string)_ library](https://www.lua.org/manual/5.1/manual.html#5.4)
+* The [_Table Manipulation (table)_ library](https://www.lua.org/manual/5.1/manual.html#5.5)
+* The [_Mathematical Functions (math)_ library](https://www.lua.org/manual/5.1/manual.html#5.6)
+* The [_Operating System Facilities (os)_ library](#os-library)
+
+In addition, the following external libraries are loaded and accessible to scripts:
+
+* The [_struct_ library](#struct-library)
+* The [_cjson_ library](#cjson-library)
+* The [_cmsgpack_ library](#cmsgpack-library)
+* The [_bitop_ library](#bitop-library)
+
+### _os_ library {#os-library}
+
+* Since version: 7.4
+* Available in scripts: yes
+* Available in functions: yes
+
+_os_ provides a set of functions for dealing with date, time, and system commands.
+More details can be found in the [Operating System Facilities](https://www.lua.org/manual/5.1/manual.html#5.8).
+Note that for sandbox security, currently only the following os functions is exposed:
+
+* `os.clock()`
+
+### _struct_ library {#struct-library}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+_struct_ is a library for packing and unpacking C-like structures in Lua.
+It provides the following functions:
+
+* [`struct.pack()`](#struct.pack)
+* [`struct.unpack()`](#struct.unpack)
+* [`struct.size()`](#struct.size)
+
+All of _struct_'s functions expect their first argument to be a [format string](#struct-formats).
+
+#### _struct_ formats {#struct-formats}
+
+The following are valid format strings for _struct_'s functions:
+
+* `>`: big endian
+* `<`: little endian
+* `![num]`: alignment
+* `x`: padding
+* `b/B`: signed/unsigned byte
+* `h/H`: signed/unsigned short
+* `l/L`: signed/unsigned long
+* `T`: size_t
+* `i/In`: signed/unsigned integer with size _n_ (defaults to the size of int)
+* `cn`: sequence of _n_ chars (from/to a string); when packing, n == 0 means the
+  whole string; when unpacking, n == 0 means use the previously read number as
+  the string's length.
+* `s`: zero-terminated string
+* `f`: float
+* `d`: double
+* ` ` (space): ignored
+
+#### `struct.pack(x)` {#struct.pack}
+
+This function returns a struct-encoded string from values.
+It accepts a [_struct_ format string](#struct-formats) as its first argument, followed by the values that are to be encoded.
+
+Usage example:
+
+```
+redis> EVAL "return struct.pack('HH', 1, 2)" 0
+"\x01\x00\x02\x00"
+```
+
+#### `struct.unpack(x)` {#struct.unpack}
+
+This function returns the decoded values from a struct.
+It accepts a [_struct_ format string](#struct-formats) as its first argument, followed by encoded struct's string.
+
+Usage example:
+
+```
+redis> EVAL "return { struct.unpack('HH', ARGV[1]) }" 0 "\x01\x00\x02\x00"
+1) (integer) 1
+2) (integer) 2
+3) (integer) 5
+```
+
+#### `struct.size(x)` {#struct.size}
+
+This function returns the size, in bytes, of a struct.
+It accepts a [_struct_ format string](#struct-formats) as its only argument.
+
+Usage example:
+
+```
+redis> EVAL "return struct.size('HH')" 0
+(integer) 4
+```
+
+### _cjson_ library {#cjson-library}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+The _cjson_ library provides fast [JSON](https://json.org) encoding and decoding from Lua.
+It provides these functions.
+
+#### `cjson.encode(x)` {#cjson.encode}
+
+This function returns a JSON-encoded string for the Lua data type provided as its argument.
+
+Usage example:
+
+```
+redis> EVAL "return cjson.encode({ ['foo'] = 'bar' })" 0
+"{\"foo\":\"bar\"}"
+```
+
+#### `cjson.decode(x)` {#cjson.decode()}
+
+This function returns a Lua data type from the JSON-encoded string provided as its argument.
+
+Usage example:
+
+```
+redis> EVAL "return cjson.decode(ARGV[1])['foo']" 0 '{"foo":"bar"}'
+"bar"
+```
+
+### _cmsgpack_ library {#cmsgpack-library}
+
+* Since version: 2.6.0
+* Available in scripts: yes
+* Available in functions: yes
+
+The _cmsgpack_ library provides fast [MessagePack](https://msgpack.org/index.html) encoding and decoding from Lua.
+It provides these functions.
+
+#### `cmsgpack.pack(x)` {#cmsgpack.pack()}
+
+This function returns the packed string encoding of the Lua data type it is given as an argument.
+
+Usage example:
+
+```
+redis> EVAL "return cmsgpack.pack({'foo', 'bar', 'baz'})" 0
+"\x93\xa3foo\xa3bar\xa3baz"
+```
+
+#### `cmsgpack.unpack(x)` {#cmsgpack.unpack()}
+
+This function returns the unpacked values from decoding its input string argument.
+
+Usage example:
+
+```
+redis> EVAL "return cmsgpack.unpack(ARGV[1])" 0 "\x93\xa3foo\xa3bar\xa3baz"
+1) "foo"
+2) "bar"
+3) "baz"
+```
+
+### _bit_ library {#bitop-library}
+
+* Since version: 2.8.18
+* Available in scripts: yes
+* Available in functions: yes
+
+The _bit_ library provides bitwise operations on numbers.
+Its documentation resides at [Lua BitOp documentation](http://bitop.luajit.org/api.html)
+It provides the following functions.
+
+#### `bit.tobit(x)` {#bit.tobit()}
+
+Normalizes a number to the numeric range for bit operations and returns it.
+
+Usage example:
+
+```
+redis> EVAL 'return bit.tobit(1)' 0
+(integer) 1
+```
+
+#### `bit.tohex(x [,n])` {#bit.tohex()}
+
+Converts its first argument to a hex string. The number of hex digits is given by the absolute value of the optional second argument.
+
+Usage example:
+
+```
+redis> EVAL 'return bit.tohex(422342)' 0
+"000671c6"
+```
+
+#### `bit.bnot(x)` {#bit.bnot()}
+
+Returns the bitwise **not** of its argument.
+
+#### `bit.bnot(x)` `bit.bor(x1 [,x2...])`, `bit.band(x1 [,x2...])` and `bit.bxor(x1 [,x2...])` {#bit.ops}
+
+Returns either the bitwise **or**, bitwise **and**, or bitwise **xor** of all of its arguments.
+Note that more than two arguments are allowed.
+
+Usage example:
+
+```
+redis> EVAL 'return bit.bor(1,2,4,8,16,32,64,128)' 0
+(integer) 255
+```
+
+#### `bit.lshift(x, n)`, `bit.rshift(x, n)` and `bit.arshift(x, n)` {#bit.shifts}
+
+Returns either the bitwise logical **left-shift**, bitwise logical **right-shift**, or bitwise **arithmetic right-shift** of its first argument by the number of bits given by the second argument.
+
+#### `bit.rol(x, n)` and `bit.ror(x, n)` {#bit.ro}
+
+Returns either the bitwise **left rotation**, or bitwise **right rotation** of its first argument by the number of bits given by the second argument.
+Bits shifted out on one side are shifted back in on the other side.
+
+#### `bit.bswap(x)` {#bit.bswap()}
+
+Swaps the bytes of its argument and returns it.
+This can be used to convert little-endian 32-bit numbers to big-endian 32-bit numbers and vice versa.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Extending Redis with Lua and Redis Functions
+
+  '
+linkTitle: Programmability
+title: Redis programmability
+weight: 20
+---
+
+Redis provides a programming interface that lets you execute custom scripts on the server itself. In Redis 7 and beyond, you can use [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) to manage and run your scripts. In Redis 6.2 and below, you use [Lua scripting with the EVAL command]({{< relref "/develop/interact/programmability/eval-intro" >}}) to program the server.
+
+## Background
+
+Redis is, by [definition](https://github.com/redis/redis/blob/unstable/MANIFESTO#L7), a _"domain-specific language for abstract data types"_.
+The language that Redis speaks consists of its [commands]({{< relref "/commands" >}}).
+Most the commands specialize at manipulating core [data types]({{< relref "/develop/data-types" >}}) in different ways.
+In many cases, these commands provide all the functionality that a developer requires for managing application data in Redis.
+
+The term **programmability** in Redis means having the ability to execute arbitrary user-defined logic by the server.
+We refer to such pieces of logic as **scripts**.
+In our case, scripts enable processing the data where it lives, a.k.a _data locality_.
+Furthermore, the responsible embedding of programmatic workflows in the Redis server can help in reducing network traffic and improving overall performance.
+Developers can use this capability for implementing robust, application-specific APIs.
+Such APIs can encapsulate business logic and maintain a data model across multiple keys and different data structures.
+
+User scripts are executed in Redis by an embedded, sandboxed scripting engine.
+Presently, Redis supports a single scripting engine, the [Lua 5.1](https://www.lua.org/) interpreter.
+
+Please refer to the [Redis Lua API Reference]({{< relref "develop/interact/programmability/lua-api" >}}) page for complete documentation.
+
+## Running scripts
+
+Redis provides two means for running scripts.
+
+Firstly, and ever since Redis 2.6.0, the [`EVAL`]({{< relref "/commands/eval" >}}) command enables running server-side scripts.
+Eval scripts provide a quick and straightforward way to have Redis run your scripts ad-hoc.
+However, using them means that the scripted logic is a part of your application (not an extension of the Redis server).
+Every applicative instance that runs a script must have the script's source code readily available for loading at any time.
+That is because scripts are only cached by the server and are volatile.
+As your application grows, this approach can become harder to develop and maintain.
+
+Secondly, added in v7.0, Redis Functions are essentially scripts that are first-class database elements.
+As such, functions decouple scripting from application logic and enable independent development, testing, and deployment of scripts.
+To use functions, they need to be loaded first, and then they are available for use by all connected clients.
+In this case, loading a function to the database becomes an administrative deployment task (such as loading a Redis module, for example), which separates the script from the application.
+
+Please refer to the following pages for more information:
+
+* [Redis Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}})
+* [Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}})
+
+When running a script or a function, Redis guarantees its atomic execution.
+The script's execution blocks all server activities during its entire time, similarly to the semantics of [transactions]({{< relref "/develop/interact/transactions" >}}).
+These semantics mean that all of the script's effects either have yet to happen or had already happened.
+The blocking semantics of an executed script apply to all connected clients at all times.
+
+Note that the potential downside of this blocking approach is that executing slow scripts is not a good idea.
+It is not hard to create fast scripts because scripting's overhead is very low.
+However, if you intend to use a slow script in your application, be aware that all other clients are blocked and can't execute any command while it is running.
+
+## Read-only scripts
+
+A read-only script is a script that only executes commands that don't modify any keys within Redis.
+Read-only scripts can be executed either by adding the `no-writes` [flag]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) to the script or by executing the script with one of the read-only script command variants: [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}), [`EVALSHA_RO`]({{< relref "/commands/evalsha_ro" >}}), or [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}).
+They have the following properties:
+
+* They can always be executed on replicas.
+* They can always be killed by the [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) command. 
+* They never fail with OOM error when redis is over the memory limit.
+* They are not blocked during write pauses, such as those that occur during coordinated failovers.
+* They cannot execute any command that may modify the data set.
+* Currently [`PUBLISH`]({{< relref "/commands/publish" >}}), [`SPUBLISH`]({{< relref "/commands/spublish" >}}) and [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) are also considered write commands in scripts, because they could attempt to propagate commands to replicas and AOF file.
+
+In addition to the benefits provided by all read-only scripts, the read-only script commands have the following advantages:
+
+* They can be used to configure an ACL user to only be able to execute read-only scripts.
+* Many clients also better support routing the read-only script commands to replicas for applications that want to use replicas for read scaling.
+
+#### Read-only script history
+
+Read-only scripts and read-only script commands were introduced in Redis 7.0
+
+* Before Redis 7.0.1 [`PUBLISH`]({{< relref "/commands/publish" >}}), [`SPUBLISH`]({{< relref "/commands/spublish" >}}) and [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) were not considered write commands in scripts
+* Before Redis 7.0.1 the `no-writes` [flag]({{< relref "develop/interact/programmability/lua-api#script_flags" >}}) did not imply `allow-oom`
+* Before Redis 7.0.1 the `no-writes` flag did not permit the script to run during write pauses.
+
+
+The recommended approach is to use the standard scripting commands with the `no-writes` flag unless you need one of the previously mentioned features.
+
+## Sandboxed script context
+
+Redis places the engine that executes user scripts inside a sandbox.
+The sandbox attempts to prevent accidental misuse and reduce potential threats from the server's environment.
+
+Scripts should never try to access the Redis server's underlying host systems, such as the file system, network, or attempt to perform any other system call other than those supported by the API.
+
+Scripts should operate solely on data stored in Redis and data provided as arguments to their execution.
+
+## Maximum execution time
+
+Scripts are subject to a maximum execution time (set by default to five seconds).
+This default timeout is enormous since a script usually runs in less than a millisecond.
+The limit is in place to handle accidental infinite loops created during development.
+
+It is possible to modify the maximum time a script can be executed with millisecond precision,
+either via `redis.conf` or by using the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command.
+The configuration parameter affecting max execution time is called `busy-reply-threshold`.
+
+When a script reaches the timeout threshold, it isn't terminated by Redis automatically.
+Doing so would violate the contract between Redis and the scripting engine that ensures that scripts are atomic.
+Interrupting the execution of a script has the potential of leaving the dataset with half-written changes.
+
+Therefore, when a script executes longer than the configured timeout, the following happens:
+
+* Redis logs that a script is running for too long.
+* It starts accepting commands again from other clients but will reply with a BUSY error to all the clients sending normal commands. The only commands allowed in this state are [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}), [`FUNCTION KILL`]({{< relref "/commands/function-kill" >}}), and `SHUTDOWN NOSAVE`.
+* It is possible to terminate a script that only executes read-only commands using the [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) and [`FUNCTION KILL`]({{< relref "/commands/function-kill" >}}) commands. These commands do not violate the scripting semantic as no data was written to the dataset by the script yet.
+* If the script had already performed even a single write operation, the only command allowed is `SHUTDOWN NOSAVE` that stops the server without saving the current data set on disk (basically, the server is aborted).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'How the Redis server manages client connections
+
+  '
+linkTitle: Client handling
+title: Redis client handling
+weight: 5
+---
+
+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:
+
+* The client socket is put in the non-blocking state since Redis uses multiplexing and non-blocking I/O.
+* The `TCP_NODELAY` option is set in order to ensure that there are no delays to the connection.
+* A *readable* file event is created so that Redis is able to collect the client queries as soon as new data is available to read on the socket.
+
+After the client is initialized, Redis checks if it is already at the limit
+configured for the number of simultaneous clients (configured using the `maxclients` configuration directive, see the next section of this document for further information).
+
+When Redis can't accept a new client connection because the maximum number of clients
+has been reached, it tries to send an error to the client in order to
+make it aware of this condition, closing the connection immediately.
+The error message will reach the client even if the connection is
+closed immediately by Redis because the new socket output buffer is usually
+big enough to contain the error, so the kernel will handle transmission
+of the error.
+
+## What Order are Client Requests Served In?
+
+The order is determined by a combination of the client socket file descriptor
+number and order in which the kernel reports events, so the order should be 
+considered as unspecified.
+
+However, Redis does the following two things when serving clients:
+
+* It only performs a single `read()` system call every time there is something new to read from the client socket. This ensures that if we have multiple clients connected, and a few send queries at a high rate, other clients are not penalized and will not experience latency issues.
+* However once new data is read from a client, all the queries contained in the current buffers are processed sequentially. This improves locality and does not need iterating a second time to see if there are clients that need some processing time.
+
+## Maximum Concurrent Connected Clients
+
+In Redis 2.4 there was a hard-coded limit for the maximum number of clients
+that could be handled simultaneously.
+
+In Redis 2.6 and newer, this limit is configurable using the `maxclients` directive in `redis.conf`. The default is 10,000 clients.
+
+However, Redis checks with the kernel what the maximum number of file
+descriptors that we are able to open is (the *soft limit* is checked). If the
+limit is less than the maximum number of clients we want to handle, plus
+32 (that is the number of file descriptors Redis reserves for internal uses),
+then the maximum number of clients is updated to match the number
+of clients it is *really able to handle* under the current operating system
+limit.
+
+When `maxclients` is set to a number greater than Redis can support, a message is logged at startup:
+
+```
+$ ./redis-server --maxclients 100000
+[41422] 23 Jan 11:28:33.179 # Unable to set the max number of files limit to 100032 (Invalid argument), setting the max clients configuration to 10112.
+```
+
+When Redis is configured in order to handle a specific number of clients it
+is a good idea to make sure that the operating system limit for the maximum
+number of file descriptors per process is also set accordingly.
+
+Under Linux these limits can be set both in the current session and as a
+system-wide setting with the following commands:
+
+* `ulimit -Sn 100000 # This will only work if hard limit is big enough.`
+* `sysctl -w fs.file-max=100000`
+
+## Output Buffer Limits
+
+Redis needs to handle a variable-length output buffer for every client, since
+a command can produce a large amount of data that needs to be transferred to the
+client.
+
+However it is possible that a client sends more commands producing more output
+to serve at a faster rate than that which Redis can send the existing output to the
+client. This is especially true with Pub/Sub clients in case a client is not
+able to process new messages fast enough.
+
+Both conditions will cause the client output buffer to grow and consume
+more and more memory. For this reason by default Redis sets limits to the
+output buffer size for different kind of clients. When the limit is reached
+the client connection is closed and the event logged in the Redis log file.
+
+There are two kind of limits Redis uses:
+
+* The **hard limit** is a fixed limit that when reached will make Redis close the client connection as soon as possible.
+* The **soft limit** instead is a limit that depends on the time, for instance a soft limit of 32 megabytes per 10 seconds means that if the client has an output buffer bigger than 32 megabytes for, continuously, 10 seconds, the connection gets closed.
+
+Different kind of clients have different default limits:
+
+* **Normal clients** have a default limit of 0, that means, no limit at all, because most normal clients use blocking implementations sending a single command and waiting for the reply to be completely read before sending the next command, so it is always not desirable to close the connection in case of a normal client.
+* **Pub/Sub clients** have a default hard limit of 32 megabytes and a soft limit of 8 megabytes per 60 seconds.
+* **Replicas** have a default hard limit of 256 megabytes and a soft limit of 64 megabyte per 60 seconds.
+
+It is possible to change the limit at runtime using the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command or in a permanent way using the Redis configuration file `redis.conf`. See the example `redis.conf` in the Redis distribution for more information about how to set the limit.
+
+## Query Buffer Hard Limit
+
+Every client is also subject to a query buffer limit. This is a non-configurable hard limit that will close the connection when the client query buffer (that is the buffer we use to accumulate commands from the client) reaches 1 GB, and is actually only an extreme limit to avoid a server crash in case of client or server software bugs.
+
+## Client Eviction
+
+Redis is built to handle a very large number of client connections.
+Client connections tend to consume memory, and when there are many of them, the aggregate memory consumption can be extremely high, leading to data eviction or out-of-memory errors.
+These cases can be mitigated to an extent using [output buffer limits](#output-buffer-limits), but Redis allows us a more robust configuration to limit the aggregate memory used by all clients' connections.
+
+
+This mechanism is called **client eviction**, and it's essentially a safety mechanism that will disconnect clients once the aggregate memory usage of all clients is above a threshold.
+The mechanism first attempts to disconnect clients that use the most memory.
+It disconnects the minimal number of clients needed to return below the `maxmemory-clients` threshold.
+
+`maxmemory-clients` defines the maximum aggregate memory usage of all clients connected to Redis.
+The aggregation takes into account all the memory used by the client connections: the [query buffer](#query-buffer-hard-limit), the output buffer, and other intermediate buffers.
+
+Note that replica and master connections aren't affected by the client eviction mechanism. Therefore, such connections are never evicted.
+
+`maxmemory-clients` can be set permanently in the configuration file (`redis.conf`) or via the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command.
+This setting can either be 0 (meaning no limit), a size in bytes (possibly with `mb`/`gb` suffix),
+or a percentage of `maxmemory` by using the `%` suffix (e.g. setting it to `10%` would mean 10% of the `maxmemory` configuration).
+
+The default setting is 0, meaning client eviction is turned off by default.
+However, for any large production deployment, it is highly recommended to configure some non-zero `maxmemory-clients` value.
+A value `5%`, for example, can be a good place to start.
+
+It is possible to flag a specific client connection to be excluded from the client eviction mechanism.
+This is useful for control path connections.
+If, for example, you have an application that monitors the server via the [`INFO`]({{< relref "/commands/info" >}}) command and alerts you in case of a problem, you might want to make sure this connection isn't evicted.
+You can do so using the following command (from the relevant client's connection):
+
+[`CLIENT NO-EVICT`]({{< relref "/commands/client-no-evict" >}}) `on`
+
+And you can revert that with:
+
+[`CLIENT NO-EVICT`]({{< relref "/commands/client-no-evict" >}}) `off`
+
+For more information and an example refer to the `maxmemory-clients` section in the default `redis.conf` file.
+
+Client eviction is available from Redis 7.0.
+
+## Client Timeouts
+
+By default recent versions of Redis don't close the connection with the client
+if the client is idle for many seconds: the connection will remain open forever.
+
+However if you don't like this behavior, you can configure a timeout, so that
+if the client is idle for more than the specified number of seconds, the client connection will be closed.
+
+You can configure this limit via `redis.conf` or simply using `CONFIG SET timeout <value>`.
+
+Note that the timeout only applies to normal clients and it **does not apply to Pub/Sub clients**, since a Pub/Sub connection is a *push style* connection so a client that is idle is the norm.
+
+Even if by default connections are not subject to timeout, there are two conditions when it makes sense to set a timeout:
+
+* Mission critical applications where a bug in the client software may saturate the Redis server with idle connections, causing service disruption.
+* As a debugging mechanism in order to be able to connect with the server if a bug in the client software saturates the server with idle connections, making it impossible to interact with the server.
+
+Timeouts are not to be considered very precise: Redis avoids setting timer events or running O(N) algorithms in order to check idle clients, so the check is performed incrementally from time to time. This means that it is possible that while the timeout is set to 10 seconds, the client connection will be closed, for instance, after 12 seconds if many clients are connected at the same time.
+
+## The CLIENT Command
+
+The Redis [`CLIENT`]({{< relref "/commands/client" >}}) command allows you to inspect the state of every connected client, to kill a specific client, and to name connections. It is a very powerful debugging tool if you use Redis at scale.
+
+[`CLIENT LIST`]({{< relref "/commands/client-list" >}}) is used in order to obtain a list of connected clients and their state:
+
+```
+redis 127.0.0.1:6379> client list
+addr=127.0.0.1:52555 fd=5 name= age=855 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=client
+addr=127.0.0.1:52787 fd=6 name= age=6 idle=5 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=ping
+```
+
+In the above example two clients are connected to the Redis server. Let's look at what some of the data returned represents:
+
+* **addr**: The client address, that is, the client IP and the remote port number it used to connect with the Redis server.
+* **fd**: The client socket file descriptor number.
+* **name**: The client name as set by [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}}).
+* **age**: The number of seconds the connection existed for.
+* **idle**: The number of seconds the connection is idle.
+* **flags**: The kind of client (N means normal client, check the [full list of flags]({{< relref "/commands/client-list" >}})).
+* **omem**: The amount of memory used by the client for the output buffer.
+* **cmd**: The last executed command.
+
+See the [[`CLIENT LIST`]({{< relref "/commands/client-list" >}})](/commands/client-list) documentation for the full listing of fields and their purpose.
+
+Once you have the list of clients, you can close a client's connection using the [`CLIENT KILL`]({{< relref "/commands/client-kill" >}}) command, specifying the client address as its argument.
+
+The commands [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}}) and [`CLIENT GETNAME`]({{< relref "/commands/client-getname" >}}) can be used to set and get the connection name. Starting with Redis 4.0, the client name is shown in the
+[`SLOWLOG`]({{< relref "/commands/slowlog" >}}) output, to help identify clients that create latency issues.
+
+## TCP keepalive
+
+From version 3.2 onwards, Redis has TCP keepalive (`SO_KEEPALIVE` socket option) enabled by default and set to about 300 seconds. This option is useful in order to detect dead peers (clients that cannot be reached even if they look connected). Moreover, if there is network equipment between clients and servers that need to see some traffic in order to take the connection open, the option will prevent unexpected connection closed events.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to build clients for Redis Sentinel
+linkTitle: Sentinel clients
+title: Sentinel client spec
+weight: 2
+---
+
+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:
+
+* Automatic configuration of clients via Sentinel.
+* Improved safety of Redis Sentinel automatic failover.
+
+For details about how Redis Sentinel works, please check the [Redis Documentation]({{< relref "/operate/oss_and_stack/management/sentinel" >}}), as this document only contains information needed for Redis client developers, and it is expected that readers are familiar with the way Redis Sentinel works.
+
+## Redis service discovery via Sentinel
+
+Redis Sentinel identifies every master with a name like "stats" or "cache".
+Every name actually identifies a *group of instances*, composed of a master
+and a variable number of replicas.
+
+The address of the Redis master that is used for a specific purpose inside a network may change after events like an automatic failover, a manually triggered failover (for instance in order to upgrade a Redis instance), and other reasons.
+
+Normally Redis clients have some kind of hard-coded configuration that specifies the address of a Redis master instance within a network as IP address and port number. However if the master address changes, manual intervention in every client is needed.
+
+A Redis client supporting Sentinel can automatically discover the address of a Redis master from the master name using Redis Sentinel. So instead of a hard coded IP address and port, a client supporting Sentinel should optionally be able to take as input:
+
+* A list of ip:port pairs pointing to known Sentinel instances.
+* The name of the service, like "cache" or "timelines".
+
+This is the procedure a client should follow in order to obtain the master address starting from the list of Sentinels and the service name.
+
+### Step 1: connect to the first Sentinel
+
+The client should iterate the list of Sentinel addresses. For every address it should try to connect to the Sentinel, using a short timeout (in the order of a few hundreds of milliseconds). On errors or timeouts the next Sentinel address should be tried.
+
+If all the Sentinel addresses were tried without success, an error should be returned to the client.
+
+The first Sentinel replying to the client request should be put at the start of the list, so that at the next reconnection, we'll try first the Sentinel that was reachable in the previous connection attempt, minimizing latency.
+
+### Step 2: ask for the master address
+
+Once a connection with a Sentinel is established, the client should retry to execute the following command on the Sentinel:
+
+    SENTINEL get-master-addr-by-name master-name
+
+Where *master-name* should be replaced with the actual service name specified by the user.
+
+The result from this call can be one of the following two replies:
+
+* An ip:port pair.
+* A null reply. This means Sentinel does not know this master.
+
+If an ip:port pair is received, this address should be used to connect to the Redis master. Otherwise if a null reply is received, the client should try the next Sentinel in the list.
+
+### Step 3: call the ROLE command in the target instance
+
+Once the client discovered the address of the master instance, it should
+attempt a connection with the master, and call the [`ROLE`]({{< relref "/commands/role" >}}) command in order
+to verify the role of the instance is actually a master.
+
+If the [`ROLE`]({{< relref "/commands/role" >}}) commands is not available (it was introduced in Redis 2.8.12), a client may resort to the `INFO replication` command parsing the `role:` field of the output.
+
+If the instance is not a master as expected, the client should wait a short amount of time (a few hundreds of milliseconds) and should try again starting from Step 1.
+
+## Handle reconnections
+
+Once the service name is resolved into the master address and a connection is established with the Redis master instance, every time a reconnection is needed, the client should resolve again the address using Sentinels restarting from Step 1. For instance Sentinel should contacted again the following cases:
+
+* If the client reconnects after a timeout or socket error.
+* If the client reconnects because it was explicitly closed or reconnected by the user.
+
+In the above cases and any other case where the client lost the connection with the Redis server, the client should resolve the master address again.
+
+## Sentinel failover disconnection
+
+Starting with Redis 2.8.12, when Redis Sentinel changes the configuration of
+an instance, for example promoting a replica to a master, demoting a master to
+replicate to the new master after a failover, or simply changing the master
+address of a stale replica instance, it sends a `CLIENT KILL type normal`
+command to the instance in order to make sure all the clients are disconnected
+from the reconfigured instance. This will force clients to resolve the master
+address again.
+
+If the client will contact a Sentinel with yet not updated information, the verification of the Redis instance role via the [`ROLE`]({{< relref "/commands/role" >}}) command will fail, allowing the client to detect that the contacted Sentinel provided stale information, and will try again.
+
+Note: it is possible that a stale master returns online at the same time a client contacts a stale Sentinel instance, so the client may connect with a stale master, and yet the ROLE output will match. However when the master is back again Sentinel will try to demote it to replica, triggering a new disconnection. The same reasoning applies to connecting to stale replicas that will get reconfigured to replicate with a different master.
+
+## Connect to replicas
+
+Sometimes clients are interested to connect to replicas, for example in order to scale read requests. This protocol supports connecting to replicas by modifying step 2 slightly. Instead of calling the following command:
+
+    SENTINEL get-master-addr-by-name master-name
+
+The clients should call instead:
+
+    SENTINEL replicas master-name
+
+In order to retrieve a list of replica instances.
+
+Symmetrically the client should verify with the [`ROLE`]({{< relref "/commands/role" >}}) command that the
+instance is actually a replica, in order to avoid scaling read queries with
+the master.
+
+## Connection pools
+
+For clients implementing connection pools, on reconnection of a single connection, the Sentinel should be contacted again, and in case of a master address change all the existing connections should be closed and connected to the new address.
+
+## Error reporting
+
+The client should correctly return the information to the user in case of errors. Specifically:
+
+* If no Sentinel can be contacted (so that the client was never able to get the reply to `SENTINEL get-master-addr-by-name`), an error that clearly states that Redis Sentinel is unreachable should be returned.
+* If all the Sentinels in the pool replied with a null reply, the user should be informed with an error that Sentinels don't know this master name.
+
+## Sentinels list automatic refresh
+
+Optionally once a successful reply to `get-master-addr-by-name` is received, a client may update its internal list of Sentinel nodes following this procedure:
+
+* Obtain a list of other Sentinels for this master using the command `SENTINEL sentinels <master-name>`.
+* Add every ip:port pair not already existing in our list at the end of the list.
+
+It is not needed for a client to be able to make the list persistent updating its own configuration. The ability to upgrade the in-memory representation of the list of Sentinels can be already useful to improve reliability.
+
+## Subscribe to Sentinel events to improve responsiveness
+
+The [Sentinel documentation]({{< relref "/operate/oss_and_stack/management/sentinel" >}}) shows how clients can connect to
+Sentinel instances using Pub/Sub in order to subscribe to changes in the
+Redis instances configurations.
+
+This mechanism can be used in order to speedup the reconfiguration of clients,
+that is, clients may listen to Pub/Sub in order to know when a configuration
+change happened in order to run the three steps protocol explained in this
+document in order to resolve the new Redis master (or replica) address.
+
+However update messages received via Pub/Sub should not substitute the
+above procedure, since there is no guarantee that a client is able to
+receive all the update messages.
+
+## Additional information
+
+For additional information or to discuss specific aspects of this guidelines, please drop a message to the [Redis Google Group](https://groups.google.com/group/redis-db).
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get additional information about a command
+linkTitle: Command tips
+title: Redis command tips
+weight: 1
+---
+
+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`]({{< relref "/commands/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.
+
+## nondeterministic_output
+
+This tip indicates that the command's output isn't deterministic.
+That means that calls to the command may yield different results with the same arguments and data.
+That difference could be the result of the command's random nature (e.g., [`RANDOMKEY`]({{< relref "/commands/randomkey" >}}) and [`SPOP`]({{< relref "/commands/spop" >}})); the call's timing (e.g., [`TTL`]({{< relref "/commands/ttl" >}})); or generic differences that relate to the server's state (e.g., [`INFO`]({{< relref "/commands/info" >}}) and [`CLIENT LIST`]({{< relref "/commands/client-list" >}})).
+
+**Note:**
+Prior to Redis 7.0, this tip was the _random_ command flag.
+
+## nondeterministic_output_order
+
+The existence of this tip indicates that the command's output is deterministic, but its ordering is random (e.g., [`HGETALL`]({{< relref "/commands/hgetall" >}}) and [`SMEMBERS`]({{< relref "/commands/smembers" >}})).
+
+**Note:**
+Prior to Redis 7.0, this tip was the _sort_\__for_\__script_ flag.
+
+## request_policy
+
+This tip can help clients determine the shards to send the command in clustering mode.
+The default behavior a client should implement for commands without the _request_policy_ tip is as follows:
+
+1. The command doesn't accept key name arguments: the client can execute the command on an arbitrary shard.
+1. For commands that accept one or more key name arguments: the client should route the command to a single shard, as determined by the hash slot of the input keys.
+
+In cases where the client should adopt a behavior different than the default, the _request_policy_ tip can be one of:
+
+- **all_nodes:** the client should execute the command on all nodes - masters and replicas alike.
+  An example is the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command. 
+  This tip is in-use by commands that don't accept key name arguments.
+  The command operates atomically per shard.
+* **all_shards:** the client should execute the command on all master shards (e.g., the [`DBSIZE`]({{< relref "/commands/dbsize" >}}) command).
+  This tip is in-use by commands that don't accept key name arguments.
+  The command operates atomically per shard.
+- **multi_shard:** the client should execute the command on several shards.
+  The client should split the inputs according to the hash slots of its input key name arguments.
+  For example, the command `DEL {foo} {foo}1 bar` should be split to `DEL {foo} {foo}1` and `DEL bar`.
+  If the keys are hashed to more than a single slot, the command must be split even if all the slots are managed by the same shard.
+  Examples for such commands include [`MSET`]({{< relref "/commands/mset" >}}), [`MGET`]({{< relref "/commands/mget" >}}) and [`DEL`]({{< relref "/commands/del" >}}).
+  However, note that [`SUNIONSTORE`]({{< relref "/commands/sunionstore" >}}) isn't considered as _multi_shard_ because all of its keys must belong to the same hash slot.
+- **special:** indicates a non-trivial form of the client's request policy, such as the [`SCAN`]({{< relref "/commands/scan" >}}) command.
+
+## response_policy
+
+This tip can help clients determine the aggregate they need to compute from the replies of multiple shards in a cluster.
+The default behavior for commands without a _request_policy_ tip only applies to replies with of nested types (i.e., an array, a set, or a map).
+The client's implementation for the default behavior should be as follows:
+
+1. The command doesn't accept key name arguments: the client can aggregate all replies within a single nested data structure.
+For example, the array replies we get from calling [`KEYS`]({{< relref "/commands/keys" >}}) against all shards.
+These should be packed in a single in no particular order.
+1. For commands that accept one or more key name arguments: the client needs to retain the same order of replies as the input key names.
+For example, [`MGET`]({{< relref "/commands/mget" >}})'s aggregated reply.
+
+The _response_policy_ tip is set for commands that reply with scalar data types, or when it's expected that clients implement a non-default aggregate.
+This tip can be one of:
+
+* **one_succeeded:** the clients should return success if at least one shard didn't reply with an error.
+  The client should reply with the first non-error reply it obtains.
+  If all shards return an error, the client can reply with any one of these.
+  For example, consider a [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) command that's sent to all shards.
+  Although the script should be loaded in all of the cluster's shards, the [`SCRIPT KILL`]({{< relref "/commands/script-kill" >}}) will typically run only on one at a given time.
+* **all_succeeded:** the client should return successfully only if there are no error replies.
+  Even a single error reply should disqualify the aggregate and be returned.
+  Otherwise, the client should return one of the non-error replies.
+  As an example, consider the [`CONFIG SET`]({{< relref "/commands/config-set" >}}), [`SCRIPT FLUSH`]({{< relref "/commands/script-flush" >}}) and [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) commands.
+* **agg_logical_and:** the client should return the result of a logical _AND_ operation on all replies (only applies to integer replies, usually from commands that return either _0_ or _1_).
+  Consider the [`SCRIPT EXISTS`]({{< relref "/commands/script-exists" >}}) command as an example.
+  It returns an array of _0_'s and _1_'s that denote the existence of its given SHA1 sums in the script cache.
+  The aggregated response should be _1_ only when all shards had reported that a given script SHA1 sum is in their respective cache.
+* **agg_logical_or:** the client should return the result of a logical _AND_ operation on all replies (only applies to integer replies, usually from commands that return either _0_ or _1_).
+* **agg_min:** the client should return the minimal value from the replies (only applies to numerical replies).
+  The aggregate reply from a cluster-wide [`WAIT`]({{< relref "/commands/wait" >}}) command, for example, should be the minimal value (number of synchronized replicas) from all shards.
+* **agg_max:** the client should return the maximal value from the replies (only applies to numerical replies).
+* **agg_sum:** the client should return the sum of replies (only applies to numerical replies).
+  Example: [`DBSIZE`]({{< relref "/commands/dbsize" >}}).
+* **special:** this type of tip indicates a non-trivial form of reply policy.
+  [`INFO`]({{< relref "/commands/info" >}}) is an excellent example of that.
+
+## Example
+
+```
+redis> command info ping
+1)  1) "ping"
+    2) (integer) -1
+    3) 1) fast
+    4) (integer) 0
+    5) (integer) 0
+    6) (integer) 0
+    7) 1) @fast
+       2) @connection
+    8) 1) "request_policy:all_shards"
+       2) "response_policy:all_succeeded"
+    9) (empty array)
+   10) (empty array)
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: The Redis Gopher protocol implementation
+linkTitle: Gopher protocol
+title: Redis and the Gopher protocol
+weight: 10
+---
+
+** Note: Support for Gopher was removed in Redis 7.0 **
+
+Redis contains an implementation of the Gopher protocol, as specified in
+the [RFC 1436](https://www.ietf.org/rfc/rfc1436.txt).
+
+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.
+
+Anyway, for the 10th birthday of the Redis, we gave it the Gopher protocol
+as a gift.
+
+## How it works
+
+The Redis Gopher support uses the inline protocol of Redis, and specifically
+two kind of inline requests that were anyway illegal: an empty request
+or any request that starts with "/" (there are no Redis commands starting
+with such a slash). Normal RESP2/RESP3 requests are completely out of the
+path of the Gopher protocol implementation and are served as usually as well.
+
+If you open a connection to Redis when Gopher is enabled and send it
+a string like "/foo", if there is a key named "/foo" it is served via the
+Gopher protocol.
+
+In order to create a real Gopher "hole" (the name of a Gopher site in Gopher
+talking), you likely need a script such as the one in [https://github.com/antirez/gopher2redis](https://github.com/antirez/gopher2redis).
+
+## SECURITY WARNING
+
+If you plan to put Redis on the internet in a publicly accessible address
+to server Gopher pages **make sure to set a password** to the instance.
+Once a password is set:
+
+1. The Gopher server (when enabled, not by default) will kill serve content via Gopher.
+2. However other commands cannot be called before the client will authenticate.
+
+So use the `requirepass` option to protect your instance.
+
+To enable Gopher support use the following configuration line.
+
+    gopher-enabled yes
+
+Accessing keys that are not strings or do not exit will generate
+an error in Gopher protocol format.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Server-assisted, client-side caching in Redis
+
+  '
+linkTitle: Client-side caching
+title: Client-side caching reference
+aliases: /develop/use/client-side-caching/
+weight: 2
+---
+
+{{<note>}}This document is intended as an in-depth reference for
+client-side caching. See
+[Client-side caching introduction]({{< relref "/develop/clients/client-side-caching" >}})
+for general usage guidelines.
+{{</note>}}
+
+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.
+
+Normally when data is required, the application servers ask the database about
+such information, like in the following diagram:
+
+
+    +-------------+                                +----------+
+    |             | ------- GET user:1234 -------> |          |
+    | Application |                                | Database |
+    |             | <---- username = Alice ------- |          |
+    +-------------+                                +----------+
+
+When client-side caching is used, the application will store the reply of
+popular queries directly inside the application memory, so that it can
+reuse such replies later, without contacting the database again:
+
+    +-------------+                                +----------+
+    |             |                                |          |
+    | Application |       ( No chat needed )       | Database |
+    |             |                                |          |
+    +-------------+                                +----------+
+    | Local cache |
+    |             |
+    | user:1234 = |
+    | username    |
+    | Alice       |
+    +-------------+
+
+While the application memory used for the local cache may not be very big,
+the time needed in order to access the local computer memory is orders of
+magnitude smaller compared to accessing a networked service like a database.
+Since often the same small percentage of data are accessed frequently,
+this pattern can greatly reduce the latency for the application to get data
+and, at the same time, the load in the database side.
+
+Moreover there are many datasets where items change very infrequently.
+For instance, most user posts in a social network are either immutable or
+rarely edited by the user. Adding to this the fact that usually a small
+percentage of the posts are very popular, either because a small set of users
+have a lot of followers and/or because recent posts have a lot more
+visibility, it is clear why such a pattern can be very useful.
+
+Usually the two key advantages of client-side caching are:
+
+1. Data is available with a very small latency.
+2. The database system receives less queries, allowing it to serve the same dataset with a smaller number of nodes.
+
+## There are two hard problems in computer science...
+
+A problem with the above pattern is how to invalidate the information that
+the application is holding, in order to avoid presenting stale data to the
+user. For example after the application above locally cached the information
+for user:1234, Alice may update her username to Flora. Yet the application
+may continue to serve the old username for user:1234.
+
+Sometimes, depending on the exact application we are modeling, this isn't a
+big deal, so the client will just use a fixed maximum "time to live" for the
+cached information. Once a given amount of time has elapsed, the information
+will no longer be considered valid. More complex patterns, when using Redis,
+leverage the Pub/Sub system in order to send invalidation messages to
+listening clients. This can be made to work but is tricky and costly from
+the point of view of the bandwidth used, because often such patterns involve
+sending the invalidation messages to every client in the application, even
+if certain clients may not have any copy of the invalidated data. Moreover
+every application query altering the data requires to use the [`PUBLISH`]({{< relref "/commands/publish" >}})
+command, costing the database more CPU time to process this command.
+
+Regardless of what schema is used, there is a simple fact: many very large
+applications implement some form of client-side caching, because it is the
+next logical step to having a fast store or a fast cache server. For this
+reason Redis 6 implements direct support for client-side caching, in order
+to make this pattern much simpler to implement, more accessible, reliable,
+and efficient.
+
+## The Redis implementation of client-side caching
+
+The Redis client-side caching support is called _Tracking_, and has two modes:
+
+* In the default mode, the server remembers what keys a given client accessed, and sends invalidation messages when the same keys are modified. This costs memory in the server side, but sends invalidation messages only for the set of keys that the client might have in memory.
+* In the _broadcasting_ mode, the server does not attempt to remember what keys a given client accessed, so this mode costs no memory at all in the server side. Instead clients subscribe to key prefixes such as `object:` or `user:`, and receive a notification message every time a key matching a subscribed prefix is touched.
+
+To recap, for now let's forget for a moment about the broadcasting mode, to
+focus on the first mode. We'll describe broadcasting in more detail later.
+
+1. Clients can enable tracking if they want. Connections start without tracking enabled.
+2. When tracking is enabled, the server remembers what keys each client requested during the connection lifetime (by sending read commands about such keys).
+3. When a key is modified by some client, or is evicted because it has an associated expire time, or evicted because of a _maxmemory_ policy, all the clients with tracking enabled that may have the key cached, are notified with an _invalidation message_.
+4. When clients receive invalidation messages, they are required to remove the corresponding keys, in order to avoid serving stale data.
+
+This is an example of the protocol:
+
+* Client 1 `->` Server: CLIENT TRACKING ON
+* Client 1 `->` Server: GET foo
+* (The server remembers that Client 1 may have the key "foo" cached)
+* (Client 1 may remember the value of "foo" inside its local memory)
+* Client 2 `->` Server: SET foo SomeOtherValue
+* Server `->` Client 1: INVALIDATE "foo"
+
+This looks great superficially, but if you imagine 10k connected clients all
+asking for millions of keys over long living connection, the server ends up
+storing too much information. For this reason Redis uses two key ideas in
+order to limit the amount of memory used server-side and the CPU cost of
+handling the data structures implementing the feature:
+
+* The server remembers the list of clients that may have cached a given key in a single global table. This table is called the **Invalidation Table**. The invalidation table can contain a maximum number of entries. If a new key is inserted, the server may evict an older entry by pretending that such key was modified (even if it was not), and sending an invalidation message to the clients. Doing so, it can reclaim the memory used for this key, even if this will force the clients having a local copy of the key to evict it.
+* Inside the invalidation table we don't really need to store pointers to clients' structures, that would force a garbage collection procedure when the client disconnects: instead what we do is just store client IDs (each Redis client has a unique numerical ID). If a client disconnects, the information will be incrementally garbage collected as caching slots are invalidated.
+* There is a single keys namespace, not divided by database numbers. So if a client is caching the key `foo` in database 2, and some other client changes the value of the key `foo` in database 3, an invalidation message will still be sent. This way we can ignore database numbers reducing both the memory usage and the implementation complexity.
+
+## Two connections mode
+
+Using the new version of the Redis protocol, RESP3, supported by Redis 6, it is possible to run the data queries and receive the invalidation messages in the same connection. However many client implementations may prefer to implement client-side caching using two separated connections: one for data, and one for invalidation messages. For this reason when a client enables tracking, it can specify to redirect the invalidation messages to another connection by specifying the "client ID" of a different connection. Many data connections can redirect invalidation messages to the same connection, this is useful for clients implementing connection pooling. The two connections model is the only one that is also supported for RESP2 (which lacks the ability to multiplex different kind of information in the same connection).
+
+Here's an example of a complete session using the Redis protocol in the old RESP2 mode involving the following steps: enabling tracking redirecting to another connection, asking for a key, and getting an invalidation message once the key gets modified.
+
+To start, the client opens a first connection that will be used for invalidations, requests the connection ID, and subscribes via Pub/Sub to the special channel that is used to get invalidation messages when in RESP2 modes (remember that RESP2 is the usual Redis protocol, and not the more advanced protocol that you can use, optionally, with Redis 6 using the [`HELLO`]({{< relref "/commands/hello" >}}) command):
+
+```
+(Connection 1 -- used for invalidations)
+CLIENT ID
+:4
+SUBSCRIBE __redis__:invalidate
+*3
+$9
+subscribe
+$20
+__redis__:invalidate
+:1
+```
+
+Now we can enable tracking from the data connection:
+
+```
+(Connection 2 -- data connection)
+CLIENT TRACKING on REDIRECT 4
++OK
+
+GET foo
+$3
+bar
+```
+
+The client may decide to cache `"foo" => "bar"` in the local memory.
+
+A different client will now modify the value of the "foo" key:
+
+```
+(Some other unrelated connection)
+SET foo bar
++OK
+```
+
+As a result, the invalidations connection will receive a message that invalidates the specified key.
+
+```
+(Connection 1 -- used for invalidations)
+*3
+$7
+message
+$20
+__redis__:invalidate
+*1
+$3
+foo
+```
+The client will check if there are cached keys in this caching slot, and will evict the information that is no longer valid.
+
+Note that the third element of the Pub/Sub message is not a single key but
+is a Redis array with just a single element. Since we send an array, if there
+are groups of keys to invalidate, we can do that in a single message.
+In case of a flush ([`FLUSHALL`]({{< relref "/commands/flushall" >}}) or [`FLUSHDB`]({{< relref "/commands/flushdb" >}})), a `null` message will be sent.
+
+A very important thing to understand about client-side caching used with
+RESP2 and a Pub/Sub connection in order to read the invalidation messages,
+is that using Pub/Sub is entirely a trick **in order to reuse old client
+implementations**, but actually the message is not really sent to a channel
+and received by all the clients subscribed to it. Only the connection we
+specified in the `REDIRECT` argument of the [`CLIENT`]({{< relref "/commands/client" >}}) command will actually
+receive the Pub/Sub message, making the feature a lot more scalable.
+
+When RESP3 is used instead, invalidation messages are sent (either in the
+same connection, or in the secondary connection when redirection is used)
+as `push` messages (read the RESP3 specification for more information).
+
+## What tracking tracks
+
+As you can see clients do not need, by default, to tell the server what keys
+they are caching. Every key that is mentioned in the context of a read-only
+command is tracked by the server, because it *could be cached*.
+
+This has the obvious advantage of not requiring the client to tell the server
+what it is caching. Moreover in many clients implementations, this is what
+you want, because a good solution could be to just cache everything that is not
+already cached, using a first-in first-out approach: we may want to cache a
+fixed number of objects, every new data we retrieve, we could cache it,
+discarding the oldest cached object. More advanced implementations may instead
+drop the least used object or alike.
+
+Note that anyway if there is write traffic on the server, caching slots
+will get invalidated during the course of the time. In general when the
+server assumes that what we get we also cache, we are making a tradeoff:
+
+1. It is more efficient when the client tends to cache many things with a policy that welcomes new objects.
+2. The server will be forced to retain more data about the client keys.
+3. The client will receive useless invalidation messages about objects it did not cache.
+
+So there is an alternative described in the next section.
+
+## Opt-in and Opt-out caching
+
+### Opt-in
+
+Clients implementations may want to cache only selected keys, and communicate
+explicitly to the server what they'll cache and what they will not. This will
+require more bandwidth when caching new objects, but at the same time reduces
+the amount of data that the server has to remember and the amount of
+invalidation messages received by the client.
+
+In order to do this, tracking must be enabled using the OPTIN option:
+
+    CLIENT TRACKING ON REDIRECT 1234 OPTIN
+
+In this mode, by default, keys mentioned in read queries *are not supposed to be cached*, instead when a client wants to cache something, it must send a special command immediately before the actual command to retrieve the data:
+
+    CLIENT CACHING YES
+    +OK
+    GET foo
+    "bar"
+
+The `CACHING` command affects the command executed immediately after it.
+However, in case the next command is [`MULTI`]({{< relref "/commands/multi" >}}), all the commands in the
+transaction will be tracked. Similarly, in case of Lua scripts, all the
+commands executed by the script will be tracked.
+
+### Opt-out
+
+Opt-out caching allows clients to automatically cache keys locally without explicitly opting in for each key.
+This approach ensures that all keys are cached by default unless specified otherwise.
+Opt-out caching can simplify the implementation of client-side caching by reducing the need for explicit commands to enable caching for individual keys.
+
+Tracking must be enabled using the OPTOUT option to enable opt-out caching:
+
+    CLIENT TRACKING ON OPTOUT
+
+If you want to exclude a specific key from being tracked and cached, use the CLIENT UNTRACKING command:
+
+    CLIENT UNTRACKING key
+
+## Broadcasting mode
+
+So far we described the first client-side caching model that Redis implements.
+There is another one, called broadcasting, that sees the problem from the
+point of view of a different tradeoff, does not consume any memory on the
+server side, but instead sends more invalidation messages to clients.
+In this mode we have the following main behaviors:
+
+* Clients enable client-side caching using the `BCAST` option, specifying one or more prefixes using the `PREFIX` option. For instance: `CLIENT TRACKING on REDIRECT 10 BCAST PREFIX object: PREFIX user:`. If no prefix is specified at all, the prefix is assumed to be the empty string, so the client will receive invalidation messages for every key that gets modified. Instead if one or more prefixes are used, only keys matching one of the specified prefixes will be sent in the invalidation messages.
+* The server does not store anything in the invalidation table. Instead it uses a different **Prefixes Table**, where each prefix is associated to a list of clients.
+* No two prefixes can track overlapping parts of the keyspace. For instance, having the prefix "foo" and "foob" would not be allowed, since they would both trigger an invalidation for the key "foobar". However, just using the prefix "foo" is sufficient.
+* Every time a key matching any of the prefixes is modified, all the clients subscribed to that prefix, will receive the invalidation message.
+* The server will consume CPU proportional to the number of registered prefixes. If you have just a few, it is hard to see any difference. With a big number of prefixes the CPU cost can become quite large.
+* In this mode the server can perform the optimization of creating a single reply for all the clients subscribed to a given prefix, and send the same reply to all. This helps to lower the CPU usage.
+
+## The NOLOOP option
+
+By default client-side tracking will send invalidation messages to the
+client that modified the key. Sometimes clients want this, since they
+implement very basic logic that does not involve automatically caching
+writes locally. However, more advanced clients may want to cache even the
+writes they are doing in the local in-memory table. In such case receiving
+an invalidation message immediately after the write is a problem, since it
+will force the client to evict the value it just cached.
+
+In this case it is possible to use the `NOLOOP` option: it works both
+in normal and broadcasting mode. Using this option, clients are able to
+tell the server they don't want to receive invalidation messages for keys
+that they modified.
+
+## Avoiding race conditions
+
+When implementing client-side caching redirecting the invalidation messages
+to a different connection, you should be aware that there is a possible
+race condition. See the following example interaction, where we'll call
+the data connection "D" and the invalidation connection "I":
+
+    [D] client -> server: GET foo
+    [I] server -> client: Invalidate foo (somebody else touched it)
+    [D] server -> client: "bar" (the reply of "GET foo")
+
+As you can see, because the reply to the GET was slower to reach the
+client, we received the invalidation message before the actual data that
+is already no longer valid. So we'll keep serving a stale version of the
+foo key. To avoid this problem, it is a good idea to populate the cache
+when we send the command with a placeholder:
+
+    Client cache: set the local copy of "foo" to "caching-in-progress"
+    [D] client-> server: GET foo.
+    [I] server -> client: Invalidate foo (somebody else touched it)
+    Client cache: delete "foo" from the local cache.
+    [D] server -> client: "bar" (the reply of "GET foo")
+    Client cache: don't set "bar" since the entry for "foo" is missing.
+
+Such a race condition is not possible when using a single connection for both
+data and invalidation messages, since the order of the messages is always known
+in that case.
+
+## What to do when losing connection with the server
+
+Similarly, if we lost the connection with the socket we use in order to
+get the invalidation messages, we may end with stale data. In order to avoid
+this problem, we need to do the following things:
+
+1. Make sure that if the connection is lost, the local cache is flushed.
+2. Both when using RESP2 with Pub/Sub, or RESP3, ping the invalidation channel periodically (you can send PING commands even when the connection is in Pub/Sub mode!). If the connection looks broken and we are not able to receive ping backs, after a maximum amount of time, close the connection and flush the cache.
+
+## What to cache
+
+Clients may want to run internal statistics about the number of times
+a given cached key was actually served in a request, to understand in the
+future what is good to cache. In general:
+
+* We don't want to cache many keys that change continuously.
+* We don't want to cache many keys that are requested very rarely.
+* We want to cache keys that are requested often and change at a reasonable rate. For an example of key not changing at a reasonable rate, think of a global counter that is continuously [`INCR`]({{< relref "/commands/incr" >}})emented.
+
+However simpler clients may just evict data using some random sampling just
+remembering the last time a given cached value was served, trying to evict
+keys that were not served recently.
+
+## Other hints for implementing client libraries
+
+* Handling TTLs: make sure you also request the key TTL and set the TTL in the local cache if you want to support caching keys with a TTL.
+* Putting a max TTL on every key is a good idea, even if it has no TTL. This protects against bugs or connection issues that would make the client have old data in the local copy.
+* Limiting the amount of memory used by clients is absolutely needed. There must be a way to evict old keys when new ones are added.
+
+## Limiting the amount of memory used by Redis
+
+Be sure to configure a suitable value for the maximum number of keys remembered by Redis or alternatively use the BCAST mode that consumes no memory at all on the Redis side. Note that the memory consumed by Redis when BCAST is not used, is proportional both to the number of keys tracked and the number of clients requesting such keys.
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: What are command key specification and how to use them in your client
+linkTitle: Command key specifications
+title: Command key specifications
+weight: 3
+---
+
+Many of the commands in Redis accept key names as input arguments.
+The 9th element in the reply of [`COMMAND`]({{< relref "/commands/command" >}}) (and [`COMMAND INFO`]({{< relref "/commands/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.
+
+Cluster-aware Redis clients had to have the keys' extraction logic hard-coded in the cases of commands such as [`EVAL`]({{< relref "/commands/eval" >}}) and [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}) that rely on a _numkeys_ argument or [`SORT`]({{< relref "/commands/sort" >}}) and its many clauses.
+Alternatively, the [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) can be used to achieve a similar extraction effect but at a higher latency.
+
+A Redis client isn't obligated to support key specifications.
+It can continue using the legacy _first key_, _last key_ and _step_ scheme along with the [_movablekeys_ flag]({{< relref "/commands/command#flags" >}}) that remain unchanged.
+
+However, a Redis client that implements key specifications support can consolidate most of its keys' extraction logic.
+Even if the client encounters an unfamiliar type of key specification, it can always revert to the [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) command.
+
+That said, most cluster-aware clients only require a single key name to perform correct command routing, so it is possible that although a command features one unfamiliar specification, its other specification may still be usable by the client.
+
+Key specifications are maps with the following keys:
+
+1. **begin_search:**: the starting index for keys' extraction.
+2. **find_keys:** the rule for identifying the keys relative to the BS.
+3. **notes**: notes about this key spec, if there are any.
+4. **flags**: indicate the type of data access.
+
+## begin_search
+
+The _begin\_search_ value of a specification informs the client of the extraction's beginning.
+The value is a map.
+There are three types of `begin_search`:
+
+1. **index:** key name arguments begin at a constant index.
+2. **keyword:** key names start after a specific keyword (token).
+3. **unknown:** an unknown type of specification - see the [incomplete flag section](#incomplete) for more details.
+
+### index
+
+The _index_ type of `begin_search` indicates that input keys appear at a constant index.
+It is a map under the _spec_ key with a single key:
+
+1. **index:** the 0-based index from which the client should start extracting key names.
+
+### keyword
+
+The _keyword_ type of `begin_search` means a literal token precedes key name arguments.
+It is a map under the _spec_ with two keys:
+
+1. **keyword:** the keyword (token) that marks the beginning of key name arguments.
+2. **startfrom:** an index to the arguments array from which the client should begin searching. 
+  This can be a negative value, which means the search should start from the end of the arguments' array, in reverse order.
+  For example, _-2_'s meaning is to search reverse from the penultimate argument.
+
+More examples of the _keyword_ search type include:
+
+* [`SET`]({{< relref "/commands/set" >}}) has a `begin_search` specification of type _index_ with a value of _1_.
+* [`XREAD`]({{< relref "/commands/xread" >}}) has a `begin_search` specification of type _keyword_ with the values _"STREAMS"_ and _1_ as _keyword_ and _startfrom_, respectively.
+* [`MIGRATE`]({{< relref "/commands/migrate" >}}) has a _start_search_ specification of type _keyword_ with the values of _"KEYS"_ and _-2_.
+
+## find_keys
+
+The `find_keys` value of a key specification tells the client how to continue the search for key names.
+`find_keys` has three possible types:
+
+1. **range:** keys stop at a specific index or relative to the last argument.
+2. **keynum:** an additional argument specifies the number of input keys.
+3. **unknown:** an unknown type of specification - see the [incomplete flag section](#incomplete) for more details.
+
+### range
+
+The _range_ type of `find_keys` is a map under the _spec_ key with three keys:
+
+1. **lastkey:** the index, relative to `begin_search`, of the last key argument.
+  This can be a negative value, in which case it isn't relative.
+  For example, _-1_ indicates to keep extracting keys until the last argument, _-2_ until one before the last, and so on.
+2. **keystep:** the number of arguments that should be skipped, after finding a key, to find the next one.
+3. **limit:** if _lastkey_ is has the value of _-1_, we use the _limit_ to stop the search by a factor.
+  _0_ and _1_ mean no limit.
+  _2_ means half of the remaining arguments, 3 means a third, and so on.
+
+### keynum
+
+The _keynum_ type of `find_keys` is a map under the _spec_ key with three keys:
+
+* **keynumidx:** the index, relative to `begin_search`, of the argument containing the number of keys.
+* **firstkey:** the index, relative to `begin_search`, of the first key.
+  This is usually the next argument after _keynumidx_, and its value, in this case, is greater by one.
+* **keystep:** Tthe number of arguments that should be skipped, after finding a key, to find the next one.
+
+Examples:
+
+* The [`SET`]({{< relref "/commands/set" >}}) command has a _range_ of _0_, _1_ and _0_.
+* The [`MSET`]({{< relref "/commands/mset" >}}) command has a _range_ of _-1_, _2_ and _0_.
+* The [`XREAD`]({{< relref "/commands/xread" >}}) command has a _range_ of _-1_, _1_ and _2_.
+* The [`ZUNION`]({{< relref "/commands/zunion" >}}) command has a _start_search_ type _index_ with the value _1_, and `find_keys` of type _keynum_ with values of _0_, _1_ and _1_.
+
+**Note:**
+this isn't a perfect solution as the module writers can come up with anything.
+However, this mechanism should allow the extraction of key name arguments for the vast majority of commands.
+
+## notes
+
+Notes about non-obvious key specs considerations, if applicable.
+
+## flags
+
+A key specification can have additional flags that provide more details about the key.
+These flags are divided into three groups, as described below.
+
+### Access type flags
+
+The following flags declare the type of access the command uses to a key's value or its metadata.
+A key's metadata includes LRU/LFU counters, type, and cardinality.
+These flags do not relate to the reply sent back to the client.
+
+Every key specification has precisely one of the following flags:
+
+* **RW:** the read-write flag.
+  The command modifies the data stored in the value of the key or its metadata.
+  This flag marks every operation that isn't distinctly a delete, an overwrite, or read-only.
+* **RO:** the read-only flag.
+  The command only reads the value of the key (although it doesn't necessarily return it).
+* **OW:** the overwrite flag.
+  The command overwrites the data stored in the value of the key.
+* **RM:** the remove flag.
+  The command deletes the key.
+ 
+### Logical operation flags
+
+The following flags declare the type of operations performed on the data stored as the key's value and its TTL (if any), not the metadata.
+These flags describe the logical operation that the command executes on data, driven by the input arguments.
+The flags do not relate to modifying or returning metadata (such as a key's type, cardinality, or existence).
+
+Every key specification may include the following flag:
+
+* **access:** the access flag.
+  This flag indicates that the command returns, copies, or somehow uses the user's data that's stored in the key.
+
+In addition, the specification may include precisely one of the following:
+
+* **update:** the update flag.
+  The command updates the data stored in the key's value.
+  The new value may depend on the old value.
+  This flag marks every operation that isn't distinctly an insert or a delete.
+* **insert:** the insert flag.
+  The command only adds data to the value; existing data isn't modified or deleted.
+* **delete:** the delete flag.
+  The command explicitly deletes data from the value stored at the key.
+
+### Miscellaneous flags
+
+Key specifications may have the following flags:
+
+* **not_key:** this flag indicates that the specified argument isn't a key.
+  This argument is treated the same as a key when computing which slot a command should be assigned to for Redis cluster. 
+  For all other purposes this argument should not be considered a key.
+* **incomplete:** this flag is explained below.
+* **variable_flags:** this flag is explained below.
+
+### incomplete
+
+Some commands feature exotic approaches when it comes to specifying their keys, which makes extraction difficult.
+Consider, for example, what would happen with a call to [`MIGRATE`]({{< relref "/commands/migrate" >}}) that includes the literal string _"KEYS"_ as an argument to its _AUTH_ clause.
+Our key specifications would miss the mark, and extraction would begin at the wrong index.
+
+Thus, we recognize that key specifications are incomplete and may fail to extract all keys.
+However, we assure that even incomplete specifications never yield the wrong names of keys, providing that the command is syntactically correct.
+
+In the case of [`MIGRATE`]({{< relref "/commands/migrate" >}}), the search begins at the end (_startfrom_ has the value of _-1_).
+If and when we encounter a key named _"KEYS"_, we'll only extract the subset of the key name arguments after it.
+That's why [`MIGRATE`]({{< relref "/commands/migrate" >}}) has the _incomplete_ flag in its key specification.
+
+Another case of incompleteness is the [`SORT`]({{< relref "/commands/sort" >}}) command.
+Here, the `begin_search` and `find_keys` are of type _unknown_.
+The client should revert to calling the [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) command to extract key names from the arguments, short of implementing it natively.
+The difficulty arises, for example, because the string _"STORE"_ is both a keyword (token) and a valid literal argument for [`SORT`]({{< relref "/commands/sort" >}}).
+
+**Note:**
+the only commands with _incomplete_ key specifications are [`SORT`]({{< relref "/commands/sort" >}}) and [`MIGRATE`]({{< relref "/commands/migrate" >}}).
+We don't expect the addition of such commands in the future.
+
+### variable_flags
+
+In some commands, the flags for the same key name argument can depend on other arguments.
+For example, consider the [`SET`]({{< relref "/commands/set" >}}) command and its optional  _GET_ argument.
+Without the _GET_ argument, [`SET`]({{< relref "/commands/set" >}}) is write-only, but it becomes a read and write command with it.
+When this flag is present, it means that the key specification flags cover all possible options, but the effective flags depend on other arguments.
+
+## Examples
+
+### SET key specifications
+
+```
+  1) 1) "flags"
+     2) 1) RW
+        2) access
+        3) update
+     3) "begin_search"
+     4) 1) "type"
+        2) "index"
+        3) "spec"
+        4) 1) "index"
+           2) (integer) 1
+     5) "find_keys"
+     6) 1) "type"
+        2) "range"
+        3) "spec"
+        4) 1) "lastkey"
+           2) (integer) 0
+           3) "keystep"
+           4) (integer) 1
+           5) "limit"
+           6) (integer) 0
+```
+
+### ZUNION key specifications
+
+```
+  1) 1) "flags"
+     2) 1) RO
+        2) access
+     3) "begin_search"
+     4) 1) "type"
+        2) "index"
+        3) "spec"
+        4) 1) "index"
+           2) (integer) 1
+     5) "find_keys"
+     6) 1) "type"
+        2) "keynum"
+        3) "spec"
+        4) 1) "keynumidx"
+           2) (integer) 0
+           3) "firstkey"
+           4) (integer) 1
+           5) "keystep"
+           6) (integer) 1
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Reference for the Redis Modules API
+linkTitle: API reference
+title: Modules API reference
+weight: 1
+---
+
+<!-- This file is generated from module.c using
+     redis/redis:utils/generate-module-api-doc.rb -->
+
+## Sections
+
+* [Heap allocation raw functions](#section-heap-allocation-raw-functions)
+* [Commands API](#section-commands-api)
+* [Module information and time measurement](#section-module-information-and-time-measurement)
+* [Automatic memory management for modules](#section-automatic-memory-management-for-modules)
+* [String objects APIs](#section-string-objects-apis)
+* [Reply APIs](#section-reply-apis)
+* [Commands replication API](#section-commands-replication-api)
+* [DB and Key APIs – Generic API](#section-db-and-key-apis-generic-api)
+* [Key API for String type](#section-key-api-for-string-type)
+* [Key API for List type](#section-key-api-for-list-type)
+* [Key API for Sorted Set type](#section-key-api-for-sorted-set-type)
+* [Key API for Sorted Set iterator](#section-key-api-for-sorted-set-iterator)
+* [Key API for Hash type](#section-key-api-for-hash-type)
+* [Key API for Stream type](#section-key-api-for-stream-type)
+* [Calling Redis commands from modules](#section-calling-redis-commands-from-modules)
+* [Modules data types](#section-modules-data-types)
+* [RDB loading and saving functions](#section-rdb-loading-and-saving-functions)
+* [Key digest API (DEBUG DIGEST interface for modules types)](#section-key-digest-api-debug-digest-interface-for-modules-types)
+* [AOF API for modules data types](#section-aof-api-for-modules-data-types)
+* [IO context handling](#section-io-context-handling)
+* [Logging](#section-logging)
+* [Blocking clients from modules](#section-blocking-clients-from-modules)
+* [Thread Safe Contexts](#section-thread-safe-contexts)
+* [Module Keyspace Notifications API](#section-module-keyspace-notifications-api)
+* [Modules Cluster API](#section-modules-cluster-api)
+* [Modules Timers API](#section-modules-timers-api)
+* [Modules EventLoop API](#section-modules-eventloop-api)
+* [Modules ACL API](#section-modules-acl-api)
+* [Modules Dictionary API](#section-modules-dictionary-api)
+* [Modules Info fields](#section-modules-info-fields)
+* [Modules utility APIs](#section-modules-utility-apis)
+* [Modules API exporting / importing](#section-modules-api-exporting-importing)
+* [Module Command Filter API](#section-module-command-filter-api)
+* [Scanning keyspace and hashes](#section-scanning-keyspace-and-hashes)
+* [Module fork API](#section-module-fork-api)
+* [Server hooks implementation](#section-server-hooks-implementation)
+* [Module Configurations API](#section-module-configurations-api)
+* [RDB load/save API](#section-rdb-load-save-api)
+* [Key eviction API](#section-key-eviction-api)
+* [Miscellaneous APIs](#section-miscellaneous-apis)
+* [Defrag API](#section-defrag-api)
+* [Function index](#section-function-index)
+
+<span id="section-heap-allocation-raw-functions"></span>
+
+## Heap allocation raw functions
+
+Memory allocated with these functions are taken into account by Redis key
+eviction algorithms and are reported in Redis memory usage information.
+
+<span id="RedisModule_Alloc"></span>
+
+### `RedisModule_Alloc`
+
+    void *RedisModule_Alloc(size_t bytes);
+
+**Available since:** 4.0.0
+
+Use like `malloc()`. Memory allocated with this function is reported in
+Redis INFO memory, used for keys eviction according to maxmemory settings
+and in general is taken into account as memory allocated by Redis.
+You should avoid using `malloc()`.
+This function panics if unable to allocate enough memory.
+
+<span id="RedisModule_TryAlloc"></span>
+
+### `RedisModule_TryAlloc`
+
+    void *RedisModule_TryAlloc(size_t bytes);
+
+**Available since:** 7.0.0
+
+Similar to [`RedisModule_Alloc`](#RedisModule_Alloc), but returns NULL in case of allocation failure, instead
+of panicking.
+
+<span id="RedisModule_Calloc"></span>
+
+### `RedisModule_Calloc`
+
+    void *RedisModule_Calloc(size_t nmemb, size_t size);
+
+**Available since:** 4.0.0
+
+Use like `calloc()`. Memory allocated with this function is reported in
+Redis INFO memory, used for keys eviction according to maxmemory settings
+and in general is taken into account as memory allocated by Redis.
+You should avoid using `calloc()` directly.
+
+<span id="RedisModule_TryCalloc"></span>
+
+### `RedisModule_TryCalloc`
+
+    void *RedisModule_TryCalloc(size_t nmemb, size_t size);
+
+**Available since:** 7.4.0
+
+Similar to [`RedisModule_Calloc`](#RedisModule_Calloc), but returns NULL in case of allocation failure, instead
+of panicking.
+
+<span id="RedisModule_Realloc"></span>
+
+### `RedisModule_Realloc`
+
+    void* RedisModule_Realloc(void *ptr, size_t bytes);
+
+**Available since:** 4.0.0
+
+Use like `realloc()` for memory obtained with [`RedisModule_Alloc()`](#RedisModule_Alloc).
+
+<span id="RedisModule_TryRealloc"></span>
+
+### `RedisModule_TryRealloc`
+
+    void *RedisModule_TryRealloc(void *ptr, size_t bytes);
+
+**Available since:** 7.4.0
+
+Similar to [`RedisModule_Realloc`](#RedisModule_Realloc), but returns NULL in case of allocation failure,
+instead of panicking.
+
+<span id="RedisModule_Free"></span>
+
+### `RedisModule_Free`
+
+    void RedisModule_Free(void *ptr);
+
+**Available since:** 4.0.0
+
+Use like `free()` for memory obtained by [`RedisModule_Alloc()`](#RedisModule_Alloc) and
+[`RedisModule_Realloc()`](#RedisModule_Realloc). However you should never try to free with
+[`RedisModule_Free()`](#RedisModule_Free) memory allocated with `malloc()` inside your module.
+
+<span id="RedisModule_Strdup"></span>
+
+### `RedisModule_Strdup`
+
+    char *RedisModule_Strdup(const char *str);
+
+**Available since:** 4.0.0
+
+Like `strdup()` but returns memory allocated with [`RedisModule_Alloc()`](#RedisModule_Alloc).
+
+<span id="RedisModule_PoolAlloc"></span>
+
+### `RedisModule_PoolAlloc`
+
+    void *RedisModule_PoolAlloc(RedisModuleCtx *ctx, size_t bytes);
+
+**Available since:** 4.0.0
+
+Return heap allocated memory that will be freed automatically when the
+module callback function returns. Mostly suitable for small allocations
+that are short living and must be released when the callback returns
+anyway. The returned memory is aligned to the architecture word size
+if at least word size bytes are requested, otherwise it is just
+aligned to the next power of two, so for example a 3 bytes request is
+4 bytes aligned while a 2 bytes request is 2 bytes aligned.
+
+There is no realloc style function since when this is needed to use the
+pool allocator is not a good idea.
+
+The function returns NULL if `bytes` is 0.
+
+<span id="section-commands-api"></span>
+
+## Commands API
+
+These functions are used to implement custom Redis commands.
+
+For examples, see [https://redis.io/docs/latest/develop/reference/modules/](https://redis.io/docs/latest/develop/reference/modules/).
+
+<span id="RedisModule_IsKeysPositionRequest"></span>
+
+### `RedisModule_IsKeysPositionRequest`
+
+    int RedisModule_IsKeysPositionRequest(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Return non-zero if a module command, that was declared with the
+flag "getkeys-api", is called in a special way to get the keys positions
+and not to get executed. Otherwise zero is returned.
+
+<span id="RedisModule_KeyAtPosWithFlags"></span>
+
+### `RedisModule_KeyAtPosWithFlags`
+
+    void RedisModule_KeyAtPosWithFlags(RedisModuleCtx *ctx, int pos, int flags);
+
+**Available since:** 7.0.0
+
+When a module command is called in order to obtain the position of
+keys, since it was flagged as "getkeys-api" during the registration,
+the command implementation checks for this special call using the
+[`RedisModule_IsKeysPositionRequest()`](#RedisModule_IsKeysPositionRequest) API and uses this function in
+order to report keys.
+
+The supported flags are the ones used by [`RedisModule_SetCommandInfo`](#RedisModule_SetCommandInfo), see `REDISMODULE_CMD_KEY_`*.
+
+
+The following is an example of how it could be used:
+
+    if (RedisModule_IsKeysPositionRequest(ctx)) {
+        RedisModule_KeyAtPosWithFlags(ctx, 2, REDISMODULE_CMD_KEY_RO | REDISMODULE_CMD_KEY_ACCESS);
+        RedisModule_KeyAtPosWithFlags(ctx, 1, REDISMODULE_CMD_KEY_RW | REDISMODULE_CMD_KEY_UPDATE | REDISMODULE_CMD_KEY_ACCESS);
+    }
+
+ Note: in the example above the get keys API could have been handled by key-specs (preferred).
+ Implementing the getkeys-api is required only when is it not possible to declare key-specs that cover all keys.
+
+<span id="RedisModule_KeyAtPos"></span>
+
+### `RedisModule_KeyAtPos`
+
+    void RedisModule_KeyAtPos(RedisModuleCtx *ctx, int pos);
+
+**Available since:** 4.0.0
+
+This API existed before [`RedisModule_KeyAtPosWithFlags`](#RedisModule_KeyAtPosWithFlags) was added, now deprecated and
+can be used for compatibility with older versions, before key-specs and flags
+were introduced.
+
+<span id="RedisModule_IsChannelsPositionRequest"></span>
+
+### `RedisModule_IsChannelsPositionRequest`
+
+    int RedisModule_IsChannelsPositionRequest(RedisModuleCtx *ctx);
+
+**Available since:** 7.0.0
+
+Return non-zero if a module command, that was declared with the
+flag "getchannels-api", is called in a special way to get the channel positions
+and not to get executed. Otherwise zero is returned.
+
+<span id="RedisModule_ChannelAtPosWithFlags"></span>
+
+### `RedisModule_ChannelAtPosWithFlags`
+
+    void RedisModule_ChannelAtPosWithFlags(RedisModuleCtx *ctx,
+                                           int pos,
+                                           int flags);
+
+**Available since:** 7.0.0
+
+When a module command is called in order to obtain the position of
+channels, since it was flagged as "getchannels-api" during the
+registration, the command implementation checks for this special call
+using the [`RedisModule_IsChannelsPositionRequest()`](#RedisModule_IsChannelsPositionRequest) API and uses this
+function in order to report the channels.
+
+The supported flags are:
+* `REDISMODULE_CMD_CHANNEL_SUBSCRIBE`: This command will subscribe to the channel.
+* `REDISMODULE_CMD_CHANNEL_UNSUBSCRIBE`: This command will unsubscribe from this channel.
+* `REDISMODULE_CMD_CHANNEL_PUBLISH`: This command will publish to this channel.
+* `REDISMODULE_CMD_CHANNEL_PATTERN`: Instead of acting on a specific channel, will act on any 
+                                   channel specified by the pattern. This is the same access
+                                   used by the PSUBSCRIBE and PUNSUBSCRIBE commands available 
+                                   in Redis. Not intended to be used with PUBLISH permissions.
+
+The following is an example of how it could be used:
+
+    if (RedisModule_IsChannelsPositionRequest(ctx)) {
+        RedisModule_ChannelAtPosWithFlags(ctx, 1, REDISMODULE_CMD_CHANNEL_SUBSCRIBE | REDISMODULE_CMD_CHANNEL_PATTERN);
+        RedisModule_ChannelAtPosWithFlags(ctx, 1, REDISMODULE_CMD_CHANNEL_PUBLISH);
+    }
+
+Note: One usage of declaring channels is for evaluating ACL permissions. In this context,
+unsubscribing is always allowed, so commands will only be checked against subscribe and
+publish permissions. This is preferred over using [`RedisModule_ACLCheckChannelPermissions`](#RedisModule_ACLCheckChannelPermissions), since
+it allows the ACLs to be checked before the command is executed.
+
+<span id="RedisModule_CreateCommand"></span>
+
+### `RedisModule_CreateCommand`
+
+    int RedisModule_CreateCommand(RedisModuleCtx *ctx,
+                                  const char *name,
+                                  RedisModuleCmdFunc cmdfunc,
+                                  const char *strflags,
+                                  int firstkey,
+                                  int lastkey,
+                                  int keystep);
+
+**Available since:** 4.0.0
+
+Register a new command in the Redis server, that will be handled by
+calling the function pointer 'cmdfunc' using the RedisModule calling
+convention.
+
+The function returns `REDISMODULE_ERR` in these cases:
+- If creation of module command is called outside the `RedisModule_OnLoad`.
+- The specified command is already busy.
+- The command name contains some chars that are not allowed.
+- A set of invalid flags were passed.
+
+Otherwise `REDISMODULE_OK` is returned and the new command is registered.
+
+This function must be called during the initialization of the module
+inside the `RedisModule_OnLoad()` function. Calling this function outside
+of the initialization function is not defined.
+
+The command function type is the following:
+
+     int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
+
+And is supposed to always return `REDISMODULE_OK`.
+
+The set of flags 'strflags' specify the behavior of the command, and should
+be passed as a C string composed of space separated words, like for
+example "write deny-oom". The set of flags are:
+
+* **"write"**:     The command may modify the data set (it may also read
+                   from it).
+* **"readonly"**:  The command returns data from keys but never writes.
+* **"admin"**:     The command is an administrative command (may change
+                   replication or perform similar tasks).
+* **"deny-oom"**:  The command may use additional memory and should be
+                   denied during out of memory conditions.
+* **"deny-script"**:   Don't allow this command in Lua scripts.
+* **"allow-loading"**: Allow this command while the server is loading data.
+                       Only commands not interacting with the data set
+                       should be allowed to run in this mode. If not sure
+                       don't use this flag.
+* **"pubsub"**:    The command publishes things on Pub/Sub channels.
+* **"random"**:    The command may have different outputs even starting
+                   from the same input arguments and key values.
+                   Starting from Redis 7.0 this flag has been deprecated.
+                   Declaring a command as "random" can be done using
+                   command tips, see https://redis.io/docs/latest/develop/reference/command-tips/.
+* **"allow-stale"**: The command is allowed to run on slaves that don't
+                     serve stale data. Don't use if you don't know what
+                     this means.
+* **"no-monitor"**: Don't propagate the command on monitor. Use this if
+                    the command has sensitive data among the arguments.
+* **"no-slowlog"**: Don't log this command in the slowlog. Use this if
+                    the command has sensitive data among the arguments.
+* **"fast"**:      The command time complexity is not greater
+                   than O(log(N)) where N is the size of the collection or
+                   anything else representing the normal scalability
+                   issue with the command.
+* **"getkeys-api"**: The command implements the interface to return
+                     the arguments that are keys. Used when start/stop/step
+                     is not enough because of the command syntax.
+* **"no-cluster"**: The command should not register in Redis Cluster
+                    since is not designed to work with it because, for
+                    example, is unable to report the position of the
+                    keys, programmatically creates key names, or any
+                    other reason.
+* **"no-auth"**:    This command can be run by an un-authenticated client.
+                    Normally this is used by a command that is used
+                    to authenticate a client.
+* **"may-replicate"**: This command may generate replication traffic, even
+                       though it's not a write command.
+* **"no-mandatory-keys"**: All the keys this command may take are optional
+* **"blocking"**: The command has the potential to block the client.
+* **"allow-busy"**: Permit the command while the server is blocked either by
+                    a script or by a slow module command, see
+                    RedisModule_Yield.
+* **"getchannels-api"**: The command implements the interface to return
+                         the arguments that are channels.
+* **"internal"**: Internal command, one that should not be exposed to the user connections.
+                  For example, module commands that are called by the modules,
+                  commands that do not perform ACL validations (relying on earlier checks)
+
+The last three parameters specify which arguments of the new command are
+Redis keys. See [https://redis.io/commands/command](https://redis.io/commands/command) for more information.
+
+* `firstkey`: One-based index of the first argument that's a key.
+              Position 0 is always the command name itself.
+              0 for commands with no keys.
+* `lastkey`:  One-based index of the last argument that's a key.
+              Negative numbers refer to counting backwards from the last
+              argument (-1 means the last argument provided)
+              0 for commands with no keys.
+* `keystep`:  Step between first and last key indexes.
+              0 for commands with no keys.
+
+This information is used by ACL, Cluster and the `COMMAND` command.
+
+NOTE: The scheme described above serves a limited purpose and can
+only be used to find keys that exist at constant indices.
+For non-trivial key arguments, you may pass 0,0,0 and use
+[`RedisModule_SetCommandInfo`](#RedisModule_SetCommandInfo) to set key specs using a more advanced scheme and use
+[`RedisModule_SetCommandACLCategories`](#RedisModule_SetCommandACLCategories) to set Redis ACL categories of the commands.
+
+<span id="RedisModule_GetCommand"></span>
+
+### `RedisModule_GetCommand`
+
+    RedisModuleCommand *RedisModule_GetCommand(RedisModuleCtx *ctx,
+                                               const char *name);
+
+**Available since:** 7.0.0
+
+Get an opaque structure, representing a module command, by command name.
+This structure is used in some of the command-related APIs.
+
+NULL is returned in case of the following errors:
+
+* Command not found
+* The command is not a module command
+* The command doesn't belong to the calling module
+
+<span id="RedisModule_CreateSubcommand"></span>
+
+### `RedisModule_CreateSubcommand`
+
+    int RedisModule_CreateSubcommand(RedisModuleCommand *parent,
+                                     const char *name,
+                                     RedisModuleCmdFunc cmdfunc,
+                                     const char *strflags,
+                                     int firstkey,
+                                     int lastkey,
+                                     int keystep);
+
+**Available since:** 7.0.0
+
+Very similar to [`RedisModule_CreateCommand`](#RedisModule_CreateCommand) except that it is used to create
+a subcommand, associated with another, container, command.
+
+Example: If a module has a configuration command, MODULE.CONFIG, then
+GET and SET should be individual subcommands, while MODULE.CONFIG is
+a command, but should not be registered with a valid `funcptr`:
+
+     if (RedisModule_CreateCommand(ctx,"module.config",NULL,"",0,0,0) == REDISMODULE_ERR)
+         return REDISMODULE_ERR;
+
+     RedisModuleCommand *parent = RedisModule_GetCommand(ctx,,"module.config");
+
+     if (RedisModule_CreateSubcommand(parent,"set",cmd_config_set,"",0,0,0) == REDISMODULE_ERR)
+        return REDISMODULE_ERR;
+
+     if (RedisModule_CreateSubcommand(parent,"get",cmd_config_get,"",0,0,0) == REDISMODULE_ERR)
+        return REDISMODULE_ERR;
+
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` in case of the following errors:
+
+* Error while parsing `strflags`
+* Command is marked as `no-cluster` but cluster mode is enabled
+* `parent` is already a subcommand (we do not allow more than one level of command nesting)
+* `parent` is a command with an implementation (`RedisModuleCmdFunc`) (A parent command should be a pure container of subcommands)
+* `parent` already has a subcommand called `name`
+* Creating a subcommand is called outside of `RedisModule_OnLoad`.
+
+<span id="RedisModule_AddACLCategory"></span>
+
+### `RedisModule_AddACLCategory`
+
+    int RedisModule_AddACLCategory(RedisModuleCtx *ctx, const char *name);
+
+**Available since:** 7.4.0
+
+[`RedisModule_AddACLCategory`](#RedisModule_AddACLCategory) can be used to add new ACL command categories. Category names
+can only contain alphanumeric characters, underscores, or dashes. Categories can only be added
+during the `RedisModule_OnLoad` function. Once a category has been added, it can not be removed. 
+Any module can register a command to any added categories using [`RedisModule_SetCommandACLCategories`](#RedisModule_SetCommandACLCategories).
+
+Returns:
+- `REDISMODULE_OK` on successfully adding the new ACL category. 
+- `REDISMODULE_ERR` on failure.
+
+On error the errno is set to:
+- EINVAL if the name contains invalid characters.
+- EBUSY if the category name already exists.
+- ENOMEM if the number of categories reached the max limit of 64 categories.
+
+<span id="RedisModule_SetCommandACLCategories"></span>
+
+### `RedisModule_SetCommandACLCategories`
+
+    int RedisModule_SetCommandACLCategories(RedisModuleCommand *command,
+                                            const char *aclflags);
+
+**Available since:** 7.2.0
+
+[`RedisModule_SetCommandACLCategories`](#RedisModule_SetCommandACLCategories) can be used to set ACL categories to module
+commands and subcommands. The set of ACL categories should be passed as
+a space separated C string 'aclflags'.
+
+Example, the acl flags 'write slow' marks the command as part of the write and 
+slow ACL categories.
+
+On success `REDISMODULE_OK` is returned. On error `REDISMODULE_ERR` is returned.
+
+This function can only be called during the `RedisModule_OnLoad` function. If called
+outside of this function, an error is returned.
+
+<span id="RedisModule_SetCommandInfo"></span>
+
+### `RedisModule_SetCommandInfo`
+
+    int RedisModule_SetCommandInfo(RedisModuleCommand *command,
+                                   const RedisModuleCommandInfo *info);
+
+**Available since:** 7.0.0
+
+Set additional command information.
+
+Affects the output of `COMMAND`, `COMMAND INFO` and `COMMAND DOCS`, Cluster,
+ACL and is used to filter commands with the wrong number of arguments before
+the call reaches the module code.
+
+This function can be called after creating a command using [`RedisModule_CreateCommand`](#RedisModule_CreateCommand)
+and fetching the command pointer using [`RedisModule_GetCommand`](#RedisModule_GetCommand). The information can
+only be set once for each command and has the following structure:
+
+    typedef struct RedisModuleCommandInfo {
+        const RedisModuleCommandInfoVersion *version;
+        const char *summary;
+        const char *complexity;
+        const char *since;
+        RedisModuleCommandHistoryEntry *history;
+        const char *tips;
+        int arity;
+        RedisModuleCommandKeySpec *key_specs;
+        RedisModuleCommandArg *args;
+    } RedisModuleCommandInfo;
+
+All fields except `version` are optional. Explanation of the fields:
+
+- `version`: This field enables compatibility with different Redis versions.
+  Always set this field to `REDISMODULE_COMMAND_INFO_VERSION`.
+
+- `summary`: A short description of the command (optional).
+
+- `complexity`: Complexity description (optional).
+
+- `since`: The version where the command was introduced (optional).
+  Note: The version specified should be the module's, not Redis version.
+
+- `history`: An array of `RedisModuleCommandHistoryEntry` (optional), which is
+  a struct with the following fields:
+
+        const char *since;
+        const char *changes;
+
+    `since` is a version string and `changes` is a string describing the
+    changes. The array is terminated by a zeroed entry, i.e. an entry with
+    both strings set to NULL.
+
+- `tips`: A string of space-separated tips regarding this command, meant for
+  clients and proxies. See [https://redis.io/docs/latest/develop/reference/command-tips/](https://redis.io/docs/latest/develop/reference/command-tips/).
+
+- `arity`: Number of arguments, including the command name itself. A positive
+  number specifies an exact number of arguments and a negative number
+  specifies a minimum number of arguments, so use -N to say >= N. Redis
+  validates a call before passing it to a module, so this can replace an
+  arity check inside the module command implementation. A value of 0 (or an
+  omitted arity field) is equivalent to -2 if the command has sub commands
+  and -1 otherwise.
+
+- `key_specs`: An array of `RedisModuleCommandKeySpec`, terminated by an
+  element memset to zero. This is a scheme that tries to describe the
+  positions of key arguments better than the old [`RedisModule_CreateCommand`](#RedisModule_CreateCommand) arguments
+  `firstkey`, `lastkey`, `keystep` and is needed if those three are not
+  enough to describe the key positions. There are two steps to retrieve key
+  positions: *begin search* (BS) in which index should find the first key and
+  *find keys* (FK) which, relative to the output of BS, describes how can we
+  will which arguments are keys. Additionally, there are key specific flags.
+
+    Key-specs cause the triplet (firstkey, lastkey, keystep) given in
+    RedisModule_CreateCommand to be recomputed, but it is still useful to provide
+    these three parameters in RedisModule_CreateCommand, to better support old Redis
+    versions where RedisModule_SetCommandInfo is not available.
+
+    Note that key-specs don't fully replace the "getkeys-api" (see
+    RedisModule_CreateCommand, RedisModule_IsKeysPositionRequest and RedisModule_KeyAtPosWithFlags) so
+    it may be a good idea to supply both key-specs and implement the
+    getkeys-api.
+
+    A key-spec has the following structure:
+
+        typedef struct RedisModuleCommandKeySpec {
+            const char *notes;
+            uint64_t flags;
+            RedisModuleKeySpecBeginSearchType begin_search_type;
+            union {
+                struct {
+                    int pos;
+                } index;
+                struct {
+                    const char *keyword;
+                    int startfrom;
+                } keyword;
+            } bs;
+            RedisModuleKeySpecFindKeysType find_keys_type;
+            union {
+                struct {
+                    int lastkey;
+                    int keystep;
+                    int limit;
+                } range;
+                struct {
+                    int keynumidx;
+                    int firstkey;
+                    int keystep;
+                } keynum;
+            } fk;
+        } RedisModuleCommandKeySpec;
+
+    Explanation of the fields of RedisModuleCommandKeySpec:
+
+    * `notes`: Optional notes or clarifications about this key spec.
+
+    * `flags`: A bitwise or of key-spec flags described below.
+
+    * `begin_search_type`: This describes how the first key is discovered.
+      There are two ways to determine the first key:
+
+        * `REDISMODULE_KSPEC_BS_UNKNOWN`: There is no way to tell where the
+          key args start.
+        * `REDISMODULE_KSPEC_BS_INDEX`: Key args start at a constant index.
+        * `REDISMODULE_KSPEC_BS_KEYWORD`: Key args start just after a
+          specific keyword.
+
+    * `bs`: This is a union in which the `index` or `keyword` branch is used
+      depending on the value of the `begin_search_type` field.
+
+        * `bs.index.pos`: The index from which we start the search for keys.
+          (`REDISMODULE_KSPEC_BS_INDEX` only.)
+
+        * `bs.keyword.keyword`: The keyword (string) that indicates the
+          beginning of key arguments. (`REDISMODULE_KSPEC_BS_KEYWORD` only.)
+
+        * `bs.keyword.startfrom`: An index in argv from which to start
+          searching. Can be negative, which means start search from the end,
+          in reverse. Example: -2 means to start in reverse from the
+          penultimate argument. (`REDISMODULE_KSPEC_BS_KEYWORD` only.)
+
+    * `find_keys_type`: After the "begin search", this describes which
+      arguments are keys. The strategies are:
+
+        * `REDISMODULE_KSPEC_BS_UNKNOWN`: There is no way to tell where the
+          key args are located.
+        * `REDISMODULE_KSPEC_FK_RANGE`: Keys end at a specific index (or
+          relative to the last argument).
+        * `REDISMODULE_KSPEC_FK_KEYNUM`: There's an argument that contains
+          the number of key args somewhere before the keys themselves.
+
+      `find_keys_type` and `fk` can be omitted if this keyspec describes
+      exactly one key.
+
+    * `fk`: This is a union in which the `range` or `keynum` branch is used
+      depending on the value of the `find_keys_type` field.
+
+        * `fk.range` (for `REDISMODULE_KSPEC_FK_RANGE`): A struct with the
+          following fields:
+
+            * `lastkey`: Index of the last key relative to the result of the
+              begin search step. Can be negative, in which case it's not
+              relative. -1 indicates the last argument, -2 one before the
+              last and so on.
+
+            * `keystep`: How many arguments should we skip after finding a
+              key, in order to find the next one?
+
+            * `limit`: If `lastkey` is -1, we use `limit` to stop the search
+              by a factor. 0 and 1 mean no limit. 2 means 1/2 of the
+              remaining args, 3 means 1/3, and so on.
+
+        * `fk.keynum` (for `REDISMODULE_KSPEC_FK_KEYNUM`): A struct with the
+          following fields:
+
+            * `keynumidx`: Index of the argument containing the number of
+              keys to come, relative to the result of the begin search step.
+
+            * `firstkey`: Index of the fist key relative to the result of the
+              begin search step. (Usually it's just after `keynumidx`, in
+              which case it should be set to `keynumidx + 1`.)
+
+            * `keystep`: How many arguments should we skip after finding a
+              key, in order to find the next one?
+
+    Key-spec flags:
+
+    The first four refer to what the command actually does with the *value or
+    metadata of the key*, and not necessarily the user data or how it affects
+    it. Each key-spec may must have exactly one of these. Any operation
+    that's not distinctly deletion, overwrite or read-only would be marked as
+    RW.
+
+    * `REDISMODULE_CMD_KEY_RO`: Read-Only. Reads the value of the key, but
+      doesn't necessarily return it.
+
+    * `REDISMODULE_CMD_KEY_RW`: Read-Write. Modifies the data stored in the
+      value of the key or its metadata.
+
+    * `REDISMODULE_CMD_KEY_OW`: Overwrite. Overwrites the data stored in the
+      value of the key.
+
+    * `REDISMODULE_CMD_KEY_RM`: Deletes the key.
+
+    The next four refer to *user data inside the value of the key*, not the
+    metadata like LRU, type, cardinality. It refers to the logical operation
+    on the user's data (actual input strings or TTL), being
+    used/returned/copied/changed. It doesn't refer to modification or
+    returning of metadata (like type, count, presence of data). ACCESS can be
+    combined with one of the write operations INSERT, DELETE or UPDATE. Any
+    write that's not an INSERT or a DELETE would be UPDATE.
+
+    * `REDISMODULE_CMD_KEY_ACCESS`: Returns, copies or uses the user data
+      from the value of the key.
+
+    * `REDISMODULE_CMD_KEY_UPDATE`: Updates data to the value, new value may
+      depend on the old value.
+
+    * `REDISMODULE_CMD_KEY_INSERT`: Adds data to the value with no chance of
+      modification or deletion of existing data.
+
+    * `REDISMODULE_CMD_KEY_DELETE`: Explicitly deletes some content from the
+      value of the key.
+
+    Other flags:
+
+    * `REDISMODULE_CMD_KEY_NOT_KEY`: The key is not actually a key, but 
+      should be routed in cluster mode as if it was a key.
+
+    * `REDISMODULE_CMD_KEY_INCOMPLETE`: The keyspec might not point out all
+      the keys it should cover.
+
+    * `REDISMODULE_CMD_KEY_VARIABLE_FLAGS`: Some keys might have different
+      flags depending on arguments.
+
+- `args`: An array of `RedisModuleCommandArg`, terminated by an element memset
+  to zero. `RedisModuleCommandArg` is a structure with at the fields described
+  below.
+
+        typedef struct RedisModuleCommandArg {
+            const char *name;
+            RedisModuleCommandArgType type;
+            int key_spec_index;
+            const char *token;
+            const char *summary;
+            const char *since;
+            int flags;
+            struct RedisModuleCommandArg *subargs;
+        } RedisModuleCommandArg;
+
+    Explanation of the fields:
+
+    * `name`: Name of the argument.
+
+    * `type`: The type of the argument. See below for details. The types
+      `REDISMODULE_ARG_TYPE_ONEOF` and `REDISMODULE_ARG_TYPE_BLOCK` require
+      an argument to have sub-arguments, i.e. `subargs`.
+
+    * `key_spec_index`: If the `type` is `REDISMODULE_ARG_TYPE_KEY` you must
+      provide the index of the key-spec associated with this argument. See
+      `key_specs` above. If the argument is not a key, you may specify -1.
+
+    * `token`: The token preceding the argument (optional). Example: the
+      argument `seconds` in `SET` has a token `EX`. If the argument consists
+      of only a token (for example `NX` in `SET`) the type should be
+      `REDISMODULE_ARG_TYPE_PURE_TOKEN` and `value` should be NULL.
+
+    * `summary`: A short description of the argument (optional).
+
+    * `since`: The first version which included this argument (optional).
+
+    * `flags`: A bitwise or of the macros `REDISMODULE_CMD_ARG_*`. See below.
+
+    * `value`: The display-value of the argument. This string is what should
+      be displayed when creating the command syntax from the output of
+      `COMMAND`. If `token` is not NULL, it should also be displayed.
+
+    Explanation of `RedisModuleCommandArgType`:
+
+    * `REDISMODULE_ARG_TYPE_STRING`: String argument.
+    * `REDISMODULE_ARG_TYPE_INTEGER`: Integer argument.
+    * `REDISMODULE_ARG_TYPE_DOUBLE`: Double-precision float argument.
+    * `REDISMODULE_ARG_TYPE_KEY`: String argument representing a keyname.
+    * `REDISMODULE_ARG_TYPE_PATTERN`: String, but regex pattern.
+    * `REDISMODULE_ARG_TYPE_UNIX_TIME`: Integer, but Unix timestamp.
+    * `REDISMODULE_ARG_TYPE_PURE_TOKEN`: Argument doesn't have a placeholder.
+      It's just a token without a value. Example: the `KEEPTTL` option of the
+      `SET` command.
+    * `REDISMODULE_ARG_TYPE_ONEOF`: Used when the user can choose only one of
+      a few sub-arguments. Requires `subargs`. Example: the `NX` and `XX`
+      options of `SET`.
+    * `REDISMODULE_ARG_TYPE_BLOCK`: Used when one wants to group together
+      several sub-arguments, usually to apply something on all of them, like
+      making the entire group "optional". Requires `subargs`. Example: the
+      `LIMIT offset count` parameters in `ZRANGE`.
+
+    Explanation of the command argument flags:
+
+    * `REDISMODULE_CMD_ARG_OPTIONAL`: The argument is optional (like GET in
+      the SET command).
+    * `REDISMODULE_CMD_ARG_MULTIPLE`: The argument may repeat itself (like
+      key in DEL).
+    * `REDISMODULE_CMD_ARG_MULTIPLE_TOKEN`: The argument may repeat itself,
+      and so does its token (like `GET pattern` in SORT).
+
+On success `REDISMODULE_OK` is returned. On error `REDISMODULE_ERR` is returned
+and `errno` is set to EINVAL if invalid info was provided or EEXIST if info
+has already been set. If the info is invalid, a warning is logged explaining
+which part of the info is invalid and why.
+
+<span id="section-module-information-and-time-measurement"></span>
+
+## Module information and time measurement
+
+<span id="RedisModule_IsModuleNameBusy"></span>
+
+### `RedisModule_IsModuleNameBusy`
+
+    int RedisModule_IsModuleNameBusy(const char *name);
+
+**Available since:** 4.0.3
+
+Return non-zero if the module name is busy.
+Otherwise zero is returned.
+
+<span id="RedisModule_Milliseconds"></span>
+
+### `RedisModule_Milliseconds`
+
+    mstime_t RedisModule_Milliseconds(void);
+
+**Available since:** 4.0.0
+
+Return the current UNIX time in milliseconds.
+
+<span id="RedisModule_MonotonicMicroseconds"></span>
+
+### `RedisModule_MonotonicMicroseconds`
+
+    uint64_t RedisModule_MonotonicMicroseconds(void);
+
+**Available since:** 7.0.0
+
+Return counter of micro-seconds relative to an arbitrary point in time.
+
+<span id="RedisModule_Microseconds"></span>
+
+### `RedisModule_Microseconds`
+
+    ustime_t RedisModule_Microseconds(void);
+
+**Available since:** 7.2.0
+
+Return the current UNIX time in microseconds
+
+<span id="RedisModule_CachedMicroseconds"></span>
+
+### `RedisModule_CachedMicroseconds`
+
+    ustime_t RedisModule_CachedMicroseconds(void);
+
+**Available since:** 7.2.0
+
+Return the cached UNIX time in microseconds.
+It is updated in the server cron job and before executing a command.
+It is useful for complex call stacks, such as a command causing a
+key space notification, causing a module to execute a [`RedisModule_Call`](#RedisModule_Call),
+causing another notification, etc.
+It makes sense that all this callbacks would use the same clock.
+
+<span id="RedisModule_BlockedClientMeasureTimeStart"></span>
+
+### `RedisModule_BlockedClientMeasureTimeStart`
+
+    int RedisModule_BlockedClientMeasureTimeStart(RedisModuleBlockedClient *bc);
+
+**Available since:** 6.2.0
+
+Mark a point in time that will be used as the start time to calculate
+the elapsed execution time when [`RedisModule_BlockedClientMeasureTimeEnd()`](#RedisModule_BlockedClientMeasureTimeEnd) is called.
+Within the same command, you can call multiple times
+[`RedisModule_BlockedClientMeasureTimeStart()`](#RedisModule_BlockedClientMeasureTimeStart) and [`RedisModule_BlockedClientMeasureTimeEnd()`](#RedisModule_BlockedClientMeasureTimeEnd)
+to accumulate independent time intervals to the background duration.
+This method always return `REDISMODULE_OK`.
+
+This function is not thread safe, If used in module thread and blocked callback (possibly main thread)
+simultaneously, it's recommended to protect them with lock owned by caller instead of GIL.
+
+<span id="RedisModule_BlockedClientMeasureTimeEnd"></span>
+
+### `RedisModule_BlockedClientMeasureTimeEnd`
+
+    int RedisModule_BlockedClientMeasureTimeEnd(RedisModuleBlockedClient *bc);
+
+**Available since:** 6.2.0
+
+Mark a point in time that will be used as the end time
+to calculate the elapsed execution time.
+On success `REDISMODULE_OK` is returned.
+This method only returns `REDISMODULE_ERR` if no start time was
+previously defined ( meaning [`RedisModule_BlockedClientMeasureTimeStart`](#RedisModule_BlockedClientMeasureTimeStart) was not called ).
+
+This function is not thread safe, If used in module thread and blocked callback (possibly main thread)
+simultaneously, it's recommended to protect them with lock owned by caller instead of GIL.
+
+<span id="RedisModule_Yield"></span>
+
+### `RedisModule_Yield`
+
+    void RedisModule_Yield(RedisModuleCtx *ctx, int flags, const char *busy_reply);
+
+**Available since:** 7.0.0
+
+This API allows modules to let Redis process background tasks, and some
+commands during long blocking execution of a module command.
+The module can call this API periodically.
+The flags is a bit mask of these:
+
+- `REDISMODULE_YIELD_FLAG_NONE`: No special flags, can perform some background
+                                 operations, but not process client commands.
+- `REDISMODULE_YIELD_FLAG_CLIENTS`: Redis can also process client commands.
+
+The `busy_reply` argument is optional, and can be used to control the verbose
+error string after the `-BUSY` error code.
+
+When the `REDISMODULE_YIELD_FLAG_CLIENTS` is used, Redis will only start
+processing client commands after the time defined by the
+`busy-reply-threshold` config, in which case Redis will start rejecting most
+commands with `-BUSY` error, but allow the ones marked with the `allow-busy`
+flag to be executed.
+This API can also be used in thread safe context (while locked), and during
+loading (in the `rdb_load` callback, in which case it'll reject commands with
+the -LOADING error)
+
+<span id="RedisModule_SetModuleOptions"></span>
+
+### `RedisModule_SetModuleOptions`
+
+    void RedisModule_SetModuleOptions(RedisModuleCtx *ctx, int options);
+
+**Available since:** 6.0.0
+
+Set flags defining capabilities or behavior bit flags.
+
+`REDISMODULE_OPTIONS_HANDLE_IO_ERRORS`:
+Generally, modules don't need to bother with this, as the process will just
+terminate if a read error happens, however, setting this flag would allow
+repl-diskless-load to work if enabled.
+The module should use [`RedisModule_IsIOError`](#RedisModule_IsIOError) after reads, before using the
+data that was read, and in case of error, propagate it upwards, and also be
+able to release the partially populated value and all it's allocations.
+
+`REDISMODULE_OPTION_NO_IMPLICIT_SIGNAL_MODIFIED`:
+See [`RedisModule_SignalModifiedKey()`](#RedisModule_SignalModifiedKey).
+
+`REDISMODULE_OPTIONS_HANDLE_REPL_ASYNC_LOAD`:
+Setting this flag indicates module awareness of diskless async replication (repl-diskless-load=swapdb)
+and that redis could be serving reads during replication instead of blocking with LOADING status.
+
+`REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS`:
+Declare that the module wants to get nested key-space notifications.
+By default, Redis will not fire key-space notifications that happened inside
+a key-space notification callback. This flag allows to change this behavior
+and fire nested key-space notifications. Notice: if enabled, the module
+should protected itself from infinite recursion.
+
+<span id="RedisModule_SignalModifiedKey"></span>
+
+### `RedisModule_SignalModifiedKey`
+
+    int RedisModule_SignalModifiedKey(RedisModuleCtx *ctx,
+                                      RedisModuleString *keyname);
+
+**Available since:** 6.0.0
+
+Signals that the key is modified from user's perspective (i.e. invalidate WATCH
+and client side caching).
+
+This is done automatically when a key opened for writing is closed, unless
+the option `REDISMODULE_OPTION_NO_IMPLICIT_SIGNAL_MODIFIED` has been set using
+[`RedisModule_SetModuleOptions()`](#RedisModule_SetModuleOptions).
+
+<span id="section-automatic-memory-management-for-modules"></span>
+
+## Automatic memory management for modules
+
+<span id="RedisModule_AutoMemory"></span>
+
+### `RedisModule_AutoMemory`
+
+    void RedisModule_AutoMemory(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Enable automatic memory management.
+
+The function must be called as the first function of a command implementation
+that wants to use automatic memory.
+
+When enabled, automatic memory management tracks and automatically frees
+keys, call replies and Redis string objects once the command returns. In most
+cases this eliminates the need of calling the following functions:
+
+1. [`RedisModule_CloseKey()`](#RedisModule_CloseKey)
+2. [`RedisModule_FreeCallReply()`](#RedisModule_FreeCallReply)
+3. [`RedisModule_FreeString()`](#RedisModule_FreeString)
+
+These functions can still be used with automatic memory management enabled,
+to optimize loops that make numerous allocations for example.
+
+<span id="section-string-objects-apis"></span>
+
+## String objects APIs
+
+<span id="RedisModule_CreateString"></span>
+
+### `RedisModule_CreateString`
+
+    RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx,
+                                                const char *ptr,
+                                                size_t len);
+
+**Available since:** 4.0.0
+
+Create a new module string object. The returned string must be freed
+with [`RedisModule_FreeString()`](#RedisModule_FreeString), unless automatic memory is enabled.
+
+The string is created by copying the `len` bytes starting
+at `ptr`. No reference is retained to the passed buffer.
+
+The module context 'ctx' is optional and may be NULL if you want to create
+a string out of the context scope. However in that case, the automatic
+memory management will not be available, and the string memory must be
+managed manually.
+
+<span id="RedisModule_CreateStringPrintf"></span>
+
+### `RedisModule_CreateStringPrintf`
+
+    RedisModuleString *RedisModule_CreateStringPrintf(RedisModuleCtx *ctx,
+                                                      const char *fmt,
+                                                      ...);
+
+**Available since:** 4.0.0
+
+Create a new module string object from a printf format and arguments.
+The returned string must be freed with [`RedisModule_FreeString()`](#RedisModule_FreeString), unless
+automatic memory is enabled.
+
+The string is created using the sds formatter function `sdscatvprintf()`.
+
+The passed context 'ctx' may be NULL if necessary, see the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_CreateStringFromLongLong"></span>
+
+### `RedisModule_CreateStringFromLongLong`
+
+    RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx,
+                                                            long long ll);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_CreateString()`](#RedisModule_CreateString), but creates a string starting from a `long long`
+integer instead of taking a buffer and its length.
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+The passed context 'ctx' may be NULL if necessary, see the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_CreateStringFromULongLong"></span>
+
+### `RedisModule_CreateStringFromULongLong`
+
+    RedisModuleString *RedisModule_CreateStringFromULongLong(RedisModuleCtx *ctx,
+                                                             unsigned long long ull);
+
+**Available since:** 7.0.3
+
+Like [`RedisModule_CreateString()`](#RedisModule_CreateString), but creates a string starting from a `unsigned long long`
+integer instead of taking a buffer and its length.
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+The passed context 'ctx' may be NULL if necessary, see the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_CreateStringFromDouble"></span>
+
+### `RedisModule_CreateStringFromDouble`
+
+    RedisModuleString *RedisModule_CreateStringFromDouble(RedisModuleCtx *ctx,
+                                                          double d);
+
+**Available since:** 6.0.0
+
+Like [`RedisModule_CreateString()`](#RedisModule_CreateString), but creates a string starting from a double
+instead of taking a buffer and its length.
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+<span id="RedisModule_CreateStringFromLongDouble"></span>
+
+### `RedisModule_CreateStringFromLongDouble`
+
+    RedisModuleString *RedisModule_CreateStringFromLongDouble(RedisModuleCtx *ctx,
+                                                              long double ld,
+                                                              int humanfriendly);
+
+**Available since:** 6.0.0
+
+Like [`RedisModule_CreateString()`](#RedisModule_CreateString), but creates a string starting from a long
+double.
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+The passed context 'ctx' may be NULL if necessary, see the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_CreateStringFromString"></span>
+
+### `RedisModule_CreateStringFromString`
+
+    RedisModuleString *RedisModule_CreateStringFromString(RedisModuleCtx *ctx,
+                                                          const RedisModuleString *str);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_CreateString()`](#RedisModule_CreateString), but creates a string starting from another
+`RedisModuleString`.
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+The passed context 'ctx' may be NULL if necessary, see the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_CreateStringFromStreamID"></span>
+
+### `RedisModule_CreateStringFromStreamID`
+
+    RedisModuleString *RedisModule_CreateStringFromStreamID(RedisModuleCtx *ctx,
+                                                            const RedisModuleStreamID *id);
+
+**Available since:** 6.2.0
+
+Creates a string from a stream ID. The returned string must be released with
+[`RedisModule_FreeString()`](#RedisModule_FreeString), unless automatic memory is enabled.
+
+The passed context `ctx` may be NULL if necessary. See the
+[`RedisModule_CreateString()`](#RedisModule_CreateString) documentation for more info.
+
+<span id="RedisModule_FreeString"></span>
+
+### `RedisModule_FreeString`
+
+    void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str);
+
+**Available since:** 4.0.0
+
+Free a module string object obtained with one of the Redis modules API calls
+that return new string objects.
+
+It is possible to call this function even when automatic memory management
+is enabled. In that case the string will be released ASAP and removed
+from the pool of string to release at the end.
+
+If the string was created with a NULL context 'ctx', it is also possible to
+pass ctx as NULL when releasing the string (but passing a context will not
+create any issue). Strings created with a context should be freed also passing
+the context, so if you want to free a string out of context later, make sure
+to create it using a NULL context.
+
+This API is not thread safe, access to these retained strings (if they originated
+from a client command arguments) must be done with GIL locked.
+
+<span id="RedisModule_RetainString"></span>
+
+### `RedisModule_RetainString`
+
+    void RedisModule_RetainString(RedisModuleCtx *ctx, RedisModuleString *str);
+
+**Available since:** 4.0.0
+
+Every call to this function, will make the string 'str' requiring
+an additional call to [`RedisModule_FreeString()`](#RedisModule_FreeString) in order to really
+free the string. Note that the automatic freeing of the string obtained
+enabling modules automatic memory management counts for one
+[`RedisModule_FreeString()`](#RedisModule_FreeString) call (it is just executed automatically).
+
+Normally you want to call this function when, at the same time
+the following conditions are true:
+
+1. You have automatic memory management enabled.
+2. You want to create string objects.
+3. Those string objects you create need to live *after* the callback
+   function(for example a command implementation) creating them returns.
+
+Usually you want this in order to store the created string object
+into your own data structure, for example when implementing a new data
+type.
+
+Note that when memory management is turned off, you don't need
+any call to RetainString() since creating a string will always result
+into a string that lives after the callback function returns, if
+no FreeString() call is performed.
+
+It is possible to call this function with a NULL context.
+
+When strings are going to be retained for an extended duration, it is good
+practice to also call [`RedisModule_TrimStringAllocation()`](#RedisModule_TrimStringAllocation) in order to
+optimize memory usage.
+
+Threaded modules that reference retained strings from other threads *must*
+explicitly trim the allocation as soon as the string is retained. Not doing
+so may result with automatic trimming which is not thread safe.
+
+This API is not thread safe, access to these retained strings (if they originated
+from a client command arguments) must be done with GIL locked.
+
+<span id="RedisModule_HoldString"></span>
+
+### `RedisModule_HoldString`
+
+    RedisModuleString* RedisModule_HoldString(RedisModuleCtx *ctx,
+                                              RedisModuleString *str);
+
+**Available since:** 6.0.7
+
+
+This function can be used instead of [`RedisModule_RetainString()`](#RedisModule_RetainString).
+The main difference between the two is that this function will always
+succeed, whereas [`RedisModule_RetainString()`](#RedisModule_RetainString) may fail because of an
+assertion.
+
+The function returns a pointer to `RedisModuleString`, which is owned
+by the caller. It requires a call to [`RedisModule_FreeString()`](#RedisModule_FreeString) to free
+the string when automatic memory management is disabled for the context.
+When automatic memory management is enabled, you can either call
+[`RedisModule_FreeString()`](#RedisModule_FreeString) or let the automation free it.
+
+This function is more efficient than [`RedisModule_CreateStringFromString()`](#RedisModule_CreateStringFromString)
+because whenever possible, it avoids copying the underlying
+`RedisModuleString`. The disadvantage of using this function is that it
+might not be possible to use [`RedisModule_StringAppendBuffer()`](#RedisModule_StringAppendBuffer) on the
+returned `RedisModuleString`.
+
+It is possible to call this function with a NULL context.
+
+When strings are going to be held for an extended duration, it is good
+practice to also call [`RedisModule_TrimStringAllocation()`](#RedisModule_TrimStringAllocation) in order to
+optimize memory usage.
+
+Threaded modules that reference held strings from other threads *must*
+explicitly trim the allocation as soon as the string is held. Not doing
+so may result with automatic trimming which is not thread safe.
+
+This API is not thread safe, access to these retained strings (if they originated
+from a client command arguments) must be done with GIL locked.
+
+<span id="RedisModule_StringPtrLen"></span>
+
+### `RedisModule_StringPtrLen`
+
+    const char *RedisModule_StringPtrLen(const RedisModuleString *str,
+                                         size_t *len);
+
+**Available since:** 4.0.0
+
+Given a string module object, this function returns the string pointer
+and length of the string. The returned pointer and length should only
+be used for read only accesses and never modified.
+
+<span id="RedisModule_StringToLongLong"></span>
+
+### `RedisModule_StringToLongLong`
+
+    int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll);
+
+**Available since:** 4.0.0
+
+Convert the string into a `long long` integer, storing it at `*ll`.
+Returns `REDISMODULE_OK` on success. If the string can't be parsed
+as a valid, strict `long long` (no spaces before/after), `REDISMODULE_ERR`
+is returned.
+
+<span id="RedisModule_StringToULongLong"></span>
+
+### `RedisModule_StringToULongLong`
+
+    int RedisModule_StringToULongLong(const RedisModuleString *str,
+                                      unsigned long long *ull);
+
+**Available since:** 7.0.3
+
+Convert the string into a `unsigned long long` integer, storing it at `*ull`.
+Returns `REDISMODULE_OK` on success. If the string can't be parsed
+as a valid, strict `unsigned long long` (no spaces before/after), `REDISMODULE_ERR`
+is returned.
+
+<span id="RedisModule_StringToDouble"></span>
+
+### `RedisModule_StringToDouble`
+
+    int RedisModule_StringToDouble(const RedisModuleString *str, double *d);
+
+**Available since:** 4.0.0
+
+Convert the string into a double, storing it at `*d`.
+Returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if the string is
+not a valid string representation of a double value.
+
+<span id="RedisModule_StringToLongDouble"></span>
+
+### `RedisModule_StringToLongDouble`
+
+    int RedisModule_StringToLongDouble(const RedisModuleString *str,
+                                       long double *ld);
+
+**Available since:** 6.0.0
+
+Convert the string into a long double, storing it at `*ld`.
+Returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if the string is
+not a valid string representation of a double value.
+
+<span id="RedisModule_StringToStreamID"></span>
+
+### `RedisModule_StringToStreamID`
+
+    int RedisModule_StringToStreamID(const RedisModuleString *str,
+                                     RedisModuleStreamID *id);
+
+**Available since:** 6.2.0
+
+Convert the string into a stream ID, storing it at `*id`.
+Returns `REDISMODULE_OK` on success and returns `REDISMODULE_ERR` if the string
+is not a valid string representation of a stream ID. The special IDs "+" and
+"-" are allowed.
+
+<span id="RedisModule_StringCompare"></span>
+
+### `RedisModule_StringCompare`
+
+    int RedisModule_StringCompare(const RedisModuleString *a,
+                                  const RedisModuleString *b);
+
+**Available since:** 4.0.0
+
+Compare two string objects, returning -1, 0 or 1 respectively if
+a < b, a == b, a > b. Strings are compared byte by byte as two
+binary blobs without any encoding care / collation attempt.
+
+<span id="RedisModule_StringAppendBuffer"></span>
+
+### `RedisModule_StringAppendBuffer`
+
+    int RedisModule_StringAppendBuffer(RedisModuleCtx *ctx,
+                                       RedisModuleString *str,
+                                       const char *buf,
+                                       size_t len);
+
+**Available since:** 4.0.0
+
+Append the specified buffer to the string 'str'. The string must be a
+string created by the user that is referenced only a single time, otherwise
+`REDISMODULE_ERR` is returned and the operation is not performed.
+
+<span id="RedisModule_TrimStringAllocation"></span>
+
+### `RedisModule_TrimStringAllocation`
+
+    void RedisModule_TrimStringAllocation(RedisModuleString *str);
+
+**Available since:** 7.0.0
+
+Trim possible excess memory allocated for a `RedisModuleString`.
+
+Sometimes a `RedisModuleString` may have more memory allocated for
+it than required, typically for argv arguments that were constructed
+from network buffers. This function optimizes such strings by reallocating
+their memory, which is useful for strings that are not short lived but
+retained for an extended duration.
+
+This operation is *not thread safe* and should only be called when
+no concurrent access to the string is guaranteed. Using it for an argv
+string in a module command before the string is potentially available
+to other threads is generally safe.
+
+Currently, Redis may also automatically trim retained strings when a
+module command returns. However, doing this explicitly should still be
+a preferred option:
+
+1. Future versions of Redis may abandon auto-trimming.
+2. Auto-trimming as currently implemented is *not thread safe*.
+   A background thread manipulating a recently retained string may end up
+   in a race condition with the auto-trim, which could result with
+   data corruption.
+
+<span id="section-reply-apis"></span>
+
+## Reply APIs
+
+These functions are used for sending replies to the client.
+
+Most functions always return `REDISMODULE_OK` so you can use it with
+'return' in order to return from the command implementation with:
+
+    if (... some condition ...)
+        return RedisModule_ReplyWithLongLong(ctx,mycount);
+
+### Reply with collection functions
+
+After starting a collection reply, the module must make calls to other
+`ReplyWith*` style functions in order to emit the elements of the collection.
+Collection types include: Array, Map, Set and Attribute.
+
+When producing collections with a number of elements that is not known
+beforehand, the function can be called with a special flag
+`REDISMODULE_POSTPONED_LEN` (`REDISMODULE_POSTPONED_ARRAY_LEN` in the past),
+and the actual number of elements can be later set with `RedisModule_ReplySet`*Length()
+call (which will set the latest "open" count if there are multiple ones).
+
+<span id="RedisModule_WrongArity"></span>
+
+### `RedisModule_WrongArity`
+
+    int RedisModule_WrongArity(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Send an error about the number of arguments given to the command,
+citing the command name in the error message. Returns `REDISMODULE_OK`.
+
+Example:
+
+    if (argc != 3) return RedisModule_WrongArity(ctx);
+
+<span id="RedisModule_ReplyWithLongLong"></span>
+
+### `RedisModule_ReplyWithLongLong`
+
+    int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long ll);
+
+**Available since:** 4.0.0
+
+Send an integer reply to the client, with the specified `long long` value.
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithError"></span>
+
+### `RedisModule_ReplyWithError`
+
+    int RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err);
+
+**Available since:** 4.0.0
+
+Reply with the error 'err'.
+
+Note that 'err' must contain all the error, including
+the initial error code. The function only provides the initial "-", so
+the usage is, for example:
+
+    RedisModule_ReplyWithError(ctx,"ERR Wrong Type");
+
+and not just:
+
+    RedisModule_ReplyWithError(ctx,"Wrong Type");
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithErrorFormat"></span>
+
+### `RedisModule_ReplyWithErrorFormat`
+
+    int RedisModule_ReplyWithErrorFormat(RedisModuleCtx *ctx,
+                                         const char *fmt,
+                                         ...);
+
+**Available since:** 7.2.0
+
+Reply with the error create from a printf format and arguments.
+
+Note that 'fmt' must contain all the error, including
+the initial error code. The function only provides the initial "-", so
+the usage is, for example:
+
+    RedisModule_ReplyWithErrorFormat(ctx,"ERR Wrong Type: %s",type);
+
+and not just:
+
+    RedisModule_ReplyWithErrorFormat(ctx,"Wrong Type: %s",type);
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithSimpleString"></span>
+
+### `RedisModule_ReplyWithSimpleString`
+
+    int RedisModule_ReplyWithSimpleString(RedisModuleCtx *ctx, const char *msg);
+
+**Available since:** 4.0.0
+
+Reply with a simple string (`+... \r\n` in RESP protocol). This replies
+are suitable only when sending a small non-binary string with small
+overhead, like "OK" or similar replies.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithArray"></span>
+
+### `RedisModule_ReplyWithArray`
+
+    int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len);
+
+**Available since:** 4.0.0
+
+Reply with an array type of 'len' elements.
+
+After starting an array reply, the module must make `len` calls to other
+`ReplyWith*` style functions in order to emit the elements of the array.
+See Reply APIs section for more details.
+
+Use [`RedisModule_ReplySetArrayLength()`](#RedisModule_ReplySetArrayLength) to set deferred length.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithMap"></span>
+
+### `RedisModule_ReplyWithMap`
+
+    int RedisModule_ReplyWithMap(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Reply with a RESP3 Map type of 'len' pairs.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+After starting a map reply, the module must make `len*2` calls to other
+`ReplyWith*` style functions in order to emit the elements of the map.
+See Reply APIs section for more details.
+
+If the connected client is using RESP2, the reply will be converted to a flat
+array.
+
+Use [`RedisModule_ReplySetMapLength()`](#RedisModule_ReplySetMapLength) to set deferred length.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithSet"></span>
+
+### `RedisModule_ReplyWithSet`
+
+    int RedisModule_ReplyWithSet(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Reply with a RESP3 Set type of 'len' elements.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+After starting a set reply, the module must make `len` calls to other
+`ReplyWith*` style functions in order to emit the elements of the set.
+See Reply APIs section for more details.
+
+If the connected client is using RESP2, the reply will be converted to an
+array type.
+
+Use [`RedisModule_ReplySetSetLength()`](#RedisModule_ReplySetSetLength) to set deferred length.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithAttribute"></span>
+
+### `RedisModule_ReplyWithAttribute`
+
+    int RedisModule_ReplyWithAttribute(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Add attributes (metadata) to the reply. Should be done before adding the
+actual reply. see [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md)#attribute-type
+
+After starting an attribute's reply, the module must make `len*2` calls to other
+`ReplyWith*` style functions in order to emit the elements of the attribute map.
+See Reply APIs section for more details.
+
+Use [`RedisModule_ReplySetAttributeLength()`](#RedisModule_ReplySetAttributeLength) to set deferred length.
+
+Not supported by RESP2 and will return `REDISMODULE_ERR`, otherwise
+the function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithNullArray"></span>
+
+### `RedisModule_ReplyWithNullArray`
+
+    int RedisModule_ReplyWithNullArray(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Reply to the client with a null array, simply null in RESP3,
+null array in RESP2.
+
+Note: In RESP3 there's no difference between Null reply and
+NullArray reply, so to prevent ambiguity it's better to avoid
+using this API and use [`RedisModule_ReplyWithNull`](#RedisModule_ReplyWithNull) instead.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithEmptyArray"></span>
+
+### `RedisModule_ReplyWithEmptyArray`
+
+    int RedisModule_ReplyWithEmptyArray(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Reply to the client with an empty array.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplySetArrayLength"></span>
+
+### `RedisModule_ReplySetArrayLength`
+
+    void RedisModule_ReplySetArrayLength(RedisModuleCtx *ctx, long len);
+
+**Available since:** 4.0.0
+
+When [`RedisModule_ReplyWithArray()`](#RedisModule_ReplyWithArray) is used with the argument
+`REDISMODULE_POSTPONED_LEN`, because we don't know beforehand the number
+of items we are going to output as elements of the array, this function
+will take care to set the array length.
+
+Since it is possible to have multiple array replies pending with unknown
+length, this function guarantees to always set the latest array length
+that was created in a postponed way.
+
+For example in order to output an array like [1,[10,20,30]] we
+could write:
+
+     RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_LEN);
+     RedisModule_ReplyWithLongLong(ctx,1);
+     RedisModule_ReplyWithArray(ctx,REDISMODULE_POSTPONED_LEN);
+     RedisModule_ReplyWithLongLong(ctx,10);
+     RedisModule_ReplyWithLongLong(ctx,20);
+     RedisModule_ReplyWithLongLong(ctx,30);
+     RedisModule_ReplySetArrayLength(ctx,3); // Set len of 10,20,30 array.
+     RedisModule_ReplySetArrayLength(ctx,2); // Set len of top array
+
+Note that in the above example there is no reason to postpone the array
+length, since we produce a fixed number of elements, but in the practice
+the code may use an iterator or other ways of creating the output so
+that is not easy to calculate in advance the number of elements.
+
+<span id="RedisModule_ReplySetMapLength"></span>
+
+### `RedisModule_ReplySetMapLength`
+
+    void RedisModule_ReplySetMapLength(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Very similar to [`RedisModule_ReplySetArrayLength`](#RedisModule_ReplySetArrayLength) except `len` should
+exactly half of the number of `ReplyWith*` functions called in the
+context of the map.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+<span id="RedisModule_ReplySetSetLength"></span>
+
+### `RedisModule_ReplySetSetLength`
+
+    void RedisModule_ReplySetSetLength(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Very similar to [`RedisModule_ReplySetArrayLength`](#RedisModule_ReplySetArrayLength)
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+<span id="RedisModule_ReplySetAttributeLength"></span>
+
+### `RedisModule_ReplySetAttributeLength`
+
+    void RedisModule_ReplySetAttributeLength(RedisModuleCtx *ctx, long len);
+
+**Available since:** 7.0.0
+
+Very similar to [`RedisModule_ReplySetMapLength`](#RedisModule_ReplySetMapLength)
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+Must not be called if [`RedisModule_ReplyWithAttribute`](#RedisModule_ReplyWithAttribute) returned an error.
+
+<span id="RedisModule_ReplyWithStringBuffer"></span>
+
+### `RedisModule_ReplyWithStringBuffer`
+
+    int RedisModule_ReplyWithStringBuffer(RedisModuleCtx *ctx,
+                                          const char *buf,
+                                          size_t len);
+
+**Available since:** 4.0.0
+
+Reply with a bulk string, taking in input a C buffer pointer and length.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithCString"></span>
+
+### `RedisModule_ReplyWithCString`
+
+    int RedisModule_ReplyWithCString(RedisModuleCtx *ctx, const char *buf);
+
+**Available since:** 5.0.6
+
+Reply with a bulk string, taking in input a C buffer pointer that is
+assumed to be null-terminated.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithString"></span>
+
+### `RedisModule_ReplyWithString`
+
+    int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str);
+
+**Available since:** 4.0.0
+
+Reply with a bulk string, taking in input a `RedisModuleString` object.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithEmptyString"></span>
+
+### `RedisModule_ReplyWithEmptyString`
+
+    int RedisModule_ReplyWithEmptyString(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Reply with an empty string.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithVerbatimStringType"></span>
+
+### `RedisModule_ReplyWithVerbatimStringType`
+
+    int RedisModule_ReplyWithVerbatimStringType(RedisModuleCtx *ctx,
+                                                const char *buf,
+                                                size_t len,
+                                                const char *ext);
+
+**Available since:** 7.0.0
+
+Reply with a binary safe string, which should not be escaped or filtered
+taking in input a C buffer pointer, length and a 3 character type/extension.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithVerbatimString"></span>
+
+### `RedisModule_ReplyWithVerbatimString`
+
+    int RedisModule_ReplyWithVerbatimString(RedisModuleCtx *ctx,
+                                            const char *buf,
+                                            size_t len);
+
+**Available since:** 6.0.0
+
+Reply with a binary safe string, which should not be escaped or filtered
+taking in input a C buffer pointer and length.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithNull"></span>
+
+### `RedisModule_ReplyWithNull`
+
+    int RedisModule_ReplyWithNull(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Reply to the client with a NULL.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithBool"></span>
+
+### `RedisModule_ReplyWithBool`
+
+    int RedisModule_ReplyWithBool(RedisModuleCtx *ctx, int b);
+
+**Available since:** 7.0.0
+
+Reply with a RESP3 Boolean type.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+In RESP3, this is boolean type
+In RESP2, it's a string response of "1" and "0" for true and false respectively.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithCallReply"></span>
+
+### `RedisModule_ReplyWithCallReply`
+
+    int RedisModule_ReplyWithCallReply(RedisModuleCtx *ctx,
+                                       RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Reply exactly what a Redis command returned us with [`RedisModule_Call()`](#RedisModule_Call).
+This function is useful when we use [`RedisModule_Call()`](#RedisModule_Call) in order to
+execute some command, as we want to reply to the client exactly the
+same reply we obtained by the command.
+
+Return:
+- `REDISMODULE_OK` on success.
+- `REDISMODULE_ERR` if the given reply is in RESP3 format but the client expects RESP2.
+  In case of an error, it's the module writer responsibility to translate the reply
+  to RESP2 (or handle it differently by returning an error). Notice that for
+  module writer convenience, it is possible to pass `0` as a parameter to the fmt
+  argument of [`RedisModule_Call`](#RedisModule_Call) so that the `RedisModuleCallReply` will return in the same
+  protocol (RESP2 or RESP3) as set in the current client's context.
+
+<span id="RedisModule_ReplyWithDouble"></span>
+
+### `RedisModule_ReplyWithDouble`
+
+    int RedisModule_ReplyWithDouble(RedisModuleCtx *ctx, double d);
+
+**Available since:** 4.0.0
+
+Reply with a RESP3 Double type.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+Send a string reply obtained converting the double 'd' into a bulk string.
+This function is basically equivalent to converting a double into
+a string into a C buffer, and then calling the function
+[`RedisModule_ReplyWithStringBuffer()`](#RedisModule_ReplyWithStringBuffer) with the buffer and length.
+
+In RESP3 the string is tagged as a double, while in RESP2 it's just a plain string 
+that the user will have to parse.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithBigNumber"></span>
+
+### `RedisModule_ReplyWithBigNumber`
+
+    int RedisModule_ReplyWithBigNumber(RedisModuleCtx *ctx,
+                                       const char *bignum,
+                                       size_t len);
+
+**Available since:** 7.0.0
+
+Reply with a RESP3 BigNumber type.
+Visit [https://github.com/antirez/RESP3/blob/master/spec.md](https://github.com/antirez/RESP3/blob/master/spec.md) for more info about RESP3.
+
+In RESP3, this is a string of length `len` that is tagged as a BigNumber, 
+however, it's up to the caller to ensure that it's a valid BigNumber.
+In RESP2, this is just a plain bulk string response.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="RedisModule_ReplyWithLongDouble"></span>
+
+### `RedisModule_ReplyWithLongDouble`
+
+    int RedisModule_ReplyWithLongDouble(RedisModuleCtx *ctx, long double ld);
+
+**Available since:** 6.0.0
+
+Send a string reply obtained converting the long double 'ld' into a bulk
+string. This function is basically equivalent to converting a long double
+into a string into a C buffer, and then calling the function
+[`RedisModule_ReplyWithStringBuffer()`](#RedisModule_ReplyWithStringBuffer) with the buffer and length.
+The double string uses human readable formatting (see
+`addReplyHumanLongDouble` in networking.c).
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="section-commands-replication-api"></span>
+
+## Commands replication API
+
+<span id="RedisModule_Replicate"></span>
+
+### `RedisModule_Replicate`
+
+    int RedisModule_Replicate(RedisModuleCtx *ctx,
+                              const char *cmdname,
+                              const char *fmt,
+                              ...);
+
+**Available since:** 4.0.0
+
+Replicate the specified command and arguments to slaves and AOF, as effect
+of execution of the calling command implementation.
+
+The replicated commands are always wrapped into the MULTI/EXEC that
+contains all the commands replicated in a given module command
+execution, in the order they were executed.
+
+Modules should try to use one interface or the other.
+
+This command follows exactly the same interface of [`RedisModule_Call()`](#RedisModule_Call),
+so a set of format specifiers must be passed, followed by arguments
+matching the provided format specifiers.
+
+Please refer to [`RedisModule_Call()`](#RedisModule_Call) for more information.
+
+Using the special "A" and "R" modifiers, the caller can exclude either
+the AOF or the replicas from the propagation of the specified command.
+Otherwise, by default, the command will be propagated in both channels.
+
+#### Note about calling this function from a thread safe context:
+
+Normally when you call this function from the callback implementing a
+module command, or any other callback provided by the Redis Module API,
+Redis will accumulate all the calls to this function in the context of
+the callback, and will propagate all the commands wrapped in a MULTI/EXEC
+transaction. However when calling this function from a threaded safe context
+that can live an undefined amount of time, and can be locked/unlocked in
+at will, it is important to note that this API is not thread-safe and
+must be executed while holding the GIL.
+
+#### Return value
+
+The command returns `REDISMODULE_ERR` if the format specifiers are invalid
+or the command name does not belong to a known command.
+
+<span id="RedisModule_ReplicateVerbatim"></span>
+
+### `RedisModule_ReplicateVerbatim`
+
+    int RedisModule_ReplicateVerbatim(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+This function will replicate the command exactly as it was invoked
+by the client. Note that the replicated commands are always wrapped
+into the MULTI/EXEC that contains all the commands replicated in a
+given module command execution, in the order they were executed.
+
+Basically this form of replication is useful when you want to propagate
+the command to the slaves and AOF file exactly as it was called, since
+the command can just be re-executed to deterministically re-create the
+new state starting from the old one.
+
+It is important to note that this API is not thread-safe and
+must be executed while holding the GIL.
+
+The function always returns `REDISMODULE_OK`.
+
+<span id="section-db-and-key-apis-generic-api"></span>
+
+## DB and Key APIs – Generic API
+
+<span id="RedisModule_GetClientId"></span>
+
+### `RedisModule_GetClientId`
+
+    unsigned long long RedisModule_GetClientId(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Return the ID of the current client calling the currently active module
+command. The returned ID has a few guarantees:
+
+1. The ID is different for each different client, so if the same client
+   executes a module command multiple times, it can be recognized as
+   having the same ID, otherwise the ID will be different.
+2. The ID increases monotonically. Clients connecting to the server later
+   are guaranteed to get IDs greater than any past ID previously seen.
+
+Valid IDs are from 1 to 2^64 - 1. If 0 is returned it means there is no way
+to fetch the ID in the context the function was currently called.
+
+After obtaining the ID, it is possible to check if the command execution
+is actually happening in the context of AOF loading, using this macro:
+
+     if (RedisModule_IsAOFClient(RedisModule_GetClientId(ctx)) {
+         // Handle it differently.
+     }
+
+<span id="RedisModule_GetClientUserNameById"></span>
+
+### `RedisModule_GetClientUserNameById`
+
+    RedisModuleString *RedisModule_GetClientUserNameById(RedisModuleCtx *ctx,
+                                                         uint64_t id);
+
+**Available since:** 6.2.1
+
+Return the ACL user name used by the client with the specified client ID.
+Client ID can be obtained with [`RedisModule_GetClientId()`](#RedisModule_GetClientId) API. If the client does not
+exist, NULL is returned and errno is set to ENOENT. If the client isn't
+using an ACL user, NULL is returned and errno is set to ENOTSUP
+
+<span id="RedisModule_GetClientInfoById"></span>
+
+### `RedisModule_GetClientInfoById`
+
+    int RedisModule_GetClientInfoById(void *ci, uint64_t id);
+
+**Available since:** 6.0.0
+
+Return information about the client with the specified ID (that was
+previously obtained via the [`RedisModule_GetClientId()`](#RedisModule_GetClientId) API). If the
+client exists, `REDISMODULE_OK` is returned, otherwise `REDISMODULE_ERR`
+is returned.
+
+When the client exist and the `ci` pointer is not NULL, but points to
+a structure of type `RedisModuleClientInfoV`1, previously initialized with
+the correct `REDISMODULE_CLIENTINFO_INITIALIZER_V1`, the structure is populated
+with the following fields:
+
+     uint64_t flags;         // REDISMODULE_CLIENTINFO_FLAG_*
+     uint64_t id;            // Client ID
+     char addr[46];          // IPv4 or IPv6 address.
+     uint16_t port;          // TCP port.
+     uint16_t db;            // Selected DB.
+
+Note: the client ID is useless in the context of this call, since we
+      already know, however the same structure could be used in other
+      contexts where we don't know the client ID, yet the same structure
+      is returned.
+
+With flags having the following meaning:
+
+    REDISMODULE_CLIENTINFO_FLAG_SSL          Client using SSL connection.
+    REDISMODULE_CLIENTINFO_FLAG_PUBSUB       Client in Pub/Sub mode.
+    REDISMODULE_CLIENTINFO_FLAG_BLOCKED      Client blocked in command.
+    REDISMODULE_CLIENTINFO_FLAG_TRACKING     Client with keys tracking on.
+    REDISMODULE_CLIENTINFO_FLAG_UNIXSOCKET   Client using unix domain socket.
+    REDISMODULE_CLIENTINFO_FLAG_MULTI        Client in MULTI state.
+
+However passing NULL is a way to just check if the client exists in case
+we are not interested in any additional information.
+
+This is the correct usage when we want the client info structure
+returned:
+
+     RedisModuleClientInfo ci = REDISMODULE_CLIENTINFO_INITIALIZER;
+     int retval = RedisModule_GetClientInfoById(&ci,client_id);
+     if (retval == REDISMODULE_OK) {
+         printf("Address: %s\n", ci.addr);
+     }
+
+<span id="RedisModule_GetClientNameById"></span>
+
+### `RedisModule_GetClientNameById`
+
+    RedisModuleString *RedisModule_GetClientNameById(RedisModuleCtx *ctx,
+                                                     uint64_t id);
+
+**Available since:** 7.0.3
+
+Returns the name of the client connection with the given ID.
+
+If the client ID does not exist or if the client has no name associated with
+it, NULL is returned.
+
+<span id="RedisModule_SetClientNameById"></span>
+
+### `RedisModule_SetClientNameById`
+
+    int RedisModule_SetClientNameById(uint64_t id, RedisModuleString *name);
+
+**Available since:** 7.0.3
+
+Sets the name of the client with the given ID. This is equivalent to the client calling
+`CLIENT SETNAME name`.
+
+Returns `REDISMODULE_OK` on success. On failure, `REDISMODULE_ERR` is returned
+and errno is set as follows:
+
+- ENOENT if the client does not exist
+- EINVAL if the name contains invalid characters
+
+<span id="RedisModule_PublishMessage"></span>
+
+### `RedisModule_PublishMessage`
+
+    int RedisModule_PublishMessage(RedisModuleCtx *ctx,
+                                   RedisModuleString *channel,
+                                   RedisModuleString *message);
+
+**Available since:** 6.0.0
+
+Publish a message to subscribers (see PUBLISH command).
+
+<span id="RedisModule_PublishMessageShard"></span>
+
+### `RedisModule_PublishMessageShard`
+
+    int RedisModule_PublishMessageShard(RedisModuleCtx *ctx,
+                                        RedisModuleString *channel,
+                                        RedisModuleString *message);
+
+**Available since:** 7.0.0
+
+Publish a message to shard-subscribers (see SPUBLISH command).
+
+<span id="RedisModule_GetSelectedDb"></span>
+
+### `RedisModule_GetSelectedDb`
+
+    int RedisModule_GetSelectedDb(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Return the currently selected DB.
+
+<span id="RedisModule_GetContextFlags"></span>
+
+### `RedisModule_GetContextFlags`
+
+    int RedisModule_GetContextFlags(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.3
+
+Return the current context's flags. The flags provide information on the
+current request context (whether the client is a Lua script or in a MULTI),
+and about the Redis instance in general, i.e replication and persistence.
+
+It is possible to call this function even with a NULL context, however
+in this case the following flags will not be reported:
+
+ * LUA, MULTI, REPLICATED, DIRTY (see below for more info).
+
+Available flags and their meaning:
+
+ * `REDISMODULE_CTX_FLAGS_LUA`: The command is running in a Lua script
+
+ * `REDISMODULE_CTX_FLAGS_MULTI`: The command is running inside a transaction
+
+ * `REDISMODULE_CTX_FLAGS_REPLICATED`: The command was sent over the replication
+   link by the MASTER
+
+ * `REDISMODULE_CTX_FLAGS_MASTER`: The Redis instance is a master
+
+ * `REDISMODULE_CTX_FLAGS_SLAVE`: The Redis instance is a slave
+
+ * `REDISMODULE_CTX_FLAGS_READONLY`: The Redis instance is read-only
+
+ * `REDISMODULE_CTX_FLAGS_CLUSTER`: The Redis instance is in cluster mode
+
+ * `REDISMODULE_CTX_FLAGS_AOF`: The Redis instance has AOF enabled
+
+ * `REDISMODULE_CTX_FLAGS_RDB`: The instance has RDB enabled
+
+ * `REDISMODULE_CTX_FLAGS_MAXMEMORY`:  The instance has Maxmemory set
+
+ * `REDISMODULE_CTX_FLAGS_EVICT`:  Maxmemory is set and has an eviction
+   policy that may delete keys
+
+ * `REDISMODULE_CTX_FLAGS_OOM`: Redis is out of memory according to the
+   maxmemory setting.
+
+ * `REDISMODULE_CTX_FLAGS_OOM_WARNING`: Less than 25% of memory remains before
+                                      reaching the maxmemory level.
+
+ * `REDISMODULE_CTX_FLAGS_LOADING`: Server is loading RDB/AOF
+
+ * `REDISMODULE_CTX_FLAGS_REPLICA_IS_STALE`: No active link with the master.
+
+ * `REDISMODULE_CTX_FLAGS_REPLICA_IS_CONNECTING`: The replica is trying to
+                                                connect with the master.
+
+ * `REDISMODULE_CTX_FLAGS_REPLICA_IS_TRANSFERRING`: Master -> Replica RDB
+                                                  transfer is in progress.
+
+ * `REDISMODULE_CTX_FLAGS_REPLICA_IS_ONLINE`: The replica has an active link
+                                            with its master. This is the
+                                            contrary of STALE state.
+
+ * `REDISMODULE_CTX_FLAGS_ACTIVE_CHILD`: There is currently some background
+                                       process active (RDB, AUX or module).
+
+ * `REDISMODULE_CTX_FLAGS_MULTI_DIRTY`: The next EXEC will fail due to dirty
+                                      CAS (touched keys).
+
+ * `REDISMODULE_CTX_FLAGS_IS_CHILD`: Redis is currently running inside
+                                   background child process.
+
+ * `REDISMODULE_CTX_FLAGS_RESP3`: Indicate the that client attached to this
+                                context is using RESP3.
+
+ * `REDISMODULE_CTX_FLAGS_SERVER_STARTUP`: The Redis instance is starting
+
+ * `REDISMODULE_CTX_FLAGS_DEBUG_ENABLED`: Debug commands are enabled for this
+                                        context.
+
+<span id="RedisModule_AvoidReplicaTraffic"></span>
+
+### `RedisModule_AvoidReplicaTraffic`
+
+    int RedisModule_AvoidReplicaTraffic(void);
+
+**Available since:** 6.0.0
+
+Returns true if a client sent the CLIENT PAUSE command to the server or
+if Redis Cluster does a manual failover, pausing the clients.
+This is needed when we have a master with replicas, and want to write,
+without adding further data to the replication channel, that the replicas
+replication offset, match the one of the master. When this happens, it is
+safe to failover the master without data loss.
+
+However modules may generate traffic by calling [`RedisModule_Call()`](#RedisModule_Call) with
+the "!" flag, or by calling [`RedisModule_Replicate()`](#RedisModule_Replicate), in a context outside
+commands execution, for instance in timeout callbacks, threads safe
+contexts, and so forth. When modules will generate too much traffic, it
+will be hard for the master and replicas offset to match, because there
+is more data to send in the replication channel.
+
+So modules may want to try to avoid very heavy background work that has
+the effect of creating data to the replication channel, when this function
+returns true. This is mostly useful for modules that have background
+garbage collection tasks, or that do writes and replicate such writes
+periodically in timer callbacks or other periodic callbacks.
+
+<span id="RedisModule_SelectDb"></span>
+
+### `RedisModule_SelectDb`
+
+    int RedisModule_SelectDb(RedisModuleCtx *ctx, int newid);
+
+**Available since:** 4.0.0
+
+Change the currently selected DB. Returns an error if the id
+is out of range.
+
+Note that the client will retain the currently selected DB even after
+the Redis command implemented by the module calling this function
+returns.
+
+If the module command wishes to change something in a different DB and
+returns back to the original one, it should call [`RedisModule_GetSelectedDb()`](#RedisModule_GetSelectedDb)
+before in order to restore the old DB number before returning.
+
+<span id="RedisModule_KeyExists"></span>
+
+### `RedisModule_KeyExists`
+
+    int RedisModule_KeyExists(RedisModuleCtx *ctx, robj *keyname);
+
+**Available since:** 7.0.0
+
+Check if a key exists, without affecting its last access time.
+
+This is equivalent to calling [`RedisModule_OpenKey`](#RedisModule_OpenKey) with the mode `REDISMODULE_READ` |
+`REDISMODULE_OPEN_KEY_NOTOUCH`, then checking if NULL was returned and, if not,
+calling [`RedisModule_CloseKey`](#RedisModule_CloseKey) on the opened key.
+
+<span id="RedisModule_OpenKey"></span>
+
+### `RedisModule_OpenKey`
+
+    RedisModuleKey *RedisModule_OpenKey(RedisModuleCtx *ctx,
+                                        robj *keyname,
+                                        int mode);
+
+**Available since:** 4.0.0
+
+Return a handle representing a Redis key, so that it is possible
+to call other APIs with the key handle as argument to perform
+operations on the key.
+
+The return value is the handle representing the key, that must be
+closed with [`RedisModule_CloseKey()`](#RedisModule_CloseKey).
+
+If the key does not exist and `REDISMODULE_WRITE` mode is requested, the handle
+is still returned, since it is possible to perform operations on
+a yet not existing key (that will be created, for example, after
+a list push operation). If the mode is just `REDISMODULE_READ` instead, and the
+key does not exist, NULL is returned. However it is still safe to
+call [`RedisModule_CloseKey()`](#RedisModule_CloseKey) and [`RedisModule_KeyType()`](#RedisModule_KeyType) on a NULL
+value.
+
+Extra flags that can be pass to the API under the mode argument:
+* `REDISMODULE_OPEN_KEY_NOTOUCH` - Avoid touching the LRU/LFU of the key when opened.
+* `REDISMODULE_OPEN_KEY_NONOTIFY` - Don't trigger keyspace event on key misses.
+* `REDISMODULE_OPEN_KEY_NOSTATS` - Don't update keyspace hits/misses counters.
+* `REDISMODULE_OPEN_KEY_NOEXPIRE` - Avoid deleting lazy expired keys.
+* `REDISMODULE_OPEN_KEY_NOEFFECTS` - Avoid any effects from fetching the key.
+* `REDISMODULE_OPEN_KEY_ACCESS_EXPIRED` - Access expired keys that have not yet been deleted
+
+<span id="RedisModule_GetOpenKeyModesAll"></span>
+
+### `RedisModule_GetOpenKeyModesAll`
+
+    int RedisModule_GetOpenKeyModesAll(void);
+
+**Available since:** 7.2.0
+
+
+Returns the full OpenKey modes mask, using the return value
+the module can check if a certain set of OpenKey modes are supported
+by the redis server version in use.
+Example:
+
+       int supportedMode = RedisModule_GetOpenKeyModesAll();
+       if (supportedMode & REDISMODULE_OPEN_KEY_NOTOUCH) {
+             // REDISMODULE_OPEN_KEY_NOTOUCH is supported
+       } else{
+             // REDISMODULE_OPEN_KEY_NOTOUCH is not supported
+       }
+
+<span id="RedisModule_CloseKey"></span>
+
+### `RedisModule_CloseKey`
+
+    void RedisModule_CloseKey(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Close a key handle.
+
+<span id="RedisModule_KeyType"></span>
+
+### `RedisModule_KeyType`
+
+    int RedisModule_KeyType(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Return the type of the key. If the key pointer is NULL then
+`REDISMODULE_KEYTYPE_EMPTY` is returned.
+
+<span id="RedisModule_ValueLength"></span>
+
+### `RedisModule_ValueLength`
+
+    size_t RedisModule_ValueLength(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Return the length of the value associated with the key.
+For strings this is the length of the string. For all the other types
+is the number of elements (just counting keys for hashes).
+
+If the key pointer is NULL or the key is empty, zero is returned.
+
+<span id="RedisModule_DeleteKey"></span>
+
+### `RedisModule_DeleteKey`
+
+    int RedisModule_DeleteKey(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+If the key is open for writing, remove it, and setup the key to
+accept new writes as an empty key (that will be created on demand).
+On success `REDISMODULE_OK` is returned. If the key is not open for
+writing `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_UnlinkKey"></span>
+
+### `RedisModule_UnlinkKey`
+
+    int RedisModule_UnlinkKey(RedisModuleKey *key);
+
+**Available since:** 4.0.7
+
+If the key is open for writing, unlink it (that is delete it in a
+non-blocking way, not reclaiming memory immediately) and setup the key to
+accept new writes as an empty key (that will be created on demand).
+On success `REDISMODULE_OK` is returned. If the key is not open for
+writing `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_GetExpire"></span>
+
+### `RedisModule_GetExpire`
+
+    mstime_t RedisModule_GetExpire(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Return the key expire value, as milliseconds of remaining TTL.
+If no TTL is associated with the key or if the key is empty,
+`REDISMODULE_NO_EXPIRE` is returned.
+
+<span id="RedisModule_SetExpire"></span>
+
+### `RedisModule_SetExpire`
+
+    int RedisModule_SetExpire(RedisModuleKey *key, mstime_t expire);
+
+**Available since:** 4.0.0
+
+Set a new expire for the key. If the special expire
+`REDISMODULE_NO_EXPIRE` is set, the expire is cancelled if there was
+one (the same as the PERSIST command).
+
+Note that the expire must be provided as a positive integer representing
+the number of milliseconds of TTL the key should have.
+
+The function returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if
+the key was not open for writing or is an empty key.
+
+<span id="RedisModule_GetAbsExpire"></span>
+
+### `RedisModule_GetAbsExpire`
+
+    mstime_t RedisModule_GetAbsExpire(RedisModuleKey *key);
+
+**Available since:** 6.2.2
+
+Return the key expire value, as absolute Unix timestamp.
+If no TTL is associated with the key or if the key is empty,
+`REDISMODULE_NO_EXPIRE` is returned.
+
+<span id="RedisModule_SetAbsExpire"></span>
+
+### `RedisModule_SetAbsExpire`
+
+    int RedisModule_SetAbsExpire(RedisModuleKey *key, mstime_t expire);
+
+**Available since:** 6.2.2
+
+Set a new expire for the key. If the special expire
+`REDISMODULE_NO_EXPIRE` is set, the expire is cancelled if there was
+one (the same as the PERSIST command).
+
+Note that the expire must be provided as a positive integer representing
+the absolute Unix timestamp the key should have.
+
+The function returns `REDISMODULE_OK` on success or `REDISMODULE_ERR` if
+the key was not open for writing or is an empty key.
+
+<span id="RedisModule_ResetDataset"></span>
+
+### `RedisModule_ResetDataset`
+
+    void RedisModule_ResetDataset(int restart_aof, int async);
+
+**Available since:** 6.0.0
+
+Performs similar operation to FLUSHALL, and optionally start a new AOF file (if enabled)
+If `restart_aof` is true, you must make sure the command that triggered this call is not
+propagated to the AOF file.
+When async is set to true, db contents will be freed by a background thread.
+
+<span id="RedisModule_DbSize"></span>
+
+### `RedisModule_DbSize`
+
+    unsigned long long RedisModule_DbSize(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Returns the number of keys in the current db.
+
+<span id="RedisModule_RandomKey"></span>
+
+### `RedisModule_RandomKey`
+
+    RedisModuleString *RedisModule_RandomKey(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Returns a name of a random key, or NULL if current db is empty.
+
+<span id="RedisModule_GetKeyNameFromOptCtx"></span>
+
+### `RedisModule_GetKeyNameFromOptCtx`
+
+    const RedisModuleString *RedisModule_GetKeyNameFromOptCtx(RedisModuleKeyOptCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the name of the key currently being processed.
+
+<span id="RedisModule_GetToKeyNameFromOptCtx"></span>
+
+### `RedisModule_GetToKeyNameFromOptCtx`
+
+    const RedisModuleString *RedisModule_GetToKeyNameFromOptCtx(RedisModuleKeyOptCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the name of the target key currently being processed.
+
+<span id="RedisModule_GetDbIdFromOptCtx"></span>
+
+### `RedisModule_GetDbIdFromOptCtx`
+
+    int RedisModule_GetDbIdFromOptCtx(RedisModuleKeyOptCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the dbid currently being processed.
+
+<span id="RedisModule_GetToDbIdFromOptCtx"></span>
+
+### `RedisModule_GetToDbIdFromOptCtx`
+
+    int RedisModule_GetToDbIdFromOptCtx(RedisModuleKeyOptCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the target dbid currently being processed.
+
+<span id="section-key-api-for-string-type"></span>
+
+## Key API for String type
+
+See also [`RedisModule_ValueLength()`](#RedisModule_ValueLength), which returns the length of a string.
+
+<span id="RedisModule_StringSet"></span>
+
+### `RedisModule_StringSet`
+
+    int RedisModule_StringSet(RedisModuleKey *key, RedisModuleString *str);
+
+**Available since:** 4.0.0
+
+If the key is open for writing, set the specified string 'str' as the
+value of the key, deleting the old value if any.
+On success `REDISMODULE_OK` is returned. If the key is not open for
+writing or there is an active iterator, `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_StringDMA"></span>
+
+### `RedisModule_StringDMA`
+
+    char *RedisModule_StringDMA(RedisModuleKey *key, size_t *len, int mode);
+
+**Available since:** 4.0.0
+
+Prepare the key associated string value for DMA access, and returns
+a pointer and size (by reference), that the user can use to read or
+modify the string in-place accessing it directly via pointer.
+
+The 'mode' is composed by bitwise OR-ing the following flags:
+
+    REDISMODULE_READ -- Read access
+    REDISMODULE_WRITE -- Write access
+
+If the DMA is not requested for writing, the pointer returned should
+only be accessed in a read-only fashion.
+
+On error (wrong type) NULL is returned.
+
+DMA access rules:
+
+1. No other key writing function should be called since the moment
+the pointer is obtained, for all the time we want to use DMA access
+to read or modify the string.
+
+2. Each time [`RedisModule_StringTruncate()`](#RedisModule_StringTruncate) is called, to continue with the DMA
+access, [`RedisModule_StringDMA()`](#RedisModule_StringDMA) should be called again to re-obtain
+a new pointer and length.
+
+3. If the returned pointer is not NULL, but the length is zero, no
+byte can be touched (the string is empty, or the key itself is empty)
+so a [`RedisModule_StringTruncate()`](#RedisModule_StringTruncate) call should be used if there is to enlarge
+the string, and later call StringDMA() again to get the pointer.
+
+<span id="RedisModule_StringTruncate"></span>
+
+### `RedisModule_StringTruncate`
+
+    int RedisModule_StringTruncate(RedisModuleKey *key, size_t newlen);
+
+**Available since:** 4.0.0
+
+If the key is open for writing and is of string type, resize it, padding
+with zero bytes if the new length is greater than the old one.
+
+After this call, [`RedisModule_StringDMA()`](#RedisModule_StringDMA) must be called again to continue
+DMA access with the new pointer.
+
+The function returns `REDISMODULE_OK` on success, and `REDISMODULE_ERR` on
+error, that is, the key is not open for writing, is not a string
+or resizing for more than 512 MB is requested.
+
+If the key is empty, a string key is created with the new string value
+unless the new length value requested is zero.
+
+<span id="section-key-api-for-list-type"></span>
+
+## Key API for List type
+
+Many of the list functions access elements by index. Since a list is in
+essence a doubly-linked list, accessing elements by index is generally an
+O(N) operation. However, if elements are accessed sequentially or with
+indices close together, the functions are optimized to seek the index from
+the previous index, rather than seeking from the ends of the list.
+
+This enables iteration to be done efficiently using a simple for loop:
+
+    long n = RedisModule_ValueLength(key);
+    for (long i = 0; i < n; i++) {
+        RedisModuleString *elem = RedisModule_ListGet(key, i);
+        // Do stuff...
+    }
+
+Note that after modifying a list using [`RedisModule_ListPop`](#RedisModule_ListPop), [`RedisModule_ListSet`](#RedisModule_ListSet) or
+[`RedisModule_ListInsert`](#RedisModule_ListInsert), the internal iterator is invalidated so the next operation
+will require a linear seek.
+
+Modifying a list in any another way, for example using [`RedisModule_Call()`](#RedisModule_Call), while a key
+is open will confuse the internal iterator and may cause trouble if the key
+is used after such modifications. The key must be reopened in this case.
+
+See also [`RedisModule_ValueLength()`](#RedisModule_ValueLength), which returns the length of a list.
+
+<span id="RedisModule_ListPush"></span>
+
+### `RedisModule_ListPush`
+
+    int RedisModule_ListPush(RedisModuleKey *key,
+                             int where,
+                             RedisModuleString *ele);
+
+**Available since:** 4.0.0
+
+Push an element into a list, on head or tail depending on 'where' argument
+(`REDISMODULE_LIST_HEAD` or `REDISMODULE_LIST_TAIL`). If the key refers to an
+empty key opened for writing, the key is created. On success, `REDISMODULE_OK`
+is returned. On failure, `REDISMODULE_ERR` is returned and `errno` is set as
+follows:
+
+- EINVAL if key or ele is NULL.
+- ENOTSUP if the key is of another type than list.
+- EBADF if the key is not opened for writing.
+
+Note: Before Redis 7.0, `errno` was not set by this function.
+
+<span id="RedisModule_ListPop"></span>
+
+### `RedisModule_ListPop`
+
+    RedisModuleString *RedisModule_ListPop(RedisModuleKey *key, int where);
+
+**Available since:** 4.0.0
+
+Pop an element from the list, and returns it as a module string object
+that the user should be free with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by enabling
+automatic memory. The `where` argument specifies if the element should be
+popped from the beginning or the end of the list (`REDISMODULE_LIST_HEAD` or
+`REDISMODULE_LIST_TAIL`). On failure, the command returns NULL and sets
+`errno` as follows:
+
+- EINVAL if key is NULL.
+- ENOTSUP if the key is empty or of another type than list.
+- EBADF if the key is not opened for writing.
+
+Note: Before Redis 7.0, `errno` was not set by this function.
+
+<span id="RedisModule_ListGet"></span>
+
+### `RedisModule_ListGet`
+
+    RedisModuleString *RedisModule_ListGet(RedisModuleKey *key, long index);
+
+**Available since:** 7.0.0
+
+Returns the element at index `index` in the list stored at `key`, like the
+LINDEX command. The element should be free'd using [`RedisModule_FreeString()`](#RedisModule_FreeString) or using
+automatic memory management.
+
+The index is zero-based, so 0 means the first element, 1 the second element
+and so on. Negative indices can be used to designate elements starting at the
+tail of the list. Here, -1 means the last element, -2 means the penultimate
+and so forth.
+
+When no value is found at the given key and index, NULL is returned and
+`errno` is set as follows:
+
+- EINVAL if key is NULL.
+- ENOTSUP if the key is not a list.
+- EBADF if the key is not opened for reading.
+- EDOM if the index is not a valid index in the list.
+
+<span id="RedisModule_ListSet"></span>
+
+### `RedisModule_ListSet`
+
+    int RedisModule_ListSet(RedisModuleKey *key,
+                            long index,
+                            RedisModuleString *value);
+
+**Available since:** 7.0.0
+
+Replaces the element at index `index` in the list stored at `key`.
+
+The index is zero-based, so 0 means the first element, 1 the second element
+and so on. Negative indices can be used to designate elements starting at the
+tail of the list. Here, -1 means the last element, -2 means the penultimate
+and so forth.
+
+On success, `REDISMODULE_OK` is returned. On failure, `REDISMODULE_ERR` is
+returned and `errno` is set as follows:
+
+- EINVAL if key or value is NULL.
+- ENOTSUP if the key is not a list.
+- EBADF if the key is not opened for writing.
+- EDOM if the index is not a valid index in the list.
+
+<span id="RedisModule_ListInsert"></span>
+
+### `RedisModule_ListInsert`
+
+    int RedisModule_ListInsert(RedisModuleKey *key,
+                               long index,
+                               RedisModuleString *value);
+
+**Available since:** 7.0.0
+
+Inserts an element at the given index.
+
+The index is zero-based, so 0 means the first element, 1 the second element
+and so on. Negative indices can be used to designate elements starting at the
+tail of the list. Here, -1 means the last element, -2 means the penultimate
+and so forth. The index is the element's index after inserting it.
+
+On success, `REDISMODULE_OK` is returned. On failure, `REDISMODULE_ERR` is
+returned and `errno` is set as follows:
+
+- EINVAL if key or value is NULL.
+- ENOTSUP if the key of another type than list.
+- EBADF if the key is not opened for writing.
+- EDOM if the index is not a valid index in the list.
+
+<span id="RedisModule_ListDelete"></span>
+
+### `RedisModule_ListDelete`
+
+    int RedisModule_ListDelete(RedisModuleKey *key, long index);
+
+**Available since:** 7.0.0
+
+Removes an element at the given index. The index is 0-based. A negative index
+can also be used, counting from the end of the list.
+
+On success, `REDISMODULE_OK` is returned. On failure, `REDISMODULE_ERR` is
+returned and `errno` is set as follows:
+
+- EINVAL if key or value is NULL.
+- ENOTSUP if the key is not a list.
+- EBADF if the key is not opened for writing.
+- EDOM if the index is not a valid index in the list.
+
+<span id="section-key-api-for-sorted-set-type"></span>
+
+## Key API for Sorted Set type
+
+See also [`RedisModule_ValueLength()`](#RedisModule_ValueLength), which returns the length of a sorted set.
+
+<span id="RedisModule_ZsetAdd"></span>
+
+### `RedisModule_ZsetAdd`
+
+    int RedisModule_ZsetAdd(RedisModuleKey *key,
+                            double score,
+                            RedisModuleString *ele,
+                            int *flagsptr);
+
+**Available since:** 4.0.0
+
+Add a new element into a sorted set, with the specified 'score'.
+If the element already exists, the score is updated.
+
+A new sorted set is created at value if the key is an empty open key
+setup for writing.
+
+Additional flags can be passed to the function via a pointer, the flags
+are both used to receive input and to communicate state when the function
+returns. 'flagsptr' can be NULL if no special flags are used.
+
+The input flags are:
+
+    REDISMODULE_ZADD_XX: Element must already exist. Do nothing otherwise.
+    REDISMODULE_ZADD_NX: Element must not exist. Do nothing otherwise.
+    REDISMODULE_ZADD_GT: If element exists, new score must be greater than the current score. 
+                         Do nothing otherwise. Can optionally be combined with XX.
+    REDISMODULE_ZADD_LT: If element exists, new score must be less than the current score.
+                         Do nothing otherwise. Can optionally be combined with XX.
+
+The output flags are:
+
+    REDISMODULE_ZADD_ADDED: The new element was added to the sorted set.
+    REDISMODULE_ZADD_UPDATED: The score of the element was updated.
+    REDISMODULE_ZADD_NOP: No operation was performed because XX or NX flags.
+
+On success the function returns `REDISMODULE_OK`. On the following errors
+`REDISMODULE_ERR` is returned:
+
+* The key was not opened for writing.
+* The key is of the wrong type.
+* 'score' double value is not a number (NaN).
+
+<span id="RedisModule_ZsetIncrby"></span>
+
+### `RedisModule_ZsetIncrby`
+
+    int RedisModule_ZsetIncrby(RedisModuleKey *key,
+                               double score,
+                               RedisModuleString *ele,
+                               int *flagsptr,
+                               double *newscore);
+
+**Available since:** 4.0.0
+
+This function works exactly like [`RedisModule_ZsetAdd()`](#RedisModule_ZsetAdd), but instead of setting
+a new score, the score of the existing element is incremented, or if the
+element does not already exist, it is added assuming the old score was
+zero.
+
+The input and output flags, and the return value, have the same exact
+meaning, with the only difference that this function will return
+`REDISMODULE_ERR` even when 'score' is a valid double number, but adding it
+to the existing score results into a NaN (not a number) condition.
+
+This function has an additional field 'newscore', if not NULL is filled
+with the new score of the element after the increment, if no error
+is returned.
+
+<span id="RedisModule_ZsetRem"></span>
+
+### `RedisModule_ZsetRem`
+
+    int RedisModule_ZsetRem(RedisModuleKey *key,
+                            RedisModuleString *ele,
+                            int *deleted);
+
+**Available since:** 4.0.0
+
+Remove the specified element from the sorted set.
+The function returns `REDISMODULE_OK` on success, and `REDISMODULE_ERR`
+on one of the following conditions:
+
+* The key was not opened for writing.
+* The key is of the wrong type.
+
+The return value does NOT indicate the fact the element was really
+removed (since it existed) or not, just if the function was executed
+with success.
+
+In order to know if the element was removed, the additional argument
+'deleted' must be passed, that populates the integer by reference
+setting it to 1 or 0 depending on the outcome of the operation.
+The 'deleted' argument can be NULL if the caller is not interested
+to know if the element was really removed.
+
+Empty keys will be handled correctly by doing nothing.
+
+<span id="RedisModule_ZsetScore"></span>
+
+### `RedisModule_ZsetScore`
+
+    int RedisModule_ZsetScore(RedisModuleKey *key,
+                              RedisModuleString *ele,
+                              double *score);
+
+**Available since:** 4.0.0
+
+On success retrieve the double score associated at the sorted set element
+'ele' and returns `REDISMODULE_OK`. Otherwise `REDISMODULE_ERR` is returned
+to signal one of the following conditions:
+
+* There is no such element 'ele' in the sorted set.
+* The key is not a sorted set.
+* The key is an open empty key.
+
+<span id="section-key-api-for-sorted-set-iterator"></span>
+
+## Key API for Sorted Set iterator
+
+<span id="RedisModule_ZsetRangeStop"></span>
+
+### `RedisModule_ZsetRangeStop`
+
+    void RedisModule_ZsetRangeStop(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Stop a sorted set iteration.
+
+<span id="RedisModule_ZsetRangeEndReached"></span>
+
+### `RedisModule_ZsetRangeEndReached`
+
+    int RedisModule_ZsetRangeEndReached(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Return the "End of range" flag value to signal the end of the iteration.
+
+<span id="RedisModule_ZsetFirstInScoreRange"></span>
+
+### `RedisModule_ZsetFirstInScoreRange`
+
+    int RedisModule_ZsetFirstInScoreRange(RedisModuleKey *key,
+                                          double min,
+                                          double max,
+                                          int minex,
+                                          int maxex);
+
+**Available since:** 4.0.0
+
+Setup a sorted set iterator seeking the first element in the specified
+range. Returns `REDISMODULE_OK` if the iterator was correctly initialized
+otherwise `REDISMODULE_ERR` is returned in the following conditions:
+
+1. The value stored at key is not a sorted set or the key is empty.
+
+The range is specified according to the two double values 'min' and 'max'.
+Both can be infinite using the following two macros:
+
+* `REDISMODULE_POSITIVE_INFINITE` for positive infinite value
+* `REDISMODULE_NEGATIVE_INFINITE` for negative infinite value
+
+'minex' and 'maxex' parameters, if true, respectively setup a range
+where the min and max value are exclusive (not included) instead of
+inclusive.
+
+<span id="RedisModule_ZsetLastInScoreRange"></span>
+
+### `RedisModule_ZsetLastInScoreRange`
+
+    int RedisModule_ZsetLastInScoreRange(RedisModuleKey *key,
+                                         double min,
+                                         double max,
+                                         int minex,
+                                         int maxex);
+
+**Available since:** 4.0.0
+
+Exactly like [`RedisModule_ZsetFirstInScoreRange()`](#RedisModule_ZsetFirstInScoreRange) but the last element of
+the range is selected for the start of the iteration instead.
+
+<span id="RedisModule_ZsetFirstInLexRange"></span>
+
+### `RedisModule_ZsetFirstInLexRange`
+
+    int RedisModule_ZsetFirstInLexRange(RedisModuleKey *key,
+                                        RedisModuleString *min,
+                                        RedisModuleString *max);
+
+**Available since:** 4.0.0
+
+Setup a sorted set iterator seeking the first element in the specified
+lexicographical range. Returns `REDISMODULE_OK` if the iterator was correctly
+initialized otherwise `REDISMODULE_ERR` is returned in the
+following conditions:
+
+1. The value stored at key is not a sorted set or the key is empty.
+2. The lexicographical range 'min' and 'max' format is invalid.
+
+'min' and 'max' should be provided as two `RedisModuleString` objects
+in the same format as the parameters passed to the ZRANGEBYLEX command.
+The function does not take ownership of the objects, so they can be released
+ASAP after the iterator is setup.
+
+<span id="RedisModule_ZsetLastInLexRange"></span>
+
+### `RedisModule_ZsetLastInLexRange`
+
+    int RedisModule_ZsetLastInLexRange(RedisModuleKey *key,
+                                       RedisModuleString *min,
+                                       RedisModuleString *max);
+
+**Available since:** 4.0.0
+
+Exactly like [`RedisModule_ZsetFirstInLexRange()`](#RedisModule_ZsetFirstInLexRange) but the last element of
+the range is selected for the start of the iteration instead.
+
+<span id="RedisModule_ZsetRangeCurrentElement"></span>
+
+### `RedisModule_ZsetRangeCurrentElement`
+
+    RedisModuleString *RedisModule_ZsetRangeCurrentElement(RedisModuleKey *key,
+                                                           double *score);
+
+**Available since:** 4.0.0
+
+Return the current sorted set element of an active sorted set iterator
+or NULL if the range specified in the iterator does not include any
+element.
+
+<span id="RedisModule_ZsetRangeNext"></span>
+
+### `RedisModule_ZsetRangeNext`
+
+    int RedisModule_ZsetRangeNext(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Go to the next element of the sorted set iterator. Returns 1 if there was
+a next element, 0 if we are already at the latest element or the range
+does not include any item at all.
+
+<span id="RedisModule_ZsetRangePrev"></span>
+
+### `RedisModule_ZsetRangePrev`
+
+    int RedisModule_ZsetRangePrev(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Go to the previous element of the sorted set iterator. Returns 1 if there was
+a previous element, 0 if we are already at the first element or the range
+does not include any item at all.
+
+<span id="section-key-api-for-hash-type"></span>
+
+## Key API for Hash type
+
+See also [`RedisModule_ValueLength()`](#RedisModule_ValueLength), which returns the number of fields in a hash.
+
+<span id="RedisModule_HashSet"></span>
+
+### `RedisModule_HashSet`
+
+    int RedisModule_HashSet(RedisModuleKey *key, int flags, ...);
+
+**Available since:** 4.0.0
+
+Set the field of the specified hash field to the specified value.
+If the key is an empty key open for writing, it is created with an empty
+hash value, in order to set the specified field.
+
+The function is variadic and the user must specify pairs of field
+names and values, both as `RedisModuleString` pointers (unless the
+CFIELD option is set, see later). At the end of the field/value-ptr pairs,
+NULL must be specified as last argument to signal the end of the arguments
+in the variadic function.
+
+Example to set the hash argv[1] to the value argv[2]:
+
+     RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],argv[2],NULL);
+
+The function can also be used in order to delete fields (if they exist)
+by setting them to the specified value of `REDISMODULE_HASH_DELETE`:
+
+     RedisModule_HashSet(key,REDISMODULE_HASH_NONE,argv[1],
+                         REDISMODULE_HASH_DELETE,NULL);
+
+The behavior of the command changes with the specified flags, that can be
+set to `REDISMODULE_HASH_NONE` if no special behavior is needed.
+
+    REDISMODULE_HASH_NX: The operation is performed only if the field was not
+                         already existing in the hash.
+    REDISMODULE_HASH_XX: The operation is performed only if the field was
+                         already existing, so that a new value could be
+                         associated to an existing filed, but no new fields
+                         are created.
+    REDISMODULE_HASH_CFIELDS: The field names passed are null terminated C
+                              strings instead of RedisModuleString objects.
+    REDISMODULE_HASH_COUNT_ALL: Include the number of inserted fields in the
+                                returned number, in addition to the number of
+                                updated and deleted fields. (Added in Redis
+                                6.2.)
+
+Unless NX is specified, the command overwrites the old field value with
+the new one.
+
+When using `REDISMODULE_HASH_CFIELDS`, field names are reported using
+normal C strings, so for example to delete the field "foo" the following
+code can be used:
+
+     RedisModule_HashSet(key,REDISMODULE_HASH_CFIELDS,"foo",
+                         REDISMODULE_HASH_DELETE,NULL);
+
+Return value:
+
+The number of fields existing in the hash prior to the call, which have been
+updated (its old value has been replaced by a new value) or deleted. If the
+flag `REDISMODULE_HASH_COUNT_ALL` is set, inserted fields not previously
+existing in the hash are also counted.
+
+If the return value is zero, `errno` is set (since Redis 6.2) as follows:
+
+- EINVAL if any unknown flags are set or if key is NULL.
+- ENOTSUP if the key is associated with a non Hash value.
+- EBADF if the key was not opened for writing.
+- ENOENT if no fields were counted as described under Return value above.
+  This is not actually an error. The return value can be zero if all fields
+  were just created and the `COUNT_ALL` flag was unset, or if changes were held
+  back due to the NX and XX flags.
+
+NOTICE: The return value semantics of this function are very different
+between Redis 6.2 and older versions. Modules that use it should determine
+the Redis version and handle it accordingly.
+
+<span id="RedisModule_HashGet"></span>
+
+### `RedisModule_HashGet`
+
+    int RedisModule_HashGet(RedisModuleKey *key, int flags, ...);
+
+**Available since:** 4.0.0
+
+Get fields from a hash value. This function is called using a variable
+number of arguments, alternating a field name (as a `RedisModuleString`
+pointer) with a pointer to a `RedisModuleString` pointer, that is set to the
+value of the field if the field exists, or NULL if the field does not exist.
+At the end of the field/value-ptr pairs, NULL must be specified as last
+argument to signal the end of the arguments in the variadic function.
+
+This is an example usage:
+
+     RedisModuleString *first, *second;
+     RedisModule_HashGet(mykey,REDISMODULE_HASH_NONE,argv[1],&first,
+                         argv[2],&second,NULL);
+
+As with [`RedisModule_HashSet()`](#RedisModule_HashSet) the behavior of the command can be specified
+passing flags different than `REDISMODULE_HASH_NONE`:
+
+`REDISMODULE_HASH_CFIELDS`: field names as null terminated C strings.
+
+`REDISMODULE_HASH_EXISTS`: instead of setting the value of the field
+expecting a `RedisModuleString` pointer to pointer, the function just
+reports if the field exists or not and expects an integer pointer
+as the second element of each pair.
+
+`REDISMODULE_HASH_EXPIRE_TIME`: retrieves the expiration time of a field in the hash.
+The function expects a `mstime_t` pointer as the second element of each pair.
+If the field does not exist or has no expiration, the value is set to 
+`REDISMODULE_NO_EXPIRE`. This flag must not be used with `REDISMODULE_HASH_EXISTS`.
+
+Example of `REDISMODULE_HASH_CFIELDS`:
+
+     RedisModuleString *username, *hashedpass;
+     RedisModule_HashGet(mykey,REDISMODULE_HASH_CFIELDS,"username",&username,"hp",&hashedpass, NULL);
+
+Example of `REDISMODULE_HASH_EXISTS`:
+
+     int exists;
+     RedisModule_HashGet(mykey,REDISMODULE_HASH_EXISTS,"username",&exists,NULL);
+
+Example of `REDISMODULE_HASH_EXPIRE_TIME`:
+
+     mstime_t hpExpireTime; 
+     RedisModule_HashGet(mykey,REDISMODULE_HASH_EXPIRE_TIME,"hp",&hpExpireTime,NULL);
+     
+The function returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` if
+the key is not a hash value.
+
+Memory management:
+
+The returned `RedisModuleString` objects should be released with
+[`RedisModule_FreeString()`](#RedisModule_FreeString), or by enabling automatic memory management.
+
+<span id="RedisModule_HashFieldMinExpire"></span>
+
+### `RedisModule_HashFieldMinExpire`
+
+    mstime_t RedisModule_HashFieldMinExpire(RedisModuleKey *key);
+
+**Available since:** unreleased
+
+
+Retrieves the minimum expiration time of fields in a hash.
+
+Return:
+  - The minimum expiration time (in milliseconds) of the hash fields if at
+    least one field has an expiration set.
+  - `REDISMODULE_NO_EXPIRE` if no fields have an expiration set or if the key
+    is not a hash.
+
+<span id="section-key-api-for-stream-type"></span>
+
+## Key API for Stream type
+
+For an introduction to streams, see [https://redis.io/docs/latest/develop/data-types/streams/](https://redis.io/docs/latest/develop/data-types/streams/).
+
+The type `RedisModuleStreamID`, which is used in stream functions, is a struct
+with two 64-bit fields and is defined as
+
+    typedef struct RedisModuleStreamID {
+        uint64_t ms;
+        uint64_t seq;
+    } RedisModuleStreamID;
+
+See also [`RedisModule_ValueLength()`](#RedisModule_ValueLength), which returns the length of a stream, and the
+conversion functions [`RedisModule_StringToStreamID()`](#RedisModule_StringToStreamID) and [`RedisModule_CreateStringFromStreamID()`](#RedisModule_CreateStringFromStreamID).
+
+<span id="RedisModule_StreamAdd"></span>
+
+### `RedisModule_StreamAdd`
+
+    int RedisModule_StreamAdd(RedisModuleKey *key,
+                              int flags,
+                              RedisModuleStreamID *id,
+                              RedisModuleString **argv,
+                              long numfields);
+
+**Available since:** 6.2.0
+
+Adds an entry to a stream. Like XADD without trimming.
+
+- `key`: The key where the stream is (or will be) stored
+- `flags`: A bit field of
+  - `REDISMODULE_STREAM_ADD_AUTOID`: Assign a stream ID automatically, like
+    `*` in the XADD command.
+- `id`: If the `AUTOID` flag is set, this is where the assigned ID is
+  returned. Can be NULL if `AUTOID` is set, if you don't care to receive the
+  ID. If `AUTOID` is not set, this is the requested ID.
+- `argv`: A pointer to an array of size `numfields * 2` containing the
+  fields and values.
+- `numfields`: The number of field-value pairs in `argv`.
+
+Returns `REDISMODULE_OK` if an entry has been added. On failure,
+`REDISMODULE_ERR` is returned and `errno` is set as follows:
+
+- EINVAL if called with invalid arguments
+- ENOTSUP if the key refers to a value of a type other than stream
+- EBADF if the key was not opened for writing
+- EDOM if the given ID was 0-0 or not greater than all other IDs in the
+  stream (only if the AUTOID flag is unset)
+- EFBIG if the stream has reached the last possible ID
+- ERANGE if the elements are too large to be stored.
+
+<span id="RedisModule_StreamDelete"></span>
+
+### `RedisModule_StreamDelete`
+
+    int RedisModule_StreamDelete(RedisModuleKey *key, RedisModuleStreamID *id);
+
+**Available since:** 6.2.0
+
+Deletes an entry from a stream.
+
+- `key`: A key opened for writing, with no stream iterator started.
+- `id`: The stream ID of the entry to delete.
+
+Returns `REDISMODULE_OK` on success. On failure, `REDISMODULE_ERR` is returned
+and `errno` is set as follows:
+
+- EINVAL if called with invalid arguments
+- ENOTSUP if the key refers to a value of a type other than stream or if the
+  key is empty
+- EBADF if the key was not opened for writing or if a stream iterator is
+  associated with the key
+- ENOENT if no entry with the given stream ID exists
+
+See also [`RedisModule_StreamIteratorDelete()`](#RedisModule_StreamIteratorDelete) for deleting the current entry while
+iterating using a stream iterator.
+
+<span id="RedisModule_StreamIteratorStart"></span>
+
+### `RedisModule_StreamIteratorStart`
+
+    int RedisModule_StreamIteratorStart(RedisModuleKey *key,
+                                        int flags,
+                                        RedisModuleStreamID *start,
+                                        RedisModuleStreamID *end);
+
+**Available since:** 6.2.0
+
+Sets up a stream iterator.
+
+- `key`: The stream key opened for reading using [`RedisModule_OpenKey()`](#RedisModule_OpenKey).
+- `flags`:
+  - `REDISMODULE_STREAM_ITERATOR_EXCLUSIVE`: Don't include `start` and `end`
+    in the iterated range.
+  - `REDISMODULE_STREAM_ITERATOR_REVERSE`: Iterate in reverse order, starting
+    from the `end` of the range.
+- `start`: The lower bound of the range. Use NULL for the beginning of the
+  stream.
+- `end`: The upper bound of the range. Use NULL for the end of the stream.
+
+Returns `REDISMODULE_OK` on success. On failure, `REDISMODULE_ERR` is returned
+and `errno` is set as follows:
+
+- EINVAL if called with invalid arguments
+- ENOTSUP if the key refers to a value of a type other than stream or if the
+  key is empty
+- EBADF if the key was not opened for writing or if a stream iterator is
+  already associated with the key
+- EDOM if `start` or `end` is outside the valid range
+
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` if the key doesn't
+refer to a stream or if invalid arguments were given.
+
+The stream IDs are retrieved using [`RedisModule_StreamIteratorNextID()`](#RedisModule_StreamIteratorNextID) and
+for each stream ID, the fields and values are retrieved using
+[`RedisModule_StreamIteratorNextField()`](#RedisModule_StreamIteratorNextField). The iterator is freed by calling
+[`RedisModule_StreamIteratorStop()`](#RedisModule_StreamIteratorStop).
+
+Example (error handling omitted):
+
+    RedisModule_StreamIteratorStart(key, 0, startid_ptr, endid_ptr);
+    RedisModuleStreamID id;
+    long numfields;
+    while (RedisModule_StreamIteratorNextID(key, &id, &numfields) ==
+           REDISMODULE_OK) {
+        RedisModuleString *field, *value;
+        while (RedisModule_StreamIteratorNextField(key, &field, &value) ==
+               REDISMODULE_OK) {
+            //
+            // ... Do stuff ...
+            //
+            RedisModule_FreeString(ctx, field);
+            RedisModule_FreeString(ctx, value);
+        }
+    }
+    RedisModule_StreamIteratorStop(key);
+
+<span id="RedisModule_StreamIteratorStop"></span>
+
+### `RedisModule_StreamIteratorStop`
+
+    int RedisModule_StreamIteratorStop(RedisModuleKey *key);
+
+**Available since:** 6.2.0
+
+Stops a stream iterator created using [`RedisModule_StreamIteratorStart()`](#RedisModule_StreamIteratorStart) and
+reclaims its memory.
+
+Returns `REDISMODULE_OK` on success. On failure, `REDISMODULE_ERR` is returned
+and `errno` is set as follows:
+
+- EINVAL if called with a NULL key
+- ENOTSUP if the key refers to a value of a type other than stream or if the
+  key is empty
+- EBADF if the key was not opened for writing or if no stream iterator is
+  associated with the key
+
+<span id="RedisModule_StreamIteratorNextID"></span>
+
+### `RedisModule_StreamIteratorNextID`
+
+    int RedisModule_StreamIteratorNextID(RedisModuleKey *key,
+                                         RedisModuleStreamID *id,
+                                         long *numfields);
+
+**Available since:** 6.2.0
+
+Finds the next stream entry and returns its stream ID and the number of
+fields.
+
+- `key`: Key for which a stream iterator has been started using
+  [`RedisModule_StreamIteratorStart()`](#RedisModule_StreamIteratorStart).
+- `id`: The stream ID returned. NULL if you don't care.
+- `numfields`: The number of fields in the found stream entry. NULL if you
+  don't care.
+
+Returns `REDISMODULE_OK` and sets `*id` and `*numfields` if an entry was found.
+On failure, `REDISMODULE_ERR` is returned and `errno` is set as follows:
+
+- EINVAL if called with a NULL key
+- ENOTSUP if the key refers to a value of a type other than stream or if the
+  key is empty
+- EBADF if no stream iterator is associated with the key
+- ENOENT if there are no more entries in the range of the iterator
+
+In practice, if [`RedisModule_StreamIteratorNextID()`](#RedisModule_StreamIteratorNextID) is called after a successful call
+to [`RedisModule_StreamIteratorStart()`](#RedisModule_StreamIteratorStart) and with the same key, it is safe to assume that
+an `REDISMODULE_ERR` return value means that there are no more entries.
+
+Use [`RedisModule_StreamIteratorNextField()`](#RedisModule_StreamIteratorNextField) to retrieve the fields and values.
+See the example at [`RedisModule_StreamIteratorStart()`](#RedisModule_StreamIteratorStart).
+
+<span id="RedisModule_StreamIteratorNextField"></span>
+
+### `RedisModule_StreamIteratorNextField`
+
+    int RedisModule_StreamIteratorNextField(RedisModuleKey *key,
+                                            RedisModuleString **field_ptr,
+                                            RedisModuleString **value_ptr);
+
+**Available since:** 6.2.0
+
+Retrieves the next field of the current stream ID and its corresponding value
+in a stream iteration. This function should be called repeatedly after calling
+[`RedisModule_StreamIteratorNextID()`](#RedisModule_StreamIteratorNextID) to fetch each field-value pair.
+
+- `key`: Key where a stream iterator has been started.
+- `field_ptr`: This is where the field is returned.
+- `value_ptr`: This is where the value is returned.
+
+Returns `REDISMODULE_OK` and points `*field_ptr` and `*value_ptr` to freshly
+allocated `RedisModuleString` objects. The string objects are freed
+automatically when the callback finishes if automatic memory is enabled. On
+failure, `REDISMODULE_ERR` is returned and `errno` is set as follows:
+
+- EINVAL if called with a NULL key
+- ENOTSUP if the key refers to a value of a type other than stream or if the
+  key is empty
+- EBADF if no stream iterator is associated with the key
+- ENOENT if there are no more fields in the current stream entry
+
+In practice, if [`RedisModule_StreamIteratorNextField()`](#RedisModule_StreamIteratorNextField) is called after a successful
+call to [`RedisModule_StreamIteratorNextID()`](#RedisModule_StreamIteratorNextID) and with the same key, it is safe to assume
+that an `REDISMODULE_ERR` return value means that there are no more fields.
+
+See the example at [`RedisModule_StreamIteratorStart()`](#RedisModule_StreamIteratorStart).
+
+<span id="RedisModule_StreamIteratorDelete"></span>
+
+### `RedisModule_StreamIteratorDelete`
+
+    int RedisModule_StreamIteratorDelete(RedisModuleKey *key);
+
+**Available since:** 6.2.0
+
+Deletes the current stream entry while iterating.
+
+This function can be called after [`RedisModule_StreamIteratorNextID()`](#RedisModule_StreamIteratorNextID) or after any
+calls to [`RedisModule_StreamIteratorNextField()`](#RedisModule_StreamIteratorNextField).
+
+Returns `REDISMODULE_OK` on success. On failure, `REDISMODULE_ERR` is returned
+and `errno` is set as follows:
+
+- EINVAL if key is NULL
+- ENOTSUP if the key is empty or is of another type than stream
+- EBADF if the key is not opened for writing, if no iterator has been started
+- ENOENT if the iterator has no current stream entry
+
+<span id="RedisModule_StreamTrimByLength"></span>
+
+### `RedisModule_StreamTrimByLength`
+
+    long long RedisModule_StreamTrimByLength(RedisModuleKey *key,
+                                             int flags,
+                                             long long length);
+
+**Available since:** 6.2.0
+
+Trim a stream by length, similar to XTRIM with MAXLEN.
+
+- `key`: Key opened for writing.
+- `flags`: A bitfield of
+  - `REDISMODULE_STREAM_TRIM_APPROX`: Trim less if it improves performance,
+    like XTRIM with `~`.
+- `length`: The number of stream entries to keep after trimming.
+
+Returns the number of entries deleted. On failure, a negative value is
+returned and `errno` is set as follows:
+
+- EINVAL if called with invalid arguments
+- ENOTSUP if the key is empty or of a type other than stream
+- EBADF if the key is not opened for writing
+
+<span id="RedisModule_StreamTrimByID"></span>
+
+### `RedisModule_StreamTrimByID`
+
+    long long RedisModule_StreamTrimByID(RedisModuleKey *key,
+                                         int flags,
+                                         RedisModuleStreamID *id);
+
+**Available since:** 6.2.0
+
+Trim a stream by ID, similar to XTRIM with MINID.
+
+- `key`: Key opened for writing.
+- `flags`: A bitfield of
+  - `REDISMODULE_STREAM_TRIM_APPROX`: Trim less if it improves performance,
+    like XTRIM with `~`.
+- `id`: The smallest stream ID to keep after trimming.
+
+Returns the number of entries deleted. On failure, a negative value is
+returned and `errno` is set as follows:
+
+- EINVAL if called with invalid arguments
+- ENOTSUP if the key is empty or of a type other than stream
+- EBADF if the key is not opened for writing
+
+<span id="section-calling-redis-commands-from-modules"></span>
+
+## Calling Redis commands from modules
+
+[`RedisModule_Call()`](#RedisModule_Call) sends a command to Redis. The remaining functions handle the reply.
+
+<span id="RedisModule_FreeCallReply"></span>
+
+### `RedisModule_FreeCallReply`
+
+    void RedisModule_FreeCallReply(RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Free a Call reply and all the nested replies it contains if it's an
+array.
+
+<span id="RedisModule_CallReplyType"></span>
+
+### `RedisModule_CallReplyType`
+
+    int RedisModule_CallReplyType(RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Return the reply type as one of the following:
+
+- `REDISMODULE_REPLY_UNKNOWN`
+- `REDISMODULE_REPLY_STRING`
+- `REDISMODULE_REPLY_ERROR`
+- `REDISMODULE_REPLY_INTEGER`
+- `REDISMODULE_REPLY_ARRAY`
+- `REDISMODULE_REPLY_NULL`
+- `REDISMODULE_REPLY_MAP`
+- `REDISMODULE_REPLY_SET`
+- `REDISMODULE_REPLY_BOOL`
+- `REDISMODULE_REPLY_DOUBLE`
+- `REDISMODULE_REPLY_BIG_NUMBER`
+- `REDISMODULE_REPLY_VERBATIM_STRING`
+- `REDISMODULE_REPLY_ATTRIBUTE`
+- `REDISMODULE_REPLY_PROMISE`
+
+<span id="RedisModule_CallReplyLength"></span>
+
+### `RedisModule_CallReplyLength`
+
+    size_t RedisModule_CallReplyLength(RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Return the reply type length, where applicable.
+
+<span id="RedisModule_CallReplyArrayElement"></span>
+
+### `RedisModule_CallReplyArrayElement`
+
+    RedisModuleCallReply *RedisModule_CallReplyArrayElement(RedisModuleCallReply *reply,
+                                                            size_t idx);
+
+**Available since:** 4.0.0
+
+Return the 'idx'-th nested call reply element of an array reply, or NULL
+if the reply type is wrong or the index is out of range.
+
+<span id="RedisModule_CallReplyInteger"></span>
+
+### `RedisModule_CallReplyInteger`
+
+    long long RedisModule_CallReplyInteger(RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Return the `long long` of an integer reply.
+
+<span id="RedisModule_CallReplyDouble"></span>
+
+### `RedisModule_CallReplyDouble`
+
+    double RedisModule_CallReplyDouble(RedisModuleCallReply *reply);
+
+**Available since:** 7.0.0
+
+Return the double value of a double reply.
+
+<span id="RedisModule_CallReplyBigNumber"></span>
+
+### `RedisModule_CallReplyBigNumber`
+
+    const char *RedisModule_CallReplyBigNumber(RedisModuleCallReply *reply,
+                                               size_t *len);
+
+**Available since:** 7.0.0
+
+Return the big number value of a big number reply.
+
+<span id="RedisModule_CallReplyVerbatim"></span>
+
+### `RedisModule_CallReplyVerbatim`
+
+    const char *RedisModule_CallReplyVerbatim(RedisModuleCallReply *reply,
+                                              size_t *len,
+                                              const char **format);
+
+**Available since:** 7.0.0
+
+Return the value of a verbatim string reply,
+An optional output argument can be given to get verbatim reply format.
+
+<span id="RedisModule_CallReplyBool"></span>
+
+### `RedisModule_CallReplyBool`
+
+    int RedisModule_CallReplyBool(RedisModuleCallReply *reply);
+
+**Available since:** 7.0.0
+
+Return the Boolean value of a Boolean reply.
+
+<span id="RedisModule_CallReplySetElement"></span>
+
+### `RedisModule_CallReplySetElement`
+
+    RedisModuleCallReply *RedisModule_CallReplySetElement(RedisModuleCallReply *reply,
+                                                          size_t idx);
+
+**Available since:** 7.0.0
+
+Return the 'idx'-th nested call reply element of a set reply, or NULL
+if the reply type is wrong or the index is out of range.
+
+<span id="RedisModule_CallReplyMapElement"></span>
+
+### `RedisModule_CallReplyMapElement`
+
+    int RedisModule_CallReplyMapElement(RedisModuleCallReply *reply,
+                                        size_t idx,
+                                        RedisModuleCallReply **key,
+                                        RedisModuleCallReply **val);
+
+**Available since:** 7.0.0
+
+Retrieve the 'idx'-th key and value of a map reply.
+
+Returns:
+- `REDISMODULE_OK` on success.
+- `REDISMODULE_ERR` if idx out of range or if the reply type is wrong.
+
+The `key` and `value` arguments are used to return by reference, and may be
+NULL if not required.
+
+<span id="RedisModule_CallReplyAttribute"></span>
+
+### `RedisModule_CallReplyAttribute`
+
+    RedisModuleCallReply *RedisModule_CallReplyAttribute(RedisModuleCallReply *reply);
+
+**Available since:** 7.0.0
+
+Return the attribute of the given reply, or NULL if no attribute exists.
+
+<span id="RedisModule_CallReplyAttributeElement"></span>
+
+### `RedisModule_CallReplyAttributeElement`
+
+    int RedisModule_CallReplyAttributeElement(RedisModuleCallReply *reply,
+                                              size_t idx,
+                                              RedisModuleCallReply **key,
+                                              RedisModuleCallReply **val);
+
+**Available since:** 7.0.0
+
+Retrieve the 'idx'-th key and value of an attribute reply.
+
+Returns:
+- `REDISMODULE_OK` on success.
+- `REDISMODULE_ERR` if idx out of range or if the reply type is wrong.
+
+The `key` and `value` arguments are used to return by reference, and may be
+NULL if not required.
+
+<span id="RedisModule_CallReplyPromiseSetUnblockHandler"></span>
+
+### `RedisModule_CallReplyPromiseSetUnblockHandler`
+
+    void RedisModule_CallReplyPromiseSetUnblockHandler(RedisModuleCallReply *reply,
+                                                       RedisModuleOnUnblocked on_unblock,
+                                                       void *private_data);
+
+**Available since:** 7.2.0
+
+Set unblock handler (callback and private data) on the given promise `RedisModuleCallReply`.
+The given reply must be of promise type (`REDISMODULE_REPLY_PROMISE`).
+
+<span id="RedisModule_CallReplyPromiseAbort"></span>
+
+### `RedisModule_CallReplyPromiseAbort`
+
+    int RedisModule_CallReplyPromiseAbort(RedisModuleCallReply *reply,
+                                          void **private_data);
+
+**Available since:** 7.2.0
+
+Abort the execution of a given promise `RedisModuleCallReply`.
+return `REDMODULE_OK` in case the abort was done successfully and `REDISMODULE_ERR`
+if its not possible to abort the execution (execution already finished).
+In case the execution was aborted (`REDMODULE_OK` was returned), the `private_data` out parameter
+will be set with the value of the private data that was given on '[`RedisModule_CallReplyPromiseSetUnblockHandler`](#RedisModule_CallReplyPromiseSetUnblockHandler)'
+so the caller will be able to release the private data.
+
+If the execution was aborted successfully, it is promised that the unblock handler will not be called.
+That said, it is possible that the abort operation will successes but the operation will still continue.
+This can happened if, for example, a module implements some blocking command and does not respect the
+disconnect callback. For pure Redis commands this can not happened.
+
+<span id="RedisModule_CallReplyStringPtr"></span>
+
+### `RedisModule_CallReplyStringPtr`
+
+    const char *RedisModule_CallReplyStringPtr(RedisModuleCallReply *reply,
+                                               size_t *len);
+
+**Available since:** 4.0.0
+
+Return the pointer and length of a string or error reply.
+
+<span id="RedisModule_CreateStringFromCallReply"></span>
+
+### `RedisModule_CreateStringFromCallReply`
+
+    RedisModuleString *RedisModule_CreateStringFromCallReply(RedisModuleCallReply *reply);
+
+**Available since:** 4.0.0
+
+Return a new string object from a call reply of type string, error or
+integer. Otherwise (wrong reply type) return NULL.
+
+<span id="RedisModule_SetContextUser"></span>
+
+### `RedisModule_SetContextUser`
+
+    void RedisModule_SetContextUser(RedisModuleCtx *ctx,
+                                    const RedisModuleUser *user);
+
+**Available since:** 7.0.6
+
+Modifies the user that [`RedisModule_Call`](#RedisModule_Call) will use (e.g. for ACL checks)
+
+<span id="RedisModule_Call"></span>
+
+### `RedisModule_Call`
+
+    RedisModuleCallReply *RedisModule_Call(RedisModuleCtx *ctx,
+                                           const char *cmdname,
+                                           const char *fmt,
+                                           ...);
+
+**Available since:** 4.0.0
+
+Exported API to call any Redis command from modules.
+
+* **cmdname**: The Redis command to call.
+* **fmt**: A format specifier string for the command's arguments. Each
+  of the arguments should be specified by a valid type specification. The
+  format specifier can also contain the modifiers `!`, `A`, `3` and `R` which
+  don't have a corresponding argument.
+
+    * `b` -- The argument is a buffer and is immediately followed by another
+             argument that is the buffer's length.
+    * `c` -- The argument is a pointer to a plain C string (null-terminated).
+    * `l` -- The argument is a `long long` integer.
+    * `s` -- The argument is a RedisModuleString.
+    * `v` -- The argument(s) is a vector of RedisModuleString.
+    * `!` -- Sends the Redis command and its arguments to replicas and AOF.
+    * `A` -- Suppress AOF propagation, send only to replicas (requires `!`).
+    * `R` -- Suppress replicas propagation, send only to AOF (requires `!`).
+    * `3` -- Return a RESP3 reply. This will change the command reply.
+             e.g., HGETALL returns a map instead of a flat array.
+    * `0` -- Return the reply in auto mode, i.e. the reply format will be the
+             same as the client attached to the given RedisModuleCtx. This will
+             probably used when you want to pass the reply directly to the client.
+    * `C` -- Run a command as the user attached to the context.
+             User is either attached automatically via the client that directly
+             issued the command and created the context or via RedisModule_SetContextUser.
+             If the context is not directly created by an issued command (such as a
+             background context and no user was set on it via RedisModule_SetContextUser,
+             RedisModule_Call will fail.
+             Checks if the command can be executed according to ACL rules and causes
+             the command to run as the determined user, so that any future user
+             dependent activity, such as ACL checks within scripts will proceed as
+             expected.
+             Otherwise, the command will run as the Redis unrestricted user.
+             Upon sending a command from an internal connection, this flag is
+             ignored and the command will run as the Redis unrestricted user.
+    * `S` -- Run the command in a script mode, this means that it will raise
+             an error if a command which are not allowed inside a script
+             (flagged with the `deny-script` flag) is invoked (like SHUTDOWN).
+             In addition, on script mode, write commands are not allowed if there are
+             not enough good replicas (as configured with `min-replicas-to-write`)
+             or when the server is unable to persist to the disk.
+    * `W` -- Do not allow to run any write command (flagged with the `write` flag).
+    * `M` -- Do not allow `deny-oom` flagged commands when over the memory limit.
+    * `E` -- Return error as RedisModuleCallReply. If there is an error before
+             invoking the command, the error is returned using errno mechanism.
+             This flag allows to get the error also as an error CallReply with
+             relevant error message.
+    * 'D' -- A "Dry Run" mode. Return before executing the underlying call().
+             If everything succeeded, it will return with a NULL, otherwise it will
+             return with a CallReply object denoting the error, as if it was called with
+             the 'E' code.
+    * 'K' -- Allow running blocking commands. If enabled and the command gets blocked, a
+             special REDISMODULE_REPLY_PROMISE will be returned. This reply type
+             indicates that the command was blocked and the reply will be given asynchronously.
+             The module can use this reply object to set a handler which will be called when
+             the command gets unblocked using RedisModule_CallReplyPromiseSetUnblockHandler.
+             The handler must be set immediately after the command invocation (without releasing
+             the Redis lock in between). If the handler is not set, the blocking command will
+             still continue its execution but the reply will be ignored (fire and forget),
+             notice that this is dangerous in case of role change, as explained below.
+             The module can use RedisModule_CallReplyPromiseAbort to abort the command invocation
+             if it was not yet finished (see RedisModule_CallReplyPromiseAbort documentation for more
+             details). It is also the module's responsibility to abort the execution on role change, either by using
+             server event (to get notified when the instance becomes a replica) or relying on the disconnect
+             callback of the original client. Failing to do so can result in a write operation on a replica.
+             Unlike other call replies, promise call reply **must** be freed while the Redis GIL is locked.
+             Notice that on unblocking, the only promise is that the unblock handler will be called,
+             If the blocking RedisModule_Call caused the module to also block some real client (using RedisModule_BlockClient),
+             it is the module responsibility to unblock this client on the unblock handler.
+             On the unblock handler it is only allowed to perform the following:
+             * Calling additional Redis commands using RedisModule_Call
+             * Open keys using RedisModule_OpenKey
+             * Replicate data to the replica or AOF
+
+             Specifically, it is not allowed to call any Redis module API which are client related such as:
+             * RedisModule_Reply* API's
+             * RedisModule_BlockClient
+             * RedisModule_GetCurrentUserName
+
+* **...**: The actual arguments to the Redis command.
+
+On success a `RedisModuleCallReply` object is returned, otherwise
+NULL is returned and errno is set to the following values:
+
+* EBADF: wrong format specifier.
+* EINVAL: wrong command arity.
+* ENOENT: command does not exist.
+* EPERM: operation in Cluster instance with key in non local slot.
+* EROFS: operation in Cluster instance when a write command is sent
+         in a readonly state.
+* ENETDOWN: operation in Cluster instance when cluster is down.
+* ENOTSUP: No ACL user for the specified module context
+* EACCES: Command cannot be executed, according to ACL rules
+* ENOSPC: Write or deny-oom command is not allowed
+* ESPIPE: Command not allowed on script mode
+
+Example code fragment:
+
+     reply = RedisModule_Call(ctx,"INCRBY","sc",argv[1],"10");
+     if (RedisModule_CallReplyType(reply) == REDISMODULE_REPLY_INTEGER) {
+       long long myval = RedisModule_CallReplyInteger(reply);
+       // Do something with myval.
+     }
+
+This API is documented here: [https://redis.io/docs/latest/develop/reference/modules/](https://redis.io/docs/latest/develop/reference/modules/)
+
+<span id="RedisModule_CallReplyProto"></span>
+
+### `RedisModule_CallReplyProto`
+
+    const char *RedisModule_CallReplyProto(RedisModuleCallReply *reply,
+                                           size_t *len);
+
+**Available since:** 4.0.0
+
+Return a pointer, and a length, to the protocol returned by the command
+that returned the reply object.
+
+<span id="section-modules-data-types"></span>
+
+## Modules data types
+
+When String DMA or using existing data structures is not enough, it is
+possible to create new data types from scratch and export them to
+Redis. The module must provide a set of callbacks for handling the
+new values exported (for example in order to provide RDB saving/loading,
+AOF rewrite, and so forth). In this section we define this API.
+
+<span id="RedisModule_CreateDataType"></span>
+
+### `RedisModule_CreateDataType`
+
+    moduleType *RedisModule_CreateDataType(RedisModuleCtx *ctx,
+                                           const char *name,
+                                           int encver,
+                                           void *typemethods_ptr);
+
+**Available since:** 4.0.0
+
+Register a new data type exported by the module. The parameters are the
+following. Please for in depth documentation check the modules API
+documentation, especially [https://redis.io/docs/latest/develop/reference/modules/modules-native-types/](https://redis.io/docs/latest/develop/reference/modules/modules-native-types/).
+
+* **name**: A 9 characters data type name that MUST be unique in the Redis
+  Modules ecosystem. Be creative... and there will be no collisions. Use
+  the charset A-Z a-z 9-0, plus the two "-_" characters. A good
+  idea is to use, for example `<typename>-<vendor>`. For example
+  "tree-AntZ" may mean "Tree data structure by @antirez". To use both
+  lower case and upper case letters helps in order to prevent collisions.
+* **encver**: Encoding version, which is, the version of the serialization
+  that a module used in order to persist data. As long as the "name"
+  matches, the RDB loading will be dispatched to the type callbacks
+  whatever 'encver' is used, however the module can understand if
+  the encoding it must load are of an older version of the module.
+  For example the module "tree-AntZ" initially used encver=0. Later
+  after an upgrade, it started to serialize data in a different format
+  and to register the type with encver=1. However this module may
+  still load old data produced by an older version if the `rdb_load`
+  callback is able to check the encver value and act accordingly.
+  The encver must be a positive value between 0 and 1023.
+
+* **typemethods_ptr** is a pointer to a `RedisModuleTypeMethods` structure
+  that should be populated with the methods callbacks and structure
+  version, like in the following example:
+
+        RedisModuleTypeMethods tm = {
+            .version = REDISMODULE_TYPE_METHOD_VERSION,
+            .rdb_load = myType_RDBLoadCallBack,
+            .rdb_save = myType_RDBSaveCallBack,
+            .aof_rewrite = myType_AOFRewriteCallBack,
+            .free = myType_FreeCallBack,
+
+            // Optional fields
+            .digest = myType_DigestCallBack,
+            .mem_usage = myType_MemUsageCallBack,
+            .aux_load = myType_AuxRDBLoadCallBack,
+            .aux_save = myType_AuxRDBSaveCallBack,
+            .free_effort = myType_FreeEffortCallBack,
+            .unlink = myType_UnlinkCallBack,
+            .copy = myType_CopyCallback,
+            .defrag = myType_DefragCallback
+
+            // Enhanced optional fields
+            .mem_usage2 = myType_MemUsageCallBack2,
+            .free_effort2 = myType_FreeEffortCallBack2,
+            .unlink2 = myType_UnlinkCallBack2,
+            .copy2 = myType_CopyCallback2,
+        }
+
+* **rdb_load**: A callback function pointer that loads data from RDB files.
+* **rdb_save**: A callback function pointer that saves data to RDB files.
+* **aof_rewrite**: A callback function pointer that rewrites data as commands.
+* **digest**: A callback function pointer that is used for `DEBUG DIGEST`.
+* **free**: A callback function pointer that can free a type value.
+* **aux_save**: A callback function pointer that saves out of keyspace data to RDB files.
+  'when' argument is either `REDISMODULE_AUX_BEFORE_RDB` or `REDISMODULE_AUX_AFTER_RDB`.
+* **aux_load**: A callback function pointer that loads out of keyspace data from RDB files.
+  Similar to `aux_save`, returns `REDISMODULE_OK` on success, and ERR otherwise.
+* **free_effort**: A callback function pointer that used to determine whether the module's
+  memory needs to be lazy reclaimed. The module should return the complexity involved by
+  freeing the value. for example: how many pointers are gonna be freed. Note that if it 
+  returns 0, we'll always do an async free.
+* **unlink**: A callback function pointer that used to notifies the module that the key has 
+  been removed from the DB by redis, and may soon be freed by a background thread. Note that 
+  it won't be called on FLUSHALL/FLUSHDB (both sync and async), and the module can use the 
+  `RedisModuleEvent_FlushDB` to hook into that.
+* **copy**: A callback function pointer that is used to make a copy of the specified key.
+  The module is expected to perform a deep copy of the specified value and return it.
+  In addition, hints about the names of the source and destination keys is provided.
+  A NULL return value is considered an error and the copy operation fails.
+  Note: if the target key exists and is being overwritten, the copy callback will be
+  called first, followed by a free callback to the value that is being replaced.
+
+* **defrag**: A callback function pointer that is used to request the module to defrag
+  a key. The module should then iterate pointers and call the relevant `RedisModule_Defrag*()`
+  functions to defragment pointers or complex types. The module should continue
+  iterating as long as [`RedisModule_DefragShouldStop()`](#RedisModule_DefragShouldStop) returns a zero value, and return a
+  zero value if finished or non-zero value if more work is left to be done. If more work
+  needs to be done, [`RedisModule_DefragCursorSet()`](#RedisModule_DefragCursorSet) and [`RedisModule_DefragCursorGet()`](#RedisModule_DefragCursorGet) can be used to track
+  this work across different calls.
+  Normally, the defrag mechanism invokes the callback without a time limit, so
+  [`RedisModule_DefragShouldStop()`](#RedisModule_DefragShouldStop) always returns zero. The "late defrag" mechanism which has
+  a time limit and provides cursor support is used only for keys that are determined
+  to have significant internal complexity. To determine this, the defrag mechanism
+  uses the `free_effort` callback and the 'active-defrag-max-scan-fields' config directive.
+  NOTE: The value is passed as a `void**` and the function is expected to update the
+  pointer if the top-level value pointer is defragmented and consequently changes.
+
+* **mem_usage2**: Similar to `mem_usage`, but provides the `RedisModuleKeyOptCtx` parameter
+  so that meta information such as key name and db id can be obtained, and
+  the `sample_size` for size estimation (see MEMORY USAGE command).
+* **free_effort2**: Similar to `free_effort`, but provides the `RedisModuleKeyOptCtx` parameter
+  so that meta information such as key name and db id can be obtained.
+* **unlink2**: Similar to `unlink`, but provides the `RedisModuleKeyOptCtx` parameter
+  so that meta information such as key name and db id can be obtained.
+* **copy2**: Similar to `copy`, but provides the `RedisModuleKeyOptCtx` parameter
+  so that meta information such as key names and db ids can be obtained.
+* **aux_save2**: Similar to `aux_save`, but with small semantic change, if the module
+  saves nothing on this callback then no data about this aux field will be written to the
+  RDB and it will be possible to load the RDB even if the module is not loaded.
+
+Note: the module name "AAAAAAAAA" is reserved and produces an error, it
+happens to be pretty lame as well.
+
+If [`RedisModule_CreateDataType()`](#RedisModule_CreateDataType) is called outside of `RedisModule_OnLoad()` function,
+there is already a module registering a type with the same name,
+or if the module name or encver is invalid, NULL is returned.
+Otherwise the new type is registered into Redis, and a reference of
+type `RedisModuleType` is returned: the caller of the function should store
+this reference into a global variable to make future use of it in the
+modules type API, since a single module may register multiple types.
+Example code fragment:
+
+     static RedisModuleType *BalancedTreeType;
+
+     int RedisModule_OnLoad(RedisModuleCtx *ctx) {
+         // some code here ...
+         BalancedTreeType = RedisModule_CreateDataType(...);
+     }
+
+<span id="RedisModule_ModuleTypeSetValue"></span>
+
+### `RedisModule_ModuleTypeSetValue`
+
+    int RedisModule_ModuleTypeSetValue(RedisModuleKey *key,
+                                       moduleType *mt,
+                                       void *value);
+
+**Available since:** 4.0.0
+
+If the key is open for writing, set the specified module type object
+as the value of the key, deleting the old value if any.
+On success `REDISMODULE_OK` is returned. If the key is not open for
+writing or there is an active iterator, `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_ModuleTypeGetType"></span>
+
+### `RedisModule_ModuleTypeGetType`
+
+    moduleType *RedisModule_ModuleTypeGetType(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Assuming [`RedisModule_KeyType()`](#RedisModule_KeyType) returned `REDISMODULE_KEYTYPE_MODULE` on
+the key, returns the module type pointer of the value stored at key.
+
+If the key is NULL, is not associated with a module type, or is empty,
+then NULL is returned instead.
+
+<span id="RedisModule_ModuleTypeGetValue"></span>
+
+### `RedisModule_ModuleTypeGetValue`
+
+    void *RedisModule_ModuleTypeGetValue(RedisModuleKey *key);
+
+**Available since:** 4.0.0
+
+Assuming [`RedisModule_KeyType()`](#RedisModule_KeyType) returned `REDISMODULE_KEYTYPE_MODULE` on
+the key, returns the module type low-level value stored at key, as
+it was set by the user via [`RedisModule_ModuleTypeSetValue()`](#RedisModule_ModuleTypeSetValue).
+
+If the key is NULL, is not associated with a module type, or is empty,
+then NULL is returned instead.
+
+<span id="section-rdb-loading-and-saving-functions"></span>
+
+## RDB loading and saving functions
+
+<span id="RedisModule_IsIOError"></span>
+
+### `RedisModule_IsIOError`
+
+    int RedisModule_IsIOError(RedisModuleIO *io);
+
+**Available since:** 6.0.0
+
+Returns true if any previous IO API failed.
+for `Load*` APIs the `REDISMODULE_OPTIONS_HANDLE_IO_ERRORS` flag must be set with
+[`RedisModule_SetModuleOptions`](#RedisModule_SetModuleOptions) first.
+
+<span id="RedisModule_SaveUnsigned"></span>
+
+### `RedisModule_SaveUnsigned`
+
+    void RedisModule_SaveUnsigned(RedisModuleIO *io, uint64_t value);
+
+**Available since:** 4.0.0
+
+Save an unsigned 64 bit value into the RDB file. This function should only
+be called in the context of the `rdb_save` method of modules implementing new
+data types.
+
+<span id="RedisModule_LoadUnsigned"></span>
+
+### `RedisModule_LoadUnsigned`
+
+    uint64_t RedisModule_LoadUnsigned(RedisModuleIO *io);
+
+**Available since:** 4.0.0
+
+Load an unsigned 64 bit value from the RDB file. This function should only
+be called in the context of the `rdb_load` method of modules implementing
+new data types.
+
+<span id="RedisModule_SaveSigned"></span>
+
+### `RedisModule_SaveSigned`
+
+    void RedisModule_SaveSigned(RedisModuleIO *io, int64_t value);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_SaveUnsigned()`](#RedisModule_SaveUnsigned) but for signed 64 bit values.
+
+<span id="RedisModule_LoadSigned"></span>
+
+### `RedisModule_LoadSigned`
+
+    int64_t RedisModule_LoadSigned(RedisModuleIO *io);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_LoadUnsigned()`](#RedisModule_LoadUnsigned) but for signed 64 bit values.
+
+<span id="RedisModule_SaveString"></span>
+
+### `RedisModule_SaveString`
+
+    void RedisModule_SaveString(RedisModuleIO *io, RedisModuleString *s);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_save` method of a module type, saves a
+string into the RDB file taking as input a `RedisModuleString`.
+
+The string can be later loaded with [`RedisModule_LoadString()`](#RedisModule_LoadString) or
+other Load family functions expecting a serialized string inside
+the RDB file.
+
+<span id="RedisModule_SaveStringBuffer"></span>
+
+### `RedisModule_SaveStringBuffer`
+
+    void RedisModule_SaveStringBuffer(RedisModuleIO *io,
+                                      const char *str,
+                                      size_t len);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_SaveString()`](#RedisModule_SaveString) but takes a raw C pointer and length
+as input.
+
+<span id="RedisModule_LoadString"></span>
+
+### `RedisModule_LoadString`
+
+    RedisModuleString *RedisModule_LoadString(RedisModuleIO *io);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_load` method of a module data type, loads a string
+from the RDB file, that was previously saved with [`RedisModule_SaveString()`](#RedisModule_SaveString)
+functions family.
+
+The returned string is a newly allocated `RedisModuleString` object, and
+the user should at some point free it with a call to [`RedisModule_FreeString()`](#RedisModule_FreeString).
+
+If the data structure does not store strings as `RedisModuleString` objects,
+the similar function [`RedisModule_LoadStringBuffer()`](#RedisModule_LoadStringBuffer) could be used instead.
+
+<span id="RedisModule_LoadStringBuffer"></span>
+
+### `RedisModule_LoadStringBuffer`
+
+    char *RedisModule_LoadStringBuffer(RedisModuleIO *io, size_t *lenptr);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_LoadString()`](#RedisModule_LoadString) but returns a heap allocated string that
+was allocated with [`RedisModule_Alloc()`](#RedisModule_Alloc), and can be resized or freed with
+[`RedisModule_Realloc()`](#RedisModule_Realloc) or [`RedisModule_Free()`](#RedisModule_Free).
+
+The size of the string is stored at '*lenptr' if not NULL.
+The returned string is not automatically NULL terminated, it is loaded
+exactly as it was stored inside the RDB file.
+
+<span id="RedisModule_SaveDouble"></span>
+
+### `RedisModule_SaveDouble`
+
+    void RedisModule_SaveDouble(RedisModuleIO *io, double value);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_save` method of a module data type, saves a double
+value to the RDB file. The double can be a valid number, a NaN or infinity.
+It is possible to load back the value with [`RedisModule_LoadDouble()`](#RedisModule_LoadDouble).
+
+<span id="RedisModule_LoadDouble"></span>
+
+### `RedisModule_LoadDouble`
+
+    double RedisModule_LoadDouble(RedisModuleIO *io);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_save` method of a module data type, loads back the
+double value saved by [`RedisModule_SaveDouble()`](#RedisModule_SaveDouble).
+
+<span id="RedisModule_SaveFloat"></span>
+
+### `RedisModule_SaveFloat`
+
+    void RedisModule_SaveFloat(RedisModuleIO *io, float value);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_save` method of a module data type, saves a float
+value to the RDB file. The float can be a valid number, a NaN or infinity.
+It is possible to load back the value with [`RedisModule_LoadFloat()`](#RedisModule_LoadFloat).
+
+<span id="RedisModule_LoadFloat"></span>
+
+### `RedisModule_LoadFloat`
+
+    float RedisModule_LoadFloat(RedisModuleIO *io);
+
+**Available since:** 4.0.0
+
+In the context of the `rdb_save` method of a module data type, loads back the
+float value saved by [`RedisModule_SaveFloat()`](#RedisModule_SaveFloat).
+
+<span id="RedisModule_SaveLongDouble"></span>
+
+### `RedisModule_SaveLongDouble`
+
+    void RedisModule_SaveLongDouble(RedisModuleIO *io, long double value);
+
+**Available since:** 6.0.0
+
+In the context of the `rdb_save` method of a module data type, saves a long double
+value to the RDB file. The double can be a valid number, a NaN or infinity.
+It is possible to load back the value with [`RedisModule_LoadLongDouble()`](#RedisModule_LoadLongDouble).
+
+<span id="RedisModule_LoadLongDouble"></span>
+
+### `RedisModule_LoadLongDouble`
+
+    long double RedisModule_LoadLongDouble(RedisModuleIO *io);
+
+**Available since:** 6.0.0
+
+In the context of the `rdb_save` method of a module data type, loads back the
+long double value saved by [`RedisModule_SaveLongDouble()`](#RedisModule_SaveLongDouble).
+
+<span id="section-key-digest-api-debug-digest-interface-for-modules-types"></span>
+
+## Key digest API (DEBUG DIGEST interface for modules types)
+
+<span id="RedisModule_DigestAddStringBuffer"></span>
+
+### `RedisModule_DigestAddStringBuffer`
+
+    void RedisModule_DigestAddStringBuffer(RedisModuleDigest *md,
+                                           const char *ele,
+                                           size_t len);
+
+**Available since:** 4.0.0
+
+Add a new element to the digest. This function can be called multiple times
+one element after the other, for all the elements that constitute a given
+data structure. The function call must be followed by the call to
+[`RedisModule_DigestEndSequence`](#RedisModule_DigestEndSequence) eventually, when all the elements that are
+always in a given order are added. See the Redis Modules data types
+documentation for more info. However this is a quick example that uses Redis
+data types as an example.
+
+To add a sequence of unordered elements (for example in the case of a Redis
+Set), the pattern to use is:
+
+    foreach element {
+        AddElement(element);
+        EndSequence();
+    }
+
+Because Sets are not ordered, so every element added has a position that
+does not depend from the other. However if instead our elements are
+ordered in pairs, like field-value pairs of a Hash, then one should
+use:
+
+    foreach key,value {
+        AddElement(key);
+        AddElement(value);
+        EndSequence();
+    }
+
+Because the key and value will be always in the above order, while instead
+the single key-value pairs, can appear in any position into a Redis hash.
+
+A list of ordered elements would be implemented with:
+
+    foreach element {
+        AddElement(element);
+    }
+    EndSequence();
+
+<span id="RedisModule_DigestAddLongLong"></span>
+
+### `RedisModule_DigestAddLongLong`
+
+    void RedisModule_DigestAddLongLong(RedisModuleDigest *md, long long ll);
+
+**Available since:** 4.0.0
+
+Like [`RedisModule_DigestAddStringBuffer()`](#RedisModule_DigestAddStringBuffer) but takes a `long long` as input
+that gets converted into a string before adding it to the digest.
+
+<span id="RedisModule_DigestEndSequence"></span>
+
+### `RedisModule_DigestEndSequence`
+
+    void RedisModule_DigestEndSequence(RedisModuleDigest *md);
+
+**Available since:** 4.0.0
+
+See the documentation for `RedisModule_DigestAddElement()`.
+
+<span id="RedisModule_LoadDataTypeFromStringEncver"></span>
+
+### `RedisModule_LoadDataTypeFromStringEncver`
+
+    void *RedisModule_LoadDataTypeFromStringEncver(const RedisModuleString *str,
+                                                   const moduleType *mt,
+                                                   int encver);
+
+**Available since:** 7.0.0
+
+Decode a serialized representation of a module data type 'mt', in a specific encoding version 'encver'
+from string 'str' and return a newly allocated value, or NULL if decoding failed.
+
+This call basically reuses the '`rdb_load`' callback which module data types
+implement in order to allow a module to arbitrarily serialize/de-serialize
+keys, similar to how the Redis 'DUMP' and 'RESTORE' commands are implemented.
+
+Modules should generally use the `REDISMODULE_OPTIONS_HANDLE_IO_ERRORS` flag and
+make sure the de-serialization code properly checks and handles IO errors
+(freeing allocated buffers and returning a NULL).
+
+If this is NOT done, Redis will handle corrupted (or just truncated) serialized
+data by producing an error message and terminating the process.
+
+<span id="RedisModule_LoadDataTypeFromString"></span>
+
+### `RedisModule_LoadDataTypeFromString`
+
+    void *RedisModule_LoadDataTypeFromString(const RedisModuleString *str,
+                                             const moduleType *mt);
+
+**Available since:** 6.0.0
+
+Similar to [`RedisModule_LoadDataTypeFromStringEncver`](#RedisModule_LoadDataTypeFromStringEncver), original version of the API, kept
+for backward compatibility.
+
+<span id="RedisModule_SaveDataTypeToString"></span>
+
+### `RedisModule_SaveDataTypeToString`
+
+    RedisModuleString *RedisModule_SaveDataTypeToString(RedisModuleCtx *ctx,
+                                                        void *data,
+                                                        const moduleType *mt);
+
+**Available since:** 6.0.0
+
+Encode a module data type 'mt' value 'data' into serialized form, and return it
+as a newly allocated `RedisModuleString`.
+
+This call basically reuses the '`rdb_save`' callback which module data types
+implement in order to allow a module to arbitrarily serialize/de-serialize
+keys, similar to how the Redis 'DUMP' and 'RESTORE' commands are implemented.
+
+<span id="RedisModule_GetKeyNameFromDigest"></span>
+
+### `RedisModule_GetKeyNameFromDigest`
+
+    const RedisModuleString *RedisModule_GetKeyNameFromDigest(RedisModuleDigest *dig);
+
+**Available since:** 7.0.0
+
+Returns the name of the key currently being processed.
+
+<span id="RedisModule_GetDbIdFromDigest"></span>
+
+### `RedisModule_GetDbIdFromDigest`
+
+    int RedisModule_GetDbIdFromDigest(RedisModuleDigest *dig);
+
+**Available since:** 7.0.0
+
+Returns the database id of the key currently being processed.
+
+<span id="section-aof-api-for-modules-data-types"></span>
+
+## AOF API for modules data types
+
+<span id="RedisModule_EmitAOF"></span>
+
+### `RedisModule_EmitAOF`
+
+    void RedisModule_EmitAOF(RedisModuleIO *io,
+                             const char *cmdname,
+                             const char *fmt,
+                             ...);
+
+**Available since:** 4.0.0
+
+Emits a command into the AOF during the AOF rewriting process. This function
+is only called in the context of the `aof_rewrite` method of data types exported
+by a module. The command works exactly like [`RedisModule_Call()`](#RedisModule_Call) in the way
+the parameters are passed, but it does not return anything as the error
+handling is performed by Redis itself.
+
+<span id="section-io-context-handling"></span>
+
+## IO context handling
+
+<span id="RedisModule_GetKeyNameFromIO"></span>
+
+### `RedisModule_GetKeyNameFromIO`
+
+    const RedisModuleString *RedisModule_GetKeyNameFromIO(RedisModuleIO *io);
+
+**Available since:** 5.0.5
+
+Returns the name of the key currently being processed.
+There is no guarantee that the key name is always available, so this may return NULL.
+
+<span id="RedisModule_GetKeyNameFromModuleKey"></span>
+
+### `RedisModule_GetKeyNameFromModuleKey`
+
+    const RedisModuleString *RedisModule_GetKeyNameFromModuleKey(RedisModuleKey *key);
+
+**Available since:** 6.0.0
+
+Returns a `RedisModuleString` with the name of the key from `RedisModuleKey`.
+
+<span id="RedisModule_GetDbIdFromModuleKey"></span>
+
+### `RedisModule_GetDbIdFromModuleKey`
+
+    int RedisModule_GetDbIdFromModuleKey(RedisModuleKey *key);
+
+**Available since:** 7.0.0
+
+Returns a database id of the key from `RedisModuleKey`.
+
+<span id="RedisModule_GetDbIdFromIO"></span>
+
+### `RedisModule_GetDbIdFromIO`
+
+    int RedisModule_GetDbIdFromIO(RedisModuleIO *io);
+
+**Available since:** 7.0.0
+
+Returns the database id of the key currently being processed.
+There is no guarantee that this info is always available, so this may return -1.
+
+<span id="section-logging"></span>
+
+## Logging
+
+<span id="RedisModule_Log"></span>
+
+### `RedisModule_Log`
+
+    void RedisModule_Log(RedisModuleCtx *ctx,
+                         const char *levelstr,
+                         const char *fmt,
+                         ...);
+
+**Available since:** 4.0.0
+
+Produces a log message to the standard Redis log, the format accepts
+printf-alike specifiers, while level is a string describing the log
+level to use when emitting the log, and must be one of the following:
+
+* "debug" (`REDISMODULE_LOGLEVEL_DEBUG`)
+* "verbose" (`REDISMODULE_LOGLEVEL_VERBOSE`)
+* "notice" (`REDISMODULE_LOGLEVEL_NOTICE`)
+* "warning" (`REDISMODULE_LOGLEVEL_WARNING`)
+
+If the specified log level is invalid, verbose is used by default.
+There is a fixed limit to the length of the log line this function is able
+to emit, this limit is not specified but is guaranteed to be more than
+a few lines of text.
+
+The ctx argument may be NULL if cannot be provided in the context of the
+caller for instance threads or callbacks, in which case a generic "module"
+will be used instead of the module name.
+
+<span id="RedisModule_LogIOError"></span>
+
+### `RedisModule_LogIOError`
+
+    void RedisModule_LogIOError(RedisModuleIO *io,
+                                const char *levelstr,
+                                const char *fmt,
+                                ...);
+
+**Available since:** 4.0.0
+
+Log errors from RDB / AOF serialization callbacks.
+
+This function should be used when a callback is returning a critical
+error to the caller since cannot load or save the data for some
+critical reason.
+
+<span id="RedisModule__Assert"></span>
+
+### `RedisModule__Assert`
+
+    void RedisModule__Assert(const char *estr, const char *file, int line);
+
+**Available since:** 6.0.0
+
+Redis-like assert function.
+
+The macro `RedisModule_Assert(expression)` is recommended, rather than
+calling this function directly.
+
+A failed assertion will shut down the server and produce logging information
+that looks identical to information generated by Redis itself.
+
+<span id="RedisModule_LatencyAddSample"></span>
+
+### `RedisModule_LatencyAddSample`
+
+    void RedisModule_LatencyAddSample(const char *event, mstime_t latency);
+
+**Available since:** 6.0.0
+
+Allows adding event to the latency monitor to be observed by the LATENCY
+command. The call is skipped if the latency is smaller than the configured
+latency-monitor-threshold.
+
+<span id="section-blocking-clients-from-modules"></span>
+
+## Blocking clients from modules
+
+For a guide about blocking commands in modules, see
+[https://redis.io/docs/latest/develop/reference/modules/modules-blocking-ops/](https://redis.io/docs/latest/develop/reference/modules/modules-blocking-ops/).
+
+<span id="RedisModule_RegisterAuthCallback"></span>
+
+### `RedisModule_RegisterAuthCallback`
+
+    void RedisModule_RegisterAuthCallback(RedisModuleCtx *ctx,
+                                          RedisModuleAuthCallback cb);
+
+**Available since:** 7.2.0
+
+This API registers a callback to execute in addition to normal password based authentication.
+Multiple callbacks can be registered across different modules. When a Module is unloaded, all the
+auth callbacks registered by it are unregistered.
+The callbacks are attempted (in the order of most recently registered first) when the AUTH/HELLO
+(with AUTH field provided) commands are called.
+The callbacks will be called with a module context along with a username and a password, and are
+expected to take one of the following actions:
+(1) Authenticate - Use the `RedisModule_AuthenticateClient`* API and return `REDISMODULE_AUTH_HANDLED`.
+This will immediately end the auth chain as successful and add the OK reply.
+(2) Deny Authentication - Return `REDISMODULE_AUTH_HANDLED` without authenticating or blocking the
+client. Optionally, `err` can be set to a custom error message and `err` will be automatically
+freed by the server.
+This will immediately end the auth chain as unsuccessful and add the ERR reply.
+(3) Block a client on authentication - Use the [`RedisModule_BlockClientOnAuth`](#RedisModule_BlockClientOnAuth) API and return
+`REDISMODULE_AUTH_HANDLED`. Here, the client will be blocked until the [`RedisModule_UnblockClient`](#RedisModule_UnblockClient) API is used
+which will trigger the auth reply callback (provided through the [`RedisModule_BlockClientOnAuth`](#RedisModule_BlockClientOnAuth)).
+In this reply callback, the Module should authenticate, deny or skip handling authentication.
+(4) Skip handling Authentication - Return `REDISMODULE_AUTH_NOT_HANDLED` without blocking the
+client. This will allow the engine to attempt the next module auth callback.
+If none of the callbacks authenticate or deny auth, then password based auth is attempted and
+will authenticate or add failure logs and reply to the clients accordingly.
+
+Note: If a client is disconnected while it was in the middle of blocking module auth, that
+occurrence of the AUTH or HELLO command will not be tracked in the INFO command stats.
+
+The following is an example of how non-blocking module based authentication can be used:
+
+     int auth_cb(RedisModuleCtx *ctx, RedisModuleString *username, RedisModuleString *password, RedisModuleString **err) {
+         const char *user = RedisModule_StringPtrLen(username, NULL);
+         const char *pwd = RedisModule_StringPtrLen(password, NULL);
+         if (!strcmp(user,"foo") && !strcmp(pwd,"valid_password")) {
+             RedisModule_AuthenticateClientWithACLUser(ctx, "foo", 3, NULL, NULL, NULL);
+             return REDISMODULE_AUTH_HANDLED;
+         }
+
+         else if (!strcmp(user,"foo") && !strcmp(pwd,"wrong_password")) {
+             RedisModuleString *log = RedisModule_CreateString(ctx, "Module Auth", 11);
+             RedisModule_ACLAddLogEntryByUserName(ctx, username, log, REDISMODULE_ACL_LOG_AUTH);
+             RedisModule_FreeString(ctx, log);
+             const char *err_msg = "Auth denied by Misc Module.";
+             *err = RedisModule_CreateString(ctx, err_msg, strlen(err_msg));
+             return REDISMODULE_AUTH_HANDLED;
+         }
+         return REDISMODULE_AUTH_NOT_HANDLED;
+      }
+
+     int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+         if (RedisModule_Init(ctx,"authmodule",1,REDISMODULE_APIVER_1)== REDISMODULE_ERR)
+             return REDISMODULE_ERR;
+         RedisModule_RegisterAuthCallback(ctx, auth_cb);
+         return REDISMODULE_OK;
+     }
+
+<span id="RedisModule_BlockClient"></span>
+
+### `RedisModule_BlockClient`
+
+    RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx,
+                                                      RedisModuleCmdFunc reply_callback,
+                                                      ;
+
+**Available since:** 4.0.0
+
+Block a client in the context of a blocking command, returning a handle
+which will be used, later, in order to unblock the client with a call to
+[`RedisModule_UnblockClient()`](#RedisModule_UnblockClient). The arguments specify callback functions
+and a timeout after which the client is unblocked.
+
+The callbacks are called in the following contexts:
+
+    reply_callback:   called after a successful RedisModule_UnblockClient()
+                      call in order to reply to the client and unblock it.
+
+    timeout_callback: called when the timeout is reached or if `CLIENT UNBLOCK`
+                      is invoked, in order to send an error to the client.
+
+    free_privdata:    called in order to free the private data that is passed
+                      by RedisModule_UnblockClient() call.
+
+Note: [`RedisModule_UnblockClient`](#RedisModule_UnblockClient) should be called for every blocked client,
+      even if client was killed, timed-out or disconnected. Failing to do so
+      will result in memory leaks.
+
+There are some cases where [`RedisModule_BlockClient()`](#RedisModule_BlockClient) cannot be used:
+
+1. If the client is a Lua script.
+2. If the client is executing a MULTI block.
+
+In these cases, a call to [`RedisModule_BlockClient()`](#RedisModule_BlockClient) will **not** block the
+client, but instead produce a specific error reply.
+
+A module that registers a `timeout_callback` function can also be unblocked
+using the `CLIENT UNBLOCK` command, which will trigger the timeout callback.
+If a callback function is not registered, then the blocked client will be
+treated as if it is not in a blocked state and `CLIENT UNBLOCK` will return
+a zero value.
+
+Measuring background time: By default the time spent in the blocked command
+is not account for the total command duration. To include such time you should
+use [`RedisModule_BlockedClientMeasureTimeStart()`](#RedisModule_BlockedClientMeasureTimeStart) and [`RedisModule_BlockedClientMeasureTimeEnd()`](#RedisModule_BlockedClientMeasureTimeEnd) one,
+or multiple times within the blocking command background work.
+
+<span id="RedisModule_BlockClientOnAuth"></span>
+
+### `RedisModule_BlockClientOnAuth`
+
+    RedisModuleBlockedClient *RedisModule_BlockClientOnAuth(RedisModuleCtx *ctx,
+                                                            RedisModuleAuthCallback reply_callback,
+                                                            ;
+
+**Available since:** 7.2.0
+
+Block the current client for module authentication in the background. If module auth is not in
+progress on the client, the API returns NULL. Otherwise, the client is blocked and the `RedisModule_BlockedClient`
+is returned similar to the [`RedisModule_BlockClient`](#RedisModule_BlockClient) API.
+Note: Only use this API from the context of a module auth callback.
+
+<span id="RedisModule_BlockClientGetPrivateData"></span>
+
+### `RedisModule_BlockClientGetPrivateData`
+
+    void *RedisModule_BlockClientGetPrivateData(RedisModuleBlockedClient *blocked_client);
+
+**Available since:** 7.2.0
+
+Get the private data that was previusely set on a blocked client
+
+<span id="RedisModule_BlockClientSetPrivateData"></span>
+
+### `RedisModule_BlockClientSetPrivateData`
+
+    void RedisModule_BlockClientSetPrivateData(RedisModuleBlockedClient *blocked_client,
+                                               void *private_data);
+
+**Available since:** 7.2.0
+
+Set private data on a blocked client
+
+<span id="RedisModule_BlockClientOnKeys"></span>
+
+### `RedisModule_BlockClientOnKeys`
+
+    RedisModuleBlockedClient *RedisModule_BlockClientOnKeys(RedisModuleCtx *ctx,
+                                                            RedisModuleCmdFunc reply_callback,
+                                                            ;
+
+**Available since:** 6.0.0
+
+This call is similar to [`RedisModule_BlockClient()`](#RedisModule_BlockClient), however in this case we
+don't just block the client, but also ask Redis to unblock it automatically
+once certain keys become "ready", that is, contain more data.
+
+Basically this is similar to what a typical Redis command usually does,
+like BLPOP or BZPOPMAX: the client blocks if it cannot be served ASAP,
+and later when the key receives new data (a list push for instance), the
+client is unblocked and served.
+
+However in the case of this module API, when the client is unblocked?
+
+1. If you block on a key of a type that has blocking operations associated,
+   like a list, a sorted set, a stream, and so forth, the client may be
+   unblocked once the relevant key is targeted by an operation that normally
+   unblocks the native blocking operations for that type. So if we block
+   on a list key, an RPUSH command may unblock our client and so forth.
+2. If you are implementing your native data type, or if you want to add new
+   unblocking conditions in addition to "1", you can call the modules API
+   [`RedisModule_SignalKeyAsReady()`](#RedisModule_SignalKeyAsReady).
+
+Anyway we can't be sure if the client should be unblocked just because the
+key is signaled as ready: for instance a successive operation may change the
+key, or a client in queue before this one can be served, modifying the key
+as well and making it empty again. So when a client is blocked with
+[`RedisModule_BlockClientOnKeys()`](#RedisModule_BlockClientOnKeys) the reply callback is not called after
+[`RedisModule_UnblockClient()`](#RedisModule_UnblockClient) is called, but every time a key is signaled as ready:
+if the reply callback can serve the client, it returns `REDISMODULE_OK`
+and the client is unblocked, otherwise it will return `REDISMODULE_ERR`
+and we'll try again later.
+
+The reply callback can access the key that was signaled as ready by
+calling the API [`RedisModule_GetBlockedClientReadyKey()`](#RedisModule_GetBlockedClientReadyKey), that returns
+just the string name of the key as a `RedisModuleString` object.
+
+Thanks to this system we can setup complex blocking scenarios, like
+unblocking a client only if a list contains at least 5 items or other
+more fancy logics.
+
+Note that another difference with [`RedisModule_BlockClient()`](#RedisModule_BlockClient), is that here
+we pass the private data directly when blocking the client: it will
+be accessible later in the reply callback. Normally when blocking with
+[`RedisModule_BlockClient()`](#RedisModule_BlockClient) the private data to reply to the client is
+passed when calling [`RedisModule_UnblockClient()`](#RedisModule_UnblockClient) but here the unblocking
+is performed by Redis itself, so we need to have some private data before
+hand. The private data is used to store any information about the specific
+unblocking operation that you are implementing. Such information will be
+freed using the `free_privdata` callback provided by the user.
+
+However the reply callback will be able to access the argument vector of
+the command, so the private data is often not needed.
+
+Note: Under normal circumstances [`RedisModule_UnblockClient`](#RedisModule_UnblockClient) should not be
+      called for clients that are blocked on keys (Either the key will
+      become ready or a timeout will occur). If for some reason you do want
+      to call RedisModule_UnblockClient it is possible: Client will be
+      handled as if it were timed-out (You must implement the timeout
+      callback in that case).
+
+<span id="RedisModule_BlockClientOnKeysWithFlags"></span>
+
+### `RedisModule_BlockClientOnKeysWithFlags`
+
+    RedisModuleBlockedClient *RedisModule_BlockClientOnKeysWithFlags(RedisModuleCtx *ctx,
+                                                                     RedisModuleCmdFunc reply_callback,
+                                                                     ;
+
+**Available since:** 7.2.0
+
+Same as [`RedisModule_BlockClientOnKeys`](#RedisModule_BlockClientOnKeys), but can take `REDISMODULE_BLOCK_`* flags
+Can be either `REDISMODULE_BLOCK_UNBLOCK_DEFAULT`, which means default behavior (same
+as calling [`RedisModule_BlockClientOnKeys`](#RedisModule_BlockClientOnKeys))
+
+The flags is a bit mask of these:
+
+- `REDISMODULE_BLOCK_UNBLOCK_DELETED`: The clients should to be awakened in case any of `keys` are deleted.
+                                       Mostly useful for commands that require the key to exist (like XREADGROUP)
+
+<span id="RedisModule_SignalKeyAsReady"></span>
+
+### `RedisModule_SignalKeyAsReady`
+
+    void RedisModule_SignalKeyAsReady(RedisModuleCtx *ctx, RedisModuleString *key);
+
+**Available since:** 6.0.0
+
+This function is used in order to potentially unblock a client blocked
+on keys with [`RedisModule_BlockClientOnKeys()`](#RedisModule_BlockClientOnKeys). When this function is called,
+all the clients blocked for this key will get their `reply_callback` called.
+
+<span id="RedisModule_UnblockClient"></span>
+
+### `RedisModule_UnblockClient`
+
+    int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata);
+
+**Available since:** 4.0.0
+
+Unblock a client blocked by `RedisModule_BlockedClient`. This will trigger
+the reply callbacks to be called in order to reply to the client.
+The 'privdata' argument will be accessible by the reply callback, so
+the caller of this function can pass any value that is needed in order to
+actually reply to the client.
+
+A common usage for 'privdata' is a thread that computes something that
+needs to be passed to the client, included but not limited some slow
+to compute reply or some reply obtained via networking.
+
+Note 1: this function can be called from threads spawned by the module.
+
+Note 2: when we unblock a client that is blocked for keys using the API
+[`RedisModule_BlockClientOnKeys()`](#RedisModule_BlockClientOnKeys), the privdata argument here is not used.
+Unblocking a client that was blocked for keys using this API will still
+require the client to get some reply, so the function will use the
+"timeout" handler in order to do so (The privdata provided in
+[`RedisModule_BlockClientOnKeys()`](#RedisModule_BlockClientOnKeys) is accessible from the timeout
+callback via [`RedisModule_GetBlockedClientPrivateData`](#RedisModule_GetBlockedClientPrivateData)).
+
+<span id="RedisModule_AbortBlock"></span>
+
+### `RedisModule_AbortBlock`
+
+    int RedisModule_AbortBlock(RedisModuleBlockedClient *bc);
+
+**Available since:** 4.0.0
+
+Abort a blocked client blocking operation: the client will be unblocked
+without firing any callback.
+
+<span id="RedisModule_SetDisconnectCallback"></span>
+
+### `RedisModule_SetDisconnectCallback`
+
+    void RedisModule_SetDisconnectCallback(RedisModuleBlockedClient *bc,
+                                           RedisModuleDisconnectFunc callback);
+
+**Available since:** 5.0.0
+
+Set a callback that will be called if a blocked client disconnects
+before the module has a chance to call [`RedisModule_UnblockClient()`](#RedisModule_UnblockClient)
+
+Usually what you want to do there, is to cleanup your module state
+so that you can call [`RedisModule_UnblockClient()`](#RedisModule_UnblockClient) safely, otherwise
+the client will remain blocked forever if the timeout is large.
+
+Notes:
+
+1. It is not safe to call Reply* family functions here, it is also
+   useless since the client is gone.
+
+2. This callback is not called if the client disconnects because of
+   a timeout. In such a case, the client is unblocked automatically
+   and the timeout callback is called.
+
+<span id="RedisModule_IsBlockedReplyRequest"></span>
+
+### `RedisModule_IsBlockedReplyRequest`
+
+    int RedisModule_IsBlockedReplyRequest(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Return non-zero if a module command was called in order to fill the
+reply for a blocked client.
+
+<span id="RedisModule_IsBlockedTimeoutRequest"></span>
+
+### `RedisModule_IsBlockedTimeoutRequest`
+
+    int RedisModule_IsBlockedTimeoutRequest(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Return non-zero if a module command was called in order to fill the
+reply for a blocked client that timed out.
+
+<span id="RedisModule_GetBlockedClientPrivateData"></span>
+
+### `RedisModule_GetBlockedClientPrivateData`
+
+    void *RedisModule_GetBlockedClientPrivateData(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Get the private data set by [`RedisModule_UnblockClient()`](#RedisModule_UnblockClient)
+
+<span id="RedisModule_GetBlockedClientReadyKey"></span>
+
+### `RedisModule_GetBlockedClientReadyKey`
+
+    RedisModuleString *RedisModule_GetBlockedClientReadyKey(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.0
+
+Get the key that is ready when the reply callback is called in the context
+of a client blocked by [`RedisModule_BlockClientOnKeys()`](#RedisModule_BlockClientOnKeys).
+
+<span id="RedisModule_GetBlockedClientHandle"></span>
+
+### `RedisModule_GetBlockedClientHandle`
+
+    RedisModuleBlockedClient *RedisModule_GetBlockedClientHandle(RedisModuleCtx *ctx);
+
+**Available since:** 5.0.0
+
+Get the blocked client associated with a given context.
+This is useful in the reply and timeout callbacks of blocked clients,
+before sometimes the module has the blocked client handle references
+around, and wants to cleanup it.
+
+<span id="RedisModule_BlockedClientDisconnected"></span>
+
+### `RedisModule_BlockedClientDisconnected`
+
+    int RedisModule_BlockedClientDisconnected(RedisModuleCtx *ctx);
+
+**Available since:** 5.0.0
+
+Return true if when the free callback of a blocked client is called,
+the reason for the client to be unblocked is that it disconnected
+while it was blocked.
+
+<span id="section-thread-safe-contexts"></span>
+
+## Thread Safe Contexts
+
+<span id="RedisModule_GetThreadSafeContext"></span>
+
+### `RedisModule_GetThreadSafeContext`
+
+    RedisModuleCtx *RedisModule_GetThreadSafeContext(RedisModuleBlockedClient *bc);
+
+**Available since:** 4.0.0
+
+Return a context which can be used inside threads to make Redis context
+calls with certain modules APIs. If 'bc' is not NULL then the module will
+be bound to a blocked client, and it will be possible to use the
+`RedisModule_Reply*` family of functions to accumulate a reply for when the
+client will be unblocked. Otherwise the thread safe context will be
+detached by a specific client.
+
+To call non-reply APIs, the thread safe context must be prepared with:
+
+    RedisModule_ThreadSafeContextLock(ctx);
+    ... make your call here ...
+    RedisModule_ThreadSafeContextUnlock(ctx);
+
+This is not needed when using `RedisModule_Reply*` functions, assuming
+that a blocked client was used when the context was created, otherwise
+no `RedisModule_Reply`* call should be made at all.
+
+NOTE: If you're creating a detached thread safe context (bc is NULL),
+consider using [`RedisModule_GetDetachedThreadSafeContext`](#RedisModule_GetDetachedThreadSafeContext) which will also retain
+the module ID and thus be more useful for logging.
+
+<span id="RedisModule_GetDetachedThreadSafeContext"></span>
+
+### `RedisModule_GetDetachedThreadSafeContext`
+
+    RedisModuleCtx *RedisModule_GetDetachedThreadSafeContext(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.9
+
+Return a detached thread safe context that is not associated with any
+specific blocked client, but is associated with the module's context.
+
+This is useful for modules that wish to hold a global context over
+a long term, for purposes such as logging.
+
+<span id="RedisModule_FreeThreadSafeContext"></span>
+
+### `RedisModule_FreeThreadSafeContext`
+
+    void RedisModule_FreeThreadSafeContext(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Release a thread safe context.
+
+<span id="RedisModule_ThreadSafeContextLock"></span>
+
+### `RedisModule_ThreadSafeContextLock`
+
+    void RedisModule_ThreadSafeContextLock(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Acquire the server lock before executing a thread safe API call.
+This is not needed for `RedisModule_Reply*` calls when there is
+a blocked client connected to the thread safe context.
+
+<span id="RedisModule_ThreadSafeContextTryLock"></span>
+
+### `RedisModule_ThreadSafeContextTryLock`
+
+    int RedisModule_ThreadSafeContextTryLock(RedisModuleCtx *ctx);
+
+**Available since:** 6.0.8
+
+Similar to [`RedisModule_ThreadSafeContextLock`](#RedisModule_ThreadSafeContextLock) but this function
+would not block if the server lock is already acquired.
+
+If successful (lock acquired) `REDISMODULE_OK` is returned,
+otherwise `REDISMODULE_ERR` is returned and errno is set
+accordingly.
+
+<span id="RedisModule_ThreadSafeContextUnlock"></span>
+
+### `RedisModule_ThreadSafeContextUnlock`
+
+    void RedisModule_ThreadSafeContextUnlock(RedisModuleCtx *ctx);
+
+**Available since:** 4.0.0
+
+Release the server lock after a thread safe API call was executed.
+
+<span id="section-module-keyspace-notifications-api"></span>
+
+## Module Keyspace Notifications API
+
+<span id="RedisModule_SubscribeToKeyspaceEvents"></span>
+
+### `RedisModule_SubscribeToKeyspaceEvents`
+
+    int RedisModule_SubscribeToKeyspaceEvents(RedisModuleCtx *ctx,
+                                              int types,
+                                              RedisModuleNotificationFunc callback);
+
+**Available since:** 4.0.9
+
+Subscribe to keyspace notifications. This is a low-level version of the
+keyspace-notifications API. A module can register callbacks to be notified
+when keyspace events occur.
+
+Notification events are filtered by their type (string events, set events,
+etc), and the subscriber callback receives only events that match a specific
+mask of event types.
+
+When subscribing to notifications with [`RedisModule_SubscribeToKeyspaceEvents`](#RedisModule_SubscribeToKeyspaceEvents)
+the module must provide an event type-mask, denoting the events the subscriber
+is interested in. This can be an ORed mask of any of the following flags:
+
+ - `REDISMODULE_NOTIFY_GENERIC`: Generic commands like DEL, EXPIRE, RENAME
+ - `REDISMODULE_NOTIFY_STRING`: String events
+ - `REDISMODULE_NOTIFY_LIST`: List events
+ - `REDISMODULE_NOTIFY_SET`: Set events
+ - `REDISMODULE_NOTIFY_HASH`: Hash events
+ - `REDISMODULE_NOTIFY_ZSET`: Sorted Set events
+ - `REDISMODULE_NOTIFY_EXPIRED`: Expiration events
+ - `REDISMODULE_NOTIFY_EVICTED`: Eviction events
+ - `REDISMODULE_NOTIFY_STREAM`: Stream events
+ - `REDISMODULE_NOTIFY_MODULE`: Module types events
+ - `REDISMODULE_NOTIFY_KEYMISS`: Key-miss events
+                               Notice, key-miss event is the only type
+                               of event that is fired from within a read command.
+                               Performing RedisModule_Call with a write command from within
+                               this notification is wrong and discourage. It will
+                               cause the read command that trigger the event to be
+                               replicated to the AOF/Replica.
+ - `REDISMODULE_NOTIFY_ALL`: All events (Excluding `REDISMODULE_NOTIFY_KEYMISS`)
+ - `REDISMODULE_NOTIFY_LOADED`: A special notification available only for modules,
+                              indicates that the key was loaded from persistence.
+                              Notice, when this event fires, the given key
+                              can not be retained, use RedisModule_CreateStringFromString
+                              instead.
+
+We do not distinguish between key events and keyspace events, and it is up
+to the module to filter the actions taken based on the key.
+
+The subscriber signature is:
+
+    int (*RedisModuleNotificationFunc) (RedisModuleCtx *ctx, int type,
+                                        const char *event,
+                                        RedisModuleString *key);
+
+`type` is the event type bit, that must match the mask given at registration
+time. The event string is the actual command being executed, and key is the
+relevant Redis key.
+
+Notification callback gets executed with a redis context that can not be
+used to send anything to the client, and has the db number where the event
+occurred as its selected db number.
+
+Notice that it is not necessary to enable notifications in redis.conf for
+module notifications to work.
+
+Warning: the notification callbacks are performed in a synchronous manner,
+so notification callbacks must to be fast, or they would slow Redis down.
+If you need to take long actions, use threads to offload them.
+
+Moreover, the fact that the notification is executed synchronously means
+that the notification code will be executed in the middle on Redis logic
+(commands logic, eviction, expire). Changing the key space while the logic
+runs is dangerous and discouraged. In order to react to key space events with
+write actions, please refer to [`RedisModule_AddPostNotificationJob`](#RedisModule_AddPostNotificationJob).
+
+See [https://redis.io/docs/latest/develop/use/keyspace-notifications/](https://redis.io/docs/latest/develop/use/keyspace-notifications/) for more information.
+
+<span id="RedisModule_AddPostNotificationJob"></span>
+
+### `RedisModule_AddPostNotificationJob`
+
+    int RedisModule_AddPostNotificationJob(RedisModuleCtx *ctx,
+                                           RedisModulePostNotificationJobFunc callback,
+                                           void *privdata,
+                                           void (*free_privdata)(void*));
+
+**Available since:** 7.2.0
+
+When running inside a key space notification callback, it is dangerous and highly discouraged to perform any write
+operation (See [`RedisModule_SubscribeToKeyspaceEvents`](#RedisModule_SubscribeToKeyspaceEvents)). In order to still perform write actions in this scenario,
+Redis provides [`RedisModule_AddPostNotificationJob`](#RedisModule_AddPostNotificationJob) API. The API allows to register a job callback which Redis will call
+when the following condition are promised to be fulfilled:
+1. It is safe to perform any write operation.
+2. The job will be called atomically along side the key space notification.
+
+Notice, one job might trigger key space notifications that will trigger more jobs.
+This raises a concerns of entering an infinite loops, we consider infinite loops
+as a logical bug that need to be fixed in the module, an attempt to protect against
+infinite loops by halting the execution could result in violation of the feature correctness
+and so Redis will make no attempt to protect the module from infinite loops.
+
+'`free_pd`' can be NULL and in such case will not be used.
+
+Return `REDISMODULE_OK` on success and `REDISMODULE_ERR` if was called while loading data from disk (AOF or RDB) or
+if the instance is a readonly replica.
+
+<span id="RedisModule_GetNotifyKeyspaceEvents"></span>
+
+### `RedisModule_GetNotifyKeyspaceEvents`
+
+    int RedisModule_GetNotifyKeyspaceEvents(void);
+
+**Available since:** 6.0.0
+
+Get the configured bitmap of notify-keyspace-events (Could be used
+for additional filtering in `RedisModuleNotificationFunc`)
+
+<span id="RedisModule_NotifyKeyspaceEvent"></span>
+
+### `RedisModule_NotifyKeyspaceEvent`
+
+    int RedisModule_NotifyKeyspaceEvent(RedisModuleCtx *ctx,
+                                        int type,
+                                        const char *event,
+                                        RedisModuleString *key);
+
+**Available since:** 6.0.0
+
+Expose notifyKeyspaceEvent to modules
+
+<span id="section-modules-cluster-api"></span>
+
+## Modules Cluster API
+
+<span id="RedisModule_RegisterClusterMessageReceiver"></span>
+
+### `RedisModule_RegisterClusterMessageReceiver`
+
+    void RedisModule_RegisterClusterMessageReceiver(RedisModuleCtx *ctx,
+                                                    uint8_t type,
+                                                    RedisModuleClusterMessageReceiver callback);
+
+**Available since:** 5.0.0
+
+Register a callback receiver for cluster messages of type 'type'. If there
+was already a registered callback, this will replace the callback function
+with the one provided, otherwise if the callback is set to NULL and there
+is already a callback for this function, the callback is unregistered
+(so this API call is also used in order to delete the receiver).
+
+<span id="RedisModule_SendClusterMessage"></span>
+
+### `RedisModule_SendClusterMessage`
+
+    int RedisModule_SendClusterMessage(RedisModuleCtx *ctx,
+                                       const char *target_id,
+                                       uint8_t type,
+                                       const char *msg,
+                                       uint32_t len);
+
+**Available since:** 5.0.0
+
+Send a message to all the nodes in the cluster if `target` is NULL, otherwise
+at the specified target, which is a `REDISMODULE_NODE_ID_LEN` bytes node ID, as
+returned by the receiver callback or by the nodes iteration functions.
+
+The function returns `REDISMODULE_OK` if the message was successfully sent,
+otherwise if the node is not connected or such node ID does not map to any
+known cluster node, `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_GetClusterNodesList"></span>
+
+### `RedisModule_GetClusterNodesList`
+
+    char **RedisModule_GetClusterNodesList(RedisModuleCtx *ctx, size_t *numnodes);
+
+**Available since:** 5.0.0
+
+Return an array of string pointers, each string pointer points to a cluster
+node ID of exactly `REDISMODULE_NODE_ID_LEN` bytes (without any null term).
+The number of returned node IDs is stored into `*numnodes`.
+However if this function is called by a module not running an a Redis
+instance with Redis Cluster enabled, NULL is returned instead.
+
+The IDs returned can be used with [`RedisModule_GetClusterNodeInfo()`](#RedisModule_GetClusterNodeInfo) in order
+to get more information about single node.
+
+The array returned by this function must be freed using the function
+[`RedisModule_FreeClusterNodesList()`](#RedisModule_FreeClusterNodesList).
+
+Example:
+
+    size_t count, j;
+    char **ids = RedisModule_GetClusterNodesList(ctx,&count);
+    for (j = 0; j < count; j++) {
+        RedisModule_Log(ctx,"notice","Node %.*s",
+            REDISMODULE_NODE_ID_LEN,ids[j]);
+    }
+    RedisModule_FreeClusterNodesList(ids);
+
+<span id="RedisModule_FreeClusterNodesList"></span>
+
+### `RedisModule_FreeClusterNodesList`
+
+    void RedisModule_FreeClusterNodesList(char **ids);
+
+**Available since:** 5.0.0
+
+Free the node list obtained with [`RedisModule_GetClusterNodesList`](#RedisModule_GetClusterNodesList).
+
+<span id="RedisModule_GetMyClusterID"></span>
+
+### `RedisModule_GetMyClusterID`
+
+    const char *RedisModule_GetMyClusterID(void);
+
+**Available since:** 5.0.0
+
+Return this node ID (`REDISMODULE_CLUSTER_ID_LEN` bytes) or NULL if the cluster
+is disabled.
+
+<span id="RedisModule_GetClusterSize"></span>
+
+### `RedisModule_GetClusterSize`
+
+    size_t RedisModule_GetClusterSize(void);
+
+**Available since:** 5.0.0
+
+Return the number of nodes in the cluster, regardless of their state
+(handshake, noaddress, ...) so that the number of active nodes may actually
+be smaller, but not greater than this number. If the instance is not in
+cluster mode, zero is returned.
+
+<span id="RedisModule_GetClusterNodeInfo"></span>
+
+### `RedisModule_GetClusterNodeInfo`
+
+    int RedisModule_GetClusterNodeInfo(RedisModuleCtx *ctx,
+                                       const char *id,
+                                       char *ip,
+                                       char *master_id,
+                                       int *port,
+                                       int *flags);
+
+**Available since:** 5.0.0
+
+Populate the specified info for the node having as ID the specified 'id',
+then returns `REDISMODULE_OK`. Otherwise if the format of node ID is invalid
+or the node ID does not exist from the POV of this local node, `REDISMODULE_ERR`
+is returned.
+
+The arguments `ip`, `master_id`, `port` and `flags` can be NULL in case we don't
+need to populate back certain info. If an `ip` and `master_id` (only populated
+if the instance is a slave) are specified, they point to buffers holding
+at least `REDISMODULE_NODE_ID_LEN` bytes. The strings written back as `ip`
+and `master_id` are not null terminated.
+
+The list of flags reported is the following:
+
+* `REDISMODULE_NODE_MYSELF`:       This node
+* `REDISMODULE_NODE_MASTER`:       The node is a master
+* `REDISMODULE_NODE_SLAVE`:        The node is a replica
+* `REDISMODULE_NODE_PFAIL`:        We see the node as failing
+* `REDISMODULE_NODE_FAIL`:         The cluster agrees the node is failing
+* `REDISMODULE_NODE_NOFAILOVER`:   The slave is configured to never failover
+
+<span id="RedisModule_SetClusterFlags"></span>
+
+### `RedisModule_SetClusterFlags`
+
+    void RedisModule_SetClusterFlags(RedisModuleCtx *ctx, uint64_t flags);
+
+**Available since:** 5.0.0
+
+Set Redis Cluster flags in order to change the normal behavior of
+Redis Cluster, especially with the goal of disabling certain functions.
+This is useful for modules that use the Cluster API in order to create
+a different distributed system, but still want to use the Redis Cluster
+message bus. Flags that can be set:
+
+* `CLUSTER_MODULE_FLAG_NO_FAILOVER`
+* `CLUSTER_MODULE_FLAG_NO_REDIRECTION`
+
+With the following effects:
+
+* `NO_FAILOVER`: prevent Redis Cluster slaves from failing over a dead master.
+               Also disables the replica migration feature.
+
+* `NO_REDIRECTION`: Every node will accept any key, without trying to perform
+                  partitioning according to the Redis Cluster algorithm.
+                  Slots information will still be propagated across the
+                  cluster, but without effect.
+
+<span id="RedisModule_ClusterKeySlot"></span>
+
+### `RedisModule_ClusterKeySlot`
+
+    unsigned int RedisModule_ClusterKeySlot(RedisModuleString *key);
+
+**Available since:** 7.4.0
+
+Returns the cluster slot of a key, similar to the `CLUSTER KEYSLOT` command.
+This function works even if cluster mode is not enabled.
+
+<span id="RedisModule_ClusterCanonicalKeyNameInSlot"></span>
+
+### `RedisModule_ClusterCanonicalKeyNameInSlot`
+
+    const char *RedisModule_ClusterCanonicalKeyNameInSlot(unsigned int slot);
+
+**Available since:** 7.4.0
+
+Returns a short string that can be used as a key or as a hash tag in a key,
+such that the key maps to the given cluster slot. Returns NULL if slot is not
+a valid slot.
+
+<span id="section-modules-timers-api"></span>
+
+## Modules Timers API
+
+Module timers are a high precision "green timers" abstraction where
+every module can register even millions of timers without problems, even if
+the actual event loop will just have a single timer that is used to awake the
+module timers subsystem in order to process the next event.
+
+All the timers are stored into a radix tree, ordered by expire time, when
+the main Redis event loop timer callback is called, we try to process all
+the timers already expired one after the other. Then we re-enter the event
+loop registering a timer that will expire when the next to process module
+timer will expire.
+
+Every time the list of active timers drops to zero, we unregister the
+main event loop timer, so that there is no overhead when such feature is
+not used.
+
+<span id="RedisModule_CreateTimer"></span>
+
+### `RedisModule_CreateTimer`
+
+    RedisModuleTimerID RedisModule_CreateTimer(RedisModuleCtx *ctx,
+                                               mstime_t period,
+                                               RedisModuleTimerProc callback,
+                                               void *data);
+
+**Available since:** 5.0.0
+
+Create a new timer that will fire after `period` milliseconds, and will call
+the specified function using `data` as argument. The returned timer ID can be
+used to get information from the timer or to stop it before it fires.
+Note that for the common use case of a repeating timer (Re-registration
+of the timer inside the `RedisModuleTimerProc` callback) it matters when
+this API is called:
+If it is called at the beginning of 'callback' it means
+the event will triggered every 'period'.
+If it is called at the end of 'callback' it means
+there will 'period' milliseconds gaps between events.
+(If the time it takes to execute 'callback' is negligible the two
+statements above mean the same)
+
+<span id="RedisModule_StopTimer"></span>
+
+### `RedisModule_StopTimer`
+
+    int RedisModule_StopTimer(RedisModuleCtx *ctx,
+                              RedisModuleTimerID id,
+                              void **data);
+
+**Available since:** 5.0.0
+
+Stop a timer, returns `REDISMODULE_OK` if the timer was found, belonged to the
+calling module, and was stopped, otherwise `REDISMODULE_ERR` is returned.
+If not NULL, the data pointer is set to the value of the data argument when
+the timer was created.
+
+<span id="RedisModule_GetTimerInfo"></span>
+
+### `RedisModule_GetTimerInfo`
+
+    int RedisModule_GetTimerInfo(RedisModuleCtx *ctx,
+                                 RedisModuleTimerID id,
+                                 uint64_t *remaining,
+                                 void **data);
+
+**Available since:** 5.0.0
+
+Obtain information about a timer: its remaining time before firing
+(in milliseconds), and the private data pointer associated with the timer.
+If the timer specified does not exist or belongs to a different module
+no information is returned and the function returns `REDISMODULE_ERR`, otherwise
+`REDISMODULE_OK` is returned. The arguments remaining or data can be NULL if
+the caller does not need certain information.
+
+<span id="section-modules-eventloop-api"></span>
+
+## Modules EventLoop API
+
+<span id="RedisModule_EventLoopAdd"></span>
+
+### `RedisModule_EventLoopAdd`
+
+    int RedisModule_EventLoopAdd(int fd,
+                                 int mask,
+                                 RedisModuleEventLoopFunc func,
+                                 void *user_data);
+
+**Available since:** 7.0.0
+
+Add a pipe / socket event to the event loop.
+
+* `mask` must be one of the following values:
+
+    * `REDISMODULE_EVENTLOOP_READABLE`
+    * `REDISMODULE_EVENTLOOP_WRITABLE`
+    * `REDISMODULE_EVENTLOOP_READABLE | REDISMODULE_EVENTLOOP_WRITABLE`
+
+On success `REDISMODULE_OK` is returned, otherwise
+`REDISMODULE_ERR` is returned and errno is set to the following values:
+
+* ERANGE: `fd` is negative or higher than `maxclients` Redis config.
+* EINVAL: `callback` is NULL or `mask` value is invalid.
+
+`errno` might take other values in case of an internal error.
+
+Example:
+
+    void onReadable(int fd, void *user_data, int mask) {
+        char buf[32];
+        int bytes = read(fd,buf,sizeof(buf));
+        printf("Read %d bytes \n", bytes);
+    }
+    RedisModule_EventLoopAdd(fd, REDISMODULE_EVENTLOOP_READABLE, onReadable, NULL);
+
+<span id="RedisModule_EventLoopDel"></span>
+
+### `RedisModule_EventLoopDel`
+
+    int RedisModule_EventLoopDel(int fd, int mask);
+
+**Available since:** 7.0.0
+
+Delete a pipe / socket event from the event loop.
+
+* `mask` must be one of the following values:
+
+    * `REDISMODULE_EVENTLOOP_READABLE`
+    * `REDISMODULE_EVENTLOOP_WRITABLE`
+    * `REDISMODULE_EVENTLOOP_READABLE | REDISMODULE_EVENTLOOP_WRITABLE`
+
+On success `REDISMODULE_OK` is returned, otherwise
+`REDISMODULE_ERR` is returned and errno is set to the following values:
+
+* ERANGE: `fd` is negative or higher than `maxclients` Redis config.
+* EINVAL: `mask` value is invalid.
+
+<span id="RedisModule_EventLoopAddOneShot"></span>
+
+### `RedisModule_EventLoopAddOneShot`
+
+    int RedisModule_EventLoopAddOneShot(RedisModuleEventLoopOneShotFunc func,
+                                        void *user_data);
+
+**Available since:** 7.0.0
+
+This function can be called from other threads to trigger callback on Redis
+main thread. On success `REDISMODULE_OK` is returned. If `func` is NULL
+`REDISMODULE_ERR` is returned and errno is set to EINVAL.
+
+<span id="section-modules-acl-api"></span>
+
+## Modules ACL API
+
+Implements a hook into the authentication and authorization within Redis.
+
+<span id="RedisModule_CreateModuleUser"></span>
+
+### `RedisModule_CreateModuleUser`
+
+    RedisModuleUser *RedisModule_CreateModuleUser(const char *name);
+
+**Available since:** 6.0.0
+
+Creates a Redis ACL user that the module can use to authenticate a client.
+After obtaining the user, the module should set what such user can do
+using the `RedisModule_SetUserACL()` function. Once configured, the user
+can be used in order to authenticate a connection, with the specified
+ACL rules, using the `RedisModule_AuthClientWithUser()` function.
+
+Note that:
+
+* Users created here are not listed by the ACL command.
+* Users created here are not checked for duplicated name, so it's up to
+  the module calling this function to take care of not creating users
+  with the same name.
+* The created user can be used to authenticate multiple Redis connections.
+
+The caller can later free the user using the function
+[`RedisModule_FreeModuleUser()`](#RedisModule_FreeModuleUser). When this function is called, if there are
+still clients authenticated with this user, they are disconnected.
+The function to free the user should only be used when the caller really
+wants to invalidate the user to define a new one with different
+capabilities.
+
+<span id="RedisModule_FreeModuleUser"></span>
+
+### `RedisModule_FreeModuleUser`
+
+    int RedisModule_FreeModuleUser(RedisModuleUser *user);
+
+**Available since:** 6.0.0
+
+Frees a given user and disconnects all of the clients that have been
+authenticated with it. See [`RedisModule_CreateModuleUser`](#RedisModule_CreateModuleUser) for detailed usage.
+
+<span id="RedisModule_SetModuleUserACL"></span>
+
+### `RedisModule_SetModuleUserACL`
+
+    int RedisModule_SetModuleUserACL(RedisModuleUser *user, const char* acl);
+
+**Available since:** 6.0.0
+
+Sets the permissions of a user created through the redis module
+interface. The syntax is the same as ACL SETUSER, so refer to the
+documentation in acl.c for more information. See [`RedisModule_CreateModuleUser`](#RedisModule_CreateModuleUser)
+for detailed usage.
+
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` on failure
+and will set an errno describing why the operation failed.
+
+<span id="RedisModule_SetModuleUserACLString"></span>
+
+### `RedisModule_SetModuleUserACLString`
+
+    int RedisModule_SetModuleUserACLString(RedisModuleCtx *ctx,
+                                           RedisModuleUser *user,
+                                           const char *acl,
+                                           RedisModuleString **error);
+
+**Available since:** 7.0.6
+
+Sets the permission of a user with a complete ACL string, such as one
+would use on the redis ACL SETUSER command line API. This differs from
+[`RedisModule_SetModuleUserACL`](#RedisModule_SetModuleUserACL), which only takes single ACL operations at a time.
+
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` on failure
+if a `RedisModuleString` is provided in error, a string describing the error
+will be returned
+
+<span id="RedisModule_GetModuleUserACLString"></span>
+
+### `RedisModule_GetModuleUserACLString`
+
+    RedisModuleString *RedisModule_GetModuleUserACLString(RedisModuleUser *user);
+
+**Available since:** 7.0.6
+
+Get the ACL string for a given user
+Returns a `RedisModuleString`
+
+<span id="RedisModule_GetCurrentUserName"></span>
+
+### `RedisModule_GetCurrentUserName`
+
+    RedisModuleString *RedisModule_GetCurrentUserName(RedisModuleCtx *ctx);
+
+**Available since:** 7.0.0
+
+Retrieve the user name of the client connection behind the current context.
+The user name can be used later, in order to get a `RedisModuleUser`.
+See more information in [`RedisModule_GetModuleUserFromUserName`](#RedisModule_GetModuleUserFromUserName).
+
+The returned string must be released with [`RedisModule_FreeString()`](#RedisModule_FreeString) or by
+enabling automatic memory management.
+
+<span id="RedisModule_GetModuleUserFromUserName"></span>
+
+### `RedisModule_GetModuleUserFromUserName`
+
+    RedisModuleUser *RedisModule_GetModuleUserFromUserName(RedisModuleString *name);
+
+**Available since:** 7.0.0
+
+A `RedisModuleUser` can be used to check if command, key or channel can be executed or
+accessed according to the ACLs rules associated with that user.
+When a Module wants to do ACL checks on a general ACL user (not created by [`RedisModule_CreateModuleUser`](#RedisModule_CreateModuleUser)),
+it can get the `RedisModuleUser` from this API, based on the user name retrieved by [`RedisModule_GetCurrentUserName`](#RedisModule_GetCurrentUserName).
+
+Since a general ACL user can be deleted at any time, this `RedisModuleUser` should be used only in the context
+where this function was called. In order to do ACL checks out of that context, the Module can store the user name,
+and call this API at any other context.
+
+Returns NULL if the user is disabled or the user does not exist.
+The caller should later free the user using the function [`RedisModule_FreeModuleUser()`](#RedisModule_FreeModuleUser).
+
+<span id="RedisModule_ACLCheckCommandPermissions"></span>
+
+### `RedisModule_ACLCheckCommandPermissions`
+
+    int RedisModule_ACLCheckCommandPermissions(RedisModuleUser *user,
+                                               RedisModuleString **argv,
+                                               int argc);
+
+**Available since:** 7.0.0
+
+Checks if the command can be executed by the user, according to the ACLs associated with it.
+
+On success a `REDISMODULE_OK` is returned, otherwise
+`REDISMODULE_ERR` is returned and errno is set to the following values:
+
+* ENOENT: Specified command does not exist.
+* EACCES: Command cannot be executed, according to ACL rules
+
+<span id="RedisModule_ACLCheckKeyPermissions"></span>
+
+### `RedisModule_ACLCheckKeyPermissions`
+
+    int RedisModule_ACLCheckKeyPermissions(RedisModuleUser *user,
+                                           RedisModuleString *key,
+                                           int flags);
+
+**Available since:** 7.0.0
+
+Check if the key can be accessed by the user according to the ACLs attached to the user
+and the flags representing the key access. The flags are the same that are used in the
+keyspec for logical operations. These flags are documented in [`RedisModule_SetCommandInfo`](#RedisModule_SetCommandInfo) as
+the `REDISMODULE_CMD_KEY_ACCESS`, `REDISMODULE_CMD_KEY_UPDATE`, `REDISMODULE_CMD_KEY_INSERT`,
+and `REDISMODULE_CMD_KEY_DELETE` flags.
+
+If no flags are supplied, the user is still required to have some access to the key for
+this command to return successfully.
+
+If the user is able to access the key then `REDISMODULE_OK` is returned, otherwise
+`REDISMODULE_ERR` is returned and errno is set to one of the following values:
+
+* EINVAL: The provided flags are invalid.
+* EACCESS: The user does not have permission to access the key.
+
+<span id="RedisModule_ACLCheckKeyPrefixPermissions"></span>
+
+### `RedisModule_ACLCheckKeyPrefixPermissions`
+
+    int RedisModule_ACLCheckKeyPrefixPermissions(RedisModuleUser *user,
+                                                 RedisModuleString *prefix,
+                                                 int flags);
+
+**Available since:** unreleased
+
+Check if the user can access keys matching the given key prefix according to the ACLs 
+attached to the user and the flags representing key access. The flags are the same that 
+are used in the keyspec for logical operations. These flags are documented in 
+[`RedisModule_SetCommandInfo`](#RedisModule_SetCommandInfo) as the `REDISMODULE_CMD_KEY_ACCESS`, 
+`REDISMODULE_CMD_KEY_UPDATE`, `REDISMODULE_CMD_KEY_INSERT`, and `REDISMODULE_CMD_KEY_DELETE` flags.
+
+If no flags are supplied, the user is still required to have some access to keys matching 
+the prefix for this command to return successfully.
+
+If the user is able to access keys matching the prefix, then `REDISMODULE_OK` is returned.
+Otherwise, `REDISMODULE_ERR` is returned and errno is set to one of the following values:
+
+* EINVAL: The provided flags are invalid.
+* EACCES: The user does not have permission to access keys matching the prefix.
+
+<span id="RedisModule_ACLCheckChannelPermissions"></span>
+
+### `RedisModule_ACLCheckChannelPermissions`
+
+    int RedisModule_ACLCheckChannelPermissions(RedisModuleUser *user,
+                                               RedisModuleString *ch,
+                                               int flags);
+
+**Available since:** 7.0.0
+
+Check if the pubsub channel can be accessed by the user based off of the given
+access flags. See [`RedisModule_ChannelAtPosWithFlags`](#RedisModule_ChannelAtPosWithFlags) for more information about the
+possible flags that can be passed in.
+
+If the user is able to access the pubsub channel then `REDISMODULE_OK` is returned, otherwise
+`REDISMODULE_ERR` is returned and errno is set to one of the following values:
+
+* EINVAL: The provided flags are invalid.
+* EACCESS: The user does not have permission to access the pubsub channel.
+
+<span id="RedisModule_ACLAddLogEntry"></span>
+
+### `RedisModule_ACLAddLogEntry`
+
+    int RedisModule_ACLAddLogEntry(RedisModuleCtx *ctx,
+                                   RedisModuleUser *user,
+                                   RedisModuleString *object,
+                                   RedisModuleACLLogEntryReason reason);
+
+**Available since:** 7.0.0
+
+Adds a new entry in the ACL log.
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` on error.
+
+For more information about ACL log, please refer to [https://redis.io/commands/acl-log](https://redis.io/commands/acl-log)
+
+<span id="RedisModule_ACLAddLogEntryByUserName"></span>
+
+### `RedisModule_ACLAddLogEntryByUserName`
+
+    int RedisModule_ACLAddLogEntryByUserName(RedisModuleCtx *ctx,
+                                             RedisModuleString *username,
+                                             RedisModuleString *object,
+                                             RedisModuleACLLogEntryReason reason);
+
+**Available since:** 7.2.0
+
+Adds a new entry in the ACL log with the `username` `RedisModuleString` provided.
+Returns `REDISMODULE_OK` on success and `REDISMODULE_ERR` on error.
+
+For more information about ACL log, please refer to [https://redis.io/commands/acl-log](https://redis.io/commands/acl-log)
+
+<span id="RedisModule_AuthenticateClientWithUser"></span>
+
+### `RedisModule_AuthenticateClientWithUser`
+
+    int RedisModule_AuthenticateClientWithUser(RedisModuleCtx *ctx,
+                                               RedisModuleUser *module_user,
+                                               RedisModuleUserChangedFunc callback,
+                                               void *privdata,
+                                               uint64_t *client_id);
+
+**Available since:** 6.0.0
+
+Authenticate the current context's user with the provided redis acl user.
+Returns `REDISMODULE_ERR` if the user is disabled.
+
+See authenticateClientWithUser for information about callback, `client_id`,
+and general usage for authentication.
+
+<span id="RedisModule_AuthenticateClientWithACLUser"></span>
+
+### `RedisModule_AuthenticateClientWithACLUser`
+
+    int RedisModule_AuthenticateClientWithACLUser(RedisModuleCtx *ctx,
+                                                  const char *name,
+                                                  size_t len,
+                                                  RedisModuleUserChangedFunc callback,
+                                                  void *privdata,
+                                                  uint64_t *client_id);
+
+**Available since:** 6.0.0
+
+Authenticate the current context's user with the provided redis acl user.
+Returns `REDISMODULE_ERR` if the user is disabled or the user does not exist.
+
+See authenticateClientWithUser for information about callback, `client_id`,
+and general usage for authentication.
+
+<span id="RedisModule_DeauthenticateAndCloseClient"></span>
+
+### `RedisModule_DeauthenticateAndCloseClient`
+
+    int RedisModule_DeauthenticateAndCloseClient(RedisModuleCtx *ctx,
+                                                 uint64_t client_id);
+
+**Available since:** 6.0.0
+
+Deauthenticate and close the client. The client resources will not be
+immediately freed, but will be cleaned up in a background job. This is
+the recommended way to deauthenticate a client since most clients can't
+handle users becoming deauthenticated. Returns `REDISMODULE_ERR` when the
+client doesn't exist and `REDISMODULE_OK` when the operation was successful.
+
+The client ID is returned from the [`RedisModule_AuthenticateClientWithUser`](#RedisModule_AuthenticateClientWithUser) and
+[`RedisModule_AuthenticateClientWithACLUser`](#RedisModule_AuthenticateClientWithACLUser) APIs, but can be obtained through
+the CLIENT api or through server events.
+
+This function is not thread safe, and must be executed within the context
+of a command or thread safe context.
+
+<span id="RedisModule_RedactClientCommandArgument"></span>
+
+### `RedisModule_RedactClientCommandArgument`
+
+    int RedisModule_RedactClientCommandArgument(RedisModuleCtx *ctx, int pos);
+
+**Available since:** 7.0.0
+
+Redact the client command argument specified at the given position. Redacted arguments 
+are obfuscated in user facing commands such as SLOWLOG or MONITOR, as well as
+never being written to server logs. This command may be called multiple times on the
+same position.
+
+Note that the command name, position 0, can not be redacted. 
+
+Returns `REDISMODULE_OK` if the argument was redacted and `REDISMODULE_ERR` if there 
+was an invalid parameter passed in or the position is outside the client 
+argument range.
+
+<span id="RedisModule_GetClientCertificate"></span>
+
+### `RedisModule_GetClientCertificate`
+
+    RedisModuleString *RedisModule_GetClientCertificate(RedisModuleCtx *ctx,
+                                                        uint64_t client_id);
+
+**Available since:** 6.0.9
+
+Return the X.509 client-side certificate used by the client to authenticate
+this connection.
+
+The return value is an allocated `RedisModuleString` that is a X.509 certificate
+encoded in PEM (Base64) format. It should be freed (or auto-freed) by the caller.
+
+A NULL value is returned in the following conditions:
+
+- Connection ID does not exist
+- Connection is not a TLS connection
+- Connection is a TLS connection but no client certificate was used
+
+<span id="section-modules-dictionary-api"></span>
+
+## Modules Dictionary API
+
+Implements a sorted dictionary (actually backed by a radix tree) with
+the usual get / set / del / num-items API, together with an iterator
+capable of going back and forth.
+
+<span id="RedisModule_CreateDict"></span>
+
+### `RedisModule_CreateDict`
+
+    RedisModuleDict *RedisModule_CreateDict(RedisModuleCtx *ctx);
+
+**Available since:** 5.0.0
+
+Create a new dictionary. The 'ctx' pointer can be the current module context
+or NULL, depending on what you want. Please follow the following rules:
+
+1. Use a NULL context if you plan to retain a reference to this dictionary
+   that will survive the time of the module callback where you created it.
+2. Use a NULL context if no context is available at the time you are creating
+   the dictionary (of course...).
+3. However use the current callback context as 'ctx' argument if the
+   dictionary time to live is just limited to the callback scope. In this
+   case, if enabled, you can enjoy the automatic memory management that will
+   reclaim the dictionary memory, as well as the strings returned by the
+   Next / Prev dictionary iterator calls.
+
+<span id="RedisModule_FreeDict"></span>
+
+### `RedisModule_FreeDict`
+
+    void RedisModule_FreeDict(RedisModuleCtx *ctx, RedisModuleDict *d);
+
+**Available since:** 5.0.0
+
+Free a dictionary created with [`RedisModule_CreateDict()`](#RedisModule_CreateDict). You need to pass the
+context pointer 'ctx' only if the dictionary was created using the
+context instead of passing NULL.
+
+<span id="RedisModule_DictSize"></span>
+
+### `RedisModule_DictSize`
+
+    uint64_t RedisModule_DictSize(RedisModuleDict *d);
+
+**Available since:** 5.0.0
+
+Return the size of the dictionary (number of keys).
+
+<span id="RedisModule_DictSetC"></span>
+
+### `RedisModule_DictSetC`
+
+    int RedisModule_DictSetC(RedisModuleDict *d,
+                             void *key,
+                             size_t keylen,
+                             void *ptr);
+
+**Available since:** 5.0.0
+
+Store the specified key into the dictionary, setting its value to the
+pointer 'ptr'. If the key was added with success, since it did not
+already exist, `REDISMODULE_OK` is returned. Otherwise if the key already
+exists the function returns `REDISMODULE_ERR`.
+
+<span id="RedisModule_DictReplaceC"></span>
+
+### `RedisModule_DictReplaceC`
+
+    int RedisModule_DictReplaceC(RedisModuleDict *d,
+                                 void *key,
+                                 size_t keylen,
+                                 void *ptr);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictSetC()`](#RedisModule_DictSetC) but will replace the key with the new
+value if the key already exists.
+
+<span id="RedisModule_DictSet"></span>
+
+### `RedisModule_DictSet`
+
+    int RedisModule_DictSet(RedisModuleDict *d, RedisModuleString *key, void *ptr);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictSetC()`](#RedisModule_DictSetC) but takes the key as a `RedisModuleString`.
+
+<span id="RedisModule_DictReplace"></span>
+
+### `RedisModule_DictReplace`
+
+    int RedisModule_DictReplace(RedisModuleDict *d,
+                                RedisModuleString *key,
+                                void *ptr);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictReplaceC()`](#RedisModule_DictReplaceC) but takes the key as a `RedisModuleString`.
+
+<span id="RedisModule_DictGetC"></span>
+
+### `RedisModule_DictGetC`
+
+    void *RedisModule_DictGetC(RedisModuleDict *d,
+                               void *key,
+                               size_t keylen,
+                               int *nokey);
+
+**Available since:** 5.0.0
+
+Return the value stored at the specified key. The function returns NULL
+both in the case the key does not exist, or if you actually stored
+NULL at key. So, optionally, if the 'nokey' pointer is not NULL, it will
+be set by reference to 1 if the key does not exist, or to 0 if the key
+exists.
+
+<span id="RedisModule_DictGet"></span>
+
+### `RedisModule_DictGet`
+
+    void *RedisModule_DictGet(RedisModuleDict *d,
+                              RedisModuleString *key,
+                              int *nokey);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictGetC()`](#RedisModule_DictGetC) but takes the key as a `RedisModuleString`.
+
+<span id="RedisModule_DictDelC"></span>
+
+### `RedisModule_DictDelC`
+
+    int RedisModule_DictDelC(RedisModuleDict *d,
+                             void *key,
+                             size_t keylen,
+                             void *oldval);
+
+**Available since:** 5.0.0
+
+Remove the specified key from the dictionary, returning `REDISMODULE_OK` if
+the key was found and deleted, or `REDISMODULE_ERR` if instead there was
+no such key in the dictionary. When the operation is successful, if
+'oldval' is not NULL, then '*oldval' is set to the value stored at the
+key before it was deleted. Using this feature it is possible to get
+a pointer to the value (for instance in order to release it), without
+having to call [`RedisModule_DictGet()`](#RedisModule_DictGet) before deleting the key.
+
+<span id="RedisModule_DictDel"></span>
+
+### `RedisModule_DictDel`
+
+    int RedisModule_DictDel(RedisModuleDict *d,
+                            RedisModuleString *key,
+                            void *oldval);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictDelC()`](#RedisModule_DictDelC) but gets the key as a `RedisModuleString`.
+
+<span id="RedisModule_DictIteratorStartC"></span>
+
+### `RedisModule_DictIteratorStartC`
+
+    RedisModuleDictIter *RedisModule_DictIteratorStartC(RedisModuleDict *d,
+                                                        const char *op,
+                                                        void *key,
+                                                        size_t keylen);
+
+**Available since:** 5.0.0
+
+Return an iterator, setup in order to start iterating from the specified
+key by applying the operator 'op', which is just a string specifying the
+comparison operator to use in order to seek the first element. The
+operators available are:
+
+* `^`   – Seek the first (lexicographically smaller) key.
+* `$`   – Seek the last  (lexicographically bigger) key.
+* `>`   – Seek the first element greater than the specified key.
+* `>=`  – Seek the first element greater or equal than the specified key.
+* `<`   – Seek the first element smaller than the specified key.
+* `<=`  – Seek the first element smaller or equal than the specified key.
+* `==`  – Seek the first element matching exactly the specified key.
+
+Note that for `^` and `$` the passed key is not used, and the user may
+just pass NULL with a length of 0.
+
+If the element to start the iteration cannot be seeked based on the
+key and operator passed, [`RedisModule_DictNext()`](#RedisModule_DictNext) / Prev() will just return
+`REDISMODULE_ERR` at the first call, otherwise they'll produce elements.
+
+<span id="RedisModule_DictIteratorStart"></span>
+
+### `RedisModule_DictIteratorStart`
+
+    RedisModuleDictIter *RedisModule_DictIteratorStart(RedisModuleDict *d,
+                                                       const char *op,
+                                                       RedisModuleString *key);
+
+**Available since:** 5.0.0
+
+Exactly like [`RedisModule_DictIteratorStartC`](#RedisModule_DictIteratorStartC), but the key is passed as a
+`RedisModuleString`.
+
+<span id="RedisModule_DictIteratorStop"></span>
+
+### `RedisModule_DictIteratorStop`
+
+    void RedisModule_DictIteratorStop(RedisModuleDictIter *di);
+
+**Available since:** 5.0.0
+
+Release the iterator created with [`RedisModule_DictIteratorStart()`](#RedisModule_DictIteratorStart). This call
+is mandatory otherwise a memory leak is introduced in the module.
+
+<span id="RedisModule_DictIteratorReseekC"></span>
+
+### `RedisModule_DictIteratorReseekC`
+
+    int RedisModule_DictIteratorReseekC(RedisModuleDictIter *di,
+                                        const char *op,
+                                        void *key,
+                                        size_t keylen);
+
+**Available since:** 5.0.0
+
+After its creation with [`RedisModule_DictIteratorStart()`](#RedisModule_DictIteratorStart), it is possible to
+change the currently selected element of the iterator by using this
+API call. The result based on the operator and key is exactly like
+the function [`RedisModule_DictIteratorStart()`](#RedisModule_DictIteratorStart), however in this case the
+return value is just `REDISMODULE_OK` in case the seeked element was found,
+or `REDISMODULE_ERR` in case it was not possible to seek the specified
+element. It is possible to reseek an iterator as many times as you want.
+
+<span id="RedisModule_DictIteratorReseek"></span>
+
+### `RedisModule_DictIteratorReseek`
+
+    int RedisModule_DictIteratorReseek(RedisModuleDictIter *di,
+                                       const char *op,
+                                       RedisModuleString *key);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictIteratorReseekC()`](#RedisModule_DictIteratorReseekC) but takes the key as a
+`RedisModuleString`.
+
+<span id="RedisModule_DictNextC"></span>
+
+### `RedisModule_DictNextC`
+
+    void *RedisModule_DictNextC(RedisModuleDictIter *di,
+                                size_t *keylen,
+                                void **dataptr);
+
+**Available since:** 5.0.0
+
+Return the current item of the dictionary iterator `di` and steps to the
+next element. If the iterator already yield the last element and there
+are no other elements to return, NULL is returned, otherwise a pointer
+to a string representing the key is provided, and the `*keylen` length
+is set by reference (if keylen is not NULL). The `*dataptr`, if not NULL
+is set to the value of the pointer stored at the returned key as auxiliary
+data (as set by the [`RedisModule_DictSet`](#RedisModule_DictSet) API).
+
+Usage example:
+
+     ... create the iterator here ...
+     char *key;
+     void *data;
+     while((key = RedisModule_DictNextC(iter,&keylen,&data)) != NULL) {
+         printf("%.*s %p\n", (int)keylen, key, data);
+     }
+
+The returned pointer is of type void because sometimes it makes sense
+to cast it to a `char*` sometimes to an unsigned `char*` depending on the
+fact it contains or not binary data, so this API ends being more
+comfortable to use.
+
+The validity of the returned pointer is until the next call to the
+next/prev iterator step. Also the pointer is no longer valid once the
+iterator is released.
+
+<span id="RedisModule_DictPrevC"></span>
+
+### `RedisModule_DictPrevC`
+
+    void *RedisModule_DictPrevC(RedisModuleDictIter *di,
+                                size_t *keylen,
+                                void **dataptr);
+
+**Available since:** 5.0.0
+
+This function is exactly like [`RedisModule_DictNext()`](#RedisModule_DictNext) but after returning
+the currently selected element in the iterator, it selects the previous
+element (lexicographically smaller) instead of the next one.
+
+<span id="RedisModule_DictNext"></span>
+
+### `RedisModule_DictNext`
+
+    RedisModuleString *RedisModule_DictNext(RedisModuleCtx *ctx,
+                                            RedisModuleDictIter *di,
+                                            void **dataptr);
+
+**Available since:** 5.0.0
+
+Like `RedisModuleNextC()`, but instead of returning an internally allocated
+buffer and key length, it returns directly a module string object allocated
+in the specified context 'ctx' (that may be NULL exactly like for the main
+API [`RedisModule_CreateString`](#RedisModule_CreateString)).
+
+The returned string object should be deallocated after use, either manually
+or by using a context that has automatic memory management active.
+
+<span id="RedisModule_DictPrev"></span>
+
+### `RedisModule_DictPrev`
+
+    RedisModuleString *RedisModule_DictPrev(RedisModuleCtx *ctx,
+                                            RedisModuleDictIter *di,
+                                            void **dataptr);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictNext()`](#RedisModule_DictNext) but after returning the currently selected
+element in the iterator, it selects the previous element (lexicographically
+smaller) instead of the next one.
+
+<span id="RedisModule_DictCompareC"></span>
+
+### `RedisModule_DictCompareC`
+
+    int RedisModule_DictCompareC(RedisModuleDictIter *di,
+                                 const char *op,
+                                 void *key,
+                                 size_t keylen);
+
+**Available since:** 5.0.0
+
+Compare the element currently pointed by the iterator to the specified
+element given by key/keylen, according to the operator 'op' (the set of
+valid operators are the same valid for [`RedisModule_DictIteratorStart`](#RedisModule_DictIteratorStart)).
+If the comparison is successful the command returns `REDISMODULE_OK`
+otherwise `REDISMODULE_ERR` is returned.
+
+This is useful when we want to just emit a lexicographical range, so
+in the loop, as we iterate elements, we can also check if we are still
+on range.
+
+The function return `REDISMODULE_ERR` if the iterator reached the
+end of elements condition as well.
+
+<span id="RedisModule_DictCompare"></span>
+
+### `RedisModule_DictCompare`
+
+    int RedisModule_DictCompare(RedisModuleDictIter *di,
+                                const char *op,
+                                RedisModuleString *key);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_DictCompareC`](#RedisModule_DictCompareC) but gets the key to compare with the current
+iterator key as a `RedisModuleString`.
+
+<span id="section-modules-info-fields"></span>
+
+## Modules Info fields
+
+<span id="RedisModule_InfoAddSection"></span>
+
+### `RedisModule_InfoAddSection`
+
+    int RedisModule_InfoAddSection(RedisModuleInfoCtx *ctx, const char *name);
+
+**Available since:** 6.0.0
+
+Used to start a new section, before adding any fields. the section name will
+be prefixed by `<modulename>_` and must only include A-Z,a-z,0-9.
+NULL or empty string indicates the default section (only `<modulename>`) is used.
+When return value is `REDISMODULE_ERR`, the section should and will be skipped.
+
+<span id="RedisModule_InfoBeginDictField"></span>
+
+### `RedisModule_InfoBeginDictField`
+
+    int RedisModule_InfoBeginDictField(RedisModuleInfoCtx *ctx, const char *name);
+
+**Available since:** 6.0.0
+
+Starts a dict field, similar to the ones in INFO KEYSPACE. Use normal
+`RedisModule_InfoAddField`* functions to add the items to this field, and
+terminate with [`RedisModule_InfoEndDictField`](#RedisModule_InfoEndDictField).
+
+<span id="RedisModule_InfoEndDictField"></span>
+
+### `RedisModule_InfoEndDictField`
+
+    int RedisModule_InfoEndDictField(RedisModuleInfoCtx *ctx);
+
+**Available since:** 6.0.0
+
+Ends a dict field, see [`RedisModule_InfoBeginDictField`](#RedisModule_InfoBeginDictField)
+
+<span id="RedisModule_InfoAddFieldString"></span>
+
+### `RedisModule_InfoAddFieldString`
+
+    int RedisModule_InfoAddFieldString(RedisModuleInfoCtx *ctx,
+                                       const char *field,
+                                       RedisModuleString *value);
+
+**Available since:** 6.0.0
+
+Used by `RedisModuleInfoFunc` to add info fields.
+Each field will be automatically prefixed by `<modulename>_`.
+Field names or values must not include `\r\n` or `:`.
+
+<span id="RedisModule_InfoAddFieldCString"></span>
+
+### `RedisModule_InfoAddFieldCString`
+
+    int RedisModule_InfoAddFieldCString(RedisModuleInfoCtx *ctx,
+                                        const char *field,
+                                        const char *value);
+
+**Available since:** 6.0.0
+
+See [`RedisModule_InfoAddFieldString()`](#RedisModule_InfoAddFieldString).
+
+<span id="RedisModule_InfoAddFieldDouble"></span>
+
+### `RedisModule_InfoAddFieldDouble`
+
+    int RedisModule_InfoAddFieldDouble(RedisModuleInfoCtx *ctx,
+                                       const char *field,
+                                       double value);
+
+**Available since:** 6.0.0
+
+See [`RedisModule_InfoAddFieldString()`](#RedisModule_InfoAddFieldString).
+
+<span id="RedisModule_InfoAddFieldLongLong"></span>
+
+### `RedisModule_InfoAddFieldLongLong`
+
+    int RedisModule_InfoAddFieldLongLong(RedisModuleInfoCtx *ctx,
+                                         const char *field,
+                                         long long value);
+
+**Available since:** 6.0.0
+
+See [`RedisModule_InfoAddFieldString()`](#RedisModule_InfoAddFieldString).
+
+<span id="RedisModule_InfoAddFieldULongLong"></span>
+
+### `RedisModule_InfoAddFieldULongLong`
+
+    int RedisModule_InfoAddFieldULongLong(RedisModuleInfoCtx *ctx,
+                                          const char *field,
+                                          unsigned long long value);
+
+**Available since:** 6.0.0
+
+See [`RedisModule_InfoAddFieldString()`](#RedisModule_InfoAddFieldString).
+
+<span id="RedisModule_RegisterInfoFunc"></span>
+
+### `RedisModule_RegisterInfoFunc`
+
+    int RedisModule_RegisterInfoFunc(RedisModuleCtx *ctx, RedisModuleInfoFunc cb);
+
+**Available since:** 6.0.0
+
+Registers callback for the INFO command. The callback should add INFO fields
+by calling the `RedisModule_InfoAddField*()` functions.
+
+<span id="RedisModule_GetServerInfo"></span>
+
+### `RedisModule_GetServerInfo`
+
+    RedisModuleServerInfoData *RedisModule_GetServerInfo(RedisModuleCtx *ctx,
+                                                         const char *section);
+
+**Available since:** 6.0.0
+
+Get information about the server similar to the one that returns from the
+INFO command. This function takes an optional 'section' argument that may
+be NULL. The return value holds the output and can be used with
+[`RedisModule_ServerInfoGetField`](#RedisModule_ServerInfoGetField) and alike to get the individual fields.
+When done, it needs to be freed with [`RedisModule_FreeServerInfo`](#RedisModule_FreeServerInfo) or with the
+automatic memory management mechanism if enabled.
+
+<span id="RedisModule_FreeServerInfo"></span>
+
+### `RedisModule_FreeServerInfo`
+
+    void RedisModule_FreeServerInfo(RedisModuleCtx *ctx,
+                                    RedisModuleServerInfoData *data);
+
+**Available since:** 6.0.0
+
+Free data created with [`RedisModule_GetServerInfo()`](#RedisModule_GetServerInfo). You need to pass the
+context pointer 'ctx' only if the dictionary was created using the
+context instead of passing NULL.
+
+<span id="RedisModule_ServerInfoGetField"></span>
+
+### `RedisModule_ServerInfoGetField`
+
+    RedisModuleString *RedisModule_ServerInfoGetField(RedisModuleCtx *ctx,
+                                                      RedisModuleServerInfoData *data,
+                                                      const char* field);
+
+**Available since:** 6.0.0
+
+Get the value of a field from data collected with [`RedisModule_GetServerInfo()`](#RedisModule_GetServerInfo). You
+need to pass the context pointer 'ctx' only if you want to use auto memory
+mechanism to release the returned string. Return value will be NULL if the
+field was not found.
+
+<span id="RedisModule_ServerInfoGetFieldC"></span>
+
+### `RedisModule_ServerInfoGetFieldC`
+
+    const char *RedisModule_ServerInfoGetFieldC(RedisModuleServerInfoData *data,
+                                                const char* field);
+
+**Available since:** 6.0.0
+
+Similar to [`RedisModule_ServerInfoGetField`](#RedisModule_ServerInfoGetField), but returns a char* which should not be freed but the caller.
+
+<span id="RedisModule_ServerInfoGetFieldSigned"></span>
+
+### `RedisModule_ServerInfoGetFieldSigned`
+
+    long long RedisModule_ServerInfoGetFieldSigned(RedisModuleServerInfoData *data,
+                                                   const char* field,
+                                                   int *out_err);
+
+**Available since:** 6.0.0
+
+Get the value of a field from data collected with [`RedisModule_GetServerInfo()`](#RedisModule_GetServerInfo). If the
+field is not found, or is not numerical or out of range, return value will be
+0, and the optional `out_err` argument will be set to `REDISMODULE_ERR`.
+
+<span id="RedisModule_ServerInfoGetFieldUnsigned"></span>
+
+### `RedisModule_ServerInfoGetFieldUnsigned`
+
+    unsigned long long RedisModule_ServerInfoGetFieldUnsigned(RedisModuleServerInfoData *data,
+                                                              const char* field,
+                                                              int *out_err);
+
+**Available since:** 6.0.0
+
+Get the value of a field from data collected with [`RedisModule_GetServerInfo()`](#RedisModule_GetServerInfo). If the
+field is not found, or is not numerical or out of range, return value will be
+0, and the optional `out_err` argument will be set to `REDISMODULE_ERR`.
+
+<span id="RedisModule_ServerInfoGetFieldDouble"></span>
+
+### `RedisModule_ServerInfoGetFieldDouble`
+
+    double RedisModule_ServerInfoGetFieldDouble(RedisModuleServerInfoData *data,
+                                                const char* field,
+                                                int *out_err);
+
+**Available since:** 6.0.0
+
+Get the value of a field from data collected with [`RedisModule_GetServerInfo()`](#RedisModule_GetServerInfo). If the
+field is not found, or is not a double, return value will be 0, and the
+optional `out_err` argument will be set to `REDISMODULE_ERR`.
+
+<span id="section-modules-utility-apis"></span>
+
+## Modules utility APIs
+
+<span id="RedisModule_GetRandomBytes"></span>
+
+### `RedisModule_GetRandomBytes`
+
+    void RedisModule_GetRandomBytes(unsigned char *dst, size_t len);
+
+**Available since:** 5.0.0
+
+Return random bytes using SHA1 in counter mode with a /dev/urandom
+initialized seed. This function is fast so can be used to generate
+many bytes without any effect on the operating system entropy pool.
+Currently this function is not thread safe.
+
+<span id="RedisModule_GetRandomHexChars"></span>
+
+### `RedisModule_GetRandomHexChars`
+
+    void RedisModule_GetRandomHexChars(char *dst, size_t len);
+
+**Available since:** 5.0.0
+
+Like [`RedisModule_GetRandomBytes()`](#RedisModule_GetRandomBytes) but instead of setting the string to
+random bytes the string is set to random characters in the in the
+hex charset [0-9a-f].
+
+<span id="section-modules-api-exporting-importing"></span>
+
+## Modules API exporting / importing
+
+<span id="RedisModule_ExportSharedAPI"></span>
+
+### `RedisModule_ExportSharedAPI`
+
+    int RedisModule_ExportSharedAPI(RedisModuleCtx *ctx,
+                                    const char *apiname,
+                                    void *func);
+
+**Available since:** 5.0.4
+
+This function is called by a module in order to export some API with a
+given name. Other modules will be able to use this API by calling the
+symmetrical function [`RedisModule_GetSharedAPI()`](#RedisModule_GetSharedAPI) and casting the return value to
+the right function pointer.
+
+The function will return `REDISMODULE_OK` if the name is not already taken,
+otherwise `REDISMODULE_ERR` will be returned and no operation will be
+performed.
+
+IMPORTANT: the apiname argument should be a string literal with static
+lifetime. The API relies on the fact that it will always be valid in
+the future.
+
+<span id="RedisModule_GetSharedAPI"></span>
+
+### `RedisModule_GetSharedAPI`
+
+    void *RedisModule_GetSharedAPI(RedisModuleCtx *ctx, const char *apiname);
+
+**Available since:** 5.0.4
+
+Request an exported API pointer. The return value is just a void pointer
+that the caller of this function will be required to cast to the right
+function pointer, so this is a private contract between modules.
+
+If the requested API is not available then NULL is returned. Because
+modules can be loaded at different times with different order, this
+function calls should be put inside some module generic API registering
+step, that is called every time a module attempts to execute a
+command that requires external APIs: if some API cannot be resolved, the
+command should return an error.
+
+Here is an example:
+
+    int ... myCommandImplementation(void) {
+       if (getExternalAPIs() == 0) {
+            reply with an error here if we cannot have the APIs
+       }
+       // Use the API:
+       myFunctionPointer(foo);
+    }
+
+And the function registerAPI() is:
+
+    int getExternalAPIs(void) {
+        static int api_loaded = 0;
+        if (api_loaded != 0) return 1; // APIs already resolved.
+
+        myFunctionPointer = RedisModule_GetSharedAPI("...");
+        if (myFunctionPointer == NULL) return 0;
+
+        return 1;
+    }
+
+<span id="section-module-command-filter-api"></span>
+
+## Module Command Filter API
+
+<span id="RedisModule_RegisterCommandFilter"></span>
+
+### `RedisModule_RegisterCommandFilter`
+
+    RedisModuleCommandFilter *RedisModule_RegisterCommandFilter(RedisModuleCtx *ctx,
+                                                                RedisModuleCommandFilterFunc callback,
+                                                                int flags);
+
+**Available since:** 5.0.5
+
+Register a new command filter function.
+
+Command filtering makes it possible for modules to extend Redis by plugging
+into the execution flow of all commands.
+
+A registered filter gets called before Redis executes *any* command.  This
+includes both core Redis commands and commands registered by any module.  The
+filter applies in all execution paths including:
+
+1. Invocation by a client.
+2. Invocation through [`RedisModule_Call()`](#RedisModule_Call) by any module.
+3. Invocation through Lua `redis.call()`.
+4. Replication of a command from a master.
+
+The filter executes in a special filter context, which is different and more
+limited than a `RedisModuleCtx`.  Because the filter affects any command, it
+must be implemented in a very efficient way to reduce the performance impact
+on Redis.  All Redis Module API calls that require a valid context (such as
+[`RedisModule_Call()`](#RedisModule_Call), [`RedisModule_OpenKey()`](#RedisModule_OpenKey), etc.) are not supported in a
+filter context.
+
+The `RedisModuleCommandFilterCtx` can be used to inspect or modify the
+executed command and its arguments.  As the filter executes before Redis
+begins processing the command, any change will affect the way the command is
+processed.  For example, a module can override Redis commands this way:
+
+1. Register a `MODULE.SET` command which implements an extended version of
+   the Redis `SET` command.
+2. Register a command filter which detects invocation of `SET` on a specific
+   pattern of keys.  Once detected, the filter will replace the first
+   argument from `SET` to `MODULE.SET`.
+3. When filter execution is complete, Redis considers the new command name
+   and therefore executes the module's own command.
+
+Note that in the above use case, if `MODULE.SET` itself uses
+[`RedisModule_Call()`](#RedisModule_Call) the filter will be applied on that call as well.  If
+that is not desired, the `REDISMODULE_CMDFILTER_NOSELF` flag can be set when
+registering the filter.
+
+The `REDISMODULE_CMDFILTER_NOSELF` flag prevents execution flows that
+originate from the module's own [`RedisModule_Call()`](#RedisModule_Call) from reaching the filter.  This
+flag is effective for all execution flows, including nested ones, as long as
+the execution begins from the module's command context or a thread-safe
+context that is associated with a blocking command.
+
+Detached thread-safe contexts are *not* associated with the module and cannot
+be protected by this flag.
+
+If multiple filters are registered (by the same or different modules), they
+are executed in the order of registration.
+
+<span id="RedisModule_UnregisterCommandFilter"></span>
+
+### `RedisModule_UnregisterCommandFilter`
+
+    int RedisModule_UnregisterCommandFilter(RedisModuleCtx *ctx,
+                                            RedisModuleCommandFilter *filter);
+
+**Available since:** 5.0.5
+
+Unregister a command filter.
+
+<span id="RedisModule_CommandFilterArgsCount"></span>
+
+### `RedisModule_CommandFilterArgsCount`
+
+    int RedisModule_CommandFilterArgsCount(RedisModuleCommandFilterCtx *fctx);
+
+**Available since:** 5.0.5
+
+Return the number of arguments a filtered command has.  The number of
+arguments include the command itself.
+
+<span id="RedisModule_CommandFilterArgGet"></span>
+
+### `RedisModule_CommandFilterArgGet`
+
+    RedisModuleString *RedisModule_CommandFilterArgGet(RedisModuleCommandFilterCtx *fctx,
+                                                       int pos);
+
+**Available since:** 5.0.5
+
+Return the specified command argument.  The first argument (position 0) is
+the command itself, and the rest are user-provided args.
+
+<span id="RedisModule_CommandFilterArgInsert"></span>
+
+### `RedisModule_CommandFilterArgInsert`
+
+    int RedisModule_CommandFilterArgInsert(RedisModuleCommandFilterCtx *fctx,
+                                           int pos,
+                                           RedisModuleString *arg);
+
+**Available since:** 5.0.5
+
+Modify the filtered command by inserting a new argument at the specified
+position.  The specified `RedisModuleString` argument may be used by Redis
+after the filter context is destroyed, so it must not be auto-memory
+allocated, freed or used elsewhere.
+
+<span id="RedisModule_CommandFilterArgReplace"></span>
+
+### `RedisModule_CommandFilterArgReplace`
+
+    int RedisModule_CommandFilterArgReplace(RedisModuleCommandFilterCtx *fctx,
+                                            int pos,
+                                            RedisModuleString *arg);
+
+**Available since:** 5.0.5
+
+Modify the filtered command by replacing an existing argument with a new one.
+The specified `RedisModuleString` argument may be used by Redis after the
+filter context is destroyed, so it must not be auto-memory allocated, freed
+or used elsewhere.
+
+<span id="RedisModule_CommandFilterArgDelete"></span>
+
+### `RedisModule_CommandFilterArgDelete`
+
+    int RedisModule_CommandFilterArgDelete(RedisModuleCommandFilterCtx *fctx,
+                                           int pos);
+
+**Available since:** 5.0.5
+
+Modify the filtered command by deleting an argument at the specified
+position.
+
+<span id="RedisModule_CommandFilterGetClientId"></span>
+
+### `RedisModule_CommandFilterGetClientId`
+
+    unsigned long long RedisModule_CommandFilterGetClientId(RedisModuleCommandFilterCtx *fctx);
+
+**Available since:** 7.2.0
+
+Get Client ID for client that issued the command we are filtering
+
+<span id="RedisModule_MallocSize"></span>
+
+### `RedisModule_MallocSize`
+
+    size_t RedisModule_MallocSize(void* ptr);
+
+**Available since:** 6.0.0
+
+For a given pointer allocated via [`RedisModule_Alloc()`](#RedisModule_Alloc) or
+[`RedisModule_Realloc()`](#RedisModule_Realloc), return the amount of memory allocated for it.
+Note that this may be different (larger) than the memory we allocated
+with the allocation calls, since sometimes the underlying allocator
+will allocate more memory.
+
+<span id="RedisModule_MallocUsableSize"></span>
+
+### `RedisModule_MallocUsableSize`
+
+    size_t RedisModule_MallocUsableSize(void *ptr);
+
+**Available since:** 7.0.1
+
+Similar to [`RedisModule_MallocSize`](#RedisModule_MallocSize), the difference is that [`RedisModule_MallocUsableSize`](#RedisModule_MallocUsableSize)
+returns the usable size of memory by the module.
+
+<span id="RedisModule_MallocSizeString"></span>
+
+### `RedisModule_MallocSizeString`
+
+    size_t RedisModule_MallocSizeString(RedisModuleString* str);
+
+**Available since:** 7.0.0
+
+Same as [`RedisModule_MallocSize`](#RedisModule_MallocSize), except it works on `RedisModuleString` pointers.
+
+<span id="RedisModule_MallocSizeDict"></span>
+
+### `RedisModule_MallocSizeDict`
+
+    size_t RedisModule_MallocSizeDict(RedisModuleDict* dict);
+
+**Available since:** 7.0.0
+
+Same as [`RedisModule_MallocSize`](#RedisModule_MallocSize), except it works on `RedisModuleDict` pointers.
+Note that the returned value is only the overhead of the underlying structures,
+it does not include the allocation size of the keys and values.
+
+<span id="RedisModule_GetUsedMemoryRatio"></span>
+
+### `RedisModule_GetUsedMemoryRatio`
+
+    float RedisModule_GetUsedMemoryRatio(void);
+
+**Available since:** 6.0.0
+
+Return the a number between 0 to 1 indicating the amount of memory
+currently used, relative to the Redis "maxmemory" configuration.
+
+* 0 - No memory limit configured.
+* Between 0 and 1 - The percentage of the memory used normalized in 0-1 range.
+* Exactly 1 - Memory limit reached.
+* Greater 1 - More memory used than the configured limit.
+
+<span id="section-scanning-keyspace-and-hashes"></span>
+
+## Scanning keyspace and hashes
+
+<span id="RedisModule_ScanCursorCreate"></span>
+
+### `RedisModule_ScanCursorCreate`
+
+    RedisModuleScanCursor *RedisModule_ScanCursorCreate(void);
+
+**Available since:** 6.0.0
+
+Create a new cursor to be used with [`RedisModule_Scan`](#RedisModule_Scan)
+
+<span id="RedisModule_ScanCursorRestart"></span>
+
+### `RedisModule_ScanCursorRestart`
+
+    void RedisModule_ScanCursorRestart(RedisModuleScanCursor *cursor);
+
+**Available since:** 6.0.0
+
+Restart an existing cursor. The keys will be rescanned.
+
+<span id="RedisModule_ScanCursorDestroy"></span>
+
+### `RedisModule_ScanCursorDestroy`
+
+    void RedisModule_ScanCursorDestroy(RedisModuleScanCursor *cursor);
+
+**Available since:** 6.0.0
+
+Destroy the cursor struct.
+
+<span id="RedisModule_Scan"></span>
+
+### `RedisModule_Scan`
+
+    int RedisModule_Scan(RedisModuleCtx *ctx,
+                         RedisModuleScanCursor *cursor,
+                         RedisModuleScanCB fn,
+                         void *privdata);
+
+**Available since:** 6.0.0
+
+Scan API that allows a module to scan all the keys and value in
+the selected db.
+
+Callback for scan implementation.
+
+    void scan_callback(RedisModuleCtx *ctx, RedisModuleString *keyname,
+                       RedisModuleKey *key, void *privdata);
+
+- `ctx`: the redis module context provided to for the scan.
+- `keyname`: owned by the caller and need to be retained if used after this
+  function.
+- `key`: holds info on the key and value, it is provided as best effort, in
+  some cases it might be NULL, in which case the user should (can) use
+  [`RedisModule_OpenKey()`](#RedisModule_OpenKey) (and CloseKey too).
+  when it is provided, it is owned by the caller and will be free when the
+  callback returns.
+- `privdata`: the user data provided to [`RedisModule_Scan()`](#RedisModule_Scan).
+
+The way it should be used:
+
+     RedisModuleScanCursor *c = RedisModule_ScanCursorCreate();
+     while(RedisModule_Scan(ctx, c, callback, privateData));
+     RedisModule_ScanCursorDestroy(c);
+
+It is also possible to use this API from another thread while the lock
+is acquired during the actual call to [`RedisModule_Scan`](#RedisModule_Scan):
+
+     RedisModuleScanCursor *c = RedisModule_ScanCursorCreate();
+     RedisModule_ThreadSafeContextLock(ctx);
+     while(RedisModule_Scan(ctx, c, callback, privateData)){
+         RedisModule_ThreadSafeContextUnlock(ctx);
+         // do some background job
+         RedisModule_ThreadSafeContextLock(ctx);
+     }
+     RedisModule_ScanCursorDestroy(c);
+
+The function will return 1 if there are more elements to scan and
+0 otherwise, possibly setting errno if the call failed.
+
+It is also possible to restart an existing cursor using [`RedisModule_ScanCursorRestart`](#RedisModule_ScanCursorRestart).
+
+IMPORTANT: This API is very similar to the Redis SCAN command from the
+point of view of the guarantees it provides. This means that the API
+may report duplicated keys, but guarantees to report at least one time
+every key that was there from the start to the end of the scanning process.
+
+NOTE: If you do database changes within the callback, you should be aware
+that the internal state of the database may change. For instance it is safe
+to delete or modify the current key, but may not be safe to delete any
+other key.
+Moreover playing with the Redis keyspace while iterating may have the
+effect of returning more duplicates. A safe pattern is to store the keys
+names you want to modify elsewhere, and perform the actions on the keys
+later when the iteration is complete. However this can cost a lot of
+memory, so it may make sense to just operate on the current key when
+possible during the iteration, given that this is safe.
+
+<span id="RedisModule_ScanKey"></span>
+
+### `RedisModule_ScanKey`
+
+    int RedisModule_ScanKey(RedisModuleKey *key,
+                            RedisModuleScanCursor *cursor,
+                            RedisModuleScanKeyCB fn,
+                            void *privdata);
+
+**Available since:** 6.0.0
+
+Scan api that allows a module to scan the elements in a hash, set or sorted set key
+
+Callback for scan implementation.
+
+    void scan_callback(RedisModuleKey *key, RedisModuleString* field, RedisModuleString* value, void *privdata);
+
+- key - the redis key context provided to for the scan.
+- field - field name, owned by the caller and need to be retained if used
+  after this function.
+- value - value string or NULL for set type, owned by the caller and need to
+  be retained if used after this function.
+- privdata - the user data provided to [`RedisModule_ScanKey`](#RedisModule_ScanKey).
+
+The way it should be used:
+
+     RedisModuleScanCursor *c = RedisModule_ScanCursorCreate();
+     RedisModuleKey *key = RedisModule_OpenKey(...);
+     while(RedisModule_ScanKey(key, c, callback, privateData));
+     RedisModule_CloseKey(key);
+     RedisModule_ScanCursorDestroy(c);
+
+It is also possible to use this API from another thread while the lock is acquired during
+the actual call to [`RedisModule_ScanKey`](#RedisModule_ScanKey), and re-opening the key each time:
+
+     RedisModuleScanCursor *c = RedisModule_ScanCursorCreate();
+     RedisModule_ThreadSafeContextLock(ctx);
+     RedisModuleKey *key = RedisModule_OpenKey(...);
+     while(RedisModule_ScanKey(ctx, c, callback, privateData)){
+         RedisModule_CloseKey(key);
+         RedisModule_ThreadSafeContextUnlock(ctx);
+         // do some background job
+         RedisModule_ThreadSafeContextLock(ctx);
+         key = RedisModule_OpenKey(...);
+     }
+     RedisModule_CloseKey(key);
+     RedisModule_ScanCursorDestroy(c);
+
+The function will return 1 if there are more elements to scan and 0 otherwise,
+possibly setting errno if the call failed.
+It is also possible to restart an existing cursor using [`RedisModule_ScanCursorRestart`](#RedisModule_ScanCursorRestart).
+
+NOTE: Certain operations are unsafe while iterating the object. For instance
+while the API guarantees to return at least one time all the elements that
+are present in the data structure consistently from the start to the end
+of the iteration (see HSCAN and similar commands documentation), the more
+you play with the elements, the more duplicates you may get. In general
+deleting the current element of the data structure is safe, while removing
+the key you are iterating is not safe.
+
+<span id="section-module-fork-api"></span>
+
+## Module fork API
+
+<span id="RedisModule_Fork"></span>
+
+### `RedisModule_Fork`
+
+    int RedisModule_Fork(RedisModuleForkDoneHandler cb, void *user_data);
+
+**Available since:** 6.0.0
+
+Create a background child process with the current frozen snapshot of the
+main process where you can do some processing in the background without
+affecting / freezing the traffic and no need for threads and GIL locking.
+Note that Redis allows for only one concurrent fork.
+When the child wants to exit, it should call [`RedisModule_ExitFromChild`](#RedisModule_ExitFromChild).
+If the parent wants to kill the child it should call [`RedisModule_KillForkChild`](#RedisModule_KillForkChild)
+The done handler callback will be executed on the parent process when the
+child existed (but not when killed)
+Return: -1 on failure, on success the parent process will get a positive PID
+of the child, and the child process will get 0.
+
+<span id="RedisModule_SendChildHeartbeat"></span>
+
+### `RedisModule_SendChildHeartbeat`
+
+    void RedisModule_SendChildHeartbeat(double progress);
+
+**Available since:** 6.2.0
+
+The module is advised to call this function from the fork child once in a while,
+so that it can report progress and COW memory to the parent which will be
+reported in INFO.
+The `progress` argument should between 0 and 1, or -1 when not available.
+
+<span id="RedisModule_ExitFromChild"></span>
+
+### `RedisModule_ExitFromChild`
+
+    int RedisModule_ExitFromChild(int retcode);
+
+**Available since:** 6.0.0
+
+Call from the child process when you want to terminate it.
+retcode will be provided to the done handler executed on the parent process.
+
+<span id="RedisModule_KillForkChild"></span>
+
+### `RedisModule_KillForkChild`
+
+    int RedisModule_KillForkChild(int child_pid);
+
+**Available since:** 6.0.0
+
+Can be used to kill the forked child process from the parent process.
+`child_pid` would be the return value of [`RedisModule_Fork`](#RedisModule_Fork).
+
+<span id="section-server-hooks-implementation"></span>
+
+## Server hooks implementation
+
+<span id="RedisModule_SubscribeToServerEvent"></span>
+
+### `RedisModule_SubscribeToServerEvent`
+
+    int RedisModule_SubscribeToServerEvent(RedisModuleCtx *ctx,
+                                           RedisModuleEvent event,
+                                           RedisModuleEventCallback callback);
+
+**Available since:** 6.0.0
+
+Register to be notified, via a callback, when the specified server event
+happens. The callback is called with the event as argument, and an additional
+argument which is a void pointer and should be cased to a specific type
+that is event-specific (but many events will just use NULL since they do not
+have additional information to pass to the callback).
+
+If the callback is NULL and there was a previous subscription, the module
+will be unsubscribed. If there was a previous subscription and the callback
+is not null, the old callback will be replaced with the new one.
+
+The callback must be of this type:
+
+    int (*RedisModuleEventCallback)(RedisModuleCtx *ctx,
+                                    RedisModuleEvent eid,
+                                    uint64_t subevent,
+                                    void *data);
+
+The 'ctx' is a normal Redis module context that the callback can use in
+order to call other modules APIs. The 'eid' is the event itself, this
+is only useful in the case the module subscribed to multiple events: using
+the 'id' field of this structure it is possible to check if the event
+is one of the events we registered with this callback. The 'subevent' field
+depends on the event that fired.
+
+Finally the 'data' pointer may be populated, only for certain events, with
+more relevant data.
+
+Here is a list of events you can use as 'eid' and related sub events:
+
+* `RedisModuleEvent_ReplicationRoleChanged`:
+
+    This event is called when the instance switches from master
+    to replica or the other way around, however the event is
+    also called when the replica remains a replica but starts to
+    replicate with a different master.
+
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_REPLROLECHANGED_NOW_MASTER`
+    * `REDISMODULE_SUBEVENT_REPLROLECHANGED_NOW_REPLICA`
+
+    The 'data' field can be casted by the callback to a
+    `RedisModuleReplicationInfo` structure with the following fields:
+
+        int master; // true if master, false if replica
+        char *masterhost; // master instance hostname for NOW_REPLICA
+        int masterport; // master instance port for NOW_REPLICA
+        char *replid1; // Main replication ID
+        char *replid2; // Secondary replication ID
+        uint64_t repl1_offset; // Main replication offset
+        uint64_t repl2_offset; // Offset of replid2 validity
+
+* `RedisModuleEvent_Persistence`
+
+    This event is called when RDB saving or AOF rewriting starts
+    and ends. The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_RDB_START`
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_AOF_START`
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_SYNC_RDB_START`
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_SYNC_AOF_START`
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_ENDED`
+    * `REDISMODULE_SUBEVENT_PERSISTENCE_FAILED`
+
+    The above events are triggered not just when the user calls the
+    relevant commands like BGSAVE, but also when a saving operation
+    or AOF rewriting occurs because of internal server triggers.
+    The SYNC_RDB_START sub events are happening in the foreground due to
+    SAVE command, FLUSHALL, or server shutdown, and the other RDB and
+    AOF sub events are executed in a background fork child, so any
+    action the module takes can only affect the generated AOF or RDB,
+    but will not be reflected in the parent process and affect connected
+    clients and commands. Also note that the AOF_START sub event may end
+    up saving RDB content in case of an AOF with rdb-preamble.
+
+* `RedisModuleEvent_FlushDB`
+
+    The FLUSHALL, FLUSHDB or an internal flush (for instance
+    because of replication, after the replica synchronization)
+    happened. The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_FLUSHDB_START`
+    * `REDISMODULE_SUBEVENT_FLUSHDB_END`
+
+    The data pointer can be casted to a RedisModuleFlushInfo
+    structure with the following fields:
+
+        int32_t async;  // True if the flush is done in a thread.
+                        // See for instance FLUSHALL ASYNC.
+                        // In this case the END callback is invoked
+                        // immediately after the database is put
+                        // in the free list of the thread.
+        int32_t dbnum;  // Flushed database number, -1 for all the DBs
+                        // in the case of the FLUSHALL operation.
+
+    The start event is called *before* the operation is initiated, thus
+    allowing the callback to call DBSIZE or other operation on the
+    yet-to-free keyspace.
+
+* `RedisModuleEvent_Loading`
+
+    Called on loading operations: at startup when the server is
+    started, but also after a first synchronization when the
+    replica is loading the RDB file from the master.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_LOADING_RDB_START`
+    * `REDISMODULE_SUBEVENT_LOADING_AOF_START`
+    * `REDISMODULE_SUBEVENT_LOADING_REPL_START`
+    * `REDISMODULE_SUBEVENT_LOADING_ENDED`
+    * `REDISMODULE_SUBEVENT_LOADING_FAILED`
+
+    Note that AOF loading may start with an RDB data in case of
+    rdb-preamble, in which case you'll only receive an AOF_START event.
+
+* `RedisModuleEvent_ClientChange`
+
+    Called when a client connects or disconnects.
+    The data pointer can be casted to a RedisModuleClientInfo
+    structure, documented in RedisModule_GetClientInfoById().
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_CLIENT_CHANGE_CONNECTED`
+    * `REDISMODULE_SUBEVENT_CLIENT_CHANGE_DISCONNECTED`
+
+* `RedisModuleEvent_Shutdown`
+
+    The server is shutting down. No subevents are available.
+
+* `RedisModuleEvent_ReplicaChange`
+
+    This event is called when the instance (that can be both a
+    master or a replica) get a new online replica, or lose a
+    replica since it gets disconnected.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_REPLICA_CHANGE_ONLINE`
+    * `REDISMODULE_SUBEVENT_REPLICA_CHANGE_OFFLINE`
+
+    No additional information is available so far: future versions
+    of Redis will have an API in order to enumerate the replicas
+    connected and their state.
+
+* `RedisModuleEvent_CronLoop`
+
+    This event is called every time Redis calls the serverCron()
+    function in order to do certain bookkeeping. Modules that are
+    required to do operations from time to time may use this callback.
+    Normally Redis calls this function 10 times per second, but
+    this changes depending on the "hz" configuration.
+    No sub events are available.
+
+    The data pointer can be casted to a RedisModuleCronLoop
+    structure with the following fields:
+
+        int32_t hz;  // Approximate number of events per second.
+
+* `RedisModuleEvent_MasterLinkChange`
+
+    This is called for replicas in order to notify when the
+    replication link becomes functional (up) with our master,
+    or when it goes down. Note that the link is not considered
+    up when we just connected to the master, but only if the
+    replication is happening correctly.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_MASTER_LINK_UP`
+    * `REDISMODULE_SUBEVENT_MASTER_LINK_DOWN`
+
+* `RedisModuleEvent_ModuleChange`
+
+    This event is called when a new module is loaded or one is unloaded.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_MODULE_LOADED`
+    * `REDISMODULE_SUBEVENT_MODULE_UNLOADED`
+
+    The data pointer can be casted to a RedisModuleModuleChange
+    structure with the following fields:
+
+        const char* module_name;  // Name of module loaded or unloaded.
+        int32_t module_version;  // Module version.
+
+* `RedisModuleEvent_LoadingProgress`
+
+    This event is called repeatedly called while an RDB or AOF file
+    is being loaded.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_LOADING_PROGRESS_RDB`
+    * `REDISMODULE_SUBEVENT_LOADING_PROGRESS_AOF`
+
+    The data pointer can be casted to a RedisModuleLoadingProgress
+    structure with the following fields:
+
+        int32_t hz;  // Approximate number of events per second.
+        int32_t progress;  // Approximate progress between 0 and 1024,
+                           // or -1 if unknown.
+
+* `RedisModuleEvent_SwapDB`
+
+    This event is called when a SWAPDB command has been successfully
+    Executed.
+    For this event call currently there is no subevents available.
+
+    The data pointer can be casted to a RedisModuleSwapDbInfo
+    structure with the following fields:
+
+        int32_t dbnum_first;    // Swap Db first dbnum
+        int32_t dbnum_second;   // Swap Db second dbnum
+
+* `RedisModuleEvent_ReplBackup`
+
+    WARNING: Replication Backup events are deprecated since Redis 7.0 and are never fired.
+    See RedisModuleEvent_ReplAsyncLoad for understanding how Async Replication Loading events
+    are now triggered when repl-diskless-load is set to swapdb.
+
+    Called when repl-diskless-load config is set to swapdb,
+    And redis needs to backup the current database for the
+    possibility to be restored later. A module with global data and
+    maybe with aux_load and aux_save callbacks may need to use this
+    notification to backup / restore / discard its globals.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_REPL_BACKUP_CREATE`
+    * `REDISMODULE_SUBEVENT_REPL_BACKUP_RESTORE`
+    * `REDISMODULE_SUBEVENT_REPL_BACKUP_DISCARD`
+
+* `RedisModuleEvent_ReplAsyncLoad`
+
+    Called when repl-diskless-load config is set to swapdb and a replication with a master of same
+    data set history (matching replication ID) occurs.
+    In which case redis serves current data set while loading new database in memory from socket.
+    Modules must have declared they support this mechanism in order to activate it, through
+    REDISMODULE_OPTIONS_HANDLE_REPL_ASYNC_LOAD flag.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_REPL_ASYNC_LOAD_STARTED`
+    * `REDISMODULE_SUBEVENT_REPL_ASYNC_LOAD_ABORTED`
+    * `REDISMODULE_SUBEVENT_REPL_ASYNC_LOAD_COMPLETED`
+
+* `RedisModuleEvent_ForkChild`
+
+    Called when a fork child (AOFRW, RDBSAVE, module fork...) is born/dies
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_FORK_CHILD_BORN`
+    * `REDISMODULE_SUBEVENT_FORK_CHILD_DIED`
+
+* `RedisModuleEvent_EventLoop`
+
+    Called on each event loop iteration, once just before the event loop goes
+    to sleep or just after it wakes up.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_EVENTLOOP_BEFORE_SLEEP`
+    * `REDISMODULE_SUBEVENT_EVENTLOOP_AFTER_SLEEP`
+
+* `RedisModule_Event_Config`
+
+    Called when a configuration event happens
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_CONFIG_CHANGE`
+
+    The data pointer can be casted to a RedisModuleConfigChange
+    structure with the following fields:
+
+        const char **config_names; // An array of C string pointers containing the
+                                   // name of each modified configuration item 
+        uint32_t num_changes;      // The number of elements in the config_names array
+
+* `RedisModule_Event_Key`
+
+    Called when a key is removed from the keyspace. We can't modify any key in
+    the event.
+    The following sub events are available:
+
+    * `REDISMODULE_SUBEVENT_KEY_DELETED`
+    * `REDISMODULE_SUBEVENT_KEY_EXPIRED`
+    * `REDISMODULE_SUBEVENT_KEY_EVICTED`
+    * `REDISMODULE_SUBEVENT_KEY_OVERWRITTEN`
+
+    The data pointer can be casted to a RedisModuleKeyInfo
+    structure with the following fields:
+
+        RedisModuleKey *key;    // Key name
+
+The function returns `REDISMODULE_OK` if the module was successfully subscribed
+for the specified event. If the API is called from a wrong context or unsupported event
+is given then `REDISMODULE_ERR` is returned.
+
+<span id="RedisModule_IsSubEventSupported"></span>
+
+### `RedisModule_IsSubEventSupported`
+
+    int RedisModule_IsSubEventSupported(RedisModuleEvent event, int64_t subevent);
+
+**Available since:** 6.0.9
+
+
+For a given server event and subevent, return zero if the
+subevent is not supported and non-zero otherwise.
+
+<span id="section-module-configurations-api"></span>
+
+## Module Configurations API
+
+<span id="RedisModule_RegisterStringConfig"></span>
+
+### `RedisModule_RegisterStringConfig`
+
+    int RedisModule_RegisterStringConfig(RedisModuleCtx *ctx,
+                                         const char *name,
+                                         const char *default_val,
+                                         unsigned int flags,
+                                         RedisModuleConfigGetStringFunc getfn,
+                                         RedisModuleConfigSetStringFunc setfn,
+                                         RedisModuleConfigApplyFunc applyfn,
+                                         void *privdata);
+
+**Available since:** 7.0.0
+
+Create a string config that Redis users can interact with via the Redis config file,
+`CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands.
+
+The actual config value is owned by the module, and the `getfn`, `setfn` and optional
+`applyfn` callbacks that are provided to Redis in order to access or manipulate the
+value. The `getfn` callback retrieves the value from the module, while the `setfn`
+callback provides a value to be stored into the module config.
+The optional `applyfn` callback is called after a `CONFIG SET` command modified one or
+more configs using the `setfn` callback and can be used to atomically apply a config
+after several configs were changed together.
+If there are multiple configs with `applyfn` callbacks set by a single `CONFIG SET`
+command, they will be deduplicated if their `applyfn` function and `privdata` pointers
+are identical, and the callback will only be run once.
+Both the `setfn` and `applyfn` can return an error if the provided value is invalid or
+cannot be used.
+The config also declares a type for the value that is validated by Redis and
+provided to the module. The config system provides the following types:
+
+* Redis String: Binary safe string data.
+* Enum: One of a finite number of string tokens, provided during registration.
+* Numeric: 64 bit signed integer, which also supports min and max values.
+* Bool: Yes or no value.
+
+The `setfn` callback is expected to return `REDISMODULE_OK` when the value is successfully
+applied. It can also return `REDISMODULE_ERR` if the value can't be applied, and the
+*err pointer can be set with a `RedisModuleString` error message to provide to the client.
+This `RedisModuleString` will be freed by redis after returning from the set callback.
+
+All configs are registered with a name, a type, a default value, private data that is made
+available in the callbacks, as well as several flags that modify the behavior of the config.
+The name must only contain alphanumeric characters or dashes. The supported flags are:
+
+* `REDISMODULE_CONFIG_DEFAULT`: The default flags for a config. This creates a config that can be modified after startup.
+* `REDISMODULE_CONFIG_IMMUTABLE`: This config can only be provided loading time.
+* `REDISMODULE_CONFIG_SENSITIVE`: The value stored in this config is redacted from all logging.
+* `REDISMODULE_CONFIG_HIDDEN`: The name is hidden from `CONFIG GET` with pattern matching.
+* `REDISMODULE_CONFIG_PROTECTED`: This config will be only be modifiable based off the value of enable-protected-configs.
+* `REDISMODULE_CONFIG_DENY_LOADING`: This config is not modifiable while the server is loading data.
+* `REDISMODULE_CONFIG_MEMORY`: For numeric configs, this config will convert data unit notations into their byte equivalent.
+* `REDISMODULE_CONFIG_BITFLAGS`: For enum configs, this config will allow multiple entries to be combined as bit flags.
+
+Default values are used on startup to set the value if it is not provided via the config file
+or command line. Default values are also used to compare to on a config rewrite.
+
+Notes:
+
+ 1. On string config sets that the string passed to the set callback will be freed after execution and the module must retain it.
+ 2. On string config gets the string will not be consumed and will be valid after execution.
+
+Example implementation:
+
+    RedisModuleString *strval;
+    int adjustable = 1;
+    RedisModuleString *getStringConfigCommand(const char *name, void *privdata) {
+        return strval;
+    }
+
+    int setStringConfigCommand(const char *name, RedisModuleString *new, void *privdata, RedisModuleString **err) {
+       if (adjustable) {
+           RedisModule_Free(strval);
+           RedisModule_RetainString(NULL, new);
+           strval = new;
+           return REDISMODULE_OK;
+       }
+       *err = RedisModule_CreateString(NULL, "Not adjustable.", 15);
+       return REDISMODULE_ERR;
+    }
+    ...
+    RedisModule_RegisterStringConfig(ctx, "string", NULL, REDISMODULE_CONFIG_DEFAULT, getStringConfigCommand, setStringConfigCommand, NULL, NULL);
+
+If the registration fails, `REDISMODULE_ERR` is returned and one of the following
+errno is set:
+* EBUSY: Registering the Config outside of `RedisModule_OnLoad`.
+* EINVAL: The provided flags are invalid for the registration or the name of the config contains invalid characters.
+* EALREADY: The provided configuration name is already used.
+
+<span id="RedisModule_RegisterBoolConfig"></span>
+
+### `RedisModule_RegisterBoolConfig`
+
+    int RedisModule_RegisterBoolConfig(RedisModuleCtx *ctx,
+                                       const char *name,
+                                       int default_val,
+                                       unsigned int flags,
+                                       RedisModuleConfigGetBoolFunc getfn,
+                                       RedisModuleConfigSetBoolFunc setfn,
+                                       RedisModuleConfigApplyFunc applyfn,
+                                       void *privdata);
+
+**Available since:** 7.0.0
+
+Create a bool config that server clients can interact with via the 
+`CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. See 
+[`RedisModule_RegisterStringConfig`](#RedisModule_RegisterStringConfig) for detailed information about configs.
+
+<span id="RedisModule_RegisterEnumConfig"></span>
+
+### `RedisModule_RegisterEnumConfig`
+
+    int RedisModule_RegisterEnumConfig(RedisModuleCtx *ctx,
+                                       const char *name,
+                                       int default_val,
+                                       unsigned int flags,
+                                       const char **enum_values,
+                                       const int *int_values,
+                                       int num_enum_vals,
+                                       RedisModuleConfigGetEnumFunc getfn,
+                                       RedisModuleConfigSetEnumFunc setfn,
+                                       RedisModuleConfigApplyFunc applyfn,
+                                       void *privdata);
+
+**Available since:** 7.0.0
+
+
+Create an enum config that server clients can interact with via the 
+`CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. 
+Enum configs are a set of string tokens to corresponding integer values, where 
+the string value is exposed to Redis clients but the value passed Redis and the
+module is the integer value. These values are defined in `enum_values`, an array
+of null-terminated c strings, and `int_vals`, an array of enum values who has an
+index partner in `enum_values`.
+Example Implementation:
+     const char *enum_vals[3] = {"first", "second", "third"};
+     const int int_vals[3] = {0, 2, 4};
+     int enum_val = 0;
+
+     int getEnumConfigCommand(const char *name, void *privdata) {
+         return enum_val;
+     }
+      
+     int setEnumConfigCommand(const char *name, int val, void *privdata, const char **err) {
+         enum_val = val;
+         return REDISMODULE_OK;
+     }
+     ...
+     RedisModule_RegisterEnumConfig(ctx, "enum", 0, REDISMODULE_CONFIG_DEFAULT, enum_vals, int_vals, 3, getEnumConfigCommand, setEnumConfigCommand, NULL, NULL);
+
+Note that you can use `REDISMODULE_CONFIG_BITFLAGS` so that multiple enum string
+can be combined into one integer as bit flags, in which case you may want to
+sort your enums so that the preferred combinations are present first.
+
+See [`RedisModule_RegisterStringConfig`](#RedisModule_RegisterStringConfig) for detailed general information about configs.
+
+<span id="RedisModule_RegisterNumericConfig"></span>
+
+### `RedisModule_RegisterNumericConfig`
+
+    int RedisModule_RegisterNumericConfig(RedisModuleCtx *ctx,
+                                          const char *name,
+                                          long long default_val,
+                                          unsigned int flags,
+                                          long long min,
+                                          long long max,
+                                          RedisModuleConfigGetNumericFunc getfn,
+                                          RedisModuleConfigSetNumericFunc setfn,
+                                          RedisModuleConfigApplyFunc applyfn,
+                                          void *privdata);
+
+**Available since:** 7.0.0
+
+
+Create an integer config that server clients can interact with via the 
+`CONFIG SET`, `CONFIG GET`, and `CONFIG REWRITE` commands. See 
+[`RedisModule_RegisterStringConfig`](#RedisModule_RegisterStringConfig) for detailed information about configs.
+
+<span id="RedisModule_LoadDefaultConfigs"></span>
+
+### `RedisModule_LoadDefaultConfigs`
+
+    int RedisModule_LoadDefaultConfigs(RedisModuleCtx *ctx);
+
+**Available since:** unreleased
+
+Applies all default configurations for the parameters the module registered.
+Only call this function if the module would like to make changes to the
+configuration values before the actual values are applied by [`RedisModule_LoadConfigs`](#RedisModule_LoadConfigs).
+Otherwise it's sufficient to call [`RedisModule_LoadConfigs`](#RedisModule_LoadConfigs), it should already set the default values if needed.
+This makes it possible to distinguish between default values and user provided values and apply other changes between setting the defaults and the user values.
+This will return `REDISMODULE_ERR` if it is called:
+1. outside `RedisModule_OnLoad`
+2. more than once
+3. after the [`RedisModule_LoadConfigs`](#RedisModule_LoadConfigs) call
+
+<span id="RedisModule_LoadConfigs"></span>
+
+### `RedisModule_LoadConfigs`
+
+    int RedisModule_LoadConfigs(RedisModuleCtx *ctx);
+
+**Available since:** 7.0.0
+
+Applies all pending configurations on the module load. This should be called
+after all of the configurations have been registered for the module inside of `RedisModule_OnLoad`.
+This will return `REDISMODULE_ERR` if it is called outside `RedisModule_OnLoad`.
+This API needs to be called when configurations are provided in either `MODULE LOADEX`
+or provided as startup arguments.
+
+<span id="section-rdb-load-save-api"></span>
+
+## RDB load/save API
+
+<span id="RedisModule_RdbStreamCreateFromFile"></span>
+
+### `RedisModule_RdbStreamCreateFromFile`
+
+    RedisModuleRdbStream *RedisModule_RdbStreamCreateFromFile(const char *filename);
+
+**Available since:** 7.2.0
+
+Create a stream object to save/load RDB to/from a file.
+
+This function returns a pointer to `RedisModuleRdbStream` which is owned
+by the caller. It requires a call to [`RedisModule_RdbStreamFree()`](#RedisModule_RdbStreamFree) to free
+the object.
+
+<span id="RedisModule_RdbStreamFree"></span>
+
+### `RedisModule_RdbStreamFree`
+
+    void RedisModule_RdbStreamFree(RedisModuleRdbStream *stream);
+
+**Available since:** 7.2.0
+
+Release an RDB stream object.
+
+<span id="RedisModule_RdbLoad"></span>
+
+### `RedisModule_RdbLoad`
+
+    int RedisModule_RdbLoad(RedisModuleCtx *ctx,
+                            RedisModuleRdbStream *stream,
+                            int flags);
+
+**Available since:** 7.2.0
+
+Load RDB file from the `stream`. Dataset will be cleared first and then RDB
+file will be loaded.
+
+`flags` must be zero. This parameter is for future use.
+
+On success `REDISMODULE_OK` is returned, otherwise `REDISMODULE_ERR` is returned
+and errno is set accordingly.
+
+Example:
+
+    RedisModuleRdbStream *s = RedisModule_RdbStreamCreateFromFile("exp.rdb");
+    RedisModule_RdbLoad(ctx, s, 0);
+    RedisModule_RdbStreamFree(s);
+
+<span id="RedisModule_RdbSave"></span>
+
+### `RedisModule_RdbSave`
+
+    int RedisModule_RdbSave(RedisModuleCtx *ctx,
+                            RedisModuleRdbStream *stream,
+                            int flags);
+
+**Available since:** 7.2.0
+
+Save dataset to the RDB stream.
+
+`flags` must be zero. This parameter is for future use.
+
+On success `REDISMODULE_OK` is returned, otherwise `REDISMODULE_ERR` is returned
+and errno is set accordingly.
+
+Example:
+
+    RedisModuleRdbStream *s = RedisModule_RdbStreamCreateFromFile("exp.rdb");
+    RedisModule_RdbSave(ctx, s, 0);
+    RedisModule_RdbStreamFree(s);
+
+<span id="RedisModule_GetInternalSecret"></span>
+
+### `RedisModule_GetInternalSecret`
+
+    const char* RedisModule_GetInternalSecret(RedisModuleCtx *ctx, size_t *len);
+
+**Available since:** unreleased
+
+Returns the internal secret of the cluster.
+Should be used to authenticate as an internal connection to a node in the
+cluster, and by that gain the permissions to execute internal commands.
+
+<span id="section-key-eviction-api"></span>
+
+## Key eviction API
+
+<span id="RedisModule_SetLRU"></span>
+
+### `RedisModule_SetLRU`
+
+    int RedisModule_SetLRU(RedisModuleKey *key, mstime_t lru_idle);
+
+**Available since:** 6.0.0
+
+Set the key last access time for LRU based eviction. not relevant if the
+servers's maxmemory policy is LFU based. Value is idle time in milliseconds.
+returns `REDISMODULE_OK` if the LRU was updated, `REDISMODULE_ERR` otherwise.
+
+<span id="RedisModule_GetLRU"></span>
+
+### `RedisModule_GetLRU`
+
+    int RedisModule_GetLRU(RedisModuleKey *key, mstime_t *lru_idle);
+
+**Available since:** 6.0.0
+
+Gets the key last access time.
+Value is idletime in milliseconds or -1 if the server's eviction policy is
+LFU based.
+returns `REDISMODULE_OK` if when key is valid.
+
+<span id="RedisModule_SetLFU"></span>
+
+### `RedisModule_SetLFU`
+
+    int RedisModule_SetLFU(RedisModuleKey *key, long long lfu_freq);
+
+**Available since:** 6.0.0
+
+Set the key access frequency. only relevant if the server's maxmemory policy
+is LFU based.
+The frequency is a logarithmic counter that provides an indication of
+the access frequencyonly (must be <= 255).
+returns `REDISMODULE_OK` if the LFU was updated, `REDISMODULE_ERR` otherwise.
+
+<span id="RedisModule_GetLFU"></span>
+
+### `RedisModule_GetLFU`
+
+    int RedisModule_GetLFU(RedisModuleKey *key, long long *lfu_freq);
+
+**Available since:** 6.0.0
+
+Gets the key access frequency or -1 if the server's eviction policy is not
+LFU based.
+returns `REDISMODULE_OK` if when key is valid.
+
+<span id="section-miscellaneous-apis"></span>
+
+## Miscellaneous APIs
+
+<span id="RedisModule_GetModuleOptionsAll"></span>
+
+### `RedisModule_GetModuleOptionsAll`
+
+    int RedisModule_GetModuleOptionsAll(void);
+
+**Available since:** 7.2.0
+
+
+Returns the full module options flags mask, using the return value
+the module can check if a certain set of module options are supported
+by the redis server version in use.
+Example:
+
+       int supportedFlags = RedisModule_GetModuleOptionsAll();
+       if (supportedFlags & REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS) {
+             // REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS is supported
+       } else{
+             // REDISMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS is not supported
+       }
+
+<span id="RedisModule_GetContextFlagsAll"></span>
+
+### `RedisModule_GetContextFlagsAll`
+
+    int RedisModule_GetContextFlagsAll(void);
+
+**Available since:** 6.0.9
+
+
+Returns the full ContextFlags mask, using the return value
+the module can check if a certain set of flags are supported
+by the redis server version in use.
+Example:
+
+       int supportedFlags = RedisModule_GetContextFlagsAll();
+       if (supportedFlags & REDISMODULE_CTX_FLAGS_MULTI) {
+             // REDISMODULE_CTX_FLAGS_MULTI is supported
+       } else{
+             // REDISMODULE_CTX_FLAGS_MULTI is not supported
+       }
+
+<span id="RedisModule_GetKeyspaceNotificationFlagsAll"></span>
+
+### `RedisModule_GetKeyspaceNotificationFlagsAll`
+
+    int RedisModule_GetKeyspaceNotificationFlagsAll(void);
+
+**Available since:** 6.0.9
+
+
+Returns the full KeyspaceNotification mask, using the return value
+the module can check if a certain set of flags are supported
+by the redis server version in use.
+Example:
+
+       int supportedFlags = RedisModule_GetKeyspaceNotificationFlagsAll();
+       if (supportedFlags & REDISMODULE_NOTIFY_LOADED) {
+             // REDISMODULE_NOTIFY_LOADED is supported
+       } else{
+             // REDISMODULE_NOTIFY_LOADED is not supported
+       }
+
+<span id="RedisModule_GetServerVersion"></span>
+
+### `RedisModule_GetServerVersion`
+
+    int RedisModule_GetServerVersion(void);
+
+**Available since:** 6.0.9
+
+
+Return the redis version in format of 0x00MMmmpp.
+Example for 6.0.7 the return value will be 0x00060007.
+
+<span id="RedisModule_GetTypeMethodVersion"></span>
+
+### `RedisModule_GetTypeMethodVersion`
+
+    int RedisModule_GetTypeMethodVersion(void);
+
+**Available since:** 6.2.0
+
+
+Return the current redis-server runtime value of `REDISMODULE_TYPE_METHOD_VERSION`.
+You can use that when calling [`RedisModule_CreateDataType`](#RedisModule_CreateDataType) to know which fields of
+`RedisModuleTypeMethods` are gonna be supported and which will be ignored.
+
+<span id="RedisModule_ModuleTypeReplaceValue"></span>
+
+### `RedisModule_ModuleTypeReplaceValue`
+
+    int RedisModule_ModuleTypeReplaceValue(RedisModuleKey *key,
+                                           moduleType *mt,
+                                           void *new_value,
+                                           void **old_value);
+
+**Available since:** 6.0.0
+
+Replace the value assigned to a module type.
+
+The key must be open for writing, have an existing value, and have a moduleType
+that matches the one specified by the caller.
+
+Unlike [`RedisModule_ModuleTypeSetValue()`](#RedisModule_ModuleTypeSetValue) which will free the old value, this function
+simply swaps the old value with the new value.
+
+The function returns `REDISMODULE_OK` on success, `REDISMODULE_ERR` on errors
+such as:
+
+1. Key is not opened for writing.
+2. Key is not a module data type key.
+3. Key is a module datatype other than 'mt'.
+
+If `old_value` is non-NULL, the old value is returned by reference.
+
+<span id="RedisModule_GetCommandKeysWithFlags"></span>
+
+### `RedisModule_GetCommandKeysWithFlags`
+
+    int *RedisModule_GetCommandKeysWithFlags(RedisModuleCtx *ctx,
+                                             RedisModuleString **argv,
+                                             int argc,
+                                             int *num_keys,
+                                             int **out_flags);
+
+**Available since:** 7.0.0
+
+For a specified command, parse its arguments and return an array that
+contains the indexes of all key name arguments. This function is
+essentially a more efficient way to do `COMMAND GETKEYS`.
+
+The `out_flags` argument is optional, and can be set to NULL.
+When provided it is filled with `REDISMODULE_CMD_KEY_` flags in matching
+indexes with the key indexes of the returned array.
+
+A NULL return value indicates the specified command has no keys, or
+an error condition. Error conditions are indicated by setting errno
+as follows:
+
+* ENOENT: Specified command does not exist.
+* EINVAL: Invalid command arity specified.
+
+NOTE: The returned array is not a Redis Module object so it does not
+get automatically freed even when auto-memory is used. The caller
+must explicitly call [`RedisModule_Free()`](#RedisModule_Free) to free it, same as the `out_flags` pointer if
+used.
+
+<span id="RedisModule_GetCommandKeys"></span>
+
+### `RedisModule_GetCommandKeys`
+
+    int *RedisModule_GetCommandKeys(RedisModuleCtx *ctx,
+                                    RedisModuleString **argv,
+                                    int argc,
+                                    int *num_keys);
+
+**Available since:** 6.0.9
+
+Identical to [`RedisModule_GetCommandKeysWithFlags`](#RedisModule_GetCommandKeysWithFlags) when flags are not needed.
+
+<span id="RedisModule_GetCurrentCommandName"></span>
+
+### `RedisModule_GetCurrentCommandName`
+
+    const char *RedisModule_GetCurrentCommandName(RedisModuleCtx *ctx);
+
+**Available since:** 6.2.5
+
+Return the name of the command currently running
+
+<span id="section-defrag-api"></span>
+
+## Defrag API
+
+<span id="RedisModule_RegisterDefragFunc"></span>
+
+### `RedisModule_RegisterDefragFunc`
+
+    int RedisModule_RegisterDefragFunc(RedisModuleCtx *ctx,
+                                       RedisModuleDefragFunc cb);
+
+**Available since:** 6.2.0
+
+Register a defrag callback for global data, i.e. anything that the module
+may allocate that is not tied to a specific data type.
+
+<span id="RedisModule_RegisterDefragFunc2"></span>
+
+### `RedisModule_RegisterDefragFunc2`
+
+    int RedisModule_RegisterDefragFunc2(RedisModuleCtx *ctx,
+                                        RedisModuleDefragFunc2 cb);
+
+**Available since:** unreleased
+
+Register a defrag callback for global data, i.e. anything that the module
+may allocate that is not tied to a specific data type.
+This is a more advanced version of [`RedisModule_RegisterDefragFunc`](#RedisModule_RegisterDefragFunc), in that it takes
+a callbacks that has a return value, and can use [`RedisModule_DefragShouldStop`](#RedisModule_DefragShouldStop)
+in and indicate that it should be called again later, or is it done (returned 0).
+
+<span id="RedisModule_RegisterDefragCallbacks"></span>
+
+### `RedisModule_RegisterDefragCallbacks`
+
+    int RedisModule_RegisterDefragCallbacks(RedisModuleCtx *ctx,
+                                            RedisModuleDefragFunc start,
+                                            RedisModuleDefragFunc end);
+
+**Available since:** unreleased
+
+Register a defrag callbacks that will be called when defrag operation starts and ends.
+
+The callbacks are the same as [`RedisModule_RegisterDefragFunc`](#RedisModule_RegisterDefragFunc) but the user
+can also assume the callbacks are called when the defrag operation starts and ends.
+
+<span id="RedisModule_DefragShouldStop"></span>
+
+### `RedisModule_DefragShouldStop`
+
+    int RedisModule_DefragShouldStop(RedisModuleDefragCtx *ctx);
+
+**Available since:** 6.2.0
+
+When the data type defrag callback iterates complex structures, this
+function should be called periodically. A zero (false) return
+indicates the callback may continue its work. A non-zero value (true)
+indicates it should stop.
+
+When stopped, the callback may use [`RedisModule_DefragCursorSet()`](#RedisModule_DefragCursorSet) to store its
+position so it can later use [`RedisModule_DefragCursorGet()`](#RedisModule_DefragCursorGet) to resume defragging.
+
+When stopped and more work is left to be done, the callback should
+return 1. Otherwise, it should return 0.
+
+<span id="RedisModule_DefragCursorSet"></span>
+
+### `RedisModule_DefragCursorSet`
+
+    int RedisModule_DefragCursorSet(RedisModuleDefragCtx *ctx,
+                                    unsigned long cursor);
+
+**Available since:** 6.2.0
+
+Store an arbitrary cursor value for future re-use.
+
+This should only be called if [`RedisModule_DefragShouldStop()`](#RedisModule_DefragShouldStop) has returned a non-zero
+value and the defrag callback is about to exit without fully iterating its
+data type.
+
+This behavior is reserved to cases where late defrag is performed. Late
+defrag is selected for keys that implement the `free_effort` callback and
+return a `free_effort` value that is larger than the defrag
+'active-defrag-max-scan-fields' configuration directive.
+
+Smaller keys, keys that do not implement `free_effort` or the global
+defrag callback are not called in late-defrag mode. In those cases, a
+call to this function will return `REDISMODULE_ERR`.
+
+The cursor may be used by the module to represent some progress into the
+module's data type. Modules may also store additional cursor-related
+information locally and use the cursor as a flag that indicates when
+traversal of a new key begins. This is possible because the API makes
+a guarantee that concurrent defragmentation of multiple keys will
+not be performed.
+
+<span id="RedisModule_DefragCursorGet"></span>
+
+### `RedisModule_DefragCursorGet`
+
+    int RedisModule_DefragCursorGet(RedisModuleDefragCtx *ctx,
+                                    unsigned long *cursor);
+
+**Available since:** 6.2.0
+
+Fetch a cursor value that has been previously stored using [`RedisModule_DefragCursorSet()`](#RedisModule_DefragCursorSet).
+
+If not called for a late defrag operation, `REDISMODULE_ERR` will be returned and
+the cursor should be ignored. See [`RedisModule_DefragCursorSet()`](#RedisModule_DefragCursorSet) for more details on
+defrag cursors.
+
+<span id="RedisModule_DefragAlloc"></span>
+
+### `RedisModule_DefragAlloc`
+
+    void *RedisModule_DefragAlloc(RedisModuleDefragCtx *ctx, void *ptr);
+
+**Available since:** 6.2.0
+
+Defrag a memory allocation previously allocated by [`RedisModule_Alloc`](#RedisModule_Alloc), [`RedisModule_Calloc`](#RedisModule_Calloc), etc.
+The defragmentation process involves allocating a new memory block and copying
+the contents to it, like `realloc()`.
+
+If defragmentation was not necessary, NULL is returned and the operation has
+no other effect.
+
+If a non-NULL value is returned, the caller should use the new pointer instead
+of the old one and update any reference to the old pointer, which must not
+be used again.
+
+<span id="RedisModule_DefragAllocRaw"></span>
+
+### `RedisModule_DefragAllocRaw`
+
+    void *RedisModule_DefragAllocRaw(RedisModuleDefragCtx *ctx, size_t size);
+
+**Available since:** unreleased
+
+Allocate memory for defrag purposes
+
+On the common cases user simply want to reallocate a pointer with a single
+owner. For such usecase [`RedisModule_DefragAlloc`](#RedisModule_DefragAlloc) is enough. But on some usecases the user
+might want to replace a pointer with multiple owners in different keys.
+In such case, an in place replacement can not work because the other key still
+keep a pointer to the old value. 
+
+[`RedisModule_DefragAllocRaw`](#RedisModule_DefragAllocRaw) and [`RedisModule_DefragFreeRaw`](#RedisModule_DefragFreeRaw) allows to control when the memory
+for defrag purposes will be allocated and when it will be freed,
+allow to support more complex defrag usecases.
+
+<span id="RedisModule_DefragFreeRaw"></span>
+
+### `RedisModule_DefragFreeRaw`
+
+    void RedisModule_DefragFreeRaw(RedisModuleDefragCtx *ctx, void *ptr);
+
+**Available since:** unreleased
+
+Free memory for defrag purposes
+
+See [`RedisModule_DefragAllocRaw`](#RedisModule_DefragAllocRaw) for more information.
+
+<span id="RedisModule_DefragRedisModuleString"></span>
+
+### `RedisModule_DefragRedisModuleString`
+
+    RedisModuleString *RedisModule_DefragRedisModuleString(RedisModuleDefragCtx *ctx,
+                                                           RedisModuleString *str);
+
+**Available since:** 6.2.0
+
+Defrag a `RedisModuleString` previously allocated by [`RedisModule_Alloc`](#RedisModule_Alloc), [`RedisModule_Calloc`](#RedisModule_Calloc), etc.
+See [`RedisModule_DefragAlloc()`](#RedisModule_DefragAlloc) for more information on how the defragmentation process
+works.
+
+NOTE: It is only possible to defrag strings that have a single reference.
+Typically this means strings retained with [`RedisModule_RetainString`](#RedisModule_RetainString) or [`RedisModule_HoldString`](#RedisModule_HoldString)
+may not be defragmentable. One exception is command argvs which, if retained
+by the module, will end up with a single reference (because the reference
+on the Redis side is dropped as soon as the command callback returns).
+
+<span id="RedisModule_DefragRedisModuleDict"></span>
+
+### `RedisModule_DefragRedisModuleDict`
+
+    RedisModuleDict *RedisModule_DefragRedisModuleDict(RedisModuleDefragCtx *ctx,
+                                                       RedisModuleDict *dict,
+                                                       RedisModuleDefragDictValueCallback valueCB,
+                                                       RedisModuleString **seekTo);
+
+**Available since:** unreleased
+
+Defragment a Redis Module Dictionary by scanning its contents and calling a value
+callback for each value.
+
+The callback gets the current value in the dict, and should update newptr to the new pointer,
+if the value was re-allocated to a different address. The callback also gets the key name just as a reference.
+The callback returns 0 when defrag is complete for this node, 1 when node needs more work.
+
+The API can work incrementally by accepting a seek position to continue from, and
+returning the next position to seek to on the next call (or return NULL when the iteration is completed).
+
+This API returns a new dict if it was re-allocated to a new address (will only
+be attempted when *seekTo is NULL on entry).
+
+<span id="RedisModule_GetKeyNameFromDefragCtx"></span>
+
+### `RedisModule_GetKeyNameFromDefragCtx`
+
+    const RedisModuleString *RedisModule_GetKeyNameFromDefragCtx(RedisModuleDefragCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the name of the key currently being processed.
+There is no guarantee that the key name is always available, so this may return NULL.
+
+<span id="RedisModule_GetDbIdFromDefragCtx"></span>
+
+### `RedisModule_GetDbIdFromDefragCtx`
+
+    int RedisModule_GetDbIdFromDefragCtx(RedisModuleDefragCtx *ctx);
+
+**Available since:** 7.0.0
+
+Returns the database id of the key currently being processed.
+There is no guarantee that this info is always available, so this may return -1.
+
+<span id="section-function-index"></span>
+
+## Function index
+
+* [`RedisModule_ACLAddLogEntry`](#RedisModule_ACLAddLogEntry)
+* [`RedisModule_ACLAddLogEntryByUserName`](#RedisModule_ACLAddLogEntryByUserName)
+* [`RedisModule_ACLCheckChannelPermissions`](#RedisModule_ACLCheckChannelPermissions)
+* [`RedisModule_ACLCheckCommandPermissions`](#RedisModule_ACLCheckCommandPermissions)
+* [`RedisModule_ACLCheckKeyPermissions`](#RedisModule_ACLCheckKeyPermissions)
+* [`RedisModule_ACLCheckKeyPrefixPermissions`](#RedisModule_ACLCheckKeyPrefixPermissions)
+* [`RedisModule_AbortBlock`](#RedisModule_AbortBlock)
+* [`RedisModule_AddACLCategory`](#RedisModule_AddACLCategory)
+* [`RedisModule_AddPostNotificationJob`](#RedisModule_AddPostNotificationJob)
+* [`RedisModule_Alloc`](#RedisModule_Alloc)
+* [`RedisModule_AuthenticateClientWithACLUser`](#RedisModule_AuthenticateClientWithACLUser)
+* [`RedisModule_AuthenticateClientWithUser`](#RedisModule_AuthenticateClientWithUser)
+* [`RedisModule_AutoMemory`](#RedisModule_AutoMemory)
+* [`RedisModule_AvoidReplicaTraffic`](#RedisModule_AvoidReplicaTraffic)
+* [`RedisModule_BlockClient`](#RedisModule_BlockClient)
+* [`RedisModule_BlockClientGetPrivateData`](#RedisModule_BlockClientGetPrivateData)
+* [`RedisModule_BlockClientOnAuth`](#RedisModule_BlockClientOnAuth)
+* [`RedisModule_BlockClientOnKeys`](#RedisModule_BlockClientOnKeys)
+* [`RedisModule_BlockClientOnKeysWithFlags`](#RedisModule_BlockClientOnKeysWithFlags)
+* [`RedisModule_BlockClientSetPrivateData`](#RedisModule_BlockClientSetPrivateData)
+* [`RedisModule_BlockedClientDisconnected`](#RedisModule_BlockedClientDisconnected)
+* [`RedisModule_BlockedClientMeasureTimeEnd`](#RedisModule_BlockedClientMeasureTimeEnd)
+* [`RedisModule_BlockedClientMeasureTimeStart`](#RedisModule_BlockedClientMeasureTimeStart)
+* [`RedisModule_CachedMicroseconds`](#RedisModule_CachedMicroseconds)
+* [`RedisModule_Call`](#RedisModule_Call)
+* [`RedisModule_CallReplyArrayElement`](#RedisModule_CallReplyArrayElement)
+* [`RedisModule_CallReplyAttribute`](#RedisModule_CallReplyAttribute)
+* [`RedisModule_CallReplyAttributeElement`](#RedisModule_CallReplyAttributeElement)
+* [`RedisModule_CallReplyBigNumber`](#RedisModule_CallReplyBigNumber)
+* [`RedisModule_CallReplyBool`](#RedisModule_CallReplyBool)
+* [`RedisModule_CallReplyDouble`](#RedisModule_CallReplyDouble)
+* [`RedisModule_CallReplyInteger`](#RedisModule_CallReplyInteger)
+* [`RedisModule_CallReplyLength`](#RedisModule_CallReplyLength)
+* [`RedisModule_CallReplyMapElement`](#RedisModule_CallReplyMapElement)
+* [`RedisModule_CallReplyPromiseAbort`](#RedisModule_CallReplyPromiseAbort)
+* [`RedisModule_CallReplyPromiseSetUnblockHandler`](#RedisModule_CallReplyPromiseSetUnblockHandler)
+* [`RedisModule_CallReplyProto`](#RedisModule_CallReplyProto)
+* [`RedisModule_CallReplySetElement`](#RedisModule_CallReplySetElement)
+* [`RedisModule_CallReplyStringPtr`](#RedisModule_CallReplyStringPtr)
+* [`RedisModule_CallReplyType`](#RedisModule_CallReplyType)
+* [`RedisModule_CallReplyVerbatim`](#RedisModule_CallReplyVerbatim)
+* [`RedisModule_Calloc`](#RedisModule_Calloc)
+* [`RedisModule_ChannelAtPosWithFlags`](#RedisModule_ChannelAtPosWithFlags)
+* [`RedisModule_CloseKey`](#RedisModule_CloseKey)
+* [`RedisModule_ClusterCanonicalKeyNameInSlot`](#RedisModule_ClusterCanonicalKeyNameInSlot)
+* [`RedisModule_ClusterKeySlot`](#RedisModule_ClusterKeySlot)
+* [`RedisModule_CommandFilterArgDelete`](#RedisModule_CommandFilterArgDelete)
+* [`RedisModule_CommandFilterArgGet`](#RedisModule_CommandFilterArgGet)
+* [`RedisModule_CommandFilterArgInsert`](#RedisModule_CommandFilterArgInsert)
+* [`RedisModule_CommandFilterArgReplace`](#RedisModule_CommandFilterArgReplace)
+* [`RedisModule_CommandFilterArgsCount`](#RedisModule_CommandFilterArgsCount)
+* [`RedisModule_CommandFilterGetClientId`](#RedisModule_CommandFilterGetClientId)
+* [`RedisModule_CreateCommand`](#RedisModule_CreateCommand)
+* [`RedisModule_CreateDataType`](#RedisModule_CreateDataType)
+* [`RedisModule_CreateDict`](#RedisModule_CreateDict)
+* [`RedisModule_CreateModuleUser`](#RedisModule_CreateModuleUser)
+* [`RedisModule_CreateString`](#RedisModule_CreateString)
+* [`RedisModule_CreateStringFromCallReply`](#RedisModule_CreateStringFromCallReply)
+* [`RedisModule_CreateStringFromDouble`](#RedisModule_CreateStringFromDouble)
+* [`RedisModule_CreateStringFromLongDouble`](#RedisModule_CreateStringFromLongDouble)
+* [`RedisModule_CreateStringFromLongLong`](#RedisModule_CreateStringFromLongLong)
+* [`RedisModule_CreateStringFromStreamID`](#RedisModule_CreateStringFromStreamID)
+* [`RedisModule_CreateStringFromString`](#RedisModule_CreateStringFromString)
+* [`RedisModule_CreateStringFromULongLong`](#RedisModule_CreateStringFromULongLong)
+* [`RedisModule_CreateStringPrintf`](#RedisModule_CreateStringPrintf)
+* [`RedisModule_CreateSubcommand`](#RedisModule_CreateSubcommand)
+* [`RedisModule_CreateTimer`](#RedisModule_CreateTimer)
+* [`RedisModule_DbSize`](#RedisModule_DbSize)
+* [`RedisModule_DeauthenticateAndCloseClient`](#RedisModule_DeauthenticateAndCloseClient)
+* [`RedisModule_DefragAlloc`](#RedisModule_DefragAlloc)
+* [`RedisModule_DefragAllocRaw`](#RedisModule_DefragAllocRaw)
+* [`RedisModule_DefragCursorGet`](#RedisModule_DefragCursorGet)
+* [`RedisModule_DefragCursorSet`](#RedisModule_DefragCursorSet)
+* [`RedisModule_DefragFreeRaw`](#RedisModule_DefragFreeRaw)
+* [`RedisModule_DefragRedisModuleDict`](#RedisModule_DefragRedisModuleDict)
+* [`RedisModule_DefragRedisModuleString`](#RedisModule_DefragRedisModuleString)
+* [`RedisModule_DefragShouldStop`](#RedisModule_DefragShouldStop)
+* [`RedisModule_DeleteKey`](#RedisModule_DeleteKey)
+* [`RedisModule_DictCompare`](#RedisModule_DictCompare)
+* [`RedisModule_DictCompareC`](#RedisModule_DictCompareC)
+* [`RedisModule_DictDel`](#RedisModule_DictDel)
+* [`RedisModule_DictDelC`](#RedisModule_DictDelC)
+* [`RedisModule_DictGet`](#RedisModule_DictGet)
+* [`RedisModule_DictGetC`](#RedisModule_DictGetC)
+* [`RedisModule_DictIteratorReseek`](#RedisModule_DictIteratorReseek)
+* [`RedisModule_DictIteratorReseekC`](#RedisModule_DictIteratorReseekC)
+* [`RedisModule_DictIteratorStart`](#RedisModule_DictIteratorStart)
+* [`RedisModule_DictIteratorStartC`](#RedisModule_DictIteratorStartC)
+* [`RedisModule_DictIteratorStop`](#RedisModule_DictIteratorStop)
+* [`RedisModule_DictNext`](#RedisModule_DictNext)
+* [`RedisModule_DictNextC`](#RedisModule_DictNextC)
+* [`RedisModule_DictPrev`](#RedisModule_DictPrev)
+* [`RedisModule_DictPrevC`](#RedisModule_DictPrevC)
+* [`RedisModule_DictReplace`](#RedisModule_DictReplace)
+* [`RedisModule_DictReplaceC`](#RedisModule_DictReplaceC)
+* [`RedisModule_DictSet`](#RedisModule_DictSet)
+* [`RedisModule_DictSetC`](#RedisModule_DictSetC)
+* [`RedisModule_DictSize`](#RedisModule_DictSize)
+* [`RedisModule_DigestAddLongLong`](#RedisModule_DigestAddLongLong)
+* [`RedisModule_DigestAddStringBuffer`](#RedisModule_DigestAddStringBuffer)
+* [`RedisModule_DigestEndSequence`](#RedisModule_DigestEndSequence)
+* [`RedisModule_EmitAOF`](#RedisModule_EmitAOF)
+* [`RedisModule_EventLoopAdd`](#RedisModule_EventLoopAdd)
+* [`RedisModule_EventLoopAddOneShot`](#RedisModule_EventLoopAddOneShot)
+* [`RedisModule_EventLoopDel`](#RedisModule_EventLoopDel)
+* [`RedisModule_ExitFromChild`](#RedisModule_ExitFromChild)
+* [`RedisModule_ExportSharedAPI`](#RedisModule_ExportSharedAPI)
+* [`RedisModule_Fork`](#RedisModule_Fork)
+* [`RedisModule_Free`](#RedisModule_Free)
+* [`RedisModule_FreeCallReply`](#RedisModule_FreeCallReply)
+* [`RedisModule_FreeClusterNodesList`](#RedisModule_FreeClusterNodesList)
+* [`RedisModule_FreeDict`](#RedisModule_FreeDict)
+* [`RedisModule_FreeModuleUser`](#RedisModule_FreeModuleUser)
+* [`RedisModule_FreeServerInfo`](#RedisModule_FreeServerInfo)
+* [`RedisModule_FreeString`](#RedisModule_FreeString)
+* [`RedisModule_FreeThreadSafeContext`](#RedisModule_FreeThreadSafeContext)
+* [`RedisModule_GetAbsExpire`](#RedisModule_GetAbsExpire)
+* [`RedisModule_GetBlockedClientHandle`](#RedisModule_GetBlockedClientHandle)
+* [`RedisModule_GetBlockedClientPrivateData`](#RedisModule_GetBlockedClientPrivateData)
+* [`RedisModule_GetBlockedClientReadyKey`](#RedisModule_GetBlockedClientReadyKey)
+* [`RedisModule_GetClientCertificate`](#RedisModule_GetClientCertificate)
+* [`RedisModule_GetClientId`](#RedisModule_GetClientId)
+* [`RedisModule_GetClientInfoById`](#RedisModule_GetClientInfoById)
+* [`RedisModule_GetClientNameById`](#RedisModule_GetClientNameById)
+* [`RedisModule_GetClientUserNameById`](#RedisModule_GetClientUserNameById)
+* [`RedisModule_GetClusterNodeInfo`](#RedisModule_GetClusterNodeInfo)
+* [`RedisModule_GetClusterNodesList`](#RedisModule_GetClusterNodesList)
+* [`RedisModule_GetClusterSize`](#RedisModule_GetClusterSize)
+* [`RedisModule_GetCommand`](#RedisModule_GetCommand)
+* [`RedisModule_GetCommandKeys`](#RedisModule_GetCommandKeys)
+* [`RedisModule_GetCommandKeysWithFlags`](#RedisModule_GetCommandKeysWithFlags)
+* [`RedisModule_GetContextFlags`](#RedisModule_GetContextFlags)
+* [`RedisModule_GetContextFlagsAll`](#RedisModule_GetContextFlagsAll)
+* [`RedisModule_GetCurrentCommandName`](#RedisModule_GetCurrentCommandName)
+* [`RedisModule_GetCurrentUserName`](#RedisModule_GetCurrentUserName)
+* [`RedisModule_GetDbIdFromDefragCtx`](#RedisModule_GetDbIdFromDefragCtx)
+* [`RedisModule_GetDbIdFromDigest`](#RedisModule_GetDbIdFromDigest)
+* [`RedisModule_GetDbIdFromIO`](#RedisModule_GetDbIdFromIO)
+* [`RedisModule_GetDbIdFromModuleKey`](#RedisModule_GetDbIdFromModuleKey)
+* [`RedisModule_GetDbIdFromOptCtx`](#RedisModule_GetDbIdFromOptCtx)
+* [`RedisModule_GetDetachedThreadSafeContext`](#RedisModule_GetDetachedThreadSafeContext)
+* [`RedisModule_GetExpire`](#RedisModule_GetExpire)
+* [`RedisModule_GetInternalSecret`](#RedisModule_GetInternalSecret)
+* [`RedisModule_GetKeyNameFromDefragCtx`](#RedisModule_GetKeyNameFromDefragCtx)
+* [`RedisModule_GetKeyNameFromDigest`](#RedisModule_GetKeyNameFromDigest)
+* [`RedisModule_GetKeyNameFromIO`](#RedisModule_GetKeyNameFromIO)
+* [`RedisModule_GetKeyNameFromModuleKey`](#RedisModule_GetKeyNameFromModuleKey)
+* [`RedisModule_GetKeyNameFromOptCtx`](#RedisModule_GetKeyNameFromOptCtx)
+* [`RedisModule_GetKeyspaceNotificationFlagsAll`](#RedisModule_GetKeyspaceNotificationFlagsAll)
+* [`RedisModule_GetLFU`](#RedisModule_GetLFU)
+* [`RedisModule_GetLRU`](#RedisModule_GetLRU)
+* [`RedisModule_GetModuleOptionsAll`](#RedisModule_GetModuleOptionsAll)
+* [`RedisModule_GetModuleUserACLString`](#RedisModule_GetModuleUserACLString)
+* [`RedisModule_GetModuleUserFromUserName`](#RedisModule_GetModuleUserFromUserName)
+* [`RedisModule_GetMyClusterID`](#RedisModule_GetMyClusterID)
+* [`RedisModule_GetNotifyKeyspaceEvents`](#RedisModule_GetNotifyKeyspaceEvents)
+* [`RedisModule_GetOpenKeyModesAll`](#RedisModule_GetOpenKeyModesAll)
+* [`RedisModule_GetRandomBytes`](#RedisModule_GetRandomBytes)
+* [`RedisModule_GetRandomHexChars`](#RedisModule_GetRandomHexChars)
+* [`RedisModule_GetSelectedDb`](#RedisModule_GetSelectedDb)
+* [`RedisModule_GetServerInfo`](#RedisModule_GetServerInfo)
+* [`RedisModule_GetServerVersion`](#RedisModule_GetServerVersion)
+* [`RedisModule_GetSharedAPI`](#RedisModule_GetSharedAPI)
+* [`RedisModule_GetThreadSafeContext`](#RedisModule_GetThreadSafeContext)
+* [`RedisModule_GetTimerInfo`](#RedisModule_GetTimerInfo)
+* [`RedisModule_GetToDbIdFromOptCtx`](#RedisModule_GetToDbIdFromOptCtx)
+* [`RedisModule_GetToKeyNameFromOptCtx`](#RedisModule_GetToKeyNameFromOptCtx)
+* [`RedisModule_GetTypeMethodVersion`](#RedisModule_GetTypeMethodVersion)
+* [`RedisModule_GetUsedMemoryRatio`](#RedisModule_GetUsedMemoryRatio)
+* [`RedisModule_HashFieldMinExpire`](#RedisModule_HashFieldMinExpire)
+* [`RedisModule_HashGet`](#RedisModule_HashGet)
+* [`RedisModule_HashSet`](#RedisModule_HashSet)
+* [`RedisModule_HoldString`](#RedisModule_HoldString)
+* [`RedisModule_InfoAddFieldCString`](#RedisModule_InfoAddFieldCString)
+* [`RedisModule_InfoAddFieldDouble`](#RedisModule_InfoAddFieldDouble)
+* [`RedisModule_InfoAddFieldLongLong`](#RedisModule_InfoAddFieldLongLong)
+* [`RedisModule_InfoAddFieldString`](#RedisModule_InfoAddFieldString)
+* [`RedisModule_InfoAddFieldULongLong`](#RedisModule_InfoAddFieldULongLong)
+* [`RedisModule_InfoAddSection`](#RedisModule_InfoAddSection)
+* [`RedisModule_InfoBeginDictField`](#RedisModule_InfoBeginDictField)
+* [`RedisModule_InfoEndDictField`](#RedisModule_InfoEndDictField)
+* [`RedisModule_IsBlockedReplyRequest`](#RedisModule_IsBlockedReplyRequest)
+* [`RedisModule_IsBlockedTimeoutRequest`](#RedisModule_IsBlockedTimeoutRequest)
+* [`RedisModule_IsChannelsPositionRequest`](#RedisModule_IsChannelsPositionRequest)
+* [`RedisModule_IsIOError`](#RedisModule_IsIOError)
+* [`RedisModule_IsKeysPositionRequest`](#RedisModule_IsKeysPositionRequest)
+* [`RedisModule_IsModuleNameBusy`](#RedisModule_IsModuleNameBusy)
+* [`RedisModule_IsSubEventSupported`](#RedisModule_IsSubEventSupported)
+* [`RedisModule_KeyAtPos`](#RedisModule_KeyAtPos)
+* [`RedisModule_KeyAtPosWithFlags`](#RedisModule_KeyAtPosWithFlags)
+* [`RedisModule_KeyExists`](#RedisModule_KeyExists)
+* [`RedisModule_KeyType`](#RedisModule_KeyType)
+* [`RedisModule_KillForkChild`](#RedisModule_KillForkChild)
+* [`RedisModule_LatencyAddSample`](#RedisModule_LatencyAddSample)
+* [`RedisModule_ListDelete`](#RedisModule_ListDelete)
+* [`RedisModule_ListGet`](#RedisModule_ListGet)
+* [`RedisModule_ListInsert`](#RedisModule_ListInsert)
+* [`RedisModule_ListPop`](#RedisModule_ListPop)
+* [`RedisModule_ListPush`](#RedisModule_ListPush)
+* [`RedisModule_ListSet`](#RedisModule_ListSet)
+* [`RedisModule_LoadConfigs`](#RedisModule_LoadConfigs)
+* [`RedisModule_LoadDataTypeFromString`](#RedisModule_LoadDataTypeFromString)
+* [`RedisModule_LoadDataTypeFromStringEncver`](#RedisModule_LoadDataTypeFromStringEncver)
+* [`RedisModule_LoadDefaultConfigs`](#RedisModule_LoadDefaultConfigs)
+* [`RedisModule_LoadDouble`](#RedisModule_LoadDouble)
+* [`RedisModule_LoadFloat`](#RedisModule_LoadFloat)
+* [`RedisModule_LoadLongDouble`](#RedisModule_LoadLongDouble)
+* [`RedisModule_LoadSigned`](#RedisModule_LoadSigned)
+* [`RedisModule_LoadString`](#RedisModule_LoadString)
+* [`RedisModule_LoadStringBuffer`](#RedisModule_LoadStringBuffer)
+* [`RedisModule_LoadUnsigned`](#RedisModule_LoadUnsigned)
+* [`RedisModule_Log`](#RedisModule_Log)
+* [`RedisModule_LogIOError`](#RedisModule_LogIOError)
+* [`RedisModule_MallocSize`](#RedisModule_MallocSize)
+* [`RedisModule_MallocSizeDict`](#RedisModule_MallocSizeDict)
+* [`RedisModule_MallocSizeString`](#RedisModule_MallocSizeString)
+* [`RedisModule_MallocUsableSize`](#RedisModule_MallocUsableSize)
+* [`RedisModule_Microseconds`](#RedisModule_Microseconds)
+* [`RedisModule_Milliseconds`](#RedisModule_Milliseconds)
+* [`RedisModule_ModuleTypeGetType`](#RedisModule_ModuleTypeGetType)
+* [`RedisModule_ModuleTypeGetValue`](#RedisModule_ModuleTypeGetValue)
+* [`RedisModule_ModuleTypeReplaceValue`](#RedisModule_ModuleTypeReplaceValue)
+* [`RedisModule_ModuleTypeSetValue`](#RedisModule_ModuleTypeSetValue)
+* [`RedisModule_MonotonicMicroseconds`](#RedisModule_MonotonicMicroseconds)
+* [`RedisModule_NotifyKeyspaceEvent`](#RedisModule_NotifyKeyspaceEvent)
+* [`RedisModule_OpenKey`](#RedisModule_OpenKey)
+* [`RedisModule_PoolAlloc`](#RedisModule_PoolAlloc)
+* [`RedisModule_PublishMessage`](#RedisModule_PublishMessage)
+* [`RedisModule_PublishMessageShard`](#RedisModule_PublishMessageShard)
+* [`RedisModule_RandomKey`](#RedisModule_RandomKey)
+* [`RedisModule_RdbLoad`](#RedisModule_RdbLoad)
+* [`RedisModule_RdbSave`](#RedisModule_RdbSave)
+* [`RedisModule_RdbStreamCreateFromFile`](#RedisModule_RdbStreamCreateFromFile)
+* [`RedisModule_RdbStreamFree`](#RedisModule_RdbStreamFree)
+* [`RedisModule_Realloc`](#RedisModule_Realloc)
+* [`RedisModule_RedactClientCommandArgument`](#RedisModule_RedactClientCommandArgument)
+* [`RedisModule_RegisterAuthCallback`](#RedisModule_RegisterAuthCallback)
+* [`RedisModule_RegisterBoolConfig`](#RedisModule_RegisterBoolConfig)
+* [`RedisModule_RegisterClusterMessageReceiver`](#RedisModule_RegisterClusterMessageReceiver)
+* [`RedisModule_RegisterCommandFilter`](#RedisModule_RegisterCommandFilter)
+* [`RedisModule_RegisterDefragCallbacks`](#RedisModule_RegisterDefragCallbacks)
+* [`RedisModule_RegisterDefragFunc`](#RedisModule_RegisterDefragFunc)
+* [`RedisModule_RegisterDefragFunc2`](#RedisModule_RegisterDefragFunc2)
+* [`RedisModule_RegisterEnumConfig`](#RedisModule_RegisterEnumConfig)
+* [`RedisModule_RegisterInfoFunc`](#RedisModule_RegisterInfoFunc)
+* [`RedisModule_RegisterNumericConfig`](#RedisModule_RegisterNumericConfig)
+* [`RedisModule_RegisterStringConfig`](#RedisModule_RegisterStringConfig)
+* [`RedisModule_Replicate`](#RedisModule_Replicate)
+* [`RedisModule_ReplicateVerbatim`](#RedisModule_ReplicateVerbatim)
+* [`RedisModule_ReplySetArrayLength`](#RedisModule_ReplySetArrayLength)
+* [`RedisModule_ReplySetAttributeLength`](#RedisModule_ReplySetAttributeLength)
+* [`RedisModule_ReplySetMapLength`](#RedisModule_ReplySetMapLength)
+* [`RedisModule_ReplySetSetLength`](#RedisModule_ReplySetSetLength)
+* [`RedisModule_ReplyWithArray`](#RedisModule_ReplyWithArray)
+* [`RedisModule_ReplyWithAttribute`](#RedisModule_ReplyWithAttribute)
+* [`RedisModule_ReplyWithBigNumber`](#RedisModule_ReplyWithBigNumber)
+* [`RedisModule_ReplyWithBool`](#RedisModule_ReplyWithBool)
+* [`RedisModule_ReplyWithCString`](#RedisModule_ReplyWithCString)
+* [`RedisModule_ReplyWithCallReply`](#RedisModule_ReplyWithCallReply)
+* [`RedisModule_ReplyWithDouble`](#RedisModule_ReplyWithDouble)
+* [`RedisModule_ReplyWithEmptyArray`](#RedisModule_ReplyWithEmptyArray)
+* [`RedisModule_ReplyWithEmptyString`](#RedisModule_ReplyWithEmptyString)
+* [`RedisModule_ReplyWithError`](#RedisModule_ReplyWithError)
+* [`RedisModule_ReplyWithErrorFormat`](#RedisModule_ReplyWithErrorFormat)
+* [`RedisModule_ReplyWithLongDouble`](#RedisModule_ReplyWithLongDouble)
+* [`RedisModule_ReplyWithLongLong`](#RedisModule_ReplyWithLongLong)
+* [`RedisModule_ReplyWithMap`](#RedisModule_ReplyWithMap)
+* [`RedisModule_ReplyWithNull`](#RedisModule_ReplyWithNull)
+* [`RedisModule_ReplyWithNullArray`](#RedisModule_ReplyWithNullArray)
+* [`RedisModule_ReplyWithSet`](#RedisModule_ReplyWithSet)
+* [`RedisModule_ReplyWithSimpleString`](#RedisModule_ReplyWithSimpleString)
+* [`RedisModule_ReplyWithString`](#RedisModule_ReplyWithString)
+* [`RedisModule_ReplyWithStringBuffer`](#RedisModule_ReplyWithStringBuffer)
+* [`RedisModule_ReplyWithVerbatimString`](#RedisModule_ReplyWithVerbatimString)
+* [`RedisModule_ReplyWithVerbatimStringType`](#RedisModule_ReplyWithVerbatimStringType)
+* [`RedisModule_ResetDataset`](#RedisModule_ResetDataset)
+* [`RedisModule_RetainString`](#RedisModule_RetainString)
+* [`RedisModule_SaveDataTypeToString`](#RedisModule_SaveDataTypeToString)
+* [`RedisModule_SaveDouble`](#RedisModule_SaveDouble)
+* [`RedisModule_SaveFloat`](#RedisModule_SaveFloat)
+* [`RedisModule_SaveLongDouble`](#RedisModule_SaveLongDouble)
+* [`RedisModule_SaveSigned`](#RedisModule_SaveSigned)
+* [`RedisModule_SaveString`](#RedisModule_SaveString)
+* [`RedisModule_SaveStringBuffer`](#RedisModule_SaveStringBuffer)
+* [`RedisModule_SaveUnsigned`](#RedisModule_SaveUnsigned)
+* [`RedisModule_Scan`](#RedisModule_Scan)
+* [`RedisModule_ScanCursorCreate`](#RedisModule_ScanCursorCreate)
+* [`RedisModule_ScanCursorDestroy`](#RedisModule_ScanCursorDestroy)
+* [`RedisModule_ScanCursorRestart`](#RedisModule_ScanCursorRestart)
+* [`RedisModule_ScanKey`](#RedisModule_ScanKey)
+* [`RedisModule_SelectDb`](#RedisModule_SelectDb)
+* [`RedisModule_SendChildHeartbeat`](#RedisModule_SendChildHeartbeat)
+* [`RedisModule_SendClusterMessage`](#RedisModule_SendClusterMessage)
+* [`RedisModule_ServerInfoGetField`](#RedisModule_ServerInfoGetField)
+* [`RedisModule_ServerInfoGetFieldC`](#RedisModule_ServerInfoGetFieldC)
+* [`RedisModule_ServerInfoGetFieldDouble`](#RedisModule_ServerInfoGetFieldDouble)
+* [`RedisModule_ServerInfoGetFieldSigned`](#RedisModule_ServerInfoGetFieldSigned)
+* [`RedisModule_ServerInfoGetFieldUnsigned`](#RedisModule_ServerInfoGetFieldUnsigned)
+* [`RedisModule_SetAbsExpire`](#RedisModule_SetAbsExpire)
+* [`RedisModule_SetClientNameById`](#RedisModule_SetClientNameById)
+* [`RedisModule_SetClusterFlags`](#RedisModule_SetClusterFlags)
+* [`RedisModule_SetCommandACLCategories`](#RedisModule_SetCommandACLCategories)
+* [`RedisModule_SetCommandInfo`](#RedisModule_SetCommandInfo)
+* [`RedisModule_SetContextUser`](#RedisModule_SetContextUser)
+* [`RedisModule_SetDisconnectCallback`](#RedisModule_SetDisconnectCallback)
+* [`RedisModule_SetExpire`](#RedisModule_SetExpire)
+* [`RedisModule_SetLFU`](#RedisModule_SetLFU)
+* [`RedisModule_SetLRU`](#RedisModule_SetLRU)
+* [`RedisModule_SetModuleOptions`](#RedisModule_SetModuleOptions)
+* [`RedisModule_SetModuleUserACL`](#RedisModule_SetModuleUserACL)
+* [`RedisModule_SetModuleUserACLString`](#RedisModule_SetModuleUserACLString)
+* [`RedisModule_SignalKeyAsReady`](#RedisModule_SignalKeyAsReady)
+* [`RedisModule_SignalModifiedKey`](#RedisModule_SignalModifiedKey)
+* [`RedisModule_StopTimer`](#RedisModule_StopTimer)
+* [`RedisModule_Strdup`](#RedisModule_Strdup)
+* [`RedisModule_StreamAdd`](#RedisModule_StreamAdd)
+* [`RedisModule_StreamDelete`](#RedisModule_StreamDelete)
+* [`RedisModule_StreamIteratorDelete`](#RedisModule_StreamIteratorDelete)
+* [`RedisModule_StreamIteratorNextField`](#RedisModule_StreamIteratorNextField)
+* [`RedisModule_StreamIteratorNextID`](#RedisModule_StreamIteratorNextID)
+* [`RedisModule_StreamIteratorStart`](#RedisModule_StreamIteratorStart)
+* [`RedisModule_StreamIteratorStop`](#RedisModule_StreamIteratorStop)
+* [`RedisModule_StreamTrimByID`](#RedisModule_StreamTrimByID)
+* [`RedisModule_StreamTrimByLength`](#RedisModule_StreamTrimByLength)
+* [`RedisModule_StringAppendBuffer`](#RedisModule_StringAppendBuffer)
+* [`RedisModule_StringCompare`](#RedisModule_StringCompare)
+* [`RedisModule_StringDMA`](#RedisModule_StringDMA)
+* [`RedisModule_StringPtrLen`](#RedisModule_StringPtrLen)
+* [`RedisModule_StringSet`](#RedisModule_StringSet)
+* [`RedisModule_StringToDouble`](#RedisModule_StringToDouble)
+* [`RedisModule_StringToLongDouble`](#RedisModule_StringToLongDouble)
+* [`RedisModule_StringToLongLong`](#RedisModule_StringToLongLong)
+* [`RedisModule_StringToStreamID`](#RedisModule_StringToStreamID)
+* [`RedisModule_StringToULongLong`](#RedisModule_StringToULongLong)
+* [`RedisModule_StringTruncate`](#RedisModule_StringTruncate)
+* [`RedisModule_SubscribeToKeyspaceEvents`](#RedisModule_SubscribeToKeyspaceEvents)
+* [`RedisModule_SubscribeToServerEvent`](#RedisModule_SubscribeToServerEvent)
+* [`RedisModule_ThreadSafeContextLock`](#RedisModule_ThreadSafeContextLock)
+* [`RedisModule_ThreadSafeContextTryLock`](#RedisModule_ThreadSafeContextTryLock)
+* [`RedisModule_ThreadSafeContextUnlock`](#RedisModule_ThreadSafeContextUnlock)
+* [`RedisModule_TrimStringAllocation`](#RedisModule_TrimStringAllocation)
+* [`RedisModule_TryAlloc`](#RedisModule_TryAlloc)
+* [`RedisModule_TryCalloc`](#RedisModule_TryCalloc)
+* [`RedisModule_TryRealloc`](#RedisModule_TryRealloc)
+* [`RedisModule_UnblockClient`](#RedisModule_UnblockClient)
+* [`RedisModule_UnlinkKey`](#RedisModule_UnlinkKey)
+* [`RedisModule_UnregisterCommandFilter`](#RedisModule_UnregisterCommandFilter)
+* [`RedisModule_ValueLength`](#RedisModule_ValueLength)
+* [`RedisModule_WrongArity`](#RedisModule_WrongArity)
+* [`RedisModule_Yield`](#RedisModule_Yield)
+* [`RedisModule_ZsetAdd`](#RedisModule_ZsetAdd)
+* [`RedisModule_ZsetFirstInLexRange`](#RedisModule_ZsetFirstInLexRange)
+* [`RedisModule_ZsetFirstInScoreRange`](#RedisModule_ZsetFirstInScoreRange)
+* [`RedisModule_ZsetIncrby`](#RedisModule_ZsetIncrby)
+* [`RedisModule_ZsetLastInLexRange`](#RedisModule_ZsetLastInLexRange)
+* [`RedisModule_ZsetLastInScoreRange`](#RedisModule_ZsetLastInScoreRange)
+* [`RedisModule_ZsetRangeCurrentElement`](#RedisModule_ZsetRangeCurrentElement)
+* [`RedisModule_ZsetRangeEndReached`](#RedisModule_ZsetRangeEndReached)
+* [`RedisModule_ZsetRangeNext`](#RedisModule_ZsetRangeNext)
+* [`RedisModule_ZsetRangePrev`](#RedisModule_ZsetRangePrev)
+* [`RedisModule_ZsetRangeStop`](#RedisModule_ZsetRangeStop)
+* [`RedisModule_ZsetRem`](#RedisModule_ZsetRem)
+* [`RedisModule_ZsetScore`](#RedisModule_ZsetScore)
+* [`RedisModule__Assert`](#RedisModule__Assert)
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to use native types in a Redis module
+linkTitle: Native types API
+title: Modules API for native types
+weight: 1
+---
+
+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.
+
+We call the ability of Redis modules to implement new data structures that
+feel like native Redis ones **native types support**. This document describes
+the API exported by the Redis modules system in order to create new data
+structures and handle the serialization in RDB files, the rewriting process
+in AOF, the type reporting via the [`TYPE`]({{< relref "/commands/type" >}}) command, and so forth.
+
+## Overview of native types
+
+A module exporting a native type is composed of the following main parts:
+
+* The implementation of some kind of new data structure and of commands operating on the new data structure.
+* A set of callbacks that handle: RDB saving, RDB loading, AOF rewriting, releasing of a value associated with a key, calculation of a value digest (hash) to be used with the `DEBUG DIGEST` command.
+* A 9 characters name that is unique to each module native data type.
+* An encoding version, used to persist into RDB files a module-specific data version, so that a module will be able to load older representations from RDB files.
+
+While to handle RDB loading, saving and AOF rewriting may look complex as a first glance, the modules API provide very high level function for handling all this, without requiring the user to handle read/write errors, so in practical terms, writing a new data structure for Redis is a simple task.
+
+A **very easy** to understand but complete example of native type implementation
+is available inside the Redis distribution in the `/modules/hellotype.c` file.
+The reader is encouraged to read the documentation by looking at this example
+implementation to see how things are applied in the practice.
+
+## Register a new data type
+
+In order to register a new native type into the Redis core, the module needs
+to declare a global variable that will hold a reference to the data type.
+The API to register the data type will return a data type reference that will
+be stored in the global variable.
+
+    static RedisModuleType *MyType;
+    #define MYTYPE_ENCODING_VERSION 0
+
+    int RedisModule_OnLoad(RedisModuleCtx *ctx) {
+	RedisModuleTypeMethods tm = {
+	    .version = REDISMODULE_TYPE_METHOD_VERSION,
+	    .rdb_load = MyTypeRDBLoad,
+	    .rdb_save = MyTypeRDBSave,
+	    .aof_rewrite = MyTypeAOFRewrite,
+	    .free = MyTypeFree
+	};
+
+        MyType = RedisModule_CreateDataType(ctx, "MyType-AZ",
+		MYTYPE_ENCODING_VERSION, &tm);
+        if (MyType == NULL) return REDISMODULE_ERR;
+    }
+
+As you can see from the example above, a single API call is needed in order to
+register the new type. However a number of function pointers are passed as
+arguments. Certain are optionals while some are mandatory. The above set
+of methods *must* be passed, while `.digest` and `.mem_usage` are optional
+and are currently not actually supported by the modules internals, so for
+now you can just ignore them.
+
+The `ctx` argument is the context that we receive in the `OnLoad` function.
+The type `name` is a 9 character name in the character set that includes
+from `A-Z`, `a-z`, `0-9`, plus the underscore `_` and minus `-` characters.
+
+Note that **this name must be unique** for each data type in the Redis
+ecosystem, so be creative, use both lower-case and upper case if it makes
+sense, and try to use the convention of mixing the type name with the name
+of the author of the module, to create a 9 character unique name.
+
+**NOTE:** It is very important that the name is exactly 9 chars or the
+registration of the type will fail. Read more to understand why.
+
+For example if I'm building a *b-tree* data structure and my name is *antirez*
+I'll call my type **btree1-az**. The name, converted to a 64 bit integer,
+is stored inside the RDB file when saving the type, and will be used when the
+RDB data is loaded in order to resolve what module can load the data. If Redis
+finds no matching module, the integer is converted back to a name in order to
+provide some clue to the user about what module is missing in order to load
+the data.
+
+The type name is also used as a reply for the [`TYPE`]({{< relref "/commands/type" >}}) command when called
+with a key holding the registered type.
+
+The `encver` argument is the encoding version used by the module to store data
+inside the RDB file. For example I can start with an encoding version of 0,
+but later when I release version 2.0 of my module, I can switch encoding to
+something better. The new module will register with an encoding version of 1,
+so when it saves new RDB files, the new version will be stored on disk. However
+when loading RDB files, the module `rdb_load` method will be called even if
+there is data found for a different encoding version (and the encoding version
+is passed as argument to `rdb_load`), so that the module can still load old
+RDB files.
+
+The last argument is a structure used in order to pass the type methods to the
+registration function: `rdb_load`, `rdb_save`, `aof_rewrite`, `digest` and
+`free` and `mem_usage` are all callbacks with the following prototypes and uses:
+
+    typedef void *(*RedisModuleTypeLoadFunc)(RedisModuleIO *rdb, int encver);
+    typedef void (*RedisModuleTypeSaveFunc)(RedisModuleIO *rdb, void *value);
+    typedef void (*RedisModuleTypeRewriteFunc)(RedisModuleIO *aof, RedisModuleString *key, void *value);
+    typedef size_t (*RedisModuleTypeMemUsageFunc)(void *value);
+    typedef void (*RedisModuleTypeDigestFunc)(RedisModuleDigest *digest, void *value);
+    typedef void (*RedisModuleTypeFreeFunc)(void *value);
+
+* `rdb_load` is called when loading data from the RDB file. It loads data in the same format as `rdb_save` produces.
+* `rdb_save` is called when saving data to the RDB file.
+* `aof_rewrite` is called when the AOF is being rewritten, and the module needs to tell Redis what is the sequence of commands to recreate the content of a given key.
+* `digest` is called when `DEBUG DIGEST` is executed and a key holding this module type is found. Currently this is not yet implemented so the function ca be left empty.
+* `mem_usage` is called when the [`MEMORY`]({{< relref "/commands/memory" >}}) command asks for the total memory consumed by a specific key, and is used in order to get the amount of bytes used by the module value.
+* `free` is called when a key with the module native type is deleted via [`DEL`]({{< relref "/commands/del" >}}) or in any other mean, in order to let the module reclaim the memory associated with such a value.
+
+### Why module types require nine character names
+
+When Redis persists to RDB files, modules specific data types require to
+be persisted as well. Now RDB files are sequences of key-value pairs
+like the following:
+
+    [1 byte type] [key] [a type specific value]
+
+The 1 byte type identifies strings, lists, sets, and so forth. In the case
+of modules data, it is set to a special value of `module data`, but of
+course this is not enough, we need the information needed to link a specific
+value with a specific module type that is able to load and handle it.
+
+So when we save a `type specific value` about a module, we prefix it with
+a 64 bit integer. 64 bits is large enough to store the information needed
+in order to lookup the module that can handle that specific type, but is
+short enough that we can prefix each module value we store inside the RDB
+without making the final RDB file too big. At the same time, this solution
+of prefixing the value with a 64 bit *signature* does not require to do
+strange things like defining in the RDB header a list of modules specific
+types. Everything is pretty simple.
+
+So, what you can store in 64 bits in order to identify a given module in
+a reliable way? Well if you build a character set of 64 symbols, you can
+easily store 9 characters of 6 bits, and you are left with 10 bits, that
+are used in order to store the *encoding version* of the type, so that
+the same type can evolve in the future and provide a different and more
+efficient or updated serialization format for RDB files.
+
+So the 64 bit prefix stored before each module value is like the following:
+
+    6|6|6|6|6|6|6|6|6|10
+
+The first 9 elements are 6-bits characters, the final 10 bits is the
+encoding version.
+
+When the RDB file is loaded back, it reads the 64 bit value, masks the final
+10 bits, and searches for a matching module in the modules types cache.
+When a matching one is found, the method to load the RDB file value is called
+with the 10 bits encoding version as argument, so that the module knows
+what version of the data layout to load, if it can support multiple versions.
+
+Now the interesting thing about all this is that, if instead the module type
+cannot be resolved, since there is no loaded module having this signature,
+we can convert back the 64 bit value into a 9 characters name, and print
+an error to the user that includes the module type name! So that she or he
+immediately realizes what's wrong.
+
+### Set and get keys
+
+After registering our new data type in the `RedisModule_OnLoad()` function,
+we also need to be able to set Redis keys having as value our native type.
+
+This normally happens in the context of commands that write data to a key.
+The native types API allow to set and get keys to module native data types,
+and to test if a given key is already associated to a value of a specific data
+type.
+
+The API uses the normal modules `RedisModule_OpenKey()` low level key access
+interface in order to deal with this. This is an example of setting a
+native type private data structure to a Redis key:
+
+    RedisModuleKey *key = RedisModule_OpenKey(ctx,keyname,REDISMODULE_WRITE);
+    struct some_private_struct *data = createMyDataStructure();
+    RedisModule_ModuleTypeSetValue(key,MyType,data);
+
+The function `RedisModule_ModuleTypeSetValue()` is used with a key handle open
+for writing, and gets three arguments: the key handle, the reference to the
+native type, as obtained during the type registration, and finally a `void*`
+pointer that contains the private data implementing the module native type.
+
+Note that Redis has no clues at all about what your data contains. It will
+just call the callbacks you provided during the method registration in order
+to perform operations on the type.
+
+Similarly we can retrieve the private data from a key using this function:
+
+    struct some_private_struct *data;
+    data = RedisModule_ModuleTypeGetValue(key);
+
+We can also test for a key to have our native type as value:
+
+    if (RedisModule_ModuleTypeGetType(key) == MyType) {
+        /* ... do something ... */
+    }
+
+However for the calls to do the right thing, we need to check if the key
+is empty, if it contains a value of the right kind, and so forth. So
+the idiomatic code to implement a command writing to our native type
+is along these lines:
+
+    RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
+        REDISMODULE_READ|REDISMODULE_WRITE);
+    int type = RedisModule_KeyType(key);
+    if (type != REDISMODULE_KEYTYPE_EMPTY &&
+        RedisModule_ModuleTypeGetType(key) != MyType)
+    {
+        return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
+    }
+
+Then if we successfully verified the key is not of the wrong type, and
+we are going to write to it, we usually want to create a new data structure if
+the key is empty, or retrieve the reference to the value associated to the
+key if there is already one:
+
+    /* Create an empty value object if the key is currently empty. */
+    struct some_private_struct *data;
+    if (type == REDISMODULE_KEYTYPE_EMPTY) {
+        data = createMyDataStructure();
+        RedisModule_ModuleTypeSetValue(key,MyTyke,data);
+    } else {
+        data = RedisModule_ModuleTypeGetValue(key);
+    }
+    /* Do something with 'data'... */
+
+### Free method
+
+As already mentioned, when Redis needs to free a key holding a native type
+value, it needs help from the module in order to release the memory. This
+is the reason why we pass a `free` callback during the type registration:
+
+    typedef void (*RedisModuleTypeFreeFunc)(void *value);
+
+A trivial implementation of the free method can be something like this,
+assuming our data structure is composed of a single allocation:
+
+    void MyTypeFreeCallback(void *value) {
+        RedisModule_Free(value);
+    }
+
+However a more real world one will call some function that performs a more
+complex memory reclaiming, by casting the void pointer to some structure
+and freeing all the resources composing the value.
+
+### RDB load and save methods
+
+The RDB saving and loading callbacks need to create (and load back) a
+representation of the data type on disk. Redis offers a high level API
+that can automatically store inside the RDB file the following types:
+
+* Unsigned 64 bit integers.
+* Signed 64 bit integers.
+* Doubles.
+* Strings.
+
+It is up to the module to find a viable representation using the above base
+types. However note that while the integer and double values are stored
+and loaded in an architecture and *endianness* agnostic way, if you use
+the raw string saving API to, for example, save a structure on disk, you
+have to care those details yourself.
+
+This is the list of functions performing RDB saving and loading:
+
+    void RedisModule_SaveUnsigned(RedisModuleIO *io, uint64_t value);
+    uint64_t RedisModule_LoadUnsigned(RedisModuleIO *io);
+    void RedisModule_SaveSigned(RedisModuleIO *io, int64_t value);
+    int64_t RedisModule_LoadSigned(RedisModuleIO *io);
+    void RedisModule_SaveString(RedisModuleIO *io, RedisModuleString *s);
+    void RedisModule_SaveStringBuffer(RedisModuleIO *io, const char *str, size_t len);
+    RedisModuleString *RedisModule_LoadString(RedisModuleIO *io);
+    char *RedisModule_LoadStringBuffer(RedisModuleIO *io, size_t *lenptr);
+    void RedisModule_SaveDouble(RedisModuleIO *io, double value);
+    double RedisModule_LoadDouble(RedisModuleIO *io);
+
+The functions don't require any error checking from the module, that can
+always assume calls succeed.
+
+As an example, imagine I've a native type that implements an array of
+double values, with the following structure:
+
+    struct double_array {
+        size_t count;
+        double *values;
+    };
+
+My `rdb_save` method may look like the following:
+
+    void DoubleArrayRDBSave(RedisModuleIO *io, void *ptr) {
+        struct dobule_array *da = ptr;
+        RedisModule_SaveUnsigned(io,da->count);
+        for (size_t j = 0; j < da->count; j++)
+            RedisModule_SaveDouble(io,da->values[j]);
+    }
+
+What we did was to store the number of elements followed by each double
+value. So when later we'll have to load the structure in the `rdb_load`
+method we'll do something like this:
+
+    void *DoubleArrayRDBLoad(RedisModuleIO *io, int encver) {
+        if (encver != DOUBLE_ARRAY_ENC_VER) {
+            /* We should actually log an error here, or try to implement
+               the ability to load older versions of our data structure. */
+            return NULL;
+        }
+
+        struct double_array *da;
+        da = RedisModule_Alloc(sizeof(*da));
+        da->count = RedisModule_LoadUnsigned(io);
+        da->values = RedisModule_Alloc(da->count * sizeof(double));
+        for (size_t j = 0; j < da->count; j++)
+            da->values[j] = RedisModule_LoadDouble(io);
+        return da;
+    }
+
+The load callback just reconstruct back the data structure from the data
+we stored in the RDB file.
+
+Note that while there is no error handling on the API that writes and reads
+from disk, still the load callback can return NULL on errors in case what
+it reads does not look correct. Redis will just panic in that case.
+
+### AOF rewriting
+
+    void RedisModule_EmitAOF(RedisModuleIO *io, const char *cmdname, const char *fmt, ...);
+
+### Allocate memory
+
+Modules data types should try to use `RedisModule_Alloc()` functions family
+in order to allocate, reallocate and release heap memory used to implement the native data structures (see the other Redis Modules documentation for detailed information).
+
+This is not just useful in order for Redis to be able to account for the memory used by the module, but there are also more advantages:
+
+* Redis uses the `jemalloc` allocator, that often prevents fragmentation problems that could be caused by using the libc allocator.
+* When loading strings from the RDB file, the native types API is able to return strings allocated directly with `RedisModule_Alloc()`, so that the module can directly link this memory into the data structure representation, avoiding a useless copy of the data.
+
+Even if you are using external libraries implementing your data structures, the
+allocation functions provided by the module API is exactly compatible with
+`malloc()`, `realloc()`, `free()` and `strdup()`, so converting the libraries
+in order to use these functions should be trivial.
+
+In case you have an external library that uses libc `malloc()`, and you want
+to avoid replacing manually all the calls with the Redis Modules API calls,
+an approach could be to use simple macros in order to replace the libc calls
+with the Redis API calls. Something like this could work:
+
+    #define malloc RedisModule_Alloc
+    #define realloc RedisModule_Realloc
+    #define free RedisModule_Free
+    #define strdup RedisModule_Strdup
+
+However take in mind that mixing libc calls with Redis API calls will result
+into troubles and crashes, so if you replace calls using macros, you need to
+make sure that all the calls are correctly replaced, and that the code with
+the substituted calls will never, for example, attempt to call
+`RedisModule_Free()` with a pointer allocated using libc `malloc()`.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'How to implement blocking commands in a Redis module
+
+  '
+linkTitle: Blocking commands
+title: Redis modules and blocking commands
+weight: 1
+---
+
+Redis has a few blocking commands among the built-in set of commands.
+One of the most used is [`BLPOP`]({{< relref "/commands/blpop" >}}) (or the symmetric [`BRPOP`]({{< relref "/commands/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`]({{< relref "/commands/blpop" >}}) case, a
+long computation happening in a thread, to receive some data from the
+network, and so forth.
+
+Redis modules have the ability to implement blocking commands as well,
+this documentation shows how the API works and describes a few patterns
+that can be used in order to model blocking commands.
+
+
+How blocking and resuming works.
+---
+
+_Note: You may want to check the `helloblock.c` example in the Redis source tree
+inside the `src/modules` directory, for a simple to understand example
+on how the blocking API is applied._
+
+In Redis modules, commands are implemented by callback functions that
+are invoked by the Redis core when the specific command is called
+by the user. Normally the callback terminates its execution sending
+some reply to the client. Using the following function instead, the
+function implementing the module command may request that the client
+is put into the blocked state:
+
+    RedisModuleBlockedClient *RedisModule_BlockClient(RedisModuleCtx *ctx, RedisModuleCmdFunc reply_callback, RedisModuleCmdFunc timeout_callback, void (*free_privdata)(void*), long long timeout_ms);
+
+The function returns a `RedisModuleBlockedClient` object, which is later
+used in order to unblock the client. The arguments have the following
+meaning:
+
+* `ctx` is the command execution context as usually in the rest of the API.
+* `reply_callback` is the callback, having the same prototype of a normal command function, that is called when the client is unblocked in order to return a reply to the client.
+* `timeout_callback` is the callback, having the same prototype of a normal command function that is called when the client reached the `ms` timeout.
+* `free_privdata` is the callback that is called in order to free the private data. Private data is a pointer to some data that is passed between the API used to unblock the client, to the callback that will send the reply to the client. We'll see how this mechanism works later in this document.
+* `ms` is the timeout in milliseconds. When the timeout is reached, the timeout callback is called and the client is automatically aborted.
+
+Once a client is blocked, it can be unblocked with the following API:
+
+    int RedisModule_UnblockClient(RedisModuleBlockedClient *bc, void *privdata);
+
+The function takes as argument the blocked client object returned by
+the previous call to `RedisModule_BlockClient()`, and unblock the client.
+Immediately before the client gets unblocked, the `reply_callback` function
+specified when the client was blocked is called: this function will
+have access to the `privdata` pointer used here.
+
+IMPORTANT: The above function is thread safe, and can be called from within
+a thread doing some work in order to implement the command that blocked
+the client.
+
+The `privdata` data will be freed automatically using the `free_privdata`
+callback when the client is unblocked. This is useful **since the reply
+callback may never be called** in case the client timeouts or disconnects
+from the server, so it's important that it's up to an external function
+to have the responsibility to free the data passed if needed.
+
+To better understand how the API works, we can imagine writing a command
+that blocks a client for one second, and then send as reply "Hello!".
+
+Note: arity checks and other non important things are not implemented
+int his command, in order to take the example simple.
+
+    int Example_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
+                             int argc)
+    {
+        RedisModuleBlockedClient *bc =
+            RedisModule_BlockClient(ctx,reply_func,timeout_func,NULL,0);
+
+        pthread_t tid;
+        pthread_create(&tid,NULL,threadmain,bc);
+
+        return REDISMODULE_OK;
+    }
+
+    void *threadmain(void *arg) {
+        RedisModuleBlockedClient *bc = arg;
+
+        sleep(1); /* Wait one second and unblock. */
+        RedisModule_UnblockClient(bc,NULL);
+    }
+
+The above command blocks the client ASAP, spawning a thread that will
+wait a second and will unblock the client. Let's check the reply and
+timeout callbacks, which are in our case very similar, since they
+just reply the client with a different reply type.
+
+    int reply_func(RedisModuleCtx *ctx, RedisModuleString **argv,
+                   int argc)
+    {
+        return RedisModule_ReplyWithSimpleString(ctx,"Hello!");
+    }
+
+    int timeout_func(RedisModuleCtx *ctx, RedisModuleString **argv,
+                   int argc)
+    {
+        return RedisModule_ReplyWithNull(ctx);
+    }
+
+The reply callback just sends the "Hello!" string to the client.
+The important bit here is that the reply callback is called when the
+client is unblocked from the thread.
+
+The timeout command returns `NULL`, as it often happens with actual
+Redis blocking commands timing out.
+
+Passing reply data when unblocking
+---
+
+The above example is simple to understand but lacks an important
+real world aspect of an actual blocking command implementation: often
+the reply function will need to know what to reply to the client,
+and this information is often provided as the client is unblocked.
+
+We could modify the above example so that the thread generates a
+random number after waiting one second. You can think at it as an
+actually expansive operation of some kind. Then this random number
+can be passed to the reply function so that we return it to the command
+caller. In order to make this working, we modify the functions as follow:
+
+    void *threadmain(void *arg) {
+        RedisModuleBlockedClient *bc = arg;
+
+        sleep(1); /* Wait one second and unblock. */
+
+        long *mynumber = RedisModule_Alloc(sizeof(long));
+        *mynumber = rand();
+        RedisModule_UnblockClient(bc,mynumber);
+    }
+
+As you can see, now the unblocking call is passing some private data,
+that is the `mynumber` pointer, to the reply callback. In order to
+obtain this private data, the reply callback will use the following
+function:
+
+    void *RedisModule_GetBlockedClientPrivateData(RedisModuleCtx *ctx);
+
+So our reply callback is modified like that:
+
+    int reply_func(RedisModuleCtx *ctx, RedisModuleString **argv,
+                   int argc)
+    {
+        long *mynumber = RedisModule_GetBlockedClientPrivateData(ctx);
+        /* IMPORTANT: don't free mynumber here, but in the
+         * free privdata callback. */
+        return RedisModule_ReplyWithLongLong(ctx,mynumber);
+    }
+
+Note that we also need to pass a `free_privdata` function when blocking
+the client with `RedisModule_BlockClient()`, since the allocated
+long value must be freed. Our callback will look like the following:
+
+    void free_privdata(void *privdata) {
+        RedisModule_Free(privdata);
+    }
+
+NOTE: It is important to stress that the private data is best freed in the
+`free_privdata` callback because the reply function may not be called
+if the client disconnects or timeout.
+
+Also note that the private data is also accessible from the timeout
+callback, always using the `GetBlockedClientPrivateData()` API.
+
+Aborting the blocking of a client
+---
+
+One problem that sometimes arises is that we need to allocate resources
+in order to implement the non blocking command. So we block the client,
+then, for example, try to create a thread, but the thread creation function
+returns an error. What to do in such a condition in order to recover? We
+don't want to take the client blocked, nor we want to call `UnblockClient()`
+because this will trigger the reply callback to be called.
+
+In this case the best thing to do is to use the following function:
+
+    int RedisModule_AbortBlock(RedisModuleBlockedClient *bc);
+
+Practically this is how to use it:
+
+    int Example_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
+                             int argc)
+    {
+        RedisModuleBlockedClient *bc =
+            RedisModule_BlockClient(ctx,reply_func,timeout_func,NULL,0);
+
+        pthread_t tid;
+        if (pthread_create(&tid,NULL,threadmain,bc) != 0) {
+            RedisModule_AbortBlock(bc);
+            RedisModule_ReplyWithError(ctx,"Sorry can't create a thread");
+        }
+
+        return REDISMODULE_OK;
+    }
+
+The client will be unblocked but the reply callback will not be called.
+
+Implementing the command, reply and timeout callback using a single function
+---
+
+The following functions can be used in order to implement the reply and
+callback with the same function that implements the primary command
+function:
+
+    int RedisModule_IsBlockedReplyRequest(RedisModuleCtx *ctx);
+    int RedisModule_IsBlockedTimeoutRequest(RedisModuleCtx *ctx);
+
+So I could rewrite the example command without using a separated
+reply and timeout callback:
+
+    int Example_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
+                             int argc)
+    {
+        if (RedisModule_IsBlockedReplyRequest(ctx)) {
+            long *mynumber = RedisModule_GetBlockedClientPrivateData(ctx);
+            return RedisModule_ReplyWithLongLong(ctx,mynumber);
+        } else if (RedisModule_IsBlockedTimeoutRequest) {
+            return RedisModule_ReplyWithNull(ctx);
+        }
+
+        RedisModuleBlockedClient *bc =
+            RedisModule_BlockClient(ctx,reply_func,timeout_func,NULL,0);
+
+        pthread_t tid;
+        if (pthread_create(&tid,NULL,threadmain,bc) != 0) {
+            RedisModule_AbortBlock(bc);
+            RedisModule_ReplyWithError(ctx,"Sorry can't create a thread");
+        }
+
+        return REDISMODULE_OK;
+    }
+
+Functionally is the same but there are people that will prefer the less
+verbose implementation that concentrates most of the command logic in a
+single function.
+
+Working on copies of data inside a thread
+---
+
+An interesting pattern in order to work with threads implementing the
+slow part of a command, is to work with a copy of the data, so that
+while some operation is performed in a key, the user continues to see
+the old version. However when the thread terminated its work, the
+representations are swapped and the new, processed version, is used.
+
+An example of this approach is the
+[Neural Redis module](https://github.com/antirez/neural-redis)
+where neural networks are trained in different threads while the
+user can still execute and inspect their older versions.
+
+Future work
+---
+
+An API is work in progress right now in order to allow Redis modules APIs
+to be called in a safe way from threads, so that the threaded command
+can access the data space and do incremental operations.
+
+There is no ETA for this feature but it may appear in the course of the
+Redis 4.0 release at some point.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Introduction to writing Redis modules
+
+  '
+linkTitle: Modules API
+title: Redis modules API
+weight: 2
+---
+
+The modules documentation is composed of the following pages:
+
+* Introduction to Redis modules (this file). An overview about Redis Modules system and API. It's a good idea to start your reading here.
+* [Implementing native data types]({{< relref "/develop/reference/modules/modules-native-types" >}}) covers the implementation of native data types into modules.
+* [Blocking operations]({{< relref "/develop/reference/modules/modules-blocking-ops" >}}) shows how to write blocking commands that will not reply immediately, but will block the client, without blocking the Redis server, and will provide a reply whenever will be possible.
+* [Redis modules API reference]({{< relref "/develop/reference/modules/modules-api-ref" >}}) is generated from module.c top comments of RedisModule functions. It is a good reference in order to understand how each function works.
+
+Redis modules make it possible to extend Redis functionality using external
+modules, rapidly implementing new Redis commands with features
+similar to what can be done inside the core itself.
+
+Redis modules are dynamic libraries that can be loaded into Redis at
+startup, or using the [`MODULE LOAD`]({{< relref "/commands/module-load" >}}) command. Redis exports a C API, in the
+form of a single C header file called `redismodule.h`. Modules are meant
+to be written in C, however it will be possible to use C++ or other languages
+that have C binding functionalities.
+
+Modules are designed in order to be loaded into different versions of Redis,
+so a given module does not need to be designed, or recompiled, in order to
+run with a specific version of Redis. For this reason, the module will
+register to the Redis core using a specific API version. The current API
+version is "1".
+
+This document is about an alpha version of Redis modules. API, functionalities
+and other details may change in the future.
+
+## Loading modules
+
+In order to test the module you are developing, you can load the module
+using the following `redis.conf` configuration directive:
+
+    loadmodule /path/to/mymodule.so
+
+It is also possible to load a module at runtime using the following command:
+
+    MODULE LOAD /path/to/mymodule.so
+
+In order to list all loaded modules, use:
+
+    MODULE LIST
+
+Finally, you can unload (and later reload if you wish) a module using the
+following command:
+
+    MODULE UNLOAD mymodule
+
+Note that `mymodule` above is not the filename without the `.so` suffix, but
+instead, the name the module used to register itself into the Redis core.
+The name can be obtained using [`MODULE LIST`]({{< relref "/commands/module-list" >}}). However it is good practice
+that the filename of the dynamic library is the same as the name the module
+uses to register itself into the Redis core.
+
+## The simplest module you can write
+
+In order to show the different parts of a module, here we'll show a very
+simple module that implements a command that outputs a random number.
+
+    #include "redismodule.h"
+    #include <stdlib.h>
+
+    int HelloworldRand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+        RedisModule_ReplyWithLongLong(ctx,rand());
+        return REDISMODULE_OK;
+    }
+
+    int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+        if (RedisModule_Init(ctx,"helloworld",1,REDISMODULE_APIVER_1)
+            == REDISMODULE_ERR) return REDISMODULE_ERR;
+
+        if (RedisModule_CreateCommand(ctx,"helloworld.rand",
+            HelloworldRand_RedisCommand, "fast random",
+            0, 0, 0) == REDISMODULE_ERR)
+            return REDISMODULE_ERR;
+
+        return REDISMODULE_OK;
+    }
+
+The example module has two functions. One implements a command called
+HELLOWORLD.RAND. This function is specific of that module. However the
+other function called `RedisModule_OnLoad()` must be present in each
+Redis module. It is the entry point for the module to be initialized,
+register its commands, and potentially other private data structures
+it uses.
+
+Note that it is a good idea for modules to call commands with the
+name of the module followed by a dot, and finally the command name,
+like in the case of `HELLOWORLD.RAND`. This way it is less likely to
+have collisions.
+
+Note that if different modules have colliding commands, they'll not be
+able to work in Redis at the same time, since the function
+`RedisModule_CreateCommand` will fail in one of the modules, so the module
+loading will abort returning an error condition.
+
+## Module initialization
+
+The above example shows the usage of the function `RedisModule_Init()`.
+It should be the first function called by the module `OnLoad` function.
+The following is the function prototype:
+
+    int RedisModule_Init(RedisModuleCtx *ctx, const char *modulename,
+                         int module_version, int api_version);
+
+The `Init` function announces the Redis core that the module has a given
+name, its version (that is reported by [`MODULE LIST`]({{< relref "/commands/module-list" >}})), and that is willing
+to use a specific version of the API.
+
+If the API version is wrong, the name is already taken, or there are other
+similar errors, the function will return `REDISMODULE_ERR`, and the module
+`OnLoad` function should return ASAP with an error.
+
+Before the `Init` function is called, no other API function can be called,
+otherwise the module will segfault and the Redis instance will crash.
+
+The second function called, `RedisModule_CreateCommand`, is used in order
+to register commands into the Redis core. The following is the prototype:
+
+    int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name,
+                                  RedisModuleCmdFunc cmdfunc, const char *strflags,
+                                  int firstkey, int lastkey, int keystep);
+
+As you can see, most Redis modules API calls all take as first argument
+the `context` of the module, so that they have a reference to the module
+calling it, to the command and client executing a given command, and so forth.
+
+To create a new command, the above function needs the context, the command's
+name, a pointer to the function implementing the command, the command's flags
+and the positions of key names in the command's arguments.
+
+The function that implements the command must have the following prototype:
+
+    int mycommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
+
+The command function arguments are just the context, that will be passed
+to all the other API calls, the command argument vector, and total number
+of arguments, as passed by the user.
+
+As you can see, the arguments are provided as pointers to a specific data
+type, the `RedisModuleString`. This is an opaque data type you have API
+functions to access and use, direct access to its fields is never needed.
+
+Zooming into the example command implementation, we can find another call:
+
+    int RedisModule_ReplyWithLongLong(RedisModuleCtx *ctx, long long integer);
+
+This function returns an integer to the client that invoked the command,
+exactly like other Redis commands do, like for example [`INCR`]({{< relref "/commands/incr" >}}) or [`SCARD`]({{< relref "/commands/scard" >}}).
+
+## Module cleanup
+
+In most cases, there is no need for special cleanup.
+When a module is unloaded, Redis will automatically unregister commands and
+unsubscribe from notifications.
+However in the case where a module contains some persistent memory or
+configuration, a module may include an optional `RedisModule_OnUnload`
+function.
+If a module provides this function, it will be invoked during the module unload
+process.
+The following is the function prototype:
+
+    int RedisModule_OnUnload(RedisModuleCtx *ctx);
+
+The `OnUnload` function may prevent module unloading by returning
+`REDISMODULE_ERR`.
+Otherwise, `REDISMODULE_OK` should be returned.
+
+## Setup and dependencies of a Redis module
+
+Redis modules don't depend on Redis or some other library, nor they
+need to be compiled with a specific `redismodule.h` file. In order
+to create a new module, just copy a recent version of `redismodule.h`
+in your source tree, link all the libraries you want, and create
+a dynamic library having the `RedisModule_OnLoad()` function symbol
+exported.
+
+The module will be able to load into different versions of Redis.
+
+A module can be designed to support both newer and older Redis versions where certain API functions are not available in all versions.
+If an API function is not implemented in the currently running Redis version, the function pointer is set to NULL.
+This allows the module to check if a function exists before using it:
+
+    if (RedisModule_SetCommandInfo != NULL) {
+        RedisModule_SetCommandInfo(cmd, &info);
+    }
+
+In recent versions of `redismodule.h`, a convenience macro `RMAPI_FUNC_SUPPORTED(funcname)` is defined.
+Using the macro or just comparing with NULL is a matter of personal preference.
+
+## Passing configuration parameters to Redis modules
+
+When the module is loaded with the [`MODULE LOAD`]({{< relref "/commands/module-load" >}}) command, or using the
+`loadmodule` directive in the `redis.conf` file, the user is able to pass
+configuration parameters to the module by adding arguments after the module
+file name:
+
+    loadmodule mymodule.so foo bar 1234
+
+In the above example the strings `foo`, `bar` and `1234` will be passed
+to the module `OnLoad()` function in the `argv` argument as an array
+of RedisModuleString pointers. The number of arguments passed is into `argc`.
+
+The way you can access those strings will be explained in the rest of this
+document. Normally the module will store the module configuration parameters
+in some `static` global variable that can be accessed module wide, so that
+the configuration can change the behavior of different commands.
+
+## Working with RedisModuleString objects
+
+The command argument vector `argv` passed to module commands, and the
+return value of other module APIs functions, are of type `RedisModuleString`.
+
+Usually you directly pass module strings to other API calls, however sometimes
+you may need to directly access the string object.
+
+There are a few functions in order to work with string objects:
+
+    const char *RedisModule_StringPtrLen(RedisModuleString *string, size_t *len);
+
+The above function accesses a string by returning its pointer and setting its
+length in `len`.
+You should never write to a string object pointer, as you can see from the
+`const` pointer qualifier.
+
+However, if you want, you can create new string objects using the following
+API:
+
+    RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len);
+
+The string returned by the above command must be freed using a corresponding
+call to `RedisModule_FreeString()`:
+
+    void RedisModule_FreeString(RedisModuleString *str);
+
+However if you want to avoid having to free strings, the automatic memory
+management, covered later in this document, can be a good alternative, by
+doing it for you.
+
+Note that the strings provided via the argument vector `argv` never need
+to be freed. You only need to free new strings you create, or new strings
+returned by other APIs, where it is specified that the returned string must
+be freed.
+
+## Creating strings from numbers or parsing strings as numbers
+
+Creating a new string from an integer is a very common operation, so there
+is a function to do this:
+
+    RedisModuleString *mystr = RedisModule_CreateStringFromLongLong(ctx,10);
+
+Similarly in order to parse a string as a number:
+
+    long long myval;
+    if (RedisModule_StringToLongLong(ctx,argv[1],&myval) == REDISMODULE_OK) {
+        /* Do something with 'myval' */
+    }
+
+## Accessing Redis keys from modules
+
+Most Redis modules, in order to be useful, have to interact with the Redis
+data space (this is not always true, for example an ID generator may
+never touch Redis keys). Redis modules have two different APIs in order to
+access the Redis data space, one is a low level API that provides very
+fast access and a set of functions to manipulate Redis data structures.
+The other API is more high level, and allows to call Redis commands and
+fetch the result, similarly to how Lua scripts access Redis.
+
+The high level API is also useful in order to access Redis functionalities
+that are not available as APIs.
+
+In general modules developers should prefer the low level API, because commands
+implemented using the low level API run at a speed comparable to the speed
+of native Redis commands. However there are definitely use cases for the
+higher level API. For example often the bottleneck could be processing the
+data and not accessing it.
+
+Also note that sometimes using the low level API is not harder compared to
+the higher level one.
+
+## Calling Redis commands
+
+The high level API to access Redis is the sum of the `RedisModule_Call()`
+function, together with the functions needed in order to access the
+reply object returned by `Call()`.
+
+`RedisModule_Call` uses a special calling convention, with a format specifier
+that is used to specify what kind of objects you are passing as arguments
+to the function.
+
+Redis commands are invoked just using a command name and a list of arguments.
+However when calling commands, the arguments may originate from different
+kind of strings: null-terminated C strings, RedisModuleString objects as
+received from the `argv` parameter in the command implementation, binary
+safe C buffers with a pointer and a length, and so forth.
+
+For example if I want to call [`INCRBY`]({{< relref "/commands/incrby" >}}) using a first argument (the key)
+a string received in the argument vector `argv`, which is an array
+of RedisModuleString object pointers, and a C string representing the
+number "10" as second argument (the increment), I'll use the following
+function call:
+
+    RedisModuleCallReply *reply;
+    reply = RedisModule_Call(ctx,"INCRBY","sc",argv[1],"10");
+
+The first argument is the context, and the second is always a null terminated
+C string with the command name. The third argument is the format specifier
+where each character corresponds to the type of the arguments that will follow.
+In the above case `"sc"` means a RedisModuleString object, and a null
+terminated C string. The other arguments are just the two arguments as
+specified. In fact `argv[1]` is a RedisModuleString and `"10"` is a null
+terminated C string.
+
+This is the full list of format specifiers:
+
+* **c** -- Null terminated C string pointer.
+* **b** -- C buffer, two arguments needed: C string pointer and `size_t` length.
+* **s** -- RedisModuleString as received in `argv` or by other Redis module APIs returning a RedisModuleString object.
+* **l** -- Long long integer.
+* **v** -- Array of RedisModuleString objects.
+* **!** -- This modifier just tells the function to replicate the command to replicas and AOF. It is ignored from the point of view of arguments parsing.
+* **A** -- This modifier, when `!` is given, tells to suppress AOF propagation: the command will be propagated only to replicas.
+* **R** -- This modifier, when `!` is given, tells to suppress replicas propagation: the command will be propagated only to the AOF if enabled.
+
+The function returns a `RedisModuleCallReply` object on success, on
+error NULL is returned.
+
+NULL is returned when the command name is invalid, the format specifier uses
+characters that are not recognized, or when the command is called with the
+wrong number of arguments. In the above cases the `errno` var is set to `EINVAL`. NULL is also returned when, in an instance with Cluster enabled, the target
+keys are about non local hash slots. In this case `errno` is set to `EPERM`.
+
+## Working with RedisModuleCallReply objects.
+
+`RedisModuleCall` returns reply objects that can be accessed using the
+`RedisModule_CallReply*` family of functions.
+
+In order to obtain the type or reply (corresponding to one of the data types
+supported by the Redis protocol), the function `RedisModule_CallReplyType()`
+is used:
+
+    reply = RedisModule_Call(ctx,"INCRBY","sc",argv[1],"10");
+    if (RedisModule_CallReplyType(reply) == REDISMODULE_REPLY_INTEGER) {
+        long long myval = RedisModule_CallReplyInteger(reply);
+        /* Do something with myval. */
+    }
+
+Valid reply types are:
+
+* `REDISMODULE_REPLY_STRING` Bulk string or status replies.
+* `REDISMODULE_REPLY_ERROR` Errors.
+* `REDISMODULE_REPLY_INTEGER` Signed 64 bit integers.
+* `REDISMODULE_REPLY_ARRAY` Array of replies.
+* `REDISMODULE_REPLY_NULL` NULL reply.
+
+Strings, errors and arrays have an associated length. For strings and errors
+the length corresponds to the length of the string. For arrays the length
+is the number of elements. To obtain the reply length the following function
+is used:
+
+    size_t reply_len = RedisModule_CallReplyLength(reply);
+
+In order to obtain the value of an integer reply, the following function is used, as already shown in the example above:
+
+    long long reply_integer_val = RedisModule_CallReplyInteger(reply);
+
+Called with a reply object of the wrong type, the above function always
+returns `LLONG_MIN`.
+
+Sub elements of array replies are accessed this way:
+
+    RedisModuleCallReply *subreply;
+    subreply = RedisModule_CallReplyArrayElement(reply,idx);
+
+The above function returns NULL if you try to access out of range elements.
+
+Strings and errors (which are like strings but with a different type) can
+be accessed using in the following way, making sure to never write to
+the resulting pointer (that is returned as a `const` pointer so that
+misusing must be pretty explicit):
+
+    size_t len;
+    char *ptr = RedisModule_CallReplyStringPtr(reply,&len);
+
+If the reply type is not a string or an error, NULL is returned.
+
+RedisCallReply objects are not the same as module string objects
+(RedisModuleString types). However sometimes you may need to pass replies
+of type string or integer, to API functions expecting a module string.
+
+When this is the case, you may want to evaluate if using the low level
+API could be a simpler way to implement your command, or you can use
+the following function in order to create a new string object from a
+call reply of type string, error or integer:
+
+    RedisModuleString *mystr = RedisModule_CreateStringFromCallReply(myreply);
+
+If the reply is not of the right type, NULL is returned.
+The returned string object should be released with `RedisModule_FreeString()`
+as usually, or by enabling automatic memory management (see corresponding
+section).
+
+## Releasing call reply objects
+
+Reply objects must be freed using `RedisModule_FreeCallReply`. For arrays,
+you need to free only the top level reply, not the nested replies.
+Currently the module implementation provides a protection in order to avoid
+crashing if you free a nested reply object for error, however this feature
+is not guaranteed to be here forever, so should not be considered part
+of the API.
+
+If you use automatic memory management (explained later in this document)
+you don't need to free replies (but you still could if you wish to release
+memory ASAP).
+
+## Returning values from Redis commands
+
+Like normal Redis commands, new commands implemented via modules must be
+able to return values to the caller. The API exports a set of functions for
+this goal, in order to return the usual types of the Redis protocol, and
+arrays of such types as elements. Also errors can be returned with any
+error string and code (the error code is the initial uppercase letters in
+the error message, like the "BUSY" string in the "BUSY the sever is busy" error
+message).
+
+All the functions to send a reply to the client are called
+`RedisModule_ReplyWith<something>`.
+
+To return an error, use:
+
+    RedisModule_ReplyWithError(RedisModuleCtx *ctx, const char *err);
+
+There is a predefined error string for key of wrong type errors:
+
+    REDISMODULE_ERRORMSG_WRONGTYPE
+
+Example usage:
+
+    RedisModule_ReplyWithError(ctx,"ERR invalid arguments");
+
+We already saw how to reply with a `long long` in the examples above:
+
+    RedisModule_ReplyWithLongLong(ctx,12345);
+
+To reply with a simple string, that can't contain binary values or newlines,
+(so it's suitable to send small words, like "OK") we use:
+
+    RedisModule_ReplyWithSimpleString(ctx,"OK");
+
+It's possible to reply with "bulk strings" that are binary safe, using
+two different functions:
+
+    int RedisModule_ReplyWithStringBuffer(RedisModuleCtx *ctx, const char *buf, size_t len);
+
+    int RedisModule_ReplyWithString(RedisModuleCtx *ctx, RedisModuleString *str);
+
+The first function gets a C pointer and length. The second a RedisModuleString
+object. Use one or the other depending on the source type you have at hand.
+
+In order to reply with an array, you just need to use a function to emit the
+array length, followed by as many calls to the above functions as the number
+of elements of the array are:
+
+    RedisModule_ReplyWithArray(ctx,2);
+    RedisModule_ReplyWithStringBuffer(ctx,"age",3);
+    RedisModule_ReplyWithLongLong(ctx,22);
+
+To return nested arrays is easy, your nested array element just uses another
+call to `RedisModule_ReplyWithArray()` followed by the calls to emit the
+sub array elements.
+
+## Returning arrays with dynamic length
+
+Sometimes it is not possible to know beforehand the number of items of
+an array. As an example, think of a Redis module implementing a FACTOR
+command that given a number outputs the prime factors. Instead of
+factorializing the number, storing the prime factors into an array, and
+later produce the command reply, a better solution is to start an array
+reply where the length is not known, and set it later. This is accomplished
+with a special argument to `RedisModule_ReplyWithArray()`:
+
+    RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);
+
+The above call starts an array reply so we can use other `ReplyWith` calls
+in order to produce the array items. Finally in order to set the length,
+use the following call:
+
+    RedisModule_ReplySetArrayLength(ctx, number_of_items);
+
+In the case of the FACTOR command, this translates to some code similar
+to this:
+
+    RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);
+    number_of_factors = 0;
+    while(still_factors) {
+        RedisModule_ReplyWithLongLong(ctx, some_factor);
+        number_of_factors++;
+    }
+    RedisModule_ReplySetArrayLength(ctx, number_of_factors);
+
+Another common use case for this feature is iterating over the arrays of
+some collection and only returning the ones passing some kind of filtering.
+
+It is possible to have multiple nested arrays with postponed reply.
+Each call to `SetArray()` will set the length of the latest corresponding
+call to `ReplyWithArray()`:
+
+    RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);
+    ... generate 100 elements ...
+    RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);
+    ... generate 10 elements ...
+    RedisModule_ReplySetArrayLength(ctx, 10);
+    RedisModule_ReplySetArrayLength(ctx, 100);
+
+This creates a 100 items array having as last element a 10 items array.
+
+## Arity and type checks
+
+Often commands need to check that the number of arguments and type of the key
+is correct. In order to report a wrong arity, there is a specific function
+called `RedisModule_WrongArity()`. The usage is trivial:
+
+    if (argc != 2) return RedisModule_WrongArity(ctx);
+
+Checking for the wrong type involves opening the key and checking the type:
+
+    RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
+        REDISMODULE_READ|REDISMODULE_WRITE);
+
+    int keytype = RedisModule_KeyType(key);
+    if (keytype != REDISMODULE_KEYTYPE_STRING &&
+        keytype != REDISMODULE_KEYTYPE_EMPTY)
+    {
+        RedisModule_CloseKey(key);
+        return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
+    }
+
+Note that you often want to proceed with a command both if the key
+is of the expected type, or if it's empty.
+
+## Low level access to keys
+
+Low level access to keys allow to perform operations on value objects associated
+to keys directly, with a speed similar to what Redis uses internally to
+implement the built-in commands.
+
+Once a key is opened, a key pointer is returned that will be used with all the
+other low level API calls in order to perform operations on the key or its
+associated value.
+
+Because the API is meant to be very fast, it cannot do too many run-time
+checks, so the user must be aware of certain rules to follow:
+
+* Opening the same key multiple times where at least one instance is opened for writing, is undefined and may lead to crashes.
+* While a key is open, it should only be accessed via the low level key API. For example opening a key, then calling DEL on the same key using the `RedisModule_Call()` API will result into a crash. However it is safe to open a key, perform some operation with the low level API, closing it, then using other APIs to manage the same key, and later opening it again to do some more work.
+
+In order to open a key the `RedisModule_OpenKey` function is used. It returns
+a key pointer, that we'll use with all the next calls to access and modify
+the value:
+
+    RedisModuleKey *key;
+    key = RedisModule_OpenKey(ctx,argv[1],REDISMODULE_READ);
+
+The second argument is the key name, that must be a `RedisModuleString` object.
+The third argument is the mode: `REDISMODULE_READ` or `REDISMODULE_WRITE`.
+It is possible to use `|` to bitwise OR the two modes to open the key in
+both modes. Currently a key opened for writing can also be accessed for reading
+but this is to be considered an implementation detail. The right mode should
+be used in sane modules.
+
+You can open non existing keys for writing, since the keys will be created
+when an attempt to write to the key is performed. However when opening keys
+just for reading, `RedisModule_OpenKey` will return NULL if the key does not
+exist.
+
+Once you are done using a key, you can close it with:
+
+    RedisModule_CloseKey(key);
+
+Note that if automatic memory management is enabled, you are not forced to
+close keys. When the module function returns, Redis will take care to close
+all the keys which are still open.
+
+## Getting the key type
+
+In order to obtain the value of a key, use the `RedisModule_KeyType()` function:
+
+    int keytype = RedisModule_KeyType(key);
+
+It returns one of the following values:
+
+    REDISMODULE_KEYTYPE_EMPTY
+    REDISMODULE_KEYTYPE_STRING
+    REDISMODULE_KEYTYPE_LIST
+    REDISMODULE_KEYTYPE_HASH
+    REDISMODULE_KEYTYPE_SET
+    REDISMODULE_KEYTYPE_ZSET
+
+The above are just the usual Redis key types, with the addition of an empty
+type, that signals the key pointer is associated with an empty key that
+does not yet exists.
+
+## Creating new keys
+
+To create a new key, open it for writing and then write to it using one
+of the key writing functions. Example:
+
+    RedisModuleKey *key;
+    key = RedisModule_OpenKey(ctx,argv[1],REDISMODULE_WRITE);
+    if (RedisModule_KeyType(key) == REDISMODULE_KEYTYPE_EMPTY) {
+        RedisModule_StringSet(key,argv[2]);
+    }
+
+## Deleting keys
+
+Just use:
+
+    RedisModule_DeleteKey(key);
+
+The function returns `REDISMODULE_ERR` if the key is not open for writing.
+Note that after a key gets deleted, it is setup in order to be targeted
+by new key commands. For example `RedisModule_KeyType()` will return it is
+an empty key, and writing to it will create a new key, possibly of another
+type (depending on the API used).
+
+## Managing key expires (TTLs)
+
+To control key expires two functions are provided, that are able to set,
+modify, get, and unset the time to live associated with a key.
+
+One function is used in order to query the current expire of an open key:
+
+    mstime_t RedisModule_GetExpire(RedisModuleKey *key);
+
+The function returns the time to live of the key in milliseconds, or
+`REDISMODULE_NO_EXPIRE` as a special value to signal the key has no associated
+expire or does not exist at all (you can differentiate the two cases checking
+if the key type is `REDISMODULE_KEYTYPE_EMPTY`).
+
+In order to change the expire of a key the following function is used instead:
+
+    int RedisModule_SetExpire(RedisModuleKey *key, mstime_t expire);
+
+When called on a non existing key, `REDISMODULE_ERR` is returned, because
+the function can only associate expires to existing open keys (non existing
+open keys are only useful in order to create new values with data type
+specific write operations).
+
+Again the `expire` time is specified in milliseconds. If the key has currently
+no expire, a new expire is set. If the key already have an expire, it is
+replaced with the new value.
+
+If the key has an expire, and the special value `REDISMODULE_NO_EXPIRE` is
+used as a new expire, the expire is removed, similarly to the Redis
+[`PERSIST`]({{< relref "/commands/persist" >}}) command. In case the key was already persistent, no operation is
+performed.
+
+## Obtaining the length of values
+
+There is a single function in order to retrieve the length of the value
+associated to an open key. The returned length is value-specific, and is
+the string length for strings, and the number of elements for the aggregated
+data types (how many elements there is in a list, set, sorted set, hash).
+
+    size_t len = RedisModule_ValueLength(key);
+
+If the key does not exist, 0 is returned by the function:
+
+## String type API
+
+Setting a new string value, like the Redis [`SET`]({{< relref "/commands/set" >}}) command does, is performed
+using:
+
+    int RedisModule_StringSet(RedisModuleKey *key, RedisModuleString *str);
+
+The function works exactly like the Redis [`SET`]({{< relref "/commands/set" >}}) command itself, that is, if
+there is a prior value (of any type) it will be deleted.
+
+Accessing existing string values is performed using DMA (direct memory
+access) for speed. The API will return a pointer and a length, so that's
+possible to access and, if needed, modify the string directly.
+
+    size_t len, j;
+    char *myptr = RedisModule_StringDMA(key,&len,REDISMODULE_WRITE);
+    for (j = 0; j < len; j++) myptr[j] = 'A';
+
+In the above example we write directly on the string. Note that if you want
+to write, you must be sure to ask for `WRITE` mode.
+
+DMA pointers are only valid if no other operations are performed with the key
+before using the pointer, after the DMA call.
+
+Sometimes when we want to manipulate strings directly, we need to change
+their size as well. For this scope, the `RedisModule_StringTruncate` function
+is used. Example:
+
+    RedisModule_StringTruncate(mykey,1024);
+
+The function truncates, or enlarges the string as needed, padding it with
+zero bytes if the previous length is smaller than the new length we request.
+If the string does not exist since `key` is associated to an open empty key,
+a string value is created and associated to the key.
+
+Note that every time `StringTruncate()` is called, we need to re-obtain
+the DMA pointer again, since the old may be invalid.
+
+## List type API
+
+It's possible to push and pop values from list values:
+
+    int RedisModule_ListPush(RedisModuleKey *key, int where, RedisModuleString *ele);
+    RedisModuleString *RedisModule_ListPop(RedisModuleKey *key, int where);
+
+In both the APIs the `where` argument specifies if to push or pop from tail
+or head, using the following macros:
+
+    REDISMODULE_LIST_HEAD
+    REDISMODULE_LIST_TAIL
+
+Elements returned by `RedisModule_ListPop()` are like strings created with
+`RedisModule_CreateString()`, they must be released with
+`RedisModule_FreeString()` or by enabling automatic memory management.
+
+## Set type API
+
+Work in progress.
+
+## Sorted set type API
+
+Documentation missing, please refer to the top comments inside `module.c`
+for the following functions:
+
+* `RedisModule_ZsetAdd`
+* `RedisModule_ZsetIncrby`
+* `RedisModule_ZsetScore`
+* `RedisModule_ZsetRem`
+
+And for the sorted set iterator:
+
+* `RedisModule_ZsetRangeStop`
+* `RedisModule_ZsetFirstInScoreRange`
+* `RedisModule_ZsetLastInScoreRange`
+* `RedisModule_ZsetFirstInLexRange`
+* `RedisModule_ZsetLastInLexRange`
+* `RedisModule_ZsetRangeCurrentElement`
+* `RedisModule_ZsetRangeNext`
+* `RedisModule_ZsetRangePrev`
+* `RedisModule_ZsetRangeEndReached`
+
+## Hash type API
+
+Documentation missing, please refer to the top comments inside `module.c`
+for the following functions:
+
+* `RedisModule_HashSet`
+* `RedisModule_HashGet`
+
+## Iterating aggregated values
+
+Work in progress.
+
+## Replicating commands
+
+If you want to use module commands exactly like normal Redis commands, in the
+context of replicated Redis instances, or using the AOF file for persistence,
+it is important for module commands to handle their replication in a consistent
+way.
+
+When using the higher level APIs to invoke commands, replication happens
+automatically if you use the "!" modifier in the format string of
+`RedisModule_Call()` as in the following example:
+
+    reply = RedisModule_Call(ctx,"INCRBY","!sc",argv[1],"10");
+
+As you can see the format specifier is `"!sc"`. The bang is not parsed as a
+format specifier, but it internally flags the command as "must replicate".
+
+If you use the above programming style, there are no problems.
+However sometimes things are more complex than that, and you use the low level
+API. In this case, if there are no side effects in the command execution, and
+it consistently always performs the same work, what is possible to do is to
+replicate the command verbatim as the user executed it. To do that, you just
+need to call the following function:
+
+    RedisModule_ReplicateVerbatim(ctx);
+
+When you use the above API, you should not use any other replication function
+since they are not guaranteed to mix well.
+
+However this is not the only option. It's also possible to exactly tell
+Redis what commands to replicate as the effect of the command execution, using
+an API similar to `RedisModule_Call()` but that instead of calling the command
+sends it to the AOF / replicas stream. Example:
+
+    RedisModule_Replicate(ctx,"INCRBY","cl","foo",my_increment);
+
+It's possible to call `RedisModule_Replicate` multiple times, and each
+will emit a command. All the sequence emitted is wrapped between a
+`MULTI/EXEC` transaction, so that the AOF and replication effects are the
+same as executing a single command.
+
+Note that `Call()` replication and `Replicate()` replication have a rule,
+in case you want to mix both forms of replication (not necessarily a good
+idea if there are simpler approaches). Commands replicated with `Call()`
+are always the first emitted in the final `MULTI/EXEC` block, while all
+the commands emitted with `Replicate()` will follow.
+
+## Automatic memory management
+
+Normally when writing programs in the C language, programmers need to manage
+memory manually. This is why the Redis modules API has functions to release
+strings, close open keys, free replies, and so forth.
+
+However given that commands are executed in a contained environment and
+with a set of strict APIs, Redis is able to provide automatic memory management
+to modules, at the cost of some performance (most of the time, a very low
+cost).
+
+When automatic memory management is enabled:
+
+1. You don't need to close open keys.
+2. You don't need to free replies.
+3. You don't need to free RedisModuleString objects.
+
+However you can still do it, if you want. For example, automatic memory
+management may be active, but inside a loop allocating a lot of strings,
+you may still want to free strings no longer used.
+
+In order to enable automatic memory management, just call the following
+function at the start of the command implementation:
+
+    RedisModule_AutoMemory(ctx);
+
+Automatic memory management is usually the way to go, however experienced
+C programmers may not use it in order to gain some speed and memory usage
+benefit.
+
+## Allocating memory into modules
+
+Normal C programs use `malloc()` and `free()` in order to allocate and
+release memory dynamically. While in Redis modules the use of malloc is
+not technically forbidden, it is a lot better to use the Redis Modules
+specific functions, that are exact replacements for `malloc`, `free`,
+`realloc` and `strdup`. These functions are:
+
+    void *RedisModule_Alloc(size_t bytes);
+    void* RedisModule_Realloc(void *ptr, size_t bytes);
+    void RedisModule_Free(void *ptr);
+    void RedisModule_Calloc(size_t nmemb, size_t size);
+    char *RedisModule_Strdup(const char *str);
+
+They work exactly like their `libc` equivalent calls, however they use
+the same allocator Redis uses, and the memory allocated using these
+functions is reported by the [`INFO`]({{< relref "/commands/info" >}}) command in the memory section, is
+accounted when enforcing the `maxmemory` policy, and in general is
+a first citizen of the Redis executable. On the contrary, the method
+allocated inside modules with libc `malloc()` is transparent to Redis.
+
+Another reason to use the modules functions in order to allocate memory
+is that, when creating native data types inside modules, the RDB loading
+functions can return deserialized strings (from the RDB file) directly
+as `RedisModule_Alloc()` allocations, so they can be used directly to
+populate data structures after loading, instead of having to copy them
+to the data structure.
+
+## Pool allocator
+
+Sometimes in commands implementations, it is required to perform many
+small allocations that will be not retained at the end of the command
+execution, but are just functional to execute the command itself.
+
+This work can be more easily accomplished using the Redis pool allocator:
+
+    void *RedisModule_PoolAlloc(RedisModuleCtx *ctx, size_t bytes);
+
+It works similarly to `malloc()`, and returns memory aligned to the
+next power of two of greater or equal to `bytes` (for a maximum alignment
+of 8 bytes). However it allocates memory in blocks, so it the overhead
+of the allocations is small, and more important, the memory allocated
+is automatically released when the command returns.
+
+So in general short living allocations are a good candidates for the pool
+allocator.
+
+## Writing commands compatible with Redis Cluster
+
+Documentation missing, please check the following functions inside `module.c`:
+
+    RedisModule_IsKeysPositionRequest(ctx);
+    RedisModule_KeyAtPos(ctx,pos);
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Redis serialization protocol (RESP) is the wire protocol that clients
+  implement
+linkTitle: Protocol spec
+title: Redis serialization protocol specification
+weight: 4
+---
+
+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.
+
+RESP is binary-safe and uses prefixed length to transfer bulk data so it does not require processing bulk data transferred from one process to another.
+
+RESP is the protocol you should implement in your Redis client.
+
+{{% alert title="Note" color="info" %}}
+The protocol outlined here is used only for client-server communication.
+[Redis Cluster]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}) uses a different binary protocol for exchanging messages between nodes.
+{{% /alert %}}
+
+## RESP versions
+Support for the first version of the RESP protocol was introduced in Redis 1.2.
+Using RESP with Redis 1.2 was optional and had mainly served the purpose of working the kinks out of the protocol.
+
+In Redis 2.0, the protocol's next version, a.k.a RESP2, became the standard communication method for clients with the Redis server.
+
+[RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md) is a superset of RESP2 that mainly aims to make a client author's life a little bit easier.
+Redis 6.0 introduced experimental opt-in support of RESP3's features (excluding streaming strings and streaming aggregates).
+In addition, the introduction of the [`HELLO`]({{< relref "/commands/hello" >}}) command allows clients to handshake and upgrade the connection's protocol version (see [Client handshake](#client-handshake)).
+
+From Redis version 7 and forward, both RESP2 and RESP3 clients can invoke all core commands.
+However, commands may return differently typed replies for different protocol versions.
+Each command has descriptions of RESP2 and RESP3 return values that you can reference.
+
+Future versions of Redis may change the default protocol version, but it is unlikely that RESP2 will become entirely deprecated.
+It is possible, however, that new features in upcoming versions will require the use of RESP3.
+
+## Network layer
+A client connects to a Redis server by creating a TCP connection to its port (the default is 6379).
+
+While RESP is technically non-TCP specific, the protocol is used exclusively with TCP connections (or equivalent stream-oriented connections like Unix sockets) in the context of Redis.
+
+## Request-Response model
+The Redis server accepts commands composed of different arguments.
+Then, the server processes the command and sends the reply back to the client.
+
+This is the simplest model possible; however, there are some exceptions:
+
+* Redis requests can be [pipelined](#multiple-commands-and-pipelining).
+  Pipelining enables clients to send multiple commands at once and wait for replies later.
+* When a RESP2 connection subscribes to a [Pub/Sub]({{< relref "/develop/interact/pubsub" >}}) channel, the protocol changes semantics and becomes a *push* protocol.
+  The client no longer requires sending commands because the server will automatically send new messages to the client (for the channels the client is subscribed to) as soon as they are received.
+* The [`MONITOR`]({{< relref "/commands/monitor" >}}) command.
+  Invoking the [`MONITOR`]({{< relref "/commands/monitor" >}}) command switches the connection to an ad-hoc push mode.
+  The protocol of this mode is not specified but is obvious to parse.
+* [Protected mode]({{< relref "operate/oss_and_stack/management/security/#protected-mode" >}}).
+  Connections opened from a non-loopback address to a Redis while in protected mode are denied and terminated by the server.
+  Before terminating the connection, Redis unconditionally sends a `-DENIED` reply, regardless of whether the client writes to the socket.
+* The [RESP3 Push type](#resp3-pushes).
+  As the name suggests, a push type allows the server to send out-of-band data to the connection.
+  The server may push data at any time, and the data isn't necessarily related to specific commands executed by the client.
+  
+Excluding these exceptions, the Redis protocol is a simple request-response protocol.
+
+## RESP protocol description
+RESP is essentially a serialization protocol that supports several data types.
+In RESP, the first byte of data determines its type.
+
+Redis generally uses RESP as a [request-response](#request-response-model) protocol in the following way:
+
+* Clients send commands to a Redis server as an [array](#arrays) of [bulk strings](#bulk-strings).
+  The first (and sometimes also the second) bulk string in the array is the command's name.
+  Subsequent elements of the array are the arguments for the command.
+* The server replies with a RESP type.
+  The reply's type is determined by the command's implementation and possibly by the client's protocol version.
+
+RESP is a binary protocol that uses control sequences encoded in standard ASCII.
+The `A` character, for example, is encoded with the binary byte of value 65.
+Similarly, the characters CR (`\r`), LF (`\n`) and SP (` `) have binary byte values of 13, 10 and 32, respectively.
+
+The `\r\n` (CRLF) is the protocol's _terminator_, which **always** separates its parts.
+
+The first byte in an RESP-serialized payload always identifies its type.
+Subsequent bytes constitute the type's contents.
+
+We categorize every RESP data type as either _simple_, _bulk_ or _aggregate_.
+
+Simple types are similar to scalars in programming languages that represent plain literal values. Booleans and Integers are such examples.
+
+RESP strings are either _simple_ or _bulk_.
+Simple strings never contain carriage return (`\r`) or line feed (`\n`) characters.
+Bulk strings can contain any binary data and may also be referred to as _binary_ or _blob_.
+Note that bulk strings may be further encoded and decoded, e.g. with a wide multi-byte encoding, by the client.
+
+Aggregates, such as Arrays and Maps, can have varying numbers of sub-elements and nesting levels.
+
+The following table summarizes the RESP data types that Redis supports:
+
+| RESP data type | Minimal protocol version | Category | First byte |
+| --- | --- | --- | --- |
+| [Simple strings](#simple-strings) | RESP2 | Simple | `+` |
+| [Simple Errors](#simple-errors) | RESP2 | Simple | `-` |
+| [Integers](#integers) | RESP2 | Simple | `:` |
+| [Bulk strings](#bulk-strings) | RESP2 | Aggregate | `$` |
+| [Arrays](#arrays) | RESP2 | Aggregate | `*` |
+| [Nulls](#nulls) | RESP3 | Simple | `_` |
+| [Booleans](#booleans) | RESP3 | Simple | `#` |
+| [Doubles](#doubles) | RESP3 | Simple | `,` |
+| [Big numbers](#big-numbers) | RESP3 | Simple | `(` |
+| [Bulk errors](#bulk-errors) | RESP3 | Aggregate | `!` |
+| [Verbatim strings](#verbatim-strings) | RESP3 | Aggregate | `=` |
+| [Maps](#maps) | RESP3 | Aggregate | `%` |
+| [Attributes](#attributes) | RESP3 | Aggregate | `|` |
+| [Sets](#sets) | RESP3 | Aggregate | `~` |
+| [Pushes](#pushes) | RESP3 | Aggregate | `>` |
+
+<a name="simple-string-reply"></a>
+
+### Simple strings
+Simple strings are encoded as a plus (`+`) character, followed by a string.
+The string mustn't contain a CR (`\r`) or LF (`\n`) character and is terminated by CRLF (i.e., `\r\n`).
+
+Simple strings transmit short, non-binary strings with minimal overhead.
+For example, many Redis commands reply with just "OK" on success.
+The encoding of this Simple String is the following 5 bytes:
+
+    +OK\r\n
+
+When Redis replies with a simple string, a client library should return to the caller a string value composed of the first character after the `+` up to the end of the string, excluding the final CRLF bytes.
+
+To send binary strings, use [bulk strings](#bulk-strings) instead.
+
+<a name="error-reply"></a>
+
+### Simple errors
+RESP has specific data types for errors.
+Simple errors, or simply just errors, are similar to [simple strings](#simple-strings), but their first character is the minus (`-`) character.
+The difference between simple strings and errors in RESP is that clients should treat errors as exceptions, whereas the string encoded in the error type is the error message itself.
+
+The basic format is:
+
+    -Error message\r\n
+
+Redis replies with an error only when something goes wrong, for example, when you try to operate against the wrong data type, or when the command does not exist.
+The client should raise an exception when it receives an Error reply.
+
+The following are examples of error replies:
+
+    -ERR unknown command 'asdf'
+    -WRONGTYPE Operation against a key holding the wrong kind of value
+
+The first upper-case word after the `-`, up to the first space or newline, represents the kind of error returned.
+This word is called an _error prefix_.
+Note that the error prefix is a convention used by Redis rather than part of the RESP error type.
+
+For example, in Redis, `ERR` is a generic error, whereas `WRONGTYPE` is a more specific error that implies that the client attempted an operation against the wrong data type.
+The error prefix allows the client to understand the type of error returned by the server without checking the exact error message.
+
+A client implementation can return different types of exceptions for various errors, or provide a generic way for trapping errors by directly providing the error name to the caller as a string.
+
+However, such a feature should not be considered vital as it is rarely useful. 
+Also, simpler client implementations can return a generic error value, such as `false`.
+
+<a name="integer-reply"></a>
+
+### Integers
+This type is a CRLF-terminated string that represents a signed, base-10, 64-bit integer.
+
+RESP encodes integers in the following way:
+
+    :[<+|->]<value>\r\n
+
+* The colon (`:`) as the first byte.
+* An optional plus (`+`) or minus (`-`) as the sign.
+* One or more decimal digits (`0`..`9`) as the integer's unsigned, base-10 value.
+* The CRLF terminator.
+
+For example, `:0\r\n` and `:1000\r\n` are integer replies (of zero and one thousand, respectively).
+
+Many Redis commands return RESP integers, including [`INCR`]({{< relref "/commands/incr" >}}), [`LLEN`]({{< relref "/commands/llen" >}}), and [`LASTSAVE`]({{< relref "/commands/lastsave" >}}).
+An integer, by itself, has no special meaning other than in the context of the command that returned it.
+For example, it is an incremental number for [`INCR`]({{< relref "/commands/incr" >}}), a UNIX timestamp for [`LASTSAVE`]({{< relref "/commands/lastsave" >}}), and so forth.
+However, the returned integer is guaranteed to be in the range of a signed 64-bit integer.
+
+In some cases, integers can represent true and false Boolean values.
+For instance, [`SISMEMBER`]({{< relref "/commands/sismember" >}}) returns 1 for true and 0 for false.
+
+Other commands, including [`SADD`]({{< relref "/commands/sadd" >}}), [`SREM`]({{< relref "/commands/srem" >}}), and [`SETNX`]({{< relref "/commands/setnx" >}}), return 1 when the data changes and 0 otherwise.
+
+<a name="bulk-string-reply"></a>
+
+### Bulk strings
+A bulk string represents a single binary string.
+The string can be of any size, but by default, Redis limits it to 512 MB (see the `proto-max-bulk-len` configuration directive).
+
+RESP encodes bulk strings in the following way:
+
+    $<length>\r\n<data>\r\n
+
+* The dollar sign (`$`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the string's length, in bytes, as an unsigned, base-10 value.
+* The CRLF terminator.
+* The data.
+* A final CRLF.
+
+So the string "hello" is encoded as follows:
+
+    $5\r\nhello\r\n
+
+The empty string's encoding is:
+
+    $0\r\n\r\n
+
+<a name="nil-reply"></a>
+
+#### Null bulk strings
+Whereas RESP3 has a dedicated data type for [null values](#nulls), RESP2 has no such type.
+Instead, due to historical reasons, the representation of null values in RESP2 is via predetermined forms of the [bulk strings](#bulk-strings) and [arrays](#arrays) types.
+
+The null bulk string represents a non-existing value.
+The [`GET`]({{< relref "/commands/get" >}}) command returns the Null Bulk String when the target key doesn't exist.
+
+It is encoded as a bulk string with the length of negative one (-1), like so:
+
+    $-1\r\n
+
+A Redis client should return a nil object when the server replies with a null bulk string rather than the empty string.
+For example, a Ruby library should return `nil` while a C library should return `NULL` (or set a special flag in the reply object).
+
+<a name="array-reply"></a>
+
+### Arrays
+Clients send commands to the Redis server as RESP arrays.
+Similarly, some Redis commands that return collections of elements use arrays as their replies. 
+An example is the [`LRANGE`]({{< relref "/commands/lrange" >}}) command that returns elements of a list.
+
+RESP Arrays' encoding uses the following format:
+
+    *<number-of-elements>\r\n<element-1>...<element-n>
+
+* An asterisk (`*`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the number of elements in the array as an unsigned, base-10 value.
+* The CRLF terminator.
+* An additional RESP type for every element of the array.
+
+So an empty Array is just the following:
+
+    *0\r\n
+
+Whereas the encoding of an array consisting of the two bulk strings "hello" and "world" is:
+
+    *2\r\n$5\r\nhello\r\n$5\r\nworld\r\n
+
+As you can see, after the `*<count>CRLF` part prefixing the array, the other data types that compose the array are concatenated one after the other.
+For example, an Array of three integers is encoded as follows:
+
+    *3\r\n:1\r\n:2\r\n:3\r\n
+
+Arrays can contain mixed data types.
+For instance, the following encoding is of a list of four integers and a bulk string:
+
+    *5\r\n
+    :1\r\n
+    :2\r\n
+    :3\r\n
+    :4\r\n
+    $5\r\n
+    hello\r\n
+
+(The raw RESP encoding is split into multiple lines for readability).
+
+The first line the server sent is `*5\r\n`.
+This numeric value tells the client that five reply types are about to follow it.
+Then, every successive reply constitutes an element in the array.
+
+All of the aggregate RESP types support nesting.
+For example, a nested array of two arrays is encoded as follows:
+
+    *2\r\n
+    *3\r\n
+    :1\r\n
+    :2\r\n
+    :3\r\n
+    *2\r\n
+    +Hello\r\n
+    -World\r\n
+
+(The raw RESP encoding is split into multiple lines for readability).
+
+The above encodes a two-element array.
+The first element is an array that, in turn, contains three integers (1, 2, 3).
+The second element is another array containing a simple string and an error.
+
+{{% alert title="Multi bulk reply" color="info" %}}
+In some places, the RESP Array type may be referred to as _multi bulk_.
+The two are the same.
+{{% /alert %}}
+
+<a name="nil-array-reply"></a>
+
+#### Null arrays
+Whereas RESP3 has a dedicated data type for [null values](#nulls), RESP2 has no such type. Instead, due to historical reasons, the representation of null values in RESP2 is via predetermined forms of the [Bulk Strings](#bulk-strings) and [arrays](#arrays) types.
+
+Null arrays exist as an alternative way of representing a null value.
+For instance, when the [`BLPOP`]({{< relref "/commands/blpop" >}}) command times out, it returns a null array.
+
+The encoding of a null array is that of an array with the length of -1, i.e.:
+
+    *-1\r\n
+
+When Redis replies with a null array, the client should return a null object rather than an empty array.
+This is necessary to distinguish between an empty list and a different condition (for instance, the timeout condition of the [`BLPOP`]({{< relref "/commands/blpop" >}}) command).
+
+#### Null elements in arrays
+Single elements of an array may be [null bulk string](#null-bulk-strings).
+This is used in Redis replies to signal that these elements are missing and not empty strings. This can happen, for example, with the [`SORT`]({{< relref "/commands/sort" >}}) command when used with the `GET pattern` option
+if the specified key is missing.
+
+Here's an example of an array reply containing a null element:
+
+    *3\r\n
+    $5\r\n
+    hello\r\n
+    $-1\r\n
+    $5\r\n
+    world\r\n
+
+Above, the second element is null.
+The client library should return to its caller something like this:
+
+    ["hello",nil,"world"]
+
+<a name="null-reply"></a>
+
+### Nulls
+The null data type represents non-existent values.
+
+Nulls' encoding is the underscore (`_`) character, followed by the CRLF terminator (`\r\n`).
+Here's Null's raw RESP encoding:
+
+    _\r\n
+
+{{% alert title="Null Bulk String, Null Arrays and Nulls" color="info" %}}
+Due to historical reasons, RESP2 features two specially crafted values for representing null values of bulk strings and arrays.
+This duality has always been a redundancy that added zero semantical value to the protocol itself.
+
+The null type, introduced in RESP3, aims to fix this wrong.
+{{% /alert %}}
+
+<a name="boolean-reply">
+
+### Booleans
+RESP booleans are encoded as follows:
+
+    #<t|f>\r\n
+
+* The octothorpe character (`#`) as the first byte.
+* A `t` character for true values, or an `f` character for false ones.
+* The CRLF terminator.
+
+<a name="double-reply"></a>
+
+### Doubles
+The Double RESP type encodes a double-precision floating point value.
+Doubles are encoded as follows:
+
+    ,[<+|->]<integral>[.<fractional>][<E|e>[sign]<exponent>]\r\n
+
+* The comma character (`,`) as the first byte.
+* An optional plus (`+`) or minus (`-`) as the sign.
+* One or more decimal digits (`0`..`9`) as an unsigned, base-10 integral value.
+* An optional dot (`.`), followed by one or more decimal digits (`0`..`9`) as an unsigned, base-10 fractional value.
+* An optional capital or lowercase letter E (`E` or `e`), followed by an optional plus (`+`) or minus (`-`) as the exponent's sign, ending with one or more decimal digits (`0`..`9`) as an unsigned, base-10 exponent value.
+* The CRLF terminator.
+
+Here's the encoding of the number 1.23:
+
+    ,1.23\r\n
+
+Because the fractional part is optional, the integer value of ten (10) can, therefore, be RESP-encoded both as an integer as well as a double:
+
+    :10\r\n
+    ,10\r\n
+
+In such cases, the Redis client should return native integer and double values, respectively, providing that these types are supported by the language of its implementation.
+
+The positive infinity, negative infinity and NaN values are encoded as follows:
+
+    ,inf\r\n
+    ,-inf\r\n
+    ,nan\r\n
+
+<a name="big-number-reply"></a>
+
+### Big numbers
+This type can encode integer values outside the range of signed 64-bit integers.
+
+Big numbers use the following encoding:
+
+    ([+|-]<number>\r\n
+
+* The left parenthesis character (`(`) as the first byte.
+* An optional plus (`+`) or minus (`-`) as the sign.
+* One or more decimal digits (`0`..`9`) as an unsigned, base-10 value.
+* The CRLF terminator.
+
+Example:
+
+    (3492890328409238509324850943850943825024385\r\n
+
+Big numbers can be positive or negative but can't include fractionals.
+Client libraries written in languages with a big number type should return a big number.
+When big numbers aren't supported, the client should return a string and, when possible, signal to the caller that the reply is a big integer (depending on the API used by the client library).
+
+<a name="bulk-error-reply"></a>
+
+### Bulk errors
+This type combines the purpose of [simple errors](#simple-errors) with the expressive power of [bulk strings](#bulk-strings).
+
+It is encoded as:
+
+    !<length>\r\n<error>\r\n
+
+* An exclamation mark (`!`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the error's length, in bytes, as an unsigned, base-10 value.
+* The CRLF terminator.
+* The error itself.
+* A final CRLF.
+
+As a convention, the error begins with an uppercase (space-delimited) word that conveys the error message.
+
+For instance, the error "SYNTAX invalid syntax" is represented by the following protocol encoding:
+
+    !21\r\n
+    SYNTAX invalid syntax\r\n
+
+(The raw RESP encoding is split into multiple lines for readability).
+
+<a name="verbatim-string-reply">
+
+### Verbatim strings
+This type is similar to the [bulk string](#bulk-strings), with the addition of providing a hint about the data's encoding.
+
+A verbatim string's RESP encoding is as follows:
+
+    =<length>\r\n<encoding>:<data>\r\n
+
+* An equal sign (`=`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the string's total length, in bytes, as an unsigned, base-10 value.
+* The CRLF terminator.
+* Exactly three (3) bytes represent the data's encoding.
+* The colon (`:`) character separates the encoding and data.
+* The data.
+* A final CRLF.
+
+Example:
+
+    =15\r\n
+    txt:Some string\r\n
+
+(The raw RESP encoding is split into multiple lines for readability).
+
+Some client libraries may ignore the difference between this type and the string type and return a native string in both cases.
+However, interactive clients, such as command line interfaces (e.g., [`redis-cli`]({{< relref "/develop/tools/cli" >}})), can use this type and know that their output should be presented to the human user as is and without quoting the string.
+
+For example, the Redis command [`INFO`]({{< relref "/commands/info" >}}) outputs a report that includes newlines.
+When using RESP3, `redis-cli` displays it correctly because it is sent as a Verbatim String reply (with its three bytes being "txt").
+When using RESP2, however, the `redis-cli` is hard-coded to look for the [`INFO`]({{< relref "/commands/info" >}}) command to ensure its correct display to the user.
+
+<a name="map-reply"></a>
+
+### Maps
+The RESP map encodes a collection of key-value tuples, i.e., a dictionary or a hash.
+
+It is encoded as follows:
+
+    %<number-of-entries>\r\n<key-1><value-1>...<key-n><value-n>
+
+* A percent character (`%`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the number of entries, or key-value tuples, in the map as an unsigned, base-10 value.
+* The CRLF terminator.
+* Two additional RESP types for every key and value in the map.
+
+For example, the following JSON object:
+
+    {
+        "first": 1,
+        "second": 2
+    }
+
+Can be encoded in RESP like so:
+
+    %2\r\n
+    +first\r\n
+    :1\r\n
+    +second\r\n
+    :2\r\n
+
+(The raw RESP encoding is split into multiple lines for readability).
+
+Both map keys and values can be any of RESP's types.
+
+Redis clients should return the idiomatic dictionary type that their language provides.
+However, low-level programming languages (such as C, for example) will likely return an array along with type information that indicates to the caller that it is a dictionary.
+
+{{% alert title="Map pattern in RESP2" color="info" %}}
+RESP2 doesn't have a map type.
+A map in RESP2 is represented by a flat array containing the keys and the values.
+The first element is a key, followed by the corresponding value, then the next key and so on, like this:
+`key1, value1, key2, value2, ...`.
+{{% /alert %}}
+
+<a name="attribute-reply"></a>
+
+### Attributes
+
+The attribute type is exactly like the Map type, but instead of a `%` character as the first byte, the `|` character is used. Attributes describe a dictionary exactly like the Map type. However the client should not consider such a dictionary part of the reply, but as auxiliary data that augments the reply.
+
+Note: in the examples below, indentation is shown only for clarity; the additional whitespace would not be part of a real reply.
+
+For example, newer versions of Redis may include the ability to report the popularity of keys for every executed command. The reply to the command `MGET a b` may be the following:
+
+    |1\r\n
+        +key-popularity\r\n
+        %2\r\n
+            $1\r\n
+            a\r\n
+            ,0.1923\r\n
+            $1\r\n
+            b\r\n
+            ,0.0012\r\n
+    *2\r\n
+        :2039123\r\n
+        :9543892\r\n
+
+The actual reply to `MGET` is just the two item array `[2039123, 9543892]`. The returned attributes specify the popularity, or frequency of requests, given as floating point numbers ranging from `0.0` to `1.0`, of the keys mentioned in the original command. Note: the actual implementation in Redis may differ.
+
+When a client reads a reply and encounters an attribute type, it should read the attribute, and continue reading the reply. The attribute reply should be accumulated separately, and the user should have a way to access such attributes. For instance, if we imagine a session in an higher level language, something like this could happen:
+
+```python
+> r = Redis.new
+#<Redis client>
+> r.mget("a","b")
+#<Redis reply>
+> r
+[2039123,9543892]
+> r.attribs
+{:key-popularity => {:a => 0.1923, :b => 0.0012}}
+```
+
+Attributes can appear anywhere before a valid part of the protocol identifying a given type, and supply information only about the part of the reply that immediately follows. For example:
+
+    *3\r\n
+        :1\r\n
+        :2\r\n
+        |1\r\n
+            +ttl\r\n
+            :3600\r\n
+        :3\r\n
+
+In the above example the third element of the array has associated auxiliary information of `{ttl:3600}`. Note that it's not up to the client library to interpret the attributes, but it should pass them to the caller in a sensible way.
+
+<a name="set-reply"></a>
+
+### Sets
+Sets are somewhat like [Arrays](#arrays) but are unordered and should only contain unique elements.
+
+RESP set's encoding is:
+
+    ~<number-of-elements>\r\n<element-1>...<element-n>
+
+* A tilde (`~`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the number of elements in the set as an unsigned, base-10 value.
+* The CRLF terminator.
+* An additional RESP type for every element of the Set.
+
+Clients should return the native set type if it is available in their programming language.
+Alternatively, in the absence of a native set type, an array coupled with type information can be used (in C, for example).
+
+<a name="push-event"></a>
+
+### Pushes
+RESP's pushes contain out-of-band data.
+They are an exception to the protocol's request-response model and provide a generic _push mode_ for connections.
+
+Push events are encoded similarly to [arrays](#arrays), differing only in their first byte:
+
+    ><number-of-elements>\r\n<element-1>...<element-n>
+
+* A greater-than sign (`>`) as the first byte.
+* One or more decimal digits (`0`..`9`) as the number of elements in the message as an unsigned, base-10 value.
+* The CRLF terminator.
+* An additional RESP type for every element of the push event.
+
+Pushed data may precede or follow any of RESP's data types but never inside them.
+That means a client won't find push data in the middle of a map reply, for example.
+It also means that pushed data may appear before or after a command's reply, as well as by itself (without calling any command).
+
+Clients should react to pushes by invoking a callback that implements their handling of the pushed data.
+
+## Client handshake
+New RESP connections should begin the session by calling the [`HELLO`]({{< relref "/commands/hello" >}}) command.
+This practice accomplishes two things:
+
+1. It allows servers to be backward compatible with RESP2 versions.
+  This is needed in Redis to make the transition to version 3 of the protocol gentler.
+2. The [`HELLO`]({{< relref "/commands/hello" >}}) command returns information about the server and the protocol that the client can use for different goals.
+
+The [`HELLO`]({{< relref "/commands/hello" >}}) command has the following high-level syntax:
+
+    HELLO <protocol-version> [optional-arguments]
+
+The first argument of the command is the protocol version we want the connection to be set.
+By default, the connection starts in RESP2 mode.
+If we specify a connection version that is too big and unsupported by the server, it should reply with a `-NOPROTO` error. Example:
+
+    Client: HELLO 4
+    Server: -NOPROTO sorry, this protocol version is not supported.
+    
+At that point, the client may retry with a lower protocol version.
+
+Similarly, the client can easily detect a server that is only able to speak RESP2:
+
+    Client: HELLO 3
+    Server: -ERR unknown command 'HELLO'
+
+The client can then proceed and use RESP2 to communicate with the server.
+
+Note that even if the protocol's version is supported, the [`HELLO`]({{< relref "/commands/hello" >}}) command may return an error, perform no action and remain in RESP2 mode. 
+For example, when used with invalid authentication credentials in the command's optional `AUTH` clause:
+
+    Client: HELLO 3 AUTH default mypassword
+    Server: -ERR invalid password
+    (the connection remains in RESP2 mode)
+
+A successful reply to the [`HELLO`]({{< relref "/commands/hello" >}}) command is a map reply.
+The information in the reply is partly server-dependent, but certain fields are mandatory for all the RESP3 implementations:
+* **server**: "redis" (or other software name).
+* **version**: the server's version.
+* **proto**: the highest supported version of the RESP protocol.
+
+In Redis' RESP3 implementation, the following fields are also emitted:
+
+* **id**: the connection's identifier (ID).
+* **mode**: "standalone", "sentinel" or "cluster".
+* **role**: "master" or "replica".
+* **modules**: list of loaded modules as an Array of Bulk Strings.
+
+## Sending commands to a Redis server
+Now that you are familiar with the RESP serialization format, you can use it to help write a Redis client library.
+We can further specify how the interaction between the client and the server works:
+
+* A client sends the Redis server an [array](#arrays) consisting of only bulk strings.
+* A Redis server replies to clients, sending any valid RESP data type as a reply.
+
+So, for example, a typical interaction could be the following.
+
+The client sends the command `LLEN mylist` to get the length of the list stored at the key _mylist_.
+Then the server replies with an [integer](#integers) reply as in the following example (`C:` is the client, `S:` the server).
+
+    C: *2\r\n
+    C: $4\r\n
+    C: LLEN\r\n
+    C: $6\r\n
+    C: mylist\r\n
+
+    S: :48293\r\n
+
+As usual, we separate different parts of the protocol with newlines for simplicity, but the actual interaction is the client sending `*2\r\n$4\r\nLLEN\r\n$6\r\nmylist\r\n` as a whole.
+
+## Multiple commands and pipelining
+A client can use the same connection to issue multiple commands.
+Pipelining is supported, so multiple commands can be sent with a single write operation by the client.
+The client can skip reading replies and continue to send the commands one after the other.
+All the replies can be read at the end.
+
+For more information, see [Pipelining]({{< relref "/develop/use/pipelining" >}}).
+
+## Inline commands
+Sometimes you may need to send a command to the Redis server but only have `telnet` available.
+While the Redis protocol is simple to implement, it is not ideal for interactive sessions, and `redis-cli` may not always be available.
+For this reason, Redis also accepts commands in the _inline command_ format.
+
+The following example demonstrates a server/client exchange using an inline command (the server chat starts with `S:`, the client chat with `C:`):
+
+    C: PING
+    S: +PONG
+
+Here's another example of an inline command where the server returns an integer:
+
+    C: EXISTS somekey
+    S: :0
+
+Basically, to issue an inline command, you write space-separated arguments in a telnet session.
+Since no command starts with `*` (the identifying byte of RESP Arrays), Redis detects this condition and parses your command inline.
+
+## High-performance parser for the Redis protocol
+
+While the Redis protocol is human-readable and easy to implement, its implementation can exhibit performance similar to that of a binary protocol.
+
+RESP uses prefixed lengths to transfer bulk data.
+That makes scanning the payload for special characters unnecessary (unlike parsing JSON, for example).
+For the same reason, quoting and escaping the payload isn't needed.
+
+Reading the length of aggregate types (for example, bulk strings or arrays) can be processed with code that performs a single operation per character while at the same time scanning for the CR character.
+
+Example (in C):
+
+```c
+#include <stdio.h>
+
+int main(void) {
+    unsigned char *p = "$123\r\n";
+    int len = 0;
+
+    p++;
+    while(*p != '\r') {
+        len = (len*10)+(*p - '0');
+        p++;
+    }
+
+    /* Now p points at '\r', and the length is in len. */
+    printf("%d\n", len);
+    return 0;
+}
+```
+
+After the first CR is identified, it can be skipped along with the following LF without further processing.
+Then, the bulk data can be read with a single read operation that doesn't inspect the payload in any way.
+Finally, the remaining CR and LF characters are discarded without additional processing.
+
+While comparable in performance to a binary protocol, the Redis protocol is significantly more straightforward to implement in most high-level languages, reducing the number of bugs in client software.
+
+## Tips for Redis client authors
+
+* For testing purposes, use [Lua's type conversions]({{< relref "develop/interact/programmability/lua-api#lua-to-resp3-type-conversion" >}}) to have Redis reply with any RESP2/RESP3 needed.
+  As an example, a RESP3 double can be generated like so:
+  ```
+  EVAL "return { double = tonumber(ARGV[1]) }" 0 1e0
+  ```
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How Redis commands expose their documentation programmatically
+linkTitle: Command arguments
+title: Redis command arguments
+weight: 7
+---
+
+The [`COMMAND DOCS`]({{< relref "/commands/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`]({{< relref "/commands/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`]({{< relref "/commands/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][tr] 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`]({{< relref "/commands/set" >}}) command).
+  - **multiple**: denotes that the argument may be repeated (such as the _key_ argument of [`DEL`]({{< relref "/commands/del" >}})).
+  - **multiple-token:** denotes the possible repetition of the argument with its preceding token (see [`SORT`]({{< relref "/commands/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.
+
+[tr]: /develop/reference/key-specs.md
+
+## Example
+
+The trimming clause of [`XADD`]({{< relref "/commands/xadd" >}}), i.e., `[MAXLEN|MINID [=|~] threshold [LIMIT count]]`, is represented at the top-level as _block_-typed argument.
+
+It consists of four nested arguments:
+
+1. **trimming strategy:** this nested argument has an _oneof_ type with two nested arguments.
+  Each of the nested arguments, _MAXLEN_ and _MINID_, is typed as _pure-token_.
+2. **trimming operator:** this nested argument is an optional _oneof_ type with two nested arguments.
+  Each of the nested arguments, _=_ and _~_, is a _pure-token_.
+3. **threshold:** this nested argument is a _string_.
+4. **count:** this nested argument is an optional _integer_ with a _token_ (_LIMIT_).
+
+Here's [`XADD`]({{< relref "/commands/xadd" >}})'s arguments array:
+
+```
+1) 1) "name"
+   2) "key"
+   3) "type"
+   4) "key"
+   5) "value"
+   6) "key"
+2)  1) "name"
+    2) "nomkstream"
+    3) "type"
+    4) "pure-token"
+    5) "token"
+    6) "NOMKSTREAM"
+    7) "since"
+    8) "6.2"
+    9) "flags"
+   10) 1) optional
+3) 1) "name"
+   2) "trim"
+   3) "type"
+   4) "block"
+   5) "flags"
+   6) 1) optional
+   7) "value"
+   8) 1) 1) "name"
+         2) "strategy"
+         3) "type"
+         4) "oneof"
+         5) "value"
+         6) 1) 1) "name"
+               2) "maxlen"
+               3) "type"
+               4) "pure-token"
+               5) "token"
+               6) "MAXLEN"
+            2) 1) "name"
+               2) "minid"
+               3) "type"
+               4) "pure-token"
+               5) "token"
+               6) "MINID"
+               7) "since"
+               8) "6.2"
+      2) 1) "name"
+         2) "operator"
+         3) "type"
+         4) "oneof"
+         5) "flags"
+         6) 1) optional
+         7) "value"
+         8) 1) 1) "name"
+               2) "equal"
+               3) "type"
+               4) "pure-token"
+               5) "token"
+               6) "="
+            2) 1) "name"
+               2) "approximately"
+               3) "type"
+               4) "pure-token"
+               5) "token"
+               6) "~"
+      3) 1) "name"
+         2) "threshold"
+         3) "type"
+         4) "string"
+         5) "value"
+         6) "threshold"
+      4)  1) "name"
+          2) "count"
+          3) "type"
+          4) "integer"
+          5) "token"
+          6) "LIMIT"
+          7) "since"
+          8) "6.2"
+          9) "flags"
+         10) 1) optional
+         11) "value"
+         12) "count"
+4) 1) "name"
+   2) "id_or_auto"
+   3) "type"
+   4) "oneof"
+   5) "value"
+   6) 1) 1) "name"
+         2) "auto_id"
+         3) "type"
+         4) "pure-token"
+         5) "token"
+         6) "*"
+      2) 1) "name"
+         2) "id"
+         3) "type"
+         4) "string"
+         5) "value"
+         6) "id"
+5) 1) "name"
+   2) "field_value"
+   3) "type"
+   4) "block"
+   5) "flags"
+   6) 1) multiple
+   7) "value"
+   8) 1) 1) "name"
+         2) "field"
+         3) "type"
+         4) "string"
+         5) "value"
+         6) "field"
+      2) 1) "name"
+         2) "value"
+         3) "type"
+         4) "string"
+         5) "value"
+         6) "value"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Specifications and protocols
+linkTitle: Reference
+title: Redis reference
+weight: 70
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Overview of Redis key eviction policies (LRU, LFU, etc.)
+linkTitle: Eviction
+title: Key eviction
+weight: 6
+---
+
+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.
+
+Note that when a command adds a lot of data to the cache (for example, a big set
+intersection stored into a new key), this might temporarily exceed the limit by
+a large amount.
+
+The sections below explain how to [configure the memory limit](#maxmem) for the cache
+and also describe the available [eviction policies](#eviction-policies) and when to
+use them.
+
+## Using the `maxmemory` configuration directive {#maxmem}
+
+The `maxmemory` configuration directive specifies
+the maximum amount of memory to use for the cache data. You can
+set `maxmemory` with the [`redis.conf`](https://github.com/redis/redis/blob/7.4.0/redis.conf)
+file at startup time. For example, to configure a memory limit of 100 megabytes,
+you can use the following directive inside `redis.conf`:
+
+```
+maxmemory 100mb
+```
+
+You can also use [`CONFIG SET`]({{< relref "/commands/config-set" >}}) to
+set `maxmemory` at runtime using [`redis-cli`]({{< relref "/develop/tools/cli" >}}):
+
+```bash
+> CONFIG SET maxmemory 100mb
+```
+
+Set `maxmemory` to zero to specify that you don't want to limit the memory
+for the dataset. This is the default behavior for 64-bit systems, while 32-bit
+systems use an implicit memory limit of 3GB.
+
+When the size of your cache exceeds the limit set by `maxmemory`, Redis will
+enforce your chosen [eviction policy](#eviction-policies) to prevent any
+further growth of the cache.
+
+### Setting `maxmemory` for a replicated or persisted instance
+
+If you are using
+[replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}})
+or [persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}})
+for a server, Redis will use some RAM as a buffer to store the set of updates waiting
+to be written to the replicas or AOF files.
+The memory used by this buffer is not included in the total that
+is compared to `maxmemory` to see if eviction is required.
+
+This is because the key evictions themselves generate updates that must be added
+to the buffer. If the updates were counted among the used
+memory then in some circumstances, the memory saved by
+evicting keys would be immediately used up by the update data added to the buffer.
+This, in turn, would trigger even more evictions and the resulting feedback loop
+could evict many items from the cache unnecessarily.
+
+If you are using replication or persistence, we recommend that you set
+`maxmemory` to leave a little RAM free to store the buffers. Note that this is not
+necessary for the `noeviction` policy (see [the section below](#eviction-policies)
+for more information about eviction policies).
+
+The [`INFO`]({{< relref "/commands/info" >}}) command returns a
+`mem_not_counted_for_evict` value in the `memory` section (you can use
+the `INFO memory` option to see just this section). This is the amount of
+memory currently used by the buffers. Although the exact amount will vary,
+you can use it to estimate how much to subtract from the total available RAM
+before setting `maxmemory`.
+
+## Eviction policies
+
+Use the `maxmemory-policy` configuration directive to select the eviction
+policy you want to use when the limit set by `maxmemory` is reached.
+
+The following policies are available:
+
+-   `noeviction`: Keys are not evicted but the server will return an error
+    when you try to execute commands that cache new data. If your database uses replication
+    then this condition only applies to the primary database. Note that commands that only
+    read existing data still work as normal.
+-   `allkeys-lru`: Evict the [least recently used](#apx-lru) (LRU) keys.
+-   `allkeys-lfu`: Evict the [least frequently used](#lfu-eviction) (LFU) keys.
+-   `allkeys-random`: Evict keys at random.
+-   `volatile-lru`: Evict the least recently used keys that have the `expire` field
+    set to `true`.
+-   `volatile-lfu`: Evict the least frequently used keys that have the `expire` field
+    set to `true`.
+-   `volatile-random`: Evict keys at random only if they have the `expire` field set
+    to `true`.
+-   `volatile-ttl`: Evict keys with the `expire` field set to `true` that have the
+    shortest remaining time-to-live (TTL) value.
+
+The `volatile-xxx` policies behave like `noeviction` if no keys have the `expire`
+field set to true, or for `volatile-ttl`, if no keys have a time-to-live value set.
+
+You should choose an eviction policy that fits the way your app
+accesses keys. You may be able to predict the access pattern in advance
+but you can also use information from the `INFO` command at runtime to
+check or improve your choice of policy (see
+[Using the `INFO` command](#using-the-info-command) below for more information).
+
+As a rule of thumb:
+
+-   Use `allkeys-lru` when you expect that a subset of elements will be accessed far
+    more often than the rest. This is a very common case according to the
+    [Pareto principle](https://en.wikipedia.org/wiki/Pareto_principle), so
+    `allkeys-lru` is a good default option if you have no reason to prefer any others.
+-   Use `allkeys-random` when you expect all keys to be accessed with roughly equal
+    frequency. An example of this is when your app reads data items in a repeating cycle.
+-   Use `volatile-ttl` if your code can estimate which keys are good candidates for eviction
+    and assign short TTLs to them. Note also that if you make good use of
+    key expiration, then you are less likely to run into the cache memory limit because keys
+    will often expire before they need to be evicted.
+
+The `volatile-lru` and `volatile-random` policies are mainly useful when you want to use
+a single Redis instance for both caching and for a set of persistent keys. However,
+you should consider running two separate Redis instances in a case like this, if possible.
+
+Also note that setting an `expire` value for a key costs memory, so a
+policy like `allkeys-lru` is more memory efficient since it doesn't need an
+`expire` value to operate.
+
+### Using the `INFO` command
+
+The [`INFO`]({{< relref "/commands/info" >}}) command provides several pieces
+of data that are useful for checking the performance of your cache. In particular,
+the `INFO stats` section includes two important entries, `keyspace_hits` (the number of
+times keys were successfully found in the cache) and `keyspace_misses` (the number
+of times a key was requested but was not in the cache). The calculation below gives
+the percentage of attempted accesses that were satisfied from the cache:
+
+```
+keyspace_hits / (keyspace_hits + keyspace_misses) * 100
+```
+
+Check that this is roughly equal to what you would expect for your app
+(naturally, a higher percentage indicates better cache performance).
+
+{{< note >}} When the [`EXISTS`]({{< relref "/commands/exists" >}})
+command reports that a key is absent then this is counted as a keyspace miss.
+{{< /note >}}
+
+If the percentage of hits is lower than expected, then this might
+mean you are not using the best eviction policy. For example, if
+you believe that a small subset of "hot" data (that will easily fit into the
+cache) should account for about 75% of accesses, you could reasonably
+expect the percentage of keyspace hits to be around 75%. If the actual
+percentage is lower, check the value of `evicted_keys` (also returned by
+`INFO stats`). A high proportion of evictions would suggest that the
+wrong keys are being evicted too often by your chosen policy
+(so `allkeys-lru` might be a good option here). If the
+value of `evicted_keys` is low and you are using key expiration, check
+`expired_keys` to see how many keys have expired. If this number is high,
+you might be using a TTL that is too low or you are choosing the wrong
+keys to expire and this is causing keys to disappear from the cache
+before they should.
+
+Other useful pieces of information returned by `INFO` include:
+
+-   `used_memory_dataset`: (`memory` section) The amount of memory used for
+    cached data. If this is greater than `maxmemory`, then the difference
+    is the amount by which `maxmemory` has been exceeded.
+-   `current_eviction_exceeded_time`: (`stats` section) The time since
+    the cache last started to exceed `maxmemory`.
+-   `commandstats` section: Among other things, this reports the number of
+    times each command issued to the server has been rejected. If you are
+    using `noeviction` or one of the `volatile_xxx` policies, you can use
+    this to find which commands are being stopped by the `maxmemory` limit
+    and how often it is happening.
+
+## Approximated LRU algorithm {#apx-lru}
+
+The Redis LRU algorithm uses an approximation of the least recently used
+keys rather than calculating them exactly. It samples a small number of keys
+at random and then evicts the ones with the longest time since last access.
+
+From Redis 3.0 onwards, the algorithm also tracks a pool of good
+candidates for eviction. This improves the performance of the algorithm, making
+it a close approximation to a true LRU algorithm.
+
+You can tune the performance of the algorithm by changing the number of samples to check
+before every eviction with the `maxmemory-samples` configuration directive:
+
+```
+maxmemory-samples 5
+```
+
+The reason Redis does not use a true LRU implementation is because it
+costs more memory. However, the approximation is virtually equivalent for an
+application using Redis. This figure compares
+the LRU approximation used by Redis with true LRU.
+
+![LRU comparison](lru_comparison.png)
+
+The test to generate the above graphs filled a Redis server with a given number of keys. The keys were accessed from the first to the last. The first keys are the best candidates for eviction using an LRU algorithm. Later more 50% of keys are added, in order to force half of the old keys to be evicted.
+
+You can see three kind of dots in the graphs, forming three distinct bands.
+
+* The light gray band are objects that were evicted.
+* The gray band are objects that were not evicted.
+* The green band are objects that were added.
+
+In a theoretical LRU implementation we expect that, among the old keys, the first half will be expired. The Redis LRU algorithm will instead only *probabilistically* expire the older keys.
+
+As you can see Redis 3.0 does a better job with 5 samples compared to Redis 2.8, however most objects that are among the latest accessed are still retained by Redis 2.8. Using a sample size of 10 in Redis 3.0 the approximation is very close to the theoretical performance of Redis 3.0.
+
+Note that LRU is just a model to predict how likely a given key will be accessed in the future. Moreover, if your data access pattern closely
+resembles the power law, most of the accesses will be in the set of keys
+the LRU approximated algorithm can handle well.
+
+In simulations we found that using a power law access pattern, the difference between true LRU and Redis approximation were minimal or non-existent.
+
+However you can raise the sample size to 10 at the cost of some additional CPU
+usage to closely approximate true LRU, and check if this makes a
+difference in your cache misses rate.
+
+To experiment in production with different values for the sample size by using
+the `CONFIG SET maxmemory-samples <count>` command, is very simple.
+
+## LFU eviction
+
+Starting with Redis 4.0, the [Least Frequently Used eviction mode](http://antirez.com/news/109) is available. This mode may work better (provide a better
+hits/misses ratio) in certain cases. In LFU mode, Redis will try to track
+the frequency of access of items, so the ones used rarely are evicted. This means
+the keys used often have a higher chance of remaining in memory.
+
+To configure the LFU mode, the following policies are available:
+
+* `volatile-lfu` Evict using approximated LFU among the keys with an expire set.
+* `allkeys-lfu` Evict any key using approximated LFU.
+
+LFU is approximated like LRU: it uses a probabilistic counter, called a [Morris counter](https://en.wikipedia.org/wiki/Approximate_counting_algorithm) to estimate the object access frequency using just a few bits per object, combined with a decay period so that the counter is reduced over time. At some point we no longer want to consider keys as frequently accessed, even if they were in the past, so that the algorithm can adapt to a shift in the access pattern.
+
+That information is sampled similarly to what happens for LRU (as explained in the previous section of this documentation) to select a candidate for eviction.
+
+However unlike LRU, LFU has certain tunable parameters: for example, how fast
+should a frequent item lower in rank if it gets no longer accessed? It is also possible to tune the Morris counters range to better adapt the algorithm to specific use cases.
+
+By default Redis is configured to:
+
+* Saturate the counter at, around, one million requests.
+* Decay the counter every one minute.
+
+Those should be reasonable values and were tested experimentally, but the user may want to play with these configuration settings to pick optimal values.
+
+Instructions about how to tune these parameters can be found inside the example `redis.conf` file in the source distribution. Briefly, they are:
+
+```
+lfu-log-factor 10
+lfu-decay-time 1
+```
+
+The decay time is the obvious one, it is the amount of minutes a counter should be decayed, when sampled and found to be older than that value. A special value of `0` means: we will never decay the counter.
+
+The counter *logarithm factor* changes how many hits are needed to saturate the frequency counter, which is just in the range 0-255. The higher the factor, the more accesses are needed to reach the maximum. The lower the factor, the better is the resolution of the counter for low accesses, according to the following table:
+
+```
++--------+------------+------------+------------+------------+------------+
+| factor | 100 hits   | 1000 hits  | 100K hits  | 1M hits    | 10M hits   |
++--------+------------+------------+------------+------------+------------+
+| 0      | 104        | 255        | 255        | 255        | 255        |
++--------+------------+------------+------------+------------+------------+
+| 1      | 18         | 49         | 255        | 255        | 255        |
++--------+------------+------------+------------+------------+------------+
+| 10     | 10         | 18         | 142        | 255        | 255        |
++--------+------------+------------+------------+------------+------------+
+| 100    | 8          | 11         | 49         | 143        | 255        |
++--------+------------+------------+------------+------------+------------+
+```
+
+So basically the factor is a trade off between better distinguishing items with low accesses VS distinguishing items with high accesses. More information is available in the example `redis.conf` file.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how to use Redis as a document database
+linkTitle: Document database
+stack: true
+title: Redis as a document database quick start guide
+weight: 2
+---
+
+
+This quick start guide shows you how to:
+
+1. Create a secondary index
+2. Add [JSON]({{< relref "/develop/data-types/json/" >}}) documents
+3. Search and query your data
+
+The examples in this article refer to a simple bicycle inventory that contains JSON documents with the following structure:
+
+```json
+{
+  "brand": "brand name",
+  "condition": "new | used | refurbished",
+  "description": "description",
+  "model": "model",
+  "price": 0
+}
+```
+
+## Setup
+
+The easiest way to get started with [Redis]({{< relref "/operate/oss_and_stack/" >}}) is to use Redis Cloud:
+
+1. Create a [free account](https://redis.com/try-free?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+
+   <img src="../img/free-cloud-db.png" width="500px">
+2. Follow the instructions to create a free database.
+
+This free Redis Cloud database comes out of the box with all the Redis Open Source features.
+
+You can alternatively use the [installation guides]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) to install Redis Open Source on your local machine.
+
+
+## Connect
+
+The first step is to connect to your Redis Open Source database. You can find further details about the connection options in this documentation site's [Tools section]({{< relref "/develop/tools" >}}). The following example shows how to connect to a Redis Open Source server that runs on localhost (`-h 127.0.0.1`) and listens on the default port (`-p 6379`): 
+
+{{< clients-example search_quickstart connect >}}
+> redis-cli -h 127.0.0.1 -p 6379
+{{< /clients-example>}}
+
+<br/>
+{{% alert title="Tip" color="warning" %}}
+You can copy and paste the connection details from the Redis Cloud database configuration page. Here is an example connection string of a Cloud database that is hosted in the AWS region `us-east-1` and listens on port 16379: `redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com:16379`. The connection string has the format `host:port`. You must also copy and paste your Cloud database's username and password and then pass the credentials to your client or use the [AUTH command]({{< relref "/commands/auth" >}}) after the connection is established.
+{{% /alert  %}}
+
+
+## Create an index
+
+As explained in the [in-memory data store]({{< relref "/develop/get-started/data-store" >}}) quick start guide, Redis allows you to access an item directly via its key. You also learned how to scan the keyspace. Whereby you can use other data structures (e.g., hashes and sorted sets) as secondary indexes, your application would need to maintain those indexes manually. Redis is a document database that allows you to declare which fields are auto-indexed. Redis currently supports secondary index creation on the [hashes]({{< relref "/develop/data-types/hashes" >}}) and [JSON]({{< relref "/develop/data-types/json" >}}) documents.
+
+The following example shows an [FT.CREATE]({{< relref "commands/ft.create" >}}) command that creates an index with some text fields, a numeric field (price), and a tag field (condition). The text fields have a weight of 1.0, meaning they have the same relevancy in the context of full-text searches. The field names follow the [JSONPath]({{< relref "/develop/data-types/json/path" >}}) notion. Each such index field maps to a property within the JSON document.
+
+
+{{< clients-example search_quickstart create_index >}}
+> FT.CREATE idx:bicycle ON JSON PREFIX 1 bicycle: SCORE 1.0 SCHEMA $.brand AS brand TEXT WEIGHT 1.0 $.model AS model TEXT WEIGHT 1.0 $.description AS description TEXT WEIGHT 1.0 $.price AS price NUMERIC $.condition AS condition TAG SEPARATOR ,
+OK
+{{< / clients-example >}}
+
+Any pre-existing JSON documents with a key prefix `bicycle:` are automatically added to the index. Additionally, any JSON documents with that prefix created or modified after index creation are added or re-added to the index.
+
+## Add JSON documents
+
+The example below shows you how to use the [JSON.SET]({{< relref "commands/json.set" >}}) command to create new JSON documents:
+
+{{< clients-example search_quickstart add_documents "" 2 >}}
+> JSON.SET "bicycle:0" "." "{\"brand\": \"Velorim\", \"model\": \"Jigger\", \"price\": 270, \"description\": \"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\\u2019 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\", \"condition\": \"new\"}"
+OK
+> JSON.SET "bicycle:1" "." "{\"brand\": \"Bicyk\", \"model\": \"Hillcraft\", \"price\": 1200, \"description\": \"Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\\\" wheel bike is just too clumsy coming off a 24\\\" bike. The Hillcraft 26 is just the solution they need!\", \"condition\": \"used\"}"
+OK
+> JSON.SET "bicycle:2" "." "{\"brand\": \"Nord\", \"model\": \"Chook air 5\", \"price\": 815, \"description\": \"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\", \"condition\": \"used\"}"
+OK
+> JSON.SET "bicycle:3" "." "{\"brand\": \"Eva\", \"model\": \"Eva 291\", \"price\": 3400, \"description\": \"The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It\\u2019s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!\", \"condition\": \"used\"}"
+OK
+> JSON.SET "bicycle:4" "." "{\"brand\": \"Noka Bikes\", \"model\": \"Kahuna\", \"price\": 3200, \"description\": \"Whether you want to try your hand at XC racing or are looking for a lively trail bike that's just as inspiring on the climbs as it is over rougher ground, the Wilder is one heck of a bike built specifically for short women. Both the frames and components have been tweaked to include a women\\u2019s saddle, different bars and unique colourway.\", \"condition\": \"used\"}"
+OK
+> JSON.SET "bicycle:5" "." "{\"brand\": \"Breakout\", \"model\": \"XBN 2.1 Alloy\", \"price\": 810, \"description\": \"The XBN 2.1 Alloy is our entry-level road bike \\u2013 but that\\u2019s not to say that it\\u2019s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\\u2019s, this is a bike which doesn\\u2019t break the bank and delivers craved performance.\", \"condition\": \"new\"}"
+OK
+> JSON.SET "bicycle:6" "." "{\"brand\": \"ScramBikes\", \"model\": \"WattBike\", \"price\": 2300, \"description\": \"The WattBike is the best e-bike for people who still feel young at heart. It has a Bafang 1000W mid-drive system and a 48V 17.5AH Samsung Lithium-Ion battery, allowing you to ride for more than 60 miles on one charge. It\\u2019s great for tackling hilly terrain or if you just fancy a more leisurely ride. With three working modes, you can choose between E-bike, assisted bicycle, and normal bike modes.\", \"condition\": \"new\"}"
+OK
+> JSON.SET "bicycle:7" "." "{\"brand\": \"Peaknetic\", \"model\": \"Secto\", \"price\": 430, \"description\": \"If you struggle with stiff fingers or a kinked neck or back after a few minutes on the road, this lightweight, aluminum bike alleviates those issues and allows you to enjoy the ride. From the ergonomic grips to the lumbar-supporting seat position, the Roll Low-Entry offers incredible comfort. The rear-inclined seat tube facilitates stability by allowing you to put a foot on the ground to balance at a stop, and the low step-over frame makes it accessible for all ability and mobility levels. The saddle is very soft, with a wide back to support your hip joints and a cutout in the center to redistribute that pressure. Rim brakes deliver satisfactory braking control, and the wide tires provide a smooth, stable ride on paved roads and gravel. Rack and fender mounts facilitate setting up the Roll Low-Entry as your preferred commuter, and the BMX-like handlebar offers space for mounting a flashlight, bell, or phone holder.\", \"condition\": \"new\"}"
+OK
+> JSON.SET "bicycle:8" "." "{\"brand\": \"nHill\", \"model\": \"Summit\", \"price\": 1200, \"description\": \"This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail in mountains on the weekends or you\\u2019re just after a stable, comfortable ride for the bike path, the Summit gives a good value for money.\", \"condition\": \"new\"}"
+OK
+> JSON.SET "bicycle:9" "." "{\"model\": \"ThrillCycle\", \"brand\": \"BikeShind\", \"price\": 815, \"description\": \"An artsy,  retro-inspired bicycle that\\u2019s as functional as it is pretty: The ThrillCycle steel frame offers a smooth ride. A 9-speed drivetrain has enough gears for coasting in the city, but we wouldn\\u2019t suggest taking it to the mountains. Fenders protect you from mud, and a rear basket lets you transport groceries, flowers and books. The ThrillCycle comes with a limited lifetime warranty, so this little guy will last you long past graduation.\", \"condition\": \"refurbished\"}"
+OK
+{{< / clients-example >}}
+
+## Search and query using the Redis Query Engine
+
+### Wildcard query
+
+You can retrieve all indexed documents using the [FT.SEARCH]({{< relref "commands/ft.search" >}}) command. Note the `LIMIT` clause below, which allows result pagination.
+
+{{< clients-example search_quickstart wildcard_query "" 10 >}}
+> FT.SEARCH "idx:bicycle" "*" LIMIT 0 10
+1) (integer) 10
+ 2) "bicycle:1"
+ 3) 1) "$"
+    2) "{\"brand\":\"Bicyk\",\"model\":\"Hillcraft\",\"price\":1200,\"description\":\"Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\\\" wheel bike is just too clumsy coming off a 24\\\" bike. The Hillcraft 26 is just the solution they need!\",\"condition\":\"used\"}"
+ 4) "bicycle:2"
+ 5) 1) "$"
+    2) "{\"brand\":\"Nord\",\"model\":\"Chook air 5\",\"price\":815,\"description\":\"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\",\"condition\":\"used\"}"
+ 6) "bicycle:4"
+ 7) 1) "$"
+    2) "{\"brand\":\"Noka Bikes\",\"model\":\"Kahuna\",\"price\":3200,\"description\":\"Whether you want to try your hand at XC racing or are looking for a lively trail bike that's just as inspiring on the climbs as it is over rougher ground, the Wilder is one heck of a bike built specifically for short women. Both the frames and components have been tweaked to include a women\xe2\x80\x99s saddle, different bars and unique colourway.\",\"condition\":\"used\"}"
+ 8) "bicycle:5"
+ 9) 1) "$"
+    2) "{\"brand\":\"Breakout\",\"model\":\"XBN 2.1 Alloy\",\"price\":810,\"description\":\"The XBN 2.1 Alloy is our entry-level road bike \xe2\x80\x93 but that\xe2\x80\x99s not to say that it\xe2\x80\x99s a basic machine. With an internal weld aluminium frame, a full carbon fork, and the slick-shifting Claris gears from Shimano\xe2\x80\x99s, this is a bike which doesn\xe2\x80\x99t break the bank and delivers craved performance.\",\"condition\":\"new\"}"
+10) "bicycle:0"
+11) 1) "$"
+    2) "{\"brand\":\"Velorim\",\"model\":\"Jigger\",\"price\":270,\"description\":\"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\xe2\x80\x99 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\",\"condition\":\"new\"}"
+12) "bicycle:6"
+13) 1) "$"
+    2) "{\"brand\":\"ScramBikes\",\"model\":\"WattBike\",\"price\":2300,\"description\":\"The WattBike is the best e-bike for people who still feel young at heart. It has a Bafang 1000W mid-drive system and a 48V 17.5AH Samsung Lithium-Ion battery, allowing you to ride for more than 60 miles on one charge. It\xe2\x80\x99s great for tackling hilly terrain or if you just fancy a more leisurely ride. With three working modes, you can choose between E-bike, assisted bicycle, and normal bike modes.\",\"condition\":\"new\"}"
+14) "bicycle:7"
+15) 1) "$"
+    2) "{\"brand\":\"Peaknetic\",\"model\":\"Secto\",\"price\":430,\"description\":\"If you struggle with stiff fingers or a kinked neck or back after a few minutes on the road, this lightweight, aluminum bike alleviates those issues and allows you to enjoy the ride. From the ergonomic grips to the lumbar-supporting seat position, the Roll Low-Entry offers incredible comfort. The rear-inclined seat tube facilitates stability by allowing you to put a foot on the ground to balance at a stop, and the low step-over frame makes it accessible for all ability and mobility levels. The saddle is very soft, with a wide back to support your hip joints and a cutout in the center to redistribute that pressure. Rim brakes deliver satisfactory braking control, and the wide tires provide a smooth, stable ride on paved roads and gravel. Rack and fender mounts facilitate setting up the Roll Low-Entry as your preferred commuter, and the BMX-like handlebar offers space for mounting a flashlight, bell, or phone holder.\",\"condition\":\"new\"}"
+16) "bicycle:9"
+17) 1) "$"
+    2) "{\"model\":\"ThrillCycle\",\"brand\":\"BikeShind\",\"price\":815,\"description\":\"An artsy,  retro-inspired bicycle that\xe2\x80\x99s as functional as it is pretty: The ThrillCycle steel frame offers a smooth ride. A 9-speed drivetrain has enough gears for coasting in the city, but we wouldn\xe2\x80\x99t suggest taking it to the mountains. Fenders protect you from mud, and a rear basket lets you transport groceries, flowers and books. The ThrillCycle comes with a limited lifetime warranty, so this little guy will last you long past graduation.\",\"condition\":\"refurbished\"}"
+18) "bicycle:3"
+19) 1) "$"
+    2) "{\"brand\":\"Eva\",\"model\":\"Eva 291\",\"price\":3400,\"description\":\"The sister company to Nord, Eva launched in 2005 as the first and only women-dedicated bicycle brand. Designed by women for women, allEva bikes are optimized for the feminine physique using analytics from a body metrics database. If you like 29ers, try the Eva 291. It\xe2\x80\x99s a brand new bike for 2022.. This full-suspension, cross-country ride has been designed for velocity. The 291 has 100mm of front and rear travel, a superlight aluminum frame and fast-rolling 29-inch wheels. Yippee!\",\"condition\":\"used\"}"
+20) "bicycle:8"
+21) 1) "$"
+    2) "{\"brand\":\"nHill\",\"model\":\"Summit\",\"price\":1200,\"description\":\"This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail in mountains on the weekends or you\xe2\x80\x99re just after a stable, comfortable ride for the bike path, the Summit gives a good value for money.\",\"condition\":\"new\"}"
+{{< / clients-example >}}
+
+### Single-term full-text query
+
+The following command shows a simple single-term query for finding all bicycles with a specific model:
+
+{{< clients-example search_quickstart query_single_term >}}
+> FT.SEARCH "idx:bicycle" "@model:Jigger" LIMIT 0 10
+1) (integer) 1
+2) "bicycle:0"
+3) 1) "$"
+   2) "{\"brand\":\"Velorim\",\"model\":\"Jigger\",\"price\":270,\"description\":\"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\xe2\x80\x99 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\",\"condition\":\"new\"}"
+{{< / clients-example >}}
+
+### Exact match query
+
+Below is a command to perform an exact match query that finds all bicycles with the brand name `Noka Bikes`. You must use double quotes around the search term when constructing an exact match query on a  text field.
+
+{{< clients-example search_quickstart query_exact_matching >}}
+> FT.SEARCH "idx:bicycle" "@brand:\"Noka Bikes\"" LIMIT 0 10
+1) (integer) 1
+2) "bicycle:4"
+3) 1) "$"
+   2) "{\"brand\":\"Noka Bikes\",\"model\":\"Kahuna\",\"price\":3200,\"description\":\"Whether you want to try your hand at XC racing or are looking for a lively trail bike that's just as inspiring on the climbs as it is over rougher ground, the Wilder is one heck of a bike built specifically for short women. Both the frames and components have been tweaked to include a women\xe2\x80\x99s saddle, different bars and unique colourway.\",\"condition\":\"used\"}"
+{{< / clients-example >}}
+
+Please see the [query documentation]({{< relref "/develop/interact/search-and-query/query/" >}}) to learn how to make more advanced queries.
+
+## Next steps
+
+You can learn more about how to use Redis Open Source as a vector database in the following quick start guide:
+
+* [Redis as a vector database]({{< relref "/develop/get-started/vector-database" >}})
+
+## Continue learning with Redis University
+
+{{< university-links >}}---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how to use Redis for RAG use cases
+linkTitle: RAG with Redis
+stack: true
+title: RAG with Redis
+weight: 4
+---
+### 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]({{< relref "/develop/get-started/vector-database" >}}).
+
+RAG involves three main steps:
+
+- **Retrieve**: Fetch relevant information from Redis using vector search and filters based on the user query.
+- **Augment**: Create a prompt for the LLM, including the user query, relevant context, and additional instructions.
+- **Generate**: Return the response generated by the LLM to the user.
+
+RAG enables LLMs to use real-time information, improving the accuracy and relevance of generated content.
+Redis is ideal for RAG due to its speed, versatility, and familiarity.
+
+### The role of Redis in RAG
+
+Redis provides a robust platform for managing real-time data. It supports the storage and retrieval of vectors, essential for handling large-scale, unstructured data and performing similarity searches. Key features and components of Redis that make it suitable for RAG include:
+
+1. **Vector database**: Stores and indexes vector embeddings that semantically represent unstructured data.
+1. **Semantic cache**: Caches frequently asked questions (FAQs) in a RAG pipeline. Using vector search, Redis retrieves similar previously answered questions, reducing LLM inference costs and latency.
+1. **LLM session manager**: Stores conversation history between an LLM and a user. Redis fetches recent and relevant portions of the chat history to provide context, improving the quality and accuracy of responses.
+1. **High performance and scalability**: Known for its [low latency and high throughput](https://redis.io/blog/benchmarking-results-for-vector-databases/), Redis is ideal for RAG systems and AI agents requiring rapid data retrieval and generation.
+
+### Build a RAG Application with Redis
+
+To build a RAG application with Redis, follow these general steps:
+
+1. **Set up Redis**: Start by setting up a Redis instance and configuring it to handle vector data.
+
+1. **Use a Framework**:
+    1. **Redis Vector Library (RedisVL)**: [RedisVL](https://redis.io/docs/latest/integrate/redisvl/) enhances the development of generative AI applications by efficiently managing vectors and metadata. It allows for storage of vector embeddings and facilitates fast similarity searches, crucial for retrieving relevant information in RAG.
+    1. **Popular AI frameworks**: Redis integrates seamlessly with various AI frameworks and tools. For instance, combining Redis with [LangChain](https://python.langchain.com/v0.2/docs/integrations/vectorstores/redis/) or [LlamaIndex](https://docs.llamaindex.ai/en/latest/examples/vector_stores/RedisIndexDemo/), libraries for building language models, enables developers to create sophisticated RAG pipelines. These integrations support efficient data management and building real-time LLM chains.
+    1. **Spring AI and Redis**: Using [Spring AI with Redis](https://redis.io/blog/building-a-rag-application-with-redis-and-spring-ai/) simplifies building RAG applications. Spring AI provides a structured approach to integrating AI capabilities into applications, while Redis handles data management, ensuring the RAG pipeline is efficient and scalable.
+
+1. **Embed and store data**: Convert your data into vector embeddings using a suitable model (e.g., BERT, GPT). Store these embeddings in Redis, where they can be quickly retrieved based on vector searches.
+
+1. **Integrate with a generative model**: Use a generative AI model that can leverage the retrieved data. The model will use the vectors stored in Redis to augment its generation process, ensuring the output is informed by relevant, up-to-date information.
+
+1. **Query and generate**: Implement the query logic to retrieve relevant vectors from Redis based on the input prompt. Feed these vectors into the generative model to produce augmented outputs.
+
+### Benefits of Using Redis for RAG
+
+- **Efficiency**: The in-memory data store of Redis ensures that retrieval operations are performed with minimal latency.
+- **Scalability**: Redis scales horizontally, seamlessly handling growing volumes of data and queries.
+- **Flexibility**: Redis supports a variety of data structures and integrates with AI frameworks.
+
+In summary, Redis offers a powerful and efficient platform for implementing RAG. Its vector management capabilities, high performance, and seamless integration with AI frameworks make it an ideal choice for enhancing generative AI applications with real-time data retrieval.
+
+### Resources
+
+- [RAG defined](https://redis.io/glossary/retrieval-augmented-generation/).
+- [RAG overview](https://redis.io/kb/doc/2ok7xd1drq/how-to-perform-retrieval-augmented-generation-rag-with-redis).
+- [Redis Vector Library (RedisVL)](https://redis.io/docs/latest/integrate/redisvl/) and [introductory article](https://redis.io/blog/introducing-the-redis-vector-library-for-enhancing-genai-development/).
+- [RAG with Redis and SpringAI](https://redis.io/blog/building-a-rag-application-with-redis-and-spring-ai/)
+- [Build a multimodal RAG app with LangChain and Redis](https://redis.io/blog/explore-the-new-multimodal-rag-template-from-langchain-and-redis/)
+- [Get hands-on with advanced Redis AI Recipes](https://github.com/redis-developer/redis-ai-resources)
+
+## Continue learning with Redis University
+
+{{< university-links >}}---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how to use basic Redis data types
+linkTitle: Data structure store
+title: Redis as an in-memory data structure store quick start guide
+weight: 1
+---
+
+This quick start guide shows you how to:
+
+1. Get started with Redis 
+2. Store data under a key in Redis
+3. Retrieve data with a key from Redis
+4. 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:
+
+1. Create a [free account](https://redis.com/try-free?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+
+    <img src="../img/free-cloud-db.png" width="500px">
+2. Follow the instructions to create a free database.
+
+You can alternatively follow the [installation guides]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) to install Redis on your local machine.
+
+## Connect
+
+The first step is to connect to Redis. You can find further details about the connection options in this documentation site's [Tools section]({{< relref "/develop/tools" >}}). The following example shows how to connect to a Redis server that runs on localhost (`-h 127.0.0.1`) and listens on the default port (`-p 6379`): 
+
+{{< clients-example search_quickstart connect >}}
+> redis-cli -h 127.0.0.1 -p 6379
+{{< /clients-example>}}
+<br/>
+{{% alert title="Tip" color="warning" %}}
+You can copy and paste the connection details from the Redis Cloud database configuration page. Here is an example connection string of a Cloud database that is hosted in the AWS region `us-east-1` and listens on port 16379: `redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com:16379`. The connection string has the format `host:port`. You must also copy and paste the username and password of your Cloud database and then either pass the credentials to your client or use the [AUTH command]({{< relref "/commands/auth" >}}) after the connection is established.
+{{% /alert  %}}
+
+## Store and retrieve data
+
+Redis stands for Remote Dictionary Server. You can use the same data types as in your local programming environment but on the server side within Redis.
+
+Similar to byte arrays, Redis strings store sequences of bytes, including text, serialized objects, counter values, and binary arrays. The following example shows you how to set and get a string value:
+
+{{< clients-example set_and_get >}}
+SET bike:1 "Process 134"
+GET bike:1
+{{< /clients-example >}}
+
+Hashes are the equivalent of dictionaries (dicts or hash maps). Among other things, you can use hashes to represent plain objects and to store groupings of counters. The following example explains how to set and access field values of an object:
+
+{{< clients-example hash_tutorial set_get_all >}}
+> 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"
+{{< /clients-example >}}
+
+You can get a complete overview of available data types in this documentation site's [data types section]({{< relref "/develop/data-types/" >}}). Each data type has commands allowing you to manipulate or retrieve data. The [commands reference]({{< relref "/commands/" >}}) provides a sophisticated explanation.
+
+## Scan the keyspace
+
+Each item within Redis has a unique key. All items live within the Redis [keyspace]({{< relref "/develop/use/keyspace" >}}). You can scan the Redis keyspace via the [SCAN command]({{< relref "/commands/scan" >}}). Here is an example that scans for the first 100 keys that have the prefix `bike:`:
+
+```
+SCAN 0 MATCH "bike:*" COUNT 100
+```
+
+[SCAN]({{< relref "/commands/scan" >}}) returns a cursor position, allowing you to scan iteratively for the next batch of keys until you reach the cursor value 0.
+
+## Next steps
+
+You can address more use cases with Redis by reading these additional quick start guides:
+
+* [Redis as a document database]({{< relref "/develop/get-started/document-database" >}})
+* [Redis as a vector database]({{< relref "/develop/get-started/vector-database" >}})
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Commonly asked questions when getting started with Redis
+
+  '
+linkTitle: FAQ
+title: Redis FAQ
+weight: 100
+---
+## How is Redis different from other key-value stores?
+
+* Redis has a different evolution path in the key-value DBs where values can contain more complex data types, with atomic operations defined on those data types. Redis data types are closely related to fundamental data structures and are exposed to the programmer as such, without additional abstraction layers.
+* Redis is an in-memory but persistent on disk database, so it represents a different trade off where very high write and read speed is achieved with the limitation of data sets that can't be larger than memory. Another advantage of
+in-memory databases is that the memory representation of complex data structures
+is much simpler to manipulate compared to the same data structures on disk, so
+Redis can do a lot with little internal complexity. At the same time the
+two on-disk storage formats (RDB and AOF) don't need to be suitable for random
+access, so they are compact and always generated in an append-only fashion
+(Even the AOF log rotation is an append-only operation, since the new version
+is generated from the copy of data in memory). However this design also involves
+different challenges compared to traditional on-disk stores. Being the main data
+representation on memory, Redis operations must be carefully handled to make sure
+there is always an updated version of the data set on disk.
+
+## What's the Redis memory footprint?
+
+To give you a few examples (all obtained using 64-bit instances):
+
+* An empty instance uses ~ 3MB of memory.
+* 1 Million small Keys -> String Value pairs use ~ 85MB of memory.
+* 1 Million Keys -> Hash value, representing an object with 5 fields, use ~ 160 MB of memory.
+
+Testing your use case is trivial. Use the `redis-benchmark` utility to generate random data sets then check the space used with the `INFO memory` command.
+
+64-bit systems will use considerably more memory than 32-bit systems to store the same keys, especially if the keys and values are small. This is because pointers take 8 bytes in 64-bit systems. But of course the advantage is that you can
+have a lot of memory in 64-bit systems, so in order to run large Redis servers a 64-bit system is more or less required. The alternative is sharding.
+
+## Why does Redis keep its entire dataset in memory?
+
+In the past the Redis developers experimented with Virtual Memory and other systems in order to allow larger than RAM datasets, but after all we are very happy if we can do one thing well: data served from memory, disk used for storage. So for now there are no plans to create an on disk backend for Redis. Most of what
+Redis is, after all, a direct result of its current design.
+
+If your real problem is not the total RAM needed, but the fact that you need
+to split your data set into multiple Redis instances, please read the
+[partitioning page]({{< relref "/operate/oss_and_stack/management/scaling" >}}) in this documentation for more info.
+
+Redis Ltd., the company sponsoring Redis development, has developed a
+"Redis on Flash" solution that uses a mixed RAM/flash approach for
+larger data sets with a biased access pattern. You may check their offering
+for more information, however this feature is not part of the Redis Open Source
+code base.
+
+## Can you use Redis with a disk-based database?
+
+Yes, a common design pattern involves taking very write-heavy small data
+in Redis (and data you need the Redis data structures to model your problem
+in an efficient way), and big *blobs* of data into an SQL or eventually
+consistent on-disk database. Similarly sometimes Redis is used in order to
+take in memory another copy of a subset of the same data stored in the on-disk
+database. This may look similar to caching, but actually is a more advanced model
+since normally the Redis dataset is updated together with the on-disk DB dataset,
+and not refreshed on cache misses.
+
+## How can I reduce Redis' overall memory usage?
+
+A good practice is to consider memory consumption when mapping your logical data model to the physical data model within Redis. These considerations include using specific data types, key patterns, and normalization.
+
+Beyond data modeling, there is more info in the [Memory Optimization page]({{< relref "/operate/oss_and_stack/management/optimization/memory-optimization" >}}).
+
+## What happens if Redis runs out of memory?
+
+Redis has built-in protections allowing the users to set a max limit on memory
+usage, using the `maxmemory` option in the configuration file to put a limit
+to the memory Redis can use. If this limit is reached, Redis will start to reply
+with an error to write commands (but will continue to accept read-only
+commands).
+
+You can also configure Redis to evict keys when the max memory limit
+is reached. See the [eviction policy docs]({{< relref "/develop/reference/eviction" >}}) for more information on this.
+
+## Background saving fails with a fork() error on Linux?
+
+Short answer: `echo 1 > /proc/sys/vm/overcommit_memory` :)
+
+And now the long one:
+
+The Redis background saving schema relies on the copy-on-write semantic of the `fork` system call in
+modern operating systems: Redis forks (creates a child process) that is an
+exact copy of the parent. The child process dumps the DB on disk and finally
+exits. In theory the child should use as much memory as the parent being a
+copy, but actually thanks to the copy-on-write semantic implemented by most
+modern operating systems the parent and child process will _share_ the common
+memory pages. A page will be duplicated only when it changes in the child or in
+the parent. Since in theory all the pages may change while the child process is
+saving, Linux can't tell in advance how much memory the child will take, so if
+the `overcommit_memory` setting is set to zero the fork will fail unless there is
+as much free RAM as required to really duplicate all the parent memory pages.
+If you have a Redis dataset of 3 GB and just 2 GB of free
+memory it will fail.
+
+Setting `overcommit_memory` to 1 tells Linux to relax and perform the fork in a
+more optimistic allocation fashion, and this is indeed what you want for Redis.
+
+You can refer to the [proc(5)][proc5] man page for explanations of the
+available values.
+
+[proc5]: http://man7.org/linux/man-pages/man5/proc.5.html
+
+## Are Redis on-disk snapshots atomic?
+
+Yes, the Redis background saving process is always forked when the server is
+outside of the execution of a command, so every command reported to be atomic
+in RAM is also atomic from the point of view of the disk snapshot.
+
+## How can Redis use multiple CPUs or cores?
+
+It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound.
+For instance, when using pipelining a Redis instance running on an average Linux system can deliver 1 million requests per second, so if your application mainly uses O(N) or O(log(N)) commands, it is hardly going to use too much CPU.
+
+However, to maximize CPU usage you can start multiple instances of Redis in
+the same box and treat them as different servers. At some point a single
+box may not be enough anyway, so if you want to use multiple CPUs you can
+start thinking of some way to shard earlier.
+
+You can find more information about using multiple Redis instances in the [Partitioning page]({{< relref "/operate/oss_and_stack/management/scaling" >}}).
+
+As of version 4.0, Redis has started implementing threaded actions. For now this is limited to deleting objects in the background and blocking commands implemented via Redis modules. For subsequent releases, the plan is to make Redis more and more threaded.
+
+## What is the maximum number of keys a single Redis instance can hold? What is the maximum number of elements in a Hash, List, Set, and Sorted Set?
+
+Redis can handle up to 2^32 keys, and was tested in practice to
+handle at least 250 million keys per instance.
+
+Every hash, list, set, and sorted set, can hold 2^32 elements.
+
+In other words your limit is likely the available memory in your system.
+
+## Why does my replica have a different number of keys its master instance?
+
+If you use keys with limited time to live (Redis expires) this is normal behavior. This is what happens:
+
+* The primary generates an RDB file on the first synchronization with the replica.
+* The RDB file will not include keys already expired in the primary but which are still in memory.
+* These keys are still in the memory of the Redis primary, even if logically expired. They'll be considered non-existent, and their memory will be reclaimed later, either incrementally or explicitly on access. While these keys are not logically part of the dataset, they are accounted for in the [`INFO`]({{< relref "/commands/info" >}}) output and in the [`DBSIZE`]({{< relref "/commands/dbsize" >}}) command.
+* When the replica reads the RDB file generated by the primary, this set of keys will not be loaded.
+
+Because of this, it's common for users with many expired keys to see fewer keys in the replicas. However, logically, the primary and replica will have the same content.
+
+## Where does the name "Redis" come from?
+
+Redis is an acronym that stands for **RE**mote **DI**ctionary **S**erver.
+
+## Why did Salvatore Sanfilippo start the Redis project?
+
+Salvatore originally created Redis to scale [LLOOGG](https://github.com/antirez/lloogg), a real-time log analysis tool. But after getting the basic Redis server working, he decided to share the work with other people and turn Redis into an open source project.
+
+## How is Redis pronounced?
+
+"Redis" (/ˈrɛd-ɪs/) is pronounced like the word "red" plus the word "kiss" without the "k".
+---
+Title: Redis for GenAI apps
+alwaysopen: false
+categories:
+- docs
+- develop
+description: Understand key benefits of using Redis for AI.
+linktitle: GenAI apps
+weight: 20
+---
+
+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.
+
+## Key Benefits of Redis in GenAI Apps
+
+- **Performance**: low-latency data access enables real-time interactions critical for AI-driven applications.
+- **Scalability**: designed to handle numerous concurrent connections, Redis is perfect for high-demand GenAI apps.
+- **Caching**: efficiently stores frequently accessed data and responses, reducing primary database load and accelerating response times.
+- **Session Management**: in-memory data structures simplify managing session states in conversational AI scenarios.
+- **Flexibility**: Redis supports diverse data structures (for example, strings, hashes, lists, sets), allowing tailored solutions for GenAI apps.
+
+[RedisVL]({{< relref "/integrate/redisvl" >}}) is a Python library with an integrated CLI, offering seamless integration with Redis to enhance GenAI applications.
+
+---
+
+## Redis Use Cases in GenAI Apps
+
+Explore how Redis optimizes various GenAI applications through specific use cases, tutorials, and demo code repositories.
+
+### Optimizing AI Agent Performance
+
+Redis improves session persistence and caching for conversational agents managing high interaction volumes. See the [Flowise Conversational Agent with Redis](https://redis.io/learn/howtos/solutions/flowise/conversational-agent) tutorial and demo for implementation details.
+
+### Chatbot Development and Management
+
+Redis supports chatbot platforms by enabling:
+
+- **Caching**: enhances bot responsiveness.
+- **Session Management**: tracks conversation states for seamless interactions.
+- **Scalability**: handles high-traffic bot usage.
+
+Learn how to build a GenAI chatbot with Redis through the [LangChain and Redis tutorial](https://redis.io/learn/howtos/solutions/vector/gen-ai-chatbot). For customer engagement platforms integrating human support with chatbots, Redis ensures rapid access to frequently used data. Check out the tutorial on [AI-Powered Video Q&A Applications](https://redis.io/learn/howtos/solutions/vector/ai-qa-videos-langchain-redis-openai-google).
+
+### Integrating ML Frameworks with Redis
+
+Machine learning frameworks leverage Redis for:
+
+- **Message Queuing**: ensures smooth communication between components.
+- **State Management**: tracks conversation states for real-time interactions.
+
+Refer to [Semantic Image-Based Queries Using LangChain and Redis](https://redis.io/learn/howtos/solutions/vector/image-summary-search) for a detailed guide. To expand your knowledge, enroll in the [Redis as a Vector Database course](https://redis.io/university/courses/ru402/), where you'll learn about integrations with tools like LangChain, LlamaIndex, FeatureForm, Amazon Bedrock, and AzureOpenAI.
+
+### Advancing Natural Language Processing
+
+Redis enhances natural language understanding by:
+
+- **Session Management**: tracks user interactions for seamless conversational experiences.
+- **Caching**: reduces latency for frequent queries.
+
+See the [Streaming LLM Output Using Redis Streams](https://redis.io/learn/howtos/solutions/streams/streaming-llm-output) tutorial for an in-depth walkthrough.
+
+Redis is a powerful tool to elevate your GenAI applications, enabling them to deliver superior performance, scalability, and user satisfaction.
+
+## Resources
+
+Check out the [Redis for AI]({{< relref "/develop/ai" >}}) documentation for getting started guides, concepts, ecosystem integrations, examples, and Python notebooks.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Understand how to use Redis as a vector database
+linkTitle: Vector database
+stack: true
+title: Redis as a vector database quick start guide
+weight: 3
+---
+
+This quick start guide helps you to:
+
+1. Understand what a vector database is
+2. Create a Redis vector database
+3. Create vector embeddings and store vectors
+4. Query data and perform a vector search
+
+{{< note >}}This guide uses [RedisVL]({{< relref "/develop/clients/redis-vl" >}}),
+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-py` (Python)]({{< relref "/develop/clients/redis-py/vecsearch" >}})
+- [`NRedisStack`(C#/.NET)]({{< relref "/develop/clients/dotnet/vecsearch" >}})
+- [`node-redis` (JavaScript/Node.js)]({{< relref "/develop/clients/nodejs/vecsearch" >}})
+- [`jedis` (Java)]({{< relref "/develop/clients/jedis/vecsearch" >}})
+- [`go-redis` (Go)]({{< relref "/develop/clients/go/vecsearch" >}})
+{{< /note >}}
+
+## Understand vector databases
+
+Data is often unstructured, which means that it isn't described by a well-defined schema. Examples of unstructured data include text passages, images, videos, or audio. One approach to storing and searching through unstructured data is to use vector embeddings.
+
+**What are vectors?** In machine learning and AI, vectors are sequences of numbers that represent data. They are the inputs and outputs of models, encapsulating underlying information in a numerical form. Vectors transform unstructured data, such as text, images, videos, and audio, into a format that machine learning models can process.
+
+- **Why are they important?** Vectors capture complex patterns and semantic meanings inherent in data, making them powerful tools for a variety of applications. They allow machine learning models to understand and manipulate unstructured data more effectively.
+- **Enhancing traditional search.** Traditional keyword or lexical search relies on exact matches of words or phrases, which can be limiting. In contrast, vector search, or semantic search, leverages the rich information captured in vector embeddings. By mapping data into a vector space, similar items are positioned near each other based on their meaning. This approach allows for more accurate and meaningful search results, as it considers the context and semantic content of the query rather than just the exact words used.
+
+
+## Create a Redis vector database
+You can use [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}}) as a vector database. It allows you to:
+
+* Store vectors and the associated metadata within hashes or [JSON]({{< relref "/develop/data-types/json" >}}) documents
+* Create and configure secondary indices for search
+* Perform vector searches
+* Update vectors and metadata
+* Delete and cleanup
+
+The easiest way to get started is to use Redis Cloud:
+
+1. Create a [free account](https://redis.com/try-free?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+
+   <img src="../img/free-cloud-db.png" width="500px">
+2. Follow the instructions to create a free database.
+
+This free Redis Cloud database comes out of the box with all the Redis Open Source features.
+
+You can alternatively use the [installation guides]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) to install Redis on your local machine.
+
+## Install the required Python packages
+
+Create a Python virtual environment and install the following dependencies using `pip`:
+
+* `redis`: You can find further details about the `redis-py` client library in the [clients]({{< relref "/develop/clients/redis-py" >}}) section of this documentation site.
+* `pandas`: Pandas is a data analysis library.
+* `sentence-transformers`: You will use the [SentenceTransformers](https://www.sbert.net/) framework to generate embeddings on full text.
+* `tabulate`: `pandas` uses `tabulate` to render Markdown.
+
+You will also need the following imports in your Python code:
+
+{{< clients-example search_vss imports />}}
+
+## Connect
+
+Connect to Redis. By default, Redis returns binary responses. To decode them, you pass the `decode_responses` parameter set to `True`:
+
+{{< clients-example search_vss connect />}}
+<br/>
+{{% alert title="Tip" color="warning" %}}
+Instead of using a local Redis server, you can copy and paste the connection details from the Redis Cloud database configuration page. Here is an example connection string of a Cloud database that is hosted in the AWS region `us-east-1` and listens on port 16379: `redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com:16379`. The connection string has the format `host:port`. You must also copy and paste the username and password of your Cloud database. The line of code for connecting with the default user changes then to `client = redis.Redis(host="redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com", port=16379, password="your_password_here", decode_responses=True)`.
+{{% /alert  %}}
+
+
+## Prepare the demo dataset
+
+This quick start guide also uses the **bikes** dataset. Here is an example document from it:
+
+```json
+{
+  "model": "Jigger",
+  "brand": "Velorim",
+  "price": 270,
+  "type": "Kids bikes",
+  "specs": {
+    "material": "aluminium",
+    "weight": "10"
+  },
+  "description": "Small and powerful, the Jigger is the best ride for the smallest of tikes! ..."
+}
+```
+
+The `description` field contains free-form text descriptions of bikes and will be used to create vector embeddings.
+
+
+###  1. Fetch the demo data
+You need to first fetch the demo dataset as a JSON array:
+
+{{< clients-example search_vss get_data />}}
+
+Inspect the structure of one of the bike JSON documents:
+
+{{< clients-example search_vss dump_data />}}
+
+### 2. Store the demo data in Redis
+Now iterate over the `bikes`  array to store the data as [JSON]({{< relref "/develop/data-types/json/" >}}) documents in Redis by using the [JSON.SET]({{< relref "commands/json.set/" >}}) command. The below code uses a [pipeline]({{< relref "/develop/use/pipelining" >}}) to minimize the network round-trip times:
+
+{{< clients-example search_vss load_data />}}
+
+Once loaded, you can retrieve a specific attribute from one of the JSON documents in Redis using a [JSONPath](https://goessner.net/articles/JsonPath/) expression:
+
+{{< clients-example search_vss get />}}
+
+### 3. Select a text embedding model
+
+[HuggingFace](https://huggingface.co) has a large catalog of text embedding models that are locally servable through the `SentenceTransformers` framework. Here we use the [MS MARCO](https://microsoft.github.io/msmarco/) model that is widely used in search engines, chatbots, and other AI applications.
+
+```python
+from sentence_transformers import SentenceTransformer
+
+embedder = SentenceTransformer('msmarco-distilbert-base-v4')
+```
+
+### 4. Generate text embeddings
+Iterate over all the Redis keys with the prefix `bikes:`:
+
+{{< clients-example search_vss get_keys />}}
+
+Use the keys as input to the [JSON.MGET]({{< relref "commands/json.mget/" >}}) command, along with the `$.description` field, to collect the descriptions in a list. Then, pass the list of descriptions to the `.encode()` method:
+
+{{< clients-example search_vss generate_embeddings />}}
+
+Insert the vectorized descriptions to the bike documents in Redis using the [JSON.SET]({{< relref "commands/json.set" >}}) command. The following command inserts a new field into each of the documents under the JSONPath `$.description_embeddings`. Once again, do this using a pipeline to avoid unnecessary network round-trips:
+
+{{< clients-example search_vss load_embeddings />}}
+
+Inspect one of the updated bike documents using the [JSON.GET]({{< relref "commands/json.get" >}}) command:
+
+{{< clients-example search_vss dump_example />}}
+
+{{% alert title="Note" color="warning" %}}
+When storing a vector embedding within a JSON document, the embedding is stored as a JSON array. In the example above, the array was shortened considerably for the sake of readability.
+{{% /alert  %}}
+
+
+## Create an index
+
+### 1. Create an index with a vector field
+
+You must create an index to query document metadata or to perform vector searches. Use the [FT.CREATE]({{< relref "commands/ft.create" >}}) command:
+
+{{< clients-example search_vss create_index >}}
+FT.CREATE idx:bikes_vss ON JSON
+  PREFIX 1 bikes: SCORE 1.0
+  SCHEMA
+    $.model TEXT WEIGHT 1.0 NOSTEM
+    $.brand TEXT WEIGHT 1.0 NOSTEM
+    $.price NUMERIC
+    $.type TAG SEPARATOR ","
+    $.description AS description TEXT WEIGHT 1.0
+    $.description_embeddings AS vector VECTOR FLAT 6 TYPE FLOAT32 DIM 768 DISTANCE_METRIC COSINE
+{{< /clients-example >}}
+
+Here is a breakdown of the `VECTOR` field definition:
+
+* `$.description_embeddings AS vector`: The vector field's JSON path and its field alias `vector`.
+* `FLAT`: Specifies the indexing method, which is either a flat index or a hierarchical navigable small world graph ([HNSW](https://arxiv.org/ftp/arxiv/papers/1603/1603.09320.pdf)).
+* `TYPE FLOAT32`: Sets the float precision of a vector component, in this case a 32-bit floating point number.
+* `DIM 768`: The length or dimension of the embeddings, determined by the chosen embedding model.
+* `DISTANCE_METRIC COSINE`: The chosen distance function: [cosine distance](https://en.wikipedia.org/wiki/Cosine_similarity).
+
+You can find further details about all these options in the [vector reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+
+### 2. Check the state of the index
+
+As soon as you execute the [FT.CREATE]({{< relref "commands/ft.create" >}}) command, the indexing process runs in the background. In a short time, all JSON documents should be indexed and ready to be queried. To validate that, you can use the [FT.INFO]({{< relref "commands/ft.info" >}}) command, which provides details and statistics about the index. Of particular interest are the number of documents successfully indexed and the number of failures:
+
+{{< clients-example search_vss validate_index >}}
+FT.INFO idx:bikes_vss
+{{< /clients-example >}}
+
+## Perform vector searches
+
+This quick start guide focuses on vector search. However, you can learn more about how to query based on document metadata in the [document database quick start guide]({{< relref "/develop/get-started/document-database" >}}).
+
+### 1. Embed your queries
+
+The following code snippet shows a list of text queries you will use to perform vector search in Redis:
+
+{{< clients-example search_vss def_bulk_queries />}}
+
+First, encode each input query as a vector embedding using the same SentenceTransformers model:
+
+{{< clients-example search_vss enc_bulk_queries />}}
+
+<br/>
+{{% alert title="Tip" color="warning" %}}
+It is vital that you use the same embedding model to embed your queries as you did your documents. Using a different model will result in poor semantic search results or error.
+{{% /alert  %}}
+
+### 2. K-nearest neighbors (KNN) search
+The KNN algorithm calculates the distance between the query vector and each vector in Redis based on the chosen distance function. It then returns the top K items with the smallest distances to the query vector. These are the most semantically similar items.
+
+Now construct a query to do just that:
+
+```python
+query = (
+    Query('(*)=>[KNN 3 @vector $query_vector AS vector_score]')
+     .sort_by('vector_score')
+     .return_fields('vector_score', 'id', 'brand', 'model', 'description')
+     .dialect(2)
+)
+```
+
+Let's break down the above query template:
+- The filter expression `(*)` means `all`. In other words, no filtering was applied. You could replace it with an expression that filters by additional metadata.
+- The `KNN` part of the query searches for the top 3 nearest neighbors.
+- The query vector must be passed in as the param `query_vector`.
+- The distance to the query vector is returned as `vector_score`.
+- The results are sorted by this `vector_score`.
+- Finally, it returns the fields `vector_score`,  `id`, `brand`, `model`, and `description` for each result.
+
+{{% alert title="Note" color="warning" %}}
+To utilize a vector query with the [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) command, you must specify DIALECT 2 or greater.
+{{% /alert  %}}
+
+You must pass the vectorized query as a byte array with the param name `query_vector`. The following code creates a Python NumPy array from the query vector and converts it into a compact, byte-level representation that can be passed as a parameter to the query:
+
+```python
+client.ft('idx:bikes_vss').search(
+    query,
+    {
+      'query_vector': np.array(encoded_query, dtype=np.float32).tobytes()
+    }
+).docs
+```
+
+With the template for the query in place, you can execute all queries in a loop. Notice that the script calculates the `vector_score` for each result as `1 - doc.vector_score`. Because the cosine distance is used as the metric, the items with the smallest distance are closer and, therefore, more similar to the query.
+
+Then, loop over the matched documents and create a list of results that can be converted into a Pandas table to visualize the results:
+
+{{< clients-example search_vss define_bulk_query />}}
+
+The query results show the individual queries' top three matches (our K parameter) along with the bike's id, brand, and model for each query.
+
+For example, for the query "Best Mountain bikes for kids", the highest similarity score (`0.54`) and, therefore the closest match was the 'Nord' brand 'Chook air 5' bike model, described as:
+
+> The Chook Air 5 gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails. The Chook Air 5 is the perfect intro to mountain biking.
+
+From the description, this bike is an excellent match for younger children, and the embeddings accurately captured the semantics of the description.
+
+{{< clients-example search_vss run_knn_query />}}
+
+| query | score | id | brand | model | description |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| Best Mountain bikes for kids | 0.54 | bikes:003 | Nord | Chook air 5 | The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails. The Chook Air 5 is the perfect intro to mountain biking. |
+|  | 0.51 | bikes:010 | nHill | Summit | This budget mountain bike from nHill performs well both on bike paths and on the trail. The fork with 100mm of travel absorbs rough terrain. Fat Kenda Booster tires give you grip in corners and on wet trails. The Shimano Tourney drivetrain offered enough gears for finding a comfortable pace to ride uphill, and the Tektro hydraulic disc brakes break smoothly. Whether you want an affordable bike that you can take to work, but also take trail riding on the weekends or you’re just after a stable,... |
+|  | 0.46 | bikes:001 | Velorim | Jigger | Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go. We say rare because this smokin’ little bike is not ideal for a nervous first-time rider, but it’s a true giddy up for a true speedster. The Jigger is a 12 inch lightweight kids bicycle and it will meet your little one’s need for speed. It’s a single... |
+
+
+## Next steps
+
+1. You can learn more about the query options, such as filters and vector range queries, by reading the [vector reference documentation]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+2. The complete [Redis Query Engine documentation]({{< relref "/develop/interact/search-and-query/" >}}) might be interesting for you.
+3. If you want to follow the code examples more interactively, then you can use the [Jupyter notebook](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/00_redispy.ipynb) that inspired this quick start guide.
+4. If you want to see more advanced examples of a Redis vector database in action, visit the [Redis AI Resources](https://github.com/redis-developer/redis-ai-resources) page on GitHub.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: 'Redis quick start guides
+
+  '
+hideListLinks: true
+linkTitle: Quick starts
+title: Quick starts
+weight: 20
+---
+
+Redis can be used as a database, cache, streaming engine, message broker, and more. The following quick start guides will show you how to use Redis for the following specific purposes:
+
+1. [Data structure store]({{< relref "/develop/get-started/data-store" >}})
+2. [Document database]({{< relref "/develop/get-started/document-database" >}})
+3. [Vector database]({{< relref "/develop/get-started/vector-database" >}})
+
+Please select the guide that aligns best with your specific usage scenario.
+
+You can find answers to frequently asked questions in the [FAQ]({{< relref "/develop/get-started/faq" >}}).
+---
+title: Develop with Redis
+description: Learn how to develop with Redis
+linkTitle: Develop
+---
+
+Explore the pages below to learn more about developing with Redis Open Source.
+---
+LinkTitle: RedisOM for Java
+Title: RedisOM for Java
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis Stack and Spring
+group: library
+stack: true
+summary: The Redis OM for Java library is based on the Spring framework and provides
+  object-mapping abstractions.
+title: Redis OM Spring
+type: integration
+weight: 9
+---
+
+Redis Stack provides a seamless and straightforward way to use different data models and functionality from Redis, including a document store, a time series data database, probabilistic data structures, and a full-text search engine.
+
+Redis Stack is supported by several client libraries, including Node.js, Java, and Python, so that developers can use their preferred language. We'll be using one of the Redis Stack supporting libraries; [Redis OM Spring](https://github.com/redis/redis-om-spring).
+Redis OM Spring provides a robust repository and custom object-mapping abstractions built on the powerful Spring Data Redis (SDR) framework.
+
+## What you’ll need:
+
+* Redis Stack: See [{{< relref "/operate/oss_and_stack/install/install-stack/" >}}]({{< relref "/operate/oss_and_stack/install/install-stack/" >}})
+* [Redis Insight]({{< relref "/develop/tools/insight" >}})
+* Your favorite browser
+* Java 11 or greater
+
+## Spring Boot scaffold with Spring Initializer
+
+We’ll start by creating a skeleton app using the [Spring Initializer](https://start.spring.io), open your browser to https://start.spring.io and let's configure our skeleton application as follows:
+
+* We’ll use a Maven-based build (check Maven checkbox)
+* And version **`2.6.4`** of Spring Boot which is the current version supported by Redis OM Spring
+* Group: **`com.redis.om`**
+* Artifact: **`skeleton`**
+* Name: **`skeleton`**
+* Description: Skeleton App for Redis OM Spring
+* Package Name: **`com.redis.om.skeleton`**
+* Packaging: JAR
+* Java: **`11`**
+* Dependencies: **`web`**, **`devtools`** and **`lombok`**.
+
+The `web` (Spring Web) gives us the ability to build RESTful applications using Spring MVC. With `devtools` we get fast application restarts and reloads. And `lombok` reduces boilerplate code like getters and setters.
+
+![Spring Initializer](./images/001_stack_spring.png "Spring Initializer")
+
+Click `Generate` and download the ZIP file, unzip it and load the Maven project into your IDE of choice.
+
+## Adding Redis OM Spring
+
+Open the Maven `pom.xml` and between the `<dependencies>` and `<build>` sections we’ll add the snapshots repositories so that we can get to latest SNAPSHOT release of redis-om-spring:
+
+{{< highlight xml >}}
+<repositories>
+  <repository>
+    <id>snapshots-repo</id>
+    <url>https://s01.oss.sonatype.org/content/repositories/snapshots/</url>
+  </repository>
+</repositories>
+{{< / highlight >}}
+
+And then in the `<dependencies>` section add version `0.3.0` of Redis OM Spring:
+
+{{< highlight xml >}}
+<dependency>
+  <groupId>com.redis.om</groupId>
+  <artifactId>redis-om-spring</artifactId>
+  <version>0.3.0-SNAPSHOT</version>
+</dependency>
+{{< / highlight >}}
+
+## Adding Swagger
+
+We'll use the Swagger UI to test our web services endpoint. To add Swagger 2 to a Spring REST web service, using the Springfox implementation add the following dependencies to the POM:
+
+{{< highlight xml >}}
+<dependency>
+  <groupId>io.springfox</groupId>
+  <artifactId>springfox-boot-starter</artifactId>
+  <version>3.0.0</version>
+</dependency>
+<dependency>
+  <groupId>io.springfox</groupId>
+  <artifactId>springfox-swagger-ui</artifactId>
+  <version>3.0.0</version>
+</dependency>
+{{< / highlight >}}
+
+Let's add Swagger Docker Bean to the Spring App class:
+
+{{< highlight java >}}
+@Bean
+public Docket api() {
+  return new Docket(DocumentationType.SWAGGER_2)
+      .select()
+      .apis(RequestHandlerSelectors.any())
+      .paths(PathSelectors.any())
+      .build();
+}
+{{< / highlight >}}
+
+Which will pick up any HTTP endpoints exposed by our application. Add to your app's property file (src/main/resources/application.properties):
+
+{{< highlight bash >}}
+spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER
+{{< / highlight >}}
+
+And finally, to enable Swagger on the application, we need to use the `EnableSwagger2` annotation, by
+annotating the main application class:
+
+{{< highlight java >}}
+@EnableSwagger2
+@SpringBootApplication
+public class SkeletonApplication {
+  // ...
+}
+{{< / highlight >}}
+
+## Creating the Domain
+
+Our domain will be fairly simple; `Person`s that have `Address`es. Let's start with the `Person` entity:
+
+{{< highlight java >}}
+package com.redis.om.skeleton.models;
+
+import java.util.Set;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.geo.Point;
+
+import com.redis.om.spring.annotations.Document;
+import com.redis.om.spring.annotations.Indexed;
+import com.redis.om.spring.annotations.Searchable;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(staticName = "of")
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+@Data
+@Document
+public class Person {
+  // Id Field, also indexed
+  @Id
+  @Indexed
+  private String id;
+
+  // Indexed for exact text matching
+  @Indexed @NonNull
+  private String firstName;
+
+  @Indexed @NonNull
+  private String lastName;
+
+  //Indexed for numeric matches
+  @Indexed @NonNull
+  private Integer age;
+
+  //Indexed for Full Text matches
+  @Searchable @NonNull
+  private String personalStatement;
+
+  //Indexed for Geo Filtering
+  @Indexed @NonNull
+  private Point homeLoc;
+
+  // Nest indexed object
+  @Indexed @NonNull
+  private Address address;
+
+  @Indexed @NonNull
+  private Set<String> skills;
+}
+{{< / highlight >}}
+
+The `Person` class has the following properties:
+
+* `id`: An autogenerated `String` using [ULIDs](https://github.com/ulid/spec)
+* `firstName`: A `String` representing their first or given name.
+* `lastName`: A `String` representing their last or surname.
+* `age`: An `Integer` representing their age in years.
+* `personalStatement`: A `String` representing a personal text statement containing facts or other biographical information.
+* `homeLoc`: A `org.springframework.data.geo.Point` representing the geo coordinates.
+* `address`: An entity of type `Address` representing the Person's postal address.
+* `skills`: A `Set<String>` representing a collection of Strings representing skills the Person possesses.
+
+### @Document
+
+The `Person` class (`com.redis.om.skeleton.models.Person`) is annotated with `@Document` (`com.redis.om.spring.annotations.Document`), which is marks the object as a Redis entity to be persisted as a JSON document by the appropriate type of repository.
+
+### @Indexed and @Searchable
+
+The fields `id`, `firstName`, `lastName`, `age`, `homeLoc`, `address`, and `skills` are all annotated
+with `@Indexed` (`com.redis.om.spring.annotations.Indexed`). On entities annotated with `@Document` Redis OM Spring will scan the fields and add an appropriate search index field to the schema for the entity. For example, for the `Person` class
+an index named `com.redis.om.skeleton.models.PersonIdx` will be created on application startup. In the index schema, a search field will be added for each `@Indexed` annotated property. RediSearch, the underlying search engine powering searches, supports Text (full-text searches), Tag (exact-match searches), Numeric (range queries), Geo (geographic range queries), and Vector (vector queries) fields. For `@Indexed` fields, the appropriate search field (Tag, Numeric, or Geo) is selected based on the property's data type.
+
+Fields marked as `@Searchable` (`com.redis.om.spring.annotations.Searchable`) such as `personalStatement` in `Person` are reflected as Full-Text search fields in the search index schema.
+
+### Nested Field Search Features
+
+The embedded class `Address` (`com.redis.om.skeleton.models.Address`) has several properties annotated with `@Indexed`  and `@Searchable`, which will generate search index fields in Redis. The scanning of these fields is triggered by the `@Indexed` annotation on the `address` property in the `Person` class:
+
+{{< highlight java >}}
+package com.redis.om.skeleton.models;
+
+import com.redis.om.spring.annotations.Indexed;
+import com.redis.om.spring.annotations.Searchable;
+
+import lombok.Data;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+@Data
+@RequiredArgsConstructor(staticName = "of")
+public class Address {
+
+  @NonNull
+  @Indexed
+  private String houseNumber;
+
+  @NonNull
+  @Searchable(nostem = true)
+  private String street;
+
+  @NonNull
+  @Indexed
+  private String city;
+
+  @NonNull
+  @Indexed
+  private String state;
+
+  @NonNull
+  @Indexed
+  private String postalCode;
+
+  @NonNull
+  @Indexed
+  private String country;
+}
+{{< / highlight >}}
+
+## Spring Data Repositories
+
+With the model in place now, we need to create the bridge between the models and the Redis, a Spring Data Repository. Like other Spring Data Repositories, Redis OM Spring data repository's goal is to reduce the boilerplate code required to implement data access significantly. Create a Java interface like:
+
+{{< highlight java >}}
+package com.redis.om.skeleton.models.repositories;
+
+import com.redis.om.skeleton.models.Person;
+import com.redis.om.spring.repository.RedisDocumentRepository;
+
+public interface PeopleRepository extends RedisDocumentRepository<Person,String> {
+
+}
+{{< / highlight >}}
+
+That's really all we need to get all the CRUD and Paging/Sorting functionality. The
+`RedisDocumentRepository` (`com.redis.om.spring.repository.RedisDocumentRepository`) extends `PagingAndSortingRepository` (`org.springframework.data.repository.PagingAndSortingRepository`) which extends CrudRepository to provide additional methods to retrieve entities using the pagination and sorting.
+
+### @EnableRedisDocumentRepositories
+
+Before we can fire up the application, we need to enable our Redis Document repositories. Like most
+Spring Data projects, Redis OM Spring provides an annotation to do so; the `@EnableRedisDocumentRepositories`. We annotate the main application class:
+
+{{< highlight java >}}
+@EnableRedisDocumentRepositories(basePackages = "com.redis.om.skeleton.*")
+@EnableSwagger2
+@SpringBootApplication
+public class SkeletonApplication {
+{{< / highlight >}}
+
+## CRUD with Repositories
+
+With the repositories enabled, we can use our repo; let's put in some data to see the object mapping in action. Let’s create `CommandLineRunner` that will execute on application startup:
+
+{{< highlight java >}}
+public class SkeletonApplication {
+
+ @Bean
+ CommandLineRunner loadTestData(PeopleRepository repo) {
+   return args -> {
+     repo.deleteAll();
+
+     String thorSays = “The Rabbit Is Correct, And Clearly The Smartest One Among You.”;
+
+     // Serendipity, 248 Seven Mile Beach Rd, Broken Head NSW 2481, Australia
+     Address thorsAddress = Address.of("248", "Seven Mile Beach Rd", "Broken Head", "NSW", "2481", "Australia");
+
+     Person thor = Person.of("Chris", "Hemsworth", 38, thorSays, new Point(153.616667, -28.716667), thorsAddress, Set.of("hammer", "biceps", "hair", "heart"));
+
+     repo.save(thor);
+   };
+ }
+{{< / highlight >}}
+
+In the `loadTestData` method, we will take an instance of the `PeopleRepository` (thank you, Spring, for Dependency Injection!). Inside the returned lambda, we will first call the repo’s `deleteAll` method, which will ensure that we have clean data on each application reload.
+
+We create a `Person` object using the Lombok generated builder method and then save it using the repo’s `save` method.
+
+### Keeping tabs with Redis Insight
+
+Let’s launch Redis Insight and connect to the localhost at port 6379. With a clean Redis Stack install, we can use the built-in CLI to check the keys in the system:
+
+![Redis Insight](./images/002_stack_spring.png "Redis Insight")
+
+For a small amount of data, you can use the `keys` command (for any significant amount of data, use `scan`):
+
+{{< highlight bash >}}
+keys *
+{{< / highlight >}}
+
+If you want to keep an eye on the commands issued against the server, Redis Insight provides a
+profiler. If you click the "profile" button at the bottom of the screen, it should reveal the profiler window, and there you can start the profiler by clicking on the “Start Profiler” arrow.
+
+Let's start our Spring Boot application by using the Maven command:
+
+{{< highlight bash >}}
+./mvnw spring-boot:run
+{{< / highlight >}}
+
+On Redis Insight, if the application starts correctly, you should see a barrage of commands fly by on the profiler:
+
+![Redis Insight](./images/003_stack_spring.png "Redis Insight")
+
+Now we can inspect the newly loaded data by simply refreshing the "Keys" view:
+
+![Redis Insight](./images/004_stack_spring.png "Redis Insight")
+
+You should now see two keys; one for the JSON document for “Thor” and one for the Redis Set that Spring Data Redis (and Redis OM Spring) use to maintain the list of primary keys for an entity.
+
+You can select any of the keys on the key list to reveal their contents on the details panel. For JSON documents, we get a nice tree-view:
+
+![Redis Insight](./images/005_stack_spring.png "Redis Insight")
+
+Several Redis commands were executed on application startup. Let’s break them down so that we can understand what's transpired.
+
+### Index Creation
+
+The first one is a call to [`FT.CREATE`]({{< relref "commands/ft.create/" >}}), which happens after Redis OM Spring scanned the `@Document` annotations. As you can see, since it encountered the annotation on `Person`, it creates the  `PersonIdx` index.
+
+{{< highlight bash >}}
+"FT.CREATE"
+  "com.redis.om.skeleton.models.PersonIdx" "ON" "JSON"
+  "PREFIX" "1" "com.redis.om.skeleton.models.Person:"
+"SCHEMA"
+  "$.id" "AS" "id" "TAG"
+  "$.firstName" "AS" "firstName" "TAG"
+  "$.lastName" "AS" "lastName" "TAG"
+  "$.age" "AS" "age" "NUMERIC"
+  "$.personalStatement" "AS" "personalStatement" "TEXT"
+  "$.homeLoc" "AS" "homeLoc" "GEO"
+  "$.address.houseNumber" "AS" "address_houseNumber" "TAG"
+  "$.address.street" "AS" "address_street" "TEXT" "NOSTEM"
+  "$.address.city" "AS" "address_city" "TAG"
+  "$.address.state" "AS" "address_state" "TAG"
+  "$.address.postalCode" "AS" "address_postalCode" "TAG"
+  "$.address.country" "AS" "address_country" "TAG"
+  "$.skills[*]" "AS" "skills"
+{{< / highlight >}}
+
+### Cleaning the Person Repository
+
+The next set of commands are generated by the call to `repo.deleteAll()`:
+
+{{< highlight bash >}}
+"DEL" "com.redis.om.skeleton.models.Person"
+"KEYS" "com.redis.om.skeleton.models.Person:*"
+{{< / highlight >}}
+
+The first call clears the set of Primary Keys that Spring Data Redis maintains (and therefore Redis OM Spring), the second call collects all the keys to delete them, but there are none to delete on this first load of the data.
+
+### Saving Person Entities
+
+The next repo call is `repo.save(thor)` that triggers the following sequence:
+
+{{< highlight bash >}}
+"SISMEMBER" "com.redis.om.skeleton.models.Person" "01FYANFH68J6WKX2PBPX21RD9H"
+"EXISTS" "com.redis.om.skeleton.models.Person:01FYANFH68J6WKX2PBPX21RD9H"
+"JSON.SET" "com.redis.om.skeleton.models.Person:01FYANFH68J6WKX2PBPX21RD9H" "." "{"id":"01FYANFH68J6WKX2PBPX21RD9H","firstName":"Chris","lastName":"Hemsworth","age":38,"personalStatement":"The Rabbit Is Correct, And Clearly The Smartest One Among You.","homeLoc":"153.616667,-28.716667","address":{"houseNumber":"248","street":"Seven Mile Beach Rd","city":"Broken Head","state":"NSW","postalCode":"2481","country":"Australia"},"skills":["biceps","hair","heart","hammer"]}
+"SADD" "com.redis.om.skeleton.models.Person" "01FYANFH68J6WKX2PBPX21RD9H"
+{{< / highlight >}}
+
+Let's break it down:
+
+* The first call uses the generated ULID to check if the id is in the set of primary keys (if it is, it’ll be removed)
+* The second call checks if JSON document exists (if it is, it’ll be removed)
+* The third call uses the [`JSON.SET`]({{< relref "commands/json.set/" >}}) command to save the JSON payload
+* The last call adds the primary key of the saved document to the set of primary keys
+
+Now that we’ve seen the repository in action via the `.save` method, we know that the trip from Java to Redis work. Now let’s add some more data to make the interactions more interesting:
+
+{{< highlight java >}}
+@Bean
+CommandLineRunner loadTestData(PeopleRepository repo) {
+  return args -> {
+    repo.deleteAll();
+
+    String thorSays = “The Rabbit Is Correct, And Clearly The Smartest One Among You.”;
+    String ironmanSays = “Doth mother know you weareth her drapes?”;
+    String blackWidowSays = “Hey, fellas. Either one of you know where the Smithsonian is? I’m here to pick up a fossil.”;
+    String wandaMaximoffSays = “You Guys Know I Can Move Things With My Mind, Right?”;
+    String gamoraSays = “I Am Going To Die Surrounded By The Biggest Idiots In The Galaxy.”;
+    String nickFurySays = “Sir, I’m Gonna Have To Ask You To Exit The Donut”;
+
+    // Serendipity, 248 Seven Mile Beach Rd, Broken Head NSW 2481, Australia
+    Address thorsAddress = Address.of("248", "Seven Mile Beach Rd", "Broken Head", "NSW", "2481", "Australia");
+
+    // 11 Commerce Dr, Riverhead, NY 11901
+    Address ironmansAddress = Address.of("11", "Commerce Dr", "Riverhead", "NY",  "11901", "US");
+
+    // 605 W 48th St, New York, NY 10019
+    Address blackWidowAddress = Address.of("605", "48th St", "New York", "NY", "10019", "US");
+
+    // 20 W 34th St, New York, NY 10001
+    Address wandaMaximoffsAddress = Address.of("20", "W 34th St", "New York", "NY", "10001", "US");
+
+    // 107 S Beverly Glen Blvd, Los Angeles, CA 90024
+    Address gamorasAddress = Address.of("107", "S Beverly Glen Blvd", "Los Angeles", "CA", "90024", "US");
+
+    // 11461 Sunset Blvd, Los Angeles, CA 90049
+    Address nickFuryAddress = Address.of("11461", "Sunset Blvd", "Los Angeles", "CA", "90049", "US");
+
+    Person thor = Person.of("Chris", "Hemsworth", 38, thorSays, new Point(153.616667, -28.716667), thorsAddress, Set.of("hammer", "biceps", "hair", "heart"));
+    Person ironman = Person.of("Robert", "Downey", 56, ironmanSays, new Point(40.9190747, -72.5371874), ironmansAddress, Set.of("tech", "money", "one-liners", "intelligence", "resources"));
+    Person blackWidow = Person.of("Scarlett", "Johansson", 37, blackWidowSays, new Point(40.7215259, -74.0129994), blackWidowAddress, Set.of("deception", "martial_arts"));
+    Person wandaMaximoff = Person.of("Elizabeth", "Olsen", 32, wandaMaximoffSays, new Point(40.6976701, -74.2598641), wandaMaximoffsAddress, Set.of("magic", "loyalty"));
+    Person gamora = Person.of("Zoe", "Saldana", 43, gamoraSays, new Point(-118.399968, 34.073087), gamorasAddress, Set.of("skills", "martial_arts"));
+    Person nickFury = Person.of("Samuel L.", "Jackson", 73, nickFurySays, new Point(-118.4345534, 34.082615), nickFuryAddress, Set.of("planning", "deception", "resources"));
+
+    repo.saveAll(List.of(thor, ironman, blackWidow, wandaMaximoff, gamora, nickFury));
+  };
+}
+{{< / highlight >}}
+
+We have 6 People in the database now; since we’re using the devtools in Spring, the app should have reloaded, and the database reseeded with new data. Press enter the key pattern input box in Redis Insight to refresh the view. Notice that we used the repository’s `saveAll` to save several objects in bulk.
+
+![Redis Insight](./images/006_stack_spring.png "Redis Insight")
+
+## Web Service Endpoints
+
+Before we beef up the repository with more interesting queries, let’s create a controller so that we can test our queries using the Swagger UI:
+
+{{< highlight java >}}
+package com.redis.om.skeleton.controllers;
+
+import com.redis.om.skeleton.models.Person;
+import com.redis.om.skeleton.models.repositories.PeopleRepository;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/people")
+public class PeopleControllerV1 {
+ @Autowired
+ PeopleRepository repo;
+
+ @GetMapping("all")
+ Iterable<Person> all() {
+   return repo.findAll();
+ }
+}
+{{< / highlight >}}
+
+In this controller, we inject a repository and use one of the CRUD methods, `findAll()`, to return all the `Person` documents in the database.
+
+If we navigate to http://localhost:8080/swagger-ui/ you should see the Swagger UI:
+
+![SwaggerUI](./images/007_stack_spring.png "SwaggerUI")
+
+We can see the `/all` method from our people-controller-v-1, expanding that you should see:
+
+![SwaggerUI](./images/008_stack_spring.png "SwaggerUI")
+
+And if you select “Try it out” and then “Execute,” you should see the resulting JSON array containing all People documents in the database:
+
+![SwaggerUI](./images/009_stack_spring.png "SwaggerUI")
+
+Let’s also add the ability to retrieve a Person by its id by using the repo’s findById method:
+
+{{< highlight java >}}
+@GetMapping("{id}")
+Optional<Person> byId(@PathVariable String id) {
+  return repo.findById(id);
+}
+{{< / highlight >}}
+
+Refreshing the Swagger UI, we should see the newly added endpoint. We can grab an id using the [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}) command on the Redis Insight CLI like this:
+
+{{< highlight bash >}}
+SRANDMEMBER com.redis.om.skeleton.models.Person
+{{< / highlight >}}
+
+Plugging the resulting ID in the Swagger UI, we can get the corresponding  JSON document:
+
+![SwaggerUI](./images/010_stack_spring.png "SwaggerUI")
+
+## Custom Repository Finders
+
+Now that we tested quite a bit of the CRUD functionality, let's add some custom finders to our repository. We’ll start with a finder over a numeric range, on the `age` property of `Person`:
+
+{{< highlight java >}}
+public interface PeopleRepository extends RedisDocumentRepository<Person,String> {
+ // Find people by age range
+ Iterable<Person> findByAgeBetween(int minAge, int maxAge);
+}
+{{< / highlight >}}
+
+At runtime, the repository method `findByAgeBetween` is fulfilled by the framework, so all you need to do is declare it, and Redis OM Spring will handle the querying and mapping of the results. The property or properties to be used are picked after the key phrase "findBy". The "Between" keyword is the predicate that tells the query builder what operation to use.
+
+To test it on the Swagger UI, let’s add a corresponding method to the controller:
+
+{{< highlight java >}}
+@GetMapping("age_between")
+Iterable<Person> byAgeBetween( //
+    @RequestParam("min") int min, //
+    @RequestParam("max") int max) {
+  return repo.findByAgeBetween(min, max);
+}
+{{< / highlight >}}
+
+Refreshing the UI, we can see the new endpoint. Let’s try it with some data:
+
+![SwaggerUI](./images/011_stack_spring.png "SwaggerUI")
+
+Invoke the endpoint with the value `30` for `min` and `37` for `max` we get two hits;
+“Scarlett Johansson” and “Elizabeth Olsen” are the only two people with ages between 30 and 37.
+
+![SwaggerUI](./images/012_stack_spring.png "SwaggerUI")
+
+If we look at the Redis Insight Profiler, we can see the resulting query, which is a range query on the index numeric field `age`:
+
+![Redis Insight](./images/013_stack_spring.png "Redis Insight Profiler")
+
+We can also create query methods with more than one property. For example, if we wanted to do a query by first and last names, we would declare a repository method like:
+
+{{< highlight java >}}
+// Find people by their first and last name
+Iterable<Person> findByFirstNameAndLastName(String firstName, String lastName);
+{{< / highlight >}}
+
+Let’s add a corresponding controller method:
+
+{{< highlight java >}}
+@GetMapping("name")
+Iterable<Person> byFirstNameAndLastName(@RequestParam("first") String firstName, //
+    @RequestParam("last") String lastName) {
+  return repo.findByFirstNameAndLastName(firstName, lastName);
+}
+{{< / highlight >}}
+
+Once again, we can refresh the swagger UI and test the newly created endpoint:
+
+![SwaggerUI](./images/014_stack_spring.png "SwaggerUI")
+
+Executing the request with the first name `Robert` and last name `Downey`, we get:
+
+![SwaggerUI](./images/015_stack_spring.png "SwaggerUI")
+
+And the resulting query on Redis Insight:
+
+![Redis Insight](./images/016_stack_spring.png "Redis Insight Profiler")
+
+Now let’s try a Geospatial query. The `homeLoc` property is a Geo Point, and by using the “Near” predicate in our method declaration, we can get a finder that takes a point and a radius around that point to search:
+
+{{< highlight java >}}
+// Draws a circular geofilter around a spot and returns all people in that
+// radius
+Iterable<Person> findByHomeLocNear(Point point, Distance distance);
+And the corresponding controller method:
+
+@GetMapping("homeloc")
+Iterable<Person> byHomeLoc(//
+    @RequestParam("lat") double lat, //
+    @RequestParam("lon") double lon, //
+    @RequestParam("d") double distance) {
+  return repo.findByHomeLocNear(new Point(lon, lat), new Distance(distance, Metrics.MILES));
+}
+{{< / highlight >}}
+
+Refreshing the Swagger US, we should now see the `byHomeLoc` endpoint. Let’s see which of the Avengers live within 10 miles of Suffolk Park Pub in South Wales, Australia... hmmm.
+
+![SwaggerUI](./images/017_stack_spring.png "SwaggerUI")
+
+Executing the request, we get the record for Chris Hemsworth:
+
+![SwaggerUI](./images/018_stack_spring.png "SwaggerUI")
+
+and in Redis Insight we can see the backing query:
+
+![Redis Insight](./images/019_stack_spring.png "Redis Insight Profiler")
+
+Let’s try a full-text search query against the `personalStatement` property. To do so, we prefix our query method with the word `search` as shown below:
+
+{{< highlight java >}}
+// Performs full-text search on a person’s personal Statement
+Iterable<Person> searchByPersonalStatement(String text);
+{{< / highlight >}}
+
+And the corresponding controller method:
+
+{{< highlight java >}}
+@GetMapping("statement")
+Iterable<Person> byPersonalStatement(@RequestParam("q") String q) {
+  return repo.searchByPersonalStatement(q);
+}
+{{< / highlight >}}
+
+Once again, we can try it on the Swagger UI with the text “mother”:
+
+![SwaggerUI](./images/020_stack_spring.png "SwaggerUI")
+
+Which results in a single hit, the record for Robert Downey Jr.:
+
+![SwaggerUI](./images/021_stack_spring.png "SwaggerUI")
+
+Notice that you can pass a query string like “moth*” with wildcards if needed
+
+![SwaggerUI](./images/022_stack_spring.png "SwaggerUI")
+
+### Nested object searches
+
+You’ve noticed that the `address` object in `Person` is mapped as a JSON object. If we want to search by address fields, we use an underscore to access the nested fields. For example, if we wanted to find a Person by their city, the method signature would be:
+
+{{< highlight java >}}
+// Performing a tag search on city
+Iterable<Person> findByAddress_City(String city);
+{{< / highlight >}}
+
+Let’s add the matching controller method so that we can test it:
+
+{{< highlight java >}}
+@GetMapping("city")
+Iterable<Person> byCity(@RequestParam("city") String city) {
+  return repo.findByAddress_City(city);
+}
+{{< / highlight >}}
+
+Let’s test the byCity endpoint:
+
+![SwaggerUI](./images/023_stack_spring.png "SwaggerUI")
+
+As expected, we should get two hits; Scarlett Johansson and Elizabeth Olsen, both with addresses in Nee York:
+
+![SwaggerUI](./images/024_stack_spring.png "SwaggerUI")
+
+The skills set is indexed as tag search. To find a Person with any of the skills in a provided list, we can add a repository method like:
+
+{{< highlight java >}}
+// Search Persons that have one of multiple skills (OR condition)
+Iterable<Person> findBySkills(Set<String> skills);
+{{< / highlight >}}
+
+And the corresponding controller method:
+
+{{< highlight java >}}
+@GetMapping("skills")
+Iterable<Person> byAnySkills(@RequestParam("skills") Set<String> skills) {
+  return repo.findBySkills(skills);
+}
+{{< / highlight >}}
+
+Let's test the endpoint with the value "deception":
+
+![SwaggerUI](./images/025_stack_spring.png "SwaggerUI")
+
+The search returns the records for Scarlett Johansson and Samuel L. Jackson:
+
+![SwaggerUI](./images/026_stack_spring.png "SwaggerUI")
+
+We can see the backing query using a tag search:
+
+![Redis Insight](./images/027_stack_spring.png "Redis Insight Profiler")
+
+## Fluid Searching with Entity Streams
+
+Redis OM Spring Entity Streams provides a Java 8 Streams interface to Query Redis JSON documents using Redis Stack. Entity Streams allow you to process data in a typesafe declarative way similar to SQL statements. Streams can be used to express a query as a chain of operations.
+
+Entity Streams in Redis OM Spring provide the same semantics as Java 8 streams. Streams can be made of Redis Mapped entities (`@Document`) or one or more properties of an Entity. Entity Streams progressively build the query until a terminal operation is invoked (such as `collect`). Whenever a Terminal operation is applied to a Stream, the Stream cannot accept additional operations to its pipeline, which means that the Stream is started.
+
+Let’s start with a simple example, a Spring `@Service` which includes `EntityStream` to query for instances of the mapped class `Person`:
+
+{{< highlight java >}}
+package com.redis.om.skeleton.services;
+
+import java.util.stream.Collectors;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.redis.om.skeleton.models.Person;
+import com.redis.om.skeleton.models.Person$;
+import com.redis.om.spring.search.stream.EntityStream;
+
+@Service
+public class PeopleService {
+  @Autowired
+  EntityStream entityStream;
+
+  // Find all people
+  public Iterable<Person> findAllPeople(int minAge, int maxAge) {
+    return entityStream //
+        .of(Person.class) //
+        .collect(Collectors.toList());
+  }
+
+}
+{{< / highlight >}}
+
+The `EntityStream` is injected into the `PeopleService` using `@Autowired`. We can then get a stream for `Person` objects by using `entityStream.of(Person.class)`. The stream represents the equivalent of a `SELECT * FROM Person` on a relational database. The call to `collect` will then execute the underlying query and return a collection of all `Person` objects in Redis.
+
+### Entity Meta-model
+
+You’re provided with a generated meta-model to produce more elaborate queries, a class with the same name as your model but ending with a dollar sign. In the
+example below, our entity model is `Person`; therefore, we get a meta-model named `Person$`. With the meta-model, you have access to the
+underlying search engine field operations. For example, we have an `age` property which is an integer. Therefore our meta-model has an `AGE` property with
+numeric operations we can use with the stream’s `filter` method such as `between`.
+
+{{< highlight java >}}
+// Find people by age range
+public Iterable<Person> findByAgeBetween(int minAge, int maxAge) {
+  return entityStream //
+      .of(Person.class) //
+      .filter(Person$.AGE.between(minAge, maxAge)) //
+      .sorted(Person$.AGE, SortOrder.ASC) //
+      .collect(Collectors.toList());
+}
+{{< / highlight >}}
+
+In this example, we also use the Streams `sorted` method to declare that our stream will be sorted by the `Person$.AGE` in `ASC`ending order.
+
+To "AND" property expressions we can chain multiple `.filter` statements. For example, to recreate
+the finder by first and last name we can use an Entity Stream in the following way:
+
+{{< highlight java >}}
+// Find people by their first and last name
+public Iterable<Person> findByFirstNameAndLastName(String firstName, String lastName) {
+  return entityStream //
+      .of(Person.class) //
+      .filter(Person$.FIRST_NAME.eq(firstName)) //
+      .filter(Person$.LAST_NAME.eq(lastName)) //
+      .collect(Collectors.toList());
+}
+{{< / highlight >}}
+
+In this article, we explored how Redis OM Spring provides a couple of APIs to tap into the power of Redis Stack’s document database and search features from Spring Boot application. We’ll explore other Redis Stack features via Redis OM Spring in future articles
+
+
+
+
+
+
+---
+description: RIOT quick start guide
+linkTitle: Quick Start
+title: Quick Start
+type: integration
+weight: 3
+---
+
+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:
+{{< /tip >}}
+
+```
+riot command --help
+riot command sub-command --help
+```
+
+Full documentation is available at [redis.github.io/riot](https://redis.github.io/riot/).
+---
+description: Install RIOT on macOS, Linux, Windows, and Docker
+linkTitle: Install
+title: Install
+type: integration
+weight: 2
+---
+
+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](https://github.com/redis/riot/releases), uncompress, and copy to the desired location.
+
+Full documentation is available at [redis.github.io/riot](https://redis.github.io/riot/).
+---
+description: RIOT documentation
+linkTitle: Documentation
+title: Documentation
+type: integration
+weight: 4
+---
+
+Full documentation for RIOT is available at [redis.github.io/riot](https://redis.github.io/riot/).---
+categories:
+- docs
+- integrate
+- stack
+- oss
+- rs
+- rc
+- oss
+description: Redis Input/Output Tools
+group: mig
+hidden: false
+hideListLinks: true
+linkTitle: RIOT
+summary: Redis Input/Output Tools (RIOT) is a command-line utility designed to help
+  you get data in and out of Redis.
+title: RIOT
+type: integration
+weight: 1
+---
+
+Redis Input/Output Tools (RIOT) is a command-line utility designed to help you get data in and out of Redis.
+
+It supports many different sources and targets:
+
+* [Files](https://redis.github.io/riot/#_file) (CSV, JSON, XML)
+* [Data generators](https://redis.github.io/riot/#_datagen) (Redis data structures, Faker)
+* [Relational databases](https://redis.github.io/riot/#_db)
+* [Redis itself](https://redis.github.io/riot/#_replication) (snapshot and live replication)
+
+Full documentation is available at [redis.github.io/riot](https://redis.github.io/riot/)
+---
+LinkTitle: Spring Data Redis
+Title: Spring Data Redis
+alwaysopen: false
+categories:
+- docs
+- integrate
+- stack
+- oss
+- rs
+- rc
+- oss
+- client
+description: Plug Redis into your Spring application with minimal effort
+group: framework
+summary: Spring Data Redis implements the Spring framework's cache abstraction for
+  Redis, which allows you to plug Redis into your Spring application with minimal
+  effort.
+type: integration
+weight: 8
+---
+
+Spring Data Redis implements the Spring framework's cache abstraction for Redis, which allows you to plug Redis into your Spring application with minimal effort.
+
+Spring's cache abstraction applies cache-aside to methods, reducing executions by storing and reusing results. When a method is invoked, the abstraction checks if it's been called with the same arguments before. If so, it returns the cached result. If not, it invokes the method, caches the result, and returns it. This way, costly methods are invoked less often. Further details are in the [Spring cache abstraction documentation](https://docs.spring.io/spring-framework/reference/integration/cache.html).
+
+## Get started
+
+In a nutshell, you need to perform the following steps to use Redis as your cache storage:
+
+1. [Configure the cache storage](https://docs.spring.io/spring-framework/reference/integration/cache/store-configuration.html) by using the [Redis cache manager](https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html) that is part of Spring Data.
+2. Annotate a repository with your `@CacheConfig`.
+3. Use the `@Cachable` annotation on a repository method to cache the results of that method.
+
+Here is an example:
+
+```
+@CacheConfig("books")
+public class BookRepositoryImpl implements BookRepository {
+
+    @Cacheable
+    public Book findBook(ISBN isbn) {...}
+}
+```
+
+## Further readings
+
+Please read the Spring framework's documentation to learn more about how to use the Redis cache abstraction for Spring:
+
+* [Spring cache abstraction](https://docs.spring.io/spring-framework/reference/integration/cache.html)
+* [Spring cache store configuration](https://docs.spring.io/spring-framework/reference/integration/cache/store-configuration.html)
+* [Spring Data Redis Cache](https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html)---
+LinkTitle: lettuce
+Title: Java client for Redis
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis and Java
+group: library
+stack: true
+summary: Lettuce is a Java library for Redis.
+title: Lettuce
+type: integration
+weight: 2
+---
+
+Connect your Java application to a Redis database using the Lettuce client library. 
+
+Refer to the complete [Lettuce guide]({{< relref "/develop/clients/lettuce" >}}) to install, connect, and use Lettuce.
+---
+LinkTitle: Uptrace with Redis Enterprise
+Title: Uptrace with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Uptrace to your Redis Enterprise cluster using
+  OpenTelemetry Collector.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Uptrace to your Redis Enterprise cluster using
+  OpenTelemetry Collector.
+type: integration
+weight: 7
+---
+
+Uptrace is an [open source APM tool](https://uptrace.dev/get/open-source-apm.html) that supports distributed tracing, metrics, and logs. You can use it to monitor applications and set up automatic alerts to receive notifications.
+
+Uptrace uses OpenTelemetry to collect and export telemetry data from software applications such as Redis. OpenTelemetry is an open source observability framework that aims to provide a single standard for all types of observability signals such as traces, metrics, and logs.
+
+With OpenTelemetry Collector, you can receive, process, and export telemetry data to any [OpenTelemetry backend](https://uptrace.dev/blog/opentelemetry-backend.html). You can also use Collector to scrape Prometheus metrics provided by Redis and then export those metrics to Uptrace.
+
+You can use Uptrace to:
+
+- Collect and display data metrics not available in the [admin console]({{< relref "/operate/rs/references/metrics" >}}).
+- Use prebuilt dashboard templates maintained by the Uptrace community.
+- Set up automatic alerts and receive notifications via email, Slack, Telegram, and others.
+- Monitor your app performance and logs using [OpenTelemetry tracing](https://uptrace.dev/opentelemetry/distributed-tracing.html).
+
+{{< image filename="/images/rs/uptrace-redis-nodes.png" >}}
+
+## Install Collector and Uptrace
+
+Because installing OpenTelemetry Collector and Uptrace can take some time, you can use the [docker-compose](https://github.com/uptrace/uptrace/tree/master/example/redis-enterprise) example that also comes with Redis Enterprise cluster.
+
+After you download the Docker example, you can edit the following configuration files in the `uptrace/example/redis-enterprise` directory before you start the Docker containers:
+
+- `otel-collector.yaml` - Configures `/etc/otelcol-contrib/config.yaml` in the OpenTelemetry Collector container.
+- `uptrace.yml` - Configures`/etc/uptrace/uptrace.yml` in the Uptrace container.
+
+You can also install OpenTelemetry and Uptrace from scratch using the following guides:
+
+- [Getting started with OpenTelemetry Collector](https://uptrace.dev/opentelemetry/collector.html)
+- [Getting started with Uptrace](https://uptrace.dev/get/get-started.html)
+
+After you install Uptrace, you can access the Uptrace UI at [http://localhost:14318/](http://localhost:14318/).
+
+## Scrape Prometheus metrics
+
+Redis Enterprise cluster exposes a Prometheus scraping endpoint on `http://localhost:8070/`. You can scrape that endpoint by adding the following lines to the OpenTelemetry Collector config:
+
+```yaml
+# /etc/otelcol-contrib/config.yaml
+
+prometheus_simple/cluster1:
+  collection_interval: 10s
+  endpoint: "localhost:8070" # Redis Cluster endpoint
+  metrics_path: "/"
+  tls:
+    insecure: false
+    insecure_skip_verify: true
+    min_version: "1.0"
+```
+
+Next, you can export the collected metrics to Uptrace using OpenTelemetry protocol (OTLP):
+
+```yaml
+# /etc/otelcol-contrib/config.yaml
+
+receivers:
+  otlp:
+    protocols:
+      grpc:
+      http:
+
+exporters:
+  otlp/uptrace:
+    # Uptrace is accepting metrics on this port
+    endpoint: localhost:14317
+    headers: { "uptrace-dsn": "http://project1_secret_token@localhost:14317/1" }
+    tls: { insecure: true }
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlp/uptrace]
+    metrics:
+      receivers: [otlp, prometheus_simple/cluster1]
+      processors: [batch]
+      exporters: [otlp/uptrace]
+    logs:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [otlp/uptrace]
+```
+
+Don't forget to restart the Collector and then check logs for any errors:
+
+```shell
+docker-compose logs otel-collector
+
+# or
+
+sudo journalctl -u otelcol-contrib -f
+```
+
+You can also check the full OpenTelemetry Collector config [here](https://github.com/uptrace/uptrace/blob/master/example/redis-enterprise/otel-collector.yaml).
+
+## View metrics
+
+When metrics start arriving to Uptrace, you should see a couple of dashboards in the Metrics tab. In total, Uptrace should create 3 dashboards for Redis Enterprise metrics:
+
+- "Redis: Nodes" dashboard displays a list of cluster nodes. You can select a node to view its metrics.
+
+- "Redis: Databases" displays a list of Redis databases in all cluster nodes. To find a specific database, you can use filters or sort the table by columns.
+
+- "Redis: Shards" contains a list of shards that you have in all cluster nodes. You can filter or sort shards and select a shard for more details.
+
+## Monitor metrics
+
+To start monitoring metrics, you need to create metrics monitors using Uptrace UI:
+
+- Open "Alerts" -> "Monitors".
+- Click "Create monitor" -> "Create metrics monitor".
+
+For example, the following monitor uses the `group by node` expression to create an alert whenever an individual Redis shard is down:
+
+```yaml
+monitors:
+  - name: Redis shard is down
+    metrics:
+      - redis_up as $redis_up
+    query:
+      - group by cluster # monitor each cluster,
+      - group by bdb # each database,
+      - group by node # and each shard
+      - $redis_up
+    min_allowed_value: 1
+    # shard should be down for 5 minutes to trigger an alert
+    for_duration: 5m
+```
+
+You can also create queries with more complex expressions.
+
+For example, the following monitors create an alert when the keyspace hit rate is lower than 75% or memory fragmentation is too high:
+
+```yaml
+monitors:
+  - name: Redis read hit rate < 75%
+    metrics:
+      - redis_keyspace_read_hits as $hits
+      - redis_keyspace_read_misses as $misses
+    query:
+      - group by cluster
+      - group by bdb
+      - group by node
+      - $hits / ($hits + $misses) as hit_rate
+    min_allowed_value: 0.75
+    for_duration: 5m
+
+  - name: Memory fragmentation is too high
+    metrics:
+      - redis_used_memory as $mem_used
+      - redis_mem_fragmentation_ratio as $fragmentation
+    query:
+      - group by cluster
+      - group by bdb
+      - group by node
+      - where $mem_used > 32mb
+      - $fragmentation
+    max_allowed_value: 3
+    for_duration: 5m
+```
+
+You can learn more about the query language [here](https://uptrace.dev/get/querying-metrics.html).
+---
+LinkTitle: Confluent with Redis Cloud
+Title: Confluent with Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: Describes how to integrate Redis Cloud into Confluent Cloud.
+group: di
+summary: The Redis Sink connector for Confluent Cloud allows you to send data from
+  Confluent Cloud to your Redis Cloud database.
+type: integration
+weight: 8
+---
+
+You can send data from [Confluent Cloud](https://confluent.cloud/) to your Redis Cloud database using the [Redis Sink connector for Confluent Cloud](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html).
+
+## Prerequisites
+
+Before you add the Redis Sink Confluent connector to your Confluent Cloud cluster:
+
+1. [Create a database]({{< relref "/operate/rc/databases/create-database" >}}) in the same region as your Confluent Cloud cluster.
+
+1. If you decide to [enable Transport Layer Security (TLS)]({{< relref "/operate/rc/security/database-security/tls-ssl" >}}) for your Redis database, [download the server certificate]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) from the Redis Cloud console and [encode it](#encode-server-certificate) to be used with Confluent Cloud.
+
+1. Ensure you meet the prerequisites in the [Redis Sink connector documentation](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#quick-start) to set up your Redis Sink with Confluent Cloud. 
+
+### Encode server certificate
+
+If you decide to enable Transport Layer Security (TLS) for your database, you will need to encode the [server certificate]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) (`redis_ca.pem`) for use as the Confluent Cloud Truststore file. To do this:
+
+1. Use a base64 utility to encode `redis_ca.pem` into base64 in a new file. For example, using the [`base64` command-line utility](https://linux.die.net/man/1/base64):
+
+    ```sh
+    $ base64 -i redis_ca.pem -o <truststore_file_name>
+    ```
+
+1. Using a text editor, add the following text to the beginning of the truststore file:
+
+    ```text
+    data:text/plain;base64
+    ```
+
+1. Save and close the truststore file.
+
+## Connect the Redis Sink connector to Redis Cloud
+
+To add the Redis Sink connector to your Confluent Cloud environment from the Redis Cloud console: 
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select **Account Settings** and then select the **Integrations** tab.
+
+1. Select the **Configure** button in the **Confluent** tile. 
+
+    {{<image filename="images/rc/account-settings-integrations-confluent.png" alt="The Confluent integration tile." >}}
+
+1. This will take you to [New Sink Connector](https://confluent.cloud/go/new-sink-connector/RedisSink) on Confluent Cloud. If you have more than one Confluent Cloud environment or Cluster, select your environment and cluster from the lists and select **Continue**.
+
+    {{<image filename="images/rc/confluent-create-connector.png" alt="Select your environment and cluster from the Create a Connector selector." >}}
+
+1. From there, follow the steps to [Enter the connector details](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#step-4-enter-the-connector-details) on the Confluent documentation.
+
+    When you get to the **Authentication** step, fill in the fields with the following information:
+
+    - **Redis hostname**: The Public endpoint of your database, without the port number. This can be found in the [Redis Cloud console](https://cloud.redis.io/) from the database list or from the **General** section of the **Configuration** tab for the source database.
+    - **Redis port number**: The database's port. This is the number at the end of your database's Public endpoint.
+    - **Redis database index**: Set this to 0 for a Redis Cloud database.
+    - **Redis server password**: Enter the database password. If you have not set your own database user and password, use the [default user password]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}), which appears in the **Security** section of the **Configuration** tab of the database details screen.
+    - **SSL mode**: Set depending on what type of [TLS authentication]({{< relref "/operate/rc/security/database-security/tls-ssl" >}}) is set for your database.
+        - If TLS authentication is turned off, select **disabled**.
+        - If TLS authentication is turned on, select **server**. 
+    - **Trustore file**: If the **SSL mode** is set to **server**, upload the truststore file created when you [encoded the server certificate](#encode-server-certificate).
+    - **Redis Server mode**: If [OSS Cluster API]({{< relref "/operate/rc/databases/configuration/clustering#oss-cluster-api" >}}) is enabled, select **Cluster**. Otherwise, select **Standalone**.
+        
+    Select **Continue** once you have entered the database information. Enter the rest of the [connector details](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#step-4-enter-the-connector-details) from the **Configuration** step.
+
+1. [Connect to your database]({{< relref "/operate/rc/rc-quickstart#connect-to-a-database" >}}) to verify that data is being stored.
+
+
+
+---
+LinkTitle: Get started
+Title: Get started with Pulumi
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: Shows how to install the Redis Cloud Pulumi provider and create a subscription.
+group: provisioning
+headerRange: '[1-3]'
+summary: With the Redis Cloud Resource Provider you can provision Redis Cloud resources
+  by using the programming language of your choice.
+toc: 'true'
+type: integration
+weight: $weight
+---
+
+Here, you'll learn how to use the [Redis Cloud Pulumi provider]({{< relref "/integrate/pulumi-provider-for-redis-cloud/" >}}) to create a Redis Cloud Pro subscription and a database using Python.
+
+## Prerequisites
+
+1. [Install Pulumi](https://www.pulumi.com/docs/install/) and [create a Pulumi account](https://app.pulumi.com/signin) if you do not have one already.
+
+1. [Create a Redis Cloud account]({{< relref "/operate/rc/rc-quickstart#create-an-account" >}}) if you do not have one already.
+
+1. [Enable the Redis Cloud API]({{< relref "/operate/rc/api/get-started/enable-the-api" >}}).
+
+1. Get your Redis Cloud [API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}}).
+
+## Install the Pulumi provider files
+
+1.  In your Python project, create an empty folder. From this folder, run `pulumi new rediscloud-python`.
+
+1. Log into Pulumi using your [Pulumi access token](https://app.pulumi.com/account/tokens) if prompted.
+
+1.  Enter a project name, description, and stack name.
+
+1.  Enter your Redis Cloud access and secret keys.
+
+1.  Enter the credit card type (Visa, Mastercard) on file with your Redis Cloud account.
+
+1.  Enter the last four numbers of the card on file with your Redis Cloud account.
+
+Once these steps are completed, the dependencies needed for the project will be installed and a Python virtual environment will be created.
+
+## Deploy resources with Pulumi
+
+The Pulumi Python project includes three main files:
+
+- `pulumi.yaml` : A metadata file which is used to help configure the Python runtime environment.
+
+- `pulumi.YOUR_PROJECT_NAME.yaml`: Contains the information related to the Cloud API access and secret key, credit card type and last 4 digits.
+
+- `__main__.py`: A Pulumi template file that creates a Redis Cloud Pro subscription. Use this template file as a starting point to create the subscription with a cloud provider and define specifications for the database (this includes memory, throughput, Redis advanced capabilities, and other information).
+
+To deploy the resources described in `__main__.py`, run `pulumi up`. This will take some time. You will be able to see your subscription being created through the [Redis Cloud console](https://cloud.redis.io/).
+
+If you want to remove these resources, run `pulumi down`.
+
+## More info
+
+- [Redis Cloud Pulumi registry](https://www.pulumi.com/registry/packages/rediscloud/)
+- [Pulumi documentation](https://www.pulumi.com/docs/)
+---
+LinkTitle: Pulumi provider for Redis Cloud
+Title: Pulumi provider for Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: Explains how to use Pulumi to provision Redis Cloud infrastructure
+group: provisioning
+summary: With the Redis Cloud Resource Provider you can provision Redis Cloud resources
+  by using the programming language of your choice.
+type: integration
+weight: 4
+hideListLinks: true
+---
+
+[Pulumi](https://www.pulumi.com/) is an automation tool that allows you to easily provision infrastructure as code. Pulumi allows developers to write infrastructure code using programming languages rather than using domain-specific languages.
+
+With the [Redis Cloud Resource Provider](https://www.pulumi.com/registry/packages/rediscloud/), you can create Redis Cloud resources in a programming language. The Pulumi Redis Cloud Provider supports the following programming languages:
+
+* TypeScript
+* Python
+* C#
+* Java
+* Go
+* YAML
+
+The Redis Cloud Pulumi provider is based on the [Redis Cloud Terraform provider]({{< relref "/integrate/terraform-provider-for-redis-cloud/" >}}).
+
+{{<note>}}
+The Redis Cloud Pulumi Redis Cloud provider supports Redis Cloud Pro. It does not support Redis Cloud Essentials.
+{{</note>}}
+
+See [Get started with Pulumi]({{< relref "/integrate/pulumi-provider-for-redis-cloud/get-started" >}}) for an example of how to use the Pulumi provider with Python.
+
+## Resources and functions
+
+Pulumi resources represent the fundamental units that make up cloud infrastructure. A provider can make functions available in its SDK and resource types. These functions are often used to acquire information that is not part of a resource.
+
+The Redis Cloud Pulumi provider allows for the following resources:
+
+* [`Subscription`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/subscription/): The basic building block of a Redis Cloud subscription.
+* [`SubscriptionDatabase`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/subscriptiondatabase/): Represents a Redis database which belongs to a specific Redis Cloud subscription.
+* [`SubscriptionPeering`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/subscriptionpeering/): A VPC peering connection (AWS or GCP) to a specific Redis Cloud subscription.
+* [`CloudAccount`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/cloudaccount/): Represents an AWS account in which you want to deploy Redis Cloud infrastructure components.
+
+    {{<note>}}
+The "bring your own AWS account" option for Redis Cloud has been deprecated. The `CloudAccount` resource is only available for legacy Redis Cloud integrations.
+    {{</note>}}
+
+* [`ActiveActiveSubscription`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/activeactivesubscription/): The basic building block of an active-active Redis Cloud subscription.
+* [`ActiveActiveSubscriptionDatabase`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/activeactivesubscriptiondatabase/): Represents a Redis database which belongs to a specific Redis Cloud active-active subscription.
+* [`ActiveActiveSubscriptionRegions`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/activeactivesubscriptionregions/): The different regions where the active-active subscription will be deployed.
+* [`ActiveActiveSubscriptionPeering`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/activeactivesubscriptionpeering/): A VPC peering connection (AWS or GCP) to a specific Redis Cloud active-active subscription.
+* [`AclRule`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/aclrule/), [`AclRole`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/aclrole/), and [`AclUser`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/acluser/): Rules, Roles, and Users for [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}).
+
+It also allows for the following functions:
+
+* [`GetCloudAccount`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getcloudaccount/): Get the information related to the AWS account.
+
+    {{<note>}}
+The "bring your own AWS account" option for Redis Cloud has been deprecated. The `CloudAccount` resource is only available for legacy Redis Cloud integrations.
+    {{</note>}}
+
+* [`GetDataPersistence`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getdatapersistence/): Get the type of database persistence.
+* [`GetDatabase`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getdatabase/): Get the information related to a specific database.
+* [`GetDatabaseModules`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getdatabasemodules/): Get the capabilities for a specific database.
+* [`GetPaymentMethod`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getpaymentmethod/): Get the payment method related to the Redis Cloud account.
+* [`GetRegions`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getregions/): Get the regions related to an active-active subscription
+* [`GetSubscription`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getsubscription/): Get the information related to a specific subscription.
+* [`GetSubscriptionPeerings`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getsubscriptionpeerings/): Get the VPC peerings (AWS or GCP) related to a specific subscription.
+* [`GetAclRule`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getaclrule/), [`GetAclRole`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getaclrole/), and [`GetAclUser`](https://www.pulumi.com/registry/packages/rediscloud/api-docs/getacluser/): Get the Rules, Roles, and Users for [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}).
+
+## More info
+
+- [Get started with Pulumi]({{< relref "/integrate/pulumi-provider-for-redis-cloud/get-started" >}})
+- [Redis Cloud Pulumi registry](https://www.pulumi.com/registry/packages/rediscloud/)
+- [Pulumi documentation](https://www.pulumi.com/docs/)
+---
+LinkTitle: RedisOM for Python
+Title: RedisOM for Python
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis Stack and Python
+group: library
+stack: true
+summary: Redis OM for Python is an object-mapping library for Redis.
+title: Redis OM Python
+type: integration
+weight: 9
+---
+
+[Redis OM Python](https://github.com/redis/redis-om-python) is a Redis client that provides high-level abstractions for managing document data in Redis. This tutorial shows you how to get up and running with Redis OM Python, Redis Stack, and the [Flask](https://flask.palletsprojects.com/) micro-framework.
+
+We'd love to see what you build with Redis Stack and Redis OM.  [Join the Redis community on Discord](https://discord.gg/redis) to chat with us about all things Redis OM and Redis Stack.  Read more about Redis OM Python [our announcement blog post](https://redis.com/blog/introducing-redis-om-for-python/).
+
+## Overview
+
+This application, an API built with Flask and a simple domain model, demonstrates common data manipulation patterns using Redis OM. 
+
+Our entity is a Person, with the following JSON representation:
+
+```json
+{
+  "first_name": "A string, the person's first or given name",
+  "last_name": "A string, the person's last or surname",
+  "age": 36,
+  "address": {
+    "street_number": 56,
+    "unit": "A string, optional unit number e.g. B or 1",
+    "street_name": "A string, name of the street they live on",
+    "city": "A string, name of the city they live in",
+    "state": "A string, state, province or county that they live in",
+    "postal_code": "A string, their zip or postal code",
+    "country": "A string, country that they live in."
+  },
+  "personal_statement": "A string, free text personal statement",
+  "skills": [
+    "A string: a skill the person has",
+    "A string: another still that the person has"
+  ]
+}
+```
+
+We'll let Redis OM handle generation of unique IDs, which it does using [ULIDs](https://github.com/ulid/spec).  Redis OM will also handle creation of unique Redis key names for us, as well as saving and retrieving entities from JSON documents stored in a Redis Stack database.
+
+## Getting Started
+
+### Requirements
+
+To run this application you'll need:
+
+* [git](https://git-scm.com/download) - to clone the repo to your machine. 
+* [Python 3.9 or higher](https://www.python.org/downloads/).
+* A [Redis Stack](https://redis.io) database, or Redis with the [Search and Query]({{< relref "/develop/interact/search-and-query/" >}}) and [JSON]({{< relref "/develop/data-types/json/" >}}) features installed. We've provided a `docker-compose.yml` for this. You can also [sign up for a free 30Mb database with Redis Cloud](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users) - be sure to check the Redis Stack option when creating your cloud database.
+* [curl](https://curl.se/), or [Postman](https://www.postman.com/) - to send HTTP requests to the application.  We'll provide examples using curl in this document.
+* Optional: [Redis Insight](https://redis.com/redis-enterprise/redis-insight/), a free data visualization and database management tool for Redis.  When downloading Redis Insight, be sure to select version 2.x or use the version that comes with Redis Stack.
+
+### Get the Source Code
+
+Clone the repository from GitHub:
+
+```bash
+$ git clone https://github.com/redis-developer/redis-om-python-flask-skeleton-app.git
+$ cd redis-om-python-flask-skeleton-app
+```
+
+### Start a Redis Stack Database, or Configure your Redis Cloud Credentials
+
+Next, we'll get a Redis Stack database up and running.  If you're using Docker:
+
+```bash
+$ docker-compose up -d
+Creating network "redis-om-python-flask-skeleton-app_default" with the default driver
+Creating redis_om_python_flask_starter ... done 
+```
+
+If you're using Redis Cloud, you'll need the hostname, port number, and password for your database.  Use these to set the `REDIS_OM_URL` environment variable like this:
+
+```bash
+$ export REDIS_OM_URL=redis://default:<password>@<host>:<port>
+```
+
+(This step is not required when working with Docker as the Docker container runs Redis on `localhost` port `6379` with no password, which is the default connection that Redis OM uses.)
+
+For example if your Redis Cloud database is at port `9139` on host `enterprise.redis.com` and your password is `5uper53cret` then you'd set `REDIS_OM_URL` as follows:
+
+```bash
+$ export REDIS_OM_URL=redis://default:5uper53cret@enterprise.redis.com:9139
+```
+
+### Create a Python Virtual Environment and Install the Dependencies
+
+Create a Python virtual environment, and install the project dependencies which are [Flask](https://pypi.org/project/Flask/), [Requests](https://pypi.org/project/requests/) (used only in the data loader script) and [Redis OM](https://pypi.org/project/redis-om/):
+
+```bash
+$ python3 -m venv venv
+$ . ./venv/bin/activate
+$ pip install -r requirements.txt
+```
+
+### Start the Flask Application
+
+Let's start the Flask application in development mode, so that Flask will restart the server for you each time you save code changes in `app.py`:
+
+```bash
+$ export FLASK_ENV=development
+$ flask run
+```
+
+If all goes well, you should see output similar to this:
+
+```bash
+$ flask run
+ * Environment: development
+ * Debug mode: on
+ * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
+ * Restarting with stat
+ * Debugger is active!
+ * Debugger PIN: XXX-XXX-XXX
+```
+
+You're now up and running, and ready to perform CRUD operations on data with Redis, Search and Query, JSON and Redis OM for Python! To make sure the server's running, point your browser at `http://127.0.0.1:5000/`, where you can expect to see the application's basic home page:
+
+![screenshot](./images/python_server_running.png)
+
+### Load the Sample Data
+
+We've provided a small amount of sample data (it's in `data/people.json`.  The Python script `dataloader.py` loads each person into Redis by posting the data to the application's create a new person endpoint.  Run it like this:
+
+```bash
+$ python dataloader.py
+Created person Robert McDonald with ID 01FX8RMR7NRS45PBT3XP9KNAZH
+Created person Kareem Khan with ID 01FX8RMR7T60ANQTS4P9NKPKX8
+Created person Fernando Ortega with ID 01FX8RMR7YB283BPZ88HAG066P
+Created person Noor Vasan with ID 01FX8RMR82D091TC37B45RCWY3
+Created person Dan Harris with ID 01FX8RMR8545RWW4DYCE5MSZA1
+```
+
+Make sure to take a copy of the output of the data loader, as your IDs will differ from those used in the tutorial.  To follow along, substitute your IDs for the ones shown above.  e.g. whenever we are working with Kareem Khan, change `01FX8RMR7T60ANQTS4P9NKPKX8` for the ID that your data loader assigned to Kareem in your Redis database.
+
+### Problems?
+
+If the Flask server fails to start, take a look at its output.  If you see log entries similar to this:
+
+```py
+raise ConnectionError(self._error_message(e))
+redis.exceptions.ConnectionError: Error 61 connecting to localhost:6379. Connection refused.
+```
+
+then you need to start the Redis Docker container if using Docker, or set the `REDIS_OM_URL` environment variable if using Redis Cloud.
+
+If you've set the `REDIS_OM_URL` environment variable, and the code errors with something like this on startup:
+
+```py
+raise ConnectionError(self._error_message(e))
+redis.exceptions.ConnectionError: Error 8 connecting to enterprise.redis.com:9139. nodename nor servname provided, or not known.
+```
+
+then you'll need to check that you used the correct hostname, port, password and format when setting `REDIS_OM_URL`.
+
+If the data loader fails to post the sample data into the application, make sure that the Flask application is running **before** running the data loader.
+
+## Create, Read, Update and Delete Data
+
+Let's create and manipulate some instances of our data model in Redis.  Here we'll look at how to call the Flask API with curl (you could also use Postman), how the code works, and how the data's stored in Redis.
+
+### Building a Person Model with Redis OM
+
+Redis OM allows us to model entities using Python classes, and the [Pydantic](https://pypi.org/project/pydantic/) framework.  Our person model is contained in the file `person.py`.  Here's some notes about how it works:
+
+* We declare a class `Person` which extends a Redis OM class `JsonModel`.  This tells Redis OM that we want to store these entities in Redis as JSON documents.
+* We then declare each field in our model, specifying the data type and whether or not we want to index on that field.  For example, here's the `age` field, which we've declared as a positive integer that we want to index on:
+
+```py
+age: PositiveInt = Field(index=True)
+```
+
+* The `skills` field is a list of strings, declared thus:
+
+```py
+skills: List[str] = Field(index=True)
+```
+
+* For the `personal_statement` field, we don't want to index on the field's value, as it's a free text sentence rather than a single word or digit. For this, we'll tell Redis OM that we want to be able to perform full text searches on the values:
+
+```py
+personal_statement: str = Field(index=True, full_text_search=True)
+```
+
+* `address` works differently from the other fields.  Note that in our JSON representation of the model, address is an object rather than a string or numerical field.  With Redis OM, this is modeled as a second class, which extends the Redis OM `EmbeddedJsonModel` class:
+
+```py
+class Address(EmbeddedJsonModel):
+    # field definitions...
+```
+
+* Fields in an `EmbeddedJsonModel` are defined in the same way, so our class contains a field definition for each data item in the address.
+
+* Not every field in our JSON is present in every address, Redis OM allows us to declare a field as optional so long as we don't index it:
+
+```py
+unit: Optional[str] = Field(index=False)
+```
+
+* We can also set a default value for a field... let's say country should be "United Kingdom" unless otherwise specified:
+
+```py
+country: str = Field(index=True, default="United Kingdom")
+```
+
+* Finally, to add the embedded address object to our Person model, we declare a field of type `Address` in the Person class:
+
+```py
+address: Address
+```
+
+### Adding New People
+
+The function `create_person` in `app.py` handles the creation of a new person in Redis.  It expects a JSON object that adheres to our Person model's schema.  The code to then create a new Person object with that data and save it in Redis is simple:
+
+```py
+  new_person = Person(**request.json)
+  new_person.save()
+  return new_person.pk
+```
+
+When a new Person instance is created, Redis OM assigns it a unique ULID primary key, which we can access as `.pk`.  We return that to the caller, so that they know the ID of the object they just created.
+
+Persisting the object to Redis is then simply a matter of calling `.save()` on it.
+
+Try it out... with the server running, add a new person using curl:
+
+```bash
+curl --location --request POST 'http://127.0.0.1:5000/person/new' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+    "first_name": "Joanne",
+    "last_name": "Peel",
+    "age": 36,
+    "personal_statement": "Music is my life, I love gigging and playing with my band.",
+    "address": {
+      "street_number": 56,
+      "unit": "4A",
+      "street_name": "The Rushes",
+      "city": "Birmingham",
+      "state": "West Midlands",
+      "postal_code": "B91 6HG",
+      "country": "United Kingdom"
+    },
+    "skills": [
+      "synths",
+      "vocals",
+      "guitar"
+    ]
+}'
+```
+
+Running the above curl command will return the unique ULID ID assigned to the newly created person. For example `01FX8SSSDN7PT9T3N0JZZA758G`.
+
+### Examining the data in Redis
+
+Let's take a look at what we just saved in Redis.  Using Redis Insight or redis-cli, connect to the database and look at the value stored at key `:person.Person:01FX8SSSDN7PT9T3N0JZZA758G`.  This is stored as a JSON document in Redis, so if using redis-cli you'll need the following command:
+
+```bash
+$ redis-cli
+127.0.0.1:6379> json.get :person.Person:01FX8SSSDN7PT9T3N0JZZA758G
+```
+
+If you're using Redis Insight, the browser will render the key value for you when you click on the key name:
+
+![Data in Redis Insight](./images/python_insight_explore_person.png)
+
+When storing data as JSON in Redis, we can update and retrieve the whole document, or just parts of it.  For example, to retrieve only the person's address and first skill, use the following command (Redis Insight users should use the built in redis-cli for this):
+
+```bash
+$ redis-cli
+127.0.0.1:6379> json.get :person.Person:01FX8SSSDN7PT9T3N0JZZA758G $.address $.skills[0]
+"{\"$.skills[0]\":[\"synths\"],\"$.address\":[{\"pk\":\"01FX8SSSDNRDSRB3HMVH00NQTT\",\"street_number\":56,\"unit\":\"4A\",\"street_name\":\"The Rushes\",\"city\":\"Birmingham\",\"state\":\"West Midlands\",\"postal_code\":\"B91 6HG\",\"country\":\"United Kingdom\"}]}"
+```
+
+For more information on the JSON Path syntax used to query JSON documents in Redis, see the [documentation]({{<relref "/develop/data-types/json/path#jsonpath-syntax">}}).
+
+### Find a Person by ID
+
+If we know a person's ID, we can retrieve their data.  The function `find_by_id` in `app.py` receives an ID as its parameter, and asks Redis OM to retrieve and populate a Person object using the ID and the Person `.get` class method:
+
+```py
+  try:
+      person = Person.get(id)
+      return person.dict()
+  except NotFoundError:
+      return {}
+```
+
+The `.dict()` method converts our Person object to a Python dictionary that Flask then returns to the caller.
+
+Note that if there is no Person with the supplied ID in Redis, `get` will throw a `NotFoundError`.
+
+Try this out with curl, substituting `01FX8SSSDN7PT9T3N0JZZA758G` for the ID of a person that you just created in your database:
+
+```bash
+curl --location --request GET 'http://localhost:5000/person/byid/01FX8SSSDN7PT9T3N0JZZA758G'
+```
+
+The server responds with a JSON object containing the user's data:
+
+```json
+{
+  "address": {
+    "city": "Birmingham",
+    "country": "United Kingdom",
+    "pk": "01FX8SSSDNRDSRB3HMVH00NQTT",
+    "postal_code": "B91 6HG",
+    "state": "West Midlands",
+    "street_name": "The Rushes",
+    "street_number": 56,
+    "unit": null
+  },
+  "age": 36,
+  "first_name": "Joanne",
+  "last_name": "Peel",
+  "personal_statement": "Music is my life, I love gigging and playing with my band.",
+  "pk": "01FX8SSSDN7PT9T3N0JZZA758G",
+  "skills": [
+    "synths",
+    "vocals",
+    "guitar"
+  ]
+}
+```
+
+### Find People with Matching First and Last Name
+
+Let's find all the people who have a given first and last name...  This is handled by the function `find_by_name` in `app.py`.
+
+Here, we're using Person's `find` class method that's provided by Redis OM.  We pass it a search query, specifying that we want to find people whose `first_name` field contains the value of the `first_name` parameter passed to `find_by_name` AND whose `last_name` field contains the value of the `last_name` parameter:
+
+```py
+  people = Person.find(
+      (Person.first_name == first_name) &
+      (Person.last_name == last_name)
+  ).all()
+```
+
+`.all()` tells Redis OM that we want to retrieve all matching people.
+
+Try this out with curl as follows:
+
+```bash
+curl --location --request GET 'http://127.0.0.1:5000/people/byname/Kareem/Khan'
+```
+
+**Note:** First and last name are case sensitive.
+
+The server responds with an object containing `results`, an array of matches:
+
+```json
+{
+  "results": [
+    {
+      "address": {
+        "city": "Sheffield",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR7THMGA84RH8ZRQRRP9", 
+        "postal_code": "S1 5RE",
+        "state": "South Yorkshire",
+        "street_name": "The Beltway",
+        "street_number": 1,
+        "unit": "A"
+      },
+      "age": 27,
+      "first_name": "Kareem",
+      "last_name": "Khan",
+      "personal_statement":"I'm Kareem, a multi-instrumentalist and singer looking to join a new rock band.",
+      "pk":"01FX8RMR7T60ANQTS4P9NKPKX8",
+      "skills": [
+        "drums",
+        "guitar",
+        "synths"
+      ]
+    }
+  ]
+}
+```
+
+### Find People within a Given Age Range
+
+It's useful to be able to find people that fall into a given age range... the function `find_in_age_range` in `app.py` handles this as follows...
+
+We'll again use Person's `find` class method, this time passing it a minimum and maximum age, specifying that we want results where the `age` field is between those values only:
+
+```py
+  people = Person.find(
+      (Person.age >= min_age) &
+      (Person.age <= max_age)
+  ).sort_by("age").all()
+```
+
+Note that we can also use `.sort_by` to specify which field we want our results sorted by.
+
+Let's find everyone between 30 and 47 years old, sorted by age:
+
+```bash
+curl --location --request GET 'http://127.0.0.1:5000/people/byage/30/47'
+```
+
+This returns a `results` object containing an array of matches:
+
+```json
+{
+  "results": [
+    {
+      "address": {
+        "city": "Sheffield",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR7NW221STN6NVRDPEDT",
+        "postal_code": "S12 2MX",
+        "state": "South Yorkshire",
+        "street_name": "Main Street",
+        "street_number": 9,
+        "unit": null
+      },
+      "age": 35,
+      "first_name": "Robert",
+      "last_name": "McDonald",
+      "personal_statement": "My name is Robert, I love meeting new people and enjoy music, coding and walking my dog.",
+      "pk": "01FX8RMR7NRS45PBT3XP9KNAZH",
+      "skills": [
+        "guitar",
+        "piano",
+        "trombone"
+      ]
+    },
+    {
+      "address": {
+        "city": "Birmingham",
+        "country": "United Kingdom",
+        "pk": "01FX8SSSDNRDSRB3HMVH00NQTT",
+        "postal_code": "B91 6HG",
+        "state": "West Midlands",
+        "street_name": "The Rushes",
+        "street_number": 56,
+        "unit": null
+      },
+      "age": 36,
+      "first_name": "Joanne",
+      "last_name": "Peel",
+      "personal_statement": "Music is my life, I love gigging and playing with my band.",
+      "pk": "01FX8SSSDN7PT9T3N0JZZA758G",
+      "skills": [
+        "synths",
+        "vocals",
+        "guitar"
+      ]
+    },
+    {
+      "address": {
+        "city": "Nottingham",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR82DDJ90CW8D1GM68YZ",
+        "postal_code": "NG1 1AA",
+        "state": "Nottinghamshire",
+        "street_name": "Broadway",
+        "street_number": 12,
+        "unit": "A-1"
+      },
+      "age": 37,
+      "first_name": "Noor",
+      "last_name": "Vasan",
+      "personal_statement": "I sing and play the guitar, I enjoy touring and meeting new people on the road.",
+      "pk": "01FX8RMR82D091TC37B45RCWY3",
+      "skills": [
+        "vocals",
+        "guitar"
+      ]
+    },
+    {
+      "address": {
+        "city": "San Diego",
+        "country": "United States",
+        "pk": "01FX8RMR7YCDAVSWBMWCH2B07G",
+        "postal_code": "92102",
+        "state": "California",
+        "street_name": "C Street",
+        "street_number": 1299,
+        "unit": null
+      },
+      "age": 43,
+      "first_name": "Fernando",
+      "last_name": "Ortega",
+      "personal_statement": "I'm in a really cool band that plays a lot of cover songs.  I'm the drummer!",
+      "pk": "01FX8RMR7YB283BPZ88HAG066P",
+      "skills": [
+        "clarinet",
+        "oboe",
+        "drums"
+      ]
+    }
+  ]
+}
+```
+
+### Find People in a Given City with a Specific Skill
+
+Now, we'll try a slightly different sort of query.  We want to find all of the people that live in a given city AND who also have a certain skill.  This requires a search over both the `city` field which is a string, and the `skills` field, which is an array of strings.
+
+Essentially we want to say "Find me all the people whose city is `city` AND whose skills array CONTAINS `desired_skill`", where `city` and `desired_skill` are the parameters to the `find_matching_skill` function in `app.py`.  Here's the code for that:
+
+```py
+  people = Person.find(
+      (Person.skills << desired_skill) &
+      (Person.address.city == city)
+  ).all()
+```
+
+The `<<` operator here is used to indicate "in" or "contains".
+
+Let's find all the guitar players in Sheffield:
+
+```bash
+curl --location --request GET 'http://127.0.0.1:5000/people/byskill/guitar/Sheffield'
+```
+
+**Note:** `Sheffield` is case sensitive.
+
+The server returns a `results` array containing matching people:
+
+```json
+{
+  "results": [
+    {
+      "address": {
+        "city": "Sheffield",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR7THMGA84RH8ZRQRRP9",
+        "postal_code": "S1 5RE",
+        "state": "South Yorkshire",
+        "street_name": "The Beltway",
+        "street_number": 1,
+        "unit": "A"
+      },
+      "age": 28,
+      "first_name": "Kareem",
+      "last_name": "Khan",
+      "personal_statement": "I'm Kareem, a multi-instrumentalist and singer looking to join a new rock band.",
+      "pk": "01FX8RMR7T60ANQTS4P9NKPKX8",
+      "skills": [
+        "drums",
+        "guitar",
+        "synths"
+      ]
+    },
+    {
+      "address": {
+        "city": "Sheffield",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR7NW221STN6NVRDPEDT",
+        "postal_code": "S12 2MX",
+        "state": "South Yorkshire",
+        "street_name": "Main Street",
+        "street_number": 9,
+        "unit": null
+      },
+      "age": 35,
+      "first_name": "Robert",
+      "last_name": "McDonald",
+      "personal_statement": "My name is Robert, I love meeting new people and enjoy music, coding and walking my dog.",
+      "pk": "01FX8RMR7NRS45PBT3XP9KNAZH",
+      "skills": [
+        "guitar",
+        "piano",
+        "trombone"
+      ]
+    }
+  ]
+}
+```
+
+### Find People using Full Text Search on their Personal Statements
+
+Each person has a `personal_statement` field, which is a free text string containing a couple of sentences about them.  We chose to index this in a way that makes it full text searchable, so let's see how to use this now.  The code for this is in the function `find_matching_statements` in `app.py`.
+
+To search for people who have the value of the parameter `search_term` in their `personal_statement` field, we use the `%` operator:
+
+```py
+  Person.find(Person.personal_statement % search_term).all()
+```
+
+Let's find everyone who talks about "play" in their personal statement.
+
+```bash
+curl --location --request GET 'http://127.0.0.1:5000/people/bystatement/play'
+```
+
+The server responds with a `results` array of matching people:
+
+```json
+{
+  "results": [
+    { 
+      "address": {
+        "city": "San Diego",
+        "country": "United States",
+        "pk": "01FX8RMR7YCDAVSWBMWCH2B07G",
+        "postal_code": "92102",
+        "state": "California",
+        "street_name": "C Street",
+        "street_number": 1299,
+        "unit": null
+      },
+      "age": 43,
+      "first_name": "Fernando",
+      "last_name": "Ortega",
+      "personal_statement": "I'm in a really cool band that plays a lot of cover songs.  I'm the drummer!",
+      "pk": "01FX8RMR7YB283BPZ88HAG066P",
+      "skills": [
+        "clarinet",
+        "oboe",
+        "drums"
+      ]
+    }, {
+      "address": {
+        "city": "Nottingham",
+        "country": "United Kingdom",
+        "pk": "01FX8RMR82DDJ90CW8D1GM68YZ",
+        "postal_code": "NG1 1AA",
+        "state": "Nottinghamshire",
+        "street_name": "Broadway",
+        "street_number": 12,
+        "unit": "A-1"
+      },
+      "age": 37,
+      "first_name": "Noor",
+      "last_name": "Vasan",
+      "personal_statement": "I sing and play the guitar, I enjoy touring and meeting new people on the road.",
+      "pk": "01FX8RMR82D091TC37B45RCWY3",
+      "skills": [
+        "vocals",
+        "guitar"
+      ]
+    },
+    {
+      "address": {
+        "city": "Birmingham",
+        "country": "United Kingdom",
+        "pk": "01FX8SSSDNRDSRB3HMVH00NQTT",
+        "postal_code": "B91 6HG",
+        "state": "West Midlands",
+        "street_name": "The Rushes",
+        "street_number": 56,
+        "unit": null
+      },
+      "age": 36,
+      "first_name": "Joanne",
+      "last_name": "Peel",
+      "personal_statement": "Music is my life, I love gigging and playing with my band.",
+      "pk": "01FX8SSSDN7PT9T3N0JZZA758G",
+      "skills": [
+        "synths",
+        "vocals",
+        "guitar"
+      ]
+    }
+  ]
+}
+```
+
+Note that we get results including matches for "play", "plays" and "playing".
+
+### Update a Person's Age
+
+As well as retrieving information from Redis, we'll also want to update a Person's data from time to time.  Let's see how to do that with Redis OM for Python.
+
+The function `update_age` in `app.py` accepts two parameters: `id` and `new_age`.  Using these, we first retrieve the person's data from Redis and create a new object with it:
+
+```py
+  try:
+      person = Person.get(id)
+
+  except NotFoundError:
+      return "Bad request", 400
+```
+
+Assuming we find the person, let's update their age and save the data back to Redis:
+
+```py
+  person.age = new_age
+  person.save()
+```
+
+Let's change Kareem Khan's age from 27 to 28:
+
+```bash
+curl --location --request POST 'http://127.0.0.1:5000/person/01FX8RMR7T60ANQTS4P9NKPKX8/age/28'
+```
+
+The server responds with `ok`.
+
+### Delete a Person
+
+If we know a person's ID, we can delete them from Redis without first having to load their data into a Person object. In the function `delete_person` in `app.py`, we call the `delete` class method on the Person class to do this:
+
+```py
+  Person.delete(id)
+```
+
+Let's delete Dan Harris, the person with ID `01FX8RMR8545RWW4DYCE5MSZA1`:
+
+```bash
+curl --location --request POST 'http://127.0.0.1:5000/person/01FX8RMR8545RWW4DYCE5MSZA1/delete'
+```
+
+The server responds with an `ok` response regardless of whether the ID provided existed in Redis.
+
+### Setting an Expiry Time for a Person
+
+This is an example of how to run arbitrary Redis commands against instances of a model saved in Redis.  Let's see how we can set the time to live (TTL) on a person, so that Redis will expire the JSON document after a configurable number of seconds have passed.
+
+The function `expire_by_id` in `app.py` handles this as follows.  It takes two parameters: `id` - the ID of a person to expire, and `seconds` - the number of seconds in the future to expire the person after.  This requires us to run the Redis [`EXPIRE`]({{< relref "/commands/expire" >}}) command against the person's key.  To do this, we need to access the Redis connection from the `Person` model like so:
+
+```py
+  person_to_expire = Person.get(id)
+  Person.db().expire(person_to_expire.key(), seconds)
+```
+
+Let's set the person with ID `01FX8RMR82D091TC37B45RCWY3` to expire in 600 seconds:
+
+```bash
+curl --location --request POST 'http://localhost:5000/person/01FX8RMR82D091TC37B45RCWY3/expire/600'
+```
+
+Using `redis-cli`, you can check that the person now has a TTL set with the Redis `expire` command:
+
+```bash
+127.0.0.1:6379> ttl :person.Person:01FX8RMR82D091TC37B45RCWY3
+(integer) 584
+```
+
+This shows that Redis will expire the key 584 seconds from now.
+
+You can use the `.db()` function on your model class to get at the underlying redis-py connection whenever you want to run lower level Redis commands.  For more details, see the [redis-py documentation](https://redis-py.readthedocs.io/en/stable/).
+
+## Shutting Down Redis (Docker)
+
+If you're using Docker, and want to shut down the Redis container when you are finished with the application, use `docker-compose down`:
+
+```bash
+$ docker-compose down
+Stopping redis_om_python_flask_starter ... done
+Removing redis_om_python_flask_starter ... done
+Removing network redis-om-python-flask-skeleton-app_default
+```
+---
+LinkTitle: Get started
+Title: Get started with Terraform
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: Shows how to install the Redis Cloud provider and create a subscription.
+group: provisioning
+headerRange: '[1-3]'
+summary: The Redis Cloud Terraform provider allows you to provision and manage Redis
+  Cloud resources.
+toc: 'true'
+type: integration
+weight: $weight
+---
+
+Here, you'll learn how to use the [Redis Cloud Terraform Provider]({{< relref "/integrate/terraform-provider-for-redis-cloud/" >}}) to create a subscription and a database.
+
+## Prerequisites
+
+1. [Install Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli).
+
+1. [Create a Redis Cloud account]({{< relref "/operate/rc/rc-quickstart#create-an-account" >}}) if you do not have one already.
+
+1. [Enable the Redis Cloud API]({{< relref "/operate/rc/api/get-started/enable-the-api" >}}).
+
+1. Get your Redis Cloud [API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}}). Set them to the following environment variables:
+
+    - Set `REDISCLOUD_ACCESS_KEY` to your API account key.
+    - Set `REDISCLOUD_SECRET_KEY` to your API user key.
+
+1. Set a [payment method]({{< relref "/operate/rc/billing-and-payments#add-payment-method" >}}).
+
+## Install the Redis Cloud provider
+
+1. Create a file to contain the Terraform configuration called `main.tf`.
+
+1. Go to the [Redis Cloud Terraform Registry](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/).
+
+1. Select **Use Provider** and copy the Terraform code located there. Paste the code into `main.tf` and save the file.
+
+   ```text
+   provider "rediscloud" {
+   }
+
+   # Example resource configuration
+   resource "rediscloud_subscription" "example" {
+      # ...
+   }
+   ```
+   
+1. Run `terraform init`.
+
+## Create a Redis Cloud subscription with Terraform
+
+In your Terraform configuration file, you can add resources and data sources to plan and create subscriptions and databases. See the [Redis Cloud Terraform Registry documentation](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs) for more info about the resources and data sources you can use as part of the Redis Cloud provider.
+
+The steps in this section show you how to plan and create a Redis Cloud Pro subscription with one database.
+
+1. Use the [`rediscloud_payment_method`](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_payment_method) data source to get the payment method ID.
+
+    ```text
+    # Get credit card details
+    data "rediscloud_payment_method" "card" {
+        card_type = "<Card type>"
+        last_four_numbers = "<Last four numbers on the card>"
+    }
+    ```
+   
+   Example:
+
+   ```text
+   data "rediscloud_payment_method" "card" {
+      card_type = "Visa"
+      last_four_numbers = "5625"
+   }
+   ```
+   
+1. Define a [`rediscloud_subscription`](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_subscription) resource to create the subscription.
+
+    ```text
+    # Create a subscription
+    resource "rediscloud_subscription" "subscription-resource" {
+            name = "subscription-name"
+            payment_method_id = data.rediscloud_payment_method.card.id # If you want to pay with a marketplace account, replace this line with payment_method = 'marketplace'.
+            memory_storage = "ram"
+
+            # Specify the cloud provider information here
+            cloud_provider {
+                    provider = "<Cloud provider>"
+                    region {
+                            region = "<region>"
+                            networking_deployment_cidr = "<CIDR>"
+                    }
+            }
+
+            #Define the average database specification for databases in the subscription
+            creation_plan {
+                    memory_limit_in_gb = 2
+                    quantity = 1
+                    replication = true
+                    throughput_measurement_by = "operations-per-second"
+                    throughput_measurement_value = 20000
+            }
+    }
+    ```
+
+   Example:
+
+   ```text
+   resource "rediscloud_subscription" "subscription-resource" {
+        name = "redis-docs-sub"
+        payment_method_id = data.rediscloud_payment_method.card.id # If you want to pay with a marketplace account, replace this line with payment_method = 'marketplace'.
+        memory_storage = "ram"
+
+        cloud_provider {
+                provider = "GCP"
+                region {
+                        region = "us-west1"
+                        networking_deployment_cidr = "192.168.0.0/24"
+                }
+        }
+
+        creation_plan {
+                memory_limit_in_gb = 2
+                quantity = 1
+                replication = true
+                throughput_measurement_by = "operations-per-second"
+                throughput_measurement_value = 20000
+                modules = ["RedisJSON"]
+        }
+   }
+   ```
+
+1. Define a [`rediscloud_subscription_database`](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_subscription_database) resource to create a database.
+
+    ```text
+    # Create a Database
+    resource "rediscloud_subscription_database" "database-resource" {
+        subscription_id = rediscloud_subscription.subscription-resource.id
+        name = "database-name"
+        memory_limit_in_gb = 2
+        data_persistence = "aof-every-write"
+        throughput_measurement_by = "operations-per-second"
+        throughput_measurement_value = 20000
+        replication = true
+
+        alert {
+        name = "dataset-size"
+        value = 40
+        }
+        depends_on = [rediscloud_subscription.subscription-resource]
+
+    }
+    ```
+   
+   Example:
+
+   ```text
+   resource "rediscloud_subscription_database" "database-resource" {
+       subscription_id = rediscloud_subscription.subscription-resource.id
+       name = "redis-docs-db"
+       memory_limit_in_gb = 2
+       data_persistence = "aof-every-write"
+       throughput_measurement_by = "operations-per-second"
+       throughput_measurement_value = 20000
+       replication = true
+
+       modules = [
+       {
+            name = "RedisJSON"
+       }
+       ]
+
+       alert {
+       name = "dataset-size"
+       value = 40
+       }
+      depends_on = [rediscloud_subscription.subscription-resource]
+
+   }
+    ```
+
+2. Run `terraform plan` to check for any syntax errors.
+
+    ```sh
+    $ terraform plan
+    data.rediscloud_payment_method.card: Reading...
+    data.rediscloud_payment_method.card: Read complete after 1s [id=8859]
+
+    Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following
+    symbols:
+    + create
+
+    Terraform will perform the following actions:
+
+        # rediscloud_subscription.subscription-resource will be created
+        + resource "rediscloud_subscription" "subscription-resource" {
+            [...]
+        }
+
+        # rediscloud_subscription_database.database-resource will be created
+        + resource "rediscloud_subscription_database" "database-resource" {
+            [...]
+        }
+    
+    Plan: 2 to add, 0 to change, 0 to destroy.
+    ```
+
+3. Run `terraform apply` to apply the changes and enter `yes` to confirm when prompted.
+
+    This will take some time. You will see messages in your terminal while the subscription and database are being created:
+
+   ```text
+   rediscloud_subscription.subscription-resource: Creating...
+   rediscloud_subscription.subscription-resource: Still creating... [10s elapsed]
+   rediscloud_subscription.subscription-resource: Still creating... [20s elapsed]
+   rediscloud_subscription.subscription-resource: Still creating... [30s elapsed]
+   ```
+
+   When provisioning is complete, you will see a message in your terminal:   
+
+   ```text
+   Apply complete! Resources: 2 added, 0 changed, 0 destroyed.
+   ```
+
+   View the [Redis Cloud console](https://cloud.redis.io/) to verify your subscription and database creation.
+
+4. If you want to remove these sample resources, run `terraform destroy`.
+
+## More info
+
+- [Redis Cloud Terraform Registry](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs)
+- [Terraform documentation](https://developer.hashicorp.com/terraform/docs)
+- [Terraform configuration syntax](https://developer.hashicorp.com/terraform/language/syntax/configuration)
+---
+LinkTitle: Terraform provider for Redis Cloud
+Title: Terraform provider for Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: null
+group: provisioning
+headerRange: '[1-3]'
+summary: The Redis Cloud Terraform provider allows you to provision and manage Redis
+  Cloud resources.
+toc: 'true'
+type: integration
+weight: 4
+hideListLinks: true
+---
+
+[Terraform](https://developer.hashicorp.com/terraform) is an open source automation tool developed by Hashicorp that allows you to easily provision infrastructure as code.
+
+Redis develops and maintains a [Terraform provider for Redis Cloud](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest). The Redis Cloud Terraform provider allows many of the same actions as found in the [Redis Cloud API]({{< relref "/operate/rc/api" >}}).
+
+See [Get started with Terraform]({{< relref "/integrate/terraform-provider-for-redis-cloud/get-started" >}}) for an example of how to use the Terraform provider.
+
+## Data sources and Resources
+
+The Terraform provider represents API actions as data sources and resources. Data sources are read-only and allow you to get information, while resources allow you to create and manage infrastructure.
+
+The Redis Cloud Terraform provider allows for the following data sources:
+
+- Redis Cloud Pro:
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_database)
+  - [Database capabilities](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_database_modules)
+  - [VPC peering connections](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_subscription_peerings)
+  - [Cloud accounts](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_cloud_account)
+  - [Supported persistence options](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_data_persistence)
+  - [AWS Transit Gateways](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_transit_gateway)
+  - Google Cloud Private Service Connect [Services](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_private_service_connect) and [Endpoints](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_private_service_connect_endpoints)
+- Redis Cloud Essentials:
+  - [Plans](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_essentials_plan)
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_essentials_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_essentials_database)
+- Active-Active:
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription_database)
+  - [AWS Transit Gateways](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_active_active_transit_gateway)
+  - Google Cloud Private Service Connect [services](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_active_active_private_service_connect) and [endpoints](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_active_active_private_service_connect_endpoints)
+- [Payment methods](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_payment_method)
+- [Supported cloud provider regions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_regions)
+- ACL [roles](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_acl_role), [rules](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_acl_rule), and [users](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/data-sources/rediscloud_acl_user)
+
+It also allows you to create and manage the following resources:
+
+- Redis Cloud Pro:
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_subscription_database)
+    - **NOTE**: Upgrade your Terraform provider to version 1.8.1 to create databases with Search and Query.
+  - [VPC peering connections](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_subscription_peering)
+  - [Cloud accounts](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_cloud_account)
+  - [AWS Transit Gateway attachments](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_transit_gateway_attachment)
+  - Google Cloud Private Service Connect [connections](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_private_service_connect), [endpoints](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_private_service_connect_endpoint) and [endpoint acceptors](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_private_service_connect_endpoint_accepter)
+- Redis Cloud Essentials:
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_essentials_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_essentials_database)
+- Active-Active:
+  - [Subscriptions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription)
+  - [Databases](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription_database)
+  - [Regions](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription_regions)
+  - [VPC peering connections](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_subscription_peering)
+  - [AWS Transit Gateway attachments](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_transit_gateway_attachment)
+  - Google Cloud Private Service Connect [connections](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_private_service_connect), [endpoints](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_private_service_connect_endpoint) and [endpoint acceptors](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_active_active_private_service_connect_endpoint_accepter)
+- ACL [rules](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_acl_rule), [roles](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_acl_role), and [users](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs/resources/rediscloud_acl_user)
+
+
+## More info
+
+- [Get started with Terraform]({{< relref "/integrate/terraform-provider-for-redis-cloud/get-started" >}})
+- [Redis Cloud Terraform Registry](https://registry.terraform.io/providers/RedisLabs/rediscloud/latest/docs)
+- [Terraform documentation](https://developer.hashicorp.com/terraform/docs)
+- [Terraform configuration syntax](https://developer.hashicorp.com/terraform/language/syntax/configuration)---
+LinkTitle: RedisOM for .NET
+Title: RedisOM for .NET
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis Stack and .NET
+group: library
+stack: true
+summary: Redis OM for .NET is an object-mapping library for Redis.
+title: Redis OM .NET
+type: integration
+weight: 9
+---
+
+[Redis OM .NET](https://github.com/redis/redis-om-dotnet) is a purpose-built library for handling documents in Redis Stack. In this tutorial, we'll build a simple ASP.NET Core Web-API app for performing CRUD operations on a simple Person & Address model, and we'll accomplish all of this with Redis OM .NET.
+
+## Prerequisites
+
+* [.NET 6 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/6.0)
+* Any IDE for writing .NET (Visual Studio, Rider, Visual Studio Code).
+* RediSearch must be installed as part of your Redis Stack configuration.
+* Optional: Docker Desktop for running redis-stack in docker for local testing.
+
+## Skip to the code
+
+If you want to skip this tutorial and just jump straight into code, all the source code is available in [GitHub](https://github.com/redis-developer/redis-om-dotnet-skeleton-app)
+
+## Run Redis Stack
+
+There are a variety of ways to run Redis Stack. One way is to use the docker image:
+
+```
+docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack
+```
+
+## Create the project
+
+To create the project, just run:
+
+```bash
+dotnet new webapi -n Redis.OM.Skeleton --no-https --kestrelHttpPort 5000
+```
+
+Then open the `Redis.OM.Skeleton.csproj` file in your IDE of choice.
+
+## Configure the app
+
+Add a `REDIS_CONNECTION_STRING` field to your `appsettings.json` file to configure the application. Set that connection string to be the URI of your Redis instance. If using the docker command mentioned earlier, your connection string will be `redis://localhost:6379`.
+
+### Connection string specification
+
+The specification for Redis URIs is located [here](https://www.iana.org/assignments/uri-schemes/prov/redis). You can use `:password@host:port` or `default:password@host:port` for connection strings that do not include `username`.
+
+## Create the model
+
+Make sure to add the `Redis.OM` package to your project. This package makes it easy to create models and query your Redis domain objects.
+
+```bash
+dotnet add package Redis.OM     
+```
+
+Now it's time to create the `Person`/`Address` model that the app will use for storing/retrieving people. Create a new directory called `Model` and add the files `Address.cs` and `Person.cs` to it. In `Address.cs`, add the following:
+
+```csharp
+using Redis.OM.Modeling;
+
+namespace Redis.OM.Skeleton.Model;
+
+public class Address
+{
+    [Indexed]
+    public int? StreetNumber { get; set; }
+    
+    [Indexed]
+    public string? Unit { get; set; }
+    
+    [Searchable]
+    public string? StreetName { get; set; }
+    
+    [Indexed]
+    public string? City { get; set; }
+    
+    [Indexed]
+    public string? State { get; set; }
+    
+    [Indexed]
+    public string? PostalCode { get; set; }
+    
+    [Indexed]
+    public string? Country { get; set; }
+    
+    [Indexed]
+    public GeoLoc Location { get; set; }
+}
+```
+
+Here, you'll notice that except `StreetName`, marked as `Searchable`, all the fields are decorated with the `Indexed` attribute. These attributes (`Searchable` and `Indexed`) tell Redis OM that you want to be able to use those fields in queries when querying your documents in Redis Stack. `Address` will not be a Document itself, so the top-level class is not decorated with anything; instead, the `Address` model will be embedded in our `Person` model.
+
+To that end, add the following to `Person.cs`
+
+```csharp
+using Redis.OM.Modeling;
+
+namespace Redis.OM.Skeleton.Model;
+
+[Document(StorageType = StorageType.Json, Prefixes = new []{"Person"})]
+public class Person
+{    
+    [RedisIdField] [Indexed]public string? Id { get; set; }
+    
+    [Indexed] public string? FirstName { get; set; }
+
+    [Indexed] public string? LastName { get; set; }
+    
+    [Indexed] public int Age { get; set; }
+    
+    [Searchable] public string? PersonalStatement { get; set; }
+    
+    [Indexed] public string[] Skills { get; set; } = Array.Empty<string>();    
+    
+    [Indexed(CascadeDepth = 1)] public Address? Address { get; set; }
+    
+}
+```
+
+There are a few things to take note of here: 
+
+1. `[Document(StorageType = StorageType.Json, Prefixes = new []{"Person"})]` Indicates that the data type that Redis OM will use to store the document in Redis is JSON and that the prefix for the keys for the Person class will be `Person`.
+
+2. `[Indexed(CascadeDepth = 1)] Address? Address { get; set; }` is one of two ways you can index an embedded object with Redis OM. This way instructs the index to cascade to the objects in the object graph, `CascadeDepth` of 1 means that it will traverse just one level, indexing the object as if it were building the index from scratch. The other method uses the `JsonPath` property of the individual indexed fields you want to search for. This more surgical approach limits the size of the index.
+
+3. the `Id` property is marked as a `RedisIdField`. This denotes the field as one that will be used to generate the document's key name when it's stored in Redis.
+
+## Create the Index
+
+With the model built, the next step is to create the index in Redis. The most correct way to manage this is to spin the index creation out into a Hosted Service, which will run when the app spins up.
+Create a `HostedServices` directory and add `IndexCreationService.cs` to that. In that file, add the following, which will create the index on startup.
+
+```csharp
+using Redis.OM.Skeleton.Model;
+
+namespace Redis.OM.Skeleton.HostedServices;
+
+public class IndexCreationService : IHostedService
+{
+    private readonly RedisConnectionProvider _provider;
+    public IndexCreationService(RedisConnectionProvider provider)
+    {
+        _provider = provider;
+    }
+    
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        await _provider.Connection.CreateIndexAsync(typeof(Person));
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}
+```
+
+Next, add the following to `Program.cs` to register the service on startup:
+
+```csharp
+builder.Services.AddHostedService<IndexCreationService>();
+```
+
+## Inject the RedisConnectionProvider
+
+Redis OM uses the `RedisConnectionProvider` class to handle connections to Redis and provides the classes you can use to interact with Redis. To use it, simply inject an instance of the RedisConnectionProvider into your app. In your `Program.cs` file, add:
+
+```csharp
+builder.Services.AddSingleton(new RedisConnectionProvider(builder.Configuration["REDIS_CONNECTION_STRING"]));
+```
+
+This will pull your connection string out of the config and initialize the provider. The provider will now be available in your controllers/services to use.
+
+## Create the PeopleController
+
+The final puzzle piece is to write the actual API controller for our People API. In the `controllers` directory, add the file `PeopleController.cs`, the skeleton of the `PeopleController`class will be:
+
+```csharp
+using Microsoft.AspNetCore.Mvc;
+using Redis.OM.Searching;
+using Redis.OM.Skeleton.Model;
+
+namespace Redis.OM.Skeleton.Controllers;
+
+[ApiController]
+[Route("[controller]")]
+public class PeopleController : ControllerBase
+{
+
+}
+```
+
+### Inject the RedisConnectionProvider
+
+To interact with Redis, inject the RedisConnectionProvider. During this dependency injection, pull out a `RedisCollection<Person>` instance, which will allow a fluent interface for querying documents in Redis.
+
+```csharp
+private readonly RedisCollection<Person> _people;
+private readonly RedisConnectionProvider _provider;
+public PeopleController(RedisConnectionProvider provider)
+{
+    _provider = provider;
+    _people = (RedisCollection<Person>)provider.RedisCollection<Person>();
+}
+```
+
+### Add route for creating a Person
+
+The first route to add to the API is a POST request for creating a person, using the `RedisCollection`, it's as simple as calling `InsertAsync`, passing in the person object:
+
+
+```csharp
+[HttpPost]
+public async Task<Person> AddPerson([FromBody] Person person)
+{
+    await _people.InsertAsync(person);
+    return person;
+}
+```
+
+### Add route to filter by age
+
+The first filter route to add to the API will let the user filter by a minimum and maximum age. Using the LINQ interface available to the `RedisCollection`, this is a simple operation:
+
+```csharp
+[HttpGet("filterAge")]
+public IList<Person> FilterByAge([FromQuery] int minAge, [FromQuery] int maxAge)
+{        
+    return _people.Where(x => x.Age >= minAge && x.Age <= maxAge).ToList();
+}
+```
+
+### Filter by GeoLocation
+
+Redis OM has a `GeoLoc` data structure, an instance of which is indexed by the `Address` model, with the `RedisCollection`, it's possible to find all objects with a radius of particular position using the `GeoFilter` method along with the field you want to filter:
+
+
+```csharp
+[HttpGet("filterGeo")]
+public IList<Person> FilterByGeo([FromQuery] double lon, [FromQuery] double lat, [FromQuery] double radius, [FromQuery] string unit)
+{
+    return _people.GeoFilter(x => x.Address!.Location, lon, lat, radius, Enum.Parse<GeoLocDistanceUnit>(unit)).ToList();
+}
+```
+
+### Filter by exact string
+
+When a string property in your model is marked as `Indexed`, e.g. `FirstName` and `LastName`, Redis OM can perform exact text matches against them. For example, the following two routes filter by `PostalCode` and name demonstrate exact string matches.
+
+```csharp
+[HttpGet("filterName")]
+public IList<Person> FilterByName([FromQuery] string firstName, [FromQuery] string lastName)
+{
+    return _people.Where(x => x.FirstName == firstName && x.LastName == lastName).ToList();
+}
+
+[HttpGet("postalCode")]
+public IList<Person> FilterByPostalCode([FromQuery] string postalCode)
+{
+    return _people.Where(x => x.Address!.PostalCode == postalCode).ToList();
+}
+```
+
+### Filter with a full-text search
+
+When a property in the model is marked as `Searchable`, like `StreetAddress` and `PersonalStatement`, you can perform a full-text search, see the filters for the `PersonalStatement` and `StreetAddress`:
+
+
+```csharp
+[HttpGet("fullText")]
+public IList<Person> FilterByPersonalStatement([FromQuery] string text){
+    return _people.Where(x => x.PersonalStatement == text).ToList();
+}
+
+[HttpGet("streetName")]
+public IList<Person> FilterByStreetName([FromQuery] string streetName)
+{
+    return _people.Where(x => x.Address!.StreetName == streetName).ToList();
+}
+```
+
+### Filter by array membership
+
+When a string array or list is marked as `Indexed`, Redis OM can filter all the records containing a given string using the `Contains` method of the array or list. For example, our `Person` model has a list of skills you can query by adding the following route.
+
+```csharp
+[HttpGet("skill")]
+public IList<Person> FilterBySkill([FromQuery] string skill)
+{
+    return _people.Where(x => x.Skills.Contains(skill)).ToList();
+}
+```
+
+### Updating a person
+
+Updating a document in Redis Stack with Redis OM can be done by first materializing the person object, making your desired changes, and then calling `Save` on the collection. The collection is responsible for keeping track of updates made to entities materialized in it; therefore, it will track and apply any updates you make in it. For example, add the following route to update the age of a Person given their Id:
+
+
+```csharp
+[HttpPatch("updateAge/{id}")]
+public IActionResult UpdateAge([FromRoute] string id, [FromBody] int newAge)
+{
+    foreach (var person in _people.Where(x => x.Id == id))
+    {
+        person.Age = newAge;
+    }
+    _people.Save();
+    return Accepted();
+}
+```
+
+### Delete a person
+
+Deleting a document from Redis can be done with `Unlink`. All that's needed is to call Unlink, passing in the key name. Given an id, we can reconstruct the key name using the prefix and the id:
+
+
+```csharp
+[HttpDelete("{id}")]
+public IActionResult DeletePerson([FromRoute] string id)
+{
+    _provider.Connection.Unlink($"Person:{id}");
+    return NoContent();
+}
+```
+
+## Run the app
+
+All that's left to do now is to run the app and test it. You can do so by running `dotnet run`, the app is now exposed on port 5000, and there should be a swagger UI that you can use to play with the API at http://localhost:5000/swagger. There's a couple of scripts, along with some data files, to insert some people into Redis using the API in the [GitHub repo](https://github.com/redis-developer/redis-om-dotnet-skeleton-app/tree/main/data)
+
+## Viewing data in with Redis Insight
+
+You can either install the Redis Insight GUI or use the Redis Insight GUI running on http://localhost:8001/.
+
+You can view the data by following these steps:
+
+1. Accept the EULA
+
+![Accept EULA](./images/Accept_EULA.png)
+
+2. Click the Add Redis Database button
+
+![Add Redis Database Button](./images/Add_Redis_Database_button.png)
+
+3. Enter your hostname and port name for your redis server. If you are using the docker image, this is `localhost` and `6379` and give your database an alias
+
+![Configure Redis Insight Database](./images/Configure_Redis_Insight_Database.png)
+
+4. Click `Add Redis Database.`
+
+## Resources
+
+The source code for this tutorial can be found in [GitHub](https://github.com/redis-developer/redis-om-dotnet-skeleton-app).
+
+---
+Title: Prometheus metrics v2 preview
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.
+group: observability
+linkTitle: Prometheus metrics v2
+summary: V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.
+type: integration
+weight: 50
+tocEmbedHeaders: true
+---
+
+{{<banner-article>}}
+While the metrics stream engine is in preview, this document provides only a partial list of v2 metrics. More metrics will be added.
+{{</banner-article>}}
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/integrate/prometheus-with-redis-enterprise/">}}) to create dashboards for important metrics.
+
+The v2 metrics in the following tables are available as of Redis Enterprise Software version 7.8.0. For help transitioning from v1 metrics to v2 PromQL, see [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2">}}).
+
+The v2 scraping endpoint also exposes metrics for `node_exporter` version 1.8.1. For more information, see the [Prometheus node_exporter GitHub repository](https://github.com/prometheus/node_exporter).
+
+{{<embed-md "rs-prometheus-metrics-v2.md">}}
+---
+Title: Prometheus metrics v1
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: V1 metrics available to Prometheus.
+group: observability
+linkTitle: Prometheus metrics v1
+summary: You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.
+type: integration
+weight: 48
+tocEmbedHeaders: true
+---
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/integrate/prometheus-with-redis-enterprise/">}}) to create dashboards for important metrics.
+
+As of Redis Enterprise Software version 7.8.2, v1 metrics are deprecated but still available. For help transitioning from v1 metrics to v2 PromQL, see [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2">}}).
+
+{{<embed-md "rs-prometheus-metrics-v1.md">}}
+---
+Title: Redis Enterprise Software observability and monitoring guidance
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Using monitoring and observability with Redis Enterprise 
+group: observability
+linkTitle: Observability and monitoring
+summary: Observe Redis Enterprise resources and database perfomance indicators.
+type: integration
+weight: 45
+tocEmbedHeaders: true
+---
+
+{{<embed-md "rs-observability.md">}}
+---
+LinkTitle: Prometheus & Grafana with Redis Software
+Title: Prometheus and Grafana with Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Use Prometheus and Grafana to collect and visualize Redis Enterprise Software metrics.
+group: observability
+summary: You can use Prometheus and Grafana to collect and visualize your Redis Enterprise
+  Software metrics.
+type: integration
+weight: 5
+tocEmbedHeaders: true
+---
+
+{{<embed-md "rs-prometheus-grafana-quickstart.md">}}
+---
+Title: Transition from Prometheus v1 to Prometheus v2
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Transition from v1 metrics to v2 PromQL equivalents.
+group: observability
+linkTitle: Transition from Prometheus v1 to v2
+summary: Transition from v1 metrics to v2 PromQL equivalents.
+type: integration
+weight: 49
+tocEmbedHeaders: true
+---
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/integrate/prometheus-with-redis-enterprise/">}}) to create dashboards for important metrics.
+
+As of Redis Enterprise Software version 7.8.2, [PromQL (Prometheus Query Language)](https://prometheus.io/docs/prometheus/latest/querying/basics/) metrics are available. V1 metrics are deprecated but still available. You can use the following tables to transition from v1 metrics to equivalent v2 PromQL. For a list of all available v2 PromQL metrics, see [Prometheus metrics v2]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions">}}).
+
+{{<embed-md "rs-prometheus-metrics-transition-plan.md">}}
+---
+LinkTitle: New Relic with Redis Enterprise
+Title: New Relic with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect New Relic to your Redis Enterprise cluster using
+  the Redis New Relic Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect New Relic to your Redis Enterprise cluster using
+  the Redis New Relic Integration.
+type: integration
+weight: 7
+---
+
+
+[New Relic](https://newrelic.com/?customer-bypass=true) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The New Relic Integration for Redis Enterprise uses Prometheus remote write functionality to connect Prometheus data 
+sources to New Relic. This integration enables Redis Enterprise users to export metrics to New Relic for analysis, 
+and includes Redis-designed dashboards for use in monitoring Redis Enterprise clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rs/redis-enterprise-newrelic.png" >}}
+## Install Redis' New Relic Integration for Redis Enterprise
+
+The New Relic Integration for Redis is based on a feature of the Prometheus data source. Prometheus can forward metrics on to 
+another destination using remote writes. The Prometheus installation must be configured to pull metrics from Redis 
+Enterprise and write them to New Relic. There are two sections, first the pull from Redis and second the write to New Relic.
+
+Get metrics from Redis Enterprise:
+
+```yaml
+  - job_name: "redis-enterprise"
+    scrape_interval: 30s
+    scrape_timeout: 30s
+    metrics_path: /
+    scheme: https
+    tls_config:
+      insecure_skip_verify: true
+    static_configs:
+      # The default Redis Enterprise Prometheus port is 8070. 
+      # Replace REDIS_ENTERPRISE_HOST with your cluster's hostname.
+      - targets: ["REDIS_ENTERPRISE_HOST:8070"]
+```
+
+Write them to New Relic:
+
+```yaml
+# Remote write configuration for New Relic.
+# - Replace REDIS_ENTERPRISE_SERVICE NAME with any name you'd like to use to refer to this data source.
+# - Replace NEW_RELIC_BEARER_TOKEN with the token you generated on the New Relic Administration -> API Keys page.
+remote_write:
+- url: https://metric-api.newrelic.com/prometheus/v1/write?prometheus_server=REDIS_ENTERPRISE_SERVICE_NAME
+  authorization:
+    credentials: NEW_RELIC_BEARER_TOKEN
+```
+
+## View metrics
+
+The Redis Enterprise Integration for New Relic contains pre-defined dashboards to aid in monitoring your Redis Enterprise deployment.
+
+The following dashboards are currently available:
+
+- Cluster: top-level statistics indicating the general health of the cluster
+- Database: performance metrics at the database level
+- Node
+- Shard: low-level details of an individual shard
+- Active-Active: replication and performance for geo-replicated clusters
+- Proxy: network and command information regarding the proxy
+- Proxy Threads: processor usage information regarding the proxy's component threads 
+
+## Monitor metrics
+
+New Relic dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible to
+filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
+retrieve the relevant data before choosing one of the options in the 'cluster' section.
+
+Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list 
+of database names and ids; use the id value when filtering input to the dashboard. 
+
+
+---
+LinkTitle: RedisOM for Node.js
+Title: RedisOM for Node.js
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis Stack and Node.js
+group: library
+stack: true
+summary: Redis OM for Node.js is an object-mapping library for Redis.
+title: Redis OM Node.js
+type: integration
+weight: 9
+---
+
+This tutorial will show you how to build an API using Node.js and Redis Stack.
+
+We'll be using [Express](https://expressjs.com/) and [Redis OM](https://github.com/redis/redis-om-node) to do this, and we assume that you have a basic understanding of Express.
+
+The API we'll be building is a simple and relatively RESTful API that reads, writes, and finds data on persons: first name, last name, age, etc. We'll also add a simple location tracking feature just for a bit of extra interest.
+
+But before we start with the coding, let's start with a description of what Redis OM *is*.
+
+
+## Prerequisites
+
+Like anything software-related, you need to have some dependencies installed before you can get started:
+
+- [Node.js 14.8+](https://nodejs.org/en/): In this tutorial, we're using JavaScript's top-level `await` feature which was introduced in Node 14.8. So, make sure you are using that version or later.
+- [Redis Stack](/download): You need a version of Redis Stack, either running locally on your machine or [in the cloud](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+- [Redis Insight](https://redis.com/redis-enterprise/redis-insight/): We'll use this to look inside Redis and make sure our code is doing what we think it's doing.
+
+
+## Starter code
+
+We're not going to code this completely from scratch. Instead, we've provided some starter code for you. Go ahead and clone it to a folder of your convenience:
+
+    git clone git@github.com:redis-developer/express-redis-om-workshop.git
+
+Now that you have the starter code, let's explore it a bit. Opening up `server.js` in the root we see that we have a simple Express app that uses [*Dotenv*](https://www.npmjs.com/package/dotenv) for configuration and [Swagger UI Express](https://www.npmjs.com/package/swagger-ui-express) for testing our API:
+
+{{< highlight javascript >}}
+import 'dotenv/config'
+
+import express from 'express'
+import swaggerUi from 'swagger-ui-express'
+import YAML from 'yamljs'
+
+/* create an express app and use JSON */
+const app = new express()
+app.use(express.json())
+
+/* set up swagger in the root */
+const swaggerDocument = YAML.load('api.yaml')
+app.use('/', swaggerUi.serve, swaggerUi.setup(swaggerDocument))
+
+/* start the server */
+app.listen(8080)
+{{< / highlight >}}
+
+Alongside this is `api.yaml`, which defines the API we're going to build and provides the information Swagger UI Express needs to render its UI. You don't need to mess with it unless you want to add some additional routes.
+
+The `persons` folder has some JSON files and a shell script. The JSON files are sample persons—all musicians because fun—that you can load into the API to test it. The shell script—`load-data.sh`—will load all the JSON files into the API using `curl`.
+
+There are two empty folders, `om` and `routers`. The `om` folder is where all the Redis OM code will go. The `routers` folder will hold code for all of our Express routes.
+
+
+## Configure and run
+
+The starter code is perfectly runnable if a bit thin. Let's configure and run it to make sure it works before we move on to writing actual code. First, get all the dependencies:
+
+    npm install
+
+Then, set up a `.env` file in the root that Dotenv can make use of. There's a `sample.env` file in the root that you can copy and modify:
+
+    cp sample.env .env
+
+The contents of `.env` looks like this:
+
+{{< highlight bash >}}
+# Put your local Redis Stack URL here. Want to run in the
+# cloud instead? Sign up at https://redis.com/try-free/.
+REDIS_URL=redis://localhost:6379
+{{< / highlight >}}
+
+There's a good chance this is already correct. However, if you need to change the `REDIS_URL` for your particular environment (e.g., you're running Redis Stack in the cloud), this is the time to do it. Once done, you should be able to run the app:
+
+    npm start
+
+Navigate to `http://localhost:8080` and check out the client that Swagger UI Express has created. None of it *works* yet because we haven't implemented any of the routes. But, you can try them out and watch them fail!
+
+The starter code runs. Let's add some Redis OM to it so it actually *does* something!
+
+
+## Setting up a Client
+
+First things first, let's set up a **client**. The `Client` class is the thing that knows how to talk to Redis on behalf of Redis OM. One option is to put our client in its own file and export it. This ensures that the application has one and only one instance of `Client` and thus only one connection to Redis Stack. Since Redis and JavaScript are both (more or less) single-threaded, this works neatly.
+
+Let's create our first file. In the `om` folder add a file called `client.js` and add the following code:
+
+{{< highlight javascript >}}
+import { Client } from 'redis-om'
+
+/* pulls the Redis URL from .env */
+const url = process.env.REDIS_URL
+
+/* create and open the Redis OM Client */
+const client = await new Client().open(url)
+
+export default client
+{{< / highlight >}}
+
+> Remember that _top-level await_ stuff we mentioned earlier? There it is!
+
+Note that we are getting our Redis URL from an environment variable. It was put there by Dotenv and read from our `.env` file. If we didn't have the `.env` file or have a `REDIS_URL` property in our `.env` file, this code would gladly read this value from the *actual* environment variables.
+
+Also note that the `.open()` method conveniently returns `this`. This `this` (can I say *this* again? I just did!) lets us chain the instantiation of the client with the opening of the client. If this isn't to your liking, you could always write it like this:
+
+{{< highlight javascript >}}
+/* create and open the Redis OM Client */
+const client = new Client()
+await client.open(url)
+{{< / highlight >}}
+
+
+## Entity, Schema, and Repository
+
+Now that we have a client that's connected to Redis, we need to start mapping some persons. To do that, we need to define an `Entity` and a `Schema`. Let's start by creating a file named `person.js` in the `om` folder and importing `client` from `client.js` and the `Entity` and `Schema` classes from Redis OM:
+
+{{< highlight javascript >}}
+import { Entity, Schema } from 'redis-om'
+import client from './client.js'
+{{< / highlight >}}
+
+### Entity
+
+Next, we need to define an **entity**. An `Entity` is the class that holds you data when you work with it—the thing being mapped to. It is what you create, read, update, and delete. Any class that extends `Entity` is an entity. We'll define our `Person` entity with a single line:
+
+{{< highlight javascript >}}
+/* our entity */
+class Person extends Entity {}
+{{< / highlight >}}
+
+### Schema
+
+A **schema** defines the fields on your entity, their types, and how they are mapped internally to Redis. By default, entities map to JSON documents. Let's create our `Schema` in `person.js`:
+
+{{< highlight javascript >}}
+/* create a Schema for Person */
+const personSchema = new Schema(Person, {
+  firstName: { type: 'string' },
+  lastName: { type: 'string' },
+  age: { type: 'number' },
+  verified: { type: 'boolean' },
+  location: { type: 'point' },
+  locationUpdated: { type: 'date' },
+  skills: { type: 'string[]' },
+  personalStatement: { type: 'text' }
+})
+{{< / highlight >}}
+
+When you create a `Schema`, it modifies the `Entity` class you handed it (`Person` in our case) adding getters and setters for the properties you define. The type those getters and setters accept and return are defined with the type parameter as shown above. Valid values are: `string`, `number`, `boolean`, `string[]`, `date`, `point`, and `text`.
+
+The first three do exactly what you think—they define a property that is a [`String`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String), a [`Number`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number), or a [`Boolean`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean). `string[]` does what you'd think as well, specifically defining an [`Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) of strings.
+
+`date` is a little different, but still more or less what you'd expect. It defines a property that returns a [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) and can be set using not only a `Date` but also a `String` containing an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date or a `Number` with the [UNIX epoch time](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#the_ecmascript_epoch_and_timestamps) in *milliseconds*.
+
+A `point` defines a point somewhere on the globe as a longitude and a latitude. It creates a property that returns and accepts a simple object with the properties of `longitude` and `latitude`. Like this:
+
+{{< highlight javascript >}}
+let point = { longitude: 12.34, latitude: 56.78 }
+{{< / highlight >}}
+
+A `text` field is a lot like a `string`. If you're just reading and writing objects, they are identical. But if you want to *search* on them, they are very, very different. We'll talk about search more later, but the tl;dr is that `string` fields can only be matched on their whole value—no partial matches—and are best for keys while `text` fields have full-text search enabled on them and are optimized for human-readable text.
+
+### Repository
+
+Now we have all the pieces that we need to create a **repository**. A `Repository` is the main interface into Redis OM. It gives us the methods to read, write, and remove a specific `Entity`. Create a `Repository` in `person.js` and make sure it's exported as you'll need it when we start implementing out API:
+
+{{< highlight javascript >}}
+/* use the client to create a Repository just for Persons */
+export const personRepository = new Repository(personSchema, client)
+{{< / highlight >}}
+
+We're almost done with setting up our repository. But we still need to create an index or we won't be able to search. We do that by calling `.createIndex()`. If an index already exists and it's identical, this function won't do anything. If it's different, it'll drop it and create a new one. Add a call to `.createIndex()` to `person.js`:
+
+{{< highlight javascript >}}
+/* create the index for Person */
+await personRepository.createIndex()
+{{< / highlight >}}
+
+That's all we need for `person.js` and all we need to start talking to Redis using Redis OM. Here's the code in its entirety:
+
+{{< highlight javascript >}}
+import { Entity, Schema } from 'redis-om'
+import client from './client.js'
+
+/* our entity */
+class Person extends Entity {}
+
+/* create a Schema for Person */
+const personSchema = new Schema(Person, {
+  firstName: { type: 'string' },
+  lastName: { type: 'string' },
+  age: { type: 'number' },
+  verified: { type: 'boolean' },
+  location: { type: 'point' },
+  locationUpdated: { type: 'date' },
+  skills: { type: 'string[]' },
+  personalStatement: { type: 'text' }
+})
+
+/* use the client to create a Repository just for Persons */
+export const personRepository = client.fetchRepository(personSchema)
+
+/* create the index for Person */
+await personRepository.createIndex()
+{{< / highlight >}}
+
+Now, let's add some routes in Express.
+
+
+## Set up the Person Router
+
+Let's create a truly RESTful API with the CRUD operations mapping to PUT, GET, POST, and DELETE respectively. We're going to do this using [Express Routers](https://expressjs.com/en/4x/api.html#router) as this makes our code nice and tidy. Create a file called `person-router.js` in the `routers` folder and in it import `Router` from Express and `personRepository` from `person.js`. Then create and export a `Router`:
+
+{{< highlight javascript >}}
+import { Router } from 'express'
+import { personRepository } from '../om/person.js'
+
+export const router = Router()
+{{< / highlight >}}
+
+Imports and exports done, let's bind the router to our Express app. Open up `server.js` and import the `Router` we just created:
+
+{{< highlight javascript >}}
+/* import routers */
+import { router as personRouter } from './routers/person-router.js'
+{{< / highlight >}}
+
+Then add the `personRouter` to the Express app:
+
+{{< highlight javascript >}}
+/* bring in some routers */
+app.use('/person', personRouter)
+{{< / highlight >}}
+
+Your `server.js` should now look like this:
+
+{{< highlight javascript >}}
+import 'dotenv/config'
+
+import express from 'express'
+import swaggerUi from 'swagger-ui-express'
+import YAML from 'yamljs'
+
+/* import routers */
+import { router as personRouter } from './routers/person-router.js'
+
+/* create an express app and use JSON */
+const app = new express()
+app.use(express.json())
+
+/* bring in some routers */
+app.use('/person', personRouter)
+
+/* set up swagger in the root */
+const swaggerDocument = YAML.load('api.yaml')
+app.use('/', swaggerUi.serve, swaggerUi.setup(swaggerDocument))
+
+/* start the server */
+app.listen(8080)
+{{< / highlight >}}
+
+Now we can add our routes to create, read, update, and delete persons. Head back to the `person-router.js` file so we can do just that.
+
+
+### Creating a Person
+
+We'll create a person first as you need to have persons in Redis before you can do any of the reading, writing, or removing of them. Add the PUT route below. This route will call `.createAndSave()` to create a `Person` from the request body and immediately save it to the Redis:
+
+{{< highlight javascript >}}
+router.put('/', async (req, res) => {
+  const person = await personRepository.createAndSave(req.body)
+  res.send(person)
+})
+{{< / highlight >}}
+
+Note that we are also returning the newly created `Person`. Let's see what that looks like by actually calling our API using the Swagger UI. Go to http://localhost:8080 in your browser and try it out. The default request body in Swagger will be fine for testing. You should see a response that looks like this:
+
+{{< highlight json >}}
+{
+  "entityId": "01FY9MWDTWW4XQNTPJ9XY9FPMN",
+  "firstName": "Rupert",
+  "lastName": "Holmes",
+  "age": 75,
+  "verified": false,
+  "location": {
+    "longitude": 45.678,
+    "latitude": 45.678
+  },
+  "locationUpdated": "2022-03-01T12:34:56.123Z",
+  "skills": [
+    "singing",
+    "songwriting",
+    "playwriting"
+  ],
+  "personalStatement": "I like piña coladas and walks in the rain"
+}
+{{< / highlight >}}
+
+This is exactly what we handed it with one exception: the `entityId`. Every entity in Redis OM has an entity ID which is—as you've probably guessed—the unique ID of that entity. It was randomly generated when we called `.createAndSave()`. Yours will be different, so make note of it.
+
+You can see this newly created JSON document in Redis with Redis Insight. Go ahead and launch Redis Insight and you should see a key with a name like `Person:01FY9MWDTWW4XQNTPJ9XY9FPMN`. The `Person` bit of the key was derived from the class name of our entity and the sequence of letters and numbers is our generated entity ID. Click on it to take a look at the JSON document you've created.
+
+You'll also see a key named `Person:index:hash`. That's a unique value that Redis OM uses to see if it needs to recreate the index or not when `.createIndex()` is called. You can safely ignore it.
+
+
+### Reading a Person
+
+Create down, let's add a GET route to read this newly created `Person`:
+
+{{< highlight javascript >}}
+router.get('/:id', async (req, res) => {
+  const person = await personRepository.fetch(req.params.id)
+  res.send(person)
+})
+{{< / highlight >}}
+
+This code extracts a parameter from the URL used in the route—the `entityId` that we received previously. It uses the `.fetch()` method on the `personRepository` to retrieve a `Person` using that `entityId`. Then, it returns that `Person`.
+
+Let's go ahead and test that in Swagger as well. You should get back exactly the same response. In fact, since this is a simple GET, we should be able to just load the URL into our browser. Test that out too by navigating to http://localhost:8080/person/01FY9MWDTWW4XQNTPJ9XY9FPMN, replacing the entity ID with your own.
+
+Now that we can read and write, let's implement the *REST* of the HTTP verbs. REST... get it?
+
+
+### Updating a Person
+
+Let's add the code to update a person using a POST route:
+
+{{< highlight javascript >}}
+router.post('/:id', async (req, res) => {
+
+  const person = await personRepository.fetch(req.params.id)
+
+  person.firstName = req.body.firstName ?? null
+  person.lastName = req.body.lastName ?? null
+  person.age = req.body.age ?? null
+  person.verified = req.body.verified ?? null
+  person.location = req.body.location ?? null
+  person.locationUpdated = req.body.locationUpdated ?? null
+  person.skills = req.body.skills ?? null
+  person.personalStatement = req.body.personalStatement ?? null
+
+  await personRepository.save(person)
+
+  res.send(person)
+})
+{{< / highlight >}}
+
+This code fetches the `Person` from the `personRepository` using the `entityId` just like our previous route did. However, now we change all the properties based on the properties in the request body. If any of them are missing, we set them to `null`. Then, we call `.save()` and return the changed `Person`.
+
+Let's test this in Swagger too, why not? Make some changes. Try removing some of the fields. What do you get back when you read it after you've changed it?
+
+### Deleting a Person
+
+Deletion—my favorite! Remember kids, deletion is 100% compression. The route that deletes is just as straightforward as the one that reads, but much more destructive:
+
+{{< highlight javascript >}}
+router.delete('/:id', async (req, res) => {
+  await personRepository.remove(req.params.id)
+  res.send({ entityId: req.params.id })
+})
+{{< / highlight >}}
+
+I guess we should probably test this one out too. Load up Swagger and exercise the route. You should get back JSON with the entity ID you just removed:
+
+{{< highlight json >}}
+{
+  "entityId": "01FY9MWDTWW4XQNTPJ9XY9FPMN"
+}
+{{< / highlight >}}
+
+And just like that, it's gone!
+
+
+### All the CRUD
+
+Do a quick check with what you've written so far. Here's what should be the totality of your `person-router.js` file:
+
+{{< highlight javascript >}}
+import { Router } from 'express'
+import { personRepository } from '../om/person.js'
+
+export const router = Router()
+
+router.put('/', async (req, res) => {
+  const person = await personRepository.createAndSave(req.body)
+  res.send(person)
+})
+
+router.get('/:id', async (req, res) => {
+  const person = await personRepository.fetch(req.params.id)
+  res.send(person)
+})
+
+router.post('/:id', async (req, res) => {
+
+  const person = await personRepository.fetch(req.params.id)
+
+  person.firstName = req.body.firstName ?? null
+  person.lastName = req.body.lastName ?? null
+  person.age = req.body.age ?? null
+  person.verified = req.body.verified ?? null
+  person.location = req.body.location ?? null
+  person.locationUpdated = req.body.locationUpdated ?? null
+  person.skills = req.body.skills ?? null
+  person.personalStatement = req.body.personalStatement ?? null
+
+  await personRepository.save(person)
+
+  res.send(person)
+})
+
+router.delete('/:id', async (req, res) => {
+  await personRepository.remove(req.params.id)
+  res.send({ entityId: req.params.id })
+})
+{{< / highlight >}}
+
+
+## Preparing to search
+
+CRUD completed, let's do some searching. In order to search, we need data to search over. Remember that `persons` folder with all the JSON documents and the `load-data.sh` shell script? Its time has arrived. Go into that folder and run the script:
+
+    cd persons
+    ./load-data.sh
+
+You should get a rather verbose response containing the JSON response from the API and the names of the files you loaded. Like this:
+
+{{< highlight json >}}
+{"entityId":"01FY9Z4RRPKF4K9H78JQ3K3CP3","firstName":"Chris","lastName":"Stapleton","age":43,"verified":true,"location":{"longitude":-84.495,"latitude":38.03},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","football","coal mining"],"personalStatement":"There are days that I can walk around like I'm alright. And I pretend to wear a smile on my face. And I could keep the pain from comin' out of my eyes. But sometimes, sometimes, sometimes I cry."} <- chris-stapleton.json
+{"entityId":"01FY9Z4RS2QQVN4XFYSNPKH6B2","firstName":"David","lastName":"Paich","age":67,"verified":false,"location":{"longitude":-118.25,"latitude":34.05},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","keyboard","blessing"],"personalStatement":"I seek to cure what's deep inside frightened of this thing that I've become"} <- david-paich.json
+{"entityId":"01FY9Z4RSD7SQMSWDFZ6S4M5MJ","firstName":"Ivan","lastName":"Doroschuk","age":64,"verified":true,"location":{"longitude":-88.273,"latitude":40.115},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","dancing","friendship"],"personalStatement":"We can dance if we want to. We can leave your friends behind. 'Cause your friends don't dance and if they don't dance well they're no friends of mine."} <- ivan-doroschuk.json
+{"entityId":"01FY9Z4RSRZFGQ21BMEKYHEVK6","firstName":"Joan","lastName":"Jett","age":63,"verified":false,"location":{"longitude":-75.273,"latitude":40.003},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","guitar","black eyeliner"],"personalStatement":"I love rock n' roll so put another dime in the jukebox, baby."} <- joan-jett.json
+{"entityId":"01FY9Z4RT25ABWYTW6ZG7R79V4","firstName":"Justin","lastName":"Timberlake","age":41,"verified":true,"location":{"longitude":-89.971,"latitude":35.118},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","dancing","half-time shows"],"personalStatement":"What goes around comes all the way back around."} <- justin-timberlake.json
+{"entityId":"01FY9Z4RTD9EKBDS2YN9CRMG1D","firstName":"Kerry","lastName":"Livgren","age":72,"verified":false,"location":{"longitude":-95.689,"latitude":39.056},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["poetry","philosophy","songwriting","guitar"],"personalStatement":"All we are is dust in the wind."} <- kerry-livgren.json
+{"entityId":"01FY9Z4RTR73HZQXK83JP94NWR","firstName":"Marshal","lastName":"Mathers","age":49,"verified":false,"location":{"longitude":-83.046,"latitude":42.331},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["rapping","songwriting","comics"],"personalStatement":"Look, if you had, one shot, or one opportunity to seize everything you ever wanted, in one moment, would you capture it, or just let it slip?"} <- marshal-mathers.json
+{"entityId":"01FY9Z4RV2QHH0Z1GJM5ND15JE","firstName":"Rupert","lastName":"Holmes","age":75,"verified":true,"location":{"longitude":-2.518,"latitude":53.259},"locationUpdated":"2022-01-01T12:00:00.000Z","skills":["singing","songwriting","playwriting"],"personalStatement":"I like piña coladas and taking walks in the rain."} <- rupert-holmes.json
+{{< / highlight >}}
+
+A little messy, but if you don't see this, then it didn't work!
+
+Now that we have some data, let's add another router to hold the search routes we want to add. Create a file named `search-router.js` in the routers folder and set it up with imports and exports just like we did in `person-router.js`:
+
+{{< highlight javascript >}}
+import { Router } from 'express'
+import { personRepository } from '../om/person.js'
+
+export const router = Router()
+{{< / highlight >}}
+
+Import the `Router` into `server.js` the same way we did for the `personRouter`:
+
+{{< highlight javascript >}}
+/* import routers */
+import { router as personRouter } from './routers/person-router.js'
+import { router as searchRouter } from './routers/search-router.js'
+{{< / highlight >}}
+
+Then add the `searchRouter` to the Express app:
+
+{{< highlight javascript >}}
+/* bring in some routers */
+app.use('/person', personRouter)
+app.use('/persons', searchRouter)
+{{< / highlight >}}
+
+Router bound, we can now add some routes.
+
+
+### Search all the things
+
+We're going to add a plethora of searches to our new `Router`. But the first will be the easiest as it's just going to return everything. Go ahead and add the following code to `search-router.js`:
+
+{{< highlight javascript >}}
+router.get('/all', async (req, res) => {
+  const persons = await personRepository.search().return.all()
+  res.send(persons)
+})
+{{< / highlight >}}
+
+Here we see how to start and finish a search. Searches start just like CRUD operations start—on a `Repository`. But instead of calling `.createAndSave()`, `.fetch()`, `.save()`, or `.remove()`, we call `.search()`. And unlike all those other methods, `.search()` doesn't end there. Instead, it allows you to build up a query (which you'll see in the next example) and then resolve it with a call to `.return.all()`.
+
+With this new route in place, go into the Swagger UI and exercise the `/persons/all` route. You should see all of the folks you added with the shell script as a JSON array.
+
+In the example above, the query is not specified—we didn't build anything up. If you do this, you'll just get everything. Which is what you want sometimes. But not most of the time. It's not really searching if you just return everything. So let's add a route that lets us find persons by their last name. Add the following code:
+
+{{< highlight javascript >}}
+router.get('/by-last-name/:lastName', async (req, res) => {
+  const lastName = req.params.lastName
+  const persons = await personRepository.search()
+    .where('lastName').equals(lastName).return.all()
+  res.send(persons)
+})
+{{< / highlight >}}
+
+In this route, we're specifying a field we want to filter on and a value that it needs to equal. The field name in the call to `.where()` is the name of the field specified in our schema. This field was defined as a `string`, which matters because the type of the field determines the methods that are available query it.
+
+In the case of a `string`, there's just `.equals()`, which will query against the value of the entire string. This is aliased as `.eq()`, `.equal()`, and `.equalTo()` for your convenience. You can even add a little more syntactic sugar with calls to `.is` and `.does` that really don't do anything but make your code pretty. Like this:
+
+{{< highlight javascript >}}
+const persons = await personRepository.search().where('lastName').is.equalTo(lastName).return.all()
+const persons = await personRepository.search().where('lastName').does.equal(lastName).return.all()
+{{< / highlight >}}
+
+You can also invert the query with a call to `.not`:
+
+{{< highlight javascript >}}
+const persons = await personRepository.search().where('lastName').is.not.equalTo(lastName).return.all()
+const persons = await personRepository.search().where('lastName').does.not.equal(lastName).return.all()
+{{< / highlight >}}
+
+In all these cases, the call to `.return.all()` executes the query we build between it and the call to `.search()`. We can search on other field types as well. Let's add some routes to search on a `number` and a `boolean` field:
+
+{{< highlight javascript >}}
+router.get('/old-enough-to-drink-in-america', async (req, res) => {
+  const persons = await personRepository.search()
+    .where('age').gte(21).return.all()
+  res.send(persons)
+})
+
+router.get('/non-verified', async (req, res) => {
+  const persons = await personRepository.search()
+    .where('verified').is.not.true().return.all()
+  res.send(persons)
+})
+{{< / highlight >}}
+
+The `number` field is filtering persons by age where the age is great than or equal to 21. Again, there are aliases and syntactic sugar:
+
+{{< highlight javascript >}}
+const persons = await personRepository.search().where('age').is.greaterThanOrEqualTo(21).return.all()
+{{< / highlight >}}
+
+But there are also more ways to query:
+
+{{< highlight javascript >}}
+const persons = await personRepository.search().where('age').eq(21).return.all()
+const persons = await personRepository.search().where('age').gt(21).return.all()
+const persons = await personRepository.search().where('age').gte(21).return.all()
+const persons = await personRepository.search().where('age').lt(21).return.all()
+const persons = await personRepository.search().where('age').lte(21).return.all()
+const persons = await personRepository.search().where('age').between(21, 65).return.all()
+{{< / highlight >}}
+
+The `boolean` field is searching for persons by their verification status. It already has some of our syntactic sugar in it. Note that this query will match a missing value or a false value. That's why I specified `.not.true()`. You can also call `.false()` on boolean fields as well as all the variations of `.equals`.
+
+{{< highlight javascript >}}
+const persons = await personRepository.search().where('verified').true().return.all()
+const persons = await personRepository.search().where('verified').false().return.all()
+const persons = await personRepository.search().where('verified').equals(true).return.all()
+{{< / highlight >}}
+
+> So, we've created a few routes and I haven't told you to test them. Maybe you have anyhow. If so, good for you, you rebel. For the rest of you, why don't you go ahead and test them now with Swagger? And, going forward, just test them when you want. Heck, create some routes of your own using the provided syntax and try those out too. Don't let me tell you how to live your life.
+
+Of course, querying on just one field is never enough. Not a problem, Redis OM can handle `.and()` and `.or()` like in this route:
+
+{{< highlight javascript >}}
+router.get('/verified-drinkers-with-last-name/:lastName', async (req, res) => {
+  const lastName = req.params.lastName
+  const persons = await personRepository.search()
+    .where('verified').is.true()
+      .and('age').gte(21)
+      .and('lastName').equals(lastName).return.all()
+  res.send(persons)
+})
+{{< / highlight >}}
+
+Here, I'm just showing the syntax for `.and()` but, of course, you can also use `.or()`.
+
+
+### Full-text search
+
+If you've defined a field with a type of `text` in your schema, you can perform full-text searches against it. The way a `text` field is searched is different from how a `string` is searched. A `string` can only be compared with `.equals()` and must match the entire string. With a `text` field, you can look for words within the string.
+
+A `text` field is optimized for human-readable text, like an essay or song lyrics. It's pretty clever. It understands that certain words (like *a*, *an*, or *the*) are common and ignores them. It understands how words are grammatically similar and so if you search for *give*, it matches *gives*, *given*, *giving*, and *gave* too. And it ignores punctuation.
+
+Let's add a route that does full-text search against our `personalStatement` field:
+
+{{< highlight javascript >}}
+router.get('/with-statement-containing/:text', async (req, res) => {
+  const text = req.params.text
+  const persons = await personRepository.search()
+    .where('personalStatement').matches(text)
+      .return.all()
+  res.send(persons)
+})
+{{< / highlight >}}
+
+Note the use of the `.matches()` function. This is the only one that works with `text` fields. It takes a string that can be one or more words—space-delimited—that you want to query for. Let's try it out. In Swagger, use this route to search for the word "walk". You should get the following results:
+
+{{< highlight json >}}
+[
+  {
+    "entityId": "01FYC7CTR027F219455PS76247",
+    "firstName": "Rupert",
+    "lastName": "Holmes",
+    "age": 75,
+    "verified": true,
+    "location": {
+      "longitude": -2.518,
+      "latitude": 53.259
+    },
+    "locationUpdated": "2022-01-01T12:00:00.000Z",
+    "skills": [
+      "singing",
+      "songwriting",
+      "playwriting"
+    ],
+    "personalStatement": "I like piña coladas and taking walks in the rain."
+  },
+  {
+    "entityId": "01FYC7CTNBJD9CZKKWPQEZEW14",
+    "firstName": "Chris",
+    "lastName": "Stapleton",
+    "age": 43,
+    "verified": true,
+    "location": {
+      "longitude": -84.495,
+      "latitude": 38.03
+    },
+    "locationUpdated": "2022-01-01T12:00:00.000Z",
+    "skills": [
+      "singing",
+      "football",
+      "coal mining"
+    ],
+    "personalStatement": "There are days that I can walk around like I'm alright. And I pretend to wear a smile on my face. And I could keep the pain from comin' out of my eyes. But sometimes, sometimes, sometimes I cry."
+  }
+]
+{{< / highlight >}}
+
+Notice how the word "walk" is matched for Rupert Holmes' personal statement that contains "walks" *and* matched for Chris Stapleton's that contains "walk". Now search "walk raining". You'll see that this returns Rupert's entry only even though the exact text of neither of these words is found in his personal statement. But they are *grammatically* related so it matched them. This is called stemming and it's a pretty cool feature of Redis Stack that Redis OM exploits.
+
+And if you search for "a rain walk" you'll *still* match Rupert's entry even though the word "a" is not in the text. Why? Because it's a common word that's not very helpful with searching. These common words are called stop words and this is another cool feature of Redis Stack that Redis OM just gets for free.
+
+
+### Searching the globe
+
+Redis Stack, and therefore Redis OM, both support searching by geographic location. You specify a point in the globe, a radius, and the units for that radius and it'll gleefully return all the entities therein. Let's add a route to do just that:
+
+{{< highlight javascript >}}
+router.get('/near/:lng,:lat/radius/:radius', async (req, res) => {
+  const longitude = Number(req.params.lng)
+  const latitude = Number(req.params.lat)
+  const radius = Number(req.params.radius)
+
+  const persons = await personRepository.search()
+    .where('location')
+      .inRadius(circle => circle
+          .longitude(longitude)
+          .latitude(latitude)
+          .radius(radius)
+          .miles)
+        .return.all()
+
+  res.send(persons)
+})
+{{< / highlight >}}
+
+This code looks a little different than the others because the way we define the circle we want to search is done with a function that is passed into the `.inRadius` method:
+
+{{< highlight javascript >}}
+circle => circle.longitude(longitude).latitude(latitude).radius(radius).miles
+{{< / highlight >}}
+
+All this function does is accept an instance of a [`Circle`](https://github.com/redis/redis-om-node/blob/main/docs/classes/Circle.md) that has been initialized with default values. We override those values by calling various builder methods to define the origin of our search (i.e. the longitude and latitude), the radius, and the units that radius is measured in. Valid units are `miles`, `meters`, `feet`, and `kilometers`.
+
+Let's try the route out. I know we can find Joan Jett at around longitude -75.0 and latitude 40.0, which is in eastern Pennsylvania. So use those coordinates with a radius of 20 miles. You should receive in response:
+
+{{< highlight json >}}
+[
+  {
+    "entityId": "01FYC7CTPKYNXQ98JSTBC37AS1",
+    "firstName": "Joan",
+    "lastName": "Jett",
+    "age": 63,
+    "verified": false,
+    "location": {
+      "longitude": -75.273,
+      "latitude": 40.003
+    },
+    "locationUpdated": "2022-01-01T12:00:00.000Z",
+    "skills": [
+      "singing",
+      "guitar",
+      "black eyeliner"
+    ],
+    "personalStatement": "I love rock n' roll so put another dime in the jukebox, baby."
+  }
+]
+{{< / highlight >}}
+
+Try widening the radius and see who else you can find.
+
+
+## Adding location tracking
+
+We're getting toward the end of the tutorial here, but before we go, I'd like to add that location tracking piece that I mentioned way back in the beginning. This next bit of code should be easily understood if you've gotten this far as it's not really doing anything I haven't talked about already.
+
+Add a new file called `location-router.js` in the `routers` folder:
+
+{{< highlight javascript >}}
+import { Router } from 'express'
+import { personRepository } from '../om/person.js'
+
+export const router = Router()
+
+router.patch('/:id/location/:lng,:lat', async (req, res) => {
+
+  const id = req.params.id
+  const longitude = Number(req.params.lng)
+  const latitude = Number(req.params.lat)
+
+  const locationUpdated = new Date()
+
+  const person = await personRepository.fetch(id)
+  person.location = { longitude, latitude }
+  person.locationUpdated = locationUpdated
+  await personRepository.save(person)
+
+  res.send({ id, locationUpdated, location: { longitude, latitude } })
+})
+{{< / highlight >}}
+
+Here we're calling `.fetch()` to fetch a person, we're updating some values for that person—the `.location` property with our longitude and latitude and the `.locationUpdated` property with the current date and time. Easy stuff.
+
+To use this `Router`, import it in `server.js`:
+
+{{< highlight javascript >}}
+/* import routers */
+import { router as personRouter } from './routers/person-router.js'
+import { router as searchRouter } from './routers/search-router.js'
+import { router as locationRouter } from './routers/location-router.js'
+{{< / highlight >}}
+
+And bind the router to a path:
+
+{{< highlight javascript >}}
+/* bring in some routers */
+app.use('/person', personRouter, locationRouter)
+app.use('/persons', searchRouter)
+{{< / highlight >}}
+
+And that's that. But this just isn't enough to satisfy. It doesn't show you anything new, except maybe the usage of a `date` field. And, it's not really location *tracking*. It just shows where these people last were, no history. So let's add some!.
+
+To add some history, we're going to use a [Redis Stream]({{< relref "/develop/data-types/streams" >}}). Streams are a big topic but don't worry if you’re not familiar with them, you can think of them as being sort of like a log file stored in a Redis key where each entry represents an event. In our case, the event would be the person moving about or checking in or whatever.
+
+But there's a problem. Redis OM doesn’t support Streams even though Redis Stack does. So how do we take advantage of them in our application? By using [Node Redis](https://github.com/redis/node-redis). Node Redis is a low-level Redis client for Node.js that gives you access to all the Redis commands and data types. Internally, Redis OM is creating and using a Node Redis connection. You can use that connection too. Or rather, Redis OM can be *told* to use the connection you are using. Let me show you how.
+
+
+## Using Node Redis
+
+Open up `client.js` in the `om` folder. Remember how we created a Redis OM `Client` and then called `.open()` on it?
+
+{{< highlight javascript >}}
+const client = await new Client().open(url)
+{{< / highlight >}}
+
+Well, the `Client` class also has a `.use()` method that takes a Node Redis connection. Modify `client.js` to open a connection to Redis using Node Redis and then `.use()` it:
+
+{{< highlight javascript >}}
+import { Client } from 'redis-om'
+import { createClient } from 'redis'
+
+/* pulls the Redis URL from .env */
+const url = process.env.REDIS_URL
+
+/* create a connection to Redis with Node Redis */
+export const connection = createClient({ url })
+await connection.connect()
+
+/* create a Client and bind it to the Node Redis connection */
+const client = await new Client().use(connection)
+
+export default client
+{{< / highlight >}}
+
+And that's it. Redis OM is now using the `connection` you created. Note that we are exporting both the `client` *and* the `connection`. Got to export the `connection` if we want to use it in our newest route.
+
+
+## Storing location history with Streams
+
+To add an event to a Stream we need to use the [XADD]({{< relref "/commands/xadd" >}}) command. Node Redis exposes that as `.xAdd()`. So, we need to add a call to `.xAdd()` in our route. Modify `location-router.js` to import our `connection`:
+
+{{< highlight javascript >}}
+import { connection } from '../om/client.js'
+{{< / highlight >}}
+
+And then in the route itself add a call to `.xAdd()`:
+
+{{< highlight javascript >}}
+  ...snip...
+  const person = await personRepository.fetch(id)
+  person.location = { longitude, latitude }
+  person.locationUpdated = locationUpdated
+  await personRepository.save(person)
+
+  let keyName = `${person.keyName}:locationHistory`
+  await connection.xAdd(keyName, '*', person.location)
+  ...snip...
+{{< / highlight >}}
+
+`.xAdd()` takes a key name, an event ID, and a JavaScript object containing the keys and values that make up the event, i.e. the event data. For the key name, we're building a string using the `.keyName` property that `Person` inherited from `Entity` (which will return something like `Person:01FYC7CTPKYNXQ98JSTBC37AS1`) combined with a hard-coded value. We're passing in `*` for our event ID, which tells Redis to just generate it based on the current time and previous event ID. And we're passing in the location—with properties of longitude and latitude—as our event data.
+
+Now, whenever this route is exercised, the longitude and latitude will be logged and the event ID will encode the time. Go ahead and use Swagger to move Joan Jett around a few times.
+
+Now, go into Redis Insight and take a look at the Stream. You'll see it there in the list of keys but if you click on it, you'll get a message saying that "This data type is coming soon!". If you don't get this message, congratulations, you live in the future! For us here in the past, we'll just issue the raw command instead:
+
+    XRANGE Person:01FYC7CTPKYNXQ98JSTBC37AS1:locationHistory - +
+
+This tells Redis to get a range of values from a Stream stored in the given the key name—`Person:01FYC7CTPKYNXQ98JSTBC37AS1:locationHistory` in our example. The next values are the starting event ID and the ending event ID. `-` is the beginning of the Stream. `+` is the end. So this returns everything in the Stream:
+
+    1) 1) "1647536562911-0"
+      2) 1) "longitude"
+          2) "45.678"
+          3) "latitude"
+          4) "45.678"
+    2) 1) "1647536564189-0"
+      2) 1) "longitude"
+          2) "45.679"
+          3) "latitude"
+          4) "45.679"
+    3) 1) "1647536565278-0"
+      2) 1) "longitude"
+          2) "45.680"
+          3) "latitude"
+          4) "45.680"
+
+And just like that, we're tracking Joan Jett.
+
+
+## Wrap-up
+
+So, now you know how to use Express + Redis OM to build an API backed by Redis Stack. And, you've got yourself some pretty decent started code in the process. Good deal! If you want to learn more, you can check out the [documentation](https://github.com/redis/redis-om-node) for Redis OM. It covers the full breadth of Redis OM's features.
+
+And thanks for taking the time to work through this. I sincerely hope you found it useful. If you have any questions, the [Redis Discord server](https://discord.gg/redis) is by far the best place to get them answered. Join the server and ask away!
+---
+linkTitle: Vectorizers
+title: Vectorizers
+type: integration
+weight: 04
+---
+
+
+In this notebook, we will show how to use RedisVL to create embeddings using the built-in text embedding vectorizers. Today RedisVL supports:
+1. OpenAI
+2. HuggingFace
+3. Vertex AI
+4. Cohere
+5. Mistral AI
+6. Amazon Bedrock
+7. Bringing your own vectorizer
+8. VoyageAI
+
+Before running this notebook, be sure to
+1. Have installed ``redisvl`` and have that environment active for this notebook.
+2. Have a running Redis Stack instance with RediSearch > 2.4 active.
+
+For example, you can run Redis Stack locally with Docker:
+
+```bash
+docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+This will run Redis on port 6379 and RedisInsight at http://localhost:8001.
+
+
+```python
+# import necessary modules
+import os
+```
+
+## Creating Text Embeddings
+
+This example will show how to create an embedding from 3 simple sentences with a number of different text vectorizers in RedisVL.
+
+- "That is a happy dog"
+- "That is a happy person"
+- "Today is a nice day"
+
+
+### OpenAI
+
+The ``OpenAITextVectorizer`` makes it simple to use RedisVL with the embeddings models at OpenAI. For this you will need to install ``openai``. 
+
+```bash
+pip install openai
+```
+
+
+
+```python
+import getpass
+
+# setup the API Key
+api_key = os.environ.get("OPENAI_API_KEY") or getpass.getpass("Enter your OpenAI API key: ")
+```
+
+
+```python
+from redisvl.utils.vectorize import OpenAITextVectorizer
+
+# create a vectorizer
+oai = OpenAITextVectorizer(
+    model="text-embedding-ada-002",
+    api_config={"api_key": api_key},
+)
+
+test = oai.embed("This is a test sentence.")
+print("Vector dimensions: ", len(test))
+test[:10]
+```
+
+    Vector dimensions:  1536
+
+
+
+
+
+    [-0.0011391325388103724,
+     -0.003206387162208557,
+     0.002380132209509611,
+     -0.004501554183661938,
+     -0.010328996926546097,
+     0.012922565452754498,
+     -0.005491119809448719,
+     -0.0029864837415516376,
+     -0.007327961269766092,
+     -0.03365817293524742]
+
+
+
+
+```python
+# Create many embeddings at once
+sentences = [
+    "That is a happy dog",
+    "That is a happy person",
+    "Today is a sunny day"
+]
+
+embeddings = oai.embed_many(sentences)
+embeddings[0][:10]
+```
+
+
+
+
+    [-0.017466850578784943,
+     1.8471690054866485e-05,
+     0.00129731057677418,
+     -0.02555876597762108,
+     -0.019842341542243958,
+     0.01603139191865921,
+     -0.0037347301840782166,
+     0.0009670283179730177,
+     0.006618348415941,
+     -0.02497442066669464]
+
+
+
+
+```python
+# openai also supports asyncronous requests, which we can use to speed up the vectorization process.
+embeddings = await oai.aembed_many(sentences)
+print("Number of Embeddings:", len(embeddings))
+
+```
+
+    Number of Embeddings: 3
+
+
+### Azure OpenAI
+
+The ``AzureOpenAITextVectorizer`` is a variation of the OpenAI vectorizer that calls OpenAI models within Azure. If you've already installed ``openai``, then you're ready to use Azure OpenAI.
+
+The only practical difference between OpenAI and Azure OpenAI is the variables required to call the API.
+
+
+```python
+# additionally to the API Key, setup the API endpoint and version
+api_key = os.environ.get("AZURE_OPENAI_API_KEY") or getpass.getpass("Enter your AzureOpenAI API key: ")
+api_version = os.environ.get("OPENAI_API_VERSION") or getpass.getpass("Enter your AzureOpenAI API version: ")
+azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT") or getpass.getpass("Enter your AzureOpenAI API endpoint: ")
+deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT_NAME", "text-embedding-ada-002")
+
+```
+
+
+```python
+from redisvl.utils.vectorize import AzureOpenAITextVectorizer
+
+# create a vectorizer
+az_oai = AzureOpenAITextVectorizer(
+    model=deployment_name, # Must be your CUSTOM deployment name
+    api_config={
+        "api_key": api_key,
+        "api_version": api_version,
+        "azure_endpoint": azure_endpoint
+    },
+)
+
+test = az_oai.embed("This is a test sentence.")
+print("Vector dimensions: ", len(test))
+test[:10]
+```
+
+
+    ---------------------------------------------------------------------------
+
+    ValueError                                Traceback (most recent call last)
+
+    Cell In[7], line 4
+          1 from redisvl.utils.vectorize import AzureOpenAITextVectorizer
+          3 # create a vectorizer
+    ----> 4 az_oai = AzureOpenAITextVectorizer(
+          5     model=deployment_name, # Must be your CUSTOM deployment name
+          6     api_config={
+          7         "api_key": api_key,
+          8         "api_version": api_version,
+          9         "azure_endpoint": azure_endpoint
+         10     },
+         11 )
+         13 test = az_oai.embed("This is a test sentence.")
+         14 print("Vector dimensions: ", len(test))
+
+
+    File ~/src/redis-vl-python/redisvl/utils/vectorize/text/azureopenai.py:78, in AzureOpenAITextVectorizer.__init__(self, model, api_config, dtype)
+         54 def __init__(
+         55     self,
+         56     model: str = "text-embedding-ada-002",
+         57     api_config: Optional[Dict] = None,
+         58     dtype: str = "float32",
+         59 ):
+         60     """Initialize the AzureOpenAI vectorizer.
+         61 
+         62     Args:
+       (...)
+         76         ValueError: If an invalid dtype is provided.
+         77     """
+    ---> 78     self._initialize_clients(api_config)
+         79     super().__init__(model=model, dims=self._set_model_dims(model), dtype=dtype)
+
+
+    File ~/src/redis-vl-python/redisvl/utils/vectorize/text/azureopenai.py:106, in AzureOpenAITextVectorizer._initialize_clients(self, api_config)
+         99 azure_endpoint = (
+        100     api_config.pop("azure_endpoint")
+        101     if api_config
+        102     else os.getenv("AZURE_OPENAI_ENDPOINT")
+        103 )
+        105 if not azure_endpoint:
+    --> 106     raise ValueError(
+        107         "AzureOpenAI API endpoint is required. "
+        108         "Provide it in api_config or set the AZURE_OPENAI_ENDPOINT\
+        109             environment variable."
+        110     )
+        112 api_version = (
+        113     api_config.pop("api_version")
+        114     if api_config
+        115     else os.getenv("OPENAI_API_VERSION")
+        116 )
+        118 if not api_version:
+
+
+    ValueError: AzureOpenAI API endpoint is required. Provide it in api_config or set the AZURE_OPENAI_ENDPOINT                    environment variable.
+
+
+
+```python
+# Just like OpenAI, AzureOpenAI supports batching embeddings and asynchronous requests.
+sentences = [
+    "That is a happy dog",
+    "That is a happy person",
+    "Today is a sunny day"
+]
+
+embeddings = await az_oai.aembed_many(sentences)
+embeddings[0][:10]
+```
+
+### Huggingface
+
+[Huggingface](https://huggingface.co/models) is a popular NLP platform that has a number of pre-trained models you can use off the shelf. RedisVL supports using Huggingface "Sentence Transformers" to create embeddings from text. To use Huggingface, you will need to install the ``sentence-transformers`` library.
+
+```bash
+pip install sentence-transformers
+```
+
+
+```python
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+from redisvl.utils.vectorize import HFTextVectorizer
+
+
+# create a vectorizer
+# choose your model from the huggingface website
+hf = HFTextVectorizer(model="sentence-transformers/all-mpnet-base-v2")
+
+# embed a sentence
+test = hf.embed("This is a test sentence.")
+test[:10]
+```
+
+
+```python
+# You can also create many embeddings at once
+embeddings = hf.embed_many(sentences, as_buffer=True)
+
+```
+
+### VertexAI
+
+[VertexAI](https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings) is GCP's fully-featured AI platform including a number of pretrained LLMs. RedisVL supports using VertexAI to create embeddings from these models. To use VertexAI, you will first need to install the ``google-cloud-aiplatform`` library.
+
+```bash
+pip install google-cloud-aiplatform>=1.26
+```
+
+1. Then you need to gain access to a [Google Cloud Project](https://cloud.google.com/gcp?hl=en) and provide [access to credentials](https://cloud.google.com/docs/authentication/application-default-credentials). This is accomplished by setting the `GOOGLE_APPLICATION_CREDENTIALS` environment variable pointing to the path of a JSON key file downloaded from your service account on GCP.
+2. Lastly, you need to find your [project ID](https://support.google.com/googleapi/answer/7014113?hl=en) and [geographic region for VertexAI](https://cloud.google.com/vertex-ai/docs/general/locations).
+
+
+**Make sure the following env vars are set:**
+
+```
+GOOGLE_APPLICATION_CREDENTIALS=<path to your gcp JSON creds>
+GCP_PROJECT_ID=<your gcp project id>
+GCP_LOCATION=<your gcp geo region for vertex ai>
+```
+
+
+```python
+from redisvl.utils.vectorize import VertexAITextVectorizer
+
+
+# create a vectorizer
+vtx = VertexAITextVectorizer(api_config={
+    "project_id": os.environ.get("GCP_PROJECT_ID") or getpass.getpass("Enter your GCP Project ID: "),
+    "location": os.environ.get("GCP_LOCATION") or getpass.getpass("Enter your GCP Location: "),
+    "google_application_credentials": os.environ.get("GOOGLE_APPLICATION_CREDENTIALS") or getpass.getpass("Enter your Google App Credentials path: ")
+})
+
+# embed a sentence
+test = vtx.embed("This is a test sentence.")
+test[:10]
+```
+
+### Cohere
+
+[Cohere](https://dashboard.cohere.ai/) allows you to implement language AI into your product. The `CohereTextVectorizer` makes it simple to use RedisVL with the embeddings models at Cohere. For this you will need to install `cohere`.
+
+```bash
+pip install cohere
+```
+
+
+```python
+import getpass
+# setup the API Key
+api_key = os.environ.get("COHERE_API_KEY") or getpass.getpass("Enter your Cohere API key: ")
+```
+
+
+Special attention needs to be paid to the `input_type` parameter for each `embed` call. For example, for embedding 
+queries, you should set `input_type='search_query'`; for embedding documents, set `input_type='search_document'`. See
+more information [here](https://docs.cohere.com/reference/embed)
+
+
+```python
+from redisvl.utils.vectorize import CohereTextVectorizer
+
+# create a vectorizer
+co = CohereTextVectorizer(
+    model="embed-english-v3.0",
+    api_config={"api_key": api_key},
+)
+
+# embed a search query
+test = co.embed("This is a test sentence.", input_type='search_query')
+print("Vector dimensions: ", len(test))
+print(test[:10])
+
+# embed a document
+test = co.embed("This is a test sentence.", input_type='search_document')
+print("Vector dimensions: ", len(test))
+print(test[:10])
+```
+
+Learn more about using RedisVL and Cohere together through [this dedicated user guide](https://docs.cohere.com/docs/redis-and-cohere).
+
+### VoyageAI
+
+[VoyageAI](https://dash.voyageai.com/) allows you to implement language AI into your product. The `VoyageAITextVectorizer` makes it simple to use RedisVL with the embeddings models at VoyageAI. For this you will need to install `voyageai`.
+
+```bash
+pip install voyageai
+```
+
+
+```python
+import getpass
+# setup the API Key
+api_key = os.environ.get("VOYAGE_API_KEY") or getpass.getpass("Enter your VoyageAI API key: ")
+```
+
+
+Special attention needs to be paid to the `input_type` parameter for each `embed` call. For example, for embedding 
+queries, you should set `input_type='query'`; for embedding documents, set `input_type='document'`. See
+more information [here](https://docs.voyageai.com/docs/embeddings)
+
+
+```python
+from redisvl.utils.vectorize import VoyageAITextVectorizer
+
+# create a vectorizer
+vo = VoyageAITextVectorizer(
+    model="voyage-law-2",  # Please check the available models at https://docs.voyageai.com/docs/embeddings
+    api_config={"api_key": api_key},
+)
+
+# embed a search query
+test = vo.embed("This is a test sentence.", input_type='query')
+print("Vector dimensions: ", len(test))
+print(test[:10])
+
+# embed a document
+test = vo.embed("This is a test sentence.", input_type='document')
+print("Vector dimensions: ", len(test))
+print(test[:10])
+```
+
+### Mistral AI
+
+[Mistral](https://console.mistral.ai/) offers LLM and embedding APIs for you to implement into your product. The `MistralAITextVectorizer` makes it simple to use RedisVL with their embeddings model.
+You will need to install `mistralai`.
+
+```bash
+pip install mistralai
+```
+
+
+```python
+from redisvl.utils.vectorize import MistralAITextVectorizer
+
+mistral = MistralAITextVectorizer()
+
+# embed a sentence using their asyncronous method
+test = await mistral.aembed("This is a test sentence.")
+print("Vector dimensions: ", len(test))
+print(test[:10])
+```
+
+### Amazon Bedrock
+
+Amazon Bedrock provides fully managed foundation models for text embeddings. Install the required dependencies:
+
+```bash
+pip install 'redisvl[bedrock]'  # Installs boto3
+```
+
+#### Configure AWS credentials:
+
+
+```python
+import os
+import getpass
+
+if "AWS_ACCESS_KEY_ID" not in os.environ:
+    os.environ["AWS_ACCESS_KEY_ID"] = getpass.getpass("Enter AWS Access Key ID: ")
+if "AWS_SECRET_ACCESS_KEY" not in os.environ:
+    os.environ["AWS_SECRET_ACCESS_KEY"] = getpass.getpass("Enter AWS Secret Key: ")
+
+os.environ["AWS_REGION"] = "us-east-1"  # Change as needed
+```
+
+#### Create embeddings:
+
+
+```python
+from redisvl.utils.vectorize import BedrockTextVectorizer
+
+bedrock = BedrockTextVectorizer(
+    model="amazon.titan-embed-text-v2:0"
+)
+
+# Single embedding
+text = "This is a test sentence."
+embedding = bedrock.embed(text)
+print(f"Vector dimensions: {len(embedding)}")
+
+# Multiple embeddings
+sentences = [
+    "That is a happy dog",
+    "That is a happy person",
+    "Today is a sunny day"
+]
+embeddings = bedrock.embed_many(sentences)
+```
+
+### Custom Vectorizers
+
+RedisVL supports the use of other vectorizers and provides a class to enable compatibility with any function that generates a vector or vectors from string data
+
+
+```python
+from redisvl.utils.vectorize import CustomTextVectorizer
+
+def generate_embeddings(text_input, **kwargs):
+    return [0.101] * 768
+
+custom_vectorizer = CustomTextVectorizer(generate_embeddings)
+
+custom_vectorizer.embed("This is a test sentence.")[:10]
+```
+
+This enables the use of custom vectorizers with other RedisVL components
+
+
+```python
+from redisvl.extensions.cache.llm import SemanticCache
+
+cache = SemanticCache(name="custom_cache", vectorizer=custom_vectorizer)
+
+cache.store("this is a test prompt", "this is a test response")
+cache.check("this is also a test prompt")
+```
+
+## Search with Provider Embeddings
+
+Now that we've created our embeddings, we can use them to search for similar sentences. We will use the same 3 sentences from above and search for similar sentences.
+
+First, we need to create the schema for our index.
+
+Here's what the schema for the example looks like in yaml for the HuggingFace vectorizer:
+
+```yaml
+version: '0.1.0'
+
+index:
+    name: vectorizers
+    prefix: doc
+    storage_type: hash
+
+fields:
+    - name: sentence
+      type: text
+    - name: embedding
+      type: vector
+      attrs:
+        dims: 768
+        algorithm: flat
+        distance_metric: cosine
+```
+
+
+```python
+from redisvl.index import SearchIndex
+
+# construct a search index from the schema
+index = SearchIndex.from_yaml("./schema.yaml", redis_url="redis://localhost:6379")
+
+# create the index (no data yet)
+index.create(overwrite=True)
+```
+
+
+```python
+# use the CLI to see the created index
+!rvl index listall
+```
+
+Loading data to RedisVL is easy. It expects a list of dictionaries. The vector is stored as bytes.
+
+
+```python
+from redisvl.redis.utils import array_to_buffer
+
+embeddings = hf.embed_many(sentences)
+
+data = [{"text": t,
+         "embedding": array_to_buffer(v, dtype="float32")}
+        for t, v in zip(sentences, embeddings)]
+
+index.load(data)
+```
+
+
+```python
+from redisvl.query import VectorQuery
+
+# use the HuggingFace vectorizer again to create a query embedding
+query_embedding = hf.embed("That is a happy cat")
+
+query = VectorQuery(
+    vector=query_embedding,
+    vector_field_name="embedding",
+    return_fields=["text"],
+    num_results=3
+)
+
+results = index.query(query)
+for doc in results:
+    print(doc["text"], doc["vector_distance"])
+```
+
+## Selecting your float data type
+When embedding text as byte arrays RedisVL supports 4 different floating point data types, `float16`, `float32`, `float64` and `bfloat16`, and 2 integer types, `int8` and `uint8`.
+Your dtype set for your vectorizer must match what is defined in your search index. If one is not explicitly set the default is `float32`.
+
+
+```python
+vectorizer = HFTextVectorizer(dtype="float16")
+
+# subsequent calls to embed('', as_buffer=True) and embed_many('', as_buffer=True) will now encode as float16
+float16_bytes = vectorizer.embed('test sentence', as_buffer=True)
+
+# to generate embeddings with different dtype instantiate a new vectorizer
+vectorizer_64 = HFTextVectorizer(dtype='float64')
+float64_bytes = vectorizer_64.embed('test sentence', as_buffer=True)
+
+float16_bytes != float64_bytes
+```
+
+
+```python
+# cleanup
+index.delete()
+```
+---
+linkTitle: Semantic routing
+title: Semantic Routing
+type: integration
+weight: 08
+---
+
+
+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.
+
+Each route has a set of references that cover the "semantic surface area" of the
+route. The incoming query from a user needs to be semantically similar to one or
+more of the references in order to "match" on the route.
+
+Additionally, each route has a `distance_threshold` which determines the maximum distance between the query and the reference for the query to be routed to the route. This value is unique to each route.
+
+
+```python
+from redisvl.extensions.router import Route
+
+
+# Define routes for the semantic router
+technology = Route(
+    name="technology",
+    references=[
+        "what are the latest advancements in AI?",
+        "tell me about the newest gadgets",
+        "what's trending in tech?"
+    ],
+    metadata={"category": "tech", "priority": 1},
+    distance_threshold=0.71
+)
+
+sports = Route(
+    name="sports",
+    references=[
+        "who won the game last night?",
+        "tell me about the upcoming sports events",
+        "what's the latest in the world of sports?",
+        "sports",
+        "basketball and football"
+    ],
+    metadata={"category": "sports", "priority": 2},
+    distance_threshold=0.72
+)
+
+entertainment = Route(
+    name="entertainment",
+    references=[
+        "what are the top movies right now?",
+        "who won the best actor award?",
+        "what's new in the entertainment industry?"
+    ],
+    metadata={"category": "entertainment", "priority": 3},
+    distance_threshold=0.7
+)
+
+```
+
+## Initialize the SemanticRouter
+
+``SemanticRouter`` will automatically create an index within Redis upon initialization for the route references. By default, it uses the `HFTextVectorizer` to 
+generate embeddings for each route reference.
+
+
+```python
+import os
+from redisvl.extensions.router import SemanticRouter
+from redisvl.utils.vectorize import HFTextVectorizer
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Initialize the SemanticRouter
+router = SemanticRouter(
+    name="topic-router",
+    vectorizer=HFTextVectorizer(),
+    routes=[technology, sports, entertainment],
+    redis_url="redis://localhost:6379",
+    overwrite=True # Blow away any other routing index with this name
+)
+```
+
+    19:18:32 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:18:32 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 17.78it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 37.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 48.76it/s]
+
+
+
+```python
+# look at the index specification created for the semantic router
+!rvl index info -i topic-router
+```
+
+    
+    
+    Index Information:
+    ╭──────────────────┬──────────────────┬──────────────────┬──────────────────┬──────────────────╮
+    │ Index Name       │ Storage Type     │ Prefixes         │ Index Options    │ Indexing         │
+    ├──────────────────┼──────────────────┼──────────────────┼──────────────────┼──────────────────┤
+    | topic-router     | HASH             | ['topic-router'] | []               | 0                |
+    ╰──────────────────┴──────────────────┴──────────────────┴──────────────────┴──────────────────╯
+    Index Fields:
+    ╭─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────╮
+    │ Name            │ Attribute       │ Type            │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │
+    ├─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┤
+    │ reference_id    │ reference_id    │ TAG             │ SEPARATOR       │ ,               │                 │                 │                 │                 │                 │                 │
+    │ route_name      │ route_name      │ TAG             │ SEPARATOR       │ ,               │                 │                 │                 │                 │                 │                 │
+    │ reference       │ reference       │ TEXT            │ WEIGHT          │ 1               │                 │                 │                 │                 │                 │                 │
+    │ vector          │ vector          │ VECTOR          │ algorithm       │ FLAT            │ data_type       │ FLOAT32         │ dim             │ 768             │ distance_metric │ COSINE          │
+    ╰─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────╯
+
+
+
+```python
+router._index.info()["num_docs"]
+```
+
+
+
+
+    11
+
+
+
+## Simple routing
+
+
+```python
+# Query the router with a statement
+route_match = router("Can you tell me about the latest in artificial intelligence?")
+route_match
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  6.40it/s]
+
+
+
+
+
+    RouteMatch(name='technology', distance=0.419145842393)
+
+
+
+
+```python
+# Query the router with a statement and return a miss
+route_match = router("are aliens real?")
+route_match
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 39.83it/s]
+
+
+
+
+
+    RouteMatch(name=None, distance=None)
+
+
+
+We can also route a statement to many routes and order them by distance:
+
+
+```python
+# Perform multi-class classification with route_many() -- toggle the max_k and the distance_threshold
+route_matches = router.route_many("How is AI used in basketball?", max_k=3)
+route_matches
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 40.50it/s]
+
+
+
+
+
+    [RouteMatch(name='technology', distance=0.556493878365),
+     RouteMatch(name='sports', distance=0.671060125033)]
+
+
+
+
+```python
+# Toggle the aggregation method -- note the different distances in the result
+from redisvl.extensions.router.schema import DistanceAggregationMethod
+
+route_matches = router.route_many("How is AI used in basketball?", aggregation_method=DistanceAggregationMethod.min, max_k=3)
+route_matches
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.18it/s]
+
+
+
+
+
+    [RouteMatch(name='technology', distance=0.556493878365),
+     RouteMatch(name='sports', distance=0.629264354706)]
+
+
+
+Note the different route match distances. This is because we used the `min` aggregation method instead of the default `avg` approach.
+
+## Update the routing config
+
+
+```python
+from redisvl.extensions.router import RoutingConfig
+
+router.update_routing_config(
+    RoutingConfig(aggregation_method=DistanceAggregationMethod.min, max_k=3)
+)
+```
+
+
+```python
+route_matches = router.route_many("Lebron James")
+route_matches
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 41.89it/s]
+
+
+
+
+
+    [RouteMatch(name='sports', distance=0.663254022598)]
+
+
+
+## Router serialization
+
+
+```python
+router.to_dict()
+```
+
+
+
+
+    {'name': 'topic-router',
+     'routes': [{'name': 'technology',
+       'references': ['what are the latest advancements in AI?',
+        'tell me about the newest gadgets',
+        "what's trending in tech?"],
+       'metadata': {'category': 'tech', 'priority': 1},
+       'distance_threshold': 0.71},
+      {'name': 'sports',
+       'references': ['who won the game last night?',
+        'tell me about the upcoming sports events',
+        "what's the latest in the world of sports?",
+        'sports',
+        'basketball and football'],
+       'metadata': {'category': 'sports', 'priority': 2},
+       'distance_threshold': 0.72},
+      {'name': 'entertainment',
+       'references': ['what are the top movies right now?',
+        'who won the best actor award?',
+        "what's new in the entertainment industry?"],
+       'metadata': {'category': 'entertainment', 'priority': 3},
+       'distance_threshold': 0.7}],
+     'vectorizer': {'type': 'hf',
+      'model': 'sentence-transformers/all-mpnet-base-v2'},
+     'routing_config': {'max_k': 3, 'aggregation_method': 'min'}}
+
+
+
+
+```python
+router2 = SemanticRouter.from_dict(router.to_dict(), redis_url="redis://localhost:6379")
+
+assert router2.to_dict() == router.to_dict()
+```
+
+    19:18:38 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:18:38 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 54.94it/s]
+
+    19:18:40 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+    
+
+
+
+```python
+router.to_yaml("router.yaml", overwrite=True)
+```
+
+
+```python
+router3 = SemanticRouter.from_yaml("router.yaml", redis_url="redis://localhost:6379")
+
+assert router3.to_dict() == router2.to_dict() == router.to_dict()
+```
+
+    19:18:40 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:18:40 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 18.77it/s]
+
+    19:18:41 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+    
+
+
+# Add route references
+
+
+```python
+router.add_route_references(route_name="technology", references=["latest AI trends", "new tech gadgets"])
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 13.22it/s]
+
+
+
+
+
+    ['topic-router:technology:f243fb2d073774e81c7815247cb3013794e6225df3cbe3769cee8c6cefaca777',
+     'topic-router:technology:7e4bca5853c1c3298b4d001de13c3c7a79a6e0f134f81acc2e7cddbd6845961f']
+
+
+
+# Get route references
+
+
+```python
+# by route name
+refs = router.get_route_references(route_name="technology")
+refs
+```
+
+
+
+
+    [{'id': 'topic-router:technology:7e4bca5853c1c3298b4d001de13c3c7a79a6e0f134f81acc2e7cddbd6845961f',
+      'reference_id': '7e4bca5853c1c3298b4d001de13c3c7a79a6e0f134f81acc2e7cddbd6845961f',
+      'route_name': 'technology',
+      'reference': 'new tech gadgets'},
+     {'id': 'topic-router:technology:f243fb2d073774e81c7815247cb3013794e6225df3cbe3769cee8c6cefaca777',
+      'reference_id': 'f243fb2d073774e81c7815247cb3013794e6225df3cbe3769cee8c6cefaca777',
+      'route_name': 'technology',
+      'reference': 'latest AI trends'},
+     {'id': 'topic-router:technology:851f51cce5a9ccfbbcb66993908be6b7871479af3e3a4b139ad292a1bf7e0676',
+      'reference_id': '851f51cce5a9ccfbbcb66993908be6b7871479af3e3a4b139ad292a1bf7e0676',
+      'route_name': 'technology',
+      'reference': 'what are the latest advancements in AI?'},
+     {'id': 'topic-router:technology:149a9c9919c58534aa0f369e85ad95ba7f00aa0513e0f81e2aff2ea4a717b0e0',
+      'reference_id': '149a9c9919c58534aa0f369e85ad95ba7f00aa0513e0f81e2aff2ea4a717b0e0',
+      'route_name': 'technology',
+      'reference': "what's trending in tech?"},
+     {'id': 'topic-router:technology:85cc73a1437df27caa2f075a29c497e5a2e532023fbb75378aedbae80779ab37',
+      'reference_id': '85cc73a1437df27caa2f075a29c497e5a2e532023fbb75378aedbae80779ab37',
+      'route_name': 'technology',
+      'reference': 'tell me about the newest gadgets'}]
+
+
+
+
+```python
+# by reference id
+refs = router.get_route_references(reference_ids=[refs[0]["reference_id"]])
+refs
+```
+
+
+
+
+    [{'id': 'topic-router:technology:7e4bca5853c1c3298b4d001de13c3c7a79a6e0f134f81acc2e7cddbd6845961f',
+      'reference_id': '7e4bca5853c1c3298b4d001de13c3c7a79a6e0f134f81acc2e7cddbd6845961f',
+      'route_name': 'technology',
+      'reference': 'new tech gadgets'}]
+
+
+
+# Delete route references
+
+
+```python
+# by route name
+deleted_count = router.delete_route_references(route_name="sports")
+deleted_count
+```
+
+
+
+
+    5
+
+
+
+
+```python
+# by id
+deleted_count = router.delete_route_references(reference_ids=[refs[0]["reference_id"]])
+deleted_count
+```
+
+
+
+
+    1
+
+
+
+## Clean up the router
+
+
+```python
+# Use clear to flush all routes from the index
+router.clear()
+```
+
+
+```python
+# Use delete to clear the index and remove it completely
+router.delete()
+```
+---
+linkTitle: Hash vs JSON storage
+title: Hash vs JSON Storage
+type: integration
+weight: 05
+---
+
+
+
+Out of the box, Redis provides a [variety of data structures](https://redis.com/redis-enterprise/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](https://redis.io/docs/data-types/hashes/) and [JSON](https://redis.io/docs/data-types/json/) data.
+
+
+Before running this notebook, be sure to
+1. Have installed ``redisvl`` and have that environment active for this notebook.
+2. Have a running Redis Stack or Redis Enterprise instance with RediSearch > 2.4 activated.
+
+For example, you can run [Redis Stack](https://redis.io/docs/install/install-stack/) locally with Docker:
+
+```bash
+docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+Or create a [FREE Redis Cloud](https://redis.io/cloud).
+
+
+```python
+# import necessary modules
+import pickle
+
+from redisvl.redis.utils import buffer_to_array
+from redisvl.index import SearchIndex
+
+
+# load in the example data and printing utils
+data = pickle.load(open("hybrid_example_data.pkl", "rb"))
+```
+
+
+```python
+from jupyterutils import result_print, table_print
+
+table_print(data)
+```
+
+
+<table><tr><th>user</th><th>age</th><th>job</th><th>credit_score</th><th>office_location</th><th>user_embedding</th></tr><tr><td>john</td><td>18</td><td>engineer</td><td>high</td><td>-122.4194,37.7749</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'</td></tr><tr><td>derrick</td><td>14</td><td>doctor</td><td>low</td><td>-122.4194,37.7749</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'</td></tr><tr><td>nancy</td><td>94</td><td>doctor</td><td>high</td><td>-122.4194,37.7749</td><td>b'333?\xcd\xcc\xcc=\x00\x00\x00?'</td></tr><tr><td>tyler</td><td>100</td><td>engineer</td><td>high</td><td>-122.0839,37.3861</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc>\x00\x00\x00?'</td></tr><tr><td>tim</td><td>12</td><td>dermatologist</td><td>high</td><td>-122.0839,37.3861</td><td>b'\xcd\xcc\xcc>\xcd\xcc\xcc>\x00\x00\x00?'</td></tr><tr><td>taimur</td><td>15</td><td>CEO</td><td>low</td><td>-122.0839,37.3861</td><td>b'\x9a\x99\x19?\xcd\xcc\xcc=\x00\x00\x00?'</td></tr><tr><td>joe</td><td>35</td><td>dentist</td><td>medium</td><td>-122.0839,37.3861</td><td>b'fff?fff?\xcd\xcc\xcc='</td></tr></table>
+
+
+## Hash or JSON -- how to choose?
+Both storage options offer a variety of features and tradeoffs. Below we will work through a dummy dataset to learn when and how to use both.
+
+### Working with Hashes
+Hashes in Redis are simple collections of field-value pairs. Think of it like a mutable single-level dictionary contains multiple "rows":
+
+
+```python
+{
+    "model": "Deimos",
+    "brand": "Ergonom",
+    "type": "Enduro bikes",
+    "price": 4972,
+}
+```
+
+Hashes are best suited for use cases with the following characteristics:
+- Performance (speed) and storage space (memory consumption) are top concerns
+- Data can be easily normalized and modeled as a single-level dict
+
+Hashes are typically the default recommendation.
+
+
+```python
+# define the hash index schema
+hash_schema = {
+    "index": {
+        "name": "user-hash",
+        "prefix": "user-hash-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": "office_location", "type": "geo"},
+        {
+            "name": "user_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": 3,
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+
+        }
+    ],
+}
+```
+
+
+```python
+# construct a search index from the hash schema
+hindex = SearchIndex.from_dict(hash_schema, redis_url="redis://localhost:6379")
+
+# create the index (no data yet)
+hindex.create(overwrite=True)
+```
+
+
+```python
+# show the underlying storage type
+hindex.storage_type
+```
+
+
+
+
+    <StorageType.HASH: 'hash'>
+
+
+
+#### Vectors as byte strings
+One nuance when working with Hashes in Redis, is that all vectorized data must be passed as a byte string (for efficient storage, indexing, and processing). An example of that can be seen below:
+
+
+```python
+# show a single entry from the data that will be loaded
+data[0]
+```
+
+
+
+
+    {'user': 'john',
+     'age': 18,
+     'job': 'engineer',
+     'credit_score': 'high',
+     'office_location': '-122.4194,37.7749',
+     'user_embedding': b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'}
+
+
+
+
+```python
+# load hash data
+keys = hindex.load(data)
+```
+
+
+```python
+!rvl stats -i user-hash
+```
+
+    
+    Statistics:
+    ╭─────────────────────────────┬─────────────╮
+    │ Stat Key                    │ Value       │
+    ├─────────────────────────────┼─────────────┤
+    │ num_docs                    │ 7           │
+    │ num_terms                   │ 6           │
+    │ max_doc_id                  │ 7           │
+    │ num_records                 │ 44          │
+    │ percent_indexed             │ 1           │
+    │ hash_indexing_failures      │ 0           │
+    │ number_of_uses              │ 1           │
+    │ bytes_per_record_avg        │ 3.40909     │
+    │ doc_table_size_mb           │ 0.000767708 │
+    │ inverted_sz_mb              │ 0.000143051 │
+    │ key_table_size_mb           │ 0.000248909 │
+    │ offset_bits_per_record_avg  │ 8           │
+    │ offset_vectors_sz_mb        │ 8.58307e-06 │
+    │ offsets_per_term_avg        │ 0.204545    │
+    │ records_per_doc_avg         │ 6.28571     │
+    │ sortable_values_size_mb     │ 0           │
+    │ total_indexing_time         │ 1.053       │
+    │ total_inverted_index_blocks │ 18          │
+    │ vector_index_sz_mb          │ 0.0202332   │
+    ╰─────────────────────────────┴─────────────╯
+
+
+#### Performing Queries
+Once our index is created and data is loaded into the right format, we can run queries against the index with RedisVL:
+
+
+```python
+from redisvl.query import VectorQuery
+from redisvl.query.filter import Tag, Text, Num
+
+t = (Tag("credit_score") == "high") & (Text("job") % "enginee*") & (Num("age") > 17)
+
+v = VectorQuery(
+    vector=[0.1, 0.1, 0.5],
+    vector_field_name="user_embedding",
+    return_fields=["user", "credit_score", "age", "job", "office_location"],
+    filter_expression=t
+)
+
+
+results = hindex.query(v)
+result_print(results)
+
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# clean up
+hindex.delete()
+
+```
+
+### Working with JSON
+
+JSON is best suited for use cases with the following characteristics:
+- Ease of use and data model flexibility are top concerns
+- Application data is already native JSON
+- Replacing another document storage/db solution
+
+
+```python
+# define the json index schema
+json_schema = {
+    "index": {
+        "name": "user-json",
+        "prefix": "user-json-docs",
+        "storage_type": "json", # JSON storage type
+    },
+    "fields": [
+        {"name": "user", "type": "tag"},
+        {"name": "credit_score", "type": "tag"},
+        {"name": "job", "type": "text"},
+        {"name": "age", "type": "numeric"},
+        {"name": "office_location", "type": "geo"},
+        {
+            "name": "user_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": 3,
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+
+        }
+    ],
+}
+```
+
+
+```python
+# construct a search index from the json schema
+jindex = SearchIndex.from_dict(json_schema, redis_url="redis://localhost:6379")
+
+# create the index (no data yet)
+jindex.create(overwrite=True)
+```
+
+
+```python
+# note the multiple indices in the same database
+!rvl index listall
+```
+
+    11:54:18 [RedisVL] INFO   Indices:
+    11:54:18 [RedisVL] INFO   1. user-json
+
+
+#### Vectors as float arrays
+Vectorized data stored in JSON must be stored as a pure array (python list) of floats. We will modify our sample data to account for this below:
+
+
+```python
+json_data = data.copy()
+
+for d in json_data:
+    d['user_embedding'] = buffer_to_array(d['user_embedding'], dtype='float32')
+```
+
+
+```python
+# inspect a single JSON record
+json_data[0]
+```
+
+
+
+
+    {'user': 'john',
+     'age': 18,
+     'job': 'engineer',
+     'credit_score': 'high',
+     'office_location': '-122.4194,37.7749',
+     'user_embedding': [0.10000000149011612, 0.10000000149011612, 0.5]}
+
+
+
+
+```python
+keys = jindex.load(json_data)
+```
+
+
+```python
+# we can now run the exact same query as above
+result_print(jindex.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr></table>
+
+
+## Cleanup
+
+
+```python
+jindex.delete()
+```
+
+# Working with nested data in JSON
+
+Redis also supports native **JSON** objects. These can be multi-level (nested) objects, with full JSONPath support for updating/retrieving sub elements:
+
+```json
+{
+    "name": "Specialized Stump jumper",
+    "metadata": {
+        "model": "Stumpjumper",
+        "brand": "Specialized",
+        "type": "Enduro bikes",
+        "price": 3000
+    },
+}
+```
+
+#### Full JSON Path support
+Because Redis enables full JSON path support, when creating an index schema, elements need to be indexed and selected by their path with the desired `name` AND `path` that points to where the data is located within the objects.
+
+By default, RedisVL will assume the path as `$.{name}` if not provided in JSON fields schema. If nested provide path as `$.object.attribute`
+
+### As an example:
+
+
+```python
+from redisvl.utils.vectorize import HFTextVectorizer
+
+emb_model = HFTextVectorizer()
+
+bike_data = [
+    {
+        "name": "Specialized Stump jumper",
+        "metadata": {
+            "model": "Stumpjumper",
+            "brand": "Specialized",
+            "type": "Enduro bikes",
+            "price": 3000
+        },
+        "description": "The Specialized Stumpjumper is a versatile enduro bike that dominates both climbs and descents. Features a FACT 11m carbon fiber frame, FOX FLOAT suspension with 160mm travel, and SRAM X01 Eagle drivetrain. The asymmetric frame design and internal storage compartment make it a practical choice for all-day adventures."
+    },
+    {
+        "name": "bike_2",
+        "metadata": {
+            "model": "Slash",
+            "brand": "Trek",
+            "type": "Enduro bikes",
+            "price": 5000
+        },
+        "description": "Trek's Slash is built for aggressive enduro riding and racing. Featuring Trek's Alpha Aluminum frame with RE:aktiv suspension technology, 160mm travel, and Knock Block frame protection. Equipped with Bontrager components and a Shimano XT drivetrain, this bike excels on technical trails and enduro race courses."
+    }
+]
+
+bike_data = [{**d, "bike_embedding": emb_model.embed(d["description"])} for d in bike_data]
+
+bike_schema = {
+    "index": {
+        "name": "bike-json",
+        "prefix": "bike-json",
+        "storage_type": "json", # JSON storage type
+    },
+    "fields": [
+        {
+            "name": "model",
+            "type": "tag",
+            "path": "$.metadata.model" # note the '$'
+        },
+        {
+            "name": "brand",
+            "type": "tag",
+            "path": "$.metadata.brand"
+        },
+        {
+            "name": "price",
+            "type": "numeric",
+            "path": "$.metadata.price"
+        },
+        {
+            "name": "bike_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": len(bike_data[0]["bike_embedding"]),
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+
+        }
+    ],
+}
+```
+
+    /Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/huggingface_hub/file_download.py:1142: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.
+      warnings.warn(
+
+
+
+```python
+# construct a search index from the json schema
+bike_index = SearchIndex.from_dict(bike_schema, redis_url="redis://localhost:6379")
+
+# create the index (no data yet)
+bike_index.create(overwrite=True)
+```
+
+
+```python
+bike_index.load(bike_data)
+```
+
+
+
+
+    ['bike-json:de92cb9955434575b20f4e87a30b03d5',
+     'bike-json:054ab3718b984532b924946fa5ce00c6']
+
+
+
+
+```python
+from redisvl.query import VectorQuery
+
+vec = emb_model.embed("I'd like a bike for aggressive riding")
+
+v = VectorQuery(
+    vector=vec,
+    vector_field_name="bike_embedding",
+    return_fields=[
+        "brand",
+        "name",
+        "$.metadata.type"
+    ]
+)
+
+
+results = bike_index.query(v)
+```
+
+**Note:** As shown in the example if you want to retrieve a field from json object that was not indexed you will also need to supply the full path as with `$.metadata.type`.
+
+
+```python
+results
+```
+
+
+
+
+    [{'id': 'bike-json:054ab3718b984532b924946fa5ce00c6',
+      'vector_distance': '0.519989073277',
+      'brand': 'Trek',
+      '$.metadata.type': 'Enduro bikes'},
+     {'id': 'bike-json:de92cb9955434575b20f4e87a30b03d5',
+      'vector_distance': '0.657624483109',
+      'brand': 'Specialized',
+      '$.metadata.type': 'Enduro bikes'}]
+
+
+
+# Cleanup
+
+
+```python
+bike_index.delete()
+```
+---
+linkTitle: Rerankers
+title: Rerankers
+type: integration
+weight: 06
+---
+
+
+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](https://sbert.net/examples/applications/cross-encoder/README.html) which can use models from [Hugging Face cross encoder models](https://huggingface.co/cross-encoder) or Hugging Face models that implement a cross encoder function ([example: BAAI/bge-reranker-base](https://huggingface.co/BAAI/bge-reranker-base)).
+- The [Cohere /rerank API](https://docs.cohere.com/docs/rerank-2).
+- The [VoyageAI /rerank API](https://docs.voyageai.com/docs/reranker).
+
+Before running this notebook, be sure to:
+1. Have installed ``redisvl`` and have that environment active for this notebook.
+2. Have a running Redis Stack instance with RediSearch > 2.4 active.
+
+For example, you can run Redis Stack locally with Docker:
+
+```bash
+docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+This will run Redis on port 6379 and RedisInsight at http://localhost:8001.
+
+
+```python
+# import necessary modules
+import os
+```
+
+## Simple Reranking
+
+Reranking provides a relevance boost to search results generated by
+traditional (lexical) or semantic search strategies.
+
+As a simple demonstration, take the passages and user query below:
+
+
+```python
+query = "What is the capital of the United States?"
+docs = [
+    "Carson City is the capital city of the American state of Nevada. At the 2010 United States Census, Carson City had a population of 55,274.",
+    "The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean that are a political division controlled by the United States. Its capital is Saipan.",
+    "Charlotte Amalie is the capital and largest city of the United States Virgin Islands. It has about 20,000 people. The city is on the island of Saint Thomas.",
+    "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America.",
+    "Capital punishment (the death penalty) has existed in the United States since before the United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states. The federal government (including the United States military) also uses capital punishment."
+]
+```
+
+The goal of reranking is to provide a more fine-grained quality improvement to
+initial search results. With RedisVL, this would likely be results coming back
+from a search operation like full text or vector.
+
+### Using the Cross-Encoder Reranker
+
+To use the cross-encoder reranker we initialize an instance of `HFCrossEncoderReranker` passing a suitable model (if no model is provided, the `cross-encoder/ms-marco-MiniLM-L-6-v2` model is used):  
+
+
+```python
+from redisvl.utils.rerank import HFCrossEncoderReranker
+
+cross_encoder_reranker = HFCrossEncoderReranker("BAAI/bge-reranker-base")
+```
+
+### Rerank documents with HFCrossEncoderReranker
+
+With the obtained reranker instance we can rerank and truncate the list of
+documents based on relevance to the initial query.
+
+
+```python
+results, scores = cross_encoder_reranker.rank(query=query, docs=docs)
+```
+
+
+```python
+for result, score in zip(results, scores):
+    print(score, " -- ", result)
+```
+
+    0.07461125403642654  --  {'content': 'Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America.'}
+    0.05220315232872963  --  {'content': 'Charlotte Amalie is the capital and largest city of the United States Virgin Islands. It has about 20,000 people. The city is on the island of Saint Thomas.'}
+    0.3802368640899658  --  {'content': 'Carson City is the capital city of the American state of Nevada. At the 2010 United States Census, Carson City had a population of 55,274.'}
+
+
+### Using the Cohere Reranker
+
+To initialize the Cohere reranker you'll need to install the cohere library and provide the right Cohere API Key.
+
+
+```python
+#!pip install cohere
+```
+
+
+```python
+import getpass
+
+# setup the API Key
+api_key = os.environ.get("COHERE_API_KEY") or getpass.getpass("Enter your Cohere API key: ")
+```
+
+
+```python
+from redisvl.utils.rerank import CohereReranker
+
+cohere_reranker = CohereReranker(limit=3, api_config={"api_key": api_key})
+```
+
+### Rerank documents with CohereReranker
+
+Below we will use the `CohereReranker` to rerank and truncate the list of
+documents above based on relevance to the initial query.
+
+
+```python
+results, scores = cohere_reranker.rank(query=query, docs=docs)
+```
+
+
+```python
+for result, score in zip(results, scores):
+    print(score, " -- ", result)
+```
+
+    0.9990564  --  Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America.
+    0.7516481  --  Capital punishment (the death penalty) has existed in the United States since before the United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states. The federal government (including the United States military) also uses capital punishment.
+    0.08882029  --  The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean that are a political division controlled by the United States. Its capital is Saipan.
+
+
+### Working with semi-structured documents
+
+Often times the initial result set includes other metadata and components that could be used to steer the reranking relevancy. To accomplish this, we can set the `rank_by` argument and provide documents with those additional fields.
+
+
+```python
+docs = [
+    {
+        "source": "wiki",
+        "passage": "Carson City is the capital city of the American state of Nevada. At the 2010 United States Census, Carson City had a population of 55,274."
+    },
+    {
+        "source": "encyclopedia",
+        "passage": "The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean that are a political division controlled by the United States. Its capital is Saipan."
+    },
+    {
+        "source": "textbook",
+        "passage": "Charlotte Amalie is the capital and largest city of the United States Virgin Islands. It has about 20,000 people. The city is on the island of Saint Thomas."
+    },
+    {
+        "source": "textbook",
+        "passage": "Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America."
+    },
+    {
+        "source": "wiki",
+        "passage": "Capital punishment (the death penalty) has existed in the United States since before the United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states. The federal government (including the United States military) also uses capital punishment."
+    }
+]
+```
+
+
+```python
+results, scores = cohere_reranker.rank(query=query, docs=docs, rank_by=["passage", "source"])
+```
+
+
+```python
+for result, score in zip(results, scores):
+    print(score, " -- ", result)
+```
+
+    0.9988121  --  {'source': 'textbook', 'passage': 'Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America.'}
+    0.5974905  --  {'source': 'wiki', 'passage': 'Capital punishment (the death penalty) has existed in the United States since before the United States was a country. As of 2017, capital punishment is legal in 30 of the 50 states. The federal government (including the United States military) also uses capital punishment.'}
+    0.059101548  --  {'source': 'encyclopedia', 'passage': 'The Commonwealth of the Northern Mariana Islands is a group of islands in the Pacific Ocean that are a political division controlled by the United States. Its capital is Saipan.'}
+
+
+### Using the VoyageAI Reranker
+
+To initialize the VoyageAI reranker you'll need to install the voyaeai library and provide the right VoyageAI API Key.
+
+
+```python
+#!pip install voyageai
+```
+
+
+```python
+import getpass
+
+# setup the API Key
+api_key = os.environ.get("VOYAGE_API_KEY") or getpass.getpass("Enter your VoyageAI API key: ")
+```
+
+
+```python
+from redisvl.utils.rerank import VoyageAIReranker
+
+reranker = VoyageAIReranker(model="rerank-lite-1", limit=3, api_config={"api_key": api_key})# Please check the available models at https://docs.voyageai.com/docs/reranker
+```
+
+### Rerank documents with VoyageAIReranker
+
+Below we will use the `VoyageAIReranker` to rerank and also truncate the list of
+documents above based on relevance to the initial query.
+
+
+```python
+results, scores = reranker.rank(query=query, docs=docs)
+```
+
+
+```python
+for result, score in zip(results, scores):
+    print(score, " -- ", result)
+```
+
+    0.796875  --  Washington, D.C. (also known as simply Washington or D.C., and officially as the District of Columbia) is the capital of the United States. It is a federal district. The President of the USA and many major national government offices are in the territory. This makes it the political center of the United States of America.
+    0.578125  --  Charlotte Amalie is the capital and largest city of the United States Virgin Islands. It has about 20,000 people. The city is on the island of Saint Thomas.
+    0.5625  --  Carson City is the capital city of the American state of Nevada. At the 2010 United States Census, Carson City had a population of 55,274.
+
+---
+linkTitle: LLM message history
+title: LLM Message History
+type: integration
+weight: 07
+---
+
+
+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 message history.
+
+
+```python
+from redisvl.extensions.message_history import MessageHistory
+chat_history = MessageHistory(name='student tutor')
+```
+
+    12:24:11 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+To align with common LLM APIs, Redis stores messages with `role` and `content` fields.
+The supported roles are "system", "user" and "llm".
+
+You can store messages one at a time or all at once.
+
+
+```python
+chat_history.add_message({"role":"system", "content":"You are a helpful geography tutor, giving simple and short answers to questions about European countries."})
+chat_history.add_messages([
+    {"role":"user", "content":"What is the capital of France?"},
+    {"role":"llm", "content":"The capital is Paris."},
+    {"role":"user", "content":"And what is the capital of Spain?"},
+    {"role":"llm", "content":"The capital is Madrid."},
+    {"role":"user", "content":"What is the population of Great Britain?"},
+    {"role":"llm", "content":"As of 2023 the population of Great Britain is approximately 67 million people."},]
+    )
+```
+
+At any point we can retrieve the recent history of the conversation. It will be ordered by entry time.
+
+
+```python
+context = chat_history.get_recent()
+for message in context:
+    print(message)
+```
+
+    {'role': 'llm', 'content': 'The capital is Paris.'}
+    {'role': 'user', 'content': 'And what is the capital of Spain?'}
+    {'role': 'llm', 'content': 'The capital is Madrid.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+
+
+In many LLM flows the conversation progresses in a series of prompt and response pairs. Message history offer a convenience function `store()` to add these simply.
+
+
+```python
+prompt = "what is the size of England compared to Portugal?"
+response = "England is larger in land area than Portal by about 15000 square miles."
+chat_history.store(prompt, response)
+
+context = chat_history.get_recent(top_k=6)
+for message in context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'And what is the capital of Spain?'}
+    {'role': 'llm', 'content': 'The capital is Madrid.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+
+
+## Managing multiple users and conversations
+
+For applications that need to handle multiple conversations concurrently, Redis supports tagging messages to keep conversations separated.
+
+
+```python
+chat_history.add_message({"role":"system", "content":"You are a helpful algebra tutor, giving simple answers to math problems."}, session_tag='student two')
+chat_history.add_messages([
+    {"role":"user", "content":"What is the value of x in the equation 2x + 3 = 7?"},
+    {"role":"llm", "content":"The value of x is 2."},
+    {"role":"user", "content":"What is the value of y in the equation 3y - 5 = 7?"},
+    {"role":"llm", "content":"The value of y is 4."}],
+    session_tag='student two'
+    )
+
+for math_message in chat_history.get_recent(session_tag='student two'):
+    print(math_message)
+```
+
+    {'role': 'system', 'content': 'You are a helpful algebra tutor, giving simple answers to math problems.'}
+    {'role': 'user', 'content': 'What is the value of x in the equation 2x + 3 = 7?'}
+    {'role': 'llm', 'content': 'The value of x is 2.'}
+    {'role': 'user', 'content': 'What is the value of y in the equation 3y - 5 = 7?'}
+    {'role': 'llm', 'content': 'The value of y is 4.'}
+
+
+## Semantic message history
+For longer conversations our list of messages keeps growing. Since LLMs are stateless we have to continue to pass this conversation history on each subsequent call to ensure the LLM has the correct context.
+
+A typical flow looks like this:
+```
+while True:
+    prompt = input('enter your next question')
+    context = chat_history.get_recent()
+    response = LLM_api_call(prompt=prompt, context=context)
+    chat_history.store(prompt, response)
+```
+
+This works, but as context keeps growing so too does our LLM token count, which increases latency and cost.
+
+Conversation histories can be truncated, but that can lead to losing relevant information that appeared early on.
+
+A better solution is to pass only the relevant conversational context on each subsequent call.
+
+For this, RedisVL has the `SemanticMessageHistory`, which uses vector similarity search to return only semantically relevant sections of the conversation.
+
+
+```python
+from redisvl.extensions.message_history import SemanticMessageHistory
+semantic_history = SemanticMessageHistory(name='tutor')
+
+semantic_history.add_messages(chat_history.get_recent(top_k=8))
+```
+
+    12:24:15 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+
+```python
+prompt = "what have I learned about the size of England?"
+semantic_history.set_distance_threshold(0.35)
+context = semantic_history.get_relevant(prompt)
+for message in context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+
+
+You can adjust the degree of semantic similarity needed to be included in your context.
+
+Setting a distance threshold close to 0.0 will require an exact semantic match, while a distance threshold of 1.0 will include everthing.
+
+
+```python
+semantic_history.set_distance_threshold(0.7)
+
+larger_context = semantic_history.get_relevant(prompt)
+for message in larger_context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+
+
+## Conversation control
+
+LLMs can hallucinate on occasion and when this happens it can be useful to prune incorrect information from conversational histories so this incorrect information doesn't continue to be passed as context.
+
+
+```python
+semantic_history.store(
+    prompt="what is the smallest country in Europe?",
+    response="Monaco is the smallest country in Europe at 0.78 square miles." # Incorrect. Vatican City is the smallest country in Europe
+    )
+
+# get the key of the incorrect message
+context = semantic_history.get_recent(top_k=1, raw=True)
+bad_key = context[0]['entry_id']
+semantic_history.drop(bad_key)
+
+corrected_context = semantic_history.get_recent()
+for message in corrected_context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+    {'role': 'user', 'content': 'what is the smallest country in Europe?'}
+
+
+
+```python
+chat_history.clear()
+semantic_history.clear()
+```
+---
+linkTitle: Getting started with RedisVL
+title: Getting Started with RedisVL
+type: integration
+weight: 01
+---
+
+`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:
+
+1. Defining an `IndexSchema`
+2. Preparing a sample dataset
+3. Creating a `SearchIndex` object
+4. Testing `rvl` CLI functionality
+5. Loading the sample data
+6. Building `VectorQuery` objects and executing searches
+7. Updating a `SearchIndex` object
+
+...and more!
+
+Prerequisites:
+- Ensure `redisvl` is installed in your Python environment.
+- Have a running instance of [Redis Stack](https://redis.io/docs/install/install-stack/) or [Redis Cloud](https://redis.io/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.
+
+### Example Schema Creation
+Consider a dataset with user information, including `job`, `age`, `credit_score`,
+and a 3-dimensional `user_embedding` vector.
+
+You must also decide on a Redis index name and key prefix to use for this
+dataset. Below are example schema definitions in both YAML and Dict format.
+
+**YAML Definition:**
+
+```yaml
+version: '0.1.0'
+
+index:
+  name: user_simple
+  prefix: user_simple_docs
+
+fields:
+    - name: user
+      type: tag
+    - name: credit_score
+      type: tag
+    - name: job
+      type: text
+    - name: age
+      type: numeric
+    - name: user_embedding
+      type: vector
+      attrs:
+        algorithm: flat
+        dims: 3
+        distance_metric: cosine
+        datatype: float32
+```
+Store this in a local file, such as `schema.yaml`, for RedisVL usage.
+
+**Python Dictionary:**
+
+
+```python
+schema = {
+    "index": {
+        "name": "user_simple",
+        "prefix": "user_simple_docs",
+    },
+    "fields": [
+        {"name": "user", "type": "tag"},
+        {"name": "credit_score", "type": "tag"},
+        {"name": "job", "type": "text"},
+        {"name": "age", "type": "numeric"},
+        {
+            "name": "user_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": 3,
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+        }
+    ]
+}
+```
+
+## Sample Dataset Preparation
+
+Below, create a mock dataset with `user`, `job`, `age`, `credit_score`, and
+`user_embedding` fields. The `user_embedding` vectors are synthetic examples
+for demonstration purposes.
+
+For more information on creating real-world embeddings, refer to this
+[article](https://mlops.community/vector-similarity-search-from-basics-to-production/).
+
+
+```python
+import numpy as np
+
+
+data = [
+    {
+        'user': 'john',
+        'age': 1,
+        'job': 'engineer',
+        'credit_score': 'high',
+        'user_embedding': np.array([0.1, 0.1, 0.5], dtype=np.float32).tobytes()
+    },
+    {
+        'user': 'mary',
+        'age': 2,
+        'job': 'doctor',
+        'credit_score': 'low',
+        'user_embedding': np.array([0.1, 0.1, 0.5], dtype=np.float32).tobytes()
+    },
+    {
+        'user': 'joe',
+        'age': 3,
+        'job': 'dentist',
+        'credit_score': 'medium',
+        'user_embedding': np.array([0.9, 0.9, 0.1], dtype=np.float32).tobytes()
+    }
+]
+```
+
+As seen above, the sample `user_embedding` vectors are converted into bytes. Using the `NumPy`, this is fairly trivial.
+
+## Create a `SearchIndex`
+
+With the schema and sample dataset ready, create a `SearchIndex`.
+
+### Bring your own Redis connection instance
+
+This is ideal in scenarios where you have custom settings on the connection instance or if your application will share a connection pool:
+
+
+```python
+from redisvl.index import SearchIndex
+from redis import Redis
+
+client = Redis.from_url("redis://localhost:6379")
+index = SearchIndex.from_dict(schema, redis_client=client, validate_on_load=True)
+```
+
+### Let the index manage the connection instance
+
+This is ideal for simple cases:
+
+
+```python
+index = SearchIndex.from_dict(schema, redis_url="redis://localhost:6379", validate_on_load=True)
+
+# If you don't specify a client or Redis URL, the index will attempt to
+# connect to Redis at the default address "redis://localhost:6379".
+```
+
+### Create the index
+
+Now that we are connected to Redis, we need to run the create command.
+
+
+```python
+index.create(overwrite=True)
+```
+
+Note that at this point, the index has no entries. Data loading follows.
+
+## Inspect with the `rvl` CLI
+Use the `rvl` CLI to inspect the created index and its fields:
+
+
+```python
+!rvl index listall
+```
+
+    19:17:09 [RedisVL] INFO   Indices:
+    19:17:09 [RedisVL] INFO   1. user_simple
+
+
+
+```python
+!rvl index info -i user_simple
+```
+
+    
+    
+    Index Information:
+    ╭──────────────────────┬──────────────────────┬──────────────────────┬──────────────────────┬──────────────────────╮
+    │ Index Name           │ Storage Type         │ Prefixes             │ Index Options        │ Indexing             │
+    ├──────────────────────┼──────────────────────┼──────────────────────┼──────────────────────┼──────────────────────┤
+    | user_simple          | HASH                 | ['user_simple_docs'] | []                   | 0                    |
+    ╰──────────────────────┴──────────────────────┴──────────────────────┴──────────────────────┴──────────────────────╯
+    Index Fields:
+    ╭─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────╮
+    │ Name            │ Attribute       │ Type            │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │
+    ├─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┤
+    │ user            │ user            │ TAG             │ SEPARATOR       │ ,               │                 │                 │                 │                 │                 │                 │
+    │ credit_score    │ credit_score    │ TAG             │ SEPARATOR       │ ,               │                 │                 │                 │                 │                 │                 │
+    │ job             │ job             │ TEXT            │ WEIGHT          │ 1               │                 │                 │                 │                 │                 │                 │
+    │ age             │ age             │ NUMERIC         │                 │                 │                 │                 │                 │                 │                 │                 │
+    │ user_embedding  │ user_embedding  │ VECTOR          │ algorithm       │ FLAT            │ data_type       │ FLOAT32         │ dim             │ 3               │ distance_metric │ COSINE          │
+    ╰─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────╯
+
+
+## Load Data to `SearchIndex`
+
+Load the sample dataset to Redis.
+
+### Validate data entries on load
+RedisVL uses pydantic validation under the hood to ensure loaded data is valid and confirms to your schema. This setting is optional and can be configured in the `SearchIndex` class.
+
+
+```python
+keys = index.load(data)
+
+print(keys)
+```
+
+    ['user_simple_docs:01JT4PPPNJZMSK2395RKD208T9', 'user_simple_docs:01JT4PPPNM63J55ZESZ4TV1VR8', 'user_simple_docs:01JT4PPPNM59RCKS2YQ58B1HQW']
+
+
+By default, `load` will create a unique Redis key as a combination of the index key `prefix` and a random ULID. You can also customize the key by providing direct keys or pointing to a specified `id_field` on load.
+
+### Load invalid data
+This will raise a `SchemaValidationError` if `validate_on_load` is set to true in the `SearchIndex` class.
+
+
+```python
+# NBVAL_SKIP
+
+keys = index.load([{"user_embedding": True}])
+```
+
+    19:17:21 redisvl.index.index ERROR   Schema validation error while loading data
+    Traceback (most recent call last):
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/index/storage.py", line 204, in _preprocess_and_validate_objects
+        processed_obj = self._validate(processed_obj)
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/index/storage.py", line 160, in _validate
+        return validate_object(self.index_schema, obj)
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/schema/validation.py", line 276, in validate_object
+        validated = model_class.model_validate(flat_obj)
+      File "/Users/justin.cechmanek/.pyenv/versions/3.13/envs/redisvl-dev/lib/python3.13/site-packages/pydantic/main.py", line 627, in model_validate
+        return cls.__pydantic_validator__.validate_python(
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
+            obj, strict=strict, from_attributes=from_attributes, context=context
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        )
+        ^
+    pydantic_core._pydantic_core.ValidationError: 1 validation error for user_simple__PydanticModel
+    user_embedding
+      Input should be a valid bytes [type=bytes_type, input_value=True, input_type=bool]
+        For further information visit https://errors.pydantic.dev/2.10/v/bytes_type
+    
+    The above exception was the direct cause of the following exception:
+    
+    Traceback (most recent call last):
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/index/index.py", line 686, in load
+        return self._storage.write(
+               ~~~~~~~~~~~~~~~~~~~^
+            self._redis_client,  # type: ignore
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        ...<6 lines>...
+            validate=self._validate_on_load,
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+        )
+        ^
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/index/storage.py", line 265, in write
+        prepared_objects = self._preprocess_and_validate_objects(
+            list(objects),  # Convert Iterable to List
+        ...<3 lines>...
+            validate=validate,
+        )
+      File "/Users/justin.cechmanek/Documents/redisvl/redisvl/index/storage.py", line 211, in _preprocess_and_validate_objects
+        raise SchemaValidationError(str(e), index=i) from e
+    redisvl.exceptions.SchemaValidationError: Validation failed for object at index 0: 1 validation error for user_simple__PydanticModel
+    user_embedding
+      Input should be a valid bytes [type=bytes_type, input_value=True, input_type=bool]
+        For further information visit https://errors.pydantic.dev/2.10/v/bytes_type
+
+
+
+    ---------------------------------------------------------------------------
+
+    ValidationError                           Traceback (most recent call last)
+
+    File ~/Documents/redisvl/redisvl/index/storage.py:204, in BaseStorage._preprocess_and_validate_objects(self, objects, id_field, keys, preprocess, validate)
+        203 if validate:
+    --> 204     processed_obj = self._validate(processed_obj)
+        206 # Store valid object with its key for writing
+
+
+    File ~/Documents/redisvl/redisvl/index/storage.py:160, in BaseStorage._validate(self, obj)
+        159 # Pass directly to validation function and let any errors propagate
+    --> 160 return validate_object(self.index_schema, obj)
+
+
+    File ~/Documents/redisvl/redisvl/schema/validation.py:276, in validate_object(schema, obj)
+        275 # Validate against model
+    --> 276 validated = model_class.model_validate(flat_obj)
+        277 return validated.model_dump(exclude_none=True)
+
+
+    File ~/.pyenv/versions/3.13/envs/redisvl-dev/lib/python3.13/site-packages/pydantic/main.py:627, in BaseModel.model_validate(cls, obj, strict, from_attributes, context)
+        626 __tracebackhide__ = True
+    --> 627 return cls.__pydantic_validator__.validate_python(
+        628     obj, strict=strict, from_attributes=from_attributes, context=context
+        629 )
+
+
+    ValidationError: 1 validation error for user_simple__PydanticModel
+    user_embedding
+      Input should be a valid bytes [type=bytes_type, input_value=True, input_type=bool]
+        For further information visit https://errors.pydantic.dev/2.10/v/bytes_type
+
+    
+    The above exception was the direct cause of the following exception:
+
+
+    SchemaValidationError                     Traceback (most recent call last)
+
+    Cell In[31], line 3
+          1 # NBVAL_SKIP
+    ----> 3 keys = index.load([{"user_embedding": True}])
+
+
+    File ~/Documents/redisvl/redisvl/index/index.py:686, in SearchIndex.load(self, data, id_field, keys, ttl, preprocess, batch_size)
+        656 """Load objects to the Redis database. Returns the list of keys loaded
+        657 to Redis.
+        658 
+       (...)
+        683     RedisVLError: If there's an error loading data to Redis.
+        684 """
+        685 try:
+    --> 686     return self._storage.write(
+        687         self._redis_client,  # type: ignore
+        688         objects=data,
+        689         id_field=id_field,
+        690         keys=keys,
+        691         ttl=ttl,
+        692         preprocess=preprocess,
+        693         batch_size=batch_size,
+        694         validate=self._validate_on_load,
+        695     )
+        696 except SchemaValidationError:
+        697     # Pass through validation errors directly
+        698     logger.exception("Schema validation error while loading data")
+
+
+    File ~/Documents/redisvl/redisvl/index/storage.py:265, in BaseStorage.write(self, redis_client, objects, id_field, keys, ttl, preprocess, batch_size, validate)
+        262     return []
+        264 # Pass 1: Preprocess and validate all objects
+    --> 265 prepared_objects = self._preprocess_and_validate_objects(
+        266     list(objects),  # Convert Iterable to List
+        267     id_field=id_field,
+        268     keys=keys,
+        269     preprocess=preprocess,
+        270     validate=validate,
+        271 )
+        273 # Pass 2: Write all valid objects in batches
+        274 added_keys = []
+
+
+    File ~/Documents/redisvl/redisvl/index/storage.py:211, in BaseStorage._preprocess_and_validate_objects(self, objects, id_field, keys, preprocess, validate)
+        207     prepared_objects.append((key, processed_obj))
+        209 except ValidationError as e:
+        210     # Convert Pydantic ValidationError to SchemaValidationError with index context
+    --> 211     raise SchemaValidationError(str(e), index=i) from e
+        212 except Exception as e:
+        213     # Capture other exceptions with context
+        214     object_id = f"at index {i}"
+
+
+    SchemaValidationError: Validation failed for object at index 0: 1 validation error for user_simple__PydanticModel
+    user_embedding
+      Input should be a valid bytes [type=bytes_type, input_value=True, input_type=bool]
+        For further information visit https://errors.pydantic.dev/2.10/v/bytes_type
+
+
+### Upsert the index with new data
+Upsert data by using the `load` method again:
+
+
+```python
+# Add more data
+new_data = [{
+    'user': 'tyler',
+    'age': 9,
+    'job': 'engineer',
+    'credit_score': 'high',
+    'user_embedding': np.array([0.1, 0.3, 0.5], dtype=np.float32).tobytes()
+}]
+keys = index.load(new_data)
+
+print(keys)
+```
+
+    ['user_simple_docs:01JT4PPX63CH5YRN2BGEYB5TS2']
+
+
+## Creating `VectorQuery` Objects
+
+Next we will create a vector query object for our newly populated index. This example will use a simple vector to demonstrate how vector similarity works. Vectors in production will likely be much larger than 3 floats and often require Machine Learning models (i.e. Huggingface sentence transformers) or an embeddings API (Cohere, OpenAI). `redisvl` provides a set of [Vectorizers]({{< relref "vectorizers#openai" >}}) to assist in vector creation.
+
+
+```python
+from redisvl.query import VectorQuery
+from jupyterutils import result_print
+
+query = VectorQuery(
+    vector=[0.1, 0.1, 0.5],
+    vector_field_name="user_embedding",
+    return_fields=["user", "age", "job", "credit_score", "vector_distance"],
+    num_results=3
+)
+```
+
+### Executing queries
+With our `VectorQuery` object defined above, we can execute the query over the `SearchIndex` using the `query` method.
+
+
+```python
+results = index.query(query)
+result_print(results)
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>age</th><th>job</th><th>credit_score</th></tr><tr><td>0</td><td>john</td><td>1</td><td>engineer</td><td>high</td></tr><tr><td>0</td><td>mary</td><td>2</td><td>doctor</td><td>low</td></tr><tr><td>0.0566299557686</td><td>tyler</td><td>9</td><td>engineer</td><td>high</td></tr></table>
+
+
+## Using an Asynchronous Redis Client
+
+The `AsyncSearchIndex` class along with an async Redis python client allows for queries, index creation, and data loading to be done asynchronously. This is the
+recommended route for working with `redisvl` in production-like settings.
+
+
+```python
+schema
+```
+
+
+
+
+    {'index': {'name': 'user_simple', 'prefix': 'user_simple_docs'},
+     'fields': [{'name': 'user', 'type': 'tag'},
+      {'name': 'credit_score', 'type': 'tag'},
+      {'name': 'job', 'type': 'text'},
+      {'name': 'age', 'type': 'numeric'},
+      {'name': 'user_embedding',
+       'type': 'vector',
+       'attrs': {'dims': 3,
+        'distance_metric': 'cosine',
+        'algorithm': 'flat',
+        'datatype': 'float32'}}]}
+
+
+
+
+```python
+from redisvl.index import AsyncSearchIndex
+from redis.asyncio import Redis
+
+client = Redis.from_url("redis://localhost:6379")
+index = AsyncSearchIndex.from_dict(schema, redis_client=client)
+```
+
+
+```python
+# execute the vector query async
+results = await index.query(query)
+result_print(results)
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>age</th><th>job</th><th>credit_score</th></tr><tr><td>0</td><td>john</td><td>1</td><td>engineer</td><td>high</td></tr><tr><td>0</td><td>mary</td><td>2</td><td>doctor</td><td>low</td></tr><tr><td>0.0566299557686</td><td>tyler</td><td>9</td><td>engineer</td><td>high</td></tr></table>
+
+
+## Updating a schema
+In some scenarios, it makes sense to update the index schema. With Redis and `redisvl`, this is easy because Redis can keep the underlying data in place while you change or make updates to the index configuration.
+
+So for our scenario, let's imagine we want to reindex this data in 2 ways:
+- by using a `Tag` type for `job` field instead of `Text`
+- by using an `hnsw` vector index for the `user_embedding` field instead of a `flat` vector index
+
+
+```python
+# Modify this schema to have what we want
+
+index.schema.remove_field("job")
+index.schema.remove_field("user_embedding")
+index.schema.add_fields([
+    {"name": "job", "type": "tag"},
+    {
+        "name": "user_embedding",
+        "type": "vector",
+        "attrs": {
+            "dims": 3,
+            "distance_metric": "cosine",
+            "algorithm": "hnsw",
+            "datatype": "float32"
+        }
+    }
+])
+```
+
+
+```python
+# Run the index update but keep underlying data in place
+await index.create(overwrite=True, drop=False)
+```
+
+    19:17:29 redisvl.index.index INFO   Index already exists, overwriting.
+
+
+
+```python
+# Execute the vector query async
+results = await index.query(query)
+result_print(results)
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>age</th><th>job</th><th>credit_score</th></tr><tr><td>0</td><td>john</td><td>1</td><td>engineer</td><td>high</td></tr><tr><td>0</td><td>mary</td><td>2</td><td>doctor</td><td>low</td></tr><tr><td>0.0566299557686</td><td>tyler</td><td>9</td><td>engineer</td><td>high</td></tr></table>
+
+
+## Check Index Stats
+Use the `rvl` CLI to check the stats for the index:
+
+
+```python
+!rvl stats -i user_simple
+```
+
+    
+    Statistics:
+    ╭─────────────────────────────┬────────────╮
+    │ Stat Key                    │ Value      │
+    ├─────────────────────────────┼────────────┤
+    │ num_docs                    │ 4          │
+    │ num_terms                   │ 0          │
+    │ max_doc_id                  │ 4          │
+    │ num_records                 │ 20         │
+    │ percent_indexed             │ 1          │
+    │ hash_indexing_failures      │ 0          │
+    │ number_of_uses              │ 2          │
+    │ bytes_per_record_avg        │ 48.2000007 │
+    │ doc_table_size_mb           │ 4.23431396 │
+    │ inverted_sz_mb              │ 9.19342041 │
+    │ key_table_size_mb           │ 1.93595886 │
+    │ offset_bits_per_record_avg  │ nan        │
+    │ offset_vectors_sz_mb        │ 0          │
+    │ offsets_per_term_avg        │ 0          │
+    │ records_per_doc_avg         │ 5          │
+    │ sortable_values_size_mb     │ 0          │
+    │ total_indexing_time         │ 0.74400001 │
+    │ total_inverted_index_blocks │ 11         │
+    │ vector_index_sz_mb          │ 0.23560333 │
+    ╰─────────────────────────────┴────────────╯
+
+
+## Cleanup
+
+Below we will clean up after our work. First, you can flush all data from Redis associated with the index by
+using the `.clear()` method. This will leave the secondary index in place for future insertions or updates.
+
+But if you want to clean up everything, including the index, just use `.delete()`
+which will by default remove the index AND the underlying data.
+
+
+```python
+# Clear all data from Redis associated with the index
+await index.clear()
+```
+
+
+
+
+    4
+
+
+
+
+```python
+# Butm the index is still in place
+await index.exists()
+```
+
+
+
+
+    True
+
+
+
+
+```python
+# Remove / delete the index in its entirety
+await index.delete()
+```
+---
+linkTitle: 0.5.1 feature overview
+title: 0.5.1 Feature Overview
+type: integration
+---
+
+
+This notebook provides an overview of what's new with the 0.5.1 release of redisvl. It also highlights changes and potential enhancements for existing usage.
+
+## What's new?
+
+- Hybrid query and text query classes
+- Threshold optimizer classes
+- Schema validation
+- Timestamp filters
+- Batched queries
+- Vector normalization
+- Hybrid policy on knn with filters
+
+## Define and load index for examples
+
+
+```python
+from redisvl.utils.vectorize import HFTextVectorizer
+from redisvl.index import SearchIndex
+import datetime as dt
+
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="redis")
+
+# Embedding model
+emb_model = HFTextVectorizer()
+
+REDIS_URL = "redis://localhost:6379/0"
+NOW = dt.datetime.now()
+
+job_data = [
+  {
+    "job_title": "Software Engineer",
+    "job_description": "Develop and maintain web applications using JavaScript, React, and Node.js.",
+    "posted": (NOW - dt.timedelta(days=1)).timestamp() # day ago
+  },
+  {
+    "job_title": "Data Analyst",
+    "job_description": "Analyze large datasets to provide business insights and create data visualizations.",
+    "posted": (NOW - dt.timedelta(days=7)).timestamp() # week ago
+  },
+  {
+    "job_title": "Marketing Manager",
+    "job_description": "Develop and implement marketing strategies to drive brand awareness and customer engagement.",
+    "posted": (NOW - dt.timedelta(days=30)).timestamp() # month ago
+  }
+]
+
+job_data = [{**job, "job_embedding": emb_model.embed(job["job_description"], as_buffer=True)} for job in job_data]
+
+
+job_schema = {
+    "index": {
+        "name": "jobs",
+        "prefix": "jobs",
+        "storage_type": "hash",
+    },
+    "fields": [
+        {"name": "job_title", "type": "text"},
+        {"name": "job_description", "type": "text"},
+        {"name": "posted", "type": "numeric"},
+        {
+            "name": "job_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": 768,
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+
+        }
+    ],
+}
+
+index = SearchIndex.from_dict(job_schema, redis_url=REDIS_URL)
+index.create(overwrite=True, drop=True)
+index.load(job_data)
+```
+
+    12:44:52 redisvl.index.index INFO   Index already exists, overwriting.
+
+
+
+
+
+    ['jobs:01JR0V1SA29RVD9AAVSTBV9P5H',
+     'jobs:01JR0V1SA209KMVHMD7G54P3H5',
+     'jobs:01JR0V1SA23ZE7BRERXTZWC33Z']
+
+
+
+# HybridQuery class
+
+Perform hybrid lexical (BM25) and vector search where results are ranked by: `hybrid_score = (1-alpha)*lexical_Score + alpha*vector_similarity`.
+
+
+```python
+from redisvl.query import HybridQuery
+
+text = "Find a job as a where you develop software"
+vec = emb_model.embed(text, as_buffer=True)
+
+query = HybridQuery(
+    text=text,
+    text_field_name="job_description",
+    vector=vec,
+    vector_field_name="job_embedding",
+    alpha=0.7,
+    num_results=10,
+    return_fields=["job_title"],
+)
+
+results = index.query(query)
+results
+```
+
+
+
+
+    [{'vector_distance': '0.61871612072',
+      'job_title': 'Software Engineer',
+      'vector_similarity': '0.69064193964',
+      'text_score': '49.6242910712',
+      'hybrid_score': '15.3707366791'},
+     {'vector_distance': '0.937997639179',
+      'job_title': 'Marketing Manager',
+      'vector_similarity': '0.53100118041',
+      'text_score': '49.6242910712',
+      'hybrid_score': '15.2589881476'},
+     {'vector_distance': '0.859166145325',
+      'job_title': 'Data Analyst',
+      'vector_similarity': '0.570416927338',
+      'text_score': '0',
+      'hybrid_score': '0.399291849136'}]
+
+
+
+# TextQueries
+
+TextQueries make it easy to perform pure lexical search with redisvl.
+
+
+```python
+from redisvl.query import TextQuery
+
+text = "Find where you develop software"
+
+query = TextQuery(
+    text=text,
+    text_field_name="job_description",
+    return_fields=["job_title"],
+    num_results=10,
+)
+
+results = index.query(query)
+results
+```
+
+
+
+
+    [{'id': 'jobs:01JR0V1SA29RVD9AAVSTBV9P5H',
+      'score': 49.62429107116745,
+      'job_title': 'Software Engineer'},
+     {'id': 'jobs:01JR0V1SA23ZE7BRERXTZWC33Z',
+      'score': 49.62429107116745,
+      'job_title': 'Marketing Manager'}]
+
+
+
+# Threshold optimization
+
+In redis 0.5.0 we added the ability to quickly configure either your semantic cache or semantic router with test data examples.
+
+For a step by step guide see: [09_threshold_optimization.ipynb](../09_threshold_optimization.ipynb).
+
+For a more advanced routing example see: [this example](https://github.com/redis-developer/redis-ai-resources/blob/main/python-recipes/semantic-router/01_routing_optimization.ipynb). 
+
+
+```python
+from redisvl.utils.optimize import CacheThresholdOptimizer
+from redisvl.extensions.cache.llm import SemanticCache
+
+sem_cache = SemanticCache(
+    name="sem_cache",                    # underlying search index name
+    redis_url="redis://localhost:6379",  # redis connection url string
+    distance_threshold=0.5               # semantic cache distance threshold
+)
+
+paris_key = sem_cache.store(prompt="what is the capital of france?", response="paris")
+rabat_key = sem_cache.store(prompt="what is the capital of morocco?", response="rabat")
+
+test_data = [
+    {
+        "query": "What's the capital of Britain?",
+        "query_match": ""
+    },
+    {
+        "query": "What's the capital of France??",
+        "query_match": paris_key
+    },
+    {
+        "query": "What's the capital city of Morocco?",
+        "query_match": rabat_key
+    },
+]
+
+print(f"\nDistance threshold before: {sem_cache.distance_threshold} \n")
+optimizer = CacheThresholdOptimizer(sem_cache, test_data)
+optimizer.optimize()
+print(f"\nDistance threshold after: {sem_cache.distance_threshold} \n")
+```
+
+    
+    Distance threshold before: 0.5 
+    
+    
+    Distance threshold after: 0.13050847457627118 
+    
+
+
+# Schema validation
+
+This feature makes it easier to make sure your data is in the right format. To demo this we will create a new index with the `validate_on_load` flag set to `True`
+
+
+```python
+# NBVAL_SKIP
+from redisvl.index import SearchIndex
+
+# sample schema
+car_schema = {
+    "index": {
+        "name": "cars",
+        "prefix": "cars",
+        "storage_type": "json",
+    },
+    "fields": [
+        {"name": "make", "type": "text"},
+        {"name": "model", "type": "text"},
+        {"name": "description", "type": "text"},
+        {"name": "mpg", "type": "numeric"},
+        {
+            "name": "car_embedding",
+            "type": "vector",
+            "attrs": {
+                "dims": 3,
+                "distance_metric": "cosine",
+                "algorithm": "flat",
+                "datatype": "float32"
+            }
+
+        }
+    ],
+}
+
+sample_data_bad = [
+    {
+        "make": "Toyota",
+        "model": "Camry",
+        "description": "A reliable sedan with great fuel economy.",
+        "mpg": 28,
+        "car_embedding": [0.1, 0.2, 0.3]
+    },
+    {
+        "make": "Honda",
+        "model": "CR-V",
+        "description": "A practical SUV with advanced technology.",
+        # incorrect type will throw an error
+        "mpg": "twenty-two",
+        "car_embedding": [0.4, 0.5, 0.6]
+    }
+]
+
+# this should now throw an error
+car_index = SearchIndex.from_dict(car_schema, redis_url=REDIS_URL, validate_on_load=True)
+car_index.create(overwrite=True)
+
+try:
+    car_index.load(sample_data_bad)
+except Exception as e:
+    print(f"Error loading data: {e}")
+```
+
+    16:20:25 redisvl.index.index ERROR   Schema validation error while loading data
+    Traceback (most recent call last):
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/index/storage.py", line 204, in _preprocess_and_validate_objects
+        processed_obj = self._validate(processed_obj)
+                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/index/storage.py", line 160, in _validate
+        return validate_object(self.index_schema, obj)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/schema/validation.py", line 276, in validate_object
+        validated = model_class.model_validate(flat_obj)
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/pydantic/main.py", line 627, in model_validate
+        return cls.__pydantic_validator__.validate_python(
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    pydantic_core._pydantic_core.ValidationError: 2 validation errors for cars__PydanticModel
+    mpg.int
+      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/int_parsing
+    mpg.float
+      Input should be a valid number, unable to parse string as a number [type=float_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/float_parsing
+    
+    The above exception was the direct cause of the following exception:
+    
+    Traceback (most recent call last):
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/index/index.py", line 615, in load
+        return self._storage.write(
+               ^^^^^^^^^^^^^^^^^^^^
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/index/storage.py", line 265, in write
+        prepared_objects = self._preprocess_and_validate_objects(
+                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      File "/Users/robert.shelton/.pyenv/versions/3.11.9/lib/python3.11/site-packages/redisvl/index/storage.py", line 211, in _preprocess_and_validate_objects
+        raise SchemaValidationError(str(e), index=i) from e
+    redisvl.exceptions.SchemaValidationError: Validation failed for object at index 1: 2 validation errors for cars__PydanticModel
+    mpg.int
+      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/int_parsing
+    mpg.float
+      Input should be a valid number, unable to parse string as a number [type=float_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/float_parsing
+    Error loading data: Validation failed for object at index 1: 2 validation errors for cars__PydanticModel
+    mpg.int
+      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/int_parsing
+    mpg.float
+      Input should be a valid number, unable to parse string as a number [type=float_parsing, input_value='twenty-two', input_type=str]
+        For further information visit https://errors.pydantic.dev/2.10/v/float_parsing
+
+
+# Timestamp filters
+
+In Redis datetime objects are stored as numeric epoch times. Timestamp filter makes it easier to handle querying by these fields by handling conversion for you.
+
+
+```python
+from redisvl.query import FilterQuery
+from redisvl.query.filter import Timestamp
+
+# find all jobs
+ts = Timestamp("posted") < NOW # now datetime created above
+
+filter_query = FilterQuery(
+    return_fields=["job_title", "job_description", "posted"], 
+    filter_expression=ts,
+    num_results=10,
+)
+res = index.query(filter_query)
+res
+```
+
+
+
+
+    [{'id': 'jobs:01JQYMYZBA6NM6DX9YW35MCHJZ',
+      'job_title': 'Software Engineer',
+      'job_description': 'Develop and maintain web applications using JavaScript, React, and Node.js.',
+      'posted': '1743625199.9'},
+     {'id': 'jobs:01JQYMYZBABXYR96H96SQ99ZPS',
+      'job_title': 'Data Analyst',
+      'job_description': 'Analyze large datasets to provide business insights and create data visualizations.',
+      'posted': '1743106799.9'},
+     {'id': 'jobs:01JQYMYZBAGEBDS270EZADQ1TM',
+      'job_title': 'Marketing Manager',
+      'job_description': 'Develop and implement marketing strategies to drive brand awareness and customer engagement.',
+      'posted': '1741123199.9'}]
+
+
+
+
+```python
+# jobs posted in the last 3 days => 1 job
+ts = Timestamp("posted") > NOW - dt.timedelta(days=3)
+
+filter_query = FilterQuery(
+    return_fields=["job_title", "job_description", "posted"], 
+    filter_expression=ts,
+    num_results=10,
+)
+res = index.query(filter_query)
+res
+```
+
+
+
+
+    [{'id': 'jobs:01JQYMYZBA6NM6DX9YW35MCHJZ',
+      'job_title': 'Software Engineer',
+      'job_description': 'Develop and maintain web applications using JavaScript, React, and Node.js.',
+      'posted': '1743625199.9'}]
+
+
+
+
+```python
+# more than 3 days ago but less than 14 days ago => 1 job
+ts = Timestamp("posted").between(
+    NOW - dt.timedelta(days=14),
+    NOW - dt.timedelta(days=3),
+)
+
+filter_query = FilterQuery(
+    return_fields=["job_title", "job_description", "posted"], 
+    filter_expression=ts,
+    num_results=10,
+)
+
+res = index.query(filter_query)
+res
+```
+
+
+
+
+    [{'id': 'jobs:01JQYMYZBABXYR96H96SQ99ZPS',
+      'job_title': 'Data Analyst',
+      'job_description': 'Analyze large datasets to provide business insights and create data visualizations.',
+      'posted': '1743106799.9'}]
+
+
+
+# Batch search
+
+This enhancement allows you to speed up the execution of queries by reducing the impact of network latency.
+
+
+```python
+import time
+num_queries = 200
+
+start = time.time()
+for i in range(num_queries):
+    # run the same filter query 
+    res = index.query(filter_query)
+end = time.time()
+print(f"Time taken for {num_queries} queries: {end - start:.2f} seconds")
+```
+
+    Time taken for 200 queries: 0.11 seconds
+
+
+
+```python
+batched_queries = [filter_query] * num_queries
+
+start = time.time()
+
+index.batch_search(batched_queries, batch_size=10)
+
+end = time.time()
+print(f"Time taken for {num_queries} batched queries: {end - start:.2f} seconds")
+```
+
+    Time taken for 200 batched queries: 0.03 seconds
+
+
+# Vector normalization
+
+By default, Redis returns the vector cosine distance when performing a search, which yields a value between 0 and 2, where 0 represents a perfect match. However, you may sometimes prefer a similarity score between 0 and 1, where 1 indicates a perfect match. When enabled, this flag performs the conversion for you. Additionally, if this flag is set to true for L2 distance, it normalizes the Euclidean distance to a value between 0 and 1 as well.
+ 
+
+
+```python
+from redisvl.query import VectorQuery
+
+query = VectorQuery(
+    vector=emb_model.embed("Software Engineer", as_buffer=True),
+    vector_field_name="job_embedding",
+    return_fields=["job_title", "job_description", "posted"],
+    normalize_vector_distance=True,
+)
+
+res = index.query(query)
+res
+```
+
+
+
+
+    [{'id': 'jobs:01JQYMYZBA6NM6DX9YW35MCHJZ',
+      'vector_distance': '0.7090711295605',
+      'job_title': 'Software Engineer',
+      'job_description': 'Develop and maintain web applications using JavaScript, React, and Node.js.',
+      'posted': '1743625199.9'},
+     {'id': 'jobs:01JQYMYZBABXYR96H96SQ99ZPS',
+      'vector_distance': '0.6049451231955',
+      'job_title': 'Data Analyst',
+      'job_description': 'Analyze large datasets to provide business insights and create data visualizations.',
+      'posted': '1743106799.9'},
+     {'id': 'jobs:01JQYMYZBAGEBDS270EZADQ1TM',
+      'vector_distance': '0.553376108408',
+      'job_title': 'Marketing Manager',
+      'job_description': 'Develop and implement marketing strategies to drive brand awareness and customer engagement.',
+      'posted': '1741123199.9'}]
+
+
+
+# Hybrid policy on knn with filters
+
+Within the default redis client you can set the `HYBRID_POLICY` which specifies the filter mode to use during vector search with filters. It can take values `BATCHES` or `ADHOC_BF`. Previously this option was not exposed by redisvl.
+
+
+```python
+from redisvl.query.filter import Text
+
+filter = Text("job_description") % "Develop"
+
+query = VectorQuery(
+    vector=emb_model.embed("Software Engineer", as_buffer=True),
+    vector_field_name="job_embedding",
+    return_fields=["job_title", "job_description", "posted"],
+    hybrid_policy="BATCHES"
+)
+
+query.set_filter(filter)
+
+res = index.query(query)
+res
+```
+
+
+
+
+    [{'id': 'jobs:01JQYMYZBA6NM6DX9YW35MCHJZ',
+      'vector_distance': '0.581857740879',
+      'job_title': 'Software Engineer',
+      'job_description': 'Develop and maintain web applications using JavaScript, React, and Node.js.',
+      'posted': '1743625199.9'},
+     {'id': 'jobs:01JQYMYZBAGEBDS270EZADQ1TM',
+      'vector_distance': '0.893247783184',
+      'job_title': 'Marketing Manager',
+      'job_description': 'Develop and implement marketing strategies to drive brand awareness and customer engagement.',
+      'posted': '1741123199.9'}]
+
+
+---
+linkTitle: Release guides
+title: Release Guides
+type: integration
+hideListLinks: true
+---
+
+
+This section contains guidelines and information for RedisVL releases.
+
+
+
+* [0.5.1 Feature Overview](0_5_0_release/)
+  * [What’s new?](0_5_0_release/#what-s-new)
+  * [Define and load index for examples](0_5_0_release/#define-and-load-index-for-examples)
+* [HybridQuery class](0_5_0_release/#hybridquery-class)
+* [TextQueries](0_5_0_release/#textqueries)
+* [Threshold optimization](0_5_0_release/#threshold-optimization)
+* [Schema validation](0_5_0_release/#schema-validation)
+* [Timestamp filters](0_5_0_release/#timestamp-filters)
+* [Batch search](0_5_0_release/#batch-search)
+* [Vector normalization](0_5_0_release/#vector-normalization)
+* [Hybrid policy on knn with filters](0_5_0_release/#hybrid-policy-on-knn-with-filters)
+---
+linkTitle: LLM session memory
+title: LLM Session Memory
+type: integration
+weight: 07
+---
+
+
+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.
+
+
+```python
+from redisvl.extensions.session_manager import StandardSessionManager
+chat_session = StandardSessionManager(name='student tutor')
+```
+
+    12:24:11 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+To align with common LLM APIs, Redis stores messages with `role` and `content` fields.
+The supported roles are "system", "user" and "llm".
+
+You can store messages one at a time or all at once.
+
+
+```python
+chat_session.add_message({"role":"system", "content":"You are a helpful geography tutor, giving simple and short answers to questions about Europen countries."})
+chat_session.add_messages([
+    {"role":"user", "content":"What is the capital of France?"},
+    {"role":"llm", "content":"The capital is Paris."},
+    {"role":"user", "content":"And what is the capital of Spain?"},
+    {"role":"llm", "content":"The capital is Madrid."},
+    {"role":"user", "content":"What is the population of Great Britain?"},
+    {"role":"llm", "content":"As of 2023 the population of Great Britain is approximately 67 million people."},]
+    )
+```
+
+At any point we can retrieve the recent history of the conversation. It will be ordered by entry time.
+
+
+```python
+context = chat_session.get_recent()
+for message in context:
+    print(message)
+```
+
+    {'role': 'llm', 'content': 'The capital is Paris.'}
+    {'role': 'user', 'content': 'And what is the capital of Spain?'}
+    {'role': 'llm', 'content': 'The capital is Madrid.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+
+
+In many LLM flows the conversation progresses in a series of prompt and response pairs. session managers offer a convienience function `store()` to add these simply.
+
+
+```python
+prompt = "what is the size of England compared to Portugal?"
+response = "England is larger in land area than Portal by about 15000 square miles."
+chat_session.store(prompt, response)
+
+context = chat_session.get_recent(top_k=6)
+for message in context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'And what is the capital of Spain?'}
+    {'role': 'llm', 'content': 'The capital is Madrid.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+
+
+## Managing multiple users and conversations
+
+For applications that need to handle multiple conversations concurrently, Redis supports tagging messages to keep conversations separated.
+
+
+```python
+chat_session.add_message({"role":"system", "content":"You are a helpful algebra tutor, giving simple answers to math problems."}, session_tag='student two')
+chat_session.add_messages([
+    {"role":"user", "content":"What is the value of x in the equation 2x + 3 = 7?"},
+    {"role":"llm", "content":"The value of x is 2."},
+    {"role":"user", "content":"What is the value of y in the equation 3y - 5 = 7?"},
+    {"role":"llm", "content":"The value of y is 4."}],
+    session_tag='student two'
+    )
+
+for math_message in chat_session.get_recent(session_tag='student two'):
+    print(math_message)
+```
+
+    {'role': 'system', 'content': 'You are a helpful algebra tutor, giving simple answers to math problems.'}
+    {'role': 'user', 'content': 'What is the value of x in the equation 2x + 3 = 7?'}
+    {'role': 'llm', 'content': 'The value of x is 2.'}
+    {'role': 'user', 'content': 'What is the value of y in the equation 3y - 5 = 7?'}
+    {'role': 'llm', 'content': 'The value of y is 4.'}
+
+
+## Semantic conversation memory
+For longer conversations our list of messages keeps growing. Since LLMs are stateless we have to continue to pass this conversation history on each subsequent call to ensure the LLM has the correct context.
+
+A typical flow looks like this:
+```
+while True:
+    prompt = input('enter your next question')
+    context = chat_session.get_recent()
+    response = LLM_api_call(prompt=prompt, context=context)
+    chat_session.store(prompt, response)
+```
+
+This works, but as context keeps growing so too does our LLM token count, which increases latency and cost.
+
+Conversation histories can be truncated, but that can lead to losing relevant information that appeared early on.
+
+A better solution is to pass only the relevant conversational context on each subsequent call.
+
+For this, RedisVL has the `SemanticSessionManager`, which uses vector similarity search to return only semantically relevant sections of the conversation.
+
+
+```python
+from redisvl.extensions.session_manager import SemanticSessionManager
+semantic_session = SemanticSessionManager(name='tutor')
+
+semantic_session.add_messages(chat_session.get_recent(top_k=8))
+```
+
+    12:24:15 redisvl.index.index INFO   Index already exists, not overwriting.
+
+
+
+```python
+prompt = "what have I learned about the size of England?"
+semantic_session.set_distance_threshold(0.35)
+context = semantic_session.get_relevant(prompt)
+for message in context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+
+
+You can adjust the degree of semantic similarity needed to be included in your context.
+
+Setting a distance threshold close to 0.0 will require an exact semantic match, while a distance threshold of 1.0 will include everthing.
+
+
+```python
+semantic_session.set_distance_threshold(0.7)
+
+larger_context = semantic_session.get_relevant(prompt)
+for message in larger_context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+
+
+## Conversation control
+
+LLMs can hallucinate on occasion and when this happens it can be useful to prune incorrect information from conversational histories so this incorrect information doesn't continue to be passed as context.
+
+
+```python
+semantic_session.store(
+    prompt="what is the smallest country in Europe?",
+    response="Monaco is the smallest country in Europe at 0.78 square miles." # Incorrect. Vatican City is the smallest country in Europe
+    )
+
+# get the key of the incorrect message
+context = semantic_session.get_recent(top_k=1, raw=True)
+bad_key = context[0]['entry_id']
+semantic_session.drop(bad_key)
+
+corrected_context = semantic_session.get_recent()
+for message in corrected_context:
+    print(message)
+```
+
+    {'role': 'user', 'content': 'What is the population of Great Britain?'}
+    {'role': 'llm', 'content': 'As of 2023 the population of Great Britain is approximately 67 million people.'}
+    {'role': 'user', 'content': 'what is the size of England compared to Portugal?'}
+    {'role': 'llm', 'content': 'England is larger in land area than Portal by about 15000 square miles.'}
+    {'role': 'user', 'content': 'what is the smallest country in Europe?'}
+
+
+
+```python
+chat_session.clear()
+```
+---
+linkTitle: Semantic caching for LLMs
+title: Semantic Caching for LLMs
+type: integration
+weight: 03
+---
+
+
+RedisVL provides a ``SemanticCache`` interface to utilize Redis' built-in caching capabilities AND vector search in order to store responses from previously-answered questions. This reduces the number of requests and tokens sent to the Large Language Models (LLM) service, decreasing costs and enhancing application throughput (by reducing the time taken to generate responses).
+
+This notebook will go over how to use Redis as a Semantic Cache for your applications
+
+First, we will import [OpenAI](https://platform.openai.com) to use their API for responding to user prompts. We will also create a simple `ask_openai` helper method to assist.
+
+
+```python
+import os
+import getpass
+import time
+import numpy as np
+
+from openai import OpenAI
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "False"
+
+api_key = os.getenv("OPENAI_API_KEY") or getpass.getpass("Enter your OpenAI API key: ")
+
+client = OpenAI(api_key=api_key)
+
+def ask_openai(question: str) -> str:
+    response = client.completions.create(
+      model="gpt-3.5-turbo-instruct",
+      prompt=question,
+      max_tokens=200
+    )
+    return response.choices[0].text.strip()
+```
+
+
+```python
+# Test
+print(ask_openai("What is the capital of France?"))
+```
+
+    19:17:51 httpx INFO   HTTP Request: POST https://api.openai.com/v1/completions "HTTP/1.1 200 OK"
+    The capital of France is Paris.
+
+
+## Initializing ``SemanticCache``
+
+``SemanticCache`` will automatically create an index within Redis upon initialization for the semantic cache content.
+
+
+```python
+from redisvl.extensions.cache.llm import SemanticCache
+from redisvl.utils .vectorize import HFTextVectorizer
+
+llmcache = SemanticCache(
+    name="llmcache",                                          # underlying search index name
+    redis_url="redis://localhost:6379",                       # redis connection url string
+    distance_threshold=0.1,                                   # semantic cache distance threshold
+    vectorizer=HFTextVectorizer("redis/langcache-embed-v1"),  # embdding model
+)
+```
+
+    19:17:51 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:17:51 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: redis/langcache-embed-v1
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 17.57it/s]
+
+
+
+```python
+# look at the index specification created for the semantic cache lookup
+!rvl index info -i llmcache
+```
+
+    
+    
+    Index Information:
+    ╭───────────────┬───────────────┬───────────────┬───────────────┬───────────────╮
+    │ Index Name    │ Storage Type  │ Prefixes      │ Index Options │ Indexing      │
+    ├───────────────┼───────────────┼───────────────┼───────────────┼───────────────┤
+    | llmcache      | HASH          | ['llmcache']  | []            | 0             |
+    ╰───────────────┴───────────────┴───────────────┴───────────────┴───────────────╯
+    Index Fields:
+    ╭─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────╮
+    │ Name            │ Attribute       │ Type            │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │
+    ├─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┤
+    │ prompt          │ prompt          │ TEXT            │ WEIGHT          │ 1               │                 │                 │                 │                 │                 │                 │
+    │ response        │ response        │ TEXT            │ WEIGHT          │ 1               │                 │                 │                 │                 │                 │                 │
+    │ inserted_at     │ inserted_at     │ NUMERIC         │                 │                 │                 │                 │                 │                 │                 │                 │
+    │ updated_at      │ updated_at      │ NUMERIC         │                 │                 │                 │                 │                 │                 │                 │                 │
+    │ prompt_vector   │ prompt_vector   │ VECTOR          │ algorithm       │ FLAT            │ data_type       │ FLOAT32         │ dim             │ 768             │ distance_metric │ COSINE          │
+    ╰─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────╯
+
+
+## Basic Cache Usage
+
+
+```python
+question = "What is the capital of France?"
+```
+
+
+```python
+# Check the semantic cache -- should be empty
+if response := llmcache.check(prompt=question):
+    print(response)
+else:
+    print("Empty cache")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 18.30it/s]
+
+    Empty cache
+
+
+    
+
+
+Our initial cache check should be empty since we have not yet stored anything in the cache. Below, store the `question`,
+proper `response`, and any arbitrary `metadata` (as a python dictionary object) in the cache.
+
+
+```python
+# Cache the question, answer, and arbitrary metadata
+llmcache.store(
+    prompt=question,
+    response="Paris",
+    metadata={"city": "Paris", "country": "france"}
+)
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 26.10it/s]
+
+
+
+
+
+    'llmcache:115049a298532be2f181edb03f766770c0db84c22aff39003fec340deaec7545'
+
+
+
+Now we will check the cache again with the same question and with a semantically similar question:
+
+
+```python
+# Check the cache again
+if response := llmcache.check(prompt=question, return_fields=["prompt", "response", "metadata"]):
+    print(response)
+else:
+    print("Empty cache")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 12.36it/s]
+
+
+    [{'prompt': 'What is the capital of France?', 'response': 'Paris', 'metadata': {'city': 'Paris', 'country': 'france'}, 'key': 'llmcache:115049a298532be2f181edb03f766770c0db84c22aff39003fec340deaec7545'}]
+
+
+
+```python
+# Check for a semantically similar result
+question = "What actually is the capital of France?"
+llmcache.check(prompt=question)[0]['response']
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 12.22it/s]
+
+
+
+
+
+    'Paris'
+
+
+
+## Customize the Distance Threshhold
+
+For most use cases, the right semantic similarity threshhold is not a fixed quantity. Depending on the choice of embedding model,
+the properties of the input query, and even business use case -- the threshhold might need to change. 
+
+Fortunately, you can seamlessly adjust the threshhold at any point like below:
+
+
+```python
+# Widen the semantic distance threshold
+llmcache.set_threshold(0.5)
+```
+
+
+```python
+# Really try to trick it by asking around the point
+# But is able to slip just under our new threshold
+question = "What is the capital city of the country in Europe that also has a city named Nice?"
+llmcache.check(prompt=question)[0]['response']
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 19.20it/s]
+
+
+
+
+
+    'Paris'
+
+
+
+
+```python
+# Invalidate the cache completely by clearing it out
+llmcache.clear()
+
+# should be empty now
+llmcache.check(prompt=question)
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 26.71it/s]
+
+
+
+
+
+    []
+
+
+
+## Utilize TTL
+
+Redis uses TTL policies (optional) to expire individual keys at points in time in the future.
+This allows you to focus on your data flow and business logic without bothering with complex cleanup tasks.
+
+A TTL policy set on the `SemanticCache` allows you to temporarily hold onto cache entries. Below, we will set the TTL policy to 5 seconds.
+
+
+```python
+llmcache.set_ttl(5) # 5 seconds
+```
+
+
+```python
+llmcache.store("This is a TTL test", "This is a TTL test response")
+
+time.sleep(6)
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 20.45it/s]
+
+
+
+```python
+# confirm that the cache has cleared by now on it's own
+result = llmcache.check("This is a TTL test")
+
+print(result)
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 17.02it/s]
+
+    []
+
+
+    
+
+
+
+```python
+# Reset the TTL to null (long lived data)
+llmcache.set_ttl()
+```
+
+## Simple Performance Testing
+
+Next, we will measure the speedup obtained by using ``SemanticCache``. We will use the ``time`` module to measure the time taken to generate responses with and without ``SemanticCache``.
+
+
+```python
+def answer_question(question: str) -> str:
+    """Helper function to answer a simple question using OpenAI with a wrapper
+    check for the answer in the semantic cache first.
+
+    Args:
+        question (str): User input question.
+
+    Returns:
+        str: Response.
+    """
+    results = llmcache.check(prompt=question)
+    if results:
+        return results[0]["response"]
+    else:
+        answer = ask_openai(question)
+        return answer
+```
+
+
+```python
+start = time.time()
+# asking a question -- openai response time
+question = "What was the name of the first US President?"
+answer = answer_question(question)
+end = time.time()
+
+print(f"Without caching, a call to openAI to answer this simple question took {end-start} seconds.")
+
+# add the entry to our LLM cache
+llmcache.store(prompt=question, response="George Washington")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 14.88it/s]
+
+
+    19:18:04 httpx INFO   HTTP Request: POST https://api.openai.com/v1/completions "HTTP/1.1 200 OK"
+    Without caching, a call to openAI to answer this simple question took 0.8826751708984375 seconds.
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 18.38it/s]
+
+
+
+
+
+    'llmcache:67e0f6e28fe2a61c0022fd42bf734bb8ffe49d3e375fd69d692574295a20fc1a'
+
+
+
+
+```python
+# Calculate the avg latency for caching over LLM usage
+times = []
+
+for _ in range(10):
+    cached_start = time.time()
+    cached_answer = answer_question(question)
+    cached_end = time.time()
+    times.append(cached_end-cached_start)
+
+avg_time_with_cache = np.mean(times)
+print(f"Avg time taken with LLM cache enabled: {avg_time_with_cache}")
+print(f"Percentage of time saved: {round(((end - start) - avg_time_with_cache) / (end - start) * 100, 2)}%")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 13.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 25.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 26.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.07it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.35it/s]
+
+    Avg time taken with LLM cache enabled: 0.0463670015335083
+    Percentage of time saved: 94.75%
+
+
+    
+
+
+
+```python
+# check the stats of the index
+!rvl stats -i llmcache
+```
+
+    
+    Statistics:
+    ╭─────────────────────────────┬────────────╮
+    │ Stat Key                    │ Value      │
+    ├─────────────────────────────┼────────────┤
+    │ num_docs                    │ 1          │
+    │ num_terms                   │ 19         │
+    │ max_doc_id                  │ 3          │
+    │ num_records                 │ 29         │
+    │ percent_indexed             │ 1          │
+    │ hash_indexing_failures      │ 0          │
+    │ number_of_uses              │ 19         │
+    │ bytes_per_record_avg        │ 75.9655151 │
+    │ doc_table_size_mb           │ 1.34468078 │
+    │ inverted_sz_mb              │ 0.00210094 │
+    │ key_table_size_mb           │ 2.76565551 │
+    │ offset_bits_per_record_avg  │ 8          │
+    │ offset_vectors_sz_mb        │ 2.09808349 │
+    │ offsets_per_term_avg        │ 0.75862067 │
+    │ records_per_doc_avg         │ 29         │
+    │ sortable_values_size_mb     │ 0          │
+    │ total_indexing_time         │ 3.875      │
+    │ total_inverted_index_blocks │ 21         │
+    │ vector_index_sz_mb          │ 3.01609802 │
+    ╰─────────────────────────────┴────────────╯
+
+
+
+```python
+# Clear the cache AND delete the underlying index
+llmcache.delete()
+```
+
+## Cache Access Controls, Tags & Filters
+When running complex workflows with similar applications, or handling multiple users it's important to keep data segregated. Building on top of RedisVL's support for complex and hybrid queries we can tag and filter cache entries using custom-defined `filterable_fields`.
+
+Let's store multiple users' data in our cache with similar prompts and ensure we return only the correct user information:
+
+
+```python
+private_cache = SemanticCache(
+    name="private_cache",
+    filterable_fields=[{"name": "user_id", "type": "tag"}]
+)
+
+private_cache.store(
+    prompt="What is the phone number linked to my account?",
+    response="The number on file is 123-555-0000",
+    filters={"user_id": "abc"},
+)
+
+private_cache.store(
+    prompt="What's the phone number linked in my account?",
+    response="The number on file is 123-555-1111",
+    filters={"user_id": "def"},
+)
+```
+
+    19:18:07 [RedisVL] WARNING   The default vectorizer has changed from `sentence-transformers/all-mpnet-base-v2` to `redis/langcache-embed-v1` in version 0.6.0 of RedisVL. For more information about this model, please refer to https://arxiv.org/abs/2504.02268 or visit https://huggingface.co/redis/langcache-embed-v1. To continue using the old vectorizer, please specify it explicitly in the constructor as: vectorizer=HFTextVectorizer(model='sentence-transformers/all-mpnet-base-v2')
+    19:18:07 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:18:07 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: redis/langcache-embed-v1
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  8.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 24.89it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 26.95it/s]
+
+
+
+
+
+    'private_cache:2831a0659fb888e203cd9fedb9f65681bfa55e4977c092ed1bf87d42d2655081'
+
+
+
+
+```python
+from redisvl.query.filter import Tag
+
+# define user id filter
+user_id_filter = Tag("user_id") == "abc"
+
+response = private_cache.check(
+    prompt="What is the phone number linked to my account?",
+    filter_expression=user_id_filter,
+    num_results=2
+)
+
+print(f"found {len(response)} entry \n{response[0]['response']}")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 27.98it/s]
+
+    found 1 entry 
+    The number on file is 123-555-0000
+
+
+    
+
+
+
+```python
+# Cleanup
+private_cache.delete()
+```
+
+Multiple `filterable_fields` can be defined on a cache, and complex filter expressions can be constructed to filter on these fields, as well as the default fields already present.
+
+
+```python
+
+complex_cache = SemanticCache(
+    name='account_data',
+    filterable_fields=[
+        {"name": "user_id", "type": "tag"},
+        {"name": "account_type", "type": "tag"},
+        {"name": "account_balance", "type": "numeric"},
+        {"name": "transaction_amount", "type": "numeric"}
+    ]
+)
+complex_cache.store(
+    prompt="what is my most recent checking account transaction under $100?",
+    response="Your most recent transaction was for $75",
+    filters={"user_id": "abc", "account_type": "checking", "transaction_amount": 75},
+)
+complex_cache.store(
+    prompt="what is my most recent savings account transaction?",
+    response="Your most recent deposit was for $300",
+    filters={"user_id": "abc", "account_type": "savings", "transaction_amount": 300},
+)
+complex_cache.store(
+    prompt="what is my most recent checking account transaction over $200?",
+    response="Your most recent transaction was for $350",
+    filters={"user_id": "abc", "account_type": "checking", "transaction_amount": 350},
+)
+complex_cache.store(
+    prompt="what is my checking account balance?",
+    response="Your current checking account is $1850",
+    filters={"user_id": "abc", "account_type": "checking"},
+)
+```
+
+    19:18:09 [RedisVL] WARNING   The default vectorizer has changed from `sentence-transformers/all-mpnet-base-v2` to `redis/langcache-embed-v1` in version 0.6.0 of RedisVL. For more information about this model, please refer to https://arxiv.org/abs/2504.02268 or visit https://huggingface.co/redis/langcache-embed-v1. To continue using the old vectorizer, please specify it explicitly in the constructor as: vectorizer=HFTextVectorizer(model='sentence-transformers/all-mpnet-base-v2')
+    19:18:09 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    19:18:09 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: redis/langcache-embed-v1
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 13.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 16.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 21.82it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 21.04it/s]
+
+
+
+
+
+    'account_data:944f89729b09ca46b99923d223db45e0bccf584cfd53fcaf87d2a58f072582d3'
+
+
+
+
+```python
+from redisvl.query.filter import Num
+
+value_filter = Num("transaction_amount") > 100
+account_filter = Tag("account_type") == "checking"
+complex_filter = value_filter & account_filter
+
+# check for checking account transactions over $100
+complex_cache.set_threshold(0.3)
+response = complex_cache.check(
+    prompt="what is my most recent checking account transaction?",
+    filter_expression=complex_filter,
+    num_results=5
+)
+print(f'found {len(response)} entry')
+print(response[0]["response"])
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.15it/s]
+
+    found 1 entry
+    Your most recent transaction was for $350
+
+
+    
+
+
+
+```python
+# Cleanup
+complex_cache.delete()
+```
+---
+linkTitle: Querying with RedisVL
+title: Querying with RedisVL
+type: integration
+weight: 02
+---
+
+
+In this notebook, we will explore more complex queries that can be performed with ``redisvl``
+
+Before running this notebook, be sure to
+1. Have installed ``redisvl`` and have that environment active for this notebook.
+2. Have a running Redis instance with RediSearch > 2.4 running.
+
+
+```python
+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)
+```
+
+
+<table><tr><th>user</th><th>age</th><th>job</th><th>credit_score</th><th>office_location</th><th>user_embedding</th><th>last_updated</th></tr><tr><td>john</td><td>18</td><td>engineer</td><td>high</td><td>-122.4194,37.7749</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'</td><td>1741627789</td></tr><tr><td>derrick</td><td>14</td><td>doctor</td><td>low</td><td>-122.4194,37.7749</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc=\x00\x00\x00?'</td><td>1741627789</td></tr><tr><td>nancy</td><td>94</td><td>doctor</td><td>high</td><td>-122.4194,37.7749</td><td>b'333?\xcd\xcc\xcc=\x00\x00\x00?'</td><td>1710696589</td></tr><tr><td>tyler</td><td>100</td><td>engineer</td><td>high</td><td>-122.0839,37.3861</td><td>b'\xcd\xcc\xcc=\xcd\xcc\xcc>\x00\x00\x00?'</td><td>1742232589</td></tr><tr><td>tim</td><td>12</td><td>dermatologist</td><td>high</td><td>-122.0839,37.3861</td><td>b'\xcd\xcc\xcc>\xcd\xcc\xcc>\x00\x00\x00?'</td><td>1739644189</td></tr><tr><td>taimur</td><td>15</td><td>CEO</td><td>low</td><td>-122.0839,37.3861</td><td>b'\x9a\x99\x19?\xcd\xcc\xcc=\x00\x00\x00?'</td><td>1742232589</td></tr><tr><td>joe</td><td>35</td><td>dentist</td><td>medium</td><td>-122.0839,37.3861</td><td>b'fff?fff?\xcd\xcc\xcc='</td><td>1742232589</td></tr></table>
+
+
+
+```python
+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"
+            }
+
+        }
+    ],
+}
+```
+
+
+```python
+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)
+```
+
+    11:40:25 redisvl.index.index INFO   Index already exists, overwriting.
+
+
+
+```python
+# use the CLI to see the created index
+!rvl index listall
+```
+
+
+```python
+# load data to redis
+keys = index.load(data)
+```
+
+
+```python
+index.info()['num_docs']
+```
+
+
+
+
+    7
+
+
+
+## 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.
+
+### Tag Filters
+
+Tag filters are filters that are applied to tag fields. These are fields that are not tokenized and are used to store a single categorical value.
+
+
+```python
+from redisvl.query import VectorQuery
+from redisvl.query.filter import Tag
+
+t = Tag("credit_score") == "high"
+
+v = VectorQuery(
+    vector=[0.1, 0.1, 0.5],
+    vector_field_name="user_embedding",
+    return_fields=["user", "credit_score", "age", "job", "office_location", "last_updated"],
+    filter_expression=t
+)
+
+results = index.query(v)
+result_print(results)
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td><td>1742232589</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td><td>1739644189</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td><td>1710696589</td></tr></table>
+
+
+
+```python
+# negation
+t = Tag("credit_score") != "high"
+
+v.set_filter(t)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td><td>1742232589</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td><td>1742232589</td></tr></table>
+
+
+
+```python
+# use multiple tags as a list
+t = Tag("credit_score") == ["high", "medium"]
+
+v.set_filter(t)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# use multiple tags as a set (to enforce uniqueness)
+t = Tag("credit_score") == set(["high", "high", "medium"])
+
+v.set_filter(t)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr></table>
+
+
+What about scenarios where you might want to dynamically generate a list of tags? Have no fear. RedisVL allows you to do this gracefully without having to check for the **empty case**. The **empty case** is when you attempt to run a Tag filter on a field with no defined values to match:
+
+`Tag("credit_score") == []`
+
+An empty filter like the one above will yield a `*` Redis query filter which implies the base case -- there is no filter here to use.
+
+
+```python
+# gracefully fallback to "*" filter if empty case
+empty_case = Tag("credit_score") == []
+
+v.set_filter(empty_case)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr></table>
+
+
+### Numeric Filters
+
+Numeric filters are filters that are applied to numeric fields and can be used to isolate a range of values for a given field.
+
+
+```python
+from redisvl.query.filter import Num
+
+numeric_filter = Num("age").between(15, 35)
+
+v.set_filter(numeric_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td><td>1742232589</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td><td>1742232589</td></tr></table>
+
+
+
+```python
+# exact match query
+numeric_filter = Num("age") == 14
+
+v.set_filter(numeric_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+
+```python
+# negation
+numeric_filter = Num("age") != 14
+
+v.set_filter(numeric_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+### Timestamp Filters
+
+In redis all times are stored as an epoch time numeric however, this class allows you to filter with python datetime for ease of use. 
+
+
+```python
+from redisvl.query.filter import Timestamp
+from datetime import datetime
+
+dt = datetime(2025, 3, 16, 13, 45, 39, 132589)
+print(f'Epoch comparison: {dt.timestamp()}')
+
+timestamp_filter = Timestamp("last_updated") > dt
+
+v.set_filter(timestamp_filter)
+result_print(index.query(v))
+```
+
+    Epoch comparison: 1742147139.132589
+
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td><td>1742232589</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td><td>1742232589</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td><td>1742232589</td></tr></table>
+
+
+
+```python
+from redisvl.query.filter import Timestamp
+from datetime import datetime
+
+dt = datetime(2025, 3, 16, 13, 45, 39, 132589)
+
+print(f'Epoch comparison: {dt.timestamp()}')
+
+timestamp_filter = Timestamp("last_updated") < dt
+
+v.set_filter(timestamp_filter)
+result_print(index.query(v))
+```
+
+    Epoch comparison: 1742147139.132589
+
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td><td>1739644189</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td><td>1710696589</td></tr></table>
+
+
+
+```python
+from redisvl.query.filter import Timestamp
+from datetime import datetime
+
+dt_1 = datetime(2025, 1, 14, 13, 45, 39, 132589)
+dt_2 = datetime(2025, 3, 16, 13, 45, 39, 132589)
+
+print(f'Epoch between: {dt_1.timestamp()} - {dt_2.timestamp()}')
+
+timestamp_filter = Timestamp("last_updated").between(dt_1, dt_2)
+
+v.set_filter(timestamp_filter)
+result_print(index.query(v))
+```
+
+    Epoch between: 1736880339.132589 - 1742147139.132589
+
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td><td>1739644189</td></tr></table>
+
+
+### Text Filters
+
+Text filters are filters that are applied to text fields. These filters are applied to the entire text field. For example, if you have a text field that contains the text "The quick brown fox jumps over the lazy dog", a text filter of "quick" will match this text field.
+
+
+```python
+from redisvl.query.filter import Text
+
+# exact match filter -- document must contain the exact word doctor
+text_filter = Text("job") == "doctor"
+
+v.set_filter(text_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th><th>last_updated</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td><td>1741627789</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td><td>1710696589</td></tr></table>
+
+
+
+```python
+# negation -- document must not contain the exact word doctor
+negate_text_filter = Text("job") != "doctor"
+
+v.set_filter(negate_text_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# wildcard match filter
+wildcard_filter = Text("job") % "doct*"
+
+v.set_filter(wildcard_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+
+```python
+# fuzzy match filter
+fuzzy_match = Text("job") % "%%engine%%"
+
+v.set_filter(fuzzy_match)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# conditional -- match documents with job field containing engineer OR doctor
+conditional = Text("job") % "engineer|doctor"
+
+v.set_filter(conditional)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+
+```python
+# gracefully fallback to "*" filter if empty case
+empty_case = Text("job") % ""
+
+v.set_filter(empty_case)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr></table>
+
+
+Use raw query strings as input. Below we use the `~` flag to indicate that the full text query is optional. We also choose the BM25 scorer and return document scores along with the result.
+
+
+```python
+v.set_filter("(~(@job:engineer))")
+v.scorer("BM25").with_scores()
+
+index.query(v)
+```
+
+
+
+
+    [{'id': 'user_queries_docs:01JMJJHE28ZW4F33ZNRKXRHYCS',
+      'score': 1.8181817787737895,
+      'vector_distance': '0',
+      'user': 'john',
+      'credit_score': 'high',
+      'age': '18',
+      'job': 'engineer',
+      'office_location': '-122.4194,37.7749'},
+     {'id': 'user_queries_docs:01JMJJHE2899024DYPXT6424N9',
+      'score': 0.0,
+      'vector_distance': '0',
+      'user': 'derrick',
+      'credit_score': 'low',
+      'age': '14',
+      'job': 'doctor',
+      'office_location': '-122.4194,37.7749'},
+     {'id': 'user_queries_docs:01JMJJPEYCQ89ZQW6QR27J72WT',
+      'score': 1.8181817787737895,
+      'vector_distance': '0',
+      'user': 'john',
+      'credit_score': 'high',
+      'age': '18',
+      'job': 'engineer',
+      'office_location': '-122.4194,37.7749'},
+     {'id': 'user_queries_docs:01JMJJPEYD544WB1TKDBJ3Z3J9',
+      'score': 0.0,
+      'vector_distance': '0',
+      'user': 'derrick',
+      'credit_score': 'low',
+      'age': '14',
+      'job': 'doctor',
+      'office_location': '-122.4194,37.7749'},
+     {'id': 'user_queries_docs:01JMJJHE28B5R6T00DH37A7KSJ',
+      'score': 1.8181817787737895,
+      'vector_distance': '0.109129190445',
+      'user': 'tyler',
+      'credit_score': 'high',
+      'age': '100',
+      'job': 'engineer',
+      'office_location': '-122.0839,37.3861'},
+     {'id': 'user_queries_docs:01JMJJPEYDPF9S5328WHCQN0ND',
+      'score': 1.8181817787737895,
+      'vector_distance': '0.109129190445',
+      'user': 'tyler',
+      'credit_score': 'high',
+      'age': '100',
+      'job': 'engineer',
+      'office_location': '-122.0839,37.3861'},
+     {'id': 'user_queries_docs:01JMJJHE28G5F943YGWMB1ZX1V',
+      'score': 0.0,
+      'vector_distance': '0.158808946609',
+      'user': 'tim',
+      'credit_score': 'high',
+      'age': '12',
+      'job': 'dermatologist',
+      'office_location': '-122.0839,37.3861'},
+     {'id': 'user_queries_docs:01JMJJPEYDKA9ARKHRK1D7KPXQ',
+      'score': 0.0,
+      'vector_distance': '0.158808946609',
+      'user': 'tim',
+      'credit_score': 'high',
+      'age': '12',
+      'job': 'dermatologist',
+      'office_location': '-122.0839,37.3861'},
+     {'id': 'user_queries_docs:01JMJJHE28NR7KF0EZEA433T2J',
+      'score': 0.0,
+      'vector_distance': '0.217882037163',
+      'user': 'taimur',
+      'credit_score': 'low',
+      'age': '15',
+      'job': 'CEO',
+      'office_location': '-122.0839,37.3861'},
+     {'id': 'user_queries_docs:01JMJJPEYD9EAVGJ2AZ8K9VX7Q',
+      'score': 0.0,
+      'vector_distance': '0.217882037163',
+      'user': 'taimur',
+      'credit_score': 'low',
+      'age': '15',
+      'job': 'CEO',
+      'office_location': '-122.0839,37.3861'}]
+
+
+
+### Geographic Filters
+
+Geographic filters are filters that are applied to geographic fields. These filters are used to find results that are within a certain distance of a given point. The distance is specified in kilometers, miles, meters, or feet. A radius can also be specified to find results within a certain radius of a given point.
+
+
+```python
+from redisvl.query.filter import Geo, GeoRadius
+
+# within 10 km of San Francisco office
+geo_filter = Geo("office_location") == GeoRadius(-122.4194, 37.7749, 10, "km")
+
+v.set_filter(geo_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>score</th><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.4545454446934474</td><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+
+```python
+# within 100 km Radius of San Francisco office
+geo_filter = Geo("office_location") == GeoRadius(-122.4194, 37.7749, 100, "km")
+
+v.set_filter(geo_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>score</th><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.4545454446934474</td><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.4545454446934474</td><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.4545454446934474</td><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.4545454446934474</td><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.4545454446934474</td><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.4545454446934474</td><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.4545454446934474</td><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# not within 10 km Radius of San Francisco office
+geo_filter = Geo("office_location") != GeoRadius(-122.4194, 37.7749, 10, "km")
+
+v.set_filter(geo_filter)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>score</th><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.0</td><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr><tr><td>0.0</td><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr></table>
+
+
+## Combining Filters
+
+In this example, we will combine a numeric filter with a tag filter. We will search for users that are between the ages of 20 and 30 and have a job of "engineer".
+
+### Intersection ("and")
+
+
+```python
+t = Tag("credit_score") == "high"
+low = Num("age") >= 18
+high = Num("age") <= 100
+ts = Timestamp("last_updated") > datetime(2025, 3, 16, 13, 45, 39, 132589)
+
+combined = t & low & high & ts
+
+v = VectorQuery([0.1, 0.1, 0.5],
+                "user_embedding",
+                return_fields=["user", "credit_score", "age", "job",  "office_location"],
+                filter_expression=combined)
+
+
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr></table>
+
+
+### Union ("or")
+
+The union of two queries is the set of all results that are returned by either of the two queries. The union of two queries is performed using the `|` operator.
+
+
+```python
+low = Num("age") < 18
+high = Num("age") > 93
+
+combined = low | high
+
+v.set_filter(combined)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+### Dynamic Combination
+
+There are often situations where you may or may not want to use a filter in a
+given query. As shown above, filters will except the ``None`` type and revert
+to a wildcard filter essentially returning all results.
+
+The same goes for filter combinations which enables rapid reuse of filters in
+requests with different parameters as shown below. This removes the need for
+a number of "if-then" conditionals to test for the empty case.
+
+
+
+
+```python
+def make_filter(age=None, credit=None, job=None):
+    flexible_filter = (
+        (Num("age") > age) &
+        (Tag("credit_score") == credit) &
+        (Text("job") % job)
+    )
+    return flexible_filter
+
+```
+
+
+```python
+# all parameters
+combined = make_filter(age=18, credit="high", job="engineer")
+v.set_filter(combined)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# just age and credit_score
+combined = make_filter(age=18, credit="high")
+v.set_filter(combined)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr></table>
+
+
+
+```python
+# just age
+combined = make_filter(age=18)
+v.set_filter(combined)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.266666650772</td><td>nancy</td><td>high</td><td>94</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr><tr><td>0.653301358223</td><td>joe</td><td>medium</td><td>35</td><td>dentist</td><td>-122.0839,37.3861</td></tr></table>
+
+
+
+```python
+# no filters
+combined = make_filter()
+v.set_filter(combined)
+result_print(index.query(v))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th><th>office_location</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td><td>-122.4194,37.7749</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr><tr><td>0.217882037163</td><td>taimur</td><td>low</td><td>15</td><td>CEO</td><td>-122.0839,37.3861</td></tr></table>
+
+
+## Non-vector Queries
+
+In some cases, you may not want to run a vector query, but just use a ``FilterExpression`` similar to a SQL query. The ``FilterQuery`` class enable this functionality. It is similar to the ``VectorQuery`` class but soley takes a ``FilterExpression``.
+
+
+```python
+from redisvl.query import FilterQuery
+
+has_low_credit = Tag("credit_score") == "low"
+
+filter_query = FilterQuery(
+    return_fields=["user", "credit_score", "age", "job", "location"],
+    filter_expression=has_low_credit
+)
+
+results = index.query(filter_query)
+
+result_print(results)
+```
+
+
+<table><tr><th>user</th><th>credit_score</th><th>age</th><th>job</th></tr><tr><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr><tr><td>taimur</td><td>low</td><td>15</td><td>CEO</td></tr><tr><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr><tr><td>taimur</td><td>low</td><td>15</td><td>CEO</td></tr></table>
+
+
+## Count Queries
+
+In some cases, you may need to use a ``FilterExpression`` to execute a ``CountQuery`` that simply returns the count of the number of entities in the pertaining set. It is similar to the ``FilterQuery`` class but does not return the values of the underlying data.
+
+
+```python
+from redisvl.query import CountQuery
+
+has_low_credit = Tag("credit_score") == "low"
+
+filter_query = CountQuery(filter_expression=has_low_credit)
+
+count = index.query(filter_query)
+
+print(f"{count} records match the filter expression {str(has_low_credit)} for the given index.")
+```
+
+    4 records match the filter expression @credit_score:{low} for the given index.
+
+
+## Range Queries
+
+Range Queries are a useful method to perform a vector search where only results within a vector ``distance_threshold`` are returned. This enables the user to find all records within their dataset that are similar to a query vector where "similar" is defined by a quantitative value.
+
+
+```python
+from redisvl.query import RangeQuery
+
+range_query = RangeQuery(
+    vector=[0.1, 0.1, 0.5],
+    vector_field_name="user_embedding",
+    return_fields=["user", "credit_score", "age", "job", "location"],
+    distance_threshold=0.2
+)
+
+# same as the vector query or filter query
+results = index.query(range_query)
+
+result_print(results)
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td></tr><tr><td>0.109129190445</td><td>tyler</td><td>high</td><td>100</td><td>engineer</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td></tr><tr><td>0.158808946609</td><td>tim</td><td>high</td><td>12</td><td>dermatologist</td></tr></table>
+
+
+We can also change the distance threshold of the query object between uses if we like. Here we will set ``distance_threshold==0.1``. This means that the query object will return all matches that are within 0.1 of the query object. This is a small distance, so we expect to get fewer matches than before.
+
+
+```python
+range_query.set_distance_threshold(0.1)
+
+result_print(index.query(range_query))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr><tr><td>0</td><td>derrick</td><td>low</td><td>14</td><td>doctor</td></tr></table>
+
+
+Range queries can also be used with filters like any other query type. The following limits the results to only include records with a ``job`` of ``engineer`` while also being within the vector range (aka distance).
+
+
+```python
+is_engineer = Text("job") == "engineer"
+
+range_query.set_filter(is_engineer)
+
+result_print(index.query(range_query))
+```
+
+
+<table><tr><th>vector_distance</th><th>user</th><th>credit_score</th><th>age</th><th>job</th></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr><tr><td>0</td><td>john</td><td>high</td><td>18</td><td>engineer</td></tr></table>
+
+
+## Advanced Query Modifiers
+
+See all modifier options available on the query API docs: https://redis.io/docs/latest/integrate/redisvl/api/query
+
+
+```python
+# Sort by a different field and change dialect
+v = VectorQuery(
+    vector=[0.1, 0.1, 0.5],
+    vector_field_name="user_embedding",
+    return_fields=["user", "credit_score", "age", "job",  "office_location"],
+    num_results=5,
+    filter_expression=is_engineer
+).sort_by("age", asc=False).dialect(3)
+
+result = index.query(v)
+result_print(result)
+```
+
+
+<table><tr><th>vector_distance</th><th>age</th><th>user</th><th>credit_score</th><th>job</th><th>office_location</th></tr><tr><td>0.109129190445</td><td>100</td><td>tyler</td><td>high</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0.109129190445</td><td>100</td><td>tyler</td><td>high</td><td>engineer</td><td>-122.0839,37.3861</td></tr><tr><td>0</td><td>18</td><td>john</td><td>high</td><td>engineer</td><td>-122.4194,37.7749</td></tr><tr><td>0</td><td>18</td><td>john</td><td>high</td><td>engineer</td><td>-122.4194,37.7749</td></tr></table>
+
+
+### Raw Redis Query String
+
+Sometimes it's helpful to convert these classes into their raw Redis query strings.
+
+
+```python
+# check out the complex query from above
+str(v)
+```
+
+
+
+
+    '@job:("engineer")=>[KNN 5 @user_embedding $vector AS vector_distance] RETURN 6 user credit_score age job office_location vector_distance SORTBY age DESC DIALECT 3 LIMIT 0 5'
+
+
+
+
+```python
+t = Tag("credit_score") == "high"
+
+str(t)
+```
+
+
+
+
+    '@credit_score:{high}'
+
+
+
+
+```python
+t = Tag("credit_score") == "high"
+low = Num("age") >= 18
+high = Num("age") <= 100
+
+combined = t & low & high
+
+str(combined)
+```
+
+
+
+
+    '((@credit_score:{high} @age:[18 +inf]) @age:[-inf 100])'
+
+
+
+The RedisVL `SearchIndex` class exposes a `search()` method which is a simple wrapper around the `FT.SEARCH` API.
+Provide any valid Redis query string.
+
+
+```python
+results = index.search(str(t))
+for r in results.docs:
+    print(r.__dict__)
+```
+
+    {'id': 'user_queries_docs:01JMJJHE28G5F943YGWMB1ZX1V', 'payload': None, 'user': 'tim', 'age': '12', 'job': 'dermatologist', 'credit_score': 'high', 'office_location': '-122.0839,37.3861', 'user_embedding': '>>\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJHE28ZW4F33ZNRKXRHYCS', 'payload': None, 'user': 'john', 'age': '18', 'job': 'engineer', 'credit_score': 'high', 'office_location': '-122.4194,37.7749', 'user_embedding': '==\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJHE28B5R6T00DH37A7KSJ', 'payload': None, 'user': 'tyler', 'age': '100', 'job': 'engineer', 'credit_score': 'high', 'office_location': '-122.0839,37.3861', 'user_embedding': '=>\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJHE28EX13NEE7BGBM8FH3', 'payload': None, 'user': 'nancy', 'age': '94', 'job': 'doctor', 'credit_score': 'high', 'office_location': '-122.4194,37.7749', 'user_embedding': '333?=\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJPEYCQ89ZQW6QR27J72WT', 'payload': None, 'user': 'john', 'age': '18', 'job': 'engineer', 'credit_score': 'high', 'office_location': '-122.4194,37.7749', 'user_embedding': '==\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJPEYDAN0M3V7EQEVPS6HX', 'payload': None, 'user': 'nancy', 'age': '94', 'job': 'doctor', 'credit_score': 'high', 'office_location': '-122.4194,37.7749', 'user_embedding': '333?=\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJPEYDPF9S5328WHCQN0ND', 'payload': None, 'user': 'tyler', 'age': '100', 'job': 'engineer', 'credit_score': 'high', 'office_location': '-122.0839,37.3861', 'user_embedding': '=>\x00\x00\x00?'}
+    {'id': 'user_queries_docs:01JMJJPEYDKA9ARKHRK1D7KPXQ', 'payload': None, 'user': 'tim', 'age': '12', 'job': 'dermatologist', 'credit_score': 'high', 'office_location': '-122.0839,37.3861', 'user_embedding': '>>\x00\x00\x00?'}
+
+
+
+```python
+# Cleanup
+index.delete()
+```
+---
+linkTitle: Caching embeddings
+title: Caching Embeddings
+type: integration
+weight: 10
+---
+
+
+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.
+
+## Setup
+
+First, let's import the necessary libraries. We'll use a text embedding model from HuggingFace to generate our embeddings.
+
+
+```python
+import os
+import time
+import numpy as np
+
+# Disable tokenizers parallelism to avoid deadlocks
+os.environ["TOKENIZERS_PARALLELISM"] = "False"
+
+# Import the EmbeddingsCache
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+from redisvl.utils.vectorize import HFTextVectorizer
+```
+
+Let's create a vectorizer to generate embeddings for our texts:
+
+
+```python
+# Initialize the vectorizer
+vectorizer = HFTextVectorizer(
+    model="redis/langcache-embed-v1",
+    cache_folder=os.getenv("SENTENCE_TRANSFORMERS_HOME")
+)
+```
+
+    /Users/tyler.hutcherson/Library/Caches/pypoetry/virtualenvs/redisvl-VnTEShF2-py3.13/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
+      from .autonotebook import tqdm as notebook_tqdm
+    Compiling the model with `torch.compile` and using a `torch.mps` device is not supported. Falling back to non-compiled mode.
+
+
+## Initializing the EmbeddingsCache
+
+Now let's initialize our `EmbeddingsCache`. The cache requires a Redis connection to store the embeddings and their associated data.
+
+
+```python
+# Initialize the embeddings cache
+cache = EmbeddingsCache(
+    name="embedcache",                  # name prefix for Redis keys
+    redis_url="redis://localhost:6379",  # Redis connection URL
+    ttl=None                            # Optional TTL in seconds (None means no expiration)
+)
+```
+
+## Basic Usage
+
+### Storing Embeddings
+
+Let's store some text with its embedding in the cache. The `set` method takes the following parameters:
+- `text`: The input text that was embedded
+- `model_name`: The name of the embedding model used
+- `embedding`: The embedding vector
+- `metadata`: Optional metadata associated with the embedding
+- `ttl`: Optional time-to-live override for this specific entry
+
+
+```python
+# Text to embed
+text = "What is machine learning?"
+model_name = "redis/langcache-embed-v1"
+
+# Generate the embedding
+embedding = vectorizer.embed(text)
+
+# Optional metadata
+metadata = {"category": "ai", "source": "user_query"}
+
+# Store in cache
+key = cache.set(
+    text=text,
+    model_name=model_name,
+    embedding=embedding,
+    metadata=metadata
+)
+
+print(f"Stored with key: {key[:15]}...")
+```
+
+    Stored with key: embedcache:909f...
+
+
+### Retrieving Embeddings
+
+To retrieve an embedding from the cache, use the `get` method with the original text and model name:
+
+
+```python
+# Retrieve from cache
+
+if result := cache.get(text=text, model_name=model_name):
+    print(f"Found in cache: {result['text']}")
+    print(f"Model: {result['model_name']}")
+    print(f"Metadata: {result['metadata']}")
+    print(f"Embedding shape: {np.array(result['embedding']).shape}")
+else:
+    print("Not found in cache.")
+```
+
+    Found in cache: What is machine learning?
+    Model: redis/langcache-embed-v1
+    Metadata: {'category': 'ai', 'source': 'user_query'}
+    Embedding shape: (768,)
+
+
+### Checking Existence
+
+You can check if an embedding exists in the cache without retrieving it using the `exists` method:
+
+
+```python
+# Check if existing text is in cache
+exists = cache.exists(text=text, model_name=model_name)
+print(f"First query exists in cache: {exists}")
+
+# Check if a new text is in cache
+new_text = "What is deep learning?"
+exists = cache.exists(text=new_text, model_name=model_name)
+print(f"New query exists in cache: {exists}")
+```
+
+    First query exists in cache: True
+    New query exists in cache: False
+
+
+### Removing Entries
+
+To remove an entry from the cache, use the `drop` method:
+
+
+```python
+# Remove from cache
+cache.drop(text=text, model_name=model_name)
+
+# Verify it's gone
+exists = cache.exists(text=text, model_name=model_name)
+print(f"After dropping: {exists}")
+```
+
+    After dropping: False
+
+
+## Advanced Usage
+
+### Key-Based Operations
+
+The `EmbeddingsCache` also provides methods that work directly with Redis keys, which can be useful for advanced use cases:
+
+
+```python
+# Store an entry again
+key = cache.set(
+    text=text,
+    model_name=model_name,
+    embedding=embedding,
+    metadata=metadata
+)
+print(f"Stored with key: {key[:15]}...")
+
+# Check existence by key
+exists_by_key = cache.exists_by_key(key)
+print(f"Exists by key: {exists_by_key}")
+
+# Retrieve by key
+result_by_key = cache.get_by_key(key)
+print(f"Retrieved by key: {result_by_key['text']}")
+
+# Drop by key
+cache.drop_by_key(key)
+```
+
+    Stored with key: embedcache:909f...
+    Exists by key: True
+    Retrieved by key: What is machine learning?
+
+
+### Batch Operations
+
+When working with multiple embeddings, batch operations can significantly improve performance by reducing network roundtrips. The `EmbeddingsCache` provides methods prefixed with `m` (for "multi") that handle batches efficiently.
+
+
+```python
+# Create multiple embeddings
+texts = [
+    "What is machine learning?",
+    "How do neural networks work?",
+    "What is deep learning?"
+]
+embeddings = [vectorizer.embed(t) for t in texts]
+
+# Prepare batch items as dictionaries
+batch_items = [
+    {
+        "text": texts[0],
+        "model_name": model_name,
+        "embedding": embeddings[0],
+        "metadata": {"category": "ai", "type": "question"}
+    },
+    {
+        "text": texts[1],
+        "model_name": model_name,
+        "embedding": embeddings[1],
+        "metadata": {"category": "ai", "type": "question"}
+    },
+    {
+        "text": texts[2],
+        "model_name": model_name,
+        "embedding": embeddings[2],
+        "metadata": {"category": "ai", "type": "question"}
+    }
+]
+
+# Store multiple embeddings in one operation
+keys = cache.mset(batch_items)
+print(f"Stored {len(keys)} embeddings with batch operation")
+
+# Check if multiple embeddings exist in one operation
+exist_results = cache.mexists(texts, model_name)
+print(f"All embeddings exist: {all(exist_results)}")
+
+# Retrieve multiple embeddings in one operation
+results = cache.mget(texts, model_name)
+print(f"Retrieved {len(results)} embeddings in one operation")
+
+# Delete multiple embeddings in one operation
+cache.mdrop(texts, model_name)
+
+# Alternative: key-based batch operations
+# cache.mget_by_keys(keys)     # Retrieve by keys
+# cache.mexists_by_keys(keys)  # Check existence by keys
+# cache.mdrop_by_keys(keys)    # Delete by keys
+```
+
+    Stored 3 embeddings with batch operation
+    All embeddings exist: True
+    Retrieved 3 embeddings in one operation
+
+
+Batch operations are particularly beneficial when working with large numbers of embeddings. They provide the same functionality as individual operations but with better performance by reducing network roundtrips.
+
+For asynchronous applications, async versions of all batch methods are also available with the `am` prefix (e.g., `amset`, `amget`, `amexists`, `amdrop`).
+
+### Working with TTL (Time-To-Live)
+
+You can set a global TTL when initializing the cache, or specify TTL for individual entries:
+
+
+```python
+# Create a cache with a default 5-second TTL
+ttl_cache = EmbeddingsCache(
+    name="ttl_cache",
+    redis_url="redis://localhost:6379",
+    ttl=5  # 5 second TTL
+)
+
+# Store an entry
+key = ttl_cache.set(
+    text=text,
+    model_name=model_name,
+    embedding=embedding
+)
+
+# Check if it exists
+exists = ttl_cache.exists_by_key(key)
+print(f"Immediately after setting: {exists}")
+
+# Wait for it to expire
+time.sleep(6)
+
+# Check again
+exists = ttl_cache.exists_by_key(key)
+print(f"After waiting: {exists}")
+```
+
+    Immediately after setting: True
+    After waiting: False
+
+
+You can also override the default TTL for individual entries:
+
+
+```python
+# Store an entry with a custom 1-second TTL
+key1 = ttl_cache.set(
+    text="Short-lived entry",
+    model_name=model_name,
+    embedding=embedding,
+    ttl=1  # Override with 1 second TTL
+)
+
+# Store another entry with the default TTL (5 seconds)
+key2 = ttl_cache.set(
+    text="Default TTL entry",
+    model_name=model_name,
+    embedding=embedding
+    # No TTL specified = uses the default 5 seconds
+)
+
+# Wait for 2 seconds
+time.sleep(2)
+
+# Check both entries
+exists1 = ttl_cache.exists_by_key(key1)
+exists2 = ttl_cache.exists_by_key(key2)
+
+print(f"Entry with custom TTL after 2 seconds: {exists1}")
+print(f"Entry with default TTL after 2 seconds: {exists2}")
+
+# Cleanup
+ttl_cache.drop_by_key(key2)
+```
+
+    Entry with custom TTL after 2 seconds: False
+    Entry with default TTL after 2 seconds: True
+
+
+## Async Support
+
+The `EmbeddingsCache` provides async versions of all methods for use in async applications. The async methods are prefixed with `a` (e.g., `aset`, `aget`, `aexists`, `adrop`).
+
+
+```python
+async def async_cache_demo():
+    # Store an entry asynchronously
+    key = await cache.aset(
+        text="Async embedding",
+        model_name=model_name,
+        embedding=embedding,
+        metadata={"async": True}
+    )
+    
+    # Check if it exists
+    exists = await cache.aexists_by_key(key)
+    print(f"Async set successful? {exists}")
+    
+    # Retrieve it
+    result = await cache.aget_by_key(key)
+    success = result is not None and result["text"] == "Async embedding"
+    print(f"Async get successful? {success}")
+    
+    # Remove it
+    await cache.adrop_by_key(key)
+
+# Run the async demo
+await async_cache_demo()
+```
+
+    Async set successful? True
+    Async get successful? True
+
+
+## Real-World Example
+
+Let's build a simple embeddings caching system for a text classification task. We'll check the cache before computing new embeddings to save computation time.
+
+
+```python
+# Create a fresh cache for this example
+example_cache = EmbeddingsCache(
+    name="example_cache",
+    redis_url="redis://localhost:6379",
+    ttl=3600  # 1 hour TTL
+)
+
+vectorizer = HFTextVectorizer(
+    model=model_name,
+    cache=example_cache,
+    cache_folder=os.getenv("SENTENCE_TRANSFORMERS_HOME")
+)
+
+# Simulate processing a stream of queries
+queries = [
+    "What is artificial intelligence?",
+    "How does machine learning work?",
+    "What is artificial intelligence?",  # Repeated query
+    "What are neural networks?",
+    "How does machine learning work?"   # Repeated query
+]
+
+# Process the queries and track statistics
+total_queries = 0
+cache_hits = 0
+
+for query in queries:
+    total_queries += 1
+    
+    # Check cache before computing
+    before = example_cache.exists(text=query, model_name=model_name)
+    if before:
+        cache_hits += 1
+    
+    # Get embedding (will compute or use cache)
+    embedding = vectorizer.embed(query)
+
+# Report statistics
+cache_misses = total_queries - cache_hits
+hit_rate = (cache_hits / total_queries) * 100
+
+print("\nStatistics:")
+print(f"Total queries: {total_queries}")
+print(f"Cache hits: {cache_hits}")
+print(f"Cache misses: {cache_misses}")
+print(f"Cache hit rate: {hit_rate:.1f}%")
+
+# Cleanup
+for query in set(queries):  # Use set to get unique queries
+    example_cache.drop(text=query, model_name=model_name)
+```
+
+    
+    Statistics:
+    Total queries: 5
+    Cache hits: 2
+    Cache misses: 3
+    Cache hit rate: 40.0%
+
+
+## Performance Benchmark
+
+Let's run benchmarks to compare the performance of embedding with and without caching, as well as batch versus individual operations.
+
+
+```python
+# Text to use for benchmarking
+benchmark_text = "This is a benchmark text to measure the performance of embedding caching."
+
+# Create a fresh cache for benchmarking
+benchmark_cache = EmbeddingsCache(
+    name="benchmark_cache",
+    redis_url="redis://localhost:6379",
+    ttl=3600  # 1 hour TTL
+)
+vectorizer.cache = benchmark_cache
+
+# Number of iterations for the benchmark
+n_iterations = 10
+
+# Benchmark without caching
+print("Benchmarking without caching:")
+start_time = time.time()
+for _ in range(n_iterations):
+    embedding = vectorizer.embed(text, skip_cache=True)
+no_cache_time = time.time() - start_time
+print(f"Time taken without caching: {no_cache_time:.4f} seconds")
+print(f"Average time per embedding: {no_cache_time/n_iterations:.4f} seconds")
+
+# Benchmark with caching
+print("\nBenchmarking with caching:")
+start_time = time.time()
+for _ in range(n_iterations):
+    embedding = vectorizer.embed(text)
+cache_time = time.time() - start_time
+print(f"Time taken with caching: {cache_time:.4f} seconds")
+print(f"Average time per embedding: {cache_time/n_iterations:.4f} seconds")
+
+# Compare performance
+speedup = no_cache_time / cache_time
+latency_reduction = (no_cache_time/n_iterations) - (cache_time/n_iterations)
+print(f"\nPerformance comparison:")
+print(f"Speedup with caching: {speedup:.2f}x faster")
+print(f"Time saved: {no_cache_time - cache_time:.4f} seconds ({(1 - cache_time/no_cache_time) * 100:.1f}%)")
+print(f"Latency reduction: {latency_reduction:.4f} seconds per query")
+```
+
+    Benchmarking without caching:
+    Time taken without caching: 0.4735 seconds
+    Average time per embedding: 0.0474 seconds
+    
+    Benchmarking with caching:
+    Time taken with caching: 0.0663 seconds
+    Average time per embedding: 0.0066 seconds
+    
+    Performance comparison:
+    Speedup with caching: 7.14x faster
+    Time saved: 0.4073 seconds (86.0%)
+    Latency reduction: 0.0407 seconds per query
+
+
+## Common Use Cases for Embedding Caching
+
+Embedding caching is particularly useful in the following scenarios:
+
+1. **Search applications**: Cache embeddings for frequently searched queries to reduce latency
+2. **Content recommendation systems**: Cache embeddings for content items to speed up similarity calculations
+3. **API services**: Reduce costs and improve response times when generating embeddings through paid APIs
+4. **Batch processing**: Speed up processing of datasets that contain duplicate texts
+5. **Chatbots and virtual assistants**: Cache embeddings for common user queries to provide faster responses
+6. **Development** workflows
+
+## Cleanup
+
+Let's clean up our caches to avoid leaving data in Redis:
+
+
+```python
+# Clean up all caches
+cache.clear()
+ttl_cache.clear()
+example_cache.clear()
+benchmark_cache.clear()
+```
+
+## Summary
+
+The `EmbeddingsCache` provides an efficient way to store and retrieve embeddings with their associated text and metadata. Key features include:
+
+- Simple API for storing and retrieving individual embeddings (`set`/`get`)
+- Batch operations for working with multiple embeddings efficiently (`mset`/`mget`/`mexists`/`mdrop`)
+- Support for metadata storage alongside embeddings
+- Configurable time-to-live (TTL) for cache entries
+- Key-based operations for advanced use cases
+- Async support for use in asynchronous applications
+- Significant performance improvements (15-20x faster with batch operations)
+
+By using the `EmbeddingsCache`, you can reduce computational costs and improve the performance of applications that rely on embeddings.
+---
+linkTitle: User guides
+title: User Guides
+type: integration
+weight: 4
+hideListLinks: true
+---
+
+
+User guides provide helpful resources for using RedisVL and its different components.
+
+
+
+* [Getting Started with RedisVL](getting_started/)
+  * [Define an `IndexSchema`](getting_started/#define-an-indexschema)
+  * [Sample Dataset Preparation](getting_started/#sample-dataset-preparation)
+  * [Create a `SearchIndex`](getting_started/#create-a-searchindex)
+  * [Inspect with the `rvl` CLI](getting_started/#inspect-with-the-rvl-cli)
+  * [Load Data to `SearchIndex`](getting_started/#load-data-to-searchindex)
+  * [Creating `VectorQuery` Objects](getting_started/#creating-vectorquery-objects)
+  * [Using an Asynchronous Redis Client](getting_started/#using-an-asynchronous-redis-client)
+  * [Updating a schema](getting_started/#updating-a-schema)
+  * [Check Index Stats](getting_started/#check-index-stats)
+  * [Cleanup](getting_started/#cleanup)
+* [Querying with RedisVL](hybrid_queries/)
+  * [Hybrid Queries](hybrid_queries/#hybrid-queries)
+  * [Combining Filters](hybrid_queries/#combining-filters)
+  * [Non-vector Queries](hybrid_queries/#non-vector-queries)
+  * [Count Queries](hybrid_queries/#count-queries)
+  * [Range Queries](hybrid_queries/#range-queries)
+  * [Advanced Query Modifiers](hybrid_queries/#advanced-query-modifiers)
+* [Semantic Caching for LLMs](llmcache/)
+  * [Initializing `SemanticCache`](llmcache/#initializing-semanticcache)
+  * [Basic Cache Usage](llmcache/#basic-cache-usage)
+  * [Customize the Distance Threshhold](llmcache/#customize-the-distance-threshhold)
+  * [Utilize TTL](llmcache/#utilize-ttl)
+  * [Simple Performance Testing](llmcache/#simple-performance-testing)
+  * [Cache Access Controls, Tags & Filters](llmcache/#cache-access-controls-tags-filters)
+* [Caching Embeddings](embeddings_cache/)
+  * [Setup](embeddings_cache/#setup)
+  * [Initializing the EmbeddingsCache](embeddings_cache/#initializing-the-embeddingscache)
+  * [Basic Usage](embeddings_cache/#basic-usage)
+  * [Advanced Usage](embeddings_cache/#advanced-usage)
+  * [Async Support](embeddings_cache/#async-support)
+  * [Real-World Example](embeddings_cache/#real-world-example)
+  * [Performance Benchmark](embeddings_cache/#performance-benchmark)
+  * [Common Use Cases for Embedding Caching](embeddings_cache/#common-use-cases-for-embedding-caching)
+  * [Cleanup](embeddings_cache/#cleanup)
+  * [Summary](embeddings_cache/#summary)
+* [Vectorizers](vectorizers/)
+  * [Creating Text Embeddings](vectorizers/#creating-text-embeddings)
+  * [Search with Provider Embeddings](vectorizers/#search-with-provider-embeddings)
+  * [Selecting your float data type](vectorizers/#selecting-your-float-data-type)
+* [Hash vs JSON Storage](hash_vs_json/)
+  * [Hash or JSON – how to choose?](hash_vs_json/#hash-or-json-how-to-choose)
+  * [Cleanup](hash_vs_json/#cleanup)
+* [Working with nested data in JSON](hash_vs_json/#working-with-nested-data-in-json)
+  * [Full JSON Path support](hash_vs_json/#full-json-path-support)
+  * [As an example:](hash_vs_json/#as-an-example)
+* [Cleanup](hash_vs_json/#id1)
+* [Rerankers](rerankers/)
+  * [Simple Reranking](rerankers/#simple-reranking)
+* [LLM Message History](message_history/)
+  * [Managing multiple users and conversations](message_history/#managing-multiple-users-and-conversations)
+  * [Semantic message history](message_history/#semantic-message-history)
+  * [Conversation control](message_history/#conversation-control)
+* [Semantic Routing](semantic_router/)
+  * [Define the Routes](semantic_router/#define-the-routes)
+  * [Initialize the SemanticRouter](semantic_router/#initialize-the-semanticrouter)
+  * [Simple routing](semantic_router/#simple-routing)
+  * [Update the routing config](semantic_router/#update-the-routing-config)
+  * [Router serialization](semantic_router/#router-serialization)
+* [Add route references](semantic_router/#add-route-references)
+* [Get route references](semantic_router/#get-route-references)
+* [Delete route references](semantic_router/#delete-route-references)
+  * [Clean up the router](semantic_router/#clean-up-the-router)
+* [Threshold Optimization](threshold_optimization/)
+* [CacheThresholdOptimizer](threshold_optimization/#cachethresholdoptimizer)
+  * [Define test_data and optimize](threshold_optimization/#define-test-data-and-optimize)
+* [RouterThresholdOptimizer](threshold_optimization/#routerthresholdoptimizer)
+  * [Define the routes](threshold_optimization/#define-the-routes)
+  * [Initialize the SemanticRouter](threshold_optimization/#initialize-the-semanticrouter)
+  * [Provide test_data](threshold_optimization/#provide-test-data)
+  * [Optimize](threshold_optimization/#optimize)
+  * [Test it out](threshold_optimization/#test-it-out)
+  * [Cleanup](threshold_optimization/#cleanup)
+* [Release Guides](release_guide/)
+  * [0.5.1 Feature Overview](release_guide/0_5_0_release/)
+  * [HybridQuery class](release_guide/0_5_0_release/#hybridquery-class)
+  * [TextQueries](release_guide/0_5_0_release/#textqueries)
+  * [Threshold optimization](release_guide/0_5_0_release/#threshold-optimization)
+  * [Schema validation](release_guide/0_5_0_release/#schema-validation)
+  * [Timestamp filters](release_guide/0_5_0_release/#timestamp-filters)
+  * [Batch search](release_guide/0_5_0_release/#batch-search)
+  * [Vector normalization](release_guide/0_5_0_release/#vector-normalization)
+  * [Hybrid policy on knn with filters](release_guide/0_5_0_release/#hybrid-policy-on-knn-with-filters)
+---
+linkTitle: Threshold optimization
+title: Threshold Optimization
+type: integration
+weight: 09
+---
+
+
+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:
+
+- prompt: `what is the capital of france?` response: `paris`
+- prompt: `what is the capital of morocco?` response: `rabat`
+
+
+```python
+from redisvl.extensions.cache.llm import SemanticCache
+from redisvl.utils.vectorize import HFTextVectorizer
+
+sem_cache = SemanticCache(
+    name="sem_cache",                                       # underlying search index name
+    redis_url="redis://localhost:6379",                     # redis connection url string
+    distance_threshold=0.5,                                 # semantic cache distance threshold
+    vectorizer=HFTextVectorizer("redis/langcache-embed-v1") # embedding model
+)
+
+paris_key = sem_cache.store(prompt="what is the capital of france?", response="paris")
+rabat_key = sem_cache.store(prompt="what is the capital of morocco?", response="rabat")
+
+```
+
+    /Users/justin.cechmanek/.pyenv/versions/3.13/envs/redisvl-dev/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
+      from .autonotebook import tqdm as notebook_tqdm
+
+
+    16:16:11 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    16:16:11 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: redis/langcache-embed-v1
+
+
+    Batches:   0%|          | 0/1 [00:00<?, ?it/s]Compiling the model with `torch.compile` and using a `torch.mps` device is not supported. Falling back to non-compiled mode.
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  3.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  1.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 25.04it/s]
+
+
+This works well but we want to make sure the cache only applies for the appropriate questions. If we test the cache with a question we don't want a response to we see that the current distance_threshold is too high. 
+
+
+```python
+sem_cache.check("what's the capital of britain?")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  1.24it/s]
+
+
+
+
+
+    [{'entry_id': 'c990cc06e5e77570e5f03360426d2b7f947cbb5a67daa8af8164bfe0b3e24fe3',
+      'prompt': 'what is the capital of france?',
+      'response': 'paris',
+      'vector_distance': 0.335606634617,
+      'inserted_at': 1746051375.81,
+      'updated_at': 1746051375.81,
+      'key': 'sem_cache:c990cc06e5e77570e5f03360426d2b7f947cbb5a67daa8af8164bfe0b3e24fe3'}]
+
+
+
+### Define test_data and optimize
+
+With the `CacheThresholdOptimizer` you can quickly tune the distance threshold by providing some test data in the form:
+
+```json
+[
+    {
+        "query": "What's the capital of Britain?",
+        "query_match": ""
+    },
+    {
+        "query": "What's the capital of France??",
+        "query_match": paris_key
+    },
+    {
+        "query": "What's the capital city of Morocco?",
+        "query_match": rabat_key
+    },
+]
+```
+
+The threshold optimizer will then efficiently execute and score different threshold against the what is currently populated in your cache and automatically update the threshold of the cache to the best setting
+
+
+```python
+from redisvl.utils.optimize import CacheThresholdOptimizer
+
+test_data = [
+    {
+        "query": "What's the capital of Britain?",
+        "query_match": ""
+    },
+    {
+        "query": "What's the capital of France??",
+        "query_match": paris_key
+    },
+    {
+        "query": "What's the capital city of Morocco?",
+        "query_match": rabat_key
+    },
+]
+
+print(f"Distance threshold before: {sem_cache.distance_threshold} \n")
+optimizer = CacheThresholdOptimizer(sem_cache, test_data)
+optimizer.optimize()
+print(f"Distance threshold after: {sem_cache.distance_threshold} \n")
+```
+
+    Distance threshold before: 0.5 
+    
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  1.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 23.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 24.43it/s]
+    /Users/justin.cechmanek/.pyenv/versions/3.13/envs/redisvl-dev/lib/python3.13/site-packages/ranx/metrics/f1.py:36: NumbaTypeSafetyWarning: unsafe cast from uint64 to int64. Precision may be lost.
+      scores[i] = _f1(qrels[i], run[i], k, rel_lvl)
+
+
+    Distance threshold after: 0.10372881355932204 
+    
+
+
+We can also see that we no longer match on the incorrect example:
+
+
+```python
+sem_cache.check("what's the capital of britain?")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 12.39it/s]
+
+
+
+
+
+    []
+
+
+
+But still match on highly relevant prompts:
+
+
+```python
+sem_cache.check("what's the capital city of france?")
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 25.92it/s]
+
+
+
+
+
+    [{'entry_id': 'c990cc06e5e77570e5f03360426d2b7f947cbb5a67daa8af8164bfe0b3e24fe3',
+      'prompt': 'what is the capital of france?',
+      'response': 'paris',
+      'vector_distance': 0.043138384819,
+      'inserted_at': 1746051375.81,
+      'updated_at': 1746051375.81,
+      'key': 'sem_cache:c990cc06e5e77570e5f03360426d2b7f947cbb5a67daa8af8164bfe0b3e24fe3'}]
+
+
+
+# RouterThresholdOptimizer
+
+Very similar to the caching case, you can optimize your router.
+
+### Define the routes
+
+
+```python
+from redisvl.extensions.router import Route
+
+routes = [
+        Route(
+            name="greeting",
+            references=["hello", "hi"],
+            metadata={"type": "greeting"},
+            distance_threshold=0.5,
+        ),
+        Route(
+            name="farewell",
+            references=["bye", "goodbye"],
+            metadata={"type": "farewell"},
+            distance_threshold=0.5,
+        ),
+    ]
+```
+
+### Initialize the SemanticRouter
+
+
+```python
+import os
+from redisvl.extensions.router import SemanticRouter
+from redisvl.utils.vectorize import HFTextVectorizer
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Initialize the SemanticRouter
+router = SemanticRouter(
+    name="greeting-router",
+    vectorizer=HFTextVectorizer(),
+    routes=routes,
+    redis_url="redis://localhost:6379",
+    overwrite=True # Blow away any other routing index with this name
+)
+```
+
+    16:16:41 sentence_transformers.SentenceTransformer INFO   Use pytorch device_name: mps
+    16:16:41 sentence_transformers.SentenceTransformer INFO   Load pretrained SentenceTransformer: sentence-transformers/all-mpnet-base-v2
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  5.90it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  4.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.29it/s]
+
+
+### Provide test_data
+
+
+```python
+test_data = [
+    # Greetings
+    {"query": "hello", "query_match": "greeting"},
+    {"query": "hi", "query_match": "greeting"},
+    {"query": "hey", "query_match": "greeting"},
+    {"query": "greetings", "query_match": "greeting"},
+    {"query": "good morning", "query_match": "greeting"},
+    {"query": "good afternoon", "query_match": "greeting"},
+    {"query": "good evening", "query_match": "greeting"},
+    {"query": "howdy", "query_match": "greeting"},
+    {"query": "what's up", "query_match": "greeting"},
+    {"query": "yo", "query_match": "greeting"},
+    {"query": "hiya", "query_match": "greeting"},
+    {"query": "salutations", "query_match": "greeting"},
+    {"query": "how's it going", "query_match": "greeting"},
+    {"query": "how are you", "query_match": "greeting"},
+    {"query": "nice to meet you", "query_match": "greeting"},
+    # Farewells
+    {"query": "goodbye", "query_match": "farewell"},
+    {"query": "bye", "query_match": "farewell"},
+    {"query": "see you later", "query_match": "farewell"},
+    {"query": "take care", "query_match": "farewell"},
+    {"query": "farewell", "query_match": "farewell"},
+    {"query": "have a good day", "query_match": "farewell"},
+    {"query": "see you soon", "query_match": "farewell"},
+    {"query": "catch you later", "query_match": "farewell"},
+    {"query": "so long", "query_match": "farewell"},
+    {"query": "peace out", "query_match": "farewell"},
+    {"query": "later", "query_match": "farewell"},
+    {"query": "all the best", "query_match": "farewell"},
+    {"query": "take it easy", "query_match": "farewell"},
+    {"query": "have a good one", "query_match": "farewell"},
+    {"query": "cheerio", "query_match": "farewell"},
+    # Null matches
+    {"query": "what's the capital of britain?", "query_match": ""},
+    {"query": "what does laffy taffy taste like?", "query_match": ""},
+]
+```
+
+### Optimize
+
+Note: by default route distance threshold optimization will use a random search to find the best threshold since, unlike caching, there are many thresholds to optimize concurrently. 
+
+
+```python
+from redisvl.utils.optimize import RouterThresholdOptimizer
+
+print(f"Route thresholds before: {router.route_thresholds} \n")
+optimizer = RouterThresholdOptimizer(router, test_data)
+optimizer.optimize()
+```
+
+    Route thresholds before: {'greeting': 0.5, 'farewell': 0.5} 
+    
+
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  7.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.81it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.68it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  9.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 44.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  9.21it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  9.56it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.82it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.00it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.18it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  7.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00,  9.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.68it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.00it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.86it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 74.82it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.64it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.84it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.29it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.15it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 75.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 73.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.86it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 74.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.81it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 53.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.07it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.29it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.93it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.15it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.62it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.78it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.88it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 52.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.46it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.29it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.46it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 22.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.67it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.21it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.04it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.20it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.88it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.29it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.07it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.87it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.90it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.23it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.18it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.82it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.15it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.56it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.68it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 72.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.74it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.05it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 71.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 20.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.29it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.76it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.89it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.49it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.81it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.82it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.23it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.56it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 52.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.87it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.06it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.49it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.21it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.87it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.67it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.84it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.62it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 22.93it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.20it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.99it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.21it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.74it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 19.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.93it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.86it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.84it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.81it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.64it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.15it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 48.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.87it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.46it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.88it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.28it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.21it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 24.78it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 51.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.93it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.64it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.04it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.04it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.49it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.78it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.46it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.56it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.11it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 26.60it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 48.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.43it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.19it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.15it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.56it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 50.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.06it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.07it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.20it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.04it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 52.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.17it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.80it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.67it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.62it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 31.04it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 54.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.03it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.59it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 54.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 53.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.55it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.89it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.89it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.02it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 38.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 54.75it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.26it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 52.05it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 53.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.93it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.06it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.88it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.79it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.01it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.35it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.24it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.05it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.70it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.73it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 69.52it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.09it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 52.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 54.25it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.34it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.47it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.92it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 28.70it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.89it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.81it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.07it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.85it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.54it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.23it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.84it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.31it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.58it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.87it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.77it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.50it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.51it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.72it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 57.14it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.98it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.41it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 67.63it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 17.08it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.97it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.86it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.74it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.91it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.53it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.64it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 56.45it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.61it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.10it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.22it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 59.16it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.86it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 58.44it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.69it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.12it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.96it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.95it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.36it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 68.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.83it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.57it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 41.90it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 20.01it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.68it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 61.99it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.13it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.30it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.66it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.39it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.27it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 63.94it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.42it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 60.40it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.71it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.32it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 62.48it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 64.38it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.65it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 65.33it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 70.37it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.00it/s]
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 66.63it/s]
+
+
+    Eval metric F1: start 0.438, end 0.812 
+    Ending thresholds: {'greeting': 0.5828282828282831, 'farewell': 0.7545454545454545}
+
+
+### Test it out
+
+
+```python
+# Query the router with a statement
+route_match = router("hi there")
+route_match
+```
+
+    Batches: 100%|██████████| 1/1 [00:00<00:00, 55.72it/s]
+
+
+
+
+
+    RouteMatch(name='greeting', distance=0.295984089375)
+
+
+
+## Cleanup
+
+
+```python
+router.delete()
+sem_cache.delete()
+```
+---
+aliases:
+- /integrate/redisvl/overview/install
+description: Install RedisVL
+linkTitle: Install
+title: Install
+type: integration
+weight: 2
+---
+## Installation
+
+Install the `redisvl` package into your Python (>=3.8) environment using the `pip` command:
+
+```shell
+pip install redisvl
+```
+
+Then make sure to have a Redis instance with the Redis Query Engine features enabled on Redis Cloud or locally in docker with Redis Stack:
+
+```shell
+docker run -d --name redis -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+After running the previous command, the Redis Insight GUI will be available at http://localhost:8001.
+---
+linkTitle: Filter
+title: Filter
+type: integration
+---
+
+
+<a id="filter-api"></a>
+
+## FilterExpression
+
+### `class FilterExpression(_filter=None, operator=None, left=None, right=None)`
+
+A FilterExpression is a logical combination of filters in RedisVL.
+
+FilterExpressions can be combined using the & and | operators to create
+complex expressions that evaluate to the Redis Query language.
+
+This presents an interface by which users can create complex queries
+without having to know the Redis Query language.
+
+```python
+from redisvl.query.filter import Tag, Num
+
+brand_is_nike = Tag("brand") == "nike"
+price_is_over_100 = Num("price") < 100
+f = brand_is_nike & price_is_over_100
+
+print(str(f))
+
+>> (@brand:{nike} @price:[-inf (100)])
+```
+
+This can be combined with the VectorQuery class to create a query:
+
+```python
+from redisvl.query import VectorQuery
+
+v = VectorQuery(
+    vector=[0.1, 0.1, 0.5, ...],
+    vector_field_name="product_embedding",
+    return_fields=["product_id", "brand", "price"],
+    filter_expression=f,
+)
+```
+
+#### `NOTE`
+Filter expressions are typically not called directly. Instead they are
+built by combining filter statements using the & and | operators.
+
+* **Parameters:**
+  * **\_filter** (*str* *|* *None*)
+  * **operator** (*FilterOperator* *|* *None*)
+  * **left** ([FilterExpression](#filterexpression) *|* *None*)
+  * **right** ([FilterExpression](#filterexpression) *|* *None*)
+
+## Tag
+
+### `class Tag(field)`
+
+A Tag filter can be applied to Tag fields
+
+* **Parameters:**
+  **field** (*str*)
+
+#### `__eq__(other)`
+
+Create a Tag equality filter expression.
+
+* **Parameters:**
+  **other** (*Union* *[* *List* *[* *str* *]* *,* *str* *]*) – The tag(s) to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Tag
+
+f = Tag("brand") == "nike"
+```
+
+#### `__ne__(other)`
+
+Create a Tag inequality filter expression.
+
+* **Parameters:**
+  **other** (*Union* *[* *List* *[* *str* *]* *,* *str* *]*) – The tag(s) to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Tag
+f = Tag("brand") != "nike"
+```
+
+#### `__str__()`
+
+Return the Redis Query string for the Tag filter
+
+* **Return type:**
+  str
+
+## Text
+
+### `class Text(field)`
+
+A Text is a FilterField representing a text field in a Redis index.
+
+* **Parameters:**
+  **field** (*str*)
+
+#### `__eq__(other)`
+
+Create a Text equality filter expression. These expressions yield
+filters that enforce an exact match on the supplied term(s).
+
+* **Parameters:**
+  **other** (*str*) – The text value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Text
+
+f = Text("job") == "engineer"
+```
+
+#### `__mod__(other)`
+
+Create a Text “LIKE” filter expression. A flexible expression that
+yields filters that can use a variety of additional operators like
+wildcards (\*), fuzzy matches (%%), or combinatorics (|) of the supplied
+term(s).
+
+* **Parameters:**
+  **other** (*str*) – The text value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Text
+
+f = Text("job") % "engine*"         # suffix wild card match
+f = Text("job") % "%%engine%%"      # fuzzy match w/ Levenshtein Distance
+f = Text("job") % "engineer|doctor" # contains either term in field
+f = Text("job") % "engineer doctor" # contains both terms in field
+```
+
+#### `__ne__(other)`
+
+Create a Text inequality filter expression. These expressions yield
+negated filters on exact matches on the supplied term(s). Opposite of an
+equality filter expression.
+
+* **Parameters:**
+  **other** (*str*) – The text value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Text
+
+f = Text("job") != "engineer"
+```
+
+#### `__str__()`
+
+Return the Redis Query string for the Text filter
+
+* **Return type:**
+  str
+
+## Num
+
+### `class Num(field)`
+
+A Num is a FilterField representing a numeric field in a Redis index.
+
+* **Parameters:**
+  **field** (*str*)
+
+#### `__eq__(other)`
+
+Create a Numeric equality filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+f = Num("zipcode") == 90210
+```
+
+#### `__ge__(other)`
+
+Create a Numeric greater than or equal to filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+
+f = Num("age") >= 18
+```
+
+#### `__gt__(other)`
+
+Create a Numeric greater than filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+
+f = Num("age") > 18
+```
+
+#### `__le__(other)`
+
+Create a Numeric less than or equal to filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+
+f = Num("age") <= 18
+```
+
+#### `__lt__(other)`
+
+Create a Numeric less than filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+
+f = Num("age") < 18
+```
+
+#### `__ne__(other)`
+
+Create a Numeric inequality filter expression.
+
+* **Parameters:**
+  **other** (*int*) – The value to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Num
+
+f = Num("zipcode") != 90210
+```
+
+#### `__str__()`
+
+Return the Redis Query string for the Numeric filter
+
+* **Return type:**
+  str
+
+#### `between(start, end, inclusive='both')`
+
+Operator for searching values between two numeric values.
+
+* **Parameters:**
+  * **start** (*int*)
+  * **end** (*int*)
+  * **inclusive** (*str*)
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+## Geo
+
+### `class Geo(field)`
+
+A Geo is a FilterField representing a geographic (lat/lon) field in a
+Redis index.
+
+* **Parameters:**
+  **field** (*str*)
+
+#### `__eq__(other)`
+
+Create a geographic filter within a specified GeoRadius.
+
+* **Parameters:**
+  **other** ([GeoRadius](#georadius)) – The geographic spec to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Geo, GeoRadius
+
+f = Geo("location") == GeoRadius(-122.4194, 37.7749, 1, unit="m")
+```
+
+#### `__ne__(other)`
+
+Create a geographic filter outside of a specified GeoRadius.
+
+* **Parameters:**
+  **other** ([GeoRadius](#georadius)) – The geographic spec to filter on.
+* **Return type:**
+  [FilterExpression](#filterexpression)
+
+```python
+from redisvl.query.filter import Geo, GeoRadius
+
+f = Geo("location") != GeoRadius(-122.4194, 37.7749, 1, unit="m")
+```
+
+#### `__str__()`
+
+Return the Redis Query string for the Geo filter
+
+* **Return type:**
+  str
+
+## GeoRadius
+
+### `class GeoRadius(longitude, latitude, radius=1, unit='km')`
+
+A GeoRadius is a GeoSpec representing a geographic radius.
+
+Create a GeoRadius specification (GeoSpec)
+
+* **Parameters:**
+  * **longitude** (*float*) – The longitude of the center of the radius.
+  * **latitude** (*float*) – The latitude of the center of the radius.
+  * **radius** (*int* *,* *optional*) – The radius of the circle. Defaults to 1.
+  * **unit** (*str* *,* *optional*) – The unit of the radius. Defaults to “km”.
+* **Raises:**
+  **ValueError** – If the unit is not one of “m”, “km”, “mi”, or “ft”.
+
+#### `__init__(longitude, latitude, radius=1, unit='km')`
+
+Create a GeoRadius specification (GeoSpec)
+
+* **Parameters:**
+  * **longitude** (*float*) – The longitude of the center of the radius.
+  * **latitude** (*float*) – The latitude of the center of the radius.
+  * **radius** (*int* *,* *optional*) – The radius of the circle. Defaults to 1.
+  * **unit** (*str* *,* *optional*) – The unit of the radius. Defaults to “km”.
+* **Raises:**
+  **ValueError** – If the unit is not one of “m”, “km”, “mi”, or “ft”.
+---
+linkTitle: Schema
+title: Schema
+type: integration
+---
+
+
+Schema in RedisVL provides a structured format to define index settings and
+field configurations using the following three components:
+
+| Component   | Description                                                                        |
+|-------------|------------------------------------------------------------------------------------|
+| version     | The version of the schema spec. Current supported version is 0.1.0.                |
+| index       | Index specific settings like name, key prefix, key separator, and storage type.    |
+| fields      | Subset of fields within your data to include in the index and any custom settings. |
+
+## IndexSchema
+
+<a id="indexschema-api"></a>
+
+### `class IndexSchema(*, index, fields={}, version='0.1.0')`
+
+A schema definition for a search index in Redis, used in RedisVL for
+configuring index settings and organizing vector and metadata fields.
+
+The class offers methods to create an index schema from a YAML file or a
+Python dictionary, supporting flexible schema definitions and easy
+integration into various workflows.
+
+An example schema.yaml file might look like this:
+
+```yaml
+version: '0.1.0'
+
+index:
+    name: user-index
+    prefix: user
+    key_separator: ":"
+    storage_type: json
+
+fields:
+    - name: user
+      type: tag
+    - name: credit_score
+      type: tag
+    - name: embedding
+      type: vector
+      attrs:
+        algorithm: flat
+        dims: 3
+        distance_metric: cosine
+        datatype: float32
+```
+
+Loading the schema for RedisVL from yaml is as simple as:
+
+```python
+from redisvl.schema import IndexSchema
+
+schema = IndexSchema.from_yaml("schema.yaml")
+```
+
+Loading the schema for RedisVL from dict is as simple as:
+
+```python
+from redisvl.schema import IndexSchema
+
+schema = IndexSchema.from_dict({
+    "index": {
+        "name": "user-index",
+        "prefix": "user",
+        "key_separator": ":",
+        "storage_type": "json",
+    },
+    "fields": [
+        {"name": "user", "type": "tag"},
+        {"name": "credit_score", "type": "tag"},
+        {
+            "name": "embedding",
+            "type": "vector",
+            "attrs": {
+                "algorithm": "flat",
+                "dims": 3,
+                "distance_metric": "cosine",
+                "datatype": "float32"
+            }
+        }
+    ]
+})
+```
+
+#### `NOTE`
+The fields attribute in the schema must contain unique field names to ensure
+correct and unambiguous field references.
+
+Create a new model by parsing and validating input data from keyword arguments.
+
+Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be
+validated to form a valid model.
+
+self is explicitly positional-only to allow self as a field name.
+
+* **Parameters:**
+  * **index** (*IndexInfo*)
+  * **fields** (*Dict* *[* *str* *,* *BaseField* *]*)
+  * **version** (*Literal* *[* *'0.1.0'* *]*)
+
+#### `add_field(field_inputs)`
+
+Adds a single field to the index schema based on the specified field
+type and attributes.
+
+This method allows for the addition of individual fields to the schema,
+providing flexibility in defining the structure of the index.
+
+* **Parameters:**
+  **field_inputs** (*Dict* *[* *str* *,* *Any* *]*) – A field to add.
+* **Raises:**
+  **ValueError** – If the field name or type are not provided or if the name
+      already exists within the schema.
+
+```python
+# Add a tag field
+schema.add_field({"name": "user", "type": "tag})
+
+# Add a vector field
+schema.add_field({
+    "name": "user-embedding",
+    "type": "vector",
+    "attrs": {
+        "dims": 1024,
+        "algorithm": "flat",
+        "datatype": "float32"
+    }
+})
+```
+
+#### `add_fields(fields)`
+
+Extends the schema with additional fields.
+
+This method allows dynamically adding new fields to the index schema. It
+processes a list of field definitions.
+
+* **Parameters:**
+  **fields** (*List* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – A list of fields to add.
+* **Raises:**
+  **ValueError** – If a field with the same name already exists in the
+      schema.
+
+```python
+schema.add_fields([
+    {"name": "user", "type": "tag"},
+    {"name": "bio", "type": "text"},
+    {
+        "name": "user-embedding",
+        "type": "vector",
+        "attrs": {
+            "dims": 1024,
+            "algorithm": "flat",
+            "datatype": "float32"
+        }
+    }
+])
+```
+
+#### `classmethod from_dict(data)`
+
+Create an IndexSchema from a dictionary.
+
+* **Parameters:**
+  **data** (*Dict* *[* *str* *,* *Any* *]*) – The index schema data.
+* **Returns:**
+  The index schema.
+* **Return type:**
+  [IndexSchema](#indexschema)
+
+```python
+from redisvl.schema import IndexSchema
+
+schema = IndexSchema.from_dict({
+    "index": {
+        "name": "docs-index",
+        "prefix": "docs",
+        "storage_type": "hash",
+    },
+    "fields": [
+        {
+            "name": "doc-id",
+            "type": "tag"
+        },
+        {
+            "name": "doc-embedding",
+            "type": "vector",
+            "attrs": {
+                "algorithm": "flat",
+                "dims": 1536
+            }
+        }
+    ]
+})
+```
+
+#### `classmethod from_yaml(file_path)`
+
+Create an IndexSchema from a YAML file.
+
+* **Parameters:**
+  **file_path** (*str*) – The path to the YAML file.
+* **Returns:**
+  The index schema.
+* **Return type:**
+  [IndexSchema](#indexschema)
+
+```python
+from redisvl.schema import IndexSchema
+schema = IndexSchema.from_yaml("schema.yaml")
+```
+
+#### `remove_field(field_name)`
+
+Removes a field from the schema based on the specified name.
+
+This method is useful for dynamically altering the schema by removing
+existing fields.
+
+* **Parameters:**
+  **field_name** (*str*) – The name of the field to be removed.
+
+#### `to_dict()`
+
+Serialize the index schema model to a dictionary, handling Enums
+and other special cases properly.
+
+* **Returns:**
+  The index schema as a dictionary.
+* **Return type:**
+  Dict[str, Any]
+
+#### `to_yaml(file_path, overwrite=True)`
+
+Write the index schema to a YAML file.
+
+* **Parameters:**
+  * **file_path** (*str*) – The path to the YAML file.
+  * **overwrite** (*bool*) – Whether to overwrite the file if it already exists.
+* **Raises:**
+  **FileExistsError** – If the file already exists and overwrite is False.
+* **Return type:**
+  None
+
+#### `property field_names: List[str]`
+
+A list of field names associated with the index schema.
+
+* **Returns:**
+  A list of field names from the schema.
+* **Return type:**
+  List[str]
+
+#### `fields: Dict[str, BaseField]`
+
+Fields associated with the search index and their properties
+
+#### `index: IndexInfo`
+
+Details of the basic index configurations.
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `version: Literal['0.1.0']`
+
+Version of the underlying index schema.
+
+## Defining Fields
+
+Fields in the schema can be defined in YAML format or as a Python dictionary, specifying a name, type, an optional path, and attributes for customization.
+
+**YAML Example**:
+
+```yaml
+- name: title
+  type: text
+  path: $.document.title
+  attrs:
+    weight: 1.0
+    no_stem: false
+    withsuffixtrie: true
+```
+
+**Python Dictionary Example**:
+
+```python
+{
+    "name": "location",
+    "type": "geo",
+    "attrs": {
+        "sortable": true
+    }
+}
+```
+
+## Supported Field Types and Attributes
+
+Each field type supports specific attributes that customize its behavior. Below are the field types and their available attributes:
+
+**Text Field Attributes**:
+
+- weight: Importance of the field in result calculation.
+- no_stem: Disables stemming during indexing.
+- withsuffixtrie: Optimizes queries by maintaining a suffix trie.
+- phonetic_matcher: Enables phonetic matching.
+- sortable: Allows sorting on this field.
+
+**Tag Field Attributes**:
+
+- separator: Character for splitting text into individual tags.
+- case_sensitive: Case sensitivity in tag matching.
+- withsuffixtrie: Suffix trie optimization for queries.
+- sortable: Enables sorting based on the tag field.
+
+**Numeric and Geo Field Attributes**:
+
+- Both numeric and geo fields support the sortable attribute, enabling sorting on these fields.
+
+**Common Vector Field Attributes**:
+
+- dims: Dimensionality of the vector.
+- algorithm: Indexing algorithm (flat or hnsw).
+- datatype: Float datatype of the vector (bfloat16, float16, float32, float64).
+- distance_metric: Metric for measuring query relevance (COSINE, L2, IP).
+
+**HNSW Vector Field Specific Attributes**:
+
+- m: Max outgoing edges per node in each layer.
+- ef_construction: Max edge candidates during build time.
+- ef_runtime: Max top candidates during search.
+- epsilon: Range search boundary factor.
+
+Note:
+: See fully documented Redis-supported fields and options here: [https://redis.io/commands/ft.create/](https://redis.io/commands/ft.create/)
+---
+linkTitle: Semantic router
+title: Semantic Router
+type: integration
+---
+
+
+<a id="semantic-router-api"></a>
+
+## Semantic Router
+
+### `class SemanticRouter(name, routes, vectorizer=None, routing_config=None, redis_client=None, redis_url='redis://localhost:6379', overwrite=False, connection_kwargs={})`
+
+Semantic Router for managing and querying route vectors.
+
+Initialize the SemanticRouter.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the semantic router.
+  * **routes** (*List* *[*[Route](#route) *]*) – List of Route objects.
+  * **vectorizer** (*BaseVectorizer* *,* *optional*) – The vectorizer used to embed route references. Defaults to default HFTextVectorizer.
+  * **routing_config** ([RoutingConfig](#routingconfig) *,* *optional*) – Configuration for routing behavior. Defaults to the default RoutingConfig.
+  * **redis_client** (*Optional* *[* *Redis* *]* *,* *optional*) – Redis client for connection. Defaults to None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **overwrite** (*bool* *,* *optional*) – Whether to overwrite existing index. Defaults to False.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+
+#### `add_route_references(route_name, references)`
+
+Add a reference(s) to an existing route.
+
+* **Parameters:**
+  * **router_name** (*str*) – The name of the router.
+  * **references** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The reference or list of references to add.
+  * **route_name** (*str*)
+* **Returns:**
+  The list of added references keys.
+* **Return type:**
+  List[str]
+
+#### `clear()`
+
+Flush all routes from the semantic router index.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Delete the semantic router index.
+
+* **Return type:**
+  None
+
+#### `delete_route_references(route_name='', reference_ids=[], keys=[])`
+
+Get references for an existing semantic router route.
+
+* **Parameters:**
+  * **Optional** (*keys*) – The name of the router.
+  * **Optional** – The reference or list of references to delete.
+  * **Optional** – List of fully qualified keys (prefix:router:reference_id) to delete.
+  * **route_name** (*str*)
+  * **reference_ids** (*List* *[* *str* *]*)
+  * **keys** (*List* *[* *str* *]*)
+* **Returns:**
+  Number of objects deleted
+* **Return type:**
+  int
+
+#### `classmethod from_dict(data, **kwargs)`
+
+Create a SemanticRouter from a dictionary.
+
+* **Parameters:**
+  **data** (*Dict* *[* *str* *,* *Any* *]*) – The dictionary containing the semantic router data.
+* **Returns:**
+  The semantic router instance.
+* **Return type:**
+  [SemanticRouter](#semanticrouter)
+* **Raises:**
+  **ValueError** – If required data is missing or invalid.
+
+```python
+from redisvl.extensions.router import SemanticRouter
+router_data = {
+    "name": "example_router",
+    "routes": [{"name": "route1", "references": ["ref1"], "distance_threshold": 0.5}],
+    "vectorizer": {"type": "openai", "model": "text-embedding-ada-002"},
+}
+router = SemanticRouter.from_dict(router_data)
+```
+
+#### `classmethod from_existing(name, redis_client=None, redis_url='redis://localhost:6379', **kwargs)`
+
+Return SemanticRouter instance from existing index.
+
+* **Parameters:**
+  * **name** (*str*)
+  * **redis_client** (*Redis* *|* *None*)
+  * **redis_url** (*str*)
+* **Return type:**
+  [SemanticRouter](#semanticrouter)
+
+#### `classmethod from_yaml(file_path, **kwargs)`
+
+Create a SemanticRouter from a YAML file.
+
+* **Parameters:**
+  **file_path** (*str*) – The path to the YAML file.
+* **Returns:**
+  The semantic router instance.
+* **Return type:**
+  [SemanticRouter](#semanticrouter)
+* **Raises:**
+  * **ValueError** – If the file path is invalid.
+  * **FileNotFoundError** – If the file does not exist.
+
+```python
+from redisvl.extensions.router import SemanticRouter
+router = SemanticRouter.from_yaml("router.yaml", redis_url="redis://localhost:6379")
+```
+
+#### `get(route_name)`
+
+Get a route by its name.
+
+* **Parameters:**
+  **route_name** (*str*) – Name of the route.
+* **Returns:**
+  The selected Route object or None if not found.
+* **Return type:**
+  Optional[[Route](#route)]
+
+#### `get_route_references(route_name='', reference_ids=[], keys=[])`
+
+Get references for an existing route route.
+
+* **Parameters:**
+  * **router_name** (*str*) – The name of the router.
+  * **references** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The reference or list of references to add.
+  * **route_name** (*str*)
+  * **reference_ids** (*List* *[* *str* *]*)
+  * **keys** (*List* *[* *str* *]*)
+* **Returns:**
+  Reference objects stored
+* **Return type:**
+  List[Dict[str, Any]]]
+
+#### `model_post_init(context, /)`
+
+This function is meant to behave like a BaseModel method to initialise private attributes.
+
+It takes context as an argument since that’s what pydantic-core passes when calling it.
+
+* **Parameters:**
+  * **self** (*BaseModel*) – The BaseModel instance.
+  * **context** (*Any*) – The context.
+* **Return type:**
+  None
+
+#### `remove_route(route_name)`
+
+Remove a route and all references from the semantic router.
+
+* **Parameters:**
+  **route_name** (*str*) – Name of the route to remove.
+* **Return type:**
+  None
+
+#### `route_many(statement=None, vector=None, max_k=None, distance_threshold=None, aggregation_method=None)`
+
+Query the semantic router with a given statement or vector for multiple matches.
+
+* **Parameters:**
+  * **statement** (*Optional* *[* *str* *]*) – The input statement to be queried.
+  * **vector** (*Optional* *[* *List* *[* *float* *]* *]*) – The input vector to be queried.
+  * **max_k** (*Optional* *[* *int* *]*) – The maximum number of top matches to return.
+  * **distance_threshold** (*Optional* *[* *float* *]*) – The threshold for semantic distance.
+  * **aggregation_method** (*Optional* *[*[DistanceAggregationMethod](#distanceaggregationmethod) *]*) – The aggregation method used for vector distances.
+* **Returns:**
+  The matching routes and their details.
+* **Return type:**
+  List[[RouteMatch](#routematch)]
+
+#### `to_dict()`
+
+Convert the SemanticRouter instance to a dictionary.
+
+* **Returns:**
+  The dictionary representation of the SemanticRouter.
+* **Return type:**
+  Dict[str, Any]
+
+```python
+from redisvl.extensions.router import SemanticRouter
+router = SemanticRouter(name="example_router", routes=[], redis_url="redis://localhost:6379")
+router_dict = router.to_dict()
+```
+
+#### `to_yaml(file_path, overwrite=True)`
+
+Write the semantic router to a YAML file.
+
+* **Parameters:**
+  * **file_path** (*str*) – The path to the YAML file.
+  * **overwrite** (*bool*) – Whether to overwrite the file if it already exists.
+* **Raises:**
+  **FileExistsError** – If the file already exists and overwrite is False.
+* **Return type:**
+  None
+
+```python
+from redisvl.extensions.router import SemanticRouter
+router = SemanticRouter(
+    name="example_router",
+    routes=[],
+    redis_url="redis://localhost:6379"
+)
+router.to_yaml("router.yaml")
+```
+
+#### `update_route_thresholds(route_thresholds)`
+
+Update the distance thresholds for each route.
+
+* **Parameters:**
+  **route_thresholds** (*Dict* *[* *str* *,* *float* *]*) – Dictionary of route names and their distance thresholds.
+
+#### `update_routing_config(routing_config)`
+
+Update the routing configuration.
+
+* **Parameters:**
+  **routing_config** ([RoutingConfig](#routingconfig)) – The new routing configuration.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `name: str`
+
+The name of the semantic router.
+
+#### `property route_names: List[str]`
+
+Get the list of route names.
+
+* **Returns:**
+  List of route names.
+* **Return type:**
+  List[str]
+
+#### `property route_thresholds: Dict[str, float | None]`
+
+Get the distance thresholds for each route.
+
+* **Returns:**
+  Dictionary of route names and their distance thresholds.
+* **Return type:**
+  Dict[str, float]
+
+#### `routes: `List[[Route](#route)]
+
+List of Route objects.
+
+#### `routing_config: `[RoutingConfig](#routingconfig)
+
+Configuration for routing behavior.
+
+#### `vectorizer: BaseVectorizer`
+
+The vectorizer used to embed route references.
+
+## Routing Config
+
+### `class RoutingConfig(*, max_k=1, aggregation_method=DistanceAggregationMethod.avg)`
+
+Configuration for routing behavior.
+
+Create a new model by parsing and validating input data from keyword arguments.
+
+Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be
+validated to form a valid model.
+
+self is explicitly positional-only to allow self as a field name.
+
+* **Parameters:**
+  * **max_k** (*Annotated* *[* *int* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+  * **aggregation_method** ([DistanceAggregationMethod](#distanceaggregationmethod))
+
+#### `max_k: Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Gt(gt=0)])]`
+
+Aggregation method to use to classify queries.
+
+#### `model_config: ClassVar[ConfigDict] = {'extra': 'ignore'}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+## Route
+
+### `class Route(*, name, references, metadata={}, distance_threshold=0.5)`
+
+Model representing a routing path with associated metadata and thresholds.
+
+Create a new model by parsing and validating input data from keyword arguments.
+
+Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be
+validated to form a valid model.
+
+self is explicitly positional-only to allow self as a field name.
+
+* **Parameters:**
+  * **name** (*str*)
+  * **references** (*List* *[* *str* *]*)
+  * **metadata** (*Dict* *[* *str* *,* *Any* *]*)
+  * **distance_threshold** (*Annotated* *[* *float* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *,* *Le* *(* *le=2* *)* *]* *)* *]*)
+
+#### `distance_threshold: Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Gt(gt=0), Le(le=2)])]`
+
+Distance threshold for matching the route.
+
+#### `metadata: Dict[str, Any]`
+
+Metadata associated with the route.
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `name: str`
+
+The name of the route.
+
+#### `references: List[str]`
+
+List of reference phrases for the route.
+
+## Route Match
+
+### `class RouteMatch(*, name=None, distance=None)`
+
+Model representing a matched route with distance information.
+
+Create a new model by parsing and validating input data from keyword arguments.
+
+Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be
+validated to form a valid model.
+
+self is explicitly positional-only to allow self as a field name.
+
+* **Parameters:**
+  * **name** (*str* *|* *None*)
+  * **distance** (*float* *|* *None*)
+
+#### `distance: float | None`
+
+The vector distance between the statement and the matched route.
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `name: str | None`
+
+The matched route name.
+
+## Distance Aggregation Method
+
+### `class DistanceAggregationMethod(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)`
+
+Enumeration for distance aggregation methods.
+
+#### `avg = 'avg'`
+
+Compute the average of the vector distances.
+
+#### `min = 'min'`
+
+Compute the minimum of the vector distances.
+
+#### `sum = 'sum'`
+
+Compute the sum of the vector distances.
+---
+linkTitle: LLM message history
+title: LLM Message History
+type: integration
+---
+
+
+## SemanticMessageHistory
+
+<a id="semantic-message-history-api"></a>
+
+### `class SemanticMessageHistory(name, session_tag=None, prefix=None, vectorizer=None, distance_threshold=0.3, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={}, overwrite=False, **kwargs)`
+
+Bases: `BaseMessageHistory`
+
+Initialize message history with index
+
+Semantic Message History stores the current and previous user text prompts
+and LLM responses to allow for enriching future prompts with session
+context. Message history is stored in individual user or LLM prompts and
+responses.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the message history index.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+  * **prefix** (*Optional* *[* *str* *]*) – Prefix for the keys for this message data.
+    Defaults to None and will be replaced with the index name.
+  * **vectorizer** (*Optional* *[* *BaseVectorizer* *]*) – The vectorizer used to create embeddings.
+  * **distance_threshold** (*float*) – The maximum semantic distance to be
+    included in the context. Defaults to 0.3.
+  * **redis_client** (*Optional* *[* *Redis* *]*) – A Redis client instance. Defaults to
+    None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+  * **overwrite** (*bool*) – Whether or not to force overwrite the schema for
+    the semantic message index. Defaults to false.
+
+The proposed schema will support a single vector embedding constructed
+from either the prompt or response in a single string.
+
+#### `add_message(message, session_tag=None)`
+
+Insert a single prompt or response into the message history.
+A timestamp is associated with it so that it can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **message** (*Dict* *[* *str* *,**str* *]*) – The user prompt or LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entry to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `add_messages(messages, session_tag=None)`
+
+Insert a list of prompts and responses into the session memory.
+A timestamp is associated with each so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **messages** (*List* *[* *Dict* *[* *str* *,* *str* *]* *]*) – The list of user prompts and LLM responses.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `clear()`
+
+Clears the message history.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Clear all message keys and remove the search index.
+
+* **Return type:**
+  None
+
+#### `drop(id=None)`
+
+Remove a specific exchange from the message history.
+
+* **Parameters:**
+  **id** (*Optional* *[* *str* *]*) – The id of the message entry to delete.
+  If None then the last entry is deleted.
+* **Return type:**
+  None
+
+#### `get_recent(top_k=5, as_text=False, raw=False, session_tag=None)`
+
+Retreive the recent message history in sequential order.
+
+* **Parameters:**
+  * **top_k** (*int*) – The number of previous exchanges to return. Default is 5.
+  * **as_text** (*bool*) – Whether to return the conversation as a single string,
+    or list of alternating prompts and responses.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    prompt and response
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag of the entries linked to a specific
+    conversation session. Defaults to instance ULID.
+* **Returns:**
+  A single string transcription of the session
+  : or list of strings if as_text is false.
+* **Return type:**
+  Union[str, List[str]]
+* **Raises:**
+  **ValueError** – if top_k is not an integer greater than or equal to 0.
+
+#### `get_relevant(prompt, as_text=False, top_k=5, fall_back=False, session_tag=None, raw=False, distance_threshold=None)`
+
+Searches the message history for information semantically related to
+the specified prompt.
+
+This method uses vector similarity search with a text prompt as input.
+It checks for semantically similar prompts and responses and gets
+the top k most relevant previous prompts or responses to include as
+context to the next LLM call.
+
+* **Parameters:**
+  * **prompt** (*str*) – The message text to search for in message history
+  * **as_text** (*bool*) – Whether to return the prompts and responses as text
+  * **JSON.** (*or as*)
+  * **top_k** (*int*) – The number of previous messages to return. Default is 5.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag of the entries linked to a specific
+    conversation session. Defaults to instance ULID.
+  * **distance_threshold** (*Optional* *[* *float* *]*) – The threshold for semantic
+    vector distance.
+  * **fall_back** (*bool*) – Whether to drop back to recent conversation history
+    if no relevant context is found.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    message.
+* **Returns:**
+  Either a list of strings, or a
+  list of prompts and responses in JSON containing the most relevant.
+* **Return type:**
+  Union[List[str], List[Dict[str,str]]
+
+Raises ValueError: if top_k is not an integer greater or equal to 0.
+
+#### `store(prompt, response, session_tag=None)`
+
+Insert a prompt:response pair into the message history. A timestamp
+is associated with each message so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to the LLM.
+  * **response** (*str*) – The corresponding LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `property messages: List[str] | List[Dict[str, str]]`
+
+Returns the full message history.
+
+## MessageHistory
+
+<a id="message-history-api"></a>
+
+### `class MessageHistory(name, session_tag=None, prefix=None, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={}, **kwargs)`
+
+Bases: `BaseMessageHistory`
+
+Initialize message history
+
+Message History stores the current and previous user text prompts and
+LLM responses to allow for enriching future prompts with session
+context. Message history is stored in individual user or LLM prompts and
+responses.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the message history index.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+  * **prefix** (*Optional* *[* *str* *]*) – Prefix for the keys for this conversation data.
+    Defaults to None and will be replaced with the index name.
+  * **redis_client** (*Optional* *[* *Redis* *]*) – A Redis client instance. Defaults to
+    None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+
+#### `add_message(message, session_tag=None)`
+
+Insert a single prompt or response into the message history.
+A timestamp is associated with it so that it can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **message** (*Dict* *[* *str* *,**str* *]*) – The user prompt or LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `add_messages(messages, session_tag=None)`
+
+Insert a list of prompts and responses into the message history.
+A timestamp is associated with each so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **messages** (*List* *[* *Dict* *[* *str* *,* *str* *]* *]*) – The list of user prompts and LLM responses.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `clear()`
+
+Clears the conversation message history.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Clear all conversation keys and remove the search index.
+
+* **Return type:**
+  None
+
+#### `drop(id=None)`
+
+Remove a specific exchange from the conversation history.
+
+* **Parameters:**
+  **id** (*Optional* *[* *str* *]*) – The id of the message entry to delete.
+  If None then the last entry is deleted.
+* **Return type:**
+  None
+
+#### `get_recent(top_k=5, as_text=False, raw=False, session_tag=None)`
+
+Retrieve the recent message history in sequential order.
+
+* **Parameters:**
+  * **top_k** (*int*) – The number of previous messages to return. Default is 5.
+  * **as_text** (*bool*) – Whether to return the conversation as a single string,
+    or list of alternating prompts and responses.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    prompt and response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag of the entries linked to a specific
+    conversation session. Defaults to instance ULID.
+* **Returns:**
+  A single string transcription of the messages
+  : or list of strings if as_text is false.
+* **Return type:**
+  Union[str, List[str]]
+* **Raises:**
+  **ValueError** – if top_k is not an integer greater than or equal to 0.
+
+#### `store(prompt, response, session_tag=None)`
+
+Insert a prompt:response pair into the message history. A timestamp
+is associated with each exchange so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to the LLM.
+  * **response** (*str*) – The corresponding LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    conversation session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `property messages: List[str] | List[Dict[str, str]]`
+
+Returns the full message history.
+---
+linkTitle: Threshold optimizers
+title: Threshold Optimizers
+type: integration
+---
+
+
+## CacheThresholdOptimizer
+
+<a id="cachethresholdoptimizer-api"></a>
+
+## RouterThresholdOptimizer
+---
+linkTitle: Query
+title: Query
+type: integration
+---
+
+
+Query classes in RedisVL provide a structured way to define simple or complex
+queries for different use cases. Each query class wraps the `redis-py` Query module
+[https://github.com/redis/redis-py/blob/master/redis/commands/search/query.py](https://github.com/redis/redis-py/blob/master/redis/commands/search/query.py) with extended functionality for ease-of-use.
+
+## VectorQuery
+
+### `class VectorQuery(vector, vector_field_name, return_fields=None, filter_expression=None, dtype='float32', num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, hybrid_policy=None, batch_size=None, ef_runtime=None, normalize_vector_distance=False)`
+
+Bases: `BaseVectorQuery`, `BaseQuery`
+
+A query for running a vector search along with an optional filter
+expression.
+
+* **Parameters:**
+  * **vector** (*List* *[* *float* *]*) – The vector to perform the vector search with.
+  * **vector_field_name** (*str*) – The name of the vector field to search
+    against in the database.
+  * **return_fields** (*List* *[* *str* *]*) – The declared fields to return with search
+    results.
+  * **filter_expression** (*Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *,* *optional*) – A filter to apply
+    along with the vector search. Defaults to None.
+  * **dtype** (*str* *,* *optional*) – The dtype of the vector. Defaults to
+    “float32”.
+  * **num_results** (*int* *,* *optional*) – The top k results to return from the
+    vector search. Defaults to 10.
+  * **return_score** (*bool* *,* *optional*) – Whether to return the vector
+    distance. Defaults to True.
+  * **dialect** (*int* *,* *optional*) – The RediSearch query dialect.
+    Defaults to 2.
+  * **sort_by** (*Optional* *[* *str* *]*) – The field to order the results by. Defaults
+    to None. Results will be ordered by vector distance.
+  * **in_order** (*bool*) – Requires the terms in the field to have
+    the same order as the terms in the query filter, regardless of
+    the offsets between them. Defaults to False.
+  * **hybrid_policy** (*Optional* *[* *str* *]*) – Controls how filters are applied during vector search.
+    Options are “BATCHES” (paginates through small batches of nearest neighbors) or
+    “ADHOC_BF” (computes scores for all vectors passing the filter).
+    “BATCHES” mode is typically faster for queries with selective filters.
+    “ADHOC_BF” mode is better when filters match a large portion of the dataset.
+    Defaults to None, which lets Redis auto-select the optimal policy.
+  * **batch_size** (*Optional* *[* *int* *]*) – When hybrid_policy is “BATCHES”, controls the number
+    of vectors to fetch in each batch. Larger values may improve performance
+    at the cost of memory usage. Only applies when hybrid_policy=”BATCHES”.
+    Defaults to None, which lets Redis auto-select an appropriate batch size.
+  * **ef_runtime** (*Optional* *[* *int* *]*) – Controls the size of the dynamic candidate list for HNSW
+    algorithm at query time. Higher values improve recall at the expense of
+    slower search performance. Defaults to None, which uses the index-defined value.
+  * **normalize_vector_distance** (*bool*) – Redis supports 3 distance metrics: L2 (euclidean),
+    IP (inner product), and COSINE. By default, L2 distance returns an unbounded value.
+    COSINE distance returns a value between 0 and 2. IP returns a value determined by
+    the magnitude of the vector. Setting this flag to true converts COSINE and L2 distance
+    to a similarity score between 0 and 1. Note: setting this flag to true for IP will
+    throw a warning since by definition COSINE similarity is normalized IP.
+* **Raises:**
+  **TypeError** – If filter_expression is not of type redisvl.query.FilterExpression
+
+#### `NOTE`
+Learn more about vector queries in Redis: [https://redis.io/docs/interact/search-and-query/search/vectors/#knn-search](https://redis.io/docs/interact/search-and-query/search/vectors/#knn-search)
+
+#### `dialect(dialect)`
+
+Add a dialect field to the query.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *Query*
+
+#### `expander(expander)`
+
+Add a expander field to the query.
+
+- **expander** - the name of the expander
+
+* **Parameters:**
+  **expander** (*str*)
+* **Return type:**
+  *Query*
+
+#### `in_order()`
+
+Match only documents where the query terms appear in
+the same order in the document.
+i.e. for the query “hello world”, we do not match “world hello”
+
+* **Return type:**
+  *Query*
+
+#### `language(language)`
+
+Analyze the query as being in the specified language.
+
+* **Parameters:**
+  **language** (*str*) – The language (e.g. chinese or english)
+* **Return type:**
+  *Query*
+
+#### `limit_fields(*fields)`
+
+Limit the search to specific TEXT fields only.
+
+- **fields**: A list of strings, case sensitive field names
+
+from the defined schema.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *Query*
+
+#### `limit_ids(*ids)`
+
+Limit the results to a specific set of pre-known document
+ids of any length.
+
+* **Return type:**
+  *Query*
+
+#### `no_content()`
+
+Set the query to only return ids and not the document content.
+
+* **Return type:**
+  *Query*
+
+#### `no_stopwords()`
+
+Prevent the query from being filtered for stopwords.
+Only useful in very big queries that you are certain contain
+no stopwords.
+
+* **Return type:**
+  *Query*
+
+#### `paging(offset, num)`
+
+Set the paging for the query (defaults to 0..10).
+
+- **offset**: Paging offset for the results. Defaults to 0
+- **num**: How many results do we want
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *Query*
+
+#### `query_string()`
+
+Return the query string of this query only.
+
+* **Return type:**
+  str
+
+#### `return_fields(*fields)`
+
+Add fields to return fields.
+
+* **Return type:**
+  *Query*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *Query*
+
+#### `set_batch_size(batch_size)`
+
+Set the batch size for the query.
+
+* **Parameters:**
+  **batch_size** (*int*) – The batch size to use when hybrid_policy is “BATCHES”.
+* **Raises:**
+  * **TypeError** – If batch_size is not an integer
+  * **ValueError** – If batch_size is not positive
+
+#### `set_ef_runtime(ef_runtime)`
+
+Set the EF_RUNTIME parameter for the query.
+
+* **Parameters:**
+  **ef_runtime** (*int*) – The EF_RUNTIME value to use for HNSW algorithm.
+  Higher values improve recall at the expense of slower search.
+* **Raises:**
+  * **TypeError** – If ef_runtime is not an integer
+  * **ValueError** – If ef_runtime is not positive
+
+#### `set_filter(filter_expression=None)`
+
+Set the filter expression for the query.
+
+* **Parameters:**
+  **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]* *,* *optional*) – The filter
+  expression or query string to use on the query.
+* **Raises:**
+  **TypeError** – If filter_expression is not a valid FilterExpression or string.
+
+#### `set_hybrid_policy(hybrid_policy)`
+
+Set the hybrid policy for the query.
+
+* **Parameters:**
+  **hybrid_policy** (*str*) – The hybrid policy to use. Options are “BATCHES”
+  or “ADHOC_BF”.
+* **Raises:**
+  **ValueError** – If hybrid_policy is not one of the valid options
+
+#### `slop(slop)`
+
+Allow a maximum of N intervening non matched terms between
+phrase terms (0 means exact phrase).
+
+* **Parameters:**
+  **slop** (*int*)
+* **Return type:**
+  *Query*
+
+#### `sort_by(field, asc=True)`
+
+Add a sortby field to the query.
+
+- **field** - the name of the field to sort by
+- **asc** - when True, sorting will be done in asceding order
+
+* **Parameters:**
+  * **field** (*str*)
+  * **asc** (*bool*)
+* **Return type:**
+  *Query*
+
+#### `timeout(timeout)`
+
+overrides the timeout parameter of the module
+
+* **Parameters:**
+  **timeout** (*float*)
+* **Return type:**
+  *Query*
+
+#### `verbatim()`
+
+Set the query to be verbatim, i.e. use no query expansion
+or stemming.
+
+* **Return type:**
+  *Query*
+
+#### `with_payloads()`
+
+Ask the engine to return document payloads.
+
+* **Return type:**
+  *Query*
+
+#### `with_scores()`
+
+Ask the engine to return document search scores.
+
+* **Return type:**
+  *Query*
+
+#### `property batch_size: int | None`
+
+Return the batch size for the query.
+
+* **Returns:**
+  The batch size for the query.
+* **Return type:**
+  Optional[int]
+
+#### `property ef_runtime: int | None`
+
+Return the EF_RUNTIME parameter for the query.
+
+* **Returns:**
+  The EF_RUNTIME value for the query.
+* **Return type:**
+  Optional[int]
+
+#### `property filter: str | `[`FilterExpression`]({{< relref "filter/#filterexpression" >}})` `
+
+The filter expression for the query.
+
+#### `property hybrid_policy: str | None`
+
+Return the hybrid policy for the query.
+
+* **Returns:**
+  The hybrid policy for the query.
+* **Return type:**
+  Optional[str]
+
+#### `property params: Dict[str, Any]`
+
+Return the parameters for the query.
+
+* **Returns:**
+  The parameters for the query.
+* **Return type:**
+  Dict[str, Any]
+
+#### `property query: BaseQuery`
+
+Return self as the query object.
+
+## VectorRangeQuery
+
+### `class VectorRangeQuery(vector, vector_field_name, return_fields=None, filter_expression=None, dtype='float32', distance_threshold=0.2, epsilon=None, num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, hybrid_policy=None, batch_size=None, normalize_vector_distance=False)`
+
+Bases: `BaseVectorQuery`, `BaseQuery`
+
+A query for running a filtered vector search based on semantic
+distance threshold.
+
+* **Parameters:**
+  * **vector** (*List* *[* *float* *]*) – The vector to perform the range query with.
+  * **vector_field_name** (*str*) – The name of the vector field to search
+    against in the database.
+  * **return_fields** (*List* *[* *str* *]*) – The declared fields to return with search
+    results.
+  * **filter_expression** (*Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *,* *optional*) – A filter to apply
+    along with the range query. Defaults to None.
+  * **dtype** (*str* *,* *optional*) – The dtype of the vector. Defaults to
+    “float32”.
+  * **distance_threshold** (*float*) – The threshold for vector distance.
+    A smaller threshold indicates a stricter semantic search.
+    Defaults to 0.2.
+  * **epsilon** (*Optional* *[* *float* *]*) – The relative factor for vector range queries,
+    setting boundaries for candidates within radius \* (1 + epsilon).
+    This controls how extensive the search is beyond the specified radius.
+    Higher values increase recall at the expense of performance.
+    Defaults to None, which uses the index-defined epsilon (typically 0.01).
+  * **num_results** (*int*) – The MAX number of results to return.
+    Defaults to 10.
+  * **return_score** (*bool* *,* *optional*) – Whether to return the vector
+    distance. Defaults to True.
+  * **dialect** (*int* *,* *optional*) – The RediSearch query dialect.
+    Defaults to 2.
+  * **sort_by** (*Optional* *[* *str* *]*) – The field to order the results by. Defaults
+    to None. Results will be ordered by vector distance.
+  * **in_order** (*bool*) – Requires the terms in the field to have
+    the same order as the terms in the query filter, regardless of
+    the offsets between them. Defaults to False.
+  * **hybrid_policy** (*Optional* *[* *str* *]*) – Controls how filters are applied during vector search.
+    Options are “BATCHES” (paginates through small batches of nearest neighbors) or
+    “ADHOC_BF” (computes scores for all vectors passing the filter).
+    “BATCHES” mode is typically faster for queries with selective filters.
+    “ADHOC_BF” mode is better when filters match a large portion of the dataset.
+    Defaults to None, which lets Redis auto-select the optimal policy.
+  * **batch_size** (*Optional* *[* *int* *]*) – When hybrid_policy is “BATCHES”, controls the number
+    of vectors to fetch in each batch. Larger values may improve performance
+    at the cost of memory usage. Only applies when hybrid_policy=”BATCHES”.
+    Defaults to None, which lets Redis auto-select an appropriate batch size.
+  * **normalize_vector_distance** (*bool*) – Redis supports 3 distance metrics: L2 (euclidean),
+    IP (inner product), and COSINE. By default, L2 distance returns an unbounded value.
+    COSINE distance returns a value between 0 and 2. IP returns a value determined by
+    the magnitude of the vector. Setting this flag to true converts COSINE and L2 distance
+    to a similarity score between 0 and 1. Note: setting this flag to true for IP will
+    throw a warning since by definition COSINE similarity is normalized IP.
+* **Raises:**
+  **TypeError** – If filter_expression is not of type redisvl.query.FilterExpression
+
+#### `NOTE`
+Learn more about vector range queries: [https://redis.io/docs/interact/search-and-query/search/vectors/#range-query](https://redis.io/docs/interact/search-and-query/search/vectors/#range-query)
+
+#### `dialect(dialect)`
+
+Add a dialect field to the query.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *Query*
+
+#### `expander(expander)`
+
+Add a expander field to the query.
+
+- **expander** - the name of the expander
+
+* **Parameters:**
+  **expander** (*str*)
+* **Return type:**
+  *Query*
+
+#### `in_order()`
+
+Match only documents where the query terms appear in
+the same order in the document.
+i.e. for the query “hello world”, we do not match “world hello”
+
+* **Return type:**
+  *Query*
+
+#### `language(language)`
+
+Analyze the query as being in the specified language.
+
+* **Parameters:**
+  **language** (*str*) – The language (e.g. chinese or english)
+* **Return type:**
+  *Query*
+
+#### `limit_fields(*fields)`
+
+Limit the search to specific TEXT fields only.
+
+- **fields**: A list of strings, case sensitive field names
+
+from the defined schema.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *Query*
+
+#### `limit_ids(*ids)`
+
+Limit the results to a specific set of pre-known document
+ids of any length.
+
+* **Return type:**
+  *Query*
+
+#### `no_content()`
+
+Set the query to only return ids and not the document content.
+
+* **Return type:**
+  *Query*
+
+#### `no_stopwords()`
+
+Prevent the query from being filtered for stopwords.
+Only useful in very big queries that you are certain contain
+no stopwords.
+
+* **Return type:**
+  *Query*
+
+#### `paging(offset, num)`
+
+Set the paging for the query (defaults to 0..10).
+
+- **offset**: Paging offset for the results. Defaults to 0
+- **num**: How many results do we want
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *Query*
+
+#### `query_string()`
+
+Return the query string of this query only.
+
+* **Return type:**
+  str
+
+#### `return_fields(*fields)`
+
+Add fields to return fields.
+
+* **Return type:**
+  *Query*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *Query*
+
+#### `set_batch_size(batch_size)`
+
+Set the batch size for the query.
+
+* **Parameters:**
+  **batch_size** (*int*) – The batch size to use when hybrid_policy is “BATCHES”.
+* **Raises:**
+  * **TypeError** – If batch_size is not an integer
+  * **ValueError** – If batch_size is not positive
+
+#### `set_distance_threshold(distance_threshold)`
+
+Set the distance threshold for the query.
+
+* **Parameters:**
+  **distance_threshold** (*float*) – Vector distance threshold.
+* **Raises:**
+  * **TypeError** – If distance_threshold is not a float or int
+  * **ValueError** – If distance_threshold is negative
+
+#### `set_epsilon(epsilon)`
+
+Set the epsilon parameter for the range query.
+
+* **Parameters:**
+  **epsilon** (*float*) – The relative factor for vector range queries,
+  setting boundaries for candidates within radius \* (1 + epsilon).
+* **Raises:**
+  * **TypeError** – If epsilon is not a float or int
+  * **ValueError** – If epsilon is negative
+
+#### `set_filter(filter_expression=None)`
+
+Set the filter expression for the query.
+
+* **Parameters:**
+  **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]* *,* *optional*) – The filter
+  expression or query string to use on the query.
+* **Raises:**
+  **TypeError** – If filter_expression is not a valid FilterExpression or string.
+
+#### `set_hybrid_policy(hybrid_policy)`
+
+Set the hybrid policy for the query.
+
+* **Parameters:**
+  **hybrid_policy** (*str*) – The hybrid policy to use. Options are “BATCHES”
+  or “ADHOC_BF”.
+* **Raises:**
+  **ValueError** – If hybrid_policy is not one of the valid options
+
+#### `slop(slop)`
+
+Allow a maximum of N intervening non matched terms between
+phrase terms (0 means exact phrase).
+
+* **Parameters:**
+  **slop** (*int*)
+* **Return type:**
+  *Query*
+
+#### `sort_by(field, asc=True)`
+
+Add a sortby field to the query.
+
+- **field** - the name of the field to sort by
+- **asc** - when True, sorting will be done in asceding order
+
+* **Parameters:**
+  * **field** (*str*)
+  * **asc** (*bool*)
+* **Return type:**
+  *Query*
+
+#### `timeout(timeout)`
+
+overrides the timeout parameter of the module
+
+* **Parameters:**
+  **timeout** (*float*)
+* **Return type:**
+  *Query*
+
+#### `verbatim()`
+
+Set the query to be verbatim, i.e. use no query expansion
+or stemming.
+
+* **Return type:**
+  *Query*
+
+#### `with_payloads()`
+
+Ask the engine to return document payloads.
+
+* **Return type:**
+  *Query*
+
+#### `with_scores()`
+
+Ask the engine to return document search scores.
+
+* **Return type:**
+  *Query*
+
+#### `property batch_size: int | None`
+
+Return the batch size for the query.
+
+* **Returns:**
+  The batch size for the query.
+* **Return type:**
+  Optional[int]
+
+#### `property distance_threshold: float`
+
+Return the distance threshold for the query.
+
+* **Returns:**
+  The distance threshold for the query.
+* **Return type:**
+  float
+
+#### `property epsilon: float | None`
+
+Return the epsilon for the query.
+
+* **Returns:**
+  The epsilon for the query, or None if not set.
+* **Return type:**
+  Optional[float]
+
+#### `property filter: str | `[`FilterExpression`]({{< relref "filter/#filterexpression" >}})` `
+
+The filter expression for the query.
+
+#### `property hybrid_policy: str | None`
+
+Return the hybrid policy for the query.
+
+* **Returns:**
+  The hybrid policy for the query.
+* **Return type:**
+  Optional[str]
+
+#### `property params: Dict[str, Any]`
+
+Return the parameters for the query.
+
+* **Returns:**
+  The parameters for the query.
+* **Return type:**
+  Dict[str, Any]
+
+#### `property query: BaseQuery`
+
+Return self as the query object.
+
+## HybridQuery
+
+### `class HybridQuery(text, text_field_name, vector, vector_field_name, text_scorer='BM25STD', filter_expression=None, alpha=0.7, dtype='float32', num_results=10, return_fields=None, stopwords='english', dialect=2)`
+
+Bases: `AggregationQuery`
+
+HybridQuery combines text and vector search in Redis.
+It allows you to perform a hybrid search using both text and vector similarity.
+It scores documents based on a weighted combination of text and vector similarity.
+
+```python
+from redisvl.query import HybridQuery
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_yaml("path/to/index.yaml")
+
+query = HybridQuery(
+    text="example text",
+    text_field_name="text_field",
+    vector=[0.1, 0.2, 0.3],
+    vector_field_name="vector_field",
+    text_scorer="BM25STD",
+    filter_expression=None,
+    alpha=0.7,
+    dtype="float32",
+    num_results=10,
+    return_fields=["field1", "field2"],
+    stopwords="english",
+    dialect=2,
+)
+
+results = index.query(query)
+```
+
+Instantiates a HybridQuery object.
+
+* **Parameters:**
+  * **text** (*str*) – The text to search for.
+  * **text_field_name** (*str*) – The text field name to search in.
+  * **vector** (*Union* *[* *bytes* *,* *List* *[* *float* *]* *]*) – The vector to perform vector similarity search.
+  * **vector_field_name** (*str*) – The vector field name to search in.
+  * **text_scorer** (*str* *,* *optional*) – The text scorer to use. Options are {TFIDF, TFIDF.DOCNORM,
+    BM25, DISMAX, DOCSCORE, BM25STD}. Defaults to “BM25STD”.
+  * **filter_expression** (*Optional* *[*[*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *,* *optional*) – The filter expression to use.
+    Defaults to None.
+  * **alpha** (*float* *,* *optional*) – The weight of the vector similarity. Documents will be scored
+    as: hybrid_score = (alpha) \* vector_score + (1-alpha) \* text_score.
+    Defaults to 0.7.
+  * **dtype** (*str* *,* *optional*) – The data type of the vector. Defaults to “float32”.
+  * **num_results** (*int* *,* *optional*) – The number of results to return. Defaults to 10.
+  * **return_fields** (*Optional* *[* *List* *[* *str* *]* *]* *,* *optional*) – The fields to return. Defaults to None.
+  * **stopwords** (*Optional* *[* *Union* *[* *str* *,* *Set* *[* *str* *]* *]* *]* *,* *optional*) – The stopwords to remove from the
+    provided text prior to searchuse. If a string such as “english” “german” is
+    provided then a default set of stopwords for that language will be used. if a list,
+    set, or tuple of strings is provided then those will be used as stopwords.
+    Defaults to “english”. if set to “None” then no stopwords will be removed.
+  * **dialect** (*int* *,* *optional*) – The Redis dialect version. Defaults to 2.
+* **Raises:**
+  * **ValueError** – If the text string is empty, or if the text string becomes empty after
+        stopwords are removed.
+  * **TypeError** – If the stopwords are not a set, list, or tuple of strings.
+
+#### `add_scores()`
+
+If set, includes the score as an ordinary field of the row.
+
+* **Return type:**
+  *AggregateRequest*
+
+#### `apply(**kwexpr)`
+
+Specify one or more projection expressions to add to each result
+
+### `Parameters`
+
+- **kwexpr**: One or more key-value pairs for a projection. The key is
+  : the alias for the projection, and the value is the projection
+    expression itself, for example apply(square_root=”sqrt(@foo)”)
+
+* **Return type:**
+  *AggregateRequest*
+
+#### `dialect(dialect)`
+
+Add a dialect field to the aggregate command.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `filter(expressions)`
+
+Specify filter for post-query results using predicates relating to
+values in the result set.
+
+### `Parameters`
+
+- **fields**: Fields to group by. This can either be a single string,
+  : or a list of strings.
+
+* **Parameters:**
+  **expressions** (*str* *|* *List* *[* *str* *]*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `group_by(fields, *reducers)`
+
+Specify by which fields to group the aggregation.
+
+### `Parameters`
+
+- **fields**: Fields to group by. This can either be a single string,
+  : or a list of strings. both cases, the field should be specified as
+    @field.
+- **reducers**: One or more reducers. Reducers may be found in the
+  : aggregation module.
+
+* **Parameters:**
+  * **fields** (*List* *[* *str* *]*)
+  * **reducers** (*Reducer* *|* *List* *[* *Reducer* *]*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `limit(offset, num)`
+
+Sets the limit for the most recent group or query.
+
+If no group has been defined yet (via group_by()) then this sets
+the limit for the initial pool of results from the query. Otherwise,
+this limits the number of items operated on from the previous group.
+
+Setting a limit on the initial search results may be useful when
+attempting to execute an aggregation on a sample of a large data set.
+
+### `Parameters`
+
+- **offset**: Result offset from which to begin paging
+- **num**: Number of results to return
+
+Example of sorting the initial results:
+
+``
+AggregateRequest("@sale_amount:[10000, inf]")            .limit(0, 10)            .group_by("@state", r.count())
+``
+
+Will only group by the states found in the first 10 results of the
+query @sale_amount:[10000, inf]. On the other hand,
+
+``
+AggregateRequest("@sale_amount:[10000, inf]")            .limit(0, 1000)            .group_by("@state", r.count()            .limit(0, 10)
+``
+
+Will group all the results matching the query, but only return the
+first 10 groups.
+
+If you only wish to return a *top-N* style query, consider using
+sort_by() instead.
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `load(*fields)`
+
+Indicate the fields to be returned in the response. These fields are
+returned in addition to any others implicitly specified.
+
+### `Parameters`
+
+- **fields**: If fields not specified, all the fields will be loaded.
+
+Otherwise, fields should be given in the format of @field.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *AggregateRequest*
+
+#### `sort_by(*fields, **kwargs)`
+
+Indicate how the results should be sorted. This can also be used for
+*top-N* style queries
+
+### `Parameters`
+
+- **fields**: The fields by which to sort. This can be either a single
+  : field or a list of fields. If you wish to specify order, you can
+    use the Asc or Desc wrapper classes.
+- **max**: Maximum number of results to return. This can be
+  : used instead of LIMIT and is also faster.
+
+Example of sorting by foo ascending and bar descending:
+
+``
+sort_by(Asc("@foo"), Desc("@bar"))
+``
+
+Return the top 10 customers:
+
+``
+AggregateRequest()            .group_by("@customer", r.sum("@paid").alias(FIELDNAME))            .sort_by(Desc("@paid"), max=10)
+``
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *AggregateRequest*
+
+#### `with_schema()`
+
+If set, the schema property will contain a list of [field, type]
+entries in the result object.
+
+* **Return type:**
+  *AggregateRequest*
+
+#### `property params: Dict[str, Any]`
+
+Return the parameters for the aggregation.
+
+* **Returns:**
+  The parameters for the aggregation.
+* **Return type:**
+  Dict[str, Any]
+
+#### `property stopwords: Set[str]`
+
+Return the stopwords used in the query.
+:returns: The stopwords used in the query.
+:rtype: Set[str]
+
+## TextQuery
+
+### `class TextQuery(text, text_field_name, text_scorer='BM25STD', filter_expression=None, return_fields=None, num_results=10, return_score=True, dialect=2, sort_by=None, in_order=False, params=None, stopwords='english')`
+
+Bases: `BaseQuery`
+
+TextQuery is a query for running a full text search, along with an optional filter expression.
+
+```python
+from redisvl.query import TextQuery
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_yaml(index.yaml)
+
+query = TextQuery(
+    text="example text",
+    text_field_name="text_field",
+    text_scorer="BM25STD",
+    filter_expression=None,
+    num_results=10,
+    return_fields=["field1", "field2"],
+    stopwords="english",
+    dialect=2,
+)
+
+results = index.query(query)
+```
+
+A query for running a full text search, along with an optional filter expression.
+
+* **Parameters:**
+  * **text** (*str*) – The text string to perform the text search with.
+  * **text_field_name** (*str*) – The name of the document field to perform text search on.
+  * **text_scorer** (*str* *,* *optional*) – The text scoring algorithm to use.
+    Defaults to BM25STD. Options are {TFIDF, BM25STD, BM25, TFIDF.DOCNORM, DISMAX, DOCSCORE}.
+    See [https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/scoring/](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/scoring/)
+  * **filter_expression** (*Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *,* *optional*) – A filter to apply
+    along with the text search. Defaults to None.
+  * **return_fields** (*List* *[* *str* *]*) – The declared fields to return with search
+    results.
+  * **num_results** (*int* *,* *optional*) – The top k results to return from the
+    search. Defaults to 10.
+  * **return_score** (*bool* *,* *optional*) – Whether to return the text score.
+    Defaults to True.
+  * **dialect** (*int* *,* *optional*) – The RediSearch query dialect.
+    Defaults to 2.
+  * **sort_by** (*Optional* *[* *str* *]*) – The field to order the results by. Defaults
+    to None. Results will be ordered by text score.
+  * **in_order** (*bool*) – Requires the terms in the field to have
+    the same order as the terms in the query filter, regardless of
+    the offsets between them. Defaults to False.
+  * **params** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *optional*) – The parameters for the query.
+    Defaults to None.
+  * **stopwords** (*Optional* *[* *Union* *[* *str* *,* *Set* *[* *str* *]* *]*) – The set of stop words to remove
+    from the query text. If a language like ‘english’ or ‘spanish’ is provided
+    a default set of stopwords for that language will be used. Users may specify
+    their own stop words by providing a List or Set of words. if set to None,
+    then no words will be removed. Defaults to ‘english’.
+* **Raises:**
+  * **ValueError** – if stopwords language string cannot be loaded.
+  * **TypeError** – If stopwords is not a valid iterable set of strings.
+
+#### `dialect(dialect)`
+
+Add a dialect field to the query.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *Query*
+
+#### `expander(expander)`
+
+Add a expander field to the query.
+
+- **expander** - the name of the expander
+
+* **Parameters:**
+  **expander** (*str*)
+* **Return type:**
+  *Query*
+
+#### `in_order()`
+
+Match only documents where the query terms appear in
+the same order in the document.
+i.e. for the query “hello world”, we do not match “world hello”
+
+* **Return type:**
+  *Query*
+
+#### `language(language)`
+
+Analyze the query as being in the specified language.
+
+* **Parameters:**
+  **language** (*str*) – The language (e.g. chinese or english)
+* **Return type:**
+  *Query*
+
+#### `limit_fields(*fields)`
+
+Limit the search to specific TEXT fields only.
+
+- **fields**: A list of strings, case sensitive field names
+
+from the defined schema.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *Query*
+
+#### `limit_ids(*ids)`
+
+Limit the results to a specific set of pre-known document
+ids of any length.
+
+* **Return type:**
+  *Query*
+
+#### `no_content()`
+
+Set the query to only return ids and not the document content.
+
+* **Return type:**
+  *Query*
+
+#### `no_stopwords()`
+
+Prevent the query from being filtered for stopwords.
+Only useful in very big queries that you are certain contain
+no stopwords.
+
+* **Return type:**
+  *Query*
+
+#### `paging(offset, num)`
+
+Set the paging for the query (defaults to 0..10).
+
+- **offset**: Paging offset for the results. Defaults to 0
+- **num**: How many results do we want
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *Query*
+
+#### `query_string()`
+
+Return the query string of this query only.
+
+* **Return type:**
+  str
+
+#### `return_fields(*fields)`
+
+Add fields to return fields.
+
+* **Return type:**
+  *Query*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *Query*
+
+#### `set_filter(filter_expression=None)`
+
+Set the filter expression for the query.
+
+* **Parameters:**
+  **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]* *,* *optional*) – The filter
+  expression or query string to use on the query.
+* **Raises:**
+  **TypeError** – If filter_expression is not a valid FilterExpression or string.
+
+#### `slop(slop)`
+
+Allow a maximum of N intervening non matched terms between
+phrase terms (0 means exact phrase).
+
+* **Parameters:**
+  **slop** (*int*)
+* **Return type:**
+  *Query*
+
+#### `sort_by(field, asc=True)`
+
+Add a sortby field to the query.
+
+- **field** - the name of the field to sort by
+- **asc** - when True, sorting will be done in asceding order
+
+* **Parameters:**
+  * **field** (*str*)
+  * **asc** (*bool*)
+* **Return type:**
+  *Query*
+
+#### `timeout(timeout)`
+
+overrides the timeout parameter of the module
+
+* **Parameters:**
+  **timeout** (*float*)
+* **Return type:**
+  *Query*
+
+#### `verbatim()`
+
+Set the query to be verbatim, i.e. use no query expansion
+or stemming.
+
+* **Return type:**
+  *Query*
+
+#### `with_payloads()`
+
+Ask the engine to return document payloads.
+
+* **Return type:**
+  *Query*
+
+#### `with_scores()`
+
+Ask the engine to return document search scores.
+
+* **Return type:**
+  *Query*
+
+#### `property filter: str | `[`FilterExpression`]({{< relref "filter/#filterexpression" >}})` `
+
+The filter expression for the query.
+
+#### `property params: Dict[str, Any]`
+
+Return the query parameters.
+
+#### `property query: BaseQuery`
+
+Return self as the query object.
+
+## FilterQuery
+
+### `class FilterQuery(filter_expression=None, return_fields=None, num_results=10, dialect=2, sort_by=None, in_order=False, params=None)`
+
+Bases: `BaseQuery`
+
+A query for running a filtered search with a filter expression.
+
+* **Parameters:**
+  * **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]*) – The optional filter
+    expression to query with. Defaults to ‘\*’.
+  * **return_fields** (*Optional* *[* *List* *[* *str* *]* *]* *,* *optional*) – The fields to return.
+  * **num_results** (*Optional* *[* *int* *]* *,* *optional*) – The number of results to return. Defaults to 10.
+  * **dialect** (*int* *,* *optional*) – The query dialect. Defaults to 2.
+  * **sort_by** (*Optional* *[* *str* *]* *,* *optional*) – The field to order the results by. Defaults to None.
+  * **in_order** (*bool* *,* *optional*) – Requires the terms in the field to have the same order as the
+    terms in the query filter. Defaults to False.
+  * **params** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *optional*) – The parameters for the query. Defaults to None.
+* **Raises:**
+  **TypeError** – If filter_expression is not of type redisvl.query.FilterExpression
+
+#### `dialect(dialect)`
+
+Add a dialect field to the query.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *Query*
+
+#### `expander(expander)`
+
+Add a expander field to the query.
+
+- **expander** - the name of the expander
+
+* **Parameters:**
+  **expander** (*str*)
+* **Return type:**
+  *Query*
+
+#### `in_order()`
+
+Match only documents where the query terms appear in
+the same order in the document.
+i.e. for the query “hello world”, we do not match “world hello”
+
+* **Return type:**
+  *Query*
+
+#### `language(language)`
+
+Analyze the query as being in the specified language.
+
+* **Parameters:**
+  **language** (*str*) – The language (e.g. chinese or english)
+* **Return type:**
+  *Query*
+
+#### `limit_fields(*fields)`
+
+Limit the search to specific TEXT fields only.
+
+- **fields**: A list of strings, case sensitive field names
+
+from the defined schema.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *Query*
+
+#### `limit_ids(*ids)`
+
+Limit the results to a specific set of pre-known document
+ids of any length.
+
+* **Return type:**
+  *Query*
+
+#### `no_content()`
+
+Set the query to only return ids and not the document content.
+
+* **Return type:**
+  *Query*
+
+#### `no_stopwords()`
+
+Prevent the query from being filtered for stopwords.
+Only useful in very big queries that you are certain contain
+no stopwords.
+
+* **Return type:**
+  *Query*
+
+#### `paging(offset, num)`
+
+Set the paging for the query (defaults to 0..10).
+
+- **offset**: Paging offset for the results. Defaults to 0
+- **num**: How many results do we want
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *Query*
+
+#### `query_string()`
+
+Return the query string of this query only.
+
+* **Return type:**
+  str
+
+#### `return_fields(*fields)`
+
+Add fields to return fields.
+
+* **Return type:**
+  *Query*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *Query*
+
+#### `set_filter(filter_expression=None)`
+
+Set the filter expression for the query.
+
+* **Parameters:**
+  **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]* *,* *optional*) – The filter
+  expression or query string to use on the query.
+* **Raises:**
+  **TypeError** – If filter_expression is not a valid FilterExpression or string.
+
+#### `slop(slop)`
+
+Allow a maximum of N intervening non matched terms between
+phrase terms (0 means exact phrase).
+
+* **Parameters:**
+  **slop** (*int*)
+* **Return type:**
+  *Query*
+
+#### `sort_by(field, asc=True)`
+
+Add a sortby field to the query.
+
+- **field** - the name of the field to sort by
+- **asc** - when True, sorting will be done in asceding order
+
+* **Parameters:**
+  * **field** (*str*)
+  * **asc** (*bool*)
+* **Return type:**
+  *Query*
+
+#### `timeout(timeout)`
+
+overrides the timeout parameter of the module
+
+* **Parameters:**
+  **timeout** (*float*)
+* **Return type:**
+  *Query*
+
+#### `verbatim()`
+
+Set the query to be verbatim, i.e. use no query expansion
+or stemming.
+
+* **Return type:**
+  *Query*
+
+#### `with_payloads()`
+
+Ask the engine to return document payloads.
+
+* **Return type:**
+  *Query*
+
+#### `with_scores()`
+
+Ask the engine to return document search scores.
+
+* **Return type:**
+  *Query*
+
+#### `property filter: str | `[`FilterExpression`]({{< relref "filter/#filterexpression" >}})` `
+
+The filter expression for the query.
+
+#### `property params: Dict[str, Any]`
+
+Return the query parameters.
+
+#### `property query: BaseQuery`
+
+Return self as the query object.
+
+## CountQuery
+
+### `class CountQuery(filter_expression=None, dialect=2, params=None)`
+
+Bases: `BaseQuery`
+
+A query for a simple count operation provided some filter expression.
+
+* **Parameters:**
+  * **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]*) – The filter expression to
+    query with. Defaults to None.
+  * **params** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *optional*) – The parameters for the query. Defaults to None.
+  * **dialect** (*int*)
+* **Raises:**
+  **TypeError** – If filter_expression is not of type redisvl.query.FilterExpression
+
+```python
+from redisvl.query import CountQuery
+from redisvl.query.filter import Tag
+
+t = Tag("brand") == "Nike"
+query = CountQuery(filter_expression=t)
+
+count = index.query(query)
+```
+
+#### `dialect(dialect)`
+
+Add a dialect field to the query.
+
+- **dialect** - dialect version to execute the query under
+
+* **Parameters:**
+  **dialect** (*int*)
+* **Return type:**
+  *Query*
+
+#### `expander(expander)`
+
+Add a expander field to the query.
+
+- **expander** - the name of the expander
+
+* **Parameters:**
+  **expander** (*str*)
+* **Return type:**
+  *Query*
+
+#### `in_order()`
+
+Match only documents where the query terms appear in
+the same order in the document.
+i.e. for the query “hello world”, we do not match “world hello”
+
+* **Return type:**
+  *Query*
+
+#### `language(language)`
+
+Analyze the query as being in the specified language.
+
+* **Parameters:**
+  **language** (*str*) – The language (e.g. chinese or english)
+* **Return type:**
+  *Query*
+
+#### `limit_fields(*fields)`
+
+Limit the search to specific TEXT fields only.
+
+- **fields**: A list of strings, case sensitive field names
+
+from the defined schema.
+
+* **Parameters:**
+  **fields** (*List* *[* *str* *]*)
+* **Return type:**
+  *Query*
+
+#### `limit_ids(*ids)`
+
+Limit the results to a specific set of pre-known document
+ids of any length.
+
+* **Return type:**
+  *Query*
+
+#### `no_content()`
+
+Set the query to only return ids and not the document content.
+
+* **Return type:**
+  *Query*
+
+#### `no_stopwords()`
+
+Prevent the query from being filtered for stopwords.
+Only useful in very big queries that you are certain contain
+no stopwords.
+
+* **Return type:**
+  *Query*
+
+#### `paging(offset, num)`
+
+Set the paging for the query (defaults to 0..10).
+
+- **offset**: Paging offset for the results. Defaults to 0
+- **num**: How many results do we want
+
+* **Parameters:**
+  * **offset** (*int*)
+  * **num** (*int*)
+* **Return type:**
+  *Query*
+
+#### `query_string()`
+
+Return the query string of this query only.
+
+* **Return type:**
+  str
+
+#### `return_fields(*fields)`
+
+Add fields to return fields.
+
+* **Return type:**
+  *Query*
+
+#### `scorer(scorer)`
+
+Use a different scoring function to evaluate document relevance.
+Default is TFIDF.
+
+* **Parameters:**
+  **scorer** (*str*) – The scoring function to use
+  (e.g. TFIDF.DOCNORM or BM25)
+* **Return type:**
+  *Query*
+
+#### `set_filter(filter_expression=None)`
+
+Set the filter expression for the query.
+
+* **Parameters:**
+  **filter_expression** (*Optional* *[* *Union* *[* *str* *,* [*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]* *]* *,* *optional*) – The filter
+  expression or query string to use on the query.
+* **Raises:**
+  **TypeError** – If filter_expression is not a valid FilterExpression or string.
+
+#### `slop(slop)`
+
+Allow a maximum of N intervening non matched terms between
+phrase terms (0 means exact phrase).
+
+* **Parameters:**
+  **slop** (*int*)
+* **Return type:**
+  *Query*
+
+#### `sort_by(field, asc=True)`
+
+Add a sortby field to the query.
+
+- **field** - the name of the field to sort by
+- **asc** - when True, sorting will be done in asceding order
+
+* **Parameters:**
+  * **field** (*str*)
+  * **asc** (*bool*)
+* **Return type:**
+  *Query*
+
+#### `timeout(timeout)`
+
+overrides the timeout parameter of the module
+
+* **Parameters:**
+  **timeout** (*float*)
+* **Return type:**
+  *Query*
+
+#### `verbatim()`
+
+Set the query to be verbatim, i.e. use no query expansion
+or stemming.
+
+* **Return type:**
+  *Query*
+
+#### `with_payloads()`
+
+Ask the engine to return document payloads.
+
+* **Return type:**
+  *Query*
+
+#### `with_scores()`
+
+Ask the engine to return document search scores.
+
+* **Return type:**
+  *Query*
+
+#### `property filter: str | `[`FilterExpression`]({{< relref "filter/#filterexpression" >}})` `
+
+The filter expression for the query.
+
+#### `property params: Dict[str, Any]`
+
+Return the query parameters.
+
+#### `property query: BaseQuery`
+
+Return self as the query object.
+---
+linkTitle: Rerankers
+title: Rerankers
+type: integration
+---
+
+
+## CohereReranker
+
+<a id="coherereranker-api"></a>
+
+### `class CohereReranker(model='rerank-english-v3.0', rank_by=None, limit=5, return_score=True, api_config=None)`
+
+Bases: `BaseReranker`
+
+The CohereReranker class uses Cohere’s API to rerank documents based on an
+input query.
+
+This reranker is designed to interact with Cohere’s /rerank API,
+requiring an API key for authentication. The key can be provided
+directly in the api_config dictionary or through the COHERE_API_KEY
+environment variable. User must obtain an API key from Cohere’s website
+([https://dashboard.cohere.com/](https://dashboard.cohere.com/)). Additionally, the cohere python
+client must be installed with pip install cohere.
+
+```python
+from redisvl.utils.rerank import CohereReranker
+
+# set up the Cohere reranker with some configuration
+reranker = CohereReranker(rank_by=["content"], limit=2)
+# rerank raw search results based on user input/query
+results = reranker.rank(
+    query="your input query text here",
+    docs=[
+        {"content": "document 1"},
+        {"content": "document 2"},
+        {"content": "document 3"}
+    ]
+)
+```
+
+Initialize the CohereReranker with specified model, ranking criteria,
+and API configuration.
+
+* **Parameters:**
+  * **model** (*str*) – The identifier for the Cohere model used for reranking.
+    Defaults to ‘rerank-english-v3.0’.
+  * **rank_by** (*Optional* *[* *List* *[* *str* *]* *]*) – Optional list of keys specifying the
+    attributes in the documents that should be considered for
+    ranking. None means ranking will rely on the model’s default
+    behavior.
+  * **limit** (*int*) – The maximum number of results to return after
+    reranking. Must be a positive integer.
+  * **return_score** (*bool*) – Whether to return scores alongside the
+    reranked results.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the API key.
+    Defaults to None.
+* **Raises:**
+  * **ImportError** – If the cohere library is not installed.
+  * **ValueError** – If the API key is not provided.
+
+#### `async arank(query, docs, **kwargs)`
+
+Rerank documents based on the provided query using the Cohere rerank API.
+
+This method processes the user’s query and the provided documents to
+rerank them in a manner that is potentially more relevant to the
+query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents
+    to be ranked, either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[Union[List[Dict[str, Any]], List[str]], float], List[Dict[str, Any]]]
+
+#### `model_post_init(context, /)`
+
+This function is meant to behave like a BaseModel method to initialise private attributes.
+
+It takes context as an argument since that’s what pydantic-core passes when calling it.
+
+* **Parameters:**
+  * **self** (*BaseModel*) – The BaseModel instance.
+  * **context** (*Any*) – The context.
+* **Return type:**
+  None
+
+#### `rank(query, docs, **kwargs)`
+
+Rerank documents based on the provided query using the Cohere rerank API.
+
+This method processes the user’s query and the provided documents to
+rerank them in a manner that is potentially more relevant to the
+query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents
+    to be ranked, either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[Union[List[Dict[str, Any]], List[str]], float], List[Dict[str, Any]]]
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+## HFCrossEncoderReranker
+
+<a id="hfcrossencoderreranker-api"></a>
+
+### `class HFCrossEncoderReranker(model='cross-encoder/ms-marco-MiniLM-L-6-v2', limit=3, return_score=True, *, rank_by=None)`
+
+Bases: `BaseReranker`
+
+The HFCrossEncoderReranker class uses a cross-encoder models from Hugging Face
+to rerank documents based on an input query.
+
+This reranker loads a cross-encoder model using the CrossEncoder class
+from the sentence_transformers library. It requires the
+sentence_transformers library to be installed.
+
+```python
+from redisvl.utils.rerank import HFCrossEncoderReranker
+
+# set up the HFCrossEncoderReranker with a specific model
+reranker = HFCrossEncoderReranker(model_name="cross-encoder/ms-marco-MiniLM-L-6-v2", limit=3)
+# rerank raw search results based on user input/query
+results = reranker.rank(
+    query="your input query text here",
+    docs=[
+        {"content": "document 1"},
+        {"content": "document 2"},
+        {"content": "document 3"}
+    ]
+)
+```
+
+Initialize the HFCrossEncoderReranker with a specified model and ranking criteria.
+
+* **Parameters:**
+  * **model** (*str*) – The name or path of the cross-encoder model to use for reranking.
+    Defaults to ‘cross-encoder/ms-marco-MiniLM-L-6-v2’.
+  * **limit** (*int*) – The maximum number of results to return after reranking. Must be a positive integer.
+  * **return_score** (*bool*) – Whether to return scores alongside the reranked results.
+  * **rank_by** (*List* *[* *str* *]*  *|* *None*)
+
+#### `async arank(query, docs, **kwargs)`
+
+Asynchronously rerank documents based on the provided query using the loaded cross-encoder model.
+
+This method processes the user’s query and the provided documents to rerank them
+in a manner that is potentially more relevant to the query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents to be ranked,
+    either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[List[Dict[str, Any]], List[float]], List[Dict[str, Any]]]
+
+#### `model_post_init(context, /)`
+
+This function is meant to behave like a BaseModel method to initialise private attributes.
+
+It takes context as an argument since that’s what pydantic-core passes when calling it.
+
+* **Parameters:**
+  * **self** (*BaseModel*) – The BaseModel instance.
+  * **context** (*Any*) – The context.
+* **Return type:**
+  None
+
+#### `rank(query, docs, **kwargs)`
+
+Rerank documents based on the provided query using the loaded cross-encoder model.
+
+This method processes the user’s query and the provided documents to rerank them
+in a manner that is potentially more relevant to the query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents to be ranked,
+    either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[List[Dict[str, Any]], List[float]], List[Dict[str, Any]]]
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+## VoyageAIReranker
+
+<a id="voyageaireranker-api"></a>
+
+### `class VoyageAIReranker(model, rank_by=None, limit=5, return_score=True, api_config=None)`
+
+Bases: `BaseReranker`
+
+The VoyageAIReranker class uses VoyageAI’s API to rerank documents based on an
+input query.
+
+This reranker is designed to interact with VoyageAI’s /rerank API,
+requiring an API key for authentication. The key can be provided
+directly in the api_config dictionary or through the VOYAGE_API_KEY
+environment variable. User must obtain an API key from VoyageAI’s website
+([https://dash.voyageai.com/](https://dash.voyageai.com/)). Additionally, the voyageai python
+client must be installed with pip install voyageai.
+
+```python
+from redisvl.utils.rerank import VoyageAIReranker
+
+# set up the VoyageAI reranker with some configuration
+reranker = VoyageAIReranker(rank_by=["content"], limit=2)
+# rerank raw search results based on user input/query
+results = reranker.rank(
+    query="your input query text here",
+    docs=[
+        {"content": "document 1"},
+        {"content": "document 2"},
+        {"content": "document 3"}
+    ]
+)
+```
+
+Initialize the VoyageAIReranker with specified model, ranking criteria,
+and API configuration.
+
+* **Parameters:**
+  * **model** (*str*) – The identifier for the VoyageAI model used for reranking.
+  * **rank_by** (*Optional* *[* *List* *[* *str* *]* *]*) – Optional list of keys specifying the
+    attributes in the documents that should be considered for
+    ranking. None means ranking will rely on the model’s default
+    behavior.
+  * **limit** (*int*) – The maximum number of results to return after
+    reranking. Must be a positive integer.
+  * **return_score** (*bool*) – Whether to return scores alongside the
+    reranked results.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the API key.
+    Defaults to None.
+* **Raises:**
+  * **ImportError** – If the voyageai library is not installed.
+  * **ValueError** – If the API key is not provided.
+
+#### `async arank(query, docs, **kwargs)`
+
+Rerank documents based on the provided query using the VoyageAI rerank API.
+
+This method processes the user’s query and the provided documents to
+rerank them in a manner that is potentially more relevant to the
+query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents
+    to be ranked, either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[Union[List[Dict[str, Any]], List[str]], float], List[Dict[str, Any]]]
+
+#### `model_post_init(context, /)`
+
+This function is meant to behave like a BaseModel method to initialise private attributes.
+
+It takes context as an argument since that’s what pydantic-core passes when calling it.
+
+* **Parameters:**
+  * **self** (*BaseModel*) – The BaseModel instance.
+  * **context** (*Any*) – The context.
+* **Return type:**
+  None
+
+#### `rank(query, docs, **kwargs)`
+
+Rerank documents based on the provided query using the VoyageAI rerank API.
+
+This method processes the user’s query and the provided documents to
+rerank them in a manner that is potentially more relevant to the
+query’s context.
+
+* **Parameters:**
+  * **query** (*str*) – The user’s search query.
+  * **docs** (*Union* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *List* *[* *str* *]* *]*) – The list of documents
+    to be ranked, either as dictionaries or strings.
+* **Returns:**
+  The reranked list of documents and optionally associated scores.
+* **Return type:**
+  Union[Tuple[Union[List[Dict[str, Any]], List[str]], float], List[Dict[str, Any]]]
+
+#### `model_config: ClassVar[ConfigDict] = {}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+---
+linkTitle: Search index classes
+title: Search Index Classes
+type: integration
+---
+
+
+| Class                                     | Description                                                                                  |
+|-------------------------------------------|----------------------------------------------------------------------------------------------|
+| [SearchIndex](#searchindex-api)           | Primary class to write, read, and search across data structures in Redis.                    |
+| [AsyncSearchIndex](#asyncsearchindex-api) | Async version of the SearchIndex to write, read, and search across data structures in Redis. |
+
+<a id="searchindex-api"></a>
+
+## SearchIndex
+
+### `class SearchIndex(schema, redis_client=None, redis_url=None, connection_kwargs=None, validate_on_load=False, **kwargs)`
+
+A search index class for interacting with Redis as a vector database.
+
+The SearchIndex is instantiated with a reference to a Redis database and an
+IndexSchema (YAML path or dictionary object) that describes the various
+settings and field configurations.
+
+```python
+from redisvl.index import SearchIndex
+
+# initialize the index object with schema from file
+index = SearchIndex.from_yaml(
+    "schemas/schema.yaml",
+    redis_url="redis://localhost:6379",
+    validate_on_load=True
+)
+
+# create the index
+index.create(overwrite=True, drop=False)
+
+# data is an iterable of dictionaries
+index.load(data)
+
+# delete index and data
+index.delete(drop=True)
+```
+
+Initialize the RedisVL search index with a schema, Redis client
+(or URL string with other connection args), connection_args, and other
+kwargs.
+
+* **Parameters:**
+  * **schema** ([*IndexSchema*]({{< relref "schema/#indexschema" >}})) – Index schema object.
+  * **redis_client** (*Optional* *[* *redis.Redis* *]*) – An
+    instantiated redis client.
+  * **redis_url** (*Optional* *[* *str* *]*) – The URL of the Redis server to
+    connect to.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]* *,* *optional*) – Redis client connection
+    args.
+  * **validate_on_load** (*bool* *,* *optional*) – Whether to validate data against schema
+    when loading. Defaults to False.
+
+#### `aggregate(*args, **kwargs)`
+
+Perform an aggregation operation against the index.
+
+Wrapper around the aggregation API that adds the index name
+to the query and passes along the rest of the arguments
+to the redis-py ft().aggregate() method.
+
+* **Returns:**
+  Raw Redis aggregation results.
+* **Return type:**
+  Result
+
+#### `batch_query(queries, batch_size=10)`
+
+Execute a batch of queries and process results.
+
+* **Parameters:**
+  * **queries** (*Sequence* *[* *BaseQuery* *]*)
+  * **batch_size** (*int*)
+* **Return type:**
+  *List*[*List*[*Dict*[str, *Any*]]]
+
+#### `batch_search(queries, batch_size=10)`
+
+Perform a search against the index for multiple queries.
+
+This method takes a list of queries and optionally query params and
+returns a list of Result objects for each query. Results are
+returned in the same order as the queries.
+
+* **Parameters:**
+  * **queries** (*List* *[* *SearchParams* *]*) – The queries to search for. batch_size
+  * **(* ***int** – The number of queries to search for at a time.
+    Defaults to 10.
+  * **optional****)** – The number of queries to search for at a time.
+    Defaults to 10.
+  * **batch_size** (*int*)
+* **Returns:**
+  The search results for each query.
+* **Return type:**
+  List[Result]
+
+#### `clear()`
+
+Clear all keys in Redis associated with the index, leaving the index
+available and in-place for future insertions or updates.
+
+* **Returns:**
+  Count of records deleted from Redis.
+* **Return type:**
+  int
+
+#### `connect(redis_url=None, **kwargs)`
+
+Connect to a Redis instance using the provided redis_url, falling
+back to the REDIS_URL environment variable (if available).
+
+Note: Additional keyword arguments (\*\*kwargs) can be used to provide
+extra options specific to the Redis connection.
+
+* **Parameters:**
+  **redis_url** (*Optional* *[* *str* *]* *,* *optional*) – The URL of the Redis server to
+  connect to.
+* **Raises:**
+  * **redis.exceptions.ConnectionError** – If the connection to the Redis
+        server fails.
+  * **ValueError** – If the Redis URL is not provided nor accessible
+        through the REDIS_URL environment variable.
+  * **ModuleNotFoundError** – If required Redis modules are not installed.
+
+#### `create(overwrite=False, drop=False)`
+
+Create an index in Redis with the current schema and properties.
+
+* **Parameters:**
+  * **overwrite** (*bool* *,* *optional*) – Whether to overwrite the index if it
+    already exists. Defaults to False.
+  * **drop** (*bool* *,* *optional*) – Whether to drop all keys associated with the
+    index in the case of overwriting. Defaults to False.
+* **Raises:**
+  * **RuntimeError** – If the index already exists and ‘overwrite’ is False.
+  * **ValueError** – If no fields are defined for the index.
+* **Return type:**
+  None
+
+```python
+# create an index in Redis; only if one does not exist with given name
+index.create()
+
+# overwrite an index in Redis without dropping associated data
+index.create(overwrite=True)
+
+# overwrite an index in Redis; drop associated data (clean slate)
+index.create(overwrite=True, drop=True)
+```
+
+#### `delete(drop=True)`
+
+Delete the search index while optionally dropping all keys associated
+with the index.
+
+* **Parameters:**
+  **drop** (*bool* *,* *optional*) – Delete the key / documents pairs in the
+  index. Defaults to True.
+* **Raises:**
+  **redis.exceptions.ResponseError** – If the index does not exist.
+
+#### `disconnect()`
+
+Disconnect from the Redis database.
+
+#### `drop_documents(ids)`
+
+Remove documents from the index by their document IDs.
+
+This method converts document IDs to Redis keys automatically by applying
+the index’s key prefix and separator configuration.
+
+* **Parameters:**
+  **ids** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The document ID or IDs to remove from the index.
+* **Returns:**
+  Count of documents deleted from Redis.
+* **Return type:**
+  int
+
+#### `drop_keys(keys)`
+
+Remove a specific entry or entries from the index by it’s key ID.
+
+* **Parameters:**
+  **keys** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The document ID or IDs to remove from the index.
+* **Returns:**
+  Count of records deleted from Redis.
+* **Return type:**
+  int
+
+#### `exists()`
+
+Check if the index exists in Redis.
+
+* **Returns:**
+  True if the index exists, False otherwise.
+* **Return type:**
+  bool
+
+#### `expire_keys(keys, ttl)`
+
+Set the expiration time for a specific entry or entries in Redis.
+
+* **Parameters:**
+  * **keys** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The entry ID or IDs to set the expiration for.
+  * **ttl** (*int*) – The time-to-live in seconds.
+* **Return type:**
+  int | *List*[int]
+
+#### `fetch(id)`
+
+Fetch an object from Redis by id.
+
+The id is typically either a unique identifier,
+or derived from some domain-specific metadata combination
+(like a document id or chunk id).
+
+* **Parameters:**
+  **id** (*str*) – The specified unique identifier for a particular
+  document indexed in Redis.
+* **Returns:**
+  The fetched object.
+* **Return type:**
+  Dict[str, Any]
+
+#### `classmethod from_dict(schema_dict, **kwargs)`
+
+Create a SearchIndex from a dictionary.
+
+* **Parameters:**
+  **schema_dict** (*Dict* *[* *str* *,* *Any* *]*) – A dictionary containing the schema.
+* **Returns:**
+  A RedisVL SearchIndex object.
+* **Return type:**
+  [SearchIndex](#searchindex)
+
+```python
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_dict({
+    "index": {
+        "name": "my-index",
+        "prefix": "rvl",
+        "storage_type": "hash",
+    },
+    "fields": [
+        {"name": "doc-id", "type": "tag"}
+    ]
+}, redis_url="redis://localhost:6379")
+```
+
+#### `classmethod from_existing(name, redis_client=None, redis_url=None, **kwargs)`
+
+Initialize from an existing search index in Redis by index name.
+
+* **Parameters:**
+  * **name** (*str*) – Name of the search index in Redis.
+  * **redis_client** (*Optional* *[* *redis.Redis* *]*) – An
+    instantiated redis client.
+  * **redis_url** (*Optional* *[* *str* *]*) – The URL of the Redis server to
+    connect to.
+* **Raises:**
+  * **ValueError** – If redis_url or redis_client is not provided.
+  * **RedisModuleVersionError** – If required Redis modules are not installed.
+
+#### `classmethod from_yaml(schema_path, **kwargs)`
+
+Create a SearchIndex from a YAML schema file.
+
+* **Parameters:**
+  **schema_path** (*str*) – Path to the YAML schema file.
+* **Returns:**
+  A RedisVL SearchIndex object.
+* **Return type:**
+  [SearchIndex](#searchindex)
+
+```python
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_yaml("schemas/schema.yaml", redis_url="redis://localhost:6379")
+```
+
+#### `info(name=None)`
+
+Get information about the index.
+
+* **Parameters:**
+  **name** (*str* *,* *optional*) – Index name to fetch info about.
+  Defaults to None.
+* **Returns:**
+  A dictionary containing the information about the index.
+* **Return type:**
+  dict
+
+#### `key(id)`
+
+Construct a redis key as a combination of an index key prefix (optional)
+and specified id.
+
+The id is typically either a unique identifier, or
+derived from some domain-specific metadata combination (like a document
+id or chunk id).
+
+* **Parameters:**
+  **id** (*str*) – The specified unique identifier for a particular
+  document indexed in Redis.
+* **Returns:**
+  The full Redis key including key prefix and value as a string.
+* **Return type:**
+  str
+
+#### `listall()`
+
+List all search indices in Redis database.
+
+* **Returns:**
+  The list of indices in the database.
+* **Return type:**
+  List[str]
+
+#### `load(data, id_field=None, keys=None, ttl=None, preprocess=None, batch_size=None)`
+
+Load objects to the Redis database. Returns the list of keys loaded
+to Redis.
+
+RedisVL automatically handles constructing the object keys, batching,
+optional preprocessing steps, and setting optional expiration
+(TTL policies) on keys.
+
+* **Parameters:**
+  * **data** (*Iterable* *[* *Any* *]*) – An iterable of objects to store.
+  * **id_field** (*Optional* *[* *str* *]* *,* *optional*) – Specified field used as the id
+    portion of the redis key (after the prefix) for each
+    object. Defaults to None.
+  * **keys** (*Optional* *[* *Iterable* *[* *str* *]* *]* *,* *optional*) – Optional iterable of keys.
+    Must match the length of objects if provided. Defaults to None.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – Time-to-live in seconds for each key.
+    Defaults to None.
+  * **preprocess** (*Optional* *[* *Callable* *]* *,* *optional*) – A function to preprocess
+    objects before storage. Defaults to None.
+  * **batch_size** (*Optional* *[* *int* *]* *,* *optional*) – Number of objects to write in
+    a single Redis pipeline execution. Defaults to class’s
+    default batch size.
+* **Returns:**
+  List of keys loaded to Redis.
+* **Return type:**
+  List[str]
+* **Raises:**
+  * **SchemaValidationError** – If validation fails when validate_on_load is enabled.
+  * **RedisVLError** – If there’s an error loading data to Redis.
+
+#### `paginate(query, page_size=30)`
+
+Execute a given query against the index and return results in
+paginated batches.
+
+This method accepts a RedisVL query instance, enabling pagination of
+results which allows for subsequent processing over each batch with a
+generator.
+
+* **Parameters:**
+  * **query** (*BaseQuery*) – The search query to be executed.
+  * **page_size** (*int* *,* *optional*) – The number of results to return in each
+    batch. Defaults to 30.
+* **Yields:**
+  A generator yielding batches of search results.
+* **Raises:**
+  * **TypeError** – If the page_size argument is not of type int.
+  * **ValueError** – If the page_size argument is less than or equal to zero.
+* **Return type:**
+  *Generator*
+
+```python
+# Iterate over paginated search results in batches of 10
+for result_batch in index.paginate(query, page_size=10):
+    # Process each batch of results
+    pass
+```
+
+#### `NOTE`
+The page_size parameter controls the number of items each result
+batch contains. Adjust this value based on performance
+considerations and the expected volume of search results.
+
+#### `query(query)`
+
+Execute a query on the index.
+
+This method takes a BaseQuery or AggregationQuery object directly, and
+handles post-processing of the search.
+
+* **Parameters:**
+  **query** (*Union* *[* *BaseQuery* *,* *AggregateQuery* *]*) – The query to run.
+* **Returns:**
+  A list of search results.
+* **Return type:**
+  List[Result]
+
+```python
+from redisvl.query import VectorQuery
+
+query = VectorQuery(
+    vector=[0.16, -0.34, 0.98, 0.23],
+    vector_field_name="embedding",
+    num_results=3
+)
+
+results = index.query(query)
+```
+
+#### `search(*args, **kwargs)`
+
+Perform a search against the index.
+
+Wrapper around the search API that adds the index name
+to the query and passes along the rest of the arguments
+to the redis-py ft().search() method.
+
+* **Returns:**
+  Raw Redis search results.
+* **Return type:**
+  Result
+
+#### `set_client(redis_client, **kwargs)`
+
+Manually set the Redis client to use with the search index.
+
+This method configures the search index to use a specific Redis or
+Async Redis client. It is useful for cases where an external,
+custom-configured client is preferred instead of creating a new one.
+
+* **Parameters:**
+  **redis_client** (*redis.Redis*) – A Redis or Async Redis
+  client instance to be used for the connection.
+* **Raises:**
+  **TypeError** – If the provided client is not valid.
+
+#### `property client: Redis | None`
+
+The underlying redis-py client object.
+
+#### `property key_separator: str`
+
+The optional separator between a defined prefix and key value in
+forming a Redis key.
+
+#### `property name: str`
+
+The name of the Redis search index.
+
+#### `property prefix: str`
+
+The optional key prefix that comes before a unique key value in
+forming a Redis key.
+
+#### `property storage_type: StorageType`
+
+The underlying storage type for the search index; either
+hash or json.
+
+<a id="asyncsearchindex-api"></a>
+
+## AsyncSearchIndex
+
+### `class AsyncSearchIndex(schema, *, redis_url=None, redis_client=None, connection_kwargs=None, validate_on_load=False, **kwargs)`
+
+A search index class for interacting with Redis as a vector database in
+async-mode.
+
+The AsyncSearchIndex is instantiated with a reference to a Redis database
+and an IndexSchema (YAML path or dictionary object) that describes the
+various settings and field configurations.
+
+```python
+from redisvl.index import AsyncSearchIndex
+
+# initialize the index object with schema from file
+index = AsyncSearchIndex.from_yaml(
+    "schemas/schema.yaml",
+    redis_url="redis://localhost:6379",
+    validate_on_load=True
+)
+
+# create the index
+await index.create(overwrite=True, drop=False)
+
+# data is an iterable of dictionaries
+await index.load(data)
+
+# delete index and data
+await index.delete(drop=True)
+```
+
+Initialize the RedisVL async search index with a schema.
+
+* **Parameters:**
+  * **schema** ([*IndexSchema*]({{< relref "schema/#indexschema" >}})) – Index schema object.
+  * **redis_url** (*Optional* *[* *str* *]* *,* *optional*) – The URL of the Redis server to
+    connect to.
+  * **redis_client** (*Optional* *[* *aredis.Redis* *]*) – An
+    instantiated redis client.
+  * **connection_kwargs** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – Redis client connection
+    args.
+  * **validate_on_load** (*bool* *,* *optional*) – Whether to validate data against schema
+    when loading. Defaults to False.
+
+#### `async aggregate(*args, **kwargs)`
+
+Perform an aggregation operation against the index.
+
+Wrapper around the aggregation API that adds the index name
+to the query and passes along the rest of the arguments
+to the redis-py ft().aggregate() method.
+
+* **Returns:**
+  Raw Redis aggregation results.
+* **Return type:**
+  Result
+
+#### `async batch_query(queries, batch_size=10)`
+
+Asynchronously execute a batch of queries and process results.
+
+* **Parameters:**
+  * **queries** (*List* *[* *BaseQuery* *]*)
+  * **batch_size** (*int*)
+* **Return type:**
+  *List*[*List*[*Dict*[str, *Any*]]]
+
+#### `async batch_search(queries, batch_size=10)`
+
+Perform a search against the index for multiple queries.
+
+This method takes a list of queries and returns a list of Result objects
+for each query. Results are returned in the same order as the queries.
+
+* **Parameters:**
+  * **queries** (*List* *[* *SearchParams* *]*) – The queries to search for. batch_size
+  * **(* ***int** – The number of queries to search for at a time.
+    Defaults to 10.
+  * **optional****)** – The number of queries to search for at a time.
+    Defaults to 10.
+  * **batch_size** (*int*)
+* **Returns:**
+  The search results for each query.
+* **Return type:**
+  List[Result]
+
+#### `async clear()`
+
+Clear all keys in Redis associated with the index, leaving the index
+available and in-place for future insertions or updates.
+
+* **Returns:**
+  Count of records deleted from Redis.
+* **Return type:**
+  int
+
+#### `connect(redis_url=None, **kwargs)`
+
+[DEPRECATED] Connect to a Redis instance. Use connection parameters in \_\_init_\_.
+
+* **Parameters:**
+  **redis_url** (*str* *|* *None*)
+
+#### `async create(overwrite=False, drop=False)`
+
+Asynchronously create an index in Redis with the current schema
+: and properties.
+
+* **Parameters:**
+  * **overwrite** (*bool* *,* *optional*) – Whether to overwrite the index if it
+    already exists. Defaults to False.
+  * **drop** (*bool* *,* *optional*) – Whether to drop all keys associated with the
+    index in the case of overwriting. Defaults to False.
+* **Raises:**
+  * **RuntimeError** – If the index already exists and ‘overwrite’ is False.
+  * **ValueError** – If no fields are defined for the index.
+* **Return type:**
+  None
+
+```python
+# create an index in Redis; only if one does not exist with given name
+await index.create()
+
+# overwrite an index in Redis without dropping associated data
+await index.create(overwrite=True)
+
+# overwrite an index in Redis; drop associated data (clean slate)
+await index.create(overwrite=True, drop=True)
+```
+
+#### `async delete(drop=True)`
+
+Delete the search index.
+
+* **Parameters:**
+  **drop** (*bool* *,* *optional*) – Delete the documents in the index.
+  Defaults to True.
+* **Raises:**
+  **redis.exceptions.ResponseError** – If the index does not exist.
+
+#### `async disconnect()`
+
+Disconnect from the Redis database.
+
+#### `async drop_documents(ids)`
+
+Remove documents from the index by their document IDs.
+
+This method converts document IDs to Redis keys automatically by applying
+the index’s key prefix and separator configuration.
+
+* **Parameters:**
+  **ids** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The document ID or IDs to remove from the index.
+* **Returns:**
+  Count of documents deleted from Redis.
+* **Return type:**
+  int
+
+#### `async drop_keys(keys)`
+
+Remove a specific entry or entries from the index by it’s key ID.
+
+* **Parameters:**
+  **keys** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The document ID or IDs to remove from the index.
+* **Returns:**
+  Count of records deleted from Redis.
+* **Return type:**
+  int
+
+#### `async exists()`
+
+Check if the index exists in Redis.
+
+* **Returns:**
+  True if the index exists, False otherwise.
+* **Return type:**
+  bool
+
+#### `async expire_keys(keys, ttl)`
+
+Set the expiration time for a specific entry or entries in Redis.
+
+* **Parameters:**
+  * **keys** (*Union* *[* *str* *,* *List* *[* *str* *]* *]*) – The entry ID or IDs to set the expiration for.
+  * **ttl** (*int*) – The time-to-live in seconds.
+* **Return type:**
+  int | *List*[int]
+
+#### `async fetch(id)`
+
+Asynchronously etch an object from Redis by id. The id is typically
+either a unique identifier, or derived from some domain-specific
+metadata combination (like a document id or chunk id).
+
+* **Parameters:**
+  **id** (*str*) – The specified unique identifier for a particular
+  document indexed in Redis.
+* **Returns:**
+  The fetched object.
+* **Return type:**
+  Dict[str, Any]
+
+#### `classmethod from_dict(schema_dict, **kwargs)`
+
+Create a SearchIndex from a dictionary.
+
+* **Parameters:**
+  **schema_dict** (*Dict* *[* *str* *,* *Any* *]*) – A dictionary containing the schema.
+* **Returns:**
+  A RedisVL SearchIndex object.
+* **Return type:**
+  [SearchIndex](#searchindex)
+
+```python
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_dict({
+    "index": {
+        "name": "my-index",
+        "prefix": "rvl",
+        "storage_type": "hash",
+    },
+    "fields": [
+        {"name": "doc-id", "type": "tag"}
+    ]
+}, redis_url="redis://localhost:6379")
+```
+
+#### `async classmethod* from_existing(name, redis_client=None, redis_url=None, **kwargs)`
+
+Initialize from an existing search index in Redis by index name.
+
+* **Parameters:**
+  * **name** (*str*) – Name of the search index in Redis.
+  * **redis_client** (*Optional* *[* *redis.Redis* *]*) – An
+    instantiated redis client.
+  * **redis_url** (*Optional* *[* *str* *]*) – The URL of the Redis server to
+    connect to.
+
+#### `classmethod from_yaml(schema_path, **kwargs)`
+
+Create a SearchIndex from a YAML schema file.
+
+* **Parameters:**
+  **schema_path** (*str*) – Path to the YAML schema file.
+* **Returns:**
+  A RedisVL SearchIndex object.
+* **Return type:**
+  [SearchIndex](#searchindex)
+
+```python
+from redisvl.index import SearchIndex
+
+index = SearchIndex.from_yaml("schemas/schema.yaml", redis_url="redis://localhost:6379")
+```
+
+#### `async info(name=None)`
+
+Get information about the index.
+
+* **Parameters:**
+  **name** (*str* *,* *optional*) – Index name to fetch info about.
+  Defaults to None.
+* **Returns:**
+  A dictionary containing the information about the index.
+* **Return type:**
+  dict
+
+#### `key(id)`
+
+Construct a redis key as a combination of an index key prefix (optional)
+and specified id.
+
+The id is typically either a unique identifier, or
+derived from some domain-specific metadata combination (like a document
+id or chunk id).
+
+* **Parameters:**
+  **id** (*str*) – The specified unique identifier for a particular
+  document indexed in Redis.
+* **Returns:**
+  The full Redis key including key prefix and value as a string.
+* **Return type:**
+  str
+
+#### `async listall()`
+
+List all search indices in Redis database.
+
+* **Returns:**
+  The list of indices in the database.
+* **Return type:**
+  List[str]
+
+#### `load(data, id_field=None, keys=None, ttl=None, preprocess=None, concurrency=None, batch_size=None)`
+
+Asynchronously load objects to Redis. Returns the list of keys loaded
+to Redis.
+
+RedisVL automatically handles constructing the object keys, batching,
+optional preprocessing steps, and setting optional expiration
+(TTL policies) on keys.
+
+* **Parameters:**
+  * **data** (*Iterable* *[* *Any* *]*) – An iterable of objects to store.
+  * **id_field** (*Optional* *[* *str* *]* *,* *optional*) – Specified field used as the id
+    portion of the redis key (after the prefix) for each
+    object. Defaults to None.
+  * **keys** (*Optional* *[* *Iterable* *[* *str* *]* *]* *,* *optional*) – Optional iterable of keys.
+    Must match the length of objects if provided. Defaults to None.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – Time-to-live in seconds for each key.
+    Defaults to None.
+  * **preprocess** (*Optional* *[* *Callable* *]* *,* *optional*) – A function to
+    preprocess objects before storage. Defaults to None.
+  * **batch_size** (*Optional* *[* *int* *]* *,* *optional*) – Number of objects to write in
+    a single Redis pipeline execution. Defaults to class’s
+    default batch size.
+  * **concurrency** (*int* *|* *None*)
+* **Returns:**
+  List of keys loaded to Redis.
+* **Return type:**
+  List[str]
+* **Raises:**
+  * **SchemaValidationError** – If validation fails when validate_on_load is enabled.
+  * **RedisVLError** – If there’s an error loading data to Redis.
+
+```python
+data = [{"test": "foo"}, {"test": "bar"}]
+
+# simple case
+keys = await index.load(data)
+
+# set 360 second ttl policy on data
+keys = await index.load(data, ttl=360)
+
+# load data with predefined keys
+keys = await index.load(data, keys=["rvl:foo", "rvl:bar"])
+
+# load data with preprocessing step
+def add_field(d):
+    d["new_field"] = 123
+    return d
+keys = await index.load(data, preprocess=add_field)
+```
+
+#### `async paginate(query, page_size=30)`
+
+Execute a given query against the index and return results in
+paginated batches.
+
+This method accepts a RedisVL query instance, enabling async pagination
+of results which allows for subsequent processing over each batch with a
+generator.
+
+* **Parameters:**
+  * **query** (*BaseQuery*) – The search query to be executed.
+  * **page_size** (*int* *,* *optional*) – The number of results to return in each
+    batch. Defaults to 30.
+* **Yields:**
+  An async generator yielding batches of search results.
+* **Raises:**
+  * **TypeError** – If the page_size argument is not of type int.
+  * **ValueError** – If the page_size argument is less than or equal to zero.
+* **Return type:**
+  *AsyncGenerator*
+
+```python
+# Iterate over paginated search results in batches of 10
+async for result_batch in index.paginate(query, page_size=10):
+    # Process each batch of results
+    pass
+```
+
+#### `NOTE`
+The page_size parameter controls the number of items each result
+batch contains. Adjust this value based on performance
+considerations and the expected volume of search results.
+
+#### `async query(query)`
+
+Asynchronously execute a query on the index.
+
+This method takes a BaseQuery or AggregationQuery object directly, runs
+the search, and handles post-processing of the search.
+
+* **Parameters:**
+  **query** (*Union* *[* *BaseQuery* *,* *AggregateQuery* *]*) – The query to run.
+* **Returns:**
+  A list of search results.
+* **Return type:**
+  List[Result]
+
+```python
+from redisvl.query import VectorQuery
+
+query = VectorQuery(
+    vector=[0.16, -0.34, 0.98, 0.23],
+    vector_field_name="embedding",
+    num_results=3
+)
+
+results = await index.query(query)
+```
+
+#### `async search(*args, **kwargs)`
+
+Perform a search on this index.
+
+Wrapper around redis.search.Search that adds the index name
+to the search query and passes along the rest of the arguments
+to the redis-py ft.search() method.
+
+* **Returns:**
+  Raw Redis search results.
+* **Return type:**
+  Result
+
+#### `set_client(redis_client)`
+
+[DEPRECATED] Manually set the Redis client to use with the search index.
+This method is deprecated; please provide connection parameters in \_\_init_\_.
+
+* **Parameters:**
+  **redis_client** (*Redis* *|* *Redis*)
+
+#### `property client: Redis | None`
+
+The underlying redis-py client object.
+
+#### `property key_separator: str`
+
+The optional separator between a defined prefix and key value in
+forming a Redis key.
+
+#### `property name: str`
+
+The name of the Redis search index.
+
+#### `property prefix: str`
+
+The optional key prefix that comes before a unique key value in
+forming a Redis key.
+
+#### `property storage_type: StorageType`
+
+The underlying storage type for the search index; either
+hash or json.
+---
+linkTitle: LLM cache
+title: LLM Cache
+type: integration
+---
+
+
+## SemanticCache
+
+<a id="semantic-cache-api"></a>
+
+### `class SemanticCache(name='llmcache', distance_threshold=0.1, ttl=None, vectorizer=None, filterable_fields=None, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={}, overwrite=False, **kwargs)`
+
+Bases: `BaseLLMCache`
+
+Semantic Cache for Large Language Models.
+
+Semantic Cache for Large Language Models.
+
+* **Parameters:**
+  * **name** (*str* *,* *optional*) – The name of the semantic cache search index.
+    Defaults to “llmcache”.
+  * **distance_threshold** (*float* *,* *optional*) – Semantic threshold for the
+    cache. Defaults to 0.1.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The time-to-live for records cached
+    in Redis. Defaults to None.
+  * **vectorizer** (*Optional* *[* *BaseVectorizer* *]* *,* *optional*) – The vectorizer for the cache.
+    Defaults to HFTextVectorizer.
+  * **filterable_fields** (*Optional* *[* *List* *[* *Dict* *[* *str* *,* *Any* *]* *]* *]*) – An optional list of RedisVL fields
+    that can be used to customize cache retrieval with filters.
+  * **redis_client** (*Optional* *[* *Redis* *]* *,* *optional*) – A redis client connection instance.
+    Defaults to None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+  * **overwrite** (*bool*) – Whether or not to force overwrite the schema for
+    the semantic cache index. Defaults to false.
+* **Raises:**
+  * **TypeError** – If an invalid vectorizer is provided.
+  * **TypeError** – If the TTL value is not an int.
+  * **ValueError** – If the threshold is not between 0 and 1.
+  * **ValueError** – If existing schema does not match new schema and overwrite is False.
+
+#### `async acheck(prompt=None, vector=None, num_results=1, return_fields=None, filter_expression=None, distance_threshold=None)`
+
+Async check the semantic cache for results similar to the specified prompt
+or vector.
+
+This method searches the cache using vector similarity with
+either a raw text prompt (converted to a vector) or a provided vector as
+input. It checks for semantically similar prompts and fetches the cached
+LLM responses.
+
+* **Parameters:**
+  * **prompt** (*Optional* *[* *str* *]* *,* *optional*) – The text prompt to search for in
+    the cache.
+  * **vector** (*Optional* *[* *List* *[* *float* *]* *]* *,* *optional*) – The vector representation
+    of the prompt to search for in the cache.
+  * **num_results** (*int* *,* *optional*) – The number of cached results to return.
+    Defaults to 1.
+  * **return_fields** (*Optional* *[* *List* *[* *str* *]* *]* *,* *optional*) – The fields to include
+    in each returned result. If None, defaults to all available
+    fields in the cached entry.
+  * **filter_expression** (*Optional* *[*[*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]*) – Optional filter expression
+    that can be used to filter cache results. Defaults to None and
+    the full cache will be searched.
+  * **distance_threshold** (*Optional* *[* *float* *]*) – The threshold for semantic
+    vector distance.
+* **Returns:**
+  A list of dicts containing the requested
+  : return fields for each similar cached response.
+* **Return type:**
+  List[Dict[str, Any]]
+* **Raises:**
+  * **ValueError** – If neither a prompt nor a vector is specified.
+  * **ValueError** – if ‘vector’ has incorrect dimensions.
+  * **TypeError** – If return_fields is not a list when provided.
+
+```python
+response = await cache.acheck(
+    prompt="What is the captial city of France?"
+)
+```
+
+#### `async aclear()`
+
+Async clear the cache of all keys.
+
+* **Return type:**
+  None
+
+#### `async adelete()`
+
+Async delete the cache and its index entirely.
+
+* **Return type:**
+  None
+
+#### `async adisconnect()`
+
+Asynchronously disconnect from Redis and search index.
+
+Closes all Redis connections and index connections.
+
+#### `async adrop(ids=None, keys=None)`
+
+Async drop specific entries from the cache by ID or Redis key.
+
+* **Parameters:**
+  * **ids** (*Optional* *[* *List* *[* *str* *]* *]*) – List of entry IDs to remove from the cache.
+    Entry IDs are the unique identifiers without the cache prefix.
+  * **keys** (*Optional* *[* *List* *[* *str* *]* *]*) – List of full Redis keys to remove from the cache.
+    Keys are the complete Redis keys including the cache prefix.
+* **Return type:**
+  None
+
+#### `NOTE`
+At least one of ids or keys must be provided.
+
+* **Raises:**
+  **ValueError** – If neither ids nor keys is provided.
+* **Parameters:**
+  * **ids** (*List* *[* *str* *]*  *|* *None*)
+  * **keys** (*List* *[* *str* *]*  *|* *None*)
+* **Return type:**
+  None
+
+#### `async aexpire(key, ttl=None)`
+
+Asynchronously set or refresh the expiration time for a key in the cache.
+
+* **Parameters:**
+  * **key** (*str*) – The Redis key to set the expiration on.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The time-to-live in seconds. If None,
+    uses the default TTL configured for this cache instance.
+    Defaults to None.
+* **Return type:**
+  None
+
+#### `NOTE`
+If neither the provided TTL nor the default TTL is set (both are None),
+this method will have no effect.
+
+#### `async astore(prompt, response, vector=None, metadata=None, filters=None, ttl=None)`
+
+Async stores the specified key-value pair in the cache along with metadata.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to cache.
+  * **response** (*str*) – The LLM response to cache.
+  * **vector** (*Optional* *[* *List* *[* *float* *]* *]* *,* *optional*) – The prompt vector to
+    cache. Defaults to None, and the prompt vector is generated on
+    demand.
+  * **metadata** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *optional*) – The optional metadata to cache
+    alongside the prompt and response. Defaults to None.
+  * **filters** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – The optional tag to assign to the cache entry.
+    Defaults to None.
+  * **ttl** (*Optional* *[* *int* *]*) – The optional TTL override to use on this individual cache
+    entry. Defaults to the global TTL setting.
+* **Returns:**
+  The Redis key for the entries added to the semantic cache.
+* **Return type:**
+  str
+* **Raises:**
+  * **ValueError** – If neither prompt nor vector is specified.
+  * **ValueError** – if vector has incorrect dimensions.
+  * **TypeError** – If provided metadata is not a dictionary.
+
+```python
+key = await cache.astore(
+    prompt="What is the captial city of France?",
+    response="Paris",
+    metadata={"city": "Paris", "country": "France"}
+)
+```
+
+#### `async aupdate(key, **kwargs)`
+
+Async update specific fields within an existing cache entry. If no fields
+are passed, then only the document TTL is refreshed.
+
+* **Parameters:**
+  **key** (*str*) – the key of the document to update using kwargs.
+* **Raises:**
+  * **ValueError if an incorrect mapping is provided as a kwarg.** – 
+  * **TypeError if metadata is provided and not** **of** **type dict.** – 
+* **Return type:**
+  None
+
+```python
+key = await cache.astore('this is a prompt', 'this is a response')
+await cache.aupdate(
+    key,
+    metadata={"hit_count": 1, "model_name": "Llama-2-7b"}
+)
+```
+
+#### `check(prompt=None, vector=None, num_results=1, return_fields=None, filter_expression=None, distance_threshold=None)`
+
+Checks the semantic cache for results similar to the specified prompt
+or vector.
+
+This method searches the cache using vector similarity with
+either a raw text prompt (converted to a vector) or a provided vector as
+input. It checks for semantically similar prompts and fetches the cached
+LLM responses.
+
+* **Parameters:**
+  * **prompt** (*Optional* *[* *str* *]* *,* *optional*) – The text prompt to search for in
+    the cache.
+  * **vector** (*Optional* *[* *List* *[* *float* *]* *]* *,* *optional*) – The vector representation
+    of the prompt to search for in the cache.
+  * **num_results** (*int* *,* *optional*) – The number of cached results to return.
+    Defaults to 1.
+  * **return_fields** (*Optional* *[* *List* *[* *str* *]* *]* *,* *optional*) – The fields to include
+    in each returned result. If None, defaults to all available
+    fields in the cached entry.
+  * **filter_expression** (*Optional* *[*[*FilterExpression*]({{< relref "filter/#filterexpression" >}}) *]*) – Optional filter expression
+    that can be used to filter cache results. Defaults to None and
+    the full cache will be searched.
+  * **distance_threshold** (*Optional* *[* *float* *]*) – The threshold for semantic
+    vector distance.
+* **Returns:**
+  A list of dicts containing the requested
+  : return fields for each similar cached response.
+* **Return type:**
+  List[Dict[str, Any]]
+* **Raises:**
+  * **ValueError** – If neither a prompt nor a vector is specified.
+  * **ValueError** – if ‘vector’ has incorrect dimensions.
+  * **TypeError** – If return_fields is not a list when provided.
+
+```python
+response = cache.check(
+    prompt="What is the captial city of France?"
+)
+```
+
+#### `clear()`
+
+Clear the cache of all keys.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Delete the cache and its index entirely.
+
+* **Return type:**
+  None
+
+#### `disconnect()`
+
+Disconnect from Redis and search index.
+
+Closes all Redis connections and index connections.
+
+#### `drop(ids=None, keys=None)`
+
+Drop specific entries from the cache by ID or Redis key.
+
+* **Parameters:**
+  * **ids** (*Optional* *[* *List* *[* *str* *]* *]*) – List of entry IDs to remove from the cache.
+    Entry IDs are the unique identifiers without the cache prefix.
+  * **keys** (*Optional* *[* *List* *[* *str* *]* *]*) – List of full Redis keys to remove from the cache.
+    Keys are the complete Redis keys including the cache prefix.
+* **Return type:**
+  None
+
+#### `NOTE`
+At least one of ids or keys must be provided.
+
+* **Raises:**
+  **ValueError** – If neither ids nor keys is provided.
+* **Parameters:**
+  * **ids** (*List* *[* *str* *]*  *|* *None*)
+  * **keys** (*List* *[* *str* *]*  *|* *None*)
+* **Return type:**
+  None
+
+#### `expire(key, ttl=None)`
+
+Set or refresh the expiration time for a key in the cache.
+
+* **Parameters:**
+  * **key** (*str*) – The Redis key to set the expiration on.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The time-to-live in seconds. If None,
+    uses the default TTL configured for this cache instance.
+    Defaults to None.
+* **Return type:**
+  None
+
+#### `NOTE`
+If neither the provided TTL nor the default TTL is set (both are None),
+this method will have no effect.
+
+#### `set_threshold(distance_threshold)`
+
+Sets the semantic distance threshold for the cache.
+
+* **Parameters:**
+  **distance_threshold** (*float*) – The semantic distance threshold for
+  the cache.
+* **Raises:**
+  **ValueError** – If the threshold is not between 0 and 1.
+* **Return type:**
+  None
+
+#### `set_ttl(ttl=None)`
+
+Set the default TTL, in seconds, for entries in the cache.
+
+* **Parameters:**
+  **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The optional time-to-live expiration
+  for the cache, in seconds.
+* **Raises:**
+  **ValueError** – If the time-to-live value is not an integer.
+* **Return type:**
+  None
+
+#### `store(prompt, response, vector=None, metadata=None, filters=None, ttl=None)`
+
+Stores the specified key-value pair in the cache along with metadata.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to cache.
+  * **response** (*str*) – The LLM response to cache.
+  * **vector** (*Optional* *[* *List* *[* *float* *]* *]* *,* *optional*) – The prompt vector to
+    cache. Defaults to None, and the prompt vector is generated on
+    demand.
+  * **metadata** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]* *,* *optional*) – The optional metadata to cache
+    alongside the prompt and response. Defaults to None.
+  * **filters** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – The optional tag to assign to the cache entry.
+    Defaults to None.
+  * **ttl** (*Optional* *[* *int* *]*) – The optional TTL override to use on this individual cache
+    entry. Defaults to the global TTL setting.
+* **Returns:**
+  The Redis key for the entries added to the semantic cache.
+* **Return type:**
+  str
+* **Raises:**
+  * **ValueError** – If neither prompt nor vector is specified.
+  * **ValueError** – if vector has incorrect dimensions.
+  * **TypeError** – If provided metadata is not a dictionary.
+
+```python
+key = cache.store(
+    prompt="What is the captial city of France?",
+    response="Paris",
+    metadata={"city": "Paris", "country": "France"}
+)
+```
+
+#### `update(key, **kwargs)`
+
+Update specific fields within an existing cache entry. If no fields
+are passed, then only the document TTL is refreshed.
+
+* **Parameters:**
+  **key** (*str*) – the key of the document to update using kwargs.
+* **Raises:**
+  * **ValueError if an incorrect mapping is provided as a kwarg.** – 
+  * **TypeError if metadata is provided and not** **of** **type dict.** – 
+* **Return type:**
+  None
+
+```python
+key = cache.store('this is a prompt', 'this is a response')
+cache.update(key, metadata={"hit_count": 1, "model_name": "Llama-2-7b"})
+```
+
+#### `property aindex: `[`AsyncSearchIndex`]({{< relref "searchindex/#asyncsearchindex" >}})`  | None`
+
+The underlying AsyncSearchIndex for the cache.
+
+* **Returns:**
+  The async search index.
+* **Return type:**
+  [AsyncSearchIndex]({{< relref "searchindex/#asyncsearchindex" >}})
+
+#### `property distance_threshold: float`
+
+The semantic distance threshold for the cache.
+
+* **Returns:**
+  The semantic distance threshold.
+* **Return type:**
+  float
+
+#### `property index: `[`SearchIndex`]({{< relref "searchindex/#searchindex" >}})` `
+
+The underlying SearchIndex for the cache.
+
+* **Returns:**
+  The search index.
+* **Return type:**
+  [SearchIndex]({{< relref "searchindex/#searchindex" >}})
+
+#### `property ttl: int | None`
+
+The default TTL, in seconds, for entries in the cache.
+
+# Embeddings Cache
+
+## EmbeddingsCache
+
+<a id="embeddings-cache-api"></a>
+
+### `class EmbeddingsCache(name='embedcache', ttl=None, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={})`
+
+Bases: `BaseCache`
+
+Embeddings Cache for storing embedding vectors with exact key matching.
+
+Initialize an embeddings cache.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the cache. Defaults to “embedcache”.
+  * **ttl** (*Optional* *[* *int* *]*) – The time-to-live for cached embeddings. Defaults to None.
+  * **redis_client** (*Optional* *[* *Redis* *]*) – Redis client instance. Defaults to None.
+  * **redis_url** (*str*) – Redis URL for connection. Defaults to “redis://localhost:6379”.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – Redis connection arguments. Defaults to {}.
+* **Raises:**
+  **ValueError** – If vector dimensions are invalid
+
+```python
+cache = EmbeddingsCache(
+    name="my_embeddings_cache",
+    ttl=3600,  # 1 hour
+    redis_url="redis://localhost:6379"
+)
+```
+
+#### `async aclear()`
+
+Async clear the cache of all keys.
+
+* **Return type:**
+  None
+
+#### `async adisconnect()`
+
+Async disconnect from Redis.
+
+* **Return type:**
+  None
+
+#### `async adrop(text, model_name)`
+
+Async remove an embedding from the cache.
+
+Asynchronously removes an embedding from the cache.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Return type:**
+  None
+
+```python
+await cache.adrop(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `async adrop_by_key(key)`
+
+Async remove an embedding from the cache by its Redis key.
+
+Asynchronously removes an embedding from the cache by its Redis key.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Return type:**
+  None
+
+```python
+await cache.adrop_by_key("embedcache:1234567890abcdef")
+```
+
+#### `async aexists(text, model_name)`
+
+Async check if an embedding exists.
+
+Asynchronously checks if an embedding exists for the given text and model.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  True if the embedding exists in the cache, False otherwise.
+* **Return type:**
+  bool
+
+```python
+if await cache.aexists("What is machine learning?", "text-embedding-ada-002"):
+    print("Embedding is in cache")
+```
+
+#### `async aexists_by_key(key)`
+
+Async check if an embedding exists for the given Redis key.
+
+Asynchronously checks if an embedding exists for the given Redis key.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Returns:**
+  True if the embedding exists in the cache, False otherwise.
+* **Return type:**
+  bool
+
+```python
+if await cache.aexists_by_key("embedcache:1234567890abcdef"):
+    print("Embedding is in cache")
+```
+
+#### `async aexpire(key, ttl=None)`
+
+Asynchronously set or refresh the expiration time for a key in the cache.
+
+* **Parameters:**
+  * **key** (*str*) – The Redis key to set the expiration on.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The time-to-live in seconds. If None,
+    uses the default TTL configured for this cache instance.
+    Defaults to None.
+* **Return type:**
+  None
+
+#### `NOTE`
+If neither the provided TTL nor the default TTL is set (both are None),
+this method will have no effect.
+
+#### `async aget(text, model_name)`
+
+Async get embedding by text and model name.
+
+Asynchronously retrieves a cached embedding for the given text and model name.
+If found, refreshes the TTL of the entry.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  Embedding cache entry or None if not found.
+* **Return type:**
+  Optional[Dict[str, Any]]
+
+```python
+embedding_data = await cache.aget(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `async aget_by_key(key)`
+
+Async get embedding by its full Redis key.
+
+Asynchronously retrieves a cached embedding for the given Redis key.
+If found, refreshes the TTL of the entry.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Returns:**
+  Embedding cache entry or None if not found.
+* **Return type:**
+  Optional[Dict[str, Any]]
+
+```python
+embedding_data = await cache.aget_by_key("embedcache:1234567890abcdef")
+```
+
+#### `async amdrop(texts, model_name)`
+
+Async remove multiple embeddings from the cache by their texts and model name.
+
+Asynchronously removes multiple embeddings in a single operation.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Return type:**
+  None
+
+```python
+# Remove multiple embeddings asynchronously
+await cache.amdrop(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `async amdrop_by_keys(keys)`
+
+Async remove multiple embeddings from the cache by their Redis keys.
+
+Asynchronously removes multiple embeddings in a single operation.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to remove.
+* **Return type:**
+  None
+
+```python
+# Remove multiple embeddings asynchronously
+await cache.amdrop_by_keys(["embedcache:key1", "embedcache:key2"])
+```
+
+#### `async amexists(texts, model_name)`
+
+Async check if multiple embeddings exist by their texts and model name.
+
+Asynchronously checks existence of multiple embeddings in a single operation.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  List of boolean values indicating whether each embedding exists.
+* **Return type:**
+  List[bool]
+
+```python
+# Check if multiple embeddings exist asynchronously
+exists_results = await cache.amexists(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `async amexists_by_keys(keys)`
+
+Async check if multiple embeddings exist by their Redis keys.
+
+Asynchronously checks existence of multiple keys in a single operation.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to check.
+* **Returns:**
+  List of boolean values indicating whether each key exists.
+  The order matches the input keys order.
+* **Return type:**
+  List[bool]
+
+```python
+# Check if multiple keys exist asynchronously
+exists_results = await cache.amexists_by_keys(["embedcache:key1", "embedcache:key2"])
+```
+
+#### `async amget(texts, model_name)`
+
+Async get multiple embeddings by their texts and model name.
+
+Asynchronously retrieves multiple cached embeddings in a single operation.
+If found, refreshes the TTL of each entry.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  List of embedding cache entries or None for texts not found.
+* **Return type:**
+  List[Optional[Dict[str, Any]]]
+
+```python
+# Get multiple embeddings asynchronously
+embedding_data = await cache.amget(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `async amget_by_keys(keys)`
+
+Async get multiple embeddings by their Redis keys.
+
+Asynchronously retrieves multiple cached embeddings in a single network roundtrip.
+If found, refreshes the TTL of each entry.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to retrieve.
+* **Returns:**
+  List of embedding cache entries or None for keys not found.
+  The order matches the input keys order.
+* **Return type:**
+  List[Optional[Dict[str, Any]]]
+
+```python
+# Get multiple embeddings asynchronously
+embedding_data = await cache.amget_by_keys([
+    "embedcache:key1",
+    "embedcache:key2"
+])
+```
+
+#### `async amset(items, ttl=None)`
+
+Async store multiple embeddings in a batch operation.
+
+Each item in the input list should be a dictionary with the following fields:
+- ‘text’: The text input that was embedded
+- ‘model_name’: The name of the embedding model
+- ‘embedding’: The embedding vector
+- ‘metadata’: Optional metadata to store with the embedding
+
+* **Parameters:**
+  * **items** (*List* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – List of dictionaries, each containing text, model_name, embedding, and optional metadata.
+  * **ttl** (*int* *|* *None*) – Optional TTL override for these entries.
+* **Returns:**
+  List of Redis keys where the embeddings were stored.
+* **Return type:**
+  List[str]
+
+```python
+# Store multiple embeddings asynchronously
+keys = await cache.amset([
+    {
+        "text": "What is ML?",
+        "model_name": "text-embedding-ada-002",
+        "embedding": [0.1, 0.2, 0.3],
+        "metadata": {"source": "user"}
+    },
+    {
+        "text": "What is AI?",
+        "model_name": "text-embedding-ada-002",
+        "embedding": [0.4, 0.5, 0.6],
+        "metadata": {"source": "docs"}
+    }
+])
+```
+
+#### `async aset(text, model_name, embedding, metadata=None, ttl=None)`
+
+Async store an embedding with its text and model name.
+
+Asynchronously stores an embedding with its text and model name.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+  * **embedding** (*List* *[* *float* *]*) – The embedding vector to store.
+  * **metadata** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – Optional metadata to store with the embedding.
+  * **ttl** (*Optional* *[* *int* *]*) – Optional TTL override for this specific entry.
+* **Returns:**
+  The Redis key where the embedding was stored.
+* **Return type:**
+  str
+
+```python
+key = await cache.aset(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002",
+    embedding=[0.1, 0.2, 0.3, ...],
+    metadata={"source": "user_query"}
+)
+```
+
+#### `clear()`
+
+Clear the cache of all keys.
+
+* **Return type:**
+  None
+
+#### `disconnect()`
+
+Disconnect from Redis.
+
+* **Return type:**
+  None
+
+#### `drop(text, model_name)`
+
+Remove an embedding from the cache.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Return type:**
+  None
+
+```python
+cache.drop(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `drop_by_key(key)`
+
+Remove an embedding from the cache by its Redis key.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Return type:**
+  None
+
+```python
+cache.drop_by_key("embedcache:1234567890abcdef")
+```
+
+#### `exists(text, model_name)`
+
+Check if an embedding exists for the given text and model.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  True if the embedding exists in the cache, False otherwise.
+* **Return type:**
+  bool
+
+```python
+if cache.exists("What is machine learning?", "text-embedding-ada-002"):
+    print("Embedding is in cache")
+```
+
+#### `exists_by_key(key)`
+
+Check if an embedding exists for the given Redis key.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Returns:**
+  True if the embedding exists in the cache, False otherwise.
+* **Return type:**
+  bool
+
+```python
+if cache.exists_by_key("embedcache:1234567890abcdef"):
+    print("Embedding is in cache")
+```
+
+#### `expire(key, ttl=None)`
+
+Set or refresh the expiration time for a key in the cache.
+
+* **Parameters:**
+  * **key** (*str*) – The Redis key to set the expiration on.
+  * **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The time-to-live in seconds. If None,
+    uses the default TTL configured for this cache instance.
+    Defaults to None.
+* **Return type:**
+  None
+
+#### `NOTE`
+If neither the provided TTL nor the default TTL is set (both are None),
+this method will have no effect.
+
+#### `get(text, model_name)`
+
+Get embedding by text and model name.
+
+Retrieves a cached embedding for the given text and model name.
+If found, refreshes the TTL of the entry.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  Embedding cache entry or None if not found.
+* **Return type:**
+  Optional[Dict[str, Any]]
+
+```python
+embedding_data = cache.get(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `get_by_key(key)`
+
+Get embedding by its full Redis key.
+
+Retrieves a cached embedding for the given Redis key.
+If found, refreshes the TTL of the entry.
+
+* **Parameters:**
+  **key** (*str*) – The full Redis key for the embedding.
+* **Returns:**
+  Embedding cache entry or None if not found.
+* **Return type:**
+  Optional[Dict[str, Any]]
+
+```python
+embedding_data = cache.get_by_key("embedcache:1234567890abcdef")
+```
+
+#### `mdrop(texts, model_name)`
+
+Remove multiple embeddings from the cache by their texts and model name.
+
+Efficiently removes multiple embeddings in a single operation.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Return type:**
+  None
+
+```python
+# Remove multiple embeddings
+cache.mdrop(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `mdrop_by_keys(keys)`
+
+Remove multiple embeddings from the cache by their Redis keys.
+
+Efficiently removes multiple embeddings in a single operation.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to remove.
+* **Return type:**
+  None
+
+```python
+# Remove multiple embeddings
+cache.mdrop_by_keys(["embedcache:key1", "embedcache:key2"])
+```
+
+#### `mexists(texts, model_name)`
+
+Check if multiple embeddings exist by their texts and model name.
+
+Efficiently checks existence of multiple embeddings in a single operation.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  List of boolean values indicating whether each embedding exists.
+* **Return type:**
+  List[bool]
+
+```python
+# Check if multiple embeddings exist
+exists_results = cache.mexists(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `mexists_by_keys(keys)`
+
+Check if multiple embeddings exist by their Redis keys.
+
+Efficiently checks existence of multiple keys in a single operation.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to check.
+* **Returns:**
+  List of boolean values indicating whether each key exists.
+  The order matches the input keys order.
+* **Return type:**
+  List[bool]
+
+```python
+# Check if multiple keys exist
+exists_results = cache.mexists_by_keys(["embedcache:key1", "embedcache:key2"])
+```
+
+#### `mget(texts, model_name)`
+
+Get multiple embeddings by their texts and model name.
+
+Efficiently retrieves multiple cached embeddings in a single operation.
+If found, refreshes the TTL of each entry.
+
+* **Parameters:**
+  * **texts** (*List* *[* *str* *]*) – List of text inputs that were embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+* **Returns:**
+  List of embedding cache entries or None for texts not found.
+* **Return type:**
+  List[Optional[Dict[str, Any]]]
+
+```python
+# Get multiple embeddings
+embedding_data = cache.mget(
+    texts=["What is machine learning?", "What is deep learning?"],
+    model_name="text-embedding-ada-002"
+)
+```
+
+#### `mget_by_keys(keys)`
+
+Get multiple embeddings by their Redis keys.
+
+Efficiently retrieves multiple cached embeddings in a single network roundtrip.
+If found, refreshes the TTL of each entry.
+
+* **Parameters:**
+  **keys** (*List* *[* *str* *]*) – List of Redis keys to retrieve.
+* **Returns:**
+  List of embedding cache entries or None for keys not found.
+  The order matches the input keys order.
+* **Return type:**
+  List[Optional[Dict[str, Any]]]
+
+```python
+# Get multiple embeddings
+embedding_data = cache.mget_by_keys([
+    "embedcache:key1",
+    "embedcache:key2"
+])
+```
+
+#### `mset(items, ttl=None)`
+
+Store multiple embeddings in a batch operation.
+
+Each item in the input list should be a dictionary with the following fields:
+- ‘text’: The text input that was embedded
+- ‘model_name’: The name of the embedding model
+- ‘embedding’: The embedding vector
+- ‘metadata’: Optional metadata to store with the embedding
+
+* **Parameters:**
+  * **items** (*List* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – List of dictionaries, each containing text, model_name, embedding, and optional metadata.
+  * **ttl** (*int* *|* *None*) – Optional TTL override for these entries.
+* **Returns:**
+  List of Redis keys where the embeddings were stored.
+* **Return type:**
+  List[str]
+
+```python
+# Store multiple embeddings
+keys = cache.mset([
+    {
+        "text": "What is ML?",
+        "model_name": "text-embedding-ada-002",
+        "embedding": [0.1, 0.2, 0.3],
+        "metadata": {"source": "user"}
+    },
+    {
+        "text": "What is AI?",
+        "model_name": "text-embedding-ada-002",
+        "embedding": [0.4, 0.5, 0.6],
+        "metadata": {"source": "docs"}
+    }
+])
+```
+
+#### `set(text, model_name, embedding, metadata=None, ttl=None)`
+
+Store an embedding with its text and model name.
+
+* **Parameters:**
+  * **text** (*str*) – The text input that was embedded.
+  * **model_name** (*str*) – The name of the embedding model.
+  * **embedding** (*List* *[* *float* *]*) – The embedding vector to store.
+  * **metadata** (*Optional* *[* *Dict* *[* *str* *,* *Any* *]* *]*) – Optional metadata to store with the embedding.
+  * **ttl** (*Optional* *[* *int* *]*) – Optional TTL override for this specific entry.
+* **Returns:**
+  The Redis key where the embedding was stored.
+* **Return type:**
+  str
+
+```python
+key = cache.set(
+    text="What is machine learning?",
+    model_name="text-embedding-ada-002",
+    embedding=[0.1, 0.2, 0.3, ...],
+    metadata={"source": "user_query"}
+)
+```
+
+#### `set_ttl(ttl=None)`
+
+Set the default TTL, in seconds, for entries in the cache.
+
+* **Parameters:**
+  **ttl** (*Optional* *[* *int* *]* *,* *optional*) – The optional time-to-live expiration
+  for the cache, in seconds.
+* **Raises:**
+  **ValueError** – If the time-to-live value is not an integer.
+* **Return type:**
+  None
+
+#### `property ttl: int | None`
+
+The default TTL, in seconds, for entries in the cache.
+---
+linkTitle: LLM session manager
+title: LLM Session Manager
+type: integration
+---
+
+
+## SemanticSessionManager
+
+<a id="semantic-session-manager-api"></a>
+
+### `class SemanticSessionManager(name, session_tag=None, prefix=None, vectorizer=None, distance_threshold=0.3, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={}, overwrite=False, **kwargs)`
+
+Bases: `BaseSessionManager`
+
+Initialize session memory with index
+
+Session Manager stores the current and previous user text prompts and
+LLM responses to allow for enriching future prompts with session
+context. Session history is stored in individual user or LLM prompts and
+responses.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the session manager index.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+  * **prefix** (*Optional* *[* *str* *]*) – Prefix for the keys for this session data.
+    Defaults to None and will be replaced with the index name.
+  * **vectorizer** (*Optional* *[* *BaseVectorizer* *]*) – The vectorizer used to create embeddings.
+  * **distance_threshold** (*float*) – The maximum semantic distance to be
+    included in the context. Defaults to 0.3.
+  * **redis_client** (*Optional* *[* *Redis* *]*) – A Redis client instance. Defaults to
+    None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+  * **overwrite** (*bool*) – Whether or not to force overwrite the schema for
+    the semantic session index. Defaults to false.
+
+The proposed schema will support a single vector embedding constructed
+from either the prompt or response in a single string.
+
+#### `add_message(message, session_tag=None)`
+
+Insert a single prompt or response into the session memory.
+A timestamp is associated with it so that it can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **message** (*Dict* *[* *str* *,**str* *]*) – The user prompt or LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `add_messages(messages, session_tag=None)`
+
+Insert a list of prompts and responses into the session memory.
+A timestamp is associated with each so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **messages** (*List* *[* *Dict* *[* *str* *,* *str* *]* *]*) – The list of user prompts and LLM responses.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `clear()`
+
+Clears the chat session history.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Clear all conversation keys and remove the search index.
+
+* **Return type:**
+  None
+
+#### `drop(id=None)`
+
+Remove a specific exchange from the conversation history.
+
+* **Parameters:**
+  **id** (*Optional* *[* *str* *]*) – The id of the session entry to delete.
+  If None then the last entry is deleted.
+* **Return type:**
+  None
+
+#### `get_recent(top_k=5, as_text=False, raw=False, session_tag=None)`
+
+Retreive the recent conversation history in sequential order.
+
+* **Parameters:**
+  * **top_k** (*int*) – The number of previous exchanges to return. Default is 5.
+  * **as_text** (*bool*) – Whether to return the conversation as a single string,
+    or list of alternating prompts and responses.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    prompt and response
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Returns:**
+  A single string transcription of the session
+  : or list of strings if as_text is false.
+* **Return type:**
+  Union[str, List[str]]
+* **Raises:**
+  **ValueError** – if top_k is not an integer greater than or equal to 0.
+
+#### `get_relevant(prompt, as_text=False, top_k=5, fall_back=False, session_tag=None, raw=False, distance_threshold=None)`
+
+Searches the chat history for information semantically related to
+the specified prompt.
+
+This method uses vector similarity search with a text prompt as input.
+It checks for semantically similar prompts and responses and gets
+the top k most relevant previous prompts or responses to include as
+context to the next LLM call.
+
+* **Parameters:**
+  * **prompt** (*str*) – The message text to search for in session memory
+  * **as_text** (*bool*) – Whether to return the prompts and responses as text
+  * **JSON** (*or as*)
+  * **top_k** (*int*) – The number of previous messages to return. Default is 5.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+  * **distance_threshold** (*Optional* *[* *float* *]*) – The threshold for semantic
+    vector distance.
+  * **fall_back** (*bool*) – Whether to drop back to recent conversation history
+    if no relevant context is found.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    message.
+* **Returns:**
+  Either a list of strings, or a
+  list of prompts and responses in JSON containing the most relevant.
+* **Return type:**
+  Union[List[str], List[Dict[str,str]]
+
+Raises ValueError: if top_k is not an integer greater or equal to 0.
+
+#### `store(prompt, response, session_tag=None)`
+
+Insert a prompt:response pair into the session memory. A timestamp
+is associated with each message so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to the LLM.
+  * **response** (*str*) – The corresponding LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `property messages: List[str] | List[Dict[str, str]]`
+
+Returns the full chat history.
+
+## StandardSessionManager
+
+<a id="standard-session-manager-api"></a>
+
+### `class StandardSessionManager(name, session_tag=None, prefix=None, redis_client=None, redis_url='redis://localhost:6379', connection_kwargs={}, **kwargs)`
+
+Bases: `BaseSessionManager`
+
+Initialize session memory
+
+Session Manager stores the current and previous user text prompts and
+LLM responses to allow for enriching future prompts with session
+context.Session history is stored in individual user or LLM prompts and
+responses.
+
+* **Parameters:**
+  * **name** (*str*) – The name of the session manager index.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+  * **prefix** (*Optional* *[* *str* *]*) – Prefix for the keys for this session data.
+    Defaults to None and will be replaced with the index name.
+  * **redis_client** (*Optional* *[* *Redis* *]*) – A Redis client instance. Defaults to
+    None.
+  * **redis_url** (*str* *,* *optional*) – The redis url. Defaults to redis://localhost:6379.
+  * **connection_kwargs** (*Dict* *[* *str* *,* *Any* *]*) – The connection arguments
+    for the redis client. Defaults to empty {}.
+
+The proposed schema will support a single combined vector embedding
+constructed from the prompt & response in a single string.
+
+#### `add_message(message, session_tag=None)`
+
+Insert a single prompt or response into the session memory.
+A timestamp is associated with it so that it can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **message** (*Dict* *[* *str* *,**str* *]*) – The user prompt or LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `add_messages(messages, session_tag=None)`
+
+Insert a list of prompts and responses into the session memory.
+A timestamp is associated with each so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **messages** (*List* *[* *Dict* *[* *str* *,* *str* *]* *]*) – The list of user prompts and LLM responses.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `clear()`
+
+Clears the chat session history.
+
+* **Return type:**
+  None
+
+#### `delete()`
+
+Clear all conversation keys and remove the search index.
+
+* **Return type:**
+  None
+
+#### `drop(id=None)`
+
+Remove a specific exchange from the conversation history.
+
+* **Parameters:**
+  **id** (*Optional* *[* *str* *]*) – The id of the session entry to delete.
+  If None then the last entry is deleted.
+* **Return type:**
+  None
+
+#### `get_recent(top_k=5, as_text=False, raw=False, session_tag=None)`
+
+Retrieve the recent conversation history in sequential order.
+
+* **Parameters:**
+  * **top_k** (*int*) – The number of previous messages to return. Default is 5.
+  * **as_text** (*bool*) – Whether to return the conversation as a single string,
+    or list of alternating prompts and responses.
+  * **raw** (*bool*) – Whether to return the full Redis hash entry or just the
+    prompt and response
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Returns:**
+  A single string transcription of the session
+  : or list of strings if as_text is false.
+* **Return type:**
+  Union[str, List[str]]
+* **Raises:**
+  **ValueError** – if top_k is not an integer greater than or equal to 0.
+
+#### `store(prompt, response, session_tag=None)`
+
+Insert a prompt:response pair into the session memory. A timestamp
+is associated with each exchange so that they can be later sorted
+in sequential ordering after retrieval.
+
+* **Parameters:**
+  * **prompt** (*str*) – The user prompt to the LLM.
+  * **response** (*str*) – The corresponding LLM response.
+  * **session_tag** (*Optional* *[* *str* *]*) – Tag to be added to entries to link to a specific
+    session. Defaults to instance ULID.
+* **Return type:**
+  None
+
+#### `property messages: List[str] | List[Dict[str, str]]`
+
+Returns the full chat history.
+---
+linkTitle: Vectorizers
+title: Vectorizers
+type: integration
+---
+
+
+## HFTextVectorizer
+
+<a id="hftextvectorizer-api"></a>
+
+### `class HFTextVectorizer(model='sentence-transformers/all-mpnet-base-v2', dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The HFTextVectorizer class leverages Hugging Face’s Sentence Transformers
+for generating vector embeddings from text input.
+
+This vectorizer is particularly useful in scenarios where advanced natural language
+processing and understanding are required, and ideal for running on your own
+hardware without usage fees.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+Utilizing this vectorizer involves specifying a pre-trained model from
+Hugging Face’s vast collection of Sentence Transformers. These models are
+trained on a variety of datasets and tasks, ensuring versatility and
+robust performance across different embedding needs.
+
+Requirements:
+: - The sentence-transformers library must be installed with pip.
+
+```python
+# Basic usage
+vectorizer = HFTextVectorizer(model="sentence-transformers/all-mpnet-base-v2")
+embedding = vectorizer.embed("Hello, world!")
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="my_embeddings_cache")
+
+vectorizer = HFTextVectorizer(
+    model="sentence-transformers/all-mpnet-base-v2",
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Batch processing
+embeddings = vectorizer.embed_many(
+    ["Hello, world!", "How are you?"],
+    batch_size=2
+)
+```
+
+Initialize the Hugging Face text vectorizer.
+
+* **Parameters:**
+  * **model** (*str*) – The pre-trained model from Hugging Face’s Sentence
+    Transformers to be used for embedding. Defaults to
+    ‘sentence-transformers/all-mpnet-base-v2’.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **\*\*kwargs** – Additional parameters to pass to the SentenceTransformer
+    constructor.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the sentence-transformers library is not installed.
+  * **ValueError** – If there is an error setting the embedding model dimensions.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_post_init(context, /)`
+
+This function is meant to behave like a BaseModel method to initialise private attributes.
+
+It takes context as an argument since that’s what pydantic-core passes when calling it.
+
+* **Parameters:**
+  * **self** (*BaseModel*) – The BaseModel instance.
+  * **context** (*Any*) – The context.
+* **Return type:**
+  None
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## OpenAITextVectorizer
+
+<a id="openaitextvectorizer-api"></a>
+
+### `class OpenAITextVectorizer(model='text-embedding-ada-002', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The OpenAITextVectorizer class utilizes OpenAI’s API to generate
+embeddings for text data.
+
+This vectorizer is designed to interact with OpenAI’s embeddings API,
+requiring an API key for authentication. The key can be provided directly
+in the api_config dictionary or through the OPENAI_API_KEY environment
+variable. Users must obtain an API key from OpenAI’s website
+([https://api.openai.com/](https://api.openai.com/)). Additionally, the openai python client must be
+installed with pip install openai>=1.13.0.
+
+The vectorizer supports both synchronous and asynchronous operations,
+allowing for batch processing of texts and flexibility in handling
+preprocessing tasks.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+# Basic usage with OpenAI embeddings
+vectorizer = OpenAITextVectorizer(
+    model="text-embedding-ada-002",
+    api_config={"api_key": "your_api_key"} # OR set OPENAI_API_KEY in your env
+)
+embedding = vectorizer.embed("Hello, world!")
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="openai_embeddings_cache")
+
+vectorizer = OpenAITextVectorizer(
+    model="text-embedding-ada-002",
+    api_config={"api_key": "your_api_key"},
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Asynchronous batch embedding of multiple texts
+embeddings = await vectorizer.aembed_many(
+    ["Hello, world!", "How are you?"],
+    batch_size=2
+)
+```
+
+Initialize the OpenAI vectorizer.
+
+* **Parameters:**
+  * **model** (*str*) – Model to use for embedding. Defaults to
+    ‘text-embedding-ada-002’.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the
+    API key and any additional OpenAI API options. Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the openai library is not installed.
+  * **ValueError** – If the OpenAI API key is not provided.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## AzureOpenAITextVectorizer
+
+<a id="azureopenaitextvectorizer-api"></a>
+
+### `class AzureOpenAITextVectorizer(model='text-embedding-ada-002', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The AzureOpenAITextVectorizer class utilizes AzureOpenAI’s API to generate
+embeddings for text data.
+
+This vectorizer is designed to interact with AzureOpenAI’s embeddings API,
+requiring an API key, an AzureOpenAI deployment endpoint and API version.
+These values can be provided directly in the api_config dictionary with
+the parameters ‘azure_endpoint’, ‘api_version’ and ‘api_key’ or through the
+environment variables ‘AZURE_OPENAI_ENDPOINT’, ‘OPENAI_API_VERSION’, and ‘AZURE_OPENAI_API_KEY’.
+Users must obtain these values from the ‘Keys and Endpoints’ section in their Azure OpenAI service.
+Additionally, the openai python client must be installed with pip install openai>=1.13.0.
+
+The vectorizer supports both synchronous and asynchronous operations,
+allowing for batch processing of texts and flexibility in handling
+preprocessing tasks.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+# Basic usage
+vectorizer = AzureOpenAITextVectorizer(
+    model="text-embedding-ada-002",
+    api_config={
+        "api_key": "your_api_key", # OR set AZURE_OPENAI_API_KEY in your env
+        "api_version": "your_api_version", # OR set OPENAI_API_VERSION in your env
+        "azure_endpoint": "your_azure_endpoint", # OR set AZURE_OPENAI_ENDPOINT in your env
+    }
+)
+embedding = vectorizer.embed("Hello, world!")
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="azureopenai_embeddings_cache")
+
+vectorizer = AzureOpenAITextVectorizer(
+    model="text-embedding-ada-002",
+    api_config={
+        "api_key": "your_api_key",
+        "api_version": "your_api_version",
+        "azure_endpoint": "your_azure_endpoint",
+    },
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Asynchronous batch embedding of multiple texts
+embeddings = await vectorizer.aembed_many(
+    ["Hello, world!", "How are you?"],
+    batch_size=2
+)
+```
+
+Initialize the AzureOpenAI vectorizer.
+
+* **Parameters:**
+  * **model** (*str*) – Deployment to use for embedding. Must be the
+    ‘Deployment name’ not the ‘Model name’. Defaults to
+    ‘text-embedding-ada-002’.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the
+    API key, API version, Azure endpoint, and any other API options.
+    Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the openai library is not installed.
+  * **ValueError** – If the AzureOpenAI API key, version, or endpoint are not provided.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## VertexAITextVectorizer
+
+<a id="vertexaitextvectorizer-api"></a>
+
+### `class VertexAITextVectorizer(model='textembedding-gecko', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The VertexAITextVectorizer uses Google’s VertexAI Palm 2 embedding model
+API to create text embeddings.
+
+This vectorizer is tailored for use in
+environments where integration with Google Cloud Platform (GCP) services is
+a key requirement.
+
+Utilizing this vectorizer requires an active GCP project and location
+(region), along with appropriate application credentials. These can be
+provided through the api_config dictionary or set the GOOGLE_APPLICATION_CREDENTIALS
+env var. Additionally, the vertexai python client must be
+installed with pip install google-cloud-aiplatform>=1.26.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+# Basic usage
+vectorizer = VertexAITextVectorizer(
+    model="textembedding-gecko",
+    api_config={
+        "project_id": "your_gcp_project_id", # OR set GCP_PROJECT_ID
+        "location": "your_gcp_location",     # OR set GCP_LOCATION
+    })
+embedding = vectorizer.embed("Hello, world!")
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="vertexai_embeddings_cache")
+
+vectorizer = VertexAITextVectorizer(
+    model="textembedding-gecko",
+    api_config={
+        "project_id": "your_gcp_project_id",
+        "location": "your_gcp_location",
+    },
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Batch embedding of multiple texts
+embeddings = vectorizer.embed_many(
+    ["Hello, world!", "Goodbye, world!"],
+    batch_size=2
+)
+```
+
+Initialize the VertexAI vectorizer.
+
+* **Parameters:**
+  * **model** (*str*) – Model to use for embedding. Defaults to
+    ‘textembedding-gecko’.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the
+    API config details. Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the google-cloud-aiplatform library is not installed.
+  * **ValueError** – If the API key is not provided.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## CohereTextVectorizer
+
+<a id="coheretextvectorizer-api"></a>
+
+### `class CohereTextVectorizer(model='embed-english-v3.0', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The CohereTextVectorizer class utilizes Cohere’s API to generate
+embeddings for text data.
+
+This vectorizer is designed to interact with Cohere’s /embed API,
+requiring an API key for authentication. The key can be provided
+directly in the api_config dictionary or through the COHERE_API_KEY
+environment variable. User must obtain an API key from Cohere’s website
+([https://dashboard.cohere.com/](https://dashboard.cohere.com/)). Additionally, the cohere python
+client must be installed with pip install cohere.
+
+The vectorizer supports only synchronous operations, allows for batch
+processing of texts and flexibility in handling preprocessing tasks.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+from redisvl.utils.vectorize import CohereTextVectorizer
+
+# Basic usage
+vectorizer = CohereTextVectorizer(
+    model="embed-english-v3.0",
+    api_config={"api_key": "your-cohere-api-key"} # OR set COHERE_API_KEY in your env
+)
+query_embedding = vectorizer.embed(
+    text="your input query text here",
+    input_type="search_query"
+)
+doc_embeddings = vectorizer.embed_many(
+    texts=["your document text", "more document text"],
+    input_type="search_document"
+)
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="cohere_embeddings_cache")
+
+vectorizer = CohereTextVectorizer(
+    model="embed-english-v3.0",
+    api_config={"api_key": "your-cohere-api-key"},
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed(
+    text="your input query text here",
+    input_type="search_query"
+)
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed(
+    text="your input query text here",
+    input_type="search_query"
+)
+```
+
+Initialize the Cohere vectorizer.
+
+Visit [https://cohere.ai/embed](https://cohere.ai/embed) to learn about embeddings.
+
+* **Parameters:**
+  * **model** (*str*) – Model to use for embedding. Defaults to ‘embed-english-v3.0’.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the API key.
+    Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    ‘float32’ will use Cohere’s float embeddings, ‘int8’ and ‘uint8’ will map
+    to Cohere’s corresponding embedding types. Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the cohere library is not installed.
+  * **ValueError** – If the API key is not provided.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## BedrockTextVectorizer
+
+<a id="bedrocktextvectorizer-api"></a>
+
+### `class BedrockTextVectorizer(model='amazon.titan-embed-text-v2:0', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The AmazonBedrockTextVectorizer class utilizes Amazon Bedrock’s API to generate
+embeddings for text data.
+
+This vectorizer is designed to interact with Amazon Bedrock API,
+requiring AWS credentials for authentication. The credentials can be provided
+directly in the api_config dictionary or through environment variables:
+- AWS_ACCESS_KEY_ID
+- AWS_SECRET_ACCESS_KEY
+- AWS_REGION (defaults to us-east-1)
+
+The vectorizer supports synchronous operations with batch processing and
+preprocessing capabilities.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+# Basic usage with explicit credentials
+vectorizer = AmazonBedrockTextVectorizer(
+    model="amazon.titan-embed-text-v2:0",
+    api_config={
+        "aws_access_key_id": "your_access_key",
+        "aws_secret_access_key": "your_secret_key",
+        "aws_region": "us-east-1"
+    }
+)
+
+# With environment variables and caching
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="bedrock_embeddings_cache")
+
+vectorizer = AmazonBedrockTextVectorizer(
+    model="amazon.titan-embed-text-v2:0",
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Generate batch embeddings
+embeddings = vectorizer.embed_many(["Hello", "World"], batch_size=2)
+```
+
+Initialize the AWS Bedrock Vectorizer.
+
+* **Parameters:**
+  * **model** (*str*) – The Bedrock model ID to use. Defaults to amazon.titan-embed-text-v2:0
+  * **api_config** (*Optional* *[* *Dict* *[* *str* *,* *str* *]* *]*) – AWS credentials and config.
+    Can include: aws_access_key_id, aws_secret_access_key, aws_region
+    If not provided, will use environment variables.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ValueError** – If credentials are not provided in config or environment.
+  * **ImportError** – If boto3 is not installed.
+  * **ValueError** – If an invalid dtype is provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## CustomTextVectorizer
+
+<a id="customtextvectorizer-api"></a>
+
+### `class CustomTextVectorizer(embed, embed_many=None, aembed=None, aembed_many=None, dtype='float32', cache=None)`
+
+Bases: `BaseVectorizer`
+
+The CustomTextVectorizer class wraps user-defined embedding methods to create
+embeddings for text data.
+
+This vectorizer is designed to accept a provided callable text vectorizer and
+provides a class definition to allow for compatibility with RedisVL.
+The vectorizer may support both synchronous and asynchronous operations which
+allows for batch processing of texts, but at a minimum only syncronous embedding
+is required to satisfy the ‘embed()’ method.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+# Basic usage with a custom embedding function
+vectorizer = CustomTextVectorizer(
+    embed = my_vectorizer.generate_embedding
+)
+embedding = vectorizer.embed("Hello, world!")
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="my_embeddings_cache")
+
+vectorizer = CustomTextVectorizer(
+    embed=my_vectorizer.generate_embedding,
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed("Hello, world!")
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed("Hello, world!")
+
+# Asynchronous batch embedding of multiple texts
+embeddings = await vectorizer.aembed_many(
+    ["Hello, world!", "How are you?"],
+    batch_size=2
+)
+```
+
+Initialize the Custom vectorizer.
+
+* **Parameters:**
+  * **embed** (*Callable*) – a Callable function that accepts a string object and returns a list of floats.
+  * **embed_many** (*Optional* *[* *Callable* *]*) – a Callable function that accepts a list of string objects and returns a list containing lists of floats. Defaults to None.
+  * **aembed** (*Optional* *[* *Callable* *]*) – an asyncronous Callable function that accepts a string object and returns a lists of floats. Defaults to None.
+  * **aembed_many** (*Optional* *[* *Callable* *]*) – an asyncronous Callable function that accepts a list of string objects and returns a list containing lists of floats. Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+* **Raises:**
+  **ValueError** – if embedding validation fails.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+
+## VoyageAITextVectorizer
+
+<a id="voyageaitextvectorizer-api"></a>
+
+### `class VoyageAITextVectorizer(model='voyage-large-2', api_config=None, dtype='float32', cache=None, *, dims=None)`
+
+Bases: `BaseVectorizer`
+
+The VoyageAITextVectorizer class utilizes VoyageAI’s API to generate
+embeddings for text data.
+
+This vectorizer is designed to interact with VoyageAI’s /embed API,
+requiring an API key for authentication. The key can be provided
+directly in the api_config dictionary or through the VOYAGE_API_KEY
+environment variable. User must obtain an API key from VoyageAI’s website
+([https://dash.voyageai.com/](https://dash.voyageai.com/)). Additionally, the voyageai python
+client must be installed with pip install voyageai.
+
+The vectorizer supports both synchronous and asynchronous operations, allows for batch
+processing of texts and flexibility in handling preprocessing tasks.
+
+You can optionally enable caching to improve performance when generating
+embeddings for repeated text inputs.
+
+```python
+from redisvl.utils.vectorize import VoyageAITextVectorizer
+
+# Basic usage
+vectorizer = VoyageAITextVectorizer(
+    model="voyage-large-2",
+    api_config={"api_key": "your-voyageai-api-key"} # OR set VOYAGE_API_KEY in your env
+)
+query_embedding = vectorizer.embed(
+    text="your input query text here",
+    input_type="query"
+)
+doc_embeddings = vectorizer.embed_many(
+    texts=["your document text", "more document text"],
+    input_type="document"
+)
+
+# With caching enabled
+from redisvl.extensions.cache.embeddings import EmbeddingsCache
+cache = EmbeddingsCache(name="voyageai_embeddings_cache")
+
+vectorizer = VoyageAITextVectorizer(
+    model="voyage-large-2",
+    api_config={"api_key": "your-voyageai-api-key"},
+    cache=cache
+)
+
+# First call will compute and cache the embedding
+embedding1 = vectorizer.embed(
+    text="your input query text here",
+    input_type="query"
+)
+
+# Second call will retrieve from cache
+embedding2 = vectorizer.embed(
+    text="your input query text here",
+    input_type="query"
+)
+```
+
+Initialize the VoyageAI vectorizer.
+
+Visit [https://docs.voyageai.com/docs/embeddings](https://docs.voyageai.com/docs/embeddings) to learn about embeddings and check the available models.
+
+* **Parameters:**
+  * **model** (*str*) – Model to use for embedding. Defaults to “voyage-large-2”.
+  * **api_config** (*Optional* *[* *Dict* *]* *,* *optional*) – Dictionary containing the API key.
+    Defaults to None.
+  * **dtype** (*str*) – the default datatype to use when embedding text as byte arrays.
+    Used when setting as_buffer=True in calls to embed() and embed_many().
+    Defaults to ‘float32’.
+  * **cache** (*Optional* *[*[*EmbeddingsCache*]({{< relref "cache/#embeddingscache" >}}) *]*) – Optional EmbeddingsCache instance to cache embeddings for
+    better performance with repeated texts. Defaults to None.
+  * **dims** (*Annotated* *[* *int* *|* *None* *,* *FieldInfo* *(* *annotation=NoneType* *,* *required=True* *,* *metadata=* *[* *Strict* *(* *strict=True* *)* *,* *Gt* *(* *gt=0* *)* *]* *)* *]*)
+* **Raises:**
+  * **ImportError** – If the voyageai library is not installed.
+  * **ValueError** – If the API key is not provided.
+
+#### `model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}`
+
+Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
+
+#### `property type: str`
+
+Return the type of vectorizer.
+---
+linkTitle: RedisVL API
+title: RedisVL API
+type: integration
+weight: 5
+hideListLinks: true
+---
+
+
+Reference documentation for the RedisVL API.
+
+
+
+* [Schema](schema/)
+  * [IndexSchema](schema/#indexschema)
+  * [Defining Fields](schema/#defining-fields)
+  * [Supported Field Types and Attributes](schema/#supported-field-types-and-attributes)
+* [Search Index Classes](searchindex/)
+  * [SearchIndex](searchindex/#searchindex)
+  * [AsyncSearchIndex](searchindex/#asyncsearchindex)
+* [Query](query/)
+  * [VectorQuery](query/#vectorquery)
+  * [VectorRangeQuery](query/#vectorrangequery)
+  * [HybridQuery](query/#hybridquery)
+  * [TextQuery](query/#textquery)
+  * [FilterQuery](query/#filterquery)
+  * [CountQuery](query/#countquery)
+* [Filter](filter/)
+  * [FilterExpression](filter/#filterexpression)
+  * [Tag](filter/#tag)
+  * [Text](filter/#text)
+  * [Num](filter/#num)
+  * [Geo](filter/#geo)
+  * [GeoRadius](filter/#georadius)
+* [Vectorizers](vectorizer/)
+  * [HFTextVectorizer](vectorizer/#hftextvectorizer)
+  * [OpenAITextVectorizer](vectorizer/#openaitextvectorizer)
+  * [AzureOpenAITextVectorizer](vectorizer/#azureopenaitextvectorizer)
+  * [VertexAITextVectorizer](vectorizer/#vertexaitextvectorizer)
+  * [CohereTextVectorizer](vectorizer/#coheretextvectorizer)
+  * [BedrockTextVectorizer](vectorizer/#bedrocktextvectorizer)
+  * [CustomTextVectorizer](vectorizer/#customtextvectorizer)
+  * [VoyageAITextVectorizer](vectorizer/#voyageaitextvectorizer)
+* [Rerankers](reranker/)
+  * [CohereReranker](reranker/#coherereranker)
+  * [HFCrossEncoderReranker](reranker/#hfcrossencoderreranker)
+  * [VoyageAIReranker](reranker/#voyageaireranker)
+* [LLM Cache](cache/)
+  * [SemanticCache](cache/#semanticcache)
+* [Embeddings Cache](cache/#embeddings-cache)
+  * [EmbeddingsCache](cache/#embeddingscache)
+* [LLM Message History](message_history/)
+  * [SemanticMessageHistory](message_history/#semanticmessagehistory)
+  * [MessageHistory](message_history/#messagehistory)
+* [Semantic Router](router/)
+  * [Semantic Router](router/#semantic-router-api)
+  * [Routing Config](router/#routing-config)
+  * [Route](router/#route)
+  * [Route Match](router/#route-match)
+  * [Distance Aggregation Method](router/#distance-aggregation-method)
+* [Threshold Optimizers](threshold_optimizer/)
+  * [CacheThresholdOptimizer](threshold_optimizer/#cachethresholdoptimizer)
+  * [RouterThresholdOptimizer](threshold_optimizer/#routerthresholdoptimizer)
+---
+linkTitle: The RedisVL CLI
+title: The RedisVL CLI
+type: integration
+---
+
+
+RedisVL is a Python library with a dedicated CLI to help load and create vector search indices within Redis.
+
+This notebook will walk through how to use the Redis Vector Library CLI (``rvl``).
+
+Before running this notebook, be sure to
+1. Have installed ``redisvl`` and have that environment active for this notebook.
+2. Have a running Redis instance with the Search and Query capability
+
+
+```python
+# First, see if the rvl tool is installed
+!rvl version
+```
+
+    19:16:18 [RedisVL] INFO   RedisVL version 0.5.2
+
+
+## Commands
+Here's a table of all the rvl commands and options. We'll go into each one in detail below.
+
+| Command       | Options                  | Description |
+|---------------|--------------------------|-------------|
+| `rvl version` |                          | display the redisvl library version|
+| `rvl index`   | `create --schema` or `-s <schema.yaml>`| create a redis index from the specified schema file|
+| `rvl index`   | `listall`                | list all the existing search indices|
+| `rvl index`   | `info --index` or ` -i <index_name>`   | display the index definition in tabular format|
+| `rvl index`   | `delete --index` or `-i <index_name>` | remove the specified index, leaving the data still in Redis|
+| `rvl index`   | `destroy --index` or `-i <index_name>`| remove the specified index, as well as the associated data|
+| `rvl stats`   | `--index` or `-i <index_name>`        | display the index statistics, including number of docs, average bytes per record, indexing time, etc|
+| `rvl stats`   | `--schema` or `-s <schema.yaml>`        | display the index statistics of a schema defined in <schema.yaml>. The index must have already been created within Redis|
+
+## Index
+
+The ``rvl index`` command can be used for a number of tasks related to creating and managing indices. Whether you are working in Python or another language, this cli tool can still be useful for managing and inspecting your indices.
+
+First, we will create an index from a yaml schema that looks like the following:
+
+
+
+```python
+%%writefile schema.yaml
+
+version: '0.1.0'
+
+index:
+    name: vectorizers
+    prefix: doc
+    storage_type: hash
+
+fields:
+    - name: sentence
+      type: text
+    - name: embedding
+      type: vector
+      attrs:
+        dims: 768
+        algorithm: flat
+        distance_metric: cosine
+```
+
+    Overwriting schema.yaml
+
+
+
+```python
+# Create an index from a yaml schema
+!rvl index create -s schema.yaml
+```
+
+    19:16:21 [RedisVL] INFO   Index created successfully
+
+
+
+```python
+# list the indices that are available
+!rvl index listall
+```
+
+    19:16:24 [RedisVL] INFO   Indices:
+    19:16:24 [RedisVL] INFO   1. vectorizers
+
+
+
+```python
+# inspect the index fields
+!rvl index info -i vectorizers
+```
+
+    
+    
+    Index Information:
+    ╭───────────────┬───────────────┬───────────────┬───────────────┬───────────────╮
+    │ Index Name    │ Storage Type  │ Prefixes      │ Index Options │ Indexing      │
+    ├───────────────┼───────────────┼───────────────┼───────────────┼───────────────┤
+    | vectorizers   | HASH          | ['doc']       | []            | 0             |
+    ╰───────────────┴───────────────┴───────────────┴───────────────┴───────────────╯
+    Index Fields:
+    ╭─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────╮
+    │ Name            │ Attribute       │ Type            │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │ Field Option    │ Option Value    │
+    ├─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┼─────────────────┤
+    │ sentence        │ sentence        │ TEXT            │ WEIGHT          │ 1               │                 │                 │                 │                 │                 │                 │
+    │ embedding       │ embedding       │ VECTOR          │ algorithm       │ FLAT            │ data_type       │ FLOAT32         │ dim             │ 768             │ distance_metric │ COSINE          │
+    ╰─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────┴─────────────────╯
+
+
+
+```python
+# delete an index without deleting the data within it
+!rvl index delete -i vectorizers
+```
+
+    19:16:29 [RedisVL] INFO   Index deleted successfully
+
+
+
+```python
+# see the indices that still exist
+!rvl index listall
+```
+
+    19:16:32 [RedisVL] INFO   Indices:
+
+
+## Stats
+
+The ``rvl stats`` command will return some basic information about the index. This is useful for checking the status of an index, or for getting information about the index to use in other commands.
+
+
+```python
+# create a new index with the same schema
+# recreating the index will reindex the documents
+!rvl index create -s schema.yaml
+```
+
+    19:16:35 [RedisVL] INFO   Index created successfully
+
+
+
+```python
+# list the indices that are available
+!rvl index listall
+```
+
+    19:16:38 [RedisVL] INFO   Indices:
+    19:16:38 [RedisVL] INFO   1. vectorizers
+
+
+
+```python
+# see all the stats for the index
+!rvl stats -i vectorizers
+```
+
+    
+    Statistics:
+    ╭─────────────────────────────┬────────────╮
+    │ Stat Key                    │ Value      │
+    ├─────────────────────────────┼────────────┤
+    │ num_docs                    │ 0          │
+    │ num_terms                   │ 0          │
+    │ max_doc_id                  │ 0          │
+    │ num_records                 │ 0          │
+    │ percent_indexed             │ 1          │
+    │ hash_indexing_failures      │ 0          │
+    │ number_of_uses              │ 1          │
+    │ bytes_per_record_avg        │ nan        │
+    │ doc_table_size_mb           │ 0          │
+    │ inverted_sz_mb              │ 0          │
+    │ key_table_size_mb           │ 0          │
+    │ offset_bits_per_record_avg  │ nan        │
+    │ offset_vectors_sz_mb        │ 0          │
+    │ offsets_per_term_avg        │ nan        │
+    │ records_per_doc_avg         │ nan        │
+    │ sortable_values_size_mb     │ 0          │
+    │ total_indexing_time         │ 0          │
+    │ total_inverted_index_blocks │ 0          │
+    │ vector_index_sz_mb          │ 0.00818634 │
+    ╰─────────────────────────────┴────────────╯
+
+
+## Optional arguments
+You can modify these commands with the below optional arguments
+
+| Argument       | Description | Default |
+|----------------|-------------|---------|
+| `-u --url`     | The full Redis URL to connec to | `redis://localhost:6379` |
+| `--host`       | Redis host to connect to | `localhost` |
+| `-p --port`    | Redis port to connect to. Must be an integer | `6379` |
+| `--user`       | Redis username, if one is required   | `default` |
+| `--ssl`        | Boolean flag indicating if ssl is required. If set the Redis base url changes to `rediss://` | None |
+| `-a --password`| Redis password, if one is required| `""` |
+
+### Choosing your Redis instance
+By default rvl first checks if you have `REDIS_URL` environment variable defined and tries to connect to that. If not, it then falls back to `localhost:6379`, unless you pass the `--host` or `--port` arguments
+
+
+```python
+# specify your Redis instance to connect to
+!rvl index listall --host localhost --port 6379
+```
+
+    19:16:43 [RedisVL] INFO   Indices:
+    19:16:43 [RedisVL] INFO   1. vectorizers
+
+
+### Using SSL encription
+If your Redis instance is configured to use SSL encription then set the `--ssl` flag.
+You can similarly specify the username and password to construct the full Redis URL
+
+
+```python
+# connect to rediss://jane_doe:password123@localhost:6379
+!rvl index listall --user jane_doe -a password123 --ssl
+```
+
+    19:16:46 [RedisVL] ERROR   Error 8 connecting to rediss:6379. nodename nor servname provided, or not known.
+
+
+
+```python
+!rvl index destroy -i vectorizers
+```
+
+    19:16:49 [RedisVL] INFO   Index deleted successfully
+
+---
+linkTitle: Install RedisVL
+title: Install RedisVL
+type: integration
+---
+
+
+There are a few ways to install RedisVL. The easiest way is to use pip.
+
+## Install RedisVL with Pip
+
+Install `redisvl` into your Python (>=3.8) environment using `pip`:
+
+```bash
+$ pip install -U redisvl
+```
+
+RedisVL comes with a few dependencies that are automatically installed, however, a few dependencies
+are optional and can be installed separately if needed:
+
+```bash
+$ pip install redisvl[all]  # install vectorizer dependencies
+$ pip install redisvl[dev]  # install dev dependencies
+```
+
+If you use ZSH, remember to escape the brackets:
+
+```bash
+$ pip install redisvl\[all\]
+```
+
+This library supports the use of hiredis, so you can also install by running:
+
+```bash
+pip install redisvl[hiredis]
+```
+
+## Install RedisVL from Source
+
+To install RedisVL from source, clone the repository and install the package using `pip`:
+
+```bash
+$ git clone https://github.com/redis/redis-vl-python.git && cd redisvl
+$ pip install .
+
+# or for an editable installation (for developers of RedisVL)
+$ pip install -e .
+```
+
+## Installing Redis
+
+RedisVL requires a distribution of Redis that supports the [Search and Query](https://redis.com/modules/redis-search/) capability of which there are 3:
+
+offering
+
+1. [Redis Cloud](https://redis.io/cloud), a fully managed cloud offering
+2. [Redis Stack](https://redis.io/docs/getting-started/install-stack/docker/), a local docker image for testing and development
+3. [Redis Enterprise](https://redis.com/redis-enterprise/), a commercial self-hosted
+
+### Redis Cloud
+
+Redis Cloud is the easiest way to get started with RedisVL. You can sign up for a free account [here](https://redis.io/cloud). Make sure to have the `Search and Query`
+capability enabled when creating your database.
+
+### Redis Stack (local development)
+
+For local development and testing, Redis-Stack can be used. We recommend running Redis
+in a docker container. To do so, run the following command:
+
+```bash
+docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+```
+
+This will also spin up the [Redis Insight GUI](https://redis.io/insight/) at `http://localhost:8001`.
+
+### Redis Enterprise (self-hosted)
+
+Redis Enterprise is a commercial offering that can be self-hosted. You can download the latest version [here](https://redis.io/downloads/).
+
+If you are considering a self-hosted Redis Enterprise deployment on Kubernetes, there is the [Redis Enterprise Operator](https://docs.redis.com/latest/kubernetes/) for Kubernetes. This will allow you to easily deploy and manage a Redis Enterprise cluster on Kubernetes.
+---
+linkTitle: Overview
+title: Overview
+type: integration
+weight: 3
+hideListLinks: true
+---
+
+
+
+
+* [Install RedisVL](installation/)
+  * [Install RedisVL with Pip](installation/#install-redisvl-with-pip)
+  * [Install RedisVL from Source](installation/#install-redisvl-from-source)
+  * [Installing Redis](installation/#installing-redis)
+* [The RedisVL CLI](cli/)
+  * [Commands](cli/#commands)
+  * [Index](cli/#index)
+  * [Stats](cli/#stats)
+  * [Optional arguments](cli/#optional-arguments)
+---
+aliases:
+- /integrate/redisvl/api
+- /integrate/redisvl/api/cache
+- /integrate/redisvl/api/filter
+- /integrate/redisvl/api/query
+- /integrate/redisvl/api/schema
+- /integrate/redisvl/api/searchindex
+- /integrate/redisvl/api/vectorizer
+- /integrate/redisvl/overview
+- /integrate/redisvl/overview/cli
+- /integrate/redisvl/user-guide
+- /integrate/redisvl/user-guide/get-started
+- /integrate/redisvl/user-guide/json-v-hashes
+- /integrate/redisvl/user-guide/query-filter
+- /integrate/redisvl/user-guide/semantic-caching
+- /integrate/redisvl/user-guide/vectorizers
+categories:
+- docs
+- integrate
+- stack
+- oss
+- rs
+- rc
+- oss
+- clients
+description: This is the Redis vector library (RedisVL).
+group: library
+hidden: false
+linkTitle: RedisVL
+summary: RedisVL provides a powerful, dedicated Python client library for using Redis
+  as a vector database. Leverage Redis's speed, reliability, and vector-based semantic
+  search capabilities to supercharge your application.
+title: RedisVL
+type: integration
+weight: 1
+---
+RedisVL is a powerful, dedicated Python client library for Redis that enables seamless integration and management of high-dimensional vector data.
+Built to support machine learning and artificial intelligence workflows, RedisVL simplifies the process of storing, searching, and analyzing vector embeddings, which are commonly used for tasks like recommendation systems, semantic search, and anomaly detection.
+
+Key features of RedisVL include:
+
+- Vector Similarity Search: Efficiently find nearest neighbors in high-dimensional spaces using algorithms like HNSW (Hierarchical Navigable Small World).
+- Integration with AI Frameworks: RedisVL works seamlessly with popular frameworks such as TensorFlow, PyTorch, and Hugging Face, making it easy to deploy AI models.
+- Scalable and Fast: Leveraging Redis's in-memory architecture, RedisVL provides low-latency access to vector data, even at scale.
+- By bridging the gap between data storage and AI model deployment, RedisVL empowers developers to build intelligent, real-time applications with minimal infrastructure complexity.
+---
+LinkTitle: Nagios with Redis Enterprise
+Title: Nagios with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: "The Redis Enterprise Software (RS)\_Nagios plugin enables you to monitor\
+  \ the status of RS\_related objects and alerts. The RS\_alerts can be related to\
+  \ the cluster, nodes, or databases."
+group: observability
+summary: "This\_Nagios plugin enables you to monitor the status of Redis Enterprise\_\
+  related components and alerts."
+title: Nagios integration with Redis Enterprise Software
+type: integration
+weight: 7
+---
+
+{{<banner-article>}}
+The Nagios plugin has been retired as of Redis Enterprise Software version 7.2.4.
+{{</banner-article>}}
+
+The Redis Enterprise Software (RS) Nagios plugin enables you to monitor the status of RS related
+objects and alerts. The RS alerts can be related to the cluster, nodes,
+or databases.
+
+The alerts that can be monitored via Nagios are the same alerts that can
+be configured in the RS UI in the Settings ­\> Alerts page, or the
+specific Database ­\> Configuration page.
+
+All alert configurations (active / not active, setting thresholds, etc')
+can only be done through the RS UI, they cannot be configured in Nagios.
+Through Nagios you can only view the status and information of the
+alerts.
+
+The full list of alerts can be found in the plugin package itself (in
+"/rlec_obj/rlec_services.cfg" file, more details below).
+
+RS Nagios plugin support API password retrieval from Gnome keyring,
+KWallet, Windows credential vault, Mac OS X Keychain, if present, or
+otherwise Linux Secret Service compatible password store. With no
+keyring service available, the password is saved with base64 encoding,
+under the user home directory.
+
+## Configuring the Nagios plugin
+
+In order to configure the Nagios plugin you need to copy the files that
+come with the package into your Nagios environment and place them in a
+Nagios configuration directory. Or, alternatively you can copy parts of
+the package configuration into your existing Nagios configuration.
+
+If Keyring capabilities are needed to store the password, python keyring
+package should be installed and used by following the below steps from
+the operating system CLI on Nagios machine:
+
+1. pip install keyring ­to install the package (See
+    https://pip.pypa.io/en/stable/installing/ on how to install python
+    pip if needed).
+1. keyring set RS-Nagios ­\<RS user email\> to set the password.
+    User email should be identical to the email used in Nagios
+    configuration and the password should be set using the same user
+    that run the Nagios server.
+
+Then, you need to update the local parameters, such as hostnames,
+addresses, and object IDs, to the values relevant for your
+RS deployment.
+
+Finally, you need to set the configuration for each node and database
+you would like to monitor. More details below.
+
+The RS Nagios package includes two components:
+
+- The plugin itself ­- with suffix "rlec_nagios_plugin"
+- Configuration files - with suffix "rlec_nagios_conf"
+
+Below is the list of files included in these packages and instructions
+regarding what updates need to be made to these flies.
+
+Note : The instructions below assume you are running on Ubuntu, have a
+clean Nagios installation, and the base Nagios directory is
+"/usr/local/nagios/"
+
+### Step 1
+
+Copy the folder named "libexec" from the plugin folder and its contents
+to "/usr/local/nagios/"
+
+These files included in it are:
+
+- check_rlec_alert
+- check_rlec_node
+- check_rlec_bdb
+- email_stub
+- rlecdigest.py
+
+Note : The check_rlec_alert, check_rlec_node, check_rlec_bdb files
+are the actual plugin implementation. You can run each of them with a
+"­h" switch in order to retrieve their documentation and their expected
+parameters.
+
+### Step 2
+
+Add the following lines to your "nagios.cfg":
+
+- cfg_dir=/usr/local/nagios/etc/rlec_obj
+- cfg_dir=/usr/local/nagios/etc/rlec_local
+- resource_file=/usr/local/nagios/etc/rlec_resource.cfg
+
+### Step 3
+
+Copy the configuration files along with their folders to
+"/usr/local/nagios/etc" and make the required updates, as detailed
+below.
+
+1. Under the "/etc" folder:
+    1. "rlec_resource.cfg " ­ holds global variables definitions for
+        the user and password to use to connect to RS. You should update
+        the variables to the relevant user and password for your
+        deployment.
+    1. "rlec_local " folder
+    1. "rlec_obj" folder
+1. Under the "/rlec_local" folder:
+    1. "cluster.cfg " ­ holds configuration details at the cluster
+        level. If you would like to monitor more than one cluster then
+        you need to duplicate the two existing entries in the file for
+        each cluster.
+        1. The first "define host" section defines a variable for the
+            IP address of the cluster that is used in other
+            configuration files.
+            1. Update the "address" to the Cluster Name (FQDN) as
+                defined in DNS, or the IP address of one of the nodes in
+                the cluster.
+            1. If you are configuring more than one RS then when
+                duplicating this section you should make sure:
+                1. The "name" is unique.
+        1. In the second "define host" section:
+            1. The "host_name " in each entry must be unique.
+            1. The "display_name" in each entry can be updated to a
+                user-friendly name that are shown in Nagios UI.
+    1. "contacts.cfg " ­ holds configuration details who to send emails
+        to. It should be updated to values relevant for your deployment.
+        If this file already exists in your existing Nagios environment
+        then you should update it accordingly.
+    1. "databases.cfg" ­ holds configuration details of the databases
+        to monitor. The "define host" section should be duplicated for
+        every database to monitor.
+        1. "host_name" should be a unique value.
+        1. "display_name " should be updated to a user-friendly name
+            to show in the UI.
+        1. "_RLECID " should be the database's internal ID that can
+            be retrieved from
+            [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) command output.
+    1. "nodes.cfg " ­ holds configuration details of the nodes in the
+        cluster. The "define host" section should be duplicated for
+        every node in the cluster.
+        1. "host_name" should be a unique value.
+        1. "display_name " should be updated to a user-friendly name
+            to show in the UI.
+        1. "address" should be updated to the DNS name mapped to the
+            IP address of the node, or to the IP address itself.
+        1. "_RLECID " should be the node's internal ID that can be
+            retrieved
+            from [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) command output.
+    1. Under the "/rlec_obj" folder:
+        1. "rlec_cmd.cfg" ­ holds configuration details of how to
+            activate the plugin. No need to make any updates to it.
+        1. "rlec_groups.cfg" holds definitions of host groups. No need
+            to make any updates to it.
+        1. "rlec_services.cfg" holds definitions of all alerts that
+            are monitored. No need to make any updates to it.
+        1. "rlec_templates.cfg" holds general RS Nagios definitions.
+            No need to make any updates to it.
+---
+LinkTitle: Datadog with Redis Cloud
+Title: Datadog with Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Datadog to your Redis Cloud cluster using the
+  Redis Datadog Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Datadog to your Redis Cloud cluster using the 
+  Redis Datadog Integration.
+type: integration
+weight: 7
+---
+
+
+[Datadog](https://www.datadoghq.com/) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The Datadog Integration for Redis Cloud uses the Datadog Integration API to connect to Redis metrics exporters. 
+The integration is based on Datadog's 
+[OpenMetrics integration](https://datadoghq.dev/integrations-core/base/openmetrics/) in their core API. This integration 
+enables Redis Cloud users to export metrics directly to Datadog for analysis, and includes Redis-designed 
+dashboards for use in monitoring Redis Cloud clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rc/redis-cloud-datadog.png" alt="screenshot of datadog dashboard">}}
+## Install Redis' Datadog Integration for Redis Cloud
+
+Installing the Datadog integration is a two-step process. Firstly, the installation must be part of your configuration. 
+Select 'Integrations' from the menu in the Datadog portal and then enter 'Redis' in the search bar, then select 
+'Redis Cloud by Redis, Inc.'. Next click 'Install Integration' in the top-right corner of the overview page.
+
+If you have not already created a VPC between the Redis Cloud cluster and the network in which the machine hosting the 
+Datadog agent lives you should do so now. Please visit [VPC Peering](https://redis.io/docs/latest/operate/rc/security/vpc-peering/) 
+and follow the instructions for the cloud platform of your choice.
+
+Returning to the Datadog console, open the 'Configure' tab of the integration and follow the instructions for installing 
+the integration on the local machine. After it has been installed follow the instruction for adding an instance to the 
+conf.yaml in /etc/datadog-agent/conf.d/redis_cloud.d.
+
+After you have edited the conf.yaml file please restart the service and check its status:
+
+```shell
+sudo service datadog-agent restart
+```
+
+followed by:
+
+```shell
+sudo service datadog-agent status
+```
+
+to be certain that the service itself is running and did not encounter any problems. Next, check the output of the 
+service; in the terminal on the Datadog agent host run the following command:
+
+```shell
+tail -f /var/log/datadog/agent.log
+```
+
+It will take several minutes for data to reach Datadog. Finally, check the Datadog console by selecting 
+Infrastructure -> Host Map from the menu and then finding the host that is monitoring the Redis Cloud instance. The host 
+should be present, and in its list of components there should be a section called 'rdsc', which is the namespace used by 
+the Redis Cloud integration, although this can take several minutes to appear. It is also possible to verify the metrics 
+by choosing Metrics -> Explorer from the menu and entering 'rdsc.bdb_up'.
+
+## View metrics
+
+The Redis Cloud Integration for Datadog contains pre-defined dashboards to aid in monitoring your Redis Cloud deployment.
+
+The following dashboards are currently available:
+
+- Overview
+- Database
+- Network
+
+A number of additional dashboards will be included in the next release (v1.1.0).
+
+## Monitor metrics
+
+See [Observability and monitoring guidance]({{< relref "/integrate/prometheus-with-redis-enterprise/observability" >}}) for monitoring details.
+---
+LinkTitle: NRedisStack
+Title: C#/.NET client for Redis
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis and C#/.NET
+group: library
+stack: true
+summary: NRedisStack is a C#/.NET library for Redis.
+title: NRedisStack
+type: integration
+weight: 2
+---
+
+Connect your C#/.NET application to a Redis database using the NRedisStack client library. 
+
+Refer to the complete [C#/.NET guide]({{< relref "/develop/clients/dotnet" >}}) to install, connect, and use NRedisStack.
+---
+LinkTitle: node-redis
+Title: Node.js client for Redis
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis and Node.js
+group: library
+stack: true
+summary: node-redis is a Node.js client library for Redis.
+title: node-redis
+type: integration
+weight: 2
+---
+
+Connect your Node.js application to a Redis database using the node-redis client library. 
+
+Refer to the complete [Node.js guide]({{< relref "/develop/clients/nodejs" >}}) to install, connect, and use node-redis.
+---
+LinkTitle: New Relic with Redis Cloud
+Title: New Relic with Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect New Relic to your Redis Cloud cluster using
+  the Redis New Relic Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect New Relic to your Redis Cloud cluster using
+  the Redis New Relic Integration.
+type: integration
+weight: 7
+---
+
+
+[New Relic](https://newrelic.com/?customer-bypass=true) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The New Relic Integration for Redis Cloud uses Prometheus remote write functionality to connect Prometheus data 
+sources to New Relic. This integration enables Redis Cloud users to export metrics to New Relic for analysis, 
+and includes Redis-designed dashboards for use in monitoring Redis Cloud clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rc/redis-cloud-newrelic.png" >}}
+## Install Redis' New Relic Integration for Redis Cloud
+
+The New Relic Integration for Redis is based on a feature of the Prometheus data source. Prometheus can forward metrics on to 
+another destination using remote writes. This will require a Prometheus installation inside the same datacenter as the 
+Redis Cloud deployment.
+
+If you have not already created a VPC between the Redis Cloud cluster and the network in which the machine hosting 
+Prometheus lives you should do so now. Please visit [VPC Peering](https://redis.io/docs/latest/operate/rc/security/vpc-peering/) 
+and follow the instructions for the cloud platform of your choice.
+
+Finally, the Prometheus installation must be configured to pull metrics from Redis Cloud and write them to New Relic. There 
+are two sections, first the pull from Redis and second the write to New Relic.
+
+Get metrics from Redis Cloud:
+
+```yaml
+  - job_name: "redis-cloud"
+    scrape_interval: 30s
+    scrape_timeout: 30s
+    metrics_path: /
+    scheme: https
+    tls_config:
+      insecure_skip_verify: true
+    static_configs:
+      # The default Redis Cloud Prometheus port is 8070. 
+      # Replace REDIS_CLOUD_HOST with your cluster's hostname.
+      - targets: ["REDIS_CLOUD_HOST:8070"]
+```
+
+Write them to New Relic:
+
+```yaml
+# Remote write configuration for New Relic.
+# - Replace REDIS_CLOUD_SERVICE NAME with any name you'd like to use to refer to this data source.
+# - Replace NEW_RELIC_BEARER_TOKEN with the token you generated on the New Relic Administration -> API Keys page.
+remote_write:
+- url: https://metric-api.newrelic.com/prometheus/v1/write?prometheus_server=REDIS_CLOUD_SERVICE_NAME
+  authorization:
+    credentials: NEW_RELIC_BEARER_TOKEN
+```
+
+## View metrics
+
+The Redis Cloud Integration for New Relic contains pre-defined dashboards to aid in monitoring your Redis Enterprise deployment.
+
+The following dashboards are currently available:
+
+- Cluster: top-level statistics indicating the general health of the cluster
+- Database: performance metrics at the database level
+- Node
+- Shard: low-level details of an individual shard
+- Active-Active: replication and performance for geo-replicated clusters
+- Proxy: network and command information regarding the proxy
+- Proxy Threads: processor usage information regarding the proxy's component threads 
+
+## Monitor metrics
+
+New Relic dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible to 
+filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
+retrieve the relevant data before choosing one of the options in the 'cluster' section.
+
+Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list 
+of database names and ids; use the id value when filtering input to the dashboard. 
+
+
+
+
+---
+Title: Write-behind architecture
+aliases: /integrate/redis-data-integration/write-behind/architecture/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Discover the main components of Write-behind
+group: di
+headerRange: '[2]'
+linkTitle: Architecture
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Write-behind lets you integrate Redis Enterprise (as the source of changes to data) and downstream databases or datastores.
+Write-behind captures any changes to a selected set of key patterns in a Redis keyspace and asynchronously writes them in small batches to the downstream database. This means that your app doesn't need to handle the data remodeling or manage the connection with the downstream database.
+
+Write-behind can normalize a key in Redis to several records in one or more tables at the target.
+To learn more about write-behind declarative jobs and normalization, see the
+[write-behind quick start guide]({{< relref "/integrate/write-behind/quickstart/write-behind-guide" >}}).
+
+## Write-behind topology
+
+Write-behind's CLI and engine are shipped as one product that can run both ingest and write-behind pipelines.
+However, the two different types of pipeline have different topologies.
+
+The Write-behind engine is installed on the Redis database that contains the application data and not on a separate staging Redis database. The Write-behind data streams and its control plane add only a small footprint of a few hundred MB to the Redis database. In the write-behind topology, Write-behind processes data in parallel on each shard and establishes a single connection from each shard to the downstream database.
+
+### Model translation
+
+Write-behind can track changes to the following Redis types:
+
+- [Hash]({{< relref "/develop/data-types/hashes" >}})
+- [JSON]({{< relref "/develop/data-types/json/" >}})
+- [Set]({{< relref "/develop/data-types/sets" >}})
+- [Sorted Set]({{< relref "/develop/data-types/sorted-sets" >}})
+
+Unlike the ingest scenario, write-behind has no default behavior for model translation. You must always
+create a declarative job to specify the mapping between Redis keys and target database records.
+The job configuration has `keys` and `mapping` sections that help make this an easy task.
+
+## Write-behind components
+
+### Write-behind CLI
+
+Write-behind's Python-based CLI is highly intuitive to use and performs validations to help you avoid mistakes.
+The CLI makes it easy to set up Write-behind and manage it over its entire lifecycle.
+
+### Write-behind Engine
+
+Write-behind uses Redis Gears as its runtime environment. The Gears and Write-behind engine logic are installed
+on all source Redis Enterprise database shards, but only primary shards process events and handle the pipeline.
+
+The Write-behind Engine reads Redis change events from Redis Streams (one for each tracked key-pattern),
+processes them, and translates them to SQL or whatever other language the target database uses.
+
+Write-behind writes changes to the target in small batches using transactions. Write-behind guarantees
+*at-least once* delivery. If any network problems, disconnections, or other temporary failures occur,
+Write-behind will keep attempting to write the changes to the target. If a hard reject occurs, Write-behind keeps the reject
+record and the reason in a *dead letter queue (DLQ)*.
+
+### Write-behind configuration
+
+The Write-behind configuration is persisted at the cluster level. The configuration is written by the CLI
+[`deploy`]({{< relref "/integrate/write-behind/reference/cli/redis-di-deploy" >}})
+command, which saves all changes to the configuration file. This mechanism allows for automatic configuration of new shards
+whenever you need them, and it can survive shard and node failure.
+---
+Title: Install RedisGears for Redis Data Integration
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Install and set up RedisGears for a Write-behind deployment
+group: di
+linkTitle: Install RedisGears
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 70
+---
+
+Write-behind requires that [RedisGears](https://redis.com/modules/redis-gears) module with the [Python plugin](https://docs.redis.com/latest/modules/redisgears/python/) is installed on the Redis Enterprise cluster.
+
+The Python plugin can be installed explicitly or alongside with the [JVM plugin](https://docs.redis.com/latest/modules/redisgears/jvm/) if the latter is needed on the cluster for other purposes.
+
+Use the [`redis-di create`]({{< relref "/integrate/write-behind/reference/cli/redis-di-create.md" >}}) command in Write-behind CLI to install RedisGears.
+
+## Download RedisGears
+
+Download RedisGears based on the Linux distribution of where Redis Enterprise is installed.
+
+### Ubuntu 20.04
+
+```bash
+curl -s --tlsv1.3 https://redismodules.s3.amazonaws.com/redisgears/redisgears.Linux-ubuntu20.04-x86_64.{{<param rdi_redis_gears_version>}}-withdeps.zip -o /tmp/redis-gears.zip
+```
+
+### Ubuntu 18.04
+
+```bash
+curl -s --tlsv1.3 https://redismodules.s3.amazonaws.com/redisgears/redisgears.Linux-ubuntu18.04-x86_64.{{<param rdi_redis_gears_version>}}-withdeps.zip -o /tmp/redis-gears.zip
+```
+
+### RHEL8
+
+```bash
+curl -s https://redismodules.s3.amazonaws.com/redisgears/redisgears.Linux-rhel8-x86_64.{{<param rdi_redis_gears_version>}}-withdeps.zip -o /tmp/redis-gears.zip
+```
+
+### RHEL7
+
+```bash
+curl -s https://redismodules.s3.amazonaws.com/redisgears/redisgears.Linux-rhel7-x86_64.{{<param rdi_redis_gears_version>}}-withdeps.zip -o /tmp/redis-gears.zip
+```
+---
+Title: Install Write-behind CLI
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Install Write-behind CLI
+group: di
+linkTitle: Install Write-behind CLI
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+The following installation instructions install the Write-behind CLI on a local workstation.
+
+Write-behind installation is done via the Write-behind CLI. The CLI should have network access to the Redis Enterprise cluster API (port 9443 by default).
+
+### Download Write-behind CLI
+
+#### Ubuntu 20.04
+
+```bash
+wget https://qa-onprem.s3.amazonaws.com/redis-di/{{<param rdi_cli_latest>}}/redis-di-ubuntu20.04-{{<param rdi_cli_latest>}}.tar.gz -O /tmp/redis-di.tar.gz
+```
+
+#### Ubuntu 18.04
+
+```bash
+wget https://qa-onprem.s3.amazonaws.com/redis-di/{{<param rdi_cli_latest>}}/redis-di-ubuntu18.04-{{<param rdi_cli_latest>}}.tar.gz -O /tmp/redis-di.tar.gz
+```
+
+#### RHEL 8
+
+```bash
+wget https://qa-onprem.s3.amazonaws.com/redis-di/{{<param rdi_cli_latest>}}/redis-di-rhel8-{{<param rdi_cli_latest>}}.tar.gz -O /tmp/redis-di.tar.gz
+```
+
+#### RHEL 7
+
+```bash
+wget https://qa-onprem.s3.amazonaws.com/redis-di/{{<param rdi_cli_latest>}}/redis-di-rhel7-{{<param rdi_cli_latest>}}.tar.gz -O /tmp/redis-di.tar.gz
+```
+
+## Install Write-behind CLI
+
+Unpack the downloaded `redis-di.tar.gz` into the `/usr/local/bin/` directory:
+
+```bash
+sudo tar xvf /tmp/redis-di.tar.gz -C /usr/local/bin/
+```
+
+> Note: Non-root users should unpack to a directory with write permission and run `redis-di` directly from it.
+---
+Title: Installation
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to install Write-behind
+group: di
+hideListLinks: false
+linkTitle: Installation
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 8
+---
+
+---
+Title: Monitoring guide
+aliases: /integrate/redis-data-integration/write-behind/monitoring-guide/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Monitor Write-behind engine and data processing jobs
+group: di
+linkTitle: Monitoring
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 70
+---
+
+Write-behind accumulates operating statistics that you can:
+
+- Observe and analyze to discover various types of problems.
+- Use for optimization purposes.
+
+## Console metrics
+
+Write-behind can display its operating metrics in the console using the
+[`redis-di status`]({{< relref "/integrate/write-behind/reference/cli/redis-di-status" >}})
+command. The command provides information about the current Write-behind engine status, target database configuration, and processing statistics broken down by stream. This tool is intended to be used by Operator to get the current snapshot of the system as well as monitoring ongoing data processing (when used in live mode).
+
+## Prometheus integration
+
+Write-behind allows collecting and exporting its metrics to [Prometheus](https://prometheus.io/) and visualizing them in [Grafana](https://grafana.com/). Operator can start the built-in exporter using the
+[`redis-di monitor`]({{< relref "/integrate/write-behind/reference/cli/redis-di-monitor" >}})
+command. The diagram describes this flow and the components involved:
+
+{{< image filename="/images/rdi/monitoring-diagram.png" >}}
+
+> Note: The host names and ports above are examples only and can be changed as needed.
+
+### Test Write-behind metrics exporter
+
+Start the Write-behind metrics exporter using the command below:
+
+```bash
+redis-di monitor
+```
+
+> Note: The default port for the exporter is `9121`. If you need to change it, use the `--exporter-port` option. The default metrics collection interval is 5 seconds. If you need to change it, use the `--collect-interval` option.
+
+Then navigate to `http://localhost:9121/` to see the exported metrics. You should be able to see the following metric:
+
+```
+rdi_engine_state{state="RUNNING",sync_mode="UNKNOWN"} 1.0
+```
+
+> Note: The actual value of the metric above can be 0 if you haven't started Write-behind engine yet (in which case, the `state` label should indicate that as well). You must have the Write-behind database created and configured before observing any metrics. If you are not seeing it or getting an error value instead, this indicates that the Write-behind database is not properly configured.
+
+## Configure Prometheus
+
+Next, configure the Prometheus scraper. Edit the `prometheus.yml` file to add the following scraper config:
+
+```yaml
+scrape_configs:
+  # scrape Write-behind metrics exporter
+  - job_name: rdi-exporter
+    static_configs:
+      - targets: ["redis-exporter:9121"]
+```
+
+> Notes:
+
+- Make sure the `targets` value above points to the host and port you configured to run the Write-behind metrics exporter.
+- The `scrape_interval` setting in Prometheus should be the same or higher than the `collect_interval` setting for the exporter. For example, if the `collect_interval` is set to 5 seconds, the `scrape_interval` should also be set to 5 seconds or more. If the `scrape_interval` is set to less than the `collect_interval`, Prometheus will scrape the exporter before it has a chance to collect and refresh metrics, and you will see duplicated values in Prometheus.
+
+## Test the Prometheus scraper
+
+After the scraper config is added to the Prometheus configuration, you should now be able to navigate to `http://<HOSTNAME>:9090/graph` (replace `<HOSTNAME>` with a valid Prometheus hostname or IP address).
+
+Explore Write-behind metrics using the [expression browser](https://prometheus.io/docs/visualization/browser/).
+
+In the expression box, type in a metric name (for example, `rdi_engine_state`) and select `Enter` or the `Execute` button to see the following result:
+
+```
+rdi_engine_state{instance="redis-exporter:9121", job="rdi-exporter", status="RUNNING", sync_mode="UNKNOWN"} 1
+```
+
+> Note: You may see more than just one Write-behind metric if Write-behind engine has already processed some data. If you do not see any metrics, check your scraper job configuration in Prometheus.
+
+## Use Grafana to analyze metrics
+
+Optionally, you may deploy the sample Grafana dashboard to monitor the status of Write-behind engine and its individual jobs. Follow these steps to import the dashboard:
+
+1. Download the **dashboard file** to your local machine.
+
+1. Log into Grafana and navigate to the list of dashboards, then choose **New > Import**:
+
+{{< image filename="/images/rdi/monitoring-grafana-new-dash.png" >}}
+
+1. On the next screen, select **Upload JSON file** and upload the file you downloaded in step 1. Make sure you select the data source that is connected to the Write-behind metrics exporter:
+
+{{< image filename="/images/rdi/monitoring-grafana-dash-configure.png" >}}
+
+1. Select **Import** and make sure you choose the jobs to monitor from the drop-down list (this will be empty if you don't have any jobs running yet):
+
+{{< image filename="/images/rdi/monitoring-grafana-dash-running.png" >}}
+
+## Write-behind metrics
+
+This list shows exported Write-behind metrics along with their descriptions:
+
+| Metric Name                 | Labels                                                                                                     | Values               | Description                                                                                                                                                                                                        |
+| --------------------------- | ---------------------------------------------------------------------------------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| rdi_engine_state            | {status=RUNNING \| STOPPED, sync_mode=SNAPSHOT \| STREAMING \| UNKNOWN}                                    | 0, 1                 | Status of Write-behind engine. 0 - Write-behind engine is stopped, 1 - Write-behind engine is running. Sync mode label indicates the last reported ingest synchronization mode.                                                               |
+| rdi_incoming_entries        | {data_source=`<stream name>`, operation=pending \| inserted \| updated \| deleted \| filtered \| rejected} | `<count of records>` | Counters, indicating the number of operations performed for each stream.                                                                                                                                           |
+| rdi_stream_event_latency_ms | {data_source=`<stream name>`}                                                                              | 0 - &infin;          | Latency calculated for each stream. Indicates the time in milliseconds the first available record has spent in the stream waiting to be processed by Write-behind engine. If no records pending it will always return zero. |
+---
+Title: Quickstart
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Get started creating a write-behind pipeline
+draft: null
+group: di
+hidden: false
+linkTitle: Quickstart
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 5
+---
+
+This guide takes you through the creation of a write-behind pipeline.
+
+
+## Concepts
+
+**Write-behind** is a processing pipeline used to synchronize data in a Redis database with a downstream data store.
+You can think about it as a pipeline that starts with change data capture (CDC) events for a Redis database and then filters, transforms, and maps the data to the target data store data structures.
+
+The **target** data store to which the write-behind pipeline connects and writes data.
+
+The write-behind pipeline is composed of one or more **jobs**. Each job is responsible for capturing change for one key pattern in Redis and mapping it to one or more tables in the downstream data store. Each job is defined in a YAML file.
+
+{{< image filename="/images/rdi/redis-di-write-behind.png" >}}
+
+## Supported data stores
+
+Write-behind currently supports these target data stores:
+
+| Data Store |
+| ---------- |
+| Cassandra  |
+| MariaDB    |
+| MySQL      |
+| Oracle     |
+| PostgreSQL |
+| Redis Enterprise     |
+| SQL Server |
+
+## Prerequisites
+
+The only prerequisite for running Write-behind is [Redis Gears Python](https://redis.com/modules/redis-gears/) >= 1.2.6 installed on the Redis Enterprise Cluster and enabled for the database you want to mirror to the downstream data store.
+For more information, see
+[RedisGears installation]({{< relref "/integrate/write-behind/installation/install-redis-gears" >}}).
+
+## Preparing the write-behind pipeline
+
+- Install [Write-behind CLI]({{< relref "/integrate/write-behind/installation/install-rdi-cli" >}}) on a Linux host that has connectivity to your Redis Enterprise Cluster.
+- Run the [`configure`]({{< relref "/integrate/write-behind/reference/cli/redis-di-configure" >}}) command to install the Write-behind Engine on your Redis database, if you have not used this Redis database with Write-behind before.
+- Run the [`scaffold`]({{< relref "/integrate/write-behind/reference/cli/redis-di-scaffold" >}}) command with the type of data store you want to use, for example:
+
+  ```bash
+  redis-di scaffold --strategy write_behind --dir . --db-type mysql
+  ```
+
+  This creates a template `config.yaml` file and a folder named `jobs` under the current directory.
+  You can specify any folder name with `--dir` or use the `--preview config.yaml` option, if your Write-behind CLI is deployed inside a Kubernetes (K8s) pod, to get the `config.yaml` template to the terminal.
+
+- Add the connections required for downstream targets in the `connections` section of `config.yaml`, for example:
+
+  ```yaml
+  connections:
+    my-postgres:
+      type: postgresql
+      host: 172.17.0.3
+      port: 5432
+      database: postgres
+      user: postgres
+      password: postgres
+      #query_args:
+      # sslmode: verify-ca
+      # sslrootcert: /opt/work/ssl/ca.crt
+      # sslkey: /opt/work/ssl/client.key
+      # sslcert: /opt/work/ssl/client.crt
+    my-mysql:
+      type: mysql
+      host: 172.17.0.4
+      port: 3306
+      database: test
+      user: test
+      password: test
+      #connect_args:
+      # ssl_ca: /opt/ssl/ca.crt
+      # ssl_cert: /opt/ssl/client.crt
+      # ssl_key: /opt/ssl/client.key
+  ```
+
+  This is the first section of the `config.yaml` file and typically the only one you'll need to edit. The `connections` section is designed to have many target connections. In the previous example, there are two downstream connections named `my-postgres` and `my-mysql`.
+
+  To obtain a secured connection using TLS, you can add more `connect_args` or `query_args`, depending on the specific target database terminology, to the connection definition.
+
+  The name can be any arbitrary name as long as it is:
+
+  - Unique for this Write-behind engine
+  - Referenced correctly by the jobs in the respective YAML files
+
+In order to prepare the pipeline, fill in the correct information for the target data store. Secrets can be provided using a reference to a secret ([see below](#how-to-provide-targets-secrets)) or by specifying a path.
+
+The `applier` section has information about the batch size and frequency used to write data to the target.
+
+Some of the `applier` attributes such as `target_data_type`, `wait_enabled`, and `retry_on_replica_failure` are specific for the Write-behind ingest pipeline and can be ignored.
+
+### Write-behind jobs
+
+Write-behind jobs are a mandatory part of the write-behind pipeline configuration.
+Under the `jobs` directory (parallel to `config.yaml`) you should have a job definition in a YAML file for every key pattern you want to write to a downstream database table.
+
+The YAML file can be named using the destination table name or another naming convention, but it has to have a unique name.
+
+Job definition has the following structure:
+
+```yaml
+source:
+  redis:
+    key_pattern: emp:*
+    trigger: write-behind
+    exclude_commands: ["json.del"]
+transform:
+  - uses: rename_field
+    with:
+      from_field: after.country
+      to_field: after.my_country
+output:
+  - uses: relational.write
+    with:
+      connection: my-connection
+      schema: my-schema
+      table: my-table
+      keys:
+        - first_name
+        - last_name
+      mapping:
+        - first_name
+        - last_name
+        - address
+        - gender
+```
+
+### Source section
+
+The `source` section describes the source of data in the pipeline.
+
+The `redis` section is common for every pipeline initiated by an event in Redis, such as applying changes to data. In the case of write-behind, it has the information required to activate a pipeline dealing with changes to data. It includes the following attributes:
+
+- The `key_pattern` attribute specifies the pattern of Redis keys to listen on. The pattern must correspond to keys that are of Hash or JSON type.
+
+- The `exclude_commands` attribute specifies which commands to ignore. For example, if you listen on a key pattern with Hash values, you can exclude the `HDEL` command so no data deletions will propagate to the downstream database. If you don't specify this attribute, Write-behind acts on all relevant commands.
+- The `trigger` attribute is mandatory and must be set to `write-behind`.
+
+- The `row_format` attribute can be used with the value `full` to receive both the `before` and `after` sections of the payload. Note that for write-behind events the `before` value of the key is never provided.
+
+ > Note: Write-behind does not support the [`expired`]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands) event. Therefore, keys that are expired in Redis will not be deleted from the target database automatically.
+> Notes: The `redis` attribute is a breaking change replacing the `keyspace` attribute. The `key_pattern` attribute replaces the `pattern` attribute. The `exclude_commands` attributes replaces the `exclude-commands` attribute. If you upgrade to version 0.105 and beyond, you must edit your existing jobs and redeploy them.
+
+### Output section
+
+The `output` section is critical. It specifies a reference to a connection from the `config.yaml` `connections` section:
+
+- The `uses` attribute specifies the type of **writer** Write-behind will use to prepare and write the data to the target.
+  In this example, it is `relational.write`, a writer that translates the data into a SQL statement with the specific dialect of the downstream relational database.
+  For a full list of supported writers, see
+  [data transformation block types]({{< relref "/integrate/write-behind/reference/data-transformation-block-types" >}}).
+
+- The `schema` attribute specifies the schema/database to use (different database have different names for schema in the object hierarchy).
+
+- The `table` attribute specifies the downstream table to use.
+
+- The `keys` section specifies the field(s) in the table that are the unique constraints in that table.
+
+- The `mapping` section is used to map database columns to Redis fields with different names or to expressions. The mapping can be all Redis data fields or a subset of them.
+
+> Note: The columns used in `keys` will be automatically included, so there's no need to repeat them in the `mapping` section.
+
+### Apply filters and transformations to write-behind
+
+The Write-behind jobs can apply filters and transformations to the data before it is written to the target. Specify the filters and transformations under the `transform` section.
+
+#### Filters
+
+Use filters to skip some of the data and not apply it to target.
+Filters can apply simple or complex expressions that take as arguments the Redis entry key, fields, and even the change op code (create, delete, update, etc.).
+See [Filter]({{< relref "/integrate/write-behind/reference/data-transformation-block-types/filter" >}}) for more information.
+
+#### Transformations
+
+Transformations manipulate the data in one of the following ways:
+
+- Renaming a field
+- Adding a field
+- Removing a field
+- Mapping source fields to use in output
+
+To learn more about transformations, see
+[data transformation pipeline]({{< relref "/integrate/write-behind/data-transformation/data-transformation-pipeline" >}}).
+
+## Provide target's secrets
+
+The target's secrets (such as TLS certificates) can be read from a path on the Redis node's file system. This allows the consumption of secrets injected from secret stores.
+
+## Deploy the write-behind pipeline
+
+To start the pipeline, run the
+[`deploy`]({{< relref "/integrate/write-behind/reference/cli/redis-di-deploy" >}}) command:
+
+```bash
+redis-di deploy
+```
+
+You can check that the pipeline is running, receiving, and writing data using the
+[`status`]({{< relref "/integrate/write-behind/reference/cli/redis-di-status" >}}) command:
+
+```bash
+redis-di status
+```
+
+## Monitor the write-behind pipeline
+
+The Write-behind pipeline collects the following metrics:
+
+| Metric Description                  | Metric in [Prometheus](https://prometheus.io/)                                                      |
+| ----------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Total incoming events by stream     | Calculated as a Prometheus DB query: `sum(pending, rejected, filtered, inserted, updated, deleted)` |
+| Created incoming events by stream   | `rdi_metrics_incoming_entries{data_source:"…",operation="inserted"}`                                |
+| Updated incoming events by stream   | `rdi_metrics_incoming_entries{data_source:"…",operation="updated"}`                                 |
+| Deleted incoming events by stream   | `rdi_metrics_incoming_entries{data_source:"…",operation="deleted"}`                                 |
+| Filtered incoming events by stream  | `rdi_metrics_incoming_entries{data_source:"…",operation="filtered"}`                                |
+| Malformed incoming events by stream | `rdi_metrics_incoming_entries{data_source:"…",operation="rejected"}`                                |
+| Total events per stream (snapshot)  | `rdi_metrics_stream_size{data_source:""}`                                                           |
+| Time in stream (snapshot)           | `rdi_metrics_stream_last_latency_ms{data_source:"…"}`                                               |
+
+To use the metrics you can either:
+
+- Run the [`status`]({{< relref "/integrate/write-behind/reference/cli/redis-di-status" >}}) command:
+
+  ```bash
+  redis-di status
+  ```
+
+- Scrape the metrics using Write-behind's Prometheus exporter
+
+## Upgrading
+
+If you need to upgrade Write-behind, you should use the
+[`upgrade`]({{< relref "/integrate/write-behind/reference/cli/redis-di-upgrade" >}}) command that provides for a zero downtime upgrade:
+
+```bash
+redis-di upgrade ...
+```
+---
+Title: Write-behind configuration guide
+aliases: /integrate/redis-data-integration/write-behind/configuration-guide/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Configure write-behind to your database
+draft: null
+group: di
+hidden: false
+linkTitle: Configuration
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+This guide shows you how to configure write-behind target connections.
+
+## Overview
+Write-behind target connections are the connections established between a Write-behind instance and a target database in a
+[write-behind scenario]({{< relref "/integrate/write-behind/quickstart/write-behind-guide" >}}).
+Write-behind is used to replicate changes captured in a Write-behind-enabled Redis Enterprise database to a target database. 
+The connections must be configured in the `config.yaml` before deploying any jobs and must follow one of the formats shown below. Multiple connections can be specified in the `connections` section.
+
+### For relational datastores
+
+```yaml
+connections:
+    my-sql-datastore:
+        type: <db-type>     # mysql | oracle | postgresql | sqlserver
+        host: <db-host>     # IP address or FQDN of a database host and instance
+        port: <db-port>     # database port
+        database: <db-name> # name of the database
+        user: <db-user>         # database user
+        password: <db-password> # database password
+        # connect_args:     # optional connection parameters passed to the driver - these are driver specific
+        # query_args:       # optional parameters for SQL query execution - typically not required for Write-behind operation
+```
+
+### For non-relational datastores
+
+```yaml
+connections:
+    my-nosql-datastore:
+        type: <db-type>     # cassandra
+        hosts: <db-hosts>   # array of IP addresses or host names of a datastore nodes
+        port: <db-port>     # database port
+        database: <db-name> # name of the database
+        user: <db-user>         # database user
+        password: <db-password> # database password
+```
+
+## Microsoft SQL Server
+
+Microsoft SQL Server supports different authentication mechanisms (SQL Server Authentication and Integrated Windows Authentication) and protocols (NTLM and Kerberos). Write-behind can use all of them. However, systems that use Kerberos may require some additional configuration.
+
+### Account permissions
+
+To enable Write-behind to work with a SQL Server database, check that the account you specify was assigned at least the `db_datawriter` role.
+
+### SQL Server authentication
+
+To use SQL Server authentication mode, create a user with login credentials and then assign the necessary permissions for the target database to that user.
+
+```yaml
+connections:
+    mssql2019-sqlauth:
+        type: sqlserver
+        host: ip-10-0-0-5.internal
+        port: 1433
+        database: rdi_wb_database
+        user: rdi_user
+        password: secret
+```
+
+### Windows authentication
+
+To use Windows authentication mode, you need to create a Windows or Active Directory account that has the necessary permissions to access the target database, and is able to log into SQL Server. The Linux machine hosting Write-behind can be configured to support the NTLM authentication protocol. 
+
+For NTLM:
+
+```yaml
+connections:
+    mssql2019-ntlm:
+        type: sqlserver
+        host: ip-10-0-0-5.internal
+        port: 1433
+        database: rdi_wb_database
+        user: MYDOMAIN\rdi_service_account  # company-domain\service-account
+        password: secret                    # NTLM requires to provide a password
+```
+
+> Note: User must be specified with the domain name for Windows Authentication to work correctly.
+
+After you configure the Write-behind connection and deploy the write-behind job, run the following SQL query to have the operator check if Write-behind is using the expected authentication mechanism and protocol. Note: this operation may require the `sysadmin` role.
+
+```sql
+SELECT session_id, auth_scheme FROM sys.dm_exec_connections;
+```
+
+The results indicate which `auth_scheme` is used by each session and may take values `SQL`, `NTLM`, and `Kerberos`.---
+Title: Data transformation pipeline
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to transform data to Redis types
+group: di
+linkTitle: Data transformation pipeline
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 20
+---
+
+Write-behind's data transformation capabilities allow users to transform their data beyond the default translation of source types to Redis types. The transformation involves no coding. Instead, it is described in a set of human readable YAML files, one per source table.
+
+The ingested format and types are different from one source to another. Currently, the only supported source is [Debezium](https://debezium.io/). The first transformation from Debezium types to native JSON with Redis types is done automatically without any need for user instructions. Then, this JSON is passed on to the user defined transformation pipeline.
+
+Each job describes the transformation logic to perform on data from a single source. The source is typically a database table or collection and is specified as the full name of this table/collection. The job may include filtering logic to skip data that matches a condition. Other logical steps in the job will transform the data into the desired output that will be stored in Redis as hashes or JSON.
+
+{{< image filename="/images/rdi/data-transformation-pipeline.png" >}}
+
+## Default job
+In situations where there is a need to perform a transformation on all ingested records without creating a specific job for specific tables, the default job is used. The transformation associated with this job will be applied to all tables that lack their own explicitly defined jobs. The default job must have a table name of "*", and only one instance of this type of job is permitted.
+
+For example, the default job can streamline tasks such as adding a prefix or postfix to Redis keys, or adding fields to new hashes and JSONs without customizing each source table.
+
+Currently, the default job is supported for ingest pipelines only.
+
+### Example
+This example demonstrates the process of adding an `app_code` field with a value of `foo` using the [add_field]({{<relref "/integrate/write-behind/reference/data-transformation-block-types/add_field">}}) block to all tables that lack explicitly defined jobs. Additionally, it appends an `aws` prefix and a `gcp` postfix to every generated hash key.
+
+default.yaml
+```yaml
+source:
+  table: "*"
+  row_format: full
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: after.app_code
+          expression: "`foo`"
+          language: jmespath
+output:
+  - uses: redis.write
+    with:
+      data_type: hash
+      key:
+        expression: concat(['aws', '#', table, '#', keys(key)[0], '#', values(key)[0], '#gcp'])
+        language: jmespath
+```
+
+## Jobs
+
+Each job is defined in a separate YAML file. All of these files will be uploaded to Write-behind using the `deploy` command.
+For more information, see [deploy configuration](#deploy-configuration)). If you are using the
+[scaffold]({{< relref "/integrate/write-behind/reference/cli/redis-di-scaffold" >}}) command,
+place the job files in the `jobs` folder.
+
+### Job YAML structure
+
+#### Fields
+
+- `source`:
+
+  This section describes the table that the job operates on:
+
+  - `server_name`: logical server name (optional). Corresponds to the `debezium.source.topic.prefix` property specified in Debezium Server's `application.properties` config file
+  - `db`: database name (optional)
+  - `schema`: database schema (optional)
+  - `table`: database table name
+  - `row_format`: format of the data to be transformed: `data_only` (default) - only payload, full - complete change record
+
+> Note: Any reference to the properties `server_name`, `db`, `schema`, and `table` will be treated by default as case insensitive. This can be changed by setting `case_insensitive` to `false`.
+
+> Cassandra only: In Cassandra, a `keyspace` is roughly the equivalent to a `schema` in other databases. Write-behind uses the `schema` property declared in a job file to match the `keyspace` attribute of the incoming change record.
+
+> MongoDB only: In MongoDB, a `replica set` is a cluster of shards with data and can be regarded as roughly equivalent to a `schema` in a relational database. A MongoDB `collection` is similar to a `table` in other databases. Write-behind uses the `schema` and `table` properties declared in a job file to match the `replica set` and `collection` attributes of the incoming change record, respectively.
+
+- `transform`:
+
+  This section includes a series of blocks that define how the data will be transformed.
+  For more information, see
+  [supported blocks]({{< relref "/integrate/write-behind/reference/data-transformation-block-types" >}})
+  and [JMESPath custom functions]({{< relref "/integrate/write-behind/reference/jmespath-custom-functions.md" >}}).
+
+- `output`:
+
+  This section defines the output targets for processed data:
+
+  - Cassandra:
+    - `uses`: `cassandra.write`: write into a Cassandra data store
+    - `with`:
+      - `connection`: connection name
+      - `keyspace`: keyspace
+      - `table`: target table
+      - `keys`: array of key columns
+      - `mapping`: array of mapping columns
+      - `opcode_field`: the name of the field in the payload that holds the operation (c - create, d - delete, u - update) for this record in the database
+  - Redis:
+    - `uses`: `redis.write`: write to a Redis data structure. Multiple blocks of this type are allowed in the same job
+    - `with`:
+      - `connection`: connection name as defined in `config.yaml` (by default, the connection named 'target' is used)
+      - `data_type`: target data structure when writing data to Redis (hash, json, set and stream are supported values)
+      - `key`: this allows you to override the key of the record by applying custom logic:
+        - `expression`: expression to execute
+        - `language`: expression language, JMESPath or SQL
+      - `expire`: positive integer value indicating a number of seconds for the key to expire. If not set, the key will never expire
+  - SQL:
+    - `uses`: `relational.write`: write into a SQL-compatible data store
+    - `with`:
+      - `connection`: connection name
+      - `schema`: schema
+      - `table`: target table name
+      - `keys`: array of key columns
+      - `mapping`: array of mapping columns
+      - `opcode_field`: the name of the field in the payload that holds the operation (c - create, d - delete, u - update) for this record in the database
+
+#### Notes
+
+- `source` is required.
+- Either `transform`, `key`, or both should be specified.
+
+#### Using key in transformations
+
+To access the Redis key (for example in a write-behind job) you will need to take the following steps:
+
+- Set `row_format: full` to allow access to the key that is part of the full data entry.
+- Use the expression `key.key` to get the Redis key as a string.
+
+#### Before and after values
+
+Update events typically report `before` and `after` sections, providing access to the data state before and after the update. 
+To access the "before" values explicitly, you will need to:
+
+- Set `row_format: full` to allow access to the key that is part of the full data entry.
+- Use the `before.<FIELD_NAME>` pattern.
+
+### Example
+
+This example shows how to rename the `fname` field to `first_name` in the table `emp` using the `rename_field` block. It also demonstrates how to set the key of this record instead of relying on the default logic.
+
+redislabs.dbo.emp.yaml
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      from_field: fname
+      to_field: first_name
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      key:
+        expression: concat(['emp:fname:',fname,':lname:',lname])
+        language: jmespath
+```
+
+### Deploy configuration
+
+In order to deploy your jobs to the remote Write-behind database, run:
+
+```bash
+redis-di deploy
+```
+
+### Deploy configuration on Kubernetes
+
+If the Write-behind CLI is deployed as a pod in a Kubernetes cluster, perform these steps to deploy your jobs:
+
+- Create a ConfigMap from the YAML files in your `jobs` folder:
+
+  ```bash
+  kubectl create configmap redis-di-jobs --from-file=jobs/
+  ```
+
+- Deploy your jobs:
+
+  ```bash
+  kubectl exec -it pod/redis-di-cli -- redis-di deploy
+  ```
+
+> Note: A delay occurs between creating/modifying the ConfigMap and its availability in the `redis-di-cli` pod. Wait around 30 seconds before running the `redis-di deploy` command.
+
+You have two options to update the ConfigMap:
+
+- For smaller changes, you can edit the ConfigMap directly with this command:
+
+  ```bash
+  kubectl edit configmap redis-di-jobs
+  ```
+
+- For bigger changes such as adding another job file, edit the files in your local `jobs` folder and then run this command:
+
+  ```bash
+  kubectl create configmap redis-di-jobs --from-file=jobs/ --dry-run=client -o yaml | kubectl apply -f -
+  ```
+
+> Note: You need to run `kubectl exec -it pod/redis-di-cli -- redis-di deploy` after updating the ConfigMap with either option.
+---
+Title: Write-behind to Redis Enterprise target example
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write-behind to Redis Enterprise target
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+The `redis.write` block can be used in the `output` section of the write-behind job in order to enable writing data to the Redis Enterprise target database. Multiple blocks can be used at the same time to write data to different data types. The following example captures data modified in the `address:*` keyspace, then creates a new JSON-like string field named `json_addr`,  and, finally, writes the results to multiple keys in target Redis Enteprise database:
+
+```yaml
+source:
+  redis:
+    trigger: write-behind
+    key_pattern: address:*
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: "json_addr"
+          expression: concat(['{"city":', city, ', "zip":', zip, '}'])
+          language: jmespath
+output:
+  - uses: redis.write
+    with:
+      data_type: hash
+      connection: target
+      key:
+        expression: concat(['addr:org_id:', org_id, ':hash'])
+        language: jmespath
+  - uses: redis.write
+    with:
+      data_type: json
+      key:
+        expression: concat(['addr:org_id:', org_id, ':json'])
+        language: jmespath
+      on_update: merge
+  - uses: redis.write
+    with:
+      data_type: set
+      key:
+        expression: concat(['addresses:', country])
+        language: jmespath
+      args:
+        member: json_addr
+  - uses: redis.write
+    with:
+      data_type: sorted_set
+      key:
+        expression: concat(['addrs_withscores:', country])
+        language: jmespath
+      args:
+        score: zip
+        member: json_addr
+  - uses: redis.write
+    with:
+      data_type: stream
+      key:
+        expression: "`addresses:events`"
+        language: jmespath
+      mapping:
+        - org_id: message_id
+        - zip: zip_code
+        - country
+```
+
+Run the following command in the source Redis Enterprise database to test the job:
+
+```shell
+127.0.0.1:12005> hset address:1 city Austin zip 78901 org_id 1 country USA
+```
+
+The result is five keys will be created in the target Redis Enterprise database (hash, JSON, set, sorted set, and stream):
+
+```shell
+127.0.0.1:12000> keys *
+1) "addr:org_id:1:hash"
+2) "addr:org_id:1:json"
+3) "addresses:USA"
+4) "addrs_withscores:USA"
+5) "addresses:events"
+```
+---
+Title: Write-behind foreach example
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write-behind foreach
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+
+The `foreach` section is used to explode a list of objects or arrays to rows in a selected target.
+The `foreach` expression is structured as `<field_name>:<JMESPath expression>`.
+The following example uses the `add_field` transformation to prepare the input JSON to the desired structure. Then, it applies `foreach` to write each `order` object as a relational database record using `keys` and `mapping`.
+In this example, the `JMESPath` function `to_string` is used to flatten an array of objects, `specs`, to a string.
+
+```yaml
+source:
+  redis:
+    key_pattern: orderdetail:*
+    trigger: write-behind
+    exclude_commands: ["json.del"]
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: my_orders
+          language: jmespath
+          expression: |
+            orders[*].{
+              code: code
+              periodStartTime: periodStartTime
+              periodEndTime: periodEndTime
+              specs: to_string(specs)
+            }
+output:
+  - uses: relational.write
+    with:
+      connection: mssql
+      schema: dbo
+      table: OrderMaster
+      keys:
+        - Code: orderDetail.code
+      mapping:
+        - DeliveryDate: orderDetail.deliveryDate
+        - ProductCode: orderDetail.productCode
+        - CountryCode: orderDetail.countryCode
+  - uses: relational.write
+    with:
+      connection: mssql
+      schema: dbo
+      table: Order
+      foreach: "order: my_orders[]"
+      keys:
+        - Code: order.code
+      mapping:
+        - OrderDetailCode: orderDetail.code
+        - PeriodStartTime: order.periodStartTime
+        - PeriodEndTime: order.periodEndTime
+        - Specs: order.specs
+
+```---
+Title: Write-behind transformation examples
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: See examples of write-behind transform job configurations
+group: di
+linkTitle: Transformation examples
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+---
+Title: Data transformation
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+hideListLinks: false
+linkTitle: Data transformation
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+The key functionality that Write-behind performs is mapping the data coming from [Debezium Server](https://debezium.io/documentation/reference/stable/operations/debezium-server.html) (representing a Source Database row data or row state change) into a Redis key with a value of [Hash]({{< relref "/develop/data-types/hashes" >}}) or [JSON]({{< relref "/develop/data-types/json/" >}}).
+There are two types of data transformations in Write-behind:
+
+1. By default, each source row is converted into one hash or one JSON key in Redis.
+  This conversion uses the Debezium schema-based conversion. The incoming data includes the schema and Write-behind uses a set of handlers to automatically convert each source column to a Redis Hash field or JSON type based on the Debezium type in the schema. See
+  [data type conversion]({{< relref "/integrate/write-behind/reference/data-types-conversion" >}})
+  for a full reference on these conversions.
+
+1. If the user wants to add or modify this default mapping, Write-behind provides declarative data transformations. These transformations are represented in YAML files. Each file contains a job, which is a set of transformations per source table. See
+[declarative transformations]({{< relref "/integrate/write-behind/data-transformation/data-transformation-pipeline" >}}) for more information.
+
+{{< image filename="/images/rdi/data-transformation-flow.png" >}}
+
+## More info
+
+---
+Title: Data type conversion
+aliases: /integrate/redis-data-integration/write-behind/reference/data-types-conversion/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Data type conversion reference
+group: di
+linkTitle: Data type conversion
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+This document describes default conversions of data types of supported databases into target redis data types.
+
+## General ANSI SQL data types
+
+| Source data type                                                                          | Target data type for HASH                                                                                                                                                                                                                                                                                           | Example for HASH                                                                                                                                                                                                                                                             |
+| :---------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| array                                                                                     | not supported                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                              |
+| bigint                                                                                    | string                                                                                                                                                                                                                                                                                                              | 2147483648 will be saved as '2147483648'                                                                                                                                                                                                                                     |
+| binary                                                                                    | bytes string <br />bytes or base64-encoded String, or a hex-encoded String, based on the connector configuration property setting `binary.handling.mode`                                                                                                                                                            | When `binary.handling.mode = bytes` the string `'hello'` will be added to the table as the binary string `'0x68656C6C6F'`,will be converted by Debezium to `'aGVsbG8AAAAAAAAAAAAAAAAAAAA='` and will be stored in Redis target database as: `'aGVsbG8AAAAAAAAAAAAAAAAAAAA='` |
+| bit string                                                                                | not supported                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                              |
+| blob                                                                                      | bytes string <br />bytes or base64-encoded String, or a hex-encoded String, based on the connector configuration property setting `binary.handling.mode`                                                                                                                                                            | When `binary.handling.mode = bytes` the binary image file ,which was loaded into the table ,will be converted by Debezium to bytes and will be stored in Redis target database as bytes string                                                                               |
+| boolean                                                                                   | string                                                                                                                                                                                                                                                                                                              | The boolean value: false will be converted by the Applier to 0 and will be saved in Redis target database as the string '0'                                                                                                                                                  |
+| char                                                                                      | string                                                                                                                                                                                                                                                                                                              | When PostgreSQL data type is char(14) 'hello world' will be saved as 'hello world &ensp; '                                                                                                                                                                                   |
+| date                                                                                      | string <br />Mapped to ms.microsec since epoch                                                                                                                                                                                                                                                                      | PG field value: `'2021-01-29'` will be converted by Debezium to the int `18656` (number of dates since epoch), which will be converted to number of ms since epoch and will be stored in Redis target database as: `'1611878400000'`                                         |
+| integer                                                                                   | string                                                                                                                                                                                                                                                                                                              | `2147483640` will be saved as `'2147483640'`                                                                                                                                                                                                                                 |
+| interval                                                                                  | not supported                                                                                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                              |
+| null                                                                                      |                                                                                                                                                                                                                                                                                                                     | The field with `null` value will be sent by Debezium as `null` and will not be stored in Redis target database                                                                                                                                                               |
+| numeric                                                                                   | string <br />Debezium configuration parameter `decimal.handling.mode` determines how the connector maps decimal values.When `decimal.handling.mode = 'precision'` the binary string,recieved by Debezium,will be converted to its corresponding numeric value and will be stored in Redis target database as string | PG field value: `4521398.56` will be converted by Debezium to binary string `'GvMbUA=='`, which will be converted to numeric value and will be stored in Redis target database as: `'4521398.56'`                                                                            |
+| smallint                                                                                  | string                                                                                                                                                                                                                                                                                                              | 32767 will be saved as '32767'                                                                                                                                                                                                                                               |
+| text                                                                                      | string                                                                                                                                                                                                                                                                                                              | 'This is a very long text for the PostgreSQL text column'                                                                                                                                                                                                                    |
+| time                                                                                      | string <br />mapped to number of seconds past midnight                                                                                                                                                                                                                                                              | `'14:23:46'` will be converted to `'51826000000'` sec                                                                                                                                                                                                                        |
+| PostgreSQL, Oracle, Cassandra: timestamp <br /> MySQL, SQL Server: datetime               | string <br />mapped to ms.microsec since epoch. <br /> SQL Server datetime format: `YYYY-MM-DD hh:mm:ss[.nnn]`, <br />range: `1753-01-01` through `9999-12-31`                                                                                                                                                      | PG field value: `'2018-06-20 15:13:16.945104'` will be converted by Debezium to `'1529507596945104'`(micro seconds) and will be stored in Redis target database as `'1529507596945.104'`                                                                                     |
+| PosrgreSQL: timestamptz <br />Oracle: timestamp with local timezone<br />MySQL: timestamp | string <br />converted to UTC and stored as number of ms.microsec since epoch                                                                                                                                                                                                                                       |                                                                                                                                                                                                                                                                              |
+| timetz                                                                                    | string <br />converted to UTC and stored as number of seconds past midnight                                                                                                                                                                                                                                         | PG field value: `'14:23:46.12345'` will be converted by Debezium to the string `'12:23:46.12345Z'` and will be stored in Redis target database as: `'44638.345'`                                                                                                             |
+| varbinary                                                                                 | bytes string <br />bytes or base64-encoded String, or a hex-encoded String, based on the connector configuration property setting `binary.handling.mode`                                                                                                                                                            | When `binary.handling.mode = bytes` the string `'hello'` will be added to the table as the binary string `'0x68656C6C6F'`,will be converted by Debezium to `'aGVsbG8='` and will be stored in Redis target database as: `'aGVsbG8='`                                         |
+| varchar                                                                                   | string                                                                                                                                                                                                                                                                                                              | 'hello world' will be saved as 'hello world'                                                                                                                                                                                                                                 |
+| xml                                                                                       | string                                                                                                                                                                                                                                                                                                              |
+
+| Source data type                                                                          | Target data type for JSON                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Example for JSON                                                                                                                                                                                                                                                             |
+| :---------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| array                                                                                     | not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                              |
+| bigint                                                                                    | number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 2147483648 will be saved as 2147483648                                                                                                                                                                                                                                       |
+| binary                                                                                    | bytes string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | When `binary.handling.mode = bytes` the string `'hello'` will be added to the table as the binary string `'0x68656C6C6F'`,will be converted by Debezium to `'aGVsbG8AAAAAAAAAAAAAAAAAAAA='` and will be stored in Redis target database as: `'aGVsbG8AAAAAAAAAAAAAAAAAAAA='` |
+| bit string                                                                                | not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                              |
+| blob                                                                                      | bytes string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | When `binary.handling.mode = bytes` the binary image file ,which was loaded into the table ,will be converted by Debezium to bytes and will be stored in Redis target database as bytes string                                                                               |
+| boolean                                                                                   | boolean                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | The boolean value:true will be saved in Redis target database as boolean data type with value True                                                                                                                                                                           |
+| char                                                                                      | string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | When PostgreSQL data type is char(14) 'hello world' will be saved as 'hello world &ensp; '                                                                                                                                                                                   |
+| date                                                                                      | number <br />Mapped to ms.microsec since epoch                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | PG field value: `2021-01-29` will be converted by Debezium to the int 18656 (number of dates since epoch), which will be converted to number of ms since epoch and will be stored in Redis target database as: `1611878400000`                                               |
+| integer                                                                                   | number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `2147483640` will be saved as `2147483640`                                                                                                                                                                                                                                   |
+| interval                                                                                  | not supported                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                              |
+| null                                                                                      |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | The field with `null` value will be sent by Debezium as `null` and will be stored in Redis target database with the value `null`                                                                                                                                             |
+| numeric                                                                                   | Debezium configuration parameter `decimal.handling.mode` determines how the connector maps decimal values. When `decimal.handling.mode = 'precision'` the binary string received by Debezium will be converted to its corresponding numeric value and will be stored in Redis target database db as number. When `decimal.handling.mode = 'string'` the string ,received by Debezium, will be stored in Redis target database as string. When `decimal.handling.mode = 'double'` the double value received by Debezium will be stored in Redis target database as number. | `decimal.handling.mode = string`: PG field value: `4521398.56` will be recieved by Debezium as the string `'4521398.56'`, and will be stored in Redis target database as the string: '`4521398.56`' .                                                                        |
+| smallint                                                                                  | number                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 32767 will be saved as 32767                                                                                                                                                                                                                                                 |
+| text                                                                                      | string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                              |
+| time                                                                                      | number number<br /> mapped to the number of seconds past midnight                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | `'14:23:46'` will be converted to `51826000000` sec                                                                                                                                                                                                                          |
+| PostgreSQL, Oracle, Cassandra: timestamp <br /> MySQL, SQL Server: datetime               | decimal <br />mapped to ms.microsec since epoch. <br /> SQL Server datetime format: `YYYY-MM-DD hh:mm:ss[.nnn]`, <br />range: `1753-01-01` through `9999-12-31`                                                                                                                                                                                                                                                                                                                                                                                                           | PG field value: `'2018-06-20 15:13:16.945104'` will be converted by Debezium to `'1529507596945104'`(micro seconds) and will be stored in Redis target database as `1529507596945.104                                                                                        |
+| PosrgreSQL: timestamptz <br />Oracle: timestamp with local timezone<br />MySQL: timestamp | number <br />converted to UTC and stored as number of ms.microsec since epoch                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                                                                                                                                                                                                                                                                              |
+| timetz                                                                                    | number <br />converted to UTC and stored as number of ms.microsec since epoch                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | PG field value: `'14:23:46.12345'` will be converted by Debezium to the string `'12:23:46.12345Z'` and will be stored in Redis target database as: `44638.345`                                                                                                               |
+| varbinary                                                                                 | bytes string <br />bytes or base64-encoded String, or a hex-encoded String, based on the connector configuration property setting `binary.handling.mode`                                                                                                                                                                                                                                                                                                                                                                                                                  | When `binary.handling.mode = bytes` the string `'hello'` will be added to the table as the binary string `'0x68656C6C6F'`,will be converted by Debezium to `'aGVsbG8='` and will be stored in Redis target database as: `'aGVsbG8='`                                         |
+| varchar                                                                                   | string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'hello world' will be saved as 'hello world’                                                                                                                                                                                                                                 |
+| xml                                                                                       | string                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |                                                                                                                                                                                                                                                                              |
+
+## Cassandra data types
+
+| Source data type      | Target data type for HASH                    | Example for HASH                                                                                                                                                                                                                                      |
+| :-------------------- | :------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ascii                 | string                                       |                                                                                                                                                                                                                                                       |
+| counter (64-bit long) | string                                       | `2`                                                                                                                                                                                                                                                   |
+| date                  | not supported                                |                                                                                                                                                                                                                                                       |
+| decimal               | not supported                                |                                                                                                                                                                                                                                                       |
+| double                | string                                       | '1.007308023'                                                                                                                                                                                                                                         |
+| duration              | not supported                                |                                                                                                                                                                                                                                                       |
+| float                 | string                                       | The number `-3.4E+38` will be received by debezium as `-3.4E38`, will be converted by the Applier to `-340000000000000000000000000000000000000` and will be saved in Redis target database as `'-340000000000000000000000000000000000000'`            |
+| frozen                | string                                       | `{'10.10.11.1', '10.10.10.1', '10.10.12.1'}` will be saved in Redis target database as a string: `'{'10.10.11.1', '10.10.10.1', '10.10.12.1'}'`                                                                                                       |
+| frozen udt            | string                                       | `{'city': 'City','street': 'Street','streetno': 2,'zipcode': '02-212'}` will be saved in Redis target database as a string: `'{'city': 'City','street': 'Street','streetno': 2,'zipcode': '02-212'}'`                                                 |
+| inet                  | string <br />IPv4 and IPv6 network addresses | The IP address `4.35.221.243` will be converted by debezium to `'/4.35.221.243'` and will be saved in Redis target database as `'/4.35.221.243'`                                                                                                      |
+| list                  | string                                       | The list `['New York', 'Paris','London','New York']` will be sent by debezium as array of strings: `['New York', 'Paris','London','New York']` and will be saved in Redis target database as the string `"['New York', 'Paris','London','New York']"` |
+| map                   | string                                       | `{'fruit' : 'Apple', 'band' : 'Beatles'}` will be saved in Redis target database as a string: `'{'fruit' : 'Apple', 'band' : 'Beatles'}'`                                                                                                             |
+| set                   | string                                       | The set `{'y','n'}` will be saved in Redis target database as the string `'{'y','n'}'                                                                                                                                                                 |
+| tinyint               | string                                       |                                                                                                                                                                                                                                                       |
+| uuid                  | string                                       | b9980b96-a85b-411c-b8e7-4be55c123793                                                                                                                                                                                                                  |
+| tuple                 | string                                       | The tuple `{ "field1": 1, "field2": "testing tuple", "field3": 2 }` will be saved in Redis target database as a string: `' { "field1": 1, "field2": "testing tuple", "field3": 2 }'`                                                                  |
+| varint                | not supported                                |                                                                                                                                                                                                                                                       |
+
+| Source data type      | Target data type for JSON                    | Example for JSON                                                                                                                                                                                                                                      |
+| :-------------------- | :------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ascii                 | string                                       |                                                                                                                                                                                                                                                       |
+| counter (64-bit long) | number                                       | 2                                                                                                                                                                                                                                                     |
+| date                  | not supported                                |                                                                                                                                                                                                                                                       |
+| decimal               | not supported                                |                                                                                                                                                                                                                                                       |
+| double                | number                                       | 1.007308023                                                                                                                                                                                                                                           |
+| duration              | not supported                                |                                                                                                                                                                                                                                                       |
+| float                 | number                                       | The number -3.4E+38 will be received by debezium as `-3.4E38` and will be saved in Redis target database as `-1e+38`                                                                                                                                  |
+| frozen                | array                                        | `{'10.10.11.1', '10.10.10.1', '10.10.12.1'}` will be saved in Redis target database as an array: `{'/10.10.11.1', '/10.10.10.1', '/10.10.12.1'}`                                                                                                      |
+| frozen udt            | object                                       | `{'city': 'City','street': 'Street','streetno': 2,'zipcode': '02-212'}` will be saved in Redis target database as string will be saved in Redis target database as an object: `{'city': 'City','street': 'Street','streetno': 2,'zipcode': '02-212'}` |
+| inet                  | string <br />IPv4 and IPv6 network addresses | The IP address `4.35.221.243` will be converted by debezium to `'/4.35.221.243'` and will be saved in Redis target database as `'/4.35.221.243'`                                                                                                      |
+| list                  | array                                        | The list `['New York', 'Paris','London','New York']` will be sent by debezium as array of strings: `['New York', 'Paris','London','New York']` and will be saved in Redis target database as an array: `['New York', 'Paris','London','New York']`    |
+| map                   | object                                       | `{'fruit' : 'Apple', 'band' : 'Beatles'}` will be saved in Redis target database as an object: `{'fruit' : 'Apple', 'band' : 'Beatles'}`                                                                                                              |
+| set                   | array                                        | The set `{'y','n'}` will be saved in Redis target database as an array: `{'y','n'}`                                                                                                                                                                   |
+| tinyint               |                                              |                                                                                                                                                                                                                                                       |
+| uuid                  | string                                       | b9980b96-a85b-411c-b8e7-4be55c123793                                                                                                                                                                                                                  |
+| tuple                 | object                                       | The tuple `{ "field1": 1, "field2": "testing tuple", "field3": 2 }` will be saved in Redis target database as an object: `{ "field1": 1, "field2": "testing tuple", "field3": 2 }`                                                                    |
+| varint                | not supported                                |                                                                                                                                                                                                                                                       |
+
+## MySQL and MariaDB data types
+
+| Source data type   | Source data type for HASH | Example for Hash                                                                                                                                                                                       |
+| ------------------ | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| enum               | string                    | MySQL enum value `'cat'` will be stored in Redis target database as `'cat'`                                                                                                                            |
+| geometry           | not supported             |                                                                                                                                                                                                        |
+| geometrycollection | not supported             |                                                                                                                                                                                                        |
+| json               | string                    | {"pid": 102, "name": "name2"}                                                                                                                                                                          |
+| linestring         | not supported             |                                                                                                                                                                                                        |
+| multilinestring    | not supported             |                                                                                                                                                                                                        |
+| multipoint         | not supported             |                                                                                                                                                                                                        |
+| multypolygon       | not supported             |                                                                                                                                                                                                        |
+| polygon            | not supported             |                                                                                                                                                                                                        |
+| set                | string                    | `'1,2,3'` will be stored in Redis target database as: `'1,2,3'`                                                                                                                                        |
+| year               | string                    | The value `'55'` will be stored in the database as `2055` and will be sent by Debezium as int32 data type with value `2055`. It will be stored in Redis target database as the string `'2055'` as well |
+
+| Source data type   | Target data type for JSON | Example for JSON                                                                                                                                                                                     |
+| ------------------ | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| enum               | string                    | MySQL enum value `'cat'` will be stored in Redis target database as `'cat'`                                                                                                                          |
+| geometry           | not supported             |                                                                                                                                                                                                      |
+| geometrycollection | not supported             |                                                                                                                                                                                                      |
+| json               | object                    | {"pid": 102, "name": "name2"}                                                                                                                                                                        |
+| linestring         | not supported             |                                                                                                                                                                                                      |
+| multilinestring    | not supported             |                                                                                                                                                                                                      |
+| multipoint         | not supported             |                                                                                                                                                                                                      |
+| multypolygon       | not supported             |                                                                                                                                                                                                      |
+| polygon            | not supported             |                                                                                                                                                                                                      |
+| set                | string                    | `'1,2,3'` will be stored in Redis target database as: `'1,2,3'`                                                                                                                                      |
+| year               | number                    | The value `'55'` will be stored in the database as `2055` and will be sent by Debezium as int32 data type with value `2055`. It will be stored in Redis target database as the number `2055` as well |
+
+## Oracle data types
+
+| Source data type                                                                   | Source data type for HASH                                       | Example for Hash                                                                                                                                                                                                     |
+| ---------------------------------------------------------------------------------- | --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| bfile                                                                              | not supported                                                   |                                                                                                                                                                                                                      |
+| binary_double                                                                      | string                                                          | '1.7E+308'                                                                                                                                                                                                           |
+| binary_float                                                                       | string                                                          | '3.40282E38'                                                                                                                                                                                                         |
+| clob                                                                               | string                                                          | large block of text                                                                                                                                                                                                  |
+| float,real,double precision <br /> real = FLOAT(63),double precision = FLOAT(126). | string                                                          | The value `-3.402E+38` will be saved in Redis target database as the string `'-340200000000000000000000000000000000000'` when Debezium configuration parameter `decimal.handling.mode = 'double'`                    |
+| long raw                                                                           | not supported                                                   |                                                                                                                                                                                                                      |
+| nchar                                                                              | string - is Unicode data type that can store Unicode characters | The string `'testing hebrew שלום'` will be stored in Redis target database as '`testing hebrew \xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d`&ensp; &ensp;&ensp;&ensp;&ensp;&ensp;&ensp;&ensp;'                                   |
+| nclob                                                                              | not supported                                                   |                                                                                                                                                                                                                      |
+| number(p,s)                                                                        | string                                                          | '10385274000.32'                                                                                                                                                                                                     |
+| nvarchar                                                                           | string - is Unicode data type that can store Unicode characters | The string `testing hebrew שלום'` will be stored in Redis target database as '`testing hebrew \xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d`'                                                                                     |
+| raw                                                                                | not supported                                                   |                                                                                                                                                                                                                      |
+| rowid                                                                              | string                                                          | AAAR1QAAOAAAACFAAA                                                                                                                                                                                                   |
+| timestamp with tz                                                                  | string                                                          | `'2021-12-30 14:23:46'` will be converted by Debezium to the string `'2021-12-30T14:23:46+02:00'` and will be stored in Redis target database as the string: `'1611878400000'` which is the number of ms since epoch |
+| urowid                                                                             | not supported                                                   |
+
+| Source data type                                                                   | Target data type for JSON                                       | Example for JSON                                                                                                                                                                                                   |
+| ---------------------------------------------------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| bfile                                                                              | not supported                                                   |                                                                                                                                                                                                                    |
+| binary_double                                                                      | number                                                          | 1.7E+308                                                                                                                                                                                                           |
+| binary_float                                                                       | number                                                          | 3.40282E38                                                                                                                                                                                                         |
+| clob                                                                               | string                                                          | large block of text                                                                                                                                                                                                |
+| float,real,double precision <br /> real = FLOAT(63),double precision = FLOAT(126). | number/string                                                   | the value `-3.402E+38` will be saved in Redis target database as the number `-340200000000000000000000000000000000000` when Debezium configuration parameter `decimal.handling.mode = 'double'`                    |
+| long raw                                                                           | not supported                                                   |                                                                                                                                                                                                                    |
+| nchar                                                                              | string - is Unicode data type that can store Unicode characters | The string `'testing hebrew שלום'` will be stored in Redis target database as '`testing hebrew \xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d`&ensp; &ensp;&ensp;&ensp;&ensp;&ensp;&ensp;&ensp;'                                 |
+| nclob                                                                              | not supported                                                   |                                                                                                                                                                                                                    |
+| number(p,s)                                                                        | number                                                          | 10385274000.32                                                                                                                                                                                                     |
+| nvarchar                                                                           | string - is Unicode data type that can store Unicode characters | The string `testing hebrew שלום'` will be stored in Redis target database as '`testing hebrew \xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d`'                                                                                   |
+| raw                                                                                | not supported                                                   |                                                                                                                                                                                                                    |
+| rowid                                                                              | string                                                          | AAAR1QAAOAAAACFAAA                                                                                                                                                                                                 |
+| timestamp with tz                                                                  | number                                                          | `'2021-12-30 14:23:46'` will be converted by Debezium to the string `'2021-12-30T14:23:46+02:00'` and will be stored in Redis target database as the number: `1611878400000` which is the number of ms since epoch |
+| urowid                                                                             | not supported                                                   |                                                                                                                                                                                                                    |
+
+## PostgreSQL data types
+
+| Source data type | Source data type for HASH                     | Example for Hash                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| box              | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| cidr             | string<br />IPv4 and IPv6 networks addresses. | '4.35.221.243/32'                                                                                                                                                                                                                                                                                                                                        |
+| circle           | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| domain           | string                                        |                                                                                                                                                                                                                                                                                                                                                          |
+| hstore           | string                                        | '{"pages":"368","author":"Katherine Dunn","category":"fiction"}'                                                                                                                                                                                                                                                                                         |
+| inet             | string<br />IPv4 and IPv6 network addresses   | '4.35.221.243'                                                                                                                                                                                                                                                                                                                                           |
+| json             | string                                        | "{"guid":&nbsp; "9c36adc1-7fb5-4d5b-83b4-90356a46061a",<br />"name": "Angela Barton",<br />"is_active": null,<br />"company": "Magnafone"<br />"address": \"178 Howard Place, Gulf, Washington,702",<br />"registered": "2009-11-07T08:53:22 +08:00",<br />"latitude": 19.793713,<br />"longitude": 86.513373,<br />"tags": ["enim","aliquip","qui\" ]}" |
+| line             | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| macaddr          | string<br /> mac addresses                    | '08:00:2b:01:02:03'                                                                                                                                                                                                                                                                                                                                      |
+| money            | string                                        | When `decimal.handling.mode = 'double'` the money value `-8793780.01` will be received by Debezium as `-8793780.01` with double data type, and will be stored in Redis target database as the string'`-8793780.01`'                                                                                                                                      |
+| path             | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| point            | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| polygon          | not supported                                 |                                                                                                                                                                                                                                                                                                                                                          |
+| uuid             | string                                        | 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'                                                                                                                                                                                                                                                                                                                   |
+|                  |                                               |                                                                                                                                                                                                                                                                                                                                                          |
+
+| Source data type | Target data type for JSON                     | Example for JSON                                                                                                                                                                                                                                                                                                                                       |
+| ---------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| box              | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| cidr             | string<br />IPv4 and IPv6 networks addresses. | '4.35.221.243/32'                                                                                                                                                                                                                                                                                                                                      |
+| circle           | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| domain           | string                                        |                                                                                                                                                                                                                                                                                                                                                        |
+| hstore           | string                                        | '{"pages":"368","author":"Katherine Dunn","category":"fiction"}                                                                                                                                                                                                                                                                                        |
+| inet             | string<br />IPv4 and IPv6 network addresses   | '4.35.221.243'                                                                                                                                                                                                                                                                                                                                         |
+| json             | object                                        | {"guid":&nbsp; "9c36adc1-7fb5-4d5b-83b4-90356a46061a",<br />"name": "Angela Barton",<br />"is_active": null,<br />"company": "Magnafone"<br />"address": \"178 Howard Place, Gulf, Washington,702",<br />"registered": "2009-11-07T08:53:22 +08:00",<br />"latitude": 19.793713,<br />"longitude": 86.513373,<br />"tags": ["enim","aliquip","qui\" ]} |
+| line             | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| macaddr          | string <br /> mac addresses                   | '08:00:2b:01:02:03'                                                                                                                                                                                                                                                                                                                                    |
+| money            | string                                        | When `decimal.handling.mode = 'double'` the money value `-8793780.01` will be received by Debezium as `-8793780.01`, with double data type and will be stored in Redis target database as the number `-8793780.01`                                                                                                                                     |
+| path             | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| point            | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| polygon          | not supported                                 |                                                                                                                                                                                                                                                                                                                                                        |
+| uuid             | string                                        | 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'                                                                                                                                                                                                                                                                                                                 |
+|                  |                                               |                                                                                                                                                                                                                                                                                                                                                        |
+
+## SQL server data types
+
+| Source data type        | Source data type for HASH                                                                                                                                                             | Example for Hash                                                                                                                                                                                                                                                                                                          |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| bit                     | string                                                                                                                                                                                | When value `>0` it will be converted by Debezium to true and will be saved in Redis target database as '`1`' while when value `= 0` it will be converted by Debezium to false and will be saved in Redis target database as '`0`'                                                                                         |
+| datetime2               | string <br />Represents the number of milliseconds since the epoch, and does not include timezone information.                                                                        | When Debezium configuration parameter `time.precision.mode='connect'`, the value '`2018-06-20 15:13:16.945104`' will be converted by Debezium to the value '`1529507596945104`' and will be saved in Redis target database database as the string `'1529507596945.104`'                                                   |
+| datetimeoffset          | string                                                                                                                                                                                | When Debezium configuration parameter `decimal.handling.mode = 'precision'`, the datetimeoffset datatype value '`12-10-25 12:32:10 +01:00`' will be converted to the string '`2025-12-10T12:32:10+01:00'` and will be saved in Redis target database as `1765366330000`                                                   |
+| decimal,float,real      | string <br /> range of values: decimal-10^38 +1 to 10^38,float-1.79E+308 to -2.23E-308, 0 and 2.23E-308 to 1.79E+308,real:- 3.40E + 38 to -1.18E - 38, 0 and 1.18E - 38 to 3.40E + 38 | When Debezium configuration parameter `decimal.handling.mode = 'precision'` the value '`-3.402E+38`' will be converted by Debezium to the binary string '`/wAP3QCzc/wpiIGe8AAAAAA=`' and will be saved in Redis target database as the string '`-340200000000000000000000000000000000000`'                                |
+| image                   | string<br /> Variable-length binary data from 0 through 2,147,483,647 bytes.                                                                                                          |                                                                                                                                                                                                                                                                                                                           |
+| money                   | string <br /> range of values: -922,337,203,685,477,5808 to 922,337,203,685,477.5807                                                                                                  | When Debezium configuration parameter `decimal.handling.mode = 'precision'` the value `922337203685477.5807` will be converted by Debezium to the binary '`f/////////8=`' string and will be saved in Redis target database as the string '`922337203685477.5807`'                                                        |
+| nchar                   | string - fixed-size string data , Unicode data type that can store Unicode characters                                                                                                 |                                                                                                                                                                                                                                                                                                                           |
+| nvarchar                | string - variable-size string data, Unicode data type that can store Unicode characters                                                                                               |                                                                                                                                                                                                                                                                                                                           |
+| numeric                 | string <br /> range of values - 10^38 +1 to 10^38                                                                                                                                     | When Debezium configuration parameter `time.precision.mode = 'connect'` and `decimal.handling.mode = 'precision'` , the value `1.00E +33` will be converted by Debezium to the binary string `'SztMqFqGw1MAAAAAAAAAAA=='` and will be saved in Redis target database as the string `'1000000000000000000000000000000000'` |
+| rowversion              | string <br />data type that exposes automatically generated, unique binary numbers within a database. rowversion is generally used as a mechanism for version-stamping table rows.    | 0x00000000000007D0                                                                                                                                                                                                                                                                                                        |
+| smalldatetime           | string <br />represents the number of milliseconds past the epoch, and does not include timezone information.                                                                         | `'2018-06-20 15:13:16`' will be converted by Debezium to `1529507580000` ms past the epoch and will be saved in Write-behind as the string '`1529507580000`'. <br />number of seconds: 16 will be not be included in the convertion and will not be saved in Redis target database                              |
+| smallmoney              | string <br />range of values: - 214,748.3648 to 214,748.3647                                                                                                                          | When Debezium configuration parameter `decimal.handling.mode = 'string'` the value `-214748.3648` will be converted by Debezium to the string `'-214748.3648'` and will be saved in Redis target database as '`-214748.3648`'                                                                                             |
+| Spatial Geometry Types  | not supported                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                           |
+| Spatial Geography Types | not supported                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                           |
+| table                   | not supported                                                                                                                                                                         |                                                                                                                                                                                                                                                                                                                           |
+| text                    | Variable-length Unicode data                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                           |
+| uniqueidentifier        | string                                                                                                                                                                                | 06BEEF00-F859-406B-9A60-0A56AB81A97                                                                                                                                                                                                                                                                                       |
+
+| Source data type        | Target data type for JSON                                                                                                                                                          | Example for JSON                                                                                                                                                                                                                                                                                                       |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| bit                     | boolean                                                                                                                                                                            | When value `>0` it will be converted by Debezium to true and will be saved in Redis target database as `True` while when value `= 0` it will be converted by Debezium to false and will be saved in Redis target database as `False`                                                                                   |
+| datetime2               | number <br /> Represents the number of milliseconds since the epoch, and does not include timezone                                                                                 | When Debezium configuration parameter `time.precision.mode='connect'`, the value '`2018-06-20 15:13:16.945104`' will be converted by Debezium to the value '`1529507596945104`' and will be saved in Redis target database database as the number `1529507596945.104`                                                  |
+| datetimeoffset          | number                                                                                                                                                                             | When Debezium configuration parameter `decimal.handling.mode = 'precision'`, the datetimeoffset datatype value '`12-10-25 12:32:10 +01:00`' will be converted to the string '`2025-12-10T12:32:10+01:00'` and will be saved in Redis target database as the string `1765366330000`                                     |
+| decimal,float,real      | number/string                                                                                                                                                                      | When Debezium configuration parameter `decimal.handling.mode = 'precision'` the value '`-3.402E+38`' will be converted by Debezium to the binary string '`/wAP3QCzc/wpiIGe8AAAAAA=`' and will be saved in Redis target database as the number `-340200000000000000000000000000000000000`                               |
+| image                   | string                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                        |
+| money                   | number/string depending on the value of decimal.handling.mode                                                                                                                      | When Debezium configuration parameter `decimal.handling.mode = 'precision'` the value `922337203685477.5807` will be converted by Debezium to the binary '`f/////////8=`' string and will be saved in Redis target database as the number `922337203685477.5807`                                                       |
+| nchar                   | string                                                                                                                                                                             |                                                                                                                                                                                                                                                                                                                        |
+| nvarchar                | string - variable-size string data, Unicode data type that can store Unicode characters                                                                                            |                                                                                                                                                                                                                                                                                                                        |
+| numeric                 | number                                                                                                                                                                             | When Debezium configuration parameter `time.precision.mode = 'connect'` and `decimal.handling.mode = 'precision'` , the value `1.00E +33` will be converted by Debezium to the binary string `'SztMqFqGw1MAAAAAAAAAAA=='` and will be saved in Redis target database as the number`1000000000000000000000000000000000` |
+| rowversion              | string <br />data type that exposes automatically generated, unique binary numbers within a database. rowversion is generally used as a mechanism for version-stamping table rows. | 0x00000000000007D0                                                                                                                                                                                                                                                                                                     |
+| smalldatetime           | number <br />represents the number of milliseconds past the epoch, and does not include timezone information.                                                                      | `'2018-06-20 15:13:16`' will be converted by Debezium to `1529507580000` ms past the epoch and will be saved in Write-behind as the number `1529507580000`. <br />number of seconds: 16 will be not be included in the convertion and will not be saved in Redis target database                             |
+| smallmoney              | number                                                                                                                                                                             | When Debezium configuration parameter `decimal.handling.mode = 'string'` the value `-214748.3648` will be converted by Debezium to the string `'-214748.3648'` and will be saved in Redis target database as '`-214748.3648`'                                                                                          |
+| Spatial Geometry Types  | not supported                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                        |
+| Spatial Geography Types | not supported                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                        |
+| table                   | not supported                                                                                                                                                                      |                                                                                                                                                                                                                                                                                                                        |
+| text                    |                                                                                                                                                                                    |                                                                                                                                                                                                                                                                                                                        |
+| uniqueidentifier        | string                                                                                                                                                                             | 06BEEF00-F859-406B-9A60-0A56AB81A97                                                                                                                                                                                                                                                                                    |
+
+\* fields with "not supported" data type will not appear in target hash.
+---
+Title: JMESPath custom functions
+aliases: /integrate/redis-data-integration/write-behind/reference/jmespath-custom-functions/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: JMESPath custom function reference
+group: di
+linkTitle: JMESPath custom functions
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+| Function             | Description                                                                                                                         | Example                                                                                                                                                                                                  | Comments                                                                                                                                                         |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `base64_decode`      | Decodes a base64(RFC 4648) encoded string                                                                                           | Input: `{"encoded": "SGVsbG8gV29ybGQh"}` <br /> Expression: `base64_decode(encoded)` <br /> Output: `Hello World!`                                                                                       |                                                                                                                                                                  |
+| `capitalize`         | Capitalizes all the words in the string                                                                                             | Input: `{"name": "john doe"}` <br /> Expression: `capitalize(name)` <br /> Output: `John Doe`                                                                                                            |                                                                                                                                                                  |
+| `concat`             | Concatenates an array of variables or literals                                                                                      | Input: `{"fname": "john", "lname": "doe"}` <br /> Expression: `concat([fname, ' ' ,lname])` <br /> Output: `john doe`                                                                                    | This is equivalent to the more verbose built-in expression: `' '.join([fname,lname])`                                                                            |
+| `filter_entries`     | Filters entries in a dictionary (object) using the given JMESPath predicate                                                         | Input: `{ "name": "John", "age": 30, "country": "US", "score": 15}` <br /> Expression: `` filter_entries(@, `key == 'name' \|\| key == 'age'`)``<br /> Output:`{"name": "John", "age": 30 }`             |                                                                                                                                                                  |
+| `from_entries`       | Converts an array of objects with `key` and `value` properties into a single object                                                 | Input: `[{"key": "name", "value": "John"}, {"key": "age", "value": 30}, {"key": "city", "value": null}]` <br /> Expression: `from_entries(@)` <br /> Output: `{"name": "John", "age": 30, "city": null}` |                                                                                                                                                                  |
+| `hash`               | Calculates a hash using the `hash_name` hash function and returns its hexadecimal representation                                    | Input: `{"some_str": "some_value"}` <br /> Expression: `hash(some_str, &#96;sha1&#96;)` <br /> Output: `8c818171573b03feeae08b0b4ffeb6999e3afc05`                                                        | Supported algorithms: sha1 (default), sha256, md5, sha384, sha3_384, blake2b, sha512, sha3_224, sha224, sha3_256, sha3_512, blake2s                              |
+| `in`                 | Checks if an element matches any value in a list of values                                                                          | Input: `{"el": "b"}` <br /> Expression: `in(el, `["a", "b", "c"]`)` <br /> Output: `True`                                                                                                                |                                                                                                                                                                  |
+| `left`               | Returns a specified number of characters from the start of a given text string                                                      | Input: `{"greeting": "hello world!"}` <br /> Expression: `left(greeting, `5`)` <br /> Output: `hello`                                                                                                    |                                                                                                                                                                  |
+| `lower`              | Converts all uppercase characters in a string into lowercase characters                                                             | Input: `{"fname": "John"}` <br /> Expression: `lower(fname)` <br /> Output: `john`                                                                                                                       |                                                                                                                                                                  |
+| `mid`                | Returns a specified number of characters from the middle of a given text string                                                     | Input: `{"greeting": "hello world!"}` <br /> Expression: `mid(greeting, `4`, `3`)` <br /> Output: `o w`                                                                                                  |                                                                                                                                                                  |
+| `json_parse`         | Returns parsed object from the given json string                                                                                    | Input: `{"data": '{"greeting": "hello world!"}'}` <br /> Expression: `parse_json(data)` <br /> Output: `{"greeting": "hello world!"}`                                                                    |                                                                                                                                                                  |
+| `regex_replace`      | Replaces a string that matches a regular expression                                                                                 | Input: `{"text": "Banana Bannnana"}` <br /> Expression: `regex_replace(text, 'Ban\w+', 'Apple Apple')` <br /> Output: `Apple Apple`                                                                      |                                                                                                                                                                  |
+| `replace`            | Replaces all the occurrences of a substring with a new one                                                                          | Input: `{"sentence": "one four three four!"}` <br /> Expression: `replace(sentence, 'four', 'two')` <br /> Output: `one two three two!`                                                                  |                                                                                                                                                                  |
+| `right`              | Returns a specified number of characters from the end of a given text string                                                        | Input: `{"greeting": "hello world!"}` <br /> Expression: `right(greeting, `6`)` <br /> Output: `world!`                                                                                                  |                                                                                                                                                                  |
+| `split`              | Splits a string into a list of strings after breaking the given string by the specified delimiter (comma by default)                | Input: `{"departments": "finance,hr,r&d"}` <br /> Expression: `split(departments)` <br /> Output: `['finance', 'hr', 'r&d']`                                                                             | Default delimiter is comma - a different delimiter can be passed to the function as the second argument, for example: `split(departments, ';')`                  |
+| `time_delta_days`    | Returns the number of days between a given `dt` and now (positive) or the number of days that have passed from now (negative)       | Input: `{"dt": '2021-10-06T18:56:16.701670+00:00'}` <br /> Expression: `time_delta_days(dt)` <br /> Output: `365`                                                                                        | If `dt` is a string, ISO datetime (2011-11-04T00:05:23+04:00, for example) is assumed. If `dt` is a number, Unix timestamp (1320365123, for example) is assumed. |
+| `time_delta_seconds` | Returns the number of seconds between a given `dt` and now (positive) or the number of seconds that have passed from now (negative) | Input: `{"dt": '2021-10-06T18:56:16.701670+00:00'}` <br /> Expression: `time_delta_days(dt)` <br /> Output: `31557600`                                                                                   | If `dt` is a string, ISO datetime (2011-11-04T00:05:23+04:00, for example) is assumed. If `dt` is a number, Unix timestamp (1320365123, for example) is assumed. |
+| `to_entries`         | Converts a given object into an array of objects with `key` and `value` properties                                                  | Input: `{"name": "John", "age": 30, "city": null}` <br /> Expression: `to_entries(@)` <br /> Output: `[{"key": "name", "value": "John"}, {"key": "age", "value": 30}, {"key": "city", "value": null}]`   |                                                                                                                                                                  |
+| `upper`              | Converts all lowercase characters in a string into uppercase characters                                                             | Input: `{"fname": "john"}` <br /> Expression: `upper(fname)` <br /> Output: `JOHN`                                                                                                                       |                                                                                                                                                                  |
+| `uuid`               | Generates a random UUID4 and returns it as a string in standard format                                                              | Input: None <br /> Expression: `uuid()` <br /> Output: `3264b35c-ff5d-44a8-8bc7-9be409dac2b7`                                                                                                            |                                                                                                                                                                  |
+---
+Title: redis-di delete-all-contexts
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Deletes all contexts
+group: di
+linkTitle: redis-di delete-all-contexts
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di delete-all-contexts [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di delete-all-contexts [OPTIONS]
+
+  Deletes all contexts
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  -f, --force                     Force operation. skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di create
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Creates the Write-behind Database instance
+group: di
+linkTitle: redis-di create
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di create [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `silent`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--silent`
+
+  Silent install. Do not prompt to enter missing parameters
+
+- `no_configure`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--no-configure`
+
+  Do not install Write-behind Engine to the Write-behind Database
+
+- `cluster_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-host`
+
+  Host/IP of Redis Enterprise Cluster (service name in case of k8s)
+
+- `cluster_api_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9443`
+  - Usage: `--cluster-api-port`
+
+  API Port of Redis Enterprise Cluster
+
+- `cluster_user` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-user`
+
+  Redis Enterprise Cluster username with either DB Member, Cluster Member or Cluster Admin roles
+
+- `cluster_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-password`
+
+  Redis Enterprise Cluster Password
+
+- `rdi_port`:
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port for the new Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: ``
+  - Usage: `--rdi-password`
+
+  Password for the new Write-behind Database (alphanumeric characters with zero or more of the following: ! & # $ ^ < > -)
+
+- `rdi_memory`:
+
+  - Type: <IntRange x>=30>
+  - Default: `100`
+  - Usage: `--rdi-memory`
+
+  Memory for Write-behind Database (in MB)
+
+- `rdi_shards`:
+
+  - Type: <IntRange x>=1>
+  - Default: `1`
+  - Usage: `--rdi-shards`
+
+  Number of database server-side shards
+
+- `replication`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--replication`
+
+  In-memory database replication
+
+- `redisgears_module`:
+
+  - Type: STRING
+  - Default: ``
+  - Usage: `--redisgears-module`
+
+  RedisGears module file
+
+- `with_rejson`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--with-rejson`
+
+  Include ReJSON in the Write-behind Database
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di create [OPTIONS]
+
+  Creates the Write-behind Database instance
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --silent                        Silent install. Do not prompt to enter
+                                  missing parameters
+  --no-configure                  Do not install Write-behind Engine to the Write-behind
+                                  Database
+  --cluster-host TEXT             Host/IP of Redis Enterprise Cluster (service
+                                  name in case of k8s)  [required]
+  --cluster-api-port INTEGER RANGE
+                                  API Port of Redis Enterprise Cluster
+                                  [default: 9443; 1000<=x<=65535; required]
+  --cluster-user TEXT             Redis Enterprise Cluster username with
+                                  either DB Member, Cluster Member or Cluster
+                                  Admin roles  [required]
+  --cluster-password TEXT         Redis Enterprise Cluster Password
+  --rdi-port INTEGER RANGE        Port for the new Write-behind Database
+                                  [1000<=x<=65535]
+  --rdi-password TEXT             Password for the new Write-behind Database
+                                  (alphanumeric characters with zero or more
+                                  of the following: ! & # $ ^ < > -)
+  --rdi-memory INTEGER RANGE      Memory for Write-behind Database (in MB)  [x>=30]
+  --rdi-shards INTEGER RANGE      Number of database server-side shards
+                                  [x>=1]
+  --replication                   In-memory database replication
+  --redisgears-module TEXT        RedisGears module file
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di deploy
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Deploys the Write-behind configurations including target
+group: di
+linkTitle: redis-di deploy
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di deploy [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `.`
+  - Usage: `--dir`
+
+  Directory containing Write-behind configuration
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di deploy [OPTIONS]
+
+  Deploys the Write-behind configurations including target
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --dir TEXT                      Directory containing Write-behind configuration
+                                  [default: .]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di list-jobs
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Lists transformation engine's jobs
+group: di
+linkTitle: redis-di list-jobs
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di list-jobs [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di list-jobs [OPTIONS]
+
+  Lists transformation engine's jobs
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di stop
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Stops the pipeline
+group: di
+linkTitle: redis-di stop
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di stop [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di stop [OPTIONS]
+
+  Stops the pipeline
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di get-rejected
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Returns all the stored rejected entries
+group: di
+linkTitle: redis-di get-rejected
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di get-rejected [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `max_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--max-records`
+
+  Maximum rejected records per DLQ
+
+- `oldest`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--oldest
+-o`
+
+  Displays the oldest rejected records. If omitted, most resent records will be retrieved
+
+- `dlq_name`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--dlq-name`
+
+  Only prints the rejected records for the specified DLQ (Dead Letter Queue) name
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di get-rejected [OPTIONS]
+
+  Returns all the stored rejected entries
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --max-records INTEGER RANGE     Maximum rejected records per DLQ  [x>=1]
+  -o, --oldest                    Displays the oldest rejected records. If
+                                  omitted, most resent records will be
+                                  retrieved
+  --dlq-name TEXT                 Only prints the rejected records for the
+                                  specified DLQ (Dead Letter Queue) name
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di delete
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Deletes Write-behind database permanently
+group: di
+linkTitle: redis-di delete
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di delete [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `cluster_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-host`
+
+  Host/IP of Redis Enterprise Cluster (service name in case of k8s)
+
+- `cluster_api_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9443`
+  - Usage: `--cluster-api-port`
+
+  API Port of Redis Enterprise Cluster
+
+- `cluster_user` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-user`
+
+  Redis Enterprise Cluster username with either DB Member, Cluster Member or Cluster Admin roles
+
+- `cluster_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-password`
+
+  Redis Enterprise Cluster Password
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di delete [OPTIONS]
+
+  Deletes Write-behind database permanently
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --cluster-host TEXT             Host/IP of Redis Enterprise Cluster (service
+                                  name in case of k8s)  [required]
+  --cluster-api-port INTEGER RANGE
+                                  API Port of Redis Enterprise Cluster
+                                  [default: 9443; 1000<=x<=65535; required]
+  --cluster-user TEXT             Redis Enterprise Cluster username with
+                                  either DB Member, Cluster Member or Cluster
+                                  Admin roles  [required]
+  --cluster-password TEXT         Redis Enterprise Cluster Password
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -f, --force                     Force operation. skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di configure
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Configures the Write-behind Database so it is ready to process data
+group: di
+linkTitle: redis-di configure
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di configure [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di configure [OPTIONS]
+
+  Configures the Write-behind Database so it is ready to process data
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di dump-support-package
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Dumps Write-behind support package
+group: di
+linkTitle: redis-di dump-support-package
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di dump-support-package [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `.`
+  - Usage: `--dir`
+
+  Directory where the support file should be generated
+
+- `dump_rejected`:
+
+  - Type: INT
+  - Default: `none`
+  - Usage: `--dump-rejected`
+
+  Dumps rejected records
+
+- `trace_timeout`:
+
+  - Type: <IntRange 1<=x<=600>
+  - Default: `none`
+  - Usage: `--trace-timeout`
+
+  Stops the trace after exceeding this timeout (in seconds)
+
+- `max_change_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `10`
+  - Usage: `--max-change-records`
+
+  Maximum traced change records per shard
+
+- `trace_only_rejected`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--trace-only-rejected`
+
+  Trace only rejected change records
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di dump-support-package [OPTIONS]
+
+  Dumps Write-behind support package
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --dir TEXT                      Directory where the support file should be
+                                  generated  [default: .]
+  --dump-rejected INTEGER         Dumps rejected records
+  --trace-timeout INTEGER RANGE   Stops the trace after exceeding this timeout
+                                  (in seconds)  [1<=x<=600]
+  --max-change-records INTEGER RANGE
+                                  Maximum traced change records per shard
+                                  [x>=1]
+  --trace-only-rejected           Trace only rejected change records
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di list-contexts
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Lists all saved contexts
+group: di
+linkTitle: redis-di list-contexts
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di list-contexts [OPTIONS]
+```
+
+## Options
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di list-contexts [OPTIONS]
+
+  Lists all saved contexts
+
+Options:
+  --help  Show this message and exit.
+```
+---
+Title: redis-di set-secret
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Writes a secret to Redis secret store
+group: di
+linkTitle: redis-di set-secret
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di set-secret [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `cluster_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-host`
+
+  Host/IP of Redis Enterprise Cluster (service name in case of k8s)
+
+- `cluster_api_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9443`
+  - Usage: `--cluster-api-port`
+
+  API Port of Redis Enterprise Cluster
+
+- `cluster_user` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-user`
+
+  Redis Enterprise Cluster username with either DB Member, Cluster Member or Cluster Admin roles
+
+- `cluster_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-password`
+
+  Redis Enterprise Cluster Password
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `secret_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--secret-name`
+
+  The name of the secret
+
+- `secret_value` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--secret-value`
+
+  The value of the secret
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di set-secret [OPTIONS]
+
+  Writes a secret to Redis secret store
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --cluster-host TEXT             Host/IP of Redis Enterprise Cluster (service
+                                  name in case of k8s)  [required]
+  --cluster-api-port INTEGER RANGE
+                                  API Port of Redis Enterprise Cluster
+                                  [default: 9443; 1000<=x<=65535; required]
+  --cluster-user TEXT             Redis Enterprise Cluster username with
+                                  either DB Member, Cluster Member or Cluster
+                                  Admin roles  [required]
+  --cluster-password TEXT         Redis Enterprise Cluster Password
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --secret-name TEXT              The name of the secret  [required]
+  --secret-value TEXT             The value of the secret  [required]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di add-context
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Adds a new context
+group: di
+linkTitle: redis-di add-context
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di add-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `cluster_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-host`
+
+  Host/IP of Redis Enterprise Cluster (service name in case of k8s)
+
+- `cluster_api_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9443`
+  - Usage: `--cluster-api-port`
+
+  API Port of Redis Enterprise Cluster
+
+- `cluster_user` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-user`
+
+  Redis Enterprise Cluster username with either DB Member, Cluster Member or Cluster Admin roles
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di add-context [OPTIONS] CONTEXT_NAME
+
+  Adds a new context
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --cluster-host TEXT             Host/IP of Redis Enterprise Cluster (service
+                                  name in case of k8s)  [required]
+  --cluster-api-port INTEGER RANGE
+                                  API Port of Redis Enterprise Cluster
+                                  [default: 9443; 1000<=x<=65535; required]
+  --cluster-user TEXT             Redis Enterprise Cluster username with
+                                  either DB Member, Cluster Member or Cluster
+                                  Admin roles  [required]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di delete-context
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Deletes a context
+group: di
+linkTitle: redis-di delete-context
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di delete-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di delete-context [OPTIONS] CONTEXT_NAME
+
+  Deletes a context
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  -f, --force                     Force operation. skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di set-context
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Sets a context to be the active one
+group: di
+linkTitle: redis-di set-context
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di set-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di set-context [OPTIONS] CONTEXT_NAME
+
+  Sets a context to be the active one
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di start
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Starts the pipeline
+group: di
+linkTitle: redis-di start
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di start [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di start [OPTIONS]
+
+  Starts the pipeline
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di monitor
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Monitors Write-behind by collecting metrics and exporting to Prometheus
+group: di
+linkTitle: redis-di monitor
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di monitor [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `exporter_port`:
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9121`
+  - Usage: `--exporter-port`
+
+  HTTP port to start the exporter on
+
+- `collect_interval`:
+
+  - Type: <IntRange 1<=x<=60>
+  - Default: `5`
+  - Usage: `--collect-interval`
+
+  Metrics collection interval (seconds)
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di monitor [OPTIONS]
+
+  Monitors Write-behind by collecting metrics and exporting to Prometheus
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --exporter-port INTEGER RANGE   HTTP port to start the exporter on
+                                  [1000<=x<=65535]
+  --collect-interval INTEGER RANGE
+                                  Metrics collection interval (seconds)
+                                  [1<=x<=60]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di reset
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Resets the pipeline into initial full sync mode
+group: di
+linkTitle: redis-di reset
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di reset [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di reset [OPTIONS]
+
+  Resets the pipeline into initial full sync mode
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -f, --force                     Force operation. skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di upgrade
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Upgrades Write-behind Engine without losing data or downtime
+group: di
+linkTitle: redis-di upgrade
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di upgrade [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `cluster_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-host`
+
+  Host/IP of Redis Enterprise Cluster (service name in case of k8s)
+
+- `cluster_api_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `9443`
+  - Usage: `--cluster-api-port`
+
+  API Port of Redis Enterprise Cluster
+
+- `cluster_user` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-user`
+
+  Redis Enterprise Cluster username with either DB Member, Cluster Member or Cluster Admin roles
+
+- `cluster_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--cluster-password`
+
+  Redis Enterprise Cluster Password
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force upgrade/downgrade. skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di upgrade [OPTIONS]
+
+  Upgrades Write-behind Engine without losing data or downtime
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --cluster-host TEXT             Host/IP of Redis Enterprise Cluster (service
+                                  name in case of k8s)  [required]
+  --cluster-api-port INTEGER RANGE
+                                  API Port of Redis Enterprise Cluster
+                                  [default: 9443; 1000<=x<=65535; required]
+  --cluster-user TEXT             Redis Enterprise Cluster username with
+                                  either DB Member, Cluster Member or Cluster
+                                  Admin roles  [required]
+  --cluster-password TEXT         Redis Enterprise Cluster Password
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -f, --force                     Force upgrade/downgrade. skips verification
+                                  prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di status
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Displays the status of the pipeline end to end
+group: di
+linkTitle: redis-di status
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di status [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `live`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--live
+-l`
+
+  Live data flow monitoring
+
+- `page_number`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--page-number
+-p`
+
+  Set the page number (live mode only)
+
+- `page_size`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--page-size
+-s`
+
+  Set the page size (live mode only)
+
+- `ingested_only`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--ingested-only
+-i`
+
+  Display ingested data streams (live mode only)
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di status [OPTIONS]
+
+  Displays the status of the pipeline end to end
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -l, --live                      Live data flow monitoring
+  -p, --page-number INTEGER RANGE
+                                  Set the page number (live mode only)  [x>=1]
+  -s, --page-size INTEGER RANGE   Set the page size (live mode only)  [x>=1]
+  -i, --ingested-only             Display ingested data streams (live mode
+                                  only)
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: A command line tool to manage & configure Write-behind
+group: di
+linkTitle: redis-di
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di [OPTIONS] COMMAND [ARGS]...
+```
+
+## Options
+
+- `version`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--version`
+
+  Show the version and exit.
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di [OPTIONS] COMMAND [ARGS]...
+
+  A command line tool to manage & configure Write-behind
+
+Options:
+  --version  Show the version and exit.
+  --help     Show this message and exit.
+
+Commands:
+  add-context           Adds a new context
+  configure             Configures the Write-behind Database so it is ready to...
+  create                Creates the Write-behind Database instance
+  delete                Deletes Write-behind database permanently
+  delete-all-contexts   Deletes all contexts
+  delete-context        Deletes a context
+  deploy                Deploys the Write-behind configurations including target
+  describe-job          Describes a transformation engine's job
+  dump-support-package  Dumps Write-behind support package
+  get-rejected          Returns all the stored rejected entries
+  list-contexts         Lists all saved contexts
+  list-jobs             Lists transformation engine's jobs
+  monitor               Monitors Write-behind by collecting metrics and exporting...
+  reset                 Resets the pipeline into initial full sync mode
+  scaffold              Generates configuration files for Write-behind and...
+  set-context           Sets a context to be the active one
+  set-secret            Writes a secret to Redis secret store
+  start                 Starts the pipeline
+  status                Displays the status of the pipeline end to end
+  stop                  Stops the pipeline
+  trace                 Starts a trace session for troubleshooting data...
+  upgrade               Upgrades Write-behind Engine without losing data or downtime
+```
+---
+Title: redis-di describe-job
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Describes a transformation engine's job
+group: di
+linkTitle: redis-di describe-job
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di describe-job [OPTIONS] JOB_NAME
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `job_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `job-name`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di describe-job [OPTIONS] JOB_NAME
+
+  Describes a transformation engine's job
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di scaffold
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Generates configuration files for Write-behind and Debezium (when ingesting data
+  to Redis)
+group: di
+linkTitle: redis-di scaffold
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di scaffold [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `db_type` (REQUIRED):
+
+  - Type: Choice([<DbType.MYSQL: 'mysql'>, <DbType.ORACLE: 'oracle'>, <DbType.POSTGRESQL: 'postgresql'>, <DbType.REDIS: 'redis'>, <DbType.SQLSERVER: 'sqlserver'>])
+  - Default: `none`
+  - Usage: `--db-type`
+
+  DB type
+
+- `strategy`:
+
+  - Type: Choice([<Strategy.INGEST: 'ingest'>, <Strategy.WRITE_BEHIND: 'write_behind'>])
+  - Default: `ingest`
+  - Usage: `--strategy`
+
+  Strategy
+
+  Output to directory or stdout
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--dir`
+
+  Directory containing Write-behind configuration
+
+- `preview`:
+
+  - Type: Choice(['debezium/application.properties', 'config.yaml'])
+  - Default: `none`
+  - Usage: `--preview`
+
+  Print the content of specified config file to CLI output
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di scaffold [OPTIONS]
+
+  Generates configuration files for Write-behind and Debezium (when ingesting data to
+  Redis)
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --db-type [mysql|oracle|postgresql|redis|sqlserver]
+                                  DB type  [required]
+  --strategy [ingest|write_behind]
+                                  Strategy  [default: ingest]
+  Output formats: [mutually_exclusive, required]
+                                  Output to directory or stdout
+    --dir TEXT                    Directory containing Write-behind configuration
+    --preview [debezium/application.properties|config.yaml]
+                                  Print the content of specified config file
+                                  to CLI output
+  --help                          Show this message and exit.
+```
+---
+Title: CLI
+aliases: /integrate/redis-data-integration/write-behind/reference/cli/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Write-behind CLI reference
+group: di
+hideListLinks: false
+linkTitle: CLI
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+---
+Title: redis-di trace
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Starts a trace session for troubleshooting data transformation
+group: di
+linkTitle: redis-di trace
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Usage
+
+```
+Usage: redis-di trace [OPTIONS]
+```
+
+## Options
+
+- `loglevel`:
+
+  - Type: Choice(['DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--loglevel
+-log-level`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of Write-behind Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1000<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of Write-behind Database
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  Write-behind Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `max_change_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `10`
+  - Usage: `--max-change-records`
+
+  Maximum traced change records per shard
+
+- `timeout` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=600>
+  - Default: `20`
+  - Usage: `--timeout`
+
+  Stops the trace after exceeding this timeout (in seconds)
+
+- `trace_only_rejected`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--trace-only-rejected`
+
+  Trace only rejected change records
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di trace [OPTIONS]
+
+  Starts a trace session for troubleshooting data transformation
+
+Options:
+  -log-level, --loglevel [DEBUG|INFO|WARN|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of Write-behind Database  [required]
+  --rdi-port INTEGER RANGE        Port of Write-behind Database  [1000<=x<=65535;
+                                  required]
+  --rdi-password TEXT             Write-behind Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --max-change-records INTEGER RANGE
+                                  Maximum traced change records per shard
+                                  [x>=1]
+  --timeout INTEGER RANGE         Stops the trace after exceeding this timeout
+                                  (in seconds)  [default: 20; 1<=x<=600;
+                                  required]
+  --trace-only-rejected           Trace only rejected change records
+  --help                          Show this message and exit.
+```
+---
+Title: filter
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Filter records
+group: di
+linkTitle: filter
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Filter records
+
+**Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: filter
+    with:
+      language: sql
+      expression: age>20
+```
+---
+Title: redis.write
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Write to a Redis Enterprise database
+group: di
+linkTitle: redis.write
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Write to a Redis Enterprise database
+
+**Properties**
+
+| Name                    | Type      | Description                                                                                                                                                                    | Required |
+| ----------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
+| **connection**          | `string`  | Name of Redis connection specified in `config.yaml`.<br/>Defaults to connection named `target`.                                                                                | no       |
+| **data_type**<br/>      | `string`  | Type of Redis target data structure.<br/>Enum: `hash`(default), `json`, `set`, `sorted_set`, `stream`, `string`.<br/>Takes precedence over system property `target_data_type`. | no       |
+| [**nest**](#nest)       | `object`  | Nest (embed) object within a different key.<br/>If nesting is specified, the following parameters are ignored: `key`, `args` and `on_update`.                                  | no       |
+| **key**                 | `object`  | Definition of the target Redis key.<br/>                                                                                                                                       | yes      |
+| &#x221F; **expression** | `string`  | Expression used to calculate the target key.                                                                                                                                   | yes      |
+| &#x221F; **language**   | `string`  | Language used to define the expression.<br/>Enum: `jmespath`, `sql`.                                                                                                           | yes      |
+| [**args**](#args)       | `object`  | Arguments for modifying the target key.<br/>Specific to the data type.                                                                                                         | no       |
+| **mapping**             | `array`   | Array of fields (or `field: alias` pairs) to be written to a Redis key.<br/>Supported for hashes, json documents and streams only.                                             | no       |
+| **on_update**           | `string`  | Target key update strategy<br/>Enum: `merge`, `replace` (default).                                                                                                             | no       |
+| **expire**              | `integer` | TTL in seconds for the modified key to expire.<br/>If not specified (or `expire: 0`), the target key will never expire.                                                        | no       |
+
+> Notes:
+
+- Job parameters always override system properties. In particular, `data_type` will override `target_data_type` and `on_update` will override `json_update_strategy` properties respectively.
+- Mapping for **JSON documents** supports nested paths (e.g. `path.to.field`) which results in creating a nested element in Redis key. When a dot is used in a field name, it must be escaped with a backslash (e.g. `path\.to\.field`). Nested paths are not supported for hashes and streams.
+- For **strings** Write-behind will automatically assume `on_update: replace` regardless of what was declared in the job file. Appends and increments are not currently supported.
+- For **streams** Write-behind will ignore `on_update` property since they are append only.
+
+> Notes:
+
+- Job parameters always override system properties. In particular, `data_type` will override `target_data_type` and `on_update` will override `json_update_strategy` properties respectively.
+- Mapping for JSON documents supports nested paths (e.g. `path.to.field`) which results in creating a nested element in Redis key. When a dot is used in a field name, it must be escaped with a backslash (e.g. `path\.to\.field`). Nested paths are not supported for hashes and streams.
+
+**Example**
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  # this block will use the default connection: target - since no explicit connection is specified,
+  # the data will be written in a JSON format as the data_type: json is specified for the block
+  - uses: redis.write
+    with:
+      data_type: json
+      key:
+        expression: concat(['invoice_id:', InvoiceId])
+        language: jmespath
+      mapping: # only the fields listed below will be written to a JSON document
+        - InvoiceId: id # this will create an element with a different name
+        - InvoiceDate: date
+        - BillingAddress: address.primary.street # this will create a nested element in the JSON document
+        - BillingCity: "address.primary.city name" # this will create a nested element with a space in the name
+        - BillingState: address.primary.state
+        - BillingPostalCode: "address.primary.zip\\.code" # this will create a nested element with a dot in the name
+        - Total # this will create an element with the same name as the original field
+      on_update: merge
+  # this block will use the explicitly specified connection: target1 - it must be defined in config.yaml
+  # the data will be written to the corresponding Redis set, based on a value of the key expression
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: set
+      key:
+        expression: concat(['invoices:', BillingCountry])
+        language: jmespath
+      args:
+        member: InvoiceId
+  # this block will use the explicitly specified connection: target1 - it must be defined in config.yaml
+  # the data will be written to the Redis sorted set named invoices:sorted as specified in the key expression
+  - uses: redis.write
+    with:
+      connection: target1
+      data_type: sorted_set
+      key:
+        expression: "`invoices:sorted`"
+        language: jmespath
+      args:
+        score: Total
+        member: InvoiceId
+  # this block will use the specified connection: target2 - this, again, has to be defined in config.yaml
+  # the data will be written to a Redis stream named invoice:events as specified in the key expression
+  - uses: redis.write
+    with:
+      connection: target2
+      data_type: stream
+      key:
+        expression: "`invoice:events`"
+        language: jmespath
+      mapping: # only the fields listed below will be written to a stream message, with two of them renamed as message_id and country
+        - InvoiceId: message_id
+        - BillingCountry: country
+        - Total
+  # this block will use the default connection: target - since no explicit connection is specified,
+  # the data will be written to a Redis string as the data_type: string is specified for the block
+  - uses: redis.write
+    with:
+      data_type: string
+      key:
+        expression: concat(['Invoice:', InvoiceId])
+        language: jmespath
+      args:
+        value: Total # only the Total field will be written to a string
+      expire: 100 # the key will expire in 100 seconds
+```
+
+<a name="args"></a>
+
+## args: object
+
+Arguments for modifying the target key
+
+**Properties**
+
+| Name       | Type     | Description                                                                                    | Required |
+| ---------- | -------- | ---------------------------------------------------------------------------------------------- | -------- |
+| **score**  | `string` | Field name used as a score for sorted sets.<br/>Valid for sorted sets only.                    | yes      |
+| **member** | `string` | Field name used as a member for sets and sorted sets.<br/>Valid for sets and sorted sets only. | yes      |
+| **value**  | `string` | Field name used as a value for strings.<br/>Valid for strings only.                            | yes      |
+
+<a name="nest"></a>
+
+## nest: object
+
+Nest (embed) object within a different key
+
+**Properties**
+
+| Name                     | Type     | Description                                                                                                                                                                                                    | Required |
+| ------------------------ | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| **parent**               | `object` | Parent object definition.                                                                                                                                                                                      | yes      |
+| &#x221F; **server_name** | `string` | Server name.                                                                                                                                                                                                   | no       |
+| &#x221F; **schema**      | `string` | Schema name.                                                                                                                                                                                                   | no       |
+| &#x221F; **table**       | `string` | Parent table.                                                                                                                                                                                                  | yes      |
+| **parent_key**           | `string` | Field name used to identify the parent key (usually FK).                                                                                                                                                       | yes      |
+| **child_key**            | `string` | Optional field name used to identify the parent key value (if different from **parent_key**) in the child record. If not specified, then the field name defined in **parent_key** is used to lookup the value. | no       |
+| **nesting_key**          | `string` | Field name used to create the nesting key (usually PK).                                                                                                                                                        | yes      |
+| **path**                 | `string` | Path, where the nested object should reside in a parent document.<br/>Must start with the root (e.g. `$.<children-elements-here>`)                                                                             | yes      |
+| **structure**            | `string` | Data structure used to represent the object in a parent document (`map` is the only supported value).                                                                                                          | no       |
+
+> Notes:
+
+- When `nest` object is defined, Write-behind will automatically assume `data_type: json` and `on_update: merge` regardless of what was declared in the job file.
+- Nesting job cannot be used together with any of the these properties: `key`, `args`. The key is automatically calculated based on the following template: `<parent_table>:<parent_key>:<parent_key.value | child_key.value>`.
+- When `expire` is specified, it will be applied to the **parent** key. Therefore all nested objects will expire together with the parent key.
+
+**Example**
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: InvoiceLine
+output:
+  - uses: redis.write
+    with:
+      nest:
+        parent:
+          # server_name: chinook
+          # schema: public
+          table: Invoice
+        nesting_key: InvoiceLineId
+        parent_key: InvoiceId
+        # child_key: ParentInvoiceId
+        path: $.InvoiceLineItems
+        # structure: map
+```
+
+> Note: In the example above `child_key` is not needed, because the FK in the child table `InvoiceLine` is defined using the same field name `InvoiceId` as in the parent table `Invoice`. If instead a FK was defined differently (e.g. InvoiceLine.ParentInvoivceId = Invoice.InvoiceId), then `child_key` parameter would be required to describe this relationship in the child job.
+---
+Title: map
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Map a record into a new output based on expressions
+group: di
+linkTitle: map
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Map a record into a new output based on expressions
+
+**Properties**
+
+| Name                          | Type               | Description                                   | Required |
+| ----------------------------- | ------------------ | --------------------------------------------- | -------- |
+| [**expression**](#expression) | `object`, `string` | Expression<br/>                               | yes      |
+| **language**                  | `string`           | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: map
+    with:
+      expression:
+        first_name: first_name
+        last_name: last_name
+        greeting: >-
+          'Hello ' || CASE WHEN gender = 'F' THEN 'Ms.' WHEN gender = 'M' THEN 'Mr.'
+          ELSE 'N/A' END || ' ' || full_name
+        country: country
+        full_name: full_name
+      language: sql
+```
+
+**Example**
+
+```yaml
+source:
+  table: customer
+transform:
+  - uses: map
+    with:
+      expression: |
+        {
+          "CustomerId": customer_id,
+          "FirstName": first_name,
+          "LastName": last_name,
+          "Company": company,
+          "Location":
+          {
+            "Street": address,
+            "City": city,
+            "State": state,
+            "Country": country,
+            "PostalCode": postal_code
+          },
+          "Phone": phone,
+          "Fax": fax,
+          "Email": email
+        }
+      language: jmespath
+```
+
+<a name="expression"></a>
+
+## expression: object
+
+Expression
+
+**No properties.**
+---
+Title: relational.write
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Write into a SQL-compatible data store
+group: di
+linkTitle: relational.write
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Write into a SQL-compatible data store
+
+**Properties**
+
+| Name                                                                                                                                                      | Type     | Description                                                                                                                                                          | Required |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| **connection**<br/>(The connection to use for loading)                                                                                                    | `string` | Logical connection name as defined in the connections.yaml<br/>                                                                                                      | yes      |
+| **schema**<br/>(The table schema of the target table)                                                                                                     | `string` | If left blank, the default schema of this connection will be used as defined in the connections.yaml<br/>                                                            | yes      |
+| **table**<br/>(The target table name)                                                                                                                     | `string` | Target table name<br/>                                                                                                                                               | yes      |
+| [**keys**](#keys)<br/>(Business keys to use in case of \`load_strategy\` is UPSERT or working with \`opcode_field\`)                                      | `array`  |                                                                                                                                                                      | no       |
+| [**mapping**](#mapping)<br/>(Fields to write)                                                                                                             | `array`  |                                                                                                                                                                      | no       |
+| **foreach**<br/>(Split a column into multiple records with a JMESPath expression)                                                                         | `string` | Use a JMESPath expression to split a column into multiple records. The expression should be in the format column: expression.<br/>Pattern: `^(?!:).*:.*(?<!:)$`<br/> | no       |
+| **opcode_field**                                                                                                                                          | `string` | Name of the field in the payload that holds the operation (c - create, d - delete, u - update) for this record in the DB<br/>                                        | no       |
+| **load_strategy**                                                                                                                                         | `string` | type of target<br/>Default: `"APPEND"`<br/>Enum: `"APPEND"`, `"REPLACE"`, `"UPSERT"`, `"TYPE2"`<br/>                                                                 | no       |
+| **active_record_indicator**                                                                                                                               | `string` | Used for `TYPE2` load_strategy. An SQL expression used to identify which rows are active<br/>                                                                        | no       |
+| [**inactive_record_mapping**](#inactive_record_mapping)<br/>(Used for \`TYPE2\` load_strategy\. The columns mapping to use to close out an active record) | `array`  | A list of columns to use. Use any valid SQL expression for the source. If 'target' is omitted, will default to the name of the source column<br/>Default: <br/>      | no       |
+
+**Additional Properties:** not allowed
+
+**No properties.**
+
+**Not [required1]:**
+**No properties.**
+
+**Example**
+
+```yaml
+id: load_snowflake
+type: relational.write
+properties:
+  connection: eu_datalake
+  table: employees
+  schema: dbo
+  load_strategy: APPEND
+```
+
+<a name="keys"></a>
+
+## keys\[\]: Business keys to use in case of \`load_strategy\` is UPSERT or working with \`opcode_field\`
+
+**Items: name of column**
+
+**No properties.**
+
+**Example**
+
+```yaml
+- fname
+- lname: last_name
+```
+
+<a name="mapping"></a>
+
+## mapping\[\]: Fields to write
+
+**Items: name of column**
+
+**No properties.**
+
+**Example**
+
+```yaml
+- fname
+- lname: last_name
+- address
+- gender
+```
+
+<a name="inactive_record_mapping"></a>
+
+## inactive_record_mapping\[\]: Used for \`TYPE2\` load_strategy\. The columns mapping to use to close out an active record
+
+A list of columns to use. Use any valid SQL expression for the source. If 'target' is omitted, will default to the name of the source column
+
+**No properties.**
+
+**Example**
+
+```yaml
+- source: CURRENT_DATE
+  target: deletedAt
+- source: "'Y'"
+  target: is_active
+```
+---
+Title: remove_field
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Remove fields
+group: di
+linkTitle: remove_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Remove fields
+
+**Option 1 (alternative):**
+Remove multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: remove_field
+    with:
+      fields:
+        - field: credit_card
+        - field: name.mname
+```
+
+**Option 2 (alternative):**
+Remove one field
+
+**Properties**
+
+| Name      | Type     | Description | Required |
+| --------- | -------- | ----------- | -------- |
+| **field** | `string` | Field<br/>  | yes      |
+
+**Additional Properties:** not allowed  
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: remove_field
+    with:
+      field: credit_card
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name      | Type     | Description | Required |
+| --------- | -------- | ----------- | -------- |
+| **field** | `string` | Field<br/>  | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: rename_field
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Rename fields. All other fields remain unchanged.
+group: di
+linkTitle: rename_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Rename fields. All other fields remain unchanged.
+
+**Option 1 (alternative):**
+Rename multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed  
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      fields:
+        - from_field: name.lname
+          to_field: name.last_name
+        - from_field: name.fname
+          to_field: name.first_name
+```
+
+**Option 2 (alternative):**
+Rename one field
+
+**Properties**
+
+| Name           | Type     | Description     | Required |
+| -------------- | -------- | --------------- | -------- |
+| **from_field** | `string` | From field<br/> | yes      |
+| **to_field**   | `string` | To field<br/>   | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      from_field: name.lname
+      to_field: name.last_name
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name           | Type     | Description     | Required |
+| -------------- | -------- | --------------- | -------- |
+| **from_field** | `string` | From field<br/> | yes      |
+| **to_field**   | `string` | To field<br/>   | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: cassandra.write
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Write into a Cassandra data store
+group: di
+linkTitle: cassandra.write
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Write into a Cassandra data store
+
+**Properties**
+
+| Name                                                   | Type     | Description                                                                                                                   | Required |
+| ------------------------------------------------------ | -------- | ----------------------------------------------------------------------------------------------------------------------------- | -------- |
+| **connection**<br/>(The connection to use for loading) | `string` | Logical connection name as defined in the connections.yaml<br/>                                                               | yes      |
+| **keyspace**                                           | `string` | Keyspace<br/>                                                                                                                 | yes      |
+| **table**<br/>(The target table name)                  | `string` | Target table name<br/>                                                                                                        | yes      |
+| [**keys**](#keys)<br/>(Business keys)                  | `array`  |                                                                                                                               | yes      |
+| [**mapping**](#mapping)<br/>(Fields to write)          | `array`  |                                                                                                                               | yes      |
+| **opcode_field**                                       | `string` | Name of the field in the payload that holds the operation (c - create, d - delete, u - update) for this record in the DB<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+id: load_snowflake
+type: relational.write
+properties:
+  connection: eu_datalake
+  table: employees
+  schema: dbo
+  load_strategy: APPEND
+```
+
+<a name="keys"></a>
+
+## keys\[\]: Business keys
+
+**Items: name of column**
+
+**No properties.**
+
+**Example**
+
+```yaml
+- fname
+- lname: last_name
+```
+
+<a name="mapping"></a>
+
+## mapping\[\]: Fields to write
+
+**Items: name of column**
+
+**No properties.**
+
+**Example**
+
+```yaml
+- fname
+- lname: last_name
+- address
+- gender
+```
+---
+Title: key
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Set the Redis key for this data entry
+group: di
+linkTitle: key
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Set the Redis key for this data entry
+
+**Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+key:
+  expression: concat([InvoiceId, '.', CustomerId])
+  language: jmespath
+```
+---
+Title: add_field
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Add fields to a record
+group: di
+linkTitle: add_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Add fields to a record
+
+**Option 1 (alternative):**
+Add multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: name.full_name
+          language: jmespath
+          expression: concat([name.fname, ' ', name.lname])
+        - field: name.fname_upper
+          language: jmespath
+          expression: upper(name.fname)
+```
+
+**Option 2 (alternative):**
+Add one field
+
+**Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **field**      | `string` | Field<br/>                                    | yes      |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: add_field
+    with:
+      field: country
+      language: sql
+      expression: country_code || ' - ' || UPPER(country_name)
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **field**      | `string` | Field<br/>                                    | yes      |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: Data transformation block types
+aliases: /integrate/redis-data-integration/write-behind/reference/data-transformation-block-types/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Data transformation block type reference
+group: di
+hideListLinks: false
+linkTitle: Data transformation block types
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+---
+Title: Write-behind configuration file
+aliases: /integrate/redis-data-integration/write-behind/reference/config-yaml-reference/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Write-behind configuration file reference
+group: di
+linkTitle: Write-behind configuration file
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+## Write-behind Configuration File
+
+**Properties**
+
+| Name                                                                                       | Type             | Description | Required |
+| ------------------------------------------------------------------------------------------ | ---------------- | ----------- | -------- |
+| [**applier**](#applier)<br/>(Configuration details of Write-behind Applier Gear) | `object`, `null` |             |          |
+| [**connections**](#connections)                                                            | `object`         |             |          |
+
+<a name="applier"></a>
+
+### applier: Configuration details of Write-behind Applier Gear
+
+**Properties**
+
+| Name                                                                                                                                 | Type                | Description                                                                                                                                                                                                      | Required |
+| ------------------------------------------------------------------------------------------------------------------------------------ | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------ | --- |
+| **on_failed_retry_interval**<br/>(Interval \(in seconds\) on which to perform retry on failure)                                      | `integer`, `string` | Default: `5`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                       |          |
+| **read_batch_size**<br/>(The batch size for reading data from source database)                                                       | `integer`, `string` | Default: `2000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                    |          |
+| **debezium_lob_encoded_placeholder**<br/>(Enable Debezium LOB placeholders)                                                          | `string`            | Default: `"X19kZWJleml1bV91bmF2YWlsYWJsZV92YWx1ZQ=="`<br/>                                                                                                                                                       |          |
+| **dedup**<br/>(Enable deduplication mechanism)                                                                                       | `boolean`           | Default: `false`<br/>                                                                                                                                                                                            |          |
+| **dedup_max_size**<br/>(Max size of the deduplication set)                                                                           | `integer`           | Default: `1024`<br/>Minimum: `1`<br/>                                                                                                                                                                            |          |
+| **duration**<br/>(Time \(in ms\) after which data will be read from stream even if read_batch_size was not reached)                  | `integer`, `string` | Default: `100`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                     |          |
+| **write_batch_size**<br/>(The batch size for writing data to target Redis database\. Should be less or equal to the read_batch_size) | `integer`, `string` | Default: `200`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                     |          |
+| **error_handling**<br/>(Error handling strategy: ignore \- skip, dlq \- store rejected messages in a dead letter queue)              | `string`            | Default: `"dlq"`<br/>Pattern: ``^\${.\*}$                                                                                                                                                                        | ignore   | dlq``<br/>   |     |
+| **dlq_max_messages**<br/>(Dead letter queue max messages per stream)                                                                 | `integer`, `string` | Default: `1000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                    |          |
+| **target_data_type**<br/>(Target data type: hash/json \- RedisJSON module must be in use in the target DB)                           | `string`            | Default: `"hash"`<br/>Pattern: ``^\${.\*}$                                                                                                                                                                       | hash     | json``<br/>  |     |
+| **json_update_strategy**<br/>(Target update strategy: replace/merge \- RedisJSON module must be in use in the target DB)             | `string`            | (DEPRECATED)<br/>Property 'json_update_strategy' will be deprecated in future releases. Use 'on_update' job-level property to define the json update strategy.<br/>Default: `"replace"`<br/>Pattern: ``^\${.\*}$ | replace  | merge``<br/> |     |
+| **initial_sync_processes**<br/>(Number of processes Write-behind Engine creates to process the initial sync with the source)                  | `integer`, `string` | Default: `4`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>Maximum: `32`<br/>                                                                                                                                     |          |
+| **wait_enabled**<br/>(Checks if the data has been written to the replica shard)                                                      | `boolean`           | Default: `false`<br/>                                                                                                                                                                                            |          |
+| **wait_timeout**<br/>(Timeout in milliseconds when checking write to the replica shard)                                              | `integer`, `string` | Default: `1000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                                                                    |          |
+| **retry_on_replica_failure**<br/>(Ensures that the data has been written to the replica shard and keeps retrying if not)             | `boolean`           | Default: `true`<br/>                                                                                                                                                                                             |          |
+
+**Additional Properties:** not allowed  
+<a name="connections"></a>
+
+### connections: Connections
+
+**Properties (Pattern)**
+
+| Name                     | Type | Description | Required |
+| ------------------------ | ---- | ----------- | -------- |
+| **\.\***                 |      |             |          |
+| **additionalProperties** |      |             |          |
+---
+Title: Write-behind reference
+aliases: /integrate/redis-data-integration/write-behind/reference/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Collects reference material for Write-behind
+group: di
+hideListLinks: false
+linkTitle: Reference
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 90
+---
+---
+Title: Write-behind configuration for mysql
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for mysql
+group: di
+linkTitle: mysql
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.mysql.MySqlConnector
+# A numeric ID of this database client, which must be unique across all currently-running database processes in the MySQL cluster.
+debezium.source.database.server.id=1
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+
+debezium.source.database.hostname=<SOURCE_DB_HOST>
+debezium.source.database.port=<SOURCE_DB_PORT>
+debezium.source.database.user=<SOURCE_DB_USER>
+debezium.source.database.password=<SOURCE_DB_PASSWORD>
+debezium.source.include.schema.changes=false
+# Determines whether the connector should omit publishing change events when there are no modifications in the included columns.
+debezium.source.skip.messages.without.change=true
+debezium.source.offset.flush.interval.ms=1000
+debezium.source.tombstones.on.delete=false
+debezium.source.schema.history.internal=io.debezium.storage.redis.history.RedisSchemaHistory
+
+# Important: Do NOT use `include` and `exclude` database lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match database names to be monitored.
+# By default, all databases are monitored.
+#debezium.source.database.include.list=<DB_NAME1>,<DB_NAME2>...
+# An optional, comma-separated list of regular expressions that match database names for which you do not want to capture changes.
+#debezium.source.database.exclude.list=<DB_NAME1>,<DB_NAME2>...
+# Important: Do NOT use `include` and `exclude` table lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers of tables whose changes you want to capture.
+#debezium.source.table.include.list=<DB_NAME.TABLE_NAME1>,<DB_NAME.TABLE_NAME2>...
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers for tables whose changes you do not want to capture.
+#debezium.source.table.exclude.list=<DB_NAME.TABLE_NAME1>,<DB_NAME.TABLE_NAME2>...
+
+# Important: Do NOT use include and exclude column lists at the same time, use either include or exclude.
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to include in change event record values.
+#debezium.source.column.include.list=<DB_NAME.TABLE_NAME.COLUMN_NAME1>,<DB_NAME.TABLE_NAME.COLUMN_NAME2>...
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to exclude from change event record values.
+#debezium.source.column.exclude.list=<DB_NAME.TABLE_NAME.COLUMN_NAME1>,<DB_NAME.TABLE_NAME.COLUMN_NAME2>...
+
+# Records only DDL statements that are relevant to tables whose changes are being captured by Debezium.
+# In case of changing the captured tables, run `redis-di reset`.
+debezium.source.schema.history.internal.store.only.captured.tables.ddl=true
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Write-behind configuration for oracle
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for oracle
+group: di
+linkTitle: oracle
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.oracle.OracleConnector
+debezium.source.log.mining.strategy=online_catalog
+debezium.source.log.mining.transaction.retention.ms=180000
+# This mode creates a JDBC query that filters not only operation types at the database level, but also schema, table, and username include/exclude lists.
+debezium.source.log.mining.query.filter.mode=in
+# The name of the Oracle Pluggable Database that the connector captures changes from.
+# For non-CDB installation, do not specify this property.
+#debezium.source.database.pdb.name=ORCLPDB1
+# Enables capturing and serialization of large object (CLOB, NCLOB, and BLOB) column values in change events.
+#debezium.source.lob.enabled=true
+# Specifies the constant that the connector provides to indicate that the original value is unchanged and not provided by the database.
+#debezium.source.unavailable.value.placeholder=__debezium_unavailable_value
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+debezium.source.database.dbname=<SOURCE_DB_NAME>
+
+debezium.source.database.hostname=<SOURCE_DB_HOST>
+debezium.source.database.port=<SOURCE_DB_PORT>
+debezium.source.database.user=<SOURCE_DB_USER>
+debezium.source.database.password=<SOURCE_DB_PASSWORD>
+debezium.source.include.schema.changes=false
+# Determines whether the connector should omit publishing change events when there are no modifications in the included columns.
+debezium.source.skip.messages.without.change=true
+debezium.source.offset.flush.interval.ms=1000
+debezium.source.tombstones.on.delete=false
+debezium.source.schema.history.internal=io.debezium.storage.redis.history.RedisSchemaHistory
+
+# Important: Do NOT use `include` and `exclude` table lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers of tables whose changes you want to capture.
+#debezium.source.table.include.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers for tables whose changes you do not want to capture.
+#debezium.source.table.exclude.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+
+# Important: Do NOT use include and exclude column lists at the same time, use either include or exclude.
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to include in change event record values.
+#debezium.source.column.include.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to exclude from change event record values.
+#debezium.source.column.exclude.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+
+# Records only DDL statements that are relevant to tables whose changes are being captured by Debezium.
+# In case of changing the captured tables, run `redis-di reset`.
+debezium.source.schema.history.internal.store.only.captured.tables.ddl=true
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Write-behind configuration for sqlserver
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for sqlserver
+group: di
+linkTitle: sqlserver
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.sqlserver.SqlServerConnector
+debezium.source.database.names=<SOURCE_DB_NAME>
+debezium.source.database.encrypt=false
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+
+debezium.source.database.hostname=<SOURCE_DB_HOST>
+debezium.source.database.port=<SOURCE_DB_PORT>
+debezium.source.database.user=<SOURCE_DB_USER>
+debezium.source.database.password=<SOURCE_DB_PASSWORD>
+debezium.source.include.schema.changes=false
+# Determines whether the connector should omit publishing change events when there are no modifications in the included columns.
+debezium.source.skip.messages.without.change=true
+debezium.source.offset.flush.interval.ms=1000
+debezium.source.tombstones.on.delete=false
+debezium.source.schema.history.internal=io.debezium.storage.redis.history.RedisSchemaHistory
+
+# Important: Do NOT use `include` and `exclude` table lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers of tables whose changes you want to capture.
+#debezium.source.table.include.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers for tables whose changes you do not want to capture.
+#debezium.source.table.exclude.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+
+# Important: Do NOT use include and exclude column lists at the same time, use either include or exclude.
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to include in change event record values.
+#debezium.source.column.include.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to exclude from change event record values.
+#debezium.source.column.exclude.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Write-behind configuration for postgresql
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for postgresql
+group: di
+linkTitle: postgresql
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.postgresql.PostgresConnector
+debezium.source.plugin.name=pgoutput
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+debezium.source.database.dbname=<SOURCE_DB_NAME>
+
+debezium.source.database.hostname=<SOURCE_DB_HOST>
+debezium.source.database.port=<SOURCE_DB_PORT>
+debezium.source.database.user=<SOURCE_DB_USER>
+debezium.source.database.password=<SOURCE_DB_PASSWORD>
+debezium.source.include.schema.changes=false
+# Determines whether the connector should omit publishing change events when there are no modifications in the included columns.
+# This property takes effect when the `REPLICA IDENTITY` of the table is set to `FULL`.
+debezium.source.skip.messages.without.change=true
+debezium.source.offset.flush.interval.ms=1000
+debezium.source.tombstones.on.delete=false
+debezium.source.schema.history.internal=io.debezium.storage.redis.history.RedisSchemaHistory
+
+# Important: Do NOT use `include` and `exclude` table lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers of tables whose changes you want to capture.
+#debezium.source.table.include.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+# An optional, comma-separated list of regular expressions that match fully-qualified table identifiers for tables whose changes you do not want to capture.
+#debezium.source.table.exclude.list=<SCHEMA_NAME.TABLE_NAME1>,<SCHEMA_NAME.TABLE_NAME2>...
+
+# Important: Do NOT use include and exclude column lists at the same time, use either include or exclude.
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to include in change event record values.
+#debezium.source.column.include.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+# An optional, comma-separated list of regular expressions that match the fully-qualified names of columns to exclude from change event record values.
+#debezium.source.column.exclude.list=<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME1>,<SCHEMA_NAME.TABLE_NAME.COLUMN_NAME2>...
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Write-behind configuration for cassandra
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for cassandra
+group: di
+linkTitle: cassandra
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.cassandra.Cassandra4Connector
+debezium.source.snapshot.consistency=ONE
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+debezium.source.cassandra.node.id=<NAME_SOURCE_NODE>
+debezium.source.cassandra.hosts=<SOURCE_DB_HOST>
+debezium.source.cassandra.port=<SOURCE_DB_PORT>
+debezium.source.cassandra.config=<ABSOLUTE_PATH_CONFIG_FILE>
+debezium.source.commit.log.relocation.dir=<RELOCATION_DIR>
+debezium.source.commit.log.real.time.processing.enabled=true
+debezium.source.commit.marked.complete.poll.interval.ms=1000
+debezium.source.http.port=8040
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Write-behind configuration for mongodb
+aliases: null
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Describes the `application.properties` settings that configure Debezium
+  Server for mongodb
+group: di
+linkTitle: mongodb
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: null
+---
+
+## application.properties
+
+```properties
+debezium.sink.type=redis
+debezium.sink.redis.message.format=extended
+debezium.sink.redis.address=<RDI_HOST>:<RDI_PORT>
+# Comment the following line if not using a password for Write-behind.
+debezium.sink.redis.password=<RDI_PASSWORD>
+debezium.sink.redis.memory.limit.mb=80
+# Redis SSL/TLS
+#debezium.sink.redis.ssl.enabled=true
+# When Redis is configured with a replica shard, these properties allow to verify that the data has been written to the replica.
+#debezium.sink.redis.wait.enabled=true
+#debezium.sink.redis.wait.timeout.ms=1000
+#debezium.sink.redis.wait.retry.enabled=true
+#debezium.sink.redis.wait.retry.delay.ms=1000
+#debezium.source.database.history.redis.ssl.enabled=true
+# Location of the Java keystore file containing an application process' own certificate and private key.
+#javax.net.ssl.keyStore=<KEY_STORE_FILE_PATH>
+# Password to access the private key from the keystore file specified by javax.net.ssl.keyStore. This password is used twice: To unlock the keystore file (store password), and To decrypt the private key stored in the keystore (key password).
+#javax.net.ssl.keyStorePassword=<KEY_STORE_PASSWORD>
+# Location of the Java keystore file containing the collection of CA certificates trusted by this application process (trust store).
+#javax.net.ssl.trustStore=<TRUSE_STORE_FILE_PATH>
+# Password to unlock the keystore file (store password) specified by javax.net.ssl.trustStore.
+#javax.net.ssl.trustStorePassword=<TRUST_STORE_PASSWORD>
+
+debezium.source.connector.class=io.debezium.connector.mongodb.MongoDbConnector
+debezium.source.mongodb.hosts=<REPLICATION_SET_NAME>/<MONGO_DB_HOST>:<MONGO_DB_PORT>
+debezium.source.mongodb.connection.mode=replica_set
+debezium.source.mongodb.user=<MONGO_DB_USER>
+debezium.source.mongodb.password=<MONGO_DB_PASSWORD>
+debezium.source.offset.storage=io.debezium.storage.redis.offset.RedisOffsetBackingStore
+debezium.source.topic.prefix=<SOURCE_LOGICAL_SERVER_NAME>
+
+debezium.source.offset.flush.interval.ms=1000
+debezium.source.tombstones.on.delete=false
+debezium.source.schema.history.internal=io.debezium.storage.redis.history.RedisSchemaHistory
+
+# Important: Do NOT use `include` and `exclude` database lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match database names to be monitored.
+# By default, all databases are monitored.
+#debezium.source.database.include.list=<DB_NAME1>,<DB_NAME2>...
+# An optional, comma-separated list of regular expressions that match database names for which you do not want to capture changes.
+#debezium.source.database.exclude.list=<DB_NAME1>,<DB_NAME2>...
+# Important: Do NOT use `include` and `exclude` collection lists at the same time, use either `include` or `exclude`.
+# An optional, comma-separated list of regular expressions that match collection names to be monitored.
+#debezium.source.collection.include.list=<DB_NAME.COLLECTION_NAME1>,<DB_NAME.COLLECTION_NAME2>...
+# An optional, comma-separated list of regular expressions that match collection names for which you do not want to capture changes.
+#debezium.source.collection.exclude.list=<DB_NAME.COLLECTION_NAME1>,<DB_NAME.COLLECTION_NAME2>...
+
+#An optional, comma-separated list of regular expressions that match field names for which you do not want to capture changes.
+#debezium.source.field_exclude_list=<DB_NAME.COLLECTION_NAME1.FIELD_NAME1>,<DB_NAME.COLLECTION_NAME.FIELD_NAME2>
+
+# Whether to include the detailed schema information generated by Debezium in each record written to RDI.
+# Note: Including the schema reduces the initial sync throughput and is not recommended for large data sets.
+debezium.source.key.converter.schemas.enable=false
+debezium.source.value.converter.schemas.enable=false
+# When detailed schema information is excluded, handle decimal numeric types as strings.
+debezium.source.decimal.handling.mode=string
+
+debezium.transforms=AddPrefix
+debezium.transforms.AddPrefix.type=org.apache.kafka.connect.transforms.RegexRouter
+debezium.transforms.AddPrefix.regex=.*
+debezium.transforms.AddPrefix.replacement=data:$0
+
+# Logging
+# Uncomment the following lines if running Debezium Server as a Java standalone process (non-containerized).
+#quarkus.log.file.enable=true
+#quarkus.log.file.path=<LOG_FILE_PATH>
+#quarkus.log.file.rotation.max-file-size=100M
+#quarkus.log.file.rotation.rotate-on-boot=true
+#quarkus.log.file.rotation.file-suffix=.yyyy-MM-dd.gz
+#quarkus.log.file.rotation.max-backup-index=3
+
+# The default minimum log level for every log category, change only quarkus.log.level when needed.
+quarkus.log.min-level=TRACE
+# The default log level for every log category.
+quarkus.log.level=INFO
+# Determine whether to enable the JSON console formatting extension, which disables "normal" console formatting.
+quarkus.log.console.json=false
+# The port on which Debezium exposes Microprofile Health endpoint and other exposed status information.
+quarkus.http.port=8088
+```
+---
+Title: Debezium Server configuration file
+aliases: /integrate/redis-data-integration/write-behind/reference/debezium/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description:
+  Application properties settings used to configure Debezim Server for
+  source database servers
+group: di
+hideListLinks: false
+linkTitle: Debezium Server configuration
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 50
+---
+
+The `application.properties` file configures Debezium Server configuration to support source databases. It contains sections that define the sink connector (Redis) configuration and the source connector configuration.
+This file needs to be saved in the host running Debezium Server.
+
+The following topics describe `application.properties` for specific database servers:
+---
+Title: Write-behind (preview)
+aliases: /integrate/redis-data-integration/write-behind/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+hideListLinks: false
+linkTitle: Write-behind (preview)
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+---
+LinkTitle: Dynatrace with Redis Enterprise
+Title: Dynatrace with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Dynatrace to your Redis Enterprise cluster using
+  the Redis Dynatrace Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Dynatrace to your Redis Enterprise cluster using
+  the Redis Dynatrace Integration.
+type: integration
+weight: 7
+---
+
+
+[Dynatrace](https://www.dynatrace.com/) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The Dynatrace Integration for Redis Enterprise uses Prometheus remote write functionality to connect Prometheus data 
+sources to Dynatrace. This integration enables Redis Enterprise users to export metrics to Dynatrace for analysis, 
+and includes Redis-designed dashboards for use in monitoring Redis Enterprise clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rs/redis-enterprise-dynatrace.png" >}}
+## Install Redis' Dynatrace Integration for Redis Enterprise
+
+At the present time the Dynatrace integration is not signed by Dynatrace, meaning that it will be necessary to download 
+the source configuration and dashboards and assemble them and sign them cryptologically with a certificate that you have 
+created. The instructions for this procedure can be found on the Dynatrace 
+[site](https://docs.dynatrace.com/docs/extend-dynatrace/extensions20/sign-extension). Please note that the instructions 
+would have you place the dashboards next to the src folder; this is incorrect, the dashboards should be located inside 
+the src folder.
+
+## View metrics
+
+The Redis Enterprise Integration for Dynatrace contains pre-defined dashboards to aid in monitoring your Redis Enterprise deployment.
+
+The following dashboards are currently available:
+
+- Cluster: top-level statistics indicating the general health of the cluster
+- Database: performance metrics at the database level
+- Node: machine performance statistics
+- Shard: low-level details of an individual shard
+- Active-Active: replication and performance for geo-replicated clusters
+- Proxy: network and command information regarding the proxy
+- Proxy Threads: processor usage information regarding the proxy's component threads 
+
+
+## Monitor metrics
+
+Dynatrace dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible to
+filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
+retrieve the relevant data before choosing one of the options in the 'cluster' section.
+
+Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list 
+of database names and ids; use the id value when filtering input to the dashboard. 
+
+
+---
+LinkTitle: Prometheus & Grafana with Redis Cloud
+Title: Prometheus and Grafana with Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rc
+description: Use Prometheus and Grafana to collect and visualize Redis Cloud metrics.
+group: observability
+summary: You can use Prometheus and Grafana to collect and visualize your Redis Cloud
+  metrics.
+type: integration
+weight: 6
+aliases:
+    - /operate/rc/cloud-integrations/prometheus-integration
+---
+
+You can use Prometheus and Grafana to collect and visualize your Redis Cloud metrics.
+
+- [Prometheus](https://prometheus.io/) is an open source systems monitoring and alerting toolkit that can scrape metrics from different sources.
+- [Grafana](https://grafana.com/) is an open source metrics visualization tool that can process Prometheus data.
+
+Redis Cloud exposes its metrics through a Prometheus endpoint. You can configure your Prometheus server to scrape metrics from your Redis Cloud subscription on port 8070.
+
+The Redis Cloud Prometheus endpoint is exposed on Redis Cloud's internal network. To access this network, enable [VPC peering]({{< relref "/operate/rc/security/vpc-peering" >}}) or [Private Service Connect]({{< relref "/operate/rc/security/private-service-connect" >}}). Both options are only available with Redis Cloud Pro. You cannot use Prometheus and Grafana with Redis Cloud Essentials.
+
+For more information on how Prometheus communicates with Redis Enterprise clusters, see [Prometheus integration with Redis Enterprise Software]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}).
+
+## Quick start
+
+You can quickly set up Prometheus and Grafana for testing using the Prometheus and Grafana Docker images. 
+
+### Prerequisites
+
+1. Create a [Redis Cloud Pro database]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}). 
+
+1. Set up [VPC peering]({{< relref "/operate/rc/security/vpc-peering" >}}).
+
+1. Extract the Prometheus endpoint from the private endpoint to your database. The private endpoint is in the [Redis Cloud console](https://cloud.redis.io/) under the [Configuration tab]({{< relref "/operate/rc/databases/view-edit-database#configuration-tab" >}}) of your database. The Prometheus endpoint is on port 8070 of the internal server.
+
+    For example, if your private endpoint is:
+
+    ```sh
+    redis-12345.internal.<cluster_address>:12345
+    ```
+
+    The Prometheus endpoint is:
+
+    ```sh
+    internal.<cluster_address>:8070
+    ``` 
+
+1. Create an instance to run Prometheus and Grafana on the same cloud provider as your Redis Cloud subscription (for example, Amazon Web Services or Google Cloud). This instance must:
+    - Exist in the same region as your Redis Cloud subscription.
+    - Connect to the VPC subnet that is peered with your Redis Cloud subscription.
+    - Allow outbound connections to port 8070, so that Prometheus can scrape the Redis Cloud server for data.
+    - Allow inbound connections to port 9090 for Prometheus and port 3000 for Grafana.
+    - Be located in one of the CIDR ranges of the RFC-1918 internal IP standard, which is comprised of three CIDR ranges:
+
+        - 10.0.0.0/8
+        - 172.16.0.0/12
+        - 192.168.0.0/16
+        
+        The Prometheus endpoint is subject to a whitelist according to this standard.
+
+### Set up Prometheus
+
+To get started with custom monitoring with Prometheus on Docker:
+
+1. Create a directory on the Prometheus instance called `prometheus` and create a `prometheus.yml` file in that directory.
+
+1. Add the following contents to `prometheus.yml`. Replace `<prometheus_endpoint>` with the Prometheus endpoint.
+
+    ```yml 
+    global:
+        scrape_interval: 15s
+        evaluation_interval: 15s
+
+        # Attach these labels to any time series or alerts when communicating with
+        # external systems (federation, remote storage, Alertmanager).
+        external_labels:
+            monitor: "prometheus-stack-monitor"
+
+    # Load and evaluate rules in this file every 'evaluation_interval' seconds.
+    #rule_files:
+    # - "first.rules"
+    # - "second.rules"
+
+    scrape_configs:
+        # scrape Prometheus itself
+        - job_name: prometheus
+        scrape_interval: 10s
+        scrape_timeout: 5s
+        static_configs:
+          - targets: ["localhost:9090"]
+
+        # scrape Redis Cloud
+        - job_name: redis-cloud
+        scrape_interval: 30s
+        scrape_timeout: 30s
+        metrics_path: /  # For v2, use /v2
+        scheme: https
+        static_configs:
+          - targets: ["<prometheus_endpoint>:8070"]
+    ```
+
+1. Create a `docker-compose.yml` file with instructions to set up the Prometheus and Grafana Docker images.
+
+    ```yml
+    version: '3'
+    services:
+        prometheus-server:
+            image: prom/prometheus
+            ports:
+                - 9090:9090
+            volumes:
+                - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
+
+        grafana-ui:
+            image: grafana/grafana
+            ports:
+                - 3000:3000
+            environment:
+                - GF_SECURITY_ADMIN_PASSWORD=secret
+            links:
+                - prometheus-server:prometheus
+    ```
+
+1. To start the containers, run:
+
+    ```sh
+    $ docker compose up -d
+    ```
+
+1. To check that all the containers are up, run: `docker ps`
+1. In your browser, sign in to Prometheus at `http://localhost:9090` to make sure the server is running.
+1. Select **Status** and then **Targets** to check that Prometheus is collecting data from the Redis Cloud cluster.
+
+    {{<image filename="images/rs/prometheus-target.png" alt="The Redis Enterprise target showing that Prometheus is connected to the Redis Enterprise Cluster.">}}
+
+    If Prometheus is connected to the cluster, you can type **node_up** in the Expression field on the Prometheus home page to see the cluster metrics.
+
+See [Prometheus Metrics]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}}) for a list of metrics that Prometheus collects from Redis Enterprise clusters.
+
+### Set up Grafana
+
+Once the Prometheus and Grafana Docker containers are running, and Prometheus is connected to your Redis Cloud subscription, you can set up your Grafana dashboards.
+
+1. Sign in to Grafana. If you installed Grafana with Docker, go to `http://localhost:3000` and sign in with:
+
+    - Username: `admin`
+    - Password: `secret`
+
+1. In the Grafana configuration menu, select **Data Sources**.
+
+1. Select **Add data source**.
+
+1. Select **Prometheus** from the list of data source types.
+
+    {{<image filename="images/rs/prometheus-datasource.png" alt="The Prometheus data source in the list of data sources on Grafana.">}}
+
+1. Enter the Prometheus configuration information:
+
+    - Name: `redis-cloud`
+    - URL: `http://prometheus-server:9090`
+    - Access: `Server`
+
+    {{<image filename="images/rc/prometheus-connection.png" alt="The Prometheus connection form in Grafana.">}}
+
+    {{< note >}}
+
+- If the network port is not accessible to the Grafana server, select the **Browser** option from the Access menu.
+- In a testing environment, you can select **Skip TLS verification**.
+
+    {{< /note >}}
+
+1. Add dashboards for your subscription and database metrics.
+    To add preconfigured dashboards:
+    1. In the Grafana dashboards menu, select **Manage**.
+    1. Select **Import**.
+    1. Add the [subscription status](https://grafana.com/grafana/dashboards/18406-subscription-status-dashboard/) and [database status](https://grafana.com/grafana/dashboards/18407-database-status-dashboard/) dashboards.
+
+### Grafana dashboards for Redis Cloud
+
+Redis publishes preconfigured dashboards for Redis Cloud and Grafana:
+
+* The [subscription status dashboard](https://grafana.com/grafana/dashboards/18406-subscription-status-dashboard/) provides an overview of your Redis Cloud subscriptions.
+* The [database status dashboard](https://grafana.com/grafana/dashboards/18407-database-status-dashboard/) displays specific database metrics, including latency, memory usage, ops/second, and key count.
+* The [Active-Active dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/cloud/basic/redis-cloud-active-active-dashboard_v9-11.json) displays metrics specific to [Active-Active databases]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}).
+
+These dashboards are open source. For additional dashboard options, or to file an issue, see the [Redis Enterprise observability Github repository](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana).
+
+For more information about configuring Grafana dashboards, see the [Grafana documentation](https://grafana.com/docs/).
+---
+LinkTitle: Set up Redis
+Title: Set up Redis for Bedrock
+alwaysopen: false
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Shows how to set up your Redis database for Amazon Bedrock.
+group: cloud-service
+summary: 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.
+type: integration
+weight: 1
+---
+
+You need to set up your Redis Cloud database before you can set it as the vector database in Amazon Bedrock. To do this, you need to:
+
+1. [Sign up for Redis Cloud and create a database](#sign-up-create-subscription)
+1. [Enable Transport Layer Security (TLS) for the database and save the certificates](#get-certs)
+1. [Store database credentials in AWS secrets manager](#store-secret)
+1. [Create a vector index in your database](#create-vector-index) for Bedrock to use
+
+After you set up the database, you can use the database information to set it as your knowledge base database when you [create a knowledge base]({{< relref "/integrate/amazon-bedrock/create-knowledge-base" >}}).
+
+## Sign up and create a database  {#sign-up-create-subscription}
+
+To set up a Redis Cloud instance for Bedrock, you need to:
+
+1. [Sign up for Redis Cloud](#sign-up) if you do not already have an account.
+1. [Create a database](#create-sub) to use for your Bedrock knowledge base.
+
+### Sign up for Redis Cloud using AWS Marketplace {#sign-up}
+
+1.  Select the [Redis Cloud](https://aws.amazon.com/marketplace/pp/prodview-mwscixe4ujhkq?sr=0-1&ref_=beagle&applicationId=AWSMPContessa) AWS marketplace link from Bedrock to be taken to the Redis Cloud plan listing.
+
+    {{<image filename="images/rc/aws-marketplace-rc-flexible-plan.png" alt="The Redis Cloud listing on AWS Marketplace" >}}
+
+1.  Subscribe to Redis Cloud listing, locate the **Set Up Your Account** button, and then select it to begin mapping your Redis Cloud account with your AWS Marketplace account.
+
+    {{<image filename="images/rc/aws-marketplace-account-setup-button.png" alt="Use the Set Up Your Account button after subscribing to Redis Cloud with your AWS Marketplace account." width="50%">}}
+
+1.  Sign in to the [Redis Cloud console](https://cloud.redis.io).
+
+1.  Select the Redis account to be mapped to your AWS Marketplace account and confirm that your payment method will change and that the connection cannot be undone.
+
+    {{<image filename="images/rc/aws-marketplace-map-account-dialog.png" alt="Use the AWS Marketplace dialog to map your Redis Cloud account to your AWS Marketplace account." width="80%">}}
+
+1.  Use the **Map account** button to confirm your choice.
+
+1.  Once your Redis account is mapped to your AWS Marketplace account, a message appears in the upper, left corner of the account panel.
+
+    {{<image filename="images/rc/aws-marketplace-billing-badge.png" alt="The AWS Marketplace badge appears when your Redis Cloud account is mapped to an AWS Marketplace account." width="150px">}}
+
+    In addition, AWS Marketplace is reported as the selected payment method.
+
+### Create a database {#create-sub} 
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select **New database**. 
+
+    {{<image filename="images/rc/button-database-new.png" alt="The New Database button creates a new database." width="120px">}}
+
+1. When the **New database** page appears, select **Pro** to create a Pro plan.
+
+    {{<image filename="images/rc/create-database-subscription-pro-new.png" alt="The Subscription selection panel with Pro selected.">}}
+
+1. After you select **Pro**, the **Database settings** section will appear. For this guide, continue with **Easy create** to get started faster.
+
+    {{<image filename="images/rc/create-pro-db-settings.png" alt="The database settings section.">}}
+
+    If you'd like to select all of the configuration options yourself, select **Custom settings**. See [Create a Redis Cloud Pro database]({{< relref "/operate/rc/databases/create-database/create-pro-database-new#custom-settings" >}}) for more details.
+
+1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.
+
+    {{<image filename="images/rc/pro-easy-create-vendor.png" alt="The database name, cloud vendor and region settings." width=75% >}}
+
+1. Select **Amazon Web Services** as the cloud vendor and select a region.
+
+1. In the **Optimal database settings** section:
+
+    {{<image filename="images/rc/pro-easy-create-size-throughput.png" alt="The Dataset size, throughput, and High availability settings.">}}
+ 
+    - Turn on [**High-availability**]({{< relref "/operate/rc/databases/configuration/high-availability" >}}).
+    - Set the Dataset size of your database based on the amount of data that Bedrock will pull from your Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html). See [Find out the size of your S3 buckets](https://aws.amazon.com/blogs/storage/find-out-the-size-of-your-amazon-s3-buckets/) to find out how much knowledge base data is stored in your S3 bucket and pick the closest size, rounded up, from the table below. 
+
+        | Total Size of Documents in S3 | Database size without replication | Database size with replication |
+|-------------------------------|-----------------------------------|--------------------------------|
+| 10,000 kb                     | 135 Mb                             | 270 Mb                         |
+| 100,000 kb                    | 1.35 Gb                            | 2.7 Gb                         |
+| 1,000,000 kb                  | 13.5 Gb                              | 27 Gb                          |
+| 10,000,000 kb                 | 135 Gb                             | 270 Gb                         |
+
+        For more information on sizing, see the [Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/#right-size-your-database-for-amazon-bedrock).
+
+1. Select **View all settings** to review the database settings that we selected for you.
+
+    {{<image filename="images/rc/pro-easy-create-optimal-settings.png" alt="The optimal database settings.">}}
+
+    If you want to change these settings, select [**Switch to custom settings**]({{< relref "/operate/rc/databases/create-database/create-pro-database-new#custom-settings" >}}).
+
+1. You will not need to enter a payment method, as it's automatically assigned to your AWS Marketplace account. Select **Confirm & pay** to create your new database.
+
+    {{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & pay to create your new database." >}}
+
+    Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes.  (The process generally takes 10-15 minutes.)
+
+    Use the **Databases list** to check the status of your subscription.  You will also receive an email when your database is ready to use.
+
+## Enable TLS and get certificates {#get-certs}
+
+For your database to be fully secure, you must enable [Transport Layer Security (TLS)]({{< relref "/operate/rc/security/database-security/tls-ssl#enable-tls" >}}) for your database with client authentication.
+
+1. Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your database from the list.
+
+1. From the database's **Configuration** screen, select the **Edit** button:
+
+    {{<image filename="images/rc/button-database-edit.png" width="100px" alt="The Edit database button lets you change selected database properties." >}}
+
+1. In the **Security** section, use the **Transport layer security (TLS)** toggle to enable TLS:
+
+    {{<image filename="images/rc/database-details-configuration-tab-security-tls-toggle.png" width="200px" alt="Use the Transport Layer Security toggle to enable TLS." >}}
+
+1. Select **Download server certificate** to download the Redis Cloud certificate bundle `redis_ca.pem`:
+
+    {{<image filename="images/rc/button-database-config-security-server-ca-download.png" width="250px" alt="Use the Download server certificate button to download the Redis Cloud CA certificates." >}}
+
+1. Select the **Mutual TLS (require client authentication)** checkbox to require client authentication.
+
+1. Select **Add client certificate** to add a certificate.
+
+    {{<image filename="images/rc/mtls-add-client-certificate.png" width="200px" alt="The Add client certificate button." >}}
+
+1. Either provide an [X.509 client certificate](https://en.wikipedia.org/wiki/X.509) or chain in PEM format for your client or select **Generate** to create one:
+
+    {{<image filename="images/rc/database-details-configuration-tab-security-tls-client-auth-certificate.png" alt="Provide or generate a certificate for Mutual TLS." >}}
+
+    - If you generate your certificate from the Redis Cloud console, a **Download certificate** button will appear after it is generated. Select it to download the certificate. 
+
+        {{<image filename="images/rc/mtls-download-certificate.png" alt="The Download certificate button." >}}
+        
+        The download contains:
+
+        - `redis-db-<database_id>.crt` – the certificate's public key.
+
+        - `redis-db-<database_id>.key` – the certificate's private key.
+
+        {{<note>}}
+You must download the certificate using the button at this point.  After your changes have been applied, the full bundle of public and private keys will no longer be available for download.
+        {{</note>}}
+    
+    - If you provide a client certificate, you will see the certificate details before you save your changes.
+
+        {{<image filename="images/rc/mtls-certificate-details.png" alt="The Download certificate button." >}}
+
+1. To apply your changes and enable TLS, select the **Save database** button:
+
+    {{<image filename="images/rc/button-database-save.png" width="140px" alt="Use the Save database button to save database changes." >}}
+
+## Store database credentials in AWS secrets manager {#store-secret}
+
+In the [AWS Management Console](https://console.aws.amazon.com/), use the **Services** menu to locate and select **Security, Identity, and Compliance** > **Secrets Manager**. [Create a secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) of type **Other type of secret** with the following key/value fields:
+
+- `username`: Database username
+- `password`: Database password
+- `serverCertificate`: Contents of the [server certificate]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) (`redis_ca.pem`)
+- `clientCertificate`: Contents of the client certificate (`redis_user.crt`)
+- `clientPrivateKey`: Contents of the client private key (`redis_user_private.key`)
+
+After you store this secret, you can view and copy the [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html#iam-resources) of your secret on the secret details page. 
+
+## Create a vector index in your database {#create-vector-index}
+
+After your Redis Cloud database is set up, create a search index with a vector field using [FT.CREATE]({{< relref "commands/ft.create" >}}) as your knowledge base for Amazon Bedrock. You can accomplish this using **Redis Insight** or `redis-cli`.
+
+### Redis Insight
+
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) is a free Redis GUI that allows you to visualize and optimize your data in Redis. 
+
+To create your vector index in Redis Insight:
+
+1. [Download and install Redis Insight](https://redis.io/insight/) if you don't have it already.
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), in your database's **Configuration** tab, select the **Connect** button next to your database to open the connection wizard.
+
+    {{< image filename="/images/rc/button-connect.png#no-click" alt="Connect button." >}}
+
+1. In the connection wizard, under **Redis Insight Desktop**, select **Public Endpoint**. Select **Open with Redis Insight** to connect to the database with Redis Insight.
+
+1. Select **Use TLS**. In the **CA Certificate** section, select **Add new CA certificate**. Give the certificate a name in the **Name** field, and enter the contents of `redis_ca.pem` into the **Certificate** field.
+
+    {{<image filename="images/rc/ri-bedrock-add-ca-cert.png" width=80% alt="The Redis Insight Add CA Certificate section." >}}
+
+1. Select **Requires TLS Client Authentication**. In the **Client Certificate** section, select **Add new certificate**. Give the certificate a name in the **Name** field. Enter the contents of `redis_user.crt` into the **Certificate** field, and the contents of `redis_user_private.key` into the **Private Key** field.
+
+    {{<image filename="images/rc/ri-bedrock-add-client-cert.png" width=80% alt="The Redis Insight Add Client Certificate section." >}}
+
+1. Select **Add Redis Database** to connect to the database.
+
+1. Select your database alias to connect to your database. Select the **Workbench** icon to go to the workbench.
+
+    {{<image filename="images/rc/ri-bedrock-workbench.png" width=50px alt="The Redis Insight workbench icon." >}}
+
+1. Enter the [FT.CREATE]({{< relref "commands/ft.create" >}}) command to create an index. 
+
+    ```text
+    FT.CREATE <index_name>                    
+        ON HASH                
+        SCHEMA
+            "<text_field>" TEXT
+            "<metadata_field>" TEXT                   
+            "<vector_field>"  VECTOR FLAT     
+                6                          
+                "TYPE" "FLOAT32"            
+                "DIM" 1536                   
+                "DISTANCE_METRIC" "COSINE"  
+    ```
+
+    Replace the following fields:
+
+    - `<index_name>` with the vector index name
+    - `<text_field>` with the text field name
+    - `<metadata_field>` with the metadata field name
+    - `<vector_field>` with the vector field name
+
+1. Select **Run** to create the index.
+
+    {{<image filename="images/rc/ri-bedrock-run-button.png" width=50px alt="The Redis Insight run button." >}}
+
+### `redis-cli`
+
+The [`redis-cli`]({{< relref "/develop/tools/cli" >}}) command-line utility lets you connect and run Redis commands directly from the command line. To use `redis-cli`, you can [install Redis]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/" >}}).
+
+Public endpoint and port details are available from the **Databases** list or the database's **Configuration** screen. Select **Connect** to view how to connect to your database with `redis-cli`.
+
+```sh
+redis-cli -h <endpoint> -p <port> --tls --cacert redis_ca.pem \
+    --cert redis_user.crt --key redis_user_private.key
+```
+
+After you are connected with `redis-cli`, create an index using [FT.CREATE]({{< relref "commands/ft.create" >}}). 
+
+```text
+FT.CREATE <index_name>                    
+    ON HASH                
+    SCHEMA
+        "<text_field>" TEXT
+        "<metadata_field>" TEXT                   
+        "<vector_field>"  VECTOR FLAT     
+            6                          
+            "TYPE" "FLOAT32"            
+            "DIM" 1536                   
+            "DISTANCE_METRIC" "COSINE"  
+```
+
+Replace the following fields:
+- `<index_name>` with the vector index name
+- `<text_field>` with the text field name
+- `<metadata_field>` with the metadata field name
+- `<vector_field>` with the vector field name
+
+## Next steps
+
+After your Redis database is set up, you can use it to [create a knowledge base]({{< relref "/integrate/amazon-bedrock/create-knowledge-base" >}}) in Amazon Bedrock.---
+LinkTitle: Create Bedrock knowledge base
+Title: Create a Bedrock knowledge base
+alwaysopen: false
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Shows how to set up your Knowledge base in Amazon Bedrock.
+group: cloud-service
+summary: 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.
+type: integration
+weight: 2
+---
+
+After you have set up a vector database with Redis Cloud, you can use it to create a knowledge base for your models.
+
+Before you begin this guide, you will need:
+
+- An [AWS S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) with text data that you want to use to train your models.
+
+- An [AWS IAM Role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) with permissions for the Bedrock knowledge base.
+
+- A Redis database that is [set up for Amazon Bedrock]({{< relref "/integrate/amazon-bedrock/set-up-redis" >}})
+
+## Create knowledge base 
+
+To use your Redis database to create a knowledge base on Amazon Bedrock:
+
+1. Sign in to the [AWS console](https://console.aws.amazon.com/). 
+
+1. Use the **Services** menu to locate and select **Machine Learning** > **Amazon Bedrock**.  This takes you to the Amazon Bedrock admin panel.
+
+1. Select **Knowledge base** > **Create knowledge base** to create your knowledge base.
+
+    {{<image filename="images/rc/bedrock-aws-button-create-knowledge-base.png" width="200px" alt="The Create knowledge base button." >}}
+
+1. In the **Knowledge base details** section, enter a name and description for your knowledge base. 
+
+1. Select the IAM role for the Bedrock knowledge base in the **IAM Permissions** section. Select **Next** to add the data source.
+
+1. Enter a name for the data source and connect your S3 bucket in the **Data source** section.
+
+1. In the **Vector database** section, select **Redis Cloud** and select the checkbox to agree with the legal disclaimer.
+
+    {{<image filename="images/rc/bedrock-aws-select-redis-vector-db.png" width="500px" alt="The Redis Cloud selection for your vector database." >}}
+
+    Fill in the fields with the following information:
+
+    - **Endpoint URL**: Public endpoint of your database. This can be found in the [Redis Cloud console](https://cloud.redis.io/) from the database list or from the **General** section of the **Configuration** tab for the source database.
+    - **Credentials Secret ARN**: [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html#iam-resources) of your [database credentials secret]({{< relref "/integrate/amazon-bedrock/set-up-redis#store-secret" >}}).
+    - **Vector Index name**: Name of the [vector index]({{< relref "/integrate/amazon-bedrock/set-up-redis#create-vector-index" >}}) 
+    - **Vector field**: Name of the [vector field]({{< relref "/integrate/amazon-bedrock/set-up-redis#create-vector-index" >}}) of the vector index
+    - **Text field**: Name of the [text field]({{< relref "/integrate/amazon-bedrock/set-up-redis#create-vector-index" >}}) of the vector index
+    - **Metadata field**: Name of the [metadata field]({{< relref "/integrate/amazon-bedrock/set-up-redis#create-vector-index" >}}) of the vector index
+
+    Select **Next** to review your settings.
+
+1. Review your knowledge base before you create it. Select **Create knowledge base** to finish creation.
+
+    {{<image filename="images/rc/bedrock-aws-button-create-knowledge-base.png" width="200px" alt="The Create knowledge base button." >}}
+
+Amazon Bedrock will sync the data from the S3 bucket and load it into your Redis database. This will take some time.
+
+Your knowledge base will have a status of **Ready** when it is ready to be connected to an Agent.
+
+{{<image filename="images/rc/bedrock-aws-status-knowledge-base-ready.png" width="500px" alt="A Bedrock knowledge base with a Ready status." >}}
+
+Select the name of your knowledge base to view the syncing status of your data sources. The data source will have a status of **Ready** when it is synced to the vector database.
+
+{{<image filename="images/rc/bedrock-aws-status-data-source-ready.png" width="600px" alt="A Bedrock data source with a Ready status." >}}
+
+After the knowledge base is ready, you can use it to [Create an agent]({{< relref "/integrate/amazon-bedrock/create-agent" >}}).
+---
+LinkTitle: Create Bedrock agent
+Title: Create a Bedrock agent
+alwaysopen: false
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Shows how to set up your Agent in Amazon Bedrock.
+group: cloud-service
+summary: 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.
+type: integration
+weight: 3
+---
+
+After you have [created a knowledge base]({{< relref "/integrate/amazon-bedrock/create-knowledge-base" >}}), you can use it to create an agent on Amazon Bedrock.
+
+Before you begin this guide, you will need:
+
+- An [AWS IAM Role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) with [permissions for the Bedrock agent](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html).
+
+- A [Bedrock knowledge base]({{< relref "/integrate/amazon-bedrock/create-knowledge-base" >}}) connected to a [Redis Cloud vector database]({{< relref "/integrate/amazon-bedrock/set-up-redis" >}}).
+
+## Create an agent
+
+1. Sign in to the [AWS console](https://console.aws.amazon.com/). 
+
+1. Use the **Services** menu to locate and select **Machine Learning** > **Amazon Bedrock**.  This takes you to the Amazon Bedrock admin panel.
+
+1. Select **Agents** > **Create Agent** to create your knowledge base.
+
+    {{<image filename="images/rc/bedrock-aws-button-create-agent.png" width="150px" alt="The Create Agent button." >}}
+
+1. In the **Agent name** section, enter a name and description for your agent.
+
+1. Select whether or not you want the agent to be able to ask for additional information in the **User input** section.
+
+1. Select the IAM role for the Bedrock agent in the **IAM Permissions** section. 
+
+1. Choose how long you want your idle session timeout to be in the **Idle session timeout** section. Select **Next** to continue.
+
+1. In the **Model details** section, choose which model you want to use and enter the instructions for your agent. Select **Next** to continue.
+
+1. In the **Action groups** section, you may specify any tasks you would like the agent to perform. Select **Next** to continue.
+
+1. Select the [knowledge base](#create-a-knowledge-base) you created and summarize the information in the knowledge base in the **Knowledge base instructions for Agent** form. Select **Add another knowledge base** if you would like to add multiple knowledge bases. 
+
+     {{<image filename="images/rc/bedrock-aws-button-add-knowledge-base.png" width="400px" alt="The Add another knowledge base button." >}}
+
+    Select **Next** to continue.
+
+1. Review your agent before you create it. Select **Create Agent** to finish creation.
+
+    {{<image filename="images/rc/bedrock-aws-button-create-agent.png" width="150px" alt="The Create Agent button." >}}
+
+Amazon Bedrock will create your agent and link it to your knowledge base. This will take some time. 
+
+Your agent will have a status of **Ready** when it is ready to be tested. 
+
+{{<image filename="images/rc/bedrock-aws-status-agent-ready.png" width="75%" alt="A Bedrock agent with a Ready status." >}}
+
+Select the name of your agent to view the versions and draft aliases of your agent. You can also test your agent by entering prompts in the **Enter your message here** field. ---
+LinkTitle: Amazon Bedrock
+Title: Amazon Bedrock
+alwaysopen: false
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Shows how to use your Redis database with Amazon Bedrock to customize
+  foundational models.
+group: cloud-service
+hideListLinks: true
+summary: 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.
+type: integration
+weight: 3
+---
+
+[Amazon Bedrock](https://aws.amazon.com/bedrock/) streamlines GenAI deployment by offering foundational models (FMs) as a unified API, eliminating complex infrastructure management. It lets you create AI-powered [Agents](https://aws.amazon.com/bedrock/agents/) that execute complex tasks. Through [Knowledge Bases](https://aws.amazon.com/bedrock/knowledge-bases/) within Amazon Bedrock, you can seamlessly tether FMs to your proprietary data sources using retrieval-augmented generation (RAG). This direct integration amplifies the FM's intelligence based on your organization's resources.
+
+Amazon Bedrock lets you choose Redis Cloud as the [vector database](https://redis.io/solutions/vector-search/) for your agent's Knowledge Base. Once Redis Cloud is integrated with Amazon Bedrock, it automatically reads text documents from your Amazon Simple Storage Service (S3) buckets. This process lets the large language model (LLM) pinpoint and extract pertinent context in response to user queries, ensuring your AI agents are well-informed and grounded in their responses.
+
+For more information about the Redis integration with Amazon Bedrock, see the [Amazon Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/).
+
+To fully set up Bedrock with Redis Cloud, you will need to do the following:
+
+1. [Set up a Redis Cloud subscription and vector database]({{< relref "/integrate/amazon-bedrock/set-up-redis" >}}) for Bedrock.
+
+1. [Create a knowledge base]({{< relref "/integrate/amazon-bedrock/create-knowledge-base" >}}) connected to your vector database.
+
+1. [Create an agent]({{< relref "/integrate/amazon-bedrock/create-agent" >}}) connected to your knowledge base.
+
+## More info
+
+- [Amazon Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/)
+- [Detailed steps](https://github.com/redis-applied-ai/aws-redis-bedrock-stack/blob/main/README.md)
+---
+Title: Architecture
+aliases: /integrate/redis-data-integration/ingest/architecture/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Discover the main components of RDI
+group: di
+headerRange: '[2]'
+linkTitle: Architecture
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 3
+---
+
+## Overview
+
+RDI implements a [change data capture](https://en.wikipedia.org/wiki/Change_data_capture) (CDC) pattern 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.
+
+To use RDI, you define a *dataset* that specifies which data items
+you want to capture from the source and how you want to
+represent them in the target. For example, if the source is a
+relational database then you specify which table columns you want
+to capture but you don't need to store them in an equivalent table
+structure in the target. This means you can choose whatever target
+representation is most suitable for your app. To convert from the
+source to the target representation, RDI applies *transformations*
+to the data after capture.
+
+RDI synchronizes the dataset between the source and target using
+a *data pipeline* that implements several processing steps
+in sequence:
+
+1.  A *CDC collector* captures changes to the source database. RDI
+    currently uses an open source collector called
+    [Debezium](https://debezium.io/) for this step.
+
+1.  The collector records the captured changes using Redis streams
+    in the RDI database.
+
+1.  A *stream processor* reads data from the streams and applies
+    any transformations that you have defined (if you don't need
+    any custom transformations then it uses defaults).
+    It then writes the data to the target database for your app to use.
+
+Note that the RDI control processes run on dedicated virtual machines (VMs)
+outside the Redis
+Enterprise cluster where the target database is kept. However, RDI keeps
+its state and configuration data and also the change data streams in a Redis database on the same cluster as the target. The following diagram shows the pipeline steps and the path the data takes on its way from the source to the target:
+
+{{< image filename="images/rdi/ingest/ingest-dataflow.webp" >}}
+
+When you first start RDI, the target database is empty and so all
+of the data in the source database is essentially "change" data.
+RDI collects this data in a phase called *initial cache loading*,
+which can take minutes or hours to finish, depending on the size
+of the source data. Once the initial cache loading is complete,
+there is a *snapshot* dataset in the target that will gradually
+change when new data gets captured from the source. At this point,
+RDI automatically enters a second phase called *change streaming*, where
+changes in the data are captured as they happen. Changes are usually
+added to the target within a few seconds after capture.
+
+## Backpressure mechanism
+
+Sometimes, data records can get added to the streams faster than RDI can
+process them. This can happen if the target is slowed or disconnected
+or simply if the source quickly generates a lot of change data.
+If this continues, then the streams will eventually occupy all the
+available memory. When RDI detects this situation, it applies a
+*backpressure* mechanism to slow or stop the flow of incoming data.
+Change data is held at the source until RDI clears the backlog and has
+enough free memory to resume streaming.
+
+{{<note>}}The Debezium log sometimes reports that RDI has run out
+of memory (usually while creating the initial snapshot). This is not
+an error, just an informative message to note that RDI has applied
+the backpressure mechanism.
+{{</note>}}
+
+### Supported sources
+
+RDI supports the following database sources using [Debezium Server](https://debezium.io/documentation/reference/stable/operations/debezium-server.html) connectors:
+
+{{< embed-md "rdi-supported-source-versions.md" >}}
+
+## How RDI is deployed
+
+RDI is designed with three *planes* that provide its services.
+
+The *control plane* contains the processes that keep RDI active.
+It includes:
+
+-   An *API server* process that exposes a REST API to observe and control RDI.
+-   An *operator* process that manages the *data plane* processes.
+-   A *metrics exporter* process that reads metrics from the RDI database
+    and exports them as [Prometheus](https://prometheus.io/) metrics.
+
+The *data plane* contains the processes that actually move the data.
+It includes the *CDC collector* and the *stream processor* that implement 
+the two phases of the pipeline lifecycle (initial cache loading and change streaming).
+
+The *management plane* provides tools that let you interact
+with the control plane. 
+
+-   Use the CLI tool to install and administer RDI and to deploy 
+    and manage a pipeline. 
+-   Use the pipeline editor included in Redis Insight to design 
+    or edit a pipeline.
+    
+The diagram below shows all RDI components and the interactions between them:
+
+{{< image filename="images/rdi/ingest/ingest-control-plane.webp" >}}
+
+The following sections describe the VM configurations you can use to
+deploy RDI.
+
+### RDI on your own VMs
+
+For this deployment, you must provide two VMs. The collector and stream processor 
+are active on one VM, while on the other they are in standby to provide high availability. 
+The two operators running on both VMs use a leader election algorithm to decide which 
+VM is the active one (the "leader").
+The diagram below shows this configuration:
+
+{{< image filename="images/rdi/ingest/ingest-active-passive-vms.webp" >}}
+
+See [Install on VMs]({{< relref "/integrate/redis-data-integration/installation/install-vm" >}})
+for more information.
+
+### RDI on Kubernetes
+
+You can use the RDI [Helm chart](https://helm.sh/docs/topics/charts/) to install
+on [Kubernetes (K8s)](https://kubernetes.io/), including Red Hat
+[OpenShift](https://docs.openshift.com/). This creates:
+
+-   A K8s [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) named `rdi`.
+    You can also use a different namespace name if you prefer.
+-   [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) and 
+    [services](https://kubernetes.io/docs/concepts/services-networking/service/) for the 
+    [RDI operator]({{< relref "/integrate/redis-data-integration/architecture#how-rdi-is-deployed" >}}),
+    [metrics exporter]({{< relref "/integrate/redis-data-integration/observability" >}}), and API server.
+-   A [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) 
+    and [RBAC resources](https://kubernetes.io/docs/reference/access-authn-authz/rbac) for the RDI operator.
+-   A [ConfigMap](https://kubernetes.io/docs/concepts/configuration/configmap/) with RDI database details.
+-   [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)
+    with the RDI database credentials and TLS certificates.
+-   Other optional K8s resources such as [ingresses](https://kubernetes.io/docs/concepts/services-networking/ingress/) 
+    that can be enabled depending on your K8s environment and needs.
+
+See [Install on Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}})
+for more information.
+
+### Secrets and security considerations
+
+The credentials for the database connections, as well as the certificates 
+for [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and
+[mTLS](https://en.wikipedia.org/wiki/Mutual_authentication#mTLS) are saved in K8s secrets. 
+RDI stores all state and configuration data inside the Redis Enterprise cluster
+and does not store any other data on your RDI VMs or anywhere else outside the cluster.
+---
+Title: Troubleshooting
+aliases: /integrate/redis-data-integration/ingest/troubleshooting/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Solve and report simple problems with RDI
+group: di
+hideListLinks: false
+linkTitle: Troubleshooting
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 50
+---
+
+The following sections explain how you can get extra information from
+Redis Data Integration (RDI) to help you solve problems that you may encounter. Redis support may
+also ask you to provide this information to help you resolve issues.
+
+## Debug information during installation {#install-debug}
+
+If the installer fails with an error, then try installing again with the
+log level set to `DEBUG`:
+
+```bash
+./install.sh -l DEBUG   # Installer script
+redis-di install -l DEBUG    # Install command
+```
+
+This gives you more detail about the installation steps and can often
+help you to pinpoint the source of the error.
+
+## RDI logs
+
+By default, RDI records the following logs in the host VM file system at
+`/opt/rdi/logs` (or whichever path you specified during installation);
+
+| Filename | Phase |
+| :-- | :-- |
+| `rdi_collector-collector-initializer.log` | Initializing the collector. |
+| `rdi_collector-debezium-ssl-init.log` | Establishing the connector SSL connections to the source and RDI database (if you are using SSL). |
+| `rdi_collector-collector-source.log` | Collector [change data capture (CDC)]({{< relref "/integrate/redis-data-integration/architecture" >}}) operations. |
+| `rdi_rdi-rdi-operator.log` | Main [RDI control plane]({{< relref "/integrate/redis-data-integration/architecture#how-rdi-is-deployed" >}}) component. |
+| `rdi_processor-processor.log` | RDI stream processing. |
+
+Logs are recorded at the minimum `INFO` level in a simple format that
+log analysis tools can use.
+
+{{< note >}}Often during the initial sync phase, the collector source log will contain a message
+saying RDI is out of
+memory. This is not an error but an informative message to say that RDI
+is applying *backpressure* to the collector. See
+[Backpressure mechanism]({{< relref "/integrate/redis-data-integration/architecture#backpressure-mechanism" >}})
+in the Architecture guide for more information.
+{{< /note >}}
+
+## Dump support package
+
+If you need to send a comprehensive set of forensics data to Redis support,
+run the
+[`redis-di dump-support-package`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-dump-support-package" >}})
+command from the CLI.
+
+This command gathers the following data:
+
+- All the internal RDI components and their status
+- All internal RDI configuration
+- List of secret names used by RDI components (but not the secrets themselves)
+- RDI logs
+- RDI component versions
+- Output from the [`redis-di status`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-status" >}}) command
+- Text of the `config.yaml` file
+- Text of the Job configuration files
+- [optional] RDI DLQ streams content
+- Rejected records along with the reason for their rejection (should not exist in production)
+---
+Title: Quickstart
+linkTitle: Quickstart
+description: Get started with a simple pipeline example
+weight: 1
+alwaysopen: false
+categories: ["redis-di"]
+aliases: /integrate/redis-data-integration/ingest/quick-start-guide/
+---
+
+In this tutorial you will learn how to install RDI and set up a pipeline to ingest live data from a [PostgreSQL](https://www.postgresql.org/) 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]({{< relref "/develop/tools/insight" >}})
+  to edit your pipeline
+- A virtual machine (VM) with one of the following operating systems:  
+  {{< embed-md "rdi-os-reqs.md" >}}
+
+## Overview
+
+The following diagram shows the structure of the pipeline we will create (see
+the [architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}}) to learn how the pipeline works):
+
+{{< image filename="images/rdi/ingest/ingest-qsg.webp" >}}
+
+Here, the RDI *collector* tracks changes in PostgreSQL and writes them to streams in the 
+RDI database in Redis. The *stream processor* then reads data records from the RDI
+database streams, processes them, and writes them to the target.
+
+### Install PostgreSQL
+
+We provide a [Docker](https://www.docker.com/) image for an example PostgreSQL
+database that we will use for the tutorial. Follow the
+[instructions on our Github page](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres/tree/main)
+to download the image and start serving the database. The database, which is
+called `chinook`, has the [schema and data](https://www.kaggle.com/datasets/samaxtech/chinook-music-store-data?select=schema_diagram.png) for an imaginary online music store
+and is already set up for the RDI collector to use.
+
+### Install RDI
+
+Install RDI using the instructions in the
+[VM installation guide]({{< relref "/integrate/redis-data-integration/installation/install-vm" >}}).
+
+RDI will create the pipeline template for your chosen source database type at
+`/opt/rdi/config`. You will need this pathname later when you prepare the pipeline for deployment
+(see [Prepare the pipeline](#prepare-the-pipeline) below).
+
+At the end of the installation, RDI CLI will prompt you to set the access secrets
+for both the source PostgreSQL database and the target Redis database. RDI needs these to
+run the pipeline.
+
+Use the Redis Enterprise Cluster Manager UI to create the RDI database with the following requirements:
+
+{{< embed-md "rdi-db-reqs.md" >}}
+
+### Prepare the pipeline
+
+During the installation, RDI placed the pipeline templates at `/opt/rdi/config`.
+If you go to that folder and run the `ll` command, you will see the pipeline
+configuration file, `config.yaml`, and the `jobs` folder (see the page about
+[Pipelines]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}) for more information). Use Redis Insight to open
+the `config.yaml` file and then edit the following settings:
+
+- Set the `host` to `localhost` and the `port` to 5432.
+- Under `tables`, specify the `Track` table from the source database.
+- Add the details of your target database to the `target` section.
+
+At this point, the pipeline is ready to deploy.
+
+### Create a context (optional) {#create-context}
+
+To manage and inspect RDI, you can use the
+[`redis-di`]({{< relref "/integrate/redis-data-integration/reference/cli" >}})
+CLI command, which has several subcommands for different purposes. Most of these commands require you
+to pass at least two options, `--rdi-host` and `--rdi-port`, to specify the host and port of your
+RDI installation. You can avoid typing these options repeatedly by saving the
+information in a *context*.
+
+When you activate a context, the saved values of
+`--rdi-host`, `--rdi-port`, and a few other options are passed automatically whenever
+you use `redis-di`. If you have more than one RDI installation, you can create a context
+for each of them and select the one you want to be active using its unique name.
+
+To create a context, use the
+[`redis-di add-context`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-add-context" >}})
+command:
+
+```bash
+redis-di add-context --rdi-host <host> --rdi-port <port> <unique-context-name>
+```
+
+These options are required but there are also a few others you can save, such as TLS credentials, if
+you are using them (see the
+[reference page]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-add-context" >}})
+for details). When you have created a context, use
+[`redis-di set-context`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-set-context" >}})
+to activate it:
+
+```bash
+redis-di set-context <context name>
+```
+
+There are also subcommands to
+[list]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-list-contexts" >}})
+and [delete]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-delete-context" >}})
+contexts.
+
+### Deploy the pipeline
+
+You can use [Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}})
+to deploy the pipeline by adding a connection to the RDI API
+endpoint (which has the same hostname or IP address as your RDI VM and uses the default HTTPS port 443) and then clicking the **Deploy** button. You can also deploy it with the following command:
+
+```bash
+redis-di deploy --dir <path to pipeline folder>
+```
+
+where the path is the one you supplied earlier during the installation. (You may also need
+to supply `--rdi-host` and `--rdi-port` options if you are not using a
+[context](#create-context) as described above.) RDI first
+validates your pipeline and then deploys it if the configuration is correct.
+
+Once the pipeline is running, you can use Redis Insight to view the data flow using the
+pipeline metrics. You can also connect to your target database to see the keys that RDI has written there.
+
+See [Deploy a pipeline]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+for more information about deployment settings.
+
+### View RDI's response to data changes
+
+Once the pipeline has loaded a *snapshot* of all the existing data from the source,
+it enters *change data capture (CDC)* mode (see the
+[architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}})
+and the
+[ingest pipeline lifecycle]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#ingest-pipeline-lifecycle" >}})
+for more information
+).
+
+To see the RDI pipeline working in CDC mode:
+ 
+- Create a simulated load on the source database
+  (see [Generating load on the database](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres?tab=readme-ov-file#generating-load-on-the-database)
+  to learn how to do this).
+- Run
+  [`redis-di status --live`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-status" >}})
+  to see the flow of records.
+- Use [Redis Insight]({{< relref "/develop/tools/insight" >}}) to look at the data in the target database.
+---
+Title: FAQ
+aliases: /integrate/redis-data-integration/ingest/faq/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Find answers to common questions about RDI
+group: di
+hideListLinks: false
+linkTitle: FAQ
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 50
+---
+
+## Which license does RDI use?
+
+You must purchase a commercial license for RDI with Redis Enterprise. This includes two extra
+Redis Enterprise shards (primary and replica) for the staging database.
+
+## How does RDI track data changes in the source database?
+
+RDI uses mechanisms that are specific for each of the supported
+source databases:
+
+- **Oracle**:  RDI uses `logminer` to parse the Oracle `binary log` and `archive logs`. This
+  lists any changes in a database view that RDI can query.
+- **MySQL/MariaDB**: RDI uses `binary log replication` to get all the commits.
+- **PostgreSQL**:  RDI uses the `pgoutput` plugin.
+- **SQL Server**: RDI uses the CDC mechanism.
+
+## How much data can RDI process?
+
+RDI uses the concept of *processing units*. Each processing unit uses 1 CPU core and can process
+about 10,000 records per second, assuming the records have a size of about 1KB each. This throughput
+might change slightly depending on the number of columns, the number of data transformations,
+and the speed of the network. Typically, one processing unit is enough for RDI to deal with the
+traffic from a relational database.
+
+## Can RDI work with any Redis database?
+
+No. RDI is designed and tested to work only with Redis Enterprise. The staging database can
+only use version 6.4 or above. The target Redis database can be of any version and can be a
+replica of an Active-Active replication setup or an Auto tiering database.
+
+## Can RDI automatically track changes to the source database schema?
+
+If you don't configure RDI to capture a specific set of tables in the schema then it will
+detect any new tables when they are added. Similarly, RDI will capture new table columns
+and changes to column names unless you configure it for a specific set of columns.
+Bear in mind that the Redis keys in the target database will change to reflect the
+new or renamed tables and columns.
+
+## Should I be concerned when the log says RDI is out of memory? {#rdi-oom}
+
+Sometimes the Debezium log will contain a message saying that RDI is out of
+memory. This is not an error but an informative message to say that RDI
+is applying *backpressure* to Debezium. See
+[Backpressure mechanism]({{< relref "/integrate/redis-data-integration/architecture#backpressure-mechanism" >}})
+in the Architecture guide for more information.
+
+## What happens when RDI can't write to the target Redis database?
+
+RDI will keep attempting to write the changes to the target and will also attempt
+to reconnect to it, if necessary. While the target is disconnected, RDI
+will keep capturing change events from the source database and adding them to its
+streams in the staging database. This continues until the staging database gets
+low on space to store new events. When RDI detects this, it applies a "back pressure"
+mechanism to capture data from the source less frequently, which reduces the risk of running
+out of space altogether. The systems that the source databases use to record changes can
+retain the change data for at least a few hours, and RDI can catch up with the
+changes as soon as the target connection recovers or the staging database has
+more space available.
+
+## What does RDI do if the data is corrupted or invalid?
+
+The collector reports the data to RDI in a structured JSON format. If
+the structure of the JSON data is invalid or if there is a fatal bug in the transformation
+job then RDI can't transform the data. When this happens, RDI will store the original data
+in a "dead letter queue" along with a message to say why it was rejected. The dead letter
+queue is stored as a capped stream in the RDI staging database. You can see its contents
+with Redis Insight or with the 
+[`redis-di get-rejected`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-get-rejected" >}})
+command from the CLI.
+---
+Title: Install on VMs
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to install RDI on one or more VMs
+group: di
+hideListLinks: false
+linkTitle: Install on VMs
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+This guide explains how to install Redis Data Integration (RDI) on one or more VMs and integrate it with
+your source database. You can also
+[Install RDI on Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}).
+
+{{< note >}}We recommend you always use the latest version, which is RDI v{{< rdi-version >}}.
+{{< /note >}}
+
+## Create the RDI database
+
+RDI uses a database on your Redis Enterprise cluster to store its state
+information. Use the Redis Enterprise Cluster Manager UI to create the RDI database with the following
+requirements:
+
+{{< embed-md "rdi-db-reqs.md" >}}
+
+## Hardware sizing
+
+RDI is mainly CPU and network bound. 
+Each of the RDI VMs should have at least:
+
+{{< embed-md "rdi-vm-reqs.md" >}}
+
+## VM Installation Requirements
+
+You would normally install RDI on two VMs for High Availability (HA) but you can also install
+just one VM if you don't need this. For example, you might not need HA during
+development and testing.
+
+{{< note >}}You can't install RDI on a host where a Redis Enterprise cluster
+is also installed, due to incompatible network rules. If you want to install RDI on a
+host that you have previously used for Redis Enterprise then you must
+use [`iptables`](https://www.netfilter.org/projects/iptables/index.html) to
+"clean" the host before installation with the following command line:
+
+```bash
+ sudo iptables-save | awk '/^[*]/ { print $1 } 
+                     /^:[A-Z]+ [^-]/ { print $1 " ACCEPT" ; }
+                     /COMMIT/ { print $0; }' | sudo iptables-restore
+```
+
+You may encounter problems if you use `iptables` v1.6.1 and earlier in
+`nftables` mode. Use `iptables` versions later than v1.6.1 or enable the `iptables`
+legacy mode with the following commands:
+
+```bash
+sudo update-alternatives --set iptables /usr/sbin/iptables-legacy
+sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy
+```
+
+Also, `iptables` versions 1.8.0-1.8.4 have known issues that can prevent RDI
+from working, especially on RHEL 8. Ideally, use `iptables` v1.8.8, which is
+known to work correctly with RDI.
+{{< /note >}}
+
+The supported OS versions for RDI are:
+
+{{< embed-md "rdi-os-reqs.md" >}}
+
+You must run the RDI installer as a privileged user because it installs
+[containerd](https://containerd.io/) and registers services. However, you don't
+need any special privileges to run RDI processes for normal operation.
+
+RDI has a few
+requirements for cloud VMs that you must implement before running the
+RDI installer, or else installation will fail. The following sections
+give full pre-installation instructions for [RHEL](#firewall-rhel) and
+[Ubuntu](#firewall-ubuntu).
+
+### RHEL {#firewall-rhel}
+
+We recommend you turn off
+[`firewalld`](https://firewalld.org/documentation/)
+before installation using the command:
+
+```bash
+sudo systemctl disable firewalld --now
+```
+
+However, if you do need to use `firewalld`, you must add the following rules:
+
+```bash
+sudo firewall-cmd --permanent --add-port=443/tcp # RDI API
+sudo firewall-cmd --permanent --add-port=6443/tcp # kube-apiserver
+sudo firewall-cmd --permanent --zone=trusted --add-source=10.42.0.0/16 # Kubernetes pods
+sudo firewall-cmd --permanent --zone=trusted --add-source=10.43.0.0/16 # Kubernetes services
+sudo firewall-cmd --reload
+```
+
+If you have `nm-cloud-setup.service` enabled, you must disable it and reboot the
+node with the following commands:
+
+```bash
+sudo systemctl disable nm-cloud-setup.service nm-cloud-setup.timer
+sudo reboot
+```
+
+### Ubuntu {#firewall-ubuntu}
+
+We recommend you turn off
+[Uncomplicated Firewall](https://wiki.ubuntu.com/UncomplicatedFirewall) (`ufw`)
+before installation with the command:
+
+```bash
+sudo ufw disable
+```
+
+However, if you do need to use `ufw`, you must add the following rules:
+
+```bash
+sudo ufw allow 443/tcp # RDI API
+sudo ufw allow 6443/tcp # kube-apiserver
+sudo ufw allow from 10.42.0.0/16 to any # Kubernetes pods
+sudo ufw allow from 10.43.0.0/16 to any # Kubernetes services
+sudo ufw reload
+```
+
+## Installation steps
+
+Follow the steps below for each of your VMs:
+
+1.  Download the RDI installer from the
+    [Redis download center](https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-installation-{{< rdi-version >}}.tar.gz)
+    (from the *Modules, Tools & Integration* category) and extract it to your preferred installation
+    folder.
+
+    ```bash
+    export RDI_VERSION={{< rdi-version >}}
+    wget https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-installation-$RDI_VERSION.tar.gz
+    tar -xvf rdi-installation-$RDI_VERSION.tar.gz
+    ```
+
+1.  Go to the installation folder:
+
+    ```bash
+    cd rdi_install/$RDI_VERSION
+    ```
+
+1.  Run the `install.sh` script as a privileged user:
+
+    ```bash
+    sudo ./install.sh
+    ```
+
+    {{< note >}}RDI uses [K3s](https://k3s.io/) as part of its implementation.
+    By default, the installer installs K3s in the `/var/lib` directory,
+    but this might be a problem if you have limited space in `/var`
+    or your company policy forbids you to install there. You can
+    select a different directory for the K3s installation using the
+    `--installation-dir` option with `install.sh`:
+
+    ```bash
+    sudo ./install.sh --installation-dir <custom-installation-directory>
+    ```
+    {{< /note >}}
+
+The RDI installer collects all necessary configuration details and alerts you to potential issues, 
+offering options to abort, apply fixes, or provide additional information. 
+Once complete, it guides you through creating secrets and setting up your pipeline.
+
+{{< note >}}It is strongly recommended to specify a hostname rather than an IP address for
+connecting to your RDI database, for the following reasons:
+
+-   Any DNS resolution issues will be detected during the installation rather than
+    later during pipeline deployment.
+-   If you use TLS, your RDI database CA certificate must contain the hostname you specified
+    either as a common name (CN) or as a subject alternative name (SAN). CA certificates
+    usually don't contain IP addresses.
+{{< /note >}}
+
+{{< note >}}If you specify `localhost` as the address of the RDI database server during
+installation then the connection will fail if the actual IP address changes for the local
+VM. For this reason, we recommend that you don't use `localhost` for the address. However,
+if you do encounter this problem, you can fix it using the following commands on the VM
+that is running RDI itself:
+
+```bash
+sudo k3s kubectl delete nodes --all
+sudo service k3s restart
+```
+{{< /note >}}
+
+After the installation is finished, RDI is ready for use.
+
+### Supply cloud DNS information
+
+{{< note >}}This section is only relevant if you are installing RDI
+on VMs in a cloud environment.
+{{< /note >}}
+
+If you are using [Amazon Route 53](https://aws.amazon.com/route53/),
+[Google Cloud DNS](https://cloud.google.com/dns?hl=en), or
+[Azure DNS](https://azure.microsoft.com/en-gb/products/dns)
+then you must supply the installer with the nameserver IP address
+during installation. The table below
+shows the appropriate IP address for each cloud provider:
+
+| Platform | Nameserver IP |
+| :-- | :-- |
+| [Amazon Route 53](https://aws.amazon.com/route53/) | 169.254.169.253 |
+| [Google Cloud DNS](https://cloud.google.com/dns?hl=en) | 169.254.169.254 |
+| [Azure DNS](https://azure.microsoft.com/en-gb/products/dns) | 168.63.129.16 |
+
+If you are using Route 53, you should first check that your VPC
+is configured to allow it. See
+[DNS attributes in your VPC](https://docs.aws.amazon.com/vpc/latest/userguide/AmazonDNS-concepts.html#vpc-dns-support)
+in the Amazon docs for more information.
+
+### Installing with High Availability
+
+To install RDI with High Availability (HA), perform the [Installation steps](#installation-steps)
+on two different VMs. The first VM will automatically become the active (primary) instance, 
+while the second VM will become the passive (secondary) one. 
+When starting the RDI installation on the second VM, the installer will detect that the RDI
+database is already in use and ask you to confirm that you intend to install RDI with HA.
+
+After the installation is complete, you must set the source and target database secrets
+on both VMs as described in [Deploy a pipeline]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}}). If you use `redis-di` to deploy your configuration, you only need to do this on one of the VMs, not both.
+
+In a High Availability setup, the RDI pipeline is only active on the primary instance (VM).
+The two RDI instances will use the RDI database for leader election. If the primary instance fails 
+to renew the lease in the RDI database, it will lose the leadership and a failover to the secondary instance
+will take place. After the failover, the secondary instance will become the primary one, 
+and the RDI pipeline will be active on that VM.
+
+## Prepare your source database
+
+Before deploying a pipeline, you must configure your source database to enable CDC. See the
+[Prepare source databases]({{< relref "/integrate/redis-data-integration/data-pipelines/prepare-dbs" >}})
+section to learn how to do this.
+
+## Deploy a pipeline
+
+When the installation is complete, and you have prepared the source database for CDC,
+you are ready to start using RDI. See the guides on how to
+[configure]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}) and
+[deploy]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+RDI pipelines for more information. You can also configure and deploy a pipeline
+using [Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}}).
+
+## Uninstall RDI
+
+If you want to remove your RDI installation, go to the installation folder and run
+the uninstall script as a privileged user:
+
+```bash
+sudo ./uninstall.sh
+```
+
+The script will ask if you are sure before proceeding:
+
+```
+This will uninstall RDI and its dependencies, are you sure? [y, N]
+```
+
+If you type anything other than "y" here, the script will abort without making any changes
+to RDI or your source database.
+---
+Title: Requirements summary
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Requirements and recommendations for RDI installations.
+group: di
+hideListLinks: false
+linkTitle: Requirements summary
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 5
+---
+
+The sections below summarize the software and hardware requirements for
+an RDI installation.
+
+## Hardware requirements for VM installation
+
+{{< embed-md "rdi-vm-reqs.md" >}}
+
+## OS requirements for VM installation
+
+{{< embed-md "rdi-os-reqs.md" >}}
+
+## Kubernetes/OpenShift supported versions
+
+{{< embed-md "rdi-k8s-reqs.md" >}}
+
+## RDI database requirements
+
+{{< embed-md "rdi-db-reqs.md" >}}
+
+## Supported source databases
+
+{{< embed-md "rdi-supported-source-versions.md" >}}
+---
+Title: Install on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to install RDI on Kubernetes
+group: di
+hideListLinks: false
+linkTitle: Install on K8s
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 20
+---
+
+This guide explains how to use the RDI [Helm chart](https://helm.sh/docs/topics/charts/)
+to install on [Kubernetes](https://kubernetes.io/) (K8s). You can also
+[Install RDI on VMs]({{< relref "/integrate/redis-data-integration/installation/install-vm" >}}).
+
+The installation creates the following K8s objects:
+
+-   A K8s [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) named `rdi`.
+    You can also use a different namespace name if you prefer.
+-   [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) and 
+    [services](https://kubernetes.io/docs/concepts/services-networking/service/) for the 
+    [RDI operator]({{< relref "/integrate/redis-data-integration/architecture#how-rdi-is-deployed" >}}),
+    [metrics exporter]({{< relref "/integrate/redis-data-integration/observability" >}}), and API server.
+-   A [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) 
+    and [RBAC resources](https://kubernetes.io/docs/reference/access-authn-authz/rbac) for the RDI operator.
+-   A [ConfigMap](https://kubernetes.io/docs/concepts/configuration/configmap/) with RDI database details.
+-   [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)
+    with the RDI database credentials and TLS certificates.
+-   Other optional K8s resources such as [ingresses](https://kubernetes.io/docs/concepts/services-networking/ingress/) 
+    that can be enabled depending on your K8s environment and needs.
+
+You can use this installation on [OpenShift](https://docs.openshift.com/) and other K8s distributions
+including cloud providers' K8s managed clusters.
+
+You can configure the RDI Helm chart to pull the RDI images from [dockerhub](https://hub.docker.com/u/redis) 
+or from your own [private image registry](#using-a-private-image-registry).
+
+## Before you install
+
+Complete the following steps before installing the RDI Helm chart:
+
+-   [Create the RDI database](#create-the-rdi-database) on your Redis Enterprise cluster.
+
+-   Create a [user]({{< relref "/operate/rs/security/access-control/create-users" >}})
+    for the RDI database if you prefer not to use the default password (see
+    [Access control]({{< relref "/operate/rs/security/access-control" >}}) for
+    more information).
+
+-   Download the RDI Helm chart tar file from the
+    [Redis download center](https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-{{< rdi-version >}}.tgz) (in the *Modules, Tools & Integration* category) .
+
+    ```bash
+    export RDI_VERSION={{< rdi-version >}}
+    wget https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-$RDI_VERSION.tgz
+    ```
+
+-   If you want to use a private image registry,
+    [prepare it with the RDI images](#using-a-private-image-registry).
+
+### Create the RDI database
+
+RDI uses a database on your Redis Enterprise cluster to store its state
+information. Use the Redis Enterprise Cluster Manager UI to create the RDI database with the following
+requirements:
+
+{{< embed-md "rdi-db-reqs.md" >}}
+
+You should then provide the details of this database in the [`values.yaml`](#the-valuesyaml-file)
+file as described below.
+
+### Using a private image registry
+
+Add the RDI images from [dockerhub](https://hub.docker.com/u/redis) to your local registry.
+You need the following RDI images with tags matching the RDI version you want to install:
+
+-   [redis/rdi-api](https://hub.docker.com/r/redis/rdi-api)
+-   [redis/rdi-operator](https://hub.docker.com/r/redis/rdi-operator)
+-   [redis/rdi-monitor](https://hub.docker.com/r/redis/rdi-monitor)
+-   [redis/rdi-processor](https://hub.docker.com/r/redis/rdi-processor)
+-   [redis/rdi-collector-api](https://hub.docker.com/r/redis/rdi-collector-api)
+-   [redis/rdi-collector-initializer](https://hub.docker.com/r/redis/rdi-collector-initializer)
+
+In addition, the RDI Helm chart uses the following 3rd party images:
+
+-   [redislabs/debezium-server:3.0.8.Final-rdi.1](https://hub.docker.com/r/redislabs/debezium-server), 
+    based on `quay.io/debezium/server/3.0.8.Final` with minor modifications: 
+    [Debezium](https://debezium.io/), an open source distributed platform for change data capture.
+-   [redis/reloader:v1.1.0](https://hub.docker.com/r/redis/reloader), originally `ghcr.io/stakater/reloader:v1.1.0`: 
+    [Reloader](https://github.com/stakater/Reloader), a K8s controller to watch changes to ConfigMaps 
+    and Secrets and do rolling upgrades.
+-   [redis/kube-webhook-certgen:v20221220-controller-v1.5.1-58-g787ea74b6](https://hub.docker.com/r/redis/kube-webhook-certgen), 
+    originally `registry.k8s.io/ingress-nginx/kube-webhook-certgen/v20221220-controller-v1.5.1-58-g787ea74b6`: 
+    [kube-webhook-certgen](https://github.com/jet/kube-webhook-certgen), K8s webhook certificate generator and patcher.
+
+The example below shows how to specify the registry and image pull secret in your
+[`rdi-values.yaml`](#the-valuesyaml-file) file for the Helm chart:
+
+```yaml
+global:
+  # Global image settings.
+  # If using a private image registry, update the default values accordingly.
+  image:
+    registry: your-registry
+    repository: your-repository # If different from "redis"
+  
+  # Image pull secrets to be used when using a private image registry.
+  imagePullSecrets:
+    - name: your-secret-name
+```
+
+To pull images from a private image registry, you must provide the image pull secret and in some cases also set the permissions. Follow the links below to learn how to use a private registry with:
+
+-   [Rancher](https://ranchermanager.docs.rancher.com/how-to-guides/new-user-guides/kubernetes-resources-setup/kubernetes-and-docker-registries#using-a-private-registry)
+-   [OpenShift](https://docs.openshift.com/container-platform/4.17/openshift_images/managing_images/using-image-pull-secrets.html)
+-   [Amazon Elastic Kubernetes Service (EKS)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_EKS.html)
+-   [Google Kubernetes Engine (GKE)](https://cloud.google.com/artifact-registry/docs/pull-cached-dockerhub-images)
+-   [Azure Kubernetes Service (AKS)](https://learn.microsoft.com/en-us/azure/aks/cluster-container-registry-integration?tabs=azure-cli)
+
+## Supported versions of Kubernetes and OpenShift
+
+{{< embed-md "rdi-k8s-reqs.md" >}}
+
+## Install the RDI Helm chart
+
+1.  Scaffold the default `values.yaml` file from the chart into a local
+    `rdi-values.yaml` file:
+
+    ```bash
+    helm show values rdi-<tag>.tar.gz > rdi-values.yaml
+    ```
+
+1.  Open the `rdi-values.yaml` file you just created, change or add the appropriate
+    values for your installation, and delete the values you have not changed to 
+    use their default values. 
+    See [The `values.yaml` file](#the-valuesyaml-file) for more details.
+
+1.  Run the `helm upgrade --install` command:
+
+    ```bash
+    helm upgrade --install rdi rdi-<tag>.tar.gz -f rdi-values.yaml -n rdi --create-namespace
+    ```
+
+    {{< note >}}The above command will install RDI in a namespace called
+    `rdi`. If you want to use a different namespace, pass the option
+    `-n <custom-namespace>` to the `helm install` command instead.
+    {{< /note >}} 
+
+### The `values.yaml` file
+
+The [`values.yaml`](https://helm.sh/docs/topics/charts/#templates-and-values) file inside the
+Helm chart contains the values you can set for the RDI Helm installation.
+See the comments by each value for more information about the values you may need to add or change 
+depending on your use case.
+
+At a minimum, you must set the values of `connection.host`, `connection.port`, and `connection.password`
+to enable the basic connection to the RDI database. 
+You must also set `api.jwtKey`, RDI uses this value to encrypt the
+[JSON web token (JWT)](https://jwt.io/) token used by RDI API. Best practice is
+to generate a value containing 32 random bytes of data (equivalent to 256
+bits) and then encode this value as ASCII characters. Use the following
+command to generate the random key from the
+[`urandom` special file](https://en.wikipedia.org/wiki//dev/random):
+
+```bash
+head -c 32 /dev/urandom | base64
+```
+
+If you use TLS to connect to the RDI database, you must set the
+CA certificate content in `connection.ssl.cacert` (for TLS). In addition, if you
+also use mTLS, you must set the client certificate and private key contents in
+`connection.ssl.cert`, and `connection.ssl.key`. 
+
+-   You can add the certificate content directly in the `rdi-values.yaml` file
+    as follows:
+
+    ```yaml
+    connection:
+      ssl:
+        enabled: true
+        cacert: |
+          -----BEGIN CERTIFICATE-----
+          ...
+          -----END CERTIFICATE-----
+        cert: |
+          -----BEGIN CERTIFICATE-----
+          ...
+          -----END CERTIFICATE-----
+        key: |
+          -----BEGIN PRIVATE KEY-----
+          ...
+          -----END PRIVATE KEY-----
+    ```
+
+-   Alternatively, you can use the `--set-file` argument to set these values to
+    the content of your certificate files as follows:
+
+    ```bash
+    helm upgrade --install rdi rdi-<tag>.tar.gz -f rdi-values.yaml -n rdi --create-namespace \
+      --set connection.ssl.enabled=true \
+      --set-file connection.ssl.cacert=<path-to-CA-certificate> \
+      --set-file connection.ssl.cert=<path-to-client-certificate> \
+      --set-file connection.ssl.key=<path-to-client-key>
+    ```
+
+## Check the installation
+
+To verify the status of the K8s deployment, run the following command:
+
+```bash
+helm list -n rdi
+```
+
+The output looks like the following. Check that the `rdi` release is listed.
+With RDI 1.8.0 or later, check that the `default` release is also listed.
+
+```
+NAME   	NAMESPACE	REVISION	UPDATED         STATUS  	CHART         	APP VERSION
+default	rdi      	1       	2025-05-08 ... 	deployed	pipeline-0.1.0	<tag>
+rdi    	rdi      	3       	2025-05-08 ...	deployed	rdi-1.0.0      	
+```
+
+Also, check that all pods have `Running` status:
+
+```bash
+kubectl get pod -n rdi
+
+NAME                      READY  STATUS  	RESTARTS  AGE
+collector-api-<id>        1/1    Running  0         29m
+rdi-api-<id>              1/1 	 Running 	0      	  29m
+rdi-metric-exporter-<id>  1/1    Running 	0      	  29m
+rdi-operator-<id>         1/1 	 Running 	0      	  29m
+rdi-reloader-<id>         1/1 	 Running 	0      	  29m
+```
+
+You can verify that the RDI API works by adding a connection to the RDI API server to
+[Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}}).
+
+## Using ingress controllers
+
+You must ensure that an appropriate
+[ingress controller](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/)
+is available in your K8s cluster to expose the RDI API service via the K8s
+[`Ingress`](https://kubernetes.io/docs/concepts/services-networking/ingress/)
+resource. Follow the documentation of your cloud provider or of
+the ingress controller to install the controller correctly.
+
+### Using the `nginx` ingress controller on AKS
+
+On AKS, if you want to use the open source
+[`nginx`](https://nginx.org/)
+[ingress controller](https://github.com/kubernetes/ingress-nginx/blob/main/README.md#readme)
+rather than the
+[AKS application routing add-on](https://learn.microsoft.com/en-us/azure/aks/app-routing),
+follow the AKS documentation for
+[creating an unmanaged ingress controller](https://learn.microsoft.com/en-us/troubleshoot/azure/azure-kubernetes/load-bal-ingress-c/create-unmanaged-ingress-controller?tabs=azure-cli).
+Specifically, ensure that one or both of the following Helm chart values is set:
+
+- `controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz`
+- `controller.service.externalTrafficPolicy=Local`
+
+## Prepare your source database
+
+Before deploying a pipeline, you must configure your source database to enable CDC. See the
+[Prepare source databases]({{< relref "/integrate/redis-data-integration/data-pipelines/prepare-dbs" >}})
+section to learn how to do this.
+
+## Deploy a pipeline
+
+When the Helm installation is complete and you have prepared the source database for CDC,
+you are ready to start using RDI.
+Use [Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}}) to
+[configure]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}) and
+[deploy]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+your pipeline.
+
+## Uninstall RDI
+
+If you want to remove your RDI K8s installation, first run
+the following commands. (If you installed RDI into a custom namespace then
+replace `rdi` with the name of your namespace.)
+
+```bash
+kubectl delete pipeline default -n rdi
+helm uninstall rdi -n rdi
+kubectl delete namespace rdi
+```
+
+{{< note >}}The line `kubectl delete pipeline default -n rdi` is only needed for RDI 1.8.0 or above.
+{{< /note >}}
+
+If you also want to delete the keys from your RDI database, connect to it with
+[`redis-cli`]({{< relref "/develop/tools/cli" >}}) and run a
+[`FLUSHALL`]({{< relref "/commands/flushall" >}}) command.
+---
+Title: Upgrading RDI
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to upgrade an existing RDI installation
+group: di
+hideListLinks: false
+linkTitle: Upgrade
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+## Upgrading a VM installation
+
+Follow the steps below to upgrade an existing
+[VM installation]({{< relref "/integrate/redis-data-integration/installation/install-vm" >}})
+of RDI:
+
+1.  Download the RDI installer from the [Redis download center](https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-installation-{{< rdi-version >}}.tar.gz)
+    (in the *Modules, Tools & Integration* category) and extract it to your
+    preferred installation folder.
+
+    ```bash
+    export RDI_VERSION={{< rdi-version >}}
+    wget https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-installation-$RDI_VERSION.tar.gz
+    tar -xvf rdi-installation-$RDI_VERSION.tar.gz
+    ```
+
+1.  Go to the installation folder:
+
+    ```bash
+    cd rdi_install/$RDI_VERSION
+    ```
+
+1.  Run the `upgrade.sh` script as a privileged user. Note that you must pass
+    your RDI password to the script unless the password is empty.
+
+    ```bash
+    sudo ./upgrade.sh --rdi-password <redis-rdi-password>
+    ```
+
+### Recovering from failure during a VM upgrade
+
+If the previous version is v1.4.4 or later, go to the `rdi_install/<PREVIOUS_VERSION>`
+directory and run `sudo ./upgrade.sh` to revert to that version, as described in the section
+[Upgrading a VM installation](#upgrading-a-vm-installation) above.
+
+If the version you are replacing is earlier than v1.4.4, follow these steps:
+
+1.  Run `redis-di --version` to check the current version.
+
+    If the version is the new one, copy the previous version
+    of the RDI CLI to `/usr/local/bin` with the following command:
+    
+    ```bash
+    sudo cp rdi_install/<PREVIOUS_VERSION>/deps/rdi-cli/<OS>/redis-di usr/local/bin
+    ```
+
+1.  Check that the CLI version is correct by running `redis-di --version`.
+
+    Then, go to the `rdi_install/<PREVIOUS_VERSION>` directory and run the
+    following command;
+
+    ```bash
+    sudo redis-di upgrade --rdi-host <RDI_REDIS_HOST> --rdi-port <RDI_REDIS_PORT>
+    ```
+
+{{< note >}}If the `collector-source` or the `processor` pods are not in the `Running` state after
+the upgrade, you must run `redis-di deploy` and check again that they are both in the
+`Running` state.
+{{< /note >}}
+
+### Upgrading a VM installation with High Availability
+
+If there is an active pipeline, upgrade RDI on the active VM first. 
+This will cause a short pipeline downtime of up to two minutes. 
+Afterwards, upgrade RDI on the passive VM. This will not cause any downtime.
+
+## Upgrading a Kubernetes installation
+
+Follow the steps below to upgrade an existing
+[Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}})
+installation of RDI:
+
+1.  If you are using a private registry, pull the new versions of all images listed in 
+    [Using a private image registry]({{< relref "/integrate/redis-data-integration/installation/install-k8s#using-a-private-image-registry" >}})
+    and add them to your local registry.
+
+1.  Download the RDI Helm chart tar file from the [Redis download center](https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-{{< rdi-version >}}.tgz)
+    (in the *Modules, Tools & Integration* category).
+
+    ```bash
+    export RDI_VERSION={{< rdi-version >}}
+    wget https://redis-enterprise-software-downloads.s3.amazonaws.com/redis-di/rdi-$RDI_VERSION.tgz
+    ```
+
+1.  Adapt your `rdi-values.yaml` file to any changes in the new RDI version if needed.
+    See also [Upgrading to RDI 1.8.0 or later from an earlier version](#upgrading-to-rdi-180-or-later-from-an-earlier-version). 
+    Before making any changes, save your existing `rdi-values.yaml` if you need to revert 
+    to the old RDI version for any reason.
+
+1.  Run the `helm upgrade` command:
+    
+    ```bash
+    helm upgrade --install rdi rdi-<tag>.tar.gz -f rdi-values.yaml -n rdi
+    ```
+
+Note that you don't need to
+[deploy]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+the RDI configuration again after this step.
+
+### Upgrading to RDI 1.8.0 or later from an earlier version
+
+When upgrading to RDI 1.8.0 or later from an earlier version 
+you must adapt your `rdi-values.yaml` file to the following changes:
+
+-   All collector and processor values that were previously under `collector`, 
+    `collectorSourceMetricsExporter`, and `processor` have been moved to 
+    `operator.dataPlane.collector` and `operator.dataPlane.processor`.
+-   `global.collectorApiEnabled` has been moved to `operator.dataPlane.collectorApi.enabled`, 
+    and is now a boolean value, not `"0"` or `"1"`.
+-   `api.authEnabled` is also now a boolean value, not `"0"` or `"1"`.
+-   The following values have been deprecated: `rdiMetricsExporter.service.protocol`, 
+    `rdiMetricsExporter.service.port`, `rdiMetricsExporter.serviceMonitor.path`, 
+    `api.service.name`.
+
+### Verifying the upgrade
+
+Check that all pods have `Running` status:
+
+```bash
+kubectl get all -n rdi
+```
+
+If you find that the upgrade did not work as expected for any reason, 
+then run the `helm upgrade` command again (as described in the section
+[Upgrading a Kubernetes installation](#upgrading-a-kubernetes-installation) above),
+but this time with the previous version you were upgrading from, and using
+your saved `rdi-values.yaml` for that version. This will restore your previous working state.
+
+{{< note >}}Downgrading from RDI 1.8.0 or later to an earlier version using `helm upgrade`
+will not work. If you need to perform such an upgrade, uninstall RDI completely first as
+described in [Uninstall RDI]({{< relref "/integrate/redis-data-integration/installation/install-k8s#uninstall-rdi" >}}),
+and then install the old version.
+{{< /note >}}
+
+## What happens during the upgrade?
+
+The upgrade process replaces the current RDI components with their new versions:
+
+-   Firstly, the control plane components are replaced. At this point, the pipeline
+    is still active but monitoring will be disconnected.
+-   Secondly, the pipeline data plane components are replaced.
+    If a pipeline is active while upgrading, the `collector-source` and `processor`
+    pods will be restarted. The pipeline will pause for up to two minutes but it 
+    will catch up very quickly after restarting. 
+    The pipeline data and state are both stored in Redis, so data will not
+    be lost during the upgrade.
+---
+Title: Install and upgrade
+aliases: /integrate/redis-data-integration/ingest/installation/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to install and upgrade RDI
+group: di
+hideListLinks: false
+linkTitle: Install/upgrade
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+The guides in this section explain the options you have for installing and upgrading RDI.
+Before you use RDI, you must also configure your source database to enable CDC. See the
+[Prepare source databases]({{< relref "/integrate/redis-data-integration/data-pipelines/prepare-dbs" >}})
+section to learn how to do this.---
+Title: Redis Data Integration release notes 1.2 (June 2024)
+alwaysopen: false
+aliases: /integrate/redis-data-integration/ingest/release-notes/rdi-1-2/
+categories:
+- docs
+- operate
+- rs
+description: API server with a set of APIs to support Redis Insight with creating, testing, deploying & monitoring RDI pipelines. RDI Installer verifies all components are running at the end of installation.
+linkTitle: 1.2 (June 2024)
+toc: 'true'
+weight: 999
+---
+
+> This minor release replaces the 1.0 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a
+[_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient
+and fast data structures that match your app's requirements. You specify the
+transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- API server with a set of APIs to support Redis Insight with creating, testing, deploying & monitoring RDI pipelines.
+- RDI Installer verifies all components are running at the end of installation.
+
+## Fixed Bugs
+
+- Support for source database TLS & mTLS was fixed. Certificate and file names used with the redis-di set-secret command can have any file names
+- Mismatch between Reloader version provided and the one required.
+
+## Limitations
+
+- RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+- RDI write-behind (which is currently in preview) should not be used on the same data set that RDI ingest is writing to Redis. This would either cause an infinite loop or would harm the data integrity, since both ingest and write-behind are asynchronous, eventually-consistent processes.
+---
+Title: Redis Data Integration release notes 1.6.2 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.2 (March 2025)
+toc: 'true'
+weight: 990
+---
+
+> This maintenance release replaces the 1.6.1 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Fix: With an RDI namespace that contains dashes, `rdi-metrics-exporter` crashes immediately upon startup
+- Fix reported security vulnerabilities
+- Fix: Connection to PostgreSQL from Debezium fails with "could not read SSL key file" when using mTLS
+
+## Fixes & Improvements
+
+- **Resolved startup crash in `rdi-metrics-exporter`**
+  Fixed an issue where the exporter would crash on startup if the RDI namespace included dashes (e.g., `my-namespace`) that are not allowed in prometheus labels.
+
+- **Security Vulnerabilities Patched**
+  Addressed the following reported CVEs:
+
+  - CVE-2019-14250
+  - CVE-2019-17543
+  - CVE-2023-32665
+  - CVE-2024-52533
+  - CVE-2020-17049
+  - CVE-2024-47874
+
+- **Improved mTLS compatibility in `collector-initializer`**
+  DER-formatted keys are now skipped during initialization, resolving a PostgreSQL connection error with Debezium (`could not read SSL key file`) when using mTLS.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.4.4 (January 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.4.4 (January 2025)
+toc: 'true'
+weight: 993
+---
+
+> This maintenance release replaces the 1.4.3 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+-   Installation on [Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}) using a [Helm chart](https://helm.sh/docs/). You can install on [OpenShift](https://docs.openshift.com/) or other flavours of K8s using Helm.
+
+- Improvements for installation on VMs:
+  - Adding an `upgrade.sh` script
+  - Uninstall script removes RDI CLI
+  - Adding an ingress to the `collector-source` metrics exporter for VM installs
+  - Fix RDI version issues during upgrade
+  - Ensure `KUBECONFIG` is set during upgrade
+  - Upgrade [`datayoga`](https://github.com/datayoga-io/datayoga) to 1.127.0 - add_field block was rejected for one or more records but the entire batch was marked as rejected. making troubleshooting difficult
+  - Fix installer not setting `RDI_REDIS_SSL` properly if SSL is enabled
+
+## Issues fixed 
+
+- **RDSC-3103**: If a record's transformation is rejected, the entire Processor batch ends up in DLQ
+- **RDSC-3130**: Failed to install 1.4.3, but successful install with 1.2.8
+- **RDSC-3141**: There is no way to reach metrics when running RDI on VM
+- **RDSC-3142**: `redis-di upgrade` fails with error message - CRITICAL - Error while attempting to upgrade RDI: Could not get the current version of the RDI instance
+- **RDSC-3143**: RDI on VM upgrade error message - Get "http://localhost:8080/openapi/v2?timeout=32s": dial tcp 127.0.0.1:8080: connect: connection refused
+- **RDSC-3156**: Add script to execute `redis-di upgrade` correctly
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.8.0 (May 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: |
+  Enhanced RDI operator for better pipeline orchestration, resiliency, observability and flexibility;
+  External collector support;
+  Labels and annotations to RDI data plane pods;
+  Custom Debezium image;
+  Calculated TTL for target database.
+linkTitle: 1.8.0 (May 2025)
+toc: 'true'
+weight: 984
+---
+
+{{< note >}}This minor release replaces the 1.6.7 release.{{< /note >}}
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Enhanced RDI operator for better pipeline orchestration, resiliency, observability, and flexibility. It 
+  will also enable many new features in the near future.
+- You can now use an external collector that is not managed by RDI but writes into RDI streams
+  (Debezium compatible).
+- You can now add labels and annotations to RDI data plane pods, for example to control service
+  mesh features.
+- RDI now uses a custom image of Debezium (based on `3.0.8.Final`) to address known vulnerabilities.
+- Added support for calculated TTL for target database keys via `expire` expressions.
+
+## Detailed changes
+
+### Helm chart changes
+
+- All collector and processor values that were previously under `collector`, `collectorSourceMetricsExporter`, and `processor` have been moved to `operator.dataPlane.collector` and `operator.dataPlane.processor`.
+- `global.collectorApiEnabled` has been moved to `operator.dataPlane.collectorApi.enabled`, and is now a boolean value (`true` or `false`), not `"0"` or `"1"`.
+- `api.authEnabled` is also now a boolean value, not `"0"` or `"1"`.
+- The following values have been deprecated: `rdiMetricsExporter.service.protocol`, `rdiMetricsExporter.service.port`, `rdiMetricsExporter.serviceMonitor.path`, `api.service.name`
+- You can now add custom labels and annotations to all RDI components.
+- You can now disable the creation of the RDI system secrets.
+
+### Operator Improvements
+
+The RDI operator has been significantly enhanced in the following areas:
+
+- **Resilience**: The operator now always maintains the desired pipeline state. Manual changes or random disruptions are reverted automatically.
+- **Automatic recovery**: When a configuration issue is resolved, the entire pipeline starts automatically, eliminating the need for manual redeployment.
+- **Consistency**: A pipeline that has been stopped with `stop` will remain stopped after `deploy` or `reset`, until explicitly started again.
+- **Enhanced configuration**: You can now configure data plane components in ways that were previously not supported, such as adding labels and annotations.
+- **External collector support**: No collector resources are created for sources of type `external`.
+- **Enhanced troubleshooting**: You can now gain extra insight into the pipeline state by examining the `Pipeline` and `PipelineRelease` custom K8s resources.
+
+### Other Features, Improvements and Enhancements
+
+- Added `expire` expression for target output in transformation jobs.
+- Addressed security vulnerabilities: TLS certificate hostname verification is now ON by default.
+- Improved Helm default values while preserving `values.yaml` formatting.
+- Enhanced Helm values and templates for better configuration.
+- Added a script to create or update secrets when using Helm (`rdi-secret.sh` in the Helm zip file).
+- Improved validation schema and ensured backward compatibility.
+- Fixed compatibility issues with newer versions of `requests` and `urllib3`.
+- Improved error messages for JSON schema validation.
+- Improved PostgreSQL documentation for mTLS.
+- Added timestamps to the `status` command.
+- Fixed issues with `primary_key` and `unique_constraint` attributes in Oracle metadata.
+- Added `capture.mode` to MongoDB scaffolding.
+- Improved Helm TLS setup for RDI database connections.
+- Enhanced error handling and validation for transformation jobs.
+- Improved documentation for supported platforms and configurations.
+
+### Fixes
+
+- Fixed HTTP 500 error when querying columns with tables parameter.
+- Improved Helm TLS setup for RDI database connections.
+- Fixed keystore overwrite when using mTLS on both source and RDI DBs in the collector.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.6 (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.6 (April 2025)
+toc: 'true'
+weight: 986
+---
+
+> This maintenance release replaces the 1.6.5 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Fixed a Redis Insight issue when accessing the RDI API `/strategies` endpoint.
+- Added a new script to the RDI Helm chart for managing the source and target database secrets. See
+  [Deploy a pipeline]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+  for more information.
+- Fixed an issue when connecting from Redis Insight to the RDI API `/login` endpoint with a non-default user.
+- Updated the RDI API `/schemas` endpoint to return a list of databases for MySQL and MariaDB, instead of an empty list of schemas.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.4.0 (October 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.4.0 (October 2024)
+toc: 'true'
+weight: 997
+---
+
+> This is a GA version of Redis Data Integration (RDI) that improves the installation of RDI.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+-   Installation on [Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}) using a [Helm chart](https://helm.sh/docs/). You can install on [OpenShift](https://docs.openshift.com/) or other flavours of K8s using Helm.
+
+- Improvements for installation on VMs:
+	- Installer checks if the OS firewall is enabled on Ubuntu and RHEL.
+	- Installer verifies DNS resolution from RDI components.
+	- Installer provides log lines from components that failed during RDI deployment if a problem occurs.
+	- Improved verification of RDI installation.
+	- Installer verifies if the RDI database is in use by another instance of RDI.
+	- Installer checks and warns if any [`iptables`](https://www.netfilter.org/projects/iptables/index.html) rules are set.
+	- Improved message when RDI tries to connect to its Redis database with invalid TLS keys.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.7 (May 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.7 (May 2025)
+toc: 'true'
+weight: 985
+---
+
+> This maintenance release replaces the 1.6.6 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Update the RDI API `/tables` and `/metadata` endpoints to filter the results by schema for MySQL and 
+  MariaDB. Schema and Database are the same for these databases.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.4.1 (November 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.4.1 (November 2024)
+toc: 'true'
+weight: 996
+---
+
+> This maintenance release replaces the 1.4.0 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+-   Installation on [Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}) using a [Helm chart](https://helm.sh/docs/). You can install on [OpenShift](https://docs.openshift.com/) or other flavours of K8s using Helm.
+
+- Improvements for installation on VMs:
+	- Installer checks if the OS firewall is enabled on Ubuntu and RHEL.
+	- Installer verifies DNS resolution from RDI components.
+	- Installer provides log lines from components that failed during RDI deployment if a problem occurs.
+	- Improved verification of RDI installation.
+	- Installer verifies if the RDI database is in use by another instance of RDI.
+	- Installer checks and warns if any [`iptables`](https://www.netfilter.org/projects/iptables/index.html) rules are set.
+	- Improved message when RDI tries to connect to its Redis database with invalid TLS keys.
+
+## Issues fixed
+
+- **RDSC-2806**: Remove incorrectly created deployment.
+- **RDSC-2792**: Disable `kubectl run` checks.
+- **RDSC-2782**: Fix `coredns` issue.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.3 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.3 (March 2025)
+toc: 'true'
+weight: 989
+---
+
+> This maintenance release replaces the 1.6.2 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Fix: RDI 1.6.2 VM Installer not working on RHEL-8 OS.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.4 (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.4 (April 2025)
+toc: 'true'
+weight: 988
+---
+
+> This maintenance release replaces the 1.6.3 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Feature: Add support for Debezium 3.0.8
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.4.2 (November 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.4.2 (November 2024)
+toc: 'true'
+weight: 995
+---
+
+> This maintenance release replaces the 1.4.1 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+-   Installation on [Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}) using a [Helm chart](https://helm.sh/docs/). You can install on [OpenShift](https://docs.openshift.com/) or other flavours of K8s using Helm.
+
+- Improvements for installation on VMs:
+	- Installer checks if the OS firewall is enabled on Ubuntu and RHEL.
+	- Installer verifies DNS resolution from RDI components.
+	- Installer provides log lines from components that failed during RDI deployment if a problem occurs.
+	- Improved verification of RDI installation.
+	- Installer verifies if the RDI database is in use by another instance of RDI.
+	- Installer checks and warns if any [`iptables`](https://www.netfilter.org/projects/iptables/index.html) rules are set.
+	- Improved message when RDI tries to connect to its Redis database with invalid TLS keys.
+
+## Issues fixed
+
+- **RDSC-2802**: Reintroduce checks for DNS resolution and network connectivity from inside a K8s pod.
+- **RDSC-2804**: RDI installation previously failed if the user specified a non-default HTTPS port.
+  The user can now specify the port correctly.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.0 (February 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.0 (February 2025)
+toc: 'true'
+weight: 992
+---
+
+> This maintenance release replaces the 1.4.4 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- RDI now requires the RDI database to have the following properties set, otherwise
+  RDI will not start:
+  - `maxmemory_policy`: `noeviction`,
+  - `aof_enabled`: `1`
+
+- Allow RDI to run in any K8s namespace
+
+- Fix metadata API to support Oracle and SQL Server
+
+- Added [denormalisation lookup block]({{< relref "/integrate/redis-data-integration/reference/data-transformation/lookup" >}})
+
+- Many bug fixes
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.2.8 (August 2024)
+alwaysopen: false
+aliases: /integrate/redis-data-integration/ingest/release-notes/rdi-1-2-8/
+categories:
+- docs
+- operate
+- rs
+description: API server with a set of APIs to support Redis Insight with creating, testing, deploying & monitoring RDI pipelines. RDI Installer verifies all components are running at the end of installation.
+linkTitle: 1.2.8 (August 2024)
+toc: 'true'
+weight: 998
+---
+
+# Redis Data Integration 1.2.8 GA
+
+> This maintenance release replaces the 1.2 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- API server with a set of APIs to support Redis Insight with creating, testing, deploying & monitoring RDI pipelines.
+- RDI Installer verifies all components are running at the end of installation.
+
+## Fixed Bugs
+
+- Fixed issue with [CoreDNS](https://coredns.io/) configuration. Previously, it could only resolve from the host DNS.
+- Fixed incorrect validation schema for jobs in [Redis Insight](https://redis.io/docs/latest/develop/connect/insight/).
+- The pipeline advanced settings were missing when downloading the pipeline from RDI but this is now fixed.
+
+## Limitations
+
+- RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+- RDI write-behind (which is currently in preview) should not be used on the same data set that RDI ingest is writing to Redis. This would either cause an infinite loop or would harm the data integrity, since both ingest and write-behind are asynchronous, eventually-consistent processes.
+---
+Title: Redis Data Integration release notes 1.6.1 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.1 (March 2025)
+toc: 'true'
+weight: 991
+---
+
+> This release replaces the 1.6.0 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Fixed missing metrics and incorrect status for SQL Server.
+- Improved Redis Insight autocomplete using schema description property.
+- Restricted Redis connections to targets and non-Redis connections to sources.
+- Enhanced scaffolded `config.yaml` with examples for each database type.
+- VM Installer: Captured output of all sub-processes.
+- Improved error message for critical errors when sending commands to Redis cluster fails.
+- Fixed issue where pipeline status did not return to streaming after stopping and starting.
+- Added RDI API logging, validation examples, and bug fixes.
+- Disabled strict parsing of collector application properties to allow overriding.
+- Fixed HTTP 500 error in `GET /pipelines/sources/{source}/columns` when passing tables parameter.
+- VM setup: Fixed incorrect output status and incomplete upgrades in `upgrade.sh` script.
+- Ensured `collector-api` service force upgrades when `Operator` restarts.
+- Corrected typos in CLI option help messages.
+- Generated and published [API reference page]({{< relref "/integrate/redis-data-integration/reference/api-reference" >}}).
+- Resolved error in `collector-api` when Source secret contains special characters.
+- Fixed RDI 1.6.0 installation failure for HA due to `rdi-operator` deployment timeout.
+- Added support for downloading Debezium image from a private registry.
+- VM Installer now supports Ubuntu 22.04 and Ubuntu 24.04.
+- Resolved performance degradation in 1.6.0 that caused the initial sync to be 3-5 times slower.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.6.5 (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.6.5 (April 2025)
+toc: 'true'
+weight: 987
+---
+
+> This maintenance release replaces the 1.6.4 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Vulnerabilities: Resolve vulnerabilities in the `collector-api` component.
+  - CVE-2025-27363
+  - CVE-2021-23336
+  - CVE-2025-27113
+  - CVE-2024-52533
+  - CVE-2025-1632
+  - CVE-2024-47535
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.4.3 (December 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Installation on Kubernetes with a Helm chart. Improvements for installation on VMs.
+linkTitle: 1.4.3 (December 2024)
+toc: 'true'
+weight: 994
+---
+
+> This maintenance release replaces the 1.4.2 release.
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a [_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient and fast data structures that match your app's requirements. You specify the transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+-   Installation on [Kubernetes]({{< relref "/integrate/redis-data-integration/installation/install-k8s" >}}) using a [Helm chart](https://helm.sh/docs/). You can install on [OpenShift](https://docs.openshift.com/) or other flavours of K8s using Helm.
+
+- Improvements for installation on VMs:
+	- Installer checks if the OS firewall is enabled on Ubuntu and RHEL.
+	- Installer verifies DNS resolution from RDI components.
+	- Installer provides log lines from components that failed during RDI deployment if a problem occurs.
+	- Improved verification of RDI installation.
+	- Installer verifies if the RDI database is in use by another instance of RDI.
+	- Installer checks and warns if any [`iptables`](https://www.netfilter.org/projects/iptables/index.html) rules are set.
+	- Improved message when RDI tries to connect to its Redis database with invalid TLS keys.
+
+## Issues fixed
+
+- **RDSC-2963**: Helm chart `rdiSysSecret` does not create an empty secret if you are not using a password.
+- **RDSC-2729**: Use Debezium Server 2.7.3 and remove Prometheus.
+- **RDSC-2333**: Ensure the installer creates the context file correctly.
+- **RDSC-2806**: Remove incorrectly created deployment.
+- **RDSC-2729**: Fix `processors` `null` instead of `{}`.
+- **RDSC-2905**: Fix DNS check with multiple IP addresses.
+- **RDSC-2845**: RDI Helm chart release is set with `tag: 0.0.0`, but this should be the current release.
+
+## Limitations
+
+RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+---
+Title: Redis Data Integration release notes 1.0 (June 2024)
+alwaysopen: false
+aliases: /integrate/redis-data-integration/ingest/release-notes/rdi-1-0/
+categories:
+- docs
+- operate
+- rs
+description: Changes to the processing mode. Simple installation. Silent installation. Pipeline orchestration. Logging. Monitoring. High availability mechanism.
+linkTitle: 1.0 (June 2024)
+toc: 'true'
+weight: 1000
+---
+
+This is the first General Availability version of Redis Data Integration (RDI).
+
+RDI’s mission is to help Redis customers sync Redis Enterprise with live data from their slow disk-based databases to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+RDI keeps the Redis cache up to date with changes in the primary database, using a
+[_Change Data Capture (CDC)_](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you _transform_ the data from relational tables into convenient
+and fast data structures that match your app's requirements. You specify the
+transformations using a configuration system, so no coding is required.
+
+## Headlines
+
+- Changes to the processing mode: The preview versions of RDI processed data inside the Redis Enterprise database using the shard CPU. The GA version moves the processing of data outside the cluster. RDI is now deployed on VMs or on Kubernetes (K8s).
+- Simple installation: RDI ships with all of its dependencies. A simple interactive installer provides a streamlined process that takes a few minutes.
+- Silent installation: RDI can be installed by software using a script and an input file.
+- Pipeline orchestration: The preview versions of RDI required you to manually install and configure the Debezium server. In this version, we add support for source database configuration to the pipeline configuration and orchestration of all pipeline components including the Debezium server (RDI Collector).
+- Logging: All RDI component logs are now shipped to a central folder and get rotated by RDI's logging mechanism.
+- Monitoring: RDI comes with two Prometheus exporters, one For Debezium Server and one for RDI's pipeline data processing.
+- High availability mechanism: The preview versions of RDI used an external clustering dependency to provide active-passive deployment of the Debezium server. The GA version has a Redis-based built-in fail-over mechanism between an active VM and a passive VM. Kubernetes deployments rely on K8s probes that are included in RDI components.
+
+## Limitations
+
+- RDI can write data to a Redis Active-Active database. However, it doesn't support writing data to two or more Active-Active replicas. Writing data from RDI to several Active-Active replicas could easily harm data integrity as RDI is not synchronous with the source database commits.
+- RDI write-behind (which is currently in preview) should not be used on the same data set that RDI ingest is writing to Redis. This would either cause an infinite loop or would harm the data integrity, since both ingest and write-behind are asynchronous, eventually-consistent processes.---
+Title: Release notes
+aliases: /integrate/redis-data-integration/ingest/release-notes/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+hideListLinks: true
+linkTitle: Release notes
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 100
+---
+
+Here's what changed recently in Redis Data Integration (RDI):
+
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Preview version
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes where to view the preview version for RDI products
+linkTitle: Preview
+weight: 999
+---
+
+RDI is now in general availability but you can still access an
+[archived version of the docs for the preview version](https://docs.redis.com/rdi-preview/rdi/)
+if you need to refer to them. Note that these docs will not be updated and
+information in the current docs supersedes the content of the preview docs.
+
+There is also another RDI product, **Write-behind**, that is still in preview.
+See the [Write-behind]({{< relref "/integrate/write-behind" >}}) docs for
+more information.
+---
+Title: Deploy a pipeline
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/data-type-handling/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to deploy an RDI pipeline
+group: di
+linkTitle: Deploy
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+The sections below explain how to deploy a pipeline after you have created the required
+[configuration]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}}).
+
+## Set secrets
+
+Before you deploy your pipeline, you must set the authentication secrets for the
+source and target databases. Each secret has a name that you can pass to the
+[`redis-di set-secret`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-set-secret" >}})
+command (VM deployment) or the `rdi-secret.sh` script (K8s deployment) to set the secret value. 
+You can then refer to these secrets in the `config.yaml` file using the syntax "`${SECRET_NAME}`"
+(the sample [config.yaml file]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#the-configyaml-file" >}}) shows these secrets in use).
+
+The table below lists all valid secret names. Note that the
+username and password are required for the source and target, but the other
+secrets are only relevant for TLS/mTLS connections.
+
+| Secret name | Description |
+| :-- | :-- |
+| `SOURCE_DB_USERNAME` | Username for the source database |
+| `SOURCE_DB_PASSWORD` | Password for the source database |
+| `SOURCE_DB_CACERT` | (For TLS only) Source database CA certificate |
+| `SOURCE_DB_CERT` | (For mTLS only) Source database client certificate |
+| `SOURCE_DB_KEY` | (For mTLS only) Source database private key |
+| `SOURCE_DB_KEY_PASSWORD` | (For mTLS only) Source database private key password |
+| `TARGET_DB_USERNAME` | Username for the target database |
+| `TARGET_DB_PASSWORD` | Password for the target database |
+| `TARGET_DB_CACERT` | (For TLS only) Target database CA certificate |
+| `TARGET_DB_CERT` | (For mTLS only) Target database client certificate |
+| `TARGET_DB_KEY` | (For mTLS only) Target database private key |
+| `TARGET_DB_KEY_PASSWORD` | (For mTLS only) Target database private key password |
+
+{{< note >}}When creating secrets for TLS or mTLS, ensure that all certificates and keys are in `PEM` format. The only exception to this is that for PostgreSQL, the private key `SOURCE_DB_KEY` secret must be in `DER` format. If you have a key in `PEM` format, you must convert it to `DER` before creating the `SOURCE_DB_KEY` secret using the command:
+
+```bash
+openssl pkcs8 -topk8 -inform PEM -outform DER -in /path/to/myclient.pem -out /path/to/myclient.pk8 -nocrypt
+```
+
+This command assumes that the private key is not encrypted. See the [`openssl` documentation](https://docs.openssl.org/master/) to learn how to convert an encrypted private key.
+{{< /note >}}
+  
+### Set secrets for VM deployment
+
+Use [`redis-di set-secret`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-set-secret" >}})
+to set secrets for a VM deployment. 
+
+The specific command lines for source secrets are as follows:
+
+```bash
+# For username and password
+redis-di set-secret SOURCE_DB_USERNAME yourUsername
+redis-di set-secret SOURCE_DB_PASSWORD yourPassword
+
+# With source TLS, in addition to the above
+redis-di set-secret SOURCE_DB_CACERT /path/to/myca.crt
+
+# With source mTLS, in addition to the above
+redis-di set-secret SOURCE_DB_CERT /path/to/myclient.crt
+redis-di set-secret SOURCE_DB_KEY /path/to/myclient.key
+# Use this only if SOURCE_DB_KEY is password-protected
+redis-di set-secret SOURCE_DB_KEY_PASSWORD yourKeyPassword 
+```
+
+The corresponding command lines for target secrets are:
+
+```bash
+# For username and password
+redis-di set-secret TARGET_DB_USERNAME yourUsername
+redis-di set-secret TARGET_DB_PASSWORD yourPassword
+
+# With target TLS, in addition to the above
+redis-di set-secret TARGET_DB_CACERT /path/to/myca.crt
+
+# With target mTLS, in addition to the above
+redis-di set-secret TARGET_DB_CERT /path/to/myclient.crt
+redis-di set-secret TARGET_DB_KEY /path/to/myclient.key
+# Use this only if TARGET_DB_KEY is password-protected
+redis-di set-secret TARGET_DB_KEY_PASSWORD yourKeyPassword
+```
+
+### Set secrets for K8s/Helm deployment using the rdi-secret.sh script
+
+Use the `rdi-secret.sh` script to set secrets for a K8s/Helm deployment. To use this script, unzip the archive that contains the RDI Helm chart and navigate to the resulting folder. The `rdi-secret.sh` script is located in the `scripts` subfolder. The general pattern for using this script is:
+
+```bash
+scripts/rdi-secret.sh set <SECRET-NAME> <SECRET-VALUE>
+```
+
+The script also lets you retrieve a specific secret or list all the secrets that have been set:
+
+```bash
+# Get specific secret
+scripts/rdi-secret.sh get <SECRET-NAME>
+
+# List all secrets
+scripts/rdi-secret.sh list
+```
+
+The specific command lines for source secrets are as follows:
+
+```bash
+# For username and password
+scripts/rdi-secret.sh set SOURCE_DB_USERNAME yourUsername
+scripts/rdi-secret.sh set SOURCE_DB_PASSWORD yourPassword
+
+# With source TLS, in addition to the above
+scripts/rdi-secret.sh set SOURCE_DB_CACERT /path/to/myca.crt
+
+# With source mTLS, in addition to the above
+scripts/rdi-secret.sh set SOURCE_DB_CERT /path/to/myclient.crt
+scripts/rdi-secret.sh set SOURCE_DB_KEY /path/to/myclient.key
+# Use this only if SOURCE_DB_KEY is password-protected
+scripts/rdi-secret.sh set SOURCE_DB_KEY_PASSWORD yourKeyPassword 
+```
+
+The corresponding command lines for target secrets are:
+
+```bash
+# For username and password
+scripts/rdi-secret.sh set TARGET_DB_USERNAME yourUsername
+scripts/rdi-secret.sh set TARGET_DB_PASSWORD yourPassword
+
+# With target TLS, in addition to the above
+scripts/rdi-secret.sh set TARGET_DB_CACERT /path/to/myca.crt
+
+# With target mTLS, in addition to the above
+scripts/rdi-secret.sh set TARGET_DB_CERT /path/to/myclient.crt
+scripts/rdi-secret.sh set TARGET_DB_KEY /path/to/myclient.key
+# Use this only if TARGET_DB_KEY is password-protected
+scripts/rdi-secret.sh set TARGET_DB_KEY_PASSWORD yourKeyPassword
+```
+
+### Set secrets for K8s/Helm deployment using Kubectl command
+
+In some scenarios, you may prefer to use [`kubectl create secret generic`](https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_secret_generic/)
+to set secrets for a K8s/Helm deployment. The general pattern of the commands is:
+
+```bash
+kubectl create secret generic <DB> \
+--namespace=rdi \
+--from-literal=<SECRET-NAME>=<SECRET-VALUE>
+```
+
+Where `<DB>` is either `source-db` for source secrets or `target-db` for target secrets.
+
+If you use TLS or mTLS for either the source or target databases, you also need to create the `source-db-ssl` and/or `target-db-ssl` K8s secrets that contain the certificates used to establish secure connections. The general pattern of the commands is:
+
+```bash
+kubectl create secret generic <DB>-ssl \
+--namespace=rdi \
+--from-file=<FILE-NAME>=<FILE-PATH>
+```
+
+The specific command lines for source secrets are as follows:
+
+```bash
+# Without source TLS
+# Create or update source-db secret
+kubectl create secret generic source-db --namespace=rdi \
+--from-literal=SOURCE_DB_USERNAME=yourUsername \
+--from-literal=SOURCE_DB_PASSWORD=yourPassword \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+
+# With source TLS
+# Create of update source-db secret
+kubectl create secret generic source-db --namespace=rdi \
+--from-literal=SOURCE_DB_USERNAME=yourUsername \
+--from-literal=SOURCE_DB_PASSWORD=yourPassword \
+--from-literal=SOURCE_DB_CACERT=/etc/certificates/source_db/ca.crt \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+# Create or update source-db-ssl secret
+kubectl create secret generic source-db-ssl --namespace=rdi \
+--from-file=ca.crt=/path/to/myca.crt \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+
+# With source mTLS
+# Create or update source-db secret
+kubectl create secret generic source-db --namespace=rdi \
+--from-literal=SOURCE_DB_USERNAME=yourUsername \
+--from-literal=SOURCE_DB_PASSWORD=yourPassword \
+--from-literal=SOURCE_DB_CACERT=/etc/certificates/source_db/ca.crt \
+--from-literal=SOURCE_DB_CERT=/etc/certificates/source_db/client.crt \
+--from-literal=SOURCE_DB_KEY=/etc/certificates/source_db/client.key \
+--from-literal=SOURCE_DB_KEY_PASSWORD=yourKeyPassword \ # add this only if SOURCE_DB_KEY is password-protected
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+# Create or update source-db-ssl secret
+kubectl create secret generic source-db-ssl --namespace=rdi \
+--from-file=ca.crt=/path/to/myca.crt \
+--from-file=client.crt=/path/to/myclient.crt \
+--from-file=client.key=/path/to/myclient.key \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+```
+
+The corresponding command lines for target secrets are:
+
+```bash
+# Without target TLS
+# Create or update target-db secret
+kubectl create secret generic target-db --namespace=rdi \
+--from-literal=TARGET_DB_USERNAME=yourUsername \
+--from-literal=TARGET_DB_PASSWORD=yourPassword \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+
+# With target TLS
+# Create of update target-db secret
+kubectl create secret generic target-db --namespace=rdi \
+--from-literal=TARGET_DB_USERNAME=yourUsername \
+--from-literal=TARGET_DB_PASSWORD=yourPassword \
+--from-literal=TARGET_DB_CACERT=/etc/certificates/target_db/ca.crt \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+# Create or update target-db-ssl secret
+kubectl create secret generic target-db-ssl --namespace=rdi \
+--from-file=ca.crt=/path/to/myca.crt \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+
+# With target mTLS
+# Create or update target-db secret
+kubectl create secret generic target-db --namespace=rdi \
+--from-literal=TARGET_DB_USERNAME=yourUsername \
+--from-literal=TARGET_DB_PASSWORD=yourPassword \
+--from-literal=TARGET_DB_CACERT=/etc/certificates/target_db/ca.crt \
+--from-literal=TARGET_DB_CERT=/etc/certificates/target_db/client.crt \
+--from-literal=TARGET_DB_KEY=/etc/certificates/target_db/client.key \
+--from-literal=TARGET_DB_KEY_PASSWORD=yourKeyPassword \ # add this only if TARGET_DB_KEY is password-protected
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+# Create or update target-db-ssl secret
+kubectl create secret generic target-db-ssl --namespace=rdi \
+--from-file=ca.crt=/path/to/myca.crt \
+--from-file=client.crt=/path/to/myclient.crt \
+--from-file=client.key=/path/to/myclient.key \
+--save-config --dry-run=client -o yaml | kubectl apply -f -
+```
+
+Note that the certificate paths contained in the secrets `SOURCE_DB_CACERT`, `SOURCE_DB_CERT`, and `SOURCE_DB_KEY` (for the source database) and `TARGET_DB_CACERT`, `TARGET_DB_CERT`, and `TARGET_DB_KEY` (for the target database) are internal to RDI, so you *must* use the values shown in the example above. You should only change the certificate paths when you create the `source-db-ssl` and `target-db-ssl` secrets.
+
+## Deploy a pipeline
+
+When you have created your configuration, including the [jobs]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#job-files" >}}), you are
+ready to deploy. Use [Redis Insight]({{< relref "/develop/tools/insight/rdi-connector" >}})
+to configure and deploy pipelines for both VM and K8s installations.
+
+For VM installations, you can also use the
+[`redis-di deploy`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-deploy" >}})
+command to deploy a pipeline:
+
+```bash
+redis-di deploy --dir <path to pipeline folder>
+```---
+Title: Data type handling
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/data-type-handling/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how relational data types are converted to Redis data types
+group: di
+linkTitle: Data type handling
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 20
+---
+
+RDI automatically converts data that has a Debezium JSON schema into Redis types.
+Some Debezium types require special conversion. For example:
+
+- Date and Time types are converted to epoch time.
+- Decimal numeric types are converted to strings so your app can use them
+  without losing precision.
+
+The following Debezium logical types are supported:
+
+- double
+- float
+- io.debezium.data.Bits
+- io.debezium.data.Json
+- io.debezium.data.VariableScaleDecimal
+- io.debezium.time.Date
+- io.debezium.time.NanoTime
+- io.debezium.time.NanoTimestamp
+- io.debezium.time.MicroTime
+- io.debezium.time.MicroTimestamp
+- io.debezium.time.ZonedTime
+- io.debezium.time.ZonedTimestamp
+- org.apache.kafka.connect.data.Date
+- org.apache.kafka.connect.data.Decimal
+- org.apache.kafka.connect.data.Time
+
+These types are **not** supported and will return "Unsupported Error":
+
+- io.debezium.time.interval
+
+All other values are treated as plain strings.
+---
+Title: Prepare AWS Aurora and PostgreSQL for RDI
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/my-sql-mariadb/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Prepare AWS Aurora/PostgreSQL databases to work with RDI
+group: di
+linkTitle: Prepare AWS Aurora/PostgreSQL
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 5
+---
+
+Follow the steps in the sections below to prepare an
+[AWS Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.html)
+database to work with RDI.
+
+## 1. Create a parameter group
+
+In the [Relational Database Service (RDS) console](https://console.aws.amazon.com/rds/),
+navigate to **Parameter groups > Create parameter group**. You will see the panel shown
+below:
+
+{{<image filename="images/rdi/ingest/prepsrc/aurora-pgsql/CreateParamGroup.webp" alt="Create parameter group panel" >}}
+
+Enter the following information:
+
+| Name | Value |
+| :-- | :-- |
+| **Parameter group name**  | rdi-aurora-pg |
+| **Description**  | Enable logical replication for RDI |
+| **Engine Type**  | Aurora PostgreSQL |
+| **Parameter group family**  | aurora-postgresql15 |
+| **Type**  | DB Cluster Parameter Group |
+
+Select **Create** to create the parameter group.
+
+## 2. Edit the parameter group
+
+Navigate to **Parameter groups** in the console. Select the `rdi-aurora-pg`
+group you have just created and then select **Edit** . You will see this panel:
+
+{{<image filename="images/rdi/ingest/prepsrc/aurora-pgsql/EditParamGroup.webp" alt="Edit parameter group panel" >}}
+
+Search for the `rds.logical_replication` parameter and set its value to 1. Then,
+select **Save Changes**.
+
+## 3. Select the new parameter group
+
+Go back to your target database on the RDS console, select **Modify** and then
+scroll down to **Additional Configuration**. Set
+the **DB Cluster Parameter Group** to the value `rdi-aurora-pg` that you have just added:
+
+{{<image filename="images/rdi/ingest/prepsrc/aurora-pgsql/CreateDB6.webp" alt="Additional Configuration panel" >}}
+---
+Title: Prepare MySQL/MariaDB for RDI
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/my-sql-mariadb/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Prepare MySQL and MariaDB databases to work with RDI
+group: di
+linkTitle: Prepare MySQL/MariaDB
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+Follow the steps in the sections below to set up a MySQL or MariaDB
+database for CDC with Debezium.
+
+## 1. Create a CDC user
+
+The Debezium connector needs a user account to connect to MySQL/MariaDB. This
+user must have appropriate permissions on all databases where you want Debezium
+to capture changes.
+
+Run the [MySQL CLI client](https://dev.mysql.com/doc/refman/8.3/en/mysql.html)
+and then run the following commands:
+
+1.  Create the CDC user:
+
+    ```sql
+    mysql> CREATE USER 'user'@'localhost' IDENTIFIED BY 'password';
+    ```
+
+1.  Grant the required permissions to the user:
+
+    ```sql
+    # MySQL <v8.0
+    mysql> GRANT SELECT, RELOAD, SHOW DATABASES, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'user' IDENTIFIED BY 'password';
+
+    # MySQL v8.0 and above
+    mysql> GRANT SELECT, RELOAD, SHOW DATABASES, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'user'@'localhost';
+    ```
+
+1.  Finalize the user's permissions:
+
+    ```sql
+    mysql> FLUSH PRIVILEGES;
+    ```
+
+## 2. Enable the binlog
+
+You must enable binary logging for MySQL replication. The binary logs record transaction
+updates so that replication tools can propagate changes. You will need administrator
+privileges to do this.
+
+First, you should check whether the `log-bin` option is already set to `ON`, using
+the following query:
+
+```sql
+// for MySql 5.x
+mysql> SELECT variable_value as "BINARY LOGGING STATUS (log-bin) ::"
+FROM information_schema.global_variables WHERE variable_name='log_bin';
+// for MySql 8.x
+mysql> SELECT variable_value as "BINARY LOGGING STATUS (log-bin) ::"
+FROM performance_schema.global_variables WHERE variable_name='log_bin';
+```
+
+If `log-bin` is `OFF` then add the following properties to your
+server configuration file:
+
+```
+server-id         = 223344 # Querying variable is called server_id, e.g. SELECT variable_value FROM information_schema.global_variables WHERE variable_name='server_id';
+log_bin                     = mysql-bin
+binlog_format               = ROW
+binlog_row_image            = FULL
+binlog_expire_logs_seconds  = 864000
+```
+
+You can run the query above again to check that `log-bin` is now `ON`.
+
+{{< note >}}If you are using [Amazon RDS for MySQL](https://aws.amazon.com/rds/mysql/) then
+you must enable automated backups for your database before it can use binary logging.
+If you don't enable automated backups first then the settings above will have no
+effect.{{< /note >}}
+
+## 3. Enable GTIDs
+
+*Global transaction identifiers (GTIDs)* uniquely identify the transactions that occur
+on a server within a cluster. You don't strictly need to use them with a Debezium MySQL
+connector, but you might find it helpful to enable them.
+Use GTIDs to simplify replication and to confirm that the primary and replica servers are
+consistent.
+
+GTIDs are available in MySQL 5.6.5 and later. See the
+[MySQL documentation about GTIDs](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#option_mysqld_gtid-mode) for more information.
+
+Follow the steps below to enable GTIDs. You will need access to the MySQL configuration file
+to do this.
+
+1.  Enable `gtid_mode`:
+
+    ```sql
+    mysql> gtid_mode=ON
+    ```
+
+1.  Enable `enforce_gtid_consistency`:
+
+    ```sql
+    mysql> enforce_gtid_consistency=ON
+    ```
+
+1.  Confirm the changes:
+
+    ```sql
+    mysql> show global variables like '%GTID%';
+    
+    >>> Result:
+
+    +--------------------------+-------+
+    | Variable_name            | Value |
+    +--------------------------+-------+
+    | enforce_gtid_consistency | ON    |
+    | gtid_mode                | ON    |
+    +--------------------------+-------+
+    ```
+
+## 4. Configure session timeouts
+
+RDI captures an initial *snapshot* of the source database when it begins
+the CDC process (see the
+[architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}})
+for more information). If your database is large then the connection could time out
+while RDI is reading the data for the snapshot. You can prevent this using the
+`interactive_timeout` and `wait_timeout` settings in your MySQL configuration file:
+
+```
+mysql> interactive_timeout=<duration-in-seconds>
+mysql> wait_timeout=<duration-in-seconds>
+```
+
+## 5. Enable query log events
+
+If you want to see the original SQL statement for each binlog event then you should
+enable `binlog_rows_query_log_events` (MySQL configuration) or
+`binlog_annotate_row_events` (MariaDB configuration):
+
+```
+mysql> binlog_rows_query_log_events=ON
+
+mariadb> binlog_annotate_row_events=ON
+```
+
+This option is available in MySQL 5.6 and later.
+
+## 6. Check `binlog_row_value_options`
+
+You should check the value of the `binlog_row_value_options` variable
+to ensure it is not set to `PARTIAL_JSON`. If it *is* set to
+`PARTIAL_JSON` then Debezium might not be able to see `UPDATE` events.
+
+Check the current value of the variable with the following command:
+
+```sql
+mysql> show global variables where variable_name = 'binlog_row_value_options';
+
+>>> Result:
+
++--------------------------+-------+
+| Variable_name            | Value |
++--------------------------+-------+
+| binlog_row_value_options |       |
++--------------------------+-------+
+```
+
+If the value is `PARTIAL_JSON` then you should unset the variable:
+
+```sql
+mysql> set @@global.binlog_row_value_options="" ;
+```
+
+## 7. Configuration is complete
+
+After following the steps above, your MySQL/MariaDB database is ready
+for Debezium to use.
+---
+Title: Prepare Oracle and Oracle RAC for RDI
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/oracle/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Prepare Oracle and Oracle RAC databases to work with RDI
+group: di
+linkTitle: Prepare Oracle
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 1
+---
+
+The Oracle Debezium connector uses
+[Oracle LogMiner](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-logminer-utility.html)
+to get data from the commitlog to a view inside the database. Follow the
+steps below to configure LogMiner and prepare your database for use with
+RDI.
+
+## 1. Configure Oracle LogMiner
+
+The following example shows the configuration for Oracle LogMiner.
+
+{{< note >}}[Amazon RDS for Oracle](https://aws.amazon.com/rds/oracle/)
+doesn't let you execute the commands
+in the example below or let you log in as `sysdba`. See the
+separate example below to [configure Amazon RDS for Oracle](#config-aws).
+{{< /note >}}
+
+```sql
+ORACLE_SID=ORACLCDB dbz_oracle sqlplus /nolog
+
+CONNECT sys/top_secret AS SYSDBA
+alter system set db_recovery_file_dest_size = 10G;
+alter system set db_recovery_file_dest = '/opt/oracle/oradata/recovery_area' scope=spfile;
+shutdown immediate
+startup mount
+alter database archivelog;
+alter database open;
+-- You should now see "Database log mode: Archive Mode"
+archive log list
+
+exit;
+```
+
+### Configure Amazon RDS for Oracle {#config-aws}
+
+AWS provides its own set of commands to configure LogMiner.
+
+{{< note >}}Before executing these commands,
+you must enable backups on your Oracle AWS RDS instance.
+{{< /note >}}
+
+Check that Oracle has backups enabled with the following command:
+
+```sql
+SQL> SELECT LOG_MODE FROM V$DATABASE;
+
+LOG_MODE
+------------
+ARCHIVELOG
+```
+
+The `LOG_MODE` should be set to `ARCHIVELOG`. If it isn't then you
+should reboot your Oracle AWS RDS instance.
+
+Once `LOG_MODE` is correctly set to ARCHIVELOG, execute the following
+commands to complete the LogMiner configuration. The first command enables
+archive logging and the second adds [supplemental logging](#supp-logging).
+
+```sql
+exec rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours',24);
+exec rdsadmin.rdsadmin_util.alter_supplemental_logging('ADD');
+```
+
+## 2. Enable supplemental logging {#supp-logging}
+
+You must enable supplemental logging for the tables you want to capture or
+for the entire database. This lets Debezium capture the state of
+database rows before and after changes occur. 
+
+The following example shows how to configure supplemental logging for all columns
+in a single table called `inventory.customers`:
+
+```sql
+ALTER TABLE inventory.customers ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;
+```
+
+{{< note >}}If you enable supplemental logging for *all* table columns, you will
+probably see the size of the Oracle redo logs increase dramatically. Avoid this
+by using supplemental logging only when you need it. {{< /note >}} 
+
+You must also enable minimal supplemental logging at the database level with
+the following command:
+
+```sql
+ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
+```
+
+## 3. Check the redo log sizing
+
+Before you use the Debezium connector, you should check with your
+database administrator that there are enough
+redo logs with enough capacity to store the data dictionary for your
+database. In general, the size of the data dictionary increases with the number
+of tables and columns in the database. If you don't have enough capacity in
+the logs then you might see performance problems with both the database and
+the Debezium connector.
+
+## 4. Set the Archive log destination
+
+You can configure up to 31 different destinations for archive logs
+(you must have administrator privileges to do this). You can set parameters for
+each destination to specify its purpose, such as log shipping for physical
+standbys, or external storage to allow for extended log retention. Oracle reports
+details about archive log destinations in the `V$ARCHIVE_DEST_STATUS` view.
+
+The Debezium Oracle connector only uses destinations that have a status of
+`VALID` and a type of `LOCAL`. If you only have one destination with these
+settings then Debezium will use it automatically.
+If you have more than one destination with these settings,
+then you should consult your database administrator about which one to
+choose for Debezium.
+
+Use the `log.mining.archive.destination.name` property in the connector configuration
+to select the archive log destination for Debezium.
+
+For example, suppose you have two archive destinations, `LOG_ARCHIVE_DEST_2` and
+`LOG_ARCHIVE_DEST_3`, and they both have status set to `VALID` and type set to
+`LOCAL`. Debezium could use either of these destinations, so you must select one
+of them explicitly in the configuration. To select `LOG_ARCHIVE_DEST_3`, you would
+use the following setting:
+
+```json
+{
+    "log.mining.archive.destination.name": "LOG_ARCHIVE_DEST_3"
+}
+```
+
+## 5. Create a user for the connector {#create-dbz-user}
+
+The Debezium Oracle connector must run as an Oracle LogMiner user with
+specific permissions. The following example shows some SQL that creates
+an Oracle user account for the connector in a multi-tenant database model:
+
+```sql
+sqlplus sys/top_secret@//localhost:1521/ORCLCDB as sysdba
+CREATE TABLESPACE logminer_tbs DATAFILE '/opt/oracle/oradata/ORCLCDB/logminer_tbs.dbf'
+    SIZE 25M REUSE AUTOEXTEND ON MAXSIZE UNLIMITED;
+exit;
+
+sqlplus sys/top_secret@//localhost:1521/ORCLPDB1 as sysdba
+CREATE TABLESPACE logminer_tbs DATAFILE '/opt/oracle/oradata/ORCLCDB/ORCLPDB1/logminer_tbs.dbf'
+    SIZE 25M REUSE AUTOEXTEND ON MAXSIZE UNLIMITED;
+exit;
+
+sqlplus sys/top_secret@//localhost:1521/ORCLCDB as sysdba
+
+CREATE USER c##dbzuser IDENTIFIED BY dbz
+    DEFAULT TABLESPACE logminer_tbs
+    QUOTA UNLIMITED ON logminer_tbs
+    CONTAINER=ALL;
+
+GRANT CREATE SESSION TO c##dbzuser CONTAINER=ALL;
+GRANT SET CONTAINER TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$DATABASE to c##dbzuser CONTAINER=ALL;
+
+-- See `Limiting privileges` below if the privileges
+-- granted by these two commands raise security concerns.
+GRANT FLASHBACK ANY TABLE TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ANY TABLE TO c##dbzuser CONTAINER=ALL;
+-- 
+
+GRANT SELECT_CATALOG_ROLE TO c##dbzuser CONTAINER=ALL;
+GRANT EXECUTE_CATALOG_ROLE TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ANY TRANSACTION TO c##dbzuser CONTAINER=ALL;
+GRANT LOGMINING TO c##dbzuser CONTAINER=ALL;
+
+-- See `Limiting privileges` below if the privileges
+-- granted by these two commands raise security concerns.
+GRANT CREATE TABLE TO c##dbzuser CONTAINER=ALL;
+GRANT LOCK ANY TABLE TO c##dbzuser CONTAINER=ALL;
+-- 
+
+GRANT CREATE SEQUENCE TO c##dbzuser CONTAINER=ALL;
+
+GRANT EXECUTE ON DBMS_LOGMNR TO c##dbzuser CONTAINER=ALL;
+GRANT EXECUTE ON DBMS_LOGMNR_D TO c##dbzuser CONTAINER=ALL;
+
+GRANT SELECT ON V_$LOG TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$LOG_HISTORY TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$LOGMNR_LOGS TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$LOGMNR_CONTENTS TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$LOGMNR_PARAMETERS TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$LOGFILE TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$ARCHIVED_LOG TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$ARCHIVE_DEST_STATUS TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$TRANSACTION TO c##dbzuser CONTAINER=ALL;
+
+GRANT SELECT ON V_$MYSTAT TO c##dbzuser CONTAINER=ALL;
+GRANT SELECT ON V_$STATNAME TO c##dbzuser CONTAINER=ALL;
+
+exit;
+```
+
+### Limiting privileges
+
+The privileges granted in the example above are convenient,
+but you may prefer to restrict them further to improve security. In particular,
+you might want to prevent the Debezium user from creating tables, or
+selecting or locking any table.
+
+The Debezium user needs the `CREATE TABLE` privilege to create the
+`LOG_MINING_FLUSH` table when it connects for the first
+time. After this point, it doesn't need to create any more tables,
+so you can safely revoke this privilege with the following command:
+
+```sql
+REVOKE CREATE TABLE FROM c##dbzuser container=all;
+```
+
+[The example above](#create-dbz-user) grants the `SELECT ANY TABLE` and
+`FLASHBACK ANY TABLE` privileges for convenience, but only the tables synced to RDI
+and the `V_$XXX` tables strictly need these privileges.
+You can replace the `GRANT SELECT ANY TABLE` command with explicit
+commands for each table. For example, you would use commands like the
+following for the tables in our sample
+[`chinook`](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres)
+database. (Note that Oracle 19c requires you to run a separate `GRANT`
+command for each table individually.)
+
+```sql
+GRANT SELECT ON chinook.album TO c##dbzuser;
+GRANT SELECT ON chinook.artist TO c##dbzuser;
+GRANT SELECT ON chinook.customer TO c##dbzuser;
+...
+```
+
+Similarly, instead of `GRANT FLASHBACK ANY TABLE`, you would use the following
+commands:
+
+```sql
+GRANT FLASHBACK ON chinook.album TO c##dbzuser;
+GRANT FLASHBACK ON chinook.artist TO c##dbzuser;
+GRANT FLASHBACK ON chinook.customer TO c##dbzuser;
+...
+```
+
+The `LOCK` privilege is automatically granted by the `SELECT`
+privilege, so you can omit this command if you have granted `SELECT`
+on specific tables.
+
+### Revoking existing privileges
+
+If you initially set the Debezium user's privileges on all tables,
+but you now want to restrict them, you can revoke the existing
+privileges before resetting them as described in the
+[Limiting privileges](#limiting-privileges) section.
+
+Use the following commands to revoke and reset the `SELECT` privileges:
+
+```sql
+REVOKE SELECT ANY TABLE FROM c##dbzuser container=all;
+ALTER SESSION SET container=orclpdb1;
+
+GRANT SELECT ON chinook.album TO c##dbzuser;
+-- ...etc
+```
+
+The equivalent commands for `FLASHBACK` are:
+
+```sql
+REVOKE FLASHBACK ANY TABLE FROM c##dbzuser container=all;
+ALTER SESSION SET container=orclpdb1;
+GRANT FLASHBACK ON chinook.album TO c##dbzuser;
+```
+
+The `SELECT` privilege automatically includes the `LOCK`
+privilege, so when you grant `SELECT` for specific tables
+you should also revoke `LOCK` on all tables:
+
+```sql
+REVOKE LOCK ANY TABLE FROM c##dbzuser container=all;
+```
+
+## 6. Configuration is complete
+
+Once you have followed the steps above, your Oracle database is ready
+for Debezium to use.
+---
+Title: Prepare PostgreSQL for RDI
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/postgresql/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Prepare PostgreSQL databases to work with RDI
+group: di
+linkTitle: Prepare PostgreSQL
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+PostgreSQL supports several
+[logical decoding plug-ins](https://wiki.postgresql.org/wiki/Logical_Decoding_Plugins)
+to enable CDC. If you don't want to use the native `pgoutput` logical replication stream support
+then you must install your preferred plug-in into the PostgreSQL server. Once you have done this,
+you must enable a replication slot, and configure a user with privileges to perform the replication.
+
+If you are using a service like [Heroku Postgres](https://www.heroku.com/postgres) to host
+your database then this might restrict the plug-ins you can use. If you can't use your preferred
+plug-in then could try the `pgoutput` decoder if you are using PostgreSQL 10 or above.
+If this doesn't work for you then you won't be able to use RDI with your database.
+
+### Amazon RDS for PostgreSQL
+
+Follow the steps below to enable CDC with [Amazon RDS for PostgreSQL](https://aws.amazon.com/rds/postgresql/):
+
+1.  Set the instance parameter `rds.logical_replication` to 1.
+
+1.  Check that the `wal_level` parameter is set to `logical` by running the query `SHOW wal_level`
+    as the database RDS master user. The parameter might not have this value in multi-zone replication
+    setups. You can't change the value manually but it should change automatically when you set the
+    `rds.logical_replication` parameter to 1. If it doesn't change then you probably just need to
+    restart your database instance. You can restart manually or wait until a restart occurs
+    during your maintenance window.
+
+1.  Set the Debezium `plugin.name` parameter to `pgoutput`.
+
+1.  Initiate logical replication from an AWS account that has the `rds_replication` role. The role grants
+    permissions to manage logical slots and to stream data using logical slots. By default, only the master user account on AWS has the `rds_replication` role on Amazon RDS, but if you have administrator privileges,
+    you can grant the role to other accounts using a query like the following:
+
+    ```sql
+    GRANT rds_replication TO <my_user>
+    ```
+
+    To enable accounts other than the master account to create an initial snapshot, you must grant `SELECT`
+    permission to the accounts on the tables to be captured. See the documentation about
+    [security for PostgreSQL logical replication](https://www.postgresql.org/docs/current/logical-replication-security.html)
+    for more information.
+
+## Install the logical decoding output plug-in
+
+As of PostgreSQL 9.4, the only way to read changes to the write-ahead-log is to
+[install a logical decoding output plug-in](https://debezium.io/documentation/reference/2.6/postgres-plugins.html).
+These plug-ins are written in C using PostgreSQL-specific APIs, as described in the
+[PostgreSQL documentation](https://www.postgresql.org/docs/current/logicaldecoding-output-plugin.html). 
+The PostgreSQL connector uses one of Debezium’s supported logical decoding
+plug-ins to receive change events from the database in either the default
+[`pgoutput`](https://github.com/postgres/postgres/blob/master/src/backend/replication/pgoutput/pgoutput.c) format (supplied with PostgreSQL) or the
+[`Protobuf`](https://github.com/protocolbuffers/protobuf) format. 
+See the
+[decoderbufs Protobuf plug-in documentation](https://github.com/debezium/postgres-decoderbufs)
+for more details about how to compile it and also its requirements and limitations.
+
+For simplicity, Debezium also provides a container image that compiles and installs the plug-ins
+on top of the upstream PostgreSQL server image. Use this image as an example of the steps
+involved in the installation.
+
+{{< note >}} The Debezium logical decoding plug-ins have been tested on Linux machines, but if you are
+using Windows or other operating systems, the installation steps might be different from
+those listed here. {{< /note >}}
+
+### Plug-in differences
+
+Plug-ins don't all behave in exactly the same way. All of them refresh information about
+the database schema when they detect that it has changed, but the `pgoutput` plug-in is
+more "eager" than some other plug-ins to do this. For example, `pgoutput` will refresh
+when it detects a change to the default value of a column but other plug-ins won't
+notice this until another, more significant change happens (such as adding a new table
+column).
+
+The Debezium project maintains a
+[Java class](https://github.com/debezium/debezium/blob/main/debezium-connector-postgres/src/test/java/io/debezium/connector/postgresql/DecoderDifferences.java) that tracks the known differences between plug-ins.
+
+
+## Configure the PostgreSQL server
+
+If you want to use a logical decoding plug-in other than the default `pgoutput` then
+you must first configure it in the `postgresql.conf` file. Set the `shared_preload_libraries`
+parameter to load your plug-in at startup. For example, to load the `decoderbufs`
+plug-in, you would add the following line:
+
+```
+# MODULES
+shared_preload_libraries = 'decoderbufs'
+```
+
+Add the line below to configure the replication slot (for any plug-in).
+This instructs the server to use logical decoding with the write-ahead log.
+
+```
+# REPLICATION
+wal_level = logical            
+```
+
+You can also set other PostgreSQL streaming replication parameters if you need them.
+For example, you can use `max_wal_senders` and `max_replication_slots` to increase
+the number of connectors that can access the sending server concurrently,
+and `wal_keep_size` to limit the maximum WAL size that a replication slot retains.
+The
+[configuration parameters](https://www.postgresql.org/docs/current/runtime-config-replication.html#RUNTIME-CONFIG-REPLICATION-SENDER)
+documentation describes all the parameters you can use.
+
+PostgreSQL’s logical decoding uses replication slots. These are guaranteed to retain all the WAL
+segments that Debezium needs even when Debezium suffers an outage. You should monitor replication
+slots carefully to avoid excessive disk consumption and other conditions such as catalog bloat that can arise
+if a replication slot is used infrequently. See the PostgreSQL documentation about
+[replication slots](https://www.postgresql.org/docs/current/warm-standby.html#STREAMING-REPLICATION-SLOTS)
+for more information.
+If you are using a `synchronous_commit` setting other than `on`, then you should set `wal_writer_delay`
+to a value of about 10 milliseconds to ensure a low latency for change events. If you don't set this then
+the default value of about 200 milliseconds will apply.
+
+{{< note >}}This guide summarizes the operation of the PostgreSQL write-ahead log, but we strongly
+recommend you consult the [PostgreSQL write-ahead log](https://www.postgresql.org/docs/current/wal-configuration.html)
+documentation to get a better understanding.{{< /note >}}
+
+## Set up permissions
+
+The Debezium connector needs a database user that has the REPLICATION and LOGIN roles so that it
+can perform replications. By default, a superuser has these roles but for security reasons, you
+should give the minimum necessary permissions to the Debezium user rather than full superuser
+permissions.
+
+If you have administrator privileges then you can create a role for your Debezium user
+using a query like the following. Note that these are the *minimum* permissions the user
+needs to perform replications, but you might also need to grant other permissions.
+
+```sql
+CREATE ROLE <name> REPLICATION LOGIN;
+```
+
+## Set privileges for Debezium to create PostgreSQL publications with `pgoutput`
+
+The Debezium user needs specific permissions to work with the `pgoutput` plug-in.
+The plug-in captures change events from the
+[*publications*](https://www.postgresql.org/docs/current/logical-replication-publication.html)
+that PostgreSQL produces for your chosen source tables. A publication contains change events from
+one or more tables that are filtered using criteria from a *publication specification*.
+
+If you have administrator privileges, you can create the publication specification
+manually or you can grant the Debezium user the privileges to create the specification
+automatically. The required privileges are:
+
+-   Replication privileges in the database to add the table to a publication.
+-   `CREATE` privileges on the database to add publications.
+-   `SELECT` privileges on the tables to copy the initial table data. Table owners
+    automatically have `SELECT` permission for the table.
+
+To add a table to a publication, the user must be an owner of the table. However, in
+this case, the source table already exists, so you must use a PostgreSQL replication
+group to share ownership between the Debezium user and the original owner. Configure
+the replication group using the following commands:
+
+1.  Create the replication group (the name `replication_group` here is
+    just an example):
+
+    ```sql
+    CREATE ROLE replication_group;
+    ```
+1.  Add the original owner of the table to the group:
+
+    ```sql
+    GRANT replication_group TO original_owner;
+    ```
+
+1.  Add the Debezium replication user to the group:
+
+    ```sql
+    GRANT replication_group TO replication_user;
+    ```
+1.  Transfer ownership of the table to `replication_group`:
+
+    ```sql
+    ALTER TABLE table_name OWNER TO replication_group;
+    ```
+
+You must also set the value of the `publication.autocreate.mode` parameter to `filtered`
+to allow Debezium to specify the publication configuration. See the
+[Debezium documentation for `publication.autocreate.mode`](https://debezium.io/documentation/reference/2.6/connectors/postgresql.html#postgresql-publication-autocreate-mode)
+to learn more about this setting.
+
+## Configure PostgreSQL for replication with the Debezium connector host
+
+You must configure the database to allow replication with the host that runs
+the PostgreSQL Debezium connector. To do this, add an entry to the
+host-based authentication file, `pg_hba.conf`, for each client that needs to
+use replication. For example, to enable replication for `<youruser>` locally,
+on the server machine, you would add a line like the following:
+
+```
+local   replication     <youruser>                          trust
+```
+
+To allow `<youruser>` on localhost to receive replication changes using IPV4,
+add the line:
+
+```
+host    replication     <youruser>  127.0.0.1/32            trust
+```
+
+To allow `<youruser>` on localhost to receive replication changes using IPV6,
+add the line:
+
+```
+host    replication     <youruser>  ::1/128                 trust 
+```
+
+Find out more from the PostgreSQL pages about
+[`pg_hba.conf`](https://www.postgresql.org/docs/10/auth-pg-hba-conf.html)
+and
+[network address types](https://www.postgresql.org/docs/current/datatype-net-types.html).
+
+## Supported PostgreSQL topologies
+
+You can use the Debezium PostgreSQL connector with a standalone PostgreSQL server or
+with a cluster of servers.
+For versions 12 and below, PostgreSQL supports logical replication slots on only primary servers.
+This means that Debezium can only connect to a primary server for CDC and the connection will
+stop if this server fails. If the same server is promoted to primary when service resumes
+then you can simply restart the Debezium connector. However, if a different server is
+promoted to primary, then you must reconfigure Debezium to use the new server
+before restarting. Also, make sure the new server has the correct plug-in and configuration
+for Debezium.
+---
+Title: Prepare SQL Server for RDI
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/sql-server/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Prepare SQL Server databases to work with RDI
+group: di
+linkTitle: Prepare SQL Server
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 2
+---
+
+To prepare your SQL Server database for Debezium, you must first create a dedicated Debezium user,
+run a script to enable CDC globally, and then separately enable CDC for each table you want to
+capture. You need administrator privileges to do this.
+
+Once you enable CDC, it captures all of the INSERT, UPDATE, and DELETE operations
+on your chosen tables. The Debezium connector can then emit these events to RDI.
+
+## 1. Create a Debezium user
+
+It is strongly recommended to create a dedicated Debezium user for the connection between RDI
+and the source database. When using an existing user, ensure that the required 
+permissions are granted and that the user is added to the CDC role.
+
+1.  Create a user with the Transact-SQL below:
+
+    ```sql
+    USE master
+    GO
+    CREATE LOGIN MyUser WITH PASSWORD = 'My_Password'
+    GO
+    USE MyDB
+    GO
+    CREATE USER MyUser FOR LOGIN MyUser
+    GO
+    ```
+
+    Replace `MyUser`, `My_Password` and `MyDB` with your chosen values.
+
+1.  Grant required permissions:
+
+    ```sql
+    USE master
+    GO
+    GRANT VIEW SERVER STATE TO MyUser
+    GO
+    USE MyDB
+    GO
+    EXEC sp_addrolemember N'db_datareader', N'MyUser'
+    GO
+    ```
+
+## 2. Enable CDC on the database
+
+There are two system stored procedures to enable CDC (you need
+administrator privileges to run these). Use `sys.sp_cdc_enable_db`
+to enable CDC for the whole database and then `sys.sp_cdc_enable_table` to enable CDC for individual tables. 
+
+Before running the procedures, ensure that:
+
+- You are a member of the `sysadmin` fixed server role for the SQL Server.
+- You are a `db_owner` of the database.
+- The SQL Server Agent is running.
+
+Then, assuming your database is called `MyDB`, run the script below to enable CDC:
+
+```sql
+USE MyDB
+GO
+EXEC sys.sp_cdc_enable_db
+GO
+```
+
+{{< note >}}For SQL Server on AWS RDS, you must use a different stored procedure:
+```sql
+EXEC msdb.dbo.rds_cdc_enable_db 'Chinook'
+GO
+```
+{{< /note >}}
+
+When you enable CDC for the database, it creates a schema called `cdc` and also
+a CDC user, metadata tables, and other system objects. 
+
+## 3. Enable CDC for the tables you want to capture
+
+1.  You must also enable CDC on the tables you want Debezium to capture using the
+following commands (again, you need administrator privileges for this):
+
+    ```sql
+    USE MyDB
+    GO
+
+    EXEC sys.sp_cdc_enable_table
+    @source_schema = N'dbo',
+    @source_name   = N'MyTable', 
+    @role_name     = N'MyRole',  
+    @supports_net_changes = 0
+    GO
+    ```
+
+    Repeat this for every table you want to capture.
+
+    {{< note >}}The value for `@role_name` can’t be a fixed database role, such as `db_datareader`. 
+    Specifying a new name will create a corresponding database role that has full access to the
+    captured change data.
+    {{< /note >}}
+  
+1.  Add the Debezium user to the CDC role:
+
+    ```sql
+    USE MyDB
+    GO
+    EXEC sp_addrolemember N'MyRole', N'MyUser'
+    GO
+    ```
+
+## 4. Check that you have access to the CDC table
+
+You can use another stored procedure `sys.sp_cdc_help_change_data_capture`
+to query the CDC information for the database and check you have enabled
+it correctly. To do this, connect as the Debezium user you created previously (`MyUser`).
+
+1.  Run the `sys.sp_cdc_help_change_data_capture` stored procedure to query
+    the CDC configuration. For example, if your database was called `MyDB` then you would
+    run the following:
+
+    ```sql
+    USE MyDB;
+    GO
+    EXEC sys.sp_cdc_help_change_data_capture
+    GO
+    ```
+
+1.  The query returns configuration information for each table in the database that
+    has CDC enabled and that contains change data that you are authorized to
+    access. If the result is empty then you should check that you have privileges
+    to access both the capture instance and the CDC tables.
+
+### Troubleshooting
+
+If no CDC is happening then it might mean that SQL Server Agent is down. You can check for this using the SQL query shown below:
+
+```sql
+IF EXISTS (SELECT 1 
+           FROM master.dbo.sysprocesses 
+           WHERE program_name = N'SQLAgent - Generic Refresher')
+BEGIN
+  SELECT @@SERVERNAME AS 'InstanceName', 1 AS 'SQLServerAgentRunning'
+END
+ELSE 
+BEGIN
+  SELECT @@SERVERNAME AS 'InstanceName', 0 AS 'SQLServerAgentRunning'
+END
+```
+
+If the query returns a result of 0, you need to need to start SQL Server Agent using the following commands:
+
+```sql
+EXEC xp_servicecontrol N'START',N'SQLServerAGENT';
+GO
+```
+
+## SQL Server capture job agent configuration parameters
+
+In SQL Server, the parameters that control the behavior of the capture job agent
+are defined in the SQL Server table `msdb.dbo.cdc_jobs`. If you experience performance
+problems while running the capture job agent then you can adjust the capture jobs
+settings to reduce CPU load. To do this, run the `sys.sp_cdc_change_job` stored procedure
+with your new parameter values.
+
+{{< note >}}A full guide to configuring the SQL Server capture job agent parameters
+is outside the scope of the Redis documentation.{{< /note >}}
+
+The following parameters are the most important ones for modifying the capture agent behavior
+of the Debezium SQL Server connector:
+
+* `pollinginterval`: This specifies the number of seconds that the capture agent
+  waits between log scan cycles. A higher value reduces the load on the database
+  host, but increases latency.  A value of 0 specifies no wait between scans.
+  The default value is 5.
+* `maxtrans`: This specifies the maximum number of transactions to process during
+  each log scan cycle. After the capture job processes the specified number of
+  transactions, it pauses for the length of time that `pollinginterval` specifies
+  before the next scan begins. A lower value reduces the load on the database host,
+  but increases latency. The default value is 500.
+* `maxscans`: This specifies a limit on the number of scan cycles that the capture
+  job can attempt when capturing the full contents of the database transaction log.
+  If the continuous parameter is set to 1, the job pauses for the length of time
+  that the `pollinginterval` specifies before it resumes scanning. A lower values
+  reduces the load on the database host, but increases latency. The default value is 10.
+
+See the SQL Server documentation for more information about capture agent parameters.
+
+## SQL Server on Azure
+
+You can also use the Debezium SQL Server connector with SQL Server on Azure.
+See Microsoft's guide to
+[configuring SQL Server on Azure for CDC with Debezium](https://learn.microsoft.com/en-us/samples/azure-samples/azure-sql-db-change-stream-debezium/azure-sql%2D%2Dsql-server-change-stream-with-debezium/)
+for more information.
+
+## Handling changes to the schema
+
+RDI can't adapt automatically when you change the schema of a CDC table in SQL Server. For example,
+if you add a new column to a table you are capturing then RDI will generate errors
+instead of capturing the changes correctly. See Debezium's
+[SQL Server schema evolution](https://debezium.io/documentation/reference/stable/connectors/sqlserver.html#sqlserver-schema-evolution)
+docs for more information.
+
+If you have administrator privileges, you can follow the steps below to update RDI after
+a schema change and resume CDC. See the
+[online schema updates](https://debezium.io/documentation/reference/stable/connectors/sqlserver.html#online-schema-updates)
+documentation for further details.
+
+1.  Make your changes to the source table schema.
+
+1.  Create a new capture table for the updated source table by running the `sys.sp_cdc_enable_table` stored
+    procedure with a new, unique value for the parameter `@capture_instance`. For example, if the old value
+    was `dbo_MyTable`, you could replace it with `dbo_MyTable_v2` (you can see the existing values by running
+    stored procedure `sys.sp_cdc_help_change_data_capture`):
+
+    ```sql
+    EXEC sys.sp_cdc_enable_table
+    @source_schema    = N'dbo',
+    @source_name      = N'MyTable',
+    @role_name        = N'MyRole',
+    @capture_instance = N'dbo_MyTable_v2',
+    @supports_net_changes = 0
+    GO
+    ```
+
+1.  When Debezium starts streaming from the new capture table, drop the old capture table by running 
+    the `sys.sp_cdc_disable_table` stored procedure with the parameter `@capture_instance` set to the old
+    capture instance name, `dbo_MyTable`:
+
+    ```sql
+    EXEC sys.sp_cdc_disable_table
+    @source_schema    = N'dbo',
+    @source_name      = N'MyTable',
+    @capture_instance = N'dbo_MyTable'
+    GO
+    ```
+
+{{< note >}}RDI will *not* correctly capture changes that happen in the time gap between changing
+the source schema (step 1 above) and updating the value of `@capture_instance` (step 2).
+Try to keep the gap as short as possible or perform the update at a time when you expect
+few changes to the data.{{< /note >}}---
+Title: Prepare source databases
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/prepare-dbs/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Enable CDC features in your source databases
+group: di
+hideListLinks: false
+linkTitle: Prepare source databases
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+Each database uses a different mechanism to track changes to its data and
+generally, these mechanisms are not switched on by default.
+RDI's Debezium collector uses these mechanisms for change data capture (CDC),
+so you must prepare your source database before you can use it with RDI.
+
+RDI supports the following source databases:
+
+{{< embed-md "rdi-supported-source-versions.md" >}}
+
+The pages in this section give detailed instructions to get your source
+database ready for Debezium to use:
+---
+Title: Data denormalization
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/data-denormalization/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn about denormalization strategies
+group: di
+linkTitle: Data denormalization
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+The data in the source database is often
+[*normalized*](https://en.wikipedia.org/wiki/Database_normalization).
+This means that columns can't have composite values (such as arrays) and relationships between entities
+are expressed as mappings of primary keys to foreign keys between different tables.
+Normalized data models reduce redundancy and improve data integrity for write queries but this comes
+at the expense of speed.
+A Redis cache, on the other hand, is focused on making *read* queries fast, so RDI provides data
+*denormalization* to help with this.
+
+## Nest strategy
+
+*Nesting* is the strategy RDI uses to denormalize many-to-one relationships in the source database.
+It does this by representing the
+parent object (the "one") as a JSON document with the children (the "many") nested inside a JSON map
+attribute in the parent. The diagram belows shows a nesting with the child objects in a map
+called `InvoiceLineItems`:
+
+{{< image filename="/images/rdi/ingest/nest-flow.webp" width="500px" >}}
+
+You configure normalization with a `nest` block in the child entities' RDI job, as shown in this example:
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: InvoiceLine
+output:
+  - uses: redis.write
+    with:
+      nest: # cannot co-exist with other parameters such as 'key'
+        parent:
+          # server_name: chinook
+          # schema: public
+          table: Invoice
+        nesting_key: InvoiceLineId # cannot be composite
+        parent_key: InvoiceId # cannot be composite
+        path: $.InvoiceLineItems # path must start from document root ($)
+        structure: map # only map supported for now
+      on_update: merge # only merge supported for now
+      data_type: json # only json supported for now
+```
+
+The job has a `with` section under `output` that includes the `nest` block.
+The job must include the following attributes in the `nest` block:
+
+- `parent`: This specifies the RDI data stream for the parent entities. Typically, you only
+  need to supply the parent `table` name, unless you are nesting children under a parent that comes from
+  a different source database. If you do this then you must also specify `server_name` and
+  `schema` attributes. Note that this attribute refers to a Redis *key* that will be added to the target
+  database, not to a table you can access from the pipeline. See [Using nesting](#using-nesting) below
+  for the format of the key that is generated.
+- `nesting_key`: The field of the child entity that stores the unique ID (primary key) of the child entity.
+- `parent_key`: The field in the parent entity that stores the unique ID (foreign key) of the parent entity.
+- `child_key`: The field in the child entity that stores the unique ID (foreign key) of the parent entity.
+  You only need to add this attribute if the name of the child's foreign key field is different from the parent's.
+- `path`: The [JSONPath](https://goessner.net/articles/JsonPath/)
+  for the map where you want to store the child entities. The path must start with the `$` character, which denotes
+  the document root.
+- `structure`: (Optional) The type of JSON nesting structure for the child entities. Currently, only a JSON map
+  is supported so if you supply this attribute then the value must be `map`.
+
+## Using nesting
+
+There are several important things to note when you use nesting:
+
+- When you specify `nest` in the job, you must also set the `data_type` attribute to `json` and
+  the `on_update` attribute to `merge` in the surrounding `output` block.
+- Key expressions are *not* supported for the `nest` output blocks. The parent key is always calculated
+  using the following template:
+
+  ```bash
+  <nest.parent.table>:<nest.parent_key>:<nest.parent_key.value | nest.child_key.value>
+  ```
+  
+  For example:
+  
+  ```bash
+  Invoice:InvoiceId:1
+  ```
+
+- If you specify `expire` in the `nest` output block then this will set the expiration on the *parent* object.
+- You can only use one level of nesting.
+- If you are using PostgreSQL then you must make the following change for all child tables that you want to nest:
+  
+  ```sql
+  ALTER TABLE <TABLE_NAME> REPLICA IDENTITY FULL;
+  ```
+  
+  This configuration affects the information written to the write-ahead log (WAL) and whether it is available
+  for RDI to capture. By default, PostgreSQL only records
+  modified fields in the log, which means that it might omit the `parent_key`. This can cause incorrect updates to the
+  Redis key in the destination database.
+  See the
+  [Debezium PostgreSQL Connector Documentation](https://debezium.io/documentation/reference/connectors/postgresql.html#postgresql-replica-identity)
+  for more information about this.
+---
+Title: Configure data pipelines
+linkTitle: Configure
+description: Learn how to configure ingest pipelines for data transformation
+weight: 1
+alwaysopen: false
+categories: ["redis-di"]
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/data-pipelines/
+---
+
+RDI implements
+[change data capture](https://en.wikipedia.org/wiki/Change_data_capture) (CDC)
+with *pipelines*. (See the
+[architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}})
+for an introduction to pipelines.)
+
+## Overview
+
+An RDI pipeline captures change data records from the source database, and transforms them
+into Redis data structures. It writes each of these new structures to a Redis target
+database under its own key. 
+
+By default, RDI transforms the source data into
+[hashes]({{< relref "/develop/data-types/hashes" >}}) or
+[JSON objects]({{< relref "/develop/data-types/json" >}}) for the target with a
+standard data mapping and a standard format for the key.
+However, you can also provide your own custom transformation [jobs](#job-files)
+for each source table, using your own data mapping and key pattern. You specify these
+jobs declaratively with YAML configuration files that require no coding.
+
+The data tranformation involves two separate stages. First, the data ingested
+during CDC is automatically transformed to a JSON format. Then,
+this JSON data gets passed on to your custom transformation for further processing.
+
+You can provide a job file for each source table you want to transform, but you
+can also add a *default job* for any tables that don't have their own.
+You must specify the full name of the source table in the job file (or the special
+name "*" in the default job) and you
+can also include filtering logic to skip data that matches a particular condition.
+As part of the transformation, you can specify whether you want to store the
+data in Redis as
+[JSON objects]({{< relref "/develop/data-types/json" >}}),
+[hashes]({{< relref "/develop/data-types/hashes" >}}),
+[sets]({{< relref "/develop/data-types/sets" >}}),
+[streams]({{< relref "/develop/data-types/streams" >}}),
+[sorted sets]({{< relref "/develop/data-types/sorted-sets" >}}), or
+[strings]({{< relref "/develop/data-types/strings" >}}).
+
+The diagram below shows the flow of data through the pipeline:
+
+{{< image filename="/images/rdi/ingest/RDIPipeDataflow.webp" >}}
+
+## Pipeline configuration
+
+RDI uses a set of [YAML](https://en.wikipedia.org/wiki/YAML)
+files to configure each pipeline. The following diagram shows the folder
+structure of the configuration:
+
+{{< image filename="images/rdi/ingest/ingest-config-folders.webp" width="600px" >}}
+
+The main configuration for the pipeline is in the `config.yaml` file.
+This specifies the connection details for the source database (such
+as host, username, and password) and also the queries that RDI will use
+to extract the required data. You should place job configurations in the `Jobs`
+folder if you want to specify your own data transformations.
+
+The sections below describe the two types of configuration file in more detail.
+
+## The `config.yaml` file
+
+Here is an example of a `config.yaml` file. Note that the values of the
+form "`${name}`" refer to secrets that you should set as described in 
+[Set secrets]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy#set-secrets" >}}). 
+In particular, you should normally use secrets as shown to set the source
+and target username and password rather than storing them in plain text in this file.
+
+```yaml
+sources:
+  mysql:
+    type: cdc
+    logging:
+      level: info
+    connection:
+      type: mysql
+      host: <DB_HOST> # e.g. localhost
+      port: 3306
+      # User and password are injected from the secrets.
+      user: ${SOURCE_DB_USERNAME}
+      password: ${SOURCE_DB_PASSWORD}
+    # Additional properties for the source collector:
+    # List of databases to include (optional).
+    # databases:
+    #   - database1
+    #   - database2
+
+    # List of tables to be synced (optional).
+    # tables:
+    #   If only one database is specified in the databases property above,
+    #   then tables can be defined without the database prefix.
+    #   <DATABASE_NAME>.<TABLE_NAME>:
+    #     List of columns to be synced (optional).
+    #     columns:
+    #       - <COLUMN_NAME>
+    #       - <COLUMN_NAME>
+    #     List of columns to be used as keys (optional).
+    #     keys:
+    #       - <COLUMN_NAME>
+
+    # Example: Sync specific tables.
+    # tables:
+    #   Sync a specific table with all its columns:
+    #   redislabscdc.account: {}
+    #   Sync a specific table with selected columns:
+    #   redislabscdc.emp:
+    #     columns:
+    #       - empno
+    #       - fname
+    #       - lname
+
+    # Advanced collector properties (optional):
+    # advanced:
+    #   Sink collector properties - see the full list at
+    #     https://debezium.io/documentation/reference/stable/operations/debezium-server.html#_redis_stream
+    #   sink:
+    #     Optional hard limits on memory usage of RDI streams.
+    #     redis.memory.limit.mb: 300
+    #     redis.memory.threshold.percentage: 85
+
+    #     Uncomment for production so RDI Collector will wait on replica
+    #     when writing entries.
+    #     redis.wait.enabled: true
+    #     redis.wait.timeout.ms: 1000
+    #     redis.wait.retry.enabled: true
+    #     redis.wait.retry.delay.ms: 1000
+
+    #   Source specific properties - see the full list at
+    #     https://debezium.io/documentation/reference/stable/connectors/
+    #   source:
+    #     snapshot.mode: initial
+    #     Uncomment if you want a snapshot to include only a subset of the rows
+    #     in a table. This property affects snapshots only.
+    #     snapshot.select.statement.overrides: <DATABASE_NAME>.<TABLE_NAME>
+    #     The specified SELECT statement determines the subset of table rows to
+    #     include in the snapshot.
+    #     snapshot.select.statement.overrides.<DATABASE_NAME>.<TABLE_NAME>: <SELECT_STATEMENT>
+
+    #     Example: Snapshot filtering by order status.
+    #     To include only orders with non-pending status from customers.orders
+    #     table:
+    #     snapshot.select.statement.overrides: customer.orders
+    #     snapshot.select.statement.overrides.customer.orders: SELECT * FROM customers.orders WHERE status != 'pending' ORDER BY order_id DESC
+
+    #   Quarkus framework properties - see the full list at
+    #     https://quarkus.io/guides/all-config
+    #   quarkus:
+    #     banner.enabled: "false"
+
+targets:
+  # Redis target database connections.
+  # The default connection must be named 'target' and is used when no
+  # connection is specified in jobs or no jobs
+  # are deployed. However multiple connections can be defined here and used
+  # in the job definition output blocks:
+  # (e.g. target1, my-cloud-redis-db2, etc.)
+  target:
+    connection:
+      type: redis
+      # Host of the Redis database to which RDI will
+      # write the processed data.
+      host: <REDIS_TARGET_DB_HOST> # e.g. localhost
+      # Port for the Redis database to which RDI will
+      # write the processed data.
+      port: <REDIS_TARGET_DB_PORT> # e.g. 12000
+      # User of the Redis database to which RDI will write the processed data.
+      # Uncomment if you are not using the default user.
+      # user: ${TARGET_DB_USERNAME}
+      # Password for Redis target database.
+      password: ${TARGET_DB_PASSWORD}
+      # SSL/TLS configuration: Uncomment to enable secure connections.
+      # key: ${TARGET_DB_KEY}
+      # key_password: ${TARGET_DB_KEY_PASSWORD}
+      # cert: ${TARGET_DB_CERT}
+      # cacert: ${TARGET_DB_CACERT}
+processors:
+  # Interval (in seconds) on which to perform retry on failure.
+  # on_failed_retry_interval: 5
+  # The batch size for reading data from the source database.
+  # read_batch_size: 2000
+  # Time (in ms) after which data will be read from stream even if
+  # read_batch_size was not reached.
+  # duration: 100
+  # The batch size for writing data to the target Redis database. Should be
+  # less than or equal to the read_batch_size.
+  # write_batch_size: 200
+  # Enable deduplication mechanism (default: false).
+  # dedup: <DEDUP_ENABLED>
+  # Max size of the deduplication set (default: 1024).
+  # dedup_max_size: <DEDUP_MAX_SIZE>
+  # Error handling strategy: ignore - skip, dlq - store rejected messages
+  # in a dead letter queue
+  # error_handling: dlq
+```
+
+The main sections of the file configure [`sources`](#sources) and [`targets`](#targets).
+
+### Sources
+
+The `sources` section has a subsection for the source that
+you need to configure. The source section starts with a unique name
+to identify the source (in the example we have a source
+called `mysql` but you can choose any name you like). The example
+configuration contains the following data:
+
+- `type`: The type of collector to use for the pipeline. 
+  Currently, the only types we support are `cdc` and `external`.
+  If the source type is set to `external`, no collector resources will be created by the operator, 
+  and all other source sections should be empty or not specified at all.
+- `connection`: The connection details for the source database: `type`, `host`, `port`, 
+  and credentials (`username` and `password`).
+  - `type` is the source database type, one of `mariadb`, `mysql`, `oracle`, `postgresql`, or `sqlserver`.
+  - If you use [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security)/
+    or [mTLS](https://en.wikipedia.org/wiki/Mutual_authentication#mTLS) to connect
+    to the source database, you may need to specify additional properties in the
+    `advanced` section with references to the corresponding certificates depending 
+    on the source database type. Note that these properties **must** be references to 
+    secrets that you should set as described in [Set secrets]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy#set-secrets" >}}).
+- `databases`: List of all databases to collect data from for source database types
+  that support multiple databases, such as `mysql` and `mariadb`.
+- `schemas`: List of all schemas to collect data from for source database types
+  that support multiple schemas, such as `oracle`, `postgresql`, and `sqlserver`.
+- `tables`: List of all tables to collect data from. Each table is identified by its
+  full name, including a database or schema prefix. If there is a single 
+  database or schema, this prefix can be omitted. 
+  For each table, you can specify:
+  - `columns`: A list of the columns you are interested in (the default is to
+    include all columns)
+  - `keys`: A list of columns to create a composite key if your table
+    doesn't already have a [`PRIMARY KEY`](https://www.w3schools.com/sql/sql_primarykey.asp) or
+    [`UNIQUE`](https://www.w3schools.com/sql/sql_unique.asp) constraint.
+  - `snapshot_sql`: A query to be used when performing the initial snapshot.
+    By default, a query that contains all listed columns of all listed tables will be used.
+- `advanced`: These optional properties configure other Debezium-specific features.
+  The available sub-sections are:
+  - `source`: Properties for reading from the source database.
+    See the Debezium [Source connectors](https://debezium.io/documentation/reference/stable/connectors/)
+    pages for more information about the properties available for each database type.
+  - `sink`: Properties for writing to Redis streams in the RDI database.
+    See the Debezium [Redis stream properties](https://debezium.io/documentation/reference/stable/operations/debezium-server.html#_redis_stream)
+    page for the full set of available properties.
+  - `quarkus`: Properties for the Debezium server, such as the log level. See the
+    Quarkus [Configuration options](https://quarkus.io/guides/all-config)
+    docs for the full set of available properties.
+
+### Targets
+
+Use this section to provide the connection details for the target Redis
+database(s). As with the sources, you should start each target section
+with a unique name that you are free to choose (here, we have used
+`target` as an example). In the `connection` section, you can specify the
+`type` of the target database, which must be `redis`, along with 
+connection details such as `host`, `port`, and credentials (`username` and `password`).
+If you use [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security)/
+or [mTLS](https://en.wikipedia.org/wiki/Mutual_authentication#mTLS) to connect 
+to the target database, you must specify the CA certificate (for TLS), 
+and the client certificate and private key (for mTLS) in `cacert`, `cert`, and `key`.
+Note that these certificates **must** be references to secrets
+that you should set as described in [Set secrets]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy#set-secrets" >}})
+(it is not possible to include these certificates as plain text in the file).
+
+{{< note >}}If you specify `localhost` as the address of either the source or target server during
+installation then the connection will fail if the actual IP address changes for the local
+VM. For this reason, we recommend that you don't use `localhost` for the address. However,
+if you do encounter this problem, you can fix it using the following commands on the VM
+that is running RDI itself:
+
+```bash
+sudo k3s kubectl delete nodes --all
+sudo service k3s restart
+```
+{{< /note >}}
+
+## Job files
+
+You can optionally supply one or more job files that specify how you want to
+transform the captured data before writing it to the target.
+Each job file contains a YAML
+configuration that controls the transformation for a particular table from the source
+database. You can also add a `default-job.yaml` file to provide
+a default transformation for tables that don't have a specific job file of their own.
+
+The job files have a structure like the following example. This configures a default
+job that:
+
+- Writes the data to a Redis hash
+- Adds a field `app_code` to the hash with a value of `foo`
+- Adds a prefix of `aws` and a suffix of `gcp` to the key
+
+```yaml
+source:
+  table: "*"
+  row_format: full
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: after.app_code
+          expression: "`foo`"
+          language: jmespath
+output:
+  - uses: redis.write
+    with:
+      data_type: hash
+      key:
+        expression: concat(['aws', '#', table, '#', keys(key)[0], '#', values(key)[0], '#gcp'])
+        language: jmespath
+```
+
+The main sections of these files are:
+
+- `source`: This is a mandatory section that specifies the data items that you want to 
+  use. You can add the following properties here:
+  - `server_name`: Logical server name (optional).
+  - `db`: Database name (optional)
+  - `schema`: Database schema (optional)
+  - `table`: Database table name. This refers to a table name you supplied in `config.yaml`. The default
+  job doesn't apply to a specific table, so use "*" in place of the table name for this job only.
+  - `row_format`: Format of the data to be transformed. This can take the values `data_only` (default) to
+  use only the payload data, or `full` to use the complete change record. See the `transform` section below
+  for details of the extra data you can access when you use the `full` option.
+  - `case_insensitive`: This applies to the `server_name`, `db`, `schema`, and `table` properties
+  and is set to `true` by default. Set it to `false` if you need to use case-sensitive values for these
+  properties.
+
+- `transform`: This is an optional section describing the transformation that the pipeline
+  applies to the data before writing it to the target. The `uses` property specifies a
+  *transformation block* that will use the parameters supplied in the `with` section. See the 
+  [data transformation reference]({{< relref "/integrate/redis-data-integration/reference/data-transformation" >}})
+  for more details about the supported transformation blocks, and also the
+  [JMESPath custom functions]({{< relref "/integrate/redis-data-integration/reference/jmespath-custom-functions" >}}) reference. You can test your transformation logic using the [dry run]({{< relref "/integrate/redis-data-integration/reference/api-reference/#tag/secure/operation/job_dry_run_api_v1_pipelines_jobs_dry_run_post" >}}) feature in the API. 
+
+  {{< note >}}If you set `row_format` to `full` under the `source` settings, you can access extra data from the
+  change record in the transformation:
+  - Use the expression `key.key` to get the generated Redis key as a string.
+  - Use `before.<FIELD_NAME>` to get the value of a field *before* it was updated in the source database
+    (the field name by itself gives you the value *after* the update).{{< /note >}}
+ 
+- `output`: This is a mandatory section to specify the data structure(s) that
+  RDI will write to
+  the target along with the text pattern for the key(s) that will access it.
+  Note that you can map one record to more than one key in Redis or nest
+  a record as a field of a JSON structure (see
+  [Data denormalization]({{< relref "/integrate/redis-data-integration/data-pipelines/data-denormalization" >}})
+  for more information about nesting). You can add the following properties in the `output` section:
+  - `uses`: This must have the value `redis.write` to specify writing to a Redis data
+  structure. You can add more than one block of this type in the same job.
+  - `with`:
+    - `connection`: Connection name as defined in `config.yaml` (by default, the connection named `target` is used).
+    - `data_type`: Target data structure when writing data to Redis. The supported types are `hash`, `json`, `set`,
+   `sorted_set`, `stream` and `string`.
+    - `key`: This lets you override the default key for the data structure with custom logic:
+      - `expression`: Expression to generate the key.
+      - `language`: Expression language, which must be `jmespath` or `sql`.
+    - `expire`: Positive integer value indicating a number of seconds for the key to expire.
+    If you don't specify this property, the key will never expire.
+
+{{< note >}}In a job file, the `transform` section is optional, but if you don't specify
+a `transform`, you must specify custom key logic in `output.with.key`. You can include
+both of these sections if you want both a custom transform and a custom key.{{< /note >}}
+
+Another example below shows how you can rename the `fname` field to `first_name` in the table `emp`
+using the
+[`rename_field`]({{< relref "/integrate/redis-data-integration/reference/data-transformation/rename_field" >}}) block. It also demonstrates how you can set the key of this record instead of relying on
+the default logic. (See the
+[Transformation examples]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples" >}})
+section for more examples of job files.)
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      from_field: fname
+      to_field: first_name
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      key:
+        expression: concat(['emp:fname:',fname,':lname:',lname])
+        language: jmespath
+```
+
+See the
+[RDI configuration file]({{< relref "/integrate/redis-data-integration/reference/config-yaml-reference" >}})
+reference for full details about the
+available source, transform, and target configuration options and see
+also the
+[data transformation reference]({{< relref "/integrate/redis-data-integration/reference/data-transformation" >}})
+for details of all the available transformation blocks.
+
+## Source preparation
+
+Before using the pipeline you must first prepare your source database to use
+the Debezium connector for *change data capture (CDC)*. See the
+[architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}})
+for more information about CDC.
+Each database type has a different set of preparation steps. You can
+find the preparation guides for the databases that RDI supports in the
+[Prepare source databases]({{< relref "/integrate/redis-data-integration/data-pipelines/prepare-dbs" >}})
+section.
+
+## Deploy a pipeline
+
+When your configuration is ready, you must deploy it to start using the pipeline. See
+[Deploy a pipeline]({{< relref "/integrate/redis-data-integration/data-pipelines/deploy" >}})
+to learn how to do this.
+
+## Pipeline lifecycle
+
+A pipeline goes through the following phases:
+
+1. *Deploy* - when you deploy the pipeline, RDI first validates it before use.
+Then, the [operator]({{< relref "/integrate/redis-data-integration/architecture#how-rdi-is-deployed">}}) creates and configures the collector and stream processor that will run the pipeline.
+1. *Snapshot* - The collector starts the pipeline by creating a snapshot of the full
+dataset. This involves reading all the relevant source data, transforming it and then
+writing it into the Redis target. You should expect this phase to take minutes or
+hours to complete if you have a lot of data.
+1. *CDC* - Once the snapshot is complete, the collector starts listening for updates to
+the source data. Whenever a change is committed to the source, the collector captures
+it and adds it to the target through the pipeline. This phase continues indefinitely
+unless you change the pipeline configuration. 
+1. *Update* - If you update the pipeline configuration, the operator applies it
+to the collector and the stream processor. Note that the changes only affect newly-captured
+data unless you reset the pipeline completely. Once RDI has accepted the updates, the
+pipeline returns to the CDC phase with the new configuration.
+1. *Reset* - There are circumstances where you might want to rebuild the dataset
+completely. For example, you might want to apply a new transformation to all the source
+data or refresh the dataset if RDI is disconnected from the
+source for a long time. In situations like these, you can *reset* the pipeline back
+to the snapshot phase. When this is complete, the pipeline continues with CDC as usual. 
+---
+Title: Write to a Redis stream
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/redis-stream-example/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis stream
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+In the example below, data is captured from the source table named `invoice` and is written to a Redis stream. The `connection` is an optional parameter that refers to the corresponding connection name defined in `config.yaml`. 
+When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+When writing to streams, you can use the optional parameter `mapping` to limit the number of fields sent in a message and to provide aliases for them. If you don't use the `mapping` parameter, all fields captured in the source will be passed as the message payload. 
+
+Note that streams are different from other data structures because existing messages are never updated or deleted. Any operation in the source will generate a new message with the corresponding operation code (`op_code` field) that is automatically added to the message payload. 
+
+In this case, the result will be a Redis stream with the name based on the key expression (for example, `invoice:events`) and with an expiration of 100 seconds for the whole stream. If you don't supply an `expire` parameter, the keys will never expire. 
+
+In the example, only three original fields are passed in the message payload: `InvoiceId` (as `message_id`), `BillingCountry` (as `country`), `Total` (as `Total`, no alias provided) and `op_code`, which is implicitly added to all messages sent to streams.    
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: stream
+      key:
+        expression: "`invoice:events`"
+        language: jmespath
+      mapping:
+        - InvoiceId: message_id
+        - BillingCountry: country
+        - Total
+      expire: 100
+```---
+Title: Write to a Redis set
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/redis-set-example/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis set
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+In the example below, data is captured from the source table named `invoice` and is written to a Redis set. The `connection` is an optional parameter that refers to the corresponding connection name defined in `config.yaml`. When you specify the
+`data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+When writing to a set, you must supply an extra argument, `member`, which specifies the field that will be written. In this case, the result will be a Redis set with key names based on the key expression (for example, `invoices:Germany`, `invoices:USA`) and with an expiration of 100 seconds. If you don't supply an `expire` parameter, the keys will never expire.    
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: set
+      key:
+        expression: concat(['invoices:', BillingCountry])
+        language: jmespath
+      args:
+        member: InvoiceId
+      expire: 100
+```---
+Title: Remove fields from a key
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Remove fields
+summary: Redis Data Integration keeps Redis in sync with a primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+By default, RDI adds fields to
+[hash]({{< relref "/develop/data-types/hashes" >}}) or
+[JSON]({{< relref "/develop/data-types/json" >}}) objects in the target
+database for each of the columns of the source table.
+The examples below show how to omit some of those fields from the target data with the
+[`remove_field`]({{< relref "/integrate/redis-data-integration/reference/data-transformation/remove_field" >}}) transformation.
+
+## Remove a single field
+
+The first example removes a single field from the data.
+The `source` section selects the `employee` table of the
+[`chinook`](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres)
+database (the optional `db` field here corresponds to the
+`sources.<source-name>.connection.database` field defined in
+[`config.yaml`]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#the-configyaml-file" >}})).
+
+In the `transform` section, the `remove_field` transformation removes the
+`hiredate` field.
+
+The `output` section specifies `hash` as the `data_type` to write to the target, which
+overrides the default setting of `target_data_type` defined in `config.yaml`. Also, the
+`output.with.key` section specifies a custom key format of the form `emp:<employeeid>`.
+Note that any fields you remove in the `transform` section are not available for
+the key calculation in the `output` section.
+
+The full example is shown below:
+
+```yaml
+source:
+  db: chinook
+  table: employee
+transform:
+  - uses: remove_field
+    with:
+      field: hiredate
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat(['emp:', employeeid])
+        language: jmespath
+```
+
+If you queried the generated target data from the default transformation
+using [`redis-cli`]({{< relref "/develop/tools/cli" >}}), you would
+see something like the following:
+
+```bash
+> hgetall emp:8
+ 1) "employeeid"
+ 2) "8"
+ 3) "lastname"
+ 4) "Callahan"
+ 5) "firstname"
+ 6) "Laura"
+ 7) "title"
+ 8) "IT Staff"
+ 9) "reportsto"
+10) "6"
+11) "birthdate"
+12) "-62467200000000"
+13) "hiredate"
+14) "1078358400000000"
+15) "address"
+16) "923 7 ST NW"
+.
+.
+```
+
+Using the job file above, the data omits the `hiredate` field:
+
+```bash
+ > hgetall emp:8
+ 1) "employeeid"
+ 2) "8"
+ 3) "lastname"
+ 4) "Callahan"
+ 5) "firstname"
+ 6) "Laura"
+ 7) "title"
+ 8) "IT Staff"
+ 9) "reportsto"
+10) "6"
+11) "birthdate"
+12) "-62467200000000"
+13) "address"
+14) "923 7 ST NW"
+.
+.
+```
+
+## Remove multiple fields
+
+The `remove_field` transformation can also remove multiple fields at the same time
+if you specify them under a `fields` subsection. The example below is similar
+to the previous one but also removes the `birthdate` field: 
+
+```yaml
+source:
+  db: chinook
+  table: employee
+transform:
+  - uses: remove_field
+    with:
+      fields:
+        - field: hiredate
+        - field: birthdate
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat(['emp:', employeeid])
+        language: jmespath
+```
+
+If you query the data, you can see that it also omits the
+`birthdate` field:
+
+```bash
+> hgetall emp:8
+ 1) "employeeid"
+ 2) "8"
+ 3) "lastname"
+ 4) "Callahan"
+ 5) "firstname"
+ 6) "Laura"
+ 7) "title"
+ 8) "IT Staff"
+ 9) "reportsto"
+10) "6"
+11) "address"
+12) "923 7 ST NW"
+.
+.
+```
+
+## Using `remove_field` with `add_field`
+
+The `remove_field` transformation is very useful in combination with
+[`add_field`]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples/redis-add-field-example" >}}).
+For example, if you use `add_field` to concatenate a person's first
+and last names, you may not need separate `firstname` and `lastname`
+fields, so you can use `remove_field` to omit them.
+See [Using `add_field` with `remove_field`]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples/redis-add-field-example#using-add_field-with-remove_field" >}})
+for an example of how to do this.
+---
+Title: Write to a Redis string
+aliases: null
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis string
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+The string data type is useful for capturing a string representation of a single column from
+a source table.
+
+In the example job below, the `title` column is captured from the `invoice` table in the source.
+The `title` is then written to the Redis target database as a string under a custom key of the
+form `AlbumTitle:42`, where the `42` is the primary key value of the table (the `albumid` column).
+
+The `connection` is an optional parameter that refers to the corresponding connection name defined in
+[`config.yaml`]({{< relref "integrate/redis-data-integration/data-pipelines/data-pipelines#the-configyaml-file" >}}). 
+When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. Here, the `string` data type also requires an `args` subsection
+with a `value` argument that specifies the column you want to capture from the source table.
+
+The optional `expire` parameter sets the length of time, in seconds, that a new key will
+persist for after it is created (here, it is 86400 seconds, which equals one day).
+After this time, the key will be deleted automatically.
+If you don't supply an `expire` parameter, the keys will never expire. 
+
+```yaml
+source:
+  server_name: chinook
+  table: album
+  row_format: full
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: string
+      key:
+        expression: concat(['AlbumTitle:', values(key)[0]])
+        language: jmespath
+      args:
+        value: title
+      expire: 86400
+```---
+Title: Add new fields to a key
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Add new fields
+summary: Redis Data Integration keeps Redis in sync with a primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+By default, RDI adds fields to
+[hash]({{< relref "/develop/data-types/hashes" >}}) or
+[JSON]({{< relref "/develop/data-types/json" >}}) objects in the target
+database that match the columns of the source table.
+The examples below show how to add extra fields to the target data with the
+[`add_field`]({{< relref "/integrate/redis-data-integration/reference/data-transformation/add_field" >}}) transformation.
+
+## Add a single field
+
+The first example adds a single field to the data.
+The `source` section selects the `customer` table of the
+[`chinook`](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres)
+database (the optional `db` value here corresponds to the
+`sources.<source-name>.connection.database` value defined in
+[`config.yaml`]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#the-configyaml-file" >}})).
+
+In the `transform` section, the `add_field` transformation adds an extra field called `localphone`
+to the object, which is created by removing the country and area code from the `phone`
+field with the
+[JMESPath]({{< relref "/integrate/redis-data-integration/reference/jmespath-custom-functions" >}}) function `regex_replace()`.
+You can also specify `sql` as the `language` if you prefer to create the new
+field with an [SQL](https://en.wikipedia.org/wiki/SQL) expression.
+
+The `output` section specifies `hash` as the `data_type` to write to the target, which
+overrides the default setting of `target_data_type` defined in `config.yaml`. Also, the
+`output.with.key` section specifies a custom key format of the form `cust:<id>` where
+the `id` part is generated by the `uuid()` function.
+
+The full example is shown below:
+
+```yaml
+source:
+  db: chinook
+  table: customer
+transform:
+  - uses: add_field
+    with:
+      expression: regex_replace(phone, '\+[0-9]+ (\([0-9]+\) )?', '')
+      field: localphone
+      language: jmespath
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat(['cust:', uuid()])
+        language: jmespath
+```
+
+If you queried the generated target data from the default transformation
+using [`redis-cli`]({{< relref "/develop/tools/cli" >}}), you would
+see something like the following:
+
+```
+ 1) "customerid"
+ 2) "27"
+ 3) "firstname"
+ 4) "Patrick"
+ 5) "lastname"
+ 6) "Gray"
+.
+.
+17) "phone"
+18) "+1 (520) 622-4200"
+.
+.
+```
+
+Using the job file above, the data also includes the new `localphone` field:
+
+```
+ 1) "customerid"
+ 2) "27"
+ 3) "firstname"
+ 4) "Patrick"
+ 5) "lastname"
+ 6) "Gray"
+ .
+ .
+23) "localphone"
+24) "622-4200"
+```
+
+## Add multiple fields
+
+The `add_field` transformation can also add multiple fields at the same time
+if you specify them under a `fields` subsection. The example below adds two
+fields to the `track` objects. The first new field, `seconds`, is created using a SQL
+expression to calculate the duration of the track in seconds from the
+`milliseconds` field.
+The second new field, `composerlist`, adds a JSON array using the `split()` function
+to split the `composer` string field wherever it contains a comma.
+
+```yaml
+source:
+  db: chinook
+  table: track
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - expression: floor(milliseconds / 1000)
+          field: seconds
+          language: sql
+        - expression: split(composer)
+          field: composerlist
+          language: jmespath
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: json
+      key:
+        expression: concat(['track:', trackid])
+        language: jmespath
+```
+
+You can query the target database to see the new fields in
+the JSON object:
+
+```bash
+> JSON.GET track:1 $
+
+"[{\"trackid\":1,\"name\":\"For Those About To Rock (We Salute You)\",\"albumid\":1,\"mediatypeid\":1,\"genreid\":1,\"composer\":\"Angus Young, Malcolm Young, Brian Johnson\",\"milliseconds\":343719,\"bytes\":11170334,\"unitprice\":\"0.99\",\"seconds\":343,\"composerlist\":[\"Angus Young\",\" Malcolm Young\",\" Brian Johnson\"]}]"
+```
+
+## Using `add_field` with `remove_field`
+
+You can use the `add_field` and
+[`remove_field`]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples/redis-remove-field-example" >}})
+transformations together to completely replace fields from the source. For example,
+if you add a new `fullname` field, you might not need the separate `firstname` and
+`lastname` fields. You can remove them with a job file like the following:
+
+```yaml
+source:
+  db: chinook
+  table: customer
+transform:
+  - uses: add_field
+    with:
+      expression: concat(firstname, ' ', lastname)
+      field: fullname
+      language: sql
+  - uses: remove_field
+    with:
+      fields:
+        - field: firstname
+        - field: lastname
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat(['cust:', customerid])
+        language: jmespath
+```
+---
+Title: Write to a Redis JSON document
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/redis-json-example/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis JSON document
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+{{<note>}}
+You must enable the [RedisJSON]({{< relref "/develop/data-types/json" >}}) module in the target Redis
+database to use this feature.
+{{</note>}}
+
+In the example below, the data is captured from the source table named `invoice` and is written to the Redis database as a JSON document. The `connection` is an optional parameter that refers to the corresponding connection name defined in `config.yaml`. When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+Another optional parameter, `on_update`, specifies the writing strategy. You can set this to either `replace` (the default) or `merge`. This affects the way the document is written to the target. Replacing the document will overwrite it completely, while merging will update it with the fields captured in the source, keeping the rest of the document intact. The `replace` option is usually more performant, while `merge` allows other jobs and applications to set extra fields in the same JSON documents. 
+
+In this case, the result will be Redis JSON documents with key names based on the key expression (for example, `invoice_id:1`) and with an expiration of 100 seconds. If you don't supply an `expire` parameter, the keys will never expire.    
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: json
+      key:
+        expression: concat(['invoice_id:', InvoiceId])
+        language: jmespath
+      on_update: replace        
+      expire: 100
+```---
+Title: Add the opcode to the Redis output
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Add the opcode to the Redis output
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 100
+---
+
+In the example below, the data is captured from the source table named `employee` and is written to the Redis database as a JSON document. When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+Here, the result will be Redis JSON documents with fields captured from the source table
+(`employeeid`, `firstname`, `lastname`) and also with
+an extra field `my_opcode` added using the `merge` update strategy (see the
+[JSON job example]({{< relref "/integrate/redis-data-integration/data-pipelines/transform-examples/redis-json-example" >}})
+for more information). The `opcode` expression refers to the operation code captured from
+the source. This is a database-specific value that indicates which type of operation generated
+the change (insert, update, etc).
+
+```yaml
+source:
+  schema: public
+  table: employee
+  row_format: full
+transform:
+  - uses: add_field
+    with:
+      field: after.my_opcode
+      expression: opcode
+      language: jmespath
+output:
+  - uses: redis.write
+    with:
+      data_type: json
+      mapping:
+        - employeeid
+        - firstname
+        - lastname
+        - my_opcode
+      connection: target
+      on_update: merge
+```---
+Title: Write to a Redis hash
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/redis-hash-example/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis hash
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+In the following example, the data is captured from the source table named `invoice` and is written to the Redis database as hash keys. The `connection` is an optional parameter that refers to the corresponding connection name defined in `config.yaml`. 
+When you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`. 
+
+In this case, the result will be Redis hashes with key names based on the key expression (for example, `invoice_id:1`) and with an expiration of 100 seconds.
+If you don't supply an `expire` parameter, the keys will never expire. 
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat(['invoice_id:', InvoiceId])
+        language: jmespath
+      expire: 100
+```---
+Title: Write to a Redis sorted set
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/redis-sorted-set-example/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Write to a Redis sorted set
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+
+In the example below, data is captured from the source table named `invoice` and is written to a Redis sorted set. The `connection` is an optional parameter that refers to the corresponding connection name defined in `config.yaml`. When
+you specify the `data_type` parameter for the job, it overrides the system-wide setting `target_data_type` defined in `config.yaml`.
+
+When writing to sorted sets, you must provide two additional arguments, `member` and `score`. These specify the field names that will be used as a member and a score to add an element to a sorted set. In this case, the result will be a Redis sorted set named `invoices:sorted` based on the key expression and with an expiration of 100 seconds for each set member. If you don't supply an `expire` parameter, the keys will never expire.
+
+```yaml
+source:
+  server_name: chinook
+  schema: public
+  table: invoice
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: sorted_set
+      key:
+        expression: "`invoices:sorted`"
+        language: jmespath
+      args:
+        score: Total
+        member: InvoiceId 
+      expire: 100      
+```
+
+Since sorted sets in Redis are inherently sorted, you can easily get the top N invoices by total invoice amount using the command below (the range 0..9 gets the top 10 invoices):
+
+```
+ZREVRANGE invoices:sorted 0 9 WITHSCORES
+```---
+Title: Transformation examples
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/transform-examples/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Explore some examples of common RDI transformations
+group: di
+hideListLinks: false
+linkTitle: Transformation examples
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+---
+Title: Restructure JSON or hash objects
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+linkTitle: Restructure objects
+summary: Redis Data Integration keeps Redis in sync with a primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+By default, RDI adds fields to
+[hash]({{< relref "/develop/data-types/hashes" >}}) or
+[JSON]({{< relref "/develop/data-types/json" >}}) objects in the target
+database that closely match the columns of the source table.
+The examples below show how you can create a completely new object structure
+from existing fields using the
+[`map`]({{< relref "/integrate/redis-data-integration/reference/data-transformation/map" >}})
+transformation.
+
+## Map to a new JSON structure
+
+The first
+[job file]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#job-files" >}})
+example creates a new [JSON]({{< relref "/develop/data-types/json" >}})
+object structure to write to the target.
+The `source` section selects the `employee` table of the
+[`chinook`](https://github.com/Redislabs-Solution-Architects/rdi-quickstart-postgres)
+database (the optional `db` value here corresponds to the
+`sources.<source-name>.connection.database` value defined in
+[`config.yaml`]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines#the-configyaml-file" >}})).
+
+In the `transform` section, the `map` transformation uses a [JMESPath](https://jmespath.org/)
+expression to specify the new JSON format. (Note that the vertical bar "|" in the `expression`
+line indicates that the following indented lines should be interpreted as a single string.)
+The expression resembles JSON notation but with data values supplied from
+table fields and
+[JMESPath functions]({{< relref "/integrate/redis-data-integration/reference/jmespath-custom-functions" >}}).
+
+Here, we rename the
+`employeeid` field to `id` and create two nested objects for the `address`
+and `contact` information. The `name` field is the concatenation of the existing
+`firstname` and `lastname` fields, with `lastname` converted to uppercase.
+In the `contact` subobject, the `email` address is obfuscated slightly, using the
+`replace()` function to hide the '@' sign and dots.
+
+In the `output` section of the job file, we specify that we want to write
+to a JSON object with a custom key. Note that in the `output` section, you must refer to
+fields defined in the `map` transformation, so we use the new name `id`
+for the key instead of `employeeid`.
+
+The full example is shown below:
+
+```yaml
+source:
+  db: chinook
+  table: employee
+transform:
+  - uses: map
+    with:
+      expression: |
+        {
+          "id": employeeid,
+          "name": concat([firstname, ' ', upper(lastname)]),
+          "address": {
+            "street": address,
+            "city": city,
+            "state": state,
+            "postalCode": postalcode,
+            "country": country
+          },
+          "contact": {
+            "phone": phone,
+            "safeEmail": replace(replace(email, '@', '_at_'), '.', '_dot_')
+          }
+        }
+      language: jmespath
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: json
+      key:
+        expression: concat(['emp:', id])
+        language: jmespath
+```
+
+If you query one of the new JSON objects, you see output like the following:
+
+```bash
+> JSON.GET emp:1 $
+"[{\"id\":1,\"name\":\"Andrew ADAMS\",\"address\":{\"street\":\"11120 Jasper Ave NW\",\"city\":\"Edmonton\",\"state\":\"AB\",\"postalCode\":\"T5K 2N1\",\"country\":\"Canada\"},\"contact\":{\"phone\":\"+1 (780) 428-9482\",\"safeEmail\":\"andrew_at_chinookcorp_dot_com\"}}]"
+```
+
+Formatted in the usual JSON style, the output looks like the sample below:
+
+```json
+{
+  "id": 1,
+  "name": "Andrew ADAMS",
+  "address": {
+    "street": "11120 Jasper Ave NW",
+    "city": "Edmonton",
+    "state": "AB",
+    "postalCode": "T5K 2N1",
+    "country": "Canada"
+  },
+  "contact": {
+    "phone": "+1 (780) 428-9482",
+    "safeEmail": "andrew_at_chinookcorp_dot_com"
+  }
+}
+```
+
+## Map to a hash structure
+
+This example creates a new [hash]({{< relref "/develop/data-types/hashes" >}})
+object structure for items from the `track` table. Here, the `map` transformation uses
+[SQL](https://en.wikipedia.org/wiki/SQL) for the expression because this is often
+more suitable for hashes or "flat"
+JSON objects without subobjects or arrays. The expression renames some of the fields.
+It also calculates more human-friendly representations for the track duration (originally
+stored in the `milliseconds` field) and the storage size (originally stored in the
+`bytes` field).
+
+The full example is shown below:
+
+```yaml
+source:
+  db: chinook
+  table: track
+transform:
+  - uses: map
+    with:
+      expression:
+          id: trackid
+          name: name
+          duration: concat(floor(milliseconds / 60000), ':', floor(mod(milliseconds / 1000, 60)))
+          storagesize: concat(round(bytes / 1048576.0, 2), 'MB')
+      language: sql
+output:
+  - uses: redis.write
+    with:
+      connection: target
+      data_type: hash
+      key:
+        expression: concat('track:', id)
+        language: sql
+```
+
+If you query the data for one of the `track` hash objects, you see output
+like the following:
+
+```bash
+> hgetall track:16
+1) "id"
+2) "16"
+3) "name"
+4) "Dog Eat Dog"
+5) "duration"
+6) "3:35.0"
+7) "storagesize"
+8) "6.71MB"
+```---
+Title: Data pipelines
+aliases: /integrate/redis-data-integration/ingest/data-pipelines/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how an RDI pipeline can transform source data before writing
+group: di
+hideListLinks: false
+linkTitle: Data pipelines
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 30
+---
+---
+Title: Observability
+aliases: /integrate/redis-data-integration/ingest/observability/
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: Learn how to monitor RDI
+group: di
+hideListLinks: false
+linkTitle: Observability
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+RDI reports metrics about its operation using
+[Prometheus exporter endpoints](https://prometheus.io/docs/instrumenting/exporters/).
+You can connect to the endpoints with
+[Prometheus](https://prometheus.io/docs/prometheus/latest/getting_started/)
+to query the metrics and plot simple graphs or with
+[Grafana](https://grafana.com/) to produce more complex visualizations and
+dashboards.
+
+RDI exposes two endpoints, one for [CDC collector metrics](#collector-metrics) and
+another for [stream processor metrics](#stream-processor-metrics).
+The sections below explain these sets of metrics in more detail.
+See the
+[architecture overview]({{< relref "/integrate/redis-data-integration/architecture#overview" >}})
+for an introduction to these concepts.
+
+{{< note >}}If you don't use Prometheus or Grafana, you can still see
+RDI metrics with the RDI monitoring screen in Redis Insight or with the
+[`redis-di status`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-status" >}})
+command from the CLI.{{< /note >}}
+
+## Collector metrics
+
+The endpoint for the collector metrics is `https://<RDI_HOST>/metrics/collector-source`
+
+These metrics are divided into three groups:
+
+- **Pipeline state**: metrics about the pipeline mode and connectivity
+- **Data flow counters**: counters for data breakdown per source table
+- **Processing performance**: processing speed of RDI micro batches
+  
+## Stream processor metrics
+
+The endpoint for the stream processor metrics is `https://<RDI_HOST>/metrics/rdi`
+
+RDI reports metrics during the two main phases of the ingest pipeline, the *snapshot*
+phase and the *change data capture (CDC)* phase. (See the
+[pipeline lifecycle]({{< relref "/integrate/redis-data-integration/data-pipelines/data-pipelines" >}})
+docs for more information). The table below shows the full set of metrics that
+RDI reports. 
+
+| Metric | Phase |
+|:-- |:-- |
+| CapturedTables | Both |
+| Connected | CDC |
+| LastEvent | Both |
+| LastTransactionId | CDC |
+| MilliSecondsBehindSource | CDC |
+| MilliSecondsSinceLastEvent | Both |
+| NumberOfCommittedTransactions | CDC |
+| NumberOfEventsFiltered | Both |
+| QueueRemainingCapacity | Both |
+| QueueTotalCapacity | Both |
+| RemainingTableCount | Snapshot |
+| RowsScanned | Snapshot |
+| SnapshotAborted | Snapshot |
+| SnapshotCompleted | Snapshot |
+| SnapshotDurationInSeconds | Snapshot |
+| SnapshotPaused | Snapshot |
+| SnapshotPausedDurationInSeconds | Snapshot |
+| SnapshotRunning | Snapshot |
+| SourceEventPosition | CDC |
+| TotalNumberOfCreateEventsSeen | CDC |
+| TotalNumberOfDeleteEventsSeen | CDC |
+| TotalNumberOfEventsSeen | Both |
+| TotalNumberOfUpdateEventsSeen | CDC |
+| TotalTableCount | Snapshot |
+
+## RDI logs
+
+RDI uses [fluentd](https://www.fluentd.org/) and
+[logrotate](https://linux.die.net/man/8/logrotate) to ship and rotate logs
+for its Kubernetes (K8s) components.
+So whenever a containerized component is removed by the RDI operator process or by K8s,
+the logs are available for you to inspect.
+By default, RDI stores logs in the host VM file system at `/opt/rdi/logs`.
+The logs are recorded at the minimum `INFO` level and get rotated when they reach a size of 100MB.
+RDI retains the last five log rotated files by default.
+Logs are in a straightforward text format, which lets you analyze them with several different observability tools.
+You can change the default log settings using the
+[`redis-di configure-rdi`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-configure-rdi" >}})
+command.
+
+## Dump support package
+
+If you ever need to send a comprehensive set of forensics data to Redis support then you should
+run the
+[`redis-di dump-support-package`]({{< relref "/integrate/redis-data-integration/reference/cli/redis-di-dump-support-package" >}})
+command from the CLI. See
+[Troubleshooting]({{< relref "/integrate/redis-data-integration/troubleshooting#dump-support-package" >}})
+for more information.
+---
+Title: JMESPath custom functions
+aliases: /integrate/redis-data-integration/ingest/reference/jmespath-custom-functions/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: JMESPath custom function reference
+group: di
+linkTitle: JMESPath custom functions
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 40
+---
+
+| Function             | Description                                                                                                                         | Example                                                                                                                                                                                                  | Comments                                                                                                                                                         |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `base64_decode`      | Decodes a base64(RFC 4648) encoded string                                                                                           | Input: `{"encoded": "SGVsbG8gV29ybGQh"}` <br /> Expression: `base64_decode(encoded)` <br /> Output: `Hello World!`                                                                                       |                                                                                                                                                                  |
+| `capitalize`         | Capitalizes all the words in the string                                                                                             | Input: `{"name": "john doe"}` <br /> Expression: `capitalize(name)` <br /> Output: `John Doe`                                                                                                            |                                                                                                                                                                  |
+| `concat`             | Concatenates an array of variables or literals                                                                                      | Input: `{"fname": "john", "lname": "doe"}` <br /> Expression: `concat([fname, ' ' ,lname])` <br /> Output: `john doe`                                                                                    | This is equivalent to the more verbose built-in expression: `' '.join([fname,lname])`                                                                            |
+| `filter_entries`     | Filters entries in a dictionary (object) using the given JMESPath predicate                                                         | Input: `{ "name": "John", "age": 30, "country": "US", "score": 15}` <br /> Expression: `` filter_entries(@, `key == 'name' \|\| key == 'age'`)``<br /> Output:`{"name": "John", "age": 30 }`             |                                                                                                                                                                  |
+| `from_entries`       | Converts an array of objects with `key` and `value` properties into a single object                                                 | Input: `[{"key": "name", "value": "John"}, {"key": "age", "value": 30}, {"key": "city", "value": null}]` <br /> Expression: `from_entries(@)` <br /> Output: `{"name": "John", "age": 30, "city": null}` |                                                                                                                                                                  |
+| `hash`               | Calculates a hash using the `hash_name` hash function and returns its hexadecimal representation                                    | Input: `{"some_str": "some_value"}` <br /> Expression: `hash(some_str, &#96;sha1&#96;)` <br /> Output: `8c818171573b03feeae08b0b4ffeb6999e3afc05`                                                        | Supported algorithms: sha1 (default), sha256, md5, sha384, sha3_384, blake2b, sha512, sha3_224, sha224, sha3_256, sha3_512, blake2s                              |
+| `in`                 | Checks if an element matches any value in a list of values                                                                          | Input: `{"el": "b"}` <br /> Expression: `in(el, `["a", "b", "c"]`)` <br /> Output: `True`                                                                                                                |                                                                                                                                                                  |
+| `left`               | Returns a specified number of characters from the start of a given text string                                                      | Input: `{"greeting": "hello world!"}` <br /> Expression: `left(greeting, `5`)` <br /> Output: `hello`                                                                                                    |                                                                                                                                                                  |
+| `lower`              | Converts all uppercase characters in a string into lowercase characters                                                             | Input: `{"fname": "John"}` <br /> Expression: `lower(fname)` <br /> Output: `john`                                                                                                                       |                                                                                                                                                                  |
+| `mid`                | Returns a specified number of characters from the middle of a given text string                                                     | Input: `{"greeting": "hello world!"}` <br /> Expression: `mid(greeting, `4`, `3`)` <br /> Output: `o w`                                                                                                  |                                                                                                                                                                  |
+| `json_parse`         | Returns parsed object from the given json string                                                                                    | Input: `{"data": '{"greeting": "hello world!"}'}` <br /> Expression: `parse_json(data)` <br /> Output: `{"greeting": "hello world!"}`                                                                    |                                                                                                                                                                  |
+| `regex_replace`      | Replaces a string that matches a regular expression                                                                                 | Input: `{"text": "Banana Bannnana"}` <br /> Expression: `regex_replace(text, 'Ban\w+', 'Apple Apple')` <br /> Output: `Apple Apple`                                                                      |                                                                                                                                                                  |
+| `replace`            | Replaces all the occurrences of a substring with a new one                                                                          | Input: `{"sentence": "one four three four!"}` <br /> Expression: `replace(sentence, 'four', 'two')` <br /> Output: `one two three two!`                                                                  |                                                                                                                                                                  |
+| `right`              | Returns a specified number of characters from the end of a given text string                                                        | Input: `{"greeting": "hello world!"}` <br /> Expression: `right(greeting, `6`)` <br /> Output: `world!`                                                                                                  |                                                                                                                                                                  |
+| `split`              | Splits a string into a list of strings after breaking the given string by the specified delimiter (comma by default)                | Input: `{"departments": "finance,hr,r&d"}` <br /> Expression: `split(departments)` <br /> Output: `['finance', 'hr', 'r&d']`                                                                             | Default delimiter is comma - a different delimiter can be passed to the function as the second argument, for example: `split(departments, ';')`                  |
+| `time_delta_days`    | Returns the number of days between a given `dt` and now (positive) or the number of days that have passed from now (negative)       | Input: `{"dt": '2021-10-06T18:56:16.701670+00:00'}` <br /> Expression: `time_delta_days(dt)` <br /> Output: `365`                                                                                        | If `dt` is a string, ISO datetime (2011-11-04T00:05:23+04:00, for example) is assumed. If `dt` is a number, Unix timestamp (1320365123, for example) is assumed. |
+| `time_delta_seconds` | Returns the number of seconds between a given `dt` and now (positive) or the number of seconds that have passed from now (negative) | Input: `{"dt": '2021-10-06T18:56:16.701670+00:00'}` <br /> Expression: `time_delta_days(dt)` <br /> Output: `31557600`                                                                                   | If `dt` is a string, ISO datetime (2011-11-04T00:05:23+04:00, for example) is assumed. If `dt` is a number, Unix timestamp (1320365123, for example) is assumed. |
+| `to_entries`         | Converts a given object into an array of objects with `key` and `value` properties                                                  | Input: `{"name": "John", "age": 30, "city": null}` <br /> Expression: `to_entries(@)` <br /> Output: `[{"key": "name", "value": "John"}, {"key": "age", "value": 30}, {"key": "city", "value": null}]`   |                                                                                                                                                                  |
+| `upper`              | Converts all lowercase characters in a string into uppercase characters                                                             | Input: `{"fname": "john"}` <br /> Expression: `upper(fname)` <br /> Output: `JOHN`                                                                                                                       |                                                                                                                                                                  |
+| `uuid`               | Generates a random UUID4 and returns it as a string in standard format                                                              | Input: None <br /> Expression: `uuid()` <br /> Output: `3264b35c-ff5d-44a8-8bc7-9be409dac2b7`                                                                                                            |                                                                                                                                                                  |
+---
+Title: redis-di delete-all-contexts
+linkTitle: redis-di delete-all-contexts
+description: Deletes all contexts
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di delete-all-contexts [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. Skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di delete-all-contexts [OPTIONS]
+
+  Deletes all contexts
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  -f, --force                     Force operation. Skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di deploy
+linkTitle: redis-di deploy
+description: Deploys the RDI configurations including target
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di deploy [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `.`
+  - Usage: `--dir`
+
+  Directory containing RDI configuration
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di deploy [OPTIONS]
+
+  Deploys the RDI configurations including target
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --dir TEXT                      Directory containing RDI configuration
+                                  [default: .]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di list-jobs
+linkTitle: redis-di list-jobs
+description: Lists transformation engine's jobs
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di list-jobs [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di list-jobs [OPTIONS]
+
+  Lists transformation engine's jobs
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di stop
+linkTitle: redis-di stop
+description: Stops the pipeline
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di stop [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di stop [OPTIONS]
+
+  Stops the pipeline
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di get-rejected
+linkTitle: redis-di get-rejected
+description: Returns all the stored rejected entries
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di get-rejected [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `max_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--max-records`
+
+  Maximum rejected records per DLQ
+
+- `oldest`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--oldest
+-o`
+
+  Displays the oldest rejected records. If omitted, most recent records will be retrieved
+
+- `dlq_name`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--dlq-name`
+
+  Only prints the rejected records for the specified DLQ (Dead Letter Queue) name
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di get-rejected [OPTIONS]
+
+  Returns all the stored rejected entries
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --max-records INTEGER RANGE     Maximum rejected records per DLQ  [x>=1]
+  -o, --oldest                    Displays the oldest rejected records. If
+                                  omitted, most recent records will be
+                                  retrieved
+  --dlq-name TEXT                 Only prints the rejected records for the
+                                  specified DLQ (Dead Letter Queue) name
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di dump-support-package
+linkTitle: redis-di dump-support-package
+description: Dumps RDI support package
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di dump-support-package [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `.`
+  - Usage: `--dir`
+
+  Directory where the support file should be generated
+
+- `dump_rejected`:
+
+  - Type: INT
+  - Default: `none`
+  - Usage: `--dump-rejected`
+
+  Dumps rejected records
+
+- `trace_timeout`:
+
+  - Type: <IntRange 1<=x<=600>
+  - Default: `none`
+  - Usage: `--trace-timeout`
+
+  Stops the trace after exceeding this timeout (in seconds)
+
+- `max_change_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `10`
+  - Usage: `--max-change-records`
+
+  Maximum traced change records
+
+- `trace_only_rejected`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--trace-only-rejected`
+
+  Trace only rejected change records
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di dump-support-package [OPTIONS]
+
+  Dumps RDI support package
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --dir TEXT                      Directory where the support file should be
+                                  generated  [default: .]
+  --dump-rejected INTEGER         Dumps rejected records
+  --trace-timeout INTEGER RANGE   Stops the trace after exceeding this timeout
+                                  (in seconds)  [1<=x<=600]
+  --max-change-records INTEGER RANGE
+                                  Maximum traced change records  [x>=1]
+  --trace-only-rejected           Trace only rejected change records
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di list-contexts
+linkTitle: redis-di list-contexts
+description: Lists all saved contexts
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di list-contexts [OPTIONS]
+```
+
+## Options
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di list-contexts [OPTIONS]
+
+  Lists all saved contexts
+
+Options:
+  --help  Show this message and exit.
+```
+---
+Title: redis-di set-secret
+linkTitle: redis-di set-secret
+description: Creates a secret of a specified key
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## 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`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `key` (REQUIRED):
+
+  - Type: Choice(['RDI_REDIS_USERNAME', 'RDI_REDIS_PASSWORD', 'RDI_REDIS_CACERT', 'RDI_REDIS_CERT', 'RDI_REDIS_KEY', 'RDI_REDIS_KEY_PASSPHRASE', 'SOURCE_DB_USERNAME', 'SOURCE_DB_PASSWORD', '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'])
+  - Default: `none`
+  - Usage: `key`
+
+- `value`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `value`
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+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]
+
+  Creates a secret of a specified key
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di add-context
+linkTitle: redis-di add-context
+description: Adds a new context
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di add-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di add-context [OPTIONS] CONTEXT_NAME
+
+  Adds a new context
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di delete-context
+linkTitle: redis-di delete-context
+description: Deletes a context
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di delete-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. Skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di delete-context [OPTIONS] CONTEXT_NAME
+
+  Deletes a context
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  -f, --force                     Force operation. Skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di install
+linkTitle: redis-di install
+description: Installs RDI
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di install [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `warning`
+  - Usage: `--log-level
+-l`
+
+- `file`:
+
+  - Type: <click.types.Path object>
+  - Default: `none`
+  - Usage: `-f
+--file`
+
+  Path to a YAML configuration file for silent installation
+
+- `installation_dir`:
+
+  - Type: <click.types.Path object>
+  - Default: `none`
+  - Usage: `--installation-dir`
+
+  Custom installation directory
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di install [OPTIONS]
+
+  Installs RDI
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: WARNING]
+  -f, --file FILE                 Path to a YAML configuration file for silent
+                                  installation
+  --installation-dir DIRECTORY    Custom installation directory
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di set-context
+linkTitle: redis-di set-context
+description: Sets a context to be the active one
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di set-context [OPTIONS] CONTEXT_NAME
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `context_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `context-name`
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di set-context [OPTIONS] CONTEXT_NAME
+
+  Sets a context to be the active one
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di configure-rdi
+linkTitle: redis-di configure-rdi
+description: Configures RDI db connection credentials
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di configure-rdi [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `rdi_log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `none`
+  - Usage: `--rdi-log-level`
+
+  Log level for RDI components
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di configure-rdi [OPTIONS]
+
+  Configures RDI db connection credentials
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --rdi-log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  Log level for RDI components
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di start
+linkTitle: redis-di start
+description: Starts the pipeline
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di start [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di start [OPTIONS]
+
+  Starts the pipeline
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di reset
+linkTitle: redis-di reset
+description: Resets the pipeline into initial full sync mode
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di reset [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. Skips verification prompts
+
+- `pause_for_confirmation`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--pause-for-confirmation`
+
+  Pause for user confirmation if manual shutdown of collector required
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di reset [OPTIONS]
+
+  Resets the pipeline into initial full sync mode
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -f, --force                     Force operation. Skips verification prompts
+  --pause-for-confirmation        Pause for user confirmation if manual
+                                  shutdown of collector required
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di upgrade
+linkTitle: redis-di upgrade
+description: Upgrades RDI without losing data or downtime
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di upgrade [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `force`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--force
+-f`
+
+  Force operation. Skips verification prompts
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di upgrade [OPTIONS]
+
+  Upgrades RDI without losing data or downtime
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -f, --force                     Force operation. Skips verification prompts
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di status
+linkTitle: redis-di status
+description: Displays the status of the pipeline end to end
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di status [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_namespace`:
+
+  - Type: STRING
+  - Default: `rdi`
+  - Usage: `--rdi-namespace`
+
+  RDI Kubernetes namespace
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `live`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--live
+-l`
+
+  Live data flow monitoring
+
+- `page_number`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--page-number
+-p`
+
+  Set the page number (live mode only)
+
+- `page_size`:
+
+  - Type: <IntRange x>=1>
+  - Default: `none`
+  - Usage: `--page-size
+-s`
+
+  Set the page size (live mode only)
+
+- `ingested_only`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--ingested-only
+-i`
+
+  Display ingested data streams (live mode only)
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di status [OPTIONS]
+
+  Displays the status of the pipeline end to end
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-namespace TEXT            RDI Kubernetes namespace  [default: rdi]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  -l, --live                      Live data flow monitoring
+  -p, --page-number INTEGER RANGE
+                                  Set the page number (live mode only)  [x>=1]
+  -s, --page-size INTEGER RANGE   Set the page size (live mode only)  [x>=1]
+  -i, --ingested-only             Display ingested data streams (live mode
+                                  only)
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di
+linkTitle: redis-di
+description: A command line tool to manage & configure Redis Data Integration
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di [OPTIONS] COMMAND [ARGS]...
+```
+
+## Options
+
+- `version`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--version`
+
+  Show the version and exit.
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di [OPTIONS] COMMAND [ARGS]...
+
+  A command line tool to manage & configure Redis Data Integration
+
+Options:
+  --version  Show the version and exit.
+  --help     Show this message and exit.
+
+Commands:
+  add-context           Adds a new context
+  configure-rdi         Configures RDI db connection credentials
+  delete-all-contexts   Deletes all contexts
+  delete-context        Deletes a context
+  deploy                Deploys the RDI configurations including target
+  describe-job          Describes a transformation engine's job
+  dump-support-package  Dumps RDI support package
+  get-rejected          Returns all the stored rejected entries
+  install               Installs RDI
+  list-contexts         Lists all saved contexts
+  list-jobs             Lists transformation engine's jobs
+  reset                 Resets the pipeline into initial full sync mode
+  scaffold              Generates configuration files for RDI
+  set-context           Sets a context to be the active one
+  set-secret            Creates a secret of a specified key
+  start                 Starts the pipeline
+  status                Displays the status of the pipeline end to end
+  stop                  Stops the pipeline
+  trace                 Starts a trace session for troubleshooting data...
+  upgrade               Upgrades RDI without losing data or downtime
+```
+---
+Title: redis-di describe-job
+linkTitle: redis-di describe-job
+description: Describes a transformation engine's job
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di describe-job [OPTIONS] JOB_NAME
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `job_name` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `job-name`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di describe-job [OPTIONS] JOB_NAME
+
+  Describes a transformation engine's job
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --help                          Show this message and exit.
+```
+---
+Title: redis-di scaffold
+linkTitle: redis-di scaffold
+description: Generates configuration files for RDI
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di scaffold [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `db_type` (REQUIRED):
+
+  - Type: Choice([<DbType.CASSANDRA: 'cassandra'>, <DbType.MARIADB: 'mariadb'>, <DbType.MONGODB: 'mongodb'>, <DbType.MYSQL: 'mysql'>, <DbType.ORACLE: 'oracle'>, <DbType.POSTGRESQL: 'postgresql'>, <DbType.SQLSERVER: 'sqlserver'>])
+  - Default: `none`
+  - Usage: `--db-type`
+
+  DB type
+
+  Output to directory or stdout
+
+- `directory`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--dir`
+
+  Directory containing RDI configuration
+
+- `preview`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--preview`
+
+  Print the content of the scaffolded config file to CLI output
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di scaffold [OPTIONS]
+
+  Generates configuration files for RDI
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --db-type [cassandra|mariadb|mongodb|mysql|oracle|postgresql|sqlserver]
+                                  DB type  [required]
+  Output formats: [mutually_exclusive, required]
+                                  Output to directory or stdout
+    --dir TEXT                    Directory containing RDI configuration
+    --preview TEXT                Print the content of the scaffolded config
+                                  file to CLI output
+  --help                          Show this message and exit.
+```
+---
+Title: CLI reference
+aliases: /integrate/redis-data-integration/ingest/reference/cli/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Reference for the RDI CLI commands
+group: di
+hideListLinks: false
+linkTitle: CLI commands
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 60
+---
+---
+Title: redis-di trace
+linkTitle: redis-di trace
+description: Starts a trace session for troubleshooting data transformation
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+## Usage
+
+```
+Usage: redis-di trace [OPTIONS]
+```
+
+## Options
+
+- `log_level`:
+
+  - Type: Choice(['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'])
+  - Default: `info`
+  - Usage: `--log-level
+-l`
+
+- `rdi_host` (REQUIRED):
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-host`
+
+  Host/IP of RDI Database
+
+- `rdi_port` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=65535>
+  - Default: `none`
+  - Usage: `--rdi-port`
+
+  Port of RDI Database
+
+- `rdi_user`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-user`
+
+  RDI Database Username
+
+- `rdi_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-password`
+
+  RDI Database Password
+
+- `rdi_key`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key`
+
+  Private key file to authenticate with
+
+- `rdi_cert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cert`
+
+  Client certificate file to authenticate with
+
+- `rdi_cacert`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-cacert`
+
+  CA certificate file to verify with
+
+- `rdi_key_password`:
+
+  - Type: STRING
+  - Default: `none`
+  - Usage: `--rdi-key-password`
+
+  Password for unlocking an encrypted private key
+
+- `max_change_records`:
+
+  - Type: <IntRange x>=1>
+  - Default: `10`
+  - Usage: `--max-change-records`
+
+  Maximum traced change records
+
+- `timeout` (REQUIRED):
+
+  - Type: <IntRange 1<=x<=600>
+  - Default: `20`
+  - Usage: `--timeout`
+
+  Stops the trace after exceeding this timeout (in seconds)
+
+- `trace_only_rejected`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--trace-only-rejected`
+
+  Trace only rejected change records
+
+- `help`:
+
+  - Type: BOOL
+  - Default: `false`
+  - Usage: `--help`
+
+  Show this message and exit.
+
+## CLI help
+
+```
+Usage: redis-di trace [OPTIONS]
+
+  Starts a trace session for troubleshooting data transformation
+
+Options:
+  -l, --log-level [TRACE|DEBUG|INFO|WARNING|ERROR|CRITICAL]
+                                  [default: INFO]
+  --rdi-host TEXT                 Host/IP of RDI Database  [required]
+  --rdi-port INTEGER RANGE        Port of RDI Database  [1<=x<=65535;
+                                  required]
+  --rdi-user TEXT                 RDI Database Username
+  --rdi-password TEXT             RDI Database Password
+  --rdi-key TEXT                  Private key file to authenticate with
+  --rdi-cert TEXT                 Client certificate file to authenticate with
+  --rdi-cacert TEXT               CA certificate file to verify with
+  --rdi-key-password TEXT         Password for unlocking an encrypted private
+                                  key
+  --max-change-records INTEGER RANGE
+                                  Maximum traced change records  [x>=1]
+  --timeout INTEGER RANGE         Stops the trace after exceeding this timeout
+                                  (in seconds)  [default: 20; 1<=x<=600;
+                                  required]
+  --trace-only-rejected           Trace only rejected change records
+  --help                          Show this message and exit.
+```
+---
+Title: Redis Data Integration configuration file
+linkTitle: RDI configuration file
+description: Redis Data Integration configuration file reference
+weight: 10
+alwaysopen: false
+categories: ["redis-di"]
+aliases:
+---
+
+Configuration file for Redis Data Integration (RDI) source collectors and target connections
+
+**Properties**
+
+| Name                                                              | Type             | Description                                                                                                                                                               | Required |
+| ----------------------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
+| [**sources**](#sources)<br/>(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<br/> |          |
+| [**processors**](#processors)<br/>(Data processing configuration) | `object`, `null` | Configuration settings that control how data is processed, including batch sizes, error handling, and performance tuning<br/>                                             |          |
+| [**targets**](#targets)<br/>(Target connections)                  | `object`         | Configuration for target Redis databases where processed data will be written<br/>                                                                                        |          |
+| [**secret\-providers**](#secret-providers)<br/>(Secret providers) | `object`         |                                                                                                                                                                           |          |
+
+<a name="sources"></a>
+
+## sources: Source collectors
+
+Defines source collectors and their configurations. Each key represents a unique source identifier, and its value contains specific configuration for that collector
+
+**Properties (Pattern)**
+
+| Name     | Type | Description | Required |
+| -------- | ---- | ----------- | -------- |
+| **\.\*** |      |             |          |
+
+<a name="processors"></a>
+
+## processors: Data processing configuration
+
+Configuration settings that control how data is processed, including batch sizes, error handling, and performance tuning
+
+**Properties**
+
+| Name                                                                 | Type                | Description                                                                                                                                                                                                                          | Required |
+| -------------------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- |
+| **on_failed_retry_interval**<br/>(Retry interval on failure)         | `integer`, `string` | Number of seconds to wait before retrying a failed operation<br/>Default: `5`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                          |          |
+| **read_batch_size**                                                  | `integer`, `string` | Maximum number of records to process in a single batch<br/>Default: `2000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                             |          |
+| **debezium_lob_encoded_placeholder**<br/>(Debezium LOB placeholder)  | `string`            | Placeholder value for LOB fields in Debezium<br/>Default: `"__debezium_unavailable_value"`<br/>                                                                                                                                      |          |
+| **dedup**<br/>(Enable deduplication)                                 | `boolean`           | Enable the deduplication mechanism to handle duplicate records<br/>Default: `false`<br/>                                                                                                                                             |          |
+| **dedup_max_size**<br/>(Deduplication set size)                      | `integer`           | Maximum number of entries to store in the deduplication set<br/>Default: `1024`<br/>Minimum: `1`<br/>                                                                                                                                |          |
+| **dedup_strategy**<br/>(Deduplication strategy)                      | `string`            | (DEPRECATED)<br/>Property 'dedup_strategy' is now deprecated. The only supported strategy is 'ignore'. Please remove from the configuration.<br/>Default: `"ignore"`<br/>Enum: `"reject"`, `"ignore"`<br/>                           |          |
+| **duration**<br/>(Batch duration limit)                              | `integer`, `string` | Maximum time in milliseconds to wait for a batch to fill before processing<br/>Default: `100`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                          |          |
+| **write_batch_size**                                                 | `integer`, `string` | Maximum number of records to write to target Redis database in a single batch<br/>Default: `200`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                       |          |
+| **error_handling**<br/>(Error handling strategy)                     | `string`            | Strategy for handling errors: ignore to skip errors, dlq to store rejected messages in dead letter queue<br/>Default: `"dlq"`<br/>Pattern: `^\${.*}$\|ignore\|dlq`<br/>                                                              |          |
+| **dlq_max_messages**<br/>(DLQ message limit)                         | `integer`, `string` | Maximum number of messages to store in dead letter queue per stream<br/>Default: `1000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                |          |
+| **target_data_type**<br/>(Target Redis data type)                    | `string`            | Data type to use in Redis: hash for Redis Hash, json for RedisJSON (requires RedisJSON module)<br/>Default: `"hash"`<br/>Pattern: `^\${.*}$\|hash\|json`<br/>                                                                        |          |
+| **json_update_strategy**                                             | `string`            | (DEPRECATED)<br/>Property 'json_update_strategy' will be deprecated in future releases. Use 'on_update' job-level property to define the json update strategy.<br/>Default: `"replace"`<br/>Pattern: `^\${.*}$\|replace\|merge`<br/> |          |
+| **initial_sync_processes**                                           | `integer`, `string` | Number of parallel processes for performing initial data synchronization<br/>Default: `4`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>Maximum: `32`<br/>                                                                            |          |
+| **idle_sleep_time_ms**<br/>(Idle sleep interval)                     | `integer`, `string` | Time in milliseconds to sleep between processing batches when idle<br/>Default: `200`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>Maximum: `999999`<br/>                                                                            |          |
+| **idle_streams_check_interval_ms**<br/>(Idle streams check interval) | `integer`, `string` | Time in milliseconds between checking for new streams when processor is idle<br/>Default: `1000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>Maximum: `999999`<br/>                                                                 |          |
+| **busy_streams_check_interval_ms**<br/>(Busy streams check interval) | `integer`, `string` | Time in milliseconds between checking for new streams when processor is busy<br/>Default: `5000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>Maximum: `999999`<br/>                                                                 |          |
+| **wait_enabled**<br/>(Enable replica wait)                           | `boolean`           | Enable verification that data has been written to replica shards<br/>Default: `false`<br/>                                                                                                                                           |          |
+| **wait_timeout**<br/>(Replica wait timeout)                          | `integer`, `string` | Maximum time in milliseconds to wait for replica write verification<br/>Default: `1000`<br/>Pattern: `^\${.*}$`<br/>Minimum: `1`<br/>                                                                                                |          |
+| **retry_on_replica_failure**                                         | `boolean`           | Continue retrying writes until successful replication to replica shards is confirmed<br/>Default: `true`<br/>                                                                                                                        |          |
+
+**Additional Properties:** not allowed  
+<a name="targets"></a>
+
+## targets: Target connections
+
+Configuration for target Redis databases where processed data will be written
+
+**Properties (Pattern)**
+
+| Name     | Type | Description | Required |
+| -------- | ---- | ----------- | -------- |
+| **\.\*** |      |             |          |
+
+<a name="secret-providers"></a>
+
+## secret\-providers: Secret providers
+
+**Properties (Pattern)**
+
+| Name                                                      | Type     | Description | Required |
+| --------------------------------------------------------- | -------- | ----------- | -------- |
+| [**\.\***](#secret-providers)<br/>(Secret provider entry) | `object` |             | yes      |
+
+<a name="secret-providers"></a>
+
+#### secret\-providers\.\.\*: Secret provider entry
+
+**Properties**
+
+| Name                                                                    | Type     | Description                   | Required |
+| ----------------------------------------------------------------------- | -------- | ----------------------------- | -------- |
+| **type**<br/>(Provider type)                                            | `string` | Enum: `"aws"`, `"vault"`<br/> | yes      |
+| [**parameters**](#secret-providersparameters)<br/>(Provider parameters) | `object` |                               | yes      |
+
+**Additional Properties:** not allowed  
+**Example**
+
+```yaml
+parameters:
+  objects:
+    - {}
+```
+
+<a name="secret-providersparameters"></a>
+
+##### secret\-providers\.\.\*\.parameters: Provider parameters
+
+**Properties**
+
+| Name                                                                          | Type       | Description | Required |
+| ----------------------------------------------------------------------------- | ---------- | ----------- | -------- |
+| [**objects**](#secret-providersparametersobjects)<br/>(Secrets objects array) | `object[]` |             | yes      |
+
+**Example**
+
+```yaml
+objects:
+  - {}
+```
+
+<a name="secret-providersparametersobjects"></a>
+
+###### secret\-providers\.\.\*\.parameters\.objects\[\]: Secrets objects array
+
+**Items: Secret object**
+
+**No properties.**
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: filter
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/filter/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Filter records
+group: di
+linkTitle: filter
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Filter records
+
+**Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: filter
+    with:
+      language: sql
+      expression: age>20
+```
+---
+Title: map
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/map/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Map a record into a new output based on expressions
+group: di
+linkTitle: map
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Map a record into a new output based on expressions
+
+**Properties**
+
+| Name                          | Type               | Description                                   | Required |
+| ----------------------------- | ------------------ | --------------------------------------------- | -------- |
+| [**expression**](#expression) | `object`, `string` | Expression<br/>                               | yes      |
+| **language**                  | `string`           | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: map
+    with:
+      expression:
+        first_name: first_name
+        last_name: last_name
+        greeting: >-
+          'Hello ' || CASE WHEN gender = 'F' THEN 'Ms.' WHEN gender = 'M' THEN 'Mr.'
+          ELSE 'N/A' END || ' ' || full_name
+        country: country
+        full_name: full_name
+      language: sql
+```
+
+**Example**
+
+```yaml
+source:
+  table: customer
+transform:
+  - uses: map
+    with:
+      expression: |
+        {
+          "CustomerId": customer_id,
+          "FirstName": first_name,
+          "LastName": last_name,
+          "Company": company,
+          "Location":
+          {
+            "Street": address,
+            "City": city,
+            "State": state,
+            "Country": country,
+            "PostalCode": postal_code
+          },
+          "Phone": phone,
+          "Fax": fax,
+          "Email": email
+        }
+      language: jmespath
+```
+
+<a name="expression"></a>
+
+## expression: object
+
+Expression
+
+**No properties.**
+---
+Title: remove_field
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/remove_field/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Remove fields
+group: di
+linkTitle: remove_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Remove fields
+
+**Option 1 (alternative):**
+Remove multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: remove_field
+    with:
+      fields:
+        - field: credit_card
+        - field: name.mname
+```
+
+**Option 2 (alternative):**
+Remove one field
+
+**Properties**
+
+| Name      | Type     | Description | Required |
+| --------- | -------- | ----------- | -------- |
+| **field** | `string` | Field<br/>  | yes      |
+
+**Additional Properties:** not allowed  
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: remove_field
+    with:
+      field: credit_card
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name      | Type     | Description | Required |
+| --------- | -------- | ----------- | -------- |
+| **field** | `string` | Field<br/>  | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: rename_field
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/rename_field/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Rename fields. All other fields remain unchanged.
+group: di
+linkTitle: rename_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Rename fields. All other fields remain unchanged.
+
+**Option 1 (alternative):**
+Rename multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed  
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      fields:
+        - from_field: name.lname
+          to_field: name.last_name
+        - from_field: name.fname
+          to_field: name.first_name
+```
+
+**Option 2 (alternative):**
+Rename one field
+
+**Properties**
+
+| Name           | Type     | Description     | Required |
+| -------------- | -------- | --------------- | -------- |
+| **from_field** | `string` | From field<br/> | yes      |
+| **to_field**   | `string` | To field<br/>   | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: rename_field
+    with:
+      from_field: name.lname
+      to_field: name.last_name
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name           | Type     | Description     | Required |
+| -------------- | -------- | --------------- | -------- |
+| **from_field** | `string` | From field<br/> | yes      |
+| **to_field**   | `string` | To field<br/>   | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: add_field
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/add_field/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Add fields to a record
+group: di
+linkTitle: add_field
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+Add fields to a record
+
+**Option 1 (alternative):**
+Add multiple fields
+
+**Properties**
+
+| Name                         | Type       | Description | Required |
+| ---------------------------- | ---------- | ----------- | -------- |
+| [**fields**](#option1fields) | `object[]` | Fields<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: add_field
+    with:
+      fields:
+        - field: name.full_name
+          language: jmespath
+          expression: concat([name.fname, ' ', name.lname])
+        - field: name.fname_upper
+          language: jmespath
+          expression: upper(name.fname)
+```
+
+**Option 2 (alternative):**
+Add one field
+
+**Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **field**      | `string` | Field<br/>                                    | yes      |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+source:
+  server_name: redislabs
+  schema: dbo
+  table: emp
+transform:
+  - uses: add_field
+    with:
+      field: country
+      language: sql
+      expression: country_code || ' - ' || UPPER(country_name)
+```
+
+<a name="option1fields"></a>
+
+## Option 1: fields\[\]: array
+
+Fields
+
+**Items**
+
+**Item Properties**
+
+| Name           | Type     | Description                                   | Required |
+| -------------- | -------- | --------------------------------------------- | -------- |
+| **field**      | `string` | Field<br/>                                    | yes      |
+| **expression** | `string` | Expression<br/>                               | yes      |
+| **language**   | `string` | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+
+**Item Additional Properties:** not allowed
+
+**Example**
+
+```yaml
+- {}
+```
+---
+Title: redis.lookup
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: Lookup data from Redis using the given command and key
+group: di
+linkTitle: redis.lookup
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 10
+---
+
+**Properties**
+
+| Name              | Type       | Description                                   | Required |
+| ----------------- | ---------- | --------------------------------------------- | -------- |
+| **connection**    | `string`   | Connection name                               | yes      |
+| **cmd**           | `string`   | The command to execute                        | yes      |
+| [**args**](#args) | `string[]` | Redis command arguments                       | yes      |
+| **language**      | `string`   | Language<br/>Enum: `"jmespath"`, `"sql"`<br/> | yes      |
+| **field**         | `string`   | The target field to write the result to<br/>  | yes      |
+
+**Additional Properties:** not allowed
+
+## args\[\]: Redis command arguments {#args}
+
+The list of expressions that produce arguments.
+
+**Items**
+
+**Item Type:** `string`
+---
+Title: Data transformation reference
+aliases: /integrate/redis-data-integration/ingest/reference/data-transformation/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: View reference material for RDI data transformations
+group: di
+hideListLinks: false
+linkTitle: Data transformation
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 60
+---
+---
+Title: Reference
+aliases: /integrate/redis-data-integration/ingest/reference/
+alwaysopen: false
+categories:
+  - docs
+  - integrate
+  - rs
+  - rdi
+description: View reference material for Redis Data Integration
+group: di
+hideListLinks: false
+linkTitle: Reference
+summary:
+  Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 60
+---
+---
+Title: RDI API Reference
+layout: rdiapireference
+type: page
+---
+---
+Title: Redis Data Integration
+aliases: /integrate/redis-data-integration/ingest
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+- rdi
+description: null
+group: di
+hideListLinks: false
+linkTitle: Redis Data Integration
+summary: Redis Data Integration keeps Redis in sync with the primary database in near
+  real time.
+type: integration
+weight: 1
+---
+
+This is the first General Availability version of Redis Data Integration (RDI).
+
+RDI's purpose is to help Redis customers sync Redis Enterprise with live data from their slow disk based databases in order to:
+
+- Meet the required speed and scale of read queries and provide an excellent and predictable user experience.
+- Save resources and time when building pipelines and coding data transformations.
+- Reduce the total cost of ownership by saving money on expensive database read replicas.
+
+If you use a relational database as the system of record for your app,
+you may eventually find
+that its performance doesn't scale well as your userbase grows. It may be
+acceptable for a few thousand users but for a few million, it can become a
+major problem. If you don't have the option of abandoning the relational
+database, you should consider using a fast
+database, such as Redis, to cache data from read queries. Since read queries
+are typically many times more common than writes, the cache will greatly
+improve performance and let your app scale without a major redesign.
+
+RDI keeps a Redis cache up to date with changes in the primary database, using a
+[*Change Data Capture (CDC)*](https://en.wikipedia.org/wiki/Change_data_capture) mechanism.
+It also lets you *transform* the data from relational tables into convenient
+and fast data structures that match your app's requirements. You specify the
+transformations using a configuration system, so no coding is necessary.
+
+{{<note>}}
+RDI is supported with Redis database or [CRDB](https://redis.io/active-active/) (Active Active Replication) targets.
+{{</note>}}
+
+## Features
+
+RDI provides enterprise-grade streaming data pipelines with the following features:
+
+- **Near realtime pipeline** - The CDC system captures changes in very short time intervals,
+  then ships and processes them in *micro-batches* to provide near real time updates to Redis.
+- **At least once guarantee** - RDI will deliver any change to the selected data set at least
+  once to the target Redis database.
+- **Data integrity** - RDI keeps the data change order per source table or unique key.
+- **High availability** - All stateless components have hot failover or quick automatic recovery.
+  RDI state is always highly available using Redis Enterprise replication.
+- **Easy to install and operate** - Use a self-documenting command line interface (CLI)
+  for all installation and day-two operations.
+- **No coding needed** - Create and test your pipelines using Redis Insight.
+- **Data-in-transit encryption** - RDI never persists data to disk. All data in-flight is
+  protected using TLS or mTLS connections.
+- **Observability - Metrics** - RDI collects data processing counters at source table granularity
+  along with data processing performance metrics. These are available via GUI, CLI and 
+  [Prometheus](https://prometheus.io/) endpoints.
+- **Observability - logs** - RDI saves rotating logs to a single folder. They are in a JSON format,
+  so you can collect and process them with your favorite observability tool.
+- **Backpressure mechanism** - RDI is designed to backoff writing data when the cache gets
+  disconnected, which prevents cascading failure. Since the change data is persisted in the source
+  database and Redis is very fast, RDI can easily catch up with missed changes after a short period of
+  disconnection. See [Backpressure mechanism]({{< relref "/integrate/redis-data-integration/architecture#backpressure-mechanism">}}) for more information.
+- **Recovering from full failure** - If the cache fails or gets disconnected for a long time,
+  RDI can reconstruct the cache data in Redis using a full snapshot of the defined dataset.
+- **High throughput** - Because RDI uses Redis for staging and writes to Redis as a target,
+  it has very high throughput. With a single processor core and records of about 1KB in size,
+  RDI processes around 10,000 records per second. While taking the initial full *snapshot* of
+  the source database, RDI automatically scales to a configurable number of processing units,
+  to fill the cache as fast as possible.
+
+## When to use RDI
+
+RDI is designed to support apps that must use a disk based database as the system of record
+but must also be fast and scalable. This is a common requirement for mobile and web
+apps with a rapidly-growing number of users; the performance of the main database is fine at first
+but it will soon struggle to handle the increasing demand without a cache.
+
+You should use RDI when:
+
+- You must use a slow database as the system of record for the app .
+- The app must always *write* its data to the slow database.
+- You already intend to use Redis for the app cache.
+- The data changes frequently in small increments.
+- Your app can tolerate *eventual* consistency of data in the Redis cache.
+
+You should *not* use RDI when:
+
+- You are migrating an existing data set into Redis only once.
+- The data is updated infrequently and in big batches.
+- Your app needs *immediate* cache consistency rather than *eventual* consistency.
+- The data is ingested from two replicas of Active-Active at the same time.
+- The app must *write* data to the Redis cache, which then updates the source database.
+- Your data set will only ever be small.
+
+## Supported source databases
+
+RDI can capture data from any of the following sources:
+
+{{< embed-md "rdi-supported-source-versions.md" >}}
+
+## Documentation
+
+Learn more about RDI from the other pages in this section:---
+LinkTitle: Datadog with Redis Enterprise
+Title: Datadog with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Datadog to your Redis Enterprise cluster using
+  the Redis Datadog Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Datadog to your Redis Enterprise cluster using
+  the Redis Datadog Integration.
+type: integration
+weight: 7
+---
+
+
+[Datadog](https://www.datadoghq.com/) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The Datadog Integration for Redis Enterprise uses Datadog's Integration API to connect to Redis metrics exporters. 
+The integration is based on the Datadog 
+[OpenMetrics integration](https://datadoghq.dev/integrations-core/base/openmetrics/) in their core API. This integration 
+enables Redis Enterprise users to export metrics directly to Datadog for analysis, and includes Redis-designed 
+dashboards for use in monitoring Redis Enterprise clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rc/redis-cloud-datadog.png" >}}
+## Install Redis' Datadog Integration for Redis Enterprise
+
+Installing the Datadog integration is a two-step process. Firstly, the installation must be part of your configuration. 
+Select 'Integrations' from the menu  in the Datadog portal and then enter 'Redis' in the search bar, then select 
+'Redis Enterprise by Redis, Inc.'. Next click 'Install Integration' in the top-right corner of the overview page. 
+Once it has been installed follow the instructions for adding an instance to the conf.yaml in 
+/etc/datadog-agent/conf.d/redis_cloud.d.
+
+After you have edited the conf.yaml file please restart the service and check its status:
+
+```shell
+sudo service datadog-agent restart
+```
+
+followed by:
+
+```shell
+sudo service datadog-agent status
+```
+
+to be certain that the service itself is running and did not encounter any problems. Next, check the output of the 
+service; in the terminal on the Datadog agent host run the following command:
+
+```shell
+tail -f /var/log/datadog/agent.log
+```
+
+It will take several minutes for data to reach Datadog. Finally, check the Datadog console by selecting 
+Infrastructure -> Host Map from the menu and then finding the host that is monitoring the Redis Enterprise instance. The host 
+should be present, and in its list of components there should be a section called 'rdse', which is the namespace used by 
+the Redis Enterprise integration, although this can take several minutes to appear. It is also possible to verify the metrics 
+by choosing Metrics -> Explorer from the menu and entering 'rdse.bdb_up'.
+
+## View metrics
+
+The Redis Enterprise Integration for Datadog contains pre-defined dashboards to aid in monitoring your Redis Enterprise deployment.
+
+The following dashboards are currently available:
+
+- Overview
+- Database
+- Node
+- Shard
+- Active-Active
+- Proxy
+- Proxy Threads
+
+
+## Monitor metrics
+
+See [Observability and monitoring guidance]({{< relref "/integrate/prometheus-with-redis-enterprise/observability" >}}) for monitoring details.
+
+---
+LinkTitle: redis-py
+Title: Python client for Redis
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis and Python
+group: library
+stack: true
+summary: redis-py is a Python library for Redis.
+title: redis-py
+type: integration
+weight: 1
+---
+
+Connect your Python application to a Redis database using the redis-py client library. 
+
+Refer to the complete [Python guide]({{< relref "/develop/clients/redis-py" >}}) to install, connect, and use redis-py.
+---
+Title: Dynatrace with Redis Cloud
+LinkTitle: Dynatrace with Redis Cloud
+categories:
+- docs
+- integrate
+- rs
+description: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Dynatrace to your Redis Cloud cluster using
+  the Redis Dynatrace Integration.
+group: observability
+summary: To collect, view, and monitor metrics data from your databases and other
+  cluster components, you can connect Dynatrace to your Redis Cloud cluster using
+  the Redis Dynatrace Integration.
+type: integration
+weight: 7
+---
+
+
+[Dynatrace](https://www.dynatrace.com/) is used by organizations of all sizes and across a wide range of industries to 
+enable digital transformation and cloud migration, drive collaboration among development, operations, security and 
+business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and 
+infrastructure, understand user behavior, and track key business metrics.
+
+The Redis Dynatrace Integration for Redis Cloud uses Prometheus remote write functionality to connect Prometheus data 
+sources to Dynatrace. This integration enables Redis Cloud users to export metrics to Dynatrace for analysis, 
+and includes Redis-designed dashboards for use in monitoring Redis Cloud clusters.
+
+This integration makes it possible to:
+- Collect and display metrics not available in the admin console
+- Set up automatic alerts for node or cluster events
+- Display these metrics alongside data from other systems
+
+{{< image filename="/images/rc/redis-cloud-dynatrace.png" >}}
+## Install Redis' Dynatrace Integration for Redis Cloud
+
+The Dynatrace Integration is based on a feature of the Prometheus data source. Prometheus can forward metrics on to 
+another destination using remote writes. This will require a Prometheus installation inside the same datacenter as the 
+Redis Cloud deployment.
+
+If you have not already created a VPC between the Redis Cloud cluster and the network in which the machine hosting 
+Prometheus lives you should do so now. Please visit [VPC Peering](https://redis.io/docs/latest/operate/rc/security/vpc-peering/) 
+and follow the instructions for the cloud platform of your choice.
+
+
+
+## View metrics
+
+The Redis Cloud Integration for Dynatrace contains pre-defined dashboards to aid in monitoring your Redis Enterprise deployment.
+
+The following dashboards are currently available:
+
+- Cluster: top-level statistics indicating the general health of the cluster
+- Database: performance metrics at the database level
+- Shard: low-level details of an individual shard
+- Active-Active: replication and performance for geo-replicated clusters
+- Proxy: network and command information regarding the proxy
+- Proxy Threads: processor usage information regarding the proxy's component threads 
+
+## Monitor metrics
+
+Dynatrace dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible 
+filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
+retrieve the relevant data before choosing one of the options in the 'cluster' section.
+
+Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list 
+of database names and ids; use the id value when filtering input to the dashboard. 
+
+
+
+---
+LinkTitle: jedis
+Title: Java client for Redis
+categories:
+- docs
+- integrate
+- oss
+- rs
+- rc
+description: Learn how to build with Redis and Java
+group: library
+stack: true
+summary: jedis is a Java library for Redis.
+title: jedis
+type: integration
+weight: 2
+---
+
+Connect your Java application to a Redis database using the Jedis client library. 
+
+Refer to the complete [Jedis guide]({{< relref "/develop/clients/jedis" >}}) to install, connect, and use Jedis.
+---
+title: Libraries and tools
+description: 
+linkTitle: Integrate
+---
+---
+categories:
+- docs
+- operate
+- redisinsight
+description: 'How to install Redis Insight on AWS EC2
+
+  '
+linkTitle: Install on AWS EC2
+title: Install on AWS EC2
+weight: 4
+---
+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.
+
+1. Navigate to EC2 under AWS Console.
+1. Click Launch Instance.
+1. Choose 64-bit Amazon Linux AMI.
+1. Choose at least a t2.medium instance. The size of the instance depends on the memory used by your ElastiCache instance that you want to analyze.
+1. Under Configure Instance:
+   * Choose the VPC that has your ElastiCache instances.
+   * Choose a subnet that has network access to your ElastiCache instances.
+   * Ensure that your EC2 instance has a public IP Address.
+   * Assign the IAM role that you created in Step 1.
+1. Under the storage section, allocate at least 100 GiB storage.
+1. Under security group, ensure that:
+    * Incoming traffic is allowed on port 5540
+    * Incoming traffic is allowed on port 22 only during installation
+1. Review and launch the ec2 instance.
+
+Step 2: Verify permissions and connectivity
+----------
+
+Next, verify that the EC2 instance has the required IAM permissions and can connect to ElastiCache Redis instances.
+
+1. SSH into the newly launched EC2 instance.
+1. Open a command prompt.
+1. Run the command `aws s3 ls`. This should list all S3 buckets.
+    1. If the `aws` command cannot be found, make sure your EC2 instance is based of Amazon Linux.
+1. Next, find the hostname of the ElastiCache instance you want to analyze and run the command `echo info | nc <redis host> 6379`.
+1. If you see some details about the ElastiCache Redis instance, you can proceed to the next step.
+1. If you cannot connect to redis, you should review your VPC, subnet, and security group settings.
+
+Step 3: Install Docker on EC2
+-------
+
+Next, install Docker on the EC2 instance. Run the following commands:
+
+1. `sudo yum update -y`
+1. `sudo yum install -y docker`
+1. `sudo service docker start`
+1. `sudo usermod -a -G docker ec2-user`
+1. Log out and log back in again to pick up the new docker group permissions.
+1. To verify, run `docker ps`. You should see some output without having to run `sudo`.
+
+Step 4: Run Redis Insight in the Docker container
+-------
+
+Finally, install Redis Insight using one of the options described below.
+
+1. If you do not want to persist your Redis Insight data:
+
+```bash
+docker run -d --name redisinsight -p 5540:5540 redis/redisinsight:latest
+```
+2. If you want to persist your Redis Insight data, first attach the Docker volume to the `/data` path and then run the following command:
+
+```bash
+docker run -d --name redisinsight -p 5540:5540 redis/redisinsight:latest -v redisinsight:/data
+```
+
+If the previous command returns a permission error, ensure that the user with `ID = 1000` has the necessary permission to access the volume provided (`redisinsight` in the command above).
+
+Find the IP Address of your EC2 instances and launch your browser at `http://<EC2 IP Address>:5540`. Accept the EULA and start using Redis Insight.
+
+Redis Insight also provides a health check endpoint at `http://<EC2 IP Address>:5540/api/health/` to monitor the health of the running container.
+
+Summary
+------
+
+In this guide, we installed Redis Insight on an AWS EC2 instance running Docker. As a next step, you should add an ElastiCache Redis Instance and then run the memory analysis.
+---
+categories:
+- docs
+- operate
+- redisinsight
+description: How to install Redis Insight on the desktop
+linkTitle: Install on desktop
+title: Install on desktop
+weight: 1
+---
+## Supported operating systems
+
+Redis Insight is supported on multiple operating systems:
+
+| Operating System | Supported Versions [^1] |
+|:---              |:---                     |
+| **Windows**      | Windows 11              |
+|                  | Windows 10              |
+| **macOS**        | macOS 15                |
+|                  | macOS 14                |
+|                  | macOS 13                |
+|                  | macOS 12                |
+|                  | macOS 11                |
+|                  | macOS 10.15             |
+| **Ubuntu Linux** | Ubuntu 24.04            |
+|                  | Ubuntu 23.10            |
+|                  | Ubuntu 22.04            |
+|                  | Ubuntu 20.04            |
+| **Debian Linux** | Debian 12               |
+|                  | Debian 11               |
+
+[^1]: Includes later versions of same major or major.minor release.
+
+## Install
+
+Redis Insight is available for download for free from this [web site](https://redis.io/insight/?utm_source=redisinsight&utm_medium=website&utm_campaign=install_redisinsight#insight-form).
+
+It is also available on:
+- Microsoft Store
+- Apple Store
+- Snapcraft
+- Flathub
+- [Docker Hub]({{< relref "/operate/redisinsight/install/install-on-docker" >}}).
+
+After installation, run the Redis Insight application in the same was as you would run other desktop applications.
+
+## Build
+
+Alternatively, you can also build Redis Insight from source. See the [wiki](https://github.com/RedisInsight/RedisInsight#build) for instructions.
+---
+categories:
+- docs
+- operate
+- redisinsight
+description: How to install Redis Insight on Kubernetes
+linkTitle: Install on Kubernetes
+title: Install on Kubernetes
+weight: 3
+---
+This tutorial shows how to install Redis Insight on [Kubernetes](https://kubernetes.io/) (K8s).
+This is an easy way to use Redis Insight with a [Redis Enterprise K8s deployment]({{< relref "operate/kubernetes/" >}}).
+
+## 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.
+
+1. Create a new file named `redisinsight.yaml` with the content below.
+
+```yaml
+# Redis Insight service with name 'redisinsight-service'
+apiVersion: v1
+kind: Service
+metadata:
+  name: redisinsight-service       # name should not be 'redisinsight'
+                                   # since the service creates
+                                   # environment variables that
+                                   # conflicts with redisinsight
+                                   # application's environment
+                                   # variables `RI_APP_HOST` and
+                                   # `RI_APP_PORT`
+spec:
+  type: LoadBalancer
+  ports:
+    - port: 80
+      targetPort: 5540
+  selector:
+    app: redisinsight
+---
+# Redis Insight deployment with name 'redisinsight'
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redisinsight #deployment name
+  labels:
+    app: redisinsight #deployment label
+spec:
+  replicas: 1 #a single replica pod
+  selector:
+    matchLabels:
+      app: redisinsight #which pods is the deployment managing, as defined by the pod template
+  template: #pod template
+    metadata:
+      labels:
+        app: redisinsight #label for pod/s
+    spec:
+      containers:
+
+      - name:  redisinsight #Container name (DNS_LABEL, unique)
+        image: redis/redisinsight:latest #repo/image
+        imagePullPolicy: IfNotPresent #Installs the latest Redis Insight version
+        volumeMounts:
+        - name: redisinsight #Pod volumes to mount into the container's filesystem. Cannot be updated.
+          mountPath: /data
+        ports:
+        - containerPort: 5540 #exposed container port and protocol
+          protocol: TCP
+      volumes:
+      - name: redisinsight
+        emptyDir: {} # node-ephemeral volume https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
+```
+
+2. Create the Redis Insight deployment and service:
+
+```sh
+kubectl apply -f redisinsight.yaml
+```
+
+3. Once the deployment and service are successfully applied and complete, access Redis Insight. This can be accomplished by using the `<external-ip>` of the service we created to reach Redis Insight.
+
+```sh
+$ kubectl get svc redisinsight-service
+NAME                   CLUSTER-IP       EXTERNAL-IP      PORT(S)         AGE
+redisinsight-service   <cluster-ip>     <external-ip>    80:32143/TCP    1m
+```
+
+4. If you are using minikube, run `minikube list` to list the service and access Redis Insight at `http://<minikube-ip>:<minikube-service-port>`.
+```
+$ minikube list
+|-------------|----------------------|--------------|---------------------------------------------|
+|  NAMESPACE  |         NAME         | TARGET PORT  |           URL                               |
+|-------------|----------------------|--------------|---------------------------------------------|
+| default     | kubernetes           | No node port |                                             |
+| default     | redisinsight-service |           80 | http://<minikube-ip>:<minikubeservice-port> |
+| kube-system | kube-dns             | No node port |                                             |
+|-------------|----------------------|--------------|---------------------------------------------|
+```
+
+## Create the Redis Insight deployment with persistant storage
+
+Below is an annotated YAML file that will create a Redis Insight
+deployment in a K8s cluster. It will assign a peristent volume created from a volume claim template.
+Write access to the container is configured in an init container. When using deployments
+with persistent writeable volumes, it's best to set the strategy to `Recreate`. Otherwise you may find yourself
+with two pods trying to use the same volume.
+
+1. Create a new file `redisinsight.yaml` with the content below.
+
+```yaml
+# Redis Insight service with name 'redisinsight-service'
+apiVersion: v1
+kind: Service
+metadata:
+  name: redisinsight-service       # name should not be 'redisinsight'
+                                   # since the service creates
+                                   # environment variables that
+                                   # conflicts with redisinsight
+                                   # application's environment
+                                   # variables `RI_APP_HOST` and
+                                   # `RI_APP_PORT`
+spec:
+  type: LoadBalancer
+  ports:
+    - port: 80
+      targetPort: 5540
+  selector:
+    app: redisinsight
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: redisinsight-pv-claim
+  labels:
+    app: redisinsight
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 2Gi
+  storageClassName: default
+---
+# Redis Insight deployment with name 'redisinsight'
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redisinsight #deployment name
+  labels:
+    app: redisinsight #deployment label
+spec:
+  replicas: 1 #a single replica pod
+  strategy:
+    type: Recreate
+  selector:
+    matchLabels:
+      app: redisinsight #which pods is the deployment managing, as defined by the pod template
+  template: #pod template
+    metadata:
+      labels:
+        app: redisinsight #label for pod/s
+    spec:
+      volumes:
+        - name: redisinsight
+          persistentVolumeClaim:
+            claimName: redisinsight-pv-claim
+      initContainers:
+        - name: init
+          image: busybox
+          command:
+            - /bin/sh
+            - '-c'
+            - |
+              chown -R 1000 /data
+          resources: {}
+          volumeMounts:
+            - name: redisinsight
+              mountPath: /data
+          terminationMessagePath: /dev/termination-log
+          terminationMessagePolicy: File
+      containers:
+        - name:  redisinsight #Container name (DNS_LABEL, unique)
+          image: redis/redisinsight:latest #repo/image
+          imagePullPolicy: IfNotPresent #Always pull image
+          volumeMounts:
+          - name: redisinsight #Pod volumes to mount into the container's filesystem. Cannot be updated.
+            mountPath: /data
+          ports:
+          - containerPort: 5540 #exposed container port and protocol
+            protocol: TCP
+```
+
+2. Create the Redis Insight deployment and service.
+
+```sh
+kubectl apply -f redisinsight.yaml
+```
+
+## Create the Redis Insight deployment without a service.
+
+Below is an annotated YAML file that will create a Redis Insight
+deployment in a K8s cluster.
+
+1. Create a new file redisinsight.yaml with the content below
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redisinsight # deployment name
+  labels:
+    app: redisinsight # deployment label
+spec:
+  replicas: 1 # a single replica pod
+  selector:
+    matchLabels:
+      app: redisinsight # which pods is the deployment managing, as defined by the pod template
+  template: # pod template
+    metadata:
+      labels:
+        app: redisinsight # label for pod/s
+    spec:
+      containers:
+      - name: redisinsight # Container name (DNS_LABEL, unique)
+        image: redis/redisinsight:latest # repo/image
+        imagePullPolicy: IfNotPresent # Always pull image
+        env:
+          # If there's a service named 'redisinsight' that exposes the
+          # deployment, we manually set `RI_APP_HOST` and
+          # `RI_APP_PORT` to override the service environment
+          # variables.
+          - name: RI_APP_HOST
+            value: "0.0.0.0"
+          - name: RI_APP_PORT
+            value: "5540"
+        volumeMounts:
+        - name: redisinsight # Pod volumes to mount into the container's filesystem. Cannot be updated.
+          mountPath: /data
+        ports:
+        - containerPort: 5540 # exposed container port and protocol
+          protocol: TCP
+        livenessProbe: # Probe to check container health
+          httpGet:
+            path: /healthcheck/ # exposed RI endpoint for healthcheck
+            port: 5540 # exposed container port
+          initialDelaySeconds: 5 # number of seconds to wait after the container starts to perform liveness probe
+          periodSeconds: 5 # period in seconds after which liveness probe is performed
+          failureThreshold: 1 # number of liveness probe failures after which container restarts
+      volumes:
+      - name: redisinsight
+        emptyDir: {} # node-ephemeral volume https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
+```
+
+2. Create the Redis Insight deployment
+
+```sh
+kubectl apply -f redisinsight.yaml
+```
+
+{{< alert title="Note" >}}
+If the deployment will be exposed by a service whose name is 'redisinsight', set `RI_APP_HOST` and `RI_APP_PORT` environment variables to override the environment variables created by the service.
+{{< /alert >}}
+
+## Run Redis Insight
+
+Once the deployment has been successfully applied and the deployment is complete, access Redis Insight. This can be accomplished by exposing the deployment as a K8s Service or by using port forwarding, as in the example below:
+
+```sh
+kubectl port-forward deployment/redisinsight 5540
+```
+
+Open your browser and point to <http://localhost:5540>
+---
+categories:
+- docs
+- operate
+- redisinsight
+description: How to install Redis Insight on Docker
+linkTitle: Install on Docker
+title: Install on Docker
+weight: 2
+---
+This tutorial shows how to install Redis Insight on [Docker](https://www.docker.com/) so you can use Redis Insight in development.
+See a separate guide for installing [Redis Insight on AWS]({{< relref "/operate/redisinsight/install/install-on-aws" >}}).
+
+## Install Docker
+
+The first step is to [install Docker for your operating system](https://docs.docker.com/install/). 
+
+## Run Redis Insight Docker image
+
+You can install Redis Insight using one of the options described below.
+
+1. If you do not want to persist your Redis Insight data:
+
+```bash
+docker run -d --name redisinsight -p 5540:5540 redis/redisinsight:latest
+```
+2. If you want to persist your Redis Insight data, first attach the Docker volume to the `/data` path and then run the following command:
+
+```bash
+docker run -d --name redisinsight -p 5540:5540 redis/redisinsight:latest -v redisinsight:/data
+```
+
+If the previous command returns a permission error, ensure that the user with `ID = 1000` has the necessary permissions to access the volume provided (`redisinsight` in the command above).
+
+Next, point your browser to `http://localhost:5540`.
+
+Redis Insight also provides a health check endpoint at `http://localhost:5540/api/health/` to monitor the health of the running container.
+---
+categories:
+- docs
+- operate
+- redisinsight
+description: Install Redis Insight on AWS, Docker, Kubernetes, and desktop
+linkTitle: Install Redis Insight
+title: Install Redis Insight
+weight: 3
+---
+
+This is a an installation guide. You'll learn how to install Redis Insight on Amazon Web Services (AWS), Docker, and Kubernetes.---
+categories:
+- docs
+- operate
+- redisinsight
+linkTitle: Configuration settings
+title: Redis Insight configuration settings
+weight: 5
+---
+## Configuration environment variables
+
+| Variable | Purpose | Default | Additional info |
+| --- | --- | --- | --- |
+| RI_APP_PORT | The port that Redis Insight listens on. | <ul><li> Docker: 5540 <li> desktop: 5530 </ul> | See [Express Documentation](https://expressjs.com/en/api.html#app.listen)|
+| RI_APP_HOST | The host that Redis Insight connects to. | <ul><li> Docker: 0.0.0.0 <li> desktop: 127.0.0.1 </ul> | See [Express Documentation](https://expressjs.com/en/api.html#app.listen)|
+| RI_SERVER_TLS_KEY | Private key for HTTPS. | n/a | Private key in [PEM format](https://www.ssl.com/guide/pem-der-crt-and-cer-x-509-encodings-and-conversions/#ftoc-heading-3). 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](https://www.ssl.com/guide/pem-der-crt-and-cer-x-509-encodings-and-conversions/#ftoc-heading-3). 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. <br> Redis insight stores sensitive information (database passwords, Workbench history, etc.) locally (using [sqlite3](https://github.com/TryGhost/node-sqlite3)). This variable allows you to store sensitive information encrypted using the specified encryption key. <br />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: <ul> <li>error<li> warn<li>info<li> http<li> verbose<li> debug<li> silly</ul> |
+| RI_FILES_LOGGER | Logs to file. | `true` | By default, you can find log files in the following folders: <ul> <li> Docker: `/data/logs` <li> desktop: `<user-home-dir>/.redisinsight-app/logs` </ul>|
+| 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` | | 
+
+## 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:
+1. Use environment variables.
+1. Use a JSON file.
+
+### Preconfigure database connections using environment variables
+Redis Insight allows you to preconfigure database connections using environment variables.
+
+**NOTES**:
+- To configure multiple database connections, replace the asterisk (*) in each environment variable with a unique identifier for each database connection. If setting up only one connection, you can omit the asterisk, and Redis Insight will default to using 0 as the ID.
+- If you modify environment variables, the changes will take effect after restarting Redis Insight.
+- If you restart Redis Insight without these environment variables, all previously added database connections will be removed.
+
+| Variable | Purpose | Default | Additional info |
+| --- | --- | --- | --- |
+| RI_REDIS_HOST* | Host of a Redis database. | N/A |  |
+| RI_REDIS_PORT* | Port of a Redis database. | `6379` |  |
+| RI_REDIS_ALIAS* | Alias of a database connection. | `{host}:{port}` |  |
+| RI_REDIS_USERNAME* | Username to connect to a Redis database. | `default` |  |
+| RI_REDIS_PASSWORD* | Password to connect to a Redis database. | No password |  |
+| RI_REDIS_TLS* | Indicates whether TLS certificates should be used to connect. | `FALSE` | Accepts `TRUE` or `FALSE` |
+| RI_REDIS_TLS_CA_BASE64* | CA certificate in base64 format. | N/A | Specify a CA certificate in this environment variable or provide a file path using `RI_REDIS_TLS_CA_PATH*`. |
+| RI_REDIS_TLS_CA_PATH* | Path to the CA certificate file. | N/A |  |
+| RI_REDIS_TLS_CERT_BASE64* | Client certificate in base64 format. | N/A | Specify a client certificate in this environment variable or provide a file path using `RI_REDIS_TLS_CERT_PATH*`. |
+| RI_REDIS_TLS_CERT_PATH* | Path to the Client certificate file. | N/A |  |
+| RI_REDIS_TLS_KEY_BASE64* | Private key for the client certificate in base64 format. | N/A | Indicate a private key in this environment variable or use another variable to get it from a file. |
+| RI_REDIS_TLS_KEY_PATH* | Path to private key file. | N/A |  |
+
+### Preconfigure database connections using a JSON file
+Redis Insight also allows you to preconfigure database connections using a JSON file.
+
+**NOTES**
+- The JSON file format should match the one used when exporting database connections from Redis Insight.
+- The `id` field in the JSON file should include unique identifiers to avoid conflicts for database connections.
+- Changes to the JSON file will take effect after restarting Redis Insight.
+- If the JSON file is removed, all database connections added via the file will be removed.
+
+| Variable | Purpose | Default | Additional info |
+| --- | --- | --- | --- |
+| RI_PRE_SETUP_DATABASES_PATH | Path to a JSON file containing the database connections to preconfigure  |  |
+
+## Use Redis Insight behind a reverse proxy
+
+When you configure Redis Insight to run behind a reverse proxy like [NGINX](https://www.nginx.com/), set the request timeout to over 30 seconds on the reverse proxy because some requests can be long-running.
+
+Redis Insight also allows you to manage its connection timeout on the form to configure the connection details. The default timeout is 30 seconds.
+
+Hosting Redis Insight behind a prefix path (path-rewriting) is not supported.
+---
+categories:
+- docs
+- operate
+- redisinsight
+linkTitle: Proxy settings
+title: Subpath proxy
+weight: 7
+---
+
+{{<note>}}
+Subpath proxy is available only on the Docker version.
+{{</note>}}
+
+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.
+{{</note>}}
+
+## 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.
+
+Redis Insight also allows you to manage its connection timeout on the form to configure the connection details. The default timeout is 30 seconds.
+
+Hosting Redis Insight behind a prefix path (path-rewriting) is not supported.
+
+
+## Example
+
+### Docker compose file
+
+```yaml
+version: "3.7"
+services:
+  redis-stack:
+    image: redis/redis-stack-server
+    networks:
+      - redis-network
+
+  redisinsight:
+    image: redis/redisinsight
+    environment:
+      - RIPORT=${RIPORT:-5540}
+      - RITRUSTEDORIGINS=http://localhost:9000
+    depends_on:
+      - redis-stack
+    networks:
+      - redis-network
+
+  nginx-basicauth:
+    image: nginx
+    volumes:
+      - ./nginx-basic-auth.conf.template:/etc/nginx/templates/nginx-basic-auth.conf.template
+    ports:
+      - "${NGINX_PORT:-9000}:${NGINX_PORT:-9000}"
+    environment:
+      - FORWARD_HOST=redisinsight
+      - FORWARD_PORT=${RIPORT:-5540}
+      - NGINX_PORT=${NGINX_PORT:-9000}
+      - BASIC_USERNAME=${BASIC_USERNAME:-redis}
+      - BASIC_PASSWORD=${BASIC_PASSWORD:-password}
+    command:
+      - bash
+      - -c
+      - |
+        printf "$$BASIC_USERNAME:$$(openssl passwd -1 $$BASIC_PASSWORD)\n" >> /etc/nginx/.htpasswd
+        /docker-entrypoint.sh nginx -g "daemon off;"
+    depends_on:
+      - redisinsight
+    networks:
+      - redis-network
+```
+
+### nginx config
+
+```
+server {
+ listen ${NGINX_PORT} default_server;
+
+ location / {
+     auth_basic             "redisinsight";
+     auth_basic_user_file   .htpasswd;
+
+     proxy_pass             http://${FORWARD_HOST}:${FORWARD_PORT};
+     proxy_read_timeout     900;
+ }
+}
+
+```
+
+### Login page
+
+{{< image filename="/images/ri/ri-reverse-proxy-login.png" alt="RedisInsight login page" >}}
+
+
+### After login
+
+{{< image filename="/images/ri/ri-reverse-proxy-post-login.png" alt="RedisInsight after login" >}}
+
+---
+title: Redis Insight
+description: Install and manage Redis Insight
+linkTitle: Redis Insight
+categories:
+- docs
+- operate
+- redisinsight
+weight: 50
+---
+
+For information on using Redis Insight, see [these pages]({{< relref "/develop/tools/insight" >}}).
+
+---
+Title: Considerations for planning Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Information about Active-Active database to take into consideration while
+  planning a deployment, such as compatibility, limitations, and special configuration
+linktitle: Planning considerations
+weight: 22
+---
+
+In Redis Enterprise, Active-Active geo-distribution is based on [conflict-free replicated data type (CRDT) technology](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type). 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]({{< relref "/operate/rs/databases/active-active/" >}}) for more information about geo-distributed replication. For more info on other high availability features, see [Durability and high availability]({{< relref "/operate/rs/databases/durability-ha/" >}}).
+
+## Participating clusters
+
+You need at least [two participating clusters]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}) for an Active-Active database. If your database requires more than ten participating clusters, contact Redis support. You can [add or remove participating clusters]({{< relref "/operate/rs/databases/active-active/manage#participating-clusters/" >}}) after database creation.
+
+{{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+{{</note>}}
+
+Changes made from the Cluster Manager UI to an Active-Active database configuration only apply to the cluster you are editing. For global configuration changes across all clusters, use the `crdb-cli` command-line utility.
+
+## Memory limits
+
+Database memory limits define the maximum size of your database across all database replicas and [shards]({{< relref "/operate/rs/references/terminology.md#redis-instance-shard" >}}) on the cluster. Your memory limit also determines the number of shards.
+
+Besides your dataset, the memory limit must also account for replication, Active-Active metadata, and module overhead. These features can increase your database size, sometimes increasing it by two times or more.
+
+Factors to consider when sizing your database:
+
+- **dataset size**: you want your limit to be above your dataset size to leave room for overhead.
+- **database throughput**: high throughput needs more shards, leading to a higher memory limit.
+- [**modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}): using modules with your database can consume more memory.
+- [**database clustering**]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}): enables you to spread your data into shards across multiple nodes (scale out).
+- [**database replication**]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}): enabling replication doubles memory consumption
+- [**Active-Active replication**]({{< relref "/operate/rs/databases/active-active/_index.md" >}}): enabling Active-Active replication requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**database replication backlog**]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog/" >}}) for synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/databases/active-active/manage.md" >}}) for synchronization between clusters. By default, this is set to 1% of the database size.
+
+It's also important to know Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit. 
+
+For more information on memory limits, see [Memory and performance]({{< relref "/operate/rs/databases/memory-performance/" >}}) or [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}).
+
+## Networking
+
+Network requirements for Active-Active databases include:
+
+- A VPN between each network that hosts a cluster with an instance (if your database spans WAN).
+- A network connection to [several ports](#network-ports) on each cluster from all nodes in all participating clusters.
+- A [network time service](#network-time-service) running on each node in all clusters.
+
+Networking between the clusters must be configured before creating an Active-Active database. The setup will fail if there is no connectivity between the clusters.
+
+### Network ports
+
+Every node must have access to the REST API ports of every other node as well as other ports for proxies, VPNs, and the Cluster Manager UI. See [Network port configurations]({{< relref "/operate/rs/networking/port-configurations.md" >}}) for more details. These ports should be allowed through firewalls that may be positioned between the clusters.
+
+### Network Time Service {#network-time-service}
+
+Active-Active databases require a time service like NTP or Chrony to make sure the clocks on all cluster nodes are synchronized.
+This is critical to avoid problems with internal cluster communications that can impact your data integrity.
+
+See [Synchronizing cluster node clocks]({{< relref "/operate/rs/clusters/configure/sync-clocks.md" >}}) for more information.
+
+## Redis modules {#redis-modules}
+
+Several Redis modules are compatible with Active-Active databases. Find the list of [compatible Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}).
+{{< note >}}
+Starting with v6.2.18, you can index, query, and perform full-text searches of nested JSON documents in Active-Active databases by combining RedisJSON and RediSearch.
+{{< /note >}}
+
+## Limitations
+
+Active-Active databases have the following limitations:
+
+- An existing database can't be changed into an Active-Active database. To move data from an existing database to an Active-Active database, you must [create a new Active-Active database]({{< relref "/operate/rs/databases/active-active/create.md" >}}) and [migrate the data]({{< relref "/operate/rs/databases/import-export/migrate-to-active-active.md" >}}).
+- [Discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}) is not supported with Active-Active databases. Active-Active databases require FQDNs or [mDNS]({{< relref "/operate/rs/networking/mdns.md" >}}).
+- The `FLUSH` command is not supported from the CLI. To flush your database, use the API or Cluster Manager UI.
+- The `UNLINK` command is a blocking command for all types of keys.
+- Cross slot multi commands (such as `MSET`) are not supported with Active-Active databases.
+- The hashing policy can't be changed after database creation.
+- If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+---
+Title: Application failover with Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: How to failover your application to connect to a remote replica.
+linkTitle: App failover
+weight: 99
+---
+Active-Active Redis deployments don't have a built-in failover or failback mechanism for application connections.
+An application deployed with an Active-Active database connects to a replica of the database that is geographically nearby.
+If that replica is not available, the application can failover to a remote replica, and failback again if necessary.
+In this article we explain how this process works.
+
+Active-Active connection failover can improve data availability, but can negatively impact data consistency.
+Active-Active replication, like Redis replication, is asynchronous.
+An application that fails over to another replica can miss write operations.
+If the failed replica saved the write operations in persistent storage,
+then the write operations are processed when the failed replica recovers.
+
+## Detecting Failure
+
+Your application can detect two types of failure:
+
+1. **Local failures** - The local replica is down or otherwise unavailable
+1. **Replication failures** - The local replica is available but fails to replicate to or from remote replicas
+
+### Local Failures
+
+Local failure is detected when the application is unable to connect to the database endpoint for any reason. Reasons for a local failure can include: multiple node failures, configuration errors, connection refused, connection timed out, unexpected protocol level errors.
+
+### Replication Failures
+
+Replication failures are more difficult to detect reliably without causing false positives. Replication failures can include: network split, replication configuration issues, remote replica failures.
+
+The most reliable method for health-checking replication is by using the Redis publish/subscribe (pub/sub) mechanism.
+
+{{< note >}}
+Note that this document does not suggest that Redis pub/sub is reliable in the common sense. Messages can get lost in certain conditions, but that is acceptable in this case because typically the application determines that replication is down only after not being able to deliver a number of messages over a period of time.
+{{< /note >}}
+
+When you use the pub/sub data type to detect failures, the application:
+
+1. Connects to all replicas and subscribes to a dedicated channel for each replica.
+1. Connects to all replicas and periodically publishes a uniquely identifiable message.
+1. Monitors received messages and ensures that it is able to receive its own messages within a predetermined window of time.
+
+You can also use known dataset changes to monitor the reliability of the replication stream,
+but pub/sub is preferred method because:
+
+1. It does not involve dataset changes.
+1. It does not make any assumptions about the dataset.
+1. Pub/sub messages are delivered as replicated effects and are a more reliable indicator of a live replication link. In certain cases, dataset keys may appear to be modified even if the replication link fails. This happens because keys may receive updates through full-state replication (re-sync) or through online replication of effects. 
+
+## Impact of sharding on failure detection
+
+If your sharding configuration is symmetric, make sure to use at least one key (PUB/SUB channels or real dataset key) per shard. Shards are replicated individually and are vulnerable to failure. Symmetric sharding configurations have the same number of shards and hash slots for all replicas.
+We do not recommend an asymmetric sharding configuration, which requires at least one key per hash slot that intersects with a pair of shards.
+
+To make sure that there is at least one key per shard, the application should:
+
+1. Use the Cluster API to retrieve the database sharding configuration.
+1. Compute a number of key names, such that there is one key per shard.
+1. Use those key names as channel names for the pub/sub mechanism.
+
+### Failing over
+
+When the application needs to failover to another replica, it should simply re-establish its connections with the endpoint on the remote replica. Because Active/Active and Redis replication are asynchronous, the remote endpoint may not have all of the locally performed and acknowledged writes.
+
+It's best if your application doesn't read its own recent writes. Those writes can be either:
+
+1. Lost forever, if the local replica has an event such as a double failure or loss of persistent files.
+1. Temporarily unavailable, but will be available at a later time if the local replica's failure is temporary.
+
+<!--- {{< note >}}
+Sample code that maps a hash slot to a key name can be found in this Python script.
+{{< /note >}} --->
+
+## Failback decision
+
+Your application can use the same checks described above to continue monitoring the state of the failed replica after failover.
+
+To monitor the state of a replica during the failback process, you must make sure the replica is available, re-synced with the remote replicas, and not in stale mode. The PUB/SUB mechanism is an effective way to monitor this.
+
+Dataset-based mechanisms are potentially less reliable for several reasons:
+1. In order to determine that a local replica is not stale, it is not enough to simply read keys from it. You must also attempt to write to it.
+1. As stated above, remote writes for some keys appear in the local replica before the replication link is back up and while the replica is still in stale mode.
+1. A replica that was never written to never becomes stale, so on startup it is immediately ready but serves stale data for a longer period of time.
+
+## Replica Configuration Changes
+
+All failover and failback operations should be done strictly on the application side, and should not involve changes to the Active-Active configuration.
+The only valid case for re-configuring the Active-Active deployment and removing a replica is when memory consumption becomes too high because garbage collection cannot be performed.
+Once a replica is removed, it can only be re-joined as a new replica and it loses any writes that were not converged.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Overview of how developing applications differs for Active-Active databases
+  from standalone Redis databases.
+linkTitle: Develop for Active-Active
+title: Develop applications with Active-Active databases
+weight: 10
+---
+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.
+
+|  **Time** | **Member CRDB1** | **Member CRDB2** |
+|  :------: | :------: | :------: |
+|  t1 | INCRBY key1 7 |  |
+|  t2 |  | INCRBY key1 3 |
+|  t3 | GET key1<br/>7 | GET key1<br/>3 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | GET key1<br/>10 | GET key1<br/>10 |
+|  t6 | DECRBY key1 3 |  |
+|  t7 |  | INCRBY key1 6 |
+|  t8 | — Sync — | — Sync — |
+|  t9 | GET key1<br/>13 | GET key1<br/>13 |
+
+Databases provide various approaches to address some of these concerns:
+
+- Active-Passive Geo-distributed deployments: With active-passive
+    distributions, all writes go to an active cluster. Redis Enterprise
+    provides a "Replica Of" capability that provides a similar approach.
+    This can be employed when the workload is heavily balanced towards
+    read and few writes. However, WAN performance and availability
+    is quite flaky and traveling large distances for writes take away
+    from application performance and availability.
+- Two-phase Commit (2PC): This approach is designed around a protocol
+    that commits a transaction across multiple transaction managers.
+    Two-phase commit provides a consistent transactional write across
+    regions but fails transactions unless all participating transaction
+    managers are "available" at the time of the transaction. The number
+    of messages exchanged and its cross-regional availability
+    requirement make two-phase commit unsuitable for even moderate
+    throughputs and cross-geo writes that go over WANs.
+- Sync update with Quorum-based writes: This approach synchronously
+    coordinates a write across majority number of replicas across
+    clusters spanning multiple regions. However, just like two-phase
+    commit, number of messages exchanged and its cross-regional
+    availability requirement make geo-distributed quorum writes
+    unsuitable for moderate throughputs and cross geo writes that go
+    over WANs.
+- Last-Writer-Wins (LWW) Conflict Resolution: Some systems provide
+    simplistic conflict resolution for all types of writes where the
+    system clocks are used to determine the winner across conflicting
+    writes. LWW is lightweight and can be suitable for simpler data.
+    However, LWW can be destructive to updates that are not necessarily
+    conflicting. For example adding a new element to a set across two
+    geographies concurrently would result in only one of these new
+    elements appearing in the final result with LWW.
+- MVCC (multi-version concurrency control): MVCC systems maintain
+    multiple versions of data and may expose ways for applications to
+    resolve conflicts. Even though MVCC system can provide a flexible
+    way to resolve conflicting writes, it comes at a cost of great
+    complexity in the development of a solution.
+
+Even though types and commands in Active-Active databases look identical to standard Redis
+types and commands, the underlying types in RS are enhanced to maintain
+more metadata to create the conflict-free data type experience. This
+section explains what you need to know about developing with Active-Active databases on
+Redis Enterprise Software.
+
+## Lua scripts
+
+Active-Active databases support Lua scripts, but unlike standard Redis, Lua scripts always
+execute in effects replication mode. There is currently no way to
+execute them in script-replication mode.
+
+## Eviction
+
+The default policy for Active-Active databases is _noeviction_ mode. Redis Enterprise version 6.0.20 and later support all eviction policies for Active-Active databases, unless [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering" >}})(previously known as Redis on Flash) is enabled.
+For details, see [eviction for Active-Active databases]({{< relref "/operate/rs/databases/memory-performance/eviction-policy#active-active-database-eviction" >}}).
+
+
+## Expiration
+
+Expiration is supported with special multi-master semantics.
+
+If a key's expiration time is changed at the same time on different
+members of the Active-Active database, the longer extended time set via TTL on a key is
+preserved. As an example:
+
+If this command was performed on key1 on cluster #1
+
+```sh
+127.0.0.1:6379> EXPIRE key1 10
+```
+
+And if this command was performed on key1 on cluster #2
+
+```sh
+127.0.0.1:6379> EXPIRE key1 50
+```
+
+The EXPIRE command setting the key to 50 would win.
+
+And if this command was performed on key1 on cluster #3:
+
+```sh
+127.0.0.1:6379> PERSIST key1
+```
+
+It would win out of the three clusters hosting the Active-Active database as it sets the
+TTL on key1 to an infinite time.
+
+The replica responsible for the "winning" expire value is also
+responsible to expire the key and propagate a DEL effect when this
+happens. A "losing" replica is from this point on not responsible
+for expiring the key, unless another EXPIRE command resets the TTL.
+Furthermore, a replica that is NOT the "owner" of the expired value:
+
+- Silently ignores the key if a user attempts to access it in READ
+    mode, e.g. treating it as if it was expired but not propagating a
+    DEL.
+- Expires it (sending a DEL) before making any modifications if a user
+    attempts to access it in WRITE mode.
+    
+    {{< note >}}
+Expiration values are in the range of [0,&nbsp;2^49] for Active-Active databases and [0,&nbsp;2^64] for non Active-Active databases.
+    {{< /note >}}
+
+## Out-of-Memory (OOM) {#outofmemory-oom}
+
+If a member Active-Active database is in an out of memory situation, that member is marked
+"inconsistent" by RS, the member stops responding to user traffic, and
+the syncer initiates full reconciliation with other peers in the Active-Active database.
+
+## Active-Active Database Key Counts
+
+Keys are counted differently for Active-Active databases:
+
+- DBSIZE (in `shard-cli dbsize`) reports key header instances
+    that represent multiple potential values of a key before a replication conflict is resolved.
+- expired_keys (in `bdb-cli info`) can be more than the keys count in DBSIZE (in `shard-cli dbsize`) 
+    because expires are not always removed when a key becomes a tombstone.
+    A tombstone is a key that is logically deleted but still takes memory
+    until it is collected by the garbage collector.
+- The Expires average TTL (in `bdb-cli info`) is computed for local expires only.
+
+## INFO
+
+The INFO command has an additional crdt section which provides advanced
+troubleshooting information (applicable to support etc.):
+
+|  **Section** | **Field** | **Description** |
+|  ------ | ------ | ------ |
+|  **CRDT Context** | crdt_config_version | Currently active Active-Active database configuration version. |
+|   | crdt_slots | Hash slots assigned and reported by this shard. |
+|   | crdt_replid | Unique Replica/Shard IDs. |
+|   | crdt_clock | Clock value of local vector clock. |
+|   | crdt_ovc | Locally observed Active-Active database vector clock. |
+|  **Peers** | A list of currently connected Peer Replication peers. This is similar to the slaves list reported by Redis. |  |
+|  **Backlogs** | A list of Peer Replication backlogs currently maintained. Typically in a full mesh topology only a single backlog is used for all peers, as the requested Ids are identical. |  |
+|  **CRDT Stats** | crdt_sync_full | Number of inbound full synchronization processes performed. |
+|   | crdt_sync_partial_ok | Number of partial (backlog based) re-synchronization processes performed. |
+|   | crdt_sync_partial-err | Number of partial re-synchronization processes failed due to exhausted backlog. |
+|   | crdt_merge_reqs | Number of inbound merge requests processed. |
+|   | crdt_effect_reqs | Number of inbound effect requests processed. |
+|   | crdt_ovc_filtered_effect_reqs | Number of inbound effect requests filtered due to old vector clock. |
+|   | crdt_gc_pending | Number of elements pending garbage collection. |
+|   | crdt_gc_attempted | Number of attempts to garbage collect tombstones. |
+|   | crdt_gc_collected | Number of tombstones garbaged collected successfully. |
+|   | crdt_gc_gvc_min | The minimal globally observed vector clock, as computed locally from all received observed clocks. |
+|   | crdt_stale_released_with_merge | Indicates last stale flag transition was a result of a complete full sync. |
+|  **CRDT Replicas** | A list of crdt_replica \<uid> entries, each describes the known state of a remote instance with the following fields: |  |
+|   | config_version | Last configuration version reported. |
+|   | shards | Number of shards. |
+|   | slots | Total number of hash slots. |
+|   | slot_coverage | A flag indicating remote shards provide full coverage (i.e. all shards are alive). |
+|   | max_ops_lag | Number of local operations not yet observed by the least updated remote shard |
+|   | min_ops_lag | Number of local operations not yet observed by the most updated remote shard |
+---
+Title: Sorted sets in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using sorted sets with an Active-Active database.
+linkTitle: Sorted sets
+weight: $weight
+---
+{{< note >}}
+[Redis Geospatial (Geo)]({{< relref "/commands/GEOADD" >}}) is based on Sorted Sets, so the same Active-Active database development instructions apply to Geo.
+{{< /note >}}
+
+Similar to Redis Sets, Redis Sorted Sets are non-repeating collections
+of Strings. The difference between the two is that every member of a
+Sorted Set is associated with a score used to order the Sorted Set from
+lowest to highest. While members are unique, they may have the same
+score.
+
+With Sorted Sets, you can quickly add, remove or update elements as
+well as get ranges by score or by rank (position). Sorted Sets in Active-Active databases
+behave the same and maintain additional metadata to handle concurrent
+conflicting writes. Conflict resolution is done in two
+phases:
+
+1. First, the database resolves conflict at the set level using "OR
+    Set" (Observed-Remove Set). With OR-Set behavior, writes across
+    multiple Active-Active database instances are typically unioned except in cases of
+    conflicts. Conflicting writes can happen when an Active-Active database instance
+    deletes an element while the other adds or updates the same element.
+    In this case, an observed Remove rule is followed, and only
+    instances it has already seen are removed. In all other cases, the
+    Add / Update element wins.
+1. Second, the database resolves conflict at the score level. In this
+    case, the score is treated as a counter and applies the same
+    conflict resolution as regular counters.
+
+See the following examples to get familiar with Sorted Sets'
+behavior in Active-Active database:
+
+Example of Simple Sorted Set with No
+Conflict:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | ZADD Z 1.2 y |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZRANGE Z 0 -1 => x y | ZRANGE Z 0 -1 => x y |
+
+**Explanation**:
+When adding two different elements to a Sorted Set from different
+replicas (in this example, x with score 1.1 was added by Instance 1 to
+Sorted Set Z, and y with score 1.2 was added by Instance 2 to Sorted Set
+Z) in a non-concurrent manner (i.e. each operation happened separately
+and after both instances were in sync), the end result is a Sorted
+Set including both elements in each Active-Active database instance.
+Example of Sorted Set and Concurrent
+Add:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 |  | ZADD Z 2.1 x |
+|  t3 | ZSCORE Z x => 1.1 | ZSCORE Z x => 2.1 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZSCORE Z x => 2.1 | ZSCORE Z x => 2.1 |
+
+**Explanation**:
+When concurrently adding an element x to a Sorted Set Z by two different
+Active-Active database instances (Instance 1 added score 1.1 and Instance 2 added score
+2.1), the Active-Active database implements Last Write Win (LWW) to determine the score of
+x. In this scenario, Instance 2 performed the ZADD operation at time
+t2\>t1 and therefore the Active-Active database sets the score 2.1 to
+x.
+
+Example of Sorted Set with Concurrent Add Happening at the Exact Same
+Time:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x | ZADD Z 2.1 x |
+|  t2 | ZSCORE Z x => 1.1 | ZSCORE Z x => 2.1 |
+|  t3 | — Sync — | — Sync — |
+|  t4 | ZSCORE Z x => 1.1 | ZSCORE Z x => 1.1 |
+
+**Explanation**:
+The example above shows a relatively rare situation, in which two Active-Active database
+instances concurrently added the same element x to a Sorted Set at the
+same exact time but with a different score, i.e. Instance 1 added x with
+a 1.1 score and Instance 2 added x with a 2.1 score. After syncing, the
+Active-Active database realized that both operations happened at the same time and
+resolved the conflict by arbitrarily (but consistently across all Active-Active database
+instances) giving precedence to Instance 1.
+Example of Sorted Set with Concurrent Counter
+Increment:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | ZINCRBY Z 1.0 x | ZINCRBY Z 1.0 x |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZSCORE Z x => 3.1 | ZSCORE Z x => 3.1 |
+
+**Explanation**:
+The result is the sum of all
+ZINCRBY
+operations performed by all Active-Active database instances.
+
+Example of Removing an Element from a Sorted
+Set:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 4.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | ZSCORE Z x => 4.1 | ZSCORE Z x => 4.1 |
+|  t4 | ZREM Z x | ZINCRBY Z 2.0 x |
+|  t5 | ZSCORE Z x => nill | ZSCORE Z x => 6.1 |
+|  t6 | — Sync — | — Sync — |
+|  t7 | ZSCORE Z x => 2.0 | ZSCORE Z x => 2.0 |
+
+**Explanation**:
+At t4 - t5, concurrent ZREM and ZINCRBY operations ran on Instance 1
+and Instance 2 respectively. Before the instances were in sync, the ZREM
+operation could only delete what had been seen by Instance 1, so
+Instance 2 was not affected. Therefore, the ZSCORE operation shows the
+local effect on x. At t7, after both instances were in-sync, the Active-Active database
+resolved the conflict by subtracting 4.1 (the value of element x in
+Instance 1) from 6.1 (the value of element x in Instance 2).
+---
+Title: Strings and bitfields in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using strings and bitfields with an Active-Active database.
+linkTitle: Strings and bitfields
+weight: $weight
+---
+Active-Active databases support both strings and bitfields.
+
+{{<note>}}
+Active-Active **bitfield** support was added in RS version 6.0.20.
+{{</note>}}
+
+Changes to both of these data structures will be replicated across Active-Active member databases.
+
+## Replication semantics
+
+Except in the case of [string counters]({{< relref "#string-counter-support" >}}) (see below), both strings and bitfields are replicated using a "last write wins" approach. The reason for this is that strings and bitfields are effectively binary objects. So, unlike with lists, sets, and hashes, the conflict resolution semantics of a given operation on a string or bitfield are undefined.
+
+### How "last write wins" works
+
+A wall-clock timestamp (OS time) is stored in the metadata of every string
+and bitfield operation. If the replication syncer cannot determine the order of operations,
+the value with the latest timestamp wins. This is the only case with Active-Active databases where OS time is used to resolve a conflict.
+
+Here's an example where an update happening to the same key at a later
+time (t2) wins over the update at t1.
+
+|  **Time** | **Region 1** | **Region 2** |
+|  :------: | :------: | :------: |
+|  t1 | SET text “a” |  |
+|  t2 |  | SET text “b” |
+|  t3 | — Sync — | — Sync — |
+|  t4 | SET text “c” |  |
+|  t5 | — Sync — | — Sync — |
+|  t6 |  | SET text “d” |
+
+### String counter support
+
+When you're using a string as counter (for instance, with the [INCR]({{< relref "/commands/incr" >}}) or [INCRBY]({{< relref "/commands/incrby" >}}) commands),
+then conflicts will be resolved semantically.
+
+On conflicting writes, counters accumulate the total counter operations
+across all member Active-Active databases in each sync.
+
+Here's an example of how counter
+values works when synced between two member Active-Active databases. With
+each sync, the counter value accumulates the private increment and
+decrements of each site and maintain an accurate counter across
+concurrent writes.
+
+|  **Time** | **Region 1** | **Region 2** |
+|  :------: | :------: | :------: |
+|  t1 | INCRBY counter 7 |  |
+|  t2 |  | INCRBY counter 3 |
+|  t3 | GET counter<br/>7 | GET counter<br/>3 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | GET counter<br/>10 | GET counter<br/>10 |
+|  t6 | DECRBY counter 3 |  |
+|  t7 |  | INCRBY counter 6 |
+|  t8 | — Sync — | — Sync — |
+|  t9 | GET counter<br/>13 | GET counter<br/>13 |
+
+{{< note >}}
+Active-Active databases support 59-bit counters.
+This limitation is to protect from overflowing a counter in a concurrent operation.
+{{< /note >}}
+---
+Title: Hashes in an Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using hashes with an Active-Active database.
+linkTitle: Hashes
+weight: $weight
+---
+Hashes are great for structured data that contain a map of fields and
+values. They are used for managing distributed user or app session
+state, user preferences, form data and so on. Hash fields contain string
+type and string types operate just like the standard Redis string types
+when it comes to CRDTs. Fields in hashes can be initialized as a string
+using HSET or HMSET or can be used to initialize counter types that are
+numeric integers using HINCRBY or floats using HINCRBYFLOAT.
+
+Hashes in Active-Active databases behave the same and maintain additional metadata to
+achieve an "OR-Set" behavior to handle concurrent conflicting writes.
+With the OR-Set behavior, writes to add new fields across multiple Active-Active database
+instances are typically unioned except in cases of conflicts.
+Conflicting instance writes can happen when an Active-Active database instance deletes a
+field while the other adds the same field. In this case and observed
+remove rule is followed. That is, remove can only remove fields it has
+already seen and in all other cases element add/update wins.
+
+Field values behave just like CRDT strings. String values can be types
+string, counter integer based on the command used for initialization of
+the field value. See "String Data Type in Active-Active databases" and "String Data Type
+with Counter Value in Active-Active databases" for more details.
+
+Here is an example of an "add wins" case:
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | HSET key1 field1 “a” |  |
+|  t2 |  | HSET key1 field2 “b” |
+|  t4 | - Sync - | - Sync - |
+|  t5 | HGETALL key1<br/>1) “field2”<br/>2) “b”<br/>3) “field1”<br/>4) “a” | HGETALL key1<br/>1) “field2”<br/>2) “b”<br/>3) “field1”<br/>4) “a” |
+---
+Title: JSON in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using JSON with an Active-Active database.
+linkTitle: JSON
+weight: $weight
+tocEmbedHeaders: true
+---
+Active-Active databases support JSON data structures.
+
+The design is based on [A Conflict-Free Replicated JSON Datatype](https://arxiv.org/abs/1608.03960) by Kleppmann and Beresford, but the implementation includes some changes. Several [conflict resolution rule](#conflict-resolution-rules) examples were adapted from this paper as well.
+
+## Prerequisites
+
+To use JSON in an Active-Active database, you must enable JSON during database creation.
+
+Active-Active Redis Cloud databases add JSON by default. See [Create an Active-Active subscription]({{< relref "/operate/rc/databases/create-database/create-active-active-database#select-capabilities" >}}) in the Redis Cloud documentation for details.
+
+In Redis Enterprise Software, JSON is not enabled by default for Active-Active databases. See [Create an Active-Active JSON database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/active-active#create-an-active-active-json-database" >}}) in the Redis Stack and Redis Enterprise documentation for instructions.
+
+{{<embed-md "json-active-active-command-differences.md">}}
+
+{{<embed-md "json-active-active-conflict-resolution.md">}}---
+Title: Sets in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using sets with an Active-Active database.
+linkTitle: Sets
+weight: $weight
+---
+A Redis set is an unordered collection of strings. It is possible to
+add, remove, and test for the existence of members with Redis commands.
+A Redis set maintains a unique collection of elements. Sets can be great
+for maintaining a list of events (click streams), users (in a group
+conversation), products (in recommendation lists), engagements (likes,
+shares) and so on.
+
+Sets in Active-Active databases behave the same and maintain additional metadata to
+achieve an "OR-Set" behavior to handle concurrent conflicting
+writes. With the OR-Set behavior, writes across multiple Active-Active database instances
+are typically unioned except in cases of conflicts. Conflicting instance
+writes can happen when a Active-Active database instance deletes an element while the
+other adds the same element. In this case and observed remove rule is
+followed. That is, remove can only remove instances it has already seen
+and in all other cases element add wins.
+
+Here is an example of an "add wins" case:
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SADD key1 “a” |  |
+|  t2 |  | SADD key1 “b” |
+|  t3 | SMEMBERS key1 “a” | SMEMBERS key1 “b” |
+|  t4 | — Sync — | — Sync — |
+|  t3 | SMEMBERS key1 “a” “b” | SMEMBERS key1 “a” “b” |
+
+Here is an example of an "observed remove" case.
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SMEMBERS key1 “a” “b” | SMEMBERS key1 “a” “b” |
+|  t2 | SREM key1 “a” | SADD key1 “c” |
+|  t3 | SREM key1 “c” |  |
+|  t4 | — Sync — | — Sync — |
+|  t3 | SMEMBERS key1 “c” “b” | SMEMBERS key1 “c” “b” |
+---
+Title: Streams in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using streams with an Active-Active database.
+linkTitle: Streams
+weight: $weight
+---
+A [Redis Stream]({{< relref "/develop/data-types/streams" >}}) is a data structure that acts like an append-only log.
+Each stream entry consists of:
+
+- A unique, monotonically increasing ID
+- A payload consisting of a series key-value pairs
+
+You add entries to a stream with the XADD command. You access stream entries using the XRANGE, XREADGROUP, and XREAD commands (however, see the caveat about XREAD below).
+
+## Streams and Active-Active
+
+Active-Active databases allow you to write to the same logical stream from more than one region.
+Streams are synchronized across the regions of an Active-Active database.
+
+In the example below, we write to a stream concurrently from two regions. Notice that after syncing, both regions have identical streams:
+
+<table style='width: auto;'>
+<thead>
+<tr>
+<th>Time</th>
+<th>Region 1</th>
+<th>Region 2</th>
+</tr>
+</thead>
+
+<tbody>
+<tr>
+<td><em>t1</em></td>
+<td><code>XADD messages * text hello</code></td>
+<td><code>XADD messages * text goodbye</code></td>
+</tr>
+
+<tr>
+<td><em>t2</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></td>
+</tr>
+
+<tr>
+<td><em>t3</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+<tr>
+<td><em>t4</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1, 1589929246795-2]</strong></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1, 1589929246795-2]</strong></td>
+</tr>
+</tbody>
+</table>
+
+Notice also that the synchronized streams contain no duplicate IDs. As long as you allow the database to generate your stream IDs, you'll never have more than one stream entry with the same ID.
+
+{{< note >}}
+Redis Open Source uses one radix tree (referred to as `rax` in the code base) to implement each stream. However, Active-Active databases implement a single logical stream using one `rax` per region.
+Each region adds entries only to its associated `rax` (but can remove entries from all `rax` trees).
+This means that XREAD and XREADGROUP iterate simultaneously over all `rax` trees and return the appropriate entry by comparing the entry IDs from each `rax`.
+{{< /note >}}
+
+### Conflict resolution
+
+Active-Active databases use an "observed-remove" approach to automatically resolve potential conflicts.
+
+With this approach, a delete only affects the locally observable data.
+
+In the example below, a stream, `x`, is created at _t1_. At _t3_, the stream exists in two regions.
+
+<table style='width: 100%;'>
+<thead>
+<tr>
+<th>Time</th>
+<th>Region 1</th>
+<th>Region 2</th>
+</tr>
+</thead>
+
+<tbody>
+<tr>
+<td><em>t1</em></td>
+<td><code>XADD messages * text hello</code></td>
+<td></td>
+</tr>
+
+<tr>
+<td><em>t2</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+<tr>
+<td><em>t3</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></code></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></code></td>
+</tr>
+
+
+<tr>
+<td><em>t4</em></td>
+<td><code>DEL messages</code></strong></td>
+<td><code>XADD messages * text goodbye</code></td>
+</tr>
+
+<tr>
+<td><em>t5</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+
+<tr>
+<td><em>t6</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></code></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></code></td>
+</tr>
+
+
+</tbody>
+</table>
+
+At _t4_, the stream is deleted from Region 1. At the same time, an entry with ID ending in `3700` is added to the same stream at Region 2. After the sync, at _t6_, the entry with ID ending in `3700` exists in both regions. This is because that entry was not visible when the local stream was deleted at _t4_.
+
+### ID generation modes
+
+Usually, you should allow Redis streams generate its own stream entry IDs. You do this by specifying `*` as the ID in calls to XADD. However, you _can_ provide your own custom ID when adding entries to a stream.
+
+Because Active-Active databases replicate asynchronously, providing your own IDs can create streams with duplicate IDs. This can occur when you write to the same stream from multiple regions.
+
+| Time | Region 1                      | Region 2                      |
+| ---- | ------------------------------- | ------------------------------- |
+| _t1_   | `XADD x 100-1 f1 v1`              | `XADD x 100-1 f1 v1`              |
+| _t2_   | _— Sync —_                    | _— Sync —_                    |
+| _t3_   | `XRANGE x - +`<br/> **→ [100-1, 100-1]** | `XRANGE x - +`<br/> **→ [100-1, 100-1]** |
+
+In this scenario, two entries with the ID `100-1` are added at _t1_. After syncing, the stream `x` contains two entries with the same ID.
+
+{{< note >}}
+Stream IDs in Redis Open Source consist of two integers separated by a dash ('-'). When the server generates the ID, the first integer is the current time in milliseconds, and the second integer is a sequence number. So, the format for stream IDs is MS-SEQ.
+{{< /note >}}
+
+To prevent duplicate IDs and to comply with the original Redis streams design, Active-Active databases provide three ID modes for XADD:
+
+1. **Strict**: In _strict_ mode, XADD allows server-generated IDs (using the '`*`' ID specifier) or IDs consisting only of the millisecond (MS) portion. When the millisecond portion of the ID is provided, the ID's sequence number is calculated using the database's region ID. This prevents duplicate IDs in the stream. Strict mode rejects full IDs (that is, IDs containing both milliseconds and a sequence number).
+1. **Semi-strict**: _Semi-strict_ mode is just like _strict_ mode except that it allows full IDs (MS-SEQ). Because it allows full IDs, duplicate IDs are possible in this mode.
+1. **Liberal**: XADD allows any monotonically ascending ID. When given the millisecond portion of the ID, the sequence number will be set to `0`. This mode may also lead to duplicate IDs.
+
+The default and recommended mode is _strict_, which prevents duplicate IDs.
+
+{{% warning %}}
+Why do you want to prevent duplicate IDs? First, XDEL, XCLAIM, and other commands can affect more than one entry when duplicate IDs are present in a stream. Second, duplicate entries may be removed if a database is exported or renamed.
+{{% /warning %}}
+
+To change XADD's ID generation mode, use the `rladmin` command-line utility:
+
+Set _strict_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode strict
+```
+
+Set _semi-strict_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode semi-strict
+```
+
+Set _liberal_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode liberal
+```
+
+### Iterating a stream with XREAD
+
+In Redis Open Source and in non-Active-Active databases, you can use XREAD to iterate over the entries in a Redis Stream. However, with an Active-Active database, XREAD may skip entries. This can happen when multiple regions write to the same stream.
+
+In the example below, XREAD skips entry `115-2`.
+
+| Time | Region 1                                         | Region 2                                         |
+| ---- | -------------------------------------------------- | -------------------------------------------------- |
+| _t1_   | `XADD x 110 f1 v1`                                   | `XADD x 115 f1 v1`                                   |
+| _t2_   | `XADD x 120 f1 v1`                                   |                                                    |
+| _t3_   | `XADD x 130 f1 v1`                                   |                                                    |
+| _t4_   | `XREAD COUNT 2 STREAMS x 0` <br/>**→ [110-1, 120-1]**       |                                                    |
+| _t5_   | _— Sync —_                                       | _— Sync —_                                       |
+| _t6_   | `XREAD COUNT 2 STREAMS x 120-1` <br/>**→ [130-1]**            |                                                    |
+| _t7_   | `XREAD STREAMS x 0` <br/>**→[110-1, 115-2, 120-1, 130-1]** | `XREAD STREAMS x 0` <br/>**→[110-1, 115-2, 120-1, 130-1]** |
+
+
+You can use XREAD to reliably consume a stream only if all writes to the stream originate from a single region. Otherwise, you should use XREADGROUP, which always guarantees reliable stream consumption.
+
+## Consumer groups
+
+Active-Active databases fully support consumer groups with Redis Streams. Here is an example of creating two consumer groups concurrently:
+
+| Time | Region 1                  | Region 2                  |
+| ---- | --------------------------- | --------------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`        | `XGROUP CREATE x group2 0`        |
+| _t2_   | `XINFO GROUPS x` <br/>**→ [group1]**     | `XINFO GROUPS x` <br/>**→ [group2]**     |
+| _t3_   | _— Sync —_                | — Sync —                |
+| _t4_   | `XINFO GROUPS x` <br/>**→ [group1, group2]** | `XINFO GROUPS x` <br/>**→ [group1, group2]** |
+
+
+{{< note >}}
+Redis Open Source uses one radix tree (`rax`) to hold the global pending entries list and another `rax` for each consumer's PEL.
+The global PEL is a unification of all consumer PELs, which are disjoint.
+
+An Active-Active database stream maintains a global PEL and a per-consumer PEL for each region.
+
+When given an ID different from the special ">" ID, XREADGROUP iterates simultaneously over all of the PELs for all consumers.
+It returns the next entry by comparing entry IDs from the different PELs.
+{{< /note >}}
+
+### Conflict resolution
+
+The "delete wins" approach is a way to automatically resolve conflicts with consumer groups.
+In case of concurrent consumer group operations, a delete will "win" over other concurrent operations on the same group.
+
+In this example, the DEL at _t4_ deletes both the observed `group1` and the non-observed `group2`:
+
+| Time | Region 1              | Region 2              |
+| ---- | ----------------------- | ----------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`    |                         |
+| _t2_   | _— Sync —_            | _— Sync —_            |
+| _t3_   | `XINFO GROUPS x` <br/>**→ [group1]** | `XINFO GROUPS x` <br/>**→ [group1]** |
+| _t4_   | `DEL x`                   | `XGROUP CREATE x group2 0`    |
+| _t5_   | _— Sync —_            | _— Sync —_            |
+| _t6_   | `EXISTS x` <br/>**→ 0** | `EXISTS x` <br/>**→  0**          |
+
+In this example, the XGROUP DESTROY at _t4_ affects both the observed `group1` created in Region 1 and the non-observed `group1` created in Region 3:
+
+| time | Region 1              | Region 2              | Region 3            |
+| ---- | ----------------------- | ----------------------- | --------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`    |                         |                       |
+| _t2_   | _— Sync —_            | _— Sync —_            |                       |
+| _t3_   | `XINFO GROUPS x` <br/>**→ [group1]** | `XINFO GROUPS x` <br/>**→  [group1]** | `XINFO GROUPS x` <br/>**→  []** |
+| _t4_   |                         | `XGROUP DESTROY x group1`     | `XGROUP CREATE x group1 0` |
+| _t5_   | _— Sync —_            | _— Sync —            | — Sync —          |
+| _t6_   | `EXISTS x` <br/>**→  0**          | `EXISTS x` <br/>**→ 0**          | `EXISTS x` <br/>**→  0**    |
+
+### Group replication
+
+Calls to XREADGROUP and XACK change the state of a consumer group or consumer. However, it's not efficient to replicate every change to a consumer or consumer group.
+
+To maintain consumer groups in Active-Active databases with optimal performance:
+
+1. Group existence (CREATE/DESTROY) is replicated.
+1. Most XACK operations are replicated.
+1. Other operations, such as XGROUP, SETID, DELCONSUMER, are not replicated.
+
+For example:
+
+| Time | Region 1                                        | Region 2               |
+| ---- | ------------------------------------------------- | ------------------------ |
+| _t1_   | `XADD messages 110 text hello`                                |                          |
+| _t2_   | `XGROUP CREATE messages group1 0`                              |                          |
+| _t3_   | `XREADGROUP GROUP group1 Alice STREAMS messages >` <br/>**→ [110-1]** |                          |
+| _t4_   | _— Sync —_                                      | _— Sync —_             |
+| _t5_   | `XRANGE messages - +` <br/>**→ [110-1]**                          | XRANGE messages - + <br/>**→ [110-1]** |
+| _t6_   | `XINFO GROUPS messages` <br/>**→ [group1]**                            | XINFO GROUPS messages <br/>**→ [group1]**   |
+| _t7_   | `XINFO CONSUMERS messages group1` <br/>**→ [Alice]**                      | XINFO CONSUMERS messages group1 <br/>**→ []**  |
+| _t8_   | `XPENDING messages group1 - + 1` <br/>**→ [110-1]**                     | XPENDING messages group1 - + 1<br/>**→ []** |
+
+Using XREADGROUP across regions can result in regions reading the same entries.
+This is due to the fact that Active-Active Streams is designed for at-least-once reads or a single consumer.
+As shown in the previous example, Region 2 is not aware of any consumer group activity, so redirecting the XREADGROUP traffic from Region 1 to Region 2 results in reading entries that have already been read.
+
+### Replication performance optimizations
+
+Consumers acknowledge messages using the XACK command. Each ack effectively records the last consumed message. This can result in a lot of cross-region traffic. To reduce this traffic, we replicate XACK messages only when all of the read entries are acknowledged.
+
+| Time | Region 1                                                      | Region 2   | Explanation                                                                                                     |
+| ---- | --------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------- |
+| _t1_   | `XADD x 110-0 f1 v1`                                              |              |                                                                                                                 |
+| _t2_   | `XADD x 120-0 f1 v1`                                              |              |                                                                                                                 |
+| _t3_   | `XADD x 130-0 f1 v1`                                              |              |                                                                                                                 |
+| _t4_   | `XGROUP CREATE x group1 0`                                            |              |                                                                                                                 |
+| _t5_   | `XREADGROUP GROUP group1 Alice STREAMS x >` <br/>**→ [110-0, 120-0, 130-0]** |              |                                                                                                                 |
+| _t6_   | `XACK x group1 110-0`                                                   |              |                                                                                                                 |
+| _t7_   | _— Sync —_                                                    | _— Sync —_ | 110-0 and its preceding entries (none) were acknowledged. We replicate an XACK effect for 110-0.                |
+| _t8_   | `XACK x group1 130-0`                                                   |              |                                                                                                                 |
+| _t9_   | _— Sync —_                                                    | _— Sync —_ | 130-0 was acknowledged, but not its preceding entries (120-0). We DO NOT replicate an XACK effect for 130-0     |
+| _t10_  | `XACK x group1 120-0`                                                   |              |                                                                                                                 |
+| _t11_  | _— Sync —_                                                    | _— Sync —_ | 120-0 and its preceding entries (110-0 through 130-0) were acknowledged. We replicate an XACK effect for 130-0. |
+
+In this scenario, if we redirect the XREADGROUP traffic from Region 1 to Region 2 we do not re-read entries 110-0, 120-0 and 130-0.
+This means that the XREADGROUP does not return already-acknowledged entries.
+
+### Guarantees
+
+Unlike XREAD, XREADGOUP will never skip stream entries.
+In traffic redirection, XREADGROUP may return entries that have been read but not acknowledged. It may also even return entries that have already been acknowledged.
+
+## Summary
+
+With Active-Active streams, you can write to the same logical stream from multiple regions. As a result, the behavior of Active-Active streams differs somewhat from the behavior you get with Redis Open Source. This is summarized below:
+
+### Stream commands
+
+1. When using the _strict_ ID generation mode, XADD does not permit full stream entry IDs (that is, an ID containing both MS and SEQ).
+1. XREAD may skip entries when iterating a stream that is concurrently written to from more than one region. For reliable stream iteration, use XREADGROUP instead.
+1. XSETID fails when the new ID is less than current ID.
+
+### Consumer group notes
+
+The following consumer group operations are replicated:
+
+1. Consecutive XACK operations
+1. Consumer group creation and deletion (that is, XGROUP CREATE and XGROUP DESTROY)
+
+All other consumer group metadata is not replicated.
+
+A few other notes:
+
+1. XGROUP SETID and DELCONSUMER are not replicated.
+1. Consumers exist locally (XREADGROUP creates a consumer implicitly).
+1. Renaming a stream (using RENAME) deletes all consumer group information.
+---
+Title: Lists in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using list with an Active-Active database.
+linkTitle: Lists
+weight: $weight
+---
+Redis lists are simply lists of strings, sorted by insertion order. It
+is possible to add elements to a Redis List that push new elements to
+the head (on the left) or to the tail (on the right) of the list. Redis
+lists can be used to easily implement queues (using LPUSH and RPOP, for
+example) and stacks (using LPUSH and LPOP, for
+example).
+
+Lists in Active-Active databases are just the same as regular Redis Lists. See the
+following examples to get familiar with Lists' behavior in an
+Active-Active database.
+
+Simple Lists
+example:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH mylist “hello” |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | LPUSH mylist “world” |
+|  t4 | — Sync — | — Sync — |
+|  t5 | LRANGE mylist 0 -1 =>“world” “hello” | LRANGE mylist 0 -1 => “world” “hello” |
+
+**Explanation**:
+The final list contains both the "world" and "hello" elements, in that
+order (Instance 2 observed "hello" when it added
+"world").
+
+Example of Lists with Concurrent
+Insertions:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | LINSERT L AFTER x y1 |  |
+|  t4 |  | LINSERT L AFTER x y2 |
+|  t5 | LRANGE L 0 -1 => x y1 | LRANGE L 0 -1 => x y2 |
+|  t6 | — Sync — | — Sync — |
+|  t7 | LRANGE L 0 -1 => x y1 y2 | LRANGE L 0 -1 => x y1 y2 |
+
+**Explanation**:
+Instance 1 added an element y1 after x, and then Instance 2 added element y2 after x.
+The final List contains all three elements: x is the first element, after it y1 and then y2.
+The Active-Active database resolves the conflict arbitrarily but applies the resolution consistently across all Active-Active database instances.
+
+Example of Deleting a List while Pushing a New
+Element:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | LRANGE L 0 -1 => x | LRANGE L 0 -1 => x |
+|  t4 | LPUSH L y | DEL L |
+|  t5 | — Sync — | — Sync — |
+|  t6 | LRANGE L 0 -1 => y | LRANGE L 0 -1 => y |
+
+**Explanation**
+At t4 - t6, DEL deletes only observed elements. This is why L still
+contains y.
+
+Example of Popping Elements from a
+List:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x y z |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | RPOP L => x |
+|  t4 | — Sync — | — Sync — |
+|  t5 | RPOP L => y |  |
+|  t6 | — Sync — | — Sync — |
+|  t7 | RPOP L => z | RPOP L => z |
+
+**Explanation**:
+At t1, the operation pushes elements x, y, z to List L. At t3, the
+sequential pops behave as expected from a queue. At t7, the concurrent
+pop in both instances might show the same result. The instance was not
+able to sync regarding the z removal so, from the point of view of each
+instance, z is located in the List and can be popped. After syncing,
+both lists are empty.
+
+Be aware of the behavior of Lists in Active-Active databases when using List as a stack
+or queue. As seen in the above example, two parallel RPOP operations
+performed by two different Active-Active database instances can get the same element in
+the case of a concurrent operation. Lists in Active-Active databases guarantee that each
+element is POP-ed at least once, but cannot guarantee that each
+element is POP-ed only once. Such behavior should be taken into
+account when, for example, using Lists in Active-Active databases as building blocks for
+inter-process communication systems.
+
+In that case, if the same element cannot be handled twice by the
+applications, it's recommended that the POP operations be performed by
+one Active-Active database instance, whereas the PUSH operations can be performed by
+multiple instances.
+---
+Title: HyperLogLog in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using hyperloglog with an Active-Active database.
+linkTitle: HyperLogLog
+weight: $weight
+---
+**HyperLogLog** is an algorithm that addresses the [count-distinct problem](https://en.wikipedia.org/wiki/Count-distinct_problem).
+To do this it approximates the numbers of items in a [set](https://en.wikipedia.org/wiki/Multiset).
+Determining the _exact_ cardinality of a set requires memory according to the cardinality of the set.
+Because it estimates the cardinality by probability, the HyperLogLog algorithm can run with more reasonable memory requirements.
+
+## HyperLogLog in Redis
+
+Redis Open source implements [HyperLogLog](https://redislabs.com/redis-best-practices/counting/hyperloglog/) (HLL) as a native data structure.
+It supports adding elements ([PFADD]({{< relref "/commands/pfadd" >}}) to an HLL, counting elements ([PFCOUNT]({{< relref "/commands/pfcount" >}}) of HLLs, and merging of ([PFMERGE]({{< relref "/commands/pfmerge" >}}) HLLs.
+
+Here is an example of a simple write case:
+
+| Time | Replica 1         | Replica 2         |
+| ---- | ----------------- | ----------------- |
+| t1   | PFADD hll x       |                   |
+| t2   | --- sync ---      |                   |
+| t3   |                   | PFADD hll y       |
+| t4   | --- sync ---      |                   |
+| t5   | PFCOUNT hll --> 2 | PFCOUNT hll --> 2 |
+
+Here is an example of a concurrent add case:
+
+| Time | Replica 1         | Replica 2         |
+| ---- | ----------------- | ----------------- |
+| t1   | PFADD hll x       | PFADD hll y       |
+| t2   | PFCOUNT hll --> 1 | PFCOUNT hll --> 1 |
+| t3   | --- sync ---      |                   |
+| t4   | PFCOUNT hll --> 2 | PFCOUNT hll --> 2 |
+
+## The DEL-wins approach
+
+Other collections in the Redis-CRDT implementation use the observed remove method to resolve conflicts.
+The CRDT-HLL uses the DEL-wins method.
+If a DEL request is received at the same time as any other request (ADD/MERGE/EXPIRE) on the HLL-key
+the replicas consistently converge to delete key.
+In the observed remove method used by other collections (sets, lists, sorted-sets and hashes),
+only the replica that received the DEL request removes the elements, but elements added concurrently in other replicas exist in the consistently converged collection.
+We chose to use the DEL-wins method for the CRDT-HLL to maintain the original time and space complexity of the HLL in Redis Open source.
+
+Here is an example of a DEL-wins case:
+
+| HLL  |                 |                 | \|  | Set  |                     |                     |
+| ---- | --------------- | --------------- | --- | ---- | ------------------- | ------------------- |
+|      |                 |                 | \|  |      |                     |                     |
+| Time | Replica 1       | Replica 2       | \|  | Time | Replica 1           | Replica 2           |
+|      |                 |                 | \|  |      |                     |                     |
+| t1   | PFADD h e1      |                 | \|  | t1   | SADD s e1           |                     |
+| t2   | --- sync ---    |                 | \|  | t2   | --- sync ---        |                     |
+| t3   | PFCOUNT h --> 1 | PFCOUNT h --> 1 | \|  | t3   | SCARD s --> 1       | SCARD s --> 1       |
+| t4   | PFADD h e2      | Del h           | \|  | t4   | SADD s e2           | Del S               |
+| t5   | PFCOUNT h --> 2 | PFCOUNT h --> 0 | \|  | t5   | SCARD s --> 2       | SCARD s --> 0       |
+| t6   | --- sync ---    |                 | \|  | t6   | --- sync ---        |                     |
+| t7   | PFCOUNT h --> 0 | PFCOUNT h --> 0 | \|  | t7   | SCARD s --> 1       | SCARD s --> 1       |
+| t8   | Exists h --> 0  | Exists h --> 0  | \|  | t8   | Exists s --> 1      | Exists s --> 1      |
+|      |                 |                 | \|  | t9   | SMEMBERS s --> {e2} | SMEMBERS s --> {e2} |
+
+## HLL in Active-Active databases versus HLL in Redis Open source
+
+In Active-Active databases, we implemented HLL within the CRDT on the basis of the Redis implementation with a few exceptions:
+
+- Redis keeps the HLL data structure as an encoded string object
+    such that you can potentially run any string request can on a key that contains an HLL. In CRDT, only get and set are supported for HLL.
+- In CRDT, if you do SET on a key that contains a value encoded as an HLL, then the value will remain an HLL. If the value is not encoded as HLL, then it will be a register.
+---
+Title: Data types for Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Introduction to differences in data types between standalone and Active-Active
+  Redis databases.
+hideListLinks: true
+linktitle: Data types
+weight: 90
+---
+
+
+Active-Active databases use conflict-free replicated data types (CRDTs). From a developer perspective, most supported data types work the same for Active-Active and standard Redis databases. However, a few methods also come with specific requirements in Active-Active databases.
+
+Even though they look identical to standard Redis data types, there are specific rules that govern the handling of
+conflicting concurrent writes for each data type.
+
+As conflict handling rules differ between data types, some commands have slightly different requirements in Active-Active databases versus standard Redis databases.
+
+See the following articles for more information 
+
+---
+Title: Active-Active Redis applications
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: General information to keep in mind while developing applications for
+  an Active-Active database.
+hideListLinks: true
+linktitle: Develop applications
+weight: 99
+---
+Developing globally distributed applications can be challenging, as
+developers have to think about race conditions and complex combinations
+of events under geo-failovers and cross-region write conflicts. In Redis Enterprise Software (RS), Active-Active databases
+simplify developing such applications by directly using built-in smarts
+for handling conflicting writes based on the data type in use. Instead
+of depending on just simplistic "last-writer-wins" type conflict
+resolution, geo-distributed Active-Active databases (formerly known as CRDBs) combines techniques defined in CRDT
+(conflict-free replicated data types) research with Redis types to
+provide smart and automatic conflict resolution based on the data types
+intent.
+
+An Active-Active database is a globally distributed database that spans multiple Redis
+Enterprise Software clusters. Each Active-Active database can have many Active-Active database instances
+that come with added smarts for handling globally distributed writes
+using the proven
+[CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)
+approach.
+[CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)
+research describes a set of techniques for creating systems that can
+handle conflicting writes. CRDBs are powered by Multi-Master Replication
+(MMR) provides a straightforward and effective way to replicate your
+data between regions and simplify development of complex applications
+that can maintain correctness under geo-failovers and concurrent
+cross-region writes to the same data.
+
+{{< image filename="/images/rs/crdbs.png" alt="Geo-replication world map">}}
+
+Active-Active databases replicate data between multiple Redis Enterprise Software
+clusters. Common uses for Active-Active databases include disaster recovery,
+geographically redundant applications, and keeping data closer to your
+user's locations. MMR is always multi-directional amongst the clusters
+configured in the Active-Active database. For unidirectional replication, please see the
+Replica Of capabilities in Redis Enterprise Software.
+
+## Example of synchronization
+
+In the example below, database writes are concurrent at the point in
+times t1 and t2 and happen before a sync can communicate the changes.
+However, writes at times t4 and t6 are not concurrent as a sync happened
+in between.
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SET key1 “a” |  |
+|  t2 |  | SET key1 “b” |
+|  t3 | — Sync — | — Sync — |
+|  t4 | SET key1 “c” |  |
+|  t5 | — Sync — | — Sync — |
+|  t6 |  | SET key1 “d” |
+
+[Learn more about
+synchronization]({{< relref "/operate/rs/databases/active-active" >}}) for
+each supported data type and [how to develop]({{< relref "/operate/rs/databases/active-active/develop/develop-for-aa.md" >}}) with them on Redis Enterprise Software.
+---
+Title: Configure distributed synchronization
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure distributed synchronization so that any available proxy
+  endpoint can manage synchronization traffic.
+linktitle: Distributed synchronization
+weight: 80
+---
+Replicated databases, such as [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}}) and [Active-Active]({{< relref "/operate/rs/databases/active-active" >}}) databases,
+use proxy endpoints to synchronize database changes with the databases on other participating clusters.
+
+To improve the throughput and lower the latency for synchronization traffic,
+you can configure a replicated database to use distributed synchronization where any available proxy endpoint can manage synchronization traffic.
+
+Every database by default has one proxy endpoint that manages client and synchronization communication with the database shards,
+and that proxy endpoint is used for database synchronization.
+This is called centralized synchronization.
+
+To prepare a database to use distributed synchronization you must first make sure that the database [proxy policy]({{< relref "/operate/rs/databases/configure/proxy-policy.md" >}})
+is defined so that either each node has a proxy endpoint or each primary (master) shard has a proxy endpoint.
+After you have multiple proxies for the database,
+you can configure the database synchronization to use distributed synchronization.
+
+## Configure distributed synchronization
+
+{{< note >}}
+You may use the database name in place of `db:<ID>` in the following `rladmin` commands.
+{{< /note >}}
+
+To configure distributed synchronization:
+
+1. To check the proxy policy for the database, run: `rladmin status`
+
+    The output of the status command shows the list of endpoints on the cluster and the proxy policy for the endpoint.
+
+    ```sh
+    ENDPOINTS:
+    DB:ID       NAME      ID                        NODE          ROLE                                SSL
+    db:1        db        endpoint:1:1              node:1        all-master-shards                   No
+    ```
+
+    If the proxy policy (also known as a _role_) is `single`, configure the policy to `all-nodes` or `all-master-shards` according to your needs with the command:
+
+    ```sh
+    rladmin bind db db:<ID> endpoint <endpoint id> policy <all-master-shards|all-nodes>
+    ```
+
+1. To configure the database to use distributed synchronization, run:
+
+    ```sh
+    rladmin tune db db:<ID> syncer_mode distributed
+    ```
+
+    To change back to centralized synchronization, run:
+
+    ```sh
+    rladmin tune db db:<ID> syncer_mode centralized
+    ```
+
+## Verify database synchronization
+
+Use `rladmin` to verify a database synchronization role:
+
+```sh
+rladmin info db db:<ID>
+```
+
+The current database role is reported as the `syncer_mode` value:
+
+```sh
+$ rladmin info db db:<ID>     
+db:<ID> [<db_name>]:
+  // (Other settings removed) 
+  syncer_mode: centralized
+```
+---
+Title: Manage Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage your Active-Active database settings.
+linktitle: Manage
+weight: 30
+---
+
+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`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}).
+
+If you need to apply changes locally to one database instance, you use the Cluster Manager UI or [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/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.
+
+## Participating clusters
+
+You can add and remove participating clusters of an Active-Active database to change the topology.
+To manage the changes to Active-Active topology, use [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/" >}}) or the participating clusters list in the Cluster Manager UI.
+
+### Add participating clusters
+
+All existing participating clusters must be online and in a syncing state when you add new participating clusters.
+
+New participating clusters create the Active-Active database instance based on the global Active-Active database configuration.
+After you add new participating clusters to an existing Active-Active database,
+the new database instance can accept connections and read operations.
+The new instance does not accept write operations until it is in the syncing state.
+
+{{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+{{</note>}}
+
+To add a new participating cluster to an existing Active-Active configuration using the Cluster Manager UI:
+
+1. Select the Active-Active database from the **Databases** list and go to its **Configuration** screen.
+
+1. Click **Edit**.
+
+1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-add-cluster.png" alt="Add cluster panel.">}}
+
+1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Click **Save**.
+
+
+### Remove participating clusters
+
+All existing participating clusters must be online and in a syncing state when you remove an online participating cluster.
+If you must remove offline participating clusters, you can forcefully remove them.
+If a forcefully removed participating cluster tries to rejoin the cluster,
+its Active-Active database membership will be out of date.
+The joined participating clusters reject updates sent from the removed participating cluster.
+To prevent rejoin attempts, purge the forcefully removed instance from the participating cluster.
+
+To remove a participating cluster using the Cluster Manager UI:
+
+1. Select the Active-Active database from the **Databases** list and go to its **Configuration** screen.
+
+1. Click **Edit**.
+
+1. In the **Participating clusters** section, point to the cluster you want to delete in the **Other participating clusters** list:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-edit-delete.png" alt="Edit and delete buttons appear when you point to an entry in the Other participating clusters list.">}}
+
+1. Click {{< image filename="/images/rs/buttons/delete-button.png#no-click" alt="The Delete button" width="25px" class="inline" >}} to remove the cluster.
+
+1. Click **Save**.
+
+## Replication backlog
+
+Redis databases that use [replication for high availability]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}) maintain a replication backlog (per shard) to synchronize the primary and replica shards of a database. In addition to the database replication backlog, Active-Active databases maintain a backlog (per shard) to synchronize the database instances between clusters.
+
+By default, both the database and Active-Active replication backlogs are set to one percent (1%) of the database size divided by the number of shards. This can range between 1MB to 250MB per shard for each backlog.
+
+### Change the replication backlog size
+
+Use the [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) utility to control the size of the replication backlogs. You can set it to `auto` or set a specific size.  
+
+Update the database replication backlog configuration with the `crdb-cli` command shown below.
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+Update the Active-Active (CRDT) replication backlog with the command shown below: 
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"crdt_repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+## Data persistence
+
+Active-Active supports AOF (Append-Only File) data persistence only.  Snapshot persistence is _not_ supported for Active-Active databases and should not be used.
+
+If an Active-Active database is currently using snapshot data persistence, use `crdb-cli` to switch to AOF persistence:
+```text
+ crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+
+---
+Title: Enable causal consistency
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable causal consistency  in an Active-Active database.
+linkTitle: Causal consistency
+weight: 70
+---
+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.
+
+### Enable causal consistency
+
+When you create an Active-Active database, you can enable causal consistency in the Cluster Manager UI:
+
+1. In the **Participating clusters** section of the **Create Active-Active database** screen, locate **Causal Consistency**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/create-a-a-db-participating-clusters.png" alt="The Participating clusters section of the Create Active-Active database screen.">}}
+
+1. Click **Change** to open the **Causal Consistency** dialog.
+
+1. Select **Enabled**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enable-causal-consistency.png" alt="Enabled is selected in the Causal Consistency dialog.">}}
+
+1. Click **Change** to confirm your selection.
+
+After database creation, you can only turn causal consistency on or off using the REST API or `crdb-cli`.
+The updated setting only affects commands and operations received after the change.
+
+### Causal consistency side effects
+
+When the causal consistency option is enabled, each instance maintains the order of operations it received from another instance
+and relays that information to all other N-2 instances,
+where N represents the number of instances used by the Active-Active database.
+
+As a result, network traffic is increased by a factor of (N-2).
+The memory consumed by each instance and overall performance are also impacted when causal consistency is activated.
+
+---
+Title: Connect to your Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to connect to an Active-Active database using redis-cli or a sample
+  Python application.
+linkTitle: Connect
+weight: 26
+---
+
+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.
+
+{{< image filename="/images/rs/crdb-diagram.png" >}}
+
+### Connecting using redis-cli {#connecting-using-rediscli}
+
+redis-cli is a simple command-line tool to interact with redis database.
+
+1. To use redis-cli on port 12000 from the node 1 terminal, run:
+
+    ```sh
+    redis-cli -p 12000
+    ```
+
+1. Store and retrieve a key in the database to test the connection with these
+    commands:
+
+    - `set key1 123`
+    - `get key1`
+
+    The output of the command looks like this:
+
+    ```sh
+    127.0.0.1:12000> set key1 123
+    OK
+    127.0.0.1:12000> get key1
+    "123"
+    ```
+
+1. Enter the terminal of node 1 in cluster 2, run the redis-cli, and
+   retrieve key1.
+
+    The output of the commands looks like this:
+
+    ```sh
+    $ redis-cli -p 12000
+    127.0.0.1:12000> get key1
+    "123"
+    ```
+
+### Connecting using _Hello World_ application in Python
+
+A simple python application running on the host machine can also connect
+to the database.
+
+{{< note >}}
+Before you continue, you must have python and
+[redis-py](https://github.com/andymccurdy/redis-py#installation)
+(python library for connecting to Redis) configured on the host machine
+running the container.
+{{< /note >}}
+
+1. In the command-line terminal, create a new file called "redis_test.py"
+
+    ```sh
+    vi redis_test.py
+    ```
+
+1. Paste this code into the "redis_test.py" file.
+
+    This application stores a value in key1 in cluster 1, gets that value from
+    key1 in cluster 1, and gets the value from key1 in cluster 2.
+
+    ```py
+    import redis
+    rp1 = redis.StrictRedis(host='localhost', port=12000, db=0)
+    rp2 = redis.StrictRedis(host='localhost', port=12002, db=0)
+    print ("set key1 123 in cluster 1")
+    print (rp1.set('key1', '123'))
+    print ("get key1 cluster 1")
+    print (rp1.get('key1'))
+    print ("get key1 from cluster 2")
+    print (rp2.get('key1'))
+    ```
+
+1. To run the "redis_test.py" application, run:
+
+    ```sh
+    python redis_test.py
+    ```
+
+    If the connection is successful, the output of the application looks like:
+
+    ```sh
+    set key1 123 in cluster 1
+    True
+    get key1 cluster 1
+    "123"
+    get key1 from cluster 2
+    "123"
+    ```---
+Title: Create an Active-Active geo-replicated database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to create an Active-Active database and things to consider when setting
+  it up.
+linkTitle: Create
+weight: 25
+---
+[Active-Active geo-replicated databases]({{< relref "/operate/rs/databases/active-active" >}}) (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]({{< relref "/operate/rs/databases/active-active/develop#example-of-synchronization" >}}) to all instances without conflict.
+
+## Steps to create an Active-Active database
+
+1. **Create a service account** - On each participating cluster, create a dedicated user account with the Admin role.
+1. **Confirm connectivity** - Confirm network connectivity between the participating clusters.
+1. **Create Active-Active database** - Connect to one of your clusters and create a new Active-Active database.
+1. **Add participating clusters** - Add the participating clusters to the Active-Active database with the user credentials for the service account.
+1. **Verify creation** - Log in to each of the participating clusters and verify your Active-Active database was created on them.
+1. **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]({{< relref "/operate/rs/databases/active-active#network-time-service-ntp-or-chrony" >}}) listener (ntpd) configured and running on each node in all clusters
+
+## Create an Active-Active database
+
+1. Create service accounts on each participating cluster:
+
+    1. In a browser, open the Cluster Manager UI for the participating cluster.
+
+        The default address is: `https://<RS_address>:8443`
+
+    1. Go to the **Access Control > Users** tab:
+
+        {{<image filename="images/rs/access-control-user-panel.png" alt="Add role with name" >}}
+    
+    1. Click **+ Add user**.
+
+    1. Enter the username, email, and password for the user.
+    
+    1. Select the **Admin** role.
+    
+    1. Click **Save**.
+
+1. To verify network connectivity between participating clusters,
+    run the following `telnet` command from each participating cluster to all other participating clusters:
+
+    ```sh
+    telnet <target FQDN> 9443
+    ```
+
+1. In a browser, open the Cluster Manager UI of the cluster where you want to create the Active-Active database.
+
+    The default address is: `https://<RS_address>:8443`
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select **Active-Active database**.
+
+1. Enter the cluster's local admin credentials, then click **Save**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enter-local-admin-credentials.png" alt="Enter the cluster's admin username and password.">}}
+    
+1. Add participating clusters that will host instances of the Active-Active database:
+
+    1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+    1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/create-db-add-participating-clusters.png" alt="Add cluster panel.">}}
+
+        {{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+        {{</note>}}
+
+    1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Enter a **Database name**.
+
+1. If your cluster supports [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}), in **Runs on** you can select **Flash** so that your database uses Flash memory. We recommend that you use AOF every 1 sec for the best performance during the initial Active-Active database sync of a new replica.
+
+1. To configure additional database settings, expand each relevant section to make changes.
+
+    See [Configuration settings](#configuration-settings) for more information about each setting.
+
+1. Click **Create**.
+
+## Configuration settings
+
+- **Database version** - The Redis version used by your database.
+
+- **Database name** - The database name requirements are:
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+- **Port** - You can define the port number that clients use to connect to the database. Otherwise, a port is randomly selected.
+
+    {{< note >}}
+You cannot change the [port number]({{< relref "/operate/rs/networking/port-configurations.md" >}})
+after the database is created.
+    {{< /note >}}
+
+- **Memory limit** - [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}) include all database replicas and shards, including replica shards in database replication and database shards in database clustering.
+
+    If the total size of the database in the cluster reaches the memory limit, the data eviction policy for the database is enforced.
+
+    {{< note >}}
+If you create a database with Auto Tiering enabled, you also need to set the RAM-to-Flash ratio
+for this database. Minimum RAM is 10%. Maximum RAM is 50%.
+    {{< /note >}}
+
+- **Memory eviction** - The default [eviction policy]({{<relref "/operate/rs/databases/memory-performance/eviction-policy">}}) for Active-Active databases is `noeviction`. Redis Enterprise versions 6.0.20 and later support all eviction policies for Active-Active databases, unless [Auto Tiering]({{<relref "/operate/rs/databases/auto-tiering">}}) is enabled.
+
+- [**Capabilities**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) (previously **Modules**) - When you create a new in-memory database, you can enable multiple Redis Stack capabilities in the database. For Auto Tiering databases, you can enable capabilities that support Auto Tiering. See [Redis Enterprise and Redis Stack feature compatibility 
+]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}) for compatibility details.
+        
+    {{<note>}}
+To use Redis Stack capabilities, enable them when you create a new database.
+You cannot enable them after database creation.
+    {{</note>}} 
+        
+    To add capabilities to the database:
+
+    1. In the **Capabilities** section, select one or more capabilities.
+    
+    1. To customize capabilities, select **Parameters** and enter the optional custom configuration.
+    
+    1. Select **Done**.
+
+### TLS
+
+If you enable TLS when you create the Active-Active database, the nodes use the TLS mode **Require TLS for CRDB communication only** to require TLS authentication and encryption for communications between participating clusters.
+        
+After you create the Active-Active database, you can set the TLS mode to **Require TLS for all communications** so client communication from applications are also authenticated and encryption.
+
+### High availability
+
+- [**Replication**]({{< relref "/operate/rs/databases/durability-ha/replication" >}}) - We recommend that all Active-Active database use replication for best intercluster synchronization performance.
+    
+    When replication is enabled, every Active-Active database master shard is replicated to a corresponding replica shard. The replica shards are then used to synchronize data between the instances, and the master shards are dedicated to handling client requests.
+    
+- [**Replica high availability**]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) - We also recommend that you enable replica high availability to ensure replica shards are highly-available for this synchronization.
+
+### Clustering
+
+- In the [**Clustering**]({{<relref "/operate/rs/databases/durability-ha/clustering">}}) section, you can either:
+
+    - **Enable sharding** and select the number of shards you want to have in the database. When database clustering is enabled, databases have limitations for [multi-key operations]({{<relref "/operate/rs/databases/durability-ha/clustering#multikey-operations">}}).
+    
+        You can increase the number of shards in the database at any time.
+        
+    - Clear the **Enable sharding** option to use only one shard, which allows you to use [multi-key operations]({{<relref "/operate/rs/databases/durability-ha/clustering#multikey-operations">}}) without the limitations.
+
+    {{<note>}}
+You cannot enable or turn off database clustering after the Active-Active database is created.
+    {{</note>}}
+
+- [**OSS Cluster API**]({{< relref "/operate/rs/databases/configure/oss-cluster-api.md" >}}) - The OSS Cluster API configuration allows access to multiple endpoints for increased throughput. The OSS Cluster API setting applies to all instances of the Active-Active database across participating clusters.
+
+    This configuration requires clients to connect to the primary node to retrieve the cluster topology before they can connect directly to proxies on each node.
+    
+    When you enable the OSS Cluster API, shard placement changes to _Sparse_, and the database proxy policy changes to _All primary shards_ automatically.
+
+### Durability
+
+To protect against loss of data stored in RAM, you can enable [**Persistence**]({{<relref "/operate/rs/databases/configure/database-persistence">}}) to store a copy of the data on disk.
+        
+Active-Active databases support append-only file (AOF) persistence only. Snapshot persistence is not supported for Active-Active databases.
+
+### Access control
+
+- **Unauthenticated access** - You can access the database as the default user without providing credentials.
+
+- **Password-only authentication** - When you configure a password for your database's default user, all connections to the database must authenticate with the [AUTH command]({{< relref "/commands/auth" >}}.
+
+    If you also configure an access control list, connections can specify other users for authentication, and requests are allowed according to the Redis ACLs specified for that user.
+
+    Creating a database without ACLs enables a *default* user with full access to the database. You can secure default user access by requiring a password.
+
+- **Access Control List** - You can specify the [user roles]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) that have access to the database and the [Redis ACLs]({{< relref "/operate/rs/security/access-control/redis-acl-overview" >}}) that apply to those connections.
+
+    You can only configure access control after the Active-Active database is created. In each participating cluster, add ACLs after database creation.
+
+    To define an access control list for a database:
+
+    1. In **Security > Access Control > Access Control List**, select **+ Add ACL**.
+
+    1. Select a [role]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) to grant database access.
+
+    1. Associate a [Redis ACL]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) with the role and database.
+
+    1. Select the check mark to add the ACL.
+
+### Causal consistency
+
+[**Causal consistency**]({{< relref "/operate/rs/databases/active-active/causal-consistency" >}}) in an Active-Active database guarantees that the order of operations on a specific key is maintained across all instances of an Active-Active database.
+    
+To enable causal consistency for an existing Active-Active database, use the REST API.
+
+<!-- Also in getting-started-crdbs.md -->
+## Test Active-Active database connections
+
+With the Redis database created, you are ready to connect to your database. See [Connect to Active-Active databases]({{< relref "/operate/rs/databases/active-active/connect.md" >}}) for tutorials and examples of multiple connection methods.
+---
+Title: Delete Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Considerations while deleting Active-Active databases.
+linktitle: Delete
+weight: 35
+---
+
+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.
+{{% /warning %}}
+
+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.
+
+We recommended that you:
+
+- Back up your data and test the restore on another database before you delete an Active-Active database.
+- Consider [flushing the data]({{< relref "/operate/rs/databases/import-export/flush.md" >}}) from the database
+    so that you can keep the Active-Active database configuration and restore the data to it if necessary.
+---
+Title: Syncer process
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Detailed information about the syncer process and its role in distributed
+  databases.
+linktitle: Syncer process
+weight: 90
+---
+
+## Syncer process
+
+Each node in a cluster containing an instance of an Active-Active database hosts a process called the syncer.
+The syncer process:
+
+1. Connects to the proxy on another participating cluster
+1. Reads data from that database instance
+1. Writes the data to the local cluster's primary(master) shard
+
+Some replication capabilities are also included in [Redis Open Source]({{< relref "/operate/oss_and_stack/management/replication" >}}).
+
+The primary (also known as master) shard at the top of the primary-replica tree creates a replication ID.
+This replication ID is identical for all replicas in that tree.
+When a new primary is appointed, the replication ID changes, but a partial sync from the previous ID is still possible.
+
+
+In a partial sync, the backlog of operations since the offset are transferred as raw operations.
+In a full sync, the data from the primary is transferred to the replica as an RDB file which is followed by a partial sync. 
+
+Partial synchronization requires a backlog large enough to store the data operations until connection is restored. See [replication backlog]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog" >}}) for more info on changing the replication backlog size.
+
+### Syncer in Active-Active replication
+
+In the case of an Active-Active database:
+
+- Multiple past replication IDs and offsets are stored to allow for multiple syncs 
+- The [Active-Active replication backlog]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog" >}}) is also sent to the replica during a full sync. 
+
+{{< warning >}}
+Full sync triggers heavy data transfers between geo-replicated instances of an Active-Active database. 
+{{< /warning >}}
+
+An Active-Active database uses partial synchronization in the following situations:
+
+- Failover of primary shard to replica shard
+- Restart or crash of replica shard that requires sync from primary
+- Migrate replica shard to another node
+- Migrate primary shard to another node as a replica using failover and replica migration
+- Migrate primary shard and preserve roles using failover, replica migration, and second failover to return shard to primary
+
+{{< note >}}
+Synchronization of data from the primary shard to the replica shard is always a full synchronization.
+{{< /note >}}---
+Title: Get started with Redis Enterprise Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Quick start guide to create an Active-Active database for test and development.
+linktitle: Get started
+weight: 20
+---
+
+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:
+
+1. Run two Redis Enterprise Software Docker containers.
+
+1. Set up each container as a cluster.
+
+1. Create a new Redis Enterprise Active-Active database.
+
+1. Test connectivity to the Active-Active database.
+
+To run an Active-Active database on installations from the [Redis Enterprise Software download package]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}),
+set up two Redis Enterprise Software installations and continue from Step 2.
+
+{{<note>}}
+This getting started guide is for development or demonstration environments.
+For production environments, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}) for instructions.
+{{</note>}}
+
+## Run two containers
+
+To spin up two Redis Enterprise Software containers, run these commands:
+
+```sh
+docker run -d --cap-add sys_resource -h rs1_node1 --name rs1_node1 -p 8443:8443 -p 9443:9443 -p 12000:12000 redislabs/redis
+```
+
+```sh
+docker run -d --cap-add sys_resource -h rs2_node1 --name rs2_node1 -p 8445:8443 -p 9445:9443 -p 12002:12000 redislabs/redis
+```
+
+The **-p** options map the Cluster Manager UI port (8443), REST API port (9443), and
+database access port differently for each container to make sure that all
+containers can be accessed from the host OS that is running the containers.
+
+## Set up two clusters
+
+1. For cluster 1, go to `https://localhost:8443` in a browser on the
+host machine to access the Redis Enterprise Software Cluster Manager UI.
+
+    {{<note>}}
+Depending on your browser, you may see a certificate error. Continue to the website.
+    {{</note>}}
+
+1. Click **Create new cluster**:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/create-cluster.png" alt="When you first install Redis Enterprise Software, you need to set up a cluster." >}}
+
+1. Enter an email and password for the administrator account, then click **Next** to proceed to cluster setup:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/admin-credentials.png" alt="Set the credentials for your admin user." >}}
+
+1. Enter your cluster license key if you have one. Otherwise, a trial version is installed.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/cluster-license-key.png" alt="Enter your cluster license key if you have one." >}}
+
+1. In the **Configuration** section of the **Cluster** settings page, enter a cluster FQDN, for example `cluster1.local`:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/config-cluster1.png" alt="Configure the cluster FQDN." >}}
+
+1. On the node setup screen, keep the default settings and click **Create cluster**:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/node-settings.png" alt="Configure the node specific settings." >}}
+
+1. Click **OK** to confirm that you are aware of the replacement of the HTTPS SSL/TLS
+    certificate on the node, and proceed through the browser warning.
+
+1. Repeat the previous steps for cluster 2 with these differences:
+
+    - In your web browser, go to `https://localhost:8445` to set up the cluster 2.
+
+    - For the **Cluster name (FQDN)**, enter a different name, such as `cluster2.local`.
+
+Now you have two Redis Enterprise Software clusters with FQDNs
+`cluster1.local` and `cluster2.local`.
+
+{{<note>}}
+Each Active-Active instance must have a unique fully-qualified domain name (FQDN).
+{{</note>}}
+
+## Create an Active-Active database
+
+1. Sign in to cluster1.local's Cluster Manager UI at `https://localhost:8443`
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select **Active-Active database**.
+
+1. Enter the cluster's local admin credentials, then click **Save**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enter-local-admin-credentials-cluster1.png" alt="Enter the cluster's admin username and password.">}}
+
+1. Add participating clusters that will host instances of the Active-Active database:
+
+    1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+    1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+        In the **Other participating clusters** list, add the address and admin credentials for the other cluster: `https://cluster2.local:9443`
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-add-cluster2.png" alt="Add cluster panel.">}}
+
+    1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Enter `database1` for **Database name** and `12000` for **Port**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/quickstart-db-name-port.png" alt="Database name and port text boxes.">}}
+
+1. Configure additional settings:
+
+    1. In the **High availability** section, turn off **Replication** since each cluster has only one node in this setup:
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/quickstart-ha-turn-off-replication-7-8-2.png" alt="Turn off replication in the High availability section.">}}
+
+
+    1. In the **Clustering** section, either:
+
+        - Make sure that **Sharding** is enabled and select the number of shards you want to have in the database. When database clustering is enabled,
+        databases are subject to limitations on [Multi-key commands]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}).
+        You can increase the number of shards in the database at any time.
+
+        - Turn off **Sharding** to use only one shard and avoid [Multi-key command]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}) limitations.
+
+        {{< note >}}
+You cannot enable or turn off database clustering after the Active-Active database is created.
+        {{< /note >}}
+
+1. Click **Create**.
+
+    {{< note >}}
+{{< embed-md "docker-memory-limitation.md" >}}
+    {{< /note >}}
+
+1. After the Active-Active database is created, sign in to the Cluster Manager UIs for cluster 1 at `https://localhost:8443` and cluster 2 at `https://localhost:8445`.
+
+1. Make sure each cluster has an Active-Active database member database with the name `database1`.
+
+    In a real-world deployment, cluster 1 and cluster 2 would most likely be
+    in separate data centers in different regions. However, for
+    local testing we created the scale-minimized deployment using two
+    local clusters running on the same host.
+
+<!-- Also in getting-started-crdbs.md -->
+## Test connection
+
+With the Redis database created, you are ready to connect to your
+database. See [Connect to Active-Active databases]({{< relref "/operate/rs/databases/active-active/connect" >}}) for tutorials and examples of multiple connection methods.
+---
+Title: Active-Active geo-distributed Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Overview of the Active-Active database in Redis Enterprise Software
+hideListLinks: true
+linktitle: Active-Active
+weight: 40
+---
+In Redis Enterprise, Active-Active geo-distribution is based on [CRDT technology](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type).
+The Redis Enterprise implementation of CRDT is called an Active-Active database (formerly known as CRDB).
+With Active-Active databases, applications can read and write to the same data set from different geographical locations seamlessly and with latency less than one millisecond (ms),
+without changing the way the application connects to the database.
+
+Active-Active databases also provide disaster recovery and accelerated data read-access for geographically distributed users.
+
+
+## High availability
+
+The [high availability]({{< relref "/operate/rs/databases/durability-ha/" >}}) that Active-Active replication provides is built upon a number of Redis Enterprise Software features (such as [clustering]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}), [replication]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}), and [replica HA]({{< relref "/operate/rs/databases/configure/replica-ha.md" >}})) as well as some features unique to Active-Active ([multi-primary replication]({{<relref "#multi-primary-replication/">}}), [automatic conflict resolution]({{<relref "#conflict-resolution/">}}), and [strong eventual consistency]({{<relref "#strong-eventual-consistency/">}})).
+
+Clustering and replication are used together in Active-Active databases to distribute multiple copies of the dataset across multiple nodes and multiple clusters. As a result, a node or cluster is less likely to become a single point of failure. If a primary node or primary shard fails, a replica is automatically promoted to primary. To avoid having one node hold all copies of certain data, the [replica HA]({{< relref "/operate/rs/databases/configure/replica-ha.md" >}}) feature (enabled by default) automatically migrates replica shards to available nodes.
+
+## Multi-primary replication
+
+In Redis Enterprise Software, replication copies data from primary shards to replica shards. Active-Active geo-distributed replication also copies both primary and replica shards to other clusters. Each Active-Active database needs to span at least two clusters; these are called participating clusters.
+
+Each participating cluster hosts an instance of your database, and each instance has its own primary node. Having multiple primary nodes means you can connect to the proxy in any of your participating clusters. Connecting to the closest cluster geographically enables near-local latency. Multi-primary replication (previously referred to as multi-master replication) also means that your users still have access to the database if one of the participating clusters fails.
+
+{{< note >}}
+Active-Active databases do not replicate the entire database, only the data.
+Database configurations, LUA scripts, and other support info are not replicated.
+{{< /note >}}
+
+## Syncer
+
+Keeping multiple copies of the dataset consistent across multiple clusters is no small task. To achieve consistency between participating clusters, Redis Active-Active replication uses a process called the [syncer]({{< relref "/operate/rs/databases/active-active/syncer" >}}). 
+
+The syncer keeps a [replication backlog]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog/" >}}), which stores changes to the dataset that the syncer sends to other participating clusters. The syncer uses partial syncs to keep replicas up to date with changes, or a full sync in the event a replica or primary is lost.
+
+## Conflict resolution
+
+Because you can connect to any participating cluster to perform a write operation, concurrent and conflicting writes are always possible. Conflict resolution is an important part of the Active-Active technology. Active-Active databases only use [conflict-free replicated data types (CRDTs)](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type). These data types provide a predictable conflict resolution and don't require any additional work from the application or client side.
+
+When developing with CRDTs for Active-Active databases, you need to consider some important differences. See [Develop applications with Active-Active databases]({{< relref "/operate/rs/databases/active-active/develop/_index.md" >}}) for related information.
+
+
+## Strong eventual consistency
+
+Maintaining strong consistency for replicated databases comes with tradeoffs in scalability and availability. Redis Active-Active databases use a strong eventual consistency model, which means that local values may differ across replicas for short periods of time, but they all eventually converge to one consistent state. Redis uses vector clocks and the CRDT conflict resolution to strengthen consistency between replicas. You can also enable the causal consistency feature to preserve the order of operations as they are synchronized among replicas.
+
+Other Redis Enterprise Software features can also be used to enhance the performance, scalability, or durability of your Active-Active database. These include [data persistence]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}), [multiple active proxies]({{< relref "/operate/rs/databases/configure/proxy-policy.md" >}}), [distributed synchronization]({{< relref "/operate/rs/databases/active-active/synchronization-mode.md" >}}), [OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api.md" >}}), and [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}).
+
+## Next steps
+
+- [Plan your Active-Active deployment]({{< relref "/operate/rs/databases/active-active/planning.md" >}})
+- [Get started with Active-Active]({{< relref "/operate/rs/databases/active-active/get-started.md" >}})
+- [Create an Active-Active database]({{< relref "/operate/rs/databases/active-active/create.md" >}})---
+Title: Configure high availability for replica shards
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure high availability for replica shards so that the cluster automatically
+  migrates the replica shards to an available node.
+linkTitle: Replica high availability
+weight: 50
+---
+
+When you enable [database replication]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}),
+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.
+
+Enabling _replica\_ha_ configures the cluster to automatically replicate the promoted replica on an available node. 
+This automatically returns the database to a state where there are two copies of the data: 
+the former replica shard which has been promoted to primary and a new replica shard.
+
+An available node:
+
+1. Meets replica migration requirements, such as [rack-awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}).
+1. Has enough available RAM to store the replica shard.
+1. Does not also contain the primary shard.
+
+In practice, replica migration creates a new replica shard and copies the data from the primary shard to the new replica shard.
+
+For example:
+
+1. Node:2 has a primary shard and node:3 has the corresponding replica shard.
+1. Either:
+
+    - Node:2 fails and the replica shard on node:3 is promoted to primary.
+    - Node:3 fails and the primary shard is no longer replicated to the replica shard on the failed node.
+
+1. If replica HA is enabled, a new replica shard is created on an available node.
+1. The data from the primary shard is replicated to the new replica shard.
+
+{{< note >}}
+- Replica HA follows all prerequisites of replica migration, such as [rack-awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}).
+- Replica HA migrates as many shards as possible based on available DRAM in the target node. When no DRAM is available, replica HA stops migrating replica shards to that node.
+{{< /note >}}
+
+## Configure high availability for replica shards
+
+If replica high availability is enabled for both the cluster and a database,
+the database's replica shards automatically migrate to another node when a primary or replica shard fails.
+If replica HA is not enabled at the cluster level,
+replica HA will not migrate replica shards even if replica HA is enabled for a database.
+
+Replica high availability is enabled for the cluster by default.
+
+When you create a database using the Cluster Manager UI, replica high availability is enabled for the database by default if you enable replication.
+
+{{<image filename="images/rs/screenshots/databases/config-replica-ha-enabled-7-8-2.png" alt="When you select the Replication checkbox in the High availability section of the database configuration screen, the Replica high availability checkbox is also selected by default.">}}
+
+To use replication without replication high availability, clear the **Replica high availability** checkbox.
+
+You can also enable or turn off replica high availability for a database using `rladmin` or the REST API.
+
+{{< note >}}
+For Active-Active databases, replica HA is enabled for the database by default to make sure that replica shards are available for Active-Active replication.
+{{< /note >}}
+
+### Configure cluster policy for replica HA
+
+To enable or turn off replica high availability by default for the entire cluster, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster slave_ha { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "slave_ha": <boolean> }
+    ```
+
+### Turn off replica HA for a database
+
+To turn off replica high availability for a specific database using `rladmin`, run:
+
+``` text
+rladmin tune db db:<ID> slave_ha disabled
+```
+
+You can use the database name in place of `db:<ID>` in the preceding command.
+
+
+## Configuration options
+
+You can see the current configuration options for replica HA with:
+
+``` text
+rladmin info cluster
+```
+
+### Grace period
+
+By default, replica HA has a 10-minute grace period after node failure and before new replica shards are created.
+
+{{<note>}}The default grace period is 30 minutes for containerized applications using [Redis Enterprise Software for Kubernetes]({{< relref "/operate/kubernetes/" >}}).{{</note>}}
+
+To configure this grace period from rladmin, run:
+
+``` text
+rladmin tune cluster slave_ha_grace_period <time_in_seconds>
+```
+
+
+### Shard priority
+
+Replica shard migration is based on priority.  When memory resources are limited, the most important replica shards are migrated first:
+
+1. `slave_ha_priority` - Replica shards with higher 
+    integer values are migrated before shards with lower values.
+
+    To assign priority to a database, run:
+
+    ``` text
+    rladmin tune db db:<ID> slave_ha_priority <positive integer>
+    ```
+    
+    You can use the database name in place of `db:<ID>` in the preceding command.
+
+1. Active-Active databases - Active-Active database synchronization uses replica shards to synchronize between the replicas.
+1. Database size - It is easier and more efficient to move replica shards of smaller databases.
+1. Database UID - The replica shards of databases with a higher UID are moved first.
+
+### Cooldown periods
+
+Both the cluster and the database have cooldown periods.
+
+After node failure, the cluster cooldown period (`slave_ha_cooldown_period`) prevents another replica migration due to another node failure for any
+database in the cluster until the cooldown period ends. The default is one hour.
+
+After a database is migrated with replica HA,
+it cannot go through another migration due to another node failure until the cooldown period for the database (`slave_ha_bdb_cooldown_period`) ends. The default is two hours.
+
+To configure cooldown periods, use [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+- For the cluster:
+
+    ``` text
+    rladmin tune cluster slave_ha_cooldown_period <time_in_seconds>
+    ```
+
+- For all databases in the cluster:
+
+    ``` text
+    rladmin tune cluster slave_ha_bdb_cooldown_period <time_in_seconds>
+    ```
+
+### Alerts
+
+The following alerts are sent during replica HA activation:
+
+- Shard migration begins after the grace period.
+- Shard migration fails because there is no available node (sent hourly).
+- Shard migration is delayed because of the cooldown period.
+---
+Title: Change database upgrade configuration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure cluster-wide policies that affect default database upgrades.
+linkTitle: Upgrade configuration
+toc: 'true'
+weight: 15
+---
+
+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:
+
+1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Upgrade configuration**.
+
+1. Change database [upgrade configuration settings](#upgrade-config-settings).
+
+1. Select **Save**.
+
+## Upgrade configuration settings {#upgrade-config-settings}
+
+### Database shard parallel upgrade
+
+To change the number of shards upgraded in parallel during database upgrades, use one of the following methods:
+
+- Cluster Manager UI – Edit **Database shard parallel upgrade** in [**Upgrade configuration**](#edit-upgrade-configuration)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster parallel_shards_upgrade { all | <integer> }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "parallel_shards_upgrade": <integer> }
+    ```
+
+### RESP3 support
+
+The cluster-wide option `resp3_default` determines the default value of the `resp3` option, which enables or deactivates RESP3 for a database, upon upgrading a database to version 7.2 or later. `resp3_default` is set to `enabled` by default.
+
+To change `resp3_default` to `disabled`, use one of the following methods:
+
+- Cluster Manager UI – Edit **RESP3 support** in [**Upgrade configuration**](#edit-upgrade-configuration)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster resp3_default { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "resp3_default": <boolean> }
+    ```
+---
+Title: Enable OSS Cluster API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: OSS Cluster API
+weight: 20
+---
+
+Review [Redis OSS Cluster API]({{< relref "/operate/rs/clusters/optimize/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.  
+
+The database must:
+
+- Use the standard [hashing policy]({{< relref "/operate/rs/databases/durability-ha/clustering#supported-hashing-policies" >}}).
+- Have the [proxy policy]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}) set to either _All primary shards_ or _All nodes_.
+
+In addition, the database must _not_:
+
+- Use node `include` or `exclude` in the proxy policy.
+- Use [RediSearch]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}), [RedisTimeSeries]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}), or [RedisGears]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1" >}}) modules.
+
+The OSS Cluster API setting applies to individual databases instead of the entire cluster.
+
+## Enable OSS Cluster API support
+
+You can use the Cluster Manager UI, the `rladmin` utility, or the REST API to enable OSS Cluster API support for a database.
+
+When you enable OSS Cluster API support for an existing database, the change applies to new connections but does not affect existing connections. Clients must close existing connections and reconnect to apply the change.
+
+### Cluster Manager UI method
+
+When you use the Cluster Manager UI to enable the OSS Cluster API, it automatically configures the [prerequisites]({{< relref "/operate/rs/databases/configure/oss-cluster-api#prerequisites" >}}).
+
+To enable the OSS Cluster API for an existing database in the Cluster Manager UI:
+
+1. From the database's **Configuration** tab, select **Edit**.
+
+1. Expand the **Clustering** section.
+
+1. Select **Enable sharding**.
+
+1. Select **OSS Cluster API**.
+
+    {{<image filename="images/rs/screenshots/databases/config-clustering-oss-cluster-api-7-8-2.png" alt="Use the *OSS Cluster API* setting to enable the API for the selected database.">}}
+
+1. Select **Save**.
+
+You can also use the Cluster Manager UI to enable the setting when creating a new database.
+
+### Command-line method
+
+You can use the [`rladmin` utility]({{< relref "/operate/rs/references/cli-utilities/rladmin/" >}}) to enable the OSS Cluster API for Redis Enterprise Software databases, including Replica Of databases.
+
+For Active-Active (CRDB) databases, [use the crdb-cli utility](#active-active-databases).
+
+Ensure the [prerequisites]({{< relref "/operate/rs/databases/configure/oss-cluster-api#prerequisites" >}}) have been configured.  Then, enable the OSS Cluster API for a Redis database from the command line:
+
+```sh
+$ rladmin tune db <database name or ID> oss_cluster enabled
+```
+
+To determine the current setting for a database from the command line, use `rladmin info db` to return the value of the `oss_cluster` setting.
+
+```sh
+$ rladmin info db test | grep oss_cluster:
+  oss_cluster: enabled
+```
+
+The OSS Cluster API setting applies to the specified database only; it does not apply to the cluster.
+
+### REST API method
+
+You can enable the OSS Cluster API when you [create a database]({{<relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1">}}) using the REST API:
+
+```sh
+POST /v1/bdbs
+{ 
+  "oss_cluster": true,
+  // Other database configuration parameters
+}
+```
+
+To enable the OSS Cluster API for an existing database, you can use an [update database configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) REST API request:
+
+```sh
+PUT /v1/bdbs/<database-id>
+{ "oss_cluster": true }
+```
+
+### Active-Active databases
+
+The OSS Cluster API setting applies to all instances of the Active-Active database across participating clusters. To enable the OSS Cluster API for Active-Active databases, use the [Cluster Manager UI](#cluster-manager-ui) or the [`crdb-cli`]({{<relref "/operate/rs/references/cli-utilities/crdb-cli">}}) utility.
+
+To create an Active-Active database and enable the OSS Cluster API with `crdb-cli`:
+
+```sh
+$ crdb-cli crdb create --name <name> \
+    --memory-size 10g --port <port> \
+    --sharding true --shards-count 2  \
+    --replication true --oss-cluster true --proxy-policy all-master-shards \
+    --instance fqdn=<fqdn>,username=<user>,password=<pass> \
+    --instance fqdn=<fqdn>,username=<user>,password=<pass> \
+    --instance fqdn=<fqdn>,username=<user>,password=<pass>
+```
+
+See the [`crdb-cli crdb create`]({{<relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/create">}}) reference for more options.
+
+To enable the OSS Cluster API for an existing Active-Active database with `crdb-cli`:
+
+1. Obtain the `CRDB-GUID` for the new database:
+
+    ```sh
+    $ crdb-cli crdb list
+    CRDB-GUID    NAME   REPL-ID  CLUSTER-FQDN
+    <CRDB-GUID>  Test   4        cluster1.local
+    ```
+
+1. Use the `CRDB-GUID` to enable the OSS Cluster API:
+
+    ```sh
+    $ crdb-cli crdb update --crdb-guid <CRDB-GUID> \
+        --oss-cluster true
+    ```
+
+## Change preferred IP type
+
+By default, using [`CLUSTER SLOTS`]({{<relref "/commands/cluster-slots">}}) and [`CLUSTER SHARDS`]({{<relref "/commands/cluster-shards">}}) in a Redis Enterprise Software cluster exposes the internal IP addresses for databases with the OSS Cluster API enabled.
+
+To use external IP addresses instead of internal IP addresses, run the following [`rladmin tune db`]({{<relref "operate/rs/references/cli-utilities/rladmin/tune#tune-db">}}) command for each affected database:
+
+```sh
+$ rladmin tune db db:<database-id> oss_cluster_api_preferred_ip_type external
+```
+
+## Turn off OSS Cluster API support
+
+To deactivate OSS Cluster API support for a database, either:
+
+- Use the Cluster Manager UI to turn off the **OSS Cluster API** in the **Clustering** section of the database **Configuration** settings.
+
+- Use the appropriate utility to deactivate the OSS Cluster API setting.
+
+    For standard databases, including Replica Of, use `rladmin`:
+
+    ```sh
+    $ rladmin tune db <name or ID> oss_cluster disabled
+    ```
+
+    For Active-Active databases, use the Cluster Manager UI or `crdb-cli`:
+
+    ```sh
+    $ crdb-cli crdb update --crdb-guid <CRDB-GUID> \
+        --oss-cluster false
+    ```
+
+When you turn off OSS Cluster API support for an existing database, the change applies to new connections but does not affect existing connections. Clients must close existing connections and reconnect to apply the change.
+
+## Multi-key command support
+
+When you enable the OSS Cluster API for a database, 
+[multi-key commands]({{< relref "/operate/rc/databases/configuration/clustering#multikey-operations" >}}) are only allowed when all keys are mapped to the same slot.
+
+To verify that your database meets this requirement, make sure that the `CLUSTER KEYSLOT` reply is the same for all keys affected by the multi-key command.  To learn more, see [multi-key operations]({{< relref "/operate/rs/databases/durability-ha/clustering#multikey-operations" >}}).
+---
+Title: Configure shard placement
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure shard placement to improve performance.
+linktitle: Shard placement
+weight: 60
+---
+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]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy.md" >}}) helps to maintain optimal performance and resiliency.
+
+{{< embed-md "shard-placement-intro.md"  >}}
+
+## Default shard placement policy
+
+When you create a new cluster, the cluster configuration has a `dense` default shard placement policy.
+When you create a database, this default policy is applied to the new database.
+
+To see the current default shard placement policy, run `rladmin info cluster`:
+
+{{< image filename="/images/rs/shard_placement_info_cluster.png" >}}
+
+To change the default shard placement policy so that new databases are created with the `sparse` shard placement policy, run:
+
+```sh
+rladmin tune cluster default_shards_placement [ dense | sparse ]
+```
+
+## Shard placement policy for a database
+
+To see the shard placement policy for a database in `rladmin status`.
+
+{{< image filename="/images/rs/shard_placement_rladmin_status.png" >}}
+
+To change the shard placement policy for a database, run:
+
+```sh
+rladmin placement db [ database name | database ID ] [ dense | sparse ]
+```
+---
+Title: Configure proxy policy
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Proxy policy
+weight: 40
+---
+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:
+
+| Proxy policy | Description | Recommended use cases | Advantages | Disadvantages |
+|--------------|-------------|-----------------------|-----------|-----------------|
+| Single | Only a single proxy is bound to the database. This is the default database configuration. | Most use cases without high traffic or load | Lower resource usage, fewer application-to-cluster connections | Higher latency, more network hops |
+| All primary shards | Multiple proxies are bound to the database, one on each node that hosts a database primary shard. | Most use cases that require multiple endpoints, such as when using the [OSS Cluster API]({{<relref "/operate/rs/clusters/optimize/oss-cluster-api">}}) | Lower latency, fewer network hops, higher throughput | Higher resource usage, more application-to-proxy connections |
+| All nodes | Multiple proxies are bound to the database, one on each node in the cluster, regardless of whether or not there is a shard from this database on the node. | When using [load balancers]({{<relref "/operate/rs/networking/cluster-lba-setup">}}) for environments without DNS | Higher throughput | Highest resource usage |
+
+## View proxy policy
+
+You can use the Cluster Manager UI, [`rladmin`]({{<relref "/operate/rs/references/cli-utilities/rladmin">}}), or the [REST API]({{<relref "/operate/rs/references/rest-api">}}) to view proxy configuration settings.
+
+The [`rladmin info cluster`]({{<relref "/operate/rs/references/cli-utilities/rladmin/info#info-cluster">}}) command returns the current proxy policy for sharded and non-sharded (single shard) databases.
+
+```sh
+$ rladmin info cluster
+cluster configuration:
+   ...
+   default_non_sharded_proxy_policy: single
+   default_sharded_proxy_policy: single
+   ...
+```
+
+## Configure database proxy policy
+
+You can use the [Cluster Manager UI](#cluster-manager-ui-method), the [REST API](#rest-api-method), or [`rladmin`](#command-line-method) to configure a database's proxy policy.
+
+{{<warning>}}
+Any configuration update that unbinds existing proxies can disconnect existing client connections.
+{{</warning>}}
+
+### Cluster Manager UI method
+
+You can change a database's proxy policy when you [create]({{<relref "/operate/rs/databases/create">}}) or [edit]({{<relref "/operate/rs/databases/configure#edit-database-settings">}}) a database using the Cluster Manager UI:
+
+1. While in edit mode on the database's configuration screen, expand the **Clustering** section.
+
+1. Select a policy from the **Database proxy** list.
+
+1. Click **Create** or **Save**.
+
+### REST API method
+
+You can specify a proxy policy when you [create a database]({{<relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1">}}) using the REST API:
+
+```sh
+POST /v1/bdbs
+{ 
+  "proxy_policy": "single | all-master-shards | all-nodes",
+  // Other database configuration parameters
+}
+```
+
+To change an existing database's proxy policy, you can use an [update database configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) REST API request:
+
+```sh
+PUT /v1/bdbs/<database-id>
+{ "proxy_policy": "single | all-master-shards | all-nodes" }
+```
+
+### Command-line method
+
+You can configure a database's proxy policy using [`rladmin bind`]({{<relref "/operate/rs/references/cli-utilities/rladmin/bind">}}).
+
+The following example changes the bind policy for a database named "db1" with an endpoint ID "1:1" to "All primary shards" proxy policy:
+
+```sh
+rladmin bind db db1 endpoint 1:1 policy all-master-shards
+```
+
+The next command performs the same task using the database ID instead of the name. The ID of this database is "1".
+
+```sh
+rladmin bind db db:1 endpoint 1:1 policy all-master-shards
+```
+
+{{< note >}}
+You can find the endpoint ID for the endpoint argument by running `rladmin status`. Look for the endpoint ID information under
+the `ENDPOINT` section of the output.
+{{< /note >}}
+
+### Reapply policies after topology changes
+
+If you want to reapply the policy after topology changes, such as node restarts,
+failovers and migrations, run this command to reset the policy:
+
+```sh
+rladmin bind db db:<ID> endpoint <endpoint id> policy <all-master-shards|all-nodes>
+```
+
+This is not required with single policies.
+
+#### Other implications
+
+During the regular operation of the cluster different actions might take
+place, such as automatic migration or automatic failover, which change
+what proxy needs to be bound to what database. When such actions take
+place the cluster attempts, as much as possible, to automatically change
+proxy bindings to adhere to the defined policies. That said, the cluster
+attempts to prevent any existing client connections from being
+disconnected, and hence might not entirely enforce the policies. In such
+cases, you can enforce the policy using the appropriate rladmin
+commands.
+
+## Multiple active proxies
+
+Each database you create in a Redis Software cluster has an endpoint, which consists of a unique URL and port on the FQDN. This endpoint receives all the traffic for all operations for that database. By default, Redis Software binds this database endpoint to one of the proxies on a single node in the cluster. This proxy becomes an active proxy and receives all the operations for the given database. If the node with the active proxy fails, a new proxy on another node takes over as part of the failover process automatically.
+
+In most cases, a single proxy can handle a large number of operations
+without consuming additional resources. However, under high load,
+network bandwidth, or a high rate of packets per second (PPS) on the
+single active proxy can become a bottleneck to how fast database
+operations can be performed. In such cases, having multiple active proxies across multiple nodes, mapped to the same external database
+endpoint, can significantly improve throughput.
+
+You can configure a database to have multiple internal proxies, which can improve performance in some cases.
+Even though multiple active proxies can help improve the throughput of database
+operations, configuring multiple active proxies may cause additional
+latency in operations as the shards and proxies are spread across
+multiple nodes in the cluster.
+
+{{< note >}}
+When the network on a single active proxy becomes the bottleneck, consider enabling multiple NIC support in Redis Software. With nodes that have multiple physical NICs (Network Interface Cards), you can configure Redis Software to separate internal and external traffic onto independent physical NICs. For more details, refer to [Multi-IP & IPv6]({{< relref "/operate/rs/networking/multi-ip-ipv6.md" >}}).
+{{< /note >}}
+
+Having multiple proxies for a database can improve Redis Software's ability for fast failover in case of proxy or node failure. With multiple proxies for a database, a client doesn't need to wait for the cluster to spin up another proxy and a DNS change in most cases. Instead, the client uses the next IP address in the list to connect to another proxy.
+---
+Title: Configure database persistence
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure database persistence with either an append-only file
+  (AOF) or snapshots.
+linktitle: Persistence
+weight: 30
+---
+
+Data is stored in RAM or a combination of RAM and flash memory ([Auto Tiering]({{< relref "/operate/rs/databases/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](https://redis.com/redis-enterprise/technology/durable-redis/) 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.
+
+## Configure database persistence
+
+You can configure persistence when you [create a database]({{< relref "/operate/rs/databases/create" >}}), or you can edit an existing database's configuration:
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select **Edit**.
+
+1. Expand the **Durability** section.
+
+1. For **Persistence**, select an [option](#data-persistence-options) from the list.
+
+1. Select **Save**.
+
+## Data persistence options
+
+There are six options for persistence in Redis Enterprise Software:
+
+|  **Options** | **Description** |
+|  ------ | ------ |
+|  None | Data is not persisted to disk at all. |
+|  Append-only file (AOF) - fsync every write | Data is fsynced to disk with every write. |
+|  Append-only file (AOF) - fsync every 1 sec | Data is fsynced to disk every second. |
+|  Snapshot, every 1 hour | A snapshot of the database is created every hour. |
+|  Snapshot, every 6 hours | A snapshot of the database is created every 6 hours. |
+|  Snapshot, every 12 hours | A snapshot of the database is created every 12 hours. |
+
+## Select a persistence strategy
+
+When selecting your persistence strategy, you should take into account your tolerance for data loss and performance needs. There will always be tradeoffs between the two.
+The fsync() system call syncs data from file buffers to disk. You can configure how often Redis performs an fsync() to most effectively make tradeoffs between performance and durability for your use case.
+Redis supports three fsync policies: every write, every second, and disabled.
+
+Redis also allows snapshots through RDB files for persistence. Within Redis Enterprise, you can configure both snapshots and fsync policies.
+
+For any high availability needs, use replication to further reduce the risk of data loss.
+
+**For use cases where data loss has a high cost:**
+
+Append-only file (AOF) - fsync every write - Redis Enterprise sets the Redis directive `appendfsyncalways`.  With this policy, Redis will wait for the write and the fsync to complete prior to sending an acknowledgement to the client that the data has written. This introduces the performance overhead of the fsync in addition to the execution of the command. The fsync policy always favors durability over performance and should be used when there is a high cost for data loss.
+
+**For use cases where data loss is tolerable only limitedly:**
+
+Append-only file (AOF) - fsync every 1 sec - Redis will fsync any newly written data every second. This policy balances performance and durability and should be used when minimal data loss is acceptable in the event of a failure. This is the default Redis policy. This policy could result in between 1 and 2 seconds worth of data loss but on average this will be closer to one second.
+
+{{< note >}}
+If you use AOF for persistence, enable replication to improve performance. When both features are enabled for a database, the replica handles persistence, which prevents any performance impact on the master.
+{{< /note >}}
+
+**For use cases where data loss is tolerable or recoverable for extended periods of time:**
+
+- Snapshot, every 1 hour - Performs a full backup every hour.
+- Snapshot, every 6 hour - Performs a full backup every 6 hours.
+- Snapshot, every 12 hour - Performs a full backup every 12 hours.
+- None - Does not back up or persist data at all.
+
+## Append-only file (AOF) vs snapshot (RDB)
+
+Now that you know the available options, to assist in making a decision
+on which option is right for your use case, here is a table about the
+two:
+
+|  **Append-only File (AOF)** | **Snapshot (RDB)** |
+|------------|-----------------|
+|  More resource intensive | Less resource intensive |
+|  Provides better durability (recover the latest point in time) | Less durable |
+|  Slower time to recover (Larger files) | Faster recovery time |
+|  More disk space required (files tend to grow large and require compaction) | Requires less resources (I/O once every several hours and no compaction required) |
+
+## Active-Active data persistence 
+
+Active-Active databases support AOF persistence only.  Snapshot persistence is not supported for Active-Active databases.
+
+If an Active-Active database is using snapshot persistence, use `crdb-cli` to switch to AOF persistence:
+
+```text
+crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config \
+   '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+## Auto Tiering data persistence
+
+Auto Tiering flash storage is not considered persistent storage.
+
+Flash-based databases are expected to hold larger datasets, and shard repair times can take longer after node failures. To better protect the database against node failures with longer repair times, consider enabling master and replica dual data persistence.
+
+However, dual data persistence with replication adds some processor
+and network overhead, especially for cloud configurations
+with network-attached persistent storage, such as EBS-backed
+volumes in AWS.
+
+There may be times when performance is critical for your use case and
+you don't want to risk data persistence adding latency.
+
+You can enable or turn off data persistence on the master shards using the
+following `rladmin` command:
+
+```sh
+rladmin tune db <database_ID_or_name> master_persistence <disabled | enabled>
+```
+---
+Title: Manage database tags
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage tags for databases in a Redis Software cluster.
+linkTitle: Database tags
+toc: 'true'
+weight: 17
+---
+
+You can create custom tags to categorize databases in a Redis Software cluster. 
+
+The **Databases** screen shows tags for each database in the list.
+
+{{<image filename="images/rs/screenshots/databases/view-db-list-tags.png" alt="The databases screen includes tags for each database.">}}
+
+## Add database tags
+
+You can add tags when you [create a database]({{<relref "/operate/rs/databases/create">}}) or [edit an existing database's configuration]({{<relref "/operate/rs/databases/configure#edit-database-settings">}}).
+
+To add tags to a database using the Cluster Manager UI:
+
+1. While in edit mode on the database's configuration screen, click **Add tags**.
+
+    {{<image filename="images/rs/screenshots/databases/add-db-tags-button.png" alt="The Add tags button on the database configuration screen.">}}
+
+1. Enter a key and value for the tag. Keys and values previously used by existing tags will appear as suggestions.
+
+    {{<image filename="images/rs/screenshots/databases/manage-db-tags-dialog-suggestions.png" alt="The Manage tags dialog lets you add, edit, or delete tags.">}}
+
+1. To add additional tags, click **Add tag**.
+
+1. After you finish adding tags, click **Done** to close the tag manager.
+
+1. Click **Create** or **Save**.
+
+## Edit database tags
+
+To edit a database's existing tags using the Cluster Manager UI:
+
+1. Go to the database's **Configuration** screen, then click **Edit**.
+
+1. Next to the existing **Tags**, click {{< image filename="/images/rs/buttons/edit-db-tags-button.png#no-click" alt="Edit tags button" width="22px" class="inline" >}}.
+
+    {{<image filename="images/rs/screenshots/databases/edit-db-tags-button-location.png" alt="The Edit tags button on the database configuration screen.">}}
+
+1. Edit or delete existing tags, or click **Add tag** to add new tags.
+
+1. After you finish editing tags, click **Done** to close the tag manager.
+
+1. Click **Save**.
+---
+Title: Configure database defaults
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster-wide policies that determine default settings when creating new
+  databases.
+linkTitle: Database defaults
+toc: 'true'
+weight: 10
+---
+
+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:
+
+1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Database defaults**.
+
+1. Configure [database defaults](#db-defaults).
+
+    {{<image filename="images/rs/screenshots/databases/db-defaults.png" alt="Database defaults configuration panel.">}}
+
+1. Select **Save**.
+
+## Database defaults {#db-defaults}
+
+### Endpoint configuration
+
+You can choose a predefined endpoint configuration to use the recommended database proxy and shards placement policies for your use case. If you want to set these policies manually instead, select **Custom** endpoint configuration.
+
+| Endpoint configuration | Database proxy | Shards placement | Description |
+|-----------|------------|----------------|------------------|------------|
+| Enterprise clustering | Single | Dense | Sets up a single endpoint that uses DNS to automatically reflect IP address updates after failover or topology changes. |
+| Using a load balancer | All nodes | Sparse | Configure Redis with a load balancer like HAProxy or Nginx for environments without DNS. |
+| Multiple endpoints | All primary shards | Sparse | To set up multiple endpoints, enable **OSS Cluster API** in the database settings and ensure client support. Clients initially connect to the primary node to retrieve the cluster topology, which allows direct connections to individual Redis proxies on each node. |
+| Custom | Single, all primary shards, or all nodes | Dense or sparse | Manually choose default database proxy and shards placement policies. |
+
+### Database proxy
+
+Redis Enterprise Software uses [proxies]({{< relref "/operate/rs/references/terminology#proxy" >}}) to manage and optimize access to database shards. Each node in the cluster runs a single proxy process, which can be active (receives incoming traffic) or passive (waits for failovers).
+
+You can configure default [proxy policies]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}) to determine which nodes' proxies are active and bound to new databases by default.
+
+To configure the default database proxy policy using the Cluster Manager UI:
+
+1. [**Edit database defaults**](#edit-database-defaults). 
+
+1. Select a predefined [**Endpoint Configuration**](#endpoint-configuration) to use a recommended database proxy policy, or choose **Custom** to set the policy manually. Changing the database proxy default in the Cluster Manager UI affects both sharded and non-sharded proxy policies.
+
+    {{<image filename="images/rs/screenshots/databases/db-defaults-endpoint-config-custom.png" alt="The Database defaults panel lets you select Database proxy and Shards placement if Endpoint Configuration is set to Custom.">}}
+
+#### Non-sharded proxy policy
+
+To configure the default proxy policy for non-sharded databases, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_non_sharded_proxy_policy { single | all-master-shards | all-nodes }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_non_sharded_proxy_policy": "single | all-master-shards | all-nodes" }
+    ```
+
+#### Sharded proxy policy
+
+To configure the default proxy policy for sharded databases, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_sharded_proxy_policy { single | all-master-shards | all-nodes }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_sharded_proxy_policy": "single | all-master-shards | all-nodes" }
+    ```
+
+### Shards placement
+
+The default [shard placement policy]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy" >}}) determines the distribution of database shards across nodes in the cluster.
+
+Shard placement policies include:
+
+- `dense`: places shards on the smallest number of nodes.
+
+- `sparse`: spreads shards across many nodes.
+
+To configure default shard placement, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. [**Edit database defaults**](#edit-database-defaults). 
+
+    1. Select a predefined [**Endpoint Configuration**](#endpoint-configuration) to use a recommended shards placement policy, or choose **Custom** to set the policy manually.
+
+        {{<image filename="images/rs/screenshots/databases/db-defaults-endpoint-config-custom.png" alt="The Database defaults panel lets you select Database proxy and Shards placement if Endpoint Configuration is set to Custom.">}}
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_shards_placement { dense | sparse }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_shards_placement": "dense | sparse" }
+    ```
+
+### Database version
+
+New databases use the default Redis database version unless you select a different **Database version** when you [create a database]({{<relref "/operate/rs/databases/create">}}) in the Cluster Manager UI or specify the `redis_version` in a [create database REST API request]({{< relref "/operate/rs/references/rest-api/requests/bdbs" >}}).
+
+To configure the Redis database version, use one of the following methods:
+
+- Cluster Manager UI: Edit **Database version** in [**Database defaults**](#edit-database-defaults)
+
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_redis_version <x.y>
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_provisioned_redis_version": "x.y" }
+    ```
+
+### Internode encryption
+
+Enable [internode encryption]({{< relref "/operate/rs/security/encryption/internode-encryption" >}}) to encrypt data in transit between nodes for new databases by default.
+
+To enable or turn off internode encryption by default, use one of the following methods:
+
+- Cluster Manager UI: Edit **Internode Encryption** in [**Database defaults**](#edit-database-defaults)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster data_internode_encryption { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "data_internode_encryption": <boolean> }
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure settings specific to each database.
+hideListLinks: true
+linktitle: Configure
+title: Configure database settings
+toc: 'true'
+weight: 20
+---
+
+You can manage your Redis Enterprise Software databases with several tools:
+
+- [Cluster Manager UI](#edit-database-settings) (the web-based user interface)
+
+- Command-line tools:
+
+    - [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) for standalone database configuration
+
+    - [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for Active-Active database configuration
+
+    - [`redis-cli`]({{< relref "/develop/tools/cli" >}}) for Redis Open Source configuration
+
+- [REST API]({{< relref "/operate/rs/references/rest-api/_index.md" >}})
+
+## Edit database settings
+
+You can change the configuration of a Redis Enterprise Software database at any time.<!--more-->
+
+To edit the configuration of a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database you want to edit.
+
+1. From the **Configuration** tab, select **Edit**.
+
+1. Change any [configurable database settings](#config-settings).
+
+    {{< note >}}
+For [Active-Active database instances]({{< relref "/operate/rs/databases/active-active" >}}), most database settings only apply to the instance that you are editing.
+    {{< /note >}}
+
+1. Select **Save**.
+
+## Configuration settings {#config-settings}
+
+### General
+
+- [**Tags**]({{<relref "/operate/rs/databases/configure/db-tags">}}) - Add custom tags to categorize the database.
+
+- **Database version** - Select the Redis version when you create a database.
+
+- **Database name** - The database name requirements are:
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+- **Endpoint port number** - You can define the port number that clients use to connect to the database. Otherwise, a port is randomly selected.
+
+    {{< note >}}
+You cannot change the [port number]({{< relref "/operate/rs/networking/port-configurations.md" >}})
+after the database is created.
+    {{< /note >}}
+
+### Capacity
+
+- **Memory limit** - [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}) include all database replicas and shards, including replica shards in database replication and database shards in database clustering.
+
+    If the total size of the database in the cluster reaches the memory limit, the memory eviction policy for the database is enforced.
+
+- **RAM limit** - If you create a database with Auto Tiering enabled, you also need to set the RAM-to-Flash ratio. Minimum RAM is 10%. Maximum RAM is 50%.
+
+- [**Memory eviction**]({{<relref "/operate/rs/databases/memory-performance/eviction-policy">}}) - By default, when the total size of the database reaches its memory limit, the database evicts keys according to the least recently used keys out of all keys with an "expire" field set to make room for new keys. You can select a different eviction policy.
+
+### Capabilities
+
+When you create a new in-memory database, you can enable multiple Redis Stack [**Capabilities**]({{<relref "/operate/oss_and_stack/stack-with-enterprise">}}).
+
+For Auto Tiering databases, you can enable capabilities that support Auto Tiering. See [Redis Enterprise and Redis Stack feature compatibility 
+]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}) for compatibility details.
+
+{{<note>}}
+To use Redis Stack capabilities, enable them when you create a new database.
+You cannot enable them after database creation.
+{{</note>}}
+
+To add capabilities to the database:
+
+1. In the **Capabilities** section, select one or more capabilities.
+    
+1. To customize capabilities, click **Parameters** and enter the optional custom configuration.
+    
+1. Click **Done**.
+
+To change capabilities' parameters for an existing database using the Cluster Manager UI:
+
+  1. In the **Capabilities** section, click **Edit Parameters**.
+
+  1. After you finish editing the module's configuration parameters, click **Done** to close the parameter editor.
+
+### High Availability
+
+- [**Replication**]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}) - We recommend you use intra-cluster replication to create replica shards for each database for high availability.
+
+    If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}), you can also enable rack-zone awareness for the database.
+
+- [**Replica high availability**]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) - Automatically migrates replica shards to an available node if a replica node fails or is promoted to primary.
+
+### Clustering
+
+- **Enable sharding** - You can either:
+
+    - Turn on sharding to enable [database clustering]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}) and select the number of database shards.
+
+        When database clustering is enabled, databases are subject to limitations on [Multi-key commands]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}).
+        
+        You can increase the number of shards in the database at any time.
+
+    - Turn off sharding to use only one shard so that you can use [Multi-key commands]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}) without the limitations.
+
+- [**Shards placement**]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy" >}}) - Determines how to distribute database shards across nodes in the cluster.
+
+    - _Dense_ places shards on the smallest number of nodes.
+    
+    - _Sparse_ spreads shards across many nodes.
+
+- [**OSS Cluster API**]({{< relref "/operate/rs/databases/configure/oss-cluster-api.md" >}}) - The OSS Cluster API configuration allows access to multiple endpoints for increased throughput.
+
+    This configuration requires clients to connect to the primary node to retrieve the cluster topology before they can connect directly to proxies on each node.
+    
+    When you enable the OSS Cluster API, shard placement changes to _Sparse_, and the database proxy policy changes to _All primary shards_ automatically.
+
+    {{<note>}}
+You must use a client that supports the cluster API to connect to a database that has the cluster API enabled.
+    {{</note>}}
+
+- **Hashing policy** - You can accept the [standard hashing policy]({{<relref "/operate/rs/databases/durability-ha/clustering#standard-hashing-policy">}}), which is compatible with Redis Open Source, or define a [custom hashing policy]({{<relref "/operate/rs/databases/durability-ha/clustering#custom-hashing-policy">}}) to define where keys are located in the clustered database.
+
+- [**Database proxy**]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}) - Determines the number and location of active proxies, which manage incoming database operation requests.
+
+### Durability
+
+- [**Persistence**]({{<relref "/operate/rs/databases/configure/database-persistence">}}) - To protect against loss of data stored in RAM, you can enable data persistence and store a copy of the data on disk with snapshots or an append-only file.
+
+- **Scheduled backup** - You can configure [periodic backups]({{<relref "/operate/rs/databases/import-export/schedule-backups">}}) of the database, including the interval and backup location parameters.
+
+### TLS
+
+You can require [**TLS**]({{< relref "/operate/rs/security/encryption/tls/" >}}) encryption and authentication for all communications, TLS encryption and authentication for Replica Of communication only, and TLS authentication for clients.
+
+### Access control
+
+- **Unauthenticated access** - You can access the database as the default user without providing credentials.
+
+- **Password-only authentication** - When you configure a password for your database's default user, all connections to the database must authenticate with the [AUTH command]({{< relref "/commands/auth" >}}).
+
+    If you also configure an access control list, connections can specify other users for authentication, and requests are allowed according to the Redis ACLs specified for that user.
+
+    Creating a database without ACLs enables a *default* user with full access to the database. You can secure default user access by requiring a password.
+
+- **Access Control List** - You can specify the [user roles]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) that have access to the database and the [Redis ACLs]({{< relref "/operate/rs/security/access-control/redis-acl-overview" >}}) that apply to those connections.
+
+    To define an access control list for a database:
+
+    1. In **Security > Access Control > Access Control List**, select **+ Add ACL**.
+
+    1. Select a [role]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) to grant database access.
+
+    1. Associate a [Redis ACL]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) with the role and database.
+
+    1. Select the check mark to add the ACL.
+
+### Alerts
+
+Select [alerts]({{<relref "/operate/rs/monitoring/v1_monitoring#database-alerts">}}) to show in the database status and configure their thresholds.
+
+You can also choose to [send alerts by email]({{<relref "/operate/rs/monitoring/v1_monitoring#send-alerts-by-email">}}) to relevant users.
+
+### Replica Of
+
+With [**Replica Of**]({{<relref "/operate/rs/databases/import-export/replica-of/create">}}), you can make the database a repository for keys from other databases.
+
+### RESP3 support
+
+[RESP]({{<relref "/develop/reference/protocol-spec">}})  (Redis Serialization Protocol) is the protocol clients use to communicate with Redis databases. If you enable RESP3 support, the database will support the RESP3 protocol in addition to RESP2.
+
+For more information about Redis Software's compatibility with RESP3, see [RESP compatibility with Redis Enterprise]({{<relref "/operate/rs/references/compatibility/resp">}}).
+
+### Internode encryption
+
+Enable **Internode encryption** to encrypt data in transit between nodes for this database. See [Internode encryption]({{< relref "/operate/rs/security/encryption/internode-encryption" >}}) for more information.
+
+---
+Title: Recover a failed database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Recover a database after the cluster fails or the database is corrupted.
+linktitle: Recover
+weight: 35
+---
+When a cluster fails or a database is corrupted, you must:
+
+1. [Restore the cluster configuration]({{< relref "/operate/rs/clusters/cluster-recovery.md" >}}) from the CCS files
+1. 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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+The database recovery process includes:
+
+1. If the cluster failed, [recover the cluster]({{< relref "/operate/rs/clusters/cluster-recovery.md" >}}).
+1. Identify recoverable databases.
+1. Restore the database data.
+1. 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]({{< relref "/operate/rs/clusters/cluster-recovery.md" >}}) before you recover the databases.
+
+- We recommend that you allocate new persistent storage drives for the new cluster nodes.
+    If you use the original storage drives,
+    make sure to back up all files on the old persistent storage drives to another location.
+
+## Recover databases
+
+After you prepare the cluster that hosts the database,
+you can run the recovery process from the [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}})
+command-line interface (CLI).
+
+To recover the database:
+
+1. Mount the persistent storage drives with the recovery files to the new nodes.
+    These drives must contain the cluster configuration backup files and database persistence files.
+
+    {{< note >}}
+Make sure that the user `redislabs` has permissions to access the storage location
+of the configuration and persistence files on each of the nodes.
+    {{< /note >}}
+
+    If you use local persistent storage, place all of the recovery files on each of the cluster nodes.
+
+1. To see which databases are recoverable, run:
+
+    ```sh
+    rladmin recover list
+    ```
+
+    The status for each database can be either ready for recovery or missing files.
+    An indication of missing files in any of the databases can result from:
+
+    - The storage location is not found - Make sure the recovery path is set correctly on all nodes in the cluster.
+    - Files are not found in the storage location - Move the files to the storage location.
+    - No permission to read the files - Change the file permissions so that redislabs:redislabs has 640 permissions.
+    - Files are corrupted - Locate copies of the files that are not corrupted.
+
+    If you cannot resolve the issues, contact [Redis support](https://redis.com/company/support/).
+
+1. Recover the database using one of the following [`rladmin recover`]({{< relref "/operate/rs/references/cli-utilities/rladmin/recover" >}}) commands:
+
+    - Recover all databases from the persistence files located in the persistent storage drives:
+    
+        ```sh
+        rladmin recover all
+        ```
+
+    - Recover a single database from the persistence files located in the persistent storage drives:
+    
+        - By database ID:
+
+            ```sh
+            rladmin recover db db:<id>
+            ```
+
+        - By database name:
+        
+            ```sh
+            rladmin recover db <name>
+            ```
+
+    - Recover only the database configuration for a single database (without the data):
+    
+        ```sh
+        rladmin recover db <name> only_configuration
+        ```
+
+    {{< note >}}
+- If persistence was not configured for the database, the database is restored empty.
+- For Active-Active databases that still have live instances, we recommend that you recover the configuration for the failed instances and let the  data update from the other instances.
+- For Active-Active databases where all instances need to be recovered, we recommend you recover one instance with the data and only recover the configuration for the other instances.
+   The empty instances then update from the recovered data.
+- If the persistence files of the databases from the old cluster are not stored in the persistent storage location of the new node,
+   you must first map the recovery path of each node to the location of the old persistence files.
+   To do this, run the `node <id> recovery_path set` command in rladmin.
+   The persistence files for each database are located in the persistent storage path of the nodes from the old cluster, usually under `/var/opt/redislabs/persist/redis`.
+    {{< /note >}}  
+
+1. To verify that the recovered databases are now active, run: 
+
+    ```sh
+    rladmin status
+    ```
+
+After the databases are recovered, make sure your Redis clients can successfully connect to the databases.
+
+## Configure automatic recovery
+
+If you enable the automatic recovery cluster policy, Redis Enterprise tries to quickly recover as much data as possible from before the disaster.
+
+To enable automatic recovery, [update the cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) using the REST API:
+
+```sh
+PUT /v1/cluster/policy
+{
+  "auto_recovery": true
+}
+```
+
+Redis Enterprise tries to recover databases from the best existing persistence files. If a persistence file isn't available, which can happen if its host node is down, the automatic recovery process waits for it to become available.
+
+For each database, you can set the `recovery_wait_time` to define how many seconds the database waits for a persistence file to become available before recovery. After the wait time elapses, the recovery process continues, which can result in partial or full data loss. The default value is `-1`, which means to wait forever. Short wait times can increase the risk of potential data loss.
+
+To change `recovery_wait_time` for an existing database using the REST API:
+
+```sh
+PUT /v1/bdbs/<bdb_uid>
+{
+  "recovery_wait_time": 3600
+}
+```
+
+You can also set `recovery_wait_time` when you [create a database]({{< relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1" >}}) using the REST API.
+---
+Title: Database replication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Replication
+weight: 40
+---
+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.
+
+You can tune your high availability configuration with:
+
+- [Rack/Zone
+Awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}) - When rack-zone awareness is used additional logic ensures that master and replica shards never share the same rack, thus ensuring availability even under loss of an entire rack.
+- [High Availability for Replica Shards]({{< relref "/operate/rs/databases/configure/replica-ha.md" >}}) - When high availability
+for replica shards is used, the replica shard is automatically migrated on node failover to maintain high availability.
+
+{{< warning >}}
+Enabling replication has implications for the total database size,
+as explained in [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}).
+{{< /warning >}}
+
+## Auto Tiering replication considerations
+
+We recommend that you set the sequential replication feature using
+`rladmin`. This is due to the potential for relatively slow replication
+times that can occur with Auto Tiering enabled databases. In some
+cases, if sequential replication is not set up, you may run out of memory. 
+
+While it does not cause data loss on the
+primary shards, the replication to replica shards may not succeed as long
+as there is high write-rate traffic on the primary and multiple
+replications at the same time.
+
+The following `rladmin` command sets the number of primary shards eligible to
+be replicated from the same cluster node, as well as the number of replica
+shards on the same cluster node that can run the replication process at
+any given time.
+
+The recommended sequential replication configuration is two, i.e.:
+
+```sh
+rladmin tune cluster max_redis_forks 1 max_slave_full_syncs 1
+```
+
+{{< note >}}
+This means that at any given time,
+only one primary and one replica can be part of a full sync replication process.
+{{< /note >}}
+
+## Database replication backlog
+
+Redis databases that use [replication for high availability]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}) maintain a replication backlog (per shard) to synchronize the primary and replica shards of a database.
+By default, the replication backlog is set to one percent (1%) of the database size divided by the database number of shards and ranges between 1MB to 250MB per shard.
+Use the [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) and the [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) utilities to control the size of the replication backlog. You can set it to `auto` or set a specific size.  
+
+The syntax varies between regular and Active-Active databases. 
+
+For a regular Redis database:
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB | 'auto'>
+```
+
+For an Active-Active database:
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+### Active-Active replication backlog
+
+In addition to the database replication backlog, Active-Active databases maintain a backlog (per shard) to synchronize the database instances between clusters.
+By default, the Active-Active replication backlog is set to one percent (1%) of the database size divided by the database number of shards, and ranges between 1MB to 250MB per shard.
+Use the [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) utility to control the size of the CRDT replication backlog. You can set it to `auto` or set a specific size:  
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"crdt_repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+**For Redis Software versions earlier than 6.0.20:**
+The replication backlog and the CRDT replication backlog defaults are set to 1MB and cannot be set dynamically with 'auto' mode.
+To control the size of the replication log, use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) to tune the local database instance in each cluster.
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB (or if ending with bytes, KB or GB, in the respective unit)>
+```---
+Title: Discovery service
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Discovery service
+weight: 30
+---
+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.
+
+Discovery Service is an alternative for applications that do not want to
+depend on DNS name resolution for their connectivity. Discovery Service
+and DNS based connectivity are not mutually exclusive. They can be used
+side by side in a given cluster where some clients can use Discovery
+Service based connection while others can use DNS name resolution when
+connecting to databases.
+
+## How discovery service works
+
+The Discovery Service is available for querying on each node of the
+cluster, listening on port 8001. To employ it, your application utilizes
+a [Redis Sentinel enabled client
+library]({{< relref "/operate/rs/databases/connect/supported-clients-browsers.md" >}})
+to connect to the Discovery Service and request the endpoint for the
+given database. The Discovery Service replies with the database's
+endpoint for that database. In case of a node failure, the Discovery
+Service is updated by the cluster manager with the new endpoint and
+clients unable to connect to the database endpoint due to the failover,
+can re-query the discovery service for the new endpoint for the
+database.
+
+The Discovery Service can return either the internal or external
+endpoint for a database. If you query the discovery service for the
+endpoint of a database named "db1", the Discovery Service returns
+the external endpoint information by default. If only an internal
+endpoint exists with no external endpoint the default behavior is to
+return the internal endpoint. The "\@internal" is added to the end of
+the database name to explicitly ask for the internal endpoint. to query
+the internal endpoint explicitly with database name "db1", you can pass
+in the database name as "db1\@internal".
+
+If you'd like to examine the metadata returned from Redis Enterprise
+Software Discovery Service you can connect to port 8001 with redis-cli
+utility and execute "SENTINEL masters". Following is a sample output
+from one of the nodes of a Redis Enterprise Software cluster:
+
+```sh
+$ ./redis-cli -p 8001
+127.0.0.1:8001> SENTINEL masters
+1) 1) "name"
+2) "db1@internal"
+3) "ip"
+4) "10.0.0.45"
+5) "port"
+6) "12000"
+7) "flags"
+8) "master,disconnected"
+9) "num-other-sentinels"
+10) "0"
+2) 1) "name"
+2) "db1"
+3) "ip"
+4) "10.0.0.45"
+5) "port"
+6) "12000"
+7) "flags"
+8) "master,disconnected"
+9) "num-other-sentinels"
+10) "0"
+```
+
+It is important to note that, the Discovery Service is not a full
+implementation of the [Redis Sentinel
+protocol]({{< relref "/operate/oss_and_stack/management/sentinel" >}}). There are aspects of the
+protocol that are not applicable or would be duplication with existing
+technology in Redis Enterprise Software. The Discovery Service
+implements only the parts required to provide applications with easy
+High Availability, be compatible with the protocol, and not rely on DNS
+to derive which node in the cluster to communicate with.
+
+{{< note >}}
+To use Redis Sentinel, every database name must be unique across the cluster.
+{{< /note >}}
+
+## Redis client support
+
+We recommend these clients that are tested for use with the [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}) that uses the Redis Sentinel API:
+
+{{< embed-md "discovery-clients.md" >}}
+
+{{< note >}}
+Redis Sentinel API can return endpoints for both master and replica
+endpoints.
+Discovery Service only supports master endpoints and does not
+support returning replica endpoints for a database.
+{{< /note >}}
+---
+Title: Database clustering
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Clustering to allow customers to spread the load of a Redis process over
+  multiple cores and the RAM of multiple servers.
+linktitle: Clustering
+weight: 10
+---
+Source available [Redis](https://redislabs.com/redis-features/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.
+
+The keyspace of a Redis Enterprise cluster is partitioned into database shards.
+Each shard resides on a single node and is managed by that node.
+Each node in a Redis database cluster can manage multiple shards.
+The key space in the shards is divided into hash slots.
+The slot of a key is determined by a hash of the key name or part of the key name.
+
+Database clustering is transparent to the Redis client that connects to the database.
+The Redis client accesses the database through a single endpoint that automatically routes all operations to the relevant shards.
+You can connect an application to a single Redis process or a clustered database without any difference in the application logic.
+
+## Terminology
+
+In clustering, these terms are commonly used:
+
+- Tag or Hash Tag - A part of the key that is used in the hash calculation.
+- Slot or Hash Slot - The result of the hash calculation.
+- Shard - Redis process that is part of the Redis clustered database.
+
+## When to use clustering (sharding)
+
+Clustering is an efficient way of scaling Redis that should be used when:
+
+- The dataset is large enough to benefit from using the RAM resources of more than one node.
+    When a dataset is more than 25 GB (50 GB for RoF), we recommend that you enable clustering to create multiple shards of the database
+    and spread the data requests across nodes.
+- The operations performed against the database are CPU-intensive, resulting in performance degradation.
+    By having multiple CPU cores manage the database's shards, the load of operations is distributed among them.
+
+## Number of shards
+
+When enabling database clustering, you can set the number of database
+shards. The minimum number of shards per database is 2 and the maximum
+depends on the subscription you purchased.
+
+After you enable database clustering and set the number of shards, you cannot deactivate database clustering or reduce the number of
+shards. You can only increase the number of shards by a multiple of the
+current number of shards. For example, if the current number of shards
+is 3, you can increase the number of shards to 6, 9, or 12. 
+
+## Supported hashing policies
+
+### Standard hashing policy
+
+When using the standard hashing policy, a clustered Redis Enterprise database behaves similarly to a standard [Redis Open Source cluster]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}#hash-tags), except when using multiple hash tags in a key's name. We recommend using only a single hash tag in a key name for hashing in Redis Enterprise.
+
+- **Keys with a hash tag**: a key's hash tag is any substring between
+    `{` and `}` in the key's name. When a key's name
+    includes the pattern `{...}`, the hash tag is used as input for the
+    hashing function.
+    
+    For example, the following key names have the same
+    hash tag and map to the same hash slot: `foo{bar}`,
+    `{bar}baz`, and `foo{bar}baz`.
+
+- **Keys without a hash tag**: when a key does not contain the `{...}`
+    pattern, the entire key's name is used for hashing.
+
+You can use a hash tag to store related keys in the same hash
+slot so multi-key operations can run on these keys. If you do not use a hash tag in the key's name, the keys are distributed evenly across the keyspace's shards.
+If your application does not perform multi-key operations, you do not
+need to use hash tags.
+
+### Custom hashing policy
+
+You can configure a custom hashing policy for a clustered database. A
+custom hashing policy is required when different keys need to be kept
+together on the same shard to allow multi-key operations. The custom
+hashing policy is provided through a set of Perl Compatible Regular
+Expressions (PCRE) rules that describe the dataset's key name patterns.
+
+To configure a custom hashing policy, enter the regular expression
+(RegEx) rules that identify the substring in the key's name - hash tag
+-- on which hashing is done. The hash tag is denoted in the
+RegEx by the use of the \`tag\` named subpattern. Different keys that
+have the same hash tag are stored and managed in the same slot.
+
+After you enable the custom hashing policy, the following default RegEx
+rules are implemented. Update these rules to fit your specific logic:
+
+|  RegEx Rule | Description |
+|  ------ | ------ |
+|  .\*{(?\<tag\>.\*)}.\* | Hashing is done on the substring between the curly braces. |
+|  (?\<tag\>.\*) | The entire key's name is used for hashing. |
+
+You can modify existing rules, add new ones, delete rules, or change
+their order to suit your application's requirements.
+
+### Custom hashing policy notes and limitations
+
+1. You can define up to 32 RegEx rules, each up to 256 characters.
+2. RegEx rules are evaluated in order, and the first rule matched
+    is used. Therefore, you should place common key name patterns at the
+    beginning of the rule list.
+3. Key names that do not match any of the RegEx rules trigger an
+    error.
+4. The '.\*(?\<tag\>)' RegEx rule forces keys into a single slot
+    because the hash key is always empty. Therefore, when used,
+    this should be the last, catch-all rule.
+5. The following flag is enabled in the regular expression parser:
+    PCRE_ANCHORED: the pattern is constrained to match only at the
+    start of the string being searched.
+
+## Change the hashing policy
+
+The hashing policy of a clustered database can be changed. However,
+most hashing policy changes trigger the deletion (FLUSHDB) of the
+data before they can be applied.
+
+Examples of such changes include:
+
+- Changing the hashing policy from standard to custom or conversely,
+    custom to standard.
+- Changing the order of custom hashing policy rules.
+- Adding new rules in the custom hashing policy.
+- Deleting rules from the custom hashing policy.
+
+{{< note >}}
+The recommended workaround for updates that are not enabled,
+or require flushing the database,
+is to back up the database and import the data to a newly configured database.
+{{< /note >}}
+
+## Multi-key operations {#multikey-operations}
+
+Operations on multiple keys in a clustered database are supported with
+the following limitations:
+
+- **Multi-key commands**: Redis offers several commands that accept
+    multiple keys as arguments. In a clustered database, most multi-key
+    commands are not allowed across slots. The following multi-key
+    commands **are allowed** across slots: DEL, MSET, MGET, EXISTS, UNLINK, TOUCH
+
+    In Active-Active databases, multi-key write commands (DEL, MSET, UNLINK) can only be run on keys that are in the same slot. However, the following multi-key commands **are allowed** across slots in Active-Active databases: MGET, EXISTS, and TOUCH.
+
+    Commands that affect all keys or keys that match a specified pattern are allowed
+    in a clustered database, for example: FLUSHDB, FLUSHALL, KEYS
+
+    {{< note >}}
+When using these commands in a sharded setup,
+the command is distributed across multiple shards
+and the responses from all shards are combined into a single response.
+    {{< /note >}}
+
+- **Geo commands**: For the [GEORADIUS]({{< relref "/commands/georadius" >}}) and
+    [GEORADIUSBYMEMBER]({{< relref "/commands/georadiusbymember" >}}) commands, the
+    STORE and STOREDIST options can only be used when all affected keys
+    reside in the same slot.
+- **Transactions**: All operations within a WATCH / MULTI / EXEC block
+    should be performed on keys that are mapped to the same slot.
+- **Lua scripts**: All keys used by a Lua script must be mapped to the same
+    slot and must be provided as arguments to the EVAL / EVALSHA commands
+    (as per the Redis specification). Using keys in a Lua script that
+    were not provided as arguments might violate the sharding concept
+    but do not result in the proper violation error being returned.
+- **Renaming/Copy keys**: The use of the RENAME / RENAMENX / COPY commands is
+    allowed only when the key's original and new values are mapped to
+    the same slot.
+---
+Title: Durability and high availability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Overview of Redis Enterprise durability features such as replication,
+  clustering, and rack-zone awareness.
+hideListLinks: true
+linktitle: Durability and availability
+weight: 60
+---
+Redis Enterprise Software comes with several features that make your data more durable and accessible. The following features can help protect your data in cases of failures or outages and help keep your data available when you need it.
+
+## Replication
+
+When you [replicate your database]({{<relref "/operate/rs/databases/durability-ha/replication">}}), each database instance (primary shard) is copied to a replica shard. When a primary shard fails, the cluster automatically promotes a replica shard to primary.
+
+## Clustering
+
+[Clustering]({{<relref "/operate/rs/databases/durability-ha/clustering">}}) (or sharding) breaks your database into individual instances (shards) and spreads them across several nodes. Clustering lets you add resources to your cluster to scale your database and prevents node failures from causing availability loss.
+
+## Database persistence
+
+[Database persistence]({{<relref "/operate/rs/databases/configure/database-persistence">}}) gives your database durability against process or server failures by saving data to disk at set intervals.
+
+## Active-Active geo-distributed replication
+
+[Active-Active Redis Enterprise databases]({{<relref "/operate/rs/databases/active-active">}}) allow reading and writing to the same dataset from multiple clusters in different geographic locations. This increases the durability of your database by reducing the likelihood of data or availability loss. It also reduces data access latency by serving requests from the nearest cluster.
+
+## Rack-zone awareness
+
+[Rack-zone awareness]({{<relref "/operate/rs/clusters/configure/rack-zone-awareness">}}) maps each node in your Redis Enterprise cluster to a physical rack or logical zone. The cluster uses this information to distribute primary shards and their replica shards in different racks or zones. This ensures data availability if a rack or zone fails.
+
+## Discovery service
+
+The [discovery service]({{<relref "/operate/rs/databases/durability-ha/discovery-service">}}) provides an IP-based connection management service used when connecting to Redis Enterprise Software databases. It lets your application discover which node hosts the database endpoint. The discovery service API complies with the [Redis Sentinel API]({{< relref "/operate/oss_and_stack/management/sentinel" >}}#sentinel-api).---
+Title: Consistency during replication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Explains the order write operations are communicated from app to proxy to shards for both non-blocking Redis write operations and blocking write operations on replication.
+linkTitle: Consistency
+weight: 20
+---
+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`]({{<relref "/commands/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:
+
+1. The application issues a write.
+2. The proxy communicates with the correct primary (also known as master) shard in the system that contains the given key.
+3. The shard writes the data and sends an acknowledgment to the proxy.
+4. The proxy sends the acknowledgment back to the application.
+5. The write is communicated from the primary shard to the replica.
+6. The replica acknowledges the write back to the primary shard.
+7. The write to a replica is persisted to disk.
+8. The write is acknowledged within the replica.
+
+{{< image filename="/images/rs/weak-consistency.png" >}}
+
+## Blocking write operation on replication
+
+With the [`WAIT`]({{<relref "/commands/wait">}}) or [`WAITAOF`]({{<relref "/commands/waitaof">}}) commands, applications can ask to wait for
+acknowledgments only after replication or persistence is confirmed on
+the replica. The flow of a write operation with `WAIT` or `WAITAOF` is:
+
+1. The application issues a write.
+2. The proxy communicates with the correct primary shard in the system that contains the given key.
+3. Replication communicates the update to the replica shard.
+4. If using `WAITAOF` and the AOF every write setting, the replica persists the update to disk before sending the acknowledgment.
+5. The acknowledgment is sent back from the replica all the way to the proxy with steps 5 to 8.
+
+The application only gets the acknowledgment from the write after durability is achieved with replication to the replica for `WAIT` or `WAITAOF` and to the persistent storage for `WAITAOF` only.
+
+{{< image filename="/images/rs/strong-consistency.png" >}}
+
+The `WAIT` command always returns the number of replicas that acknowledged the write commands sent by the current client before the `WAIT` command, both in the case where the specified number of replicas are reached, or when the timeout is reached. In Redis Enterprise Software, the number of replicas for HA enabled databases is always 1.
+
+See the [`WAITAOF`]({{<relref "/commands/waitaof">}}) command for details for enhanced data safety and durability capabilities introduced with Redis 7.2.
+---
+Title: Flush database data
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: To delete the data in a database without deleting the database, you can
+  use Redis CLI to flush it from the database.  You can also use Redis CLI, the admin
+  console, and the Redis Software REST API to flush data from Active-Active databases.
+linkTitle: Flush database
+weight: 40
+---
+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 title="Data Loss Warning" >}}
+The flush command deletes ALL in-memory and persistence data in the database.
+We recommend that you [back up your database]({{< relref "/operate/rs/databases/import-export/schedule-backups.md" >}}) before you flush the data.
+{{< /warning >}}
+
+## 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.
+
+To flush data from a database with the redis-cli, run:
+
+```sh
+redis-cli -h <hostname> -p <portnumber> -a <password> flushall
+```
+
+Example:
+
+```sh
+redis-cli -h redis-12345.cluster.local -p 9443 -a xyz flushall
+```
+
+{{< note >}}
+Port 9443 is the default [port configuration]({{< relref "/operate/rs/networking/port-configurations#https://docs.redis.com/latest/rs/networking/port-configurations#ports-and-port-ranges-used-by-redis-enterprise-software" >}}).
+{{< /note >}}
+
+
+## Flush data from an Active-Active database
+
+When you flush an Active-Active database (formerly known as CRDB), all of the replicas flush their data at the same time.
+
+To flush data from an Active-Active database, use one of the following methods:
+
+- Cluster Manager UI
+
+    1. On the **Databases** screen, select the database from the list, then click **Configuration**.
+
+    1. Click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+    1. Select **Flush database**.
+
+    1. Enter the name of the Active-Active database to confirm that you want to flush the data.
+
+    1. Click **Flush**.
+
+- Command line
+
+    1. To find the ID of the Active-Active database, run:
+
+        ```sh
+        crdb-cli crdb list
+        ```
+
+        For example:
+
+        ```sh
+        $ crdb-cli crdb list
+        CRDB-GUID                                NAME                 REPL-ID CLUSTER-FQDN
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                1       cluster1.local
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                2       cluster2.local
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                3       cluster3.local
+        ```
+
+    1. To flush the Active-Active database, run:
+
+        ```sh
+        crdb-cli crdb flush --crdb-guid <CRDB-GUID>
+        ```
+
+        The command output contains the task ID of the flush task, for example:
+
+        ```sh
+        $ crdb-cli crdb flush --crdb-guid a16fe643-4a7b-4380-a5b2-96109d2e8bca
+        Task 63239280-d060-4639-9bba-fc6a242c19fc created
+        ---> Status changed: queued -> started
+        ```
+
+    1. To check the status of the flush task, run:
+
+        ```sh
+        crdb-cli task status --task-id <Task-ID>
+        ```
+
+        For example:
+
+        ```sh
+        $ crdb-cli task status --task-id 63239280-d060-4639-9bba-fc6a242c19fc
+        Task-ID: 63239280-d060-4639-9bba-fc6a242c19fc
+        CRDB-GUID: -
+        Status: finished
+        ```
+
+- REST API
+
+    1. To find the ID of the Active-Active database, use [`GET /v1/crdbs`]({{< relref "/operate/rs/references/rest-api/requests/crdbs#get-all-crdbs" >}}):
+
+        ```sh
+        GET https://[host][:port]/v1/crdbs
+        ```
+
+    1. To flush the Active-Active database, use [`PUT /v1/crdbs/{guid}/flush`]({{< relref "/operate/rs/references/rest-api/requests/crdbs/flush#put-crdbs-flush" >}}):
+
+        ```sh
+        PUT https://[host][:port]/v1/crdbs/<guid>/flush
+        ```
+
+        The command output contains the task ID of the flush task.
+
+    1. To check the status of the flush task, use [`GET /v1/crdb_tasks`]({{< relref "/operate/rs/references/rest-api/requests/crdb_tasks#get-crdb_task" >}}):
+
+        ```sh
+        GET https://[host][:port]/v1/crdb_tasks/<task-id>
+        ```
+---
+Title: Migrate a database to Active-Active
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use Replica Of to migrate your database to an Active-Active database.
+linktitle: Migrate to Active-Active
+weight: $weight
+---
+
+If you have data in a single-region Redis Enterprise Software database that you want to migrate to an [Active-Active database]({{< relref "/operate/rs/databases/active-active" >}}),
+you'll need to create a new Active-Active database and migrate the data into the new database as a [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}}) the existing database.
+This process will gradually populate the data in the Active-Active database.
+
+Before data migration starts, all data is flushed from the Active-Active database.
+The data is migrated to the Active-Active instance where you configured migration, and the data from that instance is copied to the other Active-Active instances.
+
+When data migration is finished, turn off migration and connect your applications to the Active-Active database.
+
+{{<image filename="images/rs/A-A_migration.png" width="75%" alt="Active-Active data migration process" >}}
+
+## Prerequisites
+
+- During the migration, any applications that connect to the Active-Active database must be **read-only** to ensure the dataset is identical to the source database during the migration process. However, you can continue to write to the source database during the migration process.
+
+- If you used the mDNS protocol for the cluster name (FQDN),
+the [client mDNS prerequisites]({{< relref "/operate/rs/networking/mdns" >}}) must be met in order to communicate with other clusters.
+
+## Migrate from a Redis Enterprise cluster
+
+You can migrate a Redis Enterprise database from the [same cluster](#migrate-from-the-same-cluster) or a [different cluster](#migrate-from-a-different-cluster).
+
+### Migrate from the same cluster
+
+To migrate a database to Active-Active in the same Redis Enterprise cluster:
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **Current cluster**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-current-cluster.png" alt="Migrate to Active-Active dialog with Current cluster tab selected.">}}
+
+1. Select the source database from the list.
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+### Migrate from a different cluster
+
+{{< note >}}
+For a source database on a different Redis Enterprise Software cluster,
+you can [compress the replication data]({{< relref "/operate/rs/databases/import-export/replica-of#data-compression-for-replica-of" >}}) to save bandwidth.
+{{< /note >}}
+
+To migrate a database to Active-Active in different Redis Enterprise clusters:
+
+1. Sign in to the Cluster Manager UI of the cluster hosting the source database.
+
+    1. In **Databases**, select the source database and then select the **Configuration** tab.
+
+    1. In the **Replica Of** section, select **Use this database as a source for another database**.
+
+    1. Copy the Replica Of source URL.
+
+        {{<image filename="images/rs/screenshots/databases/config-replica-of-copy-source-url.png" alt="Copy the Replica Of source URL from the Connection link to destination dialog.">}}
+
+        To change the internal password, select **Regenerate password**.
+
+        If you regenerate the password, replication to existing destinations fails until their credentials are updated with the new password.
+
+1. Sign in to the Cluster Manager UI of the destination database’s cluster.
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **External**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-external.png" alt="Migrate to Active-Active dialog with External tab selected.">}}
+
+1. For **Source database URL**, enter the Replica Of source URL you copied in step 1.
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+## Migrate from Redis Open Source
+
+To migrate a Redis Open Source database to Active-Active:
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **External**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-external.png" alt="Migrate to Active-Active dialog with External tab selected.">}}
+
+1. Enter the **Source database URL**:
+
+    - If the database has a password:
+
+        ```sh
+        redis://:<password>@<host>:<port>
+        ```
+
+        Where the password is the Redis password represented with URL encoding escape characters.
+
+    - If the database does not have a password:
+
+        ```sh
+        redis://<host>:<port>
+        ```
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+## Stop sync after migration
+
+1. Wait until the migration is complete, indicated by the **Status** _Synced_. 
+
+    {{<note>}}
+Migration can take minutes to hours to complete depending on the dataset size and network quality.
+    {{</note>}}
+
+1. On the Active-Active database's **Configuration** screen, click **Edit**.
+
+1. In the **Migrate to Active-Active** section, click **Stop sync**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-synced.png" alt="The Migrate to Active-Active section shows the Active-Active database is synced with the source database.">}}
+
+1. In the **Stop synchronization** dialog, click **Stop** to proceed.
+
+1. Redirect client connections to the Active-Active database after **Status** changes to _Sync stopped_:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-sync-stopped.png" alt="The Migrate to Active-Active section shows the Active-Active database stopped syncing with the source database.">}}
+---
+Title: Schedule periodic backups
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Schedule backups of your databases to make sure you always have valid backups.
+linktitle: Schedule backups
+weight: 40
+---
+
+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]({{< relref "/operate/rs/databases/import-export/export-data.md" >}}).
+
+You can schedule backups to a variety of locations, including:
+
+- FTP server
+- SFTP server
+- Local mount point
+- Amazon Simple Storage Service (S3)
+- Azure Blob Storage
+- Google Cloud Storage
+
+The backup process creates compressed (.gz) RDB files that you can [import into a database]({{< relref "/operate/rs/databases/import-export/import-data.md" >}}). If the database name is longer than 30 characters, only the first 30 are used in backup file names.
+
+When you back up a database configured for database clustering,
+Redis Enterprise Software creates a backup file for each shard in the configuration.  All backup files are copied to the storage location.
+
+{{< note >}}
+
+- Make sure that you have enough space available in your storage location.
+    If there is not enough space in the backup location, the backup fails.
+- The backup configuration only applies to the database it is configured on.
+- To limit the parallel backup for shards, set both [`tune cluster max_simultaneous_backups`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}) and [`tune node max_redis_forks`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-node" >}}). `max_simultaneous_backups` is set to 4 by default.
+
+{{< /note >}}
+
+## Schedule periodic backups
+
+Before scheduling periodic backups, verify that your storage location exists and is available to the user running Redis Enterprise Software (`redislabs` by default).  You should verify that:
+
+- Permissions are set correctly.
+- The user running Redis Enterprise Software is authorized to access the storage location.
+- The authorization credentials work.
+
+Storage location access is verified before periodic backups are scheduled.
+
+To schedule periodic backups for a database:
+
+1. Sign in to the Redis Enterprise Software Cluster Manager UI using admin credentials.
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select the **Edit** button.
+
+1. Expand the **Durability** section.
+
+1. In the **Scheduled backup** section, click **Add backup path** to open the **Path configuration** dialog.
+
+1. Select the tab that corresponds to your storage location type, enter the location details, and select **Done**. 
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+
+1. Set the backup **Interval** and **Starting time**.
+
+    | Setting | Description |
+    |--------------|-------------|
+    | **Interval** | Specifies the frequency of the backup; that is, the time between each backup snapshot.<br/><br/>Supported values include _Every 24 hours_, _Every 12 hours_, _Every 4 hours_, and _Every hour_. |
+    | **Starting time** | _v6.2.8 or later:&nbsp;_ Specifies the start time in UTC for the backup; available when **Interval** is set to _Every 24 hours_ or _Every 12 hours_.<br/><br/>If not specified, defaults to a time selected by Redis Enterprise Software. |
+
+7. Select **Save**.
+
+Access to the storage location is verified when you apply your updates.  This means the location, credentials, and other details must exist and function before you can enable periodic backups.
+
+## Default backup start time
+
+If you do _not_ specify a start time for twenty-four or twelve hour backups, Redis Enterprise Software chooses a random starting time in UTC for you.
+
+This choice assumes that your database is deployed to a multi-tenant cluster containing multiple databases.  This means that default start times are staggered (offset) to ensure availability.  This is done by calculating a random offset which specifies a number of seconds added to the start time.  
+
+Here's how it works:
+
+- Assume you're enabling the backup at 4:00 pm (1600 hours).
+- You choose to back up your database every 12 hours.
+- Because you didn't set a start time, the cluster randomly chooses an offset of 4,320 seconds (or 72 minutes).
+
+This means your first periodic backup occurs 72 minutes after the time you enabled periodic backups (4:00&nbsp;pm&nbsp;+&nbsp;72&nbsp;minutes).  Backups repeat every twelve hours at roughly same time.
+
+The backup time is imprecise because they're started by a trigger process that runs every five minutes.  When the process wakes, it compares the current time to the scheduled backup time.  If that time has passed, it triggers a backup.  
+
+If the previous backup fails, the trigger process retries the backup until it succeeds.
+
+In addition, throttling and resource limits also affect backup times.
+
+For help with specific backup issues, [contact support](https://redis.com/company/support/).
+
+
+## Supported storage locations {#supported-storage-locations}
+
+Database backups can be saved to a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When saved to a local mount point or a cloud provider, backup locations need to be available to [the group and user]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view permissions and update objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before enabling backups to an FTP server, verify that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user specified in the FTP server location has read and write privileges.
+
+To store your backups on an FTP server, set its **Backup Path** using the following syntax:
+
+`ftp://[username]:[password]@[host]:[port]/[path]/`
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the backup path, if needed.
+
+Example: `ftp://username:password@10.1.1.1/home/backups/`
+
+The user account needs permission to write files to the server.
+
+### SFTP server
+
+Before enabling backups to an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user specified in the SFTP server location has read and write privileges.
+- The SSH private keys are specified correctly.  You can use the key generated by the cluster or specify a custom key.
+
+    To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To backup to an SFTP server, enter the SFTP server location in the format:
+
+```sh
+sftp://user:password@host<:custom_port>/path/
+```
+
+For example: `sftp://username:password@10.1.1.1/home/backups/`
+
+### Local mount point
+
+Before enabling periodic backups to a local mount point, verify that:
+
+- The node can connect to the destination server, the one hosting the mount point.
+- The `redislabs:redislabs` user has read and write privileges on the local mount point
+and on the destination server.
+- The backup location has enough disk space for your backup files. Backup files
+are saved with filenames that include the timestamp, which means that earlier backups are not overwritten.
+
+To back up to a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to a shell running on Redis Enterprise Software server hosting the node.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the backup location, enter the mount point.
+
+    For example: `/mnt/Public`
+
+1. Verify that the user running Redis Enterprise Software has permissions to access and update files in the mount location.
+
+### AWS Simple Storage Service
+
+To store backups in an Amazon Web Services (AWS) Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html):
+
+1.  Sign in to the [AWS Management Console](https://console.aws.amazon.com/).
+
+1. [Create an S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) if you do not already have one.
+
+1. [Create an IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to add objects to the bucket.
+
+1. [Create an access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for that user if you do not already have one.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **AWS S3** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Access Key ID** field, enter the access key ID.
+
+    - In the **Secret Access Key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate.
+
+To connect to an S3-compatible storage location:
+
+1. Configure the S3 URL with [`rladmin cluster config`]({{<relref "/operate/rs/references/cli-utilities/rladmin/cluster/config">}}): 
+
+    ```sh
+    rladmin cluster config s3_url <URL>
+    ```
+
+    Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+1. Configure the S3 CA certificate:
+
+    ```sh
+    rladmin cluster config s3_ca_cert <filepath>
+    ```
+
+    Replace `<filepath>` with the location of the S3 CA certificate `ca.pem`.
+
+### Google Cloud Storage
+
+For [Google Cloud](https://developers.google.com/console/) subscriptions, store your backups in a Google Cloud Storage bucket:
+
+1. Sign in to the Google Cloud Platform console.
+
+1. [Create a JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) if you do not already have one.
+
+1. [Create a bucket](https://cloud.google.com/storage/docs/creating-buckets#create_a_new_bucket) if you do not already have one.
+
+1. [Add a principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) to your bucket:
+
+    - In the **New principals** field, add the `client_email` from the service account key.
+
+    - Select "Storage Legacy Bucket Writer" from the **Role** list.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **Google Cloud Storage** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Client ID** field, enter the `client_id` from the service account key.
+
+    - In the **Client Email** field, enter the `client_email` from the service account key.
+
+    - In the **Private Key ID** field, enter the `private_key_id` from the service account key.
+
+    - In the **Private Key** field, enter the `private_key` from the service account key.
+      Replace `\n` with new lines.
+
+### Azure Blob Storage
+
+To store your backup in Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+To export to Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.
+
+1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.
+
+1. [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) to find the storage account name and account keys.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **Azure Blob Storage** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Azure Account Name** field, enter your storage account name.
+
+    - In the **Azure Account Key** field, enter the storage account key.
+
+To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).
+---
+Title: Export data from a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: You can export data to import it into a new database or to make a backup.  This
+  article shows how to do so.
+linktitle: Export data
+weight: 20
+---
+
+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.
+
+Export is a two-step process: a temporary copy of the data is saved to the local storage of the node and then copied to the storage destination.  (The temporary file is removed after the copy operation.)
+
+Export fails when there isn't enough space for either step.
+
+## Export database data
+
+To export data from a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database from the list, then select **Configuration**.
+
+1. Click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Export**.
+
+1.  Select the tab that corresponds to your storage location type and enter the location details.
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+
+1.  Select **Export**.
+
+## Supported storage locations {#supported-storage-locations}
+
+Data can be exported to a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When saved to a local mount point or a cloud provider, export locations need to be available to [the group and user]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view permissions and update objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before exporting data to an FTP server, verify that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user specified in the FTP server location has permission to read and write files to the server.
+
+To export data to an FTP server, set **Path** using the following syntax:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the export destination path, if needed.
+
+Example: `ftp://username:password@10.1.1.1/home/exports/`
+
+### Local mount point
+
+Before exporting data to a local mount point, verify that:
+
+- The node can connect to the server hosting the mount point.
+- The `redislabs:redislabs` user has permission to read and write files to the local mount point and to the destination server.
+- The export location has enough disk space for your exported data.
+
+To export to a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to the node's terminal.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the export location, enter the mount point.
+
+    For example: `/mnt/Public`
+
+### SFTP server
+
+Before exporting data to an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user specified in the SFTP server location has permission to read and write files to the server.
+- The SSH private keys are specified correctly.  You can use the key generated by the cluster or specify a custom key.
+
+    To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To export data to an SFTP server, enter the SFTP server location in the format:
+
+```sh
+sftp://[username]:[password]@[host]:[port]/[path]/
+```
+
+Where:
+
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the export destination path, if needed.
+
+For example: `sftp://username:password@10.1.1.1/home/exports/`
+
+### AWS Simple Storage Service
+
+To export data to an [Amazon Web Services](https://aws.amazon.com/) (AWS) Simple Storage Service (S3) bucket:
+
+1. Sign in to the [AWS console](https://console.aws.amazon.com/).
+
+1. [Create an S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) if you do not already have one.
+
+1. [Create an IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to add objects to the bucket.
+
+1. [Create an access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for that user if you do not already have one.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **AWS S3**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Access key ID** field, enter the access key ID.
+
+    - In the **Secret access key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate.
+
+To connect to an S3-compatible storage location:
+
+1. Configure the S3 URL with [`rladmin cluster config`]({{<relref "/operate/rs/references/cli-utilities/rladmin/cluster/config">}}): 
+
+    ```sh
+    rladmin cluster config s3_url <URL>
+    ```
+
+    Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+1. Configure the S3 CA certificate:
+
+    ```sh
+    rladmin cluster config s3_ca_cert <filepath>
+    ```
+
+    Replace `<filepath>` with the location of the S3 CA certificate `ca.pem`.
+
+### Google Cloud Storage
+
+To export to a [Google Cloud](https://developers.google.com/console/) storage bucket:
+
+1. Sign in to the Google Cloud console.
+
+1. [Create a JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) if you do not already have one.
+
+1. [Create a bucket](https://cloud.google.com/storage/docs/creating-buckets#create_a_new_bucket) if you do not already have one.
+
+1. [Add a principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) to your bucket:
+
+    - In the **New principals** field, add the `client_email` from the service account key.
+
+    - Select "Storage Legacy Bucket Writer" from the **Role** list.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **Google Cloud Storage**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Client ID** field, enter the `client_id` from the service account key.
+
+    - In the **Client Email** field, enter the `client_email` from the service account key.
+
+    - In the **Private Key ID** field, enter the `private_key_id` from the service account key.
+
+    - In the **Private key** field, enter the `private_key` from the service account key.
+      Replace `\n` with new lines.
+
+
+### Azure Blob Storage
+
+To export to Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.
+
+1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.
+
+1. [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) to find the storage account name and account keys.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **Azure Blob Storage**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Account name** field, enter your storage account name.
+
+    - In the **Account key** field, enter the storage account key.
+
+To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).
+---
+Title: Import data into a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: 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.
+linktitle: Import data
+weight: 10
+---
+You can import, [export]({{< relref "/operate/rs/databases/import-export/export-data" >}}),
+or [backup]({{< relref "/operate/rs/databases/import-export/schedule-backups" >}})
+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.
+{{< /warning >}}
+
+## Import data into a database
+
+To import data into a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database from the list, then select **Configuration**.
+1. Click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+1. Select **Import**.
+1. Select the tab that corresponds to your storage location type and enter the location details.
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+1. Select **Import**.
+
+## Supported storage locations {#supported-storage-services}
+
+Data can be imported from a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When importing from a local mount point or a cloud provider, import locations need to be available to [the group and user]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before importing data from an FTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user that you specify in the FTP server location has permission to read files from the server.
+
+To import data from an FTP server, set **RDB file path/s** using the following syntax:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/[filename].rdb
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the file's location path.
+- *filename*: the name of the file.
+
+Example: `ftp://username:password@10.1.1.1/home/backups/<filename>.rdb`
+
+Select **Add path** to add another import file path.
+
+### Local mount point
+
+Before importing data from a local mount point, make sure that:
+
+- The node can connect to the server hosting the mount point.
+
+- The `redislabs:redislabs` user has permission to read files on the local mount point and on the destination server.
+
+- You must mount the storage in the same path on all cluster nodes. You can also use local storage, but you must copy the imported files manually to all nodes because the import source folders on the nodes are not synchronized.
+
+To import from a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to the node's terminal.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the import location, enter the mount point.
+
+    For example: `/mnt/Public/<filename>.rdb`
+
+As of version 6.2.12, Redis Enterprise reads files directly from the mount point using a [symbolic link](https://en.wikipedia.org/wiki/Symbolic_link) (symlink) instead of copying them to a temporary directory on the node.
+
+Select **Add path** to add another import file path.
+
+### SFTP server
+
+Before importing data from an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user that you specify in the SFTP server location has permission to read files from the server.
+- The SSH private keys are specified correctly. You can use the key generated by the cluster or specify a custom key.
+    
+   To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To import data from an SFTP server, enter the SFTP server location in the format:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/[filename].rdb
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the file's location path.
+- *filename*: the name of the file.
+
+Example: `sftp://username:password@10.1.1.1/home/backups/[filename].rdb`
+
+Select **Add path** to add another import file path.
+
+### AWS Simple Storage Service {#aws-s3}
+
+Before you choose to import data from an [Amazon Web Services](https://aws.amazon.com/) (AWS) Simple Storage Service (S3) bucket, make sure you have:
+
+- The path to the file in your bucket in the format: `s3://[bucketname]/[path]/[filename].rdb`
+- [Access key ID and Secret access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for an [IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to read files from the bucket. 
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+- Select **AWS S3**.
+
+- In the **RDB file path/s** field, enter the path of your bucket. Select **Add path** to add another import file path.
+
+- In the **Access key ID** field, enter the access key ID.
+
+- In the **Secret access key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate.
+
+To connect to an S3-compatible storage location:
+
+1. Configure the S3 URL with [`rladmin cluster config`]({{<relref "/operate/rs/references/cli-utilities/rladmin/cluster/config">}}): 
+
+    ```sh
+    rladmin cluster config s3_url <URL>
+    ```
+
+    Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+1. Configure the S3 CA certificate:
+
+    ```sh
+    rladmin cluster config s3_ca_cert <filepath>
+    ```
+
+    Replace `<filepath>` with the location of the S3 CA certificate `ca.pem`.
+
+### Google Cloud Storage
+
+Before you import data from a [Google Cloud](https://developers.google.com/console/) storage bucket, make sure you have:
+
+- Storage location path in the format: `/bucket_name/[path]/[filename].rdb`
+- A [JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) for your account
+- A [principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) for your bucket with the `client_email` from the service account key and a [role](https://cloud.google.com/storage/docs/access-control/iam-roles) with permissions to get files from the bucket (such as the **Storage Legacy Object Reader** role, which grants `storage.objects.get` permissions)
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the import location details:
+
+- Select **Google Cloud Storage**.
+
+- In the **RDB file path/s** field, enter the path of your file. Select **Add path** to add another import file path.
+
+- In the **Client ID** field, enter the `client_id` from the service account key.
+
+- In the **Client email** field, enter the `client_email` from the service account key.
+
+- In the **Private key id** field, enter the `private_key_id` from the service account key.
+
+- In the **Private key** field, enter the `private_key` from the service account key.
+    Replace `\n` with new lines.
+
+### Azure Blob Storage
+
+Before you choose to import from Azure Blob Storage, make sure that you have:
+
+- Storage location path in the format: `/container_name/[path/]/<filename>.rdb`
+- Account name
+- An authentication token, either an account key or an Azure [shared access signature](https://docs.microsoft.com/en-us/rest/api/storageservices/delegate-access-with-shared-access-signature) (SAS).
+
+    To find the account name and account key, see [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage).
+
+    Azure SAS support requires Redis Software version 6.0.20.  To learn more about Azure SAS, see [Grant limited access to Azure Storage resources using shared access signatures](https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview).
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the import location details:
+
+- Select **Azure Blob Storage**.
+
+- In the **RDB file path/s** field, enter the path of your file. Select **Add path** to add another import file path.
+
+- In the **Azure Account Name** field, enter your storage account name.
+
+- In the **Azure Account Key** field, enter the storage account key.
+
+## Importing into an Active-Active database
+
+When importing data into an Active-Active database, there are two options:
+
+- [Flush all data]({{< relref "/operate/rs/databases/import-export/flush#flush-data-from-an-active-active-database" >}}) from the Active-Active database, then import the data into the database.
+- Import data but merge it into the existing database.
+
+Because Active-Active databases have a numeric counter data type,
+when you merge the imported data into the existing data RS increments counters by the value that is in the imported data.
+The import through the Redis Enterprise Cluster Manager UI handles these data types for you.
+
+You can import data into an Active-Active database [from the Cluster Manager UI](#import-data-into-a-database).
+When you import data into an Active-Active database, there is a special prompt warning that the imported data will be merged into the existing database.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Import and export data
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to import, export, flush, and migrate your data.
+hideListLinks: false
+linkTitle: Import and export
+weight: 30
+---
+---
+Title: Create a database with Replica Of
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create Replica Of database
+linkTitle: Create Replica Of database
+weight: 10
+---
+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.
+
+Replica Of can model a variety of data relationships, including:
+
+- One-to-many relationships, where multiple replicas copy a single source database.
+- Many-to-one relationships, where a single replica collects data from multiple source databases.
+
+When you change the replica status of a database by adding, removing, or changing sources, the replica database is synchronized to the new sources.  
+
+## Configure Replica Of
+
+You can configure a database as a Replica Of, where the source database is in one of the following clusters:
+
+- [Same Redis Enterprise cluster](#same-cluster)
+
+- [Different Redis Enterprise cluster](#different-cluster)
+
+- [Redis Open Source cluster](#source-available-cluster)
+
+The order of the multiple Replica Of sources has no material impact on replication.
+
+For best results when using the [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS) protocol to resolve the fully-qualified domain name (FQDN) of the cluster, verify that your client connections meet the [client mDNS prerequisites]({{< relref "/operate/rs/networking/mdns.md" >}}).
+
+{{< note >}}
+As long as Replica Of is enabled, data in the target database will not expire and will not be evicted regardless of the set [data eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}}).
+{{< /note >}}
+
+### Same Redis Enterprise cluster {#same-cluster}
+
+To configure a Replica Of database in the same Redis Enterprise cluster as the source database:
+
+1. [Create a new database]({{< relref "/operate/rs/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **Current cluster**.
+
+1. Select the source database from the list.
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+### Different Redis Enterprise cluster {#different-cluster}
+
+To configure a Replica Of database in a different Redis Enterprise cluster from the source database:
+
+1. Sign in to the Cluster Manager UI of the cluster hosting the source database.
+
+    1. In **Databases**, select the source database and then select the **Configuration** tab.
+
+    1. In the **Replica Of** section, select **Use this database as a source for another database**.
+
+    1. Copy the Replica Of source URL.
+
+        {{<image filename="images/rs/screenshots/databases/config-replica-of-copy-source-url.png" alt="Copy the Replica Of source URL from the Connection link to destination dialog.">}}
+
+        To change the internal password, select **Regenerate password**.
+
+        If you regenerate the password, replication to existing destinations fails until their credentials are updated with the new password.
+
+1. Sign in to the Cluster Manager UI of the destination database's cluster.
+
+1. [Create a new database]({{< relref "/operate/rs/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **External**.
+
+1. Enter the URL of the source database endpoint.
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+For source databases on different clusters, you can [compress replication data]({{< relref "/operate/rs/databases/import-export/replica-of/#data-compression-for-replica-of" >}}) to save bandwidth.
+        
+### Redis Open Source cluster {#source-available-cluster}
+
+To use a database from a Redis Open Source cluster as a Replica Of source:
+
+1. [Create a new database]({{< relref "/operate/rs/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **External**.
+
+1. Enter the URL of the source endpoint in one of the following formats:
+
+    - For databases with passwords:
+
+        ```sh
+        redis://:<password>@<host>:<port>
+        ```
+
+        Where the password is the Redis password represented with URL encoding escape characters.
+
+    - For databases without passwords:
+
+        ```sh
+        redis://<host>:<port>
+        ```
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+## Configure TLS for Replica Of
+
+When you enable TLS for Replica Of, the Replica Of synchronization traffic uses TLS certificates to authenticate the communication between the source and destination clusters.
+
+To encrypt Replica Of synchronization traffic, configure encryption for the [source database](#encrypt-source-database-traffic) and the destination [replica database](#encrypt-replica-database-traffic).
+
+### Encrypt source database traffic
+
+{{<embed-md "replica-of-tls-config.md">}}
+
+### Encrypt replica database traffic
+
+To enable TLS for Replica Of in the destination database:
+
+1. From the Cluster Manager UI of the cluster hosting the source database:
+
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand the **Server authentication (Proxy certificate)** section.
+
+        {{<image filename="images/rs/screenshots/cluster/security-proxy-cert.png" alt="Proxy certificate for server authentication.">}}
+
+     1. Download or copy the proxy certificate.
+
+1. From the **Configuration** tab of the Replica Of destination database, select **Edit**.
+
+1. Expand the **Replica Of** section.
+
+1. Point to the source database entry and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit it.
+
+1. Paste or upload the source proxy certificate, then select **Done**.
+
+1. Select **Save**.
+---
+Title: Replica Of Repeatedly Fails
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Troubleshoot when the Replica Of process repeatedly fails and restarts.
+linktitle: Troubleshoot repeat failures
+weight: 20
+---
+**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:
+
+    `rladmin tune db < db:id | name > slave_buffer < value >`
+
+- If the source is a Redis database not on a Redis Enterprise Software cluster,
+    use the [config set](http://redis.io/commands/config-set) command through
+    `redis-cli` to increase the client output buffer size of the **source database** with:
+
+    `config set client-output-buffer-limit "slave <hard_limit> <soft_limit> <soft_seconds>"`
+
+**Additional information**: [Top Redis Headaches for DevOps - Replication Buffer](https://redislabs.com/blog/top-redis-headaches-for-devops-replication-buffer)
+---
+Title: Replica Of geo-distributed Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica Of provides read-only access to replicas of the dataset from different geographical locations.
+hideListLinks: true
+linkTitle: Replica Of
+weight: $weight
+aliases: /operate/rs/administering/active-passive/
+---
+In Redis Enterprise, the Replica Of feature provides active-passive geo-distribution to applications  for read-only access
+to replicas of the dataset from different geographical locations.
+The Redis Enterprise implementation of active-passive replication is called Replica Of.
+
+In Replica Of, an administrator designates a database as a replica (destination) of one or more databases (sources).
+After the initial data load from source to destination is completed,
+all write commands are synchronized from the sources to the destination.
+Replica Of lets you distribute the read load of your application across multiple databases or
+synchronize the database, either within Redis Enterprise or external to Redis Enterprise, to another database.
+
+You can [create Active-Passive]({{< relref "/operate/rs/databases/import-export/replica-of/create.md" >}}) databases on Redis Enterprise Software or Redis Cloud.
+
+[Active-Active Geo-Distribution (CRDB)]({{< relref "/operate/rs/databases/active-active" >}})
+provides these benefits and also provides write access to all of the database replicas.
+
+{{< warning >}}
+Configuring a database as a replica of the database that it replicates
+creates a cyclical replication and is not supported.
+{{< /warning >}}
+
+The Replica Of is defined in the context of the destination database
+by specifying the source databases.
+
+A destination database can have a maximum of thirty-two (32) source
+databases.
+
+If only one source is defined, then the command execution order in the
+source is kept in the destination. However, when multiple sources are
+defined, commands that are replicated from the source databases are
+executed in the order in which they reach the destination database. As a
+result, commands that were executed in a certain order when compared
+across source databases might be executed in a different order on the
+destination database.
+
+{{< note >}}
+The Replica Of feature should not be confused with the
+in-memory [Database
+replication]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}})
+feature, which is used for creating a master / replica configuration that
+enables ensuring database high-availability.
+{{< /note >}}
+
+## Replication process
+
+When a database is defined as a replica of another database, all its
+existing data is deleted and replaced by data that is loaded from the
+source database.
+
+Once the initial data load is completed, an ongoing synchronization
+process takes place to keep the destination always synchronized with its
+source. During the ongoing synchronization process, there is a certain
+delay between the time when a command was executed on the source and
+when it is executed on the destination. This delay is referred to as the
+**Lag**.
+
+When there is a **synchronization error**, **the process might stop** or
+it might continue running on the assumption that the error automatically
+resolves. The result depends on the error type. See more details below.
+
+In addition, **the user can manually stop the synchronization process**.
+
+When the process is in the stopped state - whether stopped by the user
+or by the system - the user can restart the process. **Restarting the
+process causes the synchronization process to flush the DB and restart
+the process from the beginning**.
+
+### Replica Of status
+
+The replication process can have the following statuses:
+
+- **Syncing** - indicates that the synchronization process has
+    started from scratch. Progress is indicated in percentages (%).
+- **Synced** - indicates that the initial synchronization process was
+    completed and the destination is synchronizing changes on an ongoing
+    basis. The **Lag** delay in synchronization with the source is
+    indicated as a time duration.
+- **Sync stopped** - indicates that the synchronization process is
+    currently not running and the user needs to restart it in order for
+    it to continue running. This status happens if the user stops the
+    process, or if certain errors arose that prevent synchronization
+    from continuing without manual intervention. See more details below.
+
+The statuses above are shown for the source database. In addition, a
+timestamp is shown on the source indicating when the last command from
+the source was executed on the destination.
+
+The system also displays the destination database status as an aggregate
+of the statuses of all the sources.
+
+{{< note >}}
+If you encounter issues with the Replica Of process, refer
+to the troubleshooting section [Replica Of repeatedly
+fails]({{< relref "/operate/rs/databases/import-export/replica-of/replicaof-repeatedly-fails.md" >}}).
+{{< /note >}}
+
+### Synchronization errors
+
+Certain errors that occur during the synchronization process require
+user intervention for their resolution. When such errors occur, the
+synchronization process is automatically stopped.
+
+For other errors, the synchronization process continues running on the
+assumption that the error automatically resolves.
+
+Examples of errors that require user intervention for their resolution
+and that stop the synchronization process include:
+
+- Error authenticating with the source database.
+- Cross slot violation error while executing a command on a sharded
+    destination database.
+- Out-of-memory error on a source or on the destination
+    database.
+
+Example of an error that does not cause the synchronization process to
+stop:
+
+- Connection error with the source database. A connection error might
+    occur occasionally, for example as result of temporary network
+    issues that get resolved. Depending on the connection error and its
+    duration the process might be able to start syncing from the last
+    point it reached (partial sync) or require a complete
+    resynchronization from scratch across all sources (full sync).
+
+## Encryption
+
+Replica Of supports the ability to encrypt uni-directional replication
+communications between source and destination clusters utilizing TLS 1.2
+based encryption.
+
+## Data compression for Replica Of
+
+When the Replica Of is defined across different Redis Enterprise
+Software clusters, it may be beneficial to compress the data that flows
+through the network (depending on where the clusters physically reside
+and the available network).
+
+Compressing the data reduces the traffic and can help:
+
+- Resolve throughput issues
+- Reduce network traffic costs
+
+Compressing the data does have trade-offs, which is why it should not
+always be turned on by default. For example:
+
+- It uses CPU and disk resources to compress the data before sending
+    it to the network and decompress it on the other side.
+- It takes time to compress and decompress the data which can increase
+    latency.
+- Replication is disk-based and done gradually, shard by shard in the
+    case of a multi-shard database. This may have an impact on
+    replication times depending on the speed of the disks and load on
+    the database.
+- If traffic is too fast and the compression takes too much time it
+    can cause the replication process to fail and be restarted.
+
+It is advised that you test compression out in a lower environment
+before enabling it in production.
+
+In the Redis Enterprise Software management UI, when designating a
+Replica Of source from a different Redis Enterprise Software cluster,
+there is also an option to enable compression. When enabled, gzip
+compression with level -6 is utilized.
+
+## Database clustering (sharding) implications
+
+If a **source** database is sharded, that entire database is treated as
+a single source for the destination database.
+
+If the **destination** database is sharded, when the commands replicated
+from the source are executed on the destination database, the
+destination database's hashing function is executed to determine to
+which shard/s the command refers.
+
+The source and destination can have different shard counts and functions
+for placement of keys.
+
+### Synchronization in Active-Passive Replication
+
+In Active-Passive databases, one cluster hosts the source database that receives read-write operations
+and the other clusters host destination databases that receive synchronization updates from the source database.
+
+When there is a significant difference between the source and destination databases,
+the destination database flushes all of the data from its memory and starts synchronizing the data again.
+This process is called a **full sync**.
+
+For example, if the database updates for the destination databases
+that are stored by the destination database in a synchronization backlog exceed their allocated memory,
+the source database starts a full sync.
+
+{{% warning %}}
+When you failover to the destination database for write operations,
+make sure that you disable **Replica Of** before you direct clients to the destination database.
+This avoids a full sync that can overwrite your data.
+{{% /warning %}}
+
+## Active-Passive replication backlog
+
+In addition to the [database replication backlog]({{< relref "/operate/rs/databases/durability-ha/replication#database-replication-backlog" >}}), active-passive databases maintain a replication backlog (per shard) to synchronize the database instances between clusters.
+By default, the replication backlog is set to one percent (1%) of the database size divided by the database number of shards and ranges between 1MB to 250MB per shard.
+Use the [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) utility to control the size of the replication backlog. You can set it to `auto` or set a specific size.  
+
+For an Active-Passive database:
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB or 'auto'>
+```
+
+{{<note>}}
+On an Active-Passive database, the replication backlog configuration applies to both the replication backlog for shards synchronization and for synchronization of database instances between clusters.
+{{</note>}}
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+db_type: database
+description: Create a database with Redis Enterprise Software.
+linkTitle: Create a database
+title: Create a Redis Enterprise Software database
+toc: 'true'
+weight: 10
+---
+Redis Enterprise Software lets you create databases and distribute them across a cluster of nodes.
+
+To create a new database:
+
+1. Sign in to the Cluster Manager UI at `https://<hostname>:8443`
+
+1. Use one of the following methods to create a new database:
+
+    - [Quick database](#quick-database)
+
+    - [Create database](#create-database) with additional configuration
+
+1. If you did not specify a port number for the database, you can find the port number in the **Endpoint** field in the **Databases > Configuration > General** section.
+
+1. [Test client connectivity]({{< relref "/operate/rs/databases/connect/test-client-connectivity" >}}).
+
+
+{{< note >}}
+For databases with Active-Active replication for geo-distributed locations,
+see [Create an Active-Active database]({{< relref "/operate/rs/databases/active-active/create.md" >}}). To create and manage Active-Active databases, use the legacy UI.
+{{< /note >}}
+
+## Quick database
+
+To quickly create a database and skip additional configuration options during initial creation:
+
+1. On the **Databases** screen, select **Quick database**.
+
+1. Select a Redis version from the **Database version** list.
+
+1. Configure settings that are required for database creation but can be changed later:
+
+    - Database name
+
+    - Memory limit (GB)
+
+2. Configure optional settings that can't be changed after database creation:
+
+    - Endpoint port (set by the cluster if not set manually)
+
+    - Capabilities (previously modules) to enable
+
+1. Optionally select **Full options** to configure [additional settings]({{< relref "/operate/rs/databases/configure#config-settings" >}}).
+
+1. Select **Create**.
+
+## Create database
+
+To create a new database and configure additional settings:
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select the database type:
+
+    - **Single Region**
+
+    - **Active-Active database** - Multiple participating Redis Enterprise clusters can host instances of the same [Active-Active database]({{< relref "/operate/rs/databases/active-active" >}}) in different geographic locations. Every instance can receive write operations, which are synchronized across all instances without conflict.
+
+    {{<note>}}
+For Active-Active databases, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}).
+    {{</note>}}
+
+1. Select a Redis version from the **Database version** list.
+
+1. Enter a **Database name**.
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+1. To configure additional database settings, expand each relevant section to make changes.
+
+    See [Configuration settings]({{< relref "/operate/rs/databases/configure#config-settings" >}}) for more information about each setting.
+
+1. Select **Create**.
+
+## Continue learning with Redis University
+
+{{< university-links >}}---
+Title: Delete databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Delete a database from the Cluster Manager UI.
+linktitle: Delete
+weight: 36
+---
+
+When you delete a database, both the database configuration and data are removed.
+
+To delete a database from the Cluster Manager UI:
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select {{< image filename="/images/rs/icons/delete-icon.png#no-click" alt="Delete button" width="22px" class="inline" >}} **Delete**.
+
+1. In the **Delete database** dialog, confirm deletion.
+---
+Title: Auto Tiering quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Get started with Auto Tiering quickly, creating a cluster and database
+  using flash storage.
+linkTitle: Quick start
+weight: 80
+---
+This page guides you through a quick setup of [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) with a single node for testing and demo purposes. 
+
+For production environments, you can find more detailed installation instructions in the [install and setup]({{< relref "/operate/rs/installing-upgrading" >}}) section.
+
+The steps to set up a Redis Enterprise Software cluster using Auto Tiering
+with a single node are:
+
+1. Install Redis Enterprise Software or run it in a Docker
+    container.
+1. Set up a Redis Enterprise Software cluster with Auto Tiering.
+1. Create a new database with Auto Tiering enabled.
+1. Connect to your new database.
+
+## Install Redis Enterprise Software
+
+### Bare metal, VM, Cloud instance
+
+To install on bare metal, a virtual machine, or an instance:
+
+1. Download the binaries from the [Redis Enterprise download center](https://cloud.redis.io/#/sign-up/software?direct=true).
+
+1. Upload the binaries to a Linux-based operating system.
+
+1. Extract the image:
+
+    ```sh
+    tar -vxf <downloaded tar file name>
+    ```
+
+1. After the `tar` command completes, you can find a new `install.sh` script in the current directory:
+
+    ```sh
+    sudo ./install.sh -y
+    ```
+
+### Docker-based installation {#dockerbased-installation}
+
+For testing purposes, you can run a Redis Enterprise Software
+Docker container on Windows, MacOS, and Linux.
+
+```sh
+docker run -d --cap-add sys_resource --name rp -p 8443:8443 -p 12000:12000 redislabs/redis:latest
+```
+
+## Prepare and format flash memory
+
+After you [install Redis Enterprise Software](#install-redis-enterprise-software), use the `prepare_flash` script to prepare and format flash memory:
+
+```sh
+sudo /opt/redislabs/sbin/prepare_flash.sh
+```
+
+This script finds unformatted disks and mounts them as RAID partitions in `/var/opt/redislabs/flash`.
+
+To verify the disk configuration, run:
+
+```sh
+sudo lsblk
+```
+
+## Set up a cluster and enable Auto Tiering
+
+1. Direct your browser to `https://localhost:8443` on the host machine to
+see the Redis Enterprise Software Cluster Manager UI.
+
+    {{<note>}}
+Depending on your browser, you may see a certificate error.
+Choose "continue to the website" to go to the setup screen.
+    {{</note>}}
+
+1. Select **Create new cluster**.
+
+1. Set up account credentials for a cluster administrator, then select **Next** to proceed to cluster setup.
+
+1. Enter your cluster license key if you have one. Otherwise, the cluster uses the trial version.
+
+1. Provide a cluster FQDN such as `mycluster.local`, then select **Next**.
+
+1. In the **Storage configuration** section, turn on the **Enable flash storage** toggle.
+
+1. Select **Create cluster**.
+
+1. Select **OK** to confirm that you are aware of the replacement of the HTTPS TLS
+certificate on the node, and proceed through the browser warning.
+
+## Create a database
+
+On the **Databases** screen:
+
+1. Select **Quick database**.
+
+1. Verify **Flash** is selected for **Runs on**.
+
+    {{<image filename="images/rs/screenshots/databases/quick-db-flash-7-8-2.png" alt="Create a quick database with Runs on Flash selected." >}}
+
+1. Enter `12000` for the endpoint **Port** number.
+
+1. _(Optional)_ Select **Full options** to see available alerts.
+
+1. Select **Create**.
+
+You now have a  database with Auto Tiering enabled!
+
+## Connect to your database
+
+After you create the database, you can connect to it and store data. See [Test client connection]({{<relref "/operate/rs/databases/connect/test-client-connectivity">}}) for connection options and examples.
+
+## Next steps
+
+To see the true performance and scale of Auto Tiering, you must tune your I/O path and set the flash path to the mounted path of SSD or NVMe flash memory as that is what it is designed to run on. For more information, see [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}).
+---
+Title: Manage Auto Tiering storage engine
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage the storage engine used for your database with auto tiering enabled.
+linkTitle: Manage storage engine
+weight: 100
+---
+
+## Manage the storage engine
+
+Redis Enterprise Auto Tiering supports two storage engines:
+
+* [Speedb](https://www.speedb.io/) (default, recommended)
+* [RocksDB](https://rocksdb.org/)
+
+{{<warning>}}Switching between storage engines requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+### Change the storage engine
+
+1. Change the cluster level configuration for default storage engine.
+
+  * API:
+
+      ``` sh
+      curl -k -u <username>:<password> -X PUT -H "Content-Type: application/json" -d '{"bigstore_driver":"speedb"}' https://localhost:9443/v1/cluster
+     ```
+
+  * CLI:
+
+      ```sh
+      rladmin cluster config bigstore_driver {speedb | rocksdb}
+      ```
+
+2. Restart the each database on the cluster one by one.
+
+     ```sh
+     rladmin restart db { db:<id> | <name> }
+     ```
+
+{{<note>}} We recommend restarting your database at times with low usage and avoiding peak hours. For databases without persistence enabled, we also recommend using export to backup your database first.{{</note>}}
+
+## Monitor the storage engine
+
+To get the current cluster level default storage engine run:
+
+* Use the `rladmin info cluster` command look for ‘bigstore_driver’.
+
+* Use the REST API:
+
+     ```sh
+     curl -k -u <username>:<password> -X GET -H "Content-Type: application/json" https://localhost:9443/v1/cluster
+     ```
+
+Versions of Redis Enterprise 7.2 and later provide a metric called `bdb_bigstore_shard_count` to help track the shard count per database, filtered by `bdb_id` and by storage engine as shown below:
+
+
+  ```sh
+  bdb_bigstore_shard_count{bdb="1",cluster="mycluster.local",driver="rocksdb"} 1.0
+  bdb_bigstore_shard_count{bdb="1",cluster="mycluster.local",driver="speedb"} 2.0
+  ```
+
+For more about metrics for Redis Enterprise’s integration with Prometheus, see [Prometheus integration]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}}).
+---
+Title: Auto Tiering
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Auto Tiering enables your data to span both RAM and dedicated flash memory.
+hideListLinks: true
+linktitle: Auto Tiering
+weight: 50
+---
+Redis Enterprise's auto tiering offers users the unique ability to use solid state drives (SSDs) to extend databases beyond DRAM capacity.
+Developers can build applications that require large datasets using the same Redis API.
+Using SSDs can significantly reduce the infrastructure costs compared to only DRAM deployments. 
+
+Frequently used data, called hot data, belongs in the fastest memory level to deliver a real-time user experience.
+Data that is accessed less frequently, called warm data, can be kept in a slightly slower memory tier.
+Redis Enterprise’s Auto tiering maintains hot data in DRAM, keeps warm data in SSDs, and transfers data between tiers automatically.
+
+Redis Enterprise’s auto tiering is based on a high-performance storage engine (Speedb) that manages the complexity of using SSDs and DRAM as the total available memory for databases in a Redis Enterprise cluster. This implementation offers a performance boost of up to 10k operations per second per core of the database, doubling the performance of Redis on Flash.
+
+Just like all-RAM databases, databases with Auto Tiering enabled are compatible with existing Redis applications.
+
+Auto Tiering is also supported on [Redis Cloud]({{< relref "/operate/rc/" >}}) and [Redis Enterprise Software for Kubernetes]({{< relref "/operate/rs/" >}}).
+
+## Use cases
+
+The benefits associated with Auto Tiering are dependent on the use case.
+
+Auto Tiering is ideal when your:
+
+- working set is significantly smaller than your dataset (high RAM hit rate)
+- average key size is smaller than average value size (all key names are stored in RAM)
+- most recent data is the most frequently used (high RAM hit rate)
+
+Auto Tiering is not recommended for:
+
+- Long key names (all key names are stored in RAM)
+- Broad access patterns (any value could be pulled into RAM)
+- Large working sets (working set is stored in RAM)
+- Frequently moved data (moving to and from RAM too often can impact performance)
+
+Auto Tiering is not intended to be used for persistent storage. Redis Enterprise Software database persistent and ephemeral storage should be on different disks, either local or attached.
+
+## Where is my data?
+
+When using Auto Tiering, RAM storage holds:
+- All keys (names)
+- Key indexes
+- Dictionaries
+- Hot data (working set)
+
+All data is accessed through RAM. If a value in flash memory is accessed, it becomes part of the working set and is moved to RAM. These values are referred to as “hot data”.
+
+Inactive or infrequently accessed data is referred to as “warm data” and stored in flash memory. When more space is needed in RAM, warm data is moved from RAM to flash storage.
+
+{{<note>}} When using Auto Tiering with RediSearch, it’s important to note that RediSearch indexes are also stored in RAM.{{</note>}}
+
+## RAM to Flash ratio
+
+Redis Enterprise Software allows you to configure and tune the ratio of RAM-to-Flash for each database independently, optimizing performance for your specific use case.
+While this is an online operation requiring no downtime for your database, it is recommended to perform it during maintenance windows as data might move between tiers (RAM <-> Flash).
+
+The RAM limit cannot be smaller than 10% of the total memory. We recommend you keep at least 20% of all values in RAM. Do not set the RAM limit to 100%.
+
+## Flash memory
+
+Implementing Auto Tiering requires pre planning around memory and sizing. Considerations and requirements for Auto Tiering include:
+
+- Flash memory must be locally attached. Using network-attached storage (NAS), storage area networks (SAN), or solutions such as AWS Elastic Block Storage (EBS) is not supported. 
+- Flash memory must be dedicated to Auto Tiering and not shared with other parts of the database, such as durability, binaries, or persistence.
+- For the best performance, the SSDs should be NVMe based, but SATA can also be used.
+- The available flash space must be greater than or equal to the total database size (RAM+Flash). The extra space accounts for write buffers and [write amplification](https://en.wikipedia.org/wiki/Write_amplification).
+
+{{<note>}} The Redis Enterprise Software database persistent and ephemeral storage should be on different disks, either local or attached. {{</note>}}
+
+Once these requirements are met, you can create and manage both databases with Auto Tiering enabled and
+all-RAM databases in the same cluster.
+
+When you begin planning the deployment of an Auto Tiering enabled database in production,
+we recommend working closely with the Redis technical team for sizing and performance tuning.
+
+### Cloud environments
+
+When running in a cloud environment:
+
+- Flash memory is on the ephemeral SSDs of the cloud instance (for example the local NVMe of AWS i4i instnaces and Azure Lsv2 and Lsv3 series).
+- Persistent database storage needs to be network attached (for example, AWS EBS for AWS).
+
+{{<note>}}
+We specifically recommend "[Storage Optimized I4i - High I/O Instances](https://aws.amazon.com/ec2/instance-types/#storage-optimized)" because of the performance of NVMe for flash memory. {{</note>}}
+
+### On-premises environments
+
+When you begin planning the deployment of Auto Tiering in production, we recommend working closely with the Redis technical team for sizing and performance tuning.
+
+On-premises environments support more deployment options than other environments such as:
+
+- Using Redis Stack features:
+  - [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) 
+  - [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+  - [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}})
+  - [Probabilistic data structures]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+
+{{<note>}} Enabling Auto Tiering for Active-Active distributed databases requires validating and getting the Redis technical team's approval first . {{</note>}}
+
+{{<warning>}} Auto Tiering is not supported running on network attached storage (NAS), storage area network (SAN), or with local HDD drives. {{</warning>}}
+
+## Next steps
+
+- [Auto Tiering metrics]({{< relref "/operate/rs/references/metrics/auto-tiering" >}})
+- [Auto Tiering quick start]({{< relref "/operate/rs/databases/auto-tiering/quickstart.md" >}})
+
+- [Ephemeral and persistent storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}})
+- [Hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})
+---
+Title: Troubleshooting pocket guide for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Troubleshoot issues with Redis Enterprise Software, including connectivity
+  issues between the database and clients or applications.
+linktitle: Troubleshoot
+toc: 'true'
+weight: 90
+---
+
+If your client or application cannot connect to your database, verify the following.
+
+## Identify Redis host issues
+
+#### Check resource usage
+
+- Used disk space should be less than `90%`. To check the host machine's disk usage, run the [`df`](https://man7.org/linux/man-pages/man1/df.1.html) command:
+
+    ```sh
+    $ df -h
+    Filesystem      Size  Used Avail Use% Mounted on
+    overlay          59G   23G   33G  41% /
+    /dev/vda1        59G   23G   33G  41% /etc/hosts
+    ```
+
+- RAM and CPU utilization should be less than `80%`, and host resources must be available exclusively for Redis Enterprise Software. You should also make sure that swap memory is not being used or is not configured.
+
+    1. Run the [`free`](https://man7.org/linux/man-pages/man1/free.1.html) command to check memory usage:
+
+        ```sh
+        $ free
+                  total        used        free      shared  buff/cache   available
+        Mem:        6087028     1954664      993756      409196     3138608     3440856
+        Swap:       1048572           0     1048572
+        ```
+
+    1. Used CPU should be less than `80%`. To check CPU usage, use `top` or `vmstat`.
+
+        Run [`top`](https://man7.org/linux/man-pages/man1/top.1.html):
+
+        ```sh
+        $ top
+        Tasks:  54 total,   1 running,  53 sleeping,   0 stopped,   0 zombie
+       %Cpu(s):  1.7 us,  1.4 sy,  0.0 ni, 96.8 id,  0.0 wa,  0.0 hi,  0.1 si,  0.0 st
+       KiB Mem :  6087028 total,   988672 free,  1958060 used,  3140296 buff/cache
+       KiB Swap:  1048572 total,  1048572 free,        0 used.  3437460 avail Mem 
+       ```
+
+        Run [`vmstat`](https://man7.org/linux/man-pages/man8/vmstat.8.html):
+
+        ```sh
+        $ vmstat
+        procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
+        r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
+        2  0      0 988868 177588 2962876    0    0     0     6    7   12  1  1 99  0  0
+       ```
+
+    1. If CPU or RAM usage is greater than 80%, ask your system administrator which process is the culprit. If the process is not related to Redis, terminate it.
+
+#### Sync clock with time server
+
+It is recommended to sync the host clock with a time server.
+
+Verify that time is synchronized with the time server using one of the following commands:
+
+- `ntpq -p`
+
+- `chronyc sources`
+
+- [`timedatectl`](https://man7.org/linux/man-pages/man1/timedatectl.1.html)
+
+#### Remove https_proxy and http_proxy variables
+
+1. Run [`printenv`](https://man7.org/linux/man-pages/man1/printenv.1.html) and check if `https_proxy` and `http_proxy` are configured as environment variables:
+
+    ```sh
+    printenv | grep -i proxy
+    ```
+
+1. If `https_proxy` or `http_proxy` exist, remove them:
+
+    ```sh
+    unset https_proxy
+    ```
+    ```sh
+    unset http_proxy
+    ```
+
+#### Review system logs
+
+Review system logs including the syslog or journal for any error messages, warnings, or critical events. See [Logging]({{< relref "/operate/rs/clusters/logging" >}}) for more information.
+
+## Identify issues caused by security hardening
+
+- Temporarily deactivate any security hardening tools (such as selinux, cylance, McAfee, or dynatrace), and check if the problem is resolved. 
+
+- The user `redislabs` must have read and write access to `/tmp` directory. Run the following commands to verify.
+
+    1. Create a test file in `/tmp` as the `redislabs` user:
+        ```sh
+        $ su - redislabs -s /bin/bash -c 'touch /tmp/test'
+        ```
+
+    1. Verify the file was created successfully:
+        ```sh
+        $ ls -l /tmp/test
+        -rw-rw-r-- 1 redislabs redislabs 0 Aug 12 02:06 /tmp/test
+        ```
+
+- Using a non-permissive file mode creation mask (`umask`) can cause issues.
+
+    1. Check the output of `umask`:
+
+        ```sh
+        $ umask
+        0022
+        ```
+
+    1. If `umask`'s output differs from the default value `0022`, it might prevent normal operation. Consult your system administrator and revert to the default `umask` setting.
+
+## Identify cluster issues
+
+- Use `supervisorctl status` to verify all processes are in a `RUNNING` state:
+
+    ```sh
+    supervisorctl status
+    ```
+
+- Run `rlcheck` and verify no errors appear:
+
+    ```sh
+    rlcheck
+    ```
+
+- Run [`rladmin status issues_only`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) and verify that no issues appear:
+
+    ```sh
+    $ rladmin status issues_only
+    CLUSTER NODES:
+    NODE:ID ROLE ADDRESS EXTERNAL_ADDRESS HOSTNAME SHARDS CORES FREE_RAM PROVISIONAL_RAM VERSION STATUS
+
+    DATABASES:
+    DB:ID  NAME        TYPE  STATUS  SHARDS  PLACEMENT   REPLICATION    PERSISTENCE    ENDPOINT  
+
+    ENDPOINTS:
+    DB:ID               NAME             ID          NODE             ROLE             SSL       
+
+    SHARDS:
+    DB:ID      NAME     ID        NODE     ROLE     SLOTS      USED_MEMORY            STATUS     
+
+    ```
+
+- Run [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}). For each shard, `USED_MEMORY` should be less than 25 GB.
+
+    ```sh
+    $ rladmin status shards
+    SHARDS:
+    DB:ID    NAME         ID          NODE      ROLE      SLOTS       USED_MEMORY       STATUS   
+    db:1     db1          redis:1     node:1    master    0-16383     2.13MB            OK  
+    ```
+
+- Run [`rladmin cluster running_actions`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/running_actions" >}}) and confirm that no tasks are currently running (active):
+
+    ```sh
+    $ rladmin cluster running_actions
+    No active tasks
+    ```
+
+## Troubleshoot connectivity
+
+#### Database endpoint resolution
+
+1. On the client machine, check if the database endpoint can be resolved:
+
+    ```sh
+    dig <endpoint>
+    ```
+
+1. If endpoint resolution fails on the client machine, check on one of the cluster nodes:
+
+    ```sh
+    dig @localhost <endpoint>
+    ```
+
+1. If endpoint resolution succeeds on the cluster node but fails on the client machine, review the DNS configuration and fix any errors.
+
+1. If the endpoint can’t be resolved on the cluster node, [contact support](https://redis.com/company/support/).
+
+#### Client application issues
+
+1. To identify possible client application issues, test connectivity from the client machine to the database using [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+    [`INFO`]({{< relref "/commands/info" >}}):
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> INFO
+    ```
+
+    [`PING`]({{< relref "/commands/ping" >}}):
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> PING
+    ```
+   
+    or if TLS is enabled:
+    
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --tls --insecure --cert --key PING
+    ```
+
+1. If the client machine cannot connect, try to connect to the database from one of the cluster nodes:
+
+    ```sh
+    redis-cli -h <node IP or hostname> -p <port> -a <password> PING
+    ```
+
+1. If the cluster node is also unable to connect to the database, [contact Redis support](https://redis.com/company/support/).
+
+1. If the client fails to connect, but the cluster node succeeds, perform health checks on the client and network.
+
+#### Firewall access
+
+1. Run one of the following commands to verify that database access is not blocked by a firewall on the client machine or cluster:
+
+    ```sh
+    iptables -L
+    ```
+
+    ```sh
+    ufw status
+    ```
+
+    ```sh
+    firewall-cmd –list-all
+    ```
+
+1. To resolve firewall issues:
+
+    1. If a firewall is configured for your database, add the client IP address to the firewall rules.
+
+    1. Configure third-party firewalls and external proxies to allow the cluster FQDN, database endpoint IP address, and database ports.
+
+## Troubleshoot latency
+
+#### Server-side latency
+
+- Make sure the database's used memory does not reach the configured database max memory limit. For more details, see [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit" >}}).
+
+- Try to correlate the time of the latency with any surge in the following metrics:
+
+    - Number of connections
+
+    - Used memory
+
+    - Evicted keys
+
+    - Expired keys 
+
+- Run [`SLOWLOG GET`]({{< relref "/commands/slowlog-get" >}}) using [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) to identify slow commands such as [`KEYS`]({{< relref "/commands/keys" >}}) or [`HGETALL`]({{< relref "/commands/hgetall" >}}:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> SLOWLOG GET <number of entries>
+    ```
+
+    Consider using alternative commands such as [`SCAN`]({{< relref "/commands/scan" >}}), [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}})
+
+- Keys with large memory footprints can cause latency. To identify such keys, compare the keys returned by [`SLOWLOG GET`]({{< relref "/commands/slowlog-get" >}}) with the output of the following commands:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --memkeys
+    ```
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --bigkeys
+    ```
+
+- For additional diagnostics, see:
+
+    - [Diagnosing latency issues]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}})
+
+    - [View Redis slow log]({{< relref "/operate/rs/clusters/logging/redis-slow-log" >}})
+
+#### Client-side latency
+
+Verify the following:
+
+- There is no memory or CPU pressure on the client host.
+
+- The client uses a connection pool instead of frequently opening and closing connections.
+
+- The client does not erroneously open multiple connections that can pressure the client or server.
+---
+Title: Test client connection
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Test connection
+weight: 20
+---
+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:
+
+1. After you [create a Redis database]({{< relref "/operate/rs/databases/create" >}}), 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:
+
+    {{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+
+1. Try to connect to the database endpoint from your client of choice,
+    and run database commands.
+
+1. If the database does not respond, try to connect to the database
+    endpoint using the IP address rather than the FQDN. If you
+    succeed, then DNS is not properly configured. For
+    additional details, see
+    [Configure cluster DNS]({{< relref "/operate/rs/networking/cluster-dns" >}}).
+
+If any issues occur when testing database connections, [contact
+support](https://redis.com/company/support/).
+
+## Test database connections
+
+After you create a Redis database, you can connect to your
+database and store data using one of the following methods:
+
+- [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}), the built-in command-line tool
+
+- [Redis Insight](https://redis.com/redis-enterprise/redis-insight/), a free Redis GUI that is available for macOS, Windows, and Linux 
+
+- An application using a Redis client library, such as [`redis-py`](https://github.com/redis/redis-py) for Python. See the [client list]({{< relref "/develop/clients" >}}) to view all Redis clients by language.
+
+### Connect with redis-cli
+
+Connect to your database with `redis-cli` (located in the `/opt/redislabs/bin` directory), then store and retrieve a key:
+
+```sh
+$ redis-cli -h <endpoint> -p <port>
+127.0.0.1:16653> set key1 123
+OK
+127.0.0.1:16653> get key1
+"123"
+```
+
+For more `redis-cli` connection examples, see the [`redis-cli` reference]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}).
+
+### Connect with Redis Insight
+
+Redis Insight is a free Redis GUI that is available for macOS, Windows, and Linux.
+
+1. [Install Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+1. Open Redis Insight and select **Add Redis Database**.
+
+1. Enter the host and port in the **Host** and **Port** fields.
+
+1. Select **Use TLS** if [TLS]({{< relref "/operate/rs/security/encryption/tls" >}}) is set up.
+
+1. Select **Add Redis Database** to connect to the database.
+
+See the [Redis Insight documentation]({{< relref "/develop/tools/insight" >}}) for more information.
+
+### Connect with Python
+
+Python applications can connect
+to the database using the `redis-py` client library. For installation instructions, see the
+[`redis-py` README](https://github.com/redis/redis-py#readme) on GitHub.
+
+1. From the command line, create a new file called
+`redis_test.py`:
+
+    ```sh
+    vi redis_test.py
+    ```
+
+1. Paste the following code in `redis_test.py`, and replace `<host>` and `<port>` with your database's endpoint details:
+
+    ```python
+    import redis
+
+    # Connect to the database
+    r = redis.Redis(host='<host>', port=<port>)
+
+    # Store a key
+    print("set key1 123")
+    print(r.set('key1', '123'))
+
+    # Retrieve the key
+    print("get key1")
+    print(r.get('key1'))
+    ```
+
+1. Run the application:
+
+    ```sh
+    python redis_test.py
+    ```
+
+1. If the application successfully connects to your database, it outputs: 
+
+    ```sh
+    set key1 123
+    True
+    get key1
+    123
+    ```
+### Connect with discovery service
+
+You can also connect a Python application to the database using the discovery service, which complies with the Redis Sentinel API.
+
+In the IP-based connection method, you only need the database name, not the port number.
+The following example uses the discovery service that listens on port 8001 on all nodes of the cluster
+to discover the endpoint for the database named "db1".
+
+```python
+from redis.sentinel import Sentinel
+
+# with IP based connections, a list of known node IP addresses is constructed
+# to allow connection even if any one of the nodes in the list is unavailable.
+sentinel_list = [
+('10.0.0.44', 8001),
+('10.0.0.45', 8001),
+('10.0.0.46', 8001)
+]
+
+# change this to the db name you want to connect
+db_name = 'db1'
+
+sentinel = Sentinel(sentinel_list, socket_timeout=0.1)
+r = sentinel.master_for(db_name, socket_timeout=0.1)
+
+# set key "foo" to value "bar"
+print(r.set('foo', 'bar'))
+# set value for key "foo"
+print(r.get('foo'))
+```
+
+For more `redis-py` connection examples, see the [`redis-py` developer documentation](https://redis-py.readthedocs.io/en/stable/examples/connection_examples.html).
+---
+Title: Supported connection clients
+categories:
+- docs
+- operate
+- rs
+description: Info about Redis client libraries and supported clients when using the
+  discovery service.
+weight: 10
+---
+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]({{< relref "/develop/clients" >}}) appropriate for your programming language.
+
+You can also use the `redis-cli` utility to connect to a database from the command line.
+
+For examples of each approach, see the [Redis Enterprise Software quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}).
+
+Note: You cannot use client libraries to configure Redis Enterprise Software.  Instead, use:
+
+- The Redis Enterprise Software [Cluster Manager UI]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- The [REST API]({{< relref "/operate/rs/references/rest-api" >}})
+- Command-line utilities, such as [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}})
+
+### Discovery service
+
+We recommend the following clients when using a [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}) based on the Redis Sentinel API:
+
+- [redis-py]({{< relref "/develop/clients/redis-py" >}}) (Python client)
+- [NRedisStack]({{< relref "/develop/clients/dotnet" >}}) (.NET client)
+- [Jedis]({{< relref "/develop/clients/jedis" >}}) (synchronous Java client)
+- [Lettuce]({{< relref "/develop/clients/lettuce" >}}) (asynchronous Java client)
+- [go-redis]({{< relref "/develop/clients/go" >}}) (Go client)
+- [Hiredis](https://github.com/redis/hiredis) (C client)
+
+If you need to use another client, you can use [Sentinel Tunnel](https://github.com/RedisLabs/sentinel_tunnel)
+to discover the current Redis master with Sentinel and create a TCP tunnel between a local port on the client and the master.
+
+---
+Title: Connect to a database
+categories:
+- docs
+- operate
+- rs
+description: Learn how to connect your application to a Redis database hosted by Redis
+  Enterprise Software and test your connection.
+hideListLinks: true
+linkTitle: Connect
+weight: 20
+---
+
+After you [set up a cluster]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}) and [create a Redis database]({{< relref "/operate/rs/databases/create" >}}), you can connect to your database.
+
+To connect to your database, you need the database endpoint, which includes the cluster name (FQDN) and the database port. To view and copy public and private endpoints for a database in the cluster, see the database’s **Configuration > General** section in the Cluster Manager UI.
+
+{{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+
+If you try to connect with the FQDN, and the database does not respond, try connecting with the IP address. If this succeeds, DNS is not properly configured. To set up DNS, see [Configure cluster DNS]({{< relref "/operate/rs/networking/cluster-dns" >}}).
+
+If you want to secure your connection, set up [TLS]({{< relref "/operate/rs/security/encryption/tls/" >}}).
+
+## Connect to a database
+
+Use one of the following connection methods to connect to your database:
+
+- [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli/" >}}) utility
+
+- [Redis Insight](https://redis.com/redis-enterprise/redis-insight/)
+
+- [Redis client]({{< relref "/develop/clients" >}}) for your preferred programming language
+
+For examples, see [Test client connection]({{< relref "/operate/rs/databases/connect/test-client-connectivity" >}}).
+
+## Continue learning with Redis University
+
+See the [Connect to a database on Redis Software](https://university.redis.io/course/zyxx6fdkcm5ahd) for the course.
+---
+Title: Eviction policy
+alwaysOpen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: The eviction policy determines what happens when a database reaches its
+  memory limit.
+linkTitle: Eviction policy
+weight: 10
+---
+
+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&nbsp;Policy** | **Description** |
+|------------|-----------------|
+|  noeviction | New values aren't saved when memory limit is reached<br/><br/>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.
+
+The default policy for [Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) is _noeviction_ policy.
+
+## Active-Active database eviction
+
+The eviction policy mechanism for Active-Active databases kicks in earlier than for standalone databases because it requires propagation to all participating clusters. 
+The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit. If memory usage continues to rise while the keys are being evicted, the rate of eviction will increase to prevent reaching the Out-of-Memory state.
+As with standalone Redis Enterprise databases, Active-Active eviction is calculated per shard.
+To prevent over eviction, internal heuristics might prevent keys from being evicted when the shard reaches the 80% memory limit.  In such cases, keys will get evicted only when shard memory reaches 100%.
+
+In case of network issues between Active-Active instances, memory can be freed only when all instances are in sync. If there is no communication between participating clusters, it can result in eviction of all keys and the instance reaching an Out-of-Memory state.
+
+{{< note >}}
+Data eviction policies are not supported for Active-Active databases with Auto Tiering .
+{{< /note >}}
+
+## Avoid data eviction
+
+To avoid data eviction, make sure your database is large enough to hold required values.  
+
+For larger databases, consider using [Auto Tiering ]({{< relref "/operate/rs/databases/auto-tiering/" >}}).
+
+Auto Tiering stores actively-used data (also known as _hot data_) in RAM and the remaining data in flash memory (SSD).
+This lets you retain more data while ensuring the fastest access to the most critical data.
+---
+Title: Database memory limits
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: When you set a database's memory limit, you define the maximum size the
+  database can reach.
+linkTitle: Memory limits
+weight: 20
+---
+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:
+
+- **dataset size**: you want your limit to be above your dataset size to leave room for overhead.
+- **database throughput**: high throughput needs more shards, leading to a higher memory limit.
+- [**modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}): using modules with your database consumes more memory.
+- [**database clustering**]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}): enables you to spread your data into shards across multiple nodes.
+- [**database replication**]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}): enabling replication doubles memory consumption.
+
+Additional factors for Active-Active databases:
+
+- [**Active-Active replication**]({{< relref "/operate/rs/databases/active-active/_index.md" >}}): enabling Active-Active replication requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**database replication backlog**]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog/" >}}) for synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/databases/active-active/manage.md" >}}) for synchronization between clusters. By default, this is set to 1% of the database size.
+
+  It's also important to know Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit.
+
+Additional factors for  databases with Auto Tiering enabled:
+
+- The available flash space must be greater than or equal to the total database size (RAM+Flash). The extra space accounts for write buffers and [write amplification](https://en.wikipedia.org/wiki/Write_amplification).
+
+- [**database persistence**]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}): Auto Tiering uses dual database persistence where both the primary and replica shards persist to disk. This may add some processor and network overhead, especially in cloud configurations with network attached storage.
+
+## What happens when Redis Enterprise Software is low on RAM?
+
+Redis Enterprise Software manages node memory so that data is entirely in RAM (unless using Auto Tiering). If not enough RAM is available, Redis Enterprise prevents adding more data into the databases.
+
+Redis Enterprise Software protects the existing data and prevents the database from being able to store data into the shards.
+
+You can configure the cluster to move the data to another node, or even discard it according to the [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}}) set on each database by the administrator.
+
+[Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}})
+manages memory so that you can also use flash memory (SSD) to store data.
+
+### Order of events for low RAM
+
+1. If there are other nodes available, your shards migrate to other nodes.
+2. If the eviction policy allows eviction, shards start to release memory,
+which can result in data loss.
+3. If the eviction policy does not allow eviction, you'll receive
+out of memory (OOM) messages.
+4. If shards can't free memory, Redis Enterprise relies on the OS processes to stop replicas,
+but tries to avoid stopping primary shards.
+
+We recommend that you have a [monitoring platform]({{< relref "/operate/rs/monitoring/" >}}) that alerts you before a system gets low on RAM.
+You must maintain sufficient free memory to make sure that you have a healthy Redis Enterprise installation.
+
+## Memory metrics
+
+The Cluster Manager UI provides metrics that can help you evaluate your memory use.
+
+- Free RAM
+- RAM fragmentation
+- Used memory
+- Memory usage
+- Memory limit
+
+See [console metrics]({{< relref "/operate/rs/references/metrics" >}}) for more detailed information.
+
+## Related info
+
+- [Memory and performance]({{< relref "/operate/rs/databases/memory-performance" >}})
+- [Disk sizing for heavy write scenarios]({{< relref "/operate/rs/clusters/optimize/disk-sizing-heavy-write-scenarios.md" >}})
+- [Turn off services to free system memory]({{< relref "/operate/rs/clusters/optimize/turn-off-services.md" >}})
+- [Eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}})
+- [Shard placement policy]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy.md" >}})
+- [Database persistence]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}})
+---
+Title: Shard placement policy
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Detailed info about the shard placement policy.
+linkTitle: Shard placement policy
+weight: 30
+---
+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.
+
+{{< embed-md "shard-placement-intro.md"  >}}
+
+## Shard placement policies
+
+### Dense shard placement policy
+
+In the dense policy, the cluster places the database shards on as few nodes as possible.
+When the node is not able to host all of the shards, some shards are moved to another node to maintain optimal node health.
+
+For example, for a database with two master and two replica shards on a cluster with three nodes and a dense shard placement policy,
+the two master shards are hosted on one node and the two replica shards are hosted on another node.
+
+For Redis on RAM databases without the OSS cluster API enabled, use the dense policy to optimize performance.
+
+{{< image filename="/images/rs/dense_placement.png" >}}
+
+*Figure: Three nodes with two master shards (red) and two replica shards (white) with a dense placement policy*
+
+### Sparse shard placement policy
+
+In the sparse policy, the cluster places shards on as many nodes as possible to distribute the shards of a database across all available nodes.
+When all nodes have database shards, the shards are distributed evenly across the nodes to maintain optimal node health.
+
+For example, for a database with two master and two replica shards on a cluster with three nodes and a sparse shard placement policy:
+
+- Node 1 hosts one of the master shards
+- Node 2 hosts the replica for the first master shard
+- Node 3 hosts the second master shard
+- Node 1 hosts for the replica shard for master shard 2
+
+For Redis on RAM databases with OSS cluster API enabled and for databases with Auto Tiering enabled, use the sparse policy to optimize performance.
+
+{{< image filename="/images/rs/sparse_placement.png" >}}
+
+*Figure: Three nodes with two master shards (red) and two replica shards (white) with a sparse placement policy*
+
+## Related articles
+
+You can [configure the shard placement policy]({{< relref "/operate/rs/databases/configure/shard-placement.md" >}}) for each database.
+---
+Title: Memory and performance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Learn more about managing your memory and optimizing performance for
+  your database.
+hideListLinks: true
+linktitle: Memory and performance
+weight: 70
+---
+Redis Enterprise Software has multiple mechanisms in its
+architecture to help optimize storage and performance.
+
+## Memory limits
+
+Database memory limits define the maximum size your database can reach across all database replicas and [shards]({{< relref "/glossary#letter-s" >}}) on the cluster. Your memory limit will also determine the number of shards you'll need.
+
+Besides your dataset, the memory limit must also account for replication, Active-Active overhead, and module overhead, and a number of other factors. These can significantly increase your database size, sometimes increasing it by four times or more.
+
+For more information on memory limits, see [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}).
+
+## Eviction policies
+
+When a database exceeds its memory limit, eviction policies determine which data is removed. The eviction policy removes keys based on frequency of use, how recently used, randomly, expiration date, or a combination of these factors. The policy can also be set to `noeviction` to return a memory limit error when trying to insert more data.
+
+The default eviction policy for databases is `volatile-lru` which evicts the least recently used keys out of all keys with the `expire` field set. The default for Active-Active databases is `noeviction`.
+
+For more information, see [eviction policies]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}}).
+
+## Database persistence
+
+Both RAM memory and flash memory are at risk of data loss if a server or process fails. Persisting your data to disk helps protect it against loss in those situations. You can configure persistence at the time of database creation, or by editing the database’s configuration.
+
+There are two main types of persistence strategies in Redis Enterprise Software: append-only files (AoF) and snapshots.
+
+Append-only files (AoF) keep a record of data changes and writes each change to the end of a file, allowing you to recover the dataset by replaying the writes in the append-only log.
+
+Snapshots capture all the data as it exists in one moment in time and writes it to disk, allowing you to recover the entire dataset as it existed at that moment in time.
+
+For more info on data persistence see [Database persistence with Redis Enterprise Software]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}) or [Durable Redis](https://redis.com/redis-enterprise/technology/durable-redis/).
+
+## Auto Tiering 
+
+By default, Redis Enterprise Software stores your data entirely in [RAM](https://en.wikipedia.org/wiki/Random-access_memory) for improved performance. The [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) feature enables your data to span both RAM and [SSD](https://en.wikipedia.org/wiki/Solid-state_drive) storage ([flash memory](https://en.wikipedia.org/wiki/Flash_memory)). Keys are always stored in RAM, but Auto Tiering manages the location of their values. Frequently used (hot) values are stored on RAM, but infrequently used (warm) values are moved to flash memory. This saves on expensive RAM space, which give you comparable performance at a lower cost for large datasets.
+
+For more info, see [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}).
+
+## Shard placement
+
+The location of the primary and replica shards on the cluster nodes can impact your database performance.
+Primary shards and their corresponding replica shards are always placed on separate nodes for data resiliency and high availability.
+The shard placement policy helps to maintain optimal performance and resiliency.
+
+Redis Enterprise Software has two shard placement policies available:
+
+- **dense**: puts as many shards as possible on the smallest number of nodes
+- **sparse**: spread the shards across as many nodes as possible
+
+For more info about the shard placement policy, see [Shard placement policy]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy.md" >}})
+
+## Metrics
+
+From the Redis Enterprise Software Cluster Manager UI, you can monitor the performance of your clusters, nodes, databases, and shards with real-time metrics. You can also enable alerts for node, cluster, or database events such as high memory usage or throughput.
+
+With the Redis Enterprise Software API, you can also integrate Redis Enterprise metrics into other monitoring environments, such as Prometheus.
+
+For more info about monitoring with Redis Enterprise Software, see [Monitoring with metrics and alerts]({{< relref "/operate/rs/monitoring" >}}), and [Memory statistics]({{< relref "/operate/rs/databases/memory-performance/memory-limit#memory-metrics" >}}).
+
+## Scaling databases
+
+Each Redis Enterprise cluster can contain multiple databases. In Redis,
+databases represent data that belong to a single application, tenant, or
+microservice. Redis Enterprise is built to scale to 100s of databases
+per cluster to provide flexible and efficient multi-tenancy models.
+
+Each database can contain few or many Redis shards. Sharding is
+transparent to Redis applications. Master shards in the database process
+data operations for a given subset of keys. The number of shards per
+database is configurable and depend on the throughput needs of the
+applications. Databases in Redis Enterprise can be resharded into more
+Redis shards to scale throughput while maintaining sub-millisecond
+latencies. Resharding is performed without downtime.
+
+{{< image filename="/images/rs/sharding.png" >}}
+
+Redis Enterprise places master shards and replicas in separate
+nodes, racks, and zones, and uses in-memory replication to protect data
+against failures.
+
+In Redis Enterprise, each database has a quota of RAM. The quota cannot
+exceed the limits of the RAM available on the node. However, with Redis
+Enterprise Flash, RAM is extended to the local flash drive (SATA, NVMe
+SSDs etc). The total quota of the database can take advantage of both
+RAM and Flash drive. The administrator can choose the RAM vs Flash ratio
+and adjust that anytime in the lifetime of the database without
+downtime.
+
+With Auto Tiering, instead of storing all keys and data for a
+given shard in RAM, less frequently accessed values are pushed to flash.
+If applications need to access a value that is in flash, Redis
+Enterprise automatically brings the value into RAM. Depending on the
+flash hardware in use, applications experience slightly higher latency
+when bringing values back into RAM from flash. However subsequent
+accesses to the same value is fast, once the value is in RAM.
+
+## Client-side caching
+
+Client-side caching allows Redis clients to store a subset of data in a local cache and avoid sending repeated requests to the Redis database. When used to cache frequently accessed data, this technique can improve performance by decreasing network traffic, latency, and load on the database. For more information about client-side caching, see the [client-side caching introduction]({{<relref "/develop/clients/client-side-caching">}}).
+
+Redis Software supports client-side caching for databases with Redis versions 7.4 and later. See [Client-side caching compatibility with Redis Software]({{<relref "/operate/rs/references/compatibility/client-side-caching">}}) for more information about compatibility and configuration options.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This page will help you find database management information in the Databases
+  section.
+hideListLinks: false
+linktitle: Databases
+title: Manage databases
+weight: 37
+---
+
+You can manage your Redis Enterprise Software databases with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}), [`redis-cli`]({{< relref "/develop/tools/cli" >}}), [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/references/rest-api/_index.md" >}})
+
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+db_type: database
+description: How to migrate database shards to other nodes in a Redis Software cluster.
+linkTitle: Migrate shards
+title: Migrate database shards
+toc: 'true'
+weight: 32
+---
+
+To migrate database shards to other nodes in the cluster, you can use the [`rladmin migrate`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate">}}) command or [REST API requests]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate">}}).
+
+## Use cases for shard migration
+
+Migrate database shards to a different node in the following scenarios:
+
+- Before node removal.
+
+- To balance the database manually in case of latency issues or uneven load distribution across nodes.
+
+- To manage node resources, such as memory usage.
+
+## Considerations for shard migration
+
+For databases with replication:
+
+- Migrating a shard will not cause disruptions since a primary shard will still be available.
+
+- If you try to migrate a primary shard, it will be demoted to a replica shard and a replica shard will be promoted to primary before the migration. If you set `"preserve_roles": true` in the request, a second failover will occur after the migration finishes to change the migrated shard's role back to primary.
+
+For databases without replication, the migrated shard will not be available until the migration is done.
+
+Connected clients shouldn't be disconnected in either case.
+
+If too many primary shards are placed on the same node, it can impact database performance.
+
+## Migrate specific shard
+
+To migrate a specific database shard, use one of the following methods:
+
+- [`rladmin migrate shard`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate#migrate-shard">}}):
+
+    ```sh
+    rladmin migrate shard <shard_id> target_node <node_id>
+    ```
+
+- [Migrate shard]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-shard">}}) REST API request:
+
+    Specify the ID of the shard to migrate in the request path and the destination node's ID as the `target_node_uid` in the request body. See the [request reference]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-request-body">}}) for more options.
+
+    ```sh
+    POST /v1/shards/<shard_id>/actions/migrate
+    {
+        "target_node_uid": <node_id>
+    }
+    ```
+
+    Example JSON response body:
+
+    ```json
+    {
+        "action_uid": "<action_id>",
+        "description": "Migrate was triggered"
+    }
+    ```
+
+    You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+## Migrate multiple shards
+
+To migrate multiple database shards, use one of the following methods:
+
+- [`rladmin migrate shard`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate#migrate-shard">}}):
+
+    ```sh
+    rladmin migrate shard <shard_id1> <shard_id2> <shard_id3> target_node <node_id>
+    ```
+
+- [Migrate multiple shards]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-multi-shards">}}) REST API request:
+
+    Specify the IDs of the shards to migrate in the `shard_uids` list and the destination node's ID as the `target_node_uid` in the request body. See the [request reference]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-multi-request-body">}}) for more options.
+
+    ```sh
+    POST /v1/shards/actions/migrate
+    {
+        "shard_uids": ["<shard_id1>","<shard_id2>","<shard_id3>"],
+        "target_node_uid": <node_id>
+    }
+    ```
+
+    Example JSON response body:
+
+    ```json
+    {
+        "action_uid": "<action_id>",
+        "description": "Migrate was triggered"
+    }
+    ```
+
+    You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+## Migrate all shards from a node
+
+To migrate all shards from a specific node to another node, run [`rladmin migrate all_shards`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate#migrate-all_shards">}}):
+
+```sh
+rladmin migrate node <origin_node_id> all_shards target_node <node_id>
+```
+
+## Migrate primary shards
+
+You can use the [`rladmin migrate all_master_shards`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate#migrate-all_master_shards">}}) command to migrate all primary shards for a specific database or node to another node in the cluster.
+
+To migrate a specific database's primary shards:
+
+```sh
+rladmin migrate db db:<id> all_master_shards target_node <node_id>
+```
+
+To migrate all primary shards from a specific node:
+
+```sh
+rladmin migrate node <origin_node_id> all_master_shards target_node <node_id>
+```
+
+## Migrate replica shards
+
+You can use the [`rladmin migrate all_slave_shards`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate#migrate-all_slave_shards">}}) command to migrate all replica shards for a specific database or node to another node in the cluster.
+
+To migrate a specific database's replica shards:
+
+```sh
+rladmin migrate db db:<id> all_slave_shards target_node <node_id>
+```
+
+To migrate all replica shards from a specific node:
+
+```sh
+rladmin migrate node <origin_node_id> all_slave_shards target_node <node_id>
+```
+---
+Title: Considerations for planning Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Information about Active-Active database to take into consideration while
+  planning a deployment, such as compatibility, limitations, and special configuration
+linktitle: Planning considerations
+weight: 22
+url: '/operate/rs/7.4/databases/active-active/planning/'
+---
+
+In Redis Enterprise, Active-Active geo-distribution is based on [conflict-free replicated data type (CRDT) technology](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type). 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]({{< relref "/operate/rs/7.4/databases/active-active/" >}}) for more information about geo-distributed replication. For more info on other high availability features, see [Durability and high availability]({{< relref "/operate/rs/7.4/databases/durability-ha/" >}}).
+
+## Participating clusters
+
+You need at least [two participating clusters]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup" >}}) for an Active-Active database. If your database requires more than ten participating clusters, contact Redis support. You can [add or remove participating clusters]({{< relref "/operate/rs/7.4/databases/active-active/manage#participating-clusters/" >}}) after database creation.
+
+{{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/7.4/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+{{</note>}}
+
+Changes made from the Cluster Manager UI to an Active-Active database configuration only apply to the cluster you are editing. For global configuration changes across all clusters, use the `crdb-cli` command-line utility.
+
+## Memory limits
+
+Database memory limits define the maximum size of your database across all database replicas and [shards]({{< relref "/operate/rs/7.4/references/terminology.md#redis-instance-shard" >}}) on the cluster. Your memory limit also determines the number of shards.
+
+Besides your dataset, the memory limit must also account for replication, Active-Active metadata, and module overhead. These features can increase your database size, sometimes increasing it by two times or more.
+
+Factors to consider when sizing your database:
+
+- **dataset size**: you want your limit to be above your dataset size to leave room for overhead.
+- **database throughput**: high throughput needs more shards, leading to a higher memory limit.
+- [**modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}): using modules with your database can consume more memory.
+- [**database clustering**]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}): enables you to spread your data into shards across multiple nodes (scale out).
+- [**database replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}): enabling replication doubles memory consumption
+- [**Active-Active replication**]({{< relref "/operate/rs/7.4/databases/active-active/_index.md" >}}): enabling Active-Active replication requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**database replication backlog**]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog/" >}}) for synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/7.4/databases/active-active/manage.md" >}}) for synchronization between clusters. By default, this is set to 1% of the database size.
+
+It's also important to know Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit. 
+
+For more information on memory limits, see [Memory and performance]({{< relref "/operate/rs/7.4/databases/memory-performance/" >}}) or [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}).
+
+## Networking
+
+Network requirements for Active-Active databases include:
+
+- A VPN between each network that hosts a cluster with an instance (if your database spans WAN).
+- A network connection to [several ports](#network-ports) on each cluster from all nodes in all participating clusters.
+- A [network time service](#network-time-service) running on each node in all clusters.
+
+Networking between the clusters must be configured before creating an Active-Active database. The setup will fail if there is no connectivity between the clusters.
+
+### Network ports
+
+Every node must have access to the REST API ports of every other node as well as other ports for proxies, VPNs, and the Cluster Manager UI. See [Network port configurations]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}) for more details. These ports should be allowed through firewalls that may be positioned between the clusters.
+
+### Network Time Service {#network-time-service}
+
+Active-Active databases require a time service like NTP or Chrony to make sure the clocks on all cluster nodes are synchronized.
+This is critical to avoid problems with internal cluster communications that can impact your data integrity.
+
+See [Synchronizing cluster node clocks]({{< relref "/operate/rs/7.4/clusters/configure/sync-clocks.md" >}}) for more information.
+
+## Redis modules {#redis-modules}
+
+Several Redis modules are compatible with Active-Active databases. Find the list of [compatible Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}).
+{{< note >}}
+Starting with v6.2.18, you can index, query, and perform full-text searches of nested JSON documents in Active-Active databases by combining RedisJSON and RediSearch.
+{{< /note >}}
+
+## Limitations
+
+Active-Active databases have the following limitations:
+
+- An existing database can't be changed into an Active-Active database. To move data from an existing database to an Active-Active database, you must [create a new Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/create.md" >}}) and [migrate the data]({{< relref "/operate/rs/7.4/databases/import-export/migrate-to-active-active.md" >}}).
+- [Discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}) is not supported with Active-Active databases. Active-Active databases require FQDNs or [mDNS]({{< relref "/operate/rs/7.4/networking/mdns.md" >}}).
+- The `FLUSH` command is not supported from the CLI. To flush your database, use the API or Cluster Manager UI.
+- The `UNLINK` command is a blocking command for all types of keys.
+- Cross slot multi commands (such as `MSET`) are not supported with Active-Active databases.
+- The hashing policy can't be changed after database creation.
+- If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/7.4/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+---
+Title: Application failover with Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: How to failover your application to connect to a remote replica.
+linkTitle: App failover
+weight: 99
+url: '/operate/rs/7.4/databases/active-active/develop/app-failover-active-active/'
+---
+Active-Active Redis deployments don't have a built-in failover or failback mechanism for application connections.
+An application deployed with an Active-Active database connects to a replica of the database that is geographically nearby.
+If that replica is not available, the application can failover to a remote replica, and failback again if necessary.
+In this article we explain how this process works.
+
+Active-Active connection failover can improve data availability, but can negatively impact data consistency.
+Active-Active replication, like Redis replication, is asynchronous.
+An application that fails over to another replica can miss write operations.
+If the failed replica saved the write operations in persistent storage,
+then the write operations are processed when the failed replica recovers.
+
+## Detecting Failure
+
+Your application can detect two types of failure:
+
+1. **Local failures** - The local replica is down or otherwise unavailable
+1. **Replication failures** - The local replica is available but fails to replicate to or from remote replicas
+
+### Local Failures
+
+Local failure is detected when the application is unable to connect to the database endpoint for any reason. Reasons for a local failure can include: multiple node failures, configuration errors, connection refused, connection timed out, unexpected protocol level errors.
+
+### Replication Failures
+
+Replication failures are more difficult to detect reliably without causing false positives. Replication failures can include: network split, replication configuration issues, remote replica failures.
+
+The most reliable method for health-checking replication is by using the Redis publish/subscribe (pub/sub) mechanism.
+
+{{< note >}}
+Note that this document does not suggest that Redis pub/sub is reliable in the common sense. Messages can get lost in certain conditions, but that is acceptable in this case because typically the application determines that replication is down only after not being able to deliver a number of messages over a period of time.
+{{< /note >}}
+
+When you use the pub/sub data type to detect failures, the application:
+
+1. Connects to all replicas and subscribes to a dedicated channel for each replica.
+1. Connects to all replicas and periodically publishes a uniquely identifiable message.
+1. Monitors received messages and ensures that it is able to receive its own messages within a predetermined window of time.
+
+You can also use known dataset changes to monitor the reliability of the replication stream,
+but pub/sub is preferred method because:
+
+1. It does not involve dataset changes.
+1. It does not make any assumptions about the dataset.
+1. Pub/sub messages are delivered as replicated effects and are a more reliable indicator of a live replication link. In certain cases, dataset keys may appear to be modified even if the replication link fails. This happens because keys may receive updates through full-state replication (re-sync) or through online replication of effects. 
+
+## Impact of sharding on failure detection
+
+If your sharding configuration is symmetric, make sure to use at least one key (PUB/SUB channels or real dataset key) per shard. Shards are replicated individually and are vulnerable to failure. Symmetric sharding configurations have the same number of shards and hash slots for all replicas.
+We do not recommend an asymmetric sharding configuration, which requires at least one key per hash slot that intersects with a pair of shards.
+
+To make sure that there is at least one key per shard, the application should:
+
+1. Use the Cluster API to retrieve the database sharding configuration.
+1. Compute a number of key names, such that there is one key per shard.
+1. Use those key names as channel names for the pub/sub mechanism.
+
+### Failing over
+
+When the application needs to failover to another replica, it should simply re-establish its connections with the endpoint on the remote replica. Because Active/Active and Redis replication are asynchronous, the remote endpoint may not have all of the locally performed and acknowledged writes.
+
+It's best if your application doesn't read its own recent writes. Those writes can be either:
+
+1. Lost forever, if the local replica has an event such as a double failure or loss of persistent files.
+1. Temporarily unavailable, but will be available at a later time if the local replica's failure is temporary.
+
+<!--- {{< note >}}
+Sample code that maps a hash slot to a key name can be found in this Python script.
+{{< /note >}} --->
+
+## Failback decision
+
+Your application can use the same checks described above to continue monitoring the state of the failed replica after failover.
+
+To monitor the state of a replica during the failback process, you must make sure the replica is available, re-synced with the remote replicas, and not in stale mode. The PUB/SUB mechanism is an effective way to monitor this.
+
+Dataset-based mechanisms are potentially less reliable for several reasons:
+1. In order to determine that a local replica is not stale, it is not enough to simply read keys from it. You must also attempt to write to it.
+1. As stated above, remote writes for some keys appear in the local replica before the replication link is back up and while the replica is still in stale mode.
+1. A replica that was never written to never becomes stale, so on startup it is immediately ready but serves stale data for a longer period of time.
+
+## Replica Configuration Changes
+
+All failover and failback operations should be done strictly on the application side, and should not involve changes to the Active-Active configuration.
+The only valid case for re-configuring the Active-Active deployment and removing a replica is when memory consumption becomes too high because garbage collection cannot be performed.
+Once a replica is removed, it can only be re-joined as a new replica and it loses any writes that were not converged.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Overview of how developing applications differs for Active-Active databases
+  from standalone Redis databases.
+linkTitle: Develop for Active-Active
+title: Develop applications with Active-Active databases
+weight: 10
+url: '/operate/rs/7.4/databases/active-active/develop/develop-for-aa/'
+---
+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.
+
+|  **Time** | **Member CRDB1** | **Member CRDB2** |
+|  :------: | :------: | :------: |
+|  t1 | INCRBY key1 7 |  |
+|  t2 |  | INCRBY key1 3 |
+|  t3 | GET key1<br/>7 | GET key1<br/>3 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | GET key1<br/>10 | GET key1<br/>10 |
+|  t6 | DECRBY key1 3 |  |
+|  t7 |  | INCRBY key1 6 |
+|  t8 | — Sync — | — Sync — |
+|  t9 | GET key1<br/>13 | GET key1<br/>13 |
+
+Databases provide various approaches to address some of these concerns:
+
+- Active-Passive Geo-distributed deployments: With active-passive
+    distributions, all writes go to an active cluster. Redis Enterprise
+    provides a "Replica Of" capability that provides a similar approach.
+    This can be employed when the workload is heavily balanced towards
+    read and few writes. However, WAN performance and availability
+    is quite flaky and traveling large distances for writes take away
+    from application performance and availability.
+- Two-phase Commit (2PC): This approach is designed around a protocol
+    that commits a transaction across multiple transaction managers.
+    Two-phase commit provides a consistent transactional write across
+    regions but fails transactions unless all participating transaction
+    managers are "available" at the time of the transaction. The number
+    of messages exchanged and its cross-regional availability
+    requirement make two-phase commit unsuitable for even moderate
+    throughputs and cross-geo writes that go over WANs.
+- Sync update with Quorum-based writes: This approach synchronously
+    coordinates a write across majority number of replicas across
+    clusters spanning multiple regions. However, just like two-phase
+    commit, number of messages exchanged and its cross-regional
+    availability requirement make geo-distributed quorum writes
+    unsuitable for moderate throughputs and cross geo writes that go
+    over WANs.
+- Last-Writer-Wins (LWW) Conflict Resolution: Some systems provide
+    simplistic conflict resolution for all types of writes where the
+    system clocks are used to determine the winner across conflicting
+    writes. LWW is lightweight and can be suitable for simpler data.
+    However, LWW can be destructive to updates that are not necessarily
+    conflicting. For example adding a new element to a set across two
+    geographies concurrently would result in only one of these new
+    elements appearing in the final result with LWW.
+- MVCC (multi-version concurrency control): MVCC systems maintain
+    multiple versions of data and may expose ways for applications to
+    resolve conflicts. Even though MVCC system can provide a flexible
+    way to resolve conflicting writes, it comes at a cost of great
+    complexity in the development of a solution.
+
+Even though types and commands in Active-Active databases look identical to standard Redis
+types and commands, the underlying types in RS are enhanced to maintain
+more metadata to create the conflict-free data type experience. This
+section explains what you need to know about developing with Active-Active databases on
+Redis Enterprise Software.
+
+## Lua scripts
+
+Active-Active databases support Lua scripts, but unlike standard Redis, Lua scripts always
+execute in effects replication mode. There is currently no way to
+execute them in script-replication mode.
+
+## Eviction
+
+The default policy for Active-Active databases is _noeviction_ mode. Redis Enterprise version 6.0.20 and later support all eviction policies for Active-Active databases, unless [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering" >}})(previously known as Redis on Flash) is enabled.
+For details, see [eviction for Active-Active databases]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy#active-active-database-eviction" >}}).
+
+
+## Expiration
+
+Expiration is supported with special multi-master semantics.
+
+If a key's expiration time is changed at the same time on different
+members of the Active-Active database, the longer extended time set via TTL on a key is
+preserved. As an example:
+
+If this command was performed on key1 on cluster #1
+
+```sh
+127.0.0.1:6379> EXPIRE key1 10
+```
+
+And if this command was performed on key1 on cluster #2
+
+```sh
+127.0.0.1:6379> EXPIRE key1 50
+```
+
+The EXPIRE command setting the key to 50 would win.
+
+And if this command was performed on key1 on cluster #3:
+
+```sh
+127.0.0.1:6379> PERSIST key1
+```
+
+It would win out of the three clusters hosting the Active-Active database as it sets the
+TTL on key1 to an infinite time.
+
+The replica responsible for the "winning" expire value is also
+responsible to expire the key and propagate a DEL effect when this
+happens. A "losing" replica is from this point on not responsible
+for expiring the key, unless another EXPIRE command resets the TTL.
+Furthermore, a replica that is NOT the "owner" of the expired value:
+
+- Silently ignores the key if a user attempts to access it in READ
+    mode, e.g. treating it as if it was expired but not propagating a
+    DEL.
+- Expires it (sending a DEL) before making any modifications if a user
+    attempts to access it in WRITE mode.
+    
+    {{< note >}}
+Expiration values are in the range of [0,&nbsp;2^49] for Active-Active databases and [0,&nbsp;2^64] for non Active-Active databases.
+    {{< /note >}}
+
+## Out-of-Memory (OOM) {#outofmemory-oom}
+
+If a member Active-Active database is in an out of memory situation, that member is marked
+"inconsistent" by RS, the member stops responding to user traffic, and
+the syncer initiates full reconciliation with other peers in the Active-Active database.
+
+## Active-Active Database Key Counts
+
+Keys are counted differently for Active-Active databases:
+
+- DBSIZE (in `shard-cli dbsize`) reports key header instances
+    that represent multiple potential values of a key before a replication conflict is resolved.
+- expired_keys (in `bdb-cli info`) can be more than the keys count in DBSIZE (in `shard-cli dbsize`) 
+    because expires are not always removed when a key becomes a tombstone.
+    A tombstone is a key that is logically deleted but still takes memory
+    until it is collected by the garbage collector.
+- The Expires average TTL (in `bdb-cli info`) is computed for local expires only.
+
+## INFO
+
+The INFO command has an additional crdt section which provides advanced
+troubleshooting information (applicable to support etc.):
+
+|  **Section** | **Field** | **Description** |
+|  ------ | ------ | ------ |
+|  **CRDT Context** | crdt_config_version | Currently active Active-Active database configuration version. |
+|   | crdt_slots | Hash slots assigned and reported by this shard. |
+|   | crdt_replid | Unique Replica/Shard IDs. |
+|   | crdt_clock | Clock value of local vector clock. |
+|   | crdt_ovc | Locally observed Active-Active database vector clock. |
+|  **Peers** | A list of currently connected Peer Replication peers. This is similar to the slaves list reported by Redis. |  |
+|  **Backlogs** | A list of Peer Replication backlogs currently maintained. Typically in a full mesh topology only a single backlog is used for all peers, as the requested Ids are identical. |  |
+|  **CRDT Stats** | crdt_sync_full | Number of inbound full synchronization processes performed. |
+|   | crdt_sync_partial_ok | Number of partial (backlog based) re-synchronization processes performed. |
+|   | crdt_sync_partial-err | Number of partial re-synchronization processes failed due to exhausted backlog. |
+|   | crdt_merge_reqs | Number of inbound merge requests processed. |
+|   | crdt_effect_reqs | Number of inbound effect requests processed. |
+|   | crdt_ovc_filtered_effect_reqs | Number of inbound effect requests filtered due to old vector clock. |
+|   | crdt_gc_pending | Number of elements pending garbage collection. |
+|   | crdt_gc_attempted | Number of attempts to garbage collect tombstones. |
+|   | crdt_gc_collected | Number of tombstones garbaged collected successfully. |
+|   | crdt_gc_gvc_min | The minimal globally observed vector clock, as computed locally from all received observed clocks. |
+|   | crdt_stale_released_with_merge | Indicates last stale flag transition was a result of a complete full sync. |
+|  **CRDT Replicas** | A list of crdt_replica \<uid> entries, each describes the known state of a remote instance with the following fields: |  |
+|   | config_version | Last configuration version reported. |
+|   | shards | Number of shards. |
+|   | slots | Total number of hash slots. |
+|   | slot_coverage | A flag indicating remote shards provide full coverage (i.e. all shards are alive). |
+|   | max_ops_lag | Number of local operations not yet observed by the least updated remote shard |
+|   | min_ops_lag | Number of local operations not yet observed by the most updated remote shard |
+---
+Title: Sorted sets in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using sorted sets with an Active-Active database.
+linkTitle: Sorted sets
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/sorted-sets/'
+---
+{{< note >}}
+[Redis Geospatial (Geo)]({{< relref "/commands/GEOADD" >}}) is based on Sorted Sets, so the same Active-Active database development instructions apply to Geo.
+{{< /note >}}
+
+Similar to Redis Sets, Redis Sorted Sets are non-repeating collections
+of Strings. The difference between the two is that every member of a
+Sorted Set is associated with a score used to order the Sorted Set from
+lowest to highest. While members are unique, they may have the same
+score.
+
+With Sorted Sets, you can quickly add, remove or update elements as
+well as get ranges by score or by rank (position). Sorted Sets in Active-Active databases
+behave the same and maintain additional metadata to handle concurrent
+conflicting writes. Conflict resolution is done in two
+phases:
+
+1. First, the database resolves conflict at the set level using "OR
+    Set" (Observed-Remove Set). With OR-Set behavior, writes across
+    multiple Active-Active database instances are typically unioned except in cases of
+    conflicts. Conflicting writes can happen when an Active-Active database instance
+    deletes an element while the other adds or updates the same element.
+    In this case, an observed Remove rule is followed, and only
+    instances it has already seen are removed. In all other cases, the
+    Add / Update element wins.
+1. Second, the database resolves conflict at the score level. In this
+    case, the score is treated as a counter and applies the same
+    conflict resolution as regular counters.
+
+See the following examples to get familiar with Sorted Sets'
+behavior in Active-Active database:
+
+Example of Simple Sorted Set with No
+Conflict:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | ZADD Z 1.2 y |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZRANGE Z 0 -1 => x y | ZRANGE Z 0 -1 => x y |
+
+**Explanation**:
+When adding two different elements to a Sorted Set from different
+replicas (in this example, x with score 1.1 was added by Instance 1 to
+Sorted Set Z, and y with score 1.2 was added by Instance 2 to Sorted Set
+Z) in a non-concurrent manner (i.e. each operation happened separately
+and after both instances were in sync), the end result is a Sorted
+Set including both elements in each Active-Active database instance.
+Example of Sorted Set and Concurrent
+Add:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 |  | ZADD Z 2.1 x |
+|  t3 | ZSCORE Z x => 1.1 | ZSCORE Z x => 2.1 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZSCORE Z x => 2.1 | ZSCORE Z x => 2.1 |
+
+**Explanation**:
+When concurrently adding an element x to a Sorted Set Z by two different
+Active-Active database instances (Instance 1 added score 1.1 and Instance 2 added score
+2.1), the Active-Active database implements Last Write Win (LWW) to determine the score of
+x. In this scenario, Instance 2 performed the ZADD operation at time
+t2\>t1 and therefore the Active-Active database sets the score 2.1 to
+x.
+
+Example of Sorted Set with Concurrent Add Happening at the Exact Same
+Time:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x | ZADD Z 2.1 x |
+|  t2 | ZSCORE Z x => 1.1 | ZSCORE Z x => 2.1 |
+|  t3 | — Sync — | — Sync — |
+|  t4 | ZSCORE Z x => 1.1 | ZSCORE Z x => 1.1 |
+
+**Explanation**:
+The example above shows a relatively rare situation, in which two Active-Active database
+instances concurrently added the same element x to a Sorted Set at the
+same exact time but with a different score, i.e. Instance 1 added x with
+a 1.1 score and Instance 2 added x with a 2.1 score. After syncing, the
+Active-Active database realized that both operations happened at the same time and
+resolved the conflict by arbitrarily (but consistently across all Active-Active database
+instances) giving precedence to Instance 1.
+Example of Sorted Set with Concurrent Counter
+Increment:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 1.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | ZINCRBY Z 1.0 x | ZINCRBY Z 1.0 x |
+|  t4 | — Sync — | — Sync — |
+|  t5 | ZSCORE Z x => 3.1 | ZSCORE Z x => 3.1 |
+
+**Explanation**:
+The result is the sum of all
+ZINCRBY
+operations performed by all Active-Active database instances.
+
+Example of Removing an Element from a Sorted
+Set:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | ZADD Z 4.1 x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | ZSCORE Z x => 4.1 | ZSCORE Z x => 4.1 |
+|  t4 | ZREM Z x | ZINCRBY Z 2.0 x |
+|  t5 | ZSCORE Z x => nill | ZSCORE Z x => 6.1 |
+|  t6 | — Sync — | — Sync — |
+|  t7 | ZSCORE Z x => 2.0 | ZSCORE Z x => 2.0 |
+
+**Explanation**:
+At t4 - t5, concurrent ZREM and ZINCRBY operations ran on Instance 1
+and Instance 2 respectively. Before the instances were in sync, the ZREM
+operation could only delete what had been seen by Instance 1, so
+Instance 2 was not affected. Therefore, the ZSCORE operation shows the
+local effect on x. At t7, after both instances were in-sync, the Active-Active database
+resolved the conflict by subtracting 4.1 (the value of element x in
+Instance 1) from 6.1 (the value of element x in Instance 2).
+---
+Title: Strings and bitfields in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using strings and bitfields with an Active-Active database.
+linkTitle: Strings and bitfields
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/strings/'
+---
+Active-Active databases support both strings and bitfields.
+
+{{<note>}}
+Active-Active **bitfield** support was added in RS version 6.0.20.
+{{</note>}}
+
+Changes to both of these data structures will be replicated across Active-Active member databases.
+
+## Replication semantics
+
+Except in the case of [string counters]({{< relref "#string-counter-support" >}}) (see below), both strings and bitfields are replicated using a "last write wins" approach. The reason for this is that strings and bitfields are effectively binary objects. So, unlike with lists, sets, and hashes, the conflict resolution semantics of a given operation on a string or bitfield are undefined.
+
+### How "last write wins" works
+
+A wall-clock timestamp (OS time) is stored in the metadata of every string
+and bitfield operation. If the replication syncer cannot determine the order of operations,
+the value with the latest timestamp wins. This is the only case with Active-Active databases where OS time is used to resolve a conflict.
+
+Here's an example where an update happening to the same key at a later
+time (t2) wins over the update at t1.
+
+|  **Time** | **Region 1** | **Region 2** |
+|  :------: | :------: | :------: |
+|  t1 | SET text “a” |  |
+|  t2 |  | SET text “b” |
+|  t3 | — Sync — | — Sync — |
+|  t4 | SET text “c” |  |
+|  t5 | — Sync — | — Sync — |
+|  t6 |  | SET text “d” |
+
+### String counter support
+
+When you're using a string as counter (for instance, with the [INCR]({{< relref "/commands/incr" >}}) or [INCRBY]({{< relref "/commands/incrby" >}}) commands),
+then conflicts will be resolved semantically.
+
+On conflicting writes, counters accumulate the total counter operations
+across all member Active-Active databases in each sync.
+
+Here's an example of how counter
+values works when synced between two member Active-Active databases. With
+each sync, the counter value accumulates the private increment and
+decrements of each site and maintain an accurate counter across
+concurrent writes.
+
+|  **Time** | **Region 1** | **Region 2** |
+|  :------: | :------: | :------: |
+|  t1 | INCRBY counter 7 |  |
+|  t2 |  | INCRBY counter 3 |
+|  t3 | GET counter<br/>7 | GET counter<br/>3 |
+|  t4 | — Sync — | — Sync — |
+|  t5 | GET counter<br/>10 | GET counter<br/>10 |
+|  t6 | DECRBY counter 3 |  |
+|  t7 |  | INCRBY counter 6 |
+|  t8 | — Sync — | — Sync — |
+|  t9 | GET counter<br/>13 | GET counter<br/>13 |
+
+{{< note >}}
+Active-Active databases support 59-bit counters.
+This limitation is to protect from overflowing a counter in a concurrent operation.
+{{< /note >}}
+---
+Title: Hashes in an Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using hashes with an Active-Active database.
+linkTitle: Hashes
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/hashes/'
+---
+Hashes are great for structured data that contain a map of fields and
+values. They are used for managing distributed user or app session
+state, user preferences, form data and so on. Hash fields contain string
+type and string types operate just like the standard Redis string types
+when it comes to CRDTs. Fields in hashes can be initialized as a string
+using HSET or HMSET or can be used to initialize counter types that are
+numeric integers using HINCRBY or floats using HINCRBYFLOAT.
+
+Hashes in Active-Active databases behave the same and maintain additional metadata to
+achieve an "OR-Set" behavior to handle concurrent conflicting writes.
+With the OR-Set behavior, writes to add new fields across multiple Active-Active database
+instances are typically unioned except in cases of conflicts.
+Conflicting instance writes can happen when an Active-Active database instance deletes a
+field while the other adds the same field. In this case and observed
+remove rule is followed. That is, remove can only remove fields it has
+already seen and in all other cases element add/update wins.
+
+Field values behave just like CRDT strings. String values can be types
+string, counter integer based on the command used for initialization of
+the field value. See "String Data Type in Active-Active databases" and "String Data Type
+with Counter Value in Active-Active databases" for more details.
+
+Here is an example of an "add wins" case:
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | HSET key1 field1 “a” |  |
+|  t2 |  | HSET key1 field2 “b” |
+|  t4 | - Sync - | - Sync - |
+|  t5 | HGETALL key1<br/>1) “field2”<br/>2) “b”<br/>3) “field1”<br/>4) “a” | HGETALL key1<br/>1) “field2”<br/>2) “b”<br/>3) “field1”<br/>4) “a” |
+---
+Title: JSON in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using JSON with an Active-Active database.
+linkTitle: JSON
+weight: $weight
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/json/'
+---
+Active-Active databases support JSON data structures.
+
+The design is based on [A Conflict-Free Replicated JSON Datatype](https://arxiv.org/abs/1608.03960) by Kleppmann and Beresford, but the implementation includes some changes. Several [conflict resolution rule](#conflict-resolution-rules) examples were adapted from this paper as well.
+
+## Prerequisites
+
+To use JSON in an Active-Active database, you must enable JSON during database creation.
+
+Active-Active Redis Cloud databases add JSON by default. See [Create an Active-Active subscription]({{< relref "/operate/rc/databases/create-database/create-active-active-database#select-capabilities" >}}) in the Redis Cloud documentation for details.
+
+In Redis Enterprise Software, JSON is not enabled by default for Active-Active databases. See [Create an Active-Active JSON database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/active-active#create-an-active-active-json-database" >}}) in the Redis Stack and Redis Enterprise documentation for instructions.
+
+{{<embed-md "json-active-active-command-differences.md">}}
+
+{{<embed-md "json-active-active-conflict-resolution.md">}}
+---
+Title: Sets in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using sets with an Active-Active database.
+linkTitle: Sets
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/sets/'
+---
+A Redis set is an unordered collection of strings. It is possible to
+add, remove, and test for the existence of members with Redis commands.
+A Redis set maintains a unique collection of elements. Sets can be great
+for maintaining a list of events (click streams), users (in a group
+conversation), products (in recommendation lists), engagements (likes,
+shares) and so on.
+
+Sets in Active-Active databases behave the same and maintain additional metadata to
+achieve an "OR-Set" behavior to handle concurrent conflicting
+writes. With the OR-Set behavior, writes across multiple Active-Active database instances
+are typically unioned except in cases of conflicts. Conflicting instance
+writes can happen when a Active-Active database instance deletes an element while the
+other adds the same element. In this case and observed remove rule is
+followed. That is, remove can only remove instances it has already seen
+and in all other cases element add wins.
+
+Here is an example of an "add wins" case:
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SADD key1 “a” |  |
+|  t2 |  | SADD key1 “b” |
+|  t3 | SMEMBERS key1 “a” | SMEMBERS key1 “b” |
+|  t4 | — Sync — | — Sync — |
+|  t3 | SMEMBERS key1 “a” “b” | SMEMBERS key1 “a” “b” |
+
+Here is an example of an "observed remove" case.
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SMEMBERS key1 “a” “b” | SMEMBERS key1 “a” “b” |
+|  t2 | SREM key1 “a” | SADD key1 “c” |
+|  t3 | SREM key1 “c” |  |
+|  t4 | — Sync — | — Sync — |
+|  t3 | SMEMBERS key1 “c” “b” | SMEMBERS key1 “c” “b” |
+---
+Title: Streams in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using streams with an Active-Active database.
+linkTitle: Streams
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/streams/'
+---
+A [Redis Stream]({{< relref "/develop/data-types/streams" >}}) is a data structure that acts like an append-only log.
+Each stream entry consists of:
+
+- A unique, monotonically increasing ID
+- A payload consisting of a series key-value pairs
+
+You add entries to a stream with the XADD command. You access stream entries using the XRANGE, XREADGROUP, and XREAD commands (however, see the caveat about XREAD below).
+
+## Streams and Active-Active
+
+Active-Active databases allow you to write to the same logical stream from more than one region.
+Streams are synchronized across the regions of an Active-Active database.
+
+In the example below, we write to a stream concurrently from two regions. Notice that after syncing, both regions have identical streams:
+
+<table style='width: auto;'>
+<thead>
+<tr>
+<th>Time</th>
+<th>Region 1</th>
+<th>Region 2</th>
+</tr>
+</thead>
+
+<tbody>
+<tr>
+<td><em>t1</em></td>
+<td><code>XADD messages * text hello</code></td>
+<td><code>XADD messages * text goodbye</code></td>
+</tr>
+
+<tr>
+<td><em>t2</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></td>
+</tr>
+
+<tr>
+<td><em>t3</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+<tr>
+<td><em>t4</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1, 1589929246795-2]</strong></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1, 1589929246795-2]</strong></td>
+</tr>
+</tbody>
+</table>
+
+Notice also that the synchronized streams contain no duplicate IDs. As long as you allow the database to generate your stream IDs, you'll never have more than one stream entry with the same ID.
+
+{{< note >}}
+Redis Open Source uses one radix tree (referred to as `rax` in the code base) to implement each stream. However, Active-Active databases implement a single logical stream using one `rax` per region.
+Each region adds entries only to its associated `rax` (but can remove entries from all `rax` trees).
+This means that XREAD and XREADGROUP iterate simultaneously over all `rax` trees and return the appropriate entry by comparing the entry IDs from each `rax`.
+{{< /note >}}
+
+### Conflict resolution
+
+Active-Active databases use an "observed-remove" approach to automatically resolve potential conflicts.
+
+With this approach, a delete only affects the locally observable data.
+
+In the example below, a stream, `x`, is created at _t1_. At _t3_, the stream exists in two regions.
+
+<table style='width: 100%;'>
+<thead>
+<tr>
+<th>Time</th>
+<th>Region 1</th>
+<th>Region 2</th>
+</tr>
+</thead>
+
+<tbody>
+<tr>
+<td><em>t1</em></td>
+<td><code>XADD messages * text hello</code></td>
+<td></td>
+</tr>
+
+<tr>
+<td><em>t2</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+<tr>
+<td><em>t3</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></code></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929244828-1]</strong></code></td>
+</tr>
+
+
+<tr>
+<td><em>t4</em></td>
+<td><code>DEL messages</code></strong></td>
+<td><code>XADD messages * text goodbye</code></td>
+</tr>
+
+<tr>
+<td><em>t5</em></td>
+<td><em>— Sync —</em></td>
+<td><em>— Sync —</em></td>
+</tr>
+
+
+<tr>
+<td><em>t6</em></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></code></td>
+<td><code>XRANGE messages - +</code> <br/><strong>→ [1589929246795-2]</strong></code></td>
+</tr>
+
+
+</tbody>
+</table>
+
+At _t4_, the stream is deleted from Region 1. At the same time, an entry with ID ending in `3700` is added to the same stream at Region 2. After the sync, at _t6_, the entry with ID ending in `3700` exists in both regions. This is because that entry was not visible when the local stream was deleted at _t4_.
+
+### ID generation modes
+
+Usually, you should allow Redis streams generate its own stream entry IDs. You do this by specifying `*` as the ID in calls to XADD. However, you _can_ provide your own custom ID when adding entries to a stream.
+
+Because Active-Active databases replicate asynchronously, providing your own IDs can create streams with duplicate IDs. This can occur when you write to the same stream from multiple regions.
+
+| Time | Region 1                      | Region 2                      |
+| ---- | ------------------------------- | ------------------------------- |
+| _t1_   | `XADD x 100-1 f1 v1`              | `XADD x 100-1 f1 v1`              |
+| _t2_   | _— Sync —_                    | _— Sync —_                    |
+| _t3_   | `XRANGE x - +`<br/> **→ [100-1, 100-1]** | `XRANGE x - +`<br/> **→ [100-1, 100-1]** |
+
+In this scenario, two entries with the ID `100-1` are added at _t1_. After syncing, the stream `x` contains two entries with the same ID.
+
+{{< note >}}
+Stream IDs in Redis Open Source consist of two integers separated by a dash ('-'). When the server generates the ID, the first integer is the current time in milliseconds, and the second integer is a sequence number. So, the format for stream IDs is MS-SEQ.
+{{< /note >}}
+
+To prevent duplicate IDs and to comply with the original Redis streams design, Active-Active databases provide three ID modes for XADD:
+
+1. **Strict**: In _strict_ mode, XADD allows server-generated IDs (using the '`*`' ID specifier) or IDs consisting only of the millisecond (MS) portion. When the millisecond portion of the ID is provided, the ID's sequence number is calculated using the database's region ID. This prevents duplicate IDs in the stream. Strict mode rejects full IDs (that is, IDs containing both milliseconds and a sequence number).
+1. **Semi-strict**: _Semi-strict_ mode is just like _strict_ mode except that it allows full IDs (MS-SEQ). Because it allows full IDs, duplicate IDs are possible in this mode.
+1. **Liberal**: XADD allows any monotonically ascending ID. When given the millisecond portion of the ID, the sequence number will be set to `0`. This mode may also lead to duplicate IDs.
+
+The default and recommended mode is _strict_, which prevents duplicate IDs.
+
+{{% warning %}}
+Why do you want to prevent duplicate IDs? First, XDEL, XCLAIM, and other commands can affect more than one entry when duplicate IDs are present in a stream. Second, duplicate entries may be removed if a database is exported or renamed.
+{{% /warning %}}
+
+To change XADD's ID generation mode, use the `rladmin` command-line utility:
+
+Set _strict_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode strict
+```
+
+Set _semi-strict_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode semi-strict
+```
+
+Set _liberal_ mode:
+```sh
+rladmin tune db crdb crdt_xadd_id_uniqueness_mode liberal
+```
+
+### Iterating a stream with XREAD
+
+In Redis Open Source and in non-Active-Active databases, you can use XREAD to iterate over the entries in a Redis Stream. However, with an Active-Active database, XREAD may skip entries. This can happen when multiple regions write to the same stream.
+
+In the example below, XREAD skips entry `115-2`.
+
+| Time | Region 1                                         | Region 2                                         |
+| ---- | -------------------------------------------------- | -------------------------------------------------- |
+| _t1_   | `XADD x 110 f1 v1`                                   | `XADD x 115 f1 v1`                                   |
+| _t2_   | `XADD x 120 f1 v1`                                   |                                                    |
+| _t3_   | `XADD x 130 f1 v1`                                   |                                                    |
+| _t4_   | `XREAD COUNT 2 STREAMS x 0` <br/>**→ [110-1, 120-1]**       |                                                    |
+| _t5_   | _— Sync —_                                       | _— Sync —_                                       |
+| _t6_   | `XREAD COUNT 2 STREAMS x 120-1` <br/>**→ [130-1]**            |                                                    |
+| _t7_   | `XREAD STREAMS x 0` <br/>**→[110-1, 115-2, 120-1, 130-1]** | `XREAD STREAMS x 0` <br/>**→[110-1, 115-2, 120-1, 130-1]** |
+
+
+You can use XREAD to reliably consume a stream only if all writes to the stream originate from a single region. Otherwise, you should use XREADGROUP, which always guarantees reliable stream consumption.
+
+## Consumer groups
+
+Active-Active databases fully support consumer groups with Redis Streams. Here is an example of creating two consumer groups concurrently:
+
+| Time | Region 1                  | Region 2                  |
+| ---- | --------------------------- | --------------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`        | `XGROUP CREATE x group2 0`        |
+| _t2_   | `XINFO GROUPS x` <br/>**→ [group1]**     | `XINFO GROUPS x` <br/>**→ [group2]**     |
+| _t3_   | _— Sync —_                | — Sync —                |
+| _t4_   | `XINFO GROUPS x` <br/>**→ [group1, group2]** | `XINFO GROUPS x` <br/>**→ [group1, group2]** |
+
+
+{{< note >}}
+Redis Open Source uses one radix tree (`rax`) to hold the global pending entries list and another `rax` for each consumer's PEL.
+The global PEL is a unification of all consumer PELs, which are disjoint.
+
+An Active-Active database stream maintains a global PEL and a per-consumer PEL for each region.
+
+When given an ID different from the special ">" ID, XREADGROUP iterates simultaneously over all of the PELs for all consumers.
+It returns the next entry by comparing entry IDs from the different PELs.
+{{< /note >}}
+
+### Conflict resolution
+
+The "delete wins" approach is a way to automatically resolve conflicts with consumer groups.
+In case of concurrent consumer group operations, a delete will "win" over other concurrent operations on the same group.
+
+In this example, the DEL at _t4_ deletes both the observed `group1` and the non-observed `group2`:
+
+| Time | Region 1              | Region 2              |
+| ---- | ----------------------- | ----------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`    |                         |
+| _t2_   | _— Sync —_            | _— Sync —_            |
+| _t3_   | `XINFO GROUPS x` <br/>**→ [group1]** | `XINFO GROUPS x` <br/>**→ [group1]** |
+| _t4_   | `DEL x`                   | `XGROUP CREATE x group2 0`    |
+| _t5_   | _— Sync —_            | _— Sync —_            |
+| _t6_   | `EXISTS x` <br/>**→ 0** | `EXISTS x` <br/>**→  0**          |
+
+In this example, the XGROUP DESTROY at _t4_ affects both the observed `group1` created in Region 1 and the non-observed `group1` created in Region 3:
+
+| time | Region 1              | Region 2              | Region 3            |
+| ---- | ----------------------- | ----------------------- | --------------------- |
+| _t1_   | `XGROUP CREATE x group1 0`    |                         |                       |
+| _t2_   | _— Sync —_            | _— Sync —_            |                       |
+| _t3_   | `XINFO GROUPS x` <br/>**→ [group1]** | `XINFO GROUPS x` <br/>**→  [group1]** | `XINFO GROUPS x` <br/>**→  []** |
+| _t4_   |                         | `XGROUP DESTROY x group1`     | `XGROUP CREATE x group1 0` |
+| _t5_   | _— Sync —_            | _— Sync —            | — Sync —          |
+| _t6_   | `EXISTS x` <br/>**→  0**          | `EXISTS x` <br/>**→ 0**          | `EXISTS x` <br/>**→  0**    |
+
+### Group replication
+
+Calls to XREADGROUP and XACK change the state of a consumer group or consumer. However, it's not efficient to replicate every change to a consumer or consumer group.
+
+To maintain consumer groups in Active-Active databases with optimal performance:
+
+1. Group existence (CREATE/DESTROY) is replicated.
+1. Most XACK operations are replicated.
+1. Other operations, such as XGROUP, SETID, DELCONSUMER, are not replicated.
+
+For example:
+
+| Time | Region 1                                        | Region 2               |
+| ---- | ------------------------------------------------- | ------------------------ |
+| _t1_   | `XADD messages 110 text hello`                                |                          |
+| _t2_   | `XGROUP CREATE messages group1 0`                              |                          |
+| _t3_   | `XREADGROUP GROUP group1 Alice STREAMS messages >` <br/>**→ [110-1]** |                          |
+| _t4_   | _— Sync —_                                      | _— Sync —_             |
+| _t5_   | `XRANGE messages - +` <br/>**→ [110-1]**                          | XRANGE messages - + <br/>**→ [110-1]** |
+| _t6_   | `XINFO GROUPS messages` <br/>**→ [group1]**                            | XINFO GROUPS messages <br/>**→ [group1]**   |
+| _t7_   | `XINFO CONSUMERS messages group1` <br/>**→ [Alice]**                      | XINFO CONSUMERS messages group1 <br/>**→ []**  |
+| _t8_   | `XPENDING messages group1 - + 1` <br/>**→ [110-1]**                     | XPENDING messages group1 - + 1<br/>**→ []** |
+
+Using XREADGROUP across regions can result in regions reading the same entries.
+This is due to the fact that Active-Active Streams is designed for at-least-once reads or a single consumer.
+As shown in the previous example, Region 2 is not aware of any consumer group activity, so redirecting the XREADGROUP traffic from Region 1 to Region 2 results in reading entries that have already been read.
+
+### Replication performance optimizations
+
+Consumers acknowledge messages using the XACK command. Each ack effectively records the last consumed message. This can result in a lot of cross-region traffic. To reduce this traffic, we replicate XACK messages only when all of the read entries are acknowledged.
+
+| Time | Region 1                                                      | Region 2   | Explanation                                                                                                     |
+| ---- | --------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------- |
+| _t1_   | `XADD x 110-0 f1 v1`                                              |              |                                                                                                                 |
+| _t2_   | `XADD x 120-0 f1 v1`                                              |              |                                                                                                                 |
+| _t3_   | `XADD x 130-0 f1 v1`                                              |              |                                                                                                                 |
+| _t4_   | `XGROUP CREATE x group1 0`                                            |              |                                                                                                                 |
+| _t5_   | `XREADGROUP GROUP group1 Alice STREAMS x >` <br/>**→ [110-0, 120-0, 130-0]** |              |                                                                                                                 |
+| _t6_   | `XACK x group1 110-0`                                                   |              |                                                                                                                 |
+| _t7_   | _— Sync —_                                                    | _— Sync —_ | 110-0 and its preceding entries (none) were acknowledged. We replicate an XACK effect for 110-0.                |
+| _t8_   | `XACK x group1 130-0`                                                   |              |                                                                                                                 |
+| _t9_   | _— Sync —_                                                    | _— Sync —_ | 130-0 was acknowledged, but not its preceding entries (120-0). We DO NOT replicate an XACK effect for 130-0     |
+| _t10_  | `XACK x group1 120-0`                                                   |              |                                                                                                                 |
+| _t11_  | _— Sync —_                                                    | _— Sync —_ | 120-0 and its preceding entries (110-0 through 130-0) were acknowledged. We replicate an XACK effect for 130-0. |
+
+In this scenario, if we redirect the XREADGROUP traffic from Region 1 to Region 2 we do not re-read entries 110-0, 120-0 and 130-0.
+This means that the XREADGROUP does not return already-acknowledged entries.
+
+### Guarantees
+
+Unlike XREAD, XREADGOUP will never skip stream entries.
+In traffic redirection, XREADGROUP may return entries that have been read but not acknowledged. It may also even return entries that have already been acknowledged.
+
+## Summary
+
+With Active-Active streams, you can write to the same logical stream from multiple regions. As a result, the behavior of Active-Active streams differs somewhat from the behavior you get with Redis Open Source. This is summarized below:
+
+### Stream commands
+
+1. When using the _strict_ ID generation mode, XADD does not permit full stream entry IDs (that is, an ID containing both MS and SEQ).
+1. XREAD may skip entries when iterating a stream that is concurrently written to from more than one region. For reliable stream iteration, use XREADGROUP instead.
+1. XSETID fails when the new ID is less than current ID.
+
+### Consumer group notes
+
+The following consumer group operations are replicated:
+
+1. Consecutive XACK operations
+1. Consumer group creation and deletion (that is, XGROUP CREATE and XGROUP DESTROY)
+
+All other consumer group metadata is not replicated.
+
+A few other notes:
+
+1. XGROUP SETID and DELCONSUMER are not replicated.
+1. Consumers exist locally (XREADGROUP creates a consumer implicitly).
+1. Renaming a stream (using RENAME) deletes all consumer group information.
+---
+Title: Lists in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using list with an Active-Active database.
+linkTitle: Lists
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/lists/'
+---
+Redis lists are simply lists of strings, sorted by insertion order. It
+is possible to add elements to a Redis List that push new elements to
+the head (on the left) or to the tail (on the right) of the list. Redis
+lists can be used to easily implement queues (using LPUSH and RPOP, for
+example) and stacks (using LPUSH and LPOP, for
+example).
+
+Lists in Active-Active databases are just the same as regular Redis Lists. See the
+following examples to get familiar with Lists' behavior in an
+Active-Active database.
+
+Simple Lists
+example:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH mylist “hello” |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | LPUSH mylist “world” |
+|  t4 | — Sync — | — Sync — |
+|  t5 | LRANGE mylist 0 -1 =>“world” “hello” | LRANGE mylist 0 -1 => “world” “hello” |
+
+**Explanation**:
+The final list contains both the "world" and "hello" elements, in that
+order (Instance 2 observed "hello" when it added
+"world").
+
+Example of Lists with Concurrent
+Insertions:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | LINSERT L AFTER x y1 |  |
+|  t4 |  | LINSERT L AFTER x y2 |
+|  t5 | LRANGE L 0 -1 => x y1 | LRANGE L 0 -1 => x y2 |
+|  t6 | — Sync — | — Sync — |
+|  t7 | LRANGE L 0 -1 => x y1 y2 | LRANGE L 0 -1 => x y1 y2 |
+
+**Explanation**:
+Instance 1 added an element y1 after x, and then Instance 2 added element y2 after x.
+The final List contains all three elements: x is the first element, after it y1 and then y2.
+The Active-Active database resolves the conflict arbitrarily but applies the resolution consistently across all Active-Active database instances.
+
+Example of Deleting a List while Pushing a New
+Element:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 | LRANGE L 0 -1 => x | LRANGE L 0 -1 => x |
+|  t4 | LPUSH L y | DEL L |
+|  t5 | — Sync — | — Sync — |
+|  t6 | LRANGE L 0 -1 => y | LRANGE L 0 -1 => y |
+
+**Explanation**
+At t4 - t6, DEL deletes only observed elements. This is why L still
+contains y.
+
+Example of Popping Elements from a
+List:
+
+|  **Time** | **CRDB Instance 1** | **CRDB Instance 2** |
+|  ------: | :------: | :------: |
+|  t1 | LPUSH L x y z |  |
+|  t2 | — Sync — | — Sync — |
+|  t3 |  | RPOP L => x |
+|  t4 | — Sync — | — Sync — |
+|  t5 | RPOP L => y |  |
+|  t6 | — Sync — | — Sync — |
+|  t7 | RPOP L => z | RPOP L => z |
+
+**Explanation**:
+At t1, the operation pushes elements x, y, z to List L. At t3, the
+sequential pops behave as expected from a queue. At t7, the concurrent
+pop in both instances might show the same result. The instance was not
+able to sync regarding the z removal so, from the point of view of each
+instance, z is located in the List and can be popped. After syncing,
+both lists are empty.
+
+Be aware of the behavior of Lists in Active-Active databases when using List as a stack
+or queue. As seen in the above example, two parallel RPOP operations
+performed by two different Active-Active database instances can get the same element in
+the case of a concurrent operation. Lists in Active-Active databases guarantee that each
+element is POP-ed at least once, but cannot guarantee that each
+element is POP-ed only once. Such behavior should be taken into
+account when, for example, using Lists in Active-Active databases as building blocks for
+inter-process communication systems.
+
+In that case, if the same element cannot be handled twice by the
+applications, it's recommended that the POP operations be performed by
+one Active-Active database instance, whereas the PUSH operations can be performed by
+multiple instances.
+---
+Title: HyperLogLog in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Information about using hyperloglog with an Active-Active database.
+linkTitle: HyperLogLog
+weight: $weight
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/hyperloglog/'
+---
+**HyperLogLog** is an algorithm that addresses the [count-distinct problem](https://en.wikipedia.org/wiki/Count-distinct_problem).
+To do this it approximates the numbers of items in a [set](https://en.wikipedia.org/wiki/Multiset).
+Determining the _exact_ cardinality of a set requires memory according to the cardinality of the set.
+Because it estimates the cardinality by probability, the HyperLogLog algorithm can run with more reasonable memory requirements.
+
+## HyperLogLog in Redis
+
+Redis Open Source implements [HyperLogLog](https://redislabs.com/redis-best-practices/counting/hyperloglog/) (HLL) as a native data structure.
+It supports adding elements ([PFADD]({{< relref "/commands/pfadd" >}}) to an HLL, counting elements ([PFCOUNT]({{< relref "/commands/pfcount" >}}) of HLLs, and merging of ([PFMERGE]({{< relref "/commands/pfmerge" >}}) HLLs.
+
+Here is an example of a simple write case:
+
+| Time | Replica 1         | Replica 2         |
+| ---- | ----------------- | ----------------- |
+| t1   | PFADD hll x       |                   |
+| t2   | --- sync ---      |                   |
+| t3   |                   | PFADD hll y       |
+| t4   | --- sync ---      |                   |
+| t5   | PFCOUNT hll --> 2 | PFCOUNT hll --> 2 |
+
+Here is an example of a concurrent add case:
+
+| Time | Replica 1         | Replica 2         |
+| ---- | ----------------- | ----------------- |
+| t1   | PFADD hll x       | PFADD hll y       |
+| t2   | PFCOUNT hll --> 1 | PFCOUNT hll --> 1 |
+| t3   | --- sync ---      |                   |
+| t4   | PFCOUNT hll --> 2 | PFCOUNT hll --> 2 |
+
+## The DEL-wins approach
+
+Other collections in the Redis-CRDT implementation use the observed remove method to resolve conflicts.
+The CRDT-HLL uses the DEL-wins method.
+If a DEL request is received at the same time as any other request (ADD/MERGE/EXPIRE) on the HLL-key
+the replicas consistently converge to delete key.
+In the observed remove method used by other collections (sets, lists, sorted-sets and hashes),
+only the replica that received the DEL request removes the elements, but elements added concurrently in other replicas exist in the consistently converged collection.
+We chose to use the DEL-wins method for the CRDT-HLL to maintain the original time and space complexity of the HLL in Redis Open Source.
+
+Here is an example of a DEL-wins case:
+
+| HLL  |                 |                 | \|  | Set  |                     |                     |
+| ---- | --------------- | --------------- | --- | ---- | ------------------- | ------------------- |
+|      |                 |                 | \|  |      |                     |                     |
+| Time | Replica 1       | Replica 2       | \|  | Time | Replica 1           | Replica 2           |
+|      |                 |                 | \|  |      |                     |                     |
+| t1   | PFADD h e1      |                 | \|  | t1   | SADD s e1           |                     |
+| t2   | --- sync ---    |                 | \|  | t2   | --- sync ---        |                     |
+| t3   | PFCOUNT h --> 1 | PFCOUNT h --> 1 | \|  | t3   | SCARD s --> 1       | SCARD s --> 1       |
+| t4   | PFADD h e2      | Del h           | \|  | t4   | SADD s e2           | Del S               |
+| t5   | PFCOUNT h --> 2 | PFCOUNT h --> 0 | \|  | t5   | SCARD s --> 2       | SCARD s --> 0       |
+| t6   | --- sync ---    |                 | \|  | t6   | --- sync ---        |                     |
+| t7   | PFCOUNT h --> 0 | PFCOUNT h --> 0 | \|  | t7   | SCARD s --> 1       | SCARD s --> 1       |
+| t8   | Exists h --> 0  | Exists h --> 0  | \|  | t8   | Exists s --> 1      | Exists s --> 1      |
+|      |                 |                 | \|  | t9   | SMEMBERS s --> {e2} | SMEMBERS s --> {e2} |
+
+## HLL in Active-Active databases versus HLL in Redis Open Source
+
+In Active-Active databases, we implemented HLL within the CRDT on the basis of the Redis implementation with a few exceptions:
+
+- Redis keeps the HLL data structure as an encoded string object
+    such that you can potentially run any string request can on a key that contains an HLL. In CRDT, only get and set are supported for HLL.
+- In CRDT, if you do SET on a key that contains a value encoded as an HLL, then the value will remain an HLL. If the value is not encoded as HLL, then it will be a register.
+---
+Title: Data types for Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Introduction to differences in data types between standalone and Active-Active
+  Redis databases.
+hideListLinks: true
+linktitle: Data types
+weight: 90
+url: '/operate/rs/7.4/databases/active-active/develop/data-types/'
+---
+
+
+Active-Active databases use conflict-free replicated data types (CRDTs). From a developer perspective, most supported data types work the same for Active-Active and standard Redis databases. However, a few methods also come with specific requirements in Active-Active databases.
+
+Even though they look identical to standard Redis data types, there are specific rules that govern the handling of
+conflicting concurrent writes for each data type.
+
+As conflict handling rules differ between data types, some commands have slightly different requirements in Active-Active databases versus standard Redis databases.
+
+See the following articles for more information 
+
+---
+Title: Active-Active Redis applications
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: General information to keep in mind while developing applications for
+  an Active-Active database.
+hideListLinks: true
+linktitle: Develop applications
+weight: 99
+url: '/operate/rs/7.4/databases/active-active/develop/'
+---
+Developing globally distributed applications can be challenging, as
+developers have to think about race conditions and complex combinations
+of events under geo-failovers and cross-region write conflicts. In Redis Enterprise Software (RS), Active-Active databases
+simplify developing such applications by directly using built-in smarts
+for handling conflicting writes based on the data type in use. Instead
+of depending on just simplistic "last-writer-wins" type conflict
+resolution, geo-distributed Active-Active databases (formerly known as CRDBs) combines techniques defined in CRDT
+(conflict-free replicated data types) research with Redis types to
+provide smart and automatic conflict resolution based on the data types
+intent.
+
+An Active-Active database is a globally distributed database that spans multiple Redis
+Enterprise Software clusters. Each Active-Active database can have many Active-Active database instances
+that come with added smarts for handling globally distributed writes
+using the proven
+[CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)
+approach.
+[CRDT](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)
+research describes a set of techniques for creating systems that can
+handle conflicting writes. CRDBs are powered by Multi-Master Replication
+(MMR) provides a straightforward and effective way to replicate your
+data between regions and simplify development of complex applications
+that can maintain correctness under geo-failovers and concurrent
+cross-region writes to the same data.
+
+{{< image filename="/images/rs/crdbs.png" alt="Geo-replication world map">}}
+
+Active-Active databases replicate data between multiple Redis Enterprise Software
+clusters. Common uses for Active-Active databases include disaster recovery,
+geographically redundant applications, and keeping data closer to your
+user's locations. MMR is always multi-directional amongst the clusters
+configured in the Active-Active database. For unidirectional replication, please see the
+Replica Of capabilities in Redis Enterprise Software.
+
+## Example of synchronization
+
+In the example below, database writes are concurrent at the point in
+times t1 and t2 and happen before a sync can communicate the changes.
+However, writes at times t4 and t6 are not concurrent as a sync happened
+in between.
+
+|  **Time** | **CRDB Instance1** | **CRDB Instance2** |
+|  ------: | :------: | :------: |
+|  t1 | SET key1 “a” |  |
+|  t2 |  | SET key1 “b” |
+|  t3 | — Sync — | — Sync — |
+|  t4 | SET key1 “c” |  |
+|  t5 | — Sync — | — Sync — |
+|  t6 |  | SET key1 “d” |
+
+[Learn more about
+synchronization]({{< relref "/operate/rs/7.4/databases/active-active" >}}) for
+each supported data type and [how to develop]({{< relref "/operate/rs/7.4/databases/active-active/develop/develop-for-aa.md" >}}) with them on Redis Enterprise Software.
+---
+Title: Configure distributed synchronization
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure distributed synchronization so that any available proxy
+  endpoint can manage synchronization traffic.
+linktitle: Distributed synchronization
+weight: 80
+url: '/operate/rs/7.4/databases/active-active/synchronization-mode/'
+---
+Replicated databases, such as [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}}) and [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active" >}}) databases,
+use proxy endpoints to synchronize database changes with the databases on other participating clusters.
+
+To improve the throughput and lower the latency for synchronization traffic,
+you can configure a replicated database to use distributed synchronization where any available proxy endpoint can manage synchronization traffic.
+
+Every database by default has one proxy endpoint that manages client and synchronization communication with the database shards,
+and that proxy endpoint is used for database synchronization.
+This is called centralized synchronization.
+
+To prepare a database to use distributed synchronization you must first make sure that the database [proxy policy]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy.md" >}})
+is defined so that either each node has a proxy endpoint or each primary (master) shard has a proxy endpoint.
+After you have multiple proxies for the database,
+you can configure the database synchronization to use distributed synchronization.
+
+## Configure distributed synchronization
+
+{{< note >}}
+You may use the database name in place of `db:<ID>` in the following `rladmin` commands.
+{{< /note >}}
+
+To configure distributed synchronization:
+
+1. To check the proxy policy for the database, run: `rladmin status`
+
+    The output of the status command shows the list of endpoints on the cluster and the proxy policy for the endpoint.
+
+    ```sh
+    ENDPOINTS:
+    DB:ID       NAME      ID                        NODE          ROLE                                SSL
+    db:1        db        endpoint:1:1              node:1        all-master-shards                   No
+    ```
+
+    If the proxy policy (also known as a _role_) is `single`, configure the policy to `all-nodes` or `all-master-shards` according to your needs with the command:
+
+    ```sh
+    rladmin bind db db:<ID> endpoint <endpoint id> policy <all-master-shards|all-nodes>
+    ```
+
+1. To configure the database to use distributed synchronization, run:
+
+    ```sh
+    rladmin tune db db:<ID> syncer_mode distributed
+    ```
+
+    To change back to centralized synchronization, run:
+
+    ```sh
+    rladmin tune db db:<ID> syncer_mode centralized
+    ```
+
+## Verify database synchronization
+
+Use `rladmin` to verify a database synchronization role:
+
+```sh
+rladmin info db db:<ID>
+```
+
+The current database role is reported as the `syncer_mode` value:
+
+```sh
+$ rladmin info db db:<ID>     
+db:<ID> [<db_name>]:
+  // (Other settings removed) 
+  syncer_mode: centralized
+```
+---
+Title: Manage Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage your Active-Active database settings.
+linktitle: Manage
+weight: 30
+url: '/operate/rs/7.4/databases/active-active/manage/'
+---
+
+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`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}).
+
+If you need to apply changes locally to one database instance, you use the Cluster Manager UI or [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/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.
+
+## Participating clusters
+
+You can add and remove participating clusters of an Active-Active database to change the topology.
+To manage the changes to Active-Active topology, use [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/" >}}) or the participating clusters list in the Cluster Manager UI.
+
+### Add participating clusters
+
+All existing participating clusters must be online and in a syncing state when you add new participating clusters.
+
+New participating clusters create the Active-Active database instance based on the global Active-Active database configuration.
+After you add new participating clusters to an existing Active-Active database,
+the new database instance can accept connections and read operations.
+The new instance does not accept write operations until it is in the syncing state.
+
+{{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/7.4/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+{{</note>}}
+
+To add a new participating cluster to an existing Active-Active configuration using the Cluster Manager UI:
+
+1. Select the Active-Active database from the **Databases** list and go to its **Configuration** screen.
+
+1. Click **Edit**.
+
+1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-add-cluster.png" alt="Add cluster panel.">}}
+
+1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Click **Save**.
+
+
+### Remove participating clusters
+
+All existing participating clusters must be online and in a syncing state when you remove an online participating cluster.
+If you must remove offline participating clusters, you can forcefully remove them.
+If a forcefully removed participating cluster tries to rejoin the cluster,
+its Active-Active database membership will be out of date.
+The joined participating clusters reject updates sent from the removed participating cluster.
+To prevent rejoin attempts, purge the forcefully removed instance from the participating cluster.
+
+To remove a participating cluster using the Cluster Manager UI:
+
+1. Select the Active-Active database from the **Databases** list and go to its **Configuration** screen.
+
+1. Click **Edit**.
+
+1. In the **Participating clusters** section, point to the cluster you want to delete in the **Other participating clusters** list:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-edit-delete.png" alt="Edit and delete buttons appear when you point to an entry in the Other participating clusters list.">}}
+
+1. Click {{< image filename="/images/rs/buttons/delete-button.png#no-click" alt="The Delete button" width="25px" class="inline" >}} to remove the cluster.
+
+1. Click **Save**.
+
+## Replication backlog
+
+Redis databases that use [replication for high availability]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}) maintain a replication backlog (per shard) to synchronize the primary and replica shards of a database. In addition to the database replication backlog, Active-Active databases maintain a backlog (per shard) to synchronize the database instances between clusters.
+
+By default, both the database and Active-Active replication backlogs are set to one percent (1%) of the database size divided by the number of shards. This can range between 1MB to 250MB per shard for each backlog.
+
+### Change the replication backlog size
+
+Use the [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) utility to control the size of the replication backlogs. You can set it to `auto` or set a specific size.  
+
+Update the database replication backlog configuration with the `crdb-cli` command shown below.
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+Update the Active-Active (CRDT) replication backlog with the command shown below: 
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"crdt_repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+## Data persistence
+
+Active-Active supports AOF (Append-Only File) data persistence only.  Snapshot persistence is _not_ supported for Active-Active databases and should not be used.
+
+If an Active-Active database is currently using snapshot data persistence, use `crdb-cli` to switch to AOF persistence:
+```text
+ crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+
+---
+Title: Enable causal consistency
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable causal consistency  in an Active-Active database.
+linkTitle: Causal consistency
+weight: 70
+url: '/operate/rs/7.4/databases/active-active/causal-consistency/'
+---
+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.
+
+### Enable causal consistency
+
+When you create an Active-Active database, you can enable causal consistency in the Cluster Manager UI:
+
+1. In the **Participating clusters** section of the **Create Active-Active database** screen, locate **Causal Consistency**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/create-a-a-db-participating-clusters.png" alt="The Participating clusters section of the Create Active-Active database screen.">}}
+
+1. Click **Change** to open the **Causal Consistency** dialog.
+
+1. Select **Enabled**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enable-causal-consistency.png" alt="Enabled is selected in the Causal Consistency dialog.">}}
+
+1. Click **Change** to confirm your selection.
+
+After database creation, you can only turn causal consistency on or off using the REST API or `crdb-cli`.
+The updated setting only affects commands and operations received after the change.
+
+### Causal consistency side effects
+
+When the causal consistency option is enabled, each instance maintains the order of operations it received from another instance
+and relays that information to all other N-2 instances,
+where N represents the number of instances used by the Active-Active database.
+
+As a result, network traffic is increased by a factor of (N-2).
+The memory consumed by each instance and overall performance are also impacted when causal consistency is activated.
+
+---
+Title: Connect to your Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to connect to an Active-Active database using redis-cli or a sample
+  Python application.
+linkTitle: Connect
+weight: 26
+url: '/operate/rs/7.4/databases/active-active/connect/'
+---
+
+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.
+
+{{< image filename="/images/rs/crdb-diagram.png" >}}
+
+### Connecting using redis-cli {#connecting-using-rediscli}
+
+redis-cli is a simple command-line tool to interact with redis database.
+
+1. To use redis-cli on port 12000 from the node 1 terminal, run:
+
+    ```sh
+    redis-cli -p 12000
+    ```
+
+1. Store and retrieve a key in the database to test the connection with these
+    commands:
+
+    - `set key1 123`
+    - `get key1`
+
+    The output of the command looks like this:
+
+    ```sh
+    127.0.0.1:12000> set key1 123
+    OK
+    127.0.0.1:12000> get key1
+    "123"
+    ```
+
+1. Enter the terminal of node 1 in cluster 2, run the redis-cli, and
+   retrieve key1.
+
+    The output of the commands looks like this:
+
+    ```sh
+    $ redis-cli -p 12000
+    127.0.0.1:12000> get key1
+    "123"
+    ```
+
+### Connecting using _Hello World_ application in Python
+
+A simple python application running on the host machine can also connect
+to the database.
+
+{{< note >}}
+Before you continue, you must have python and
+[redis-py](https://github.com/andymccurdy/redis-py#installation)
+(python library for connecting to Redis) configured on the host machine
+running the container.
+{{< /note >}}
+
+1. In the command-line terminal, create a new file called "redis_test.py"
+
+    ```sh
+    vi redis_test.py
+    ```
+
+1. Paste this code into the "redis_test.py" file.
+
+    This application stores a value in key1 in cluster 1, gets that value from
+    key1 in cluster 1, and gets the value from key1 in cluster 2.
+
+    ```py
+    import redis
+    rp1 = redis.StrictRedis(host='localhost', port=12000, db=0)
+    rp2 = redis.StrictRedis(host='localhost', port=12002, db=0)
+    print ("set key1 123 in cluster 1")
+    print (rp1.set('key1', '123'))
+    print ("get key1 cluster 1")
+    print (rp1.get('key1'))
+    print ("get key1 from cluster 2")
+    print (rp2.get('key1'))
+    ```
+
+1. To run the "redis_test.py" application, run:
+
+    ```sh
+    python redis_test.py
+    ```
+
+    If the connection is successful, the output of the application looks like:
+
+    ```sh
+    set key1 123 in cluster 1
+    True
+    get key1 cluster 1
+    "123"
+    get key1 from cluster 2
+    "123"
+    ```
+---
+Title: Create an Active-Active geo-replicated database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to create an Active-Active database and things to consider when setting
+  it up.
+linkTitle: Create
+weight: 25
+url: '/operate/rs/7.4/databases/active-active/create/'
+---
+[Active-Active geo-replicated databases]({{< relref "/operate/rs/7.4/databases/active-active" >}}) (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]({{< relref "/operate/rs/7.4/databases/active-active/develop#example-of-synchronization" >}}) to all instances without conflict.
+
+## Steps to create an Active-Active database
+
+1. **Create a service account** - On each participating cluster, create a dedicated user account with the Admin role.
+1. **Confirm connectivity** - Confirm network connectivity between the participating clusters.
+1. **Create Active-Active database** - Connect to one of your clusters and create a new Active-Active database.
+1. **Add participating clusters** - Add the participating clusters to the Active-Active database with the user credentials for the service account.
+1. **Verify creation** - Log in to each of the participating clusters and verify your Active-Active database was created on them.
+1. **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]({{< relref "/operate/rs/7.4/databases/active-active#network-time-service-ntp-or-chrony" >}}) listener (ntpd) configured and running on each node in all clusters
+
+## Create an Active-Active database
+
+1. Create service accounts on each participating cluster:
+
+    1. In a browser, open the Cluster Manager UI for the participating cluster.
+
+        The default address is: `https://<RS_address>:8443`
+
+    1. Go to the **Access Control > Users** tab:
+
+        {{<image filename="images/rs/access-control-user-panel.png" alt="Add role with name" >}}
+    
+    1. Click **+ Add user**.
+
+    1. Enter the username, email, and password for the user.
+    
+    1. Select the **Admin** role.
+    
+    1. Click **Save**.
+
+1. To verify network connectivity between participating clusters,
+    run the following `telnet` command from each participating cluster to all other participating clusters:
+
+    ```sh
+    telnet <target FQDN> 9443
+    ```
+
+1. In a browser, open the Cluster Manager UI of the cluster where you want to create the Active-Active database.
+
+    The default address is: `https://<RS_address>:8443`
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select **Active-Active database**.
+
+1. Enter the cluster's local admin credentials, then click **Save**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enter-local-admin-credentials.png" alt="Enter the cluster's admin username and password.">}}
+    
+1. Add participating clusters that will host instances of the Active-Active database:
+
+    1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+    1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/create-db-add-participating-clusters.png" alt="Add cluster panel.">}}
+
+        {{<note>}}
+If an Active-Active database [runs on flash memory]({{<relref "/operate/rs/7.4/databases/auto-tiering">}}), you cannot add participating clusters that run on RAM only.
+        {{</note>}}
+
+    1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Enter a **Database name**.
+
+1. If your cluster supports [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}), in **Runs on** you can select **Flash** so that your database uses Flash memory. We recommend that you use AOF every 1 sec for the best performance during the initial Active-Active database sync of a new replica.
+
+1. To configure additional database settings, expand each relevant section to make changes.
+
+    See [Configuration settings](#configuration-settings) for more information about each setting.
+
+1. Click **Create**.
+
+## Configuration settings
+
+- **Database version** - The Redis version used by your database.
+
+- **Database name** - The database name requirements are:
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+- **Port** - You can define the port number that clients use to connect to the database. Otherwise, a port is randomly selected.
+
+    {{< note >}}
+You cannot change the [port number]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}})
+after the database is created.
+    {{< /note >}}
+
+- **Memory limit** - [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}) include all database replicas and shards, including replica shards in database replication and database shards in database clustering.
+
+    If the total size of the database in the cluster reaches the memory limit, the data eviction policy for the database is enforced.
+
+    {{< note >}}
+If you create a database with Auto Tiering enabled, you also need to set the RAM-to-Flash ratio
+for this database. Minimum RAM is 10%. Maximum RAM is 50%.
+    {{< /note >}}
+
+- [**Capabilities**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) (previously **Modules**) - When you create a new in-memory database, you can enable multiple Redis Stack capabilities in the database. For Auto Tiering databases, you can enable capabilities that support Auto Tiering. See [Redis Enterprise and Redis Stack feature compatibility 
+]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}) for compatibility details.
+        
+    {{<note>}}
+To use Redis Stack capabilities, enable them when you create a new database.
+You cannot enable them after database creation.
+    {{</note>}} 
+        
+    To add capabilities to the database:
+
+    1. In the **Capabilities** section, select one or more capabilities.
+    
+    1. To customize capabilities, select **Parameters** and enter the optional custom configuration.
+    
+    1. Select **Done**.
+
+### TLS
+
+If you enable TLS when you create the Active-Active database, the nodes use the TLS mode **Require TLS for CRDB communication only** to require TLS authentication and encryption for communications between participating clusters.
+        
+After you create the Active-Active database, you can set the TLS mode to **Require TLS for all communications** so client communication from applications are also authenticated and encryption.
+
+### High availability & durability
+
+- [**Replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}) - We recommend that all Active-Active database use replication for best intercluster synchronization performance.
+    
+    When replication is enabled, every Active-Active database master shard is replicated to a corresponding replica shard. The replica shards are then used to synchronize data between the instances, and the master shards are dedicated to handling client requests.
+    
+    We also recommend that you enable [replica HA]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) to ensure that the replica shards are highly-available for this synchronization.
+
+- [**Data persistence**]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}) - To protect against loss of data stored in RAM, you can enable data persistence to store a copy of the data on disk.
+        
+    Active-Active databases support append-only file (AOF) persistence only. Snapshot persistence is not supported for Active-Active databases.
+
+- **Eviction policy** - The default eviction policy for Active-Active databases is `noeviction`. Redis Enterprise version 6.0.20 and later support all eviction policies for Active-Active databases, unless [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering" >}}) is enabled.
+
+### Clustering
+
+- In the **Database clustering** option, you can either:
+
+    - Make sure the Database clustering is enabled and select the number of shards
+        that you want to have in the database. When database clustering is enabled,
+        databases are subject to limitations on [Multi-key commands]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}).
+        You can increase the number of shards in the database at any time.
+        
+    - Clear the **Database clustering** option to use only one shard so that you
+        can use [Multi-key commands]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}})
+        without the limitations.
+
+    {{<note>}}
+You cannot enable or turn off database clustering after the Active-Active database is created.
+    {{</note>}}
+
+- [**OSS Cluster API**]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api.md" >}}) - {{< embed-md "oss-cluster-api-intro.md"  >}}
+
+### Access control
+
+- **Unauthenticated access** - You can access the database as the default user without providing credentials.
+
+- **Password-only authentication** - When you configure a password for your database's default user, all connections to the database must authenticate with the [AUTH command]({{< relref "/commands/auth" >}}.
+
+    If you also configure an access control list, connections can specify other users for authentication, and requests are allowed according to the Redis ACLs specified for that user.
+
+    Creating a database without ACLs enables a *default* user with full access to the database. You can secure default user access by requiring a password.
+
+- **Access Control List** - You can specify the [user roles]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) that have access to the database and the [Redis ACLs]({{< relref "/operate/rs/7.4/security/access-control/redis-acl-overview" >}}) that apply to those connections.
+
+    You can only configure access control after the Active-Active database is created. In each participating cluster, add ACLs after database creation.
+
+    To define an access control list for a database:
+
+    1. In **Security > Access Control > Access Control List**, select **+ Add ACL**.
+
+    1. Select a [role]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) to grant database access.
+
+    1. Associate a [Redis ACL]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) with the role and database.
+
+    1. Select the check mark to add the ACL.
+
+### Causal consistency
+
+[**Causal consistency**]({{< relref "/operate/rs/7.4/databases/active-active/causal-consistency" >}}) in an Active-Active database guarantees that the order of operations on a specific key is maintained across all instances of an Active-Active database.
+    
+To enable causal consistency for an existing Active-Active database, use the REST API.
+
+<!-- Also in getting-started-crdbs.md -->
+## Test Active-Active database connections
+
+With the Redis database created, you are ready to connect to your database. See [Connect to Active-Active databases]({{< relref "/operate/rs/7.4/databases/active-active/connect.md" >}}) for tutorials and examples of multiple connection methods.
+---
+Title: Delete Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Considerations while deleting Active-Active databases.
+linktitle: Delete
+weight: 35
+url: '/operate/rs/7.4/databases/active-active/delete/'
+---
+
+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.
+{{% /warning %}}
+
+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.
+
+We recommended that you:
+
+- Back up your data and test the restore on another database before you delete an Active-Active database.
+- Consider [flushing the data]({{< relref "/operate/rs/7.4/databases/import-export/flush.md" >}}) from the database
+    so that you can keep the Active-Active database configuration and restore the data to it if necessary.
+---
+Title: Syncer process
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Detailed information about the syncer process and its role in distributed
+  databases.
+linktitle: Syncer process
+weight: 90
+url: '/operate/rs/7.4/databases/active-active/syncer/'
+---
+
+## Syncer process
+
+Each node in a cluster containing an instance of an Active-Active database hosts a process called the syncer.
+The syncer process:
+
+1. Connects to the proxy on another participating cluster
+1. Reads data from that database instance
+1. Writes the data to the local cluster's primary(master) shard
+
+Some replication capabilities are also included in [Redis Open Source]({{< relref "/operate/oss_and_stack/management/replication" >}}).
+
+The primary (also known as master) shard at the top of the primary-replica tree creates a replication ID.
+This replication ID is identical for all replicas in that tree.
+When a new primary is appointed, the replication ID changes, but a partial sync from the previous ID is still possible.
+
+
+In a partial sync, the backlog of operations since the offset are transferred as raw operations.
+In a full sync, the data from the primary is transferred to the replica as an RDB file which is followed by a partial sync. 
+
+Partial synchronization requires a backlog large enough to store the data operations until connection is restored. See [replication backlog]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog" >}}) for more info on changing the replication backlog size.
+
+### Syncer in Active-Active replication
+
+In the case of an Active-Active database:
+
+- Multiple past replication IDs and offsets are stored to allow for multiple syncs 
+- The [Active-Active replication backlog]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog" >}}) is also sent to the replica during a full sync. 
+
+{{< warning >}}
+Full sync triggers heavy data transfers between geo-replicated instances of an Active-Active database. 
+{{< /warning >}}
+
+An Active-Active database uses partial synchronization in the following situations:
+
+- Failover of primary shard to replica shard
+- Restart or crash of replica shard that requires sync from primary
+- Migrate replica shard to another node
+- Migrate primary shard to another node as a replica using failover and replica migration
+- Migrate primary shard and preserve roles using failover, replica migration, and second failover to return shard to primary
+
+{{< note >}}
+Synchronization of data from the primary shard to the replica shard is always a full synchronization.
+{{< /note >}}
+---
+Title: Get started with Redis Enterprise Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Quick start guide to create an Active-Active database for test and development.
+linktitle: Get started
+weight: 20
+url: '/operate/rs/7.4/databases/active-active/get-started/'
+---
+
+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:
+
+1. Run two Redis Enterprise Software Docker containers.
+
+1. Set up each container as a cluster.
+
+1. Create a new Redis Enterprise Active-Active database.
+
+1. Test connectivity to the Active-Active database.
+
+To run an Active-Active database on installations from the [Redis Enterprise Software download package]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}),
+set up two Redis Enterprise Software installations and continue from Step 2.
+
+{{<note>}}
+This getting started guide is for development or demonstration environments.
+For production environments, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}}) for instructions.
+{{</note>}}
+
+## Run two containers
+
+To spin up two Redis Enterprise Software containers, run these commands:
+
+```sh
+docker run -d --cap-add sys_resource -h rs1_node1 --name rs1_node1 -p 8443:8443 -p 9443:9443 -p 12000:12000 redislabs/redis
+```
+
+```sh
+docker run -d --cap-add sys_resource -h rs2_node1 --name rs2_node1 -p 8445:8443 -p 9445:9443 -p 12002:12000 redislabs/redis
+```
+
+The **-p** options map the Cluster Manager UI port (8443), REST API port (9443), and
+database access port differently for each container to make sure that all
+containers can be accessed from the host OS that is running the containers.
+
+## Set up two clusters
+
+1. For cluster 1, go to `https://localhost:8443` in a browser on the
+host machine to access the Redis Enterprise Software Cluster Manager UI.
+
+    {{<note>}}
+Depending on your browser, you may see a certificate error. Continue to the website.
+    {{</note>}}
+
+1. Click **Create new cluster**:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/create-cluster.png" alt="When you first install Redis Enterprise Software, you need to set up a cluster." >}}
+
+1. Enter an email and password for the administrator account, then click **Next** to proceed to cluster setup:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/admin-credentials.png" alt="Set the credentials for your admin user." >}}
+
+1. Enter your cluster license key if you have one. Otherwise, a trial version is installed.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/cluster-license-key.png" alt="Enter your cluster license key if you have one." >}}
+
+1. In the **Configuration** section of the **Cluster** settings page, enter a cluster FQDN, for example `cluster1.local`:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/config-cluster1.png" alt="Configure the cluster FQDN." >}}
+
+1. On the node setup screen, keep the default settings and click **Create cluster**:
+
+    {{<image filename="images/rs/screenshots/cluster/setup/node-settings.png" alt="Configure the node specific settings." >}}
+
+1. Click **OK** to confirm that you are aware of the replacement of the HTTPS SSL/TLS
+    certificate on the node, and proceed through the browser warning.
+
+1. Repeat the previous steps for cluster 2 with these differences:
+
+    - In your web browser, go to `https://localhost:8445` to set up the cluster 2.
+
+    - For the **Cluster name (FQDN)**, enter a different name, such as `cluster2.local`.
+
+Now you have two Redis Enterprise Software clusters with FQDNs
+`cluster1.local` and `cluster2.local`.
+
+{{<note>}}
+Each Active-Active instance must have a unique fully-qualified domain name (FQDN).
+{{</note>}}
+
+## Create an Active-Active database
+
+1. Sign in to cluster1.local's Cluster Manager UI at `https://localhost:8443`
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select **Active-Active database**.
+
+1. Enter the cluster's local admin credentials, then click **Save**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enter-local-admin-credentials-cluster1.png" alt="Enter the cluster's admin username and password.">}}
+
+1. Add participating clusters that will host instances of the Active-Active database:
+
+    1. In the **Participating clusters** section, go to **Other participating clusters** and click **+ Add cluster**.
+
+    1. In the **Add cluster** configuration panel, enter the new cluster's URL, port number, and the admin username and password for the new participating cluster:
+
+        In the **Other participating clusters** list, add the address and admin credentials for the other cluster: `https://cluster2.local:9443`
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/participating-clusters-add-cluster2.png" alt="Add cluster panel.">}}
+
+    1. Click **Join cluster** to add the cluster to the list of participating clusters. 
+
+1. Enter `database1` for **Database name** and `12000` for **Port**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/quickstart-db-name-port.png" alt="Database name and port text boxes.">}}
+
+1. Configure additional settings:
+
+    1. In the **High availability & durability** section, turn off **Replication** since each cluster has only one node in this setup:
+
+        {{<image filename="images/rs/screenshots/databases/active-active-databases/quickstart-ha-turn-off-replication.png" alt="Turn off replication in the High availability & durability section.">}}
+
+
+    1. In the **Clustering** section, either:
+
+        - Make sure that **Sharding** is enabled and select the number of shards you want to have in the database. When database clustering is enabled,
+        databases are subject to limitations on [Multi-key commands]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering" >}}).
+        You can increase the number of shards in the database at any time.
+
+        - Turn off **Sharding** to use only one shard and avoid [Multi-key command]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering" >}}) limitations.
+
+        {{< note >}}
+You cannot enable or turn off database clustering after the Active-Active database is created.
+        {{< /note >}}
+
+1. Click **Create**.
+
+    {{< note >}}
+{{< embed-md "docker-memory-limitation.md" >}}
+    {{< /note >}}
+
+1. After the Active-Active database is created, sign in to the Cluster Manager UIs for cluster 1 at `https://localhost:8443` and cluster 2 at `https://localhost:8445`.
+
+1. Make sure each cluster has an Active-Active database member database with the name `database1`.
+
+    In a real-world deployment, cluster 1 and cluster 2 would most likely be
+    in separate data centers in different regions. However, for
+    local testing we created the scale-minimized deployment using two
+    local clusters running on the same host.
+
+<!-- Also in getting-started-crdbs.md -->
+## Test connection
+
+With the Redis database created, you are ready to connect to your
+database. See [Connect to Active-Active databases]({{< relref "/operate/rs/7.4/databases/active-active/connect" >}}) for tutorials and examples of multiple connection methods.
+---
+Title: Active-Active geo-distributed Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Overview of the Active-Active database in Redis Enterprise Software
+hideListLinks: true
+linktitle: Active-Active
+weight: 40
+url: '/operate/rs/7.4/databases/active-active/'
+---
+In Redis Enterprise, Active-Active geo-distribution is based on [CRDT technology](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type).
+The Redis Enterprise implementation of CRDT is called an Active-Active database (formerly known as CRDB).
+With Active-Active databases, applications can read and write to the same data set from different geographical locations seamlessly and with latency less than one millisecond (ms),
+without changing the way the application connects to the database.
+
+Active-Active databases also provide disaster recovery and accelerated data read-access for geographically distributed users.
+
+
+## High availability
+
+The [high availability]({{< relref "/operate/rs/7.4/databases/durability-ha/" >}}) that Active-Active replication provides is built upon a number of Redis Enterprise Software features (such as [clustering]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}), [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}), and [replica HA]({{< relref "/operate/rs/7.4/databases/configure/replica-ha.md" >}})) as well as some features unique to Active-Active ([multi-primary replication]({{<relref "#multi-primary-replication/">}}), [automatic conflict resolution]({{<relref "#conflict-resolution/">}}), and [strong eventual consistency]({{<relref "#strong-eventual-consistency/">}})).
+
+Clustering and replication are used together in Active-Active databases to distribute multiple copies of the dataset across multiple nodes and multiple clusters. As a result, a node or cluster is less likely to become a single point of failure. If a primary node or primary shard fails, a replica is automatically promoted to primary. To avoid having one node hold all copies of certain data, the [replica HA]({{< relref "/operate/rs/7.4/databases/configure/replica-ha.md" >}}) feature (enabled by default) automatically migrates replica shards to available nodes.
+
+## Multi-primary replication
+
+In Redis Enterprise Software, replication copies data from primary shards to replica shards. Active-Active geo-distributed replication also copies both primary and replica shards to other clusters. Each Active-Active database needs to span at least two clusters; these are called participating clusters.
+
+Each participating cluster hosts an instance of your database, and each instance has its own primary node. Having multiple primary nodes means you can connect to the proxy in any of your participating clusters. Connecting to the closest cluster geographically enables near-local latency. Multi-primary replication (previously referred to as multi-master replication) also means that your users still have access to the database if one of the participating clusters fails.
+
+{{< note >}}
+Active-Active databases do not replicate the entire database, only the data.
+Database configurations, LUA scripts, and other support info are not replicated.
+{{< /note >}}
+
+## Syncer
+
+Keeping multiple copies of the dataset consistent across multiple clusters is no small task. To achieve consistency between participating clusters, Redis Active-Active replication uses a process called the [syncer]({{< relref "/operate/rs/7.4/databases/active-active/syncer" >}}). 
+
+The syncer keeps a [replication backlog]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog/" >}}), which stores changes to the dataset that the syncer sends to other participating clusters. The syncer uses partial syncs to keep replicas up to date with changes, or a full sync in the event a replica or primary is lost.
+
+## Conflict resolution
+
+Because you can connect to any participating cluster to perform a write operation, concurrent and conflicting writes are always possible. Conflict resolution is an important part of the Active-Active technology. Active-Active databases only use [conflict-free replicated data types (CRDTs)](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type). These data types provide a predictable conflict resolution and don't require any additional work from the application or client side.
+
+When developing with CRDTs for Active-Active databases, you need to consider some important differences. See [Develop applications with Active-Active databases]({{< relref "/operate/rs/7.4/databases/active-active/develop/_index.md" >}}) for related information.
+
+
+## Strong eventual consistency
+
+Maintaining strong consistency for replicated databases comes with tradeoffs in scalability and availability. Redis Active-Active databases use a strong eventual consistency model, which means that local values may differ across replicas for short periods of time, but they all eventually converge to one consistent state. Redis uses vector clocks and the CRDT conflict resolution to strengthen consistency between replicas. You can also enable the causal consistency feature to preserve the order of operations as they are synchronized among replicas.
+
+Other Redis Enterprise Software features can also be used to enhance the performance, scalability, or durability of your Active-Active database. These include [data persistence]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}), [multiple active proxies]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy.md" >}}), [distributed synchronization]({{< relref "/operate/rs/7.4/databases/active-active/synchronization-mode.md" >}}), [OSS Cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api.md" >}}), and [rack-zone awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}).
+
+## Next steps
+
+- [Plan your Active-Active deployment]({{< relref "/operate/rs/7.4/databases/active-active/planning.md" >}})
+- [Get started with Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/get-started.md" >}})
+- [Create an Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/create.md" >}})
+---
+Title: Configure high availability for replica shards
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure high availability for replica shards so that the cluster automatically
+  migrates the replica shards to an available node.
+linkTitle: Replica high availability
+weight: 50
+url: '/operate/rs/7.4/databases/configure/replica-ha/'
+---
+
+When you enable [database replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}),
+Redis Enterprise Software creates a replica of each primary (master) 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.
+
+Enabling _replica\_ha_ configures the cluster to automatically replicate the promoted replica on an available node. 
+This automatically returns the database to a state where there are two copies of the data: 
+the former replica shard which has been promoted to primary and a new replica shard.
+
+An available node:
+
+1. Meets replica migration requirements, such as [rack-awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}).
+1. Has enough available RAM to store the replica shard.
+1. Does not also contain the master shard.
+
+In practice, replica migration creates a new replica shard and copies the data from the master shard to the new replica shard.
+
+For example:
+
+1. Node:2 has a master shard and node:3 has the corresponding replica shard.
+1. Either:
+
+    - Node:2 fails and the replica shard on node:3 is promoted to master.
+    - Node:3 fails and the master shard is no longer replicated to the replica shard on the failed node.
+
+1. If replica HA is enabled, a new replica shard is created on an available node.
+1. The data from the master shard is replicated to the new replica shard.
+
+{{< note >}}
+- Replica HA follows all prerequisites of replica migration, such as [rack-awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}).
+- Replica HA migrates as many shards as possible based on available DRAM in the target node. When no DRAM is available, replica HA stops migrating replica shards to that node.
+{{< /note >}}
+
+## Configure high availability for replica shards
+
+If replica high availability is enabled for both the cluster and a database,
+the database's replica shards automatically migrate to another node when a master or replica shard fails.
+If replica HA is not enabled at the cluster level,
+replica HA will not migrate replica shards even if replica HA is enabled for a database.
+
+Replica high availability is enabled for the cluster by default.
+
+When you create a database using the Cluster Manager UI, replica high availability is enabled for the database by default if you enable replication.
+
+{{<image filename="images/rs/screenshots/databases/config-replica-ha-enabled.png" alt="When you select the Replication checkbox in the High availability & durability section of the database configuration screen, the Replica high availability checkbox is also selected by default.">}}
+
+To use replication without replication high availability, clear the **Replica high availability** checkbox.
+
+You can also enable or turn off replica high availability for a database using `rladmin` or the REST API.
+
+{{< note >}}
+For Active-Active databases, replica HA is enabled for the database by default to make sure that replica shards are available for Active-Active replication.
+{{< /note >}}
+
+### Configure cluster policy for replica HA
+
+{{<note>}}
+The replica HA cluster policy is deprecated as of Redis Enterprise Software version 7.2.4.
+{{</note>}}
+
+To enable or turn off replica high availability by default for the entire cluster, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster slave_ha { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "slave_ha": <boolean> }
+    ```
+
+### Turn off replica HA for a database
+
+To turn off replica high availability for a specific database using `rladmin`, run:
+
+``` text
+rladmin tune db db:<ID> slave_ha disabled
+```
+
+You can use the database name in place of `db:<ID>` in the preceding command.
+
+
+## Configuration options
+
+You can see the current configuration options for replica HA with:
+
+``` text
+rladmin info cluster
+```
+
+### Grace period
+
+By default, replica HA has a 10-minute grace period after node failure and before new replica shards are created.
+
+{{<note>}}The default grace period is 30 minutes for containerized applications using [Redis Enterprise Software for Kubernetes]({{< relref "/operate/kubernetes/" >}}).{{</note>}}
+
+To configure this grace period from rladmin, run:
+
+``` text
+rladmin tune cluster slave_ha_grace_period <time_in_seconds>
+```
+
+
+### Shard priority
+
+Replica shard migration is based on priority.  When memory resources are limited, the most important replica shards are migrated first:
+
+1. `slave_ha_priority` - Replica shards with higher 
+    integer values are migrated before shards with lower values.
+
+    To assign priority to a database, run:
+
+    ``` text
+    rladmin tune db db:<ID> slave_ha_priority <positive integer>
+    ```
+    
+    You can use the database name in place of `db:<ID>` in the preceding command.
+
+1. Active-Active databases - Active-Active database synchronization uses replica shards to synchronize between the replicas.
+1. Database size - It is easier and more efficient to move replica shards of smaller databases.
+1. Database UID - The replica shards of databases with a higher UID are moved first.
+
+### Cooldown periods
+
+Both the cluster and the database have cooldown periods.
+
+After node failure, the cluster cooldown period (`slave_ha_cooldown_period`) prevents another replica migration due to another node failure for any
+database in the cluster until the cooldown period ends. The default is one hour.
+
+After a database is migrated with replica HA,
+it cannot go through another migration due to another node failure until the cooldown period for the database (`slave_ha_bdb_cooldown_period`) ends. The default is two hours.
+
+To configure cooldown periods, use [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+- For the cluster:
+
+    ``` text
+    rladmin tune cluster slave_ha_cooldown_period <time_in_seconds>
+    ```
+
+- For all databases in the cluster:
+
+    ``` text
+    rladmin tune cluster slave_ha_bdb_cooldown_period <time_in_seconds>
+    ```
+
+### Alerts
+
+The following alerts are sent during replica HA activation:
+
+- Shard migration begins after the grace period.
+- Shard migration fails because there is no available node (sent hourly).
+- Shard migration is delayed because of the cooldown period.
+---
+Title: Change database upgrade configuration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure cluster-wide policies that affect default database upgrades.
+linkTitle: Upgrade configuration
+toc: 'true'
+weight: 15
+url: '/operate/rs/7.4/databases/configure/db-upgrade/'
+---
+
+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:
+
+1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Upgrade configuration**.
+
+1. Change database [upgrade configuration settings](#upgrade-config-settings).
+
+1. Select **Save**.
+
+## Upgrade configuration settings {#upgrade-config-settings}
+
+### Database shard parallel upgrade
+
+To change the number of shards upgraded in parallel during database upgrades, use one of the following methods:
+
+- Cluster Manager UI – Edit **Database shard parallel upgrade** in [**Upgrade configuration**](#edit-upgrade-configuration)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster parallel_shards_upgrade { all | <integer> }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "parallel_shards_upgrade": <integer> }
+    ```
+
+### RESP3 support
+
+The cluster-wide option `resp3_default` determines the default value of the `resp3` option, which enables or deactivates RESP3 for a database, upon upgrading a database to version 7.2 or later. `resp3_default` is set to `enabled` by default.
+
+To change `resp3_default` to `disabled`, use one of the following methods:
+
+- Cluster Manager UI – Edit **RESP3 support** in [**Upgrade configuration**](#edit-upgrade-configuration)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster resp3_default { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "resp3_default": <boolean> }
+    ```
+---
+Title: Enable OSS Cluster API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: OSS Cluster API
+weight: 20
+aliases: 
+    - /operate/rs/concepts/data-access/oss-cluster-api
+url: '/operate/rs/7.4/databases/configure/oss-cluster-api/'
+---
+
+Review [Redis OSS Cluster API]({{< relref "/operate/rs/7.4/clusters/optimize/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.  
+
+The database must:
+
+- Use the standard [hashing policy]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering#supported-hashing-policies" >}}).
+- Have the [proxy policy]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}) set to either `all-master-shards` or `all-nodes`.
+
+In addition, the database must _not_:
+
+- Use node `include` or `exclude` in the proxy policy.
+- Use [RediSearch]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}), [RedisTimeSeries]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}), or [RedisGears]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1" >}}) modules.
+
+The OSS Cluster API setting applies to individual databases instead of the entire cluster.
+
+## Enable OSS Cluster API support
+
+You can use the Cluster Manager UI or the `rladmin` utility to enable OSS Cluster API support for a database.
+
+### Cluster Manager UI
+
+When you use the Cluster Manager UI to enable the OSS Cluster API, it automatically configures the [prerequisites]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api#prerequisites" >}}).
+
+To enable the OSS Cluster API for an existing database in the Cluster Manager UI:
+
+1. From the database's **Configuration** tab, select **Edit**.
+
+1. Expand the **Clustering** section.
+
+1. Turn on the **OSS Cluster API** toggle.
+
+    {{<image filename="images/rs/screenshots/databases/config-clustering-oss-cluster-api.png" alt="Use the *OSS Cluster API* setting to enable the API for the selected database.">}}
+
+1. Select **Save**.
+
+You can also use the Cluster Manager UI to enable the setting when creating a new database.
+
+### Command line (`rladmin`)
+
+You can use the [`rladmin` utility]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/" >}}) to enable the OSS Cluster API for Redis Enterprise Software databases, including Replica Of databases.
+
+For Active-Active (CRDB) databases, [use the crdb-cli utility](#active-active-databases).
+
+Ensure the [prerequisites]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api#prerequisites" >}}) have been configured.  Then, enable the OSS Cluster API for a Redis database from the command line:
+
+```sh
+$ rladmin tune db <database name or ID> oss_cluster enabled
+```
+
+To determine the current setting for a database from the command line, use `rladmin info db` to return the value of the `oss_cluster` setting.
+
+```sh
+$ rladmin info db test | grep oss_cluster:
+  oss_cluster: enabled
+```
+
+The OSS Cluster API setting applies to the specified database only; it does not apply to the cluster.
+
+### Active-Active databases
+
+Ensure the [prerequisites]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api#prerequisites" >}}) have been configured.  Then, use the `crdb-cli` utility to enable the OSS Cluster API for Active-Active databases:
+
+```sh
+$ crdb-cli crdb update --crdb-guid <GUID> --oss-cluster true
+```
+
+For best results, you should do this when you first create the database.  
+
+Here's the basic process:
+
+1. Create the Active-Active database: 
+
+    ```sh
+    $ crdb-cli crdb create --name <name> \
+       --memory-size 10g --port <port> \
+       --sharding true --shards-count 2  \
+       --replication true --oss-cluster true --proxy-policy all-master-shards \
+       --instance fqdn=<fqdn>,username=<user>,password=<pass> \
+       --instance fqdn=<fqdn>,username=<user>,password=<pass> \
+       --instance fqdn=<fqdn>,username=<user>,password=<pass>
+    ```
+
+1. Obtain the CRDB-GUID ID for the new database:
+
+    ```sh
+    $ crdb-cli crdb list
+    CRDB-GUID    NAME   REPL-ID  CLUSTER-FQDN
+    <CRDB-GUID>  Test   4        cluster1.local
+    ```
+
+1. Use the CRDB-GUID ID to enable the OSS Cluster API:
+
+    ```sh
+    $ crdb-cli crdb update --crdb-guid <CRDB-GUID> \
+        --oss-cluster true
+    ```
+
+The OSS Cluster API setting applies to all of the instances of the Active-Active database.
+
+## Turn off OSS Cluster API support
+
+To deactivate OSS Cluster API support for a database, either:
+
+- Use the Cluster Manager UI to turn off the **OSS Cluster API** toggle from the database **Configuration** settings.
+
+- Use the appropriate utility to deactivate the OSS Cluster API setting.
+
+    For standard databases, including Replica Of, use `rladmin`:
+
+    ```sh
+    $ rladmin tune db <name or ID> oss_cluster disabled
+    ```
+
+    For Active-Active databases, use `crdb-cli`:
+
+    ```sh
+    $ crdb-cli crdb update --crdb-guid <CRDB-GUID> \
+        --oss-cluster false
+    ```
+
+## Multi-key command support
+
+When you enable the OSS Cluster API for a database, 
+[multi-key commands]({{< relref "/operate/rc/databases/configuration/clustering#multikey-operations" >}}) are only allowed when all keys are mapped to the same slot.
+
+To verify that your database meets this requirement, make sure that the `CLUSTER KEYSLOT` reply is the same for all keys affected by the multi-key command.  To learn more, see [multi-key operations]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering#multikey-operations" >}}).
+---
+Title: Configure shard placement
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure shard placement to improve performance.
+linktitle: Shard placement
+weight: 60
+url: '/operate/rs/7.4/databases/configure/shard-placement/'
+---
+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]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy.md" >}}) helps to maintain optimal performance and resiliency.
+
+{{< embed-md "shard-placement-intro.md"  >}}
+
+## Default shard placement policy
+
+When you create a new cluster, the cluster configuration has a `dense` default shard placement policy.
+When you create a database, this default policy is applied to the new database.
+
+To see the current default shard placement policy, run `rladmin info cluster`:
+
+{{< image filename="/images/rs/shard_placement_info_cluster.png" >}}
+
+To change the default shard placement policy so that new databases are created with the `sparse` shard placement policy, run:
+
+```sh
+rladmin tune cluster default_shards_placement [ dense | sparse ]
+```
+
+## Shard placement policy for a database
+
+To see the shard placement policy for a database in `rladmin status`.
+
+{{< image filename="/images/rs/shard_placement_rladmin_status.png" >}}
+
+To change the shard placement policy for a database, run:
+
+```sh
+rladmin placement db [ database name | database ID ] [ dense | sparse ]
+```
+---
+Title: Configure proxy policy
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Proxy policy
+weight: 40
+url: '/operate/rs/7.4/databases/configure/proxy-policy/'
+---
+Redis Enterprise Software (RS) provides high-performance data access
+through a proxy process that manages and optimizes access to shards
+within the RS 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 these proxy policies:
+
+| **Proxy Policy** | **Description** |
+|------------|-----------------|
+| Single | There is only a single proxy that is bound to the database. This is the default database configuration and preferable in most use cases. |
+| All Master Shards | There are multiple proxies that are bound to the database, one on each node that hosts a database master shard. This mode fits most use cases that require multiple proxies. |
+| All Nodes | There are multiple proxies that are bound to the database, one on each node in the cluster, regardless of whether or not there is a shard from this database on the node. This mode should be used only in special cases, such as [using a load balancer]({{< relref "/operate/rs/7.4/networking/cluster-lba-setup.md" >}}). |
+
+{{< note >}}
+Manual intervention is also available via the rladmin bind add and
+remove commands.
+{{< /note >}}
+
+## Database configuration
+
+A database can be configured with a proxy policy using rladmin bind.
+
+Warning: Any configuration update which causes existing proxies to be
+unbounded can cause existing client connections to get disconnected.
+
+You can run rladmin to control and view the existing settings for proxy
+configuration.
+
+The **info** command on cluster returns the existing proxy policy for
+sharded and non-sharded (single shard) databases.
+
+```sh
+$ rladmin info cluster
+cluster configuration:
+   repl_diskless: enabled
+   default_non_sharded_proxy_policy: single
+   default_sharded_proxy_policy: single
+   default_shards_placement: dense
+   default_shards_overbooking: disabled
+   default_fork_evict_ram: enabled
+   default_redis_version: 3.2
+   redis_migrate_node_threshold: 0KB (0 bytes)
+   redis_migrate_node_threshold_percent: 8 (%)
+   redis_provision_node_threshold: 0KB (0 bytes)
+   redis_provision_node_threshold_percent: 12 (%)
+   max_simultaneous_backups: 4
+   watchdog profile: local-network
+```
+
+You can configure the proxy policy using the `bind` command in
+rladmin. The following command is an example that changes the bind
+policy for a database named "db1" with an endpoint id "1:1" to "All
+Master Shards" proxy policy.
+
+```sh
+rladmin bind db db1 endpoint 1:1 policy all-master-shards
+```
+
+The next command performs the same task using the database id in place of the name.  The id of this database is "1".
+
+```sh
+rladmin bind db db:1 endpoint 1:1 policy all-master-shards
+```
+
+{{< note >}}
+You can find the endpoint id for the endpoint argument by running
+*status* command for rladmin. Look for the endpoint id information under
+the *ENDPOINT* section of the output.
+{{< /note >}}
+
+### Reapply policies after topology changes
+
+If you want to reapply the policy after topology changes, such as node restarts,
+failovers and migrations, run this command to reset the policy:
+
+```sh
+rladmin bind db db:<ID> endpoint <endpoint id> policy <all-master-shards|all-nodes>
+```
+
+This is not required with single policies.
+
+#### Other implications
+
+During the regular operation of the cluster different actions might take
+place, such as automatic migration or automatic failover, which change
+what proxy needs to be bound to what database. When such actions take
+place the cluster attempts, as much as possible, to automatically change
+proxy bindings to adhere to the defined policies. That said, the cluster
+attempts to prevent any existing client connections from being
+disconnected, and hence might not entirely enforce the policies. In such
+cases, you can enforce the policy using the appropriate rladmin
+commands.
+
+## About multiple active proxy support
+
+RS allows multiple databases to be created. Each database gets an
+endpoint (a unique URL and port on the FQDN). This endpoint receives all
+the traffic for all operations for that database. By default, RS binds
+this database endpoint to one of the proxies on a single node in the
+cluster. This proxy becomes an active proxy and receives all the
+operations for the given database. (note that if the node with the
+active proxy fails, a new proxy on another node takes over as part of
+the failover process automatically).
+
+In most cases, a single proxy can handle a large number of operations
+without consuming additional resources. However, under high load,
+network bandwidth or a high rate of packets per second (PPS) on the
+single active proxy can become a bottleneck to how fast database
+operation can be performed. In such cases, having multiple active
+proxies, across multiple nodes, mapped to the same external database
+endpoint, can significantly improve throughput.
+
+With the multiple active proxies capability, RS enables you to configure
+a database to have multiple internal proxies in order to improve
+performance, in some cases. It is important to note that, even though
+multiple active proxies can help improve the throughput of database
+operations, configuring multiple active proxies may cause additional
+latency in operations as the shards and proxies are spread across
+multiple nodes in the cluster.
+
+{{< note >}}
+When the network on a single active proxy becomes the bottleneck,
+you might also look into enabling the multiple NIC support in RS. With
+nodes that have multiple physical NICs (Network Interface Cards), you
+can configure RS to separate internal and external traffic onto
+independent physical NICs. For more details, refer to [Manage IP addresses]({{< relref "/operate/rs/7.4/networking/multi-ip-ipv6" >}}).
+{{< /note >}}
+
+Having multiple proxies for a database can improve RS's ability for fast
+failover in case of proxy and/or node failure. With multiple proxies for
+a database, there is no need for a client to wait for the cluster
+to spin up another proxy and a DNS change in most cases, the client
+just uses the next IP in the list to connect to another proxy.
+---
+Title: Configure database persistence
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure database persistence with either an append-only file
+  (AOF) or snapshots.
+linktitle: Persistence
+weight: 30
+url: '/operate/rs/7.4/databases/configure/database-persistence/'
+---
+All data is stored and managed exclusively in either RAM or RAM + flash Memory ([Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}})) and therefore, is at risk of being lost upon a process or server
+failure. As Redis Enterprise Software is not just a caching solution, but also a full-fledged database, [persistence](https://redis.com/redis-enterprise/technology/durable-redis/) to disk
+is critical. Therefore, Redis Enterprise Software supports persisting data to disk on a per-database basis and in multiple ways.
+
+[Persistence](https://redis.com/redis-enterprise/technology/durable-redis/) can be configured either during database creation or by editing an existing
+database's configuration. While the persistence model can be changed dynamically, it can take time for your database to switch from one persistence model to the other. It depends on what you are switching from and to, but also on the size of your database.
+
+## Configure database persistence
+
+You can configure persistence when you [create a database]({{< relref "/operate/rs/7.4/databases/create" >}}), or you can edit an existing database's configuration:
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select **Edit**.
+
+1. Expand the **High Availability** section.
+
+1. For **Persistence**, select an [option](#data-persistence-options) from the list.
+
+1. Select **Save**.
+
+## Data persistence options
+
+There are six options for persistence in Redis Enterprise Software:
+
+|  **Options** | **Description** |
+|  ------ | ------ |
+|  None | Data is not persisted to disk at all. |
+|  Append-only file (AOF) - fsync every write | Data is fsynced to disk with every write. |
+|  Append-only file (AOF) - fsync every 1 sec | Data is fsynced to disk every second. |
+|  Snapshot, every 1 hour | A snapshot of the database is created every hour. |
+|  Snapshot, every 6 hours | A snapshot of the database is created every 6 hours. |
+|  Snapshot, every 12 hours | A snapshot of the database is created every 12 hours. |
+
+## Select a persistence strategy
+
+When selecting your persistence strategy, you should take into account your tolerance for data loss and performance needs. There will always be tradeoffs between the two.
+The fsync() system call syncs data from file buffers to disk. You can configure how often Redis performs an fsync() to most effectively make tradeoffs between performance and durability for your use case.
+Redis supports three fsync policies: every write, every second, and disabled.
+
+Redis also allows snapshots through RDB files for persistence. Within Redis Enterprise, you can configure both snapshots and fsync policies.
+
+For any high availability needs, use replication to further reduce the risk of data loss.
+
+**For use cases where data loss has a high cost:**
+
+Append-only file (AOF) - fsync every write - Redis Enterprise sets the Redis directive `appendfsyncalways`.  With this policy, Redis will wait for the write and the fsync to complete prior to sending an acknowledgement to the client that the data has written. This introduces the performance overhead of the fsync in addition to the execution of the command. The fsync policy always favors durability over performance and should be used when there is a high cost for data loss.
+
+**For use cases where data loss is tolerable only limitedly:**
+
+Append-only file (AOF) - fsync every 1 sec - Redis will fsync any newly written data every second. This policy balances performance and durability and should be used when minimal data loss is acceptable in the event of a failure. This is the default Redis policy. This policy could result in between 1 and 2 seconds worth of data loss but on average this will be closer to one second.
+
+{{< note >}}
+If you use AOF for persistence, enable replication to improve performance. When both features are enabled for a database, the replica handles persistence, which prevents any performance impact on the master.
+{{< /note >}}
+
+**For use cases where data loss is tolerable or recoverable for extended periods of time:**
+
+- Snapshot, every 1 hour - Performs a full backup every hour.
+- Snapshot, every 6 hour - Performs a full backup every 6 hours.
+- Snapshot, every 12 hour - Performs a full backup every 12 hours.
+- None - Does not back up or persist data at all.
+
+## Append-only file (AOF) vs snapshot (RDB)
+
+Now that you know the available options, to assist in making a decision
+on which option is right for your use case, here is a table about the
+two:
+
+|  **Append-only File (AOF)** | **Snapshot (RDB)** |
+|------------|-----------------|
+|  More resource intensive | Less resource intensive |
+|  Provides better durability (recover the latest point in time) | Less durable |
+|  Slower time to recover (Larger files) | Faster recovery time |
+|  More disk space required (files tend to grow large and require compaction) | Requires less resources (I/O once every several hours and no compaction required) |
+
+## Active-Active data persistence 
+
+Active-Active databases support AOF persistence only.  Snapshot persistence is not supported for Active-Active databases.
+
+If an Active-Active database is using snapshot persistence, use `crdb-cli` to switch to AOF persistence:
+
+```text
+crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config \
+   '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+## Auto Tiering data persistence
+
+Auto Tiering flash storage is not considered persistent storage.
+
+Flash-based databases are expected to hold larger datasets, and shard repair times can take longer after node failures. To better protect the database against node failures with longer repair times, consider enabling master and replica dual data persistence.
+
+However, dual data persistence with replication adds some processor
+and network overhead, especially for cloud configurations
+with network-attached persistent storage, such as EBS-backed
+volumes in AWS.
+
+There may be times when performance is critical for your use case and
+you don't want to risk data persistence adding latency.
+
+You can enable or turn off data persistence on the master shards using the
+following `rladmin` command:
+
+```sh
+rladmin tune db <database_ID_or_name> master_persistence <disabled | enabled>
+```
+---
+Title: Configure database defaults
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster-wide policies that determine default settings when creating new
+  databases.
+linkTitle: Database defaults
+toc: 'true'
+weight: 10
+url: '/operate/rs/7.4/databases/configure/db-defaults/'
+---
+
+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:
+
+1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Database defaults**.
+
+1. Configure [database defaults](#db-defaults).
+
+    {{<image filename="images/rs/screenshots/databases/db-defaults.png" alt="Database defaults configuration panel.">}}
+
+1. Select **Save**.
+
+## Database defaults {#db-defaults}
+
+### Endpoint configuration
+
+You can choose a predefined endpoint configuration to use the recommended database proxy and shards placement policies for your use case. If you want to set these policies manually instead, select **Custom** endpoint configuration.
+
+| Endpoint configuration | Database proxy | Shards placement | Description |
+|-----------|------------|----------------|------------------|------------|
+| Enterprise clustering | Single | Dense | Sets up a single endpoint that uses DNS to automatically reflect IP address updates after failover or topology changes. |
+| Using a load balancer | All nodes | Sparse | Configure Redis with a load balancer like HAProxy or Nginx for environments without DNS. |
+| Multiple endpoints | All primary shards | Sparse | To set up multiple endpoints, enable **OSS Cluster API** in the database settings and ensure client support. Clients initially connect to the primary node to retrieve the cluster topology, which allows direct connections to individual Redis proxies on each node. |
+| Custom | Single, all primary shards, or all nodes | Dense or sparse | Manually choose default database proxy and shards placement policies. |
+
+### Database proxy
+
+Redis Enterprise Software uses [proxies]({{< relref "/operate/rs/7.4/references/terminology#proxy" >}}) to manage and optimize access to database shards. Each node in the cluster runs a single proxy process, which can be active (receives incoming traffic) or passive (waits for failovers).
+
+You can configure default [proxy policies]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}) to determine which nodes' proxies are active and bound to new databases by default.
+
+To configure the default database proxy policy using the Cluster Manager UI:
+
+1. [**Edit database defaults**](#edit-database-defaults). 
+
+1. Select a predefined [**Endpoint Configuration**](#endpoint-configuration) to use a recommended database proxy policy, or choose **Custom** to set the policy manually. Changing the database proxy default in the Cluster Manager UI affects both sharded and non-sharded proxy policies.
+
+    {{<image filename="images/rs/screenshots/databases/db-defaults-endpoint-config-custom.png" alt="The Database defaults panel lets you select Database proxy and Shards placement if Endpoint Configuration is set to Custom.">}}
+
+#### Non-sharded proxy policy
+
+To configure the default proxy policy for non-sharded databases, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_non_sharded_proxy_policy { single | all-master-shards | all-nodes }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_non_sharded_proxy_policy": "single | all-master-shards | all-nodes" }
+    ```
+
+#### Sharded proxy policy
+
+To configure the default proxy policy for sharded databases, use one of the following methods:
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_sharded_proxy_policy { single | all-master-shards | all-nodes }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_sharded_proxy_policy": "single | all-master-shards | all-nodes" }
+    ```
+
+### Shards placement
+
+The default [shard placement policy]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy" >}}) determines the distribution of database shards across nodes in the cluster.
+
+Shard placement policies include:
+
+- `dense`: places shards on the smallest number of nodes.
+
+- `sparse`: spreads shards across many nodes.
+
+To configure default shard placement, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. [**Edit database defaults**](#edit-database-defaults). 
+
+    1. Select a predefined [**Endpoint Configuration**](#endpoint-configuration) to use a recommended shards placement policy, or choose **Custom** to set the policy manually.
+
+        {{<image filename="images/rs/screenshots/databases/db-defaults-endpoint-config-custom.png" alt="The Database defaults panel lets you select Database proxy and Shards placement if Endpoint Configuration is set to Custom.">}}
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_shards_placement { dense | sparse }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_shards_placement": "dense | sparse" }
+    ```
+
+### Database version
+
+New databases use the default Redis database version unless you select a different **Database version** when you [create a database]({{<relref "/operate/rs/7.4/databases/create">}}) in the Cluster Manager UI or specify the `redis_version` in a [create database REST API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs" >}}).
+
+To configure the Redis database version, use one of the following methods:
+
+- Cluster Manager UI: Edit **Database version** in [**Database defaults**](#edit-database-defaults)
+
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster default_redis_version <x.y>
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_provisioned_redis_version": "x.y" }
+    ```
+
+### Internode encryption
+
+Enable [internode encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption" >}}) to encrypt data in transit between nodes for new databases by default.
+
+To enable or turn off internode encryption by default, use one of the following methods:
+
+- Cluster Manager UI: Edit **Internode Encryption** in [**Database defaults**](#edit-database-defaults)
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster data_internode_encryption { enabled | disabled }
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "data_internode_encryption": <boolean> }
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure settings specific to each database.
+hideListLinks: true
+linktitle: Configure
+title: Configure database settings
+toc: 'true'
+weight: 20
+url: '/operate/rs/7.4/databases/configure/'
+---
+
+You can manage your Redis Enterprise Software databases with several tools:
+
+- [Cluster Manager UI](#edit-database-settings) (the web-based user interface)
+
+- Command-line tools:
+
+    - [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) for standalone database configuration
+
+    - [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) for Active-Active database configuration
+
+    - [`redis-cli`]({{< relref "/develop/tools/cli" >}}) for Redis Open Source configuration
+
+- [REST API]({{< relref "/operate/rs/7.4/references/rest-api/_index.md" >}})
+
+## Edit database settings
+
+You can change the configuration of a Redis Enterprise Software database at any time.<!--more-->
+
+To edit the configuration of a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database you want to edit.
+
+1. From the **Configuration** tab, select **Edit**.
+
+1. Change any [configurable database settings](#config-settings).
+
+    {{< note >}}
+For [Active-Active database instances]({{< relref "/operate/rs/7.4/databases/active-active" >}}), most database settings only apply to the instance that you are editing.
+    {{< /note >}}
+
+1. Select **Save**.
+
+## Configuration settings {#config-settings}
+
+- **Database version** - Select the Redis version when you create a database.
+
+- **Name** - The database name requirements are:
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+- **Endpoint port number** - You can define the port number that clients use to connect to the database. Otherwise, a port is randomly selected.
+
+    {{< note >}}
+You cannot change the [port number]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}})
+after the database is created.
+    {{< /note >}}
+
+- **Memory limit** - [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}) include all database replicas and shards, including replica shards in database replication and database shards in database clustering.
+
+    If the total size of the database in the cluster reaches the memory limit, the data eviction policy for the database is enforced.
+
+    {{< note >}}
+If you create a database with Auto Tiering enabled, you also need to set the RAM-to-Flash ratio
+for this database. Minimum RAM is 10%. Maximum RAM is 50%.
+    {{< /note >}}
+
+- [**Capabilities**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) (previously **Modules**) - When you create a new in-memory database, you can enable multiple Redis Stack capabilities in the database. For Auto Tiering databases, you can enable capabilities that support Auto Tiering. See [Redis Enterprise and Redis Stack feature compatibility 
+]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}) for compatibility details.
+        
+    {{< note >}}
+To use Redis Stack capabilities, enable them when you create a new database.
+You cannot enable them after database creation.
+    {{< /note >}} 
+        
+    To add capabilities to the database:
+
+    1. In the **Capabilities** section, select one or more capabilities.
+    
+    1. To customize capabilities, select **Parameters** and enter the optional custom configuration.
+    
+    1. Select **Done**.
+
+### High availability & durability
+
+- [**Replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}) - We recommend you use intra-cluster replication to create replica shards for each database for high availability.
+
+    If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}), you can also enable rack-zone awareness for the database.
+
+- [**Replica high availability**]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) - Automatically migrates replica shards to an available node if a replica node fails or is promoted to primary.
+
+- [**Persistence**]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}) - To protect against loss of data stored in RAM, you can enable data persistence and store a copy of the data on disk with snapshots or an Append Only File.
+
+- [**Data eviction policy**]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy.md" >}}) - By default, when the total size of the database reaches its memory limit the database evicts keys according to the least recently used keys out of all keys with an "expire" field set in order to make room for new keys. You can select a different data eviction policy.
+
+### Clustering
+
+- **Sharding** - You can either:
+    - Turn on **Sharding** to enable [database clustering]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}) and select the number of database shards.
+
+        When database clustering is enabled, databases are subject to limitations on [Multi-key commands]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}).
+        
+        You can increase the number of shards in the database at any time.
+
+        You can accept the [standard hashing policy]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering#standard-hashing-policy" >}}), which is compatible with Redis Open Source, or define a [custom hashing policy]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering#custom-hashing-policy" >}}) to define where keys are located in the clustered database.
+
+    - Turn off **Sharding** to use only one shard so that you can use [Multi-key commands]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}) without the limitations.
+
+- [**OSS Cluster API**]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api.md" >}}) - The OSS Cluster API configuration allows access to multiple endpoints for increased throughput.
+
+    This configuration requires clients to connect to the primary node to retrieve the cluster topology before they can connect directly to proxies on each node.
+    
+    When you enable the OSS Cluster API, shard placement changes to _Sparse_, and the database proxy policy changes to _All primary shards_ automatically.
+
+    {{<note>}}
+You must use a client that supports the cluster API to connect to a database that has the cluster API enabled.
+    {{</note>}}
+
+- [**Shards placement**]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy" >}}) - Determines how to distribute database shards across nodes in the cluster.
+
+    - _Dense_ places shards on the smallest number of nodes.
+    
+    - _Sparse_ spreads shards across many nodes.
+
+- [**Database proxy**]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}) - Determines the number and location of active proxies, which manage incoming database operation requests.
+
+### Replica Of
+
+With [**Replica Of**]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create.md" >}}), you can make the database a repository for keys from other databases.
+
+### Scheduled backup
+
+You can configure [periodic backups]({{< relref "/operate/rs/7.4/databases/import-export/schedule-backups" >}}) of the database, including the interval and backup location parameters.
+
+### Alerts
+
+Select [alerts]({{< relref "/operate/rs/7.4/clusters/monitoring#database-alerts" >}}) to show in the database status and configure their thresholds.
+
+You can also choose to [send alerts by email]({{< relref "/operate/rs/7.4/clusters/monitoring#send-alerts-by-email" >}}) to relevant users.
+
+### TLS
+
+You can require [**TLS**]({{< relref "/operate/rs/7.4/security/encryption/tls/" >}}) encryption and authentication for all communications, TLS encryption and authentication for Replica Of communication only, and TLS authentication for clients.
+
+### Access control
+
+- **Unauthenticated access** - You can access the database as the default user without providing credentials.
+
+- **Password-only authentication** - When you configure a password for your database's default user, all connections to the database must authenticate with the [AUTH command]({{< relref "/commands/auth" >}}).
+
+    If you also configure an access control list, connections can specify other users for authentication, and requests are allowed according to the Redis ACLs specified for that user.
+
+    Creating a database without ACLs enables a *default* user with full access to the database. You can secure default user access by requiring a password.
+
+- **Access Control List** - You can specify the [user roles]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) that have access to the database and the [Redis ACLs]({{< relref "/operate/rs/7.4/security/access-control/redis-acl-overview" >}}) that apply to those connections.
+
+    To define an access control list for a database:
+
+    1. In **Security > Access Control > Access Control List**, select **+ Add ACL**.
+
+    1. Select a [role]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) to grant database access.
+
+    1. Associate a [Redis ACL]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) with the role and database.
+
+    1. Select the check mark to add the ACL.
+
+### Internode encryption
+
+Enable **Internode encryption** to encrypt data in transit between nodes for this database. See [Internode encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption" >}}) for more information.
+
+---
+Title: Recover a failed database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Recover a database after the cluster fails or the database is corrupted.
+linktitle: Recover
+weight: 35
+url: '/operate/rs/7.4/databases/recover/'
+---
+When a cluster fails or a database is corrupted, you must:
+
+1. [Restore the cluster configuration]({{< relref "/operate/rs/7.4/clusters/cluster-recovery.md" >}}) from the CCS files
+1. 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]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+The database recovery process includes:
+
+1. If the cluster failed, [recover the cluster]({{< relref "/operate/rs/7.4/clusters/cluster-recovery.md" >}}).
+1. Identify recoverable databases.
+1. Restore the database data.
+1. 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]({{< relref "/operate/rs/7.4/clusters/cluster-recovery.md" >}}) before you recover the databases.
+
+- We recommend that you allocate new persistent storage drives for the new cluster nodes.
+    If you use the original storage drives,
+    make sure to back up all files on the old persistent storage drives to another location.
+
+## Recover databases
+
+After you prepare the cluster that hosts the database,
+you can run the recovery process from the [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}})
+command-line interface (CLI).
+
+To recover the database:
+
+1. Mount the persistent storage drives with the recovery files to the new nodes.
+    These drives must contain the cluster configuration backup files and database persistence files.
+
+    {{< note >}}
+Make sure that the user `redislabs` has permissions to access the storage location
+of the configuration and persistence files on each of the nodes.
+    {{< /note >}}
+
+    If you use local persistent storage, place all of the recovery files on each of the cluster nodes.
+
+1. To see which databases are recoverable, run:
+
+    ```sh
+    rladmin recover list
+    ```
+
+    The status for each database can be either ready for recovery or missing files.
+    An indication of missing files in any of the databases can result from:
+
+    - The storage location is not found - Make sure the recovery path is set correctly on all nodes in the cluster.
+    - Files are not found in the storage location - Move the files to the storage location.
+    - No permission to read the files - Change the file permissions so that redislabs:redislabs has 640 permissions.
+    - Files are corrupted - Locate copies of the files that are not corrupted.
+
+    If you cannot resolve the issues, contact [Redis support](https://redis.com/company/support/).
+
+1. Recover the database using one of the following [`rladmin recover`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/recover" >}}) commands:
+
+    - Recover all databases from the persistence files located in the persistent storage drives:
+    
+        ```sh
+        rladmin recover all
+        ```
+
+    - Recover a single database from the persistence files located in the persistent storage drives:
+    
+        - By database ID:
+
+            ```sh
+            rladmin recover db db:<id>
+            ```
+
+        - By database name:
+        
+            ```sh
+            rladmin recover db <name>
+            ```
+
+    - Recover only the database configuration for a single database (without the data):
+    
+        ```sh
+        rladmin recover db <name> only_configuration
+        ```
+
+    {{< note >}}
+- If persistence was not configured for the database, the database is restored empty.
+- For Active-Active databases that still have live instances, we recommend that you recover the configuration for the failed instances and let the  data update from the other instances.
+- For Active-Active databases where all instances need to be recovered, we recommend you recover one instance with the data and only recover the configuration for the other instances.
+   The empty instances then update from the recovered data.
+- If the persistence files of the databases from the old cluster are not stored in the persistent storage location of the new node,
+   you must first map the recovery path of each node to the location of the old persistence files.
+   To do this, run the `node <id> recovery_path set` command in rladmin.
+   The persistence files for each database are located in the persistent storage path of the nodes from the old cluster, usually under `/var/opt/redislabs/persist/redis`.
+    {{< /note >}}  
+
+1. To verify that the recovered databases are now active, run: 
+
+    ```sh
+    rladmin status
+    ```
+
+After the databases are recovered, make sure your Redis clients can successfully connect to the databases.
+
+## Configure automatic recovery
+
+If you enable the automatic recovery cluster policy, Redis Enterprise tries to quickly recover as much data as possible from before the disaster.
+
+To enable automatic recovery, [update the cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) using the REST API:
+
+```sh
+PUT /v1/cluster/policy
+{
+  "auto_recovery": true
+}
+```
+
+Redis Enterprise tries to recover databases from the best existing persistence files. If a persistence file isn't available, which can happen if its host node is down, the automatic recovery process waits for it to become available.
+
+For each database, you can set the `recovery_wait_time` to define how many seconds the database waits for a persistence file to become available before recovery. After the wait time elapses, the recovery process continues, which can result in partial or full data loss. The default value is `-1`, which means to wait forever. Short wait times can increase the risk of potential data loss.
+
+To change `recovery_wait_time` for an existing database using the REST API:
+
+```sh
+PUT /v1/bdbs/<bdb_uid>
+{
+  "recovery_wait_time": 3600
+}
+```
+
+You can also set `recovery_wait_time` when you [create a database]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#post-bdbs-v1" >}}) using the REST API.
+---
+Title: Database replication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Replication
+weight: 40
+url: '/operate/rs/7.4/databases/durability-ha/replication/'
+---
+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.
+
+You can tune your high availability configuration with:
+
+- [Rack/Zone
+Awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}) - When rack-zone awareness is used additional logic ensures that master and replica shards never share the same rack, thus ensuring availability even under loss of an entire rack.
+- [High Availability for Replica Shards]({{< relref "/operate/rs/7.4/databases/configure/replica-ha.md" >}}) - When high availability
+for replica shards is used, the replica shard is automatically migrated on node failover to maintain high availability.
+
+{{< warning >}}
+Enabling replication has implications for the total database size,
+as explained in [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}).
+{{< /warning >}}
+
+## Auto Tiering replication considerations
+
+We recommend that you set the sequential replication feature using
+`rladmin`. This is due to the potential for relatively slow replication
+times that can occur with Auto Tiering enabled databases. In some
+cases, if sequential replication is not set up, you may run out of memory. 
+
+While it does not cause data loss on the
+primary shards, the replication to replica shards may not succeed as long
+as there is high write-rate traffic on the primary and multiple
+replications at the same time.
+
+The following `rladmin` command sets the number of primary shards eligible to
+be replicated from the same cluster node, as well as the number of replica
+shards on the same cluster node that can run the replication process at
+any given time.
+
+The recommended sequential replication configuration is two, i.e.:
+
+```sh
+rladmin tune cluster max_redis_forks 1 max_slave_full_syncs 1
+```
+
+{{< note >}}
+This means that at any given time,
+only one primary and one replica can be part of a full sync replication process.
+{{< /note >}}
+
+## Database replication backlog
+
+Redis databases that use [replication for high availability]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}) maintain a replication backlog (per shard) to synchronize the primary and replica shards of a database.
+By default, the replication backlog is set to one percent (1%) of the database size divided by the database number of shards and ranges between 1MB to 250MB per shard.
+Use the [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) and the [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) utilities to control the size of the replication backlog. You can set it to `auto` or set a specific size.  
+
+The syntax varies between regular and Active-Active databases. 
+
+For a regular Redis database:
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB | 'auto'>
+```
+
+For an Active-Active database:
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+### Active-Active replication backlog
+
+In addition to the database replication backlog, Active-Active databases maintain a backlog (per shard) to synchronize the database instances between clusters.
+By default, the Active-Active replication backlog is set to one percent (1%) of the database size divided by the database number of shards, and ranges between 1MB to 250MB per shard.
+Use the [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) utility to control the size of the CRDT replication backlog. You can set it to `auto` or set a specific size:  
+
+```text
+crdb-cli crdb update --crdb-guid <crdb_guid> --default-db-config "{\"crdt_repl_backlog_size\": <size in MB | 'auto'>}"
+```
+
+**For Redis Software versions earlier than 6.0.20:**
+The replication backlog and the CRDT replication backlog defaults are set to 1MB and cannot be set dynamically with 'auto' mode.
+To control the size of the replication log, use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) to tune the local database instance in each cluster.
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB (or if ending with bytes, KB or GB, in the respective unit)>
+```
+---
+Title: Discovery service
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Discovery service
+weight: 30
+url: '/operate/rs/7.4/databases/durability-ha/discovery-service/'
+---
+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.
+
+Discovery Service is an alternative for applications that do not want to
+depend on DNS name resolution for their connectivity. Discovery Service
+and DNS based connectivity are not mutually exclusive. They can be used
+side by side in a given cluster where some clients can use Discovery
+Service based connection while others can use DNS name resolution when
+connecting to databases.
+
+## How discovery service works
+
+The Discovery Service is available for querying on each node of the
+cluster, listening on port 8001. To employ it, your application utilizes
+a [Redis Sentinel enabled client
+library]({{< relref "/operate/rs/7.4/databases/connect/supported-clients-browsers.md" >}})
+to connect to the Discovery Service and request the endpoint for the
+given database. The Discovery Service replies with the database's
+endpoint for that database. In case of a node failure, the Discovery
+Service is updated by the cluster manager with the new endpoint and
+clients unable to connect to the database endpoint due to the failover,
+can re-query the discovery service for the new endpoint for the
+database.
+
+The Discovery Service can return either the internal or external
+endpoint for a database. If you query the discovery service for the
+endpoint of a database named "db1", the Discovery Service returns
+the external endpoint information by default. If only an internal
+endpoint exists with no external endpoint the default behavior is to
+return the internal endpoint. The "\@internal" is added to the end of
+the database name to explicitly ask for the internal endpoint. to query
+the internal endpoint explicitly with database name "db1", you can pass
+in the database name as "db1\@internal".
+
+If you'd like to examine the metadata returned from Redis Enterprise
+Software Discovery Service you can connect to port 8001 with redis-cli
+utility and execute "SENTINEL masters". Following is a sample output
+from one of the nodes of a Redis Enterprise Software cluster:
+
+```sh
+$ ./redis-cli -p 8001
+127.0.0.1:8001> SENTINEL masters
+1) 1) "name"
+2) "db1@internal"
+3) "ip"
+4) "10.0.0.45"
+5) "port"
+6) "12000"
+7) "flags"
+8) "master,disconnected"
+9) "num-other-sentinels"
+10) "0"
+2) 1) "name"
+2) "db1"
+3) "ip"
+4) "10.0.0.45"
+5) "port"
+6) "12000"
+7) "flags"
+8) "master,disconnected"
+9) "num-other-sentinels"
+10) "0"
+```
+
+It is important to note that, the Discovery Service is not a full
+implementation of the [Redis Sentinel
+protocol]({{< relref "/operate/oss_and_stack/management/sentinel" >}}). There are aspects of the
+protocol that are not applicable or would be duplication with existing
+technology in Redis Enterprise Software. The Discovery Service
+implements only the parts required to provide applications with easy
+High Availability, be compatible with the protocol, and not rely on DNS
+to derive which node in the cluster to communicate with.
+
+{{< note >}}
+To use Redis Sentinel, every database name must be unique across the cluster.
+{{< /note >}}
+
+## Redis client support
+
+We recommend these clients that are tested for use with the [Discovery Service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}) that uses the Redis Sentinel API:
+
+{{< embed-md "discovery-clients.md" >}}
+
+{{< note >}}
+Redis Sentinel API can return endpoints for both master and replica
+endpoints.
+Discovery Service only supports master endpoints and does not
+support returning replica endpoints for a database.
+{{< /note >}}
+---
+Title: Database clustering
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Clustering to allow customers to spread the load of a Redis process over
+  multiple cores and the RAM of multiple servers.
+linktitle: Clustering
+weight: 10
+url: '/operate/rs/7.4/databases/durability-ha/clustering/'
+---
+Source available [Redis](https://redislabs.com/redis-features/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.
+
+The keyspace of a Redis Enterprise cluster is partitioned into database shards.
+Each shard resides on a single node and is managed by that node.
+Each node in a Redis database cluster can manage multiple shards.
+The key space in the shards is divided into hash slots.
+The slot of a key is determined by a hash of the key name or part of the key name.
+
+Database clustering is transparent to the Redis client that connects to the database.
+The Redis client accesses the database through a single endpoint that automatically routes all operations to the relevant shards.
+You can connect an application to a single Redis process or a clustered database without any difference in the application logic.
+
+## Terminology
+
+In clustering, these terms are commonly used:
+
+- Tag or Hash Tag - A part of the key that is used in the hash calculation.
+- Slot or Hash Slot - The result of the hash calculation.
+- Shard - Redis process that is part of the Redis clustered database.
+
+## When to use clustering (sharding)
+
+Clustering is an efficient way of scaling Redis that should be used when:
+
+- The dataset is large enough to benefit from using the RAM resources of more than one node.
+    When a dataset is more than 25 GB (50 GB for RoF), we recommend that you enable clustering to create multiple shards of the database
+    and spread the data requests across nodes.
+- The operations performed against the database are CPU-intensive, resulting in performance degradation.
+    By having multiple CPU cores manage the database's shards, the load of operations is distributed among them.
+
+## Number of shards
+
+When enabling database clustering, you can set the number of database
+shards. The minimum number of shards per database is 2 and the maximum
+depends on the subscription you purchased.
+
+After you enable database clustering and set the number of shards, you cannot deactivate database clustering or reduce the number of
+shards. You can only increase the number of shards by a multiple of the
+current number of shards. For example, if the current number of shards
+is 3, you can increase the number of shards to 6, 9, or 12. 
+
+## Supported hashing policies
+
+### Standard hashing policy
+
+When using the standard hashing policy, a clustered Redis Enterprise database behaves similarly to a standard [Redis Open Source cluster]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}#hash-tags), except when using multiple hash tags in a key's name. We recommend using only a single hash tag in a key name for hashing in Redis Enterprise.
+
+- **Keys with a hash tag**: a key's hash tag is any substring between
+    `{` and `}` in the key's name. When a key's name
+    includes the pattern `{...}`, the hash tag is used as input for the
+    hashing function.
+    
+    For example, the following key names have the same
+    hash tag and map to the same hash slot: `foo{bar}`,
+    `{bar}baz`, and `foo{bar}baz`.
+
+- **Keys without a hash tag**: when a key does not contain the `{...}`
+    pattern, the entire key's name is used for hashing.
+
+You can use a hash tag to store related keys in the same hash
+slot so multi-key operations can run on these keys. If you do not use a hash tag in the key's name, the keys are distributed evenly across the keyspace's shards.
+If your application does not perform multi-key operations, you do not
+need to use hash tags.
+
+### Custom hashing policy
+
+You can configure a custom hashing policy for a clustered database. A
+custom hashing policy is required when different keys need to be kept
+together on the same shard to allow multi-key operations. The custom
+hashing policy is provided through a set of Perl Compatible Regular
+Expressions (PCRE) rules that describe the dataset's key name patterns.
+
+To configure a custom hashing policy, enter the regular expression
+(RegEx) rules that identify the substring in the key's name - hash tag
+-- on which hashing is done. The hash tag is denoted in the
+RegEx by the use of the \`tag\` named subpattern. Different keys that
+have the same hash tag are stored and managed in the same slot.
+
+After you enable the custom hashing policy, the following default RegEx
+rules are implemented. Update these rules to fit your specific logic:
+
+|  RegEx Rule | Description |
+|  ------ | ------ |
+|  .\*{(?\<tag\>.\*)}.\* | Hashing is done on the substring between the curly braces. |
+|  (?\<tag\>.\*) | The entire key's name is used for hashing. |
+
+You can modify existing rules, add new ones, delete rules, or change
+their order to suit your application's requirements.
+
+### Custom hashing policy notes and limitations
+
+1. You can define up to 32 RegEx rules, each up to 256 characters.
+2. RegEx rules are evaluated in order, and the first rule matched
+    is used. Therefore, you should place common key name patterns at the
+    beginning of the rule list.
+3. Key names that do not match any of the RegEx rules trigger an
+    error.
+4. The '.\*(?\<tag\>)' RegEx rule forces keys into a single slot
+    because the hash key is always empty. Therefore, when used,
+    this should be the last, catch-all rule.
+5. The following flag is enabled in the regular expression parser:
+    PCRE_ANCHORED: the pattern is constrained to match only at the
+    start of the string being searched.
+
+## Change the hashing policy
+
+The hashing policy of a clustered database can be changed. However,
+most hashing policy changes trigger the deletion (FLUSHDB) of the
+data before they can be applied.
+
+Examples of such changes include:
+
+- Changing the hashing policy from standard to custom or conversely,
+    custom to standard.
+- Changing the order of custom hashing policy rules.
+- Adding new rules in the custom hashing policy.
+- Deleting rules from the custom hashing policy.
+
+{{< note >}}
+The recommended workaround for updates that are not enabled,
+or require flushing the database,
+is to back up the database and import the data to a newly configured database.
+{{< /note >}}
+
+## Multi-key operations {#multikey-operations}
+
+Operations on multiple keys in a clustered database are supported with
+the following limitations:
+
+- **Multi-key commands**: Redis offers several commands that accept
+    multiple keys as arguments. In a clustered database, most multi-key
+    commands are not allowed across slots. The following multi-key
+    commands **are allowed** across slots: DEL, MSET, MGET, EXISTS, UNLINK, TOUCH
+
+    In Active-Active databases, multi-key write commands (DEL, MSET, UNLINK) can only be run on keys that are in the same slot. However, the following multi-key commands **are allowed** across slots in Active-Active databases: MGET, EXISTS, and TOUCH.
+
+    Commands that affect all keys or keys that match a specified pattern are allowed
+    in a clustered database, for example: FLUSHDB, FLUSHALL, KEYS
+
+    {{< note >}}
+When using these commands in a sharded setup,
+the command is distributed across multiple shards
+and the responses from all shards are combined into a single response.
+    {{< /note >}}
+
+- **Geo commands**: For the [GEORADIUS]({{< relref "/commands/georadius" >}}) and
+    [GEORADIUSBYMEMBER]({{< relref "/commands/georadiusbymember" >}}) commands, the
+    STORE and STOREDIST options can only be used when all affected keys
+    reside in the same slot.
+- **Transactions**: All operations within a WATCH / MULTI / EXEC block
+    should be performed on keys that are mapped to the same slot.
+- **Lua scripts**: All keys used by a Lua script must be mapped to the same
+    slot and must be provided as arguments to the EVAL / EVALSHA commands
+    (as per the Redis specification). Using keys in a Lua script that
+    were not provided as arguments might violate the sharding concept
+    but do not result in the proper violation error being returned.
+- **Renaming/Copy keys**: The use of the RENAME / RENAMENX / COPY commands is
+    allowed only when the key's original and new values are mapped to
+    the same slot.
+---
+Title: Durability and high availability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Overview of Redis Enterprise durability features such as replication,
+  clustering, and rack-zone awareness.
+hideListLinks: true
+linktitle: Durability and availability
+weight: 60
+url: '/operate/rs/7.4/databases/durability-ha/'
+---
+Redis Enterprise Software comes with several features that make your data more durable and accessible. The following features can help protect your data in cases of failures or outages and help keep your data available when you need it.
+
+## Replication
+
+When you [replicate your database]({{<relref "/operate/rs/7.4/databases/durability-ha/replication">}}), each database instance (shard) is copied one or more times. Your database will have one primary shard and one or more replica shards. When a primary shard fails, Redis Enterprise automatically promotes a replica shard to primary. 
+
+## Clustering
+
+[Clustering]({{<relref "/operate/rs/7.4/databases/durability-ha/clustering">}}) (or sharding) breaks your database into individual instances (shards) and spreads them across several nodes. Clustering lets you add resources to your cluster to scale your database and prevents node failures from causing availability loss.
+
+## Database persistence
+
+[Database persistence]({{<relref "/operate/rs/7.4/databases/configure/database-persistence">}}) gives your database durability against process or server failures by saving data to disk at set intervals.
+
+## Active-Active geo-distributed replication
+
+[Active-Active Redis Enterprise databases]({{<relref "/operate/rs/7.4/databases/active-active">}}) distribute your replicated data across multiple nodes and availability zones. This increases the durability of your database by reducing the likelihood of data or availability loss. It also reduces data access latency.
+
+## Rack-zone awareness
+
+[Rack-zone awareness]({{<relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness">}}) maps each node in your Redis Enterprise cluster to a physical rack or logical zone. The cluster uses this information to distribute primary shards and their replica shards in different racks or zones. This ensures data availability if a rack or zone fails.
+
+## Discovery service
+
+The [discovery service]({{<relref "/operate/rs/7.4/databases/durability-ha/discovery-service">}}) provides an IP-based connection management service used when connecting to Redis Enterprise Software databases. It lets your application discover which node hosts the database endpoint. The discovery service API complies with the [Redis Sentinel API]({{< relref "/operate/oss_and_stack/management/sentinel" >}}#sentinel-api).
+---
+Title: Consistency during replication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Explains the order write operations are communicated from app to proxy to shards for both non-blocking Redis write operations and blocking write operations on replication.
+linkTitle: Consistency
+weight: 20
+url: '/operate/rs/7.4/databases/durability-ha/consistency/'
+---
+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`]({{<relref "/commands/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:
+
+1. The application issues a write.
+2. The proxy communicates with the correct primary (also known as master) shard in the system that contains the given key.
+3. The shard writes the data and sends an acknowledgment to the proxy.
+4. The proxy sends the acknowledgment back to the application.
+5. The write is communicated from the primary shard to the replica.
+6. The replica acknowledges the write back to the primary shard.
+7. The write to a replica is persisted to disk.
+8. The write is acknowledged within the replica.
+
+{{< image filename="/images/rs/weak-consistency.png" >}}
+
+## Blocking write operation on replication
+
+With the [`WAIT`]({{<relref "/commands/wait">}}) or [`WAITAOF`]({{<relref "/commands/waitaof">}}) commands, applications can ask to wait for
+acknowledgments only after replication or persistence is confirmed on
+the replica. The flow of a write operation with `WAIT` or `WAITAOF` is:
+
+1. The application issues a write.
+2. The proxy communicates with the correct primary shard in the system that contains the given key.
+3. Replication communicates the update to the replica shard.
+4. If using `WAITAOF` and the AOF every write setting, the replica persists the update to disk before sending the acknowledgment.
+5. The acknowledgment is sent back from the replica all the way to the proxy with steps 5 to 8.
+
+The application only gets the acknowledgment from the write after durability is achieved with replication to the replica for `WAIT` or `WAITAOF` and to the persistent storage for `WAITAOF` only.
+
+{{< image filename="/images/rs/strong-consistency.png" >}}
+
+The `WAIT` command always returns the number of replicas that acknowledged the write commands sent by the current client before the `WAIT` command, both in the case where the specified number of replicas are reached, or when the timeout is reached. In Redis Enterprise Software, the number of replicas for HA enabled databases is always 1.
+
+See the [`WAITAOF`]({{<relref "/commands/waitaof">}}) command for details for enhanced data safety and durability capabilities introduced with Redis 7.2.
+---
+Title: Flush database data
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: To delete the data in a database without deleting the database, you can
+  use Redis CLI to flush it from the database.  You can also use Redis CLI, the admin
+  console, and the Redis Software REST API to flush data from Active-Active databases.
+linkTitle: Flush database
+weight: 40
+url: '/operate/rs/7.4/databases/import-export/flush/'
+---
+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 title="Data Loss Warning" >}}
+The flush command deletes ALL in-memory and persistence data in the database.
+We recommend that you [back up your database]({{< relref "/operate/rs/7.4/databases/import-export/schedule-backups.md" >}}) before you flush the data.
+{{< /warning >}}
+
+## 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.
+
+To flush data from a database with the redis-cli, run:
+
+```sh
+redis-cli -h <hostname> -p <portnumber> -a <password> flushall
+```
+
+Example:
+
+```sh
+redis-cli -h redis-12345.cluster.local -p 9443 -a xyz flushall
+```
+
+{{< note >}}
+Port 9443 is the default [port configuration]({{< relref "/operate/rs/7.4/networking/port-configurations#https://docs.redis.com/latest/rs/networking/port-configurations#ports-and-port-ranges-used-by-redis-enterprise-software" >}}).
+{{< /note >}}
+
+
+## Flush data from an Active-Active database
+
+When you flush an Active-Active database (formerly known as CRDB), all of the replicas flush their data at the same time.
+
+To flush data from an Active-Active database:
+
+- Cluster Manager UI
+
+    1. If you are using the new Cluster Manager UI, switch to the legacy admin console.
+
+        {{<image filename="images/rs/screenshots/switch-to-legacy-ui.png"  width="300px" alt="Select switch to legacy admin console from the dropdown.">}}
+
+    1. Go to **database** and select the Active-Active database that you want to flush.
+    1. Go to **configuration** and click **Flush** at the bottom of the page.
+    1. Enter the name of the Active-Active database to confirm that you want to flush the data.
+
+- Command line
+
+    1. To find the ID of the Active-Active database, run:
+
+        ```sh
+        crdb-cli crdb list
+        ```
+
+        For example:
+
+        ```sh
+        $ crdb-cli crdb list
+        CRDB-GUID                                NAME                 REPL-ID CLUSTER-FQDN
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                1       cluster1.local
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                2       cluster2.local
+        a16fe643-4a7b-4380-a5b2-96109d2e8bca     crdb1                3       cluster3.local
+        ```
+
+    1. To flush the Active-Active database, run:
+
+        ```sh
+        crdb-cli crdb flush --crdb-guid <CRDB-GUID>
+        ```
+
+        The command output contains the task ID of the flush task, for example:
+
+        ```sh
+        $ crdb-cli crdb flush --crdb-guid a16fe643-4a7b-4380-a5b2-96109d2e8bca
+        Task 63239280-d060-4639-9bba-fc6a242c19fc created
+        ---> Status changed: queued -> started
+        ```
+
+    1. To check the status of the flush task, run:
+
+        ```sh
+        crdb-cli task status --task-id <Task-ID>
+        ```
+
+        For example:
+
+        ```sh
+        $ crdb-cli task status --task-id 63239280-d060-4639-9bba-fc6a242c19fc
+        Task-ID: 63239280-d060-4639-9bba-fc6a242c19fc
+        CRDB-GUID: -
+        Status: finished
+        ```
+
+- REST API
+
+    1. To find the ID of the Active-Active database, use [`GET /v1/crdbs`]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdbs#get-all-crdbs" >}}):
+
+        ```sh
+        GET https://[host][:port]/v1/crdbs
+        ```
+
+    1. To flush the Active-Active database, use [`PUT /v1/crdbs/{guid}/flush`]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdbs/flush#put-crdbs-flush" >}}):
+
+        ```sh
+        PUT https://[host][:port]/v1/crdbs/<guid>/flush
+        ```
+
+        The command output contains the task ID of the flush task.
+
+    1. To check the status of the flush task, use [`GET /v1/crdb_tasks`]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdb_tasks#get-crdb_task" >}}):
+
+        ```sh
+        GET https://[host][:port]/v1/crdb_tasks/<task-id>
+        ```
+---
+Title: Migrate a database to Active-Active
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use Replica Of to migrate your database to an Active-Active database.
+linktitle: Migrate to Active-Active
+weight: $weight
+url: '/operate/rs/7.4/databases/import-export/migrate-to-active-active/'
+---
+
+If you have data in a single-region Redis Enterprise Software database that you want to migrate to an [Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active" >}}),
+you'll need to create a new Active-Active database and migrate the data into the new database as a [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}}) the existing database.
+This process will gradually populate the data in the Active-Active database.
+
+Before data migration starts, all data is flushed from the Active-Active database.
+The data is migrated to the Active-Active instance where you configured migration, and the data from that instance is copied to the other Active-Active instances.
+
+When data migration is finished, turn off migration and connect your applications to the Active-Active database.
+
+{{<image filename="images/rs/A-A_migration.png" width="75%" alt="Active-Active data migration process" >}}
+
+## Prerequisites
+
+- During the migration, any applications that connect to the Active-Active database must be **read-only** to ensure the dataset is identical to the source database during the migration process. However, you can continue to write to the source database during the migration process.
+
+- If you used the mDNS protocol for the cluster name (FQDN),
+the [client mDNS prerequisites]({{< relref "/operate/rs/7.4/networking/mdns" >}}) must be met in order to communicate with other clusters.
+
+## Migrate from a Redis Enterprise cluster
+
+You can migrate a Redis Enterprise database from the [same cluster](#migrate-from-the-same-cluster) or a [different cluster](#migrate-from-a-different-cluster).
+
+### Migrate from the same cluster
+
+To migrate a database to Active-Active in the same Redis Enterprise cluster:
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **Current cluster**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-current-cluster.png" alt="Migrate to Active-Active dialog with Current cluster tab selected.">}}
+
+1. Select the source database from the list.
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+### Migrate from a different cluster
+
+{{< note >}}
+For a source database on a different Redis Enterprise Software cluster,
+you can [compress the replication data]({{< relref "/operate/rs/7.4/databases/import-export/replica-of#data-compression-for-replica-of" >}}) to save bandwidth.
+{{< /note >}}
+
+To migrate a database to Active-Active in different Redis Enterprise clusters:
+
+1. Sign in to the Cluster Manager UI of the cluster hosting the source database.
+
+    1. In **Databases**, select the source database and then select the **Configuration** tab.
+
+    1. In the **Replica Of** section, select **Use this database as a source for another database**.
+
+    1. Copy the Replica Of source URL.
+
+        {{<image filename="images/rs/screenshots/databases/config-replica-of-copy-source-url.png" alt="Copy the Replica Of source URL from the Connection link to destination dialog.">}}
+
+        To change the internal password, select **Regenerate password**.
+
+        If you regenerate the password, replication to existing destinations fails until their credentials are updated with the new password.
+
+1. Sign in to the Cluster Manager UI of the destination database’s cluster.
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **External**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-external.png" alt="Migrate to Active-Active dialog with External tab selected.">}}
+
+1. For **Source database URL**, enter the Replica Of source URL you copied in step 1.
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+## Migrate from Redis Open Source
+
+To migrate a Redis Open Source database to Active-Active:
+
+1. Create a new Active-Active database. For prerequisites and detailed instructions, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}}).
+
+1. After the Active-Active database is active, click **Edit** on the **Configuration** screen.
+
+1. Expand the **Migrate to Active-Active** section:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-section.png" alt="Migrate to Active-Active section.">}}
+
+1. Click **+ Add source database**.
+
+1. In the **Migrate to Active-Active** dialog, select **External**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-dialog-external.png" alt="Migrate to Active-Active dialog with External tab selected.">}}
+
+1. Enter the **Source database URL**:
+
+    - If the database has a password:
+
+        ```sh
+        redis://:<password>@<host>:<port>
+        ```
+
+        Where the password is the Redis password represented with URL encoding escape characters.
+
+    - If the database does not have a password:
+
+        ```sh
+        redis://<host>:<port>
+        ```
+
+1. Click **Add source**.
+
+1. Click **Save**.
+
+## Stop sync after migration
+
+1. Wait until the migration is complete, indicated by the **Status** _Synced_. 
+
+    {{<note>}}
+Migration can take minutes to hours to complete depending on the dataset size and network quality.
+    {{</note>}}
+
+1. On the Active-Active database's **Configuration** screen, click **Edit**.
+
+1. In the **Migrate to Active-Active** section, click **Stop sync**:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-synced.png" alt="The Migrate to Active-Active section shows the Active-Active database is synced with the source database.">}}
+
+1. In the **Stop synchronization** dialog, click **Stop** to proceed.
+
+1. Redirect client connections to the Active-Active database after **Status** changes to _Sync stopped_:
+
+    {{<image filename="images/rs/screenshots/databases/migrate-to-active-active/migrate-to-active-active-sync-stopped.png" alt="The Migrate to Active-Active section shows the Active-Active database stopped syncing with the source database.">}}
+---
+Title: Schedule periodic backups
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Schedule backups of your databases to make sure you always have valid backups.
+linktitle: Schedule backups
+weight: 40
+url: '/operate/rs/7.4/databases/import-export/schedule-backups/'
+---
+
+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]({{< relref "/operate/rs/7.4/databases/import-export/export-data.md" >}}).
+
+You can schedule backups to a variety of locations, including:
+
+- FTP server
+- SFTP server
+- Local mount point
+- Amazon Simple Storage Service (S3)
+- Azure Blob Storage
+- Google Cloud Storage
+
+The backup process creates compressed (.gz) RDB files that you can [import into a database]({{< relref "/operate/rs/7.4/databases/import-export/import-data.md" >}}).
+
+When you back up a database configured for database clustering,
+Redis Enterprise Software creates a backup file for each shard in the configuration.  All backup files are copied to the storage location.
+
+{{< note >}}
+
+- Make sure that you have enough space available in your storage location.
+    If there is not enough space in the backup location, the backup fails.
+- The backup configuration only applies to the database it is configured on.
+- To limit the parallel backup for shards, set both [`tune cluster max_simultaneous_backups`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}) and [`tune node max_redis_forks`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-node" >}}). `max_simultaneous_backups` is set to 4 by default.
+
+{{< /note >}}
+
+## Schedule periodic backups
+
+Before scheduling periodic backups, verify that your storage location exists and is available to the user running Redis Enterprise Software (`redislabs` by default).  You should verify that:
+
+- Permissions are set correctly.
+- The user running Redis Enterprise Software is authorized to access the storage location.
+- The authorization credentials work.
+
+Storage location access is verified before periodic backups are scheduled.
+
+To schedule periodic backups for a database:
+
+1. Sign in to the Redis Enterprise Software Cluster Manager UI using admin credentials.
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select the **Edit** button.
+
+1. Expand the **Scheduled backup** section.
+
+1. Select **Add backup path** to open the **Path configuration** dialog.
+
+1. Select the tab that corresponds to your storage location type, enter the location details, and select **Done**. 
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+
+1. Set the backup **Interval** and **Starting time**.
+
+    | Setting | Description |
+    |--------------|-------------|
+    | **Interval** | Specifies the frequency of the backup; that is, the time between each backup snapshot.<br/><br/>Supported values include _Every 24 hours_, _Every 12 hours_, _Every 4 hours_, and _Every hour_. |
+    | **Starting time** | _v6.2.8 or later:&nbsp;_ Specifies the start time in UTC for the backup; available when **Interval** is set to _Every 24 hours_ or _Every 12 hours_.<br/><br/>If not specified, defaults to a time selected by Redis Enterprise Software. |
+
+7. Select **Save**.
+
+Access to the storage location is verified when you apply your updates.  This means the location, credentials, and other details must exist and function before you can enable periodic backups.
+
+## Default backup start time
+
+If you do _not_ specify a start time for twenty-four or twelve hour backups, Redis Enterprise Software chooses a random starting time in UTC for you.
+
+This choice assumes that your database is deployed to a multi-tenant cluster containing multiple databases.  This means that default start times are staggered (offset) to ensure availability.  This is done by calculating a random offset which specifies a number of seconds added to the start time.  
+
+Here's how it works:
+
+- Assume you're enabling the backup at 4:00 pm (1600 hours).
+- You choose to back up your database every 12 hours.
+- Because you didn't set a start time, the cluster randomly chooses an offset of 4,320 seconds (or 72 minutes).
+
+This means your first periodic backup occurs 72 minutes after the time you enabled periodic backups (4:00&nbsp;pm&nbsp;+&nbsp;72&nbsp;minutes).  Backups repeat every twelve hours at roughly same time.
+
+The backup time is imprecise because they're started by a trigger process that runs every five minutes.  When the process wakes, it compares the current time to the scheduled backup time.  If that time has passed, it triggers a backup.  
+
+If the previous backup fails, the trigger process retries the backup until it succeeds.
+
+In addition, throttling and resource limits also affect backup times.
+
+For help with specific backup issues, [contact support](https://redis.com/company/support/).
+
+
+## Supported storage locations {#supported-storage-locations}
+
+Database backups can be saved to a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When saved to a local mount point or a cloud provider, backup locations need to be available to [the group and user]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view permissions and update objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before enabling backups to an FTP server, verify that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user specified in the FTP server location has read and write privileges.
+
+To store your backups on an FTP server, set its **Backup Path** using the following syntax:
+
+`ftp://[username]:[password]@[host]:[port]/[path]/`
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the backup path, if needed.
+
+Example: `ftp://username:password@10.1.1.1/home/backups/`
+
+The user account needs permission to write files to the server.
+
+### SFTP server
+
+Before enabling backups to an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user specified in the SFTP server location has read and write privileges.
+- The SSH private keys are specified correctly.  You can use the key generated by the cluster or specify a custom key.
+
+    To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To backup to an SFTP server, enter the SFTP server location in the format:
+
+```sh
+sftp://user:password@host<:custom_port>/path/
+```
+
+For example: `sftp://username:password@10.1.1.1/home/backups/`
+
+### Local mount point
+
+Before enabling periodic backups to a local mount point, verify that:
+
+- The node can connect to the destination server, the one hosting the mount point.
+- The `redislabs:redislabs` user has read and write privileges on the local mount point
+and on the destination server.
+- The backup location has enough disk space for your backup files. Backup files
+are saved with filenames that include the timestamp, which means that earlier backups are not overwritten.
+
+To back up to a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to a shell running on Redis Enterprise Software server hosting the node.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the backup location, enter the mount point.
+
+    For example: `/mnt/Public`
+
+1. Verify that the user running Redis Enterprise Software has permissions to access and update files in the mount location.
+
+### AWS Simple Storage Service
+
+To store backups in an Amazon Web Services (AWS) Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html):
+
+1.  Sign in to the [AWS Management Console](https://console.aws.amazon.com/).
+
+1. [Create an S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) if you do not already have one.
+
+1. [Create an IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to add objects to the bucket.
+
+1. [Create an access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for that user if you do not already have one.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **AWS S3** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Access Key ID** field, enter the access key ID.
+
+    - In the **Secret Access Key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate. To connect to an S3-compatible storage location, run [`rladmin cluster config`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config">}}): 
+
+```sh
+rladmin cluster config s3_url <URL>
+```
+
+Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+### Google Cloud Storage
+
+For [Google Cloud](https://developers.google.com/console/) subscriptions, store your backups in a Google Cloud Storage bucket:
+
+1. Sign in to the Google Cloud Platform console.
+
+1. [Create a JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) if you do not already have one.
+
+1. [Create a bucket](https://cloud.google.com/storage/docs/creating-buckets#create_a_new_bucket) if you do not already have one.
+
+1. [Add a principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) to your bucket:
+
+    - In the **New principals** field, add the `client_email` from the service account key.
+
+    - Select "Storage Legacy Bucket Writer" from the **Role** list.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **Google Cloud Storage** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Client ID** field, enter the `client_id` from the service account key.
+
+    - In the **Client Email** field, enter the `client_email` from the service account key.
+
+    - In the **Private Key ID** field, enter the `private_key_id` from the service account key.
+
+    - In the **Private Key** field, enter the `private_key` from the service account key.
+      Replace `\n` with new lines.
+
+### Azure Blob Storage
+
+To store your backup in Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+To export to Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.
+
+1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.
+
+1. [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) to find the storage account name and account keys.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the backup location details:
+
+    - Select the **Azure Blob Storage** tab on the **Path configuration** dialog.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Azure Account Name** field, enter your storage account name.
+
+    - In the **Azure Account Key** field, enter the storage account key.
+
+To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).
+---
+Title: Export data from a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: You can export data to import it into a new database or to make a backup.  This
+  article shows how to do so.
+linktitle: Export data
+weight: 20
+url: '/operate/rs/7.4/databases/import-export/export-data/'
+---
+
+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.
+
+Export is a two-step process: a temporary copy of the data is saved to the local storage of the node and then copied to the storage destination.  (The temporary file is removed after the copy operation.)
+
+Export fails when there isn't enough space for either step.
+
+## Export database data
+
+To export data from a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database from the list, then select **Configuration**.
+
+1. Click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+1. Select **Export**.
+
+1.  Select the tab that corresponds to your storage location type and enter the location details.
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+
+1.  Select **Export**.
+
+## Supported storage locations {#supported-storage-locations}
+
+Data can be exported to a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When saved to a local mount point or a cloud provider, export locations need to be available to [the group and user]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view permissions and update objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before exporting data to an FTP server, verify that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user specified in the FTP server location has permission to read and write files to the server.
+
+To export data to an FTP server, set **Path** using the following syntax:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the export destination path, if needed.
+
+Example: `ftp://username:password@10.1.1.1/home/exports/`
+
+### Local mount point
+
+Before exporting data to a local mount point, verify that:
+
+- The node can connect to the server hosting the mount point.
+- The `redislabs:redislabs` user has permission to read and write files to the local mount point and to the destination server.
+- The export location has enough disk space for your exported data.
+
+To export to a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to the node's terminal.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the export location, enter the mount point.
+
+    For example: `/mnt/Public`
+
+### SFTP server
+
+Before exporting data to an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user specified in the SFTP server location has permission to read and write files to the server.
+- The SSH private keys are specified correctly.  You can use the key generated by the cluster or specify a custom key.
+
+    To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To export data to an SFTP server, enter the SFTP server location in the format:
+
+```sh
+sftp://[username]:[password]@[host]:[port]/[path]/
+```
+
+Where:
+
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the export destination path, if needed.
+
+For example: `sftp://username:password@10.1.1.1/home/exports/`
+
+### AWS Simple Storage Service
+
+To export data to an [Amazon Web Services](https://aws.amazon.com/) (AWS) Simple Storage Service (S3) bucket:
+
+1. Sign in to the [AWS console](https://console.aws.amazon.com/).
+
+1. [Create an S3 bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) if you do not already have one.
+
+1. [Create an IAM User](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to add objects to the bucket.
+
+1. [Create an access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for that user if you do not already have one.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **AWS S3**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Access key ID** field, enter the access key ID.
+
+    - In the **Secret access key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate. To connect to an S3-compatible storage location, run [`rladmin cluster config`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config">}}): 
+
+```sh
+rladmin cluster config s3_url <URL>
+```
+
+Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+### Google Cloud Storage
+
+To export to a [Google Cloud](https://developers.google.com/console/) storage bucket:
+
+1. Sign in to the Google Cloud console.
+
+1. [Create a JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) if you do not already have one.
+
+1. [Create a bucket](https://cloud.google.com/storage/docs/creating-buckets#create_a_new_bucket) if you do not already have one.
+
+1. [Add a principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) to your bucket:
+
+    - In the **New principals** field, add the `client_email` from the service account key.
+
+    - Select "Storage Legacy Bucket Writer" from the **Role** list.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **Google Cloud Storage**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Client ID** field, enter the `client_id` from the service account key.
+
+    - In the **Client Email** field, enter the `client_email` from the service account key.
+
+    - In the **Private Key ID** field, enter the `private_key_id` from the service account key.
+
+    - In the **Private key** field, enter the `private_key` from the service account key.
+      Replace `\n` with new lines.
+
+
+### Azure Blob Storage
+
+To export to Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.
+
+1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.
+
+1. [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) to find the storage account name and account keys.
+
+1. In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+    - Select **Azure Blob Storage**.
+
+    - In the **Path** field, enter the path of your bucket.
+
+    - In the **Account name** field, enter your storage account name.
+
+    - In the **Account key** field, enter the storage account key.
+
+To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).
+---
+Title: Import data into a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: 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.
+linktitle: Import data
+weight: 10
+url: '/operate/rs/7.4/databases/import-export/import-data/'
+---
+You can import, [export]({{< relref "/operate/rs/7.4/databases/import-export/export-data" >}}),
+or [backup]({{< relref "/operate/rs/7.4/databases/import-export/schedule-backups" >}})
+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.
+{{< /warning >}}
+
+## Import data into a database
+
+To import data into a database using the Cluster Manager UI:
+
+1. On the **Databases** screen, select the database from the list, then select **Configuration**.
+1. Click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+1. Select **Import**.
+1. Select the tab that corresponds to your storage location type and enter the location details.
+
+    See [Supported storage locations](#supported-storage-locations) for more information about each storage location type.
+1. Select **Import**.
+
+## Supported storage locations {#supported-storage-services}
+
+Data can be imported from a local mount point, transferred to [a URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) using FTP/SFTP, or stored on cloud provider storage.
+
+When importing from a local mount point or a cloud provider, import locations need to be available to [the group and user]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}}) running Redis Enterprise Software, `redislabs:redislabs` by default.  
+
+Redis Enterprise Software needs the ability to view objects in the storage location. Implementation details vary according to the provider and your configuration. To learn more, consult the provider's documentation.
+
+The following sections provide general guidelines.  Because provider features change frequently, use your provider's documentation for the latest info.
+
+### FTP server
+
+Before importing data from an FTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the FTP server.
+- The user that you specify in the FTP server location has permission to read files from the server.
+
+To import data from an FTP server, set **RDB file path/s** using the following syntax:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/[filename].rdb
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the file's location path.
+- *filename*: the name of the file.
+
+Example: `ftp://username:password@10.1.1.1/home/backups/<filename>.rdb`
+
+Select **Add path** to add another import file path.
+
+### Local mount point
+
+Before importing data from a local mount point, make sure that:
+
+- The node can connect to the server hosting the mount point.
+
+- The `redislabs:redislabs` user has permission to read files on the local mount point and on the destination server.
+
+- You must mount the storage in the same path on all cluster nodes. You can also use local storage, but you must copy the imported files manually to all nodes because the import source folders on the nodes are not synchronized.
+
+To import from a local mount point:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to the node's terminal.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the import location, enter the mount point.
+
+    For example: `/mnt/Public/<filename>.rdb`
+
+As of version 6.2.12, Redis Enterprise reads files directly from the mount point using a [symbolic link](https://en.wikipedia.org/wiki/Symbolic_link) (symlink) instead of copying them to a temporary directory on the node.
+
+Select **Add path** to add another import file path.
+
+### SFTP server
+
+Before importing data from an SFTP server, make sure that:
+
+- Your Redis Enterprise cluster can connect and authenticate to the SFTP server.
+- The user that you specify in the SFTP server location has permission to read files from the server.
+- The SSH private keys are specified correctly. You can use the key generated by the cluster or specify a custom key.
+    
+   To use the cluster auto generated key:
+    
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand **Cluster SSH Public Key**.
+    
+    1. Download or copy the cluster SSH public key to the appropriate location on the SFTP server.
+
+        Use the server documentation to determine the appropriate location for the SSH public key.
+
+To import data from an SFTP server, enter the SFTP server location in the format:
+
+```sh
+[protocol]://[username]:[password]@[host]:[port]/[path]/[filename].rdb
+```
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the file's location path.
+- *filename*: the name of the file.
+
+Example: `sftp://username:password@10.1.1.1/home/backups/[filename].rdb`
+
+Select **Add path** to add another import file path.
+
+### AWS Simple Storage Service {#aws-s3}
+
+Before you choose to import data from an [Amazon Web Services](https://aws.amazon.com/) (AWS) Simple Storage Service (S3) bucket, make sure you have:
+
+- The path to the file in your bucket in the format: `s3://[bucketname]/[path]/[filename].rdb`
+- [Access key ID and Secret access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) for an [IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) with permission to read files from the bucket. 
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the export location details:
+
+- Select **AWS S3**.
+
+- In the **RDB file path/s** field, enter the path of your bucket. Select **Add path** to add another import file path.
+
+- In the **Access key ID** field, enter the access key ID.
+
+- In the **Secret access key** field, enter the secret access key.
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS. The storage service must have a valid SSL certificate. To connect to an S3-compatible storage location, run [`rladmin cluster config`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config">}}): 
+
+```sh
+rladmin cluster config s3_url <URL>
+```
+
+Replace `<URL>` with the hostname or IP address of the S3-compatible storage location.
+
+### Google Cloud Storage
+
+Before you import data from a [Google Cloud](https://developers.google.com/console/) storage bucket, make sure you have:
+
+- Storage location path in the format: `/bucket_name/[path]/[filename].rdb`
+- A [JSON service account key](https://cloud.google.com/iam/docs/creating-managing-service-account-keys#creating) for your account
+- A [principal](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-add) for your bucket with the `client_email` from the service account key and a [role](https://cloud.google.com/storage/docs/access-control/iam-roles) with permissions to get files from the bucket (such as the **Storage Legacy Object Reader** role, which grants `storage.objects.get` permissions)
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the import location details:
+
+- Select **Google Cloud Storage**.
+
+- In the **RDB file path/s** field, enter the path of your file. Select **Add path** to add another import file path.
+
+- In the **Client ID** field, enter the `client_id` from the service account key.
+
+- In the **Client email** field, enter the `client_email` from the service account key.
+
+- In the **Private key id** field, enter the `private_key_id` from the service account key.
+
+- In the **Private key** field, enter the `private_key` from the service account key.
+    Replace `\n` with new lines.
+
+### Azure Blob Storage
+
+Before you choose to import from Azure Blob Storage, make sure that you have:
+
+- Storage location path in the format: `/container_name/[path/]/<filename>.rdb`
+- Account name
+- An authentication token, either an account key or an Azure [shared access signature](https://docs.microsoft.com/en-us/rest/api/storageservices/delegate-access-with-shared-access-signature) (SAS).
+
+    To find the account name and account key, see [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage).
+
+    Azure SAS support requires Redis Software version 6.0.20.  To learn more about Azure SAS, see [Grant limited access to Azure Storage resources using shared access signatures](https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview).
+
+In the Redis Enterprise Software Cluster Manager UI, when you enter the import location details:
+
+- Select **Azure Blob Storage**.
+
+- In the **RDB file path/s** field, enter the path of your file. Select **Add path** to add another import file path.
+
+- In the **Azure Account Name** field, enter your storage account name.
+
+- In the **Azure Account Key** field, enter the storage account key.
+
+## Importing into an Active-Active database
+
+When importing data into an Active-Active database, there are two options:
+
+- [Flush all data]({{< relref "/operate/rs/7.4/databases/import-export/flush#flush-data-from-an-active-active-database" >}}) from the Active-Active database, then import the data into the database.
+- Import data but merge it into the existing database.
+
+Because Active-Active databases have a numeric counter data type,
+when you merge the imported data into the existing data RS increments counters by the value that is in the imported data.
+The import through the Redis Enterprise Cluster Manager UI handles these data types for you.
+
+You can import data into an Active-Active database [from the Cluster Manager UI](#import-data-into-a-database).
+When you import data into an Active-Active database, there is a special prompt warning that the imported data will be merged into the existing database.
+---
+Title: Import and export data
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to import, export, flush, and migrate your data.
+hideListLinks: false
+linkTitle: Import and export
+weight: 30
+url: '/operate/rs/7.4/databases/import-export/'
+---
+---
+Title: Create a database with Replica Of
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create Replica Of database
+linkTitle: Create Replica Of database
+weight: 10
+url: '/operate/rs/7.4/databases/import-export/replica-of/create/'
+---
+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.
+
+Replica Of can model a variety of data relationships, including:
+
+- One-to-many relationships, where multiple replicas copy a single source database.
+- Many-to-one relationships, where a single replica collects data from multiple source databases.
+
+When you change the replica status of a database by adding, removing, or changing sources, the replica database is synchronized to the new sources.  
+
+## Configure Replica Of
+
+You can configure a database as a Replica Of, where the source database is in one of the following clusters:
+
+- [Same Redis Enterprise cluster](#same-cluster)
+
+- [Different Redis Enterprise cluster](#different-cluster)
+
+- [Redis Open Source cluster](#source-available-cluster)
+
+The order of the multiple Replica Of sources has no material impact on replication.
+
+For best results when using the [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS) protocol to resolve the fully-qualified domain name (FQDN) of the cluster, verify that your client connections meet the [client mDNS prerequisites]({{< relref "/operate/rs/7.4/networking/mdns.md" >}}).
+
+{{< note >}}
+As long as Replica Of is enabled, data in the target database will not expire and will not be evicted regardless of the set [data eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy.md" >}}).
+{{< /note >}}
+
+### Same Redis Enterprise cluster {#same-cluster}
+
+To configure a Replica Of database in the same Redis Enterprise cluster as the source database:
+
+1. [Create a new database]({{< relref "/operate/rs/7.4/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **Current cluster**.
+
+1. Select the source database from the list.
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+### Different Redis Enterprise cluster {#different-cluster}
+
+To configure a Replica Of database in a different Redis Enterprise cluster from the source database:
+
+1. Sign in to the Cluster Manager UI of the cluster hosting the source database.
+
+    1. In **Databases**, select the source database and then select the **Configuration** tab.
+
+    1. In the **Replica Of** section, select **Use this database as a source for another database**.
+
+    1. Copy the Replica Of source URL.
+
+        {{<image filename="images/rs/screenshots/databases/config-replica-of-copy-source-url.png" alt="Copy the Replica Of source URL from the Connection link to destination dialog.">}}
+
+        To change the internal password, select **Regenerate password**.
+
+        If you regenerate the password, replication to existing destinations fails until their credentials are updated with the new password.
+
+1. Sign in to the Cluster Manager UI of the destination database's cluster.
+
+1. [Create a new database]({{< relref "/operate/rs/7.4/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **External**.
+
+1. Enter the URL of the source database endpoint.
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+For source databases on different clusters, you can [compress replication data]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/#data-compression-for-replica-of" >}}) to save bandwidth.
+        
+### Redis Open Source cluster {#source-available-cluster}
+
+To use a database from a Redis Open Source cluster as a Replica Of source:
+
+1. [Create a new database]({{< relref "/operate/rs/7.4/databases/create" >}}) or select an existing database from the **Databases** screen.
+
+1. For an existing database, select **Edit** from the **Configuration** tab.
+
+1. Expand the **Replica Of** section.
+
+1. Select **+ Add source database**.
+
+1. In the **Connect a Replica Of source database** dialog, select **External**.
+
+1. Enter the URL of the source endpoint in one of the following formats:
+
+    - For databases with passwords:
+
+        ```sh
+        redis://:<password>@<host>:<port>
+        ```
+
+        Where the password is the Redis password represented with URL encoding escape characters.
+
+    - For databases without passwords:
+
+        ```sh
+        redis://<host>:<port>
+        ```
+
+1. Select **Add source**.
+
+1. Select **Save**.
+
+## Configure TLS for Replica Of
+
+When you enable TLS for Replica Of, the Replica Of synchronization traffic uses TLS certificates to authenticate the communication between the source and destination clusters.
+
+To encrypt Replica Of synchronization traffic, configure encryption for the [source database](#encrypt-source-database-traffic) and the destination [replica database](#encrypt-replica-database-traffic).
+
+### Encrypt source database traffic
+
+{{<embed-md "replica-of-tls-config.md">}}
+
+### Encrypt replica database traffic
+
+To enable TLS for Replica Of in the destination database:
+
+1. From the Cluster Manager UI of the cluster hosting the source database:
+
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand the **Server authentication (Proxy certificate)** section.
+
+        {{<image filename="images/rs/screenshots/cluster/security-proxy-cert.png" alt="Proxy certificate for server authentication.">}}
+
+     1. Download or copy the proxy certificate.
+
+1. From the **Configuration** tab of the Replica Of destination database, select **Edit**.
+
+1. Expand the **Replica Of** section.
+
+1. Point to the source database entry and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit it.
+
+1. Paste or upload the source proxy certificate, then select **Done**.
+
+1. Select **Save**.
+---
+Title: Replica Of Repeatedly Fails
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Troubleshoot when the Replica Of process repeatedly fails and restarts.
+linktitle: Troubleshoot repeat failures
+weight: 20
+url: '/operate/rs/7.4/databases/import-export/replica-of/replicaof-repeatedly-fails/'
+---
+**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:
+
+    `rladmin tune db < db:id | name > slave_buffer < value >`
+
+- If the source is a Redis database not on a Redis Enterprise Software cluster,
+    use the [config set](http://redis.io/commands/config-set) command through
+    `redis-cli` to increase the client output buffer size of the **source database** with:
+
+    `config set client-output-buffer-limit "slave <hard_limit> <soft_limit> <soft_seconds>"`
+
+**Additional information**: [Top Redis Headaches for DevOps - Replication Buffer](https://redislabs.com/blog/top-redis-headaches-for-devops-replication-buffer)
+---
+Title: Replica Of geo-distributed Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica Of provides read-only access to replicas of the dataset from different geographical locations.
+hideListLinks: true
+linkTitle: Replica Of
+weight: $weight
+url: '/operate/rs/7.4/databases/import-export/replica-of/'
+---
+In Redis Enterprise, the Replica Of feature provides active-passive geo-distribution to applications  for read-only access
+to replicas of the dataset from different geographical locations.
+The Redis Enterprise implementation of active-passive replication is called Replica Of.
+
+In Replica Of, an administrator designates a database as a replica (destination) of one or more databases (sources).
+After the initial data load from source to destination is completed,
+all write commands are synchronized from the sources to the destination.
+Replica Of lets you distribute the read load of your application across multiple databases or
+synchronize the database, either within Redis Enterprise or external to Redis Enterprise, to another database.
+
+You can [create Active-Passive]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create.md" >}}) databases on Redis Enterprise Software or Redis Cloud.
+
+[Active-Active Geo-Distribution (CRDB)]({{< relref "/operate/rs/7.4/databases/active-active" >}})
+provides these benefits and also provides write access to all of the database replicas.
+
+{{< warning >}}
+Configuring a database as a replica of the database that it replicates
+creates a cyclical replication and is not supported.
+{{< /warning >}}
+
+The Replica Of is defined in the context of the destination database
+by specifying the source databases.
+
+A destination database can have a maximum of thirty-two (32) source
+databases.
+
+If only one source is defined, then the command execution order in the
+source is kept in the destination. However, when multiple sources are
+defined, commands that are replicated from the source databases are
+executed in the order in which they reach the destination database. As a
+result, commands that were executed in a certain order when compared
+across source databases might be executed in a different order on the
+destination database.
+
+{{< note >}}
+The Replica Of feature should not be confused with the
+in-memory [Database
+replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}})
+feature, which is used for creating a master / replica configuration that
+enables ensuring database high-availability.
+{{< /note >}}
+
+## Replication process
+
+When a database is defined as a replica of another database, all its
+existing data is deleted and replaced by data that is loaded from the
+source database.
+
+Once the initial data load is completed, an ongoing synchronization
+process takes place to keep the destination always synchronized with its
+source. During the ongoing synchronization process, there is a certain
+delay between the time when a command was executed on the source and
+when it is executed on the destination. This delay is referred to as the
+**Lag**.
+
+When there is a **synchronization error**, **the process might stop** or
+it might continue running on the assumption that the error automatically
+resolves. The result depends on the error type. See more details below.
+
+In addition, **the user can manually stop the synchronization process**.
+
+When the process is in the stopped state - whether stopped by the user
+or by the system - the user can restart the process. **Restarting the
+process causes the synchronization process to flush the DB and restart
+the process from the beginning**.
+
+### Replica Of status
+
+The replication process can have the following statuses:
+
+- **Syncing** - indicates that the synchronization process has
+    started from scratch. Progress is indicated in percentages (%).
+- **Synced** - indicates that the initial synchronization process was
+    completed and the destination is synchronizing changes on an ongoing
+    basis. The **Lag** delay in synchronization with the source is
+    indicated as a time duration.
+- **Sync stopped** - indicates that the synchronization process is
+    currently not running and the user needs to restart it in order for
+    it to continue running. This status happens if the user stops the
+    process, or if certain errors arose that prevent synchronization
+    from continuing without manual intervention. See more details below.
+
+The statuses above are shown for the source database. In addition, a
+timestamp is shown on the source indicating when the last command from
+the source was executed on the destination.
+
+The system also displays the destination database status as an aggregate
+of the statuses of all the sources.
+
+{{< note >}}
+If you encounter issues with the Replica Of process, refer
+to the troubleshooting section [Replica Of repeatedly
+fails]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/replicaof-repeatedly-fails.md" >}}).
+{{< /note >}}
+
+### Synchronization errors
+
+Certain errors that occur during the synchronization process require
+user intervention for their resolution. When such errors occur, the
+synchronization process is automatically stopped.
+
+For other errors, the synchronization process continues running on the
+assumption that the error automatically resolves.
+
+Examples of errors that require user intervention for their resolution
+and that stop the synchronization process include:
+
+- Error authenticating with the source database.
+- Cross slot violation error while executing a command on a sharded
+    destination database.
+- Out-of-memory error on a source or on the destination
+    database.
+
+Example of an error that does not cause the synchronization process to
+stop:
+
+- Connection error with the source database. A connection error might
+    occur occasionally, for example as result of temporary network
+    issues that get resolved. Depending on the connection error and its
+    duration the process might be able to start syncing from the last
+    point it reached (partial sync) or require a complete
+    resynchronization from scratch across all sources (full sync).
+
+## Encryption
+
+Replica Of supports the ability to encrypt uni-directional replication
+communications between source and destination clusters utilizing TLS 1.2
+based encryption.
+
+## Data compression for Replica Of
+
+When the Replica Of is defined across different Redis Enterprise
+Software clusters, it may be beneficial to compress the data that flows
+through the network (depending on where the clusters physically reside
+and the available network).
+
+Compressing the data reduces the traffic and can help:
+
+- Resolve throughput issues
+- Reduce network traffic costs
+
+Compressing the data does have trade-offs, which is why it should not
+always be turned on by default. For example:
+
+- It uses CPU and disk resources to compress the data before sending
+    it to the network and decompress it on the other side.
+- It takes time to compress and decompress the data which can increase
+    latency.
+- Replication is disk-based and done gradually, shard by shard in the
+    case of a multi-shard database. This may have an impact on
+    replication times depending on the speed of the disks and load on
+    the database.
+- If traffic is too fast and the compression takes too much time it
+    can cause the replication process to fail and be restarted.
+
+It is advised that you test compression out in a lower environment
+before enabling it in production.
+
+In the Redis Enterprise Software management UI, when designating a
+Replica Of source from a different Redis Enterprise Software cluster,
+there is also an option to enable compression. When enabled, gzip
+compression with level -6 is utilized.
+
+## Database clustering (sharding) implications
+
+If a **source** database is sharded, that entire database is treated as
+a single source for the destination database.
+
+If the **destination** database is sharded, when the commands replicated
+from the source are executed on the destination database, the
+destination database's hashing function is executed to determine to
+which shard/s the command refers.
+
+The source and destination can have different shard counts and functions
+for placement of keys.
+
+### Synchronization in Active-Passive Replication
+
+In Active-Passive databases, one cluster hosts the source database that receives read-write operations
+and the other clusters host destination databases that receive synchronization updates from the source database.
+
+When there is a significant difference between the source and destination databases,
+the destination database flushes all of the data from its memory and starts synchronizing the data again.
+This process is called a **full sync**.
+
+For example, if the database updates for the destination databases
+that are stored by the destination database in a synchronization backlog exceed their allocated memory,
+the source database starts a full sync.
+
+{{% warning %}}
+When you failover to the destination database for write operations,
+make sure that you disable **Replica Of** before you direct clients to the destination database.
+This avoids a full sync that can overwrite your data.
+{{% /warning %}}
+
+## Active-Passive replication backlog
+
+In addition to the [database replication backlog]({{< relref "/operate/rs/7.4/databases/durability-ha/replication#database-replication-backlog" >}}), active-passive databases maintain a replication backlog (per shard) to synchronize the database instances between clusters.
+By default, the replication backlog is set to one percent (1%) of the database size divided by the database number of shards and ranges between 1MB to 250MB per shard.
+Use the [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) utility to control the size of the replication backlog. You can set it to `auto` or set a specific size.  
+
+For an Active-Passive database:
+```text
+rladmin tune db <db:id | name> repl_backlog <Backlog size in MB or 'auto'>
+```
+
+{{<note>}}
+On an Active-Passive database, the replication backlog configuration applies to both the replication backlog for shards synchronization and for synchronization of database instances between clusters.
+{{</note>}}
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+db_type: database
+description: Create a database with Redis Enterprise Software.
+linkTitle: Create a database
+title: Create a Redis Enterprise Software database
+toc: 'true'
+weight: 10
+url: '/operate/rs/7.4/databases/create/'
+---
+Redis Enterprise Software lets you create databases and distribute them across a cluster of nodes.
+
+To create a new database:
+
+1. Sign in to the Cluster Manager UI at `https://<hostname>:8443`
+
+1. Use one of the following methods to create a new database:
+
+    - [Quick database](#quick-database)
+
+    - [Create database](#create-database) with additional configuration
+
+1. If you did not specify a port number for the database, you can find the port number in the **Endpoint** field in the **Databases > Configuration > General** section.
+
+1. [Test client connectivity]({{< relref "/operate/rs/7.4/databases/connect/test-client-connectivity" >}}).
+
+
+{{< note >}}
+For databases with Active-Active replication for geo-distributed locations,
+see [Create an Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/create.md" >}}). To create and manage Active-Active databases, use the legacy UI.
+{{< /note >}}
+
+## Quick database
+
+To quickly create a database and skip additional configuration options during initial creation:
+
+1. On the **Databases** screen, select **Quick database**.
+
+1. Select a Redis version from the **Database version** list.
+
+1. Configure settings that are required for database creation but can be changed later:
+
+    - Database name
+
+    - Memory limit (GB)
+
+2. Configure optional settings that can't be changed after database creation:
+
+    - Endpoint port (set by the cluster if not set manually)
+
+    - Capabilities (previously modules) to enable
+
+1. Optionally select **Full options** to configure [additional settings]({{< relref "/operate/rs/7.4/databases/configure#config-settings" >}}).
+
+1. Select **Create**.
+
+## Create database
+
+To create a new database and configure additional settings:
+
+1. Open the **Create database** menu with one of the following methods:
+
+    - Click the **+** button next to **Databases** in the navigation menu:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-plus-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+        
+    - Go to the **Databases** screen and select **Create database**:
+
+        {{<image filename="images/rs/screenshots/databases/create-db-button-drop-down.png" width="350px" alt="Create database menu has two options: Single Region and Active-Active database.">}}
+
+1. Select the database type:
+
+    - **Single Region**
+
+    - **Active-Active database** - Multiple participating Redis Enterprise clusters can host instances of the same [Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active" >}}) in different geographic locations. Every instance can receive write operations, which are synchronized across all instances without conflict.
+
+    {{<note>}}
+For Active-Active databases, see [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}}).
+    {{</note>}}
+
+1. Select a Redis version from the **Database version** list.
+
+1. Enter a **Database name**.
+
+    - Maximum of 63 characters
+
+    - Only letters, numbers, or hyphens (-) are valid characters
+
+    - Must start and end with a letter or digit
+
+    - Case-sensitive
+
+1. To configure additional database settings, expand each relevant section to make changes.
+
+    See [Configuration settings]({{< relref "/operate/rs/7.4/databases/configure#config-settings" >}}) for more information about each setting.
+
+1. Select **Create**.
+---
+Title: Delete databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Delete a database from the Cluster Manager UI.
+linktitle: Delete
+weight: 36
+url: '/operate/rs/7.4/databases/delete/'
+---
+
+When you delete a database, both the database configuration and data are removed.
+
+To delete a database from the Cluster Manager UI:
+
+1. From the **Databases** list, select the database, then select **Configuration**.
+
+1. Select {{< image filename="/images/rs/icons/delete-icon.png#no-click" alt="Delete button" width="22px" class="inline" >}} **Delete**.
+
+1. In the **Delete database** dialog, confirm deletion.
+---
+Title: Auto Tiering quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Get started with Auto Tiering quickly, creating a cluster and database
+  using flash storage.
+linkTitle: Quick start
+weight: 80
+url: '/operate/rs/7.4/databases/auto-tiering/quickstart/'
+---
+This page guides you through a quick setup of [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}) with a single node for testing and demo purposes. 
+
+For production environments, you can find more detailed installation instructions in the [install and setup]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) section.
+
+The steps to set up a Redis Enterprise Software cluster using Auto Tiering
+with a single node are:
+
+1. Install Redis Enterprise Software or run it in a Docker
+    container.
+1. Set up a Redis Enterprise Software cluster with Auto Tiering.
+1. Create a new database with Auto Tiering enabled.
+1. Connect to your new database.
+
+## Install Redis Enterprise Software
+
+### Bare metal, VM, Cloud instance
+
+To install on bare metal, a virtual machine, or an instance:
+
+1. Download the binaries from the [Redis Enterprise download center](https://cloud.redis.io/#/sign-up/software?direct=true).
+
+1. Upload the binaries to a Linux-based operating system.
+
+1. Extract the image:
+
+    ```sh
+    tar -vxf <downloaded tar file name>
+    ```
+
+1. After the `tar` command completes, you can find a new `install.sh` script in the current directory:
+
+    ```sh
+    sudo ./install.sh -y
+    ```
+
+### Docker-based installation {#dockerbased-installation}
+
+For testing purposes, you can run a Redis Enterprise Software
+Docker container on Windows, MacOS, and Linux.
+
+```sh
+docker run -d --cap-add sys_resource --name rp -p 8443:8443 -p 12000:12000 redislabs/redis:latest
+```
+
+## Prepare and format flash memory
+
+After you [install Redis Enterprise Software](#install-redis-enterprise-software), use the `prepare_flash` script to prepare and format flash memory:
+
+```sh
+sudo /opt/redislabs/sbin/prepare_flash.sh
+```
+
+This script finds unformatted disks and mounts them as RAID partitions in `/var/opt/redislabs/flash`.
+
+To verify the disk configuration, run:
+
+```sh
+sudo lsblk
+```
+
+## Set up a cluster and enable Auto Tiering
+
+1. Direct your browser to `https://localhost:8443` on the host machine to
+see the Redis Enterprise Software Cluster Manager UI.
+
+    {{<note>}}
+Depending on your browser, you may see a certificate error.
+Choose "continue to the website" to go to the setup screen.
+    {{</note>}}
+
+1. Select **Create new cluster**.
+
+1. Set up account credentials for a cluster administrator, then select **Next** to proceed to cluster setup.
+
+1. Enter your cluster license key if you have one. Otherwise, the cluster uses the trial version.
+
+1. Provide a cluster FQDN such as `mycluster.local`, then select **Next**.
+
+1. In the **Storage configuration** section, turn on the **Enable flash storage** toggle.
+
+1. Select **Create cluster**.
+
+1. Select **OK** to confirm that you are aware of the replacement of the HTTPS TLS
+certificate on the node, and proceed through the browser warning.
+
+## Create a database
+
+On the **Databases** screen:
+
+1. Select **Quick database**.
+
+1. Verify **Flash** is selected for **Runs on**.
+
+    {{<image filename="images/rs/screenshots/databases/quick-db-flash.png" alt="Create a quick database with Runs on Flash selected." >}}
+
+1. Enter `12000` for the endpoint **Port** number.
+
+1. _(Optional)_ Select **Full options** to see available alerts.
+
+1. Select **Create**.
+
+You now have a  database with Auto Tiering enabled!
+
+## Connect to your database
+
+You are ready to connect to your database to store data. See the [test connectivity]({{< relref "/operate/rs/7.4/databases/connect/test-client-connectivity.md" >}}) page to learn how to connect to your database.
+
+## Next steps
+
+If you want to generate load against the
+database or add a bunch of data for cluster testing, see the [memtier_benchmark quick start]({{< relref "/operate/rs/7.4/clusters/optimize/memtier-benchmark.md" >}}) for help.
+
+To see the true performance and scale of Auto Tiering, you must tune your I/O path and set the flash path to the mounted path of SSD or NVMe flash memory as that is what it is designed to run on. For more information, see [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}).
+---
+Title: Manage Auto Tiering storage engine
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage the storage engine used for your database with auto tiering enabled.
+linkTitle: Manage storage engine
+weight: 100
+url: '/operate/rs/7.4/databases/auto-tiering/storage-engine/'
+---
+
+## Manage the storage engine
+
+Redis Enterprise Auto Tiering supports two storage engines:
+
+* [Speedb](https://www.speedb.io/) (default, recommended)
+* [RocksDB](https://rocksdb.org/)
+
+{{<warning>}}Switching between storage engines requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+### Change the storage engine
+
+1. Change the cluster level configuration for default storage engine.
+
+  * API:
+
+      ``` sh
+      curl -k -u <username>:<password> -X PUT -H "Content-Type: application/json" -d '{"bigstore_driver":"speedb"}' https://localhost:9443/v1/cluster
+     ```
+
+  * CLI:
+
+      ```sh
+      rladmin cluster config bigstore_driver {speedb | rocksdb}
+      ```
+
+2. Restart the each database on the cluster one by one.
+
+     ```sh
+     rladmin restart db { db:<id> | <name> }
+     ```
+
+{{<note>}} We recommend restarting your database at times with low usage and avoiding peak hours. For databases without persistence enabled, we also recommend using export to backup your database first.{{</note>}}
+
+## Monitor the storage engine
+
+To get the current cluster level default storage engine run:
+
+* Use the `rladmin info cluster` command look for ‘bigstore_driver’.
+
+* Use the REST API:
+
+     ```sh
+     curl -k -u <username>:<password> -X GET -H "Content-Type: application/json" https://localhost:9443/v1/cluster
+     ```
+
+Versions of Redis Enterprise 7.2 and later provide a metric called `bdb_bigstore_shard_count` to help track the shard count per database, filtered by `bdb_id` and by storage engine as shown below:
+
+
+  ```sh
+  bdb_bigstore_shard_count{bdb="1",cluster="mycluster.local",driver="rocksdb"} 1.0
+  bdb_bigstore_shard_count{bdb="1",cluster="mycluster.local",driver="speedb"} 2.0
+  ```
+
+For more about metrics for Redis Enterprise’s integration with Prometheus, see [Prometheus integration]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}}).
+---
+Title: Auto Tiering
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Auto Tiering enables your data to span both RAM and dedicated flash memory.
+hideListLinks: true
+linktitle: Auto Tiering
+weight: 50
+url: '/operate/rs/7.4/databases/auto-tiering/'
+---
+Redis Enterprise's auto tiering offers users the unique ability to use solid state drives (SSDs) to extend databases beyond DRAM capacity.
+Developers can build applications that require large datasets using the same Redis API.
+Using SSDs can significantly reduce the infrastructure costs compared to only DRAM deployments. 
+
+Frequently used data, called hot data, belongs in the fastest memory level to deliver a real-time user experience.
+Data that is accessed less frequently, called warm data, can be kept in a slightly slower memory tier.
+Redis Enterprise’s Auto tiering maintains hot data in DRAM, keeps warm data in SSDs, and transfers data between tiers automatically.
+
+Redis Enterprise’s auto tiering is based on a high-performance storage engine (Speedb) that manages the complexity of using SSDs and DRAM as the total available memory for databases in a Redis Enterprise cluster. This implementation offers a performance boost of up to 10k operations per second per core of the database, doubling the performance of Redis on Flash.
+
+Just like all-RAM databases, databases with Auto Tiering enabled are compatible with existing Redis applications.
+
+Auto Tiering is also supported on [Redis Cloud]({{< relref "/operate/rc/" >}}) and [Redis Enterprise Software for Kubernetes]({{< relref "/operate/rs/" >}}).
+
+## Use cases
+
+The benefits associated with Auto Tiering are dependent on the use case.
+
+Auto Tiering is ideal when your:
+
+- working set is significantly smaller than your dataset (high RAM hit rate)
+- average key size is smaller than average value size (all key names are stored in RAM)
+- most recent data is the most frequently used (high RAM hit rate)
+
+Auto Tiering is not recommended for:
+
+- Long key names (all key names are stored in RAM)
+- Broad access patterns (any value could be pulled into RAM)
+- Large working sets (working set is stored in RAM)
+- Frequently moved data (moving to and from RAM too often can impact performance)
+
+Auto Tiering is not intended to be used for persistent storage. Redis Enterprise Software database persistent and ephemeral storage should be on different disks, either local or attached.
+
+## Where is my data?
+
+When using Auto Tiering, RAM storage holds:
+- All keys (names)
+- Key indexes
+- Dictionaries
+- Hot data (working set)
+
+All data is accessed through RAM. If a value in flash memory is accessed, it becomes part of the working set and is moved to RAM. These values are referred to as “hot data”.
+
+Inactive or infrequently accessed data is referred to as “warm data” and stored in flash memory. When more space is needed in RAM, warm data is moved from RAM to flash storage.
+
+{{<note>}} When using Auto Tiering with RediSearch, it’s important to note that RediSearch indexes are also stored in RAM.{{</note>}}
+
+## RAM to Flash ratio
+
+Redis Enterprise Software allows you to configure and tune the ratio of RAM-to-Flash for each database independently, optimizing performance for your specific use case.
+While this is an online operation requiring no downtime for your database, it is recommended to perform it during maintenance windows as data might move between tiers (RAM <-> Flash).
+
+The RAM limit cannot be smaller than 10% of the total memory. We recommend you keep at least 20% of all values in RAM. Do not set the RAM limit to 100%.
+
+## Flash memory
+
+Implementing Auto Tiering requires pre planning around memory and sizing. Considerations and requirements for Auto Tiering include:
+
+- Flash memory must be locally attached (as opposed to network attached storage (NAS) and storage area networks (SAN)).
+- Flash memory must be dedicated to Auto Tiering and not shared with other parts of the database, such as durability, binaries, or persistence.
+- For the best performance, the SSDs should be NVMe based, but SATA can also be used.
+- The available flash space must be greater than or equal to the total database size (RAM+Flash). The extra space accounts for write buffers and [write amplification](https://en.wikipedia.org/wiki/Write_amplification).
+
+{{<note>}} The Redis Enterprise Software database persistent and ephemeral storage should be on different disks, either local or attached. {{</note>}}
+
+Once these requirements are met, you can create and manage both databases with Auto Tiering enabled and
+all-RAM databases in the same cluster.
+
+When you begin planning the deployment of an Auto Tiering enabled database in production,
+we recommend working closely with the Redis technical team for sizing and performance tuning.
+
+### Cloud environments
+
+When running in a cloud environment:
+
+- Flash memory is on the ephemeral SSDs of the cloud instance (for example the local NVMe of AWS i4i instnaces and Azure Lsv2 and Lsv3 series).
+- Persistent database storage needs to be network attached (for example, AWS EBS for AWS).
+
+{{<note>}}
+We specifically recommend "[Storage Optimized I4i - High I/O Instances](https://aws.amazon.com/ec2/instance-types/#storage-optimized)" because of the performance of NVMe for flash memory. {{</note>}}
+
+### On-premises environments
+
+When you begin planning the deployment of Auto Tiering in production, we recommend working closely with the Redis technical team for sizing and performance tuning.
+
+On-premises environments support more deployment options than other environments such as:
+
+- Using Redis Stack features:
+  - [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) 
+  - [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+  - [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}})
+  - [Probabilistic data structures]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+
+{{<note>}} Enabling Auto Tiering for Active-Active distributed databases requires validating and getting the Redis technical team's approval first . {{</note>}}
+
+{{<warning>}} Auto Tiering is not supported running on network attached storage (NAS), storage area network (SAN), or with local HDD drives. {{</warning>}}
+
+## Next steps
+
+- [Auto Tiering metrics]({{< relref "/operate/rs/7.4/references/metrics/auto-tiering" >}})
+- [Auto Tiering quick start]({{< relref "/operate/rs/7.4/databases/auto-tiering/quickstart.md" >}})
+
+- [Ephemeral and persistent storage]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}})
+- [Hardware requirements]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})
+---
+Title: Troubleshooting pocket guide for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Troubleshoot issues with Redis Enterprise Software, including connectivity
+  issues between the database and clients or applications.
+linktitle: Troubleshoot
+toc: 'true'
+weight: 90
+url: '/operate/rs/7.4/databases/connect/troubleshooting-guide/'
+---
+
+If your client or application cannot connect to your database, verify the following.
+
+## Identify Redis host issues
+
+#### Check resource usage
+
+- Used disk space should be less than `90%`. To check the host machine's disk usage, run the [`df`](https://man7.org/linux/man-pages/man1/df.1.html) command:
+
+    ```sh
+    $ df -h
+    Filesystem      Size  Used Avail Use% Mounted on
+    overlay          59G   23G   33G  41% /
+    /dev/vda1        59G   23G   33G  41% /etc/hosts
+    ```
+
+- RAM and CPU utilization should be less than `80%`, and host resources must be available exclusively for Redis Enterprise Software. You should also make sure that swap memory is not being used or is not configured.
+
+    1. Run the [`free`](https://man7.org/linux/man-pages/man1/free.1.html) command to check memory usage:
+
+        ```sh
+        $ free
+                  total        used        free      shared  buff/cache   available
+        Mem:        6087028     1954664      993756      409196     3138608     3440856
+        Swap:       1048572           0     1048572
+        ```
+
+    1. Used CPU should be less than `80%`. To check CPU usage, use `top` or `vmstat`.
+
+        Run [`top`](https://man7.org/linux/man-pages/man1/top.1.html):
+
+        ```sh
+        $ top
+        Tasks:  54 total,   1 running,  53 sleeping,   0 stopped,   0 zombie
+       %Cpu(s):  1.7 us,  1.4 sy,  0.0 ni, 96.8 id,  0.0 wa,  0.0 hi,  0.1 si,  0.0 st
+       KiB Mem :  6087028 total,   988672 free,  1958060 used,  3140296 buff/cache
+       KiB Swap:  1048572 total,  1048572 free,        0 used.  3437460 avail Mem 
+       ```
+
+        Run [`vmstat`](https://man7.org/linux/man-pages/man8/vmstat.8.html):
+
+        ```sh
+        $ vmstat
+        procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
+        r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
+        2  0      0 988868 177588 2962876    0    0     0     6    7   12  1  1 99  0  0
+       ```
+
+    1. If CPU or RAM usage is greater than 80%, ask your system administrator which process is the culprit. If the process is not related to Redis, terminate it.
+
+#### Sync clock with time server
+
+It is recommended to sync the host clock with a time server.
+
+Verify that time is synchronized with the time server using one of the following commands:
+
+- `ntpq -p`
+
+- `chronyc sources`
+
+- [`timedatectl`](https://man7.org/linux/man-pages/man1/timedatectl.1.html)
+
+#### Remove https_proxy and http_proxy variables
+
+1. Run [`printenv`](https://man7.org/linux/man-pages/man1/printenv.1.html) and check if `https_proxy` and `http_proxy` are configured as environment variables:
+
+    ```sh
+    printenv | grep -i proxy
+    ```
+
+1. If `https_proxy` or `http_proxy` exist, remove them:
+
+    ```sh
+    unset https_proxy
+    ```
+    ```sh
+    unset http_proxy
+    ```
+
+#### Review system logs
+
+Review system logs including the syslog or journal for any error messages, warnings, or critical events. See [Logging]({{< relref "/operate/rs/7.4/clusters/logging" >}}) for more information.
+
+## Identify issues caused by security hardening
+
+- Temporarily deactivate any security hardening tools (such as selinux, cylance, McAfee, or dynatrace), and check if the problem is resolved. 
+
+- The user `redislabs` must have read and write access to `/tmp` directory. Run the following commands to verify.
+
+    1. Create a test file in `/tmp` as the `redislabs` user:
+        ```sh
+        $ su - redislabs -s /bin/bash -c 'touch /tmp/test'
+        ```
+
+    1. Verify the file was created successfully:
+        ```sh
+        $ ls -l /tmp/test
+        -rw-rw-r-- 1 redislabs redislabs 0 Aug 12 02:06 /tmp/test
+        ```
+
+- Using a non-permissive file mode creation mask (`umask`) can cause issues.
+
+    1. Check the output of `umask`:
+
+        ```sh
+        $ umask
+        0022
+        ```
+
+    1. If `umask`'s output differs from the default value `0022`, it might prevent normal operation. Consult your system administrator and revert to the default `umask` setting.
+
+## Identify cluster issues
+
+- Use `supervisorctl status` to verify all processes are in a `RUNNING` state:
+
+    ```sh
+    supervisorctl status
+    ```
+
+- Run `rlcheck` and verify no errors appear:
+
+    ```sh
+    rlcheck
+    ```
+
+- Run [`rladmin status issues_only`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) and verify that no issues appear:
+
+    ```sh
+    $ rladmin status issues_only
+    CLUSTER NODES:
+    NODE:ID ROLE ADDRESS EXTERNAL_ADDRESS HOSTNAME SHARDS CORES FREE_RAM PROVISIONAL_RAM VERSION STATUS
+
+    DATABASES:
+    DB:ID  NAME        TYPE  STATUS  SHARDS  PLACEMENT   REPLICATION    PERSISTENCE    ENDPOINT  
+
+    ENDPOINTS:
+    DB:ID               NAME             ID          NODE             ROLE             SSL       
+
+    SHARDS:
+    DB:ID      NAME     ID        NODE     ROLE     SLOTS      USED_MEMORY            STATUS     
+
+    ```
+
+- Run [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}). For each shard, `USED_MEMORY` should be less than 25 GB.
+
+    ```sh
+    $ rladmin status shards
+    SHARDS:
+    DB:ID    NAME         ID          NODE      ROLE      SLOTS       USED_MEMORY       STATUS   
+    db:1     db1          redis:1     node:1    master    0-16383     2.13MB            OK  
+    ```
+
+- Run [`rladmin cluster running_actions`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/running_actions" >}}) and confirm that no tasks are currently running (active):
+
+    ```sh
+    $ rladmin cluster running_actions
+    No active tasks
+    ```
+
+## Troubleshoot connectivity
+
+#### Database endpoint resolution
+
+1. On the client machine, check if the database endpoint can be resolved:
+
+    ```sh
+    dig <endpoint>
+    ```
+
+1. If endpoint resolution fails on the client machine, check on one of the cluster nodes:
+
+    ```sh
+    dig @localhost <endpoint>
+    ```
+
+1. If endpoint resolution succeeds on the cluster node but fails on the client machine, review the DNS configuration and fix any errors.
+
+1. If the endpoint can’t be resolved on the cluster node, [contact support](https://redis.com/company/support/).
+
+#### Client application issues
+
+1. To identify possible client application issues, test connectivity from the client machine to the database using [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}):
+
+    [`INFO`]({{< relref "/commands/info" >}}):
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> INFO
+    ```
+
+    [`PING`]({{< relref "/commands/ping" >}}):
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> PING
+    ```
+   
+    or if TLS is enabled:
+    
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --tls --insecure --cert --key PING
+    ```
+
+1. If the client machine cannot connect, try to connect to the database from one of the cluster nodes:
+
+    ```sh
+    redis-cli -h <node IP or hostname> -p <port> -a <password> PING
+    ```
+
+1. If the cluster node is also unable to connect to the database, [contact Redis support](https://redis.com/company/support/).
+
+1. If the client fails to connect, but the cluster node succeeds, perform health checks on the client and network.
+
+#### Firewall access
+
+1. Run one of the following commands to verify that database access is not blocked by a firewall on the client machine or cluster:
+
+    ```sh
+    iptables -L
+    ```
+
+    ```sh
+    ufw status
+    ```
+
+    ```sh
+    firewall-cmd –list-all
+    ```
+
+1. To resolve firewall issues:
+
+    1. If a firewall is configured for your database, add the client IP address to the firewall rules.
+
+    1. Configure third-party firewalls and external proxies to allow the cluster FQDN, database endpoint IP address, and database ports.
+
+## Troubleshoot latency
+
+#### Server-side latency
+
+- Make sure the database's used memory does not reach the configured database max memory limit. For more details, see [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit" >}}).
+
+- Try to correlate the time of the latency with any surge in the following metrics:
+
+    - Number of connections
+
+    - Used memory
+
+    - Evicted keys
+
+    - Expired keys 
+
+- Run [`SLOWLOG GET`]({{< relref "/commands/slowlog-get" >}}) using [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}) to identify slow commands such as [`KEYS`]({{< relref "/commands/keys" >}}) or [`HGETALL`]({{< relref "/commands/hgetall" >}}:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> SLOWLOG GET <number of entries>
+    ```
+
+    Consider using alternative commands such as [`SCAN`]({{< relref "/commands/scan" >}}), [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}})
+
+- Keys with large memory footprints can cause latency. To identify such keys, compare the keys returned by [`SLOWLOG GET`]({{< relref "/commands/slowlog-get" >}}) with the output of the following commands:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --memkeys
+    ```
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> -a <password> --bigkeys
+    ```
+
+- For additional diagnostics, see:
+
+    - [Diagnosing latency issues]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}})
+
+    - [View Redis slow log]({{< relref "/operate/rs/7.4/clusters/logging/redis-slow-log" >}})
+
+#### Client-side latency
+
+Verify the following:
+
+- There is no memory or CPU pressure on the client host.
+
+- The client uses a connection pool instead of frequently opening and closing connections.
+
+- The client does not erroneously open multiple connections that can pressure the client or server.
+---
+Title: Test client connection
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Test connection
+weight: 20
+url: '/operate/rs/7.4/databases/connect/test-client-connectivity/'
+---
+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:
+
+1. After you [create a Redis database]({{< relref "/operate/rs/7.4/databases/create" >}}), 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:
+
+    {{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+
+1. Try to connect to the database endpoint from your client of choice,
+    and run database commands.
+
+1. If the database does not respond, try to connect to the database
+    endpoint using the IP address rather than the FQDN. If you
+    succeed, then DNS is not properly configured. For
+    additional details, see
+    [Configure cluster DNS]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}).
+
+If any issues occur when testing database connections, [contact
+support](https://redis.com/company/support/).
+
+## Test database connections
+
+After you create a Redis database, you can connect to your
+database and store data using one of the following methods:
+
+- [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}), the built-in command-line tool
+
+- [Redis Insight](https://redis.com/redis-enterprise/redis-insight/), a free Redis GUI that is available for macOS, Windows, and Linux 
+
+- An application using a Redis client library, such as [`redis-py`](https://github.com/redis/redis-py) for Python. See the [client list]({{< relref "/develop/clients/" >}}) to view all Redis clients by language.
+
+### Connect with redis-cli
+
+Connect to your database with `redis-cli` (located in the `/opt/redislabs/bin` directory), then store and retrieve a key:
+
+```sh
+$ redis-cli -h <endpoint> -p <port>
+127.0.0.1:16653> set key1 123
+OK
+127.0.0.1:16653> get key1
+"123"
+```
+
+For more `redis-cli` connection examples, see the [`redis-cli` reference]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}).
+
+### Connect with Redis Insight
+
+Redis Insight is a free Redis GUI that is available for macOS, Windows, and Linux.
+
+1. [Install Redis Insight]({{< relref "/develop/tools/insight/" >}}).
+
+1. Open Redis Insight and select **Add Redis Database**.
+
+1. Enter the host and port in the **Host** and **Port** fields.
+
+1. Select **Use TLS** if [TLS]({{< relref "/operate/rs/7.4/security/encryption/tls" >}}) is set up.
+
+1. Select **Add Redis Database** to connect to the database.
+
+See the [Redis Insight documentation]({{< relref "/develop/tools/insight/" >}}) for more information.
+
+### Connect with Python
+
+Python applications can connect
+to the database using the `redis-py` client library. For installation instructions, see the
+[`redis-py` README](https://github.com/redis/redis-py#readme) on GitHub.
+
+1. From the command line, create a new file called
+`redis_test.py`:
+
+    ```sh
+    vi redis_test.py
+    ```
+
+1. Paste the following code in `redis_test.py`, and replace `<host>` and `<port>` with your database's endpoint details:
+
+    ```python
+    import redis
+
+    # Connect to the database
+    r = redis.Redis(host='<host>', port=<port>)
+
+    # Store a key
+    print("set key1 123")
+    print(r.set('key1', '123'))
+
+    # Retrieve the key
+    print("get key1")
+    print(r.get('key1'))
+    ```
+
+1. Run the application:
+
+    ```sh
+    python redis_test.py
+    ```
+
+1. If the application successfully connects to your database, it outputs: 
+
+    ```sh
+    set key1 123
+    True
+    get key1
+    123
+    ```
+### Connect with discovery service
+
+You can also connect a Python application to the database using the discovery service, which complies with the Redis Sentinel API.
+
+In the IP-based connection method, you only need the database name, not the port number.
+The following example uses the discovery service that listens on port 8001 on all nodes of the cluster
+to discover the endpoint for the database named "db1".
+
+```python
+from redis.sentinel import Sentinel
+
+# with IP based connections, a list of known node IP addresses is constructed
+# to allow connection even if any one of the nodes in the list is unavailable.
+sentinel_list = [
+('10.0.0.44', 8001),
+('10.0.0.45', 8001),
+('10.0.0.46', 8001)
+]
+
+# change this to the db name you want to connect
+db_name = 'db1'
+
+sentinel = Sentinel(sentinel_list, socket_timeout=0.1)
+r = sentinel.master_for(db_name, socket_timeout=0.1)
+
+# set key "foo" to value "bar"
+print(r.set('foo', 'bar'))
+# set value for key "foo"
+print(r.get('foo'))
+```
+
+For more `redis-py` connection examples, see the [`redis-py` developer documentation](https://redis-py.readthedocs.io/en/stable/examples/connection_examples.html).
+---
+Title: Supported connection clients
+categories:
+- docs
+- operate
+- rs
+description: Info about Redis client libraries and supported clients when using the
+  discovery service.
+weight: 10
+url: '/operate/rs/7.4/databases/connect/supported-clients-browsers/'
+---
+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]({{< relref "/develop/clients/" >}}) appropriate for your programming language.
+
+You can also use the `redis-cli` utility to connect to a database from the command line.
+
+For examples of each approach, see the [Redis Enterprise Software quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}).
+
+Note: You cannot use client libraries to configure Redis Enterprise Software.  Instead, use:
+
+- The Redis Enterprise Software [Cluster Manager UI]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- The [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}})
+- Command-line utilities, such as [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}})
+
+### Discovery service
+
+We recommend the following clients when using a [discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}) based on the Redis Sentinel API:
+
+- [redis-py]({{< relref "/develop/clients/redis-py" >}}) (Python client)
+- [NRedisStack]({{< relref "/develop/clients/dotnet" >}}) (.NET client)
+- [Jedis]({{< relref "/develop/clients/jedis" >}}) (synchronous Java client)
+- [Lettuce]({{< relref "/develop/clients/lettuce" >}}) (asynchronous Java client)
+- [go-redis]({{< relref "/develop/clients/go" >}}) (Go client)
+- [Hiredis](https://github.com/redis/hiredis) (C client)
+
+If you need to use another client, you can use [Sentinel Tunnel](https://github.com/RedisLabs/sentinel_tunnel)
+to discover the current Redis master with Sentinel and create a TCP tunnel between a local port on the client and the master.
+
+---
+Title: Connect to a database
+categories:
+- docs
+- operate
+- rs
+description: Learn how to connect your application to a Redis database hosted by Redis
+  Enterprise Software and test your connection.
+hideListLinks: true
+linkTitle: Connect
+weight: 20
+url: '/operate/rs/7.4/databases/connect/'
+---
+
+After you [set up a cluster]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup" >}}) and [create a Redis database]({{< relref "/operate/rs/7.4/databases/create" >}}), you can connect to your database.
+
+To connect to your database, you need the database endpoint, which includes the cluster name (FQDN) and the database port. To view and copy public and private endpoints for a database in the cluster, see the database’s **Configuration > General** section in the Cluster Manager UI.
+
+{{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+
+If you try to connect with the FQDN, and the database does not respond, try connecting with the IP address. If this succeeds, DNS is not properly configured. To set up DNS, see [Configure cluster DNS]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}).
+
+If you want to secure your connection, set up [TLS]({{< relref "/operate/rs/7.4/security/encryption/tls/" >}}).
+
+## Connect to a database
+
+Use one of the following connection methods to connect to your database:
+
+- [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli/" >}}) utility
+
+- [Redis Insight](https://redis.com/redis-enterprise/redis-insight/)
+
+- [Redis client]({{< relref "/develop/clients/" >}}) for your preferred programming language
+
+For examples, see [Test client connection]({{< relref "/operate/rs/7.4/databases/connect/test-client-connectivity" >}}).
+---
+Title: Eviction policy
+alwaysOpen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: The eviction policy determines what happens when a database reaches its
+  memory limit.
+linkTitle: Eviction policy
+weight: 10
+url: '/operate/rs/7.4/databases/memory-performance/eviction-policy/'
+---
+
+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&nbsp;Policy** | **Description** |
+|------------|-----------------|
+|  noeviction | New values aren't saved when memory limit is reached<br/><br/>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.
+
+The default policy for [Active-Active databases]({{< relref "/operate/rs/7.4/databases/active-active" >}}) is _noeviction_ policy.
+
+## Active-Active database eviction
+
+The eviction policy mechanism for Active-Active databases kicks in earlier than for standalone databases because it requires propagation to all participating clusters. 
+The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit. If memory usage continues to rise while the keys are being evicted, the rate of eviction will increase to prevent reaching the Out-of-Memory state.
+As with standalone Redis Enterprise databases, Active-Active eviction is calculated per shard.
+To prevent over eviction, internal heuristics might prevent keys from being evicted when the shard reaches the 80% memory limit.  In such cases, keys will get evicted only when shard memory reaches 100%.
+
+In case of network issues between Active-Active instances, memory can be freed only when all instances are in sync. If there is no communication between participating clusters, it can result in eviction of all keys and the instance reaching an Out-of-Memory state.
+
+{{< note >}}
+Data eviction policies are not supported for Active-Active databases with Auto Tiering .
+{{< /note >}}
+
+## Avoid data eviction
+
+To avoid data eviction, make sure your database is large enough to hold required values.  
+
+For larger databases, consider using [Auto Tiering ]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}).
+
+Auto Tiering stores actively-used data (also known as _hot data_) in RAM and the remaining data in flash memory (SSD).
+This lets you retain more data while ensuring the fastest access to the most critical data.
+---
+Title: Database memory limits
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: When you set a database's memory limit, you define the maximum size the
+  database can reach.
+linkTitle: Memory limits
+weight: 20
+url: '/operate/rs/7.4/databases/memory-performance/memory-limit/'
+---
+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:
+
+- **dataset size**: you want your limit to be above your dataset size to leave room for overhead.
+- **database throughput**: high throughput needs more shards, leading to a higher memory limit.
+- [**modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}): using modules with your database consumes more memory.
+- [**database clustering**]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering.md" >}}): enables you to spread your data into shards across multiple nodes.
+- [**database replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}): enabling replication doubles memory consumption.
+
+Additional factors for Active-Active databases:
+
+- [**Active-Active replication**]({{< relref "/operate/rs/7.4/databases/active-active/_index.md" >}}): enabling Active-Active replication requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**database replication backlog**]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog/" >}}) for synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/7.4/databases/active-active/manage.md" >}}) for synchronization between clusters. By default, this is set to 1% of the database size.
+
+  It's also important to know Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit.
+
+Additional factors for  databases with Auto Tiering enabled:
+
+- The available flash space must be greater than or equal to the total database size (RAM+Flash). The extra space accounts for write buffers and [write amplification](https://en.wikipedia.org/wiki/Write_amplification).
+
+- [**database persistence**]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}): Auto Tiering uses dual database persistence where both the primary and replica shards persist to disk. This may add some processor and network overhead, especially in cloud configurations with network attached storage.
+
+## What happens when Redis Enterprise Software is low on RAM?
+
+Redis Enterprise Software manages node memory so that data is entirely in RAM (unless using Auto Tiering). If not enough RAM is available, Redis Enterprise prevents adding more data into the databases.
+
+Redis Enterprise Software protects the existing data and prevents the database from being able to store data into the shards.
+
+You can configure the cluster to move the data to another node, or even discard it according to the [eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy.md" >}}) set on each database by the administrator.
+
+[Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}})
+manages memory so that you can also use flash memory (SSD) to store data.
+
+### Order of events for low RAM
+
+1. If there are other nodes available, your shards migrate to other nodes.
+2. If the eviction policy allows eviction, shards start to release memory,
+which can result in data loss.
+3. If the eviction policy does not allow eviction, you'll receive
+out of memory (OOM) messages.
+4. If shards can't free memory, Redis Enterprise relies on the OS processes to stop replicas,
+but tries to avoid stopping primary shards.
+
+We recommend that you have a [monitoring platform]({{< relref "/operate/rs/7.4/clusters/monitoring/" >}}) that alerts you before a system gets low on RAM.
+You must maintain sufficient free memory to make sure that you have a healthy Redis Enterprise installation.
+
+## Memory metrics
+
+The Cluster Manager UI provides metrics that can help you evaluate your memory use.
+
+- Free RAM
+- RAM fragmentation
+- Used memory
+- Memory usage
+- Memory limit
+
+See [console metrics]({{< relref "/operate/rs/7.4/references/metrics" >}}) for more detailed information.
+
+## Related info
+
+- [Memory and performance]({{< relref "/operate/rs/7.4/databases/memory-performance" >}})
+- [Disk sizing for heavy write scenarios]({{< relref "/operate/rs/7.4/clusters/optimize/disk-sizing-heavy-write-scenarios.md" >}})
+- [Turn off services to free system memory]({{< relref "/operate/rs/7.4/clusters/optimize/turn-off-services.md" >}})
+- [Eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy.md" >}})
+- [Shard placement policy]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy.md" >}})
+- [Database persistence]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}})
+---
+Title: Shard placement policy
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Detailed info about the shard placement policy.
+linkTitle: Shard placement policy
+weight: 30
+url: '/operate/rs/7.4/databases/memory-performance/shard-placement-policy/'
+---
+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.
+
+{{< embed-md "shard-placement-intro.md"  >}}
+
+## Shard placement policies
+
+### Dense shard placement policy
+
+In the dense policy, the cluster places the database shards on as few nodes as possible.
+When the node is not able to host all of the shards, some shards are moved to another node to maintain optimal node health.
+
+For example, for a database with two master and two replica shards on a cluster with three nodes and a dense shard placement policy,
+the two master shards are hosted on one node and the two replica shards are hosted on another node.
+
+For Redis on RAM databases without the OSS cluster API enabled, use the dense policy to optimize performance.
+
+{{< image filename="/images/rs/dense_placement.png" >}}
+
+*Figure: Three nodes with two master shards (red) and two replica shards (white) with a dense placement policy*
+
+### Sparse shard placement policy
+
+In the sparse policy, the cluster places shards on as many nodes as possible to distribute the shards of a database across all available nodes.
+When all nodes have database shards, the shards are distributed evenly across the nodes to maintain optimal node health.
+
+For example, for a database with two master and two replica shards on a cluster with three nodes and a sparse shard placement policy:
+
+- Node 1 hosts one of the master shards
+- Node 2 hosts the replica for the first master shard
+- Node 3 hosts the second master shard
+- Node 1 hosts for the replica shard for master shard 2
+
+For Redis on RAM databases with OSS cluster API enabled and for databases with Auto Tiering enabled, use the sparse policy to optimize performance.
+
+{{< image filename="/images/rs/sparse_placement.png" >}}
+
+*Figure: Three nodes with two master shards (red) and two replica shards (white) with a sparse placement policy*
+
+## Related articles
+
+You can [configure the shard placement policy]({{< relref "/operate/rs/7.4/databases/configure/shard-placement.md" >}}) for each database.
+---
+Title: Memory and performance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Learn more about managing your memory and optimizing performance for
+  your database.
+hideListLinks: true
+linktitle: Memory and performance
+weight: 70
+url: '/operate/rs/7.4/databases/memory-performance/'
+---
+Redis Enterprise Software has multiple mechanisms in its
+architecture to help optimize storage and performance.
+
+## Memory limits
+
+Database memory limits define the maximum size your database can reach across all database replicas and [shards]({{< relref "/glossary#letter-s" >}}) on the cluster. Your memory limit will also determine the number of shards you'll need.
+
+Besides your dataset, the memory limit must also account for replication, Active-Active overhead, and module overhead, and a number of other factors. These can significantly increase your database size, sometimes increasing it by four times or more.
+
+For more information on memory limits, see [Database memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}).
+
+## Eviction policies
+
+When a database exceeds its memory limit, eviction policies determine which data is removed. The eviction policy removes keys based on frequency of use, how recently used, randomly, expiration date, or a combination of these factors. The policy can also be set to `noeviction` to return a memory limit error when trying to insert more data.
+
+The default eviction policy for databases is `volatile-lru` which evicts the least recently used keys out of all keys with the `expire` field set. The default for Active-Active databases is `noeviction`.
+
+For more information, see [eviction policies]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy.md" >}}).
+
+## Database persistence
+
+Both RAM memory and flash memory are at risk of data loss if a server or process fails. Persisting your data to disk helps protect it against loss in those situations. You can configure persistence at the time of database creation, or by editing the database’s configuration.
+
+There are two main types of persistence strategies in Redis Enterprise Software: append-only files (AoF) and snapshots.
+
+Append-only files (AoF) keep a record of data changes and writes each change to the end of a file, allowing you to recover the dataset by replaying the writes in the append-only log.
+
+Snapshots capture all the data as it exists in one moment in time and writes it to disk, allowing you to recover the entire dataset as it existed at that moment in time.
+
+For more info on data persistence see [Database persistence with Redis Enterprise Software]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}) or [Durable Redis](https://redis.com/redis-enterprise/technology/durable-redis/).
+
+## Auto Tiering 
+
+By default, Redis Enterprise Software stores your data entirely in [RAM](https://en.wikipedia.org/wiki/Random-access_memory) for improved performance. The [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}) feature enables your data to span both RAM and [SSD](https://en.wikipedia.org/wiki/Solid-state_drive) storage ([flash memory](https://en.wikipedia.org/wiki/Flash_memory)). Keys are always stored in RAM, but Auto Tiering manages the location of their values. Frequently used (hot) values are stored on RAM, but infrequently used (warm) values are moved to flash memory. This saves on expensive RAM space, which give you comparable performance at a lower cost for large datasets.
+
+For more info, see [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}).
+
+## Shard placement
+
+The location of the primary and replica shards on the cluster nodes can impact your database performance.
+Primary shards and their corresponding replica shards are always placed on separate nodes for data resiliency and high availability.
+The shard placement policy helps to maintain optimal performance and resiliency.
+
+Redis Enterprise Software has two shard placement policies available:
+
+- **dense**: puts as many shards as possible on the smallest number of nodes
+- **sparse**: spread the shards across as many nodes as possible
+
+For more info about the shard placement policy, see [Shard placement policy]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy.md" >}})
+
+## Metrics
+
+From the Redis Enterprise Software Cluster Manager UI, you can monitor the performance of your clusters, nodes, databases, and shards with real-time metrics. You can also enable alerts for node, cluster, or database events such as high memory usage or throughput.
+
+With the Redis Enterprise Software API, you can also integrate Redis Enterprise metrics into other monitoring environments, such as Prometheus.
+
+For more info about monitoring with Redis Enterprise Software, see [Monitoring with metrics and alerts]({{< relref "/operate/rs/7.4/clusters/monitoring/_index.md" >}}), and [Memory statistics]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit#memory-metrics" >}}).
+
+## Scaling databases
+
+Each Redis Enterprise cluster can contain multiple databases. In Redis,
+databases represent data that belong to a single application, tenant, or
+microservice. Redis Enterprise is built to scale to 100s of databases
+per cluster to provide flexible and efficient multi-tenancy models.
+
+Each database can contain few or many Redis shards. Sharding is
+transparent to Redis applications. Master shards in the database process
+data operations for a given subset of keys. The number of shards per
+database is configurable and depend on the throughput needs of the
+applications. Databases in Redis Enterprise can be resharded into more
+Redis shards to scale throughput while maintaining sub-millisecond
+latencies. Resharding is performed without downtime.
+
+{{< image filename="/images/rs/sharding.png" >}}
+
+Redis Enterprise places master shards and replicas in separate
+nodes, racks, and zones, and uses in-memory replication to protect data
+against failures.
+
+In Redis Enterprise, each database has a quota of RAM. The quota cannot
+exceed the limits of the RAM available on the node. However, with Redis
+Enterprise Flash, RAM is extended to the local flash drive (SATA, NVMe
+SSDs etc). The total quota of the database can take advantage of both
+RAM and Flash drive. The administrator can choose the RAM vs Flash ratio
+and adjust that anytime in the lifetime of the database without
+downtime.
+
+With Auto Tiering, instead of storing all keys and data for a
+given shard in RAM, less frequently accessed values are pushed to flash.
+If applications need to access a value that is in flash, Redis
+Enterprise automatically brings the value into RAM. Depending on the
+flash hardware in use, applications experience slightly higher latency
+when bringing values back into RAM from flash. However subsequent
+accesses to the same value is fast, once the value is in RAM.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This page will help you find database management information in the Databases
+  section.
+hideListLinks: false
+linktitle: Databases
+title: Manage databases
+weight: 37
+url: '/operate/rs/7.4/databases/'
+---
+
+You can manage your Redis Enterprise Software databases with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}), [`redis-cli`]({{< relref "/develop/tools/cli" >}}), [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/7.4/references/rest-api/_index.md" >}})
+
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+db_type: database
+description: How to migrate database shards to other nodes in a Redis Software cluster.
+linkTitle: Migrate shards
+title: Migrate database shards
+toc: 'true'
+weight: 32
+url: '/operate/rs/7.4/databases/migrate-shards/'
+---
+
+To migrate database shards to other nodes in the cluster, you can use the [`rladmin migrate`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate">}}) command or [REST API requests]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate">}}).
+
+## Use cases for shard migration
+
+Migrate database shards to a different node in the following scenarios:
+
+- Before node removal.
+
+- To balance the database manually in case of latency issues or uneven load distribution across nodes.
+
+- To manage node resources, such as memory usage.
+
+## Considerations for shard migration
+
+For databases with replication:
+
+- Migrating a shard will not cause disruptions since a primary shard will still be available.
+
+- If you try to migrate a primary shard, it will be demoted to a replica shard and a replica shard will be promoted to primary before the migration. If you set `"preserve_roles": true` in the request, a second failover will occur after the migration finishes to change the migrated shard's role back to primary.
+
+For databases without replication, the migrated shard will not be available until the migration is done.
+
+Connected clients shouldn't be disconnected in either case.
+
+If too many primary shards are placed on the same node, it can impact database performance.
+
+## Migrate specific shard
+
+To migrate a specific database shard, use one of the following methods:
+
+- [`rladmin migrate shard`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate#migrate-shard">}}):
+
+    ```sh
+    rladmin migrate shard <shard_id> target_node <node_id>
+    ```
+
+- [Migrate shard]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-shard">}}) REST API request:
+
+    Specify the ID of the shard to migrate in the request path and the destination node's ID as the `target_node_uid` in the request body. See the [request reference]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-request-body">}}) for more options.
+
+    ```sh
+    POST /v1/shards/<shard_id>/actions/migrate
+    {
+        "target_node_uid": <node_id>
+    }
+    ```
+
+    Example JSON response body:
+
+    ```json
+    {
+        "action_uid": "<action_id>",
+        "description": "Migrate was triggered"
+    }
+    ```
+
+    You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/7.4/references/rest-api/requests/actions#get-action">}}) request.
+
+## Migrate multiple shards
+
+To migrate multiple database shards, use one of the following methods:
+
+- [`rladmin migrate shard`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate#migrate-shard">}}):
+
+    ```sh
+    rladmin migrate shard <shard_id1> <shard_id2> <shard_id3> target_node <node_id>
+    ```
+
+- [Migrate multiple shards]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-multi-shards">}}) REST API request:
+
+    Specify the IDs of the shards to migrate in the `shard_uids` list and the destination node's ID as the `target_node_uid` in the request body. See the [request reference]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-multi-request-body">}}) for more options.
+
+    ```sh
+    POST /v1/shards/actions/migrate
+    {
+        "shard_uids": ["<shard_id1>","<shard_id2>","<shard_id3>"],
+        "target_node_uid": <node_id>
+    }
+    ```
+
+    Example JSON response body:
+
+    ```json
+    {
+        "action_uid": "<action_id>",
+        "description": "Migrate was triggered"
+    }
+    ```
+
+    You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/7.4/references/rest-api/requests/actions#get-action">}}) request.
+
+## Migrate all shards from a node
+
+To migrate all shards from a specific node to another node, run [`rladmin migrate all_shards`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate#migrate-all_shards">}}):
+
+```sh
+rladmin migrate node <origin_node_id> all_shards target_node <node_id>
+```
+
+## Migrate primary shards
+
+You can use the [`rladmin migrate all_master_shards`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate#migrate-all_master_shards">}}) command to migrate all primary shards for a specific database or node to another node in the cluster.
+
+To migrate a specific database's primary shards:
+
+```sh
+rladmin migrate db db:<id> all_master_shards target_node <node_id>
+```
+
+To migrate all primary shards from a specific node:
+
+```sh
+rladmin migrate node <origin_node_id> all_master_shards target_node <node_id>
+```
+
+## Migrate replica shards
+
+You can use the [`rladmin migrate all_slave_shards`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/migrate#migrate-all_slave_shards">}}) command to migrate all replica shards for a specific database or node to another node in the cluster.
+
+To migrate a specific database's replica shards:
+
+```sh
+rladmin migrate db db:<id> all_slave_shards target_node <node_id>
+```
+
+To migrate all replica shards from a specific node:
+
+```sh
+rladmin migrate node <origin_node_id> all_slave_shards target_node <node_id>
+```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes internode encryption which improves the security of data in
+  transit.
+linkTitle: Internode encryption
+title: Internode encryption
+weight: 15
+url: '/operate/rs/7.4/security/encryption/internode-encryption/'
+---
+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.
+
+{{<image filename="images/rs/internode-encryption.png" alt="A diagram showing the interaction between data internode encryption, control plane encryption, and various elements of a cluster." >}}
+
+Data internode encryption is disabled by default for individual databases in order to optimize for performance.  Encryption adds latency and overhead; the impact is measurable and varies according to the database, its field types, and the details of the underlying use case. 
+
+You can enable data internode encryption for a database by changing the database configuration settings.  This lets you choose when to favor performance and when to encrypt data.
+
+## Prerequisites
+
+Internode encryption requires certain prerequisites.  
+
+You need to:
+
+- Upgrade all nodes in the cluster to v6.2.4 or later.
+
+- Open port 3342 for the TLS channel used for encrypted communication.
+
+
+## Enable data internode encryption
+
+To enable internode encryption for a database (also called _data internode encryption_), you need to enable the appropriate setting for each database you wish to encrypt.  To do so, you can:
+
+- Use the Cluster Manager UI to enable the **Internode Encryption** setting from the database **Security** screen.
+
+-  Use the `rladmin` command-line utility to set the [data_internode_encryption]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-db" >}}) setting for the database:
+
+    ``` shell
+    rladmin tune db <database_id> data_internode_encryption enabled
+    ``` 
+
+- Use the Redis Enterprise Software REST API to set the `data_internode_encryption` setting for the database.
+
+    ``` rest
+    put /v1/bdbs/${database_id}
+    { “data_internode_encryption” : true }
+    ```
+
+When you change the data internode encryption setting for a database, all active remote client connections are disconnected.  This restarts the internal (DMC) proxy and disconnects all client connections.
+
+## Change cluster policy
+
+To enable internode encryption for new databases by default, use one of the following methods:
+
+- Cluster Manager UI
+
+    1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+    1. Select **Database defaults**.
+
+    1. Go to **Internode Encryption** and click **Change**.
+
+    1. Select **Enabled** to enable internode encryption for new databases by default.
+
+    1. Click **Change**.
+
+    1. Select **Save**.
+
+- [rladmin tune cluster]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster data_internode_encryption enabled
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "data_internode_encryption": true }
+    ```
+
+## Encryption ciphers and settings
+
+To encrypt internode communications, Redis Enterprise Software uses TLS 1.2 and the following cipher suites:
+
+- ECDHE-RSA-AES256-GCM-SHA384
+- ECDHE-RSA-AES128-GCM-SHA256
+
+As of Redis Enterprise Software v7.4, internode encryption also supports TLS 1.3 with the following cipher suites:
+
+- TLS_AES_128_GCM_SHA256
+- TLS_AES_256_GCM_SHA384
+
+The TLS layer determines which TLS version to use.
+
+No configurable settings are exposed; internode encryption is used internally within a cluster and not exposed to any outside service.
+
+## Certificate authority and rotation
+
+Starting with v6.2.4, internode communication is managed, in part, by two certificates: one for the control plane and one for the data plane.  These certificates are signed by a private certificate authority (CA).  The CA is not exposed outside of the cluster, so it cannot be accessed by external processes or services.  In addition, each cluster generates a unique CA that is not used anywhere else.
+
+The private CA is generated when a cluster is created or upgraded to 6.2.4.  
+
+When nodes join the cluster, the cluster CA is used to generate certificates for the new node, one for each plane.  Certificates signed by the private CA are not shared between clusters and they're not exposed outside the cluster.
+
+All certificates signed by the internal CA expire after ninety (90) days and automatically rotate every thirty (30) days.  Alerts also monitor certificate expiration and trigger when certificate expiration falls below 45 days.  If you receive such an alert, contact support.
+
+You can use the Redis Enterprise Software REST API to rotate certificates manually:
+
+``` rest
+POST /v1/cluster/certificates/rotate
+```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Configure TLS protocol
+title: Configure TLS protocol
+weight: 50
+url: '/operate/rs/7.4/security/encryption/tls/tls-protocols/'
+---
+
+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:
+
+- Control plane - The TLS configuration for cluster administration.
+- Data plane - The TLS configuration for the communication between applications and databases.
+- Discovery service (Sentinel) - The TLS configuration for the [discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}).
+
+You can configure TLS protocols with the [Cluster Manager UI](#edit-tls-ui), [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}), or the [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster#put-cluster" >}}).
+
+{{<warning>}}
+- After you set the minimum TLS version, Redis Enterprise Software does not accept communications with TLS versions older than the specified version.
+
+- If you set TLS 1.3 as the minimum TLS version, clients must support TLS 1.3 to connect to Redis Enterprise.
+{{</warning>}}
+
+TLS support depends on the operating system. You cannot enable support for protocols or versions that aren't supported by the operating system running Redis Enterprise Software.  In addition, updates to the operating system or to Redis Enterprise Software can impact protocol and version support.  
+
+If you have trouble enabling specific versions of TLS, verify that they're supported by your operating system and that they're configured correctly.
+
+{{<note>}}
+TLSv1.2 is generally recommended as the minimum TLS version for encrypted communications. Check with your security team to confirm which TLS protocols meet your organization's policies.
+{{</note>}}
+
+### Edit TLS settings in the UI {#edit-tls-ui}
+
+To configure minimum TLS versions using the Cluster Manager UI:
+
+1. Go to **Cluster > Security**, then select the **TLS** tab.
+
+1. Click **Edit**.
+
+1. Select the minimum TLS version for cluster connections, database connections, and the discovery service:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-protocols-edit.png" alt="Cluster > Security > TLS settings in edit mode in the Cluster Manager UI." >}}
+  
+1. Select the TLS mode for the discovery service:
+
+    - **Allowed** - Allows both TLS and non-TLS connections
+    - **Required** - Allows only TLS connections
+    - **Disabled** - Allows only non-TLS connections
+
+1. Click **Save**.
+
+### Control plane TLS
+
+To set the minimum TLS protocol for the control plane using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_control_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+For example:
+
+```sh
+rladmin cluster config min_control_TLS_version 1.2
+```
+
+### Data plane TLS
+
+To set the minimum TLS protocol for the data path using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_data_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+For example:
+
+```sh
+rladmin cluster config min_data_TLS_version 1.2
+```
+
+
+### Discovery service TLS
+
+To enable TLS for the discovery service using `rladmin`:
+
+- Default: Allows both TLS and non-TLS connections
+- Syntax: `rladmin cluster config sentinel_tls_mode <ssl_policy>`
+- `ssl_policy` values available:
+  - `allowed` - Allows both TLS and non-TLS connections
+  - `required` - Allows only TLS connections
+  - `disabled` - Allows only non-TLS connections
+
+To set the minimum TLS protocol for the discovery service using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_sentinel_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+To enforce a minimum TLS version for the discovery service, run the following commands:
+
+1. Allow only TLS connections:
+
+    ```sh
+    rladmin cluster config sentinel_tls_mode required
+    ```
+
+1. Set the minimal TLS version:
+
+    ```sh
+    rladmin cluster config min_sentinel_TLS_version 1.2
+    ```
+
+1. Restart the discovery service on all cluster nodes to apply your changes:
+
+    ```sh
+    supervisorctl restart sentinel_service
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows how to configure cipher suites.
+linkTitle: Configure cipher suites
+title: Configure cipher suites
+weight: 60
+url: '/operate/rs/7.4/security/encryption/tls/ciphers/'
+---
+
+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 | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.2 communications for cluster administration (control plane) |
+| data_cipher_list | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.2 communications between applications and databases (data plane) |
+| sentinel_cipher_suites | <span title="Yes">&#x2705; Yes</span> | Cipher list for [discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service" >}}) (Sentinel) TLS 1.2 communications |
+
+## TLS 1.3 cipher suites
+
+| Name | Configurable | Description |
+|------------|--------------|-------------|
+| control_cipher_suites_tls_1_3 | <span title="No">&#x274c; No</span> | Cipher list for TLS 1.3 communications for cluster administration (control plane) |
+| data_cipher_suites_tls_1_3 | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.3 communications between applications and databases (data plane) |
+| sentinel_cipher_suites_tls_1_3 | <span title="No">&#x274c; No</span> | Cipher list for [discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service" >}}) (Sentinel) TLS 1.3 communications |
+
+## Configure cipher suites
+
+You can configure ciphers with the [Cluster Manager UI](#edit-ciphers-ui), [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}), or the [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster#put-cluster" >}}).
+
+{{<warning>}}
+Configuring cipher suites overwrites existing ciphers rather than appending new ciphers to the list.
+{{</warning>}}
+
+When you modify your cipher suites, make sure:
+
+- The configured TLS version matches the required cipher suites.
+- The certificates in use are properly signed to support the required cipher suites.
+
+{{<note>}}
+- Redis Enterprise Software doesn't support static [Diffie–Hellman (`DH`) key exchange](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) ciphers.
+
+- Support for Ephemeral Diffie–Hellman (ECDHE) key exchange ciphers depends on the operating system version and security policy.
+{{</note>}}
+
+### Edit cipher suites in the UI {#edit-ciphers-ui}
+
+To configure cipher suites using the Cluster Manager UI:
+
+1. Go to **Cluster > Security**, then select the **TLS** tab.
+
+1. In the **Cipher suites lists** section, click **Configure**:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-cipher-suites-view.png" alt="Cipher suites lists as shown in the Cluster Manager UI." >}}
+
+1. Edit the TLS cipher suites in the text boxes:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-cipher-suites-edit.png" alt="Edit cipher suites drawer in the Cluster Manager UI." >}}
+
+1. Click **Save**.
+
+### Control plane cipher suites {#control-plane-ciphers-tls-1-2}
+
+As of Redis Enterprise Software version 6.0.12, control plane cipher suites can use the BoringSSL library format for TLS connections to the Cluster Manager UI. See the BoringSSL documentation for a full list of available [BoringSSL configurations](https://github.com/google/boringssl/blob/master/ssl/test/runner/cipher_suites.go#L99-L131).
+
+#### Configure TLS 1.2 control plane cipher suites
+
+To configure TLS 1.2 cipher suites for cluster communication, use the following [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config control_cipher_suites <BoringSSL cipher list>
+```
+
+See the example below to configure cipher suites for the control plane:
+
+```sh
+rladmin cluster config control_cipher_suites ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305
+```
+{{<note>}}
+- The deprecated 3DES and RC4 cipher suites are no longer supported.
+{{</note>}}
+
+
+### Data plane cipher suites {#data-plane-ciphers-tls-1-2}
+
+Data plane cipher suites use the OpenSSL library format in Redis Enterprise Software version 6.0.20 or later. For a list of available OpenSSL configurations, see [Ciphers](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) (OpenSSL).
+
+#### Configure TLS 1.2 data plane cipher suites
+
+To configure TLS 1.2 cipher suites for communications between applications and databases, use the following [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config  data_cipher_list <OpenSSL cipher list>
+```
+
+See the example below to configure cipher suites for the data plane:
+
+```sh
+rladmin cluster config data_cipher_list AES128-SHA:AES256-SHA
+```
+{{<note>}}
+- The deprecated 3DES and RC4 cipher suites are no longer supported.
+{{</note>}}
+
+#### Configure TLS 1.3 data plane cipher suites
+
+To configure TLS 1.3 cipher suites for communications between applications and databases, use the following [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config data_cipher_suites_tls_1_3 <OpenSSL cipher list>
+```
+
+The following example configures TLS 1.3 cipher suites for the data plane:
+
+```sh
+rladmin cluster config data_cipher_suites_tls_1_3 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
+```
+
+### Discovery service cipher suites {#discovery-service-ciphers-tls-1-2}
+
+Sentinel service cipher suites use the golang.org OpenSSL format for [discovery service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service" >}}) TLS connections in Redis Enterprise Software version 6.0.20 or later. See their documentation for a list of [available configurations](https://golang.org/src/crypto/tls/cipher_suites.go).
+
+#### Configure TLS 1.2 discovery service cipher suites
+
+To configure TLS 1.2 cipher suites for the discovery service cipher suites, use the following [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config  sentinel_cipher_suites <golang cipher list> 
+```
+
+See the example below to configure cipher suites for the sentinel service:
+
+```sh
+rladmin cluster config sentinel_cipher_suites TLS_RSA_WITH_AES_128_CBC_SHA:TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
+```
+---
+Title: Enable TLS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows how to enable TLS.
+linkTitle: Enable TLS
+weight: 40
+url: '/operate/rs/7.4/security/encryption/tls/enable-tls/'
+---
+
+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]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}})
+- Communication to and from your database to other clusters for synchronization using [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/_index.md" >}})
+
+{{<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.
+{{</note>}}
+
+## Enable TLS for client connections {#client}
+
+To enable TLS for client connections:
+
+1. From your database's **Security** tab, select **Edit**.
+
+1. In the **TLS - Transport Layer Security for secure connections** section, make sure the checkbox is selected.
+
+1. In the **Apply TLS for** section, select **Clients and databases + Between databases**.
+
+1. Select **Save**.
+
+To enable mutual TLS for client connections:
+
+1. Select **Mutual TLS (Client authentication)**.
+
+    {{<image filename="images/rs/screenshots/databases/security-mtls-clients.png"  alt="Mutual TLS authentication configuration.">}}
+
+1. For each client certificate, select **+ Add certificate**, paste or upload the client certificate, then select **Done**.
+
+    If your database uses Replica Of or Active-Active replication, you also need to add the syncer certificates for the participating clusters. See [Enable TLS for Replica Of cluster connections](#enable-tls-for-replica-of-cluster-connections) or [Enable TLS for Active-Active cluster connections](#enable-tls-for-active-active-cluster-connections) for instructions.
+
+1. You can configure **Additional certificate validations** to further limit connections to clients with valid certificates.
+
+    Additional certificate validations occur only when loading a [certificate chain](https://en.wikipedia.org/wiki/Chain_of_trust#Computer_security) that includes the [root certificate](https://en.wikipedia.org/wiki/Root_certificate) and intermediate [CA](https://en.wikipedia.org/wiki/Certificate_authority) certificate but does not include a leaf (end-entity) certificate. If you include a leaf certificate, mutual client authentication skips any additional certificate validations.
+
+    1. Select a certificate validation option.
+
+        | Validation option | Description |
+        |-------------------|-------------|
+        | _No validation_ | Authenticates clients with valid certificates. No additional validations are enforced. |
+        | _By Subject Alternative Name_ | A client certificate is valid only if its Common Name (CN) matches an entry in the list of valid subjects. Ignores other [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes. |
+        | _By full Subject Name_ | A client certificate is valid only if its [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes match an entry in the list of valid subjects. |
+
+    1. If you selected **No validation**, you can skip this step. Otherwise, select **+ Add validation** to create a new entry and then enter valid [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes for your client certificates. All `Subject` attributes are case-sensitive.
+
+        | Subject attribute<br />(case-sensitive) | Description |
+        |-------------------|-------------|
+        | _Common Name (CN)_ | Name of the client authenticated by the certificate (_required_) |
+        | _Organization (O)_ | The client's organization or company name |
+        | <nobr>_Organizational Unit (OU)_</nobr> | Name of the unit or department within the organization |
+        | _Locality (L)_ | The organization's city |
+        | _State / Province (ST)_ | The organization's state or province |
+        | _Country (C)_ | 2-letter code that represents the organization's country |
+
+        You can only enter a single value for each field, except for the _Organizational Unit (OU)_ field. If your client certificate has a `Subject` with multiple  _Organizational Unit (OU)_ values, press the `Enter` or `Return` key after entering each value to add multiple Organizational Units.
+
+        {{<image filename="images/rs/screenshots/databases/security-mtls-add-cert-validation-multi-ou.png" width="350px" alt="An example that shows adding a certificate validation with multiple organizational units.">}}
+
+        **Breaking change:** If you use the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) instead of the Cluster Manager UI to configure additional certificate validations, note that `authorized_names` is deprecated as of Redis Enterprise v6.4.2. Use `authorized_subjects` instead. See the [BDB object reference]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) for more details.
+
+1. Select **Save**.
+
+    {{< note >}}
+By default, Redis Enterprise Software validates client certificate expiration dates.  You can use `rladmin` to turn off this behavior.
+
+```sh
+rladmin tune db < db:id | name > mtls_allow_outdated_certs enabled
+```
+    
+    {{< /note >}}
+
+## Enable TLS for Active-Active cluster connections
+
+To enable TLS for Active-Active cluster connections:
+
+1. If you are using the new Cluster Manager UI, switch to the legacy admin console.
+
+    {{<image filename="images/rs/screenshots/switch-to-legacy-ui.png"  width="300px" alt="Select switch to legacy admin console from the dropdown.">}}
+
+1. [Retrieve syncer certificates.](#retrieve-syncer-certificates)
+
+1. [Configure TLS certificates for Active-Active.](#configure-tls-certificates-for-active-active)
+
+1. [Configure TLS on all participating clusters.](#configure-tls-on-all-participating-clusters)
+
+{{< note >}}
+You cannot enable or turn off TLS after the Active-Active database is created, but you can change the TLS configuration.
+{{< /note >}}
+
+### Retrieve syncer certificates
+
+For each participating cluster, copy the syncer certificate from the **general** settings tab.
+
+{{< image filename="/images/rs/general-settings-syncer-cert.png" alt="general-settings-syncer-cert" >}}
+
+### Configure TLS certificates for Active-Active
+
+1. During database creation (see [Create an Active-Active Geo-Replicated Database]({{< relref "/operate/rs/7.4/databases/active-active/create.md" >}}), select **Edit** from the **configuration** tab.
+1. Enable **TLS**.
+    - **Enforce client authentication** is selected by default. If you clear this option, you will still enforce encryption, but TLS client authentication will be deactivated.
+1. Select **Require TLS for CRDB communication only** from the dropdown menu.
+    {{< image filename="/images/rs/crdb-tls-all.png" alt="crdb-tls-all" >}}
+1. Select **Add** {{< image filename="/images/rs/icon_add.png#no-click" alt="Add" >}}
+1. Paste a syncer certificate into the text box.
+    {{< image filename="/images/rs/database-tls-replica-certs.png" alt="Database TLS Configuration" >}}
+1. Save the syncer certificate. {{< image filename="/images/rs/icon_save.png#no-click" alt="Save" >}}
+1. Repeat this process, adding the syncer certificate for each participating cluster.
+1. Optional: If also you want to require TLS for client connections, select **Require TLS for All Communications** from the dropdown and add client certificates as well.
+1. Select **Update** at the bottom of the screen to save your configuration.
+
+### Configure TLS on all participating clusters
+
+Repeat this process on all participating clusters.
+
+To enforce TLS authentication, Active-Active databases require syncer certificates for each cluster connection. If every participating cluster doesn't have a syncer certificate for every other participating cluster, synchronization will fail.
+
+## Enable TLS for Replica Of cluster connections
+
+{{<embed-md "replica-of-tls-config.md">}}
+---
+Title: Transport Layer Security (TLS)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of Transport Layer Security (TLS).
+hideListLinks: true
+linkTitle: TLS
+weight: 10
+url: '/operate/rs/7.4/security/encryption/tls/'
+---
+[Transport Layer Security (TLS)](https://en.wikipedia.org/wiki/Transport_Layer_Security), a successor to SSL, ensures the privacy of data sent between applications and Redis databases. TLS also secures connections between Redis Enterprise Software nodes.
+
+You can [use TLS authentication]({{< relref "/operate/rs/7.4/security/encryption/tls/enable-tls" >}}) for the following types of communication:
+
+- Communication from clients (applications) to your database
+- Communication from your database to other clusters for replication using [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of" >}})
+- Communication to and from your database to other clusters for synchronization using [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/" >}})
+
+## Protocols and ciphers
+
+TLS protocols and ciphers define the overall suite of algorithms that clients are able to connect to the servers with.
+
+You can change the [TLS protocols]({{< relref "/operate/rs/7.4/security/encryption/tls/tls-protocols" >}}) and [ciphers]({{< relref "/operate/rs/7.4/security/encryption/tls/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.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable PEM encryption to encrypt all private keys on disk.
+linkTitle: Encrypt private keys
+title: Encrypt private keys
+toc: 'true'
+weight: 50
+url: '/operate/rs/7.4/security/encryption/pem-encryption/'
+---
+
+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`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}).
+
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config encrypt_pkeys enabled
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster#put-cluster" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster
+    { "encrypt_pkeys": true }
+    ```
+
+## Deactivate PEM encryption
+
+To deactivate PEM encryption and decrypt private keys on the disk, use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}).
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config encrypt_pkeys disabled
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster#put-cluster" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster
+    { "encrypt_pkeys": false }
+    ```
+---
+Title: Encryption in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Encryption in Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Encryption
+toc: 'true'
+weight: 60
+url: '/operate/rs/7.4/security/encryption/'
+---
+
+Redis Enterprise Software uses encryption to secure communications between clusters, nodes, databases, and clients and to protect [data in transit](https://en.wikipedia.org/wiki/Data_in_transit), [at rest](https://en.wikipedia.org/wiki/Data_at_rest), and [in use](https://en.wikipedia.org/wiki/Data_in_use).
+
+## Encrypt data in transit
+
+### TLS
+
+Redis Enterprise Software uses [Transport Layer Security (TLS)]({{<relref "/operate/rs/7.4/security/encryption/tls">}}) to encrypt communications for the following:
+
+- Cluster Manager UI
+
+- Command-line utilities
+
+- REST API
+
+- Internode communication
+
+You can also [enable TLS authentication]({{< relref "/operate/rs/7.4/security/encryption/tls/enable-tls" >}}) for the following:
+
+- Communication from clients or applications to your database
+
+- Communication from your database to other clusters for replication using [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}})
+
+- Communication to and from your database to other clusters for [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/_index.md" >}}) synchronization
+
+### Internode encryption
+
+[Internode encryption]({{<relref "/operate/rs/7.4/security/encryption/internode-encryption">}}) uses TLS to encrypt data in transit between cluster nodes.
+
+By default, internode encryption is enabled for the control plane, which manages the cluster and databases. If you also want to encrypt replication and proxy communications between database shards on different nodes, [enable data internode encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption#enable-data-internode-encryption" >}}).
+
+### Require HTTPS for REST API endpoints
+
+By default, the Redis Enterprise Software API supports communication over HTTP and HTTPS. However, you can [turn off HTTP support]({{< relref "/operate/rs/7.4/references/rest-api/encryption" >}}) to ensure that API requests are encrypted.
+
+## Encrypt data at rest
+
+### File system encryption
+
+To encrypt data stored on disk, use file system-based encryption capabilities available on Linux operating systems before you install Redis Enterprise Software.
+
+### Private key encryption
+
+Enable PEM encryption to [encrypt all private keys]({{< relref "/operate/rs/7.4/security/encryption/pem-encryption" >}}) on disk.
+
+## Encrypt data in use
+
+### Client-side encryption
+
+Use client-side encryption to encrypt the data an application stores in a Redis database. The application decrypts the data when it retrieves it from the database.
+
+You can add client-side encryption logic to your application or use built-in client functions.
+
+Client-side encryption has the following limitations:
+
+- Operations that must operate on the data, such as increments, comparisons, and searches will not function properly.
+
+- Increases management overhead.
+
+- Reduces performance.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to audit connection events.
+linkTitle: Audit events
+title: Audit connection events
+weight: 15
+url: '/operate/rs/7.4/security/audit-events/'
+---
+
+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.
+
+For development and testing environments, notifications can be saved to a local file; however, this is neither supported nor intended for production environments.
+
+For performance reasons, auditing is not enabled by default.  In addition, auditing occurs in the background (asynchronously) and is non-blocking by design.  That is, the action that triggered the notification continues without regard to the status of the notification or the listening tool.  
+
+## Enable audit notifications
+
+### Cluster audits
+
+To enable auditing for your cluster, use:
+
+- `rladmin`
+
+    ```
+    rladmin cluster config auditing db_conns \
+       audit_protocol <TCP|local> \
+       audit_address <address> \
+       audit_port <port> \
+       audit_reconnect_interval <interval in seconds> \
+       audit_reconnect_max_attempts <number of attempts>
+    ```
+
+    where:
+
+    - _audit\_protocol_ indicates the protocol used to process notifications.  For production systems, _TCP_ is the only value. 
+
+    - _audit\_address_ defines the TCP/IP address where one can listen for notifications
+
+    - _audit\_port_ defines the port where one can listen for notifications
+   
+    - _audit\_reconnect\_interval_ defines the interval (in seconds) between attempts to reconnect to the listener. Default is 1 second.
+    
+    - _audit\_reconnect\_max\_attempts_ defines the maximum number of attempts to reconnect. Default is 0. (infinite)
+
+    Development systems can set _audit\_protocol_ to `local` for testing and training purposes; however, this setting is _not_ supported for production use.  
+    
+    When `audit_protocol` is set to `local`, `<address>` should be set to a [stream socket](https://man7.org/linux/man-pages/man7/unix.7.html) defined on the machine running Redis Enterprise and _`<port>`_ should not be specified: 
+    
+    ```
+    rladmin cluster config auditing db_conns \
+       audit_protocol local audit_address <output-file>
+    ```
+
+    The output file (and path) must be accessible by the user and group running Redis Enterprise Software.
+
+- the [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/auditing-db-conns#put-cluster-audit-db-conns" >}})
+
+    ```
+    PUT /v1/cluster/auditing/db_conns
+    { 
+        "audit_address": "<address>", 
+        "audit_port": <port>, 
+        "audit_protocol": "TCP",
+        "audit_reconnect_interval": <interval>,
+        "audit_reconnect_max_attempts": <max attempts>
+    }
+    ```
+
+    where `<address>` is a string containing the TCP/IP address, `<port>` is a numeric value representing the port, `<interval>` is a numeric value representing the interval in seconds, and `<max attempts>` is a numeric value representing the maximum number of attempts to execute.
+
+### Database audits
+
+Once auditing is enabled for your cluster, you can audit individual databases.  To do so, use:
+
+- `rladmin`
+
+    ```
+    rladmin tune db db:<id|name> db_conns_auditing enabled
+    ```
+
+    where the value of the _db:_ parameter is either the cluster ID of the database or the database name.
+
+    To deactivate auditing, set `db_conns_auditing` to `disabled`.
+
+    Use `rladmin info` to retrieve additional details:
+
+    ```
+    rladmin info db <id|name>
+    rladmin info cluster
+    ```
+
+- the [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#put-bdbs" >}})
+
+    ```
+    PUT /v1/bdbs/1
+    { "db_conns_auditing": true }
+    ```
+
+    To deactivate auditing, set `db_conns_auditing` to `false`.
+
+You must enable auditing for your cluster before auditing a database; otherwise, an error appears:
+
+>  _Error setting description: Unable to enable DB Connections Auditing before feature configurations are set.                                                                                                  
+>  Error setting error_code: db_conns_auditing_config_missing_
+
+To resolve this error, enable the protocol for your cluster _before_ attempting to audit a database.
+
+### Policy defaults for new databases
+
+To audit connections for new databases by default, use:
+
+- `rladmin`
+
+    ```
+    rladmin tune cluster db_conns_auditing enabled
+    ```
+
+    To deactivate this policy, set `db_conns_auditing` to `disabled`.
+
+- the [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}})
+
+    ```
+    PUT /v1/cluster/policy
+    { "db_conns_auditing": true }
+    ```
+
+    To deactivate this policy, set `db_conns_auditing` to `false`.
+
+## Notification examples
+
+Audit event notifications are reported as JSON objects.
+
+### New connection
+
+This example reports a new connection for a database:
+
+``` json
+{
+    "ts":1655821384,
+    "new_conn":
+    {
+        "id":2285001002 ,
+        "srcip":"127.0.0.1",
+        "srcp":"39338",
+        "trgip":"127.0.0.1",
+        "trgp":"12635",
+        "hname":"",
+        "bdb_name":"DB1",
+        "bdb_uid":"5"
+    }
+}
+```
+
+### Authentication request
+
+Here is a sample authentication request for a database:
+
+``` json
+{
+    "ts":1655821384,
+    "action":"auth",
+    "id":2285001002 ,
+    "srcip":"127.0.0.1",
+    "srcp":"39338",
+    "trgip":"127.0.0.1",
+    "trgp":"12635",
+    "hname":"",
+    "bdb_name":"DB1",
+    "bdb_uid":"5",
+    "status":2,
+    "username":"user_one",
+    "identity":"user:1",
+    "acl-rules":"~* +@all"
+}
+```
+
+The `status` field reports the following: 
+
+- Values of 2, 7, or 8 indicate success.
+
+- Values of 3 or 5 indicate that the client authentication is in progress and should conclude later.
+
+- Other values indicate failures.
+
+### Database disconnect
+
+Here's what's reported when a database connection is closed:
+
+``` json
+{
+    "ts":1655821384,
+    "close_conn":
+    {
+        "id":2285001002,
+        "srcip":"127.0.0.1",
+        "srcp":"39338",
+        "trgip":"127.0.0.1",
+        "trgp":"12635",
+        "hname":"",
+        "bdb_name":"DB1",
+        "bdb_uid":"5"
+    }
+}
+```
+
+## Notification field reference
+
+The field value that appears immediately after the timestamp describes the action that triggered the notification.  The following values may appear:
+
+- `new_conn` indicates a new external connection
+- `new_int_conn` indicates a new internal connection 
+- `close_conn` occurs when a connection is closed
+- `"action":"auth"` indicates an authentication request and can refer to new authentication requests or authorization checks on existing connections
+
+In addition, the following fields may also appear in audit event notifications:
+
+| Field&nbsp;name | Description |
+|:---------:|-------------|
+| `acl-rules` | ACL rules associated with the connection, which includes a rule for the `default` user. |
+| `bdb_name` | Destination database name - The name of the database being accessed. | 
+| `bdb_uid` | Destination database ID - The cluster ID of the database being accessed. | 
+| `hname` | Client hostname - The hostname of the client.  Currently empty; reserved for future use. |
+| `id` | Connection ID - Unique connection ID assigned by the proxy. |
+| `identity` | Identity - A unique ID the proxy assigned to the user for the current connection. |
+| `srcip` | Source IP address - Source TCP/IP address of the client accessing the Redis database. |
+| `srcp` | Source port - Port associated with the source IP address accessing the Redis database. Combine the port with the address to uniquely identify the socket. |
+| `status` | Status result code - An integer representing the result of an authentication request. |
+| `trgip` | Target IP address - The IP address of the destination being accessed by the action. |
+| `trgp` | Target port - The port of the destination being accessed by the action.  Combine the port with the destination IP address to uniquely identify the database being accessed. |
+| `ts`  | Timestamp - The date and time of the event, in [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC).  Granularity is within one second. |
+| `username` | Authentication username  - Username associated with the connection; can include `default` for databases that allow default access.  (Passwords are _not_ recorded). |
+
+## Status result codes
+
+The `status` field reports the results of an authentication request as an integer.  Here's what different values mean:
+
+| Error&nbsp;value | Error code | Description | 
+|:-------------:|------------|-------------|
+| `0` | AUTHENTICATION_FAILED | Invalid username and/or password. |
+| `1` | AUTHENTICATION_FAILED_TOO_LONG | Username or password are too long. |
+| `2` | AUTHENTICATION_NOT_REQUIRED | Client tried to authenticate, but authentication isn't necessary. | 
+| `3` | AUTHENTICATION_DIRECTORY_PENDING | Attempting to receive authentication info from the directory in async mode. |
+| `4` | AUTHENTICATION_DIRECTORY_ERROR | Authentication attempt failed because there was a directory connection error. |
+| `5` | AUTHENTICATION_SYNCER_IN_PROGRESS | Syncer SASL handshake. Return SASL response and wait for the next request. | 
+| `6` | AUTHENTICATION_SYNCER_FAILED | Syncer SASL handshake. Returned SASL response and closed the connection. |
+| `7` | AUTHENTICATION_SYNCER_OK | Syncer authenticated. Returned SASL response. |
+| `8` | AUTHENTICATION_OK | Client successfully authenticated. |
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Monitor certificates on a Redis Enterprise cluster.
+linkTitle: Monitor certificates
+title: Monitor certificates
+weight: 10
+url: '/operate/rs/7.4/security/certificates/monitor-certificates/'
+---
+
+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]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}).
+
+Here are some examples of the `node_cert_expiration_seconds` metric:
+
+```sh
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="cm",node="1",path="/etc/opt/redislabs/cm_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="api",node="1",path="/etc/opt/redislabs/api_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="proxy",node="1",path="/etc/opt/redislabs/proxy_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="metrics_exporter",node="1",path="/etc/opt/redislabs/metrics_exporter_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="syncer",node="1",path="/etc/opt/redislabs/syncer_cert.pem"} 31104000.0
+```
+
+The following certificates relate to [internode communication TLS encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption" >}}) and are automatically rotated by Redis Enterprise Software:
+
+```sh
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="ccs_internode_encryption",node="1",path="/etc/opt/redislabs/ccs_internode_encryption_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="data_internode_encryption",node="1",path="/etc/opt/redislabs/data_internode_encryption_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="mesh_ca_signed",node="1",path="/etc/opt/redislabs/mesh_ca_signed_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="gossip_ca_signed",node="1",path="/etc/opt/redislabs/gossip_ca_signed_cert.pem"} 2592000.0
+```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create self-signed certificates to install on a Redis Enterprise cluster.
+linkTitle: Create certificates
+title: Create certificates
+weight: 10
+url: '/operate/rs/7.4/security/certificates/create-certificates/'
+---
+
+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](https://en.wikipedia.org/wiki/Certificate_authority) (CA).
+
+## Renew self-signed certificates
+
+As of [v6.2.18-70]({{< relref "/operate/rs/release-notes/rs-6-2-18-releases/rs-6-2-18-70" >}}), Redis Enterprise Software includes a script to generate self-signed certificates.  
+
+By default, the `generate_self_signed_certs.sh` script is located in `/opt/redislabs/utils/`.  
+
+Here, you learn how to use this script to generate new certificates and how to install them.
+
+### Step 1: Generate new certificates 
+
+Sign in to the machine hosting the cluster's master node and then run the following command:
+
+``` bash
+% sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+   -f "<DomainName1 DomainName2>" -d <Days> -t <Type>
+```
+
+where:
+
+- _\<DomainName1>_ is the fully qualified domain name (FQDN) of the cluster.  (This is the name given to the cluster when first created.)
+- _\<DomainName2>_ is an optional FQDN for the cluster.  Multiple domain names are allowed, separated by whitespace.  Quotation marks (`""`) should enclose the full set of names.
+- _\<Days>_ is an integer specifying the number of days the certificate should be valid.  We recommend against setting this longer than a year (365 days).
+
+    _\<Days>_ is optional and defaults to `365`.
+
+- _\<Type>_ is a string identifying the name of the certificate to generate.  
+    
+    The following values are supported:
+
+    | Value | Description |
+    |-------|-------------|
+    | `api` | The REST API |
+    | `cm` | The Cluster Manager UI |
+    | `metrics` | The metrics exporter |
+    | `proxy` | The database endpoint |
+    | `syncer` | The synchronization process |
+    | `all` | Generates all certificates in a single operation |
+
+    _Type_ is optional and defaults to `all`.
+
+When you run the script, it either reports success (`"Self signed cert generated successfully"`) or an error message.  Use the error message to troubleshoot any issues.
+
+The following example generates all self signed certificates for `mycluster.example.com`; these certificates expire one year after the command is run:
+
+``` bash
+$ sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+    -f "mycluster.example.com"`
+```
+
+Suppose you want to create a Cluster Manager UI certificate to support two clusters for a period of two years.  The following example shows how:
+
+``` bash
+$ sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+    -f "mycluster.example.com anothercluster.example.com" -d 730 -t cm
+```
+
+Here, a certificate file and certificate key are generated to support the following domains:
+
+``` text
+mycluster.example.com
+*.mycluster.example.com
+anothercluster.example.com 
+*.anothercluster.example.com
+```
+
+### Step 2: Locate the new certificate files
+
+When successful, the script generates two .PEM files for each generated certificate: a certificate file and a certificate key, each named after the type of certificate generated (see earlier table for individual certificate names.)
+
+These files can be found in the `/tmp` directory.
+
+``` bash
+$ ls -la /tmp/*.pem
+```
+
+### Step 3: Set permissions
+
+We recommend setting the permissions of your new certificate files to limit read and write access to the file owner and to set group and other user permissions to read access.
+
+``` bash
+$ sudo chmod 644 /tmp/*.pem
+```
+
+### Step 4: Replace existing certificates {#replace-self-signed}
+
+You can use `rladmin` to replace the existing certificates with new certificates:
+
+``` console
+$ rladmin cluster certificate set <CertName> certificate_file \
+   <CertFilename>.pem key_file <KeyFilename>.pem
+```
+
+The following values are supported for the _\<CertName>_ parameter:
+
+| Value | Description |
+|-------|-------------|
+| `api` | The REST API |
+| `cm` | The Cluster Manager UI |
+| `metrics_exporter` | The metrics exporter |
+| `proxy` | The database endpoint |
+| `syncer` | The synchronization process |
+
+You can also use the REST API.  To learn more, see [Update certificates]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates#how-to-update-certificates" >}}).
+
+## Create CA-signed certificates
+
+You can use certificates signed by a [certificate authority](https://en.wikipedia.org/wiki/Certificate_authority) (CA).  
+
+For best results, use the following guidelines to create the certificates.
+
+### TLS certificate guidelines
+
+When you create certificates signed by a certificate authority, you need to create server certificates and client certificates.  The following provide guidelines that apply to both certificates and guidance for each certificate type. 
+
+#### Guidelines for server and client certificates
+
+1.  Include the full [certificate chain](https://en.wikipedia.org/wiki/X.509#Certificate_chains_and_cross-certification) when creating certificate .PEM files for either server or client certificates.   
+
+1.  List (_chain_) certificates in the .PEM file in the following order:
+
+    ``` text    
+    -----BEGIN CERTIFICATE-----    
+    Domain (leaf) certificate
+    -----END CERTIFICATE-----
+    -----BEGIN CERTIFICATE-----
+    Intermediate CA certificate
+    -----END CERTIFICATE----
+    -----BEGIN CERTIFICATE-----
+    Trusted Root CA certificate
+    -----END CERTIFICATE-----
+    ```
+
+#### Server certificate guidelines
+
+Server certificates support clusters.  
+
+In addition to the general guidelines described earlier, the following guidelines apply to server certificates:
+
+1.  Use the cluster's fully qualified domain name (FQDN) as the certificate Common Name (CN).
+
+1.  Set the following values according to the values specified by your security team or certificate authority:
+
+    - Country Name (C)
+    - State or Province Name (ST)
+    - Locality Name (L)
+    - Organization Name (O)
+    - Organization Unit  (OU)
+
+1.  The [Subject Alternative Name](https://en.wikipedia.org/wiki/Subject_Alternative_Name) (SAN) should include the following values based on the FQDN:
+
+    ``` text
+    dns=<cluster-fqdn>
+    dns=*.<cluster-fqdn>
+    dns=internal.<cluster-fqdn>
+    dns=*.internal.<cluster-fqdn>
+    ```
+
+1.  The Extended Key Usage attribute should be set to `TLS Web Client Authentication` and `TLS Web Server Authentication`.
+
+1.  We strongly recommend using a strong hash algorithm, such as <nobr>SHA-256</nobr> or <nobr>SHA-512</nobr>.
+
+    Individual operating systems might limit access to specific algorithms.  For example, Ubuntu 20.04 [limits  access](https://manpages.ubuntu.com/manpages/focal/man7/crypto-policies.7.html) to <nobr>SHA-1</nobr>.  In such cases, Redis Enterprise Software is limited to the features supported by the underlying operating system.
+
+
+#### Client certificate guidelines
+
+Client certificates support database connections.  
+
+In addition to the general guidelines described earlier, the following guidelines apply to client certificates:
+
+1.  The Extended Key Usage attribute should be set to `TLS Web Client Authentication`.
+
+1.  We strongly recommend using a strong hash algorithm, such as <nobr>SHA-256</nobr> or <nobr>SHA-512</nobr>.
+
+    Individual operating systems might limit access to specific algorithms.  For example, Ubuntu 20.04 [limits  access](https://manpages.ubuntu.com/manpages/focal/man7/crypto-policies.7.html) to <nobr>SHA-1</nobr>.  In such cases, Redis Enterprise Software is limited to the features supported by the underlying operating system.
+
+### Create certificates
+
+The actual process of creating CA-signed certificates varies according to the CA.  In addition, your security team may have custom instructions that you need to follow. 
+
+Here, we demonstrate the general process using OpenSSL.  If your CA provides alternate tools, you should use those according to their instructions. 
+
+However you choose to create the certificates, be sure to incorporate the guidelines described earlier.
+
+1.  Create a private key.
+
+    ``` bash
+    $ openssl genrsa -out <key-file-name>.pem 2048
+    ```
+
+1.  Create a certificate signing request.
+
+    ``` bash
+    $ openssl req -new -key <key-file-name>.pem -out \
+       <key-file-name>.csr -config <csr-config-file>.cnf
+    ```
+    _Important:&nbsp;_ The .CNF file is a configuration file.  Check with your security team or certificate authority for help creating a valid configuration file for your environment.
+
+3.  Sign the private key using your certificate authority.
+
+    ```sh
+    $ openssl x509 -req -in <key-file-name>.csr -signkey <key-file-name>.pem -out <cert-name>.pem
+    ```
+
+    The signing process varies for each organization and CA vendor.  Consult your security team and certificate authority for specific instructions describing how to sign a certificate.
+
+4.  Upload the certificate to your cluster.
+
+    You can use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/certificate" >}}) to replace the existing certificates with new certificates:
+
+    ``` console
+    $ rladmin cluster certificate set <cert-name> certificate_file \
+       <cert-name>.pem key_file <key-file-name>.pem
+    ```
+
+    For a list of values supported by the `<cert-name>` parameter, see the [earlier table](#replace-self-signed).
+
+    You can also use the REST API.  To learn more, see [Update certificates]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates#how-to-update-certificates" >}}).
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use OCSP stapling to verify certificates maintained by a third-party
+  CA and authenticate connection attempts between clients and servers.
+linkTitle: Enable OCSP stapling
+title: Enable OCSP stapling
+weight: 50
+url: '/operate/rs/7.4/security/certificates/ocsp-stapling/'
+---
+
+OCSP ([Online Certificate Status Protocol](https://en.wikipedia.org/wiki/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)](https://en.wikipedia.org/wiki/Certificate_authority).
+
+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](https://en.wikipedia.org/wiki/Certificate_revocation_list) and sends the status back as a signed and timestamped response.
+
+## OCSP stapling overview
+
+ With OCSP enabled, the Redis Enterprise server regularly polls the CA's OCSP responder for the certificate's status. After it receives the response, the server caches this status until its next polling attempt.
+
+ When a client tries to connect to the Redis Enterprise server, they perform a [TLS handshake](https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_handshake) to authenticate the server and create a secure, encrypted connection. During the TLS handshake, [OCSP stapling](https://en.wikipedia.org/wiki/OCSP_stapling) lets the Redis Enterprise server send (or "staple") the cached certificate status to the client.
+
+If the stapled OCSP response confirms the certificate is still valid, the TLS handshake succeeds and the client connects to the server.
+
+The TLS handshake fails and the client blocks the connection to the server if the stapled OCSP response indicates either:
+
+- The certificate has been revoked.
+
+- The certificate's status is unknown. This can happen if the OCSP responder fails to send a response.
+
+## Set up OCSP stapling
+
+You can configure and enable OCSP stapling for your Redis Enterprise cluster with the [Cluster Manager UI](#cluster-manager-ui-method), the [REST API](#rest-api-method), or [`rladmin`](#rladmin-method).
+
+While OCSP is enabled, the server always staples the cached OCSP status when a client tries to connect. It is the client's responsibility to use the stapled OCSP status. Some Redis clients, such as [Jedis](https://github.com/redis/jedis) and [redis-py](https://github.com/redis/redis-py), already support OCSP stapling, but others might require additional configuration.
+
+### Cluster Manager UI method
+
+To set up OCSP stapling with the Redis Enterprise Cluster Manager UI:
+
+1. Go to **Cluster > Security > OCSP**.
+
+1. In the **Responder URI** section, select **Replace Certificate** to update the proxy certificate.
+
+1. Provide the key and certificate signed by your third-party CA, then select **Save**.
+
+1. Configure query settings if you don't want to use their default values:
+
+    | Name | Default value | Description |
+    |------|---------------|-------------|
+    | **Query frequency** | 1 hour | The time interval between OCSP queries to the responder URI. |
+    | **Response timeout** | 1 second | The time interval in seconds to wait for a response before timing out. |
+    | **Recovery frequency** | 1 minute | The time interval between retries after a failed query. |
+    | **Recovery maximum tries** | 5 | The number of retries before the validation query fails and invalidates the certificate. |
+
+1. Select **Enable** to turn on OCSP stapling.
+
+### REST API method
+
+To set up OCSP stapling with the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}):
+
+1. Use the REST API to [replace the proxy certificate]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates#use-the-rest-api" >}}) with a certificate signed by your third-party CA.
+
+1. To configure and enable OCSP, send a [`PUT` request to the `/v1/ocsp`]({{< relref "/operate/rs/7.4/references/rest-api/requests/ocsp#put-ocsp" >}}) endpoint and include an [OCSP JSON object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp" >}}) in the request body:
+
+    ```json
+    {
+        "ocsp_functionality": true,
+        "query_frequency": 3600,
+        "response_timeout": 1,
+        "recovery_frequency": 60,
+        "recovery_max_tries": 5
+    }
+    ```
+
+### `rladmin` method
+
+To set up OCSP stapling with the [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command-line utility:
+
+1. Use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/certificate" >}}) to [replace the proxy certificate]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates#use-the-cli" >}}) with a certificate signed by your third-party CA.
+
+1. Update the cluster's OCSP settings with the [`rladmin cluster ocsp config`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/ocsp#ocsp-config" >}}) command if you don't want to use their default values.
+
+    For example: 
+
+    ```sh
+    rladmin cluster ocsp config recovery_frequency set 30
+    ```
+
+1. Enable OCSP:
+
+    ```sh
+    rladmin cluster ocsp config ocsp_functionality set enabled
+    ```
+---
+Title: Certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of certificates in Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Certificates
+weight: 60
+url: '/operate/rs/7.4/security/certificates/'
+---
+
+Redis Enterprise Software uses self-signed certificates by default to ensure that the product is secure. If using a self-signed certificate is not the right solution for you, you can import a certificate signed by a certificate authority of your choice.
+
+Here's the list of self-signed certificates that create secure, encrypted connections to your Redis Enterprise cluster:
+
+| Certificate name | Description |
+|------------------|-------------|
+| `api` | Encrypts [REST API]({{< relref "/operate/rs/7.4/references/rest-api/" >}}) requests and responses. |
+| `cm` | Secures connections to the Redis Enterprise Cluster Manager UI. |
+| `ldap_client` | Secures connections between LDAP clients and LDAP servers. |
+| `metrics_exporter` | Sends Redis Enterprise metrics to external [monitoring tools]({{< relref "/operate/rs/7.4/clusters/monitoring/" >}}) over a secure connection. |
+| `proxy` | Creates secure, encrypted connections between clients and databases. |
+| `syncer` | For [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/" >}}) or [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}}) databases, encrypts data during the synchronization of participating clusters. |
+
+These self-signed certificates are generated on the first node of each Redis Enterprise Software installation and are copied to all other nodes added to the cluster.
+
+When you use the default self-signed certificates and you connect to the Cluster Manager UI over a web browser, you'll see an untrusted connection notification.
+
+Depending on your browser, you can allow the connection for each session or add an exception to trust the certificate for all future sessions.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update certificates in a Redis Enterprise cluster.
+linkTitle: Update certificates
+title: Update certificates
+weight: 20
+url: '/operate/rs/7.4/security/certificates/updating-certificates/'
+---
+
+{{<warning>}}
+When you update the certificates, the new certificate replaces the same certificates on all nodes in the cluster.
+{{</warning>}}
+
+## How to update certificates
+
+You can use the [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) command-line interface (CLI) or the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) to update certificates. The Cluster Manager UI lets you update proxy and syncer certificates on the **Cluster > Security > Certificates** screen.
+
+The new certificates are used the next time the clients connect to the database.
+
+When you upgrade Redis Enterprise Software, the upgrade process copies the certificates that are on the first upgraded node to all of the nodes in the cluster.
+
+{{<note>}}
+Don't manually overwrite the files located in `/etc/opt/redislabs`. Instead, upload new certificates to a temporary location on one of the cluster nodes, such as the `/tmp` directory.
+{{</note>}}
+
+### Use the Cluster Manager UI
+
+To replace proxy or syncer certificates using the Cluster Manager UI:
+
+1. Go to **Cluster > Security > Certificates**.
+
+1. Expand the section for the certificate you want to update:
+    - For the proxy certificate, expand **Server authentication**.
+    - For the syncer certificate, expand **Replica Of and Active-Active authentication**.
+
+    {{<image filename="images/rs/screenshots/cluster/security-expand-proxy-cert.png"  alt="Expanded proxy certificate for server authentication.">}}
+
+1. Click **Replace Certificate** to open the dialog.
+
+    {{<image filename="images/rs/screenshots/cluster/security-replace-proxy-cert.png"  alt="Replace proxy certificate dialog.">}}
+
+1. Upload the key file.
+
+1. Upload the new certificate.
+
+1. Click **Save**.
+
+### Use the CLI
+
+To replace certificates with the `rladmin` CLI, run the [`cluster certificate set`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/certificate" >}}) command:
+
+```sh
+ rladmin cluster certificate set <cert-name> certificate_file <cert-file-name>.pem key_file <key-file-name>.pem
+```
+
+Replace the following variables with your own values:
+
+- `<cert-name>` - The name of the certificate you want to replace. See the [certificates table]({{< relref "/operate/rs/7.4/security/certificates" >}}) for the list of valid certificate names.
+- `<cert-file-name>` - The name of your certificate file
+- `<key-file-name>` - The name of your key file
+
+For example, to replace the Cluster Manager UI (`cm`) certificate with the private key `key.pem` and the certificate file `cluster.pem`:
+
+```sh
+rladmin cluster certificate set cm certificate_file cluster.pem key_file key.pem
+```
+
+### Use the REST API
+
+To replace a certificate using the REST API, use [`PUT /v1/cluster/update_cert`]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/certificates#put-cluster-update_cert" >}}):
+
+```sh
+PUT https://[host][:port]/v1/cluster/update_cert
+    '{ "name": "<cert_name>", "key": "<key>", "certificate": "<cert>" }'
+```
+
+Replace the following variables with your own values:
+
+- `<cert_name>` - The name of the certificate to replace. See the [certificates table]({{< relref "/operate/rs/7.4/security/certificates" >}}) for the list of valid certificate names.
+- `<key>` - The contents of the \*\_key.pem file
+
+    {{< tip >}}
+
+  The key file contains `\n` end of line characters (EOL) that you cannot paste into the API call.
+  You can use `sed -z 's/\n/\\\n/g'` to escape the EOL characters.
+  {{< /tip >}}
+
+- `<cert>` - The contents of the \*\_cert.pem file
+
+## Replica Of database certificates
+
+This section describes how to update certificates for Replica Of databases.
+
+### Update proxy certificates {#update-ap-proxy-certs}
+
+To update the proxy certificate on clusters running Replica Of databases:
+
+1. Use the Cluster Manager UI, `rladmin`, or the REST API to update the proxy certificate on the source database cluster.
+
+1. From the Cluster Manager UI, update the destination database (_replica_) configuration with the [new certificate]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create#encrypt-replica-database-traffic" >}}).
+
+{{<note>}}
+- Perform step 2 as quickly as possible after performing step 1.  Connections using the previous certificate are rejected after applying the new certificate.  Until both steps are performed, recovery of the database sync cannot be established.
+{{</note>}}
+
+## Active-Active database certificates
+
+### Update proxy certificates {#update-aa-proxy-certs}
+
+To update proxy certificate on clusters running Active-Active databases:
+
+1. Use the Cluster Manager UI, `rladmin`, or the REST API to update proxy certificates on a single cluster, multiple clusters, or all participating clusters.
+
+1. Use the [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) utility to update Active-Active database configuration from the command line. Run the following command once for each Active-Active database residing on the modified clusters:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --force
+    ```
+
+{{<note>}}
+- Perform step 2 as quickly as possible after performing step 1.  Connections using the previous certificate are rejected after applying the new certificate.  Until both steps are performed, recovery of the database sync cannot be established.<br/>
+- Do not run any other `crdb-cli crdb update` operations between the two steps.
+{{</note>}}
+
+### Update syncer certificates {#update-aa-syncer-certs}
+
+To update your syncer certificate on clusters running Active-Active databases, follow these steps:
+
+1. Update your syncer certificate on one or more of the participating clusters using the Cluster Manager UI, `rladmin`, or the REST API. You can update a single cluster, multiple clusters, or all participating clusters.
+
+1. Update the Active-Active database configuration from the command line with the [`crdb-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) utility. Run this command once for each Active-Active database that resides on the modified clusters:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --force
+    ```
+
+{{<note>}}
+- Run step 2 as quickly as possible after step 1. Between the two steps, new syncer connections that use the ‘old’ certificate will get rejected by the cluster that has been updated with the new certificate (in step 1).<br/>
+- Do not run any other `crdb-cli crdb update` operations between the two steps.<br/>
+- **Known limitation**: Updating syncer certificate on versions prior to 6.0.20-81 will restart the proxy and syncer connections. In these cases, we recommend scheduling certificate replacement carefully to minimize customer impact.
+{{</note>}}
+---
+Title: Recommended security practices
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Recommended security practices
+hideListLinks: true
+weight: 5
+aliases:
+    - /operate/rs/security/admin-console-security/
+url: '/operate/rs/7.4/security/recommended-security-practices/'
+---
+
+## Deployment security
+
+When deploying Redis Enterprise Software to production, we recommend the following practices:
+
+- **Deploy Redis Enterprise inside a trusted network**:  Redis Enterprise is database software and should be deployed on a trusted network not accessible to the public internet. Deploying Redis Enterprise in a trusted network reduces the likelihood that someone can obtain unauthorized access to your data or the ability to manage your database configuration.
+
+- **Implement anti-virus exclusions**: To ensure that anti-virus solutions that scan files or intercept processes to protect memory do not interfere with Redis Enterprise software, you should ensure that anti-virus exclusions are implemented across all nodes in their Redis Enterprise cluster in a consistent policy. This helps ensure that anti-virus software does not impact the availability of your Redis Enterprise cluster.
+
+    If you are replacing your existing antivirus solution or installing/supporting Redis Enterprise, make sure that the below paths are excluded:
+
+    {{< note >}}
+For antivirus solutions that intercept processes, binary files may have to be excluded directly depending on the requirements of your anti-virus vendor.
+    {{< /note >}}
+
+    | **Path** | **Description** |
+    |------------|-----------------|
+    | /opt/redislabs | Main installation directory for all Redis Enterprise Software binaries |
+    | /opt/redislabs/bin | Binaries for all the utilities for command line access and managements such as "rladmin" or "redis-cli" |
+    | /opt/redislabs/config | System configuration files |
+    | /opt/redislabs/lib | System library files |
+    | /opt/redislabs/sbin | System binaries for tweaking provisioning |
+
+- **Send logs to a remote logging server**: Redis Enterprise is configured to send logs by default to syslog. To send these logs to a remote logging server you must [configure syslog]({{<relref "/operate/rs/7.4/clusters/logging/log-security">}}) based the requirements of the remote logging server vendor. Remote logging helps ensure that the logs are not deleted so that you can rotate the logs to prevent your server disk from filling up.
+
+- **Deploy clusters with an odd number of 3 or more nodes**: Redis is an available and partition-tolerant database. We recommend that Redis Enterprise be deployed in a cluster of an odd number of 3 or more nodes so that you are able to successfully failover in the event of a failure.
+
+- **Reboot nodes in a sequence rather than all at once**: It is best practice to frequently maintain reboot schedules. If you reboot too many servers at once, it is possible to cause a quorum failure that results in loss of availability of the database. We recommend that rebooting be done in a phased manner so that quorum is not lost. For example, to maintain quorum in a 3 node cluster, at least 2 nodes must be up at all times. Only one server should be rebooted at any given time to maintain quorum.
+
+- **Implement client-side encryption**: Client-side encryption, or the practice of encrypting data within an application before storing it in a database, such as Redis, is the most widely adopted method to achieve encryption in memory. Redis is an in-memory database and stores data in-memory. If you require encryption in memory, better known as encryption in use, then client side encryption may be the right solution for you. Please be aware that database functions that need to operate on data — such as simple searching functions, comparisons, and incremental operations — don’t work with client-side encryption.
+
+## Cluster security
+
+- **Control the level of access to your system**: Redis Enterprise lets you decide which users can access the cluster, which users can access databases, and which users can access both. We recommend preventing database users from accessing the cluster. See [Access control]({{<relref "/operate/rs/7.4/security/access-control">}}) for more information.
+
+- **Enable LDAP authentication**: If your organization uses the Lightweight Directory Access Protocol (LDAP), we recommend enabling Redis Enterprise Software support for role-based LDAP authentication.
+
+- **Require HTTPS for API endpoints**: Redis Enterprise comes with a REST API to help automate tasks. This API is available in both an encrypted and unencrypted endpoint for backward compatibility. You can [disable the unencrypted endpoint]({{<relref "/operate/rs/7.4/references/rest-api/encryption#require-https-for-api-endpoints">}}) with no loss in functionality.
+
+## Database security
+
+Redis Enterprise offers several database security controls to help protect your data against unauthorized access and to improve the operational security of your database. The following section details configurable security controls available for implementation.
+
+- **Use strong Redis passwords**: A frequent recommendation in the security industry is to use strong passwords to authenticate users. This helps to prevent brute force password guessing attacks against your database. Its important to check that your password aligns with your organizations security policy.
+
+- **Deactivate default user access**: Redis Enterprise comes with a "default" user for backwards compatibility with applications designed with versions of Redis prior to Redis Enterprise 6. The default user is turned on by default. This allows you to access the database without specifying a username and only using a shared secret. For applications designed to use access control lists, we recommend that you [deactivate default user access]({{<relref "/operate/rs/7.4/security/access-control/manage-users/default-user#deactivate-default-user">}}).
+
+- **Configure Transport Layer Security (TLS)**: Similar to the control plane, you can also [configure TLS protocols]({{<relref "/operate/rs/7.4/security/encryption/tls/tls-protocols">}}) to help support your security and compliance needs.
+
+- **Enable client certificate authentication**: To prevent unauthorized access to your data, Redis Enterprise databases support the [TLS protocol]({{<relref "/operate/rs/7.4/security/encryption/tls#client-certificate-authentication">}}), which includes authentication and encryption. Client certificate authentication can be used to ensure only authorized hosts can access the database.
+
+- **Install trusted certificates**: Redis implements self-signed certificates for the database proxy and replication service, but many organizations prefer to [use their own certificates]({{<relref "/operate/rs/7.4/security/certificates/create-certificates">}}).
+
+- **Configure and verify database backups**: Implementing a disaster recovery strategy is an important part of data security. Redis Enterprise supports [database backups to many destinations]({{<relref "/operate/rs/7.4/databases/import-export/schedule-backups">}}).
+---
+Title: Rotate passwords
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Rotate user passwords.
+linkTitle: Rotate passwords
+toc: 'true'
+weight: 70
+url: '/operate/rs/7.4/security/access-control/manage-passwords/rotate-passwords/'
+---
+
+Redis Enterprise Software lets you implement password rotation policies using the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}).
+
+You can add a new password for a database user without immediately invalidating the old one (which might cause authentication errors in production).
+
+{{< note >}}
+Password rotation does not work for the default user. [Add additional users]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}) to enable password rotation.
+{{< /note >}}
+
+## Password rotation policies
+
+For user access to the Redis Enterprise Software Cluster Manager UI,
+you can set a [password expiration policy]({{< relref "/operate/rs/7.4/security/access-control/manage-passwords/password-expiration" >}}) to prompt the user to change their password.
+
+However, for database connections that rely on password authentication,
+you need to allow for authentication with the existing password while you roll out the new password to your systems.
+
+With the Redis Enterprise Software REST API, you can add additional passwords to a user account for authentication to the database or the Cluster Manager UI and API.
+
+After the old password is replaced in the database connections, you can delete the old password to finish the password rotation process.
+
+{{< warning >}}
+Multiple passwords are only supported using the REST API.
+If you reset the password for a user in the Cluster Manager UI,
+the new password replaces all other passwords for that user.
+{{< /warning >}}
+
+The new password cannot already exist as a password for the user and must meet the [password complexity]({{< relref "/operate/rs/7.4/security/access-control/manage-passwords/password-complexity-rules" >}}) requirements, if enabled.
+
+## Rotate password
+
+To rotate the password of a user account:
+
+1. Add an additional password to a user account with [`POST /v1/users/password`]({{< relref "/operate/rs/7.4/references/rest-api/requests/users/password#add-password" >}}):
+
+    ```sh
+    POST https://[host][:port]/v1/users/password
+         '{"username":"<username>", "old_password":"<an_existing_password>", "new_password":"<a_new_password>"}'
+    ```
+
+    After you send this request, you can authenticate with both the old and the new password.
+
+1. Update the password in all database connections that connect with the user account.
+1. Delete the original password with [`DELETE /v1/users/password`]({{< relref "/operate/rs/7.4/references/rest-api/requests/users/password#update-password" >}}):
+
+    ```sh
+    DELETE https://[host][:port]/v1/users/password
+           '{"username":"<username>", "old_password":"<an_existing_password>"}'
+    ```
+
+    If there is only one valid password for a user account, you cannot delete that password.
+
+## Replace all passwords
+
+You can also replace all existing passwords for a user account with a single password that does not match any existing passwords.
+This can be helpful if you suspect that your passwords are compromised and you want to quickly resecure the account.
+
+To replace all existing passwords for a user account with a single new password, use [`PUT /v1/users/password`]({{< relref "/operate/rs/7.4/references/rest-api/requests/users/password#delete-password" >}}):
+
+```sh
+PUT https://[host][:port]/v1/users/password
+    '{"username":"<username>", "old_password":"<an_existing_password>", "new_password":"<a_new_password>"}'
+```
+
+All of the existing passwords are deleted and only the new password is valid.
+
+{{<note>}}
+If you send the above request without specifying it is a `PUT` request, the new password is added to the list of existing passwords.
+{{</note>}}
+---
+Title: Configure password expiration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure password expiration to enforce expiration of a user's password
+  after a specified number of days.
+linkTitle: Password expiration
+toc: 'true'
+weight: 50
+url: '/operate/rs/7.4/security/access-control/manage-passwords/password-expiration/'
+---
+
+## Enable password expiration 
+
+To enforce an expiration of a user's password after a specified number of days:
+
+- Use the Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn on **Expiration**.
+
+    1. Enter the number of days before passwords expire.
+
+    1. Select **Save**.
+
+- Use the `cluster` endpoint of the REST API
+
+    ``` REST
+    PUT https://[host][:port]/v1/cluster
+    {"password_expiration_duration":<number_of_days>}
+    ```
+
+## Deactivate password expiration
+
+To deactivate password expiration:
+
+- Use the Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn off **Expiration**.
+
+    1. Select **Save**.
+
+- Use the `cluster` REST API endpoint to set `password_expiration_duration` to `0` (zero).
+---
+Title: Update admin credentials for Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update admin credentials for Active-Active databases.
+linkTitle: Update Active-Active admin credentials
+weight: 90
+url: '/operate/rs/7.4/security/access-control/manage-passwords/active-active-admin-credentials/'
+---
+
+Active-Active databases use administrator credentials to manage operations.
+
+To update the administrator user password on a cluster with Active-Active databases:
+
+1. From the user management page, update the administrator user password on the clusters you want to update.
+
+1. For each participating cluster _and_ each Active-Active database, update the admin user credentials to match the changes in step 1. 
+
+{{<warning>}}
+Do not perform any management operations on the databases until these steps are complete.
+{{</warning>}}
+---
+Title: Enable password complexity rules
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable password complexity rules.
+linkTitle: Password complexity rules
+toc: 'true'
+weight: 30
+url: '/operate/rs/7.4/security/access-control/manage-passwords/password-complexity-rules/'
+---
+
+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.
+
+In addition, the password:
+
+- Cannot contain the user's email address or the reverse of the email address.
+- Cannot have more than three repeating characters.
+
+Password complexity rules apply when a new user account is created and when the password is changed.  Password complexity rules are not applied to accounts authenticated by an external identity provider.  
+
+You can use the Cluster Manager UI or the REST API to enable password complexity rules.
+
+## Enable using the Cluster Manager UI
+
+To enable password complexity rules using the Cluster Manager UI:
+
+1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+1. In the **Password** section, turn on **Complexity rules**.
+
+1. Select **Save**.
+
+## Enable using the REST API
+
+To use the REST API to enable password complexity rules:
+
+``` REST
+PUT https://[host][:port]/v1/cluster
+{"password_complexity":true}
+```
+
+## Deactivate password complexity rules
+
+To deactivate password complexity rules:
+
+- Use the Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn off **Complexity rules**.
+
+    1. Select **Save**.
+
+- Use the `cluster` REST API endpoint to set `password_complexity` to `false`
+---
+Title: Set password policies
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set password policies.
+hideListLinks: true
+linkTitle: Set password policies
+toc: 'true'
+weight: 30
+url: '/operate/rs/7.4/security/access-control/manage-passwords/'
+---
+
+Redis Enterprise Software provides several ways to manage the passwords of local accounts, including:
+
+- [Password complexity rules]({{< relref "/operate/rs/7.4/security/access-control/manage-passwords/password-complexity-rules" >}})
+
+- [Password expiration]({{< relref "/operate/rs/7.4/security/access-control/manage-passwords/password-expiration" >}})
+
+- [Password rotation]({{< relref "/operate/rs/7.4/security/access-control/manage-passwords/rotate-passwords" >}})
+
+You can also manage a user's ability to [sign in]({{< relref "/operate/rs/7.4/security/access-control/manage-users/login-lockout#user-login-lockout" >}}) and control [session timeout]({{< relref "/operate/rs/7.4/security/access-control/manage-users/login-lockout#session-timeout" >}}).
+
+To enforce more advanced password policies, we recommend using [LDAP integration]({{< relref "/operate/rs/7.4/security/access-control/ldap" >}}) with an external identity provider, such as Active Directory.
+
+{{<note>}}
+Redis Enterprise Software stores all user passwords using the SHA-256 cryptographic hash function.
+{{</note>}}
+---
+Title: Manage user login
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage user login lockout and session timeout.
+linkTitle: Manage user login and session
+toc: 'true'
+weight: 40
+url: '/operate/rs/7.4/security/access-control/manage-users/login-lockout/'
+---
+
+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.
+
+## User login lockout
+
+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`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}).
+
+### View login lockout settings
+
+You can view the cluster's user login lockout settings from **Cluster > Security > Preferences > Lockout threshold** in the Cluster Manager UI or with [`rladmin info cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-cluster" >}}):
+
+```sh
+$ rladmin info cluster | grep login_lockout
+    login_lockout_counter_reset_after: 900
+    login_lockout_duration: 1800
+    login_lockout_threshold: 5
+```
+
+### Configure user login lockout
+
+To change the user login lockout settings using the Cluster Manager UI:
+
+1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+1. In the **Lockout threshold** section, make sure the checkbox is selected.
+
+    {{<image filename="images/rs/screenshots/cluster/security-preferences-lockout-threshold.png" alt="The Lockout threshold configuration section" >}}
+
+1. Configure the following **Lockout threshold** settings:
+
+    1. **Log-in attempts until user is revoked** - The number of failed login attempts allowed before the user account is locked.
+
+    1. **Time between failed login attempts** in seconds, minutes, or hours - The amount of time during which failed login attempts are counted.
+
+    1. For **Unlock method**, select one of the following:
+
+        - **Locked duration** to set how long the user account is locked after excessive failed login attempts.
+
+        - **Only Admin can unlock the user by resetting the password**.
+
+1. Select **Save**.
+
+### Change allowed login attempts
+
+To change the number of failed login attempts allowed before the user account is locked, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold <integer>
+    ```
+
+    For example, to set the lockout threshold to 10 failed login attempts, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 10
+    ```
+
+    If you set the lockout threshold to 0, it turns off account lockout, and the cluster settings show `login_lockout_threshold: disabled`.
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 0
+    ```
+
+### Change time before login attempts reset
+
+To change the amount of time during which failed login attempts are counted, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_counter_reset_after <seconds>
+    ```
+
+    For example, to set the lockout reset to 1 hour, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_counter_reset_after 3600
+    ```
+
+### Change login lockout duration
+
+To change the amount of time that the user account is locked after excessive failed login attempts, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_duration <login_lockout_duration>
+    ```
+
+    For example, to set the lockout duration to 1 hour, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_duration 3600
+    ```
+
+    If you set the lockout duration to 0, then the account can be unlocked only when an administrator changes the account's password.
+
+    ```sh
+    rladmin tune cluster login_lockout_duration 0
+    ```
+
+    The cluster settings now show `login_lockout_duration: admin-release`.
+
+### Unlock locked user accounts
+
+To unlock a user account in the Cluster Manager UI:
+
+1. Go to **Access Control > Users**. Locked users have a "User is locked out" label:
+
+   {{<image filename="images/rs/screenshots/access-control/users-locked-out.png" alt="The Access Control > Users configuration screen in the Cluster Manager UI" >}}
+
+1. Point to the user you want to unlock, then click **Reset to unlock**:
+
+   {{<image filename="images/rs/screenshots/access-control/users-reset-to-unlock.png" alt="Reset to unlock button appears when you point to a locked user in the list" >}}
+
+1. In the **Reset user password** dialog, enter a new password for the user:
+
+   {{<image filename="images/rs/screenshots/access-control/users-reset-user-password-dialog.png" alt="Reset user password dialog" >}}
+
+1. Select **Save** to reset the user's password and unlock their account.
+
+To unlock a user account or reset a user password with `rladmin`, run:
+
+```sh
+rladmin cluster reset_password <user_email>
+```
+
+To unlock a user account or reset a user password with the REST API, use [`PUT /v1/users`]({{< relref "/operate/rs/7.4/references/rest-api/requests/users#put-user" >}}):
+
+```sh
+PUT /v1/users
+{"password": "<new_password>"}
+```
+
+### Turn off login lockout
+
+To turn off user login lockout and allow unlimited login attempts, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. Clear the **Lockout threshold** checkbox.
+
+    1. Select **Save**.
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 0
+    ```
+
+The cluster settings show `login_lockout_threshold: disabled`.
+
+## Configure session timeout
+
+The Redis Enterprise Cluster Manager UI supports session timeouts. By default, users are automatically logged out after 15 minutes of inactivity.
+
+To customize the session timeout, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. For **Session timeout**, select minutes or hours from the list and enter the timeout value.
+
+    1. Select **Save**.
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config cm_session_timeout_minutes <number_of_min>
+    ```
+
+    The `<number_of_min>` is the number of minutes after which sessions will time out.
+---
+Title: Manage user security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage user account security settings.
+hideListLinks: false
+linkTitle: Manage user security
+weight: 20
+url: '/operate/rs/7.4/security/access-control/manage-users/'
+---
+
+Redis Enterprise supports the following user account security settings:
+
+- Password complexity
+- Password expiration
+- User lockouts
+- Account inactivity timeout
+
+## Manage users and user security
+
+---
+Title: Manage default user
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage a database's default user.
+linkTitle: Manage default user
+toc: 'true'
+weight: 60
+url: '/operate/rs/7.4/security/access-control/manage-users/default-user/'
+---
+
+When you [create a database]({{< relref "/operate/rs/7.4/databases/create" >}}), 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.
+
+{{<image filename="images/rs/screenshots/databases/security-access-control-password-only.png" alt="Select Password-only authentication to require a password to access the database." >}}
+
+## Authenticate as default user
+
+When you configure a password for your database, all connections to the database must authenticate using the [AUTH]({{< relref "/commands/auth" >}}) command. See Redis security's [authentication]({{<relref "/operate/oss_and_stack/management/security/#authentication">}}) section for more information.
+
+```sh
+AUTH <default-database-password>
+```
+
+## Change default database password
+
+To change the default user's password:
+
+1. From the database's **Security** tab, select **Edit**.
+
+1. In the **Access Control** section, select **Password-only authentication** as the **Access method**.
+
+1. Enter and re-enter the new password.
+
+1. Select **Save**.
+
+## Deactivate default user
+
+If you set up [role-based access control]({{< relref "/operate/rs/7.4/security/access-control" >}}) with [access control lists]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}}) (ACLs) for your database and don't require backwards compatibility with versions earlier than Redis 6, you can [deactivate the default user]({{< relref "/operate/rs/7.4/security/access-control/manage-users/default-user" >}}).
+
+{{<warning>}}
+Before you deactivate default user access, make sure the role associated with the database is [assigned to a user]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}). Otherwise, the database will be inaccessible.
+{{</warning>}}
+
+To deactivate the default user:
+
+1. From the database's **Security** tab, select **Edit**.
+
+1. In the **Access Control** section, select **Using ACL only** as the **Access method**.
+
+    {{<image filename="images/rs/screenshots/databases/security-access-control-acl-only.png" alt="Select Using ACL only to deactivate default user access to the database." >}}
+
+1. Choose at least one role and Redis ACL to access the database.
+
+1. Select **Save**.
+---
+Title: Update database ACLs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to use the Cluster Manager UI to update database access
+  control lists (ACLs) to authorize access to roles authorizing LDAP user access.
+weight: 45
+url: '/operate/rs/7.4/security/access-control/ldap/update-database-acls/'
+---
+
+To grant LDAP users access to a database, assign the mapped access role to the access control list (ACL) for the database.
+
+1.  In the Cluster Manager UI, go to **Databases**, then select the database from the list.
+
+1.  From the **Security** tab, select the **Edit** button.
+
+1.  In the **Access Control List** section, select **+ Add ACL**.
+
+    {{<image filename="images/rs/screenshots/databases/security-access-control-acl-only.png" alt="Updating a database access control list (ACL)" >}}
+
+1.  Select the appropriate roles and then save your changes.
+
+If you assign multiple roles to an ACL and a user is authorized by more than one of these roles, their access is determined by the first “matching” rule in the list.  
+
+If the first rule gives them read access and the third rule authorizes write access, the user will only be able to read data.  
+
+As a result, we recommend ordering roles so that higher access roles appear before roles with more limited access. 
+
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap.md" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles.md" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/7.4/security/" >}})
+---
+Title: Enable role-based LDAP
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to enable role-based LDAP authentication and authorization
+  using the Cluster Manager UI.
+weight: 25
+url: '/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap/'
+---
+
+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.
+
+## Set up LDAP connection
+
+To configure and enable LDAP from the Cluster Manager UI:
+
+1. Go to **Access Control > LDAP > Configuration**.
+
+1. Select **+ Create**.
+
+1. In **Set LDAP**, configure [LDAP server settings](#ldap-server-settings), [bind credentials](#bind-credentials), [authentication query](#authentication-query), and [authorization query](#authorization-query).
+
+   {{<image filename="images/rs/screenshots/access-control/ldap-config.png" alt="The LDAP configuration screen in the Cluster Manager UI" >}}
+
+1. Select **Save & Enable**.
+
+### LDAP server settings
+
+The **LDAP server** settings define the communication settings used for LDAP authentication and authorization. These include:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Protocol type** | Underlying communication protocol; must be _LDAP_, _LDAPS_, or _STARTTLS_ |
+| **Host** | URL of the LDAP server |
+| **Port** | LDAP server port number |
+| **Trusted CA certificate** |  _(LDAPS or STARTTLS protocols only)_ Certificate for the trusted certificate authority (CA) |
+
+When defining multiple LDAP hosts, the organization tree structure must be identical for all hosts.
+
+### Bind credentials
+
+These settings define the credentials for the bind query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Distinguished Name** | Example: `cd=admin,dc=example,dc=org` |
+| **Password** | Example: `admin1` |
+| **Client certificate authentication** |_(LDAPS or STARTTLS protocols only)_ Place checkmark to enable | 
+| **Client public key** | _(LDAPS or STARTTLS protocols only)_ The client public key for authentication |
+| **Client private key** | _(LDAPS or STARTTLS protocols only)_ The client private key for authentication |
+
+### Authentication query
+
+These settings define the authentication query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Search user by** | Either _Template_ or _Query_ |
+| **Template** | _(template search)_ Example: `cn=%u,ou=dev,dc=example,dc=com` |
+| **Base** | _(query search)_ Example: `ou=dev,dc=example,dc=com` |
+| **Filter** | _(query search)_ Example: `(cn=%u)` |
+| **Scope**  | _(query search)_ Must be _baseObject_, _singleLevel_, or _wholeSubtree_ |
+
+In this example, `%u` is replaced by the username attempting to access the Redis Enterprise resource.
+
+### Authorization query
+
+These settings define the group authorization query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Search groups by** | Either _Attribute_ or _Query_ |
+| **Attribute** | _(attribute search)_ Example: `memberOf` (case-sensitive) |
+| **Base** | _(query search)_ Example: `ou=groups,dc=example,dc=com` |
+| **Filter** | _(query search)_ Example: `(members=%D)` |
+| **Scope**  | _(query search)_ Must be _baseObject_, _singleLevel_, or _wholeSubtree_ |
+
+In this example, `%D` is replaced by the Distinguished Name of the user attempting to access the Redis Enterprise resource.
+
+### Authentication timeout
+
+The **Authentication timeout** setting determines the connection timeout to the LDAP server during user authentication.
+
+By default, the timeout is 5 seconds, which is recommended for most cases.
+ 
+However, if you enable multi-factor authentication (MFA) for your LDAP server, you might need to increase the timeout to provide enough time for MFA verification. You can set it to any integer in the range of 5-60 seconds.
+
+## More info
+
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/7.4/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Software [security and practices]({{< relref "/operate/rs/7.4/security/" >}})
+---
+Title: Map LDAP groups to roles
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to map LDAP authorization groups to Redis Enterprise roles
+  using the Cluster Manager UI.
+weight: 35
+url: '/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles/'
+---
+
+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:
+
+1. Select **Access Control > LDAP > Mapping**.
+
+    {{<note>}}
+You can map LDAP roles when LDAP configuration is not enabled, but they won't have any effect until you [configure and enable LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap" >}}).
+    {{</note>}}
+
+    {{<image filename="images/rs/access-control-ldap-mappings-panel.png" alt="Enable LDAP mappings Panel" >}}
+
+1.  Select the **+ Add LDAP Mapping** button to create a new mapping and then enter the following details:
+
+    | _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Name** | A descriptive, unique name for the mapping |
+| **Distinguished Name** | The distinguished name of the LDAP group to be mapped.  <br/>Example: `cn=admins,ou=groups,dc=example,dc=com` |
+| **Role** | The Redis Software access control role defined for this group |
+| **Email** | _(Optional)_ An address to receive alerts|
+| **Alerts**  | Selections identifying the desired alerts. |
+
+    {{<image filename="images/rs/access-control-ldap-mappings-add.png" alt="Enable LDAP mappings Panel" >}}
+
+1.  When finished, select the **Save** button.
+
+Create a mapping for each LDAP group used to authenticate and/or authorize access to Redis Enterprise Software resources.
+
+The scope of the authorization depends on the access control role:
+
+- If the role authorizes admin management, LDAP users are authorized as cluster management administrators.
+
+- If the role authorizes database access, LDAP users are authorized to use the database to the limits specified in the role.
+
+- To authorize LDAP users to specific databases, update the database access control lists (ACLs) to include the mapped LDAP role.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/7.4/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/7.4/security/" >}})
+---
+Title: Migrate to role-based LDAP
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to migrate existing cluster-based LDAP deployments to role-based
+  LDAP.
+weight: 55
+url: '/operate/rs/7.4/security/access-control/ldap/migrate-to-role-based-ldap/'
+---
+
+Redis Enterprise Software supports LDAP through a [role-based mechanism]({{< relref "/operate/rs/7.4/security/access-control/ldap/" >}}), first introduced [in v6.0.20]({{< relref "/operate/rs/release-notes/rs-6-0-20-april-2021" >}}).
+
+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:
+
+1.  Identify accounts per app on the customer end.
+
+1.  Create or identify an LDAP user account on the server that is responsible for LDAP authentication and authorization.
+
+1.  Create or identify an LDAP group that contains the app team members.
+
+1.  Verify or configure the Redis Enterprise ACLs.
+
+1.  Configure each database ACL.
+
+1.  Remove the earlier "external" (LDAP) users from Redis Enterprise.
+
+1.  _(Recommended)_ Update cluster configuration to replace the cluster-based configuration file.
+
+    You can use `rladmin` to update the cluster configuration:
+
+    ``` bash
+    $ touch /tmp/saslauthd_empty.conf
+    $ rladmin cluster config saslauthd_ldap_conf \
+         /tmp/saslauthd_empty.conf
+    ```
+
+    Here, a blank file replaces the earlier configuration.
+
+1.  Use **Access Control > LDAP > Configuration** to enable role-based LDAP.
+
+1.  Map your LDAP groups to access control roles.
+
+1.  Test application connectivity using the LDAP credentials of an app team member.
+
+1.  _(Recommended)_ Turn off default access for the database to avoid anonymous client connections.
+
+ Because deployments and requirements vary, you’ll likely need to adjust these guidelines.
+
+## Test LDAP access
+
+To test your LDAP integration, you can:
+
+- Connect with `redis-cli` and use the [`AUTH` command]({{< relref "/commands/auth" >}}) to test LDAP username/password credentials.
+
+- Sign in to the Cluster Manager UI using LDAP credentials authorized for admin access.
+
+- Use [Redis Insight]({{< relref "/develop/tools/insight/" >}}) to access a database using authorized LDAP credentials.
+
+- Use the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) to connect using authorized LDAP credentials.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/7.4/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/7.4/security/" >}})
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how Redis Enterprise Software integrates LDAP authentication
+  and authorization. Also describes how to enable LDAP for your deployment of Redis
+  Enterprise Software.
+hideListLinks: true
+linkTitle: LDAP authentication
+title: LDAP authentication
+weight: 50
+url: '/operate/rs/7.4/security/access-control/ldap/'
+---
+
+Redis Enterprise Software supports [Lightweight Directory Access Protocol](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol) (LDAP) authentication and authorization through its [role-based access controls]({{< relref "/operate/rs/7.4/security/access-control" >}}) (RBAC).  You can use LDAP to authorize access to the Cluster Manager UI and to control database access.
+
+You can configure LDAP roles using the Redis Enterprise Cluster Manager UI or [REST API]({{< relref "/operate/rs/7.4/references/rest-api/requests/ldap_mappings/" >}}).
+
+## How it works
+
+Here's how role-based LDAP integration works:
+
+{{<image filename="images/rs/access-control-ldap-diagram.png" alt="LDAP overview" >}}
+
+1.  A user signs in with their LDAP credentials.  
+
+    Based on the LDAP configuration details, the username is mapped to an LDAP Distinguished Name.
+
+1.  A simple [LDAP bind request](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Bind_(authenticate)) is attempted using the Distinguished Name and the password.  The sign-in fails if the bind fails.
+
+1.  Obtain the user’s LDAP group memberships.
+
+    Using configured LDAP details, obtain a list of the user’s group memberships.
+
+1.  Compare the user’s LDAP group memberships to those mapped to local roles.
+
+1.  Determine if one of the user's groups is authorized to access the target resource.  If so, the user is granted the level of access authorized to the role.  
+
+To access the Cluster Manager UI, the user needs to belong to an LDAP group mapped to an administrative role.  
+
+For database access, the user needs to belong to an LDAP group mapped to a role listed in the database’s access control list (ACL).  The rights granted to the group determine the user's level of access. 
+
+## Prerequisites 
+
+Before you enable LDAP in Redis Enterprise, you need:
+
+1. The following LDAP details:
+
+    - Server URI, including host, port, and protocol details.  
+    - Certificate details for secure protocols.  
+    - Bind credentials, including Distinguished Name, password, and (optionally) client public and private keys for certificate authentication.  
+    - Authentication query details, whether template or query.  
+    - Authorization query details, whether attribute or query.  
+    - The Distinguished Names of LDAP groups you’ll use to authorize access to Redis Enterprise resources. 
+
+1. The LDAP groups that correspond to the levels of access you wish to authorize.  Each LDAP group will be mapped to a Redis Enterprise access control role.
+
+1. A Redis Enterprise access control role for each LDAP group. Before you enable LDAP, you need to set up [role-based access controls]({{< relref "/operate/rs/7.4/security/access-control" >}}) (RBAC).
+
+## Enable LDAP
+
+To enable LDAP:
+
+1.  From **Access Control > LDAP** in the Cluster Manager UI, select the **Configuration** tab and [enable LDAP access]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap" >}}).
+
+    {{<image filename="images/rs/access-control-ldap-panel.png" alt="Enable LDAP Panel" >}}
+
+2.  Map LDAP groups to [access control roles]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles" >}}).
+
+3.  Update database access control lists (ACLs) to [authorize role access]({{< relref "/operate/rs/7.4/security/access-control/ldap/update-database-acls" >}}).  
+
+If you already have appropriate roles, you can update them to include LDAP groups.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap/enable-role-based-ldap" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/7.4/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/7.4/security/" >}})
+
+---
+Title: Create users
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create users and assign access control roles.
+linkTitle: Create users
+weight: 10
+aliases:
+    - /operate/rs/security/access-control/manage-users/add-users/
+    - /operate/rs/security/access-control/rbac/assign-user-role/
+url: '/operate/rs/7.4/security/access-control/create-users/'
+---
+
+## Prerequisites
+
+Before you create other users:
+
+1. Review the [access control overview]({{<relref "/operate/rs/7.4/security/access-control">}}) to learn how to use role-based access control (RBAC) to manage users' cluster access and database access.
+
+1. Create roles you can assign to users. See [Create roles with cluster access only]({{<relref "/operate/rs/7.4/security/access-control/create-cluster-roles">}}), [Create roles with database access only]({{<relref "/operate/rs/7.4/security/access-control/create-db-roles">}}), or [Create roles with combined access]({{<relref "/operate/rs/7.4/security/access-control/create-combined-roles">}}) for instructions.
+
+## Add users
+
+To add a user to the cluster:
+
+1. From the **Access Control > Users** tab in the Cluster Manager UI, select **+ Add user**.
+
+    {{<image filename="images/rs/access-control-user-panel.png" alt="Add role with name" >}}
+
+1. Enter the name, email, and password of the new user.
+
+    {{<image filename="images/rs/access-control-user-add.png" alt="Add role with name" >}}
+
+1. Assign a **Role** to the user to grant permissions for cluster management and data access.
+
+    {{<image filename="images/rs/access-control-user-role-select.png" width="300px" alt="Add role to user." >}}
+
+1. Select the **Alerts** the user should receive by email:
+
+    - **Receive alerts for databases** - The alerts that are enabled for the selected databases will be sent to the user. Choose **All databases** or **Customize** to select the individual databases to send alerts for.
+    
+    - **Receive cluster alerts** - The alerts that are enabled for the cluster in **Cluster > Alerts Settings** are sent to the user.
+
+1. Select **Save**.
+
+## Assign roles to users
+
+Assign a role, associated with specific databases and access control lists (ACLs), to a user to grant database access:
+
+1. From the **Access Control > Users** tab in the Cluster Manager UI, you can:
+
+    - Point to an existing user and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit the user.
+    
+    - Select **+ Add user** to [create a new user]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}).
+
+1. Select a role to assign to the user.
+
+    {{<image filename="images/rs/access-control-user-role-select.png" width="300px" alt="Add role to user." >}}
+
+1. Select **Save**.
+
+## Next steps
+
+Depending on the type of the user's assigned role (cluster management role or data access role), the user can now:
+
+- [Connect to a database]({{< relref "/operate/rs/7.4/databases/connect" >}}) associated with the role and run limited Redis commands, depending on the role's Redis ACLs.
+
+- Sign in to the Redis Enterprise Software Cluster Manager UI.
+
+- Make a [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) request.
+---
+Title: Create roles with cluster access only
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with cluster access only.
+linkTitle: Create roles with cluster access only
+weight: 14
+aliases:
+    - /operate/rs/security/access-control/admin-console-access/
+url: '/operate/rs/7.4/security/access-control/create-cluster-roles/'
+---
+
+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]({{<relref "/operate/rs/7.4/references/rest-api">}}).
+
+1. **DB Viewer** - Read database settings
+1. **DB Member** - Administer databases
+1. **Cluster Viewer** - Read cluster settings
+1. **Cluster Member** - Administer the cluster
+1. **Admin** - Full cluster access
+1. **None** - For data access only - cannot access the Cluster Manager UI or use the REST API
+
+For more details about the privileges granted by each of these roles, see [Cluster Manager UI permissions](#cluster-manager-ui-permissions) or [REST API permissions]({{<relref "/operate/rs/7.4/references/rest-api/permissions">}}).
+
+## Cluster Manager UI permissions
+
+Here's a summary of the Cluster Manager UI actions permitted by each default management role:
+
+| Action | DB Viewer | DB Member | Cluster Viewer | Cluster Member | Admin |
+|--------|:---------:|:---------:|:--------------:|:-----------:|:------:|
+| Create support package | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| Edit database configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| Reset slow log | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View cluster configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View cluster logs | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span><br /> |
+| View cluster metrics | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View database configuration | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View database metrics | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View node configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View node metrics | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View Redis database password | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View slow log | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View and edit cluster settings |<span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> |
+
+## Create roles for cluster access {#create-cluster-role}
+
+To create a role that grants cluster access but does not grant access to any databases:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name" >}}
+
+1. Enter a descriptive name for the role.
+
+1. Choose a **Cluster management role** to determine cluster management permissions.
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-create-role-cluster-only.png" alt="Select a cluster management role to set the level of cluster management permissions for the new role." >}}
+    
+1. To prevent database access when using this role, do not add any ACLs.
+
+1. Select **Save**.
+
+You can [assign the new role to users]({{<relref "/operate/rs/7.4/security/access-control/create-users#assign-roles-to-users">}}) to grant cluster access.
+---
+Title: Create roles with combined access
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with both cluster and database access.
+linkTitle: Create roles with combined access
+weight: 16
+url: '/operate/rs/7.4/security/access-control/create-combined-roles/'
+---
+
+To create a role that grants database access privileges and allows access to the Cluster Management UI and REST API:
+
+1. [Define Redis ACLs](#define-redis-acls) that determine database access privileges.
+
+1. [Create a role with ACLs](#create-role) added and choose a **Cluster management role** other than **None**.
+
+## Define Redis ACLs
+
+To define a Redis ACL rule that you can assign to a role:
+
+1. From **Access Control > Redis ACLs**, you can either:
+
+    - Point to a Redis ACL and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing Redis ACL.
+
+    - Select **+ Add Redis ACL** to create a new Redis ACL.
+
+1. Enter a descriptive name for the Redis ACL. This will be used to associate the ACL rule with the role.
+
+1. Define the ACL rule. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/7.4/security/access-control/redis-acl-overview">}}).
+
+    {{<note>}}
+The **ACL builder** does not support selectors and key permissions. Use **Free text command** to manually define them instead.
+    {{</note>}}
+
+1. Select **Save**.
+
+{{<note>}}
+For multi-key commands on multi-slot keys, the return value is `failure`, but the command runs on the keys that are allowed.
+{{</note>}}
+
+## Create roles with ACLs and cluster access {#create-role}
+
+To create a role that grants database access privileges and allows access to the Cluster Management UI and REST API:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name">}}
+
+1. Enter a descriptive name for the role. This will be used to reference the role when configuring users.
+
+1. Choose a **Cluster management role** other than **None**. For details about permissions granted by each role, see [Cluster Manager UI permissions]({{<relref "/operate/rs/7.4/security/access-control/create-cluster-roles#cluster-manager-ui-permissions">}}) and [REST API permissions]({{<relref "/operate/rs/7.4/references/rest-api/permissions">}}).
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-create-combined-role-select-cm-role.png" alt="Add role with name">}}
+    
+1. Select **+ Add ACL**.
+
+    {{<image filename="images/rs/access-control-role-acl.png" alt="Add role database acl">}}
+
+1.  Choose a Redis ACL and databases to associate with the role.
+
+    {{<image filename="images/rs/screenshots/access-control/access-control-role-databases.png" alt="Add databases to access">}}
+
+1. Select the check mark {{< image filename="/images/rs/buttons/checkmark-button.png#no-click" alt="The Check button" width="25px" class="inline" >}} to confirm.
+
+1. Select **Save**.
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-save-combined-role.png" alt="Add databases to access">}}
+
+You can [assign the new role to users]({{<relref "/operate/rs/7.4/security/access-control/create-users#assign-roles-to-users">}}) to grant database access and access to the Cluster Manager UI and REST API.
+---
+Title: Overview of Redis ACLs in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of Redis ACLs, syntax, and ACL command support in Redis Enterprise Software.
+linkTitle: Redis ACL overview
+weight: 17
+aliases:
+    - /operate/rs/security/access-control/rbac/configure-acl/
+url: '/operate/rs/7.4/security/access-control/redis-acl-overview/'
+---
+
+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.
+
+## Redis ACL syntax
+
+Redis ACLs are defined by a [Redis syntax]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) where you specify the commands or command categories that are allowed for specific keys.
+
+### Commands and categories
+
+Redis ACL rules can allow or block specific [Redis commands]({{< relref "/commands" >}}) or [command categories]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories).
+
+- `+` includes commands
+
+- `-` excludes commands
+
+- `+@` includes command categories
+
+- `-@` excludes command categories
+
+The following example allows all `read` commands and the `SET` command:
+
+```sh
++@read +SET
+```
+
+Module commands have several ACL limitations:
+
+- [Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) do not have command categories.
+
+- Other [command category]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories) ACLs, such as `+@read` and `+@write`, do not include Redis module commands. `+@all` is the only exception because it allows all Redis commands.
+
+- You have to include individual module commands in a Redis ACL rule to allow them.
+
+    For example, the following Redis ACL rule allows read-only commands and the RediSearch commands `FT.INFO` and `FT.SEARCH`:
+
+    ```sh
+    +@read +FT.INFO +FT.SEARCH
+    ```
+
+### Key patterns
+
+To define access to specific keys or key patterns, use the following prefixes:
+
+- `~` or `%RW~` allows read and write access to keys.
+
+- `%R~` allows read access to keys.
+
+- `%W~` allows write access to keys.
+
+`%RW~`, `%R~`, and `%W~` are only supported for databases with Redis version 7.2 or later.
+
+The following example allows read and write access to all keys that start with "app1" and read-only access to all keys that start with "app2":
+
+```sh
+~app1* %R~app2*
+```
+
+### Pub/sub channels
+
+The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) (only supported for databases with Redis version 6.2 or later).
+
+To limit access to specific channels, include `resetchannels` before the allowed channels:
+
+```sh
+resetchannels &channel1 &channel2
+```
+
+### Selectors
+
+[Selectors]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors) let you define multiple sets of rules in a single Redis ACL (only supported for databases with Redis version 7.2 or later). A command is allowed if it matches the base rule or any selector in the Redis ACL.
+
+- `(<rule set>)` creates a new selector.
+
+- `clearselectors` deletes all existing selectors for a user. This action does not delete the base ACL rule.
+
+In the following example, the base rule allows `GET key1` and the selector allows `SET key2`:
+
+```sh
++GET ~key1 (+SET ~key2)
+```
+
+## Default pub/sub permissions
+
+Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access.
+
+The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default:
+
+- For versions 6.4.2 and 7.2, `acl-pubsub-default` is permissive (`allchannels` or `&*`) by default to accommodate earlier Redis versions.
+
+- In future versions, `acl-pubsub-default` will change to restrictive (`resetchannels`). Restrictive permissions block all pub/sub channels by default, unless explicitly permitted by an ACL rule.
+
+If you use ACLs and pub/sub channels, you should review your databases and ACL settings and plan to transition your cluster to restrictive pub/sub permissions in preparation for future Redis Enterprise Software releases.
+
+### Prepare for restrictive pub/sub permissions
+
+To secure pub/sub channels and prepare your cluster for future Redis Enterprise Software releases that default to restrictive pub/sub permissions:
+
+1. Upgrade Redis databases:
+
+    - For Redis Enterprise Software version 6.4.2, upgrade all databases in the cluster to Redis DB version 6.2.
+    
+    - For Redis Enterprise Software version 7.2, upgrade all databases in the cluster to Redis DB version 7.2 or 6.2.
+
+1. Create or update ACLs with permissions for specific channels using the `resetchannels &channel` format.
+
+1. Associate the ACLs with relevant databases.
+
+1. Set default pub/sub permissions (`acl-pubsub-default`) to restrictive. See [Change default pub/sub permissions](#change-default-pubsub-permissions) for details.
+
+1. If any issues occur, you can temporarily change the default pub/sub setting back to permissive. Resolve any problematic ACLs before making pub/sub permissions restrictive again.
+
+{{<note>}}
+When you change the cluster's default pub/sub permissions to restrictive, `&*` is added to the **Full Access** ACL. Before you make this change, consider the following:
+
+- Because pub/sub ACL syntax was added in Redis 6.2, you can't associate the **Full Access** ACL with database versions 6.0 or lower after this change.
+
+- The **Full Access** ACL is not reverted if you change `acl-pubsub-default` to permissive again.
+
+- Every database with the default user enabled uses the **Full Access** ACL.
+{{</note>}}
+
+### Change default pub/sub permissions
+
+As of Redis Enterprise version 6.4.2, you can configure `acl_pubsub_default`, which determines the default pub/sub permissions for all databases in the cluster. You can set `acl_pubsub_default` to the following values:
+
+- `resetchannels` is restrictive and blocks access to all channels by default.
+
+- `allchannels` is permissive and allows access to all channels by default. 
+
+To make default pub/sub permissions restrictive:
+
+1. [Upgrade all databases]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-database" >}}) in the cluster to Redis version 6.2 or later.
+
+1. Set the default to restrictive (`resetchannels`) using one of the following methods:
+
+    - New Cluster Manager UI (only available for Redis Enterprise versions 7.2 and later):
+    
+        1. Navigate to **Access Control > Settings > Pub/Sub ACLs** and select **Edit**.
+        
+        1. For **Default permissions for Pub/Sub ACLs**, select **Restrictive**, then **Save**.
+
+    - [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+        ```sh
+        rladmin tune cluster acl_pubsub_default resetchannels
+        ```
+
+    - [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+        ```sh
+        PUT /v1/cluster/policy
+        { "acl_pubsub_default": "resetchannels" }
+        ```
+
+## ACL command support
+
+Redis Enterprise Software does not support certain Redis ACL commands. Instead, you can manage access controls from the Cluster Manager UI.
+
+{{<embed-md "acl-command-compatibility.md">}}
+
+Redis ACLs also have the following differences in Redis Enterprise Software:
+
+- The `MULTI`, `EXEC`, `DISCARD` commands are always allowed, but ACLs are enforced on `MULTI` subcommands.
+
+- Nested selectors are not supported.
+
+    For example, the following selectors are not valid in Redis Enterprise: <nobr>`+GET ~key1 (+SET (+SET ~key2) ~key3)`</nobr>
+
+- Key and pub/sub patterns do not allow the following characters: `'(', ')'`
+
+- The following password configuration syntax is not supported: `'>', '<', '#!', 'resetpass'`
+
+    To configure passwords in Redis Enterprise Software, use one of the following methods:
+
+    - [`rladmin cluster reset_password`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/reset_password" >}}):
+    
+        ```sh
+        rladmin cluster reset_password <user email>
+        ```
+
+    - REST API [`PUT /v1/users`]({{< relref "/operate/rs/7.4/references/rest-api/requests/users#put-user" >}}) request and provide `password`
+
+---
+Title: Create roles with database access only 
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with database access only.
+linkTitle: Create roles with database access only 
+weight: 15
+aliases:
+    - /operate/rs/security/access-control/database-access/
+url: '/operate/rs/7.4/security/access-control/create-db-roles/'
+---
+
+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]({{<relref "/operate/rs/7.4/security/access-control/redis-acl-overview">}}) 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:
+
+1. [Define Redis ACLs](#define-redis-acls) that determine database access privileges.
+
+1. [Create a role with ACLs](#create-roles-with-acls) added and leave the **Cluster management role** as **None**.
+
+## Define Redis ACLs
+
+To define a Redis ACL rule that you can assign to a role:
+
+1. From **Access Control > Redis ACLs**, you can either:
+
+    - Point to a Redis ACL and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing Redis ACL.
+
+    - Select **+ Add Redis ACL** to create a new Redis ACL.
+
+1. Enter a descriptive name for the Redis ACL. This will be used to associate the ACL rule with the role.
+
+1. Define the ACL rule. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/7.4/security/access-control/redis-acl-overview">}}).
+
+    {{<note>}}
+The **ACL builder** does not support selectors and key permissions. Use **Free text command** to manually define them instead.
+    {{</note>}}
+
+1. Select **Save**.
+
+{{<note>}}
+For multi-key commands on multi-slot keys, the return value is `failure`, but the command runs on the keys that are allowed.
+{{</note>}}
+
+## Create roles with ACLs
+
+To create a role that grants database access to users but blocks access to the Redis Enterprise Cluster Manager UI and REST API, set the **Cluster management role** to **None**.
+
+To define a role for database access:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name" >}}
+
+1. Enter a descriptive name for the role. This will be used to reference the role when configuring users.
+
+1. Leave **Cluster management role** as the default **None**.
+
+    {{<image filename="images/rs/access-control-role-name.png" alt="Add role with name" >}}
+    
+1. Select **+ Add ACL**.
+
+    {{<image filename="images/rs/access-control-role-acl.png" alt="Add role database acl" >}}
+
+1.  Choose a Redis ACL and databases to associate with the role.
+
+    {{<image filename="images/rs/screenshots/access-control/access-control-role-databases.png" alt="Add databases to access" >}}
+
+1. Select the check mark {{< image filename="/images/rs/buttons/checkmark-button.png#no-click" alt="The Check button" width="25px" class="inline" >}} to confirm.
+
+1. Select **Save**.
+
+    {{<image filename="images/rs/access-control-role-save.png" alt="Add databases to access" >}}
+
+You can [assign the new role to users]({{<relref "/operate/rs/7.4/security/access-control/create-users#assign-roles-to-users">}}) to grant database access.
+---
+Title: Access control
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of access control in Redis Enterprise Software.
+hideListLinks: false
+linkTitle: Access control
+weight: 10
+aliases:
+    - /operate/rs/security/access-control/rbac/
+    - /operate/rs/security/access-control/rbac/create-roles/
+url: '/operate/rs/7.4/security/access-control/'
+---
+
+Redis Enterprise Software lets you use role-based access control (RBAC) to manage users' access privileges. RBAC requires you to do the following:
+
+1. Create roles and define each role's access privileges.
+
+1. Create users and assign roles to them. The assigned role determines the user's access privileges.
+
+## Cluster access versus database access
+
+Redis Enterprise allows two separate paths of access:
+
+- **Cluster access** allows performing management-related actions, such as creating databases and viewing statistics.
+
+- **Database access** allows performing data-related actions, like reading and writing data in a database.
+
+You can grant cluster access, database access, or both to each role. These roles let you differentiate between users who can access databases and users who can access cluster management, according to your organization's security needs.
+
+The following diagram shows three different options for roles and users:
+
+{{<image filename="images/rs/rbac-diagram.png" alt="Role-based access control diagram.">}}
+
+- Role A was created with permission to access the cluster and perform management-related actions. Because user A was assigned role A, they can access the cluster but cannot access databases.
+
+- Role B was created with permission to access one or more databases and perform data-related actions. Because user B was assigned role B, they cannot access the cluster but can access databases.
+
+- Role C was created with cluster access and database access permissions. Because user C was assigned role C, they can access the cluster and databases.
+
+## Default database access
+
+When you create a database, [default user access]({{< relref "/operate/rs/7.4/security/access-control/manage-users/default-user" >}}) is enabled automatically.
+
+If you set up role-based access controls for your database and don't require compatibility with versions earlier than Redis 6, you can [deactivate the default user]({{< relref "/operate/rs/7.4/security/access-control/manage-users/default-user" >}}).
+
+{{<warning>}}
+Before you [deactivate default user access]({{< relref "/operate/rs/7.4/security/access-control/manage-users/default-user#deactivate-default-user" >}}), make sure the role associated with the database is [assigned to a user]({{< relref "/operate/rs/7.4/security/access-control/create-users#assign-roles-to-users" >}}). Otherwise, the database will be inaccessible.
+{{</warning>}}
+
+## More info
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: true
+weight: 60
+aliases:
+    - /operate/rs/administering/designing-production/security
+url: '/operate/rs/7.4/security/'
+---
+
+Redis Enterprise Software provides various features to secure your Redis Enterprise Software deployment:
+
+| Login and passwords | Users and roles | Encryption and TLS | Certificates and audit |
+|---------------------|-----------------|--------------------|-----------------------|
+| [Password attempts and session timeout]({{<relref "/operate/rs/7.4/security/access-control/manage-users/login-lockout">}}) | [Cluster and database access explained]({{<relref "/operate/rs/7.4/security/access-control">}}) | [Enable TLS]({{<relref "/operate/rs/7.4/security/encryption/tls/enable-tls">}}) | [Create certificates]({{<relref "/operate/rs/7.4/security/certificates/create-certificates">}}) |
+| [Password complexity]({{<relref "/operate/rs/7.4/security/access-control/manage-passwords/password-complexity-rules">}}) | [Create users]({{<relref "/operate/rs/7.4/security/access-control/create-users">}}) | [Configure TLS protocols]({{<relref "/operate/rs/7.4/security/encryption/tls/tls-protocols">}}) | [Monitor certificates]({{<relref "/operate/rs/7.4/security/certificates/monitor-certificates">}}) |
+| [Password expiration]({{<relref "/operate/rs/7.4/security/access-control/manage-passwords/password-expiration">}}) | [Create roles]({{<relref "/operate/rs/7.4/security/access-control/create-combined-roles">}}) | [Configure cipher suites]({{<relref "/operate/rs/7.4/security/encryption/tls/ciphers">}}) | [Update certificates]({{<relref "/operate/rs/7.4/security/certificates/updating-certificates">}}) |
+| [Default database access]({{<relref "/operate/rs/7.4/security/access-control/manage-users/default-user">}}) | [Redis ACLs]({{<relref "/operate/rs/7.4/security/access-control/redis-acl-overview">}}) | [Encrypt private keys on disk]({{<relref "/operate/rs/7.4/security/encryption/pem-encryption">}}) | [Enable OCSP stapling]({{<relref "/operate/rs/7.4/security/certificates/ocsp-stapling">}}) |
+| [Rotate user passwords]({{<relref "/operate/rs/7.4/security/access-control/manage-passwords/rotate-passwords">}}) | [Integrate with LDAP]({{<relref "/operate/rs/7.4/security/access-control/ldap">}}) | [Internode encryption]({{<relref "/operate/rs/7.4/security/encryption/internode-encryption">}}) | [Audit database connections]({{<relref "/operate/rs/7.4/security/audit-events">}}) |
+
+## Recommended security practices
+
+See [Recommended security practices]({{<relref "/operate/rs/7.4/security/recommended-security-practices">}}) to learn how to protect Redis Enterprise Software.
+
+## Redis Trust Center
+
+Visit our [Trust Center](https://trust.redis.io/) to learn more about Redis security policies. If you find a suspected security bug, you can [submit a report](https://hackerone.com/redis-vdp?type=team).
+---
+Title: Compatibility with Redis Open Source configuration settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Open Source configuration settings supported by Redis Enterprise.
+linkTitle: Configuration settings
+weight: 50
+url: '/operate/rs/7.4/references/compatibility/config-settings/'
+---
+
+Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}) only support a subset of [Redis Open Source configuration settings]({{<relref "/operate/oss_and_stack/management/config">}}). Using [`CONFIG GET`]({{< relref "/commands/config-get" >}}) or [`CONFIG SET`]({{< relref "/commands/config-set" >}}) with unsupported configuration settings returns an error.
+
+| Setting | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| activerehashing | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| busy-reply-threshold | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Value must be between 0 and 60000 milliseconds. |
+| hash-max-listpack-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-listpack-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-ziplist-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-ziplist-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hll-sparse-max-bytes | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-compress-depth | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-max-listpack-size | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-max-ziplist-size | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| lua-time-limit | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Value must be between 0 and 60000 milliseconds. |
+| notify-keyspace-events | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| set-max-intset-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| slowlog-log-slower-than | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Value must be larger than 1000 microseconds. |
+| slowlog-max-len | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Value must be between 128 and 1024. |
+| stream-node-max-bytes | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| stream-node-max-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-listpack-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-listpack-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-ziplist-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-ziplist-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Connection management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Connection management commands compatibility.
+linkTitle: Connection management
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/connection/'
+---
+
+The following tables show which Redis Open Source [connection management commands]({{< relref "/commands" >}}?group=connection) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [AUTH]({{< relref "/commands/auth" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT CACHING]({{< relref "/commands/client-caching" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT GETNAME]({{< relref "/commands/client-getname" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT GETREDIR]({{< relref "/commands/client-getredir" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT ID]({{< relref "/commands/client-id" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Because Redis Enterprise clustering allows [multiple active proxies]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}), `CLIENT ID` cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies. |
+| [CLIENT INFO]({{< relref "/commands/client-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT KILL]({{< relref "/commands/client-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT LIST]({{< relref "/commands/client-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT NO-EVICT]({{< relref "/commands/client-no-evict" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT <nobr>NO-TOUCH</nobr>]({{< relref "/commands/client-no-touch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT PAUSE]({{< relref "/commands/client-pause" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT REPLY]({{< relref "/commands/client-reply" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT SETINFO]({{< relref "/commands/client-setinfo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT SETNAME]({{< relref "/commands/client-setname" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT TRACKING]({{< relref "/commands/client-tracking" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT TRACKINGINFO]({{< relref "/commands/client-trackinginfo" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT UNBLOCK]({{< relref "/commands/client-unblock" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT UNPAUSE]({{< relref "/commands/client-unpause" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ECHO]({{< relref "/commands/echo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HELLO]({{< relref "/commands/hello" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PING]({{< relref "/commands/ping" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [QUIT]({{< relref "/commands/quit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v7.2.0. |
+| [RESET]({{< relref "/commands/reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SELECT]({{< relref "/commands/select" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | 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. |
+---
+Title: Cluster management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Cluster management commands compatible with Redis Enterprise.
+linkTitle: Cluster management
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/cluster/'
+---
+
+[Clustering in Redis Enterprise Software]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering" >}}) and [Redis Cloud]({{< relref "/operate/rc/databases/configuration/clustering" >}}) differs from the [Redis Open Source cluster]({{<relref "/operate/oss_and_stack/management/scaling">}}) and works with all standard Redis clients.
+
+Redis Enterprise blocks most [cluster commands]({{< relref "/commands" >}}?group=cluster). If you try to use a blocked cluster command, it returns an error.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [ASKING]({{< relref "/commands/asking" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER ADDSLOTS]({{< relref "/commands/cluster-addslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER ADDSLOTSRANGE]({{< relref "/commands/cluster-addslotsrange" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER BUMPEPOCH]({{< relref "/commands/cluster-bumpepoch" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER COUNT-FAILURE-REPORTS]({{< relref "/commands/cluster-count-failure-reports" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER COUNTKEYSINSLOT]({{< relref "/commands/cluster-countkeysinslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER DELSLOTS]({{< relref "/commands/cluster-delslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER DELSLOTSRANGE]({{< relref "/commands/cluster-delslotsrange" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FAILOVER]({{< relref "/commands/cluster-failover" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FLUSHSLOTS]({{< relref "/commands/cluster-flushslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FORGET]({{< relref "/commands/cluster-forget" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER GETKEYSINSLOT]({{< relref "/commands/cluster-getkeysinslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER HELP]({{< relref "/commands/cluster-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER INFO]({{< relref "/commands/cluster-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER KEYSLOT]({{< relref "/commands/cluster-keyslot" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER LINKS]({{< relref "/commands/cluster-links" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MEET]({{< relref "/commands/cluster-meet" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MYID]({{< relref "/commands/cluster-myid" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MYSHARDID]({{< relref "/commands/cluster-myshardid" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER NODES]({{< relref "/commands/cluster-nodes" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER REPLICAS]({{< relref "/commands/cluster-replicas" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER REPLICATE]({{< relref "/commands/cluster-replicate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER RESET]({{< relref "/commands/cluster-reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SAVECONFIG]({{< relref "/commands/cluster-saveconfig" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SET-CONFIG-EPOCH]({{< relref "/commands/cluster-set-config-epoch" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SETSLOT]({{< relref "/commands/cluster-setslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SHARDS]({{< relref "/commands/cluster-shards" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SLAVES]({{< relref "/commands/cluster-slaves" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v5.0.0. |
+| [CLUSTER SLOTS]({{< relref "/commands/cluster-slots" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). Deprecated as of Redis v7.0.0. |
+| [READONLY]({{< relref "/commands/readonly" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [READWRITE]({{< relref "/commands/readwrite" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+---
+Title: Data type commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Data type commands compatibility (bitmaps, geospatial indices, hashes,
+  HyperLogLogs, lists, sets, sorted sets, streams, strings).
+linkTitle: Data types
+toc: 'true'
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/data-types/'
+---
+
+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
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BITCOUNT]({{< relref "/commands/bitcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITFIELD]({{< relref "/commands/bitfield" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITFIELD_RO]({{< relref "/commands/bitfield_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITOP]({{< relref "/commands/bitop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span>  |  |
+| [BITPOS]({{< relref "/commands/bitpos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span>  |  |
+| [GETBIT]({{< relref "/commands/getbit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETBIT]({{< relref "/commands/setbit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Geospatial indices commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [GEOADD]({{< relref "/commands/geoadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEODIST]({{< relref "/commands/geodist" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOHASH]({{< relref "/commands/geohash" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOPOS]({{< relref "/commands/geopos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEORADIUS]({{< relref "/commands/georadius" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUS_RO]({{< relref "/commands/georadius_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUSBYMEMBER]({{< relref "/commands/georadiusbymember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUSBYMEMBER_RO]({{< relref "/commands/georadiusbymember_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEOSEARCH]({{< relref "/commands/geosearch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOSEARCHSTORE]({{< relref "/commands/geosearchstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Hash commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [HDEL]({{< relref "/commands/hdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HEXISTS]({{< relref "/commands/hexists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HGET]({{< relref "/commands/hget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HGETALL]({{< relref "/commands/hgetall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HINCRBY]({{< relref "/commands/hincrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HINCRBYFLOAT]({{< relref "/commands/hincrbyfloat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HKEYS]({{< relref "/commands/hkeys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HLEN]({{< relref "/commands/hlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HMGET]({{< relref "/commands/hmget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HMSET]({{< relref "/commands/hmset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v4.0.0. |
+| [HRANDFIELD]({{< relref "/commands/hrandfield" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSCAN]({{< relref "/commands/hscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSET]({{< relref "/commands/hset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSETNX]({{< relref "/commands/hsetnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSTRLEN]({{< relref "/commands/hstrlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HVALS]({{< relref "/commands/hvals" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## HyperLogLog commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [PFADD]({{< relref "/commands/pfadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFCOUNT]({{< relref "/commands/pfcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFDEBUG]({{< relref "/commands/pfdebug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [PFMERGE]({{< relref "/commands/pfmerge" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFSELFTEST]({{< relref "/commands/pfselftest" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## List commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BLMOVE]({{< relref "/commands/blmove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BLMPOP]({{< relref "/commands/blmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BLPOP]({{< relref "/commands/blpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BRPOP]({{< relref "/commands/brpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BRPOPLPUSH]({{< relref "/commands/brpoplpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [LINDEX]({{< relref "/commands/lindex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LINSERT]({{< relref "/commands/linsert" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LLEN]({{< relref "/commands/llen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LMOVE]({{< relref "/commands/lmove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LMPOP]({{< relref "/commands/lmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPOP]({{< relref "/commands/lpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPOS]({{< relref "/commands/lpos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPUSH]({{< relref "/commands/lpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPUSHX]({{< relref "/commands/lpushx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LRANGE]({{< relref "/commands/lrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LREM]({{< relref "/commands/lrem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LSET]({{< relref "/commands/lset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LTRIM]({{< relref "/commands/ltrim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPOP]({{< relref "/commands/rpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPOPLPUSH]({{< relref "/commands/rpoplpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [RPUSH]({{< relref "/commands/rpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPUSHX]({{< relref "/commands/rpushx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Set commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [SADD]({{< relref "/commands/sadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCARD]({{< relref "/commands/scard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SDIFF]({{< relref "/commands/sdiff" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SDIFFSTORE]({{< relref "/commands/sdiffstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTER]({{< relref "/commands/sinter" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTERCARD]({{< relref "/commands/sintercard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTERSTORE]({{< relref "/commands/sinterstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SISMEMBER]({{< relref "/commands/sismember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMEMBERS]({{< relref "/commands/smembers" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMISMEMBER]({{< relref "/commands/sismember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMOVE]({{< relref "/commands/smove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SPOP]({{< relref "/commands/spop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SRANDMEMBER]({{< relref "/commands/srandmember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SREM]({{< relref "/commands/srem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SSCAN]({{< relref "/commands/sscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNION]({{< relref "/commands/sunion" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNIONSTORE]({{< relref "/commands/sunionstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Sorted set commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BZMPOP]({{< relref "/commands/bzmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BZPOPMAX]({{< relref "/commands/bzpopmax" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BZPOPMIN]({{< relref "/commands/bzpopmin" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZADD]({{< relref "/commands/zadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZCARD]({{< relref "/commands/zcard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZCOUNT]({{< relref "/commands/zcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZDIFF]({{< relref "/commands/zdiff" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZDIFFSTORE]({{< relref "/commands/zdiffstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINCRBY]({{< relref "/commands/zincrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTER]({{< relref "/commands/zinter" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTERCARD]({{< relref "/commands/zintercard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTERSTORE]({{< relref "/commands/zinterstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZLEXCOUNT]({{< relref "/commands/zlexcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZMPOP]({{< relref "/commands/zmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZMSCORE]({{< relref "/commands/zmscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZPOPMAX]({{< relref "/commands/zpopmax" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZPOPMIN]({{< relref "/commands/zpopmin" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANDMEMBER]({{< relref "/commands/zrandmember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANGE]({{< relref "/commands/zrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANGEBYLEX]({{< relref "/commands/zrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZRANGEBYSCORE]({{< relref "/commands/zrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZRANGESTORE]({{< relref "/commands/zrangestore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANK]({{< relref "/commands/zrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREM]({{< relref "/commands/zrem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYLEX]({{< relref "/commands/zremrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYRANK]({{< relref "/commands/zremrangebyrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYSCORE]({{< relref "/commands/zremrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREVRANGE]({{< relref "/commands/zrevrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANGEBYLEX]({{< relref "/commands/zrevrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANGEBYSCORE]({{< relref "/commands/zrevrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANK]({{< relref "/commands/zrevrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZSCAN]({{< relref "/commands/zscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZSCORE]({{< relref "/commands/zscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZUNION]({{< relref "/commands/zunion" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZUNIONSTORE]({{< relref "/commands/zunionstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Stream commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [XACK]({{< relref "/commands/xack" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XADD]({{< relref "/commands/xadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XAUTOCLAIM]({{< relref "/commands/xautoclaim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XCLAIM]({{< relref "/commands/xclaim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XDEL]({{< relref "/commands/xdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XGROUP]({{< relref "/commands/xgroup" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XINFO]({{< relref "/commands/xinfo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XLEN]({{< relref "/commands/xlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XPENDING]({{< relref "/commands/xpending" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XRANGE]({{< relref "/commands/xrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREAD]({{< relref "/commands/xread" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREADGROUP]({{< relref "/commands/xreadgroup" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREVRANGE]({{< relref "/commands/xrevrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XSETID]({{< relref "/commands/xsetid" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XTRIM]({{< relref "/commands/xtrim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## String commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [APPEND]({{< relref "/commands/append" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DECR]({{< relref "/commands/decr" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DECRBY]({{< relref "/commands/decrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GET]({{< relref "/commands/get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETDEL]({{< relref "/commands/getdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETEX]({{< relref "/commands/getex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | \*Not supported for HyperLogLog. |
+| [GETRANGE]({{< relref "/commands/getrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETSET]({{< relref "/commands/getset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [INCR]({{< relref "/commands/incr" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INCRBY]({{< relref "/commands/incrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INCRBYFLOAT]({{< relref "/commands/incrbyfloat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LCS]({{< relref "/commands/lcs" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MGET]({{< relref "/commands/mget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MSET]({{< relref "/commands/mset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MSETNX]({{< relref "/commands/msetnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PSETEX]({{< relref "/commands/psetex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SET]({{< relref "/commands/set" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETEX]({{< relref "/commands/setex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETNX]({{< relref "/commands/setnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETRANGE]({{< relref "/commands/setrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| STRALGO | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v7.0.0. |
+| [STRLEN]({{< relref "/commands/strlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUBSTR]({{< relref "/commands/substr" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v2.0.0. |
+---
+Title: Server management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Server management commands compatibility.
+linkTitle: Server management
+toc: 'true'
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/server/'
+---
+
+The following tables show which Redis Open Source [server management commands]({{< relref "/commands" >}}?group=server) 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]({{< relref "/operate/rs/7.4/security/access-control" >}}) and the [Redis Cloud console]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control.md" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Might reply with "unknown user" for LDAP users even if `AUTH` succeeds. |
+| [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL HELP]({{< relref "/commands/acl-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL LIST]({{< relref "/commands/acl-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL LOAD]({{< relref "/commands/acl-load" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL LOG]({{< relref "/commands/acl-log" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL SAVE]({{< relref "/commands/acl-save" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL USERS]({{< relref "/commands/acl-users" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+
+## Configuration commands
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [CONFIG GET]({{< relref "/commands/config-get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | [Only supports a subset of configuration settings.]({{< relref "/operate/rs/7.4/references/compatibility/config-settings" >}}) |
+| [CONFIG RESETSTAT]({{< relref "/commands/config-resetstat" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CONFIG REWRITE]({{< relref "/commands/config-rewrite" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CONFIG SET]({{< relref "/commands/config-set" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | [Only supports a subset of configuration settings.]({{< relref "/operate/rs/7.4/references/compatibility/config-settings" >}}) |
+
+
+## General server commands
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [COMMAND]({{< relref "/commands/command" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND COUNT]({{< relref "/commands/command-count" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND DOCS]({{< relref "/commands/command-docs" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND GETKEYS]({{< relref "/commands/command-getkeys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND GETKEYSANDFLAGS]({{< relref "/commands/command-getkeysandflags" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND HELP]({{< relref "/commands/command-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND INFO]({{< relref "/commands/command-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND LIST]({{< relref "/commands/command-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DEBUG]({{< relref "/commands/debug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [FLUSHALL]({{< relref "/commands/flushall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*Can use the [Active-Active flush API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdbs/flush" >}}). |
+| [FLUSHDB]({{< relref "/commands/flushdb" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*Can use the [Active-Active flush API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdbs/flush" >}}). |
+| [LOLWUT]({{< relref "/commands/lolwut" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SHUTDOWN]({{< relref "/commands/shutdown" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SWAPDB]({{< relref "/commands/swapdb" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [TIME]({{< relref "/commands/time" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Module commands
+
+For Redis Enterprise Software, you can [manage Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/" >}}) from the Cluster Manager UI or with [REST API requests]({{< relref "/operate/rs/7.4/references/rest-api/requests/modules" >}}).
+
+Redis Cloud manages modules for you and lets you [enable modules]({{< relref "/operate/rc/databases/create-database#modules" >}}) when you create a database.
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [MODULE HELP]({{< relref "/commands/module-help" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE LIST]({{< relref "/commands/module-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MODULE LOAD]({{< relref "/commands/module-load" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE LOADEX]({{< relref "/commands/module-loadex" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE UNLOAD]({{< relref "/commands/module-unload" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## Monitoring commands
+
+Although Redis Enterprise does not support certain monitoring commands, you can use the Cluster Manager UI to view Redis Enterprise Software [metrics]({{< relref "/operate/rs/7.4/clusters/monitoring" >}}) and [logs]({{< relref "/operate/rs/7.4/clusters/logging" >}}) or the Redis Cloud console to view Redis Cloud [metrics]({{< relref "/operate/rc/databases/monitor-performance" >}}) and [logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [DBSIZE]({{< relref "/commands/dbsize" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INFO]({{< relref "/commands/info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.<br />Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY GRAPH]({{< relref "/commands/latency-graph" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY HELP]({{< relref "/commands/latency-help" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY HISTOGRAM]({{< relref "/commands/latency-histogram" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LATENCY HISTORY]({{< relref "/commands/latency-history" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY LATEST]({{< relref "/commands/latency-latest" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY RESET]({{< relref "/commands/latency-reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) in Redis versions earlier than 7. |
+| [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY STATS]({{< relref "/commands/memory-stats" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) in Redis versions earlier than 7. |
+| [MONITOR]({{< relref "/commands/monitor" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+
+## Persistence commands
+
+Data persistence and backup commands are not available in Redis Enterprise. Instead, you can [manage data persistence]({{< relref "/operate/rs/7.4/databases/configure/database-persistence" >}}) and [backups]({{< relref "/operate/rs/7.4/databases/import-export/schedule-backups" >}}) from the Redis Enterprise Software Cluster Manager UI and the [Redis Cloud console]({{< relref "/operate/rc/databases/view-edit-database#durability-section" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BGREWRITEAOF]({{< relref "/commands/bgrewriteaof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [BGSAVE]({{< relref "/commands/bgsave" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LASTSAVE]({{< relref "/commands/lastsave" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SAVE]({{< relref "/commands/save" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## Replication commands
+
+Redis Enterprise automatically manages [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [FAILOVER]({{< relref "/commands/failover" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MIGRATE]({{< relref "/commands/migrate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [PSYNC]({{< relref "/commands/psync" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [REPLCONF]({{< relref "/commands/replconf" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [REPLICAOF]({{< relref "/commands/replicaof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [RESTORE-ASKING]({{< relref "/commands/restore-asking" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ROLE]({{< relref "/commands/role" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SLAVEOF]({{< relref "/commands/slaveof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v5.0.0. |
+| [SYNC]({{< relref "/commands/sync" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+---
+Title: Pub/sub commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Pub/sub commands compatibility.
+linkTitle: Pub/sub
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/pub-sub/'
+---
+
+The following table shows which Redis Open Source [pub/sub commands]({{< relref "/commands" >}}?group=pubsub) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [PSUBSCRIBE]({{< relref "/commands/psubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBLISH]({{< relref "/commands/publish" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB CHANNELS]({{< relref "/commands/pubsub-channels" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB NUMPAT]({{< relref "/commands/pubsub-numpat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB NUMSUB]({{< relref "/commands/pubsub-numsub" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB SHARDCHANNELS]({{< relref "/commands/pubsub-shardchannels" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB SHARDNUMSUB]({{< relref "/commands/pubsub-shardnumsub" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUNSUBSCRIBE]({{< relref "/commands/punsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SPUBLISH]({{< relref "/commands/spublish" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SSUBSCRIBE]({{< relref "/commands/ssubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUBSCRIBE]({{< relref "/commands/subscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNSUBSCRIBE]({{< relref "/commands/sunsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNSUBSCRIBE]({{< relref "/commands/unsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Transaction commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Transaction commands compatibility.
+linkTitle: Transactions
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/transactions/'
+---
+
+The following table shows which Redis Open Source [transaction commands]({{< relref "/commands" >}}?group=transactions) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [DISCARD]({{< relref "/commands/discard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXEC]({{< relref "/commands/exec" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MULTI]({{< relref "/commands/multi" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNWATCH]({{< relref "/commands/unwatch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [WATCH]({{< relref "/commands/watch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Compatibility with Redis Open Source commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Open Source commands compatible with Redis Enterprise.
+hideListLinks: true
+linkTitle: Commands
+weight: 30
+url: '/operate/rs/7.4/references/compatibility/commands/'
+---
+
+Learn which Redis Open Source commands are compatible with Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}).
+
+Select a command group for more details about compatibility with standard and Active-Active Redis Enterprise.
+
+{{<table-children columnNames="Command group,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: Scripting commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Scripting and function commands compatibility.
+linkTitle: Scripting
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/scripting/'
+---
+
+The following table shows which Redis Open Source [scripting and function commands]({{< relref "/commands" >}}?group=scripting) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+## Function commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [FCALL]({{< relref "/commands/fcall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FCALL_RO]({{< relref "/commands/fcall_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION DELETE]({{< relref "/commands/function-delete" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION DUMP]({{< relref "/commands/function-dump" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION FLUSH]({{< relref "/commands/function-flush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION HELP]({{< relref "/commands/function-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION KILL]({{< relref "/commands/function-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION LIST]({{< relref "/commands/function-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION LOAD]({{< relref "/commands/function-load" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION RESTORE]({{< relref "/commands/function-restore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION STATS]({{< relref "/commands/function-stats" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+## Scripting commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [EVAL]({{< relref "/commands/eval" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVAL_RO]({{< relref "/commands/eval_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVALSHA]({{< relref "/commands/evalsha" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVALSHA_RO]({{< relref "/commands/evalsha_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT DEBUG]({{< relref "/commands/script-debug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SCRIPT EXISTS]({{< relref "/commands/script-exists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT FLUSH]({{< relref "/commands/script-flush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT KILL]({{< relref "/commands/script-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT LOAD]({{< relref "/commands/script-load" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Key commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Generic key commands compatible with Redis Enterprise.
+linkTitle: Keys (generic)
+weight: 10
+url: '/operate/rs/7.4/references/compatibility/commands/generic/'
+---
+
+The following table shows which Redis Open Source [key (generic) commands]({{< relref "/commands" >}}?group=generic) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [COPY]({{< relref "/commands/copy" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | For Active-Active or clustered databases, the source and destination keys must be in the same hash slot.<br /><br />\*Not supported for stream consumer group info. |
+| [DEL]({{< relref "/commands/del" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DUMP]({{< relref "/commands/dump" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXISTS]({{< relref "/commands/exists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIRE]({{< relref "/commands/expire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIREAT]({{< relref "/commands/expireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIRETIME]({{< relref "/commands/expiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [KEYS]({{< relref "/commands/keys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MIGRATE]({{< relref "/commands/migrate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MOVE]({{< relref "/commands/move" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Redis Enterprise does not support shared databases due to potential negative performance impacts and blocks any related commands. |
+| [OBJECT ENCODING]({{< relref "/commands/object-encoding" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT FREQ]({{< relref "/commands/object-freq" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT IDLETIME]({{< relref "/commands/object-idletime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT REFCOUNT]({{< relref "/commands/object-refcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PERSIST]({{< relref "/commands/persist" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIRE]({{< relref "/commands/pexpire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIREAT]({{< relref "/commands/pexpireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIRETIME]({{< relref "/commands/pexpiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PTTL]({{< relref "/commands/pttl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RANDOMKEY]({{< relref "/commands/randomkey" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RENAME]({{< relref "/commands/rename" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | For Active-Active or clustered databases, the original key and new key must be in the same hash slot.<br /><br />\*Not supported for stream consumer group info. |
+| [RENAMENX]({{< relref "/commands/renamenx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | For Active-Active or clustered databases, the original key and new key must be in the same hash slot. |
+| [RESTORE]({{< relref "/commands/restore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported">&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported">&#x274c; Active-Active\*</nobr></span> | \*Only supported for module keys. |
+| [SCAN]({{< relref "/commands/scan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SORT]({{< relref "/commands/sort" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SORT_RO]({{< relref "/commands/sort_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TOUCH]({{< relref "/commands/touch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TTL]({{< relref "/commands/ttl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TYPE]({{< relref "/commands/type" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNLINK]({{< relref "/commands/unlink" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [WAIT]({{< relref "/commands/wait" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Not supported">&#x274c; Standard**</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*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.<br></br>\*\*`WAIT` commands are supported on Redis Cloud Flexible subscriptions. |
+| [WAITAOF]({{< relref "/commands/waitaof" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+---
+Title: RESP compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise supports RESP2 and RESP3.
+linkTitle: RESP
+toc: 'true'
+weight: 80
+url: '/operate/rs/7.4/references/compatibility/resp/'
+---
+
+RESP (Redis Serialization Protocol) is the protocol that clients use to communicate with Redis databases. See the [RESP protocol specification]({{< relref "/develop/reference/protocol-spec" >}}) for more information.
+
+## Supported RESP versions
+
+- RESP2 is supported by all Redis Enterprise versions.
+
+- RESP3 is supported by Redis Enterprise 7.2 and later.
+
+{{<note>}}
+Redis Enterprise versions that support RESP3 continue to support RESP2.
+{{</note>}}
+
+
+## Enable RESP3 for a database {#enable-resp3}
+
+To use RESP3 with a Redis Enterprise Software database:
+
+1. Upgrade Redis servers to version 7.2 or later.
+
+    For Active-Active and Replica Of databases:
+ 
+    1. Upgrade all participating clusters to Redis Enterprise version 7.2.x or later.
+ 
+    1. Upgrade all databases to version 7.x or later.
+
+1. Enable RESP3 support for your database (`enabled` by default):
+
+    - [`rladmin tune db`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+        ```sh
+        rladmin tune db db:<ID> resp3 enabled
+        ```
+
+        You can use the database name in place of `db:<ID>` in the preceding command.
+
+    - [Update database configuration]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#put-bdbs" >}}) REST API request:
+
+        ```sh
+        PUT /v1/bdbs/<uid> 
+        { "resp3": true }
+        ```
+
+ ## Deactivate RESP3 for a database {#deactivate-resp3}
+
+ To deactivate RESP3 support for a database:
+
+- [`rladmin tune db`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+     ```sh
+    rladmin tune db db:<ID> resp3 disabled
+    ```
+
+    You can use the database name in place of `db:<ID>` in the preceding command.
+
+- [Update database configuration]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#put-bdbs" >}}) REST API request:
+
+    ```sh
+    PUT /v1/bdbs/<uid> 
+    { "resp3": false }
+    ```
+
+ When RESP3 is deactivated, connected clients that use RESP3 are disconnected from the database.
+
+{{<note>}}
+You cannot use sharded pub/sub if you deactivate RESP3 support.
+{{</note>}}
+
+## Change default RESP3 option
+
+The cluster-wide option `resp3_default` determines the default value of the `resp3` option, which enables or deactivates RESP3 for a database, upon upgrading a database to version 7.2. `resp3_default` is set to `enabled` by default.
+
+To change `resp3_default` to `disabled`, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+    1. Select **Upgrade configuration**.
+
+    1. For **RESP3 support**, select **Disable**.
+
+    1. Click **Save**.
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}})
+
+    ```sh
+    rladmin tune cluster resp3_default disabled
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "resp3_default": false }
+    ```
+
+## Client prerequisites for Redis 7.2 upgrade
+
+The Redis clients [Go-Redis](https://redis.uptrace.dev/) version 9 and [Lettuce](https://redis.github.io/lettuce/) versions 6 and later use RESP3 by default. If you use either client to run Redis Stack commands, you should set the client's protocol version to RESP2 before upgrading your database to Redis version 7.2 to prevent potential application issues due to RESP3 breaking changes.
+
+### Go-Redis
+
+For applications using Go-Redis v9.0.5 or later, set the protocol version to RESP2:
+
+```go
+client := redis.NewClient(&redis.Options{
+    Addr:     "<database_endpoint>",
+    Protocol: 2, // Pin the protocol version
+})
+```
+
+### Lettuce
+
+To set the protocol version to RESP2 with Lettuce v6 or later:
+
+```java
+import io.lettuce.core.*;
+import io.lettuce.core.api.*;
+import io.lettuce.core.protocol.ProtocolVersion;
+
+// ...
+RedisClient client = RedisClient.create("<database_endpoint>");
+client.setOptions(ClientOptions.builder()
+        .protocolVersion(ProtocolVersion.RESP2) // Pin the protocol version 	
+        .build());
+// ...
+```
+
+If you are using [LettuceMod](https://github.com/redis-developer/lettucemod/), you need to upgrade to [v3.6.0](https://github.com/redis-developer/lettucemod/releases/tag/v3.6.0).
+---
+Title: Redis Enterprise compatibility with Redis Open Source
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Enterprise compatibility with Redis Open Source.
+hideListLinks: true
+linkTitle: Redis Open Source compatibility
+weight: $weight
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/references/compatibility/'
+---
+Both Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}) are compatible with Redis Open Source. 
+
+{{< embed-md "rc-rs-oss-compatibility.md"  >}}
+
+## RESP compatibility
+
+Redis Enterprise Software and Redis Cloud support RESP2 and RESP3. See [RESP compatibility with Redis Enterprise]({{< relref "/operate/rs/7.4/references/compatibility/resp" >}}) for more information.
+
+## Compatibility with open source Redis Cluster API
+
+Redis Enterprise supports [Redis OSS Cluster API]({{< relref "/operate/rs/7.4/clusters/optimize/oss-cluster-api" >}}) if it is enabled for a database. For more information, see [Enable OSS Cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}).
+---
+Title: Resource usage metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Resource usage
+weight: $weight
+url: '/operate/rs/7.4/references/metrics/resource-usage/'
+---
+
+## Connections
+
+Number of connections to the database.
+
+**Components measured**: Cluster, Node, and Database
+
+## CPU usage
+
+Percent of the node CPU used. 
+
+**Components measured**:  Cluster and Node
+
+### Main thread CPU usage 
+
+Percent of the CPU used by the main thread.
+
+**Components measured**: Database and Shard
+
+### Fork CPU usage
+
+CPU usage of Redis child forks.
+
+**Components measured**: Database and Shard
+
+### Total CPU usage 
+
+Percent usage of the CPU for all nodes.
+
+**Components measured**: Database
+
+## Free disk space
+
+Remaining unused disk space.
+
+**Components measured**:  Cluster and Node
+
+## Memory
+### Used memory 
+
+Total memory used by the database, including RAM, [Flash]({{< relref "/operate/rs/7.4/databases/auto-tiering" >}}) (if enabled), and [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}) (if enabled).
+
+Used memory does not include:
+
+1. Fragmentation overhead - The ratio of memory seen by the operating system to memory allocated by Redis
+2. Replication buffers at the primary nodes - Set to 10% of used memory and is between 64 MB and 2048 MB
+3. Memory used by Lua scripts - Does not exceed 1 MB
+4. Copy on Write (COW) operation that can be triggered by:
+    - A full replication process
+    - A database snapshot process
+    - AOF rewrite process
+
+Used memory is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+### Free RAM
+
+Available RAM for System use.
+
+**Components measured**:  Cluster and Node
+
+### Memory limit 
+
+Memory size limit of the database, enforced on the [used memory](#used-memory).
+
+**Components measured**: Database
+
+### Memory usage 
+
+Percent of memory used by Redis out of the [memory limit](#memory-limit).
+
+**Components measured**: Database
+## Traffic
+
+### Incoming traffic 
+
+Total incoming traffic to the database in bytes/sec.
+
+All incoming traffic is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Cluster, Node and Database
+
+#### Incoming traffic compressed
+
+Total incoming compressed traffic (in bytes/sec) per [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active" >}}) replica database. 
+
+#### Incoming traffic uncompressed
+
+Total incoming uncompressed traffic (in bytes/sec) per [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active" >}}) replica database. 
+
+### Outgoing traffic 
+
+Total outgoing traffic from the database in bytes per second.
+
+Outgoing traffic is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Cluster, Node and Database
+
+
+
+
+
+
+
+ 
+---
+Title: Database operations metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: null
+linkTitle: Database operations
+weight: $weight
+url: '/operate/rs/7.4/references/metrics/database-operations/'
+---
+
+## Evicted objects/sec
+
+Number of objects evicted from the database per second.
+
+Objects are evicted from the database according to the [eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy" >}}).
+
+Object information is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Expired objects/sec
+
+Number of expired objects per second.
+
+Object information is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Hit ratio 
+
+Ratio of the number of operations on existing keys out of the total number of operations. 
+
+**Components measured**: Database and Shard
+
+### Read misses/sec
+
+The number of [read operations](#readssec) per second on keys that do not exist.
+
+Read misses are not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database
+
+### Write misses/sec 
+
+Number of [write operations](#writessec) per second on keys that do not exist.
+
+Write misses are not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Latency 
+
+The total amount of time between sending a Redis operation and receiving a response from the database.
+
+The graph shows average, minimum, maximum, and last latency values for all latency metrics.
+
+**Components measured**: Database
+
+### Reads latency 
+
+[Latency](#latency) of [read operations](#readssec).
+
+**Components measured**: Database
+
+### Writes latency 
+
+[Latency](#latency) per [write operation](#writessec).
+
+**Components measured**: Database
+
+### Other commands latency 
+
+[Latency](#latency) of [other operations](#other-commandssec).
+
+**Components measured**: Database
+
+## Ops/sec
+
+Number of total operations per second, which includes [read operations](#readssec), [write operations](#writessec), and [other operations](#other-commandssec).
+
+**Components measured**: Cluster, Node, Database, and Shard
+
+### Reads/sec
+
+Number of total read operations per second.
+
+To find out which commands are read operations, run the following command with [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}):
+
+```sh
+ACL CAT read
+```
+
+**Components measured**: Database
+
+### Writes/sec
+
+Number of total write operations per second.
+
+To find out which commands are write operations, run the following command with [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}):
+
+```sh
+ACL CAT write
+```
+
+**Components measured**: Database
+
+#### Pending writes min
+
+Minimum number of write operations queued per [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active" >}}) replica database. 
+
+#### Pending writes max
+
+Maximum number of write operations queued per [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active" >}}) replica database. 
+
+### Other commands/sec 
+
+Number of operations per second that are not [read operations](#readssec) or [write operations](#writessec).
+
+Examples of other operations include [PING]({{< relref "/commands/ping" >}}), [AUTH]({{< relref "/commands/auth" >}}, and [INFO]({{< relref "/commands/info" >}}
+
+**Components measured**: Database
+
+## Total keys 
+
+Total number of keys in the dataset.
+ 
+Does not include replicated keys, even if [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}) is enabled.
+
+Total keys is not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}). 
+
+**Components measured**: Database
+
+
+
+
+
+
+
+
+---
+Title: Real-time metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Documents the metrics that are tracked with Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Metrics
+weight: $weight
+url: '/operate/rs/7.4/references/metrics/'
+---
+
+In the Redis Enterprise Cluster Manager UI, you can see real-time performance metrics for clusters, nodes, databases, and shards, and configure alerts that send notifications based on alert parameters. Select the **Metrics** tab to view the metrics for each component. For more information, see [Monitoring with metrics and alerts]({{< relref "/operate/rs/7.4/clusters/monitoring" >}}).
+
+See the following topics for metrics definitions:
+- [Database operations]({{< relref "/operate/rs/7.4/references/metrics/database-operations" >}}) for database metrics
+- [Resource usage]({{< relref "/operate/rs/7.4/references/metrics/resource-usage" >}}) for resource and database usage metrics
+- [Auto Tiering]({{< relref "/operate/rs/7.4/references/metrics/auto-tiering" >}}) for additional metrics for [Auto Tiering ]({{< relref "/operate/rs/7.4/databases/auto-tiering" >}}) databases
+
+## Prometheus metrics
+
+To collect and display metrics data from your databases and other cluster components,
+you can connect your [Prometheus](https://prometheus.io/) and [Grafana](https://grafana.com/) server to your Redis Enterprise Software cluster. See [Metrics in Prometheus]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}}) for a list of available metrics.
+
+We recommend you use Prometheus and Grafana to view metrics history and trends.
+
+See [Prometheus integration]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}) to learn how to connect Prometheus and Grafana to your Redis Enterprise database.
+
+## Limitations
+
+### Shard limit
+
+Metrics information is not shown for clusters with more than 128 shards. For large clusters, we recommend you use [Prometheus and Grafana]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}) to view metrics.
+
+### Metrics not shown during shard migration
+
+The following metrics are not measured during [shard migration]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}). If you view these metrics while resharding, the graph will be blank.
+
+- [Evicted objects/sec]({{< relref "/operate/rs/7.4/references/metrics/database-operations#evicted-objectssec" >}})
+- [Expired objects/sec]({{< relref "/operate/rs/7.4/references/metrics/database-operations#expired-objectssec" >}})
+- [Read misses/sec]({{< relref "/operate/rs/7.4/references/metrics/database-operations#read-missessec" >}})
+- [Write misses/sec]({{< relref "/operate/rs/7.4/references/metrics/database-operations#write-missessec" >}})
+- [Total keys]({{< relref "/operate/rs/7.4/references/metrics/database-operations#total-keys" >}})
+- [Incoming traffic]({{< relref "/operate/rs/7.4/references/metrics/resource-usage#incoming-traffic" >}})
+- [Outgoing traffic]({{< relref "/operate/rs/7.4/references/metrics/resource-usage#outgoing-traffic" >}})
+- [Used memory]({{< relref "/operate/rs/7.4/references/metrics/resource-usage#used-memory" >}})
+---
+Title: Auto Tiering Metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Auto Tiering
+weight: $weight
+url: '/operate/rs/7.4/references/metrics/auto-tiering/'
+---
+
+These metrics are additional metrics for [Auto Tiering ]({{< relref "/operate/rs/7.4/databases/auto-tiering" >}}) databases.
+
+#### % Values in RAM
+
+Percent of keys whose values are stored in RAM.
+
+A low percentage alert means most of the RAM is used for holding keys and not much RAM is available for values. This can be due to a high number of small keys or a few large keys. Inserting more keys might cause the database to run out of memory.
+
+If the percent of values in RAM is low for a subset of the database's shards, it might also indicate an unbalanced database.
+
+**Components measured**: Database and Shard
+
+#### Values in flash
+
+Number of keys with values stored in flash, not including [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}).
+
+**Components measured**: Database and Shard
+
+#### Values in RAM
+
+Number of keys with values stored in RAM, not including [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}).
+
+**Components measured**: Database and Shard 
+
+#### Flash key-value operations
+
+Number of operations on flash key values (read + write + del) per second.
+
+**Components measured**: Node
+
+#### Flash bytes/sec
+
+Number of total bytes read and written per second on flash memory.
+
+**Components measured**: Cluster, Node, Database, and Shard
+
+#### Flash I/O operations/sec
+
+Number of input/output operations per second on the flash storage device.
+
+**Components measured**: Cluster and Node
+
+#### RAM:Flash access ratio
+
+Ratio between logical Redis key value operations and actual flash key value operations.
+
+**Components measured**: Database and Shard
+
+#### RAM hit ratio
+
+Ratio of requests processed directly from RAM to total number of requests processed.
+
+**Components measured**: Database and Shard
+
+#### Used flash
+
+Total amount of memory used to store values in flash.
+
+**Components measured**: Database and Shard
+
+#### Free flash
+
+Amount of free space on flash storage. 
+
+**Components measured**: Cluster and Node
+
+#### Flash fragmentation
+
+Ratio between the used logical flash memory and the physical flash memory that is used.
+
+**Components measured**: Database and Shard
+
+#### Used RAM
+
+Total size of data stored in RAM, including keys, values, overheads, and [replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}) (if enabled).
+
+**Components measured**: Database and Shard
+
+#### RAM dataset overhead
+
+Percentage of the [RAM limit](#ram-limit) that is used for anything other than values, such as key names, dictionaries, and other overheads.
+
+**Components measured**: Database and Shard
+
+#### RAM limit
+
+Maximum amount of RAM that can be used in bytes.
+
+**Components measured**: Database
+
+#### RAM usage
+
+Percentage of the [RAM limit](#ram-limit) used.
+
+**Components measured**: Database
+
+#### Storage engine usage
+
+Total count of shards used, filtered by the sorage engine (Speedb / RockSB) per given database.
+
+**Components measured**: Database, Shards
+
+
+
+#### Calculated metrics
+
+These RoF statistics can be calculated from other metrics.
+
+- RoF average key size with overhead
+
+    ([ram_dataset_overhead](#ram-dataset-overhead) * [used_ram](#used-ram))
+                    / ([total_keys]({{< relref "/operate/rs/7.4/references/metrics/database-operations#total-keys" >}}) * 2)
+
+- RoF average value size in RAM
+
+    ((1 - [ram_dataset_overhead](#ram-dataset-overhead)) * [used_ram](#used-ram)) / ([values_in_ram](#values-in-ram) * 2)
+
+- RoF average value size in flash
+
+    [used_flash](#used-flash) / [values_in_flash](#values-in-flash)    
+---
+Title: Supported platforms
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software is supported on several operating systems,
+  cloud environments, and virtual environments.
+linkTitle: Supported platforms
+weight: 30
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/references/supported-platforms/'
+---
+{{<embed-md "supported-platforms-embed.md">}}
+---
+Title: Supported upgrade paths for Redis Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Supported paths to upgrade a Redis Software cluster.
+linkTitle: Upgrade paths
+weight: 30
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/references/upgrade-paths/'
+---
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+For detailed upgrade instructions, see [Upgrade a Redis Enterprise Software cluster]({{<relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster">}}).
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/7.4/installing-upgrading/product-lifecycle">}}) for more information about release numbers and the end-of-life schedule.
+---
+Title: Connecting to Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: null
+url: '/operate/rs/7.4/references/connecting-to-redis/'
+---
+To establish a connection to a Redis database, you'll need the following information:
+
+- The hostname or IP address of the Redis server
+- The port number that the Redis server is listening at
+- The database password (when configured with an authentication password which is **strongly recommended**)
+- The SSL certificates (when configured with SSL authentication and encryption - see [this article](/kb/read-more-ssl) for more information)
+
+The combination of `hostname:port` is commonly referred to as the "endpoint." This information is readily obtainable from your Redis Enterprise Cluster and Redis Cloud admin consoles. Unless otherwise specified, our Redis databases are accessible via a single managed endpoint to ensure high availability.
+
+You can connect to a Redis database using a wide variety of tools and libraries depending on your needs. Here's a short list:
+
+- Use one of the many [clients for Redis](redis.io/clients) - see below for client-specific information and examples
+- Code your own Redis client based on the [Redis Serialization Protocol (RESP)](http://redis.io/topics/protocol)
+- Make friends with Redis' own command line tool - `redis-cli` - to quickly connect and manage any Redis database (**tip:** you can also use `telnet` instead)
+- Use tools that provide a [GUI for Redis](/blog/so-youre-looking-for-the-redis-gui)
+
+## Basic connection troubleshooting
+
+Connecting to a remote server can be challenging. Here’s a quick checklist for common pitfalls:
+
+- Verify that the connection information was copy-pasted correctly <- more than 90% of connectivity issues are due to a single missing character.
+- If you're using Redis in the cloud or not inside of a LAN, consider adjusting your client's timeout settings
+- Try disabling any security measures that your database may have been set up with (e.g. Source IP/Subnet lists, Security Groups, SSL, etc...).
+- Try using a command line tool to connect to the database from your server - it is possible that your host and/port are blocked by the network.
+- If you've managed to open a connection, try sending the `INFO` command and act on its reply or error message.
+- Redis Enterprise Software Redis databases only support connecting to the default database (0) and block some administrative commands. To learn more, see:
+    - Redis Enterprise Cluster: [REC compatibility](/redis-enterprise-documentation/rlec-compatibility)
+    - Redis Cloud FAQ: [Are you fully compatible with Redis Open Source](/faqs#are-you-fully-compatible-with-open-source-redis)
+
+If you encounter any difficulties or have questions please feel free to [contact our help desk](mailto:support@redislabs.com).
+---
+Title: Clustering Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: null
+url: '/operate/rs/7.4/references/clustering-redis/'
+---
+Joining multiple Redis servers into a Redis cluster is a challenging task, especially because Redis supports complex data structures and commands required by modern web applications, in high-throughput and low latency (sub-millisecond) conditions. Some of those challenges are:
+
+- Performing union and intersection operations over List/Set/Sorted Set
+   data types across multiple shards and nodes
+- Maintaining consistency across multi-shard/multi-node architecture,
+   while running (a) a SORT command over a List of Hash keys; or (b) a
+   Redis transaction that includes multiple keys; or (c) a Lua script
+   with multiple keys
+- Creating a simple abstraction layer that hides the complex cluster
+   architecture from the user’s application, without code modifications
+   and while supporting infinite scalability
+- Maintaining a reliable and consistent infrastructure in a cluster
+   configuration
+
+There are several solutions to clustering Redis, most notable of which is the [Redis Open Source cluster](http://redis.io/topics/cluster-spec).
+
+Redis Enterprise Software and Redis Cloud were built from the ground up to provide a Redis cluster of any size while supporting all Redis commands. Your dataset is distributed across multiple shards in multiple nodes of the Redis cluster and is constantly monitored to ensure optimal performance. When needed, more shards and nodes can be added to your dataset so it can scale continuously and limitlessly.
+
+Redis Enterprise clusters provide a single endpoint to connect to, and do not require any code changes or special configuration from the application’s perspective. For more information on setting up and using Redis Enterprise clusters, see [Database clustering]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering/" >}}).
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Explains terms used in Redis Enterprise Software and its docs.
+linkTitle: Terminology
+title: Terminology in Redis Enterprise Software
+weight: $weight
+url: '/operate/rs/7.4/references/terminology/'
+---
+Here are explanations of some of the terms used in Redis Enterprise Software.
+
+## Node
+
+A _node_ is a physical machine, virtual machine, container or cloud
+instance on which the RS installation package was installed and the
+setup process was run in order to make the machine part of the cluster.
+
+Each node is a container for running multiple Redis
+instances, referred to as "shards".
+
+The recommended configuration for a production cluster is an uneven
+number of nodes, with a minimum of three. Note that in some
+configurations, certain functionalities might be blocked. For example,
+if a cluster has only one node you cannot enable database replication,
+which helps to achieve high availability.
+
+A node is made up of several components, as detailed below, and works
+together with the other cluster nodes.
+
+## Redis instance (shard)
+
+As indicated above, each node serves as a container for hosting multiple
+database instances, referred to as "shards".
+
+Redis Enterprise Software supports various database configurations:
+
+- **Standard Redis database** - A single Redis shard with no
+    replication or clustering.
+- **Highly available Redis database** - Every database master shard
+    has a replica shard, so that if the master shard fails the
+    cluster can automatically fail over to the replica with minimal impact. Master and replica shards are always placed on separate
+    nodes to ensure high availability.
+- **Clustered Redis database** - The data stored in the database is
+    split across several shards. The number of shards can be defined by
+    the user. Various performance optimization algorithms define where
+    shards are placed within the cluster. During the lifetime of the
+    cluster, these algorithms might migrate a shard between nodes.
+- **Clustered and highly available Redis database** - Each master shard
+    in the clustered database has a replica shard, enabling failover if
+    the master shard fails.
+
+## Proxy
+
+Each node includes one zero-latency, multi-threaded proxy
+(written in low-level C) that masks the underlying system complexity. The
+proxy oversees forwarding Redis operations to the database shards on
+behalf of a Redis client.
+
+The proxy simplifies the cluster operation, from the application or
+Redis client point of view, by enabling the use of a standard Redis
+client. The zero-latency proxy is built over a cut-through architecture
+and employs various optimization methods. For example, to help ensure
+high-throughput and low-latency performance, the proxy might use
+instruction pipelining even if not instructed to do so by the client.
+
+## Database endpoint
+
+Each database is served by a database endpoint that is part of and
+managed by the proxies. The endpoint oversees forwarding Redis
+operations to specific database shards.
+
+If the master shard fails and the replica shard is promoted to master, the
+master endpoint is updated to point to the new master shard.
+
+If the master endpoint fails, the replica endpoint is promoted to be the
+new master endpoint and is updated to point to the master shard.
+
+Similarly, if both the master shard and the master endpoint fail, then
+both the replica shard and the replica endpoint are promoted to be the new
+master shard and master endpoint.
+
+Shards and their endpoints do not
+have to reside within the same node in the cluster.
+
+In the case of a clustered database with multiple database shards, only
+one master endpoint acts as the master endpoint for all master shards,
+forwarding Redis operations to all shards as needed.
+
+## Cluster manager
+
+The cluster manager oversees all node management-related tasks, and the
+cluster manager in the master node looks after all the cluster related
+tasks.
+
+The cluster manager is designed in a way that is totally decoupled from
+the Redis operation. This enables RS to react in a much faster and
+accurate manner to failure events, so that, for example, a node failure
+event triggers mass failover operations of all the master endpoints
+and master shards that are hosted on the failed node.
+
+In addition, this architecture guarantees that each Redis shard is only
+dealing with processing Redis commands in a shared-nothing architecture,
+thus maintaining the inherent high-throughput and low-latency of each
+Redis process. Lastly, this architecture guarantees that any change in
+the cluster manager itself does not affect the Redis operation.
+
+Some of the primary functionalities of the cluster manager include:
+
+- Deciding where shards are created
+- Deciding when shards are migrated and to where
+- Monitoring database size
+- Monitoring databases and endpoints across all nodes
+- Running the database resharding process
+- Running the database provisioning and de-provisioning processes
+- Gathering operational statistics
+- Enforcing license and subscription limitations
+
+---
+Title: redis-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Run Redis commands.
+hideListLinks: true
+linkTitle: redis-cli (run Redis commands)
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/redis-cli/'
+---
+
+The `redis-cli` command-line utility lets you interact with a Redis database. With `redis-cli`, you can run [Redis commands]({{< relref "/commands" >}}) directly from the command-line terminal or with [interactive mode](#interactive-mode).
+
+If you want to run Redis commands without `redis-cli`, you can [connect to a database with Redis Insight]({{< relref "/develop/tools/insight/" >}}) and use the built-in [CLI]({{< relref "/develop/tools/insight/" >}}) prompt instead.
+
+## Install `redis-cli`
+
+When you install Redis Enterprise Software or Redis Open Source, it also installs the `redis-cli` command-line utility.
+
+To learn how to install Redis and `redis-cli`, see the following installation guides:
+
+- [Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack/" >}})
+
+- [Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Redis Enterprise Software with Docker]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+## Connect to a database
+
+To run Redis commands with `redis-cli`, you need to connect to your Redis database.
+
+You can find endpoint and port details in the **Databases** list or the database’s **Configuration** screen.
+
+### Connect remotely
+
+If you have `redis-cli` installed on your local machine, you can use it to connect to a remote Redis database. You will need to provide the database's connection details, such as the hostname or IP address, port, and password.
+
+```sh
+$ redis-cli -h <endpoint> -p <port> -a <password>
+```
+
+You can also provide the password with the `REDISCLI_AUTH` environment variable instead of the `-a` option:
+
+```sh
+$ export REDISCLI_AUTH=<password>
+$ redis-cli -h <endpoint> -p <port>
+```
+
+### Connect over TLS
+
+To connect to a Redis Enterprise Software or Redis Cloud database over TLS:
+
+1. Download or copy the Redis Enterprise server (or proxy) certificates.
+
+    - For Redis Cloud, see [Download certificates]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) for detailed instructions on how to download the server certificates (`redis_ca.pem`) from the [Redis Cloud console](https://cloud.redis.io/).
+
+    - For Redis Enterprise Software, copy the proxy certificate from the Cluster Manager UI (**Cluster > Security > Certificates > Server authentication**) or from a cluster node (`/etc/opt/redislabs/proxy_cert.pem`).
+
+1. Copy the certificate to each client machine.
+
+1. If your database doesn't require client authentication, provide the Redis Enterprise server certificate (`redis_ca.pem` for Cloud or `proxy_cert.pem` for Software) when you connect:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> --tls --cacert <redis_cert>.pem
+    ```
+
+1. If your database requires client authentication, provide your client's private and public keys along with the Redis Enterprise server certificate (`redis_ca.pem` for Cloud or `proxy_cert.pem` for Software) when you connect:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> --tls --cacert <redis_cert>.pem \
+        --cert redis_user.crt --key redis_user_private.key
+    ```
+
+### Connect with Docker
+
+If your Redis database runs in a Docker container, you can use `docker exec` to run `redis-cli` commands:
+
+```sh
+$ docker exec -it <Redis container name> redis-cli -p <port>
+```
+
+## Basic use
+
+You can run `redis-cli` commands directly from the command-line terminal:
+
+```sh
+$ redis-cli -h <endpoint> -p <port> <Redis command>
+```
+
+For example, you can use `redis-cli` to test your database connection and store a new Redis string in the database:
+
+```sh
+$ redis-cli -h <endpoint> -p 12000 PING
+PONG
+$ redis-cli -h <endpoint> -p 12000 SET mykey "Hello world"
+OK
+$ redis-cli -h <endpoint> -p 12000 GET mykey              
+"Hello world"
+```
+
+For more information, see [Command line usage]({{< relref "/develop/tools/cli" >}}#command-line-usage).
+
+## Interactive mode
+
+In `redis-cli` [interactive mode]({{< relref "/develop/tools/cli" >}}#interactive-mode), you can:
+
+- Run any `redis-cli` command without prefacing it with `redis-cli`.
+- Enter `?` for more information about how to use the `HELP` command and [set `redis-cli` preferences]({{< relref "/develop/tools/cli" >}}#preferences).
+- Enter [`HELP`]({{< relref "/develop/tools/cli" >}}#showing-help-about-redis-commands) followed by the name of a command for more information about the command and its options.
+- Press the `Tab` key for command completion.
+- Enter `exit` or `quit` or press `Control+D` to exit interactive mode and return to the terminal prompt.
+
+This example shows how to start interactive mode and run Redis commands:
+
+```sh
+$ redis-cli -p 12000
+127.0.0.1:12000> PING
+PONG
+127.0.0.1:12000> SET mykey "Hello world"
+OK
+127.0.0.1:12000> GET mykey
+"Hello world"
+```
+
+## Examples
+
+### Check slowlog
+
+Run [`slowlog get`]({{< relref "/commands/slowlog-get" >}}) for a list of recent slow commands:
+
+```sh
+redis-cli -h <endpoint> -p <port> slowlog get <number of entries>
+```
+
+### Scan for big keys
+
+Scan the database for big keys:
+
+```sh
+redis-cli -h <endpoint> -p <port> --bigkeys
+```
+
+See [Scanning for big keys]({{< relref "/develop/tools/cli" >}}#scanning-for-big-keys) for more information.
+
+## More info
+
+- [Redis CLI documentation]({{< relref "/develop/tools/cli" >}})
+- [Redis commands reference]({{< relref "/commands/" >}}
+---
+Title: rlcheck
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Verify nodes.
+hideListLinks: true
+linkTitle: rlcheck (verify nodes)
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rlcheck/'
+---
+The `rlcheck` utility runs various [tests](#tests) to check the health of a Redis Enterprise Software node and reports any discovered issues.
+You can use this utility to confirm a successful installation or to verify that the node is functioning properly.
+
+To resolve issues reported by `rlcheck`, [contact Redis support](https://redis.com/company/support/).
+
+## Run rlcheck
+
+You can run `rlcheck` from the node host's command line.
+The output of `rlcheck` shows information specific to the host you run it on.
+
+To run `rlcheck` tests:
+
+1. Sign in to the Redis Enterprise Software host with an account that is a member of the **redislabs** operating system group.
+
+1. Run: 
+
+    ```sh
+    rlcheck
+    ```
+
+## Options
+
+You can run `rlcheck` with the following options:
+
+| Option | Description |
+|--------|-------------|
+| <nobr>`--suppress-tests TEXT`</nobr> | Skip the specified, comma-delimited list of tests. See [Tests](#tests) for the list of tests and descriptions. |
+| <nobr>`--retry-delay INTEGER`</nobr> | Delay between retries, in seconds. |
+| <nobr>`--retry INTEGER`</nobr> | Number of retries after a failure. |
+| <nobr>`--file-path TEXT`</nobr> | Custom path to `rlcheck.log`. |
+| <nobr>`--continue-on-error`</nobr> | Continue to run all tests even if a test fails, then show all errors when complete. |
+| `--help` | Return the list of `rlcheck` options. |
+
+## Tests
+
+`rlcheck` runs the following tests by default:
+
+| Test name | Description |
+|-----------|-------------|
+| verify_owner_and_group | Verifies the owner and group for Redis Enterprise Software files are correct. |
+| verify_bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| verify_services | Verifies all Redis Enterprise Software services are running. |
+| verify_port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| verify_pidfiles | Verifies all active local shards have PID files. |
+| verify_capabilities | Verifies all binaries have the proper capability bits. |
+| verify_existing_sockets | Verifies sockets exist for all processes that require them. |
+| verify_host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />•`transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| verify_tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+| verify_encrypted_gossip | Verifies gossip communication is encrypted. |
+---
+Title: rladmin tune
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures parameters for databases, proxies, nodes, and clusters.
+headerRange: '[1-2]'
+linkTitle: tune
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/tune/'
+---
+
+Configures parameters for databases, proxies, nodes, and clusters.
+
+## `tune cluster`
+
+Configures cluster parameters.
+
+``` sh
+rladmin tune cluster
+        [ repl_diskless { enabled | disabled } ]
+        [ redis_provision_node_threshold <size> ]
+        [ redis_migrate_node_threshold <size> ]
+        [ redis_provision_node_threshold_percent <percent> ]
+        [ redis_migrate_node_threshold_percent <percent> ]
+        [ max_simultaneous_backups <number> ]
+        [ failure_detection_sensitivity { high | low } ]
+        [ watchdog_profile { cloud | local-network } ]
+        [ slave_ha { enabled | disabled } ]
+        [ slave_ha_grace_period <seconds> ]
+        [ slave_ha_cooldown_period <seconds> ]
+        [ slave_ha_bdb_cooldown_period <seconds> ]
+        [ max_saved_events_per_type <value> ]
+        [ parallel_shards_upgrade <value> ]
+        [ default_concurrent_restore_actions <value> ]
+        [ show_internals { enabled | disabled } ]
+        [ expose_hostnames_for_all_suffixes { enabled | disabled } ]
+        [ redis_upgrade_policy { latest | major } ]
+        [ default_redis_version <value> ]
+        [ default_non_sharded_proxy_policy { single | all-master-shards | all-nodes } ]
+        [ default_sharded_proxy_policy { single | all-master-shards | all-nodes } ]
+        [ default_shards_placement { dense | sparse } ]
+        [ data_internode_encryption { enabled | disabled } ]
+        [ db_conns_auditing { enabled | disabled } ]
+        [ acl_pubsub_default { resetchannels | allchannels } ]
+        [ resp3_default { enabled | disabled } ]
+        [ automatic_node_offload { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameters                             | Type/Value                        | Description                                                                                                                  |
+|----------------------------------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------|
+| acl_pubsub_default | `resetchannels`<br /> `allchannels` | Default pub/sub ACL rule for all databases in the cluster:<br />•`resetchannels` blocks access to all channels (restrictive)<br />•`allchannels` allows access to all channels (permissive) |
+| automatic_node_offload | `enabled`<br />`disabled` | Define whether automatic node offload migration will take place |
+| data_internode_encryption              | `enabled`<br />`disabled`       | Activates or deactivates [internode encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption" >}}) for new databases    |
+| db_conns_auditing                      | `enabled`<br /> `disabled`      | Activates or deactivates [connection auditing]({{< relref "/operate/rs/7.4/security/audit-events" >}}) by default for new databases of a cluster                                                                  |
+| default_concurrent_restore_actions     | integer<br />`all`              | Default number of concurrent actions when restoring a node from a snapshot (positive integer or "all")                         |
+| default_non_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default [proxy policy]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}) for newly created non-sharded databases' endpoints |
+| default_redis_version                  | version number                    | The default Redis database compatibility version used to create new databases.<br/><br/>  The value parameter should be a version number in the form of "x.y" where _x_ represents the major version number and _y_ represents the minor version number.  The final value corresponds to the desired version of Redis.<br/><br/>You cannot set _default_redis_version_ to a value higher than that supported by the current _redis_upgrade_policy_ value. |
+| default_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default [proxy policy]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy" >}}) for newly created sharded databases' endpoints |
+| default_shards_placement | `dense`<br />`sparse` | New databases place shards according to the default [shard placement policy]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy" >}}) |
+| expose_hostnames_for_all_suffixes      | `enabled`<br />`disabled`       | Exposes hostnames for all DNS suffixes                                                                                       |
+| failure_detection_sensitivity | `high`<br />`low` | Predefined thresholds and timeouts for failure detection (previously known as `watchdog_profile`)<br />• `high` (previously `local-network`) – high failure detection sensitivity, lower thresholds, faster failure detection and failover<br />• `low` (previously `cloud`) – low failure detection sensitivity, higher tolerance for latency variance (also called network jitter) |
+| login_lockout_counter_reset_after      | time in seconds                   | Time after failed login attempt before the counter resets to 0                                                                   |
+| login_lockout_duration                 | time in seconds                   | Time a locked account remains locked ( "0" means only an admin can unlock the account)                                   |
+| login_lockout_threshold                | integer                           | Number of failed sign-in attempts to trigger locking a user account ("0" means never lock the account)                   |
+| max_saved_events_per_type              | integer                           | Maximum number of events each type saved in CCS per object type                                                              |
+| max_simultaneous_backups               | integer (default: 4)                      | Number of database backups allowed to run at the same time. Combines with `max_redis_forks` (set by [`tune node`](#tune-node)) to determine the number of shard backups allowed to run simultaneously.                                                                                  |
+| parallel_shards_upgrade                | integer<br />`all`              | Number of shards upgraded in parallel during DB upgrade (positive integer or "all")                                          |
+| redis_migrate_node_threshold           | size in MB                        | Memory (in MBs by default or can be specified) needed to migrate a database between nodes                                   |
+| redis_migrate_node_threshold_percent   | percentage                | Memory (in percentage) needed to migrate a database between nodes                                                            |
+| redis_provision_node_threshold         | size in MB                        | Memory (in MBs by default or can be specified) needed to provision a new database                                           |
+| redis_provision_node_threshold_percent | percentage                | Memory (in percentage) needed to provision a new database                                                                    |
+| redis_upgrade_policy                   | `latest`<br />`major`           | When you upgrade or create a new Redis database, this policy determines which version of Redis database compatibility is used.<br /><br />Supported values are:<ul><li><p>`latest`, which applies the most recent Redis compatibility update \(_effective default prior to v6.2.4_)<p></li><li>`major`, which applies the most recent major release compatibility update (_default as of v6.2.4_).</li></ul>                                                                                                                 |
+| repl_diskless                          | `enabled`<br />`disabled`       | Activates or deactivates diskless replication (can be overridden per database)                                              |
+| resp3_default | `enabled` <br /> `disabled` | Determines the default value of the `resp3` option upon upgrading a database to version 7.2 (defaults to `enabled`) |
+| show_internals                         | `enabled`<br />`disabled`       | Controls the visibility of internal databases that are only used for the cluster's management                                |
+| slave_ha                               | `enabled` <br /> `disabled`   | Activates or deactivates [replica high availability]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) in the cluster<br />(enabled by default; use [`rladmin tune db`](#tune-db) to change `slave_ha` for a specific database)<br /><br />Deprecated as of Redis Enterprise Software v7.2.4. |
+| slave_ha_bdb_cooldown_period           | time in seconds (default: 7200) | Time (in seconds) a database must wait after its shards are relocated by [replica high availability]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) before it can go through another shard migration if another node fails (default is 2 hours) |
+| slave_ha_cooldown_period               | time in seconds (default: 3600) | Time (in seconds) [replica high availability]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) must wait after relocating shards due to node failure before performing another shard migration for any database in the cluster (default is 1 hour) |
+| slave_ha_grace_period                  | time in seconds (default: 600) | Time (in seconds) between when a node fails and when [replica high availability]({{< relref "/operate/rs/7.4/databases/configure/replica-ha" >}}) starts relocating shards to another node      |
+| watchdog_profile                       | `cloud` <br /> `local-network` | Watchdog profiles with preconfigured thresholds and timeouts (deprecated as of Redis Enterprise Software v6.4.2-69; use <span class="break-all">`failure_detection_sensitivity`</span> instead)<br />• `cloud` is suitable for common cloud environments and has a higher tolerance for latency variance (also called network jitter).<br />• `local-network` is suitable for dedicated LANs and has better failure detection and failover times. |
+
+### Returns
+
+Returns `Finished successfully` if the cluster configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info cluster`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-cluster" >}}) to verify the cluster configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune cluster slave_ha enabled
+Finished successfully
+$ rladmin info cluster | grep slave_ha
+    slave_ha: enabled
+```
+
+## `tune db`
+
+Configures database parameters.
+
+``` sh
+rladmin tune db { db:<id> | <name> }
+        [ slave_buffer <auto | valueMB | hard:soft:time> ]
+        [ client_buffer <value> ]
+        [ repl_backlog <valueMB | auto> ]
+        [ crdt_repl_backlog <valueMB | auto> ]
+        [ repl_timeout <seconds> ]
+        [ repl_diskless { enabled | disabled | default } ]
+        [ master_persistence { enabled | disabled } ]
+        [ maxclients <value> ]
+        [ schedpolicy { cmp | mru | spread | mnp } ]
+        [ max_shard_pipeline <value> ]
+        [ conns <value> ]
+        [ conns_type <value> ]
+        [ max_client_pipeline <value> ]
+        [ max_connections <value> ]
+        [ max_aof_file_size <size> ]
+        [ max_aof_load_time <seconds> ]
+        [ oss_cluster { enabled | disabled } ]
+        [ oss_cluster_api_preferred_ip_type <value> ]
+        [ slave_ha { enabled | disabled } ]
+        [ slave_ha_priority <value> ]
+        [ skip_import_analyze { enabled | disabled } ]
+        [ mkms { enabled | disabled } ]
+        [ continue_on_error ]
+        [ gradual_src_mode { enabled | disabled } ]
+        [ gradual_sync_mode { enabled | disabled | auto } ]
+        [ gradual_sync_max_shards_per_source <value> ]
+        [ module_name <value> ] [ module_config_params <value> ]
+        [ crdt_xadd_id_uniqueness_mode { liberal | semi-strict | strict } ]
+        [ metrics_export_all { enabled | disabled } ]
+        [ syncer_mode { distributed | centralized }]
+        [ syncer_monitoring { enabled | disabled } ]
+        [ mtls_allow_weak_hashing { enabled | disabled } ]
+        [ mtls_allow_outdated_cert { enabled | disabled } ]
+        [ data_internode_encryption { enabled | disabled } ]
+        [ db_conns_auditing { enabled | disabled } ]
+        [ resp3 { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter                            | Type/Value                       | Description                                                                                                                           |
+|--------------------------------------|----------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| db:id                                | integer                          | ID of the specified database                                                                                                          |
+| name                                 | string                           | Name of the specified database                                                                                                        |
+| client_buffer                        | value in MB hard:soft:time       | Redis client output buffer limits                                                                                                     |
+| conns                                | integer                          | Size of internal connection pool, specified per-thread or per-shard depending on conns_type                                           |
+| conns_type                           | `per-thread`<br /> `per-shard`   | Specifies connection pool size as either per-thread or per-shard                                                                      |
+| continue_on_error                    |                                  | Flag that skips tuning shards that can't be reached                                                                                   |
+| crdt_repl_backlog                    | value in MB<br /> `auto`         | Size of the Active-Active replication buffer                                                                                          |
+| crdt_xadd_id_uniqueness_mode         | `liberal`<br /> `semi-strict`<br /> `strict` | XADD's behavior in an Active-Active database, defined as liberal, semi-strict, or strict (see descriptions below)         |
+| data_internode_encryption            | `enabled`<br /> `disabled`       | Activates or deactivates [internode encryption]({{< relref "/operate/rs/7.4/security/encryption/internode-encryption" >}}) for the database               |
+| db_conns_auditing                    | `enabled`<br /> `disabled`       | Activates or deactivates database [connection auditing]({{< relref "/operate/rs/7.4/security/audit-events" >}}) for a database                                                                 |
+| gradual_src_mode                     | `enabled`<br /> `disabled`       | Activates or deactivates gradual sync of sources                                                                                      |
+| gradual_sync_max_shards_per_source   | integer                          | Number of shards per sync source that can be replicated in parallel (positive integer)                                                |
+| gradual_sync_mode                    | `enabled`<br /> `disabled`<br /> `auto` | Activates, deactivates, or automatically determines gradual sync of source shards                                              |
+| master_persistence                   | `enabled`<br /> `disabled`       | If enabled, persists the primary shard in addition to replica shards in a replicated and persistent database. |
+| max_aof_file_size                    | size in MB                       | Maximum size (in MB, if not specified) of [AoF]({{< relref "/glossary/_index.md#letter-a" >}}) file (minimum value is 10 GB)              |
+| max_aof_load_time | time in seconds | Time limit in seconds to load a shard from an append-only file (AOF). If exceeded, an AOF rewrite is initiated to decrease future load time.<br />Minimum: 2700 seconds (45 minutes) <br />Default: 3600 seconds (1 hour) |
+| max_client_pipeline                  | integer                          | Maximum commands in the proxy's pipeline per client connection (max value is 2047, default value is 200)                              |
+| max_connections                      | integer                          | Maximum client connections to the database's endpoint (default value is 0, which is unlimited)                                            |
+| max_shard_pipeline                   | integer                          | Maximum commands in the proxy's pipeline per shard connection (default value is 200)                                                  |
+| maxclients                           | integer                          | Controls the maximum client connections between the proxy and shards (default value is 10000)                                         |
+| metrics_export_all                   | `enabled`<br /> `disabled`       | Activates the exporter to expose all shard metrics                                                                                    |
+| mkms                                 | `enabled`<br /> `disabled`       | Activates multi-key multi-slot commands                                                                                               |
+| module_config_params | string | Configures module arguments at runtime. Enclose `module_config_params` within quotation marks. |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf`<br />`rg` | The module to configure with `module_config_params` |
+| mtls_allow_outdated_cert             | `enabled`<br /> `disabled`       | Activates outdated certificates in mTLS connections                                   |
+| mtls_allow_weak_hashing              | `enabled`<br /> `disabled`       | Activates weak hashing (less than 2048 bits) in mTLS connections                       |
+| oss_cluster                          | `enabled`<br /> `disabled`       | Activates OSS cluster API                                                                                                             |
+| oss_cluster_api_preferred_ip_type    | `internal`<br /> `external`      | IP type for the endpoint and database in the OSS cluster API (default is internal)                                     |
+| repl_backlog                         | size in MB<br /> `auto`          | Size of the replication buffer                                                                                        |
+| repl_diskless                        | `enabled`<br /> `disabled`<br /> `default`   | Activates or deactivates diskless replication (defaults to the cluster setting)                                          |
+| repl_timeout                         | time in seconds                  | Replication timeout (in seconds)                                                                                                      |
+| resp3 | `enabled`<br /> `disabled` | Enables or deactivates RESP3 support (defaults to `enabled`) |
+| schedpolicy                          | `cmp`<br /> `mru`<br /> `spread`<br /> `mnp` | Controls how server-side connections are used when forwarding traffic to shards                                           |
+| skip_import_analyze                  | `enabled`<br /> `disabled`       | Skips the analyzing step when importing a database                                                                                    |
+| slave_buffer                         | `auto`<br />value in MB<br /> hard:soft:time | Redis replica output buffer limits<br />• `auto`: dynamically adjusts the buffer limit based on the shard’s current used memory<br />• value in MB: sets the buffer limit in MB<br />• hard:soft:time: sets the hard limit (maximum buffer size in MB), soft limit in MB, and the time in seconds that the soft limit can be exceeded |
+| slave_ha                             | `enabled`<br /> `disabled`       | Activates or deactivates replica high availability (defaults to the cluster setting)                                                      |
+| slave_ha_priority                    | integer                          | Priority of the database in the replica high-availability mechanism                                                                           |
+| syncer_mode                          | `distributed`<br /> `centralized`| Configures syncer to run in distributed or centralized mode. For distributed syncer, the DMC policy must be all-nodes or all-master-nodes |
+| syncer_monitoring                    | `enabled`<br /> `disabled`       | Activates syncer monitoring                                                                                                           |
+
+| XADD behavior mode | Description |
+| - | - |
+| liberal | XADD succeeds with any valid ID (not recommended, allows duplicate IDs) |
+| semi-strict | Allows a full ID. Partial IDs are completed with the unique database instance ID (not recommended, allows duplicate IDs). |
+| strict | XADD fails if a full ID is given. Partial IDs are completed using the unique database instance ID. |
+
+### Returns
+
+Returns `Finished successfully` if the database configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info db`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-db" >}}) to verify the database configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune db db:4 repl_timeout 300
+Tuning database: o
+Finished successfully
+$ rladmin info db db:4 | grep repl_timeout
+  repl_timeout: 300 seconds
+```
+
+## `tune node`
+
+Configures node parameters.
+
+``` sh
+tune node  { <id> | all }
+     [ max_listeners <value> ]
+     [ max_redis_forks <value> ]
+     [ max_redis_servers <value> ]
+     [ max_slave_full_syncs <value> ]
+     [ quorum_only { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter            | Type/Value | Description                                                                                                                      |
+|----------------------|------------|----------------------------------------------------------------------------------------------------------------------------------|
+| id                   | integer    | ID of the specified node                                                                                                         |
+| all                  |            | Configures settings for all nodes                                                                                                |
+| max_listeners        | integer    | Maximum number of endpoints that may be bound to the node                                                                        |
+| max_redis_forks      | integer    | Maximum number of background processes forked from shards that may exist on the node at any given time                           |
+| max_redis_servers    | integer    | Maximum number of shards allowed to reside on the node                                                                           |
+| max_slave_full_syncs | integer    | Maximum number of simultaneous replica full-syncs that may be running at any given time (0: Unlimited, -1: Use cluster settings) |
+| quorum_only          | `enabled`<br /> `disabled` | If activated, configures the node as a [quorum-only node]({{< relref "/glossary/_index.md#letter-p" >}})                         |
+
+### Returns
+
+Returns `Finished successfully` if the node configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info node`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-node" >}}) to verify the node configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune node 3 max_redis_servers 120
+Finished successfully
+$ rladmin info node 3 | grep "max redis servers"
+    max redis servers: 120
+```
+
+## `tune proxy`
+
+Configures proxy parameters.
+
+``` sh
+rladmin tune proxy { <id> | all }
+        [ mode { static | dynamic } ]
+        [ threads <value> ]
+        [ max_threads <value> ]
+        [ scale_threshold <value> ]
+        [ scale_duration <seconds> ]
+```
+
+### Parameters
+
+| Parameter       | Type/Value                 | Description                                                                         |
+|-----------------|----------------------------|-------------------------------------------------------------------------------------|
+| id              | integer                    | ID of the specified proxy                                                           |
+| all             |                            | Configures settings for all proxies                                                 |
+| max_threads     | integer, (range:&nbsp;1-255) | Maximum number of threads allowed                                                   |
+| mode            | `static`<br /> `dynamic` | Determines if the proxy automatically adjusts the number of threads based on load size  |
+| scale_duration  | time in seconds, (range:&nbsp;10-300) | Time of scale_threshold CPU utilization before the automatic proxy automatically scales |
+| scale_threshold | percentage, (range:&nbsp;50-99) | CPU utilization threshold that triggers spawning new threads                        |
+| threads         | integer, (range:&nbsp;1-255) | Initial number of threads created at startup                                        |
+
+### Returns
+
+Returns `OK` if the proxy configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info proxy`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-proxy" >}}) to verify the proxy configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune proxy 2 scale_threshold 75
+Configuring proxies:
+  - proxy:2: ok
+$ rladmin info proxy 2 | grep scale_threshold
+    scale_threshold: 75 (%)
+```
+---
+Title: rladmin cluster master
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Identifies or changes the cluster's master node.
+headerRange: '[1-2]'
+linkTitle: master
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/master/'
+---
+
+Identifies the cluster's master node. Use `set` to change the cluster's master to a different node.
+
+```sh
+cluster master [ set <node_id> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node_id | integer | Unique node ID |
+
+### Returns
+
+Returns the ID of the cluster's master node. Otherwise, it returns an error message.
+
+### Example
+
+Identify the cluster's master node:
+
+```sh
+$ rladmin cluster master
+Node 1 is the cluster master node
+```
+
+Change the cluster master to node 3:
+
+```sh
+$ rladmin cluster master set 3
+Node 3 set to be the cluster master node
+```
+---
+Title: rladmin cluster recover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Recovers a cluster from a backup file.
+headerRange: '[1-2]'
+linkTitle: recover
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/recover/'
+---
+
+Recovers a cluster from a backup file. The default location of the configuration backup file is `/var/opt/redislabs/persist/ccs/ccs-redis.rdb`.
+
+```sh
+rladmin cluster recover
+        filename <recovery filename>
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ rack_id <ID> ]
+        [ override_rack_id ]
+        [ node_uid <number> ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP address> ]
+        [ external_addr <IP address> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| addr | IP address | Sets a node's internal IP address. If not provided, the node sets the address automatically. (optional) |
+| ccs_persistent_path | filepath | Path to the location of CCS snapshots (default is the same as persistent_path) (optional) |
+| external_addr | IP address | Sets a node's external IP address. If not provided, the node sets the address automatically. (optional) |
+| ephemeral_path | filepath (default:&nbsp;/var/opt/redislabs) | Path to an ephemeral storage location (optional) |
+| filename | filepath | Backup file to use for recovery |
+| flash_enabled | | Enables flash storage (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location in case the node does not support CAPI (required if flash_enabled) |
+| node_uid | integer (default:&nbsp;1) | Specifies which node will recover first and become master (optional) |
+| override_rack_id | | Changes to a new rack, specified by `rack_id` (optional) |
+| persistent_path | filepath | Path to the persistent storage location (optional) |
+| rack_id | string | Switches to the specified rack (optional) |
+
+### Returns
+
+Returns `ok` if the cluster recovered successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster recover filename /tmp/persist/ccs/ccs-redis.rdb node_uid 1 rack_id 5
+Initiating cluster recovery... ok
+```
+---
+Title: rladmin cluster stats_archiver
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enables/deactivates the stats archiver.
+headerRange: '[1-2]'
+linkTitle: stats_archiver
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/stats_archiver/'
+---
+
+Enables or deactivates the stats archiver, which logs statistics in CSV (comma-separated values) format.
+
+```sh
+rladmin cluster stats_archiver { enabled | disabled }
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| enabled | Turn on the stats archiver |
+| disabled | Turn off the stats archiver |
+
+### Returns
+
+Returns the updated status of the stats archiver. 
+
+### Example
+
+```sh
+$ rladmin cluster stats_archiver enabled 
+Status: enabled
+```
+---
+Title: rladmin cluster reset_password
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Changes the password for a given email.
+headerRange: '[1-2]'
+linkTitle: reset_password
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/reset_password/'
+---
+
+Changes the password for the user associated with the specified email address.
+
+Enter a new password when prompted. Then enter the same password when prompted a second time to confirm the password change.
+
+```sh
+rladmin cluster reset_password <user email>
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| user email | email address | The email address of the user that needs a password reset |
+
+### Returns
+
+Reports whether the password change succeeded or an error occurred. 
+
+### Example
+
+```sh
+$ rladmin cluster reset_password user@example.com
+New password: 
+New password (again): 
+Password changed.
+```
+---
+Title: rladmin cluster config
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Updates the cluster's configuration.
+headerRange: '[1-2]'
+linkTitle: config
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config/'
+---
+
+Updates the cluster configuration.
+
+```sh
+ rladmin cluster config 
+        [ auditing db_conns audit_protocol { TCP | local } 
+           audit_address <audit_address> audit_port <audit_port> ]
+        [bigstore_driver {speedb | rocksdb} ]
+        [ control_cipher_suites <BoringSSL cipher list> ]
+        [ cm_port <number> ]
+        [ cm_session_timeout_minutes <minutes> ]
+        [ cnm_http_port <number> ]
+        [ cnm_https_port <number> ]
+        [ crdb_coordinator_port <number> ]
+        [ data_cipher_list <openSSL cipher list> ]
+        [ data_cipher_suites_tls_1_3 <openSSL cipher list> ]
+        [ debuginfo_path <filepath> ]
+        [ encrypt_pkeys { enabled | disabled } ]
+        [ envoy_admin_port <new-port> ]
+        [ envoy_mgmt_server_port <new-port> ]
+        [ gossip_envoy_admin_port <new-port> ]
+        [ handle_redirects { enabled | disabled } ]
+        [ handle_metrics_redirects { enabled | disabled } ]
+        [ http_support { enabled | disabled } ]
+        [ ipv6 { enabled | disabled } ]
+        [ min_control_TLS_version { 1.2 | 1.3 } ]
+        [ min_data_TLS_version { 1.2 | 1.3 } ]
+        [ min_sentinel_TLS_version { 1.2 | 1.3 } ]
+        [ reserved_ports <list of ports/port ranges> ]
+        [ s3_url <URL> ]
+        [ s3_ca_cert <filepath> ]
+        [ saslauthd_ldap_conf </tmp/ldap.conf> ]
+        [ sentinel_tls_mode { allowed | required | disabled } ]
+        [ sentinel_cipher_suites <golang cipher list> ]
+        [ services { cm_server | crdb_coordinator | crdb_worker | 
+                     mdns_server | pdns_server | saslauthd | 
+                     stats_archiver } { enabled | disabled } ]
+        [ upgrade_mode { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| audit_address | string | TCP/IP address where a listener can capture [audit event notifications]({{< relref "/operate/rs/7.4/security/audit-events" >}}) |
+| audit_port | string | Port where a listener can capture [audit event notifications]({{< relref "/operate/rs/7.4/security/audit-events" >}}) |
+| audit_protocol | `tcp`<br/>`local` | Protocol used for [audit event notifications]({{< relref "/operate/rs/7.4/security/audit-events" >}})<br/>For production systems, only `tcp` is supported. |
+| control_cipher_suites | list of ciphers | Cipher suites used for TLS connections to the Cluster Manager UI (specified in the format understood by the BoringSSL library)<br />(previously named `cipher_suites`) |
+| cm_port | integer | UI server listening port |
+| cm_session_timeout_minutes | integer | Timeout in minutes for the CM session
+| cnm_http_port | integer | HTTP REST API server listening port |
+| cnm_https_port | integer | HTTPS REST API server listening port |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| data_cipher_list | list of ciphers | Cipher suites used by the the data plane (specified in the format understood by the OpenSSL library) |
+| data_cipher_suites_tls_1_3 |  list of ciphers | Specifies the enabled TLS 1.3 ciphers for the data plane |
+| debuginfo_path | filepath | Local directory to place generated support package files |
+| encrypt_pkeys | `enabled`<br />`disabled` | Enable or turn off encryption of private keys |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| handle_redirects | `enabled`<br />`disabled` | Enable or turn off handling DNS redirects when DNS is not configured and running behind a load balancer |
+| handle_metrics_redirects | `enabled`<br />`disabled` | Enable or turn off handling cluster redirects internally for Metrics API |
+| http_support | `enabled`<br />`disabled` | Enable or turn off using HTTP for REST API connections |
+| ipv6 | `enabled`<br />`disabled` | Enable or turn off IPv6 connections to the Cluster Manager UI |
+| min_control_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the control path |
+| min_data_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the data path |
+| min_sentinel_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the discovery service |
+| reserved_ports | list of ports/port ranges | List of reserved ports and/or port ranges to avoid using for database endpoints (for example `reserved_ports 11000 13000-13010`) |
+| s3_url | string | The URL of S3 export and import |
+| s3_ca_cert | string | The CA certificate filepath for S3 export and import |
+| saslauthd_ldap_conf | filepath | Updates LDAP authentication configuration for the cluster |
+| sentinel_cipher_suites | list of ciphers | Cipher suites used by the discovery service (supported ciphers are implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package) |
+| sentinel_tls_mode | `allowed`<br />`required`<br />`disabled` | Define the SSL policy for the discovery service<br />(previously named `sentinel_ssl_policy`) |
+| services | `cm_server`<br />`crdb_coordinator`<br />`crdb_worker`<br />`mdns_server`<br />`pdns_server`<br />`saslauthd`<br />`stats_archiver`<br /><br />`enabled`<br />`disabled` | Enable or turn off selected cluster services |
+| upgrade_mode | `enabled`<br />`disabled` | Enable or turn off upgrade mode on the cluster |
+
+### Returns
+
+Reports whether the cluster was configured successfully. Displays an error message if the configuration attempt fails.
+
+### Example
+
+```sh
+$ rladmin cluster config cm_session_timeout_minutes 20
+Cluster configured successfully
+```
+---
+Title: rladmin cluster ocsp
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages OCSP.
+headerRange: '[1-2]'
+linkTitle: ocsp
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/ocsp/'
+---
+
+Manages OCSP configuration and verifies the status of a server certificate maintained by a third-party [certificate authority (CA)](https://en.wikipedia.org/wiki/Certificate_authority).
+
+## `ocsp certificate_compatible`
+
+Checks if the proxy certificate contains an OCSP URI.
+
+```sh
+rladmin cluster ocsp certificate_compatible
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the OCSP URI if it exists. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp certificate_compatible
+Success. OCSP URI is http://responder.ocsp.url.com
+```
+
+## `ocsp config`
+
+Displays or updates OCSP configuration. Run the command without the `set` option to display the current configuration of a parameter.
+
+```sh
+rladmin cluster ocsp config <OCSP parameter>
+        [set <value>]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|---------------|-------------|
+| ocsp_functionality | enabled<br></br>disabled | Enables or turns off OCSP for the cluster |
+| query_frequency | integer <nobr>(range: 60-86400)</nobr> <nobr>(default: 3600)</nobr> | The time interval in seconds between OCSP queries to check the certificate's status |
+| recovery_frequency | integer <nobr>(range: 60-86400)</nobr> <nobr>(default: 60)</nobr> | The time interval in seconds between retries after a failed query |
+| recovery_max_tries | integer <nobr>(range: 1-100)</nobr> <nobr>(default: 5)</nobr> | The number of retries before the validation query fails and invalidates the certificate |
+| responder_url | string | The OCSP server URL embedded in the proxy certificate (you cannot manually set this parameter) |
+| response_timeout | integer <nobr>(range: 1-60)</nobr> <nobr>(default: 1)</nobr> | The time interval in seconds to wait for a response before timing out |
+
+### Returns
+
+If you run the `ocsp config` command without the `set` option, it displays the specified parameter's current configuration.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp config recovery_frequency
+Recovery frequency of the OCSP server is 60 seconds
+$ rladmin cluster ocsp config recovery_frequency set 30
+$ rladmin cluster ocsp config recovery_frequency
+Recovery frequency of the OCSP server is 30 seconds
+```
+
+## `ocsp status`
+
+Returns the latest cached status of the certificate's OCSP response.
+
+```sh
+rladmin cluster ocsp status
+```
+### Parameters
+
+None
+
+### Returns
+
+Returns the latest cached status of the certificate's OCSP response.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp status
+OCSP certificate status is: REVOKED
+produced_at: Wed, 22 Dec 2021 12:50:11 GMT
+responder_url: http://responder.ocsp.url.com
+revocation_time: Wed, 22 Dec 2021 12:50:04 GMT
+this_update: Wed, 22 Dec 2021 12:50:11 GMT
+```
+
+## `ocsp test_certificate`
+
+Queries the OCSP server for the certificate's latest status, then caches and displays the response.
+
+```sh
+rladmin cluster ocsp test_certificate
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the latest status of the certificate's OCSP response.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp test_certificate
+Initiating a query to OCSP server
+...OCSP certificate status is: REVOKED
+produced_at: Wed, 22 Dec 2021 12:50:11 GMT
+responder_url: http://responder.ocsp.url.com
+revocation_time: Wed, 22 Dec 2021 12:50:04 GMT
+this_update: Wed, 22 Dec 2021 12:50:11 GMT
+```
+---
+Title: rladmin cluster certificate
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets the cluster certificate.
+headerRange: '[1-2]'
+linkTitle: certificate
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/certificate/'
+---
+
+Sets a cluster certificate to a specified PEM file.
+
+```sh
+rladmin cluster certificate
+        set <certificate name>
+        certificate_file <certificate filepath>
+        [ key_file <key filepath> ]
+```
+
+To set a certificate for a specific service, use the corresponding certificate name. See the [certificates table]({{< relref "/operate/rs/7.4/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| certificate name | 'cm'<br /> 'api'<br /> 'proxy'<br /> 'syncer'<br /> 'metrics_exporter' | Name of the certificate to update |
+| certificate_file | filepath | Path to the certificate file |
+| key_file | filepath | Path to the key file (optional) |
+
+### Returns
+
+Reports that the certificate was set to the specified file. Returns an error message if the certificate fails to update.
+
+### Example
+
+```sh
+$ rladmin cluster certificate set proxy \
+       certificate_file /tmp/proxy.pem
+Set proxy certificate to contents of file /tmp/proxy.pem
+```
+---
+Title: rladmin cluster create
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates a new cluster.
+headerRange: '[1-2]'
+linkTitle: create
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/create/'
+---
+
+Creates a new cluster. The node where you run `rladmin cluster create` becomes the first node of the new cluster.
+
+```sh
+cluster create
+        name <cluster name>
+        username <admin email>
+        password <admin password>
+        [ node_uid <node UID> ] 
+        [ rack_aware ]
+        [ rack_id <node rack ID> ]
+        [ license_file <file> ]
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ register_dns_suffix ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP.address> ]
+        [ external_addr <IP.address.1> [<IP.address.2> ... <IP.address.N>] ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| addr | IP address | The node's internal IP address (optional) |
+| ccs_persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the location of CCS snapshots (optional) |
+| ephemeral_path | filepath (default:&nbsp;/var/opt/redislabs) | Path to the ephemeral storage location (optional) |
+| external_addr | list of IP addresses | A space-delimited list of the node's external IP addresses (optional) |
+| flash_enabled | | Enables flash storage (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location (optional) |
+| license_file | filepath | Path to the RLEC license file (optional) |
+| name | string | Cluster name |
+| node_uid | integer | Unique node ID (optional) |
+| password | string | Admin user's password |
+| persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the persistent storage location (optional) |
+| rack_aware | | Activates or deactivates rack awareness (optional) |
+| rack_id | string | The rack's unique identifier (optional) |
+| register_dns_suffix | | Enables database mapping to both internal and external IP addresses (optional) |
+| username | email address | Admin user's email address |
+
+### Returns
+
+Returns `ok` if the new cluster was created successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster create name cluster.local \
+        username admin@example.com \
+        password admin-password
+Creating a new cluster... ok
+```
+---
+Title: rladmin cluster running_actions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Lists all active tasks.
+headerRange: '[1-2]'
+linkTitle: running_actions
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/running_actions/'
+---
+
+Lists all active tasks running on the cluster.
+
+```sh
+rladmin cluster running_actions
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns details about any active tasks running on the cluster. 
+
+### Example
+
+```sh
+$ rladmin cluster running_actions
+Got 1 tasks:
+1) Task: maintenance_on (ce391d81-8d51-4ce2-8f63-729c7ac2589e) Node: 1 Status: running
+```
+---
+Title: rladmin cluster debug_info
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates a support package.
+headerRange: '[1-2]'
+linkTitle: debug_info
+tags:
+- configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/debug_info/'
+---
+
+Downloads a support package to the specified path. If you do not specify a path, it downloads the package to the default path specified in the cluster configuration file.
+
+```sh
+rladmin cluster debug_info
+        [ node <ID> ]
+        [ path <path> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node | integer | Downloads a support package for the specified node |
+| path | filepath | Specifies the location where the support package should download |
+
+### Returns
+
+Reports the progress of the support package download.
+
+### Example
+
+```sh
+$ rladmin cluster debug_info node 1
+Preparing the debug info files package
+Downloading...
+[==================================================]
+Downloading complete. File /tmp/debuginfo.20220511-215637.node-1.tar.gz is saved.
+```
+---
+Title: rladmin cluster join
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Adds a node to an existing cluster.
+headerRange: '[1-2]'
+linkTitle: join
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/join/'
+---
+
+Adds a node to an existing cluster.
+
+```sh
+rladmin cluster join
+        nodes <node IP address>
+        username <admin user email>
+        password <admin password>
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ rack_id <node rack ID> ]
+        [ override_rack_id ]
+        [ replace_node <node UID> ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP.address> ]
+        [ external_addr <IP.address.1> [<IP.address.2> ... <IP.address.N>] ]
+        [ override_repair ]
+        [ accept_servers { enabled | disabled } ]
+        [ cnm_http_port <port> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| accept_servers | 'enabled'<br />'disabled' | Allows allocation of resources on the new node when enabled (optional) |
+| addr | IP address | Sets a node's internal IP address. If not provided, the node sets the address automatically. (optional) |
+| ccs_persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the CCS snapshot location (the default is the same as persistent_path) (optional) |
+| cnm_http_port | integer | Joins a cluster that has a non-default cnm_http_port (optional) |
+| ephemeral_path | filepath | Path to the ephemeral storage location (optional) |
+| external_addr | list of IP addresses | Sets a node's external IP addresses (space-delimited list). If not provided, the node sets the address automatically. (optional) |
+| flash_enabled |  | Enables flash capabilities for a database (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location in case the node does not support CAPI (required if flash_enabled) |
+| nodes | IP address | Internal IP address of an existing node in the cluster |
+| override_rack_id |  | Changes to a new rack, specified by `rack_id` (optional) |
+| override_repair |  | Enables joining a cluster with a dead node (optional) |
+| password | string | Admin user's password |
+| persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the persistent storage location (optional) |
+| rack_id | string | Moves the node to the specified rack (optional) |
+| replace_node | integer | Replaces the specified node with the new node (optional) |
+| username | email address | Admin user's email address |
+
+### Returns
+
+Returns `ok` if the node joined the cluster successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster join nodes 192.0.2.2 \
+        username admin@example.com \
+        password admin-password
+Joining cluster... ok
+```
+---
+Title: rladmin cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage cluster.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: cluster
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/cluster/'
+---
+
+Manages cluster configuration and administration. Most `rladmin cluster` commands are only for clusters that are already configured, while a few others are only for new clusters that have not been configured.
+
+## Commands for configured clusters
+
+{{<table-children columnNames="Command,Description" columnSources="linkTitle,Description" enableLinks="linkTitle" limitTags="configured">}}
+
+## Commands for non-configured clusters
+
+{{<table-children columnNames="Command,Description" columnSources="linkTitle,Description" enableLinks="linkTitle" limitTags="non-configured">}}
+---
+Title: rladmin bind
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages the proxy policy for a specified database endpoint.
+headerRange: '[1-2]'
+linkTitle: bind
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/bind/'
+---
+
+Manages the proxy policy for a specific database endpoint.
+
+## `bind endpoint exclude`
+
+Defines a list of nodes to exclude from the proxy policy for a specific database endpoint. When you exclude a node, the endpoint cannot bind to the node's proxy.
+
+Each time you run an exclude command, it overwrites the previous list of excluded nodes.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id> exclude
+        <proxy_id1 .. proxy_idN>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| proxy     | list of proxy IDs          | Proxies to exclude                                                           |
+
+### Returns
+
+Returns `Finished successfully` if the list of excluded proxies was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                  NODE      ROLE                      SSL
+db:6     tr02   endpoint:6:1        node:2    all-nodes                 No
+db:6     tr02   endpoint:6:1        node:1    all-nodes                 No
+db:6     tr02   endpoint:6:1        node:3    all-nodes                 No
+$ rladmin bind endpoint 6:1 exclude 2
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:1    all-nodes -2               No
+db:6     tr02   endpoint:6:1       node:3    all-nodes -2               No
+```
+
+## `bind endpoint include`
+
+Defines a list of nodes to include in the proxy policy for the specific database endpoint.
+
+Each time you run an include command, it overwrites the previous list of included nodes.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id> include
+        <proxy_id1 .. proxy_idN>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| proxy     | list of proxy IDs          | Proxies to include                                                           |
+
+### Returns
+
+Returns `Finished successfully` if the list of included proxies was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No
+$ rladmin bind endpoint 6:1 include 3
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID   NAME   ID                NODE      ROLE                          SSL
+db:6    tr02   endpoint:6:1      node:1    all-master-shards +3          No
+db:6    tr02   endpoint:6:1      node:3    all-master-shards +3          No
+```
+
+## `bind endpoint policy`
+
+Changes the overall proxy policy for a specific database endpoint.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id>
+        policy { single | all-master-shards | all-nodes }
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| policy    | <nobr>'all-master-shards'</nobr><br /> <nobr>'all-nodes'</nobr><br /> 'single' | Changes the [proxy policy](#proxy-policies) to the specified policy |
+
+| Proxy&nbsp;policy<a name="proxy-policies"> | Description |
+| - | - |
+| all-master-shards | Multiple proxies, one on each master node (best for high traffic and multiple master shards)                     |
+| all-nodes | Multiple proxies, one on each node of the cluster (increases traffic in the cluster, only used in special cases) |
+| single | All traffic flows through a single proxy bound to the database endpoint (preferable in most cases)               |
+
+### Returns
+
+Returns `Finished successfully` if the proxy policy was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:1    all-nodes -2               No
+db:6     tr02   endpoint:6:1       node:3    all-nodes -2               No
+$ rladmin bind endpoint 6:1 policy all-master-shards
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No
+```
+---
+Title: rladmin restart
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Restarts Redis Enterprise Software processes for a specific database.
+headerRange: '[1-2]'
+linkTitle: restart
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/restart/'
+---
+
+Schedules a restart of the Redis Enterprise Software processes on primary and replica instances of a specific database.
+
+``` sh
+rladmin restart db { db:<id> | <name> }
+        [preserve_roles]
+        [discard_data]
+        [force_discard]
+```
+
+### Parameters
+
+| Parameter      | Type/Value                     | Description                                                           |
+|----------------|--------------------------------|-----------------------------------------------------------------------|
+| db             | db:\<id\><br /> name           | Restarts Redis Enterprise Software processes for the specified database                |
+| discard_data   |                                | Allows discarding data if there is no persistence or replication      |
+| force_discard  |                                | Forcibly discards data even if there is persistence or replication    |
+| preserve_roles |                                | Performs an additional failover to maintain shard roles               |
+
+### Returns
+
+Returns `Done` if the restart completed successfully. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin restart db db:5 preserve_roles
+Monitoring 1db07491-35da-4bb6-9bc1-56949f4c312a
+active - SMUpgradeBDB init
+active - SMUpgradeBDB stop_forwarding
+active - SMUpgradeBDB stop_active_expire
+active - SMUpgradeBDB check_slave
+oactive - SMUpgradeBDB stop_active_expire
+active - SMUpgradeBDB second_failover
+completed - SMUpgradeBDB
+Done
+```
+---
+Title: rladmin migrate
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Moves Redis Enterprise Software shards or endpoints to a new node in
+  the same cluster.
+headerRange: '[1-2]'
+linkTitle: migrate
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/migrate/'
+---
+
+Moves Redis Enterprise shards or endpoints to a new node in the same cluster.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/7.4/databases/migrate-shards">}}).
+
+## `migrate all_master_shards`
+
+Moves all primary shards of a specified database or node to a new node in the same cluster.
+
+```sh
+rladmin migrate { db { db:<id> | <name> } | node <origin node ID> }
+        all_master_shards
+        target_node <id>
+        [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:6 sort ROLE
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:6   tr02       redis:14   node:3  master  0-4095        3.01MB        OK     
+db:6   tr02       redis:16   node:3  master  4096-8191     3.2MB         OK     
+db:6   tr02       redis:18   node:3  master  8192-12287    3.2MB         OK     
+db:6   tr02       redis:20   node:3  master  12288-16383   3.01MB        OK
+$ rladmin migrate db db:6 all_master_shards target_node 1
+Monitoring 8b0f28e2-4342-427a-a8e3-a68cba653ffe
+queued - migrate_shards
+running - migrate_shards
+Executing migrate_redis with shards_uids ['18', '14', '20', '16']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards node 1
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:6   tr02       redis:14   node:1  master  0-4095        3.22MB        OK     
+db:6   tr02       redis:16   node:1  master  4096-8191     3.22MB        OK     
+db:6   tr02       redis:18   node:1  master  8192-12287    3.22MB        OK     
+db:6   tr02       redis:20   node:1  master  12288-16383   2.99MB        OK  
+```
+## `migrate all_shards`
+
+Moves all shards on a specified node to a new node in the same cluster.
+
+``` sh
+rladmin migrate node <origin node ID>
+            [ max_concurrent_bdb_migrations <value> ]
+            all_shards
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| max_concurrent_bdb_migrations | integer                | Sets the maximum number of concurrent endpoint migrations                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards node 1
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:5   tr01       redis:12   node:1  master  0-16383       3.04MB        OK
+db:6   tr02       redis:15   node:1  slave   0-4095        2.93MB        OK
+db:6   tr02       redis:17   node:1  slave   4096-8191     2.93MB        OK
+db:6   tr02       redis:19   node:1  slave   8192-12287    3.08MB        OK
+db:6   tr02       redis:21   node:1  slave   12288-16383   3.08MB        OK
+$ rladmin migrate node 1 all_shards target_node 2
+Monitoring 71a4f371-9264-4398-a454-ce3ff4858c09
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['21', '15', '17', '19']
+OExecuting migrate_redis with shards_uids ['12']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards node 2
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:5   tr01       redis:12   node:2  master  0-16383       3.14MB        OK
+db:6   tr02       redis:15   node:2  slave   0-4095        2.96MB        OK
+db:6   tr02       redis:17   node:2  slave   4096-8191     2.96MB        OK
+db:6   tr02       redis:19   node:2  slave   8192-12287    2.96MB        OK
+db:6   tr02       redis:21   node:2  slave   12288-16383   2.96MB        OK
+```
+
+## `migrate all_slave_shards`
+
+Moves all replica shards of a specified database or node to a new node in the same cluster.
+
+```sh
+rladmin migrate { db { db:<id> | <name> } | node <origin node ID> }
+            all_slave_shards
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:6 node 2
+SHARDS:
+DB:ID  NAME      ID         NODE    ROLE   SLOTS          USED_MEMORY    STATUS
+db:6   tr02      redis:15   node:2  slave  0-4095         3.06MB         OK
+db:6   tr02      redis:17   node:2  slave  4096-8191      3.06MB         OK
+db:6   tr02      redis:19   node:2  slave  8192-12287     3.06MB         OK
+db:6   tr02      redis:21   node:2  slave  12288-16383    3.06MB         OK
+$ rladmin migrate db db:6 all_slave_shards target_node 3
+Monitoring 5d36a98c-3dc8-435f-8ed9-35809ba017a4
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['15', '17', '21', '19']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards db db:6 node 3
+SHARDS:
+DB:ID  NAME      ID         NODE    ROLE   SLOTS          USED_MEMORY    STATUS
+db:6   tr02      redis:15   node:3  slave  0-4095         3.04MB         OK
+db:6   tr02      redis:17   node:3  slave  4096-8191      3.04MB         OK
+db:6   tr02      redis:19   node:3  slave  8192-12287     3.04MB         OK
+db:6   tr02      redis:21   node:3  slave  12288-16383    3.04MB         OK
+```
+
+## `migrate endpoint_to_shards`
+
+Moves database endpoints to the node where the majority of primary shards are located.
+
+```sh
+rladmin migrate [ db { db:<id> | <name> } ]
+            endpoint_to_shards
+            [ restrict_target_node <id> ]
+            [ commit ]
+            [ max_concurrent_bdb_migrations <value> ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| restrict_target_node          | integer | Moves the endpoint only if the target node matches the specified node |
+| commit                        |                        | Performs endpoint movement                                                      |
+| max_concurrent_bdb_migrations | integer                | Sets the maximum number of concurrent endpoint migrations                           |
+
+
+### Returns
+
+Returns a list of steps to perform the migration. If the `commit` flag is set, the steps will run and return `Finished successfully` if they were completed. Otherwise, returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the endpoints were moved.
+
+### Example
+
+```sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL     
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No      
+$ rladmin migrate db db:6 endpoint_to_shards
+* Going to bind endpoint:6:1 to node 1
+Dry-run completed, add 'commit' argument to execute
+$ rladmin migrate db db:6 endpoint_to_shards commit
+* Going to bind endpoint:6:1 to node 1
+Executing bind endpoint:6:1: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL     
+db:6     tr02   endpoint:6:1       node:1    all-master-shards          No      
+```
+
+## `migrate shard`
+
+Moves one or more shards to a new node in the same cluster.
+
+```sh
+rladmin migrate shard <id1.. idN>
+            [ preserve_roles ]
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| shard                         | list of shard IDs      | Shards to migrate                                                               |
+| preserve_roles                |                        | Performs an additional failover to guarantee the primary shards' roles are preserved |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:5
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:2   master   0-16383   3.01MB         OK
+db:5   tr01        redis:13   node:3   slave    0-16383   3.1MB          OK
+$ rladmin migrate shard 13 target_node 1
+Monitoring d2637eea-9504-4e94-a70c-76df087efcb2
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['13']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards db db:5
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:2   master   0-16383   3.01MB         OK
+db:5   tr01        redis:13   node:1   slave    0-16383   3.04MB         OK
+```
+---
+Title: rladmin recover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Recovers databases in recovery mode.
+headerRange: '[1-2]'
+linkTitle: recover
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/recover/'
+---
+
+Recovers databases in recovery mode after events such as cluster failure, and restores the databases' configurations and data from stored persistence files. See [Recover a failed database]({{< relref "/operate/rs/7.4/databases/recover" >}}) for detailed instructions.
+
+Database persistence files are stored in `/var/opt/redislabs/persist/redis/` by default, but you can specify a different directory to use for database recovery with [`rladmin node <id> recovery_path set <path>`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/node/recovery-path" >}}).
+
+## `recover all`
+
+Recovers all databases in recovery mode.
+
+```sh
+rladmin recover all
+        [ only_configuration ]
+```
+
+### Parameters
+
+| Parameters         | Type/Value | Description                                 |
+|--------------------|------------|---------------------------------------------|
+| only_configuration |            | Recover database configuration without data |
+
+### Returns
+
+Returns `Completed successfully` if the database was recovered. Otherwise, returns an error.
+
+### Example
+
+```
+$ rladmin recover all
+  0% [ 0 recovered | 0 failed ] |         | Elapsed Time: 0:00:00[first-db (db:1) recovery] Initiated.[second-db (db:2) recovery] Initiated.
+ 50% [ 0 recovered | 0 failed ] |###      | Elapsed Time: 0:00:04[first-db (db:1) recovery] Completed successfully
+ 75% [ 1 recovered | 0 failed ] |######   | Elapsed Time: 0:00:06[second-db (db:2) recovery] Completed successfully
+100% [ 2 recovered | 0 failed ] |#########| Elapsed Time: 0:00:08
+```
+
+## `recover db`
+
+Recovers a specific database in recovery mode.
+
+```sh
+rladmin recover db { db:<id> | <name> }
+        [ only_configuration ]
+```
+
+### Parameters
+
+| Parameters         | Type/Value           | Description                                 |
+|--------------------|----------------------|---------------------------------------------|
+| db                 | db:\<id\> <br />name | Database to recover                         |
+| only_configuration |                      | Recover database configuration without data |
+
+### Returns
+
+Returns `Completed successfully` if the database was recovered. Otherwise, returns an error.
+
+### Example
+
+```
+$ rladmin recover db db:1
+  0% [ 0 recovered | 0 failed ] |      | Elapsed Time: 0:00:00[demo-db (db:1) recovery] Initiated.
+ 50% [ 0 recovered | 0 failed ] |###   | Elapsed Time: 0:00:00[demo-db (db:1) recovery] Completed successfully
+100% [ 1 recovered | 0 failed ] |######| Elapsed Time: 0:00:02
+```
+
+## `recover list`
+
+Shows a list of all databases that are currently in recovery mode.
+
+```sh
+rladmin recover list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Displays a list of all recoverable databases. If no databases are in recovery mode, returns `No recoverable databases found`.
+
+### Example
+
+```sh
+$ rladmin recover list
+DATABASES IN RECOVERY STATE:
+DB:ID  NAME  TYPE   SHARDS  REPLICATION  PERSISTENCE  STATUS
+db:5   tr01  redis  1       enabled      aof          missing-files
+db:6   tr02  redis  4       enabled      snapshot     ready
+```
+
+## `recover s3_import`
+
+Imports current database snapshot files from an AWS S3 bucket to a directory on the node.
+
+```sh
+rladmin recover s3_import
+                s3_bucket <bucket name>
+                [ s3_prefix <prefix> ]
+                s3_access_key_id <access key>
+                s3_secret_access_key <secret access key>
+                import_path <path>
+```
+
+### Parameters
+
+| Parameters           | Type/Value | Description                                                      |
+|----------------------|------------|------------------------------------------------------------------|
+| s3_bucket            | string     | S3 bucket name                                                   |
+| s3_prefix            | string     | S3 object prefix                                                 |
+| s3_access_key_id     | string     | S3 access key ID                                                 |
+| s3_secret_access_key | string     | S3 secret access key                                             |
+| import_path           | filepath   | Local import path where all database snapshots will be imported  |
+
+### Returns
+
+Returns `Completed successfully` if the database files were imported. Otherwise, returns an error.
+
+### Example
+
+```sh
+rladmin recover s3_import s3_bucket <bucket-name> s3_prefix <s3-prefix>/ s3_access_key_id <access-key> s3_secret_access_key <secret-access-key> import_path /tmp
+```
+---
+Title: rladmin status
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Displays the current cluster status and topology information.
+headerRange: '[1-2]'
+linkTitle: status
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/status/'
+---
+
+Displays the current cluster status and topology information.
+
+## `status`
+
+Displays the current status of all nodes, databases, database endpoints, and shards on the cluster.
+
+``` sh
+rladmin status
+        [ extra <parameter> ]
+        [ issues_only]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| issues_only | Filters out all items that have an `OK` status  |
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all databases in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns tables of the status of all nodes, databases, and database endpoints on the cluster.
+
+If `issues_only` is specified, it only shows instances that do not have an `OK` status.
+
+### Example
+
+``` sh
+$ rladmin status extra all
+CLUSTER:
+OK. Cluster master: 1 (198.51.100.2)
+Cluster health: OK, [1, 0.13333333333333333, 0.03333333333333333]
+failures/minute - avg1 1.00, avg15 0.13, avg60 0.03.
+
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS      EXTERNAL_ADDRESS HOSTNAME     MASTERS SLAVES OVERBOOKING_DEPTH SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   SHA    RACK-ID STATUS
+node:1  master 198.51.100.2                  3d99db1fdf4b 4       0      10.91GB           4/100  6     14.91GB/19.54GB 10.91GB/16.02GB 6.2.12-37 5c2106 -       OK    
+node:2  slave  198.51.100.3                  fc7a3d332458 0       0      11.4GB            0/100  6     14.91GB/19.54GB 11.4GB/16.02GB  6.2.12-37 5c2106 -       OK    
+*node:3 slave  198.51.100.4                  b87cc06c830f 0       0      11.4GB            0/100  6     14.91GB/19.54GB 11.4GB/16.02GB  6.2.12-37 5c2106 -       OK    
+
+DATABASES:
+DB:ID NAME      TYPE  STATUS SHARDS PLACEMENT REPLICATION PERSISTENCE ENDPOINT                        EXEC_STATE EXEC_STATE_MACHINE BACKUP_PROGRESS MISSING_BACKUP_TIME REDIS_VERSION
+db:3  database3 redis active 4      dense     disabled    disabled    redis-11103.cluster.local:11103 N/A        N/A                N/A             N/A                 6.0.16       
+
+ENDPOINTS:
+DB:ID     NAME             ID                    NODE       ROLE       SSL        WATCHDOG_STATUS          
+db:3      database3        endpoint:3:1          node:1     single     No         OK                       
+
+SHARDS:
+DB:ID NAME      ID      NODE   ROLE   SLOTS       USED_MEMORY BACKUP_PROGRESS RAM_FRAG WATCHDOG_STATUS STATUS
+db:3  database3 redis:4 node:1 master 0-4095      2.08MB      N/A             4.73MB   OK              OK    
+db:3  database3 redis:5 node:1 master 4096-8191   2.08MB      N/A             4.62MB   OK              OK    
+db:3  database3 redis:6 node:1 master 8192-12287  2.08MB      N/A             4.59MB   OK              OK    
+db:3  database3 redis:7 node:1 master 12288-16383 2.08MB      N/A             4.66MB   OK              OK
+```
+
+## `status databases`
+
+Displays the current status of all databases on the cluster.
+
+``` sh
+rladmin status databases
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all databases in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns a table of the status of all databases on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows databases that do not have an `OK` status.
+
+### Example
+
+``` sh
+$ rladmin status databases sort REPLICATION PERSISTENCE
+DB:ID NAME      TYPE  STATUS SHARDS PLACEMENT REPLICATION PERSISTENCE ENDPOINT                                       
+db:1  database1 redis active 1      dense     disabled    disabled    redis-10269.testdbd11169.localhost:10269
+db:2  database2 redis active 1      dense     disabled    snapshot    redis-13897.testdbd11169.localhost:13897
+db:3  database3 redis active 1      dense     enabled     snapshot    redis-19416.testdbd13186.localhost:19416
+```
+
+## `status endpoints`
+
+Displays the current status of all endpoints on the cluster.
+
+``` sh
+rladmin status endpoints
+        [ node <id> ]
+        [ db { db:<id> | <name> } ]
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| node \<id\> | Only show endpoints for the specified node ID |
+| db db:\<id\> | Only show endpoints for the specified database ID |
+| db \<name\> | Only show endpoints for the specified database name |
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all endpoints in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns a table of the status of all endpoints on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows endpoints that do not have an `OK` status.
+
+### Example
+
+``` sh
+$ rladmin status endpoints
+DB:ID     NAME             ID                    NODE        ROLE        SSL    
+db:1      database1        endpoint:1:1          node:1      single      No     
+db:2      database2        endpoint:2:1          node:2      single      No     
+db:3      database3        endpoint:3:1          node:3      single      No
+```
+
+## `status modules`
+
+Displays the current status of modules installed on the cluster and modules used by databases. This information is not included in the combined status report returned by [`rladmin status`](#status).
+
+``` sh
+rladmin status modules
+        [ db { db:<id1> | <name1> } ... { db:<idN> | <nameN> } ]
+        [ extra { all | min_redis_version | module_id } ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| db db:\<id\> | Provide a list of database IDs to show only modules used by the specified databases<br />(for example: `rladmin status modules db db:1 db:2`) |
+| db \<name\> | Provide a list of database names to show only modules used by the specified databases<br />(for example: `rladmin status modules db name1 name2`) |
+| extra all | Shows all extra information |
+| extra module_id | Shows module IDs |
+| extra&nbsp;min_redis_version | Shows the minimum compatible Redis database version for each module |
+
+### Returns
+
+Returns the status of modules installed on the cluster and modules used by databases.
+
+### Example
+
+```sh
+$ rladmin status modules extra all                
+CLUSTER MODULES:
+MODULE           VERSION   MIN_REDIS_VERSION  ID                                
+RedisBloom       2.4.5     6.0                1b895a180592cbcae5bd3bff6af24be2  
+RedisBloom       2.6.8     7.1                95264e7c9ac9540268c115c86a94659b  
+RediSearch 2     2.6.12    6.0                2c000539f65272f7a2712ed3662c2b6b  
+RediSearch 2     2.8.9     7.1                dd9a75710db528afa691767e9310ac6f  
+RedisGears       2.0.15    7.1                18c83d024b8ee22e7caf030862026ca6  
+RedisGraph       2.10.12   6.0                5a1f2fdedb8f6ca18f81371ea8d28f68  
+RedisJSON        2.4.7     6.0                28308b101a0203c21fa460e7eeb9344a  
+RedisJSON        2.6.8     7.1                b631b6a863edde1b53b2f7a27a49c004  
+RedisTimeSeries  1.8.11    6.0                8fe09b00f56afe5dba160d234a6606af  
+RedisTimeSeries  1.10.9    7.1                98a492a017ea6669a162fd3503bf31f3  
+
+DATABASE MODULES:
+DB:ID      NAME             MODULE            VERSION  ARGS              STATUS 
+db:1       search-json-db   RediSearch 2      2.8.9    PARTITIONS AUTO   OK     
+db:1       search-json-db   RedisJSON         2.6.8                      OK     
+db:2       timeseries-db    RedisTimeSeries   1.10.9                     OK      
+```
+
+## `status nodes`
+
+Displays the current status of all nodes on the cluster.
+
+``` sh
+rladmin status nodes
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all nodes in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns a table of the status of all nodes on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows nodes that do not have an `OK` status.
+
+### Example
+
+``` sh
+$ rladmin status nodes sort PROVISIONAL_RAM HOSTNAME
+CLUSTER NODES:
+NODE:ID     ROLE       ADDRESS          EXTERNAL_ADDRESS          HOSTNAME            SHARDS     CORES          FREE_RAM                 PROVISIONAL_RAM          VERSION        STATUS   
+node:1      master     198.51.100.2                                 3d99db1fdf4b        4/100      6              14.74GB/19.54GB          10.73GB/16.02GB          6.2.12-37      OK       
+*node:3     slave      198.51.100.4                                 b87cc06c830f        0/100      6              14.74GB/19.54GB          11.22GB/16.02GB          6.2.12-37      OK       
+node:2      slave      198.51.100.3                                 fc7a3d332458        0/100      6              14.74GB/19.54GB          11.22GB/16.02GB          6.2.12-37      OK       
+```
+
+## `status shards`
+
+Displays the current status of all shards on the cluster.
+
+``` sh
+rladmin status shards
+        [ node <id> ]
+        [ db {db:<id> | <name>} ]
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| node \<id\> | Only show shards for the specified node ID |
+| db db:\<id\> | Only show shards for the specified database ID |
+| db \<name\> | Only show shards for the specified database name |
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra shardstats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all shards in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns a table of the status of all shards on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows shards that do not have an `OK` status.
+
+### Example
+
+``` sh
+$ rladmin status shards sort USED_MEMORY ID
+SHARDS:
+DB:ID               NAME                       ID                   NODE               ROLE               SLOTS                           USED_MEMORY                     STATUS          
+db:3                database3                  redis:6              node:1             master             8192-12287                      2.04MB                          OK              
+db:3                database3                  redis:4              node:1             master             0-4095                          2.08MB                          OK              
+db:3                database3                  redis:5              node:1             master             4096-8191                       2.08MB                          OK              
+db:3                database3                  redis:7              node:1             master             12288-16383                     2.08MB                          OK              
+```
+---
+Title: rladmin verify
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prints verification reports for the cluster.
+headerRange: '[1-2]'
+linkTitle: verify
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/verify/'
+---
+
+Prints verification reports for the cluster.
+
+## `verify balance`
+
+Prints a balance report that displays all of the unbalanced endpoints or nodes in the cluster.
+
+```sh
+rladmin verify balance [ node <ID> ]
+```
+
+The [proxy policy]({{< relref "/operate/rs/7.4/databases/configure/proxy-policy#proxy-policies" >}}) determines which nodes or endpoints to report as unbalanced.
+
+A node is unbalanced if:
+- `all-nodes` proxy policy and the node has no endpoint
+
+An endpoint is unbalanced in the following cases:
+- `single` proxy policy and one of the following is true:  
+    - Shard placement is [`sparse`]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy.md#sparse-shard-placement-policy" >}}) and none of the master shards are on the node
+    - Shard placement is [`dense`]({{< relref "/operate/rs/7.4/databases/memory-performance/shard-placement-policy.md#dense-shard-placement-policy" >}}) and some master shards are on a different node from the endpoint
+- `all-master-shards` proxy policy and one of the following is true:  
+    - None of the master shards are on the node
+    - Some master shards are on a different node from the endpoint
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node | integer | Specify a node ID to return a balance table for that node only (optional) |
+
+### Returns
+
+Returns a table of unbalanced endpoints and nodes in the cluster.
+
+### Examples
+
+Verify all nodes:
+
+```sh
+$ rladmin verify balance       
+The table presents all of the unbalanced endpoints/nodes in the cluster
+BALANCE:
+NODE:ID  DB:ID  NAME  ENDPOINT:ID  PROXY_POLICY  LOCAL SHARDS   TOTAL SHARDS
+```
+
+Verify a specific node:
+
+```sh
+$ rladmin verify balance node 1
+The table presents all of the unbalanced endpoints/nodes in the cluster
+BALANCE:
+NODE:ID  DB:ID  NAME  ENDPOINT:ID  PROXY_POLICY  LOCAL SHARDS   TOTAL SHARDS
+```
+
+## `verify rack_aware`
+
+Verifies that the cluster complies with the rack awareness policy and reports any discovered rack collisions, if [rack-zone awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness" >}}) is enabled.
+
+```sh
+rladmin verify rack_aware
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns whether the cluster is rack aware. If rack awareness is enabled, it returns any rack collisions.
+
+### Example
+
+```sh
+$ rladmin verify rack_aware
+
+Cluster policy is not configured for rack awareness.
+```
+---
+Title: rladmin placement
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures the shard placement policy for a database.
+headerRange: '[1-2]'
+linkTitle: placement
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/placement/'
+---
+
+Configures the shard placement policy for a specified database.
+
+``` sh
+rladmin placement
+        db { db:<id> | <name> }
+        { dense | sparse }
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Configures shard placement for the specified database                                         |
+| dense     |                                | Places new shards on the same node as long as it has resources                                |
+| sparse    |                                | Places new shards on the maximum number of available nodes within the cluster                 |
+
+### Returns
+
+Returns the new shard placement policy if the policy was changed successfully. Otherwise, it returns an error.
+
+Use [`rladmin status databases`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-databases" >}}) to verify that the failover completed.
+
+### Example
+
+``` sh
+$ rladmin status databases
+DATABASES:
+DB:ID  NAME       TYPE   STATUS   SHARDS   PLACEMENT    REPLICATION    PERSISTENCE    ENDPOINT                                
+db:5   tr01       redis  active   1        dense        enabled        aof            redis-12000.cluster.local:12000         
+$ rladmin placement db db:5 sparse
+Shards placement policy is now sparse
+$ rladmin status databases
+DATABASES:
+DB:ID  NAME       TYPE   STATUS   SHARDS   PLACEMENT    REPLICATION    PERSISTENCE    ENDPOINT                                
+db:5   tr01       redis  active   1        sparse       enabled        aof            redis-12000.cluster.local:12000         
+```
+---
+Title: rladmin info
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the current configuration of a cluster, database, node, or proxy.
+headerRange: '[1-2]'
+linkTitle: info
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/info/'
+---
+
+Shows the current configuration of specified databases, proxies, clusters, or nodes.
+
+## `info cluster`
+
+Lists the current configuration for the cluster.
+
+```sh
+rladmin info cluster
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the current configuration for the cluster.
+
+### Example
+
+``` sh
+$ rladmin info cluster
+Cluster configuration:
+    repl_diskless: enabled
+    shards_overbooking: disabled
+    default_non_sharded_proxy_policy: single
+    default_sharded_proxy_policy: single
+    default_shards_placement: dense
+    default_fork_evict_ram: enabled
+    default_provisioned_redis_version: 6.0
+    redis_migrate_node_threshold: 0KB (0 bytes)
+    redis_migrate_node_threshold_percent: 4 (%)
+    redis_provision_node_threshold: 0KB (0 bytes)
+    redis_provision_node_threshold_percent: 12 (%)
+    max_simultaneous_backups: 4
+    slave_ha: enabled
+    slave_ha_grace_period: 600
+    slave_ha_cooldown_period: 3600
+    slave_ha_bdb_cooldown_period: 7200
+    parallel_shards_upgrade: 0
+    show_internals: disabled
+    expose_hostnames_for_all_suffixes: disabled
+    login_lockout_threshold: 5
+    login_lockout_duration: 1800
+    login_lockout_counter_reset_after: 900
+    default_concurrent_restore_actions: 10
+    endpoint_rebind_propagation_grace_time: 15
+    data_internode_encryption: disabled
+    redis_upgrade_policy: major
+    db_conns_auditing: disabled
+    watchdog profile: local-network
+    http support: enabled
+    upgrade mode: disabled
+    cm_session_timeout_minutes: 15
+    cm_port: 8443
+    cnm_http_port: 8080
+    cnm_https_port: 9443
+    bigstore_driver: speedb
+```
+
+## `info db`
+
+Shows the current configuration for databases.
+
+```sh
+rladmin info db [ {db:<id> | <name>} ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| db:id     | ID of the specified database (optional) |
+| name      | Name of the specified database (optional) |
+
+### Returns
+
+Returns the current configuration for all databases.
+
+If `db:<id>` or `<name>` is specified, returns the current configuration for the specified database.
+
+### Example
+
+``` sh
+$ rladmin info db db:1
+db:1 [database1]:
+    client_buffer_limits: 1GB (hard limit)/512MB (soft limit) in 30 seconds
+    slave_buffer: auto
+    pubsub_buffer_limits: 32MB (hard limit)/8MB (soft limit) in 60 seconds
+    proxy_client_buffer_limits: 0KB (hard limit)/0KB (soft limit) in 0 seconds
+    proxy_slave_buffer_limits: 1GB (hard limit)/512MB (soft limit) in 60 seconds
+    proxy_pubsub_buffer_limits: 32MB (hard limit)/8MB (soft limit) in 60 seconds
+    repl_backlog: 1.02MB (1073741 bytes)
+    repl_timeout: 360 seconds
+    repl_diskless: default
+    master_persistence: disabled
+    maxclients: 10000
+    conns: 5
+    conns_type: per-thread
+    sched_policy: cmp
+    max_aof_file_size: 300GB
+    max_aof_load_time: 3600 seconds
+    dedicated_replicaof_threads: 5
+    max_client_pipeline: 200
+    max_shard_pipeline: 2000
+    max_connections: 0
+    oss_cluster: disabled
+    oss_cluster_api_preferred_ip_type: internal
+    gradual_src_mode: disabled
+    gradual_src_max_sources: 1
+    gradual_sync_mode: auto
+    gradual_sync_max_shards_per_source: 1
+    slave_ha: disabled (database)
+    mkms: enabled
+    oss_sharding: disabled
+    mtls_allow_weak_hashing: disabled
+    mtls_allow_outdated_certs: disabled
+    data_internode_encryption: disabled
+    proxy_policy: single
+    db_conns_auditing: disabled
+    syncer_mode: centralized
+```
+
+## `info node`
+
+Lists the current configuration for all nodes.
+
+```sh
+rladmin info node [ <id> ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| id     | ID of the specified node |
+
+### Returns
+
+Returns the current configuration for all nodes.
+
+If `<id>` is specified, returns the current configuration for the specified node.
+
+### Example
+
+``` sh
+$ rladmin info node 3
+Command Output: node:3
+    address: 198.51.100.17
+    external addresses: N/A
+    recovery path: N/A
+    quorum only: disabled
+    max redis servers: 100
+    max listeners: 100
+```
+
+## `info proxy`
+
+Lists the current configuration for a proxy.
+
+``` sh
+rladmin info proxy { <id> | all }
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| id      | ID of the specified proxy |
+| all       | Show the current configuration for all proxies (optional) |
+
+### Returns
+
+If no parameter is specified or the `all` option is specified, returns the current configuration for all proxies.
+
+If `<id>`is specified, returns the current configuration for the specified proxy.
+
+### Example
+
+``` sh
+$ rladmin info proxy
+proxy:1
+    mode: dynamic
+    scale_threshold: 80 (%)
+    scale_duration: 30 (seconds)
+    max_threads: 8
+    threads: 3
+```
+---
+Title: rladmin help
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows available commands or specific command usage.
+headerRange: '[1-2]'
+linkTitle: help
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/help/'
+---
+
+Lists all options and parameters for `rladmin` commands.
+
+``` sh
+rladmin help [command]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+|  command   |  Display help for this `rladmin` command (optional)  |
+
+### Returns
+
+Returns a list of available `rladmin` commands.
+
+If a `command` is specified, returns a list of all the options and parameters for that `rladmin` command.
+
+### Example
+
+```sh
+$ rladmin help
+usage: rladmin [options] [command] [command args]
+
+Options:
+  -y  Assume Yes for all required user confirmations.
+
+Commands:
+  bind      Bind an endpoint
+  cluster   Cluster management commands
+  exit      Exit admin shell
+  failover  Fail-over master to slave
+  help      Show available commands, or use help <command> for a specific command
+  info      Show information about tunable parameters
+  migrate   Migrate elements between nodes
+  node      Node management commands
+  placement Configure shards placement policy
+  recover   Recover databases
+  restart   Restart database shards
+  status    Show status information
+  suffix    Suffix management
+  tune      Tune system parameters
+  upgrade   Upgrade entity version
+  verify    Cluster verification reports
+
+Use "rladmin help [command]" to get more information on a specific command.
+```
+---
+Title: rladmin suffix
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages the DNS suffixes in the cluster.
+headerRange: '[1-2]'
+linkTitle: suffix
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/suffix/'
+---
+
+Manages the DNS suffixes in the cluster.
+
+## `suffix add`
+
+Adds a DNS suffix to the cluster.
+
+``` sh
+rladmin suffix add name <name>
+        [default]
+        [internal]
+        [mdns]
+        [use_aaaa_ns]
+        [slaves <ip>..]
+```
+
+### Parameters
+
+| Parameter | Type/Value       | Description                                                                                   |
+|-----------|------------------|-----------------------------------------------------------------------------------------------|
+| name      | string           | DNS suffix to add to the cluster                                                             |
+| default   |                  | Sets the given suffix as the default. If a default already exists, this overwrites it.  |
+| internal  |                  | Forces the given suffix to use private IPs                                                    |
+| mdns      |                  | Activates multicast DNS support for the given suffix                                           |
+| slaves    | list of IPv4 addresses | The given suffix will notify the frontend DNS servers when a change in the frontend DNS has occurred |
+| use_aaaa_ns |                | Activates IPv6 address support |
+
+### Returns
+
+Returns `Added suffixes successfully` if the suffix was added. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin suffix add name new.rediscluster.local
+Added suffixes successfully
+```
+
+## `suffix delete`
+
+Deletes an existing DNS suffix from the cluster.
+
+``` sh
+rladmin suffix delete name <name>
+```
+
+### Parameters
+
+| Parameter | Type/Value       | Description                                                                                   |
+|-----------|------------------|-----------------------------------------------------------------------------------------------|
+| name      | string           | DNS suffix to delete from the cluster                                                         |
+
+### Returns
+
+Returns `Suffix deleted successfully` if the suffix was deleted. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin suffix delete name new.rediscluster.local
+Suffix deleted successfully
+```
+
+## `suffix list`
+
+Lists the DNS suffixes in the cluster.
+
+```sh
+rladmin suffix list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns a list of the DNS suffixes.
+
+### Example
+
+``` sh
+$ rladmin suffix list
+List of all suffixes:
+cluster.local
+new.rediscluster.local
+```
+---
+Title: rladmin failover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Fail over primary shards of a database to their replicas.
+headerRange: '[1-2]'
+linkTitle: failover
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/failover/'
+---
+
+Fails over one or more primary (also known as master) shards of a database and promotes their respective replicas to primary shards.
+
+``` sh
+rladmin failover
+        [db { db:<id> | <name> }]
+        shard <id1 ... idN>
+        [immediate]
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Fail over shards for the specified database                                                   |
+| shard     | one or more primary shard IDs  | Primary shard or shards to fail over                                                          |
+| immediate |                                | Perform failover without verifying the replica shards are in full sync with the master shards |
+
+### Returns
+
+Returns `Finished successfully` if the failover completed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the failover completed.
+
+### Example
+
+``` sh
+$ rladmin status shards
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:1   slave    0-16383   3.02MB         OK     
+db:5   tr01        redis:13   node:2   master   0-16383   3.09MB         OK     
+$ rladmin failover shard 13
+Executing shard fail-over: OOO.
+Finished successfully
+$ rladmin status shards
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:1   master   0-16383   3.12MB         OK     
+db:5   tr01        redis:13   node:2   slave    0-16383   2.99MB         OK
+```
+---
+Title: rladmin upgrade
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrades the version of a module or Redis Enterprise Software for a database.
+headerRange: '[1-2]'
+linkTitle: upgrade
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/upgrade/'
+---
+
+Upgrades the version of a module or Redis Enterprise Software for a database.
+
+## `upgrade db`
+
+Schedules a restart of the primary and replica processes of a database and then upgrades the database to the latest version of Redis Enterprise Software.
+
+For more information, see [Upgrade an existing Redis Software Deployment]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading" >}}).
+
+```sh
+rladmin upgrade db { db:<id> | <name> }
+                [ preserve_roles ]
+                [ keep_redis_version ]
+                [ discard_data ]
+                [ force_discard ]
+                [ parallel_shards_upgrade ]
+                [ keep_crdt_protocol_version ]
+                [ redis_version <version> ]
+                [ force ]
+                [ { latest_with_modules | and module module_name <module name> version <version> module_args <arguments string> } ]
+```
+
+As of v6.2.4, the default behavior for `upgrade db` has changed.  It is now controlled by a new parameter that sets the default upgrade policy used to create new databases and to upgrade ones already in the cluster.  To learn more, see [`tune cluster default_redis_version`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}).
+
+### Parameters
+
+| Parameters                 | Type/Value               | Description                                                                                                            |
+|----------------------------|--------------------------|------------------------------------------------------------------------------------------------------------------------|
+| db                         | db:\<id\> <br />name     | Database to upgrade                                                                                                    |
+| and module | [upgrade module](#upgrade-module) command | Clause that allows the upgrade of a database and a specified Redis module in a single step with only one restart (can be specified multiple times)  |
+| discard_data               |                          | Indicates that data will not be saved after the upgrade                                                                |
+| force                      |                          | Forces upgrade and skips warnings and confirmations                                                                    |
+| force_discard              |                          | Forces `discard_data` if replication or persistence is enabled                                                   |
+| keep_crdt_protocol_version |                          | Keeps the current CRDT protocol version                                                                                |
+| keep_redis_version       |                          | Upgrades to a new patch release, not to the latest major.minor version                                                 |
+| latest_with_modules        |                          | Upgrades the Redis Enterprise Software version and all modules in the database                                                             |
+| parallel_shards_upgrade    | integer <br />'all'        | Maximum number of shards to upgrade all at once                                                                        |
+| preserve_roles             |                          | Performs an additional failover to guarantee the shards' roles are preserved                                             |
+| redis_version              | Redis version            | Upgrades the database to the specified version instead of the latest version                                               |
+
+### Returns
+
+Returns `Done` if the upgrade completed. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin upgrade db db:5
+Monitoring e39c8e87-75f9-4891-8c86-78cf151b720b
+active - SMUpgradeBDB init
+active - SMUpgradeBDB check_slaves
+.active - SMUpgradeBDB prepare
+active - SMUpgradeBDB stop_forwarding
+oactive - SMUpgradeBDB start_wd
+active - SMUpgradeBDB wait_for_version
+.completed - SMUpgradeBDB
+Done
+```
+
+## `upgrade module`
+
+Upgrades Redis modules in use by a specific database.
+
+For more information, see [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+```sh
+rladmin upgrade module
+        db_name { db:<id> | <name> }
+        module_name <mod_name>
+        version <version>
+        module_args <args_str>
+```
+
+### Parameters
+
+| Parameters                 | Type/Value               | Description                                                                                                            |
+|----------------------------|--------------------------|------------------------------------------------------------------------------------------------------------------------|
+| db_name                    | db:\<id\> <br />name     | Upgrade a module for the specified database                                                                                     |
+| module_name                | 'ReJSON'<br />'graph'<br />'search'<br />'bf'<br />'rg'<br />'timeseries' | Redis module to upgrade                                       |
+| version                    | module version number    | Upgrades the module to the specified version                                                                               |
+| module_args                | 'keep_args'<br />string    | Module configuration options                                                                                                       |
+
+For more information about module configuration options, see [Module configuration options]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database#module-configuration-options" >}}).
+
+### Returns
+
+Returns `Done` if the upgrade completed. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin upgrade module db_name db:8 module_name graph version 20812 module_args ""
+Monitoring 21ac7659-e44c-4cc9-b243-a07922b2a6cc
+active - SMUpgradeBDB init
+active - SMUpgradeBDB wait_for_version
+Ocompleted - SMUpgradeBDB
+Done
+```
+---
+Title: rladmin node enslave
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Changes a node's resources to replicas.
+headerRange: '[1-2]'
+linkTitle: enslave
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/enslave/'
+---
+
+Changes the resources of a node to replicas.
+
+## `node enslave`
+
+Changes all of the node's endpoints and shards to replicas.
+
+``` sh
+rladmin node <ID> enslave
+        [demote_node]
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's endpoints and shards to replicas             |
+| demote_node           |                                | If the node is a primary node, changes the node to replica                     |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status shards node 2
+SHARDS:
+DB:ID      NAME           ID               NODE         ROLE         SLOTS                  USED_MEMORY            STATUS
+db:6       tr02           redis:14         node:2       master       0-4095                 3.2MB                  OK
+db:6       tr02           redis:16         node:2       master       4096-8191              3.12MB                 OK
+db:6       tr02           redis:18         node:2       master       8192-12287             3.16MB                 OK
+db:6       tr02           redis:20         node:2       master       12288-16383            3.12MB                 OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 slave  192.0.2.12 198.51.100.1      3d99db1fdf4b 1/100  6           14.43GB/19.54GB  10.87GB/16.02GB  6.2.12-37 OK
+node:2  master 192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.43GB/19.54GB  10.88GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.14                   b87cc06c830f 5/120  6           14.43GB/19.54GB  10.83GB/16.02GB  6.2.12-37 OK
+$ rladmin node 2 enslave demote_node
+Performing enslave_node action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 1/100  6           14.72GB/19.54GB  10.91GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.72GB/19.54GB  11.17GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.14                   b87cc06c830f 5/120  6           14.72GB/19.54GB  10.92GB/16.02GB  6.2.12-37 OK
+$ rladmin status shards node 2
+SHARDS:
+DB:ID      NAME             ID               NODE         ROLE       SLOTS                  USED_MEMORY            STATUS
+db:6       tr02             redis:14         node:2       slave      0-4095                 2.99MB                 OK
+db:6       tr02             redis:16         node:2       slave      4096-8191              3.01MB                 OK
+db:6       tr02             redis:18         node:2       slave      8192-12287             2.93MB                 OK
+db:6       tr02             redis:20         node:2       slave      12288-16383            3.06MB                 OK
+```
+
+## `node enslave endpoints_only`
+
+Changes the role for all endpoints on a node to replica.
+
+``` sh
+rladmin node <ID> enslave endpoints_only
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's endpoints to replicas                        |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status endpoints
+ENDPOINTS:
+DB:ID         NAME        ID                             NODE            ROLE                                       SSL       
+db:5          tr01        endpoint:5:1                   node:1          single                                     No        
+db:6          tr02        endpoint:6:1                   node:3          all-master-shards                          No        
+$ rladmin node 1 enslave endpoints_only
+Performing enslave_node action on node:1: 100%
+OK
+$ rladmin status endpoints
+ENDPOINTS:
+DB:ID         NAME        ID                             NODE            ROLE                                       SSL       
+db:5          tr01        endpoint:5:1                   node:3          single                                     No        
+db:6          tr02        endpoint:6:1                   node:3          all-master-shards                          No       
+```
+
+## `node enslave shards_only`
+
+Changes the role for all shards of a node to replica.
+
+``` sh
+rladmin node <ID> enslave shards_only
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's shards to replicas                          |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status shards node 3
+SHARDS:
+DB:ID      NAME           ID               NODE         ROLE         SLOTS                  USED_MEMORY            STATUS     
+db:5       tr01           redis:12         node:3       master       0-16383                3.04MB                 OK         
+db:6       tr02           redis:15         node:3       master       0-4095                 4.13MB                 OK         
+db:6       tr02           redis:17         node:3       master       4096-8191              4.13MB                 OK         
+db:6       tr02           redis:19         node:3       master       8192-12287             4.13MB                 OK         
+db:6       tr02           redis:21         node:3       master       12288-16383            4.13MB                 OK         
+$ rladmin node 3 enslave shards_only
+Performing enslave_node action on node:3: 100%
+OK
+$ rladmin status shards node 3
+SHARDS:
+DB:ID      NAME             ID               NODE         ROLE       SLOTS                  USED_MEMORY            STATUS     
+db:5       tr01             redis:12         node:3       slave      0-16383                2.98MB                 OK         
+db:6       tr02             redis:15         node:3       slave      0-4095                 4.23MB                 OK         
+db:6       tr02             redis:17         node:3       slave      4096-8191              4.11MB                 OK         
+db:6       tr02             redis:19         node:3       slave      8192-12287             4.19MB                 OK         
+db:6       tr02             redis:21         node:3       slave      12288-16383            4.27MB                 OK
+```
+---
+Title: rladmin node maintenance_mode
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turns quorum-only mode on or off for a node.
+headerRange: '[1-2]'
+linkTitle: maintenance_mode
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/maintenance-mode/'
+---
+
+Configures [quorum-only mode]({{< relref "/operate/rs/7.4/clusters/maintenance-mode#activate-maintenance-mode" >}}) on a node.
+
+## `node maintenance_mode on`
+
+Migrates shards out of the node and turns the node into a quorum node to prevent shards from returning to it.
+
+```sh
+rladmin node <ID> maintenance_mode on
+        [ keep_slave_shards ]
+        [ evict_ha_replica { enabled | disabled } ]
+        [ evict_active_active_replica { enabled | disabled } ]
+        [ evict_dbs <list of database names or IDs> ]
+        [ demote_node ]
+        [ overwrite_snapshot ]
+        [ max_concurrent_actions <integer> ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Turns the specified node into a quorum node                                              |
+| demote_node           |                                | If the node is a primary node, changes the node to replica                                |
+| evict_ha_replica | `enabled`<br />`disabled` | Migrates the HA replica shards in the node |
+| evict_active_active_replica | `enabled`<br />`disabled` | Migrates the Active-Active replica shards in the node |
+| evict_dbs | list of database names or IDs | Specify databases whose shards should be evicted from the node when entering maintenance mode.<br /><br />Examples:<br />`$ rladmin node 1 maintenance_mode on evict_dbs db:1 db:2`<br />`$ rladmin node 1 maintenance_mode on evict_dbs db_name1 db_name2` |
+| keep_slave_shards     |                                | Keeps replica shards in the node and demotes primary shards to replicas.<br /><br />Deprecated as of Redis Enterprise Software 7.4.2. Use `evict_ha_replica disabled evict_active_active_replica disabled` instead. |
+| max_concurrent_actions | integer | Maximum number of concurrent actions during node maintenance |
+| overwrite_snapshot | | Overwrites the latest existing node snapshot taken when enabling maintenance mode |
+
+### Returns
+
+Returns `OK` if the node was converted successfully. If the cluster does not have enough resources to migrate the shards, the process returns a warning.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the node became a quorum node.
+
+### Example
+
+```sh
+$ rladmin node 2 maintenance_mode on overwrite_snapshot
+Found snapshot from 2024-01-06T11:36:47Z, overwriting the snapshot
+Performing maintenance_on action on node:2: 0%
+created snapshot NodeSnapshot<name=maintenance_mode_2024-01-11_20-25-37,time=None,node_uid=2>
+
+node:2 will not accept any more shards
+Performing maintenance_on action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.21GB/19.54GB  10.62GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 0/0    6           14.21GB/19.54GB  0KB/0KB          6.2.12-37 OK
+node:4  slave  192.0.2.14                   6d754fe12cb9 5/100  6           14.21GB/19.54GB  10.62GB/16.02GB  6.2.12-37 OK
+```
+
+## `node maintenance_mode off`
+
+Turns maintenance mode off and returns the node to its previous state.
+
+```sh
+rladmin node <ID> maintenance_mode off
+        [ { snapshot_name <name> | skip_shards_restore } ]
+        [ max_concurrent_actions <integer> ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Restores the node back to the previous state                                              |
+| max_concurrent_actions | integer | Maximum number of concurrent actions during node maintenance |
+| skip_shards_restore   |                                | Does not restore shards back to the node                                                  |
+| snapshot_name         | string                         | Restores the node back to a state stored in the specified snapshot                        |
+
+### Returns
+
+Returns `OK` if the node was restored successfully.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the node was restored.
+
+### Example
+
+```sh
+$ rladmin node 2 maintenance_mode off
+Performing maintenance_off action on node:2: 0%
+Found snapshot: NodeSnapshot<name=maintenance_mode_2022-05-12_20-25-37,time=2022-05-12T20:25:37Z,node_uid=2>
+Performing maintenance_off action on node:2: 0%
+migrate redis:12 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:12 to node:2: finished
+Performing maintenance_off action on node:2: 0%
+migrate redis:17 to node:2: executing
+
+migrate redis:15 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:17 to node:2: finished
+
+migrate redis:15 to node:2: finished
+Performing maintenance_off action on node:2: 0%
+failover redis:16: executing
+
+failover redis:14: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:16: finished
+
+failover redis:14: finished
+Performing maintenance_off action on node:2: 0%
+failover redis:18: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:18: finished
+
+migrate redis:21 to node:2: executing
+
+migrate redis:19 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:21 to node:2: finished
+
+migrate redis:19 to node:2: finished
+
+failover redis:20: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:20: finished
+Performing maintenance_off action on node:2: 0%
+rebind endpoint:6:1: executing
+Performing maintenance_off action on node:2: 0%
+rebind endpoint:6:1: finished
+Performing maintenance_off action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME      SHARDS CORES       FREE_RAM        PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b  5/100  6           14.2GB/19.54GB  10.61GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458  5/100  6           14.2GB/19.54GB  10.61GB/16.02GB  6.2.12-37 OK    
+node:4  slave  192.0.2.14                   6d754fe12cb9  0/100  6           14.2GB/19.54GB  10.69GB/16.02GB  6.2.12-37 OK
+```
+---
+Title: rladmin node external_addr
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures a node's external IP addresses.
+headerRange: '[1-2]'
+linkTitle: external_addr
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/external-addr/'
+---
+
+Configures a node's external IP addresses.
+
+## `node external_addr add`
+
+Adds an external IP address that accepts inbound user connections for the node.
+
+```sh
+rladmin node <ID> external_addr
+        add <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Adds an external IP address for the specified node                                               |
+| IP address | IP address                     | External IP address of the node                                                               |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was added. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was added.
+
+### Example
+
+``` sh
+$ rladmin node 1 external_addr add 198.51.100.1
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1      3d99db1fdf4b 5/100  6           14.75GB/19.54GB  11.15GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.3                   fc7a3d332458 0/100  6           14.75GB/19.54GB  11.24GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6           14.75GB/19.54GB  11.15GB/16.02GB  6.2.12-37 OK
+```
+
+## `node external_addr set`
+
+Sets one or more external IP addresses that accepts inbound user connections for the node.
+
+```sh
+rladmin node <ID> external_addr
+        set <IP address 1> ... <IP address N>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets external IP addresses for the specified node                                             |
+| IP address | list of IP addresses           | Sets specified IP addresses as external addresses                                                 |
+
+### Returns
+
+Returns `Updated successfully` if the IP addresses were set. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was set.
+
+### Example
+
+``` sh
+$ rladmin node 2 external_addr set 198.51.100.2 198.51.100.3
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS          HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1              3d99db1fdf4b 5/100  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3 198.51.100.2,198.51.100.3 fc7a3d332458 0/100  6     14.75GB/19.54GB 11.23GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                           b87cc06c830f 5/120  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+```
+## `node external_addr remove`
+
+Removes the specified external IP address from the node.
+
+```sh
+rladmin node <ID> external_addr
+        remove <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Removes an external IP address for the specified node                                            |
+| IP address | IP address                     | Removes the specified IP address of the node                                                      |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was removed. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was removed.
+
+### Example
+
+``` sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS          HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1              3d99db1fdf4b 5/100  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3 198.51.100.2,198.51.100.3 fc7a3d332458 0/100  6     14.75GB/19.54GB 11.23GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                           b87cc06c830f 5/120  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+$ rladmin node 2 external_addr remove 198.51.100.3
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1      3d99db1fdf4b 5/100  6           14.74GB/19.54GB  11.14GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.3 198.51.100.2      fc7a3d332458 0/100  6           14.74GB/19.54GB  11.22GB/16.02GB  6.2.12-37 OK    
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6           14.74GB/19.54GB  11.14GB/16.02GB  6.2.12-37 OK    
+```
+---
+Title: rladmin node snapshot
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages snapshots of the configuration of a node's shards and endpoints.
+headerRange: '[1-2]'
+linkTitle: snapshot
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/snapshot/'
+---
+
+Manages snapshots of the configuration of a node's shards and endpoints.
+
+You can create node snapshots and use them to restore the node's shards and endpoints to a configuration from a previous point in time. If you restore a node from a snapshot (for example, after an event such as failover or maintenance), the node's shards have the same placement and roles as when the snapshot was created.
+
+## `node snapshot create`
+
+Creates a snapshot of a node's current configuration, including the placement of shards and endpoints on the node and the shards' roles.
+
+```sh
+rladmin node <ID> snapshot create <name>
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Creates a snapshot of the specified node                    |
+| name                  | string                         | Name of the created snapshot                                |
+
+### Returns
+
+Returns `Done` if the snapshot was created successfully. Otherwise, returns an error.
+
+### Example
+
+```sh
+$ rladmin node 1 snapshot create snap1
+Creating node snapshot 'snap1' for node:1
+Done.
+```
+
+## `node snapshot delete`
+
+Deletes an existing snapshot of a node.
+
+```sh
+rladmin node <ID> snapshot delete <name>
+```
+
+{{<note>}}
+You cannot use this command to delete a snapshot created by maintenance mode. As of Redis Enterprise Software version 7.4.2, only the latest maintenance mode snapshot is kept.
+{{</note>}}
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Deletes a snapshot of the specified node                    |
+| name                  | string                         | Deletes the specified snapshot                                |
+
+### Returns
+
+Returns `Done` if the snapshot was deleted successfully. Otherwise, returns an error.
+
+### Example
+
+```sh
+$ rladmin node 1 snapshot delete snap1
+Deleting node snapshot 'snap1' for node:1
+Done.
+```
+
+## `node snapshot list`
+
+Displays a list of created snapshots for the specified node.
+
+``` sh
+rladmin node <ID> snapshot list
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Displays snapshots of the specified node                    |
+
+### Returns
+
+Returns a list of snapshots of the specified node.
+
+### Example
+
+```sh
+$ rladmin node 2 snapshot list
+Name                                               Node    Time
+snap2                                              2       2022-05-12T19:27:51Z
+```
+
+## `node snapshot restore`
+
+Restores a node's shards and endpoints as close to the stored snapshot as possible.
+
+```sh
+rladmin node <ID> snapshot restore <name>
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Restore the specified node from a snapshot.                    |
+| restore              | string                           | Name of the snapshot used to restore the node.              |
+
+### Returns
+
+Returns `Snapshot restore completed successfully` if the actions needed to restore the snapshot completed successfully. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin node 2 snapshot restore snap2
+Reading node snapshot 'snap2' for node:2
+Planning restore
+Planned actions:
+* migrate redis:15 to node:2
+* failover redis:14
+* migrate redis:17 to node:2
+* failover redis:16
+* migrate redis:19 to node:2
+* failover redis:18
+* migrate redis:21 to node:2
+* failover redis:20
+Proceed?[Y]es/[N]o? Y
+2022-05-12T19:43:31.486613 Scheduling 8 actions
+[2022-05-12T19:43:31.521422 Actions Status: 8 waiting ]
+* [migrate redis:21 to node:2] waiting => executing
+* [migrate redis:19 to node:2] waiting => executing
+* [migrate redis:17 to node:2] waiting => executing
+* [migrate redis:15 to node:2] waiting => executing
+[2022-05-12T19:43:32.586084 Actions Status: 4 executing | 4 waiting ]
+* [migrate redis:21 to node:2] executing => finished
+* [migrate redis:19 to node:2] executing => finished
+* [migrate redis:17 to node:2] executing => finished
+* [migrate redis:15 to node:2] executing => finished
+* [failover redis:20] waiting => executing
+* [failover redis:18] waiting => executing
+* [failover redis:16] waiting => executing
+* [failover redis:14] waiting => executing
+[2022-05-12T19:43:33.719496 Actions Status: 4 finished | 4 executing ]
+* [failover redis:20] executing => finished
+* [failover redis:18] executing => finished
+* [failover redis:16] executing => finished
+* [failover redis:14] executing => finished
+Snapshot restore completed successfully.
+```
+---
+Title: rladmin node addr set
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets a node's internal IP address.
+headerRange: '[1-2]'
+linkTitle: addr
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/addr/'
+---
+
+Sets the internal IP address of a node. You can only set the internal IP address when the node is down. See [Change internal IP address]({{< relref "/operate/rs/7.4/networking/multi-ip-ipv6#change-internal-ip-address" >}}) for detailed instructions.
+
+```sh
+rladmin node <ID> addr set <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets the internal IP address of the specified node                                                |
+| addr   | IP address                     | Sets the node's internal IP address to the specified IP address                                      |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was set. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the internal IP address was changed.
+
+### Example
+
+```sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2                   3d99db1fdf4b 5/100  6     16.06GB/19.54GB 12.46GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3                   fc7a3d332458 0/100  6     -/19.54GB       -/16.02GB       6.2.12-37 DOWN, last seen 33s ago
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6     16.06GB/19.54GB 12.46GB/16.02GB 6.2.12-37 OK
+$ rladmin node 2 addr set 192.0.2.5
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2                   3d99db1fdf4b 5/100  6     14.78GB/19.54GB 11.18GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.5                   fc7a3d332458 0/100  6     14.78GB/19.54GB 11.26GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6     14.78GB/19.54GB 11.18GB/16.02GB 6.2.12-37 OK
+```
+---
+Title: rladmin node recovery_path set
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets a node's local recovery path.
+headerRange: '[1-2]'
+linkTitle: recovery_path
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/recovery-path/'
+---
+
+Sets the node's local recovery path, which specifies the directory where [persistence files]({{< relref "/operate/rs/7.4/databases/configure/database-persistence" >}}) are stored. You can use these persistence files to [recover a failed database]({{< relref "/operate/rs/7.4/databases/recover" >}}).
+
+```sh
+rladmin node <ID> recovery_path set <path>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets the recovery path for the specified node                                            |
+| path      | filepath                       | Path to the folder where persistence files are stored                                         |
+
+### Returns
+
+Returns `Updated successfully` if the recovery path was set. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin node 2 recovery_path set /var/opt/redislabs/persist/redis
+Updated successfully.
+```
+---
+Title: rladmin node remove
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Removes a node from the cluster.
+headerRange: '[1-2]'
+linkTitle: remove
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/remove/'
+---
+
+Removes the specified node from the cluster.
+
+```sh
+rladmin node <ID> remove [ wait_for_persistence { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                 |
+|-----------------------|--------------------------------|-------------------------------------------------------------|
+| node                  | integer                        | The node to remove from the cluster                    |
+| wait_for_persistence  | `enabled`<br />`disabled`      | Ensures persistence files are available for recovery. The cluster policy `persistent_node_removal` determines the default value. |
+
+### Returns
+
+Returns `OK` if the node was removed successfully. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify that the node was removed.
+
+### Example
+
+```sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.26GB/19.54GB  10.67GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.26GB/19.54GB  10.71GB/16.02GB  6.2.12-37 OK    
+node:3  slave  192.0.2.14                   b87cc06c830f 1/120  6           14.26GB/19.54GB  10.7GB/16.02GB   6.2.12-37 OK    
+$ rladmin node 3 remove
+Performing remove action on node:3: 100%
+OK
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.34GB/19.54GB  10.74GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 5/100  6           14.34GB/19.54GB  10.74GB/16.02GB  6.2.12-37 OK
+```
+---
+Title: rladmin node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage nodes.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: node
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/node/'
+---
+
+`rladmin node` commands manage nodes in the cluster.
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: rladmin
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Redis Enterprise clusters and databases.
+hideListLinks: true
+linkTitle: rladmin (manage cluster)
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/rladmin/'
+---
+
+`rladmin` is a command-line utility that lets you perform administrative tasks such as failover, migration, and endpoint binding on a Redis Enterprise Software cluster. You can also use `rladmin` to edit cluster and database configurations.
+
+Although you can use the Cluster Manager UI for some of these tasks, others are unique to the `rladmin` command-line tool.
+
+## `rladmin` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Use the `rladmin` shell
+
+To open the `rladmin` shell:
+
+1. Sign in to a Redis Enterprise Software node with an account that is a member of the **redislabs** group.
+
+    The `rladmin` binary is located in `/opt/redislabs/bin`. If you don't have this directory in your `PATH`, you may want to add it. Otherwise, you can use `bash -l <username>` to sign in as a user with permissions for that directory.
+
+1. Run: `rladmin`
+
+    {{<note>}}
+If the CLI does not recognize the `rladmin` command,
+run this command to load the necessary configuration first: <nobr>`bash -l`</nobr>
+    {{</note>}}
+
+In the `rladmin` shell, you can:
+
+- Run any `rladmin` command without prefacing it with `rladmin`.
+- Enter `?` to view the full list of available commands.
+- Enter [`help`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/help" >}}) followed by the name of a command for a detailed explanation of the command and its usage.
+- Press the `Tab` key for command completion.
+- Enter `exit` or press `Control+D` to exit the `rladmin` shell and return to the terminal prompt.
+---
+Title: Command-line utilities
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reference for Redis Enterprise Software command-line utilities, including rladmin, redis-cli, crdb-cli, and rlcheck.
+hideListLinks: true
+linkTitle: Command-line utilities
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/'
+---
+
+Redis Enterprise Software includes a set of utilities to help you manage and test your cluster. To use a utility, run it from the command line.
+
+## Public utilities
+
+Administrators can use these CLI tools to manage and test a Redis Enterprise cluster. You can find the binaries in the `/opt/redislabs/bin/` directory.
+
+{{<table-children columnNames="Utility,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Internal utilities
+
+The `/opt/redislabs/bin/` directory also contains utilities used internally by Redis Enterprise Software and for troubleshooting.
+
+{{<warning>}}
+Do not use these tools for normal operations.
+{{</warning>}}
+
+| Utility | Description |
+|---------|-------------|
+| bdb-cli | `redis-cli` connected to a database. |
+| ccs-cli | Inspect Cluster Configuration Store. |
+| cnm-ctl | Manages services for provisioning, migration, monitoring, <br />resharding, rebalancing, deprovisioning, and autoscaling. |
+| consistency_checker | Checks the consistency of Redis instances. |
+| crdbtop | Monitor Active-Active databases. |
+| debug_mode | Enables debug mode. |
+| debuginfo | Collects cluster information. |
+| dmc-cli | Configure and monitor the DMC proxy. |
+| pdns_control | Sends commands to a running PowerDNS nameserver. |
+| redis_ctl | Stops or starts Redis instances. |
+| rl_rdbloader | Load RDB backup files to a server. |
+| rlutil | Maintenance utility. |
+| shard-cli | `redis-cli` connected to a shard. |
+| supervisorctl | Manages the lifecycles of Redis Enterprise services. |
+---
+Title: crdb-cli crdb flush
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Clears all keys from an Active-Active database.
+linkTitle: flush
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/flush/'
+---
+
+Clears all keys from an Active-Active database.
+
+```sh
+crdb-cli crdb flush --crdb-guid <guid>
+         [ --no-wait ]
+```
+
+This command is irreversible. If the data in your database is important, back it up before you flush the database.
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+| no-wait             |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task clearing the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be cleared and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb flush --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+Task 53cdc59e-ecf5-4564-a8dd-448d71f9e568 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb remove-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Removes a peer replica from an Active-Active database.
+linkTitle: remove-instance
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/remove-instance/'
+---
+
+Removes a peer replica instance from the Active-Active database and deletes the instance and its data from the participating cluster.
+
+```sh
+crdb-cli crdb remove-instance --crdb-guid <guid>
+         --instance-id <instance-id>
+         [ --force ]
+         [ --no-wait ]
+```
+
+If the cluster cannot communicate with the instance that you want to remove, you can:
+
+1. Use the `--force` option to remove the instance from the Active-Active database without purging the data from the instance.
+
+1. Run [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) from the removed instance to delete the Active-Active database and its data.
+
+### Parameters
+
+| Parameter                    | Value  | Description|
+|------------------------------|--------|------------|
+| crdb-guid         | string | The GUID of the database (required) |
+| instance-id | string | The ID of the local instance to remove (required) |
+| force                        |        | Removes the instance without purging data from the instance. <br>If --force is specified, you must run [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) from the removed instance. |
+| no-wait                      |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is deleting the instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be removed and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb remove-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 --instance-id 2 --force
+Task b1eba5ba-90de-49e9-8678-d66daa1afb51 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb get
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the current configuration of an Active-Active database.
+linkTitle: get
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/get/'
+---
+
+Shows the current configuration of an Active-Active database.
+
+```sh
+crdb-cli crdb get --crdb-guid <guid>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+
+### Returns
+
+Returns the current configuration of the database.
+
+### Example
+
+```sh
+$ crdb-cli crdb get --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+CRDB-GUID: d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+Name: database1
+Encryption: False
+Causal consistency: False
+Protocol version: 1
+FeatureSet version: 5
+Modules: []
+Default-DB-Config:
+  memory_size: 1073741824
+  port: 12000
+  replication: True
+  shard_key_regex: [{'regex': '.*\\{(?<tag>.*)\\}.*'}, {'regex': '(?<tag>.*)'}]
+  sharding: True
+  shards_count: 1
+  tls_mode: disabled
+  rack_aware: None
+  data_persistence: None
+  authentication_redis_pass: None
+  authentication_admin_pass: None
+  oss_sharding: None
+  oss_cluster: None
+  proxy_policy: None
+  shards_placement: None
+  oss_cluster_api_preferred_ip_type: None
+  bigstore: None
+  bigstore_ram_size: None
+  aof_policy: None
+  snapshot_policy: None
+  max_aof_load_time: None
+  max_aof_file_size: None
+Instance:
+  Id: 1
+  Cluster:
+    FQDN: cluster1.redis.local
+    URL: https://cluster1.redis.local:9443
+    Replication-Endpoint: <Default>
+    Replication TLS SNI: <Default>
+  Compression: 3
+  DB-Config:
+    authentication_admin_pass: 
+    replication: None
+    rack_aware: None
+    memory_size: None
+    data_persistence: None
+    tls_mode: None
+    authentication_redis_pass: None
+    port: None
+    shards_count: None
+    shard_key_regex: None
+    oss_sharding: None
+    oss_cluster: None
+    proxy_policy: None
+    shards_placement: None
+    oss_cluster_api_preferred_ip_type: None
+    bigstore: None
+    bigstore_ram_size: None
+    aof_policy: None
+    snapshot_policy: None
+    max_aof_load_time: None
+    max_aof_file_size: None
+Instance:
+  Id: 2
+  Cluster:
+    FQDN: cluster2.redis.local
+    URL: https://cluster2.redis.local:9443
+    Replication-Endpoint: <Default>
+    Replication TLS SNI: <Default>
+  Compression: 3
+  DB-Config:
+    authentication_admin_pass: 
+    replication: None
+    rack_aware: None
+    memory_size: None
+    data_persistence: None
+    tls_mode: None
+    authentication_redis_pass: None
+    port: None
+    shards_count: None
+    shard_key_regex: None
+    oss_sharding: None
+    oss_cluster: None
+    proxy_policy: None
+    shards_placement: None
+    oss_cluster_api_preferred_ip_type: None
+    bigstore: None
+    bigstore_ram_size: None
+    aof_policy: None
+    snapshot_policy: None
+    max_aof_load_time: None
+    max_aof_file_size: None
+```
+---
+Title: crdb-cli crdb health-report
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the health report of an Active-Active database.
+linkTitle: health-report
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/health-report/'
+---
+
+Shows the health report of the API management layer of an Active-Active database.
+
+```sh
+crdb-cli crdb health-report --crdb-guid <guid>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+
+### Returns
+
+Returns the health report of the API management layer of the database.
+
+### Example
+
+```sh
+$ crdb-cli crdb health-report --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+[
+  {
+    "active_config_version":1,
+    "cluster_name":"cluster2.redis.local",
+    "configurations":[
+      {
+        "causal_consistency":false,
+        "encryption":false,
+        "featureset_version":5,
+        "instances":[
+          {
+            "cluster":{
+              "name":"cluster1.redis.local",
+              "url":"https:\/\/cluster1.redis.local:9443"
+            },
+            "db_uid":"",
+            "id":1
+          },
+          {
+            "cluster":{
+              "name":"cluster2.redis.local",
+              "url":"https:\/\/cluster2.redis.local:9443"
+            },
+            "db_uid":"1",
+            "id":2
+          }
+        ],
+        "name":"database1",
+        "protocol_version":1,
+        "status":"commit-completed",
+        "version":1
+      }
+    ],
+    "connections":[
+      {
+        "name":"cluster1.redis.local",
+        "status":"ok"
+      },
+      {
+        "name":"cluster2.redis.local",
+        "status":"ok"
+      }
+    ],
+    "guid":"d84f6fe4-5bb7-49d2-a188-8900e09c6f66",
+    "name":"database1",
+    "connection_error":null
+  },
+  {
+    "active_config_version":1,
+    "cluster_name":"cluster1.redis.local",
+    "configurations":[
+      {
+        "causal_consistency":false,
+        "encryption":false,
+        "featureset_version":5,
+        "instances":[
+          {
+            "cluster":{
+              "name":"cluster1.redis.local",
+              "url":"https:\/\/cluster1.redis.local:9443"
+            },
+            "db_uid":"4",
+            "id":1
+          },
+          {
+            "cluster":{
+              "name":"cluster2.redis.local",
+              "url":"https:\/\/cluster2.redis.local:9443"
+            },
+            "db_uid":"",
+            "id":2
+          }
+        ],
+        "name":"database1",
+        "protocol_version":1,
+        "status":"commit-completed",
+        "version":1
+      }
+    ],
+    "connections":[
+      {
+        "name":"cluster1.redis.local",
+        "status":"ok"
+      },
+      {
+        "name":"cluster2.redis.local",
+        "status":"ok"
+      }
+    ],
+    "guid":"d84f6fe4-5bb7-49d2-a188-8900e09c6f66",
+    "name":"database1",
+    "connection_error":null
+  }
+]
+```
+---
+Title: crdb-cli crdb add-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Adds a peer replica to an Active-Active database.
+linkTitle: add-instance
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/add-instance/'
+---
+
+Adds a peer replica to an existing Active-Active database in order to host the database on another cluster. This creates an additional active instance of the database on the specified cluster.
+
+```sh
+crdb-cli crdb add-instance --crdb-guid <guid>
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         [ --compression <0-6> ]
+         [ --no-wait ]
+```
+
+### Parameters
+
+| Parameter | Value   | Description |
+|-----------|---------|-------------|
+| crdb-guid | string  | The GUID of the database (required) |
+| instance | strings | The connection information for the new participating cluster (required) |
+| compression | 0-6     | The level of data compression: 0=Compression disabled <br> <br> 6=High compression and resource load (Default: 3) |
+| no-wait | | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is adding the new instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be added and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb add-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 \
+        --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin-password
+Task f809fae7-8e26-4c8f-9955-b74dbbd47949 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb list
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows a list of all Active-Active databases.
+linkTitle: list
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/list/'
+---
+
+Shows a list of all Active-Active databases.
+
+```sh
+crdb-cli crdb list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns a list of all Active-Active databases that the cluster participates in. Each database is represented with a unique GUID, the name of the database, an instance ID, and the FQDN of the cluster that hosts the instance.
+
+### Example
+
+```sh
+$ crdb-cli crdb list
+CRDB-GUID                             NAME       REPL-ID  CLUSTER-FQDN
+d84f6fe4-5bb7-49d2-a188-8900e09c6f66  database1  1        cluster1.redis.local
+d84f6fe4-5bb7-49d2-a188-8900e09c6f66  database1  2        cluster2.redis.local
+```
+---
+Title: crdb-cli crdb create
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates an Active-Active database.
+linkTitle: create
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/create/'
+---
+
+Creates an Active-Active database.
+
+```sh
+crdb-cli crdb create --name <name>
+         --memory-size <maximum_memory>
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         [--port <port_number>]
+         [--no-wait]
+         [--default-db-config <configuration>]
+         [--default-db-config-file <filename>]
+         [--compression <0-6>]
+         [--causal-consistency { true | false } ]
+         [--password <password>]
+         [--replication { true | false } ]
+         [--encryption { true | false } ]
+         [--sharding { false | true } ]
+         [--shards-count <number_of_shards>]
+         [--shard-key-regex <regex_rule>]
+         [--oss-cluster { true | false } ]
+         [--bigstore { true | false }]
+         [--bigstore-ram-size <maximum_memory>]
+         [--with-module name=<module_name>,version=<module_version>,args=<module_args>]
+```
+
+### Prerequisites
+
+Before you create an Active-Active database, you must have:
+
+- At least two participating clusters
+- [Network connectivity]({{< relref "/operate/rs/7.4/networking/port-configurations" >}}) between the participating clusters
+
+### Parameters
+
+
+| Parameter&nbsp;&&nbsp;options(s)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;                                                                             | Value                                           | Description                                                                                                                                                                                                                  |
+|---------------------------------------------------------------------------------------|-------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| name \<CRDB_name\>                                                                  | string                                          | Name of the Active-Active database (required)                                                                                                                                                                                |
+| memory-size \<maximum_memory\>                                                                | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum database memory (required)                                                                                                                                                                                           |
+| instance<br/>&nbsp;&nbsp; fqdn=\<cluster_fqdn\>,<br/>&nbsp;&nbsp; username=\<username\>,<br/>&nbsp;&nbsp; password=\<password\>         | strings                                         | The connection information for the participating clusters (required for each participating cluster)                                                                                                                          |
+| port \<port_number\>                                                                 | integer                                         | TCP port for the Active-Active database on all participating clusters                                                                                                                                                        |
+| default-db-config \<configuration\>                                                  | string                                          | Default database configuration options                                                                                                                                                                                       |
+| default-db-config-file \<filename\>                                                  | filepath                                        | Default database configuration options from a file                                                                                                                                                                           |
+| no-wait                                                                               |                                                 | Prevents `crdb-cli` from running another command before this command finishes                                                                                                                                                  |
+| compression                                                                           | 0-6                                             | The level of data compression: <br /><br > 0 = No compression <br /><br > 6 = High compression and resource load (Default: 3)                                                                                                            |
+| causal-consistency                                                                    | true <br/> false (*default*)                        | [Causal consistency]({{< relref "/operate/rs/7.4/databases/active-active/causal-consistency.md" >}}) applies updates to all instances in the order they were received                                                     |
+| password \<password\>                                                                | string                                          | Password for access to the database                                                                                                                                                                                          |
+| replication                                                                           | true <br/> false (*default*)                        | Activates or deactivates [database replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}}) where every master shard replicates to a replica shard                                                       |
+| encryption                                                                            | true <br/> false (*default*)                        | Activates or deactivates encryption                                                                                                                                                                                          |
+| sharding                                                                              | true <br/> false (*default*)                        | Activates or deactivates sharding (also known as [database clustering]({{< relref "/operate/rs/7.4/databases/durability-ha/replication.md" >}})). Cannot be updated after the database is created                                   |
+| shards-count \<number_of_shards\>                                                              | integer                                         | If sharding is enabled, this specifies the number of Redis shards for each database instance                                                                                                                                 |
+| oss-cluster                                                                           | true<br/>false (*default*)                               | Activates [OSS cluster API]({{< relref "/operate/rs/7.4/clusters/optimize/oss-cluster-api" >}})                                                                                                                                |
+| shard-key-regex \<regex_rule\>                                                       | string                                          | If clustering is enabled, this defines a regex rule (also known as a [hashing policy]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering#custom-hashing-policy" >}})) that determines which keys are located in each shard (defaults to `{u'regex': u'.*\\{(?<tag>.*)\\}.*'}, {u'regex': u'(?<tag>.*)'} `) |
+| bigstore                                                                              | true <br/> <br/> false (*default*)                        | If true, the database uses Auto Tiering to add flash memory to the database                                                                                                                                                |
+| bigstore-ram-size \<size\>                                                           | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum RAM limit for  databases with Auto Tiering enabled                                                                                                                                                                           |
+| with-module<br/>&nbsp;&nbsp;name=\<module_name\>,<br/>&nbsp;&nbsp;version=\<module_version\>,<br/>&nbsp;&nbsp;args=\<module_args\> | strings                                         | Creates a database with a specific module                                                                                                                                                                                    |
+| eviction-policy                                                     | noeviction (*default*)<br/>allkeys-lru<br/>allkeys-lfu<br/>allkeys-random<br/>volatile-lru<br/>volatile-lfu<br/>volatile-random<br/>volatile-ttl | Sets [eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy" >}})                                                                                                          |
+| proxy-policy                                                                          | all-nodes<br>all-master-shards<br>single        | Sets proxy policy |
+
+
+
+### Returns
+
+Returns the task ID of the task that is creating the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be created and then return the CRDB GUID.
+
+### Examples
+
+```sh
+$ crdb-cli crdb create --name database1 --memory-size 1GB --port 12000 \
+           --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin \
+           --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin
+Task 633aaea3-97ee-4bcb-af39-a9cb25d7d4da created
+  ---> Status changed: queued -> started
+  ---> CRDB GUID Assigned: crdb:d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+  ---> Status changed: started -> finished
+```
+
+To create an Active-Active database with two shards in each instance and with encrypted traffic between the clusters:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --shards-count 2 --encryption true
+```
+
+To create an Active-Active database with two shards and with RediSearch 2.0.6 module:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --shards-count 2 --with-module name=search,version="2.0.6",args="PARTITIONS AUTO"
+```
+
+To create an Active-Active database with two shards and with encrypted traffic between the clusters:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --encryption true --shards-count 2
+```
+
+To create an Active-Active database with 1 shard in each instance and not wait for the response:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --no-wait
+```
+---
+Title: crdb-cli crdb delete
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Deletes an Active-Active database.
+linkTitle: delete
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/delete/'
+---
+
+Deletes an Active-Active database.
+
+```sh
+crdb-cli crdb delete --crdb-guid <guid>
+         [ --no-wait ]
+```
+
+This command is irreversible. If the data in your database is important, back it up before you delete the database.
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid | string | The GUID of the database (required) |
+| no-wait             |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is deleting the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be deleted and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb delete --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35
+Task dfe6cacc-88ff-4667-812e-938fd05fe359 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb update
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Updates the configuration of an Active-Active database.
+linkTitle: update
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/update/'
+---
+
+Updates the configuration of an Active-Active database.
+
+```sh
+crdb-cli crdb update --crdb-guid <guid>
+         [--no-wait]
+         [--force]
+         [--default-db-config <configuration> ]
+         [--default-db-config-file <filename>]
+         [--compression <0-6>]
+         [--causal-consistency { true | false } ]
+         [--credentials id=<id>,username=<username>,password=<password> ]
+         [--encryption { true | false } ]
+         [--oss-cluster { true | false } ]
+         [--featureset-version { true | false } ]
+         [--memory-size <maximum_memory>]
+         [--bigstore-ram-size <maximum_memory>]
+         [--update-module name=<name>,featureset_version=<version>]
+```
+
+If you want to change the configuration of the local instance only, use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) instead.
+
+### Parameters
+
+| Parameter                                                           | Value                                                                                                                         | Description                                                                                                                                                              |
+|---------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| crdb-guid \<guid\>                                                 | string                                                                                                                        | GUID of the Active-Active database (required)                                                                                                                            |
+| bigstore-ram-size \<maximum_memory\>                                                  | size in bytes, kilobytes (KB), or gigabytes (GB)                                                                               | Maximum RAM limit for the  databases with Auto Tiering enabled, if activated                                                                                                          |
+| memory-size \<maximum_memory\>                                                                | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum database memory (required)                                                                                                                                                                                           |
+| causal-consistency                                                  | true <br/>false                                                                                                           | [Causal consistency]({{< relref "/operate/rs/7.4/databases/active-active/causal-consistency.md" >}}) applies updates to all instances in the order they were received |
+| compression                                                         | 0-6                                                                                                                           | The level of data compression: <br /><br /> 0 = No compression <br /><br /> 6 = High compression and resource load (Default: 3)                                                        |
+| credentials id=\<id\>,username=\<username\>,password=\<password\> | strings                                                                                                                       | Updates the credentials for access to the instance                                                                                                                       |
+| default-db-config \<configuration\>                                                  |                                                                                                                               | Default database configuration from stdin                                                                                                                                |
+| default-db-config-file \<filename\>                                | filepath                                                                                                                      | Default database configuration from file                                                                                                                                 |
+| encryption                                                          | true <br/>false                                                                                                           | Activates or deactivates encryption                                                                                                                                      |
+| force                                                               |                                                                                                                               | Force an update even if there are no changes                                                                                                                             |
+| no-wait                                                             |                                                                                                                               | Do not wait for the command to finish                                                                                                                                    |
+| oss-cluster                                                         | true <br/>false                                                                                                           | Activates or deactivates OSS Cluster mode                                                                                                                                |
+| eviction-policy                                                     | noeviction<br/>allkeys-lru<br/>allkeys-lfu<br/>allkeys-random<br/>volatile-lru<br/>volatile-lfu<br/>volatile-random<br/>volatile-ttl | Updates [eviction policy]({{< relref "/operate/rs/7.4/databases/memory-performance/eviction-policy" >}})                                                                                                          |
+| featureset-version                                                  | true<br/>false                                                                                                             | Updates to latest FeatureSet version                                                                                                                                     |
+| update-module name=\<name>,featureset_version=\<version\>         | strings                                                                                                                       | Update a module to the specified version                                                                                                                                 |
+
+### Returns
+
+Returns the task ID of the task that is updating the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be updated and then return "finished."
+
+### Example
+
+```sh
+$ crdb-cli crdb update --crdb-guid 968d586c-e12d-4b8f-8473-42eb88d0a3a2 --memory-size 2GBTask 7e98efc1-8233-4578-9e0c-cdc854b8af9e created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb purge-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Deletes data from a local instance and removes it from the Active-Active
+  database.
+linkTitle: purge-instance
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/purge-instance/'
+---
+
+Deletes data from a local instance and removes the instance from the Active-Active database.
+
+```sh
+crdb-cli crdb purge-instance --crdb-guid <guid>
+         --instance-id <instance-id>
+         [ --no-wait ]
+```
+
+Once this command finishes, the other replicas must remove this instance with [`crdb-cli crdb remove-instance --force`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/remove-instance" >}}).
+
+### Parameters
+
+| Parameter                 | Value  | Description                                      |
+|---------------------------|--------|--------------------------------------------------|
+| crdb-guid        | string | The GUID of the database (required)              |
+| instance-id  | string | The ID of the local instance (required) |
+| no-wait                   |        | Does not wait for the task to complete           |
+
+### Returns
+
+Returns the task ID of the task that is purging the local instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be purged and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb purge-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 --instance-id 2
+Task add0705c-87f1-4c28-ad6a-ab5d98e00c58 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active databases.
+hideListLinks: true
+linkTitle: crdb
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/crdb/'
+---
+
+Use `crdb-cli crdb` commands to manage Active-Active databases.
+
+## `crdb-cli crdb` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: crdb-cli task status
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the status of a specified Active-Active database task.
+linkTitle: status
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/task/status/'
+---
+
+Shows the status of a specified Active-Active database task.
+
+```sh
+crdb-cli task status --task-id <task_id>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| task-id \<task_id\>  | string | An Active-Active database task ID (required) |
+| verbose              | N/A    | Returns detailed information when specified |
+| no-verbose           | N/A    | Returns limited information when specified |
+
+The `--verbose` and `--no-verbose` options are mutually incompatible; specify one or the other.
+
+The `404 Not Found` error indicates an invalid task ID.  Use the [`task list`]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/task/list" >}}) command to determine available task IDs.
+
+### Returns
+
+Returns the status of an Active-Active database task.
+
+### Example
+
+```sh
+$ crdb-cli task status --task-id e1c49470-ae0b-4df8-885b-9c755dd614d0
+Task-ID: e1c49470-ae0b-4df8-885b-9c755dd614d0
+CRDB-GUID: 1d7741cc-1110-4e2f-bc6c-935292783d24
+Operation: create_crdb
+Status: finished
+Worker-Name: crdb_worker:1:0
+Started: 2022-10-12T09:33:41Z
+Ended: 2022-10-12T09:33:55Z
+```
+---
+Title: crdb-cli task list
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Lists active and recent Active-Active database tasks.
+linkTitle: list
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/task/list/'
+---
+
+Lists active and recent Active-Active database tasks.
+
+```sh
+crdb-cli task list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+A table listing current and recent Active-Active tasks.  Each entry includes the following:
+
+| Column | Description |
+|--------|-------------|
+| Task ID | String containing the unique ID associated with the task<br/>Example: `e1c49470-ae0b-4df8-885b-9c755dd614d0` |
+| CRDB-GUID | String containing the unique ID associated with the Active-Active database affected by the task<br/>Example: `1d7741cc-1110-4e2f-bc6c-935292783d24` |
+| Operation | String describing the task action<br/>Example: `create_crdb` |
+| Status | String indicating the task status<br/>Example: `finished` |
+| Worker name | String identifying the process handling the task<br/>Example: `crdb_worker:1:0` |
+| Started | TimeStamp value indicating when the task started ([UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time))<br/>Example: `2022-10-12T09:33:41Z` |
+| Ended | TimeStamp value indicating when the task ended (UTC)<br/>Example: ` 2022-10-12T09:33:55Z` |
+
+### Example
+
+```sh
+$ crdb-cli task list
+TASK-ID    CRDB-GUID  OPERATION    STATUS    WORKER-NAME  STARTED    ENDED               
+<task-ID>  <crdb-ID>  <operation>  <result>  <worker-ID>  <started>  <ended>
+```
+---
+Title: crdb-cli task cancel
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Attempts to cancel a specified Active-Active database task.
+linkTitle: cancel
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/task/cancel/'
+---
+
+Cancels the Active-Active database task specified by the task ID.
+
+```sh
+crdb-cli task cancel --task-id <task_id>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| task-id \<task_id\>  | string | An Active-Active database task ID (required) |
+
+### Returns
+
+Attempts to cancel an Active-Active database task.
+
+Be aware that tasks may complete before they can be cancelled.
+
+### Example
+
+```sh
+$ crdb-cli task cancel --task-id 2901c2a3-2828-4717-80c0-6f27f1dd2d7c 
+```
+---
+Title: crdb-cli task commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active tasks.
+hideListLinks: true
+linkTitle: task
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/task/'
+---
+
+The `crdb-cli task` commands help investigate Active-Active database performance issues.  They should not be used except as directed by Support.
+
+## `crdb-cli task` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active databases.
+hideListLinks: true
+linkTitle: crdb-cli (manage Active-Active)
+weight: $weight
+url: '/operate/rs/7.4/references/cli-utilities/crdb-cli/'
+---
+
+An [Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/_index.md" >}}) (also known as CRDB or conflict-free replicated database)
+replicates your data across Redis Enterprise Software clusters located in geographically distributed regions.
+Active-Active databases allow read-write access in all locations, making them ideal for distributed applications that require fast response times and disaster recovery.
+
+The Active-Active database on an individual cluster is called an **instance**.
+Each cluster that hosts an instance is called a **participating cluster**.
+
+An Active-Active database requires two or more participating clusters.
+Each instance is responsible for updating the instances that reside on other participating clusters with the transactions it receives.
+Write conflicts are resolved using [conflict-free replicated data types]({{< relref "/operate/rs/7.4/databases/active-active" >}}) (CRDTs).
+
+To programmatically maintain an Active-Active database and its instances, you can use the `crdb-cli` command-line tool.
+
+## `crdb-cli` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Use the crdb-cli
+
+To use the `crdb-cli` tool, use SSH to sign in to a Redis Enterprise host with a user that belongs to the group that Redis Enterprise Software was installed with (Default: **redislabs**).
+If you sign in with a non-root user, you must add `/opt/redislabs/bin/` to your `PATH` environment variables.
+
+`crdb-cli` commands use the syntax: `crdb-cli <command> <arguments>` to let you:
+
+- Create, list, update, flush, or delete an Active-Active database.
+- Add or remove an instance of the Active-Active database on a specific cluster.
+
+Each command creates a task.
+
+By default, the command runs immediately and displays the result in the output.
+
+If you use the <nobr>`--no-wait`</nobr> flag, the command runs in the background so that your application is not delayed by the response.
+
+Use the [`crdb-cli task` commands]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli/task/" >}}) to manage Active-Active database tasks.
+
+For each `crdb-cli` command, you can use <nobr>`--help`</nobr> for additional information about the command.
+---
+Title: Benchmark an Auto Tiering enabled database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Benchmark Auto Tiering
+weight: $weight
+url: '/operate/rs/7.4/references/memtier-benchmark/'
+---
+Auto Tiering on Redis Enterprise Software lets you use cost-effective Flash memory as a RAM extension for your database.
+
+But what does the performance look like as compared to a memory-only database, one stored solely in RAM?
+
+These scenarios use the `memtier_benchmark` utility to evaluate the performance of a Redis Enterprise Software deployment, including the trial version.  
+
+The `memtier_benchmark` utility is located in `/opt/redislabs/bin/` of Redis Enterprise Software deployments.  To test performance for cloud provider deployments, see the [memtier-benchmark GitHub project](https://github.com/RedisLabs/memtier_benchmark).
+
+For additional, such as assistance with larger clusters, [contact support](https://redislabs.com/company/support/).
+
+
+## Benchmark and performance test considerations
+
+These tests assume you're using a trial version of Redis Enterprise Software and want to test the performance of a Auto Tiering enabled database in the following scenarios:
+
+- Without replication: Four (4) master shards
+- With replication: Two (2) primary and two replica shards
+
+With the trial version of Redis Enterprise Software you can create a cluster of up to four shards using a combination of database configurations, including:
+
+- Four databases, each with a single master shard
+- Two highly available databases with replication enabled (each database has one master shard and one replica shard)
+- One non-replicated clustered database with four master shards
+- One highly available and clustered database with two master shards and two replica shards
+
+## Test environment and cluster setup
+
+For the test environment, you need to:
+
+1. Create a cluster with three nodes.
+1. Prepare the flash memory.
+1. Configure the load generation tool.
+
+### Creating a three-node cluster {#creating-a-threenode-rs-cluster}
+
+This performance test requires a three-node cluster.
+
+You can run all of these tests on Amazon AWS with these hosts:
+
+- 2 x i3.2xlarge (8 vCPU, 61 GiB RAM, up to 10GBit, 1.9TB NMVe SSD)
+
+    These nodes serve RoF data
+
+- 1 x m4.large, which acts as a quorum node
+
+To learn how to install Redis Enterprise Software and set up a cluster, see:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}) for a test installation
+- [Install and upgrade]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) for a production installation
+
+These tests use a quorum node to reduce AWS EC2 instance use while maintaining the three nodes required to support a quorum node in case of node failure.  Quorum nodes can be on less powerful instances because they do not have shards or support traffic.
+
+As of this writing, i3.2xlarge instances are required because they support NVMe SSDs, which are required to support RoF.  Auto Tiering requires Flash-enabled storage, such as NVMe SSDs.
+
+For best results, compare performance of a Flash-enabled deployment to the performance in a RAM-only environment, such as a strictly on-premises deployment.
+
+## Prepare the flash memory
+
+After you install RS on the nodes,
+the flash memory attached to the i3.2xlarge instances must be prepared and formatted with the `/opt/redislabs/sbin/prepare_flash.sh` script.
+
+## Set up the load generation tool
+
+The memtier_benchmark load generator tool generates the load on the RoF databases.
+To use this tool, install RS on a dedicated instance that is not part of the RS cluster
+but is in the same region/zone/subnet of your cluster.
+We recommend that you use a relatively powerful instance to avoid bottlenecks at the load generation tool itself.
+
+For these tests, the load generation host uses a c4.8xlarge instance type.
+
+## Database configuration parameters
+
+### Create a Auto Tiering test database
+
+You can use the Redis Enterprise Cluster Manager UI to create a test database.
+We recommend that you use a separate database for each test case with these requirements:
+
+|  **Parameter** | **With replication** | **Without replication** | **Description** |
+|  ------ | ------ | ------ | ------ |
+|  Name | test-1 | test-2 | The name of the test database |
+|  Memory limit | 100 GB | 100 GB | The memory limit refers to RAM+Flash, aggregated across all the shards of the database, including master and replica shards. |
+|  RAM limit | 0.3 | 0.3 | RoF always keeps the Redis keys and Redis dictionary in RAM and additional RAM is required for storing hot values. For the purpose of these tests 30% RAM was calculated as an optimal value. |
+|  Replication | Enabled | Disabled | A database with no replication has only master shards. A database with replication has master and replica shards. |
+|  Data persistence | None | None | No data persistence is needed for these tests. |
+|  Database clustering | Enabled | Enabled | A clustered database consists of multiple shards. |
+|  Number of (master) shards | 2 | 4 | Shards are distributed as follows:<br/>- With replication: One master shard and one replica shard on each node<br/>- Without replication: Two master shards on each node |
+|  Other parameters | Default | Default | Keep the default values for the other configuration parameters. |
+
+## Data population
+
+### Populate the benchmark dataset
+
+The memtier_benchmark load generation tool populates the database.
+To populate the database with N items of 500 Bytes each in size, on the load generation instance run:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-maximum=$N -n allkeys -d 500 --key-pattern=P:P --ratio=1:0
+```
+
+Set up a test database:
+
+|  **Parameter** | **Description** |
+|  ------ | ------ |
+|  Database host<br/>(-s) | The fully qualified name of the endpoint or the IP shown in the RS database configuration |
+|  Database port<br/>(-p) | The endpoint port shown in your database configuration |
+|  Number of items<br/>(–key-maximum) | With replication: 75 Million<br/>Without replication: 150 Million |
+|  Item size<br/>(-d) | 500 Bytes |
+
+## Centralize the keyspace
+
+### With replication {#centralize-with-repl}
+
+To create roughly 20.5 million items in RAM for your highly available clustered database with 75 million items, run:
+
+```sh
+$ memtier_benchmark  -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-minimum=27250000 --key-maximum=47750000 -n allkeys
+--key-pattern=P:P --ratio=0:1
+```
+
+To verify the database values, use **Values in RAM** metric, which is available from the **Metrics** tab of your database in the Cluster Manager UI.
+
+### Without replication {#centralize-wo-repl}
+
+To create 41 million items in RAM without replication enabled and 150 million items, run:
+
+```sh
+$ memtier_benchmark  -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-minimum=54500000 --key-maximum=95500000 -n allkeys
+--key-pattern=P:P --ratio=0:1
+```
+
+## Test runs
+
+### Generate load
+
+#### With replication {#generate-with-repl}
+
+We recommend that you do a dry run and double check the RAM Hit Ratio on the **Metrics** screen in the Cluster Manager UI before you write down the test results.
+
+To test RoF with an 85% RAM Hit Ratio, run:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --pipeline=11 -c 20 -t 1
+-d 500 --key-maximum=75000000 --key-pattern=G:G --key-stddev=5125000
+--ratio=1:1 --distinct-client-seed --randomize --test-time=600
+--run-count=1 --out-file=test.out
+```
+
+#### Without replication {#generate-wo-repl}
+
+Here is the command for 150 million items:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --pipeline=24 -c 20 -t 1
+-d 500 --key-maximum=150000000 --key-pattern=G:G --key-stddev=10250000
+--ratio=1:1 --distinct-client-seed --randomize --test-time=600
+--run-count=1 --out-file=test.out
+```
+
+Where:
+
+|  **Parameter** | **Description** |
+|------------|-----------------|
+|  Access pattern (--key-pattern) and standard deviation (--key-stddev) | Controls the RAM Hit ratio after the centralization process is complete |
+|  Number of threads (-t and -c)\ | Controls how many connections are opened to the database, whereby the number of connections is the number of threads multiplied by the number of connections per thread (-t) and number of clients per thread (-c) |
+|  Pipelining (--pipeline)\ | Pipelining allows you to send multiple requests without waiting for each individual response (-t) and number of clients per thread (-c) |
+|  Read\write ratio (--ratio)\ | A value of 1:1 means that you have the same number of write operations as read operations (-t) and number of clients per thread (-c) |
+
+## Test results
+
+### Monitor the test results
+
+You can either monitor the results in the **Metrics** tab of the Cluster Manager UI or with the `memtier_benchmark` output.  However, be aware that:
+
+- The memtier_benchmark results include the network latency between the load generator instance and the cluster instances.
+
+- The metrics shown in the Cluster Manager UI do _not_ include network latency.
+
+### Expected results
+
+You should expect to see an average throughput of:
+
+- Around 160,000 ops/sec when testing without replication (i.e. Four master shards)
+- Around 115,000 ops/sec when testing with enabled replication (i.e. 2 master and 2 replica shards)
+
+In both cases, the average latency should be below one millisecond.
+---
+Title: Develop with Redis clients
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis client libraries allow you to connect to Redis instances from within
+  your application. This section provides an overview of several recommended Redis
+  clients for popular programming and scripting languages.
+hideListLinks: true
+linkTitle: Redis clients
+weight: 80
+url: '/operate/rs/7.4/references/client_references/'
+---
+To connect to Redis instances from within your application, use a Redis client library that matches your application's language.
+
+## Official clients
+
+| Language | Client name |
+| :---------- | :------------- |
+| .Net | [NRedisStack]({{< relref "/develop/clients/dotnet" >}}) |
+| Go | [go-redis]({{< relref "/develop/clients/go" >}}) |
+| Java | [Jedis]({{< relref "/develop/clients/jedis" >}}) (Synchronous) and [Lettuce]({{< relref "/develop/clients/lettuce" >}}) (Asynchronous) |
+| Node.js | [node-redis]({{< relref "/develop/clients/nodejs" >}}) |
+| Python | [redis-py]({{< relref "/develop/clients/redis-py" >}}) |
+
+Select a client name to see its quick start.
+
+## Other clients
+
+For a list of community-driven Redis clients, which are available for more programming languages, see
+[Community-supported clients]({{< relref "/develop/clients#community-supported-clients" >}}).
+---
+Title: Permissions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the permissions used with Redis Enterprise Software REST API
+  calls.
+linkTitle: Permissions
+weight: 60
+url: '/operate/rs/7.4/references/rest-api/permissions/'
+---
+
+Some Redis Enterprise [REST API requests]({{< relref "/operate/rs/7.4/references/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]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}) or a [<nobr>`PUT /v1/users/{uid}`</nobr> API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/users#put-user" >}}) 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.
+
+Available management roles include:
+
+- **none**: No REST API permissions.
+- **[db_viewer](#db-viewer-role)**: Can view database info.
+- **[db_member](#db-member-role)**: Can create or modify databases and view their info.
+- **[cluster_viewer](#cluster-viewer-role)**: Can view cluster and database info.
+- **[cluster_member](#cluster-member-role)**: Can modify the cluster and databases and view their info.
+- **[admin](#admin-role)**: Can view and modify all elements of the cluster.
+
+## Permissions list for each role
+
+| Role | Permissions |
+|------|-------------|
+| none | No permissions |
+| <a name="admin-role"></a>admin | [add_cluster_module](#add_cluster_module), [cancel_cluster_action](#cancel_cluster_action), [cancel_node_action](#cancel_node_action), [config_ldap](#config_ldap), [config_ocsp](#config_ocsp), [create_bdb](#create_bdb), [create_crdb](#create_crdb), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_redis_acl](#create_redis_acl), [create_role](#create_role), [delete_bdb](#delete_bdb), [delete_cluster_module](#delete_cluster_module), [delete_crdb](#delete_crdb), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [edit_bdb_module](#edit_bdb_module), [flush_crdb](#flush_crdb), [install_new_license](#install_new_license), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [start_cluster_action](#start_cluster_action), [start_node_action](#start_node_action), [test_ocsp_status](#test_ocsp_status), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_cluster](#update_cluster), [update_crdb](#update_crdb), [update_ldap_mapping](#update_ldap_mapping), [update_node](#update_node), [update_proxy](#update_proxy), [update_redis_acl](#update_redis_acl), [update_role](#update_role), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_ocsp_config](#view_ocsp_config), [view_ocsp_status](#view_ocsp_status), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info) |
+| <a name="cluster-member-role"></a>cluster_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+
+## Roles list per permission
+
+| Permission | Roles |
+|------------|-------|
+| <a name="add_cluster_module"></a>add_cluster_module| admin |
+| <a name="cancel_cluster_action"></a>cancel_cluster_action | admin |
+| <a name="cancel_node_action"></a>cancel_node_action | admin |
+| <a name="config_ldap"></a>config_ldap | admin |
+| <a name="config_ocsp"></a>config_ocsp | admin |
+| <a name="create_bdb"></a>create_bdb | admin<br />cluster_member<br />db_member |
+| <a name="create_crdb"></a>create_crdb | admin<br />cluster_member<br />db_member |
+| <a name="create_ldap_mapping"></a>create_ldap_mapping | admin |
+| <a name="create_new_user"></a>create_new_user | admin |
+| <a name="create_redis_acl"></a>create_redis_acl | admin |
+| <a name="create_role"></a>create_role | admin |
+| <a name="delete_bdb"></a>delete_bdb | admin<br />cluster_member<br />db_member |
+| <a name="delete_cluster_module"></a>delete_cluster_module | admin |
+| <a name="delete_crdb"></a>delete_crdb | admin<br />cluster_member<br />db_member |
+| <a name="delete_ldap_mapping"></a>delete_ldap_mapping | admin |
+| <a name="delete_redis_acl"></a>delete_redis_acl | admin |
+| <a name="delete_role"></a>delete_role | admin |
+| <a name="delete_user"></a>delete_user | admin |
+| <a name="edit_bdb_module"></a>edit_bdb_module | admin<br />cluster_member<br />db_member |
+| <a name="flush_crdb"></a>flush_crdb | admin<br />cluster_member<br />db_member |
+| <a name="install_new_license"></a>install_new_license | admin |
+| <a name="migrate_shard"></a>migrate_shard | admin<br />cluster_member<br />db_member |
+| <a name="purge_instance"></a>purge_instance | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_backup_status"></a>reset_bdb_current_backup_status | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_export_status"></a>reset_bdb_current_export_status | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_import_status"></a>reset_bdb_current_import_status | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_export"></a>start_bdb_export | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_import"></a>start_bdb_import | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_recovery"></a>start_bdb_recovery | admin<br />cluster_member<br />db_member |
+| <a name="start_cluster_action"></a>start_cluster_action | admin |
+| <a name="start_node_action"></a>start_node_action | admin |
+| <a name="test_ocsp_status"></a>test_ocsp_status | admin |
+| <a name="update_bdb"></a>update_bdb | admin<br />cluster_member<br />db_member |
+| <a name="update_bdb_alerts"></a>update_bdb_alerts | admin<br />cluster_member<br />db_member |
+| <a name="update_bdb_with_action"></a>update_bdb_with_action | admin<br />cluster_member<br />db_member |
+| <a name="update_cluster"></a>update_cluster | admin |
+| <a name="update_crdb"></a>update_crdb | admin<br />cluster_member<br />db_member |
+| <a name="update_ldap_mapping"></a>update_ldap_mapping | admin |
+| <a name="update_node"></a>update_node | admin |
+| <a name="update_proxy"></a>update_proxy | admin |
+| <a name="update_redis_acl"></a>update_redis_acl | admin |
+| <a name="update_role"></a>update_role | admin |
+| <a name="update_user"></a>update_user | admin |
+| <a name="view_all_bdb_stats"></a>view_all_bdb_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_bdbs_alerts"></a>view_all_bdbs_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_bdbs_info"></a>view_all_bdbs_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_ldap_mappings_info"></a>view_all_ldap_mappings_info | admin |
+| <a name="view_all_nodes_alerts"></a>view_all_nodes_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_nodes_checks"></a>view_all_nodes_checks | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_nodes_info"></a>view_all_nodes_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_nodes_stats"></a>view_all_nodes_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_proxies_info"></a>view_all_proxies_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_redis_acls_info"></a>view_all_redis_acls_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_roles_info"></a>view_all_roles_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_shard_stats"></a>view_all_shard_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_all_users_info"></a>view_all_users_info | admin |
+| <a name="view_bdb_alerts"></a>view_bdb_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |<a
+| <a name="view_bdb_info"></a>view_bdb_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_bdb_recovery_plan"></a>view_bdb_recovery_plan | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_bdb_stats"></a>view_bdb_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_cluster_alerts"></a>view_cluster_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_cluster_info"></a>view_cluster_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_cluster_keys"></a>view_cluster_keys | admin<br />cluster_member |
+| <a name="view_cluster_modules"></a>view_cluster_modules | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_cluster_stats"></a>view_cluster_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_crdb"></a>view_crdb | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_crdb_list"></a>view_crdb_list | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_crdb_task"></a>view_crdb_task | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_crdb_task_list"></a>view_crdb_task_list | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_debugging_info"></a>view_debugging_info | admin<br />cluster_member<br />db_member<br /> |
+| <a name="view_endpoint_stats"></a>view_endpoint_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_ldap_config"></a>view_ldap_config | admin |
+| <a name="view_ldap_mapping_info"></a>view_ldap_mapping_info | admin |
+| <a name="view_license"></a>view_license | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_logged_events"></a>view_logged_events | admin<br />cluster_member<br />cluster_viewer<br />db_member |
+| <a name="view_node_alerts"></a>view_node_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_node_check"></a>view_node_check | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_node_info"></a>view_node_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_node_stats"></a>view_node_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_ocsp_config"></a>view_ocsp_config | admin |
+| <a name="view_ocsp_status"></a>view_ocsp_status | admin |
+| <a name="view_proxy_info"></a>view_proxy_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_redis_acl_info"></a>view_redis_acl_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_redis_pass"></a>view_redis_pass | admin<br />cluster_member<br />db_member |
+| <a name="view_role_info"></a>view_role_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_shard_stats"></a>view_shard_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_status_of_all_node_actions"></a>view_status_of_all_node_actions | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_status_of_cluster_action"></a>view_status_of_cluster_action | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_status_of_node_action"></a>view_status_of_node_action | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+| <a name="view_user_info"></a>view_user_info | admin |
+---
+Title: Redis Enterprise Software REST API quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software REST API quick start
+linkTitle: Quick start
+weight: 20
+url: '/operate/rs/7.4/references/rest-api/quick-start/'
+---
+
+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.
+
+| Type | Description |
+|------|-------------|
+| [Authentication]({{< relref "/operate/rs/7.4/references/rest-api#authentication" >}}) | Use [Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication) with your cluster username (email) and password |
+| [Ports]({{< relref "/operate/rs/7.4/references/rest-api#ports" >}}) | All calls are made to port 9443 by default |
+| [Versions]({{< relref "/operate/rs/7.4/references/rest-api#versions" >}}) | Specify the version in the request [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) |
+| [Headers]({{< relref "/operate/rs/7.4/references/rest-api#headers" >}}) | `Accept` and `Content-Type` should be `application/json` |
+| [Response types and error codes]({{< relref "/operate/rs/7.4/references/rest-api#response-types-and-error-codes" >}}) | A response of `200 OK` means success; otherwise, the request failed due to an error |  
+
+For more information, see [Redis Enterprise Software REST API]({{< relref "/operate/rs/7.4/references/rest-api/" >}}).
+
+## cURL example requests
+
+[cURL](https://curl.se/) is a command-line tool that allows you to send HTTP requests from a terminal.
+
+You can use the following options to build a cURL request:
+
+| Option | Description |
+|--------|-------------|
+| -X     | Method (GET, PUT, PATCH, POST, or DELETE) |
+| -H     | Request header, can be specified multiple times |
+| -u     | Username and password information |
+| -d     | JSON data for PUT or POST requests |
+| -F     | Form data for PUT or POST requests, such as for the [`POST /v1/modules`]({{< relref "/operate/rs/7.4/references/rest-api/requests/modules/#post-module" >}}) or [`POST /v2/modules`]({{< relref "/operate/rs/7.4/references/rest-api/requests/modules/#post-module-v2" >}}) endpoint |
+| -k     | Turn off SSL  verification |
+| -i     | Show headers and status code as well as the response body |
+
+See the [cURL documentation](https://curl.se/docs/) for more information.
+
+### GET request
+
+Use the following cURL command to get a list of databases with the [GET `/v1/bdbs/`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#get-all-bdbs" >}}) endpoint.
+
+```sh
+$ curl -X GET -H "accept: application/json" \
+              -u "[username]:[password]" \
+              https://[host][:port]/v1/bdbs -k -i
+
+HTTP/1.1 200 OK
+server: envoy
+date: Tue, 14 Jun 2022 19:24:30 GMT
+content-type: application/json
+content-length: 2833
+cluster-state-id: 42
+x-envoy-upstream-service-time: 25
+
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+```
+
+In the response body, the `uid` is the database ID. You can use the database ID to view or update the database using the API.
+
+For more information about the fields returned by [GET `/v1/bdbs/`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#get-all-bdbs" >}}), see the [`bdbs` object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/" >}}).
+
+### PUT request
+
+Once you have the database ID, you can use [PUT `/v1/bdbs/`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#put-bdbs" >}}) to update the configuration of the database.
+
+For example, you can pass the database `uid` 1 as a URL parameter and use the `-d` option to specify the new `name` when you send the request. This changes the database's `name` from `tr01` to `database1`:
+
+```sh
+$ curl -X PUT -H "accept: application/json" \
+            -H "content-type: application/json" \
+            -u "cameron.bates@redis.com:test123" \
+            https://[host]:[port]/v1/bdbs/1 \
+            -d '{ "name": "database1" }' -k -i
+HTTP/1.1 200 OK
+server: envoy
+date: Tue, 14 Jun 2022 20:00:25 GMT
+content-type: application/json
+content-length: 2933
+cluster-state-id: 43
+x-envoy-upstream-service-time: 159
+
+{
+    ...
+    "name" : "database1",
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+For more information about the fields you can update with [PUT `/v1/bdbs/`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#put-bdbs" >}}), see the [`bdbs` object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/" >}}).
+
+## Client examples
+
+You can also use client libraries to make API requests in your preferred language.
+
+To follow these examples, you need:
+
+- A [Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}) node
+- Python 3 and the [requests](https://pypi.org/project/requests/) Python library
+- [node.js](https://nodejs.dev/) and [node-fetch](https://www.npmjs.com/package/node-fetch)
+
+### Python
+
+```python
+import json
+import requests
+
+# Required connection information - replace with your host, port, username, and password
+host = "[host]"
+port = "[port]"
+username = "[username]"
+password = "[password]"
+
+# Get the list of databases using GET /v1/bdbs
+bdbs_uri = "https://{}:{}/v1/bdbs".format(host, port)
+
+print("GET {}".format(bdbs_uri))
+get_resp = requests.get(bdbs_uri,
+        auth = (username, password),
+        headers = { "accept" : "application/json" },
+        verify = False)
+
+print("{} {}".format(get_resp.status_code, get_resp.reason))
+for header in get_resp.headers.keys():
+    print("{}: {}".format(header, get_resp.headers[header]))
+
+print("\n" + json.dumps(get_resp.json(), indent=4))
+
+# Rename all databases using PUT /v1/bdbs
+for bdb in get_resp.json():
+    uid = bdb["uid"] # Get the database ID from the JSON response
+
+    put_uri = "{}/{}".format(bdbs_uri, uid)
+    new_name = "database{}".format(uid)
+    put_data = { "name" : new_name }
+
+    print("PUT {} {}".format(put_uri, json.dumps(put_data)))
+
+    put_resp = requests.put(put_uri,
+        data = json.dumps(put_data),
+        auth = (username, password),
+        headers = { "content-type" : "application/json" },
+        verify = False)
+
+    print("{} {}".format(put_resp.status_code, put_resp.reason))
+    for header in put_resp.headers.keys():
+        print("{}: {}".format(header, put_resp.headers[header]))
+
+    print("\n" + json.dumps(put_resp.json(), indent=4))
+```
+
+See the [Python requests library documentation](https://requests.readthedocs.io/en/latest/) for more information.
+
+#### Output
+
+```sh
+$ python rs_api.py
+python rs_api.py
+GET https://[host]:[port]/v1/bdbs
+InsecureRequestWarning: Unverified HTTPS request is being made to host '[host]'.
+Adding certificate verification is strongly advised.
+See: https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+  warnings.warn(
+200 OK
+server: envoy
+date: Wed, 15 Jun 2022 15:49:43 GMT
+content-type: application/json
+content-length: 2832
+cluster-state-id: 89
+x-envoy-upstream-service-time: 27
+
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+
+PUT https://[host]:[port]/v1/bdbs/1 {"name": "database1"}
+InsecureRequestWarning: Unverified HTTPS request is being made to host '[host]'.
+Adding certificate verification is strongly advised.
+See: https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+  warnings.warn(
+200 OK
+server: envoy
+date: Wed, 15 Jun 2022 15:49:43 GMT
+content-type: application/json
+content-length: 2933
+cluster-state-id: 90
+x-envoy-upstream-service-time: 128
+
+{
+    ...
+    "name" : "database1",
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+### node.js
+
+```js
+import fetch, { Headers } from 'node-fetch';
+import * as https from 'https';
+
+const HOST = '[host]';
+const PORT = '[port]';
+const USERNAME = '[username]';
+const PASSWORD = '[password]';
+
+// Get the list of databases using GET /v1/bdbs
+const BDBS_URI = `https://${HOST}:${PORT}/v1/bdbs`;
+const USER_CREDENTIALS = Buffer.from(`${USERNAME}:${PASSWORD}`).toString('base64');
+const AUTH_HEADER = `Basic ${USER_CREDENTIALS}`;
+
+console.log(`GET ${BDBS_URI}`);
+
+const HTTPS_AGENT = new https.Agent({
+    rejectUnauthorized: false
+});
+
+const response = await fetch(BDBS_URI, {
+    method: 'GET',
+    headers: {
+        'Accept': 'application/json',
+        'Authorization': AUTH_HEADER
+    },
+    agent: HTTPS_AGENT
+});
+
+const responseObject = await response.json();
+console.log(`${response.status}: ${response.statusText}`);
+console.log(responseObject);
+
+// Rename all databases using PUT /v1/bdbs
+for (const database of responseObject) {
+    const DATABASE_URI = `${BDBS_URI}/${database.uid}`;
+    const new_name = `database${database.uid}`;
+
+    console.log(`PUT ${DATABASE_URI}`);
+
+    const response = await fetch(DATABASE_URI, {
+        method: 'PUT',
+        headers: {
+            'Authorization': AUTH_HEADER,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            'name': new_name
+        }),
+        agent: HTTPS_AGENT
+    });
+
+    console.log(`${response.status}: ${response.statusText}`);
+    console.log(await(response.json()));
+}
+```
+
+See the [node-fetch documentation](https://www.npmjs.com/package/node-fetch) for more info.
+
+#### Output
+
+```sh
+$ node rs_api.js
+GET https://[host]:[port]/v1/bdbs
+200: OK
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "slave_ha" : false,
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+PUT https://[host]:[port]/v1/bdbs/1
+200: OK
+{
+    ...
+    "name" : "tr01",
+    ...
+    "slave_ha" : true,
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+## More info
+
+- [Redis Enterprise Software REST API]({{< relref "/operate/rs/7.4/references/rest-api/" >}})
+- [Redis Enterprise Software REST API requests]({{< relref "/operate/rs/7.4/references/rest-api/requests/" >}})
+---
+Title: DB metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the DB metrics used with Redis Enterprise Software REST API
+  calls.
+linkTitle: DB metrics
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/statistics/db-metrics/'
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| avg_latency | float | Average latency of operations on the DB (microseconds). Only returned when there is traffic. |
+| avg_other_latency | float | Average latency of other (non read/write) operations (microseconds). Only returned when there is traffic. |
+| avg_read_latency | float | Average latency of read operations (microseconds). Only returned when there is traffic. |
+| avg_write_latency | float | Average latency of write operations (microseconds). Only returned when there is traffic. |
+| big_del_flash | float | Rate of key deletes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_del_ram | float | Rate of key deletes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| big_fetch_flash | float | Rate of key reads/updates for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_fetch_ram | float | Rate of key reads/updates for keys in RAM (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_flash | float | Rate of key operations on flash. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_redis | float | Rate of Redis operations on keys. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_flash | float | Rate of key writes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_ram | float | Rate of key writes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| bigstore_io_dels | float | Rate of key deletions from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_read_bytes | float | Throughput of I/O read operations against backend flash |for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_reads | float | Rate of key reads from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_write_bytes | float | Throughput of I/O write operations against backend flash |for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_writes | float | Rate of key writes from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards of the DB (BigRedis) (ops/sec). Only returned when BigRedis is enabled. |
+| bigstore_kv_ops | float | Rate of value read/write/del operations against backend flash for all shards of the DB (BigRedis) (key access/sec). Only returned when BigRedis is enabled |
+| bigstore_objs_flash | float | Value count on flash (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_objs_ram | float | Value count in RAM (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| conns | float | Number of client connections to the DB’s endpoints |
+| disk_frag_ratio | float | Flash fragmentation ratio (used/required). Only returned when BigRedis is enabled. |
+| egress_bytes | float | Rate of outgoing network traffic to the DB’s endpoint (bytes/sec) |
+| evicted_objects | float | Rate of key evictions from DB (evictions/sec) |
+| expired_objects | float | Rate keys expired in DB (expirations/sec) |
+| fork_cpu_system | float | % cores utilization in system mode for all Redis shard fork child processes of this database |
+| fork_cpu_user | float | % cores utilization in user mode for all Redis shard fork child processes of this database |
+| ingress_bytes | float | Rate of incoming network traffic to the DB’s endpoint (bytes/sec) |
+| instantaneous_ops_per_sec | float | Request rate handled by all shards of the DB (ops/sec) |
+| last_req_time | date, ISO_8601 format | Last request time received to the DB (ISO format 2015-07-05T22:16:18Z). Returns 1/1/1970 when unavailable. |
+| last_res_time | date, ISO_8601 format | Last response time received from DB (ISO format 2015-07-05T22:16:18Z). Returns 1/1/1970 when unavailable. |
+| main_thread_cpu_system | float | % cores utilization in system mode for all Redis shard main threads of this database |
+| main_thread_cpu_user | float | % cores utilization in user mode for all Redis shard main threads of this database |
+| mem_frag_ratio | float | RAM fragmentation ratio (RSS/allocated RAM) |
+| mem_not_counted_for_evict | float | Portion of used_memory (in bytes) not counted for eviction and OOM errors |
+| mem_size_lua | float | Redis Lua scripting heap size (bytes) |
+| monitor_sessions_count | float | Number of client connected in monitor mode to the DB |
+| no_of_expires | float | Number of volatile keys in the DB |
+| no_of_keys | float | Number of keys in the DB |
+| other_req | float | Rate of other (non read/write) requests on DB (ops/sec) |
+| other_res | float | Rate of other (non read/write) responses on DB (ops/sec) |
+| pubsub_channels | float | Count the pub/sub channels with subscribed clients |
+| pubsub_patterns | float | Count the pub/sub patterns with subscribed clients |
+| ram_overhead | float | Non values RAM overhead (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| read_hits | float | Rate of read operations accessing an existing key (ops/sec) |
+| read_misses | float | Rate of read operations accessing a nonexistent key (ops/sec) |
+| read_req | float | Rate of read requests on DB (ops/sec) |
+| read_res | float | Rate of read responses on DB (ops/sec) |
+| shard_cpu_system | float | % cores utilization in system mode for all Redis shard processes of this database |
+| shard_cpu_user | float | % cores utilization in user mode for the Redis shard process |
+| total_connections_received | float | Rate of new client connections to the DB (connections/sec) |
+| total_req | float | Rate of all requests on DB (ops/sec) |
+| total_res | float | Rate of all responses on DB (ops/sec) |
+| used_bigstore | float | Flash used by DB (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| used_memory | float | Memory used by DB (in BigRedis this includes flash) (bytes) |
+| used_ram | float | RAM used by DB (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| write_hits | float | Rate of write operations accessing an existing key (ops/sec) |
+| write_misses | float | Rate of write operations accessing a nonexistent key (ops/sec) |
+| write_req | float | Rate of write requests on DB (ops/sec) |
+| write_res | float | Rate of write responses on DB (ops/sec) |
+---
+Title: Node metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node metrics used with Redis Enterprise Software REST API
+  calls.
+linkTitle: node metrics
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/statistics/node-metrics/'
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| available_flash | float | Available flash on the node (bytes) |
+| available_memory | float | Available RAM on the node (bytes) |
+| avg_latency | float | Average latency of requests handled by endpoints on the node (micro-sec); returned only when there is traffic |
+| bigstore_free | float | Free space of backend flash (used by flash DB's BigRedis) (bytes); returned only when BigRedis is enabled |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (ops/sec); returned only when BigRedis is enabled |
+| bigstore_kv_ops | float | Rate of value read/write operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (ops/sec); returned only when BigRedis is enabled |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (bytes/sec); returned only when BigRedis is enabled |
+| conns | float | Number of clients connected to endpoints on the node |
+| cpu_idle | float | CPU idle time portion (0-1, multiply by 100 to get percent) |
+| cpu_system | float | CPU time portion spent in kernel (0-1, multiply by 100 to get percent) |
+| cpu_user | float | CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| cur_aof_rewrites | float | Number of current AOF rewrites by shards on this node |
+| egress_bytes | float | Rate of outgoing network traffic to the node (bytes/sec) |
+| ephemeral_storage_avail | float | Disk space available to Redis Enterprise processes on configured ephemeral disk (bytes) |
+| ephemeral_storage_free | float | Free disk space on configured ephemeral disk (bytes) |
+| free_memory | float | Free memory on the node (bytes) |
+| ingress_bytes | float | Rate of incoming network traffic to the node (bytes/sec) |
+| persistent_storage_avail | float | Disk space available to Redis Enterprise processes on configured persistent disk (bytes) |
+| persistent_storage_free | float | Free disk space on configured persistent disk (bytes) |
+| provisional_flash | float | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| provisional_memory | float | Amount of RAM available for new shards on this node, taking into account overbooking, max Redis servers, reserved memory, and provision and migration thresholds (bytes) |
+| total_req | float | Request rate handled by endpoints on the node (ops/sec) |
+---
+Title: Cluster metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster metrics used with Redis Enterprise Software REST
+  API calls.
+linkTitle: cluster metrics
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/statistics/cluster-metrics/'
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| available_flash | float | Sum of available flash in all nodes (bytes) |
+| available_memory | float | Sum of available memory in all nodes (bytes) |
+| avg_latency | float | Average latency of requests handled by all cluster endpoints (micro-sec); returned only when there is traffic |
+| bigstore_free | float | Sum of free space of backend flash (used by flash DB's BigRedis) on all cluster nodes (bytes); only returned when BigRedis is enabled |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| bigstore_kv_ops | float | Rate of value read/write operations against back-end flash for all shards which are part of a flash based DB (BigRedis) in cluster (ops/sec); only returned when BigRedis is enabled |
+| bigstore_throughput | float | Throughput I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) in the cluster (bytes/sec); only returned when BigRedis is enabled |
+| conns | float | Total number of clients connected to all cluster endpoints |
+| cpu_idle | float | CPU idle time portion, the value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent) |
+| cpu_system | float | CPU time portion spent in kernel on the cluster, the value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent) |
+| cpu_user | float | CPU time portion spent by users-pace processes on the cluster. The value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent). |
+| egress_bytes | float | Sum of rate of outgoing network traffic on all cluster nodes (bytes/sec) |
+| ephemeral_storage_avail | float | Sum of disk space available to Redis Enterprise processes on configured ephemeral disk on all cluster nodes (bytes) |
+| ephemeral_storage_free | float | Sum of free disk space on configured ephemeral disk on all cluster nodes (bytes) |
+| free_memory | float | Sum of free memory in all cluster nodes (bytes) |
+| ingress_bytes | float | Sum of rate of incoming network traffic on all cluster nodes (bytes/sec) |
+| persistent_storage_avail | float | Sum of disk space available to Redis Enterprise processes on configured persistent disk on all cluster nodes (bytes) |
+| persistent_storage_free | float | Sum of free disk space on configured persistent disk on all cluster nodes (bytes) |
+| provisional_flash | float | Sum of provisional flash in all nodes (bytes) |
+| provisional_memory | float | Sum of provisional memory in all nodes (bytes) |
+| total_req | float | Request rate handled by all endpoints on the cluster (ops/sec) |
+---
+Title: Statistics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains metrics for clusters, databases, nodes, or shards
+hideListLinks: true
+linkTitle: statistics
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/statistics/'
+---
+
+## Statistics overview
+
+Clusters, databases, nodes, and shards collect various statistics at regular time intervals. View the statistics for these objects using `GET stats` requests to their respective endpoints:
+- [Cluster stats]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/stats" >}})
+- [Database stats]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/stats" >}})
+- [Node stats]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/stats" >}})
+- [Shard stats]({{< relref "/operate/rs/7.4/references/rest-api/requests/shards/stats" >}})
+
+View endpoint stats using `GET` requests, see:
+- [Endpoint stats]({{< relref "/operate/rs/7.4/references/rest-api/requests/endpoints-stats" >}})
+
+### Response object
+
+Statistics returned from API requests always contain the following fields:
+- `interval`: a string that represents the statistics time interval. Valid values include: 
+    - 1sec
+    - 10sec
+    - 5min
+    - 15min
+    - 1hour
+    - 12hour
+    - 1week
+- `stime`: a timestamp that represents the beginning of the interval, in the format "2015-05-27T12:00:00Z"
+- `etime`: a timestamp that represents the end of the interval, in the format "2015-05-27T12:00:00Z"
+
+The statistics returned by the API also contain fields that represent the values of different metrics for an object during the specified time interval.
+
+More details about the metrics relevant to each object:
+- [Cluster metrics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics/cluster-metrics" >}})
+- [DB metrics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics/db-metrics" >}})
+- [Node metrics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics/node-metrics" >}})
+- [Shard metrics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics/shard-metrics" >}})
+
+{{<note>}}
+Certain statistics are not documented because they are for internal use only and should be ignored. Some statistics will only appear in API responses when they are relevant.
+{{</note>}}
+
+### Optional URL parameters
+
+There are several optional URL parameters you can pass to the various `GET stats` requests to filter the returned statistics.
+
+- `stime`: limit the start of the time range of the returned statistics
+- `etime`: limit the end of the time range of the returned statistics
+- `metrics`: only return the statistics for the specified metrics (comma-separated list)
+
+## Maximum number of samples per interval
+
+The system retains a maximum number of most recent samples for each interval.
+
+| Interval | Max samples |
+|----------|-------------|
+| 1sec     | 10 |
+| 10sec    | 30 |
+| 5min     | 12 |
+| 15min    | 96 |
+| 1hour    | 168 |
+| 12hour   | 62 |
+| 1week    | 53 |
+
+The actual number of samples returned by a `GET stats` request depends on how many samples are available and any filters applied by the optional URL parameters. For example, newly created objects (clusters, nodes, databases, or shards) or a narrow time filter range will return fewer samples.
+
+{{<note>}}
+To reduce load generated by stats collection, relatively inactive databases or shards (less than 5 ops/sec) do not collect 1sec stats at one second intervals. Instead, they collect 1sec stats every 2-5 seconds but still retain the same maximum number of samples.
+{{</note>}}
+---
+Title: Shard metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the shard metrics used with Redis Enterprise Software REST
+  API calls.
+linkTitle: shard metrics
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/statistics/shard-metrics/'
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| aof_rewrite_inprog | float | The number of simultaneous AOF rewrites that are in progress |
+| avg_ttl | float | Estimated average time to live of a random key (msec) |
+| big_del_flash | float | Rate of key deletes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_del_ram | float | Rate of key deletes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| big_fetch_flash | float | Rate of key reads/updates for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_fetch_ram | float | Rate of key reads/updates for keys in RAM (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_flash | float | Rate of key operations on flash. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_redis | float | Rate of Redis operations on keys. Can be used to compute the ratio of I/O operations) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_flash | float | Rate of key writes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_ram | float | Rate of key writes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| bigstore_io_dels | float | Rate of key deletions from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_read_bytes | float | Throughput of I/O read operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_reads | float | Rate of key reads from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_write_bytes | float | Throughput of I/O write operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_writes | float | Rate of key writes from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards of the DB (BigRedis) (ops/sec). Only returned when BigRedis is enabled. |
+| bigstore_kv_ops | float | Rate of value read/write/del operations against backend flash for all shards of the DB (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_objs_flash | float | Key count on flash (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_objs_ram | float | Key count in RAM (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| blocked_clients | float | Count the clients waiting on a blocking call |
+| connected_clients | float | Number of client connections to the specific shard |
+| disk_frag_ratio | float | Flash fragmentation ratio (used/required). Only returned when BigRedis is enabled. |
+| evicted_objects | float | Rate of key evictions from DB (evictions/sec) |
+| expired_objects | float | Rate keys expired in DB (expirations/sec) |
+| fork_cpu_system | float | % cores utilization in system mode for the Redis shard fork child process |
+| fork_cpu_user | float | % cores utilization in user mode for the Redis shard fork child process |
+| last_save_time | float | Time of the last RDB save |
+| main_thread_cpu_system | float | % cores utilization in system mode for the Redis shard main thread |
+| main_thread_cpu_user | float | % cores utilization in user mode for the Redis shard main thread |
+| mem_frag_ratio | float | RAM fragmentation ratio (RSS/allocated RAM) |
+| mem_not_counted_for_evict | float | Portion of used_memory (in bytes) not counted for eviction and OOM errors |
+| mem_size_lua | float | Redis Lua scripting heap size (bytes) |
+| no_of_expires | float | Number of volatile keys on the shard |
+| no_of_keys | float | Number of keys in DB |
+| pubsub_channels | float | Count the pub/sub channels with subscribed clients |
+| pubsub_patterns | float | Count the pub/sub patterns with subscribed clients |
+| rdb_changes_since_last_save | float | Count changes since last RDB save |
+| read_hits | float | Rate of read operations accessing an existing key (ops/sec) |
+| read_misses | float | Rate of read operations accessing a nonexistent key (ops/sec) |
+| shard_cpu_system | float | % cores utilization in system mode for the Redis shard process |
+| shard_cpu_user | float | % cores utilization in user mode for the Redis shard process |
+| total_req | float | Rate of operations on DB (ops/sec) |
+| used_memory | float | Memory used by shard (in BigRedis this includes flash) (bytes) |
+| used_memory_peak | float | The largest amount of memory used by this shard (bytes) |
+| used_memory_rss | float | Resident set size of this shard (bytes) |
+| write_hits | float | Rate of write operations accessing an existing key (ops/sec) |
+| write_misses | float | Rate of write operations accessing a nonexistent key (ops/sec) |
+---
+Title: Alert settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the alert_settings object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: alert_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/cluster/alert_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cluster_certs_about_to_expire | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Cluster certificate will expire in x days |
+| cluster_even_node_count | boolean (default:&nbsp;false) | True high availability requires an odd number of nodes in the cluster |
+| cluster_flash_overcommit | boolean (default:&nbsp;false) | Flash memory committed to databases is larger than cluster total flash memory |
+| cluster_inconsistent_redis_sw | boolean (default:&nbsp;false) | Some shards in the cluster are running different versions of Redis software |
+| cluster_inconsistent_rl_sw | boolean (default:&nbsp;false) | Some nodes in the cluster are running different versions of Redis Enterprise software |
+| cluster_internal_bdb | boolean (default:&nbsp;false) | Issues with internal cluster databases |
+| cluster_multiple_nodes_down | boolean (default:&nbsp;false) | Multiple cluster nodes are down (this might cause data loss) |
+| cluster_node_joined | boolean (default:&nbsp;false) | New node joined the cluster |
+| cluster_node_remove_abort_completed | boolean (default:&nbsp;false) | Cancel node remove operation completed |
+| cluster_node_remove_abort_failed | boolean (default:&nbsp;false) | Cancel node remove operation failed |
+| cluster_node_remove_completed | boolean (default:&nbsp;false) | Node removed from the cluster |
+| cluster_node_remove_failed | boolean (default:&nbsp;false) | Failed to remove a node from the cluster |
+| cluster_ocsp_query_failed | boolean (default:&nbsp;false) | Failed to query the OCSP server |
+| cluster_ocsp_status_revoked | boolean (default:&nbsp;false) | OCSP certificate status is REVOKED |
+| cluster_ram_overcommit | boolean (default:&nbsp;false) | RAM committed to databases is larger than cluster total RAM |
+| cluster_too_few_nodes_for_replication | boolean (default:&nbsp;false) | Replication requires at least 2 nodes in the cluster |
+| node_aof_slow_disk_io | boolean (default:&nbsp;false) | AOF reaching disk I/O limits
+| node_checks_error | boolean (default:&nbsp;false) | Some node checks have failed |
+| node_cpu_utilization | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node CPU utilization has reached the threshold value (% of the utilization limit) |
+| node_ephemeral_storage | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node ephemeral storage has reached the threshold value (% of the storage limit) |
+| node_failed | boolean (default:&nbsp;false) | Node failed |
+| node_free_flash | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node flash storage has reached the threshold value (% of the storage limit) |
+| node_insufficient_disk_aofrw | boolean (default:&nbsp;false) | Insufficient AOF disk space |
+| node_internal_certs_about_to_expire | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object| Internal certificate on node will expire in x days |
+| node_memory | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node memory has reached the threshold value (% of the memory limit) |
+| node_net_throughput | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node network throughput has reached the threshold value (bytes/s) |
+| node_persistent_storage | [cluster_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}}) object | Node persistent storage has reached the threshold value (% of the storage limit) |
+---
+Title: Cluster alert settings with threshold object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster_alert_settings_with_threshold object used with
+  Redis Enterprise Software REST API calls.
+linkTitle: cluster_alert_settings_with_threshold
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| enabled    | boolean (default:&nbsp;false)  | Alert enabled or disabled |
+| threshold  | string                    | Threshold for alert going on/off |
+---
+Title: Cluster object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a cluster
+hideListLinks: true
+linkTitle: cluster
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/cluster/'
+---
+
+An API object that represents the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| alert_settings | [alert_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster/alert_settings" >}}) object | Cluster and node alert settings |
+| bigstore_driver | 'speedb'<br />'rocksdb' | Storage engine for Auto Tiering |
+| cluster_ssh_public_key | string | Cluster's autogenerated SSH public key |
+| cm_port | integer, (range:&nbsp;1024-65535) | UI HTTPS listening port |
+| cm_session_timeout_minutes | integer (default:&nbsp;15) | The timeout (in minutes) for the session to the CM |
+| cnm_http_max_threads_per_worker | integer (default: 10) | Maximum number of threads per worker in the `cnm_http` service (deprecated) |
+| cnm_http_port | integer, (range:&nbsp;1024-65535) | API HTTP listening port |
+| cnm_http_workers | integer (default: 1) | Number of workers in the `cnm_http` service |
+| cnm_https_port | integer, (range:&nbsp;1024-65535) | API HTTPS listening port |
+| control_cipher_suites | string | Specifies the enabled ciphers for the control plane. The ciphers are specified in the format understood by the BoringSSL library. |
+| control_cipher_suites_tls_1_3 | string | Specifies the enabled TLS 1.3 ciphers for the control plane. The ciphers are specified in the format understood by the BoringSSL library. (read-only) |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| crdt_rest_client_retries | integer | Maximum number of retries for the REST client used by the Active-Active management API |
+| crdt_rest_client_timeout | integer | Timeout for REST client used by the Active-Active management API |
+| created_time | string | Cluster creation date (read-only) |
+| data_cipher_list | string | Specifies the enabled ciphers for the data plane. The ciphers are specified in the format understood by the OpenSSL library. |
+| data_cipher_suites_tls_1_3 | string | Specifies the enabled TLS 1.3 ciphers for the data plane. |
+| debuginfo_path | string | Path to a local directory used when generating support packages |
+| default_non_sharded_proxy_policy | string (default:&nbsp;single) | Default proxy_policy for newly created non-sharded databases' endpoints (read-only) |
+| default_sharded_proxy_policy | string (default:&nbsp;all-master-shards) | Default proxy_policy for newly created sharded databases' endpoints (read-only) |
+| email_alerts | boolean (default:&nbsp;false) | Send node/cluster email alerts (requires valid SMTP and email_from settings) |
+| email_from | string | Sender email for automated emails |
+| encrypt_pkeys | boolean (default:&nbsp;false) | Enable or turn off encryption of private keys |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| envoy_max_downstream_connections | integer, (range:&nbsp;100-2048) | The max downstream connections envoy is allowed to open |
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| handle_redirects | boolean (default:&nbsp;false) | Handle API HTTPS requests and redirect to the master node internally |
+| http_support | boolean (default:&nbsp;false) | Enable or turn off HTTP support |
+| min_control_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the control path |
+| min_data_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the data path |
+| min_sentinel_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the data path |
+| name | string | Cluster's fully qualified domain name (read-only) |
+| password_complexity | boolean (default:&nbsp;false) | Enforce password complexity policy |
+| password_expiration_duration | integer (default:&nbsp;0) | The number of days a password is valid until the user is required to replace it |
+| proxy_certificate | string | Cluster's proxy certificate |
+| proxy_max_ccs_disconnection_time | integer | Cluster-wide proxy timeout policy between proxy and CCS |
+| rack_aware | boolean | Cluster operates in a rack-aware mode (read-only) |
+| reserved_ports | array of strings | List of reserved ports and/or port ranges to avoid using for database endpoints (for example `"reserved_ports": ["11000", "13000-13010"]`) |
+| s3_url | string | Specifies the URL for S3 export and import |
+| saslauthd_ldap_conf | string | saslauthd LDAP configuration |
+| sentinel_cipher_suites | array | Specifies the list of enabled ciphers for the sentinel service. The supported ciphers are those implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package. |
+| sentinel_cipher_suites_tls_1_3 | string | Specifies the list of enabled TLS 1.3 ciphers for the discovery (sentinel) service. The supported ciphers are those implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package.(read-only) |
+| sentinel_tls_mode | 'allowed'<br />'disabled' <br />'required' | Determines whether the discovery service allows, blocks, or requires TLS connections (previously named `sentinel_ssl_policy`)<br />**allowed**: Allows both TLS and non-TLS connections<br />**disabled**: Allows only non-TLS connections<br />**required**: Allows only TLS connections |
+| slave_ha | boolean (default:&nbsp;false) | Enable the replica high-availability mechanism (read-only) |
+| slave_ha_bdb_cooldown_period | integer (default:&nbsp;86400) | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database (read-only) |
+| slave_ha_cooldown_period | integer (default:&nbsp;3600) | Time in seconds between runs of the replica high-availability mechanism on different nodes (read-only) |
+| slave_ha_grace_period | integer (default:&nbsp;900) | Time in seconds between a node failure and when the replica high-availability mechanism starts relocating shards (read-only) |
+| slowlog_in_sanitized_support | boolean | Whether to include slowlogs in the sanitized support package |
+| smtp_host | string | SMTP server for automated emails |
+| smtp_password | string | SMTP server password |
+| smtp_port | integer | SMTP server port for automated emails |
+| smtp_tls_mode | 'none'<br />'starttls'<br />'tls' | Specifies which TLS mode to use for SMTP access |
+| smtp_use_tls | boolean (default:&nbsp;false) | Use TLS for SMTP access (deprecated as of Redis Enterprise v4.3.3, use smtp_tls_mode field instead) |
+| smtp_username | string | SMTP server username (pattern does not allow special characters &,\<,>,") |
+| syncer_certificate | string | Cluster's syncer certificate |
+| upgrade_mode | boolean (default:&nbsp;false) | Is cluster currently in upgrade mode |
+| use_external_ipv6 | boolean (default:&nbsp;true) | Should redislabs services listen on ipv6 |
+| use_ipv6 | boolean (default:&nbsp;true) | Should redislabs services listen on ipv6 (deprecated as of Redis Enterprise v6.4.2, replaced with use_external_ipv6) |
+| wait_command | boolean (default:&nbsp;true) | Supports Redis wait command (read-only) |
+---
+Title: LDAP mapping object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a mapping between an LDAP group and roles
+linkTitle: ldap_mapping
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/ldap_mapping/'
+---
+
+An API object that represents an [LDAP mapping]({{< relref "/operate/rs/7.4/security/access-control/ldap/map-ldap-groups-to-roles" >}}) between an LDAP group and [roles]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}).
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | LDAP mapping's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API (read-only) |
+| bdbs_email_alerts | complex object | UIDs of databases that associated email addresses will receive alerts for |
+| cluster_email_alerts | boolean | Activate cluster email alerts for an associated email |
+| dn | string | An LDAP group's distinguished name |
+| email | string | Email address used for alerts (if set) |
+| email_alerts | boolean (default:&nbsp;true) | Activate email alerts for an associated email |
+| name | string | Role's name |
+| role_uids | array of integers | List of role UIDs associated with the LDAP group |
+---
+Title: Cluster identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster_identity object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: cluster_identity
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/cluster_identity/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| name          | string                | Fully qualified cluster name. Limited to 64 characters and must comply with the IETF's RFC 952 standard and section 2.1 of the RFC 1123 standard. |
+| nodes         | array of strings       | Array of IP addresses of existing cluster nodes |
+| wait_command  | boolean (default:&nbsp;true) | Supports Redis wait command |
+---
+Title: Identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the identity object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: identity
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/identity/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Assumed node's UID to join cluster. Used to replace a dead node with a new one. |
+| accept_servers | boolean (default:&nbsp;true) | If true, no shards will be created on the node |
+| addr | string | Internal IP address of node |
+| external_addr | complex object | External IP addresses of node. `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| name | string | Node's name |
+| override_rack_id | boolean | When replacing an existing node in a rack-aware cluster, allows the new node to be located in a different rack |
+| rack_id | string | Rack ID, overrides cloud config |
+| use_internal_ipv6 | boolean (default:&nbsp;false) | Node uses IPv6 for internal communication |
+---
+Title: Credentials object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the credentials object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: credentials
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/credentials/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| password   | string       | Admin password |
+| username   | string       | Admin username (pattern does not allow special characters &,\<,>,") |
+---
+Title: Limits object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the limits object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: limits
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/limits/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| max_listeners      | integer (default:&nbsp;100)    | Max allowed listeners on node |
+| max_redis_servers  | integer (default:&nbsp;100)    | Max allowed Redis servers on node |
+---
+Title: Paths object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the paths object used with Redis Enterprise Software REST API
+  calls.
+linkTitle: paths
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/paths/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bigstore_path | string | Bigredis storage path |
+| ccs_persistent_path | string | Persistent storage path of CCS |
+| ephemeral_path | string | Ephemeral storage path |
+| persistent_path | string | Persistent storage path |
+---
+Title: Policy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the policy object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: policy
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/policy/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| default_fork_evict_ram | boolean (default:&nbsp;false) | If true, the databases should evict data from RAM to ensure successful replication or persistence |
+| default_non_sharded_proxy_policy | **'single'** <br />'all-master-shards'<br />'all-nodes' | Default proxy_policy for newly created non-sharded databases' endpoints |
+| default_sharded_proxy_policy | 'single'<br /> **'all-master-shards'** <br />'all-nodes' | Default proxy_policy for newly created sharded databases' endpoints |
+| default_shards_placement | 'dense'<br /> **'sparse'** | Default shards_placement for newly created databases |
+| rack_aware | boolean | Cluster rack awareness |
+| shards_overbooking | boolean (default:&nbsp;true) | If true, all databases' memory_size settings are ignored during shards placement |
+---
+Title: Node identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node_identity object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: node_identity
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/node_identity/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bigstore_driver | 'rocksdb' | Bigstore driver name or none (deprecated) |
+| bigstore_enabled | boolean | Bigstore enabled or disabled |
+| identity | [identity]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/identity" >}}) object | Node identity |
+| limits | [limits]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/limits" >}}) object | Node limits |
+| paths | [paths]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/paths" >}}) object | Storage paths object |
+---
+Title: Bootstrap object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for bootstrap configuration
+hideListLinks: true
+linkTitle: bootstrap
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bootstrap/'
+---
+
+A bootstrap configuration object.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| action | 'create_cluster'<br />'join_cluster'<br />'recover_cluster' | Action to perform |
+| cluster | [cluster_identity]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/cluster_identity" >}}) object | Cluster to join or create |
+| cnm_https_port | integer | Port to join a cluster with non-default cnm_https port |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| credentials | [credentials]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/credentials" >}}) object | Cluster admin credentials |
+| dns_suffixes | {{<code>}}
+[{
+  "name": string,
+  "cluster_default": boolean,
+  "use_aaaa_ns": boolean,
+  "use_internal_addr": boolean,
+  "slaves": array
+}, ...]
+{{</code>}} | Explicit configuration of DNS suffixes<br />**name**: DNS suffix name<br />**cluster_default**: Should this suffix be the default cluster suffix<br />**use_aaaa_ns**: Should AAAA records be published for NS records<br />**use_internal_addr**: Should internal cluster IPs be published for databases<br />**slaves**: List of replica servers that should be published as NS and notified |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| license | string | License string. If not provided, a trial license is set by default. |
+| max_retries | integer | Max number of retries in case of recoverable errors |
+| node | [node_identity]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/node_identity" >}}) object | Node description |
+| policy | [policy]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap/policy" >}}) object | Policy object |
+| recovery_filename | string | Name of backup file to recover from |
+| required_version | string | This node can only join the cluster if all nodes in the cluster have a version greater than the required_version |
+| retry_time | integer | Max waiting time between retries (in seconds) |
+
+
+---
+Title: Check result object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains the results of a cluster check
+linkTitle: check_result
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/check_result/'
+---
+
+Cluster check result
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cluster_test_result | boolean | Indication if any of the tests failed |
+| nodes | {{<code>}}
+[{
+  "node_uid": integer,
+  "result": boolean,
+  "error": string
+}, ...]
+{{</code>}} | Nodes results |
+---
+Title: CRDB task object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a CRDB task
+linkTitle: crdb_task
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb_task/'
+---
+
+An object that represents an Active-Active (CRDB) task.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| id | string | CRDB task ID (read only) |
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) (read-only) |
+| errors | {{<code>}}
+[{
+  "cluster_name": string,
+  "description": string,
+  "error_code": string
+}, ...] {{</code>}} | Details for errors that occurred on a cluster |
+| status | 'queued' <br />'started' <br />'finished' <br />'failed' | CRDB task status (read only) |
+---
+Title: MDNS server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the mdns_server object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: mdns_server
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/mdns_server/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the multicast DNS server |
+---
+Title: CRDB worker object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the crdb_worker object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: crdb_worker
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/crdb_worker/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CRDB worker processes |
+---
+Title: Stats archiver object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the stats_archiver object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: stats_archiver
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/stats_archiver/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the stats archiver service |
+---
+Title: CRDB coordinator object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the crdb_coordinator object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: crdb_coordinator
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/crdb_coordinator/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CRDB coordinator process |
+---
+Title: CM server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cm_server object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: cm_server
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/cm_server/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CM server |
+---
+Title: PDNS server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the pdns_server object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: pdns_server
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/pdns_server/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the PDNS server |
+---
+Title: Alert manager object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the alert_mgr object used with Redis Enterprise Software REST API calls.
+linkTitle: alert_mgr
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/alert_mgr/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the alert manager processes |
+---
+Title: Services configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for optional cluster services settings
+hideListLinks: true
+linkTitle: services_configuration
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/services_configuration/'
+---
+
+Optional cluster services settings
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| alert_mgr | [alert_mgr]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/alert_mgr" >}}) object | Whether to enable/disable the alert manager processes |
+| cm_server | [cm_server]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/cm_server" >}}) object | Whether to enable/disable the CM server |
+| crdb_coordinator | [crdb_coordinator]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/crdb_coordinator" >}}) object | Whether to enable/disable the CRDB coordinator process |
+| crdb_worker | [crdb_worker]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/crdb_worker" >}}) object | Whether to enable/disable the CRDB worker processes |
+| mdns_server | [mdns_server]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/mdns_server" >}}) object | Whether to enable/disable the multicast DNS server |
+| pdns_server | [pdns_server]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/pdns_server" >}}) object | Whether to enable/disable the PDNS server |
+| stats_archiver | [stats_archiver]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration/stats_archiver" >}}) object | Whether to enable/disable the stats archiver service |
+---
+Title: Alert object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains alert info
+linkTitle: alert
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/alert/'
+---
+
+You can view, configure, and enable various alerts for the cluster.
+
+Alerts are bound to a cluster object (such as a [BDB]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) or [node]({{< relref "/operate/rs/7.4/references/rest-api/objects/node" >}})), and the cluster's state determines whether the alerts turn on or off.
+
+  Name  | Type/Value | Description | Writable
+|-------|------------|-------------|----------|
+| change_time | string | Timestamp when alert state last changed | |
+| change_value | object | Contains data relevant to the evaluation time when the alert went on/off (thresholds, sampled values, etc.) | |
+| enabled | boolean | If true, alert is enabled | x |
+| severity | 'DEBUG'<br />'INFO'<br />'WARNING'<br />'ERROR'<br />'CRITICAL' | The alert's severity | |
+| state | boolean | If true, alert is currently triggered | |
+| threshold | string | Represents an alert threshold when applicable | x |
+---
+Title: JWT authorize object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for user authentication or a JW token refresh request
+linkTitle: jwt_authorize
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/jwt_authorize/'
+---
+
+An API object for user authentication or a JW token refresh request.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| password | string | The user’s password (required) |
+| ttl | integer (range: 1-86400) (default: 300) | Time to live - The amount of time in seconds the token will be valid |
+| username | string | The user’s username (required) |
+---
+Title: Node object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a node in the cluster
+linkTitle: node
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/node/'
+---
+
+An API object that represents a node in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Cluster unique ID of node (read-only) |
+| accept_servers | boolean (default:&nbsp;true) | The node only accepts new shards if `accept_servers` is `true` |
+| addr | string | Internal IP address of node |
+| architecture | string | Hardware architecture (read-only) |
+| bigredis_storage_path | string | Flash storage path (read-only) |
+| bigstore_driver | 'ibm-capi-ga1'<br />'ibm-capi-ga2'<br />'ibm-capi-ga4'<br />'speedb'<br />'rocksdb' | Bigstore driver name or none (deprecated as of Redis Enterprise v7.2, use the [cluster object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster" >}})'s bigstore_driver instead) |
+| bigstore_size | integer | Storage size of bigstore storage (read-only) |
+| cores | integer | Total number of CPU cores (read-only) |
+| ephemeral_storage_path | string | Ephemeral storage path (read-only) |
+| ephemeral_storage_size | number | Ephemeral storage size (bytes) (read-only) |
+| external_addr | complex object | External IP addresses of node. `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| max_listeners | integer | Maximum number of listeners on the node |
+| max_redis_servers | integer | Maximum number of shards on the node |
+| os_family | 'rhel'<br />'ubuntu'<br />'amzn' | Operating system family (read-only) |
+| os_name | string | Operating system name (read-only) |
+| os_semantic_version | string | Full version number (read-only) |
+| os_version | string | Installed OS version (human-readable) (read-only) |
+| persistent_storage_path | string | Persistent storage path (read-only) |
+| persistent_storage_size | number | Persistent storage size (bytes) (read- only) |
+| public_addr | string | Public IP address of node (deprecated as of Redis Enterprise v4.3.3, use external_addr instead) |
+| rack_id | string | Rack ID where node is installed |
+| recovery_path | string | Recovery files path |
+| shard_count | integer | Number of shards on the node (read-only) |
+| shard_list | array of integers | Cluster unique IDs of all node shards |
+| software_version | string | Installed Redis Enterprise cluster software version (read-only) |
+| status | 'active'<br />'decommissioning'<br />'down'<br />'provisioning' | Node status (read-only) |
+| supported_database_versions | {{<code>}}
+[{
+  "db_type": string,
+  "version": string
+}, ...]
+{{</code>}} | Versions of Redis Open Source databases supported by Redis Enterprise Software on the node (read-only)<br />**db_type**: Type of database<br />**version**: Version of database |
+| system_time | string | System time (UTC) (read-only) |
+| total_memory | integer | Total memory of node (bytes) (read-only) |
+| uptime | integer | System uptime (seconds) (read-only) |
+| use_internal_ipv6 | boolean (default:&nbsp;false) | Node uses IPv6 for internal communication. Value is taken from bootstrap identity (read-only) |
+---
+Title: Cluster settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for cluster resource management settings
+linkTitle: cluster_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/cluster_settings/'
+---
+
+Cluster resources management policy
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| acl_pubsub_default | `resetchannels`<br /> `allchannels` | Default pub/sub ACL rule for all databases in the cluster:<br />•`resetchannels` blocks access to all channels (restrictive)<br />•`allchannels` allows access to all channels (permissive) |
+| auto_recovery | boolean (default:&nbsp;false) | Defines whether to use automatic recovery after shard failure |
+| automatic_node_offload | boolean (default:&nbsp;true) | Defines whether the cluster will automatically migrate shards from a node, in case the node is overbooked |
+| bigstore_migrate_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| bigstore_migrate_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| bigstore_provision_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| bigstore_provision_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| data_internode_encryption | boolean | Enable/deactivate encryption of the data plane internode communication |
+| db_conns_auditing | boolean | [Audit connections]({{< relref "/operate/rs/7.4/security/audit-events" >}}) for new databases by default if set to true. |
+| default_concurrent_restore_actions | integer | Default number of restore actions allowed at the same time. Set to 0 to allow any number of simultaneous restore actions. |
+| default_fork_evict_ram | boolean | If true, the bdbs should evict data from RAM to ensure successful replication or persistence |
+| default_non_sharded_proxy_policy | `single`<br /><br />`all-master-shards`</nobr><br /><br />`all-nodes` | Default proxy_policy for newly created non-sharded databases' endpoints |
+| default_provisioned_redis_version | string | Default Redis version |
+| default_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default proxy_policy for newly created sharded databases' endpoints |
+| default_shards_placement | `dense`<br />`sparse` | Default shards_placement for a newly created databases |
+| endpoint_rebind_propagation_grace_time | integer | Time to wait between the addition and removal of a proxy |
+| failure_detection_sensitivity | `high`<br />`low` | Predefined thresholds and timeouts for failure detection (previously known as <span class="break-all">`watchdog_profile`</span>)<br />• `high` (previously `local-network`) – high failure detection sensitivity, lower thresholds, faster failure detection and failover<br />• `low` (previously `cloud`) – low failure detection sensitivity, higher tolerance for latency variance (also called network jitter) |
+| hide_user_data_from_log | boolean (default: false) | Set to `true` to enable the `hide-user-data-from-log` Redis configuration setting, which avoids logging user data |
+| login_lockout_counter_reset_after | integer | Number of seconds that must elapse between failed sign in attempts before the lockout counter is reset to 0. |
+| login_lockout_duration | integer | Duration (in secs) of account lockout. If set to 0, the account lockout will persist until released by an admin. |
+| login_lockout_threshold | integer | Number of failed sign in attempts allowed before locking a user account |
+| max_saved_events_per_type | integer | Maximum saved events per event type |
+| max_simultaneous_backups | integer (default: 4) | Maximum number of backup processes allowed at the same time |
+| parallel_shards_upgrade | integer | Maximum number of shards to upgrade in parallel |
+| persistence_cleanup_scan_interval | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the Redis cleanup schedule |
+| persistent_node_removal | boolean | When removing a node, wait for persistence files to be created for all migrated shards |
+| rack_aware | boolean | Cluster operates in a rack-aware mode |
+| redis_migrate_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| redis_migrate_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| redis_provision_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| redis_provision_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| redis_upgrade_policy | **`major`** <br />`latest` | Create/upgrade Redis Enterprise software on databases in the cluster by compatibility with major versions or latest versions of Redis Open Source |
+| resp3_default | boolean (default:&nbsp;true) | Determines the default value of the `resp3` option upon upgrading a database to version 7.2 |
+| shards_overbooking | boolean | If true, all databases' memory_size is ignored during shards placement |
+| show_internals | boolean | Show internal databases (and their shards and endpoints) REST APIs |
+| slave_ha | boolean | Enable the replica high-availability mechanism. Deprecated as of Redis Enterprise Software v7.2.4. |
+| slave_ha_bdb_cooldown_period | integer | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database |
+| slave_ha_cooldown_period | integer | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database |
+| slave_ha_grace_period | integer | Time in seconds between a node failure and when the replica high-availability mechanism starts relocating shards |
+---
+Title: Module object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a Redis module
+linkTitle: module
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/module/'
+---
+
+Represents a [Redis module]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}).
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | string | Cluster unique ID of module |
+| architecture | string | Architecture used to compile the module |
+| author | string | Module creator |
+| capabilities | array of strings | List of capabilities supported by this module |
+| capability_name | string | Short description of module functionality |
+| command_line_args | string | Command line arguments passed to the module |
+| config_command | string | Name of command to configure module arguments at runtime |
+| dependencies | object dependencies | Module dependencies |
+| description | string | Short description of the module
+| display_name | string | Name of module for display purposes |
+| email | string | Author's email address |
+| homepage | string | Module's homepage |
+| is_bundled | boolean | Whether module came bundled with a version of Redis Enterprise |
+| license | string | Module is distributed under this license
+| min_redis_pack_version | string | Minimum Redis Enterprise Software cluster version required by this module |
+| min_redis_version | string | Minimum Redis database version required by this module |
+| module_file | string | Module filename |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name<br/> |
+| os | string | Operating system used to compile the module |
+| os_list | array of strings | List of supported operating systems |
+| semantic_version | string | Module's semantic version |
+| sha256 | string | SHA256 of module binary |
+| version | integer | Module's version |
+---
+Title: Suffix object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a DNS suffix
+linkTitle: suffix
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/suffix/'
+---
+
+An API object that represents a DNS suffix in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| default | boolean | Suffix is the default suffix for the cluster (read-only) |
+| internal | boolean | Does the suffix point to internal IP addresses (read-only) |
+| mdns | boolean | Support for multicast DNS (read-only) |
+| name | string | Unique suffix name that represents its zone (read-only) |
+| slaves | array of strings | Frontend DNS servers to be updated by this suffix |
+| use_aaaa_ns | boolean | Suffix uses AAAA NS entries (read-only) |
+---
+Title: Database connection auditing configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for database connection auditing settings
+linkTitle: db_conns_auditing_config
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/db-conns-auditing-config/'
+---
+
+Database connection auditing configuration
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| audit_address | string | TCP/IP address where one can listen for notifications. |
+| audit_port | integer | Port where one can listen for notifications. |
+| audit_protocol | `TCP`<br />`local` | Protocol used to process notifications. For production systems, `TCP` is the only valid value. |
+| audit_reconnect_interval | integer | Interval (in seconds) between attempts to reconnect to the listener. Default is 1 second. |
+| audit_reconnect_max_attempts | integer | Maximum number of attempts to reconnect. Default is 0 (infinite). |
+---
+Title: LDAP object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains the cluster's LDAP configuration
+linkTitle: ldap
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/ldap/'
+---
+
+An API object that represents the cluster's [LDAP]({{< relref "/operate/rs/7.4/security/access-control/ldap" >}}) configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bind_dn | string | DN used when binding with the LDAP server to run queries |
+| bind_pass | string | Password used when binding with the LDAP server to run queries |
+| ca_cert | string | PEM-encoded CA certificate(s) used to validate TLS connections to the LDAP server |
+| cache_ttl | integer (default:&nbsp;300) | Maximum TTL (in seconds) of cached entries |
+| control_plane | boolean (default:&nbsp;false) | Use LDAP for user authentication/authorization in the control plane |
+| data_plane | boolean (default:&nbsp;false) | Use LDAP for user authentication/authorization in the data plane |
+| directory_timeout_s | integer (range:&nbsp;5-60) (default:&nbsp;5) | The connection timeout to the LDAP server when authenticating a user, in seconds |
+| dn_group_attr | string | The name of an attribute of the LDAP user entity that contains a list of the groups that user belongs to. (Mutually exclusive with "dn_group_query") |
+| dn_group_query | complex object | An LDAP search query for mapping from a user DN to the groups the user is a member of. The substring "%D" in the filter will be replaced with the user's DN. (Mutually exclusive with "dn_group_attr") |
+| starttls | boolean (default:&nbsp;false) | Use StartTLS negotiation for the LDAP connection |
+| uris | array of strings | URIs of LDAP servers that only contain the schema, host, and port |
+| user_dn_query | complex object | An LDAP search query for mapping from a username to a user DN. The substring "%u" in the filter will be replaced with the username. (Mutually exclusive with "user_dn_template") |
+| user_dn_template | string | A string template that maps between the username, provided to the cluster for authentication, and the LDAP DN. The substring "%u" will be replaced with the username. (Mutually exclusive with "user_dn_query") |
+---
+Title: CRDB cluster info object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents Active-Active cluster info
+linkTitle: cluster_info
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/cluster_info/'
+---
+
+Configuration details for a cluster that is part of an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| credentials | {{<code>}}
+{
+  "username": string,
+  "password": string
+} {{</code>}} | Cluster access credentials (required) |
+| name | string | Cluster fully qualified name, used to uniquely identify the cluster. Typically this is the same as the hostname used in the URL, although in some configruations the URL may point to a different name/address. (required) |
+| replication_endpoint | string | Address to use for peer replication. If not specified, it is assumed that standard cluster naming conventions apply. |
+| replication_tls_sni | string | Cluster SNI for TLS connections |
+| url | string | Cluster access URL (required) |
+---
+Title: CRDB health report configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the database configuration to include in an
+  Active-Active database health report.
+linkTitle: health_report_configuration
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/health_report/health_report_configuration/'
+---
+
+An object that represents the database configuration to include in an Active-Active database health report.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| causal_consistency | boolean | Enables causal consistency across Active-Active replicas |
+| encryption | boolean | Intercluster encryption |
+| featureset_version | integer | CRDB active FeatureSet version |
+| instances | {{<code>}}[{
+  // Unique instance ID
+  "id": integer,
+  // Local database instance ID
+  "db_uid": string,
+  "cluster": {
+    // Cluster FQDN
+    "name": string
+    // Cluster access URL
+    "url": string
+  }
+}, ...] {{</code>}} | Local database instances  |
+| name | string | Name of database |
+| protocol_version | integer | CRDB active protocol version |
+| status | string | Current status of the configuration.<br/>Possible values:<br/>**posted:**  Configuration was posted to all replicas<br/>**ready:** All replicas have finished processing posted configuration (create a database)<br/>**committed**: Posted configuration is now active on all replicas<br/>**commit-completed:** All replicas have finished processing committed configuration (database is active)<br/>**failed:** Configuration failed to post |
+| version | integer | Database configuration version |
+---
+Title: CRDB health report object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents an Active-Active database health report.
+hideListLinks: true
+linkTitle: health_report
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/health_report/'
+---
+
+An object that represents an Active-Active database health report.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| active_config_version | integer | Active configuration version |
+| cluster_name | string | Name of local Active-Active cluster |
+| configurations | array of [health_report_configuration]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/health_report/health_report_configuration" >}}) objects | Stored database configurations |
+| connection_error | string | Error string if remote cluster is not available |
+| connections | {{<code>}}
+[{
+  "name": string,
+  "replication_links": [ 
+    {
+      "link_uid": "bdb_uid:replica_uid", 
+      "status": "up | down" 
+    } ],
+  "status": string
+}, ...] {{</code>}} | Connections to other clusters and their statuses. A replication link's `bdb_uid` is the unique ID of a local database instance ([bdb]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}})) in the current cluster. The `replica_uid` is the unique ID of the database's remote replica, located in the connected cluster. |
+| name | string | Name of the Active-Active database |
+---
+Title: CRDB database config object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the database configuration
+linkTitle: database_config
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/database_config/'
+---
+
+An object that represents the database configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| aof_policy | string | Policy for Append-Only File data persistence |
+| authentication_admin_pass | string | Administrative databases access token |
+| authentication_redis_pass | string | Redis AUTH password (deprecated as of Redis Enterprise v7.2, replaced with multiple passwords feature in version 6.0.X) |
+| bigstore | boolean | Database driver is Auto Tiering |
+| bigstore_ram_size | integer | Memory size of RAM size |
+| data_persistence | string | Database on-disk persistence |
+| enforce_client_authentication | **'enabled'** <br />'disabled' | Require authentication of client certificates for SSL connections to the database. If enabled, a certificate should be provided in either <span class="break-all">`authentication_ssl_client_certs`</span> or <span class="break-all">`authentication_ssl_crdt_certs`</span> |
+| max_aof_file_size | integer | Hint for maximum AOF file size |
+| max_aof_load_time | integer | Hint for maximum AOF reload time |
+| memory_size | integer | Database memory size limit, in bytes |
+| oss_cluster | boolean | Enables OSS Cluster mode |
+| oss_cluster_api_preferred_ip_type | string | Indicates preferred IP type in OSS cluster API: internal/external |
+| oss_sharding | boolean | An alternative to shard_key_regex for using the common case of the OSS shard hashing policy |
+| port | integer | TCP port for database access |
+| proxy_policy | string | The policy used for proxy binding to the endpoint |
+| rack_aware | boolean | Require the database to be always replicated across multiple racks |
+| replication | boolean | Database replication |
+| sharding | boolean (default:&nbsp;false) | Cluster mode (server-side sharding). When true, shard hashing rules must be provided by either `oss_sharding` or `shard_key_regex` |
+| shard_key_regex | `[{ "regex": string }, ...]` | Custom keyname-based sharding rules (required if sharding is enabled)<br /><br />To use the default rules you should set the value to:<br />`[{"regex": ".*\\{(?<tag>.*)\\}.*"}, {"regex": "(?<tag>.*)"}]` |
+| shards_count | integer | Number of database shards |
+| shards_placement | string | Control the density of shards: should they reside on as few or as many nodes as possible |
+| snapshot_policy | array of [snapshot_policy]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/snapshot_policy" >}}) objects | Policy for snapshot-based data persistence (required) |
+| tls_mode | string | Encrypt communication |
+---
+Title: CRDB instance info object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents Active-Active instance info
+linkTitle: instance_info
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/instance_info/'
+---
+
+An object that represents Active-Active instance info.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| id | integer | Unique instance ID |
+| cluster | [CRDB cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/cluster_info" >}}) object | |
+| compression | integer | Compression level when syncing from this source |
+| db_config | [CRDB database_config]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/database_config" >}}) object | Database configuration |
+| db_uid | string | ID of local database instance. This field is likely to be empty for instances other than the local one. |
+---
+Title: CRDB modify request object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object to update an Active-Active database
+linkTitle: modify_request
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/modify_request/'
+---
+
+An object to update an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| add_instances | array of [CRDB instance_info]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/instance_info" >}}) objects | List of new CRDB instances |
+| crdb | [CRDB]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb" >}}) object | An object that represents an Active-Active database |
+| force_update | boolean | (Warning: This flag can cause unintended and dangerous changes) Force the configuration update and increment the configuration version even if there is no change to the configuration parameters. If you use force, you can mistakenly cause the other instances to update to the configuration version even though it was not changed. |
+| remove_instances | array of integers | List of unique instance IDs |
+| remove_instances.force_remove | boolean | Force removal of instance from the Active-Active database. Before we remove an instance from an Active-Active database, all of the operations that the instance received from clients must be propagated to the other instances. This is the safe method to remove an instance from the Active-Active database. If the instance does not have connectivity to other instances, the propagation fails and removal fails. To remove an instance that does not have connectivity to other instances, you must use the force flag. The removed instance keeps its data and configuration for the instance. After you remove an instance by force, you must use the purge_instances API on the removed instance. |
+---
+Title: CRDB object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents an Active-Active database
+hideListLinks: true
+linkTitle: crdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/crdb/'
+---
+
+An object that represents an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| guid | string | The global unique ID of the Active-Active database |
+| causal_consistency | boolean | Enables causal consistency across CRDT instances |
+| default_db_config| [CRDB database_config]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/database_config" >}}) object | Default database configuration |
+| encryption | boolean | Encrypt communication |
+| featureset_version | integer | Active-Active database active FeatureSet version
+| instances | array of [CRDB instance_info]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/instance_info" >}}) objects | |
+| local_databases | {{<code>}}[{
+  "bdb_uid": string,
+  "id": integer
+}, ...] {{</code>}} | Mapping of instance IDs for local databases to local BDB IDs |
+| name | string | Name of Active-Active database |
+| protocol_version | integer | Active-Active database active protocol version |
+---
+Title: OCSP object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the cluster's OCSP configuration
+linkTitle: ocsp
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/ocsp/'
+---
+
+An API object that represents the cluster's OCSP configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| ocsp_functionality | boolean (default:&nbsp;false) | Enables or turns off OCSP for the cluster |
+| query_frequency | integer <nobr>(range: 60-86400)</nobr> (default:&nbsp;3600) | The time interval in seconds between OCSP queries to check the certificate’s status |
+| recovery_frequency | integer <nobr>(range: 60-86400)</nobr> (default:&nbsp;60) | The time interval in seconds between retries after the OCSP responder returns an invalid status for the certificate |
+| recovery_max_tries | integer <nobr>(range: 1-100)</nobr> (default:&nbsp;5) | The number of retries before the validation query fails and invalidates the certificate |
+| responder_url | string | The OCSP server URL embedded in the proxy certificate (if available) (read-only) |
+| response_timeout | integer <nobr>(range: 1-60)</nobr> (default:&nbsp;1) | The time interval in seconds to wait for a response before timing out |
+---
+Title: Certificate rotation job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cert_rotation_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: cert_rotation_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/cert_rotation_job_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression              | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the certificate rotation schedule |
+| expiry_days_before_rotation  | integer, (range:&nbsp;1-90) (default:&nbsp;60) | Number of days before a certificate expires before rotation |
+---
+Title: Rotate CCS job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the rotate_ccs_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: rotate_ccs_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/rotate_ccs_job_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the CCS rotation schedule |
+| file_suffix | string (default:&nbsp;5min) | String added to the end of the rotated RDB files |
+| rotate_max_num | integer, (range:&nbsp;1-100) (default:&nbsp;24) | The maximum number of saved RDB files |
+---
+Title: Redis cleanup job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the redis_cleanup_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: redis_cleanup_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/redis_cleanup_job_settings/'
+---
+
+Deprecated and replaced with `persistence_cleanup_scan_interval`.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the Redis cleanup schedule |
+---
+Title: Log rotation job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the log_rotation_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: log_rotation_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/log_rotation_job_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the log rotation schedule |
+---
+Title: Backup job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the backup_job_settings object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: backup_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/backup_job_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the backup schedule |
+---
+Title: Node checks job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node_checks_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: node_checks_job_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/node_checks_job_settings/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the node checks schedule |
+---
+Title: Job scheduler object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for job scheduler settings
+hideListLinks: true
+linkTitle: job_scheduler
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/job_scheduler/'
+---
+
+An API object that represents the job scheduler settings in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| backup_job_settings | [backup_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/backup_job_settings" >}}) object | Backup job settings |
+| cert_rotation_job_settings | [cert_rotation_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/cert_rotation_job_settings" >}}) object | Job settings for internal certificate rotation |
+| log_rotation_job_settings | [log_rotation_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/log_rotation_job_settings" >}}) object | Log rotation job settings |
+| node_checks_job_settings | [node_checks_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/node_checks_job_settings" >}}) object | Node checks job settings |
+| redis_cleanup_job_settings | [redis_cleanup_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/redis_cleanup_job_settings" >}}) object | Redis cleanup job settings (deprecated as of Redis Enterprise v6.4.2, replaced with persistence_cleanup_scan_interval) |
+| rotate_ccs_job_settings | [rotate_ccs_job_settings]({{< relref "/operate/rs/7.4/references/rest-api/objects/job_scheduler/rotate_ccs_job_settings" >}}) object | Rotate CCS job settings |
+---
+Title: User object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a Redis Enterprise user
+linkTitle: user
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/user/'
+---
+
+An API object that represents a Redis Enterprise user.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | User's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API request (read-only) |
+| auth_method | **'regular'** | User's authentication method (deprecated as of Redis Enterprise v7.2) |
+| bdbs_email_alerts | complex object | UIDs of databases that user will receive alerts for |
+| cluster_email_alerts | boolean | Activate cluster email alerts for a user |
+| email | string | User's email (pattern matching only ASCII characters) |
+| email_alerts | boolean (default:&nbsp;true) | Activate email alerts for a user |
+| name | string | User's name (pattern does not allow non-ASCII and special characters &,\<,>,") |
+| password | string | User's password. If `password_hash_method` is set to `1`, the password should be hashed using SHA-256. The format before hashing is `username:clustername:password`. | 
+| password_hash_method | '1' | Used when password is passed pre-hashed to specify the hashing method |
+| password_issue_date | string | The date in which the password was set (read-only) |
+| role | 'admin'<br />'cluster_member'<br />'cluster_viewer'<br />'db_member'<br /> **'db_viewer'** <br />'none' | User's [role]({{< relref "/operate/rs/7.4/references/rest-api/permissions#roles" >}}) |
+| role_uids | array of integers | UIDs of user's roles for role-based access control |
+| status | 'active'<br />'locked' | User sign-in status (read-only)<br />**active**: able to sign in<br />**locked**: unable to sign in |
+---
+Title: BDB alert settings with threshold object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb_alert_settings_with_threshold object used with Redis
+  Enterprise Software REST API calls.
+linkTitle: bdb_alert_settings_with_threshold
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| enabled    | boolean (default:&nbsp;false)  | Alert enabled or disabled |
+| threshold  | string                         | Threshold for alert going on/off |
+---
+Title: Database alerts settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for database alerts configuration
+hideListLinks: true
+linkTitle: db_alerts_settings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/'
+---
+
+An API object that represents the database alerts configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bdb_backup_delayed | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Periodic backup has been delayed for longer than specified threshold value (minutes) |
+| bdb_crdt_src_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB source sync lag is higher than specified threshold value (seconds) |
+| bdb_crdt_src_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB source sync had a connection error while trying to connect to replica source |
+| bdb_crdt_src_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB sync encountered in general error |
+| bdb_high_latency | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Latency is higher than specified threshold value (microsec) |
+| bdb_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync lag is higher than specified threshold value (seconds) (deprecated as of Redis Enterprise v5.0.1) |
+| bdb_high_throughput | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Throughput is higher than specified threshold value (requests / sec) |
+| bdb_long_running_action | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | An alert for state machines that are running for too long |
+| bdb_low_throughput | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Throughput is lower than specified threshold value (requests / sec) |
+| bdb_ram_dataset_overhead | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Dataset RAM overhead of a shard has reached the threshold value (% of its RAM limit) |
+| bdb_ram_values | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Percent of values kept in a shard's RAM is lower than (% of its key count) |
+| bdb_replica_src_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of source sync lag is higher than specified threshold value (seconds) |
+| bdb_replica_src_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of source sync has connection error while trying to connect replica source |
+| bdb_replica_src_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync encountered in general error |
+| bdb_shard_num_ram_values | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Number of values kept in a shard's RAM is lower than (values) |
+| bdb_size | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Dataset size has reached the threshold value \(% of the memory limit) |
+| bdb_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync has connection error while trying to connect replica source (deprecated as of Redis Enterprise v5.0.1) |
+| bdb_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/7.4/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync encountered in general error (deprecated as of Redis Enterprise v5.0.1) |
+---
+Title: BDB dataset import sources object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb dataset_import_sources object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: dataset_import_sources
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/dataset_import_sources/'
+---
+
+You can import data to a database from the following location types:
+
+-   HTTP/S
+-   FTP
+-   SFTP
+-   Amazon S3
+-   Google Cloud Storage
+-   Microsoft Azure Storage
+-   NAS/Local Storage
+
+The source file to import should be in the [RDB]({{< relref "/operate/rs/7.4/databases/configure/database-persistence.md" >}}) format. It can also be in a compressed (gz) RDB file.
+
+Supply an array of dataset import source objects to import data from multiple files.
+
+## Basic parameters
+
+For all import location objects, you need to specify the location type via the `type` field.
+
+| Location type | "type" value |
+|---------------|--------------|
+| FTP/S | "url" |
+| SFTP | "sftp" |
+| Amazon S3 | "s3" |
+| Google Cloud Storage | "gs" |
+| Microsoft Azure Storage | "abs" |
+| NAS/Local Storage | "mount_point" |
+
+## Location-specific parameters
+
+Any additional required parameters may differ based on the import location type.
+
+### FTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| url | string | A URI that represents the FTP/S location with the following format: `ftp://user:password@host:port/path/`. The user and password can be omitted if not needed. |
+
+### SFTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| key | string | SSH private key to secure the SFTP server connection. If you do not specify an SSH private key, the autogenerated private key of the cluster is used and you must add the SSH public key of the cluster to the SFTP server configuration. (optional) |
+| sftp_url | string | SFTP URL in the format: `sftp://user:password@host[:port]/path/filename.rdb`. The default port number is 22 and the default path is '/'. |
+
+### AWS S3
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| access_key_id | string | The AWS Access Key ID with access to the bucket |
+| bucket_name | string | S3 bucket name |
+| region_name | string | Amazon S3 region name (optional) |
+| secret_access_key | string | The AWS Secret Access that matches the Access Key ID |
+| subdir | string | Path to the backup directory in the S3 bucket (optional) |
+
+### Google Cloud Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| bucket_name | string | Cloud Storage bucket name |
+| client_email | string | Email address for the Cloud Storage client ID |
+| client_id | string | Cloud Storage client ID with access to the Cloud Storage bucket |
+| private_key | string | Private key for the Cloud Storage matching the private key ID |
+| private_key_id | string | Cloud Storage private key ID with access to the Cloud Storage bucket |
+| subdir | string | Path to the backup directory in the Cloud Storage bucket (optional) |
+
+### Azure Blob Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| account_key | string | Access key for the storage account |
+| account_name | string | Storage account name with access to the container |
+| container | string | Blob Storage container name |
+| sas_token | string | Token to authenticate with shared access signature |
+| subdir | string | Path to the backup directory in the Blob Storage container (optional) |
+
+{{<note>}}
+`account_key` and `sas_token` are mutually exclusive
+{{</note>}}
+
+### NAS/Local Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| path | string | Path to the locally mounted filename to import. You must create the mount point on all nodes, and the `redislabs:redislabs` user must have read permissions on the local mount point.
+---
+Title: BDB status field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb status field used with Redis Enterprise Software REST
+  API calls.
+linkTitle: status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/status/'
+---
+
+The BDB status field is a read-only field that represents the database status.
+
+Possible status values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'active' | Database is active and no special action is in progress | 'active-change-pending' <br />'import-pending' <br />'delete-pending' |
+| 'active-change-pending' | |'active' |
+| 'creation-failed' | Initial database creation failed | |
+| 'delete-pending' | Database deletion is in progress | |
+| 'import-pending' | Dataset import is in progress | 'active' |
+| 'pending' | Temporary status during database creation | 'active'<br />'creation-failed' |
+| 'recovery' | Not currently relevant (intended for future use) | |
+
+{{< image filename="/images/rs/rest-api-bdb-status.png#no-click" alt="BDB status" >}}
+---
+Title: BDB backup/export location object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb backup_location/export_location object used with Redis
+  Enterprise Software REST API calls.
+linkTitle: backup_location/export_location
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/backup_location/'
+---
+
+You can back up or export a database's dataset to the following types of locations:
+
+-   FTP/S
+-   SFTP
+-   Amazon S3
+-   Google Cloud Storage
+-   Microsoft Azure Storage
+-   NAS/Local Storage
+
+## Basic parameters
+
+For all backup/export location objects, you need to specify the location type via the `type` field.
+
+| Location type | "type" value |
+|---------------|--------------|
+| FTP/S | "url" |
+| SFTP | "sftp" |
+| Amazon S3 | "s3" |
+| Google Cloud Storage | "gs" |
+| Microsoft Azure Storage | "abs" |
+| NAS/Local Storage | "mount_point" |
+
+## Location-specific parameters
+
+Any additional required parameters may differ based on the backup/export location type.
+
+### FTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| url | string | A URI that represents a FTP/S location with the following format: `ftp://user:password@host:port/path/`. The user and password can be omitted if not needed. |
+
+### SFTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| key | string | SSH private key to secure the SFTP server connection. If you do not specify an SSH private key, the autogenerated private key of the cluster is used, and you must add the SSH public key of the cluster to the SFTP server configuration. (optional) |
+| sftp_url | string | SFTP URL in the format: `sftp://user:password@host[:port][/path/]`. The default port number is 22 and the default path is '/'. |
+
+### AWS S3
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| access_key_id | string | The AWS Access Key ID with access to the bucket |
+| bucket_name | string | S3 bucket name |
+| region_name | string | Amazon S3 region name (optional) |
+| secret_access_key | string | The AWS Secret Access Key that matches the Access Key ID |
+| subdir | string | Path to the backup directory in the S3 bucket (optional) |
+
+### Google Cloud Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| bucket_name | string | Cloud Storage bucket name |
+| client_email | string | Email address for the Cloud Storage client ID |
+| client_id | string | Cloud Storage client ID with access to the Cloud Storage bucket |
+| private_key | string | Cloud Storage private key that matches the private key ID |
+| private_key_id | string | Cloud Storage private key ID with access to the Cloud Storage bucket |
+| subdir | string | Path to the backup directory in the Cloud Storage bucket (optional) |
+
+### Azure Blob Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| account_key | string | Access key for the storage account |
+| account_name | string | Storage account name with access to the container |
+| container | string | Blob Storage container name |
+| sas_token | string | Token to authenticate with shared access signature |
+| subdir | string | Path to the backup directory in the Blob Storage container (optional) |
+
+{{<note>}}
+`account_key` and `sas_token` are mutually exclusive
+{{</note>}}
+
+### NAS/Local Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| path | string | Path to the local mount point. You must create the mount point on all nodes, and the `redislabs:redislabs` user must have read and write permissions on the local mount point. |
+---
+Title: Syncer sources object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the syncer_sources object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: syncer_sources
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/syncer_sources/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Unique ID of this source |
+| client_cert | string | Client certificate to use if encryption is enabled |
+| client_key | string | Client key to use if encryption is enabled |
+| compression | integer, <nobr>(range: 0-6)</nobr> | Compression level for the replication link |
+| encryption | boolean | Encryption enabled/disabled |
+| lag | integer | Lag in milliseconds between source and destination (while synced) |
+| last_error | string | Last error encountered when syncing from the source |
+| last_update | string | Time when we last received an update from the source |
+| rdb_size | integer | The source's RDB size to be transferred during the syncing phase |
+| rdb_transferred | integer | Number of bytes transferred from the source's RDB during the syncing phase |
+| replication_tls_sni | string | Replication TLS server name indication |
+| server_cert | string | Server certificate to use if encryption is enabled |
+| status | string | Sync status of this source |
+| uri | string | Source Redis URI |
+---
+Title: Snapshot policy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the snapshot_policy object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: snapshot_policy
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/snapshot_policy/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| secs   | integer | Interval in seconds between snapshots |
+| writes | integer | Number of write changes required to trigger a snapshot |
+---
+Title: BDB replica sync field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb replica_sync field used with Redis Enterprise Software
+  REST API calls.
+linkTitle: replica_sync
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/replica_sync/'
+---
+
+The BDB `replica_sync` field relates to the [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create.md" >}}) feature, which enables the creation of a Redis database (single- or multi-shard) that synchronizes data from another Redis database (single- or multi-shard).
+
+You can use the `replica_sync` field to enable, disable, or pause the [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create.md" >}}) sync process. The BDB `crdt_sync` field has a similar purpose for the Redis CRDB.
+
+Possible BDB sync values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'disabled' | (default value) Disables the sync process and represents that no sync is currently configured or running. | 'enabled' |
+| 'enabled' | Enables the sync process and represents that the process is currently active. | 'stopped' <br />'paused' |
+| 'paused' | Pauses the sync process. The process is configured but is not currently executing any sync commands. | 'enabled' <br />'stopped' |
+| 'stopped' | An unrecoverable error occurred during the sync process, which caused the system to stop the sync. | 'enabled' |
+
+{{< image filename="/images/rs/rest-api-bdb-sync.png#no-click" alt="BDB sync" >}}
+
+When the sync is in the 'stopped' or 'paused' state, then the `last_error` field in the relevant source entry in the `sync_sources` "status" field contains the detailed error message.
+---
+Title: BDB replica sources status field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb replica_sources status field used with Redis Enterprise
+  Software REST API calls.
+linkTitle: replica_sources status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/replica_sources_status/'
+---
+
+The `replica_sources` status field relates to the [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/create.md" >}}) feature, which enables the creation of a Redis database (single- or multi-shard) that synchronizes data from another Redis database (single- or multi-shard).
+
+The status field represents the Replica Of sync status for a specific sync source.
+
+Possible status values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'out-of-sync' | Sync process is disconnected from source and trying to reconnect | 'syncing' |
+| 'syncing' | Sync process is in progress | 'in-sync' <br />'out-of-sync' |
+| 'in-sync' | Sync process finished successfully, and new commands are syncing on a regular basis | 'syncing' <br />'out-of-sync'
+
+{{< image filename="/images/rs/rest-api-replica-sources-status.png#no-click" alt="Replica sources status" >}}
+---
+Title: BDB object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a database
+hideListLinks: true
+linkTitle: bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb/'
+---
+
+An API object that represents a managed database in the cluster.
+
+| Name | Type/Value & Description |
+|------|-------------------------|
+| uid | integer; Cluster unique ID of database. Can be set during creation but cannot be updated. |
+| account_id | integer; SM account ID |
+| action_uid | string; Currently running action's UID (read-only) |
+| aof_policy | Policy for Append-Only File data persistence<br />Values:<br />**'appendfsync-every-sec'** <br />'appendfsync-always' |
+| authentication_admin_pass | string; Password for administrative access to the BDB (used for SYNC from the BDB) |
+| authentication_redis_pass | string; Redis AUTH password authentication.  <br/>Use for Redis databases only.  Ignored for memcached databases. (deprecated as of Redis Enterprise v7.2, replaced with multiple passwords feature in version 6.0.X) |
+| authentication_sasl_pass | string; Binary memcache SASL password |
+| authentication_sasl_uname | string; Binary memcache SASL username (pattern does not allow special characters &,\<,>,") |
+| authentication_ssl_client_certs | {{<code>}}[{<br />  "client_cert": string<br />}, ...]{{</code>}} List of authorized client certificates<br />**client_cert**: X.509 PEM (base64) encoded certificate |
+| authentication_ssl_crdt_certs | {{<code>}}[{<br />  "client_cert": string<br />}, ...]{{</code>}} List of authorized CRDT certificates<br />**client_cert**: X.509 PEM (base64) encoded certificate |
+| authorized_names | array of strings; Additional certified names (deprecated as of Redis Enterprise v6.4.2; use authorized_subjects instead) |
+| authorized_subjects | {{<code>}}[{<br />  "CN": string,<br />  "O": string,<br />  "OU": [array of strings],<br />  "L": string,<br />  "ST": string,<br />  "C": string<br />}, ...]{{</code>}} A list of valid subjects used for additional certificate validations during TLS client authentication. All subject attributes are case-sensitive.<br />**Required subject fields**:<br />"CN" for Common Name<br />**Optional subject fields:**<br />"O" for Organization<br />"OU" for Organizational Unit (array of strings)<br />"L" for Locality (city)<br />"ST" for State/Province<br />"C" for 2-letter country code |
+| auto_upgrade | boolean (default:&nbsp;false); Upgrade the database automatically after a cluster upgrade |
+| avoid_nodes | array of strings; Cluster node UIDs to avoid when placing the database's shards and binding its endpoints |
+| background_op | {{<code>}}[{<br />  "status": string,<br />  "name": string,<br />  "error": object,<br />  "progress": number<br />}, ...]{{</code>}} (read-only); **progress**: Percent of completed steps in current operation |
+| backup | boolean (default:&nbsp;false); Policy for periodic database backup |
+| backup_failure_reason | Reason of last failed backup process (read-only)<br />Values:<br />'no-permission'<br />'wrong-file-path'<br />'general-error' |
+| backup_history | integer (default:&nbsp;0); Backup history retention policy (number of days, 0 is forever) |
+| backup_interval | integer; Interval in seconds in which automatic backup will be initiated |
+| backup_interval_offset | integer; Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval) |
+| backup_location | [complex object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/backup_location" >}});  Target for automatic database backups. <br />Call `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| backup_progress | number, <nobr>(range: 0-100)</nobr>;  Database scheduled periodic backup progress (percentage) (read-only) |
+| backup_status | Status of scheduled periodic backup process (read-only)<br />Values:<br />'exporting'<br />'succeeded'<br />'failed' |
+| bigstore | boolean (default:&nbsp;false);  Database bigstore option |
+| bigstore_ram_size | integer (default:&nbsp;0);  Memory size of bigstore RAM part. |
+| bigstore_ram_weights | {{<code>}}[{<br />  "shard_uid": integer,<br />  "weight": number<br />}, ...]{{</code>}} List of shard UIDs and their bigstore RAM weights;<br /> **shard_uid**: Shard UID;<br /> **weight**: Relative weight of RAM distribution |
+| client_cert_subject_validation_type | Enables additional certificate validations that further limit connections to clients with valid certificates during TLS client authentication.<br />Values:<br />**disabled**: Authenticates clients with valid certificates. No additional validations are enforced.<br />**san_cn**: A client certificate is valid only if its Common Name (CN) matches an entry in the list of valid subjects. Ignores other Subject attributes.<br />**full_subject**: A client certificate is valid only if its Subject attributes match an entry in the list of valid subjects. |
+| conns | integer (default&nbsp;5);  Number of internal proxy connections |
+| conns_type | Connections limit type<br />Values:<br />**‘per-thread’**<br />‘per-shard’ |
+| crdt | boolean (default:&nbsp;false);  Use CRDT-based data types for multi-master replication |
+| crdt_causal_consistency | boolean (default:&nbsp;false);  Causal consistent CRDB. |
+| crdt_config_version | integer;  Replica-set configuration version, for internal use only. |
+| crdt_featureset_version | integer;  CRDB active FeatureSet version |
+| crdt_ghost_replica_ids | string;  Removed replicas IDs, for internal use only. |
+| crdt_guid | string;  GUID of CRDB this database belongs to, for internal use only. |
+| crdt_modules | string;  CRDB modules information. The string representation of a JSON list, containing hashmaps. |
+| crdt_protocol_version | integer;  CRDB active Protocol version |
+| crdt_repl_backlog_size | string;  Active-Active replication backlog size ('auto' or size in bytes) |
+| crdt_replica_id | integer;  Local replica ID, for internal use only. |
+| crdt_replicas | string;  Replica set configuration, for internal use only. |
+| crdt_sources | array of [syncer_sources]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/syncer_sources" >}}) objects; Remote endpoints/peers of CRDB database to sync from. See the 'bdb -\> replica_sources' section |
+| crdt_sync | Enable, disable, or pause syncing from specified crdt_sources. Applicable only for Active-Active databases. See [replica_sync]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/replica_sync" >}}) for more details.<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| crdt_sync_dist | boolean;  Enable/disable distributed syncer in master-master |
+| crdt_syncer_auto_oom_unlatch | boolean (default:&nbsp;true);  Syncer automatically attempts to recover synchronisation from peers after this database throws an Out-Of-Memory error. Otherwise, the syncer exits |
+| crdt_xadd_id_uniqueness_mode | XADD strict ID uniqueness mode. CRDT only.<br />Values:<br />‘liberal’<br />**‘strict’**<br />‘semi-strict’ |
+| created_time | string;  The date and time the database was created (read-only) |
+| data_internode_encryption | boolean;  Should the data plane internode communication for this database be encrypted |
+| data_persistence | Database on-disk persistence policy. For snapshot persistence, a [snapshot_policy]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/snapshot_policy" >}}) must be provided<br />Values:<br />**'disabled'** <br />'snapshot'<br />'aof' |
+| dataset_import_sources | [complex object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/dataset_import_sources" >}});  Array of source file location description objects to import from when performing an import action. This is write-only and cannot be read after set. <br />Call `GET /v1/jsonschema` to retrieve the object's structure. |
+| db_conns_auditing | boolean;  Enables/deactivates [database connection auditing]({{< relref "/operate/rs/7.4/security/audit-events" >}}) |
+| default_user | boolean (default:&nbsp;true); Allow/disallow a default user to connect |
+| disabled_commands | string (default: ); Redis commands which are disabled in db |
+| dns_address_master | string;  Database private address endpoint FQDN (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| email_alerts | boolean (default:&nbsp;false);  Send email alerts for this DB |
+| endpoint | string;  Latest bound endpoint. Used when reconfiguring an endpoint via update |
+| endpoint_ip | complex object;  External IP addresses of node hosting the BDB's endpoint. `GET /v1/jsonschema` to retrieve the object's structure. (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| endpoint_node | integer;  Node UID hosting the BDB's endpoint (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| endpoints | array; List of database access endpoints (read-only)<br />**uid**: Unique identification of this source<br />**dns_name**: Endpoint’s DNS name<br />**port**: Endpoint’s TCP port number<br />**addr**: Endpoint’s accessible addresses<br />**proxy_policy**: The policy used for proxy binding to the endpoint<br />**exclude_proxies**: List of proxies to exclude<br />**include_proxies**: List of proxies to include<br />**addr_type**: Indicates if the endpoint is based on internal or external IPs<br /><span class="break-all">**oss_cluster_api_preferred_ip_type**</span>: Indicates preferred IP type in the OSS cluster API: internal/external<br /><span class="break-all">**oss_cluster_api_preferred_endpoint_type**</span>: Indicates preferred endpoint type in the OSS cluster API: ip/hostname |
+| enforce_client_authentication | Require authentication of client certificates for SSL connections to the database. If set to 'enabled', a certificate should be provided in either authentication_ssl_client_certs or authentication_ssl_crdt_certs<br />Values:<br />**'enabled'** <br />'disabled' |
+| eviction_policy | Database eviction policy (Redis style).<br />Values:<br />'volatile-lru'<br />'volatile-ttl'<br />'volatile-random'<br />'allkeys-lru'<br />'allkeys-random'<br />'noeviction'<br />'volatile-lfu'<br />'allkeys-lfu'<br />**Redis DB default**: 'volatile-lru'<br />**memcached DB default**: 'allkeys-lru' |
+| export_failure_reason | Reason of last failed export process (read-only)<br />Values:<br />'no-permission'<br />'wrong-file-path'<br /> 'general-error' |
+| export_progress | number, <nobr>(range: 0-100)</nobr>; Database manually triggered export progress (percentage) (read-only) |
+| export_status | Status of manually triggered export process (read-only)<br />Values:<br />'exporting'<br />'succeeded'<br />'failed' |
+| generate_text_monitor | boolean;  Enable/disable generation of syncer monitoring information |
+| gradual_src_max_sources | integer (default:&nbsp;1); Sync a maximum N sources in parallel (gradual_src_mode should be enabled for this to take effect) |
+| gradual_src_mode | Indicates if gradual sync (of sync sources) should be activated<br />Values:<br />'enabled'<br />'disabled' |
+| gradual_sync_max_shards_per_source | integer (default:&nbsp;1); Sync a maximum of N shards per source in parallel (gradual_sync_mode should be enabled for this to take effect) |
+| gradual_sync_mode | Indicates if gradual sync (of source shards) should be activated ('auto' for automatic decision)<br />Values:<br />'enabled'<br />'disabled'<br />'auto' |
+| hash_slots_policy | The policy used for hash slots handling<br />Values:<br/> **'legacy'**: slots range is '1-4096'<br /> **'16k'**: slots range is '0-16383' |
+| implicit_shard_key | boolean (default:&nbsp;false); Controls the behavior of what happens in case a key does not match any of the regex rules. <br /> **true**: if a key does not match any of the rules, the entire key will be used for the hashing function <br /> **false**: if a key does not match any of the rules, an error will be returned. |
+| import_failure_reason | Import failure reason (read-only)<br />Values:<br />'download-error'<br />'file-corrupted'<br />'general-error'<br />'file-larger-than-mem-limit:\<n bytes of expected dataset>:\<n bytes configured bdb limit>'<br />'key-too-long'<br />'invalid-bulk-length'<br />'out-of-memory' |
+| import_progress | number, <nobr>(range: 0-100)</nobr>; Database import progress (percentage) (read-only) |
+| import_status | Database import process status (read-only)<br />Values:<br />'idle'<br />'initializing'<br />'importing'<br />'succeeded'<br />'failed' |
+| internal | boolean (default:&nbsp;false); Is this a database used by the cluster internally |
+| last_backup_time | string; Time of last successful backup (read-only) |
+| last_changed_time | string; Last administrative configuration change (read-only) |
+| last_export_time | string; Time of last successful export (read-only) |
+| max_aof_file_size | integer; Maximum size for shard's AOF file (bytes). Default 300GB, (on bigstore DB 150GB) |
+| max_aof_load_time | integer (default:&nbsp;3600); Maximum time shard's AOF reload should take (seconds). |
+| max_client_pipeline | integer (default:&nbsp;200); Maximum number of pipelined commands per connection. Maximum value is 2047. |
+| max_connections | integer (default:&nbsp;0); Maximum number of client connections allowed (0 unlimited) |
+| max_pipelined | integer (default:&nbsp;2000); Determines the maximum number of commands in the proxy’s pipeline per shard connection. |
+| master_persistence | boolean (default:&nbsp;false); If true, persists the primary shard in addition to replica shards in a replicated and persistent database. |
+| memory_size | integer (default:&nbsp;0); Database memory limit (0 is unlimited), expressed in bytes. |
+| metrics_export_all | boolean; Enable/disable exposing all shard metrics through the metrics exporter |
+| mkms | boolean (default:&nbsp;true); Are MKMS (Multi Key Multi Slots) commands supported? |
+| module_list | {{<code>}}[{<br />  "module_id": string,<br />  "module_args": [<br />    u'string',<br />    u'null'],<br />  "module_name": string,<br />  "semantic_version": string<br />}, ...]{{</code>}} List of modules associated with the database<br /><br />**module_id**: Module UID <br />**module_args**: Module command-line arguments (pattern does not allow special characters &,\<,>,")<br />**module_name**: Module's name<br />**semantic_version**: Module's semantic version<br /><br />As of Redis Enterprise Software v7.4.2, **module_id** and **semantic_version** are optional. |
+| mtls_allow_outdated_certs | boolean; An optional mTLS relaxation flag for certs verification |
+| mtls_allow_weak_hashing | boolean; An optional mTLS relaxation flag for certs verification |
+| name | string; Database name. Only letters, numbers, or hyphens are valid characters. The name must start and end with a letter or number. |
+| oss_cluster | boolean (default:&nbsp;false); OSS Cluster mode option. Cannot be enabled with `'hash_slots_policy': 'legacy'` |
+| <span class="break-all">oss_cluster_api_preferred_endpoint_type</span> | Endpoint type in the OSS cluster API<br />Values:<br />**‘ip’**<br />‘hostname’ |
+| <span class="break-all">oss_cluster_api_preferred_ip_type</span> | Internal/external IP type in OSS cluster API. Default value for new endpoints<br />Values:<br />**'internal'** <br />'external' |
+| oss_sharding | boolean (default:&nbsp;false); An alternative to `shard_key_regex` for using the common case of the OSS shard hashing policy |
+| port | integer; TCP port on which the database is available. Generated automatically if omitted and returned as 0 |
+| proxy_policy | The default policy used for proxy binding to endpoints<br />Values:<br />'single'<br />'all-master-shards'<br />'all-nodes' |
+| rack_aware | boolean (default:&nbsp;false); Require the database to always replicate across multiple racks |
+| recovery_wait_time | integer (default:&nbsp;-1); Defines how many seconds to wait for the persistence file to become available during auto recovery. After the wait time expires, auto recovery completes with potential data loss. The default `-1` means to wait forever. |
+| redis_version | string; Version of the redis-server processes: e.g. 6.0, 5.0-big |
+| repl_backlog_size | string; Redis replication backlog size ('auto' or size in bytes) |
+| replica_sources | array of [syncer_sources]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/syncer_sources" >}}) objects; Remote endpoints of database to sync from. See the 'bdb -\> replica_sources' section |
+| [replica_sync]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/replica_sync" >}}) | Enable, disable, or pause syncing from specified replica_sources<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| replica_sync_dist | boolean; Enable/disable distributed syncer in replica-of |
+| replication | boolean (default:&nbsp;false); In-memory database replication mode |
+| resp3 | boolean (default:&nbsp;true); Enables or deactivates RESP3 support |
+| roles_permissions | {{<code>}}[{<br />  "role_uid": integer,<br />  "redis_acl_uid": integer<br />}, ...]{{</code>}} |
+| sched_policy | Controls how server-side connections are used when forwarding traffic to shards.<br />Values:<br />**cmp**: Closest to max_pipelined policy. Pick the connection with the most pipelined commands that has not reached the max_pipelined limit.<br />**mru**: Try to use most recently used connections.<br />**spread**: Try to use all connections.<br />**mnp**: Minimal pipeline policy. Pick the connection with the least pipelined commands. |
+| shard_block_crossslot_keys | boolean (default:&nbsp;false); In Lua scripts, prevent use of keys from different hash slots within the range owned by the current shard |
+| shard_block_foreign_keys | boolean (default:&nbsp;true); In Lua scripts, `foreign_keys` prevent use of keys which could reside in a different shard (foreign keys) |
+| shard_key_regex | Custom keyname-based sharding rules.<br />`[{"regex": string}, ...]`<br />To use the default rules you should set the value to: <br />`[{"regex": ".*\\{(?<tag>.*)\\}.*"}, {"regex": "(?<tag>.*)"}]` |
+| shard_list | array of integers; Cluster unique IDs of all database shards. |
+| sharding | boolean (default:&nbsp;false); Cluster mode (server-side sharding). When true, shard hashing rules must be provided by either `oss_sharding` or `shard_key_regex` |
+| shards_count | integer, <nobr>(range: 1-512)</nobr> (default:&nbsp;1); Number of database server-side shards |
+| shards_placement | Control the density of shards <br />Values:<br />**'dense'**: Shards reside on as few nodes as possible <br /> **'sparse'**: Shards reside on as many nodes as possible |
+| skip_import_analyze | Enable/disable skipping the analysis stage when importing an RDB file<br />Values:<br />'enabled'<br />'disabled' |
+| slave_buffer | Redis replica output buffer limits<br />Values:<br />'auto'<br />value in MB<br />hard:soft:time |
+| slave_ha | boolean; Enable replica high availability mechanism for this database (default takes the cluster setting) |
+| slave_ha_priority | integer; Priority of the BDB in replica high availability mechanism |
+| snapshot_policy | array of [snapshot_policy]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/snapshot_policy" >}}) objects; Policy for snapshot-based data persistence. A dataset snapshot will be taken every N secs if there are at least M writes changes in the dataset |
+| ssl | boolean (default:&nbsp;false); Require SSL authenticated and encrypted connections to the database (deprecated as of Redis Enterprise v5.0.1) |
+| [status]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/status" >}}) | Database lifecycle status (read-only)<br />Values:<br />'pending'<br />'active'<br />'active-change-pending'<br />'delete-pending'<br />'import-pending'<br />'creation-failed'<br />'recovery' |
+| support_syncer_reconf | boolean; Determines whether the syncer handles its own configuration changes. If false, the DMC restarts the syncer upon a configuration change. |
+| sync | (deprecated as of Redis Enterprise v5.0.1, use [replica_sync]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/replica_sync" >}}) or crdt_sync instead) Enable, disable, or pause syncing from specified sync_sources<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| sync_dedicated_threads | integer (range:&nbsp;0-10) (default:&nbsp;5); Number of dedicated Replica Of threads |
+| sync_sources | {{<code>}}[{<br />  "uid": integer,<br />  "uri": string,<br />  "compression": integer,<br />  "status": string,<br />  "rdb_transferred": integer,<br />  "rdb_size": integer,<br />  "last_update": string,<br />  "lag": integer,<br />  "last_error": string<br />}, ...]{{</code>}} (deprecated as of Redis Enterprise v5.0.1, instead use replica_sources or crdt_sources) Remote endpoints of database to sync from. See the 'bdb -\> replica_sources' section<br />**uid**: Numeric unique identification of this source<br />**uri**: Source Redis URI<br />**compression**: Compression level for the replication link<br />**status**: Sync status of this source<br />**rdb_transferred**: Number of bytes transferred from the source's RDB during the syncing phase<br />**rdb_size**: The source's RDB size to be transferred during the syncing phase<br />**last_update**: Time last update was received from the source<br />**lag**: Lag in millisec between source and destination (while synced)<br />**last_error**: Last error encountered when syncing from the source |
+| syncer_log_level | Minimum syncer log level to log. Only logs with this level or higher will be logged.<br />Values:<br />‘crit’<br />‘error’<br />‘warn’<br />**‘info’**<br />‘trace’<br />‘debug’ |
+| syncer_mode | The syncer for replication between database instances is either on a single node (centralized) or on each node that has a proxy according to the proxy policy (distributed). (read-only)<br />Values:<br />'distributed'<br />'centralized' |
+| tags | {{<code>}}[{<br />  "key": string,<br />  "value": string<br />}, ...]{{</code>}} Optional list of tag objects attached to the database. Each tag requires a key-value pair.<br />**key**: Represents the tag's meaning and must be unique among tags (pattern does not allow special characters &,\<,>,")<br />**value**: The tag's value.|
+| tls_mode | Require TLS-authenticated and encrypted connections to the database<br />Values:<br />'enabled'<br /> **'disabled'** <br />'replica_ssl' |
+| type | Type of database<br />Values:<br />**'redis'** <br />'memcached' |
+| use_nodes | array of strings; Cluster node UIDs to use for database shards and bound endpoints |
+| version | string; Database compatibility version: full Redis/memcached version number, such as 6.0.6. This value can only change during database creation and database upgrades.|
+| wait_command | boolean (default:&nbsp;true); Supports Redis wait command (read-only) |
+---
+Title: BDB group object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a group of databases with a shared memory pool
+linkTitle: bdb_group
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/bdb_group/'
+---
+
+An API object that represents a group of databases that share a memory pool.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid          | integer          | Cluster unique ID of the database group |
+| members      | array of strings | A list of UIDs of member databases (read-only) |
+| memory_size  | integer          | The common memory pool size limit for all databases in the group, expressed in bytes |
+---
+Title: Action object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents cluster actions
+linkTitle: action
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/action/'
+---
+
+The cluster allows you to invoke general maintenance actions such as rebalancing or taking a node offline by moving all of its entities to other nodes.
+
+Actions are implemented as tasks in the cluster. Every task has a unique `task_id` assigned by the cluster, a task name which describes the task, a status, and additional task-specific parameters.
+
+The REST API provides a simplified interface that allows callers to invoke actions and query their status without a specific `task_id`.
+
+The action lifecycle is based on the following status and status transitions:
+
+{{< image filename="/images/rs/rest-api-action-cycle.png#no-click" alt="Action lifecycle" >}}
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress        | float <nobr>(range: 0-100)</nobr> | Represents percent completed (As of v7.4.2, the return value type changed to 'float' to provide improved progress indication) |
+| status          | queued | Requested operation and added it to the queue to await processing |
+|                 | starting | Picked up operation from the queue and started processing |
+|                 | running | Currently executing operation |
+|                 | cancelling | Operation cancellation is in progress |
+|                 | cancelled | Operation cancelled |
+|                 | completed | Operation completed |
+|                 | failed | Operation failed |
+
+When a task fails, the `error_code` and `error_message` fields describe the error.
+
+Possible `error_code` values:
+
+ Code                    | Description                                    |
+|-------------------------|------------------------------------------------|
+| internal_error          | An internal error that cannot be mapped to a more precise error code
+| insufficient_resources  | The cluster does not have sufficient resources to complete the required operation
+
+---
+Title: State machine object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a state machine.
+linkTitle: state-machine
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/state-machine/'
+---
+
+A state machine object tracks the status of database actions.
+
+A state machine contains the following attributes:
+
+| Name        | Type/Value | Description |
+|-------------|------------|-------------|
+| action_uid  | string     | A globally unique identifier of the action |
+| object_name | string     | Name of the object being manipulated by the state machine |
+| status      | pending    | Requested state machine has not started |
+|             | active     | State machine is currently running |
+|             | completed  | Operation complete |
+|             | failed     | Operation or state machine failed |
+| name        | string     | Name of the running (or failed) state machine |
+| state       | string     | Current state within the state machine, when known |
+| error       | string     | A descriptive error string for failed state machine, when known |
+---
+Title: Role object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a role
+linkTitle: role
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/role/'
+---
+
+An API object that represents a role.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Role's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the GET /actions/{uid} API (read-only) |
+| management | 'admin'<br />'db_member'<br />'db_viewer'<br />'cluster_member'<br />'cluster_viewer'<br />'none' | [Management role]({{< relref "/operate/rs/7.4/references/rest-api/permissions#roles" >}}) |
+| name | string | Role's name |
+---
+Title: Redis ACL object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a Redis access control list (ACL)
+linkTitle: redis_acl
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/redis_acl/'
+---
+
+An API object that represents a Redis [access control list (ACL)]({{< relref "/operate/rs/7.4/security/access-control/create-db-roles" >}})
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Object's unique ID |
+| account_id | integer | SM account ID |
+| acl | string | Redis ACL's string |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API (read-only) |
+| name | string | Redis ACL's name |
+| min_version | string | Minimum database version that supports this ACL. Read only |
+| max_version | string | Maximum database version that supports this ACL. Read only |
+
+---
+Title: Proxy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a proxy in the cluster
+linkTitle: proxy
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/proxy/'
+---
+
+An API object that represents a [proxy](https://en.wikipedia.org/wiki/Proxy_server) in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Unique ID of the proxy (read-only) |
+| backlog | integer | TCP listen queue backlog |
+| client_keepcnt | integer | Client TCP keepalive count |
+| client_keepidle | integer | Client TCP keepalive idle |
+| client_keepintvl | integer | Client TCP keepalive interval |
+| conns | integer | Number of connections |
+| duration_usage_threshold | integer, <nobr>(range: 10-300)</nobr> | Max number of threads |
+| dynamic_threads_scaling | boolean | Automatically adjust the number of threads|
+| ignore_bdb_cconn_limit | boolean | Ignore client connection limits |
+| ignore_bdb_cconn_output_buff_limits | boolean | Ignore buffer limit |
+| log_level | `crit`<br />`error`<br />`warn`<br />`info`<br />`trace`<br />`debug` | Minimum log level to log. Only logs with this level or greater will be logged. |
+| max_listeners | integer | Max number of listeners |
+| max_servers | integer | Max number of Redis servers |
+| max_threads | integer, <nobr>(range: 1-256)</nobr> | Max number of threads |
+| max_worker_client_conns | integer | Max client connections per thread |
+| max_worker_server_conns | integer | Max server connections per thread |
+| max_worker_txns | integer | Max in-flight transactions per thread |
+| threads | integer, <nobr>(range: 1-256)</nobr> | Number of threads |
+| threads_usage_threshold | integer, <nobr>(range: 50-99)</nobr> | Max number of threads |
+---
+Title: Sync object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the sync object used with Redis Enterprise Software REST API
+  calls.
+linkTitle: sync
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/shard/sync/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | integer        | Number of bytes remaining in current sync |
+| status    | 'in_progress'<br />'idle'<br />'link_down' | Indication of the shard's current sync status |
+---
+Title: Loading object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the loading object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: loading
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/shard/loading/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | number, (range: 0-100) | Percentage of bytes already loaded |
+| status    | 'in_progress'<br />'idle' | Status of the load of a dump file (read-only) |
+---
+Title: Backup object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the backup object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: backup
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/shard/backup/'
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | number, (range: 0-100) | Shard backup progress (percentage) |
+| status    | 'exporting'<br />'succeeded'<br />'failed' | Status of scheduled periodic backup process |
+---
+Title: Shard object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a database shard
+hideListLinks: true
+linkTitle: shard
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/shard/'
+---
+
+An API object that represents a Redis shard in a database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | string | Cluster unique ID of shard |
+| assigned_slots | string | Shards hash slot range |
+| backup | [backup]({{< relref "/operate/rs/7.4/references/rest-api/objects/shard/backup" >}}) object | Current status of scheduled periodic backup process |
+| bdb_uid | integer | The ID of the database this shard belongs to |
+| bigstore_ram_weight | number | Shards RAM distribution weight |
+| detailed_status | 'busy'<br />'down'<br />'importing'<br />'loading'<br />'ok'<br />'timeout'<br />'trimming'<br />'unknown' | A more detailed status of the shard |
+| loading | [loading]({{< relref "/operate/rs/7.4/references/rest-api/objects/shard/loading" >}}) object | Current status of dump file loading |
+| node_uid | string | The ID of the node this shard is located on |
+| redis_info | redis_info object | A sub-dictionary of the [Redis INFO command]({{< relref "/commands/info" >}}) |
+| report_timestamp | string | The time in which the shard's info was collected (read-only) |
+| role | 'master'<br />'slave' | Role of this shard |
+| status | 'active'<br />'inactive'<br />'trimming' | The current status of the shard |
+| sync | [sync]({{< relref "/operate/rs/7.4/references/rest-api/objects/shard/sync.md" >}}) object | Shard's current sync status and progress |
+---
+Title: OCSP status object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the cluster's OCSP status
+linkTitle: ocsp_status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/objects/ocsp_status/'
+---
+
+An API object that represents the cluster's OCSP status.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cert_status | string | Indicates the proxy certificate's status: GOOD/REVOKED/UNKNOWN (read-only) |
+| responder_url | string | The OCSP responder URL this status came from (read-only) |
+| next_update | string | The expected date and time of the next certificate status update (read-only) |
+| produced_at | string | The date and time when the OCSP responder signed this response (read-only) |
+| revocation_time | string | The date and time when the certificate was revoked or placed on hold (read-only) |
+| this_update | string | The most recent time that the responder confirmed the current status (read-only) |
+---
+Title: Redis Enterprise REST API objects
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the objects used with Redis Enterprise Software REST API calls.
+hideListLinks: true
+linkTitle: Objects
+weight: 40
+url: '/operate/rs/7.4/references/rest-api/objects/'
+---
+
+Certain [REST API requests]({{< relref "/operate/rs/7.4/references/rest-api/requests" >}}) require you to include specific objects in the request body. Many requests also return objects in the response body.
+
+Both REST API requests and responses represent these objects as [JSON](https://www.json.org).
+
+{{< table-children columnNames="Object,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Suffixes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: DNS suffixes requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: suffixes
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/suffixes/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-suffixes) | `/v1/suffixes` | Get all DNS suffixes |
+
+## Get all suffixes {#get-all-suffixes}
+
+	GET /v1/suffixes
+
+Get all DNS suffixes in the cluster.
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/suffixes 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+The response body contains a JSON array with all suffixes, represented as [suffix objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/suffix" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "name": "cluster.fqdn",
+        "// additional fields..."
+    },
+    {
+        "name": "internal.cluster.fqdn",
+        "// additional fields..."
+    }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Migrate shards requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to migrate database shards
+headerRange: '[1-2]'
+linkTitle: migrate
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-multi-shards) | `/v1/shards/actions/migrate` | Migrate multiple shards |
+| [POST](#post-shard) | `/v1/shards/{uid}/actions/migrate` | Migrate a specific shard |
+
+## Migrate multiple shards {#post-multi-shards}
+
+    POST /v1/shards/actions/migrate
+
+Migrates the list of given shard UIDs to the node specified by `target_node_uid`. The shards can be from multiple databases. This request is asynchronous.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/7.4/databases/migrate-shards">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [migrate_shard]({{< relref "/operate/rs/7.4/references/rest-api/permissions#migrate_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-multi-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/actions/migrate
+
+#### Example JSON body
+
+```json
+{
+  "shard_uids": ["2","4","6"],
+  "target_node_uid": 9,
+  "override_rack_policy": false,
+  "preserve_roles": false,
+  "max_concurrent_bdb_migrations": 3
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body {#post-multi-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| shard_uids | array of strings | List of shard UIDs to migrate. |
+| target_node_uid | integer | UID of the node to where the shards should migrate. |
+| override_rack_policy | boolean | If true, overrides and ignores rack-aware policy violations. |
+| dry_run | boolean | Determines whether the migration is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. |
+| preserve_roles | boolean | If true, preserves the migrated shards' roles after migration. |
+| max_concurrent_bdb_migrations | integer | The number of concurrent databases that can migrate shards. |
+
+### Response {#post-multi-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/7.4/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Migrate was triggered"
+}
+```
+
+### Status codes {#post-multi-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Conflicting parameters. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | A list of shard UIDs is required and not given, a specified shard does not exist, or a node UID is required and not given. |
+| [500 Internal Server Error](https://www.rfc-editor.org/rfc/rfc9110.html#name-500-internal-server-error) | Migration failed. |
+
+
+## Migrate shard {#post-shard}
+
+    POST /v1/shards/{int: uid}/actions/migrate
+
+Migrates the shard with the given `shard_uid` to the node specified by `target_node_uid`. If the shard is already on the target node, nothing happens. This request is asynchronous.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/7.4/databases/migrate-shards">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [migrate_shard]({{< relref "/operate/rs/7.4/references/rest-api/permissions#migrate_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/1/actions/migrate
+
+#### Example JSON body
+
+```json
+{
+    "target_node_uid": 9,
+    "override_rack_policy": false,
+    "preserve_roles": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard to migrate. |
+
+
+#### Request body {#post-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| target_node_uid | integer | UID of the node to where the shard should migrate. |
+| override_rack_policy | boolean | If true, overrides and ignores rack-aware policy violations. |
+| dry_run | boolean | Determines whether the migration is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. |
+| preserve_roles | boolean | If true, preserves the migrated shards' roles after migration. |
+
+### Response {#post-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/7.4/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Migrate was triggered"
+}
+```
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist, or node UID is required and not given. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy. |
+---
+Title: Shard actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to perform shard actions
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/shards/actions/'
+---
+
+## Migrate
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-multi-shards">}}) | `/v1/shards/actions/migrate` | Migrate multiple shards |
+| [POST]({{<relref "/operate/rs/7.4/references/rest-api/requests/shards/actions/migrate#post-shard">}}) | `/v1/shards/{uid}/actions/migrate` | Migrate a specific shard |
+---
+Title: Latest shards stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent shard statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+aliases: /operate/rs/references/rest-api/requests/shards-stats/last/
+url: '/operate/rs/7.4/references/rest-api/requests/shards/stats/last/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards-stats-last) | `/v1/shards/stats/last` | Get most recent stats for all shards |
+| [GET](#get-shard-stats-last) | `/v1/shards/stats/last/{uid}` | Get most recent stats for a specific shard |
+
+## Get latest stats for all shards {#get-all-shards-stats-last}
+
+	GET /v1/shards/stats/last
+
+Get most recent statistics for all shards.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_shard_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_shard_stats" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/last?interval=1sec&stime=015-05-27T08:27:35Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response} 
+
+Returns most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all shards.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:28:36Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+   },
+   "2": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:40Z",
+      "etime": "2015-05-28T08:28:45Z",
+      "// additional fields..."
+   }
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | No shards exist |
+
+## Get latest shard stats {#get-shard-stats-last}
+
+	GET /v1/shards/stats/last/{int: uid}
+
+Get most recent statistics for a specific shard.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_shard_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_shard_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/last/1?interval=1sec&stime=2015-05-28T08:27:35Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns the most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the specified shard.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:27:36Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+   }
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Shard isn't currently active |
+---
+Title: Shards stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shard statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+aliases: /operate/rs/references/rest-api/requests/shards-stats/
+url: '/operate/rs/7.4/references/rest-api/requests/shards/stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards-stats) | `/v1/shards/stats` | Get stats for all shards |
+| [GET](#get-shard-stats) | `/v1/shards/stats/{uid}` | Get stats for a specific shard |
+
+## Get all shards stats {#get-all-shards-stats}
+
+	GET /v1/shards/stats
+
+Get statistics for all shards.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_shard_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_shard_stats" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| parent_uid | integer | Only return shard from the given BDB ID (optional) |
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| metrics | list | Comma-separated list of [metric names]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics/shard-metrics" >}}) for which we want statistics (default is all) (optional) |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all shards.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "status": "active",
+    "uid": "1",
+    "node_uid": "1",
+    "assigned_slots": "0-8191",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:27:40Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:40Z",
+      "etime": "2015-05-28T08:27:45Z",
+      "// additional fields..."
+      }
+    ]
+  },
+  {
+    "uid": "2",
+    "status": "active",
+    "node_uid": "1",
+    "assigned_slots": "8192-16383",
+    "intervals": [
+      {
+        "interval": "1sec",
+        "stime": "2015-05-28T08:27:35Z",
+        "etime": "2015-05-28T08:27:40Z",
+        "// additional fields..."
+      },
+      {
+        "interval": "1sec",
+        "stime": "2015-05-28T08:27:40Z",
+        "etime": "2015-05-28T08:27:45Z",
+        "// additional fields..."
+      }
+    ]
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | No shards exist |
+
+## Get shard stats {#get-shard-stats}
+
+	GET /v1/shards/stats/{int: uid}
+
+Get statistics for a specific shard.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_shard_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_shard_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the specified shard.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "status": "active",
+  "node_uid": "1",
+  "role": "master",
+  "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:24:13Z",
+      "etime": "2015-05-28T08:24:18Z",
+      "avg_ttl": 0.0,
+      "blocked_clients": 0.0,
+      "connected_clients": 9.0,
+      "etime": "2015-05-28T08:24:18Z",
+      "evicted_objects": 0.0,
+      "expired_objects": 0.0,
+      "last_save_time": 1432541051.0,
+      "used_memory": 5651440.0,
+      "mem_size_lua": 35840.0,
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "no_of_expires": 0.0,
+      "no_of_keys": 0.0,
+      "pubsub_channels": 0.0,
+      "pubsub_patterns": 0.0,
+      "rdb_changes_since_last_save": 0.0,
+      "read_hits": 0.0,
+      "read_misses": 0.0,
+      "stime": "2015-05-28T08:24:13Z",
+      "sync_full": 0.0,
+      "sync_partial_err": 0.0,
+      "sync_partial_ok": 0.0,
+      "total_req": 0.0,
+      "write_hits": 0.0,
+      "write_misses": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:24:18Z",
+      "etime": "2015-05-28T08:24:23Z",
+
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Shard isn't currently active |
+---
+Title: Shard requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database shards
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: shards
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/shards/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards) | `/v1/shards` | Get all shards |
+| [GET](#get-shard) | `/v1/shards/{uid}` | Get a specific shard |
+
+## Get all shards {#get-all-shards}
+
+	GET /v1/shards
+
+Get information about all shards in the cluster.
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| extra_info_keys | list of strings | A list of extra keys to be fetched (optional) |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [shard objects]({{<relref "/operate/rs/7.4/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "role": "master",
+    "assigned_slots": "0-16383",
+    "bdb_uid": 1,
+    "detailed_status": "ok",
+    "loading": {
+      "status": "idle"
+    },
+    "node_uid": "1",
+    "redis_info": {
+			"connected_clients": 14,
+			"used_memory_rss": 12263424
+		},
+    "report_timestamp": "2024-06-28T18:44:01Z",
+    "status": "active"
+  },
+  {
+    "uid": 2,
+    "role": "slave",
+    // additional fields...
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+
+## Get shard {#get-shard}
+
+	GET /v1/shards/{int: uid}
+
+Gets information about a single shard.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/1?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the requested shard. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| extra_info_keys | list of strings | A list of extra keys to be fetched (optional) |
+
+### Response {#get-response} 
+
+Returns a [shard object]({{<relref "/operate/rs/7.4/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+{
+  "assigned_slots": "0-16383",
+  "bdb_uid": 1,
+  "detailed_status": "ok",
+  "loading": {
+    "status": "idle"
+  },
+  "node_uid": "1",
+  "redis_info": {
+		"connected_clients": 14,
+		"used_memory_rss": 12263424
+	},
+  "role": "master",
+  "report_timestamp": "2024-06-28T18:44:01Z",
+  "status": "active",
+  "uid": "1"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard UID does not exist. |
+---
+Title: Cluster debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /cluster/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/debuginfo/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-debuginfo) | `/v1/cluster/debuginfo` | Get debug info from all nodes and databases |
+
+## Get cluster debug info {#get-cluster-debuginfo}
+
+	GET /v1/cluster/debuginfo
+
+Downloads a tar file that contains debug info from all nodes and databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info for all nodes.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Cluster services configuration requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster services configuration requests
+headerRange: '[1-2]'
+linkTitle: services_configuration
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/services_configuration/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-services_config) | `/v1/cluster/services_configuration` | Get cluster services settings |
+| [PUT](#put-cluster-services_config) | `/v1/cluster/services_configuration` | Update cluster services settings |
+
+## Get cluster services configuration {#get-cluster-services_config}
+
+	GET /v1/cluster/services_configuration
+
+Get cluster services settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/services_configuration 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [services configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "mdns_server": {
+         "operating_mode": "enabled"
+     },
+     "// additional services..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Update cluster services configuration {#put-cluster-services_config}
+
+	PUT /v1/cluster/services_configuration
+
+Update the cluster services settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/services_configuration 
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "// additional services..."
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [services configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [services configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/services_configuration" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "mdns_server": {
+         "operating_mode": "enabled"
+     },
+     "// additional services..."
+}
+```
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Rotate cluster certificates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Rotate cluster certificates requests
+headerRange: '[1-2]'
+linkTitle: rotate
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/certificates/rotate/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-cluster-certificates-rotate) | `/v1/cluster/certificates/rotate` | Regenerate all internal cluster certificates |
+
+## Rotate cluster certificates {#post-cluster-certificates-rotate}
+
+	POST /v1/cluster/certificates/rotate
+
+Regenerates all _internal_ cluster certificates.
+
+The certificate rotation will be performed on all nodes within the cluster. If
+"name" is provided, only rotate the specified certificate on all nodes within the cluster.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/cluster/certificates/rotate
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#post-response} 
+
+Responds with a `200 OK` status code if the internal certificates successfully rotate across the entire cluster.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Failed, not all nodes have been updated. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Unsupported internal certificate rotation. |
+---
+Title: Cluster certificates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster certificates requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: certificates
+weight: $weight
+aliases: 
+    - /operate/rs/references/rest-api/requests/cluster/update-cert
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/certificates/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-certificates) | `/v1/cluster/certificates` | Get cluster certificates |
+| [PUT](#put-cluster-update_cert) | `/v1/cluster/update_cert` | Update a cluster certificate |
+| [DELETE](#delete-cluster-certificate) | `/v1/cluster/certificates/{certificate_name}` | Delete cluster certificate |
+
+## Get cluster certificates {#get-cluster-certificates}
+
+	GET /v1/cluster/certificates
+
+Get the cluster's certificates.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/certificates 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the cluster's certificates and keys.
+
+#### Example JSON body
+
+```json
+{
+    "api_cert": "-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----",
+    "api_key": "-----BEGIN RSA PRIVATE KEY-----...-----END RSA PRIVATE KEY-----"
+    "// additional certificates..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+
+## Update cluster certificate {#put-cluster-update_cert}
+
+```sh
+PUT /v1/cluster/update_cert
+```
+
+Replaces an existing certificate on all nodes within the cluster with a new certificate. The new certificate must pass validation before it can replace the old certificate.
+
+See the [certificates table]({{< relref "/operate/rs/7.4/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/cluster/update_cert
+```
+
+#### Example JSON body
+
+```json
+{
+    "name": "certificate1",
+    "key": "-----BEGIN RSA PRIVATE KEY-----\n[key_content]\n-----END RSA PRIVATE KEY-----",
+    "certificate": "-----BEGIN CERTIFICATE-----\n[cert_content]\n-----END CERTIFICATE-----",
+}
+```
+
+Replace `[key_content]` with the content of the private key and `[cert_content]` with the content of the certificate.
+
+### Response {#put-response}
+
+Responds with the `200 OK` status code if the certificate replacement succeeds across the entire cluster.
+
+Otherwise, retry the certificate update in case the failure was due to a temporary issue in the cluster.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Failed, invalid certificate. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Failed, unknown certificate. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Failed, invalid certificate. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Failed, expired certificate. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Failed, not all nodes have been updated. |
+
+
+## Delete cluster certificate {#delete-cluster-certificate}
+
+	DELETE /v1/cluster/certificates/{string: certificate_name}
+
+Removes the specified cluster certificate from both CCS and disk
+across all nodes. Only optional certificates can be deleted through
+this endpoint. See the [certificates table]({{< relref "/operate/rs/7.4/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/certificates/<certificate_name>
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates the certificate deletion success or failure.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Operation successful |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Failed, requested deletion of an unknown certificate |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Failed, requested deletion of a required certificate |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed, error while deleting certificate from disk |
+---
+Title: Check all cluster nodes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that run checks on all cluster nodes.
+headerRange: '[1-2]'
+linkTitle: check
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/check/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-check) | `/v1/cluster/check` | Runs checks on all cluster nodes |
+
+## Check all nodes {#get-cluster-check}
+
+	GET /v1/cluster/check
+
+Runs the following checks on all cluster nodes:
+
+| Check name | Description |
+|-----------|-------------|
+| bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| services | Verifies all Redis Enterprise Software services are running. |
+| port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| pidfiles | Verifies all active local shards have PID files. |
+| capabilities | Verifies all binaries have the proper capability bits. |
+| existing_sockets | Verifies sockets exist for all processes that require them. |
+| host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />• `transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_checks]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_nodes_checks" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/check
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+### Response {#get-response} 
+
+Returns a JSON array with results from all nodes.
+
+When errors occur, the server returns a JSON object with `result: false` and an `error` field that provides additional information for each node that had an error. If an error occurs during a check, the `error` field only includes a message for the first check that fails on each node.
+
+Possible `error` messages:
+
+- "bootstrap request to cnm_http failed,resp_code: ...,resp_content: ..."
+- "process ... is not running or not responding (...)"
+- "could not communicate with 'supervisorctl': ..."
+- "connectivity check failed retrieving ports for testing"
+
+#### Example JSON body
+
+```json
+{
+  "cluster_test_result": false,
+  "nodes": [
+    {
+      "node_uid": "1",
+      "result": true
+    },
+    {
+      "node_uid": "2",
+      "result": true
+    },
+    {
+      "node_uid": "3",
+      "result": false,
+      "error": "process alert_mgr is not running or not responding ([Errno 111] Connection refused)"
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+---
+Title: Cluster LDAP requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: LDAP configuration requests
+headerRange: '[1-2]'
+linkTitle: ldap
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/ldap/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-ldap) | `/v1/cluster/ldap` | Get LDAP configuration |
+| [PUT](#put-cluster-ldap) | `/v1/cluster/ldap` | Set/update LDAP configuration |
+| [DELETE](#delete-cluster-ldap) | `/v1/cluster/ldap` | Delete LDAP configuration |
+
+## Get LDAP configuration {#get-cluster-ldap}
+
+	GET /v1/cluster/ldap
+
+Get the LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ldap_config]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_ldap_config" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/ldap 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [LDAP object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap" >}}).
+
+#### Example JSON body
+
+```json
+{
+   "bind_dn": "rl_admin",
+   "bind_pass": "***",
+   "ca_cert": "",
+   "control_plane": false,
+   "data_plane": false,
+   "dn_group_attr": "MemberOf",
+   "dn_group_query": {},
+   "starttls": false,
+   "uris": ["ldap://ldap.example.org:636"],
+   "user_dn_query": {},
+   "user_dn_template": "cn=%u, ou=users,dc=example,dc=org"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+
+## Update LDAP configuration {#put-cluster-ldap}
+
+	PUT /v1/cluster/ldap
+
+Set or update the cluster LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ldap]({{< relref "/operate/rs/7.4/references/rest-api/permissions#config_ldap" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	POST /v1/cluster/ldap 
+
+#### Example JSON body
+
+```json
+{
+    "uris": [
+       "ldap://ldap.redislabs.com:389"
+    ],
+    "bind_dn": "rl_admin",
+    "bind_pass": "secret",
+    "user_dn_template": "cn=%u,dc=example,dc=org",
+    "dn_group_attr": "MemberOf",
+    "directory_timeout_s": 5
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#put-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| illegal_fields_combination | An unacceptable combination of fields was specified for the configuration object (e.g.: two mutually-exclusive fields), or a required field is missing.| 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, LDAP config has been set. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+
+## Delete LDAP configuration {#delete-cluster-ldap}
+
+	DELETE /v1/cluster/ldap
+
+Clear the LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ldap]({{< relref "/operate/rs/7.4/references/rest-api/permissions#config_ldap" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/ldap 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+---
+Title: Cluster module capabilities requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis module capabilities requests
+headerRange: '[1-2]'
+linkTitle: module-capabilities
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/module-capabilities/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-module-capabilities) | `/v1/cluster/module-capabilities` | List possible Redis module capabilities |
+
+## List Redis module capabilities {#get-cluster-module-capabilities}
+
+	GET /v1/cluster/module-capabilities
+
+List possible Redis module capabilities.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_modules]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_modules" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/module-capabilities 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains a list of capability names and descriptions.
+
+#### Example JSON body
+
+```json
+{
+  "all_capabilities": [
+    {"name": "types", "desc": "module has its own types and not only operate on existing redis types"},
+    {"name": "no_multi_key", "desc": "module has no methods that operate on multiple keys"}
+    "// additional capabilities..."
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+---
+Title: Auditing database connections requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Auditing database connections requests
+headerRange: '[1-2]'
+linkTitle: auditing/db_conns
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/auditing-db-conns/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Get database connection auditing settings |
+| [PUT](#put-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Update database connection auditing settings |
+| [DELETE](#delete-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Delete database connection auditing settings |
+
+## Get database auditing settings {#get-cluster-audit-db-conns}
+
+	GET /v1/cluster/auditing/db_conns
+
+Gets the configuration settings for [auditing database connections]({{< relref "/operate/rs/7.4/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/auditing/db_conns 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [database connection auditing configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/db-conns-auditing-config" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_protocol": "TCP",
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_auditing_unsupported_by_capability | Not all nodes support DB Connections Auditing capability  | 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+
+## Update database auditing {#put-cluster-audit-db-conns}
+
+	PUT /v1/cluster/auditing/db_conns
+
+Updates the configuration settings for [auditing database connections]({{< relref "/operate/rs/7.4/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/auditing/db_conns
+
+#### Example JSON body
+
+```json
+{
+    "audit_protocol": "TCP",
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [database connection auditing configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/db-conns-auditing-config" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [database connection auditing configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/db-conns-auditing-config" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_protocol": "TCP",
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+### Error codes {#put-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_auditing_unsupported_by_capability | Not all nodes support DB Connections Auditing capability  | 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+
+## Delete database auditing settings {#delete-cluster-audit-db-conns}
+
+	DELETE /v1/cluster/auditing/db_conns
+
+Resets the configuration settings for [auditing database connections]({{< relref "/operate/rs/7.4/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/auditing/db_conns 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates whether the database connection auditing settings reset successfully or failed to reset.
+
+### Error codes {#delete-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_audit_config_not_found | Unable to find the auditing configuration |
+| cannot_delete_audit_config_when_policy_enabled | Auditing cluster policy is 'enabled' when trying to delete the auditing configuration |
+| cannot_delete_audit_config_when_bdb_enabled | One of the databases has auditing configuration 'enabled' when trying to delete the auditing configuration |
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Configuration not found |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+---
+Title: Cluster alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/alerts/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-alerts) | `/v1/cluster/alerts` | Get all cluster alerts |
+| [GET](#get-alert) | `/v1/cluster/alerts/{alert}` | Get a specific cluster alert |
+
+## Get all cluster alerts {#get-all-alerts}
+
+	GET /v1/cluster/alerts
+
+Get all alert states for the cluster object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster’s alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-all-response} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "cluster_too_few_nodes_for_replication": {
+        "change_time": "2014-12-22T11:48:00Z",
+        "change_value": {
+            "state": false
+        },
+       "enabled": true,
+       "state": "off",
+       "severity": "WARNING",
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get cluster alert {#get-alert}
+
+	GET /v1/cluster/alerts/{alert}
+
+Get a cluster alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/alerts/cluster_too_few_nodes_for_replication 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster’s alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "change_time": "2014-12-22T11:48:00Z",
+    "change_value": {
+        "state": false
+    },
+   "enabled": true,
+   "state": "off",
+   "severity": "WARNING",
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert does not exist |
+---
+Title: Cluster actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster action requests
+headerRange: '[1-2]'
+linkTitle: actions
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/actions/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-cluster-actions) | `/v1/cluster/actions` | Get the status of all actions  |
+| [GET](#get-cluster-action) | `/v1/cluster/actions/{action}` | Get the status of a specific action |
+| [POST](#post-cluster-action) | `/v1/cluster/actions/{action}` | Initiate a cluster-wide action |
+| [DELETE](#delete-cluster-action) | `/v1/cluster/actions/{action}` | Cancel action or remove action status |
+
+## Get all cluster actions {#get-all-cluster-actions}
+
+	GET /v1/cluster/actions
+
+Get the status of all currently executing, queued, or completed cluster actions.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+    GET /v1/cluster/actions
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [action objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}). 
+
+#### Example JSON body
+
+```json
+{
+    "actions": [
+        {
+            "name": "action_name",
+            "status": "queued",
+            "progress": 0.0
+        }
+    ]
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Get cluster action {#get-cluster-action}
+
+	GET /v1/cluster/actions/{action}
+
+Get the status of a currently executing, queued, or completed cluster action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The action to check. |
+
+### Response {#get-response} 
+
+Returns an [action object]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}). 
+
+#### Example JSON body
+
+```json
+{
+    "name": "action_name",
+     "status": "queued",
+    "progress": 0.0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Initiate cluster-wide action {#post-cluster-action}
+
+	POST /v1/cluster/actions/{action}
+
+Initiate a cluster-wide action.
+
+The API allows only a single instance of any action type to be
+invoked at the same time, and violations of this requirement will
+result in a `409 CONFLICT` response.
+
+The caller is expected to query and process the results of the
+previously executed instance of the same action, which will be
+removed as soon as the new one is submitted.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [start_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#start_cluster_action" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+    POST /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action required. |
+
+Supported cluster actions:
+
+- `change_master`: Promotes a specified node to become the primary node of the cluster, which coordinates cluster-wide operations. Include the `node_uid` of the node you want to promote in the request body.
+
+    ```sh
+    POST /v1/cluster/actions/change_master
+    {
+        "node_uid": "2"
+    }
+    ```
+
+### Response {#post-response} 
+
+The body content may provide additional action details. Currently, it is not used. 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, action was initiated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad action or content provided. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | A conflicting action is already in progress. |
+
+## Cancel action {#delete-cluster-action}
+
+	DELETE /v1/cluster/actions/{action}
+
+Cancel a queued or executing cluster action, or remove the status of
+a previously executed and completed action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [cancel_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#cancel_cluster_action" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+    DELETE /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action to cancel, currently no actions are supported. |
+
+### Response {#delete-response} 
+
+Returns a status code.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action will be cancelled when possible. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action unknown or not currently running. |
+---
+Title: Cluster policy requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster policy requests
+headerRange: '[1-2]'
+linkTitle: policy
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/policy/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-policy) | `/v1/cluster/policy` | Get cluster policy settings |
+| [PUT](#put-cluster-policy) | `/v1/cluster/policy` | Update cluster policy settings |
+
+## Get cluster policy {#get-cluster-policy}
+
+	GET /v1/cluster/policy
+
+Gets the cluster's current policy settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/policy 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [cluster settings object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster_settings" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "db_conns_auditing": false,
+    "default_non_sharded_proxy_policy": "single",
+    "default_provisioned_redis_version": "6.0",
+    "default_sharded_proxy_policy": "single",
+    "default_shards_placement": "dense",
+    "redis_upgrade_policy": "major",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+
+## Update cluster policy {#put-cluster-policy}
+
+	PUT /v1/cluster/policy
+
+Update cluster policy settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/policy
+
+#### Example JSON body
+
+```json
+{
+    "default_shards_placement": "sparse",
+    "default_sharded_proxy_policy": "all-nodes"
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [cluster settings object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster_settings" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns a status code that indicates the success or failure of the cluster settings update.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Failed to set parameters |
+---
+Title: Cluster last stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent cluster statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/stats/last/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-stats-last) | `/v1/cluster/stats/last` | Get most recent cluster stats |
+
+## Get latest cluster stats {#get-cluster-stats-last}
+
+	GET /v1/cluster/stats/last
+
+Get the most recent cluster statistics.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/stats/last?interval=1sec&stime=2015-10-14T06:44:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns the most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the cluster.
+
+#### Example JSON body
+
+```json
+{
+    "conns": 0.0,
+    "cpu_idle": 0.8424999999988358,
+    "cpu_system": 0.01749999999992724,
+    "cpu_user": 0.08374999999978172,
+    "egress_bytes": 7403.0,
+    "ephemeral_storage_avail": 151638712320.0,
+    "ephemeral_storage_free": 162375925760.0,
+    "etime": "2015-10-14T06:44:01Z",
+    "free_memory": 5862400000.0,
+    "ingress_bytes": 7469.0,
+    "interval": "1sec",
+    "persistent_storage_avail": 151638712320.0,
+    "persistent_storage_free": 162375925760.0,
+    "stime": "2015-10-14T06:44:00Z",
+    "total_req": 0.0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal server error |
+---
+Title: Cluster stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-stats) | `/v1/cluster/stats` | Get cluster stats |
+
+## Get cluster stats {#get-cluster-stats}
+
+```sh
+GET /v1/cluster/stats
+```
+
+Get cluster statistics.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/cluster/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the cluster.
+
+#### Example JSON body
+
+```json
+{
+  "intervals": [
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T12:00:00Z",
+      "etime": "2015-05-28T12:59:59Z",
+      "conns": 0.0,
+      "cpu_idle": 0.8533959401503577,
+      "cpu_system": 0.01602159448549579,
+      "cpu_user": 0.08721123782294203,
+      "egress_bytes": 1111.2184745131947,
+      "ephemeral_storage_avail": 3406676307.1449075,
+      "ephemeral_storage_free": 4455091440.360014,
+      "free_memory": 2745470765.673594,
+      "ingress_bytes": 220.84083194769272,
+      "interval": "1week",
+      "persistent_storage_avail": 3406676307.1533995,
+      "persistent_storage_free": 4455091440.088265,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T13:00:00Z",
+      "etime": "2015-05-28T13:59:59Z",
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X GET
+        https://[host][:port]/v1/cluster/stats?interval=1hour
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/cluster/stats?interval=1hour"
+auth = ("[username]", "[password]")
+
+response = requests.request("GET", url, auth=auth)
+
+print(response.text)
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal server error |
+---
+Title: Cluster requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster settings requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: cluster
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/cluster/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster) | `/v1/cluster` | Get cluster info |
+| [PUT](#put-cluster) | `/v1/cluster` | Update cluster settings |
+
+## Get cluster info {#get-cluster}
+
+	GET /v1/cluster
+
+Get cluster info.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [cluster object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster" >}}).
+
+#### Example JSON body
+
+```json
+{
+   "name": "my-rlec-cluster",
+   "alert_settings": { "..." },
+   "created_time": "2015-04-29T09:09:25Z",
+   "email_alerts": false,
+   "email_from": "",
+   "rack_aware": false,
+   "smtp_host": "",
+   "smtp_password": "",
+   "smtp_port": 25,
+   "smtp_tls_mode": "none",
+   "smtp_username": ""
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Update cluster settings {#put-cluster}
+
+	PUT /v1/cluster
+
+Update cluster settings.
+
+If called with the `dry_run` URL query string, the function will
+validate the [cluster object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster" >}}), but will not apply the requested
+changes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster 
+
+#### Example JSON body
+
+```json
+{
+    "email_alerts": true,
+    "alert_settings": {
+        "node_failed": true,
+        "node_memory": {
+            "enabled": true,
+            "threshold": "80"
+        }
+    }
+}
+```
+
+The above request will enable email alerts and alert reporting for node failures and node removals.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run | string | Validate but don't apply the new cluster settings |
+
+#### Request body
+
+Include a [cluster object]({{< relref "/operate/rs/7.4/references/rest-api/objects/cluster" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+#### Example JSON body
+
+```json
+{
+    "name": "mycluster.mydomain.com",
+    "email_alerts": true,
+    "alert_settings": {
+        "node_failed": true,
+        "node_memory": {
+            "enabled": true,
+            "threshold": "80"
+        }
+    },
+    "// additional fields..."
+}
+```
+
+### Error codes {#put-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| bad_nginx_conf | • Designated port is already bound.<br></br>• nginx configuration is illegal. | 
+| bad_debuginfo_path | • Debuginfo path doesn't exist.<br></br>• Debuginfo path is inaccessible. | 
+| config_edit_conflict | Cluster config was edited by another source simultaneously. | 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided. |
+
+---
+Title: Bootstrap validation requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Boostrap validation requests
+headerRange: '[1-2]'
+linkTitle: validate
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bootstrap/validate/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bootstrap-validate) | `/v1/bootstrap/validate/{action}` | Perform bootstrap validation |
+
+## Bootstrap validation {#post-bootstrap-validate}
+
+	POST /v1/bootstrap/validate/{action}
+
+Perform bootstrap validation.
+
+Unlike actual bootstrapping, this request blocks and immediately
+returns with a response.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/bootstrap/validate/join_cluster
+
+#### Request body
+
+The request must contain a [bootstrap configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap" >}}), similar to the one used for actual bootstrapping.
+
+### Response {#post-response} 
+
+If an error occurs, the call returns a `bootstrap_status` JSON object that contains the following fields:
+
+| Field | Description |
+|-------|-------------|
+| state | Current bootstrap state.<br></br>`idle`: No bootstrapping started.<br></br>`initiated`: Bootstrap request received.<br></br>`creating_cluster`: In the process of creating a new cluster.<br></br>`joining_cluster`: In the process of joining an existing cluster.<br></br>`error`: The last bootstrap action failed.<br></br>`completed`: The last bootstrap action completed successfully.|
+| start_time | Bootstrap process start time |
+| end_time | Bootstrap process end time |
+| error_code | If state is `error`, this error code describes the type of error encountered. |
+| error_details | An error-specific object that may contain additional information about the error. A common field in use is `message` which provides a more verbose error message.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, validation was successful. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Validation failed, bootstrap status is returned as body. |
+---
+Title: Bootstrap requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Bootstrap requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: bootstrap
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bootstrap/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bootstrap) | `/v1/boostrap` | Get the local node's bootstrap status |
+| [POST](#post-bootstrap) | `/v1/bootstrap/{action}` | Initiate bootstrapping |
+
+## Get bootstrap status {#get-bootstrap}
+
+```sh
+GET /v1/bootstrap
+```
+
+Get the local node's bootstrap status.
+
+This request is accepted as soon the cluster software is installed and before the node is part of an active cluster.
+
+Once the node is part of an active cluster, authentication is required.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bootstrap
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+The JSON response object contains a `bootstrap_status` object and a `local_node_info` object.
+
+The `bootstrap_status` object contains the following information:
+
+| Field | Description |
+|-------|-------------|
+| state | Current bootstrap state.<br></br>`idle`: No bootstrapping started.<br></br>`initiated`: Bootstrap request received.<br></br>`creating_cluster`: In the process of creating a new cluster.<br></br>`recovering_cluster`: In the process of recovering a cluster.<br /><br />`joining_cluster`: In the process of joining an existing cluster.<br></br>`error`: The last bootstrap action failed.<br></br>`completed`: The last bootstrap action completed successfully.|
+| start_time | Bootstrap process start time |
+| end_time | Bootstrap process end time |
+| error_code | If state is `error`, this error code describes the type of error encountered. |
+| error_details | An error-specific object that may contain additional information about the error. A common field in use is `message` which provides a more verbose error message.
+
+The `local_node_info` object is a subset of a [node object]({{< relref "/operate/rs/7.4/references/rest-api/objects/node" >}}) that provides information about the node configuration.
+
+#### Example JSON body
+
+```json
+{
+    "bootstrap_status": {
+        "start_time": "2014-08-29T11:19:49Z",
+        "end_time": "2014-08-29T11:19:49Z",
+        "state": "completed"
+    },
+    "local_node_info": {
+        "uid": 3,
+        "software_version": "0.90.0-1",
+        "cores": 2,
+        "ephemeral_storage_path": "/var/opt/redislabs/tmp",
+        "ephemeral_storage_size": 1018889.8304,
+        "os_version": "Ubuntu 14.04 LTS",
+        "persistent_storage_path": "/var/opt/redislabs/persist/redis",
+        "persistent_storage_size": 1018889.8304,
+        "total_memory": 24137,
+        "uptime": 50278,
+        "available_addrs": [{
+                                 "address": "172.16.50.122",
+                                 "format": "ipv4",
+                                 "if_name": "eth0",
+                                 "private": true
+                             },
+                             {
+                                 "address": "10.0.3.1",
+                                 "format": "ipv4",
+                                 "if_name": "lxcbr0",
+                                 "private": true
+                             },
+                             {
+                                 "address": "172.17.0.1",
+                                 "format": "ipv4",
+                                 "if_name": "docker0",
+                                 "private": true
+                             },
+                            {
+                                 "address": "2001:db8:0:f101::1",
+                                 "format": "ipv6",
+                                 "if_name": "eth0",
+                                 "private": false
+                            }]
+    }
+}
+```
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| config_error | An error related to the bootstrap configuration provided (e.g. bad JSON). |
+| connect_error | Failed to connect to cluster (e.g. FQDN DNS could not resolve, no/wrong node IP provided, etc. |
+| access_denied | Invalid credentials supplied. |
+| invalid_license | The license string provided is invalid. Additional info can be fetched from the `error_details` object, which includes the violation code in case the license is valid but its terms are violated. |
+| repair_required | Cluster is in degraded mode and can only accept replacement nodes. When this happens, `error_details` contains two fields: `failed_nodes` and `replace_candidate`. The `failed_nodes` field is an array of objects, each describing a failed node with at least a `uid` field and an optional `rack_id`. `replace_candidate` is the UID of the node most suitable for replacement. |
+| insufficient_node_memory | An attempt to replace a dead node fails because the replaced node does not have enough memory. When this happens, error_details contains a required_memory field which indicates the node memory requirement. |
+| insufficient_node_flash | An attempt to replace a dead node fails because the replaced node does not have enough flash. When this happens, `error_details` contains a `required_flash` field which indicates the node flash requirement. |
+| time_not_sync | An attempt to join a node with system time not synchronized with the rest of the cluster. |
+| rack_id_required | An attempt to join a node with no `rack_id` in a rack-aware cluster. In addition, a `current_rack_ids` field will include an array of currently used rack ids. |
+| socket_directory_mismatch | An attempt to join a node with a socket directory setting that differs from the cluster |
+| node_config_mismatch | An attempt to join a node with a configuration setting (e.g. confdir, osuser, installdir) that differs from the cluster |
+| path_error | A needed path does not exist or is not accessable. |        
+| internal_error | A different, unspecified internal error was encountered. |
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Start bootstrapping {#post-bootstrap}
+
+```sh
+POST /v1/bootstrap/{action}
+```
+
+Initiate bootstrapping.
+
+The request must contain a bootstrap configuration JSON object, as
+described in [Object attributes]({{< relref "/operate/rs/7.4/references/rest-api/objects/" >}}) or a minimal subset.
+
+Bootstrapping is permitted only when the current bootstrap state is
+`idle` or `error` (in which case the process will restart with the new
+configuration).
+
+This request is asynchronous - once the request has been accepted,
+the caller is expected to poll bootstrap status while waiting for it to
+complete.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bootstrap/create_cluster
+```
+
+#### Example JSON body
+
+##### Join cluster
+```json
+{
+    "action": "join_cluster",
+    "cluster": {
+       "nodes":[ "1.1.1.1", "2.2.2.2" ]
+    },
+    "node": {
+       "paths": {
+          "persistent_path": "/path/to/persistent/storage",
+          "ephemeral_path": "/path/to/ephemeral/storage",
+          "bigstore_path": "/path/to/bigstore/storage"
+       },
+       "bigstore_driver": "speedb",
+       "identity": {
+          "addr":"1.2.3.4",
+          "external_addr":["2001:0db8:85a3:0000:0000:8a2e:0370:7334", "3.4.5.6"]
+       }
+    },
+    "credentials": {
+       "username": "my_username",
+       "password": "my_password"
+    }
+}
+```
+
+##### Create cluster
+```json
+{
+    "action": "create_cluster",
+    "cluster": {
+       "nodes": [],
+       "name": "my.cluster"
+    },
+    "node": {
+       "paths": {
+          "persistent_path": "/path/to/persistent/storage",
+          "ephemeral_path": "/path/to/ephemeral/storage",
+          "bigstore_path": "/path/to/bigredis/storage"
+       },
+       "identity": {
+          "addr":"1.2.3.4",
+          "external_addr":["2001:0db8:85a3:0000:0000:8a2e:0370:7334", "3.4.5.6"]
+       },
+       "bigstore_driver": "rocksdb"
+    },
+    "license": "----- LICENSE START -----\ndi+iK...KniI9\n----- LICENSE END -----\n",
+    "credentials": {
+       "username": "my_username",
+       "password": "my_password"
+    }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [bootstrap object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bootstrap" >}}) in the request body.
+
+### Response {#post-response}
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Request received and processing begins. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Bootstrap already in progress (check state) |
+---
+Title: License requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: License requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: license
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/license/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-license) | `/v1/license` | Get license details |
+| [PUT](#put-license) | `/v1/license` | Update the license |
+
+## Get license {#get-license}
+
+	GET /v1/license
+
+Returns the license details, including license string, expiration,
+and supported features.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_license]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_license" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/license 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the license details:
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| license | string | License data |
+| cluster_name | string | The cluster name (FQDN) |
+| expired | boolean | If the cluster key is expired (`true` or `false`) |
+| activation_date | string | The date of the cluster key activation |
+| expiration_date | string | The date of the cluster key expiration |
+| key | string | License key |
+| features | array of strings | Features supported by the cluster |
+| owner | string | License owner |
+| shards_limit | integer | The total number of shards allowed by the cluster key |
+| ram_shards_limit | integer | The number of RAM shards allowed by the cluster key (as of v7.2) |
+| ram_shards_in_use | integer | The number of RAM shards in use |
+| flash_shards_limit | integer | The number of flash shards (Auto Tiering) allowed by the cluster key (as of v7.2) |
+| flash_shards_in_use | integer | The number of flash shards in use |
+
+#### Example JSON body
+
+```json
+{
+    "license": "----- LICENSE START -----\\ndi+iK...KniI9\\n----- LICENSE END -----\\n",
+    "expired": true,
+    "activation_date":"2018-12-31T00:00:00Z",
+    "expiration_date":"2019-12-31T00:00:00Z",
+    "ram_shards_in_use": 0,
+    "ram_shards_limit": 300,
+    "flash_shards_in_use": 0,
+    "flash_shards_limit": 100,
+    "shards_limit": 400,
+    "features": ["bigstore"],
+    "owner": "Redis",
+    "cluster_name": "mycluster.local",
+    "key": "----- LICENSE START -----\\ndi+iK...KniI9\\n----- LICENSE END -----\\n"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | License is returned in the response body. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No license is installed. |
+
+## Update license {#put-license}
+
+	PUT /v1/license
+
+Validate and install a new license string.
+
+If you do not provide a valid license, the cluster behaves as if the license was deleted. See [Expired cluster license]({{< relref "/operate/rs/7.4/clusters/configure/license-keys#expired-cluster-license" >}}) for a list of available actions and restrictions.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [install_new_license]({{< relref "/operate/rs/7.4/references/rest-api/permissions#install_new_license" >}}) |
+
+### Request {#put-request} 
+
+The request must be a JSON object with a single key named "license".
+
+#### Example HTTP request
+
+	PUT /v1/license 
+
+#### Example JSON body
+
+```json
+{
+    "license": "----- LICENSE START -----\ndi+iK...KniI9\n----- LICENSE END -----\n"
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include a JSON object that contains the new `license` string in the request body.
+
+### Response {#put-response} 
+
+Returns an error if the new license is not valid.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | License installed successfully. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Invalid request, either bad JSON object or corrupted license was supplied. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | License violation. A response body provides more details on the specific cause. |
+---
+Title: Node debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /nodes/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/debuginfo/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-all-nodes) | `/v1/nodes/debuginfo` | Get debug info from all nodes |
+| [GET](#get-debuginfo-node) | `/v1/nodes/{node_uid}/debuginfo` | Get debug info from a specific node |
+
+## Get debug info from all nodes {#get-debuginfo-all-nodes}
+
+	GET /v1/nodes/debuginfo
+
+Downloads a tar file that contains debug info from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/debuginfo
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+
+## Get node debug info {#get-debuginfo-node}
+
+	GET /v1/nodes/{int: node_uid}/debuginfo
+
+Downloads a tar file that contains debug info from a specific node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/1/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Node status requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that return a node's hostname and role.
+headerRange: '[1-2]'
+linkTitle: status
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/status/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-status) | `/v1/nodes/status` | Get the status of all nodes |
+| [GET](#get-node-status) | `/v1/nodes/{uid}/status` | Get a node's status |
+
+## Get all node statuses {#get-all-nodes-status}
+
+	GET /v1/nodes/status
+
+Gets the status of all nodes. Includes each node's hostname and role in the cluster:
+
+- Primary nodes return `"role": "master"`
+
+- Replica nodes return `"role": "slave"`
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/status
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+For each node in the cluster, returns a JSON object that contains each node's hostname, role, and other status details.
+
+If a maintenance snapshot exists due to an in-progress or improperly stopped [node maintenance]({{<relref "/operate/rs/7.4/clusters/maintenance-mode">}}) process, the response includes a `maintenance_snapshot` field.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "cores": 8,
+        "free_provisional_ram": 0,
+        "free_ram": 3499368448,
+        "hostname": "3d99db1fdf4b",
+        "maintenance_snapshot": {
+            "created_time": "2024-09-06 20:47:23",
+            "name": "maintenance_mode_2024-09-06_20-47-23",
+            "node_uid": "1"
+        },
+        "master_shards": [],
+        "node_overbooking_depth": 0,
+        "node_status": "active",
+        "role": "master",
+        "slave_shards": [],
+        "software_version": "7.4.6-22",
+        "software_version_sha": "6c37b1483b5fb6110c8055c1526aa58eec1d29d3519e92310859101419248831",
+        "total_memory": 6219673600,
+        "total_provisional_ram": 0
+    },
+    "2": {
+        "hostname": "fc7a3d332458",
+        "role": "slave",
+        // additional fields
+    },
+    "3": {
+        "hostname": "b87cc06c830f",
+        "role": "slave",
+        // additional fields
+    }
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+
+## Get node status {#get-node-status}
+
+	GET /v1/nodes/{int: uid}/status
+
+Gets the status of a node. Includes the node's hostname and role in the cluster:
+
+- Primary nodes return `"role": "master"`
+
+- Replica nodes return `"role": "slave"`
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/1/status
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The node's unique ID. |
+
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the node's hostname, role, and other status details.
+
+If a maintenance snapshot exists due to an in-progress or improperly stopped [node maintenance]({{<relref "/operate/rs/7.4/clusters/maintenance-mode">}}) process, the response includes a `maintenance_snapshot` field.
+
+#### Example JSON body
+
+```json
+{
+    "cores": 8,
+    "free_provisional_ram": 0,
+    "free_ram": 3504422912,
+    "hostname": "3d99db1fdf4b",
+    "maintenance_snapshot": {
+        "created_time": "2024-09-06 20:47:23",
+        "name": "maintenance_mode_2024-09-06_20-47-23",
+        "node_uid": "1"
+    },
+    "master_shards": [],
+    "node_overbooking_depth": 0,
+    "node_status": "active",
+    "role": "master",
+    "slave_shards": [],
+    "software_version": "7.4.6-22",
+    "software_version_sha": "6c37b1483b5fb6110c8055c1526aa58eec1d29d3519e92310859101419248831",
+    "total_memory": 6219673600,
+    "total_provisional_ram": 0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+---
+Title: Check node requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that run checks on a cluster node.
+headerRange: '[1-2]'
+linkTitle: check
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/check/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-node-check) | `/v1/nodes/check/{uid}` | Runs checks on a cluster node |
+
+## Check node {#get-node-check}
+
+	GET /v1/nodes/check/{int: uid}
+
+Runs the following checks on a cluster node:
+
+| Check name | Description |
+|-----------|-------------|
+| bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| services | Verifies all Redis Enterprise Software services are running. |
+| port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| pidfiles | Verifies all active local shards have PID files. |
+| capabilities | Verifies all binaries have the proper capability bits. |
+| existing_sockets | Verifies sockets exist for all processes that require them. |
+| host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />• `transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_check]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_check" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/check/1
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The node's unique ID. |
+
+
+### Response {#get-response} 
+
+Returns a JSON object with the node's check results.
+
+When errors occur, the server returns a JSON object with `result: false` and an `error` field that provides additional information. If an error occurs during a check, the `error` field only includes a message for the first check that fails.
+
+Possible `error` messages:
+
+- "bootstrap request to cnm_http failed,resp_code: ...,resp_content: ..."
+- "process ... is not running or not responding (...)"
+- "could not communicate with 'supervisorctl': ..."
+- "connectivity check failed retrieving ports for testing"
+
+#### Example JSON body
+
+```json
+{
+    "node_uid": 1,
+    "result": true
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+---
+Title: Node alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/alerts/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-alerts) | `/v1/nodes/alerts` | Get all alert states for all nodes |
+| [GET](#get-node-alerts) | `/v1/nodes/alerts/{uid}` | Get all alert states for a node |
+| [GET](#get-node-alert) | `/v1/nodes/alerts/{uid}/{alert}` | Get node alert state |
+
+## Get all alert states {#get-all-nodes-alerts}
+
+	GET /v1/nodes/alerts
+
+Get all alert states for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_nodes_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-all-response} 
+
+Returns a hash of node UIDs and the [alert states]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) for each node.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "node_cpu_utilization": {
+            "change_time": "2014-12-22T10:42:00Z",
+            "change_value": {
+                "cpu_util": 2.500000000145519,
+                "global_threshold": "1",
+                "state": true
+            },
+            "enabled": true,
+            "state": true,
+            "severity": "WARNING"
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get node alert states {#get-node-alerts}
+
+	GET /v1/nodes/alerts/{int: uid}
+
+Get all alert states for a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_alerts" >}}) |
+
+### Request {#get-request-all-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts/1 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response-all-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states for a specific node.
+
+#### Example JSON body
+
+```json
+{
+   "node_cpu_utilization": {
+        "change_time": "2014-12-22T10:42:00Z",
+        "change_value": {
+            "cpu_util": 2.500000000145519,
+            "global_threshold": "1",
+            "state": true
+        },
+        "enabled": true,
+        "state": true,
+        "severity": "WARNING",
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified node does not exist |
+
+## Get node alert state {#get-node-alert}
+
+	GET /v1/nodes/alerts/{int: uid}/{alert}
+
+Get a node alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts/1/node_cpu_utilization 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "change_time": "2014-12-22T10:42:00Z",
+    "change_value": {
+        "cpu_util": 2.500000000145519,
+        "global_threshold": "1",
+        "state": true
+    },
+    "enabled": true,
+    "state": true,
+    "severity": "WARNING",
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or node does not exist |
+---
+Title: Node snapshot requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node snapshot requests
+headerRange: '[1-2]'
+linkTitle: snapshots
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/snapshots/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-snapshots) | `/v1/nodes/{uid}/snapshots` | Get node snapshots |
+| [DELETE](#delete-snapshot) | `/v1/nodes/{uid}/snapshots/{snapshot_name}` | Delete a node snapshot |
+
+## Get node snapshots {#get-snapshots}
+
+```sh
+GET /v1/nodes/{int: uid}/snapshots
+```
+
+Get all cluster node snapshots of the specified node.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_node_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/snapshots
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+### Response {#get-response}
+
+Returns an array of node snapshot JSON objects.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "created_time": "2024-01-10 20:55:54",
+        "name": "nightly_snapshot_1",
+        "node_uid": "1"
+    },
+    {
+        "created_time": "2024-01-11 20:55:54",
+        "name": "nightly_snapshot_2",
+        "node_uid": "1"
+    }
+]
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+
+## Delete node snapshot {#delete-snapshot}
+
+```sh
+DELETE /v1/nodes/{int: uid}/snapshots/{snapshot_name}
+```
+
+Delete a cluster node snapshot. Snapshots created by maintenance mode are not deleted.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_node]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_node" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/nodes/1/snapshots/nightly_snapshot_19
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated node. |
+| snapshot_name | string | The unique name of the snapshot to delete. |
+
+### Response {#delete-response}
+
+Returns a JSON object that represents the deleted node snapshot.
+
+#### Example JSON body
+
+```json
+{
+    "created_time": "2024-01-11 20:55:54",
+    "name": "nightly_snapshot_19",
+    "node_uid": "1"
+}
+```
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Node snapshot is a maintenance snapshot and cannot be deleted |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node uid does not exist |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Snapshot name does not exist for this node uid |
+---
+Title: Node actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node action requests
+headerRange: '[1-2]'
+linkTitle: actions
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/actions/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-actions) | `/v1/nodes/actions` | Get status of all actions on all nodes|
+| [GET](#get-node-actions) | `/v1/nodes/{node_uid}/actions` | Get status of all actions on a specific node |
+| [GET](#get-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Get status of an action on a specific node |
+| [POST](#post-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Initiate node action |
+| [DELETE](#delete-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Cancel action or remove action status |
+
+## Get all actions {#get-all-nodes-actions}
+
+```sh
+GET /v1/nodes/actions
+```
+
+Get the status of all currently executing, pending, or completed
+actions on all nodes.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_status_of_all_node_actions]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_all_node_actions" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/actions
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a list of [action objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}).
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+
+## Get node actions statuses {#get-node-actions}
+
+```sh
+GET /v1/nodes/{node_uid}/actions
+```
+
+Get the status of all actions on a specific node.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_status_of_node_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_node_action" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request-all-actions}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/actions
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The action to check. |
+
+### Response {#get-response-all-actions}
+
+Returns a JSON object that includes a list of [action objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}) for the specified node.
+
+If no actions are available, the response will include an empty array.
+
+#### Example JSON body
+
+```json
+{
+    "actions": [
+        {
+            "name": "remove_node",
+            "node_uid": "1",
+            "status": "running",
+            "progress": 10
+        }
+    ]
+}
+```
+
+### Error codes {#get-error-codes-all-actions}
+
+| Code | Description |
+|------|-------------|
+| internal_error | An internal error that cannot be mapped to a more precise error code has been encountered. |
+| insufficient_resources | The cluster does not have sufficient resources to complete the required operation. |
+
+### Status codes {#get-status-codes-all-actions}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Get node action status {#get-node-action}
+
+```sh
+GET /v1/nodes/{node_uid}/actions/{action}
+```
+
+Get the status of a currently executing, queued, or completed action on a specific node.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+Returns an [action object]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}) for the specified node.
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| internal_error | An internal error that cannot be mapped to a more precise error code has been encountered. |
+| insufficient_resources | The cluster does not have sufficient resources to complete the required operation. |
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Initiate node action {#post-node-action}
+
+```sh
+POST /v1/nodes/{node_uid}/actions/{action}
+```
+
+Initiate a node action.
+
+The API allows only a single instance of any action type to be
+invoked at the same time, and violations of this requirement will
+result in a `409 CONFLICT` response.
+
+The caller is expected to query and process the results of the
+previously executed instance of the same action, which will be
+removed as soon as the new one is submitted.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_node_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#start_node_action" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action required. |
+
+Currently supported actions are:
+
+- `remove`: Removes the node from the cluster after migrating all bound resources to other nodes. As soon as a successful remove request is received, the cluster will no longer automatically migrate resources, such as shards and endpoints, to the node even if the remove task fails at some point.
+
+    - By default, the remove node action completes after all resources migrate off the removed node. Node removal does not wait for migrated shards' persistence files to be created on the new nodes.
+    
+        To change node removal to wait for the creation of new persistence files for all migrated shards, set `wait_for_persistence` to `true` in the request body or [update the cluster policy]({{<relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy">}}) `persistent_node_removal` to `true` to change the cluster's default behavior.
+
+        ```sh
+        POST /v1/nodes/<node_id>/actions/remove
+        {
+            "wait_for_persistence": true
+        }
+        ```
+
+- `maintenance_on`: Creates a snapshot of the node, migrates shards to other nodes, and prepares the node for maintenance. See [maintenance mode]({{< relref "/operate/rs/7.4/clusters/maintenance-mode" >}}) for more information.
+
+    - As of Redis Enterprise Software version 7.4.2, a new node snapshot is created only if no maintenance mode snapshots already exist or if you set `"overwrite_snapshot": true` in the request body.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true
+        }
+        ```
+
+    - If there aren't enough resources to migrate shards out of the maintained node, set `"evict_ha_replica": false` and `"evict_active_active_replica": false` in the request body to keep the replica shards in place but demote any master shards. Use these two parameters instead of `keep_slave_shards`, which is deprecated as of Redis Enterprise Software version 7.4.2.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true,
+            "evict_ha_replica": false,
+            "evict_active_active_replica": false
+        }
+        ```
+
+    - To specify databases whose shards should be evicted from the node when entering maintenance mode, set `"evict_dbs": ["List of database ID strings"]` in the request body.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true,
+            "evict_dbs": ["1", "3"] 
+        }
+        ```
+
+- `maintenance_off`: Restores node to its previous state before maintenance started. See [maintenance mode]({{< relref "/operate/rs/7.4/clusters/maintenance-mode" >}}) for more information.
+
+    - By default, it uses the latest node snapshot.
+
+    - Use `"snapshot_name":`&nbsp;`"..."` in the request body to restore the state from a specific snapshot.
+
+    - To avoid restoring shards at the node, use `"skip_shards_restore":`&nbsp;`true`.
+
+- `enslave_node`: Turn node into a replica.
+
+### Response {#post-response}
+
+The body content may provide additional action details.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action initiated successfully. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Only a single instance of any action type can be invoked at the same time. |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -X POST -u "[username]:[password]" -d "{}"
+            https://[host][:port]/v1/nodes/1/actions/remove
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][port]/v1/nodes/1/actions/remove"
+
+payload = json.dumps({})
+headers = {
+  'Content-Type': 'application/json',
+}
+auth = ("[username]", "[password]")
+
+response = requests.request("POST", url, auth=auth, headers=headers, data=payload)
+
+print(response.text)
+```
+
+## Cancel action {#delete-node-action}
+
+```sh
+DELETE /v1/nodes/{node_uid}/actions/{action}
+```
+
+Cancel a queued or executing node action, or remove the status of a
+previously executed and completed action.
+
+### Permissions
+
+| Permission name |
+|-----------------|
+| [cancel_node_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#cancel_node_action" >}}) |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action to cancel. |
+
+### Response {#delete-response}
+
+Returns a status code.
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action will be cancelled when possible. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action unknown or not currently running. |
+---
+Title: Latest node stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent node statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/stats/last/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-stats-last) | `/v1/nodes/stats/last` | Get latest stats for all nodes |
+| [GET](#get-node-stats-last) | `/v1/nodes/stats/last/{uid}` | Get latest stats for a single node |
+
+## Get latest stats for all nodes {#get-all-nodes-stats-last}
+
+```sh
+GET /v1/nodes/stats/last
+```
+
+Get latest statistics for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_nodes_stats" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/last?interval=1sec&stime=2015-10-14T06:29:43Z
+```
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all nodes.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+         "conns": 0.0,
+         "cpu_idle": 0.922500000015134,
+         "cpu_system": 0.007499999999708962,
+         "cpu_user": 0.01749999999810825,
+         "cur_aof_rewrites": 0.0,
+         "egress_bytes": 7887.0,
+         "ephemeral_storage_avail": 75821363200.0,
+         "ephemeral_storage_free": 81189969920.0,
+         "etime": "2015-10-14T06:29:44Z",
+         "free_memory": 2956963840.0,
+         "ingress_bytes": 4950.0,
+         "interval": "1sec",
+         "persistent_storage_avail": 75821363200.0,
+         "persistent_storage_free": 81189969920.0,
+         "stime": "2015-10-14T06:29:43Z",
+         "total_req": 0.0
+     },
+     "2": {
+         "conns": 0.0,
+         "cpu_idle": 0.922500000015134,
+         "// additional fields..."
+     }
+}
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No nodes exist |
+
+## Get latest node stats {#get-node-stats-last}
+
+```sh
+GET /v1/nodes/stats/last/{int: uid}
+```
+
+Get the latest statistics of a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_stats" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/last/1?interval=1sec&stime=2015-10-13T09:01:54Z
+```
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601)format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601)format (optional) |
+
+### Response {#get-response}
+
+Returns the most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the specified node.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+         "conns": 0.0,
+         "cpu_idle": 0.8049999999930151,
+         "cpu_system": 0.02750000000014552,
+         "cpu_user": 0.12000000000080036,
+         "cur_aof_rewrites": 0.0,
+         "egress_bytes": 2169.0,
+         "ephemeral_storage_avail": 75920293888.0,
+         "ephemeral_storage_free": 81288900608.0,
+         "etime": "2015-10-13T09:01:55Z",
+         "free_memory": 3285381120.0,
+         "ingress_bytes": 3020.0,
+         "interval": "1sec",
+         "persistent_storage_avail": 75920293888.0,
+         "persistent_storage_free": 81288900608.0,
+         "stime": "2015-10-13T09:01:54Z",
+         "total_req": 0.0
+    }
+}
+```
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Node isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Mode is in recovery state |
+---
+Title: Node stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-stats) | `/v1/nodes/stats` | Get stats for all nodes |
+| [GET](#get-node-stats) | `/v1/nodes/stats/{uid}` | Get stats for a single node |
+
+## Get all nodes stats {#get-all-nodes-stats}
+
+```sh
+GET /v1/nodes/stats
+```
+
+Get statistics for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_nodes_stats" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional)  |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all nodes.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+   ]
+  },
+  {
+    "uid": "2",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+   ]
+  }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No nodes exist |
+
+## Get node stats {#get-node-stats}
+
+```sh
+GET /v1/nodes/stats/{int: uid}
+```
+
+Get statistics for a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_stats" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for the specified node.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Node isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Node is in recovery state |
+---
+Title: Nodes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: nodes
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/nodes/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes) | `/v1/nodes` | Get all cluster nodes |
+| [GET](#get-node) | `/v1/nodes/{uid}` | Get a single cluster node |
+| [PUT](#put-node) | `/v1/nodes/{uid}` | Update a node |
+
+## Get all nodes {#get-all-nodes}
+
+```sh
+GET /v1/nodes
+```
+
+Get all cluster nodes.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_nodes_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_nodes_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [node objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/node" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+      "uid": 1,
+      "status": "active",
+      "uptime": 262735,
+      "total_memory": 6260334592,
+      "software_version": "0.90.0-1",
+      "ephemeral_storage_size": 20639797248,
+      "persistent_storage_path": "/var/opt/redislabs/persist",
+      "persistent_storage_size": 20639797248,
+      "os_version": "Ubuntu 14.04.2 LTS",
+      "ephemeral_storage_path": "/var/opt/redislabs/tmp",
+      "architecture": "x86_64",
+      "shard_count": 23,
+      "public_addr": "",
+      "cores": 4,
+      "rack_id": "",
+      "supported_database_versions": [
+        {
+          "db_type": "memcached",
+          "version": "1.4.17"
+        },
+        {
+          "db_type": "redis",
+          "version": "2.6.16"
+        },
+        {
+          "db_type": "redis",
+          "version": "2.8.19"
+        }
+      ],
+      "shard_list": [1, 3, 4],
+      "addr": "10.0.3.61"
+    },
+    {
+      "uid": 1,
+      "status": "active",
+      "// additional fields..."
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get node {#get-node}
+
+```sh
+GET /v1/nodes/{int: uid}
+```
+
+Get a single cluster node.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_node_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_node_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+### Response {#get-response}
+
+Returns a [node object]({{< relref "/operate/rs/7.4/references/rest-api/objects/node" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "node:1",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+
+## Update node {#put-node}
+
+```sh
+PUT /v1/nodes/{int: uid}
+```
+
+Update a [node object]({{< relref "/operate/rs/7.4/references/rest-api/objects/node" >}}).
+
+Currently, you can edit the following attributes:
+
+- `addr`
+
+- `external_addr`
+
+- `recovery_path`
+
+- `accept_servers`
+
+{{<note>}}
+You can only update the `addr` attribute for offline nodes. Otherwise, the request returns an error.
+{{</note>}}
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_node]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_node" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/nodes/1
+```
+
+#### Example JSON body
+
+```json
+{
+    "addr": "10.0.0.1",
+    "external_addr" : [
+        "192.0.2.24"
+    ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Media type of request/response body |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated node. |
+
+
+#### Body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| addr | string | Internal IP address of node |
+| external_addr | JSON array | External IP addresses of the node |
+| recovery_path | string | Path for recovery files |
+| accept_servers | boolean | If true, no shards will be created on the node |
+
+### Response {#put-response}
+
+If the request is successful, the body will be empty. Otherwise, it may contain a JSON object with an error code and error message.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Update request cannot be processed. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided. |
+
+#### Error codes {#put-error-codes}
+
+| Code | Description |
+|------|-------------|
+| node_not_found | Node does not exist |
+| node_not_offline | Attempted to change node address while it is online |
+| node_already_populated | The node contains shards or endpoints, cannot disable accept_servers |
+| invalid_oss_cluster_port_mapping | Cannot enable "accept_servers" since there are databases with "oss_cluster_port_mapping" that do not have a port configuration for the current node |
+| node_already_has_rack_id | Attempted to change node's rack_id when it already has one |
+---
+Title: Redis access control list (ACL) requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis access control list (ACL) requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: redis_acls
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/redis_acls/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-redis_acls) | `/v1/redis_acls` | Get all Redis ACLs |
+| [GET](#get-redis_acl) | `/v1/redis_acls/{uid}` | Get a single Redis ACL |
+| [PUT](#put-redis_acl) | `/v1/redis_acls/{uid}` | Update a Redis ACL |
+| [POST](#post-redis_acl) | `/v1/redis_acls` | Create a new Redis ACL |
+| [DELETE](#delete-redis_acl) | `/v1/redis_acls/{uid}` | Delete a Redis ACL |
+
+## Get all Redis ACLs {#get-all-redis_acls}
+
+```sh
+GET /v1/redis_acls
+```
+
+Get all Redis ACL objects.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_redis_acls_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_redis_acls_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/redis_acls
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [Redis ACL objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+     "uid": 1,
+     "name": "Full Access",
+     "acl": "+@all ~*"
+    },
+    {
+     "uid": 2,
+     "name": "Read Only",
+     "acl": "+@read ~*"
+    },
+    {
+     "uid": 3,
+     "name": "Not Dangerous",
+     "acl": "+@all -@dangerous ~*"
+    },
+    {
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Get Redis ACL {#get-redis_acl}
+
+```sh
+GET /v1/redis_acls/{int: uid}
+```
+
+Get a single Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_redis_acl_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_redis_acl_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/redis_acls/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The object's unique ID. |
+
+### Response {#get-response}
+
+Returns a [Redis ACL object]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | redis_acl does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Update Redis ACL {#put-redis_acl}
+
+```sh
+PUT /v1/redis_acls/{int: uid}
+```
+
+Update an existing Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_redis_acl]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_redis_acl" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/redis_acls/17
+```
+
+#### Example JSON body
+
+```json
+{
+     "acl": "~* +@geo -@dangerous"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include a [Redis ACL object]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns the updated [Redis ACL object]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo -@dangerous"
+}
+```
+
+### Error codes {#put-error-codes}
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.|
+| name_already_exists | An object of the same type and name exists|
+| invalid_param | A parameter has an illegal value|
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, redis_acl was updated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existent redis_acl. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Cannot change a read-only object |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Create Redis ACL {#post-redis_acl}
+
+```sh
+POST /v1/redis_acls
+```
+
+Create a new Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_redis_acl]({{< relref "/operate/rs/7.4/references/rest-api/permissions#create_redis_acl" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/redis_acls
+```
+
+#### Example JSON body
+
+```json
+{
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include a [Redis ACL object]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}) in the request body.
+
+### Response {#post-response}
+
+Returns the newly created [Redis ACL object]({{< relref "/operate/rs/7.4/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+### Error codes {#post-error-codes}
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version. |
+| name_already_exists | An object of the same type and name exists |
+| missing_field | A needed field is missing |
+| invalid_param | A parameter has an illegal value |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, redis_acl is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+### Examples
+
+#### cURL
+
+```sh
+curl -k -u "[username]:[password]" -X POST \
+     -H 'Content-Type: application/json' \
+     -d '{ "name": "Geo", "acl": "~* +@geo" }' \
+     https://[host][:port]/v1/redis_acls
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/redis_acls"
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+payload = json.dumps({
+    "name": "Geo",
+    "acl": "~* +@geo"
+})
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+           auth=auth, headers=headers, payload=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete Redis ACL {#delete-redis_acl}
+
+```sh
+DELETE /v1/redis_acls/{int: uid}
+```
+
+Delete a Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_redis_acl]({{< relref "/operate/rs/7.4/references/rest-api/permissions#delete_redis_acl" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/redis_acls/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The redis_acl unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code that indicates the Redis ACL deletion success or failure.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the redis_acl is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Cannot delete a read-only object |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+---
+Title: Roles requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Roles requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: roles
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/roles/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-roles) | `/v1/roles` | Get all roles |
+| [GET](#get-role) | `/v1/roles/{uid}` | Get a single role |
+| [PUT](#put-role) | `/v1/roles/{uid}` | Update an existing role |
+| [POST](#post-role) | `/v1/roles` | Create a new role |
+| [DELETE](#delete-role) | `/v1/roles/{uid}` | Delete a role |
+
+## Get all roles {#get-all-roles}
+
+```sh
+GET /v1/roles
+```
+
+Get all roles' details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_roles_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_roles_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/roles
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [role objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": 1,
+        "name": "Admin",
+        "management": "admin"
+    },
+    {
+        "uid": 2,
+        "name": "Cluster Member",
+        "management": "cluster_member"
+    },
+    {
+        "uid": 3,
+        "name": "Cluster Viewer",
+        "management": "cluster_viewer"
+    },
+    {
+        "uid": 4,
+        "name": "DB Member",
+        "management": "db_member"
+    },
+    {
+        "uid": 5,
+        "name": "DB Viewer",
+        "management": "db_viewer"
+    },
+    {
+        "uid": 6,
+        "name": "None",
+        "management": "none"
+    },
+    {
+        "uid": 17,
+        "name": "DBA",
+        "management": "admin"
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Get role
+
+```sh
+GET /v1/roles/{int: uid}
+```
+
+Get the details of a single role.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_role_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_role_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/roles/1
+```
+
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The role's unique ID. |
+
+### Response {#get-response}
+
+Returns a [role object]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Role does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Update role {#put-role}
+
+```sh
+PUT /v1/roles/{int: uid}
+```
+
+Update an existing role's details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_role]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_role" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/roles/17
+```
+
+#### Example JSON body
+
+```json
+{
+     "management": "cluster_member"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Body
+
+Include a [role object]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns a [role object]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}) with the updated fields.
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "cluster_member"
+}
+```
+
+### Error codes {#put-error-codes}
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.|
+| name_already_exists | An object of the same type and name exists.|
+| change_last_admin_role_not_allowed | At least one user with admin role should exist.|
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, role is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existant role. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Create role {#post-role}
+
+```sh
+POST /v1/roles
+```
+
+Create a new role.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_role]({{< relref "/operate/rs/7.4/references/rest-api/permissions#create_role" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/roles
+```
+
+#### Example JSON body
+
+```json
+{
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Body
+
+Include a [role object]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}) in the request body.
+
+### Response {#post-response}
+
+Returns the newly created [role object]({{< relref "/operate/rs/7.4/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+### Error codes {#post-error-codes}
+
+Possible `error_code`values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version. |
+| name_already_exists | An object of the same type and name exists |
+| missing_field | A needed field is missing |
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, role is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+### Examples
+
+#### cURL
+
+```sh
+curl -k -u "[username]:[password]" -X POST \
+     -H 'Content-Type: application/json' \
+     -d '{ "name": "DBA", "management": "admin" }' \
+     https://[host][:port]/v1/roles
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/roles"
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+payload = json.dumps({
+    "name": "DBA",
+    "management": "admin"
+})
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+           auth=auth, headers=headers, payload=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete role {#delete-role}
+
+```sh
+DELETE /v1/roles/{int: uid}
+```
+
+Delete a role object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_role]({{< relref "/operate/rs/7.4/references/rest-api/permissions#delete_role" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/roles/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The role unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code to indicate role deletion success or failure.
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the role is deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Role does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+---
+Title: Suffix requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: DNS suffix requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: suffix
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/suffix/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-suffix) | `/v1/suffix/{name}` | Get a single DNS suffix |
+
+## Get suffix {#get-suffix}
+
+	GET /v1/suffix/{string: name}
+
+Get a single DNS suffix.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/suffix/cluster.fqdn 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| name | string | The unique name of the suffix requested. |
+
+### Response {#get-response} 
+
+Returns a [suffix object]({{< relref "/operate/rs/7.4/references/rest-api/objects/suffix" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "name": "cluster.fqdn",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Suffix name does not exist |
+---
+Title: Database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /bdbs/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/debuginfo/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo-bdb) | `/v1/bdbs/debuginfo` | Get debug info from all databases |
+| [GET](#get-debuginfo-bdb) | `/v1/bdbs/{bdb_uid}/debuginfo` | Get debug info from a specific database |
+
+## Get debug info from all databases {#get-all-debuginfo-bdb}
+
+	GET /v1/bdbs/debuginfo
+
+Downloads a tar file that contains debug info from all databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/debuginfo
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+
+
+## Get database debug info {#get-debuginfo-bdb}
+
+	GET /v1/bdbs/{int: bdb_uid}/debuginfo
+
+Downloads a tar file that contains debug info from the database specified by `bdb_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/1/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Replica syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica syncer state requests
+headerRange: '[1-2]'
+linkTitle: replica
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/syncer_state/replica/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state/replica` | Get a CRDB replica's syncer state |
+
+## Get replica syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state/replica
+```
+
+Get a CRDB replica's syncer state as JSON.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state/replica
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: CRDT syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: CRDT syncer state requests
+headerRange: '[1-2]'
+linkTitle: crdt
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/syncer_state/crdt/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state/crdt` |  Get a CRDB's syncer state |
+
+## Get CRDB syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state/crdt
+```
+
+Get a CRDB's syncer state as JSON.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state/crdt
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: Syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Syncer state requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: syncer_state
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/syncer_state/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state` | Get a CRDB's syncer state |
+
+## Get syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state
+```
+
+Get a CRDB's syncer state as JSON.
+
+{{<warning>}}
+This endpoint is deprecated as of Redis Enterprise Software version 7.2.4 and will be removed in a future release. Use [`/v1/bdbs/<uid>/syncer_state/crdt`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/syncer_state/crdt" >}}) instead.
+{{</warning>}}
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: Database replica sources alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica source alert requests
+headerRange: '[1-2]'
+linkTitle: replica_sources/alerts
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/replica_sources-alerts/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-replica-sources-alerts) | `/v1/bdbs/replica_sources/alerts` | Get all replica sources alert states for all BDBs |
+| [GET](#get-bdbs-replica-sources-alerts) | `/v1/bdbs/replica_sources/alerts/{uid}` | Get all replica sources alert states for a BDB |
+| [GET](#get-bdbs-replica_source-all-alerts) | `/v1/bdbs/replica_sources/alerts/{uid}/{replica_src_id}` | Get all alert states for a replica source |
+| [GET](#get-bdbs-replica-source-alert) | `/v1/bdbs/replica_sources/alerts/{uid}/{replica_src_id}/{alert}` | Get a replica source alert state |
+
+## Get all DBs replica sources alert states {#get-all-bdbs-replica-sources-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts
+
+Get all alert states for all replica sources of all BDBs.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a hash of alert UIDs and the alerts states for each BDB.
+
+See [REST API alerts overview]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) for a description of the alert state object.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "replica_src_syncer_connection_error": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get DB replica source alert states {#get-bdbs-replica-sources-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}
+
+Get all alert states for all replica sources of a specific bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-all-replica-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#get-response-all-replica-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "replica_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-replica-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get replica source alert states {#get-bdbs-replica_source-all-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}/{int: replica_src_id}
+
+Get all alert states for a specific replica source of a bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-replica-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1/2 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| replica_src_id | integer | The ID of the replica source in this BDB |
+
+### Response {#get-response-replica-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "replica_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-replica-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get replica source alert state {#get-bdbs-replica-source-alert}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}/{int: replica_src_id}/{alert}
+
+Get a replica source alert state of a specific bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alert} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1/2/replica_src_syncer_connection_error 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| replica_src_id | integer | The ID of the replica source in this BDB |
+| alert | string | The alert name |
+
+### Response {#get-response-alert} 
+
+Returns an [alert state object]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes-alert} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+---
+Title: Database shards requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database shards
+headerRange: '[1-2]'
+linkTitle: shards
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/shards/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdb-shards) | `/v1/bdbs/{bdb_uid}/shards` | Get the status of a database's shards |
+
+## Get database shards {#get-bdb-shards}
+
+	GET /v1/bdbs/{int: bdb_uid}/shards
+
+Gets the status for all shards that belong to the specified database.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/1/shards?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the database. |
+
+### Response {#get-response} 
+
+The response body contains a JSON array with all shards, represented as [shard objects]({{<relref "/operate/rs/7.4/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": "1",
+		"role": "master",
+		"assigned_slots": "0-8191",
+        "bdb_uid": 1,
+        "detailed_status": "ok",
+        "loading": {
+            "status": "idle"
+        },
+        "node_uid": "1",
+        "redis_info": {
+			"connected_clients": 14,
+            "used_memory_rss": 12460032
+        },
+        "report_timestamp": "2024-09-13T15:28:10Z",
+        "status": "active"
+    },
+    {
+        "uid": 2,
+        "role": "slave",
+        // additional fields...
+    }
+]
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | bdb uid does not exist. |
+---
+Title: Database passwords requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database password requests
+headerRange: '[1-2]'
+linkTitle: passwords
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/passwords/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Update database password |
+| [POST](#post-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Add database password |
+| [DELETE](#delete-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Delete database password |
+
+## Update database password {#put-bdbs-password}
+
+	PUT /v1/bdbs/{int: uid}/passwords
+
+Set a single password for the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "new password"
+}
+```
+
+The above request resets the password of the bdb to ‘new password’.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to update the password. |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | New password |
+
+### Response {#put-response} 
+
+Returns a status code that indicates password update success or failure.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was changed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+
+## Add database password {#post-bdbs-password}
+
+	POST /v1/bdbs/{int: uid}/passwords
+
+Add a password to the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "password to add"
+}
+```
+
+The above request adds a password to the bdb.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to add password. |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | Password to add |
+
+### Response {#post-response} 
+
+Returns a status code that indicates password creation success or failure.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was added. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+
+## Delete database password {#delete-bdbs-password}
+
+	DELETE /v1/bdbs/{int: uid}/passwords
+
+Delete a password from the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "password to delete"
+}
+```
+
+The above request deletes a password from the bdb.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to delete password. |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | Password to delete |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates password deletion success or failure.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+---
+Title: CRDB peer stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active peer instance statistics requests
+headerRange: '[1-2]'
+linkTitle: peer_stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/peer_stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-peer_stats) | `/v1/bdbs/{bdb_uid}/peer_stats` | Get stats for all CRDB peer instances |
+| [GET](#get-bdbs-peer_stats) | `/v1/bdbs/{bdb_uid}/peer_stats/{uid}` | Get stats for a specific CRDB peer instance |
+
+## Get all CRDB peer stats {#get-all-bdbs-peer_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/peer_stats
+```
+
+Get statistics for all peer instances of a local CRDB instance.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/peer_stats?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local CRDB instance. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all CRDB peer instances.
+
+#### Example JSON body
+
+```json
+{ "peer_stats": [
+     {
+         "intervals": [
+             {
+                 "egress_bytes": 0.0,
+                 "egress_bytes_decompressed": 0.0,
+                 "etime": "2017-10-22T19:30:00Z",
+                 "ingress_bytes": 18528,
+                 "ingress_bytes_decompressed": 185992,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.244,
+                 "pending_local_writes_max": 0.0,
+                 "pending_local_writes_min": 0.0,
+                 "stime": "2017-10-22T19:25:00Z"
+             },
+             {
+                 "egress_bytes": 0.0,
+                 "egress_bytes_decompressed": 0.0,
+                 "etime": "2017-10-22T19:35:00Z",
+                 "ingress_bytes": 18,
+                 "ingress_bytes_decompressed": 192,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.0,
+                 "pending_local_writes_max": 0.0,
+                 "pending_local_writes_min": 0.0,
+                 "stime": "2017-10-22T19:30:00Z"
+             }
+         ],
+         "uid": "3"
+     }
+   ]
+ }
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Database is not a CRDB. |
+
+## Get CRDB peer stats {#get-bdbs-peer_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/peer_stats/{int: uid}
+```
+
+Get statistics for a specific CRDB peer instance.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/peer_stats/3?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local CRDB instance. |
+| uid | integer | The peer instance uid, as specified in the CRDB instance list. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for a specific CRDB peer instance.
+
+#### Example JSON body
+
+```json
+{
+    "intervals": [
+        {
+            "egress_bytes": 0.0,
+            "egress_bytes_decompressed": 0.0,
+            "etime": "2017-10-22T19:30:00Z",
+            "ingress_bytes": 18528,
+            "ingress_bytes_decompressed": 185992,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.244,
+            "pending_local_writes_max": 0.0,
+            "pending_local_writes_min": 0.0,
+            "stime": "2017-10-22T19:25:00Z"
+        },
+        {
+            "egress_bytes": 0.0,
+            "egress_bytes_decompressed": 0.0,
+            "etime": "2017-10-22T19:35:00Z",
+            "ingress_bytes": 18,
+            "ingress_bytes_decompressed": 192,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.0,
+            "pending_local_writes_max": 0.0,
+            "pending_local_writes_min": 0.0,
+            "stime": "2017-10-22T19:30:00Z"
+        }
+    ],
+    "uid": "3"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or peer does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Database is not a CRDB. |
+---
+Title: Database alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/alerts/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-alerts) | `/v1/bdbs/alerts` | Get all alert states for all databases |
+| [GET](#get-bdbs-alerts) | `/v1/bdbs/alerts/{uid}` | Get all alert states for a specific database |
+| [GET](#get-bdbs-alert) | `/v1/bdbs/alerts/{uid}/{alert}` | Get a specific database alert state |
+| [POST](#post-bdbs-alerts) | `/v1/bdbs/alerts/{uid}` | Update a database’s alerts configuration |
+
+## Get all database alerts {#get-all-bdbs-alerts}
+
+	GET /v1/bdbs/alerts
+
+Get all alert states for all databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a hash of alert UIDs and the [alerts]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) states for each database.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "bdb_size": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get database alerts {#get-bdbs-alerts}
+
+	GET /v1/bdbs/alerts/{int: uid}
+
+Get all alert states for a database.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "bdb_size": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get database alert {#get-bdbs-alert}
+
+	GET /v1/bdbs/alerts/{int: uid}/{alert}
+
+Get a database alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts/1/bdb_size 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| alert | string | The alert name |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+
+## Update database alert {#post-bdbs-alerts}
+
+	POST /v1/bdbs/alerts/{int: uid}
+
+Updates a database's alerts configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb_alerts" >}}) |
+
+### Request {#post-request} 
+
+If passed with the dry_run URL query string, the function will validate the alert thresholds, but not commit them.
+
+#### Example HTTP request
+
+	POST /v1/bdbs/alerts/1 
+
+#### Example JSON body
+
+```json
+{
+     "bdb_size":{
+         "threshold":"80",
+         "enabled":true
+     },
+     "bdb_high_syncer_lag":{
+         "threshold":"",
+         "enabled":false
+     },
+     "bdb_low_throughput":{
+         "threshold":"1",
+         "enabled":true
+     },
+     "bdb_high_latency":{
+         "threshold":"3000",
+         "enabled":true
+     },
+     "bdb_high_throughput":{
+         "threshold":"1",
+         "enabled":true
+     },
+     "bdb_backup_delayed":{
+         "threshold":"1800",
+         "enabled":true
+     }
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | Database ID |
+| dry_run | string | Validate the alert thresholds but do not apply them |
+
+#### Request body
+
+The request must contain a single JSON object with one or many database [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+### Response {#post-response} 
+
+The response includes the updated database [alerts]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified database was not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, database alerts updated. |
+---
+Title: Import reset status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database import status requests
+headerRange: '[1-2]'
+linkTitle: import_reset_status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/import_reset_status/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-import-reset-status) | `/v1/bdbs/{uid}/actions/import_reset_status` | Reset database import status |
+
+## Reset database import status {#put-bdbs-actions-import-reset-status}
+
+	PUT /v1/bdbs/{int: uid}/actions/import_reset_status
+
+Reset the database’s `import_status` to idle if a backup is not in progress and clears the value of the `import_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_import_status]({{< relref "/operate/rs/7.4/references/rest-api/permissions#reset_bdb_current_import_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/import_reset_status
+```
+
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Recover database requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database recovery
+headerRange: '[1-2]'
+linkTitle: recover
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/recover/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdbs-actions-recover) | `/v1/bdbs/{uid}/actions/recover` | Get database recovery plan  |
+| [POST](#post-bdbs-actions-recover) | `/v1/bdbs/{uid}/actions/recover` | Recover database  |
+
+## Get recovery plan {#get-bdbs-actions-recover}
+
+```sh
+GET /v1/bdbs/{int: uid}/actions/recover
+```
+
+Fetches the recovery plan for a database. The recovery plan provides information about the recovery status, such as whether recovery is possible, and details on available files to use for recovery.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_recovery_plan]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_recovery_plan" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/actions/recover
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the database's recovery plan, including recovery files and status.
+
+#### Example response body
+
+```json
+{
+  "data_files": [
+    {
+      "filename": "appendonly-1.aof",
+      "last_modified": 1721164863.8883622,
+      "node_uid": "1",
+      "shard_role": "master",
+      "shard_slots": "1-2048",
+      "shard_uid": "1",
+      "size": 88
+    },
+    {
+      "filename": "appendonly-2.aof",
+      "last_modified": 1721164863.8883622,
+      "node_uid": "2",
+      "shard_role": "slave",
+      "shard_slots": "2049-4096",
+      "shard_uid": "2",
+      "size": 88
+    }
+  ],
+  "status": "ready"
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Database UID does not exist. |
+
+## Recover database {#post-bdbs-actions-recover}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/recover
+```
+
+Initiates [recovery for a database]({{<relref "operate/rs/databases/recover">}}) in a recoverable state where all the database's files are available after [cluster recovery]({{<relref "/operate/rs/7.4/clusters/cluster-recovery">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_recovery]({{< relref "/operate/rs/7.4/references/rest-api/permissions#start_bdb_recovery" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+The request body can either be empty or include a recovery plan.
+
+If the request body is empty, the database will be recovered automatically:
+
+- Databases with no persistence are recovered with no data.
+
+- Persistent files such as AOF or RDB will be loaded from their expected storage locations where replica or primary shards were last active.
+
+- If persistent files are not found where expected but can be located on other cluster nodes, they will be used.
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/recover
+```
+
+#### Example request body
+
+```json
+{
+  "data_files": [
+    {
+      "filename": "appendonly-1.aof",
+      "node_uid": "1",
+      "shard_slots": "1-2048"
+    },
+    {
+      "filename": "appendonly-2.aof",
+      "node_uid": "2",
+      "shard_slots": "2049-4096"
+    }
+  ],
+  "ignore_errors": false,
+  "recover_without_data": false
+}
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to recover. |
+
+### Response {#post-response}
+
+Returns a status code. Also returns a JSON object with an `action_uid` in the request body if successful.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | The request is accepted and is being processed. When the database is recovered, its status will become `active`. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Attempting to perform an action on a nonexistent database. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy with another action, recovery is already in progress, or is not in a recoverable state. |
+---
+Title: Export resets status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database export status requests
+headerRange: '[1-2]'
+linkTitle: export_reset_status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/export_reset_status/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-export-reset-status) | `/v1/bdbs/{uid}/actions/export_reset_status` | Reset database export status |
+
+## Reset database export status {#put-bdbs-actions-export-reset-status}
+
+	PUT /v1/bdbs/{int: uid}/actions/export_reset_status
+
+Resets the database's `export_status` to idle if an export is not in progress and clears the value of the `export_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_export_status]({{< relref "/operate/rs/7.4/references/rest-api/permissions#reset_bdb_current_export_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/export_reset_status
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Backup reset status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database backup status requests
+headerRange: '[1-2]'
+linkTitle: backup_reset_status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/backup_reset_status/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-backup-reset-status) | `/v1/bdbs/{uid}/actions/backup_reset_status` | Reset database backup status |
+
+## Reset database backup status {#put-bdbs-actions-backup-reset-status}
+
+```sh
+PUT /v1/bdbs/{int: uid}/actions/backup_reset_status
+```
+
+Resets the database's `backup_status` to idle if a backup is not in progress and clears the value of the `backup_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_backup_status]({{< relref "/operate/rs/7.4/references/rest-api/permissions#reset_bdb_current_backup_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/backup_reset_status
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Optimize shards placement database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Optimize shard placement requests
+headerRange: '[1-2]'
+linkTitle: optimize_shards_placement
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/optimize_shards_placement/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdbs-actions-optimize-shards-placement) | `/v1/bdbs/{uid}/actions/optimize_shards_placement` | Get optimized shards placement for a database  |
+
+
+## Get optimized shards placement {#get-bdbs-actions-optimize-shards-placement}
+
+```sh
+GET /v1/bdbs/{int: uid}/actions/optimize_shards_placement
+```
+
+Get optimized shards placement for the given database.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/actions/optimize_shards_placement
+```
+
+#### Query parameters
+
+Include query parameters in a `GET` request to generate an optimized shard placement blueprint for a database, using settings that are different from the database's current configuration.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| avoid_nodes | list of integers | Comma-separated list of cluster node IDs to avoid when placing the database’s shards and binding its endpoints (for example, `avoid_nodes=1,2`) |
+| memory_size | integer (default:&nbsp;0) | Database memory limit (0 is unlimited), expressed in bytes |
+| shards_count | integer, <nobr>(range: 1-512)</nobr> (default:&nbsp;1) | Number of database server-side shards |
+| shards_placement | `dense` <br />`sparse` | Control the density of shards <br /> `dense`: Shards reside on as few nodes as possible <br /> `sparse`: Shards reside on as many nodes as possible |
+| bigstore_ram_size | integer (default:&nbsp;0) | Memory size of bigstore RAM part, expressed in bytes |
+| replication | `enabled`<br />`disabled` | In-memory database replication mode |
+
+The following example request includes `shards_count` and `memory_size` as query parameters:
+
+```sh
+GET /v1/bdbs/1/actions/optimize_shards_placement?shards_count=10&memory_size=10000
+```
+
+### Response {#get-response}
+
+To rearrange the database shards, you can submit the blueprint returned in this response body as the `shards_blueprint` field in the [`PUT`&nbsp;`/v1/bdbs/{uid}`](#put-bdbs-rearrange-shards) request.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "5461-10922"
+    },
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "10923-16383"
+    },
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "0-5460"
+    }
+]
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Length | 352 | Length of the request body in octets |
+| cluster-state-id | 30 | Cluster state ID |
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database UID does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not enough resources in the cluster to host the database |
+
+## Rearrange database shards {#put-bdbs-rearrange-shards}
+
+Use the blueprint returned by the [`GET`&nbsp;`/v1/bdbs/{uid}/actions/optimize_shards_placement`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions/optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}) request as the value of the `shards_blueprint` field to rearrange the database shards.
+
+To ensure that the optimized shard placement is relevant for the current cluster state, pass the `cluster-state-id`, taken from the response header of the `GET` request, in the [`PUT`&nbsp;`/v1/bdbs/{uid}`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#put-bdbs" >}}) request headers.
+
+The cluster will reject the update if its state was changed since the optimal shards placement was obtained.
+
+### Request
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| cluster-state-id | 30 | Cluster state ID |
+
+#### Example JSON body
+
+```json
+{
+  "shards_blueprint": [
+    {
+      "nodes": [
+        {
+          "node_uid": "2",
+          "role": "master"
+        }
+      ],
+      "slot_range": "0-8191"
+    },
+    "..."
+  ]
+}
+```
+
+{{<warning>}}
+If you submit such an optimized blueprint, it may cause strain on the cluster and its resources. Use with caution.
+{{</warning>}}
+---
+Title: Import database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Import database requests
+headerRange: '[1-2]'
+linkTitle: import
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/import/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-import) | `/v1/bdbs/{uid}/actions/import` | Initiate manual dataset import |
+
+## Initiate manual dataset import {#post-bdbs-actions-import}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/import
+```
+
+Initiate a manual import process.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_import]({{< relref "/operate/rs/7.4/references/rest-api/permissions#start_bdb_import" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/import
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Length | 0 | Length of the request body in octets |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+#### Body
+
+The request _may_ contain a subset of the [BDB JSON object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}), which includes the following import-related attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dataset_import_sources | array of [dataset_import_sources]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/dataset_import_sources" >}}) objects | Details for the import sources. Call [`GET /v1/jsonschema`]({{< relref "/operate/rs/7.4/references/rest-api/requests/jsonschema#get-jsonschema" >}}) on the bdb object and review the `dataset_import_sources` field to retrieve the object's structure.  |
+| email_notification | boolean | Enable/disable an email notification on import failure/ completion. (optional) |
+
+{{<note>}}
+Other attributes are not allowed and will cause the request to fail.
+{{</note>}}
+
+##### Example JSON Body
+
+```json
+{
+    "dataset_import_sources": [
+        {
+            "type": "url",
+            "url": "http://..."
+        },
+        {
+            "type": "url",
+            "url": "redis://..."
+        }
+    ],
+    "email_notification": true
+}
+```
+
+This request initiates an import process using `dataset_import_sources` values that were previously configured for the database.
+
+### Response {#post-response}
+
+Returns a status code.
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. In order to monitor progress, the `import_status`, `import_progress`, and `import_failure_reason` attributes can be consulted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Export database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Export database requests
+headerRange: '[1-2]'
+linkTitle: export
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/export/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-export) | `/v1/bdbs/{uid}/actions/export` | Initiate database export |
+
+## Initiate database export {#post-bdbs-actions-export}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/export
+```
+
+Initiate a database export.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_export]({{< relref "/operate/rs/7.4/references/rest-api/permissions#start_bdb_export" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/export
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+
+#### Body
+
+The request body should contain a JSON object with the following export parameters:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| export_location | [backup_location/export_location]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb/backup_location" >}}) object | Details for the export destination. Call [`GET /v1/jsonschema`]({{< relref "/operate/rs/7.4/references/rest-api/requests/jsonschema#get-jsonschema" >}}) on the bdb object and review the `backup_location` field to retrieve the object's structure.  |
+| email_notification | boolean | Enable/disable an email notification on export failure/ completion. (optional) |
+
+##### Example JSON body
+
+```json
+{
+    "export_location": {
+        "type": "url",
+        "url": "ftp://..."
+    },
+    "email_notification": true
+}
+```
+
+The above request initiates an export operation to the specified location.
+
+### Response {#post-response}
+
+Returns a status code.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. In order to monitor progress, the BDB's `export_status`, `export_progress`, and `export_failure_reason` attributes can be consulted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Database actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database action requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/actions/'
+---
+
+## Backup
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./backup_reset_status#put-bdbs-actions-backup-reset-status" >}}) | `/v1/bdbs/{uid}/actions/backup_reset_status` | Reset database backup status |
+
+## Export
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./export_reset_status#put-bdbs-actions-export-reset-status" >}}) | `/v1/bdbs/{uid}/actions/export_reset_status` | Reset database export status |
+| [POST]({{< relref "./export#post-bdbs-actions-export" >}}) | `/v1/bdbs/{uid}/actions/export` | Initiate database export |
+
+## Import
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./import_reset_status#put-bdbs-actions-import-reset-status" >}}) | `/v1/bdbs/{uid}/actions/import_reset_status` | Reset database import status |
+| [POST]({{< relref "./import#post-bdbs-actions-import" >}}) | `/v1/bdbs/{uid}/actions/import` | Initiate manual dataset import |
+
+## Optimize shards placement
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}) | `/v1/bdbs/{uid}/actions/optimize_shards_placement` | Get optimized shards placement for a database  |
+
+## Recover
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{<relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions/recover#get-bdbs-actions-recover">}}) | `/v1/bdbs/{uid}/actions/recover` | Get database recovery plan  |
+| [POST]({{<relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions/recover#post-bdbs-actions-recover">}}) | `/v1/bdbs/{uid}/actions/recover` | Recover database  |
+---
+Title: Database upgrade requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database upgrade requests
+headerRange: '[1-2]'
+linkTitle: upgrade
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/upgrade/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-upgrade) | `/v1/bdbs/{uid}/upgrade` | Upgrade database |
+
+## Upgrade database {#post-bdbs-upgrade}
+
+	POST /v1/bdbs/{int: uid}/upgrade
+
+Upgrade a database.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb_with_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb_with_action" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/upgrade 
+
+#### Example JSON body
+
+```json
+{
+    "swap_roles": true,
+    "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| force_restart | boolean | Restart shards even if no version change (default: false) |
+| keep_redis_version | boolean | Keep current Redis version (default: false) |
+| keep_crdt_protocol_version | boolean | Keep current crdt protocol version (default: false)  |
+| may_discard_data | boolean | Discard data in a non-replicated, non-persistent bdb (default: false) |
+| force_discard | boolean | Discard data even if the bdb is replicated and/or persistent (default: false) |
+| preserve_roles | boolean | Preserve shards' master/replica roles (requires an extra failover) (default: false) |
+| parallel_shards_upgrade | integer | Max number of shards to upgrade in parallel (default: all) |
+| modules | list of modules | List of dicts representing the modules that will be upgraded.<br></br>Each dict includes:<br></br>• `current_module`: uid of a module to upgrade<br></br>• `new_module`: uid of the module we want to upgrade to<br></br>• `new_module_args`: args list for the new module (no defaults for the three module-related parameters).
+| redis_version | version number | Upgrades the database to the specified Redis version instead of the latest version |
+| latest_with_modules | boolean | Upgrades the database to the latest Redis version and latest supported versions of modules available in the cluster |
+
+### Response {#post-response} 
+
+Returns the upgraded [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "replication": true,
+    "data_persistence": "aof",
+    "// additional fields..."
+}
+```
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, bdb upgrade initiated (`action_uid` can be used to track progress) |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Malformed or bad command |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | New module version capabilities don't comply with the database configuration |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+---
+Title: Database modules config requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure Redis module requests
+headerRange: '[1-2]'
+linkTitle: config
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/modules/config/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdb-modules-config) | `/v1/bdbs/{uid}/modules/config` | Configure module |
+
+## Configure module {#post-bdb-modules-config}
+
+	POST /v1/bdbs/{string: uid}/modules/config
+
+Use the module runtime configuration command (if defined) to configure new arguments for the module.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/7.4/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/modules/config
+
+#### Example JSON body
+
+```json
+{
+  "modules": [
+    {
+      "module_name": "search",
+      "module_args": "MINPREFIX 3 MAXEXPANSIONS 1000"
+    }
+  ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list of JSON objects | List of modules (module_name) and their new configuration settings (module_args) |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name |
+| module_args | string | Module command line arguments (pattern does not allow special characters &,<,>,”) |
+
+### Response {#post-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_not_exist | Database with given UID doesn't exist in cluster | 
+| missing_field | "module_name" or "module_args" are not defined in request | 
+| invalid_schema | JSON object received is not a dict object | 
+| param_error | "module_args" parameter was not parsed properly | 
+| module_not_exist | Module with given "module_name" does not exist for the database | 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Module does not support runtime configuration of arguments. |
+---
+Title: Database upgrade modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade Redis module requests
+headerRange: '[1-2]'
+linkTitle: upgrade
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/modules/upgrade/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdb-modules-upgrade) | `/v1/bdbs/{uid}/modules/upgrade` | Upgrade module |
+
+## Upgrade module {#post-bdb-modules-upgrade}
+
+	POST /v1/bdbs/{string: uid}/modules/upgrade
+
+Upgrades module version on a specific BDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/7.4/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/modules/upgrade
+
+#### Example JSON body
+
+```json
+{
+     "modules": [
+         {"module_name": "ReJson",
+         "current_semantic_version": "2.2.1",
+         "new_module": "aa3648d79bd4082d414587c42ea0b234"}
+     ],
+     "// Optional fields to fine-tune restart and failover behavior:",
+     "preserve_roles": true,
+     "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list | List of dicts representing the modules that will be upgraded. Each dict must include: <br></br> • **current_module**: uid of a module to upgrade <br></br> • **new_module**: UID of the module we want to upgrade to <br></br> • **new_module_args**: args list for the new module |
+| preserve_roles | boolean | Preserve shards’ master/replica roles (optional) |
+| may_discard_data | boolean | Discard data in a non-replicated non-persistent bdb (optional) |
+
+### Response {#post-response} 
+
+Returns the upgraded [module object]({{< relref "/operate/rs/7.4/references/rest-api/objects/module" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "module_id": "aa3648d79bd4082d414587c42ea0b234",
+    "module_name": "ReJson",
+    "semantic_version": "2.2.2"
+    "// additional fields..."
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| missing_module | Module is not present in cluster.| 
+| module_downgrade_unsupported | Module downgrade is not allowed.| 
+| redis_incompatible_version | Module min_redis_version is bigger than the current Redis version.| 
+| redis_pack_incompatible_version | Module min_redis_pack_version is bigger than the current Redis Enterprise version.| 
+| unsupported_module_capabilities | New version of module does support all the capabilities needed for the database configuration| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb or node not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+---
+Title: Database modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis module requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: modules
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/modules/'
+---
+
+## Configure module
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/modules/config#post-bdb-modules-config" >}}) | `/v1/bdbs/{uid}/modules/config` | Configure module |
+
+## Upgrade module
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/modules/upgrade#post-bdb-modules-upgrade" >}}) | `/v1/bdbs/{uid}/modules/upgrade` | Upgrade module |
+---
+Title: Database syncer source stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Syncer source statistics requests
+headerRange: '[1-2]'
+linkTitle: sync_source_stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/sync_source_stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-sync_source_stats) | `/v1/bdbs/{bdb_uid}/sync_source_stats` | Get stats for all syncer sources |
+| [GET](#get-bdbs-sync_source_stats) | `/v1/bdbs/{bdb_uid}/sync_source_stats/{uid}` | Get stats for a specific syncer instance |
+
+## Get all syncer source stats {#get-all-bdbs-sync_source_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/sync_source_stats
+```
+
+Get stats for all syncer sources of a local database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/sync_source_stats?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local database. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | Optional end time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all syncer sources.
+
+#### Example JSON body
+
+```json
+{ "sync_source_stats": [
+     {
+         "intervals": [
+             {
+                 "etime": "2017-10-22T19:30:00Z",
+                 "ingress_bytes": 18528,
+                 "ingress_bytes_decompressed": 185992,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.244,
+                 "stime": "2017-10-22T19:25:00Z"
+             },
+             {
+                 "etime": "2017-10-22T19:35:00Z",
+                 "ingress_bytes": 18,
+                 "ingress_bytes_decompressed": 192,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.0,
+                 "stime": "2017-10-22T19:30:00Z"
+             }
+         ],
+         "uid": "1"
+     }
+   ]
+ }
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database does not exist. |
+
+## Get syncer instance stats {#get-bdbs-sync_source_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/sync_source_stats/{int: uid}
+```
+
+Get stats for a specific syncer (Replica Of) instance.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/sync_source_stats/1?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local database. |
+| uid | integer | The sync_source uid. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Optional start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | Optional end time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for a specific syncer instance.
+
+#### Example JSON body
+
+```json
+{
+    "intervals": [
+        {
+            "etime": "2017-10-22T19:30:00Z",
+            "ingress_bytes": 18528,
+            "ingress_bytes_decompressed": 185992,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.244,
+            "stime": "2017-10-22T19:25:00Z"
+        },
+        {
+            "etime": "2017-10-22T19:35:00Z",
+            "ingress_bytes": 18,
+            "ingress_bytes_decompressed": 192,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.0,
+            "stime": "2017-10-22T19:30:00Z"
+        }
+    ],
+    "uid": "1"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or sync_source do not exist. |
+---
+Title: Latest database stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent database statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/stats/last/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-stats-last) | `/v1/bdbs/stats/last` | Get most recent stats for all databases |
+| [GET](#get-bdbs-stats-last) | `/v1/bdbs/stats/last/{uid}` | Get most recent stats for a specific database |
+
+## Get latest stats for all databases {#get-all-bdbs-stats-last}
+
+```sh
+GET /v1/bdbs/stats/last
+```
+
+Get the most recent statistics for all databases.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+1. Without metrics filter (returns all metrics by default)
+    ```
+    GET /v1/bdbs/stats/last
+    ```
+
+2. With metrics filter
+    ```
+    GET /v1/bdbs/stats/last?metrics=no_of_keys,used_memory
+    ```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| metrics | string | Comma-separated list of metric names for which we want statistics (default is all). (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all databases.
+
+#### Example JSON body
+
+1. Without metrics filter (returns all metrics by default)
+    ```json
+    {
+    "1": {
+        "stime": "2015-05-28T08:06:37Z",
+        "etime": "2015-05-28T08:06:44Z",
+        "conns": 0.0,
+        "egress_bytes": 0.0,
+        "etime": "2015-05-28T08:06:44Z",
+        "evicted_objects": 0.0,
+        "expired_objects": 0.0,
+        "ingress_bytes": 0.0,
+        "instantaneous_ops_per_sec": 0.0,
+        "last_req_time": "1970-01-01T00:00:00Z",
+        "last_res_time": "1970-01-01T00:00:00Z",
+        "used_memory": 5651336.0,
+        "mem_size_lua": 35840.0,
+        "monitor_sessions_count": 0.0,
+        "no_of_keys": 0.0,
+        "other_req": 0.0,
+        "other_res": 0.0,
+        "read_hits": 0.0,
+        "read_misses": 0.0,
+        "read_req": 0.0,
+        "read_res": 0.0,
+        "total_connections_received": 0.0,
+        "total_req": 0.0,
+        "total_res": 0.0,
+        "write_hits": 0.0,
+        "write_misses": 0.0,
+        "write_req": 0.0,
+        "write_res": 0.0
+    },
+    "2": {
+        "stime": "2015-05-28T08:06:37Z",
+        "etime": "2015-05-28T08:06:44Z",
+
+        "// additional fields..."
+    },
+
+    "// Additional BDBs..."
+    }
+    ```
+
+2. With metrics filter
+    ```json
+    {
+    "1": {
+      "etime": "2015-05-28T08:06:44Z",
+      "used_memory": 5651576.0,
+      "no_of_keys": 0.0,
+      "stime": "2015-05-28T08:06:37Z"
+    },
+    "2": {
+      "etime": "2015-05-28T08:06:44ZZ",
+      "used_memory": 5651440.0,
+      "no_of_keys": 0.0,
+      "stime": "2015-05-28T08:06:37Z"
+    },
+
+    "// Additional BDBs.."
+    }
+    ```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No bdbs exist |
+
+## Get latest database stats {#get-bdbs-stats-last}
+
+```sh
+GET /v1/bdbs/stats/last/{int: uid}
+```
+
+Get the most recent statistics for a specific database.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats/last/1?metrics=no_of_keys,used_memory
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the requested BDB. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| metrics | string | Comma-separated list of metric names for which we want statistics (default is all). (optional) |
+
+### Response {#get-response}
+
+Returns the most recent [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for a specific database.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+     "etime": "2015-06-23T12:05:08Z",
+     "used_memory": 5651576.0,
+     "no_of_keys": 0.0,
+     "stime": "2015-06-23T12:05:03Z"
+   }
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | bdb isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | bdb is in recovery state |
+---
+Title: Database stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-stats) | `/v1/bdbs/stats` | Get stats for all databases |
+| [GET](#get-bdbs-stats) | `/v1/bdbs/stats/{uid}` | Get stats for a specific database |
+
+## Get all database stats {#get-all-bdbs-stats}
+
+```sh
+GET /v1/bdbs/stats
+```
+
+Get statistics for all databases.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for all databases.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "intervals": [
+      {
+         "interval": "1hour",
+         "stime": "2015-05-27T12:00:00Z",
+         "etime": "2015-05-28T12:59:59Z",
+         "avg_latency": 0.0,
+         "conns": 0.0,
+         "egress_bytes": 0.0,
+         "etime": "2015-05-28T00:00:00Z",
+         "evicted_objects": 0.0,
+         "expired_objects": 0.0,
+         "ingress_bytes": 0.0,
+         "instantaneous_ops_per_sec": 0.00011973180076628352,
+         "last_req_time": "1970-01-01T00:00:00Z",
+         "last_res_time": "1970-01-01T00:00:00Z",
+         "used_memory": 5656299.362068966,
+         "mem_size_lua": 35840.0,
+         "monitor_sessions_count": 0.0,
+         "no_of_keys": 0.0,
+         "other_req": 0.0,
+         "other_res": 0.0,
+         "read_hits": 0.0,
+         "read_misses": 0.0,
+         "read_req": 0.0,
+         "read_res": 0.0,
+         "total_connections_received": 0.0,
+         "total_req": 0.0,
+         "total_res": 0.0,
+         "write_hits": 0.0,
+         "write_misses": 0.0,
+         "write_req": 0.0,
+         "write_res": 0.0
+      },
+      {
+         "interval": "1hour",
+         "interval": "1hour",
+         "stime": "2015-05-27T13:00:00Z",
+         "etime": "2015-05-28T13:59:59Z",
+         "avg_latency": 599.08,
+         "// additional fields..."
+      }
+    ]
+  },
+  {
+    "uid": "2",
+    "intervals": [
+      {
+        "interval": "1hour",
+        "stime": "2015-05-27T12:00:00Z",
+        "etime": "2015-05-28T12:59:59Z",
+        "avg_latency": 0.0,
+        "// additional fields..."
+      },
+      {
+        "interval": "1hour",
+        "stime": "2015-05-27T13:00:00Z",
+        "etime": "2015-05-28T13:59:59Z",
+
+        "// additional fields..."
+      }
+    ]
+  }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No bdbs exist |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X GET
+        https://[host][:port]/v1/bdbs/stats?interval=1hour
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/bdbs/stats?interval=1hour"
+auth = ("[username]", "[password]")
+
+response = requests.request("GET", url, auth=auth)
+
+print(response.text)
+```
+
+## Get database stats {#get-bdbs-stats}
+
+```sh
+GET /v1/bdbs/stats/{int: uid}
+```
+
+Get statistics for a specific database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the BDB requested. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/7.4/references/rest-api/objects/statistics" >}}) for a specific database.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "intervals": [
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T12:00:00Z",
+      "etime": "2015-05-28T12:59:59Z",
+      "avg_latency": 0.0,
+      "conns": 0.0,
+      "egress_bytes": 0.0,
+      "evicted_objects": 0.0,
+      "pubsub_channels": 0,
+      "pubsub_patterns": 0,
+      "expired_objects": 0.0,
+      "ingress_bytes": 0.0,
+      "instantaneous_ops_per_sec": 0.00011973180076628352,
+      "last_req_time": "1970-01-01T00:00:00Z",
+      "last_res_time": "1970-01-01T00:00:00Z",
+      "used_memory": 5656299.362068966,
+      "mem_size_lua": 35840.0,
+      "monitor_sessions_count": 0.0,
+      "no_of_keys": 0.0,
+      "other_req": 0.0,
+      "other_res": 0.0,
+      "read_hits": 0.0,
+      "read_misses": 0.0,
+      "read_req": 0.0,
+      "read_res": 0.0,
+      "total_connections_received": 0.0,
+      "total_req": 0.0,
+      "total_res": 0.0,
+      "write_hits": 0.0,
+      "write_misses": 0.0,
+      "write_req": 0.0,
+      "write_res": 0.0
+    },
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T13:00:00Z",
+      "etime": "2015-05-28T13:59:59Z",
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | bdb isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | bdb is in recovery state |
+---
+Title: Database requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: bdbs
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs) | `/v1/bdbs` | Get all databases |
+| [GET](#get-bdbs) | `/v1/bdbs/{uid}` | Get a single database |
+| [PUT](#put-bdbs) | `/v1/bdbs/{uid}` | Update database configuration |
+| [PUT](#put-bdbs-action) | `/v1/bdbs/{uid}/{action}` | Update database configuration and perform additional action |
+| [POST](#post-bdbs-v1) | `/v1/bdbs` | Create a new database |
+| [POST](#post-bdbs-v2) | `/v2/bdbs` | Create a new database |
+| [DELETE](#delete-bdbs) | `/v1/bdbs/{uid}` | Delete a database |
+
+## Get all databases {#get-all-bdbs}
+
+```sh
+GET /v1/bdbs
+```
+
+Get all databases in the cluster.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_all_bdbs_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdbs_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs?fields=uid,name
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| fields | string | Comma-separated list of field names to return (by default all fields are returned). (optional) |
+
+### Response {#get-all-response}
+
+The response body contains a JSON array with all databases, represented as [BDB objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Body
+
+```json
+[
+    {
+        "uid": 1,
+        "name": "name of database #1",
+        "// additional fields..."
+    },
+    {
+        "uid": 2,
+        "name": "name of database #2",
+        "// additional fields..."
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -X GET -u "[username]:[password]" \
+       -H "accept: application/json" \
+       https://[host][:port]/v1/bdbs?fields=uid,name
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/bdbs?fields=uid,name"
+auth = ("[username]", "[password]")
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+response = requests.request("GET", url, auth=auth, headers=headers)
+
+print(response.text)
+```
+
+## Get a database {#get-bdbs}
+
+```sh
+GET /v1/bdbs/{int: uid}
+```
+
+Get a single database.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| fields | string | Comma-separated list of field names to return (by default all fields are returned). (optional) |
+
+### Response {#get-response}
+
+Returns a [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database UID does not exist |
+
+## Update database configuration {#put-bdbs}
+
+```sh
+PUT /v1/bdbs/{int: uid}
+```
+Update the configuration of an active database.
+
+If called with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) against the existing database, but will not invoke the state machine that will update it.
+
+This is the basic version of the update request. See [Update database and perform action](#put-bdbs-action) to send an update request with an additional action.
+
+To track this request's progress, poll the [`/actions/<action_uid>` endpoint]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions" >}}) with the action_uid returned in the response body.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |      | Validate the new [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) but don't apply the update. |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database for which update is requested. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) with updated fields in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "replication": true,
+    "data_persistence": "aof"
+}
+```
+
+The above request attempts to modify a database configuration to enable in-memory data replication and append-only file data persistence.
+
+### Response {#put-response}
+
+Returns the updated [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "replication": true,
+    "data_persistence": "aof",
+    "// additional fields..."
+}
+```
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'active-change-pending' until the request has been fully processed. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Attempting to change a database while it is busy with another configuration change. In this context, this is a temporary condition, and the request should be reattempted later. |
+
+#### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| rack_awareness_violation | • Non rack-aware cluster.<br />• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed.|
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| insufficient_resources | Shards count exceeds shards limit per bdb. |
+| not_supported_action_on_crdt | `reset_admin_pass` action is not allowed on CRDT enabled BDB. |
+| name_violation | CRDT database name cannot be changed. |
+| bad_shards_blueprint | The sharding blueprint is broken or doesn’t fit the BDB. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| replication_node_violation | Not enough nodes for replication. |
+| replication_size_violation | Database limit too small for replication. |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| crdt_sharding_violation | CRDB created without sharding cannot be changed to use sharding
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+## Update database and perform action {#put-bdbs-action}
+
+```sh
+PUT /v1/bdbs/{int: uid}/{action}
+```
+Update the configuration of an active database and perform an additional action.
+
+If called with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) against the existing database, but will not invoke the state machine that will update it.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb_with_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_bdb_with_action" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request-action}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/reset_admin_pass
+```
+The above request resets the admin password after updating the database.
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to update. |
+| action | string | Additional action to perform. Currently supported actions are: `flush`, `reset_admin_pass`. |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |       | Validate the new [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) but don't apply the update. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) with updated fields in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "replication": true,
+    "data_persistence": "aof"
+}
+```
+
+The above request attempts to modify a database configuration to enable in-memory data replication and append-only file data persistence.
+
+{{<note>}}
+To change the shard hashing policy, you must flush all keys from the database.
+{{</note>}}
+
+### Response {#put-response-action}
+
+If the request succeeds, the response body returns the updated [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}). If an error occurs, the response body may include an error code and message with more details.
+
+#### Status codes {#put-status-codes-action}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'active-change-pending' until the request has been fully processed. |
+| [403&nbsp;Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | redislabs license expired. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Attempting to change a database while it is busy with another configuration change. In this context, this is a temporary condition, and the request should be reattempted later. |
+
+#### Error codes {#put-error-codes-action}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| rack_awareness_violation | • Non rack-aware cluster.<br />• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed.|
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| insufficient_resources | Shards count exceeds shards limit per bdb. |
+| not_supported_action_on_crdt | `reset_admin_pass` action is not allowed on CRDT enabled BDB. |
+| name_violation | CRDT database name cannot be changed. |
+| bad_shards_blueprint | The sharding blueprint is broken or doesn’t fit the BDB. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| replication_node_violation | Not enough nodes for replication. |
+| replication_size_violation | Database limit too small for replication. |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| crdt_sharding_violation | CRDB created without sharding cannot be changed to use sharding
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+## Create database v1 {#post-bdbs-v1}
+
+```sh
+POST /v1/bdbs
+```
+Create a new database in the cluster.
+
+The request must contain a single JSON [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) with the configuration parameters for the new database.
+
+The following parameters are required to create the database:
+
+| Parameter | Type/Value | Description |
+|----------|------------|-------------|
+| name     | string     | Name of the new database |
+| memory_size | integer | Size of the database, in bytes |
+
+If passed with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}), but will not invoke the state machine that will create it.
+
+To track this request's progress, poll the [`/actions/<action_uid>` endpoint]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions" >}}) with the `action_uid` returned in the response body.
+
+The cluster will use default configuration for any missing database field. The cluster creates a database UID if it is missing.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#create_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request-v1}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run |    | Validate the new [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) but don't create the database. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) in the request body.
+
+The following parameters are required to create the database:
+
+| Paramter | Type/Value | Description |
+|----------|------------|-------------|
+| name     | string     | Name of the new database |
+| memory_size | integer | Size of the database, in bytes |
+
+The `uid` of the database is auto-assigned by the cluster because it was not explicitly listed in this request. If you specify the database ID (`uid`), then you must specify the database ID for every subsequent database and make sure that the database ID does not conflict with an existing database. If you do not specify the database ID, then the it is automatically assigned in sequential order.
+
+Defaults are used for all other configuration parameters.
+
+#### Example JSON body
+
+```json
+{
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824
+}
+```
+
+The above request is an attempt to create a Redis database with a user-specified name and a memory limit of 1GB.
+
+### Response {#post-response-v1}
+
+The response includes the newly created [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824,
+    "// additional fields..."
+}
+```
+
+#### Error codes {#post-error-codes-v1}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| uid_exists | The specified database UID is already in use. |
+| missing_db_name | DB name is a required property. |
+| missing_memory_size | Memory Size is a required property. |
+| missing_module | Modules missing from the cluster. |
+| port_unavailable | The specified database port is reserved or already in use. |
+| invalid_sharding | Invalid sharding configuration was specified. |
+| bad_shards_blueprint | The sharding blueprint is broken. |
+| not_rack_aware | Cluster is not rack-aware and a rack-aware database was requested. |
+| invalid_version | An invalid database version was requested. |
+| busy | The request failed because another request is being processed at the same time on the same database. |
+| invalid_data_persistence | Invalid data persistence configuration. |
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_sasl_credentials | SASL credentials are missing or invalid. |
+| invalid_replication | Not enough nodes to perform replication. |
+| insufficient_resources | Not enough resources in cluster to host the database. |
+| rack_awareness_violation | • Rack awareness violation.<br/>• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed. |
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| memcached_cannot_use_modules | Cannot create a memcached database with modules. |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| wrong_cluster_state_id | The given CLUSTER-STATE-ID does not match the current one
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+#### Status codes {#post-status-codes-v1}
+
+| Code | Description |
+|------|-------------|
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | redislabs license expired. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database with the same UID already exists. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, database is being created. |
+
+## Create database v2 {#post-bdbs-v2}
+
+```sh
+POST /v2/bdbs
+```
+Create a new database in the cluster. See [`POST /v1/bdbs`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#post-bdbs-v1" >}}) for more information.
+
+The database's configuration should be under the "bdb" field.
+
+This endpoint allows you to specify a recovery_plan to recover a database. If you include a recovery_plan within the request body, the database will be loaded from the persistence files according to the recovery plan. The recovery plan must match the number of shards requested for the database.
+
+The persistence files must exist in the locations specified by the recovery plan. The persistence files must belong to a database with the same shard settings as the one being created (slot range distribution and shard_key_regex); otherwise, the operation will fail or yield unpredictable results.
+
+If you create a database with a shards_blueprint and a recovery plan, the shard placement may not fully follow the shards_blueprint.
+
+### Request {#post-request-v2}
+
+#### Example HTTP request
+
+```sh
+POST /v2/bdbs
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run |    | Validate the new [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) but don't create the database. |
+
+#### Body
+
+Include a JSON object that contains a [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}) and an optional `recovery_plan` object in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "bdb": {
+        "name": "test-database",
+        "type": "redis",
+        "memory_size": 1073741824,
+        "shards_count": 1
+    },
+    "recovery_plan": {
+        "data_files": [
+            {
+                "shard_slots": "0-16383",
+                "node_uid": "1",
+                "filename": "redis-4.rdb"
+            }
+        ]
+    }
+}
+```
+
+### Response {#post-response-v2}
+
+The response includes the newly created [BDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824,
+    "shards_count": 1,
+    "// additional fields..."
+}
+```
+
+## Delete database {#delete-bdbs}
+
+```sh
+DELETE /v1/bdbs/{int: uid}
+```
+Delete an active database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_bdb]({{< relref "/operate/rs/7.4/references/rest-api/permissions#delete_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/bdbs/1
+```
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to delete. |
+
+### Response {#delete-response}
+
+Returns a status code that indicates the database deletion success or failure.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'delete-pending' until the request has been fully processed. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Attempting to delete an internal database. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent database. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Either the database is not in 'active' state and cannot be deleted, or it is busy with another configuration change. In the second case, this is a temporary condition, and the request should be re-attempted later. |
+---
+Title: Database CRDT sources alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Conflict-free replicated data type (CRDT) source alert requests
+headerRange: '[1-2]'
+linkTitle: crdt_sources/alerts
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/bdbs/crdt_sources-alerts/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-crdt-sources-alerts) | `/v1/bdbs/crdt_sources/alerts` | Get all CRDT sources alert states for all CRDB databases |
+| [GET](#get-bdbs-crdt-sources-alerts) | `/v1/bdbs/crdt_sources/alerts/{uid}` | Get all CRDT sources alert states for a database |
+| [GET](#get-bdbs-crdt-source-all-alerts) | `/v1/bdbs/crdt_sources/alerts/{uid}/{crdt_src_id}` | Get all alert states for a CRDT source |
+| [GET](#get-bdbs-crdt-source-alert) | `/v1/bdbs/crdt_sources/alerts/{uid}/{crdt_src_id}/{alert}` | Get a database alert state |
+
+## Get all CRDB CRDT source alert states {#get-all-bdbs-crdt-sources-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts
+
+Get all alert states for all CRDT sources of all CRDBs.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a hash of alert UIDs and the [alerts states]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) for each local BDB of CRDB.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "crdt_src_syncer_connection_error": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get all BDB CRDT sources alert states {#get-bdbs-crdt-sources-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}
+
+Get all alert states for all crdt sources for a specific local bdb of a CRDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-all-crdt-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#get-response-all-crdt-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "crdt_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-crdt-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get all CRDT source alert states {#get-bdbs-crdt-source-all-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}/{int: crdt_src_id}
+
+Get all alert states for specific crdt source for a specific local BDB
+of a CRDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-crdt-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1/2 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| crdt_src_id | integer | The ID of the crdt source in this BDB |
+
+### Response {#get-response-crdt-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}) and their states. 
+
+#### Example JSON body
+
+```json
+{
+    "crdt_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-crdt-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get database alert state {#get-bdbs-crdt-source-alert}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}/{int: crdt_src_id}/{alert}
+
+Get a BDB alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alert} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1/2/crdt_src_syncer_connection_error 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| crdt_src_id | integer | The ID of the crdt source in this BDB |
+| alert | string | The alert name |
+
+### Response {#get-response-alert} 
+
+Returns an [alert object]({{< relref "/operate/rs/7.4/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes-alert} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+---
+Title: CRDB flush requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Flush Active-Active database requests
+headerRange: '[1-2]'
+linkTitle: flush
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdbs/flush/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-crdbs-flush) | `/v1/crdbs/{crdb_guid}/flush` | Flush an Active-Active database |
+
+## Flush an Active-Active database {#put-crdbs-flush}
+
+```sh
+PUT /v1/crdbs/{crdb_guid}/flush
+```
+
+Flush an Active-Active database.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79/flush
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+### Response {#put-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Configuration cannot be accepted, typically because it was already committed. |
+---
+Title: CRDB health report requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database health report requests
+headerRange: '[1-2]'
+linkTitle: health_report
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdbs/health_report/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-crdbs-health) | `/v1/crdbs/{crdb_guid}/health_report` | Get a health report for an Active-Active database |
+
+## Get health report {#get-crdbs-health}
+
+	GET /v1/crdbs/{crdb_guid}/health_report
+
+Get a health report for an Active-Active database.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/crdbs/{crdb_guid}/health_report
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instance_id | integer | The request retrieves information from the specified Active-Active database instance. If this instance doesn’t exist, the request retrieves information from all instances. (optional) |
+
+### Response {#get-response} 
+
+Returns a JSON array of [CRDB health report objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/health_report" >}}).
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+---
+Title: CRDB purge requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Purge removed Active-Active database requests
+headerRange: '[1-2]'
+linkTitle: purge
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdbs/purge/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-crdbs-purge) | `/v1/crdbs/{crdb_guid}/purge` | Purge data from an instance that was forcibly removed from the Active-Active database |
+
+## Purge data from removed instance {#put-crdbs-purge}
+
+	PUT /v1/crdbs/{crdb_guid}/purge
+
+Purge the data from an instance that was removed from the
+Active-Active database by force.
+
+When you force the removal of an instance from an Active-Active
+database, the removed instance keeps the data and configuration
+according to the last successful synchronization.
+
+To delete the data and configuration from the forcefully removed
+instance you must use this API (Must be executed locally on the
+removed instance).
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+    PUT /v1/crdbs/1/purge
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instances | array of integers | Array of unique instance IDs |
+
+### Response {#put-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration, instance, or Active-Active database not found. |
+---
+Title: CRDB updates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update Active-Active configuration requests
+headerRange: '[1-2]'
+linkTitle: updates
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdbs/updates/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-crdbs-updates) | `/v1/crdbs/{crdb_guid}/updates` | Modify Active-Active confgurarion |
+
+## Modify Active-Active configuration {#post-crdbs-updates}
+
+	POST /v1/crdbs/{crdb_guid}/updates
+
+Modify Active-Active configuration.
+
+{{<warning>}}
+This is a very powerful API request and can cause damage if used incorrectly.
+{{</warning>}}
+
+In order to add or remove instances, you must use this API. For simple configuration updates, it is recommended to use PATCH on /crdbs/{crdb_guid} instead.
+
+Updating default_db_config affects both existing and new instances that may be added.
+
+When you update db_config, it changes the configuration of the database that you specify. This field overrides corresponding fields (if any) in default_db_config.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+    POST /v1/crdbs/1/updates
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+Include a [CRDB modify_request object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb/modify_request" >}}) with updated fields in the request body.
+
+### Response {#post-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The posted Active-Active database contains invalid parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration, instance or Active-Active database not found. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+---
+Title: CRDBs requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: crdbs
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdbs/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-crdbs) | `/v1/crdbs` | Get all Active-Active databases |
+| [GET](#get-crdb) | `/v1/crdbs/{crdb_guid}` | Get a specific Active-Active database |
+| [PATCH](#patch-crdbs) | `/v1/crdbs/{crdb_guid}` | Update an Active-Active database |
+| [POST](#post-crdb) | `/v1/crdbs` | Create a new Active-Active database |
+| [DELETE](#delete-crdb) | `/v1/crdbs/{crdb_guid}` | Delete an Active-Active database |
+
+## Get all Active-Active databases {#get-all-crdbs}
+
+```sh
+GET /v1/crdbs
+```
+
+Get a list of all Active-Active databases on the cluster.
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/crdbs
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [CRDB objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb" >}}).
+
+##### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | A list of Active-Active database. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+
+## Get an Active-Active database {#get-crdb}
+
+```sh
+GET /v1/crdbs/{crdb_guid}
+```
+
+Get a specific Active-Active database.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+ GET /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instance_id | integer | Instance from which to get the Active-Active database information |
+
+### Response {#get-response}
+
+Returns a [CRDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb" >}}).
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Active-Active database information is returned. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or configuration does not exist. |
+
+## Update an Active-Active database {#patch-crdbs}
+
+```sh
+PATCH /v1/crdbs/{crdb_guid}
+```
+
+Update an Active-Active database's configuration.
+
+In order to add or remove instances, use [<nobr>`POST crdbs/{crdb_guid}/updates`</nobr>]({{< relref "/operate/rs/7.4/references/rest-api/requests/crdbs/updates#post-crdbs-updates" >}}) instead.
+
+### Request {#patch-request}
+
+#### Example HTTP request
+
+```sh
+ PATCH /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+Include a [CRDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb" >}}) with updated fields in the request body.
+
+### Response {#patch-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#patch-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The posted Active-Active database contains invalid parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+
+## Create an Active-Active database {#post-crdb}
+
+```sh
+POST /v1/crdbs
+```
+
+Create a new Active-Active database.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+ POST /v1/crdbs
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### Request body
+
+Include a [CRDB object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb" >}}), which defines the Active-Active database, in the request body.
+
+##### Example body
+
+```json
+{
+    "default_db_config":
+    {
+        "name": "sample-crdb",
+        "memory_size": 214748365
+    },
+    "instances":
+    [
+        {
+            "cluster":
+            {
+                "url": "http://<cluster1_FQDN>:9443",
+                "credentials":
+                {
+                    "username": "<username>",
+                    "password": "<password>"
+                },
+                "name": "cluster-1"
+            },
+            "compression": 6
+        },
+        {
+            "cluster":
+            {
+                "url": "http://<cluster2_FQDN>:9443",
+                "credentials":
+                {
+                    "username": "<username>",
+                    "password": "<password>"
+                },
+                "name": "cluster-2"
+            },
+            "compression": 6
+        }
+    ],
+    "name": "sample-crdb"
+}
+```
+
+This JSON body creates an Active-Active database without TLS and with two participating clusters.
+
+### Response {#post-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+
+## Delete an Active-Active database {#delete-crdb}
+
+```sh
+DELETE /v1/crdbs/{crdb_guid}
+```
+
+Delete an Active-Active database.
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+ DELETE /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+### Response {#delete-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The Active-Active GUID is invalid or the Active-Active database was already deleted. |
+---
+Title: Logs requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster event logs requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: logs
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/logs/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-logs) | `/v1/logs` | Get cluster events log |
+
+## Get cluster events log {#get-logs}
+
+	GET /v1/logs
+
+Get cluster events log.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_logged_events]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_logged_events" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/logs?order=desc 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| stime | ISO_8601 | Start time before which we don't want events. (optional) |
+| etime | ISO_8601 | End time after which we don't want events. (optional) |
+| order | string | desc/asc - get events in descending or ascending order. Defaults to asc. |
+| limit | integer | Maximum number of events to return. (optional) |
+| offset | integer | Skip offset events before returning first one (useful for pagination). (optional) |
+
+### Response {#get-response} 
+
+Returns a JSON array of events.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "time": "2014-08-29T11:19:49Z",
+    "type": "bdb_name_updated",
+    "severity": "INFO",
+    "bdb_uid": "1",
+    "old_val": "test",
+    "new_val": "test123"
+  },
+  {
+    "time": "2014-08-29T11:18:48Z",
+    "type": "cluster_bdb_created",
+    "severity": "INFO",
+    "bdb_uid": "1",
+    "bdb_name": "test"
+  },
+  {
+    "time": "2014-08-29T11:17:49Z",
+    "type": "cluster_node_joined",
+    "severity": "INFO",
+    "node_uid": 2
+  }
+]
+```
+
+#### Event object
+
+| Field | Description |
+|-------|-------------|
+| time | Timestamp when event happened. |
+| type | Event type. Additional fields may be available for certain event types. |
+| additional fields | Additional fields may be present based on event type.|
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: JSON schema requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: API object JSON schema requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: jsonschema
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/jsonschema/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-jsonschema) | `/v1/jsonschema` | Get JSON schema of API objects |
+
+## Get object JSON schema {#get-jsonschema}
+
+	GET /v1/jsonschema
+
+Get the JSON schema of various [Redis Enterprise REST API objects]({{< relref "/operate/rs/7.4/references/rest-api/objects" >}}).
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/jsonschema?object=bdb 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| object | string | Optional. The API object name: 'cluster', 'node', 'bdb' etc. |
+
+### Response {#get-response} 
+
+Returns the JSON schema of the specified API object.
+
+#### Example JSON body
+
+```json
+{
+     "type": "object",
+     "description": "An API object that represents a managed database in the cluster.",
+     "properties": {
+          "...."
+     },
+     "...."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid object. |
+---
+Title: LDAP mappings requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: LDAP mappings requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: ldap_mappings
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/ldap_mappings/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-ldap_mappings) | `/v1/ldap_mappings` | Get all LDAP mappings |
+| [GET](#get-ldap_mapping) | `/v1/ldap_mappings/{uid}` | Get a single LDAP mapping |
+| [PUT](#put-ldap_mapping) | `/v1/ldap_mappings/{uid}` | Update an LDAP mapping |
+| [POST](#post-ldap_mappings) | `/v1/ldap_mappings` | Create a new LDAP mapping |
+| [DELETE](#delete-ldap_mappings) | `/v1/ldap_mappings/{uid}` | Delete an LDAP mapping |
+
+## Get all LDAP mappings {#get-all-ldap_mappings}
+
+	GET /v1/ldap_mappings
+
+Get all LDAP mappings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_ldap_mappings_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_ldap_mappings_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/ldap_mappings 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [LDAP mapping objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap_mapping" >}}).
+
+#### Example JSON body
+
+```json
+[
+  {
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get LDAP mapping {#get-ldap_mapping}
+
+	GET /v1/ldap_mappings/{int: uid}
+
+Get a specific LDAP mapping.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ldap_mapping_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_ldap_mapping_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ldap_mappings/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The object's unique ID. |
+
+### Response {#get-response} 
+
+Returns an [LDAP mapping object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap_mapping" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+}
+```
+
+### Error codes {#get-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| ldap_mapping_not_exist | An object does not exist| 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | ldap_mapping does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+
+## Update LDAP mapping {#put-ldap_mapping}
+
+	PUT /v1/ldap_mappings/{int: uid}
+
+Update an existing ldap_mapping object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_ldap_mapping]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_ldap_mapping" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/ldap_mappings/17 
+
+#### Example JSON body
+
+```json
+{
+    "dn": "OU=ops,DC=redislabs,DC=com",
+    "email": "ops@redislabs.com",
+    "email_alerts": true,
+    "bdbs_email_alerts": ["1","2"],
+    "cluster_email_alerts": true
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP mapping object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap_mapping" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops,DC=redislabs,DC=com",
+     "email": "ops@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+}
+```
+
+### Error codes {#put-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| name_already_exists | An object of the same type and name exists| 
+| ldap_mapping_not_exist | An object does not exist| 
+| invalid_dn_param | A dn parameter has an illegal value| 
+| invalid_name_param | A name parameter has an illegal value| 
+| invalid_role_uids_param | A role_uids parameter has an illegal value| 
+| invalid_account_id_param | An account_id parameter has an illegal value| 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, LDAP mapping is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existing LDAP mapping. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mapping yet. |
+
+## Create LDAP mapping {#post-ldap_mappings}
+
+	POST /v1/ldap_mappings
+
+Create a new LDAP mapping.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [create_ldap_mapping]({{< relref "/operate/rs/7.4/references/rest-api/permissions#create_ldap_mapping" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/ldap_mappings 
+
+#### Example JSON body
+
+```json
+{
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP mapping object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ldap_mapping" >}}) in the request body.
+
+### Response {#post-response} 
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"]
+}
+```
+
+### Error codes {#post-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| name_already_exists | An object of the same type and name exists| 
+| missing_field | A needed field is missing| 
+| invalid_dn_param | A dn parameter has an illegal value| 
+| invalid_name_param | A name parameter has an illegal value| 
+| invalid_role_uids_param | A role_uids parameter has an illegal value| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, an LDAP-mapping object is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+
+## Delete LDAP mapping {#delete-ldap_mappings}
+
+	DELETE /v1/ldap_mappings/{int: uid}
+
+Delete an LDAP mapping object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [delete_ldap_mapping]({{< relref "/operate/rs/7.4/references/rest-api/permissions#delete_ldap_mapping" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/ldap_mappings/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The ldap_mapping unique ID. |
+
+### Response {#delete-response} 
+
+Returns a status code. If an error occurs, the response body may include a more specific error code and message.
+
+### Error codes {#delete-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| ldap_mapping_not_exist | An object does not exist| 
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the ldap_mapping is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+---
+Title: All nodes database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/all/bdb requests.
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/debuginfo/all/bdb/'
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo-bdb) | `/v1/debuginfo/all/bdb/{bdb_uid}` | Get debug info for a database from all nodes |
+
+## Get database debug info for all nodes {#get-all-debuginfo-bdb}
+
+	GET /v1/debuginfo/all/bdb/{int: bdb_uid}
+
+Downloads a tar file that contains debug info for the specified database (`bdb_uid`) from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/all/bdb/1 
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: All nodes debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/all requests.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: all
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/debuginfo/all/'
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo) | `/v1/debuginfo/all` | Get debug info for all nodes |
+
+## Get debug info for all nodes {#get-all-debuginfo}
+
+	GET /v1/debuginfo/all
+
+Downloads a tar file that contains debug info from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/all 
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info for all nodes.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Current node database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/node/bdb requests.
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/debuginfo/node/bdb/'
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-node-bdb) | `/v1/debuginfo/node/bdb/{bdb_uid}` | Get debug info for the current node regarding a specific database |
+
+## Get database debug info for current node {#get-debuginfo-node-bdb}
+
+	GET /v1/debuginfo/node/bdb/{int: bdb_uid}
+
+Downloads a tar file that contains debug info for the specified database (`bdb_uid`) from the current node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/node/bdb/1 
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Current node debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/node requests.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: node
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/debuginfo/node/'
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-node) | `/v1/debuginfo/node` | Get debug info for the current node |
+
+## Get debug info for current node {#get-debuginfo-node}
+
+	GET /v1/debuginfo/node
+
+Downloads a tar file that contains debug info for the current node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/node 
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Debug info requests
+hideListLinks: true
+linkTitle: debuginfo
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/debuginfo/'
+---
+
+{{<banner-article>}}
+These REST API paths are deprecated as of Redis Enterprise Software version 7.4.2. Use the new paths [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/debuginfo" >}}), [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/debuginfo" >}}), and [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+Downloads a support package, which includes logs and information about the cluster, nodes, databases, and shards, as a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+## Get debug info for all nodes in the cluster
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./all#get-all-debuginfo" >}}) | `/v1/debuginfo/all` | Gets debug info for all nodes |
+| [GET]({{< relref "./all/bdb#get-all-debuginfo-bdb" >}}) | `/v1/debuginfo/all/bdb/{bdb_uid}` | Gets debug info for a database from all nodes |
+
+## Get debug info for the current node
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./node#get-debuginfo-node" >}}) | `/v1/debuginfo/node` | Gets debug info for the current node |
+| [GET]({{< relref "./node/bdb#get-debuginfo-node-bdb" >}}) | `/v1/debuginfo/node/bdb/{bdb_uid}` | Gets debug info for a database from the current node |
+---
+Title: Refresh JWT requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Refresh JW token requests
+headerRange: '[1-2]'
+linkTitle: refresh_jwt
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/users/refresh_jwt/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-refresh_jwt) | `/v1/users/refresh_jwt` | Get a new authentication token |
+
+## Get a new authentication token {#post-refresh_jwt}
+
+    POST /v1/users/refresh_jwt
+
+Generate a new JSON Web Token (JWT) for authentication.
+
+Takes a valid token and returns the new token generated by the request.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/users/refresh_jwt 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Authorization | JWT eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.<br></br>eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJ<br></br>leHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0e<br></br>dFzcLElMOHsshaqQk2HUNgdsUKxMU | Valid JSON Web Token (JWT) |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ttl | integer | Time to live - The amount of time in seconds the token will be valid (optional) |
+
+### Response {#post-response} 
+
+Returns a JSON object that contains the generated access token.
+
+#### Example JSON body
+
+```json
+ {
+     "access_token": "eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJleHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0edFzcLElMOHsshaqQk2HUNgdsUKxMU"
+ }
+```
+
+
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | A new token is given. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The token is invalid or password has expired. |
+---
+Title: User password requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: User password requests
+headerRange: '[1-2]'
+linkTitle: password
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/users/password/'
+---
+
+| Method                     | Path                 | Description                 |
+|----------------------------|----------------------|-----------------------------|
+| [PUT](#update-password)    | `/v1/users/password` | Change an existing password |
+| [POST](#add-password)      | `/v1/users/password` | Add a new password          |
+| [DELETE](#delete-password) | `/v1/users/password` | Delete a password           |
+
+## Update password {#update-password}
+    
+    PUT /v1/users/password
+    
+Reset the password list of an internal user to include a new password.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+    PUT /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "a password that exists in the current list",
+      "new_password": "the new (single) password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON object with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username     | string | Affected user (required) |
+| old_password | string | A password that exists in the current list (required) |
+| new_password | string | The new password (required) |
+
+### Response {#put-response}
+
+Returns a status code to indicate password update success or failure.
+
+### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only work when the password_complexity feature is enabled). |
+| new_password_same_as_current | The given new password is identical to one of the already existing passwords. |
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, password changed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to reset password to a non-existing user. |
+
+## Add password {#add-password}
+
+    POST /v1/users/password
+
+Add a new password to an internal user's passwords list.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "an existing password",
+      "new_password": "a password to add"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON object with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username     | string | Affected user (required) |
+| old_password | string | A password that exists in the current list (required) |
+| new_password | string | The new (single) password (required) |
+
+### Response {#post-response}
+
+Returns a status code to indicate password creation success or failure. If an error occurs, the response body may include a more specific error code and message.
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only work when the password_complexity feature is enabled). |
+| new_password_same_as_current | The given new password is identical to one of the already existing passwords. |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, new password was added to the list of valid passwords. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to add a password to a non-existing user. |
+
+## Delete password {#delete-password}
+    DELETE /v1/users/password
+
+Delete a password from an internal user's passwords list.
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+    DELETE /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "an existing password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username | string | Affected user (required) |
+| old_password | string | Existing password to be deleted (required) |
+
+### Response {#delete-response}
+
+### Error codes {#delete-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| cannot_delete_last_password | Cannot delete the last password of a user |
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, new password was deleted from the list of valid passwords. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a password to a non-existing user. |
+---
+Title: Users requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: User requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: users
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/users/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-users) | `/v1/users` | Get all users |
+| [GET](#get-user) | `/v1/users/{uid}` | Get a single user |
+| [PUT](#put-user) | `/v1/users/{uid}` | Update a user's configuration |
+| [POST](#post-user) | `/v1/users` | Create a new user |
+| [DELETE](#delete-user) | `/v1/users/{uid}` | Delete a user |
+
+## Get all users {#get-all-users}
+
+```sh
+GET /v1/users
+```
+
+Get a list of all users.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_users_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_users_info" >}}) | admin |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/users
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [user objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": 1,
+        "password_issue_date": "2017-03-02T09:43:34Z",
+        "email": "user@example.com",
+        "name": "John Doe",
+        "email_alerts": true,
+        "bdbs_email_alerts": ["1","2"],
+        "role": "admin",
+        "auth_method": "regular",
+        "status": "active"
+    },
+    {
+        "uid": 2,
+        "password_issue_date": "2017-03-02T09:43:34Z",
+        "email": "user2@example.com",
+        "name": "Jane Poe",
+        "email_alerts": true,
+        "role": "db_viewer",
+        "auth_method": "regular",
+        "status": "active"
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get user {#get-user}
+
+```sh
+GET /v1/users/{int: uid}
+```
+
+Get a single user's details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_user_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_user_info" >}}) | admin |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/users/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+### Response {#get-response}
+
+Returns a [user object]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}) that contains the details for the specified user ID.
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "password_issue_date": "2017-03-07T15:11:08Z",
+    "role": "db_viewer",
+    "email_alerts": true,
+    "bdbs_email_alerts": ["1","2"],
+    "email": "user@example.com",
+    "name": "John Doe",
+    "auth_method": "regular",
+    "status": "active"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | User does not exist. |
+
+## Update user {#put-user}
+
+```sh
+PUT /v1/users/{int: uid}
+```
+
+Update an existing user's configuration.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_user]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_user" >}}) | admin |
+
+Any user can change their own name, password, or alert preferences.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/users/1
+```
+
+#### Example JSON body
+
+```json
+{
+     "email_alerts": false,
+     "role_uids": [ 2, 4 ]
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+
+#### Request body
+
+Include a [user object]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns the updated [user object]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "password_issue_date": "2017-03-07T15:11:08Z",
+     "email": "user@example.com",
+     "name": "Jane Poe",
+     "email_alerts": false,
+     "role": "db_viewer",
+     "role_uids": [ 2, 4 ],
+     "auth_method": "regular"
+}
+```
+
+{{<note>}}
+For [RBAC-enabled clusters]({{< relref "/operate/rs/7.4/security/access-control" >}}), the returned user details include `role_uids` instead of `role`.
+{{</note>}}
+
+### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only works when the password_complexity feature is enabled).|
+| new_password_same_as_current | The given new password is identical to the old password.|
+| email_already_exists | The given email is already taken.|
+| change_last_admin_role_not_allowed | At least one user with admin role should exist.|
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the user is updated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existing user. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+
+## Create user {#post-user}
+
+```sh
+POST /v1/users
+```
+
+Create a new user.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_new_user]({{< relref "/operate/rs/7.4/references/rest-api/permissions#create_new_user" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/users
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Body
+
+Include a single [user object]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}) in the request body. The user object must have an email, password, and role.
+
+{{<note>}}
+For [RBAC-enabled clusters]({{< relref "/operate/rs/7.4/security/access-control" >}}), use `role_uids` instead of `role` in the request body.
+{{</note>}}
+
+`email_alerts` can be configured either as:
+
+- `true` - user will receive alerts for all databases configured in `bdbs_email_alerts`. The user will receive alerts for all databases by default if `bdbs_email_alerts` is not configured. `bdbs_email_alerts` can be a list of database UIDs or `[‘all’]` meaning all databases.
+
+- `false` - user will not receive alerts for any databases
+
+##### Example JSON body
+
+```json
+{
+     "email": "newuser@example.com",
+     "password": "my-password",
+     "name": "Pat Doe",
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "role_uids": [ 3, 4 ],
+     "auth_method": "regular"
+}
+```
+
+### Response {#post-response}
+
+Returns the newly created [user object]({{< relref "/operate/rs/7.4/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "password_issue_date": "2017-03-07T15:11:08Z",
+     "email": "newuser@example.com",
+     "name": "Pat Doe",
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "role": "db_viewer",
+     "role_uids": [ 3, 4 ],
+     "auth_method": "regular"
+}
+```
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information.
+
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only works when the password_complexity feature is enabled).|
+| email_already_exists | The given email is already taken.|
+| name_already_exists | The given name is already taken.|
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, user is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | User with the same email already exists. |
+
+### Examples
+
+#### cURL
+
+```sh
+$ curl -k -X POST -u '[username]:[password]' \
+       -H 'Content-Type: application/json' \
+       -d '{ "email": "newuser@example.com", \
+           "password": "my-password", \
+           "name": "Pat Doe", \
+           "email_alerts": true, \
+           "bdbs_email_alerts": ["1","2"], \
+           "role_uids": [ 3, 4 ], \
+           "auth_method": "regular" }' \
+       'https://[host][:port]/v1/users'
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/users"
+auth = ("[username]", "[password]")
+
+payload = json.dumps({
+  "email": "newuser@example.com",
+  "password": "my-password",
+  "name": "Pat Doe",
+  "email_alerts": True,
+  "bdbs_email_alerts": [
+    "1",
+    "2"
+  ],
+  "role_uids": [
+    3,
+    4
+  ],
+  "auth_method": "regular"
+})
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+response = requests.request("POST", url, auth=auth, headers=headers, data=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete user {#delete-user}
+
+```sh
+DELETE /v1/users/{int: uid}
+```
+
+Delete a user.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_user]({{< relref "/operate/rs/7.4/references/rest-api/permissions#delete_user" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/users/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+### Response {#delete-response}
+
+Returns a status code to indicate the success or failure of the user deletion.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the user is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+---
+Title: Authorize user requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Users authorization requests
+headerRange: '[1-2]'
+linkTitle: authorize
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/users/authorize/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-authorize) | `/v1/users/authorize` | Authorize a user |
+
+## Authorize user {#post-authorize}
+
+    POST /v1/users/authorize
+
+Generate a JSON Web Token (JWT) for a user to use as authorization to access the REST API.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/users/authorize
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "user@redislabs.com",
+      "password": "my_password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [JWT authorize object]({{< relref "/operate/rs/7.4/references/rest-api/objects/jwt_authorize" >}}) with a valid username and password in the request body.
+
+### Response {#post-response}
+
+Returns a JSON object that contains the generated access token.
+
+#### Example JSON body
+
+  ```json
+  {
+      "access_token": "eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJleHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0edFzcLElMOHsshaqQk2HUNgdsUKxMU"
+  }
+  ```
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_expired | The password has expired and must be changed. |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The user is authorized. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request could not be understood by the server due to malformed syntax. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+---
+Title: Endpoints stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Endpoint statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: endpoints/stats
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/endpoints-stats/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-endpoints-stats) | `/v1/endpoints/stats` | Get stats for all endpoints |
+
+## Get all endpoints stats {#get-endpoints-stats}
+
+	GET /v1/endpoints/stats
+
+Get statistics for all endpoint-proxy links.
+
+{{<note>}}
+This method will return both endpoints and listeners stats for backwards
+compatability.
+{{</note>}}
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_endpoint_stats]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_endpoint_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/endpoints/stats?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+The `uid` format in the response is: `"BDB_UID:ENDPOINT_UID:PROXY_UID"`
+
+For example: `{"uid": "1:2:3"}` means `BDB_UID=1`, `ENDPOINT_UID=2`, and `PROXY_UID=3`
+
+#### Example JSON body
+
+```json
+[
+   {
+      "uid" : "365:1:1",
+      "intervals" : [
+         {
+            "interval" : "10sec",
+            "total_req" : 0,
+            "egress_bytes" : 0,
+            "cmd_get" : 0,
+            "monitor_sessions_count" : 0,
+            "auth_errors" : 0,
+            "acc_latency" : 0,
+            "stime" : "2017-01-12T14:59:50Z",
+            "write_res" : 0,
+            "total_connections_received" : 0,
+            "cmd_set" : 0,
+            "read_req" : 0,
+            "max_connections_exceeded" : 0,
+            "acc_write_latency" : 0,
+            "write_req" : 0,
+            "other_res" : 0,
+            "cmd_flush" : 0,
+            "acc_read_latency" : 0,
+            "other_req" : 0,
+            "conns" : 0,
+            "write_started_res" : 0,
+            "cmd_touch" : 0,
+            "read_res" : 0,
+            "auth_cmds" : 0,
+            "etime" : "2017-01-12T15:00:00Z",
+            "total_started_res" : 0,
+            "ingress_bytes" : 0,
+            "last_res_time" : 0,
+            "read_started_res" : 0,
+            "acc_other_latency" : 0,
+            "total_res" : 0,
+            "last_req_time" : 0,
+            "other_started_res" : 0
+         }
+      ]
+   },
+   {
+      "intervals" : [
+         {
+            "acc_read_latency" : 0,
+            "other_req" : 0,
+            "etime" : "2017-01-12T15:00:00Z",
+            "auth_cmds" : 0,
+            "total_started_res" : 0,
+            "write_started_res" : 0,
+            "cmd_touch" : 0,
+            "conns" : 0,
+            "read_res" : 0,
+            "total_res" : 0,
+            "other_started_res" : 0,
+            "last_req_time" : 0,
+            "read_started_res" : 0,
+            "last_res_time" : 0,
+            "ingress_bytes" : 0,
+            "acc_other_latency" : 0,
+            "egress_bytes" : 0,
+            "interval" : "10sec",
+            "total_req" : 0,
+            "acc_latency" : 0,
+            "auth_errors" : 0,
+            "cmd_get" : 0,
+            "monitor_sessions_count" : 0,
+            "read_req" : 0,
+            "max_connections_exceeded" : 0,
+            "total_connections_received" : 0,
+            "cmd_set" : 0,
+            "acc_write_latency" : 0,
+            "write_req" : 0,
+            "stime" : "2017-01-12T14:59:50Z",
+            "write_res" : 0,
+            "cmd_flush" : 0,
+            "other_res" : 0
+         }
+      ],
+      "uid" : "333:1:2"
+   }
+]
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Database actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database actions requests
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/actions/bdb/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-db-actions) | `/v1/actions/bdb/{bdb_uid}` | Get the status of a specific database's actions |
+
+## Get database actions {#get-db-actions}
+
+```
+GET /v1/actions/bdb/{bdb_uid}
+```
+
+Get the status of all currently executing, pending, or completed state-machine-related actions for a specific database. This API tracks short-lived API requests that return `action_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions/bdb/1
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | string | Unique database ID |
+
+### Response {#get-response}
+
+Returns an array of JSON objects with attributes from [actions]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}) and [state machines]({{< relref "/operate/rs/7.4/references/rest-api/objects/state-machine" >}}).
+
+Each action contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "action_uid": "8afc7f70-f3ae-4244-a5e9-5133e78b2e97",
+        "heartbeat": 1703067908,
+        "name": "SMUpdateBDB",
+        "object_name": "bdb:1",
+        "pending_ops": {},
+        "progress": 50.0,
+        "state": "proxy_policy",
+        "status": "active"
+    }
+]
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about state-machine actions |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found |
+---
+Title: Actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Actions requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/actions/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-actions) | `/v1/actions` | Get all actions |
+| [GET](#get-action) | `/v1/actions/{uid}` | Get a single action |
+
+## Get all actions {#get-all-actions}
+
+```
+GET /v1/actions
+```
+
+Get the status of all actions (executing, queued, or completed) on all entities (clusters, nodes, and databases). This API tracks long-lived API requests that return either a `task_id` or an `action_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions
+```
+
+### Response {#get-all-response}
+
+Returns a JSON array of [action objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}) and an array of [state-machine objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/state-machine" >}}).
+
+Regardless of an action’s source, each action in the response contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+{
+  "actions": [
+    {
+      "action_uid": "159ca2f8-7bf3-4cda-97e8-4eb560665c28",
+      "name": "retry_bdb",
+      "node_uid": "2",
+      "progress": "100",
+      "status": "completed",
+      "task_id": "159ca2f8-7bf3-4cda-97e8-4eb560665c28"
+    },
+    {
+      "action_uid": "661697c5-c747-41bd-ab81-ffc8fd13c494",
+      "name": "retry_bdb",
+      "node_uid": "1",
+      "progress": "100",
+      "status": "completed",
+      "task_id": "661697c5-c747-41bd-ab81-ffc8fd13c494"
+    }
+  ],
+  "state-machines": [
+    {
+      "action_uid": "a10586b1-60bc-428e-9bc6-392eb5f0d8ae",
+      "heartbeat": 1650378874,
+      "name": "SMCreateBDB",
+      "object_name": "bdb:1",
+      "progress": 100,
+      "status": "completed"
+    }
+  ]
+}
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run).|
+
+## Get a specific action {#get-action}
+
+```
+GET /v1/actions/{uid}
+```
+
+Get the status of a currently executing, queued, or completed action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions/{uid}
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | string | The action_uid to check |
+
+### Response {#get-response}
+
+Returns an [action object]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}).
+
+Regardless of an action’s source, each action contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+{
+  "action_uid": "159ca2f8-7bf3-4cda-97e8-4eb560665c28",
+  "name": "retry_bdb",
+  "node_uid": "2",
+  "progress": "100",
+  "status": "completed",
+  "task_id": "159ca2f8-7bf3-4cda-97e8-4eb560665c28"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run) |
+---
+Title: CRDB tasks requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database task status requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: crdb_tasks
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/crdb_tasks/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-crdb_task) | `/v1/crdb_tasks/{task_id}` | Get the status of an executed task |
+
+## Get task status {#get-crdb_task}
+
+	GET /v1/crdb_tasks/{task_id}
+
+Get the status of an executed task.
+
+The status of a completed task is kept for 500 seconds by default.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/crdb_tasks/1
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Result-TTL | integer | Task time to live |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| task_id | string | Task ID |
+
+### Response {#get-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/7.4/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Task status. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Task not found. |
+---
+Title: OCSP status requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP status requests
+headerRange: '[1-2]'
+linkTitle: status
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/ocsp/status/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-status) | `/v1/ocsp/status` | Get OCSP status |
+
+## Get OCSP status {#get-status}
+
+	GET /v1/ocsp/status
+
+Gets the latest cached status of the proxy certificate’s OCSP response.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ocsp_status]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_ocsp_status" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ocsp/status 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [OCSP status object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp_status" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "responder_url": "http://responder.ocsp.url.com",
+    "cert_status": "REVOKED",
+    "produced_at": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "this_update": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "next_update": "Wed, 22 Dec 2021 14:50:00 GMT",
+    "revocation_time": "Wed, 22 Dec 2021 12:50:04 GMT"
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability | 
+| invalid_ocsp_response | The server returned a response that is not OCSP-compatible |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |
+---
+Title: OCSP test requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP test requests
+headerRange: '[1-2]'
+linkTitle: test
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/ocsp/test/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-test) | `/v1/ocsp/test` | Test OCSP |
+
+## Test OCSP {#post-test}
+
+	POST /v1/ocsp/test
+
+Queries the OCSP server for the proxy certificate’s latest status and returns the response as JSON. It caches the response if the OCSP feature is enabled.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [test_ocsp_status]({{< relref "/operate/rs/7.4/references/rest-api/permissions#test_ocsp_status" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/ocsp/test 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#post-response} 
+
+Returns an [OCSP status object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp_status" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "responder_url": "http://responder.ocsp.url.com",
+    "cert_status": "REVOKED",
+    "produced_at": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "this_update": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "next_update": "Wed, 22 Dec 2021 14:50:00 GMT",
+    "revocation_time": "Wed, 22 Dec 2021 12:50:04 GMT"
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_responder_url | Tried to test OCSP status with no responder URL configured |
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability |
+| task_queued_for_too_long | OCSP polling task was in status “queued” for over 5 seconds |
+| invalid_ocsp_response | The server returned a response that is not compatible with OCSP |
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success querying the OCSP server |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature is not supported in all nodes |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | `responder_url` is not configured or polling task failed |
+---
+Title: OCSP requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: ocsp
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/ocsp/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-ocsp) | `/v1/ocsp` | Get OCSP configuration |
+| [PUT](#put-ocsp) | `/v1/ocsp` | Update OCSP configuration |
+
+## Get OCSP configuration {#get-ocsp}
+
+	GET /v1/ocsp
+
+Gets the cluster's OCSP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ocsp_config]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_ocsp_config" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ocsp 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [OCSP configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "ocsp_functionality": true,
+    "responder_url": "http://responder.ocsp.url.com",
+    "query_frequency": 3800,
+    "response_timeout": 2,
+    "recovery_frequency": 80,
+    "recovery_max_tries": 20
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability | 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |
+
+## Update OCSP configuration {#put-ocsp}
+
+	PUT /v1/ocsp
+
+Updates the cluster's OCSP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ocsp]({{< relref "/operate/rs/7.4/references/rest-api/permissions#config_ocsp" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/ocsp 
+
+#### Example JSON body
+
+```json
+{
+    "ocsp_functionality": true,
+    "query_frequency": 3800,
+    "response_timeout": 2,
+    "recovery_frequency": 80,
+    "recovery_max_tries": 20
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include an [OCSP configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [OCSP configuration object]({{< relref "/operate/rs/7.4/references/rest-api/objects/ocsp" >}}).
+
+### Error codes {#put-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| invalid_schema | An illegal parameter or a parameter with an illegal value |
+| no_responder_url | Tried to enable OCSP with no responder URL configured |
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability |
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, OCSP config has been set |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |
+---
+Title: Proxy requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Proxy requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: proxies
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/proxies/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-proxies) | `/v1/proxies` | Get all proxies |
+| [GET](#get-proxy) | `/v1/proxies/{uid}` | Get a proxy |
+| [PUT](#put-proxy) | `/v1/proxies/{uid}` | Update a proxy |
+| [PUT](#put-all-proxies) | `/v1/proxies` | Update all proxies |
+
+## Get all proxies {#get-all-proxies}
+
+```sh
+GET /v1/proxies
+```
+
+Get all the proxies in the cluster.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_proxies_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_all_proxies_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/proxies
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [proxy objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/proxy" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+         "uid": 1,
+         "client_keepintvl": 30,
+         "max_worker_server_conns": 16384,
+         "client_keepcnt": 6,
+         "max_threads": 64,
+         "ignore_bdb_cconn_output_buff_limits": false,
+         "dynamic_threads_scaling": false,
+         "max_worker_client_conns": 16384,
+         "max_servers": 4096,
+         "client_keepidle": 180,
+         "duration_usage_threshold": 30,
+         "max_worker_txns": 65536,
+         "threads": 3,
+         "max_listeners": 1024,
+         "conns": 500000,
+         "ignore_bdb_cconn_limit": false,
+         "threads_usage_threshold": 80,
+         "backlog": 1024
+    },
+    {
+        "uid": 2,
+        "threads": 3,
+        // additional fields...
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get proxy {#get-proxy}
+
+```sh
+GET /v1/proxies/{int: uid}
+```
+
+Get a single proxy's info.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_proxy_info]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_proxy_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/proxies/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The proxy's unique node ID |
+
+### Response {#get-response}
+
+Returns a [proxy object]({{< relref "/operate/rs/7.4/references/rest-api/objects/proxy" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "client_keepintvl": 30,
+     "max_worker_server_conns": 16384,
+     "client_keepcnt": 6,
+     "max_threads": 64,
+     "ignore_bdb_cconn_output_buff_limits": false,
+     "dynamic_threads_scaling": false,
+     "max_worker_client_conns": 16384,
+     "max_servers": 4096,
+     "client_keepidle": 180,
+     "duration_usage_threshold": 30,
+     "max_worker_txns": 65536,
+     "threads": 3,
+     "max_listeners": 1024,
+     "conns": 500000,
+     "ignore_bdb_cconn_limit": false,
+     "threads_usage_threshold": 80,
+     "backlog": 1024
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Proxy UID does not exist |
+
+## Update proxy {#put-proxy}
+
+```sh
+PUT /v1/proxies/{int: uid}
+```
+
+Updates a proxy object, notifies the proxy, and waits for acknowledgment (ACK) unless the node is dead.
+
+Automatically restarts the proxy service if `allow_restart` is `true` and any updated parameters require a restart for the changes to take effect. For example, a restart is required if you change `threads` to a lower number.
+
+However, if `allow_restart` is `false`, such changes only take effect after the next proxy restart.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_proxy]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_proxy" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/proxies/1
+```
+
+#### Example JSON body
+
+```json
+{
+  "allow_restart": true,
+  "proxy": {
+    "threads": 8
+  }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Request body media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated proxy. Corresponds to the node ID. |
+
+#### Request body
+
+Include a JSON object in the request body. The JSON object can contain the boolean field `allow_restart` and a [proxy object]({{< relref "/operate/rs/7.4/references/rest-api/objects/proxy" >}}) with updated fields.
+
+### Response {#put-response}
+
+Returns a status code to indicate the success or failure of the proxy update.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Proxy does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Error while waiting for confirmation from proxy |
+| [504 Gateway Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.5) | Timeout while waiting for confirmation from proxy |
+
+## Update all proxies {#put-all-proxies}
+
+```sh
+PUT /v1/proxies
+```
+
+Updates all the proxy objects, notifies the proxies, and waits for acknowledgment (ACK) unless the node is dead.
+
+Automatically restarts the relevant proxy services if `allow_restart` is `true` and any updated parameters require a restart for the changes to take effect.
+
+However, if `allow_restart` is `false`, such changes only take effect after the next proxy restart.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_proxy]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_proxy" >}}) | admin |
+
+### Request {#put-all-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/proxies
+```
+
+#### Example JSON body
+
+```json
+{
+  "allow_restart": true,
+  "proxy": {
+    "threads": 8,
+    "max_threads": 12
+  }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Request body media type |
+
+#### Request body
+
+Include a JSON object in the request body. The JSON object can contain the boolean field `allow_restart` and a [proxy object]({{< relref "/operate/rs/7.4/references/rest-api/objects/proxy" >}}) with updated fields.
+
+### Response {#put-all-response}
+
+Returns a status code to indicate the success or failure of the proxy updates.
+
+### Status codes {#put-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Error while waiting for confirmation from proxy |
+| [504 Gateway Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.5) | Timeout while waiting for confirmation from proxy |
+---
+Title: Configure module requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure module requests
+headerRange: '[1-2]'
+linkTitle: config/bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/modules/config/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-modules-config-bdb) | `/v1/modules/config/bdb/{uid}` | Configure module |
+
+## Configure module {#post-modules-config-bdb}
+
+	POST /v1/modules/config/bdb/{string: uid}
+
+Use the module runtime configuration command (if defined) to configure new arguments for the module.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/7.4/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/modules/config/bdb/1
+
+#### Example JSON body
+
+```json
+{
+  "modules": [
+    {
+      "module_name": "search",
+      "module_args": "MINPREFIX 3 MAXEXPANSIONS 1000"
+    }
+  ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list of JSON objects | List of modules (module_name) and their new configuration settings (module_args) |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name |
+| module_args | string | Module command line arguments (pattern does not allow special characters &,<,>,”) |
+
+### Response {#post-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_not_exist | Database with given UID doesn't exist in cluster | 
+| missing_field | "module_name" or "module_args" are not defined in request | 
+| invalid_schema | JSON object received is not a dict object | 
+| param_error | "module_args" parameter was not parsed properly | 
+| module_not_exist | Module with given "module_name" does not exist for the database | 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Module does not support runtime configuration of arguments. |
+---
+Title: Upgrade module requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade module requests
+headerRange: '[1-2]'
+linkTitle: upgrade/bdb
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/modules/upgrade/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-modules-upgrade-bdb) | `/v1/modules/upgrade/bdb/{uid}` | Upgrade module |
+
+## Upgrade module {#post-modules-upgrade-bdb}
+
+	POST /v1/modules/upgrade/bdb/{string: uid}
+
+Upgrades the module version on a specific database.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/7.4/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/modules/upgrade/bdb/1
+
+#### Example JSON body
+
+```json
+{
+     "modules": [
+         {"module_name": "ReJson",
+         "current_semantic_version": "2.2.1",
+         "new_module": "aa3648d79bd4082d414587c42ea0b234"}
+     ],
+     "// Optional fields to fine-tune restart and failover behavior:",
+     "preserve_roles": true,
+     "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list | List of dicts representing the modules that will be upgraded. Each dict must include: <br></br> • **current_module**: UID of a module to upgrade <br></br> • **new_module**: UID of the module we want to upgrade to <br></br> • **new_module_args**: args list for the new module |
+| preserve_roles | boolean | Preserve shards’ master/replica roles (optional) |
+| may_discard_data | boolean | Discard data in a non-replicated non-persistent database (optional) |
+
+### Response {#post-response} 
+
+Returns the upgraded [module object]({{< relref "/operate/rs/7.4/references/rest-api/objects/module" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "module_id": "aa3648d79bd4082d414587c42ea0b234",
+    "module_name": "ReJson",
+    "semantic_version": "2.2.2"
+    "// additional fields..."
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| missing_module | Module is not present in cluster.| 
+| module_downgrade_unsupported | Module downgrade is not allowed.| 
+| redis_incompatible_version | Module min_redis_version is bigger than the current Redis version.| 
+| redis_pack_incompatible_version | Module min_redis_pack_version is bigger than the current Redis Enterprise version.| 
+| unsupported_module_capabilities | New version of module does support all the capabilities needed for the database configuration| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb or node not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+---
+Title: Modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis modules requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: modules
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/requests/modules/'
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#list-modules) | `/v1/modules` | List available modules |
+| [GET](#get-module) | `/v1/modules/{uid}` | Get a specific module |
+| [POST](#post-module) | `/v1/modules` | Upload a new module (deprecated) |
+| [POST](#post-module-v2) | `/v2/modules` | Upload a new module |
+| [DELETE](#delete-module) | `/v1/modules/{uid}` | Delete a module (deprecated) |
+| [DELETE](#delete-module-v2) | `/v2/modules/{uid}` | Delete a module |
+
+## List modules {#list-modules}
+
+```sh
+GET /v1/modules
+```
+
+List available modules, i.e. modules stored within the CCS.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_modules]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_modules" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#list-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | 127.0.0.1:9443 | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+### Response {#list-response}
+
+Returns a JSON array of [module objects]({{< relref "/operate/rs/7.4/references/rest-api/objects/module" >}}).
+
+#### Status codes {#list-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get module {#get-module}
+
+```sh
+GET /v1/modules/{string: uid}
+```
+
+Get specific available modules, i.e. modules stored within the CCS.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_modules]({{< relref "/operate/rs/7.4/references/rest-api/permissions#view_cluster_modules" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | 127.0.0.1:9443 | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#get-response}
+
+Returns a [module object]({{< relref "/operate/rs/7.4/references/rest-api/objects/module" >}}).
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Module does not exist. |
+
+## Upload module v1 {#post-module}
+
+```sh
+POST /v1/modules
+```
+
+{{<note>}}
+`POST /v1/modules` is deprecated as of Redis Enterprise Software version 7.2. Use [`POST /v2/modules`](#post-module-v2) instead.
+{{</note>}}
+
+Uploads a new module to the cluster.
+
+The request must contain a Redis module, bundled using [RedisModule
+Packer](https://github.com/RedisLabs/RAMP). For modules in Redis Stack, download the module from the [download center](https://redis.io/downloads/).
+
+See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster#rest-api-method" >}}) for more information.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | string | Domain name |
+| Accept | \*/\* | Accepted media type |
+| Content-Length | integer | Length of the request body in octets |
+| Expect | 100-continue | Requires particular server behaviors |
+| Content-Type | multipart/form-data | Media type of request/response body |
+
+### Response {#post-response}
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+#### Error codes {#post-error-codes}
+
+The server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_module | Module wasn't provided or could not be found |
+| invalid_module | Module either corrupted or packaged files are wrong |
+| module_exists | Module already in system |
+| min_redis_pack_version | Module isn't supported yet in this Redis pack |
+| unsupported_module_capabilities | The module does not support required capabilities|
+| os_not_supported | This module is not supported for this operating system |
+| dependencies_not_supported | This endpoint does not support dependencies, see v2 |
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Either missing module file or an invalid module file. |
+
+### Examples
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X POST
+       -F "module=@/tmp/rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip"
+       https://[host][:port]/v1/modules
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/modules"
+
+files=[
+    ('module',
+        ('rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip',
+        open('/tmp/rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip','rb'),
+        'application/zip')
+    )
+]
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+                            auth=auth, files=files, verify=False)
+
+print(response.text)
+```
+
+## Upload module v2 {#post-module-v2}
+
+```sh
+POST /v2/modules
+```
+
+Asynchronously uploads a new module to the cluster.
+
+The request must contain a Redis module bundled using [RedisModule Packer](https://github.com/RedisLabs/RAMP).
+
+For modules in Redis Stack, download the module from the [download center](https://redis.io/downloads/#software). See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster#rest-api-method" >}}) for more information.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#post-request-v2}
+
+#### Example HTTP request
+
+```sh
+POST /v2/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | string| Domain name |
+| Accept | \*/\* | Accepted media type |
+| Content-Length | integer | Length of the request body in octets |
+| Expect | 100-continue | Requires particular server behaviors |
+| Content-Type | multipart/form-data; | Media type of request/response body |
+
+### Response {#post-response-v2}
+
+Returns a [module object]({{< relref "/operate/rs/7.4/references/rest-api/objects/module" >}}) with an additional `action_uid` field.
+
+You can use the `action_uid` to track the progress of the module upload.
+
+#### Example JSON body
+
+```json
+{
+   "action_uid":"dfc0152c-8449-4b1c-9184-480ea7cb526c",
+   "author":"RedisLabs",
+   "capabilities":[
+      "types",
+      "crdb",
+      "failover_migrate",
+      "persistence_aof",
+      "persistence_rdb",
+      "clustering",
+      "backup_restore"
+   ],
+   "command_line_args":"Plugin gears_python CreateVenv 1",
+   "config_command":"RG.CONFIGSET",
+   "dependencies":{
+      "gears_jvm":{
+         "sha256":"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+         "url":"http://example.com/redisgears_plugins/jvm_plugin/gears-jvm.linux-centos7-x64.0.1.0.tgz"
+      },
+      "gears_python":{
+         "sha256":"22dca9cd75484cb15b8130db37f5284e22e3759002154361f72f6d2db46ee682",
+         "url":"http://example.com/redisgears-python.linux-centos7-x64.1.2.1.tgz"
+      }
+   },
+   "description":"Dynamic execution framework for your Redis data",
+   "display_name":"RedisGears",
+   "email":"user@example.com",
+   "homepage":"http://redisgears.io",
+   "is_bundled":false,
+   "license":"Redis Source Available License Agreement",
+   "min_redis_pack_version":"6.0.0",
+   "min_redis_version":"6.0.0",
+   "module_name":"rg",
+   "semantic_version":"1.2.1",
+   "sha256":"2935ea53611803c8acf0015253c5ae1cd81391bbacb23e14598841e1edd8d28b",
+   "uid":"98f255d5d33704c8e4e97897fd92e32d",
+   "version":10201
+}
+```
+
+### Error codes {#post-error-codes-v2}
+
+The server may return a JSON object with `error_code` and `message` fields that provide additional information.
+
+Possible `error_code` values include [`/v1/modules` error codes](#post-error-codes) and the following:
+
+| Code | Description |
+|------|-------------|
+| invalid_dependency_data | Provided dependencies have an unexpected format |
+
+### Status codes {#post-status-codes-v2}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, scheduled module upload. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Module name or version does not exist. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Dependency not found. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get dependency. |
+
+## Delete module v1 {#delete-module}
+
+```sh
+DELETE /v1/modules/{string: uid}
+```
+
+{{<note>}}
+`DELETE /v1/modules` is deprecated as of Redis Enterprise Software version 7.2. Use [`DELETE /v2/modules`](#delete-module-v2) instead.
+{{</note>}}
+
+Delete a module.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code to indicate module deletion success or failure.
+
+#### Error codes {#delete-error-codes}
+
+| Code | Description |
+|------|-------------|
+| dependencies_not_supported | You can use the following API endpoint to delete this module with its dependencies: [`/v2/modules/<uid>`](#delete-module-v2) |
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the module is deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent module. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+
+## Delete module v2 {#delete-module-v2}
+
+```sh
+DELETE /v2/modules/{string: uid}
+```
+
+Delete a module.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/7.4/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#delete-request-v2}
+
+#### Example HTTP request
+
+```sh
+DELETE /v2/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#delete-response-v2}
+
+Returns a JSON object with an `action_uid` that allows you to track the progress of module deletion.
+
+#### Status codes {#delete-status-codes-v2}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, scheduled module deletion. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent module. |
+---
+Title: Redis Enterprise REST API requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the requests supported by the Redis Enterprise Software REST
+  API calls.
+hideListLinks: true
+linkTitle: Requests
+weight: 30
+url: '/operate/rs/7.4/references/rest-api/requests/'
+---
+
+A REST API request requires the following components:
+- [HTTP method](https://restfulapi.net/http-methods/) (`GET`, `PUT`, `PATCH`, `POST`, `DELETE`)
+- Base URL
+- Endpoint
+
+Some requests may also require:
+- URL parameters
+- [Query parameters](https://en.wikipedia.org/wiki/Query_string)
+- [JSON](http://www.json.org) request body
+- [Permissions]({{< relref "/operate/rs/7.4/references/rest-api/permissions" >}})
+
+{{< table-children columnNames="Request,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Encrypt REST API requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Encrypt requests
+weight: 30
+url: '/operate/rs/7.4/references/rest-api/encryption/'
+---
+
+## 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.
+
+Before you turn off HTTP support, be sure to migrate any scripts or proxy configurations that use HTTP to the encrypted API endpoint to prevent broken connections.
+
+To turn off HTTP support for API endpoints, run:
+
+```sh
+rladmin cluster config http_support disabled
+```
+---
+Title: REST API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the REST API available to Redis Enterprise Software deployments.
+hideListLinks: true
+weight: $weight
+url: '/operate/rs/7.4/references/rest-api/'
+---
+Redis Enterprise Software provides a REST API to help you automate common tasks.
+
+Here, you'll find the details of the API and how to use it.  
+
+For more info, see:
+
+- Supported [request endpoints]({{< relref "/operate/rs/7.4/references/rest-api/requests" >}}), organized by path
+- Supported [objects]({{< relref "/operate/rs/7.4/references/rest-api/objects" >}}), both request and response
+- Built-in roles and associated [permissions]({{< relref "/operate/rs/7.4/references/rest-api/permissions" >}})
+- [Redis Enterprise Software REST API quick start]({{< relref "/operate/rs/7.4/references/rest-api/quick-start" >}}) with examples
+
+## Authentication
+
+Authentication to the Redis Enterprise Software API occurs via [Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication). Provide your username and password as the basic auth credentials.
+
+If the username and password is incorrect or missing, the request will fail with a [`401 Unauthorized`](https://www.rfc-editor.org/rfc/rfc9110.html#name-401-unauthorized) status code.
+
+Example request using [cURL](https://curl.se/):
+
+``` bash
+curl -u "demo@redislabs.com:password" \
+    https://localhost:9443/v1/bdbs
+```
+
+For more examples, see the [Redis Enterprise Software REST API quick start]({{< relref "/operate/rs/7.4/references/rest-api/quick-start" >}}).
+
+### Permissions
+
+By default, the admin user is authorized for access to all endpoints. Use [role-based access controls]({{< relref "/operate/rs/7.4/security/access-control" >}}) and [role permissions]({{< relref "/operate/rs/7.4/references/rest-api/permissions" >}}) to manage access.
+
+If a user attempts to access an endpoint that is not allowed in their role, the request will fail with a [`403 Forbidden`](https://www.rfc-editor.org/rfc/rfc9110.html#name-403-forbidden) status code. For more details on which user roles can access certain endpoints, see [Permissions]({{< relref "/operate/rs/7.4/references/rest-api/permissions" >}}).
+
+### Certificates
+
+The Redis Enterprise Software REST API uses [Self-signed certificates]({{< relref "/operate/rs/7.4/security/certificates" >}}) to ensure the product is secure. When you use the default self-signed certificates, the HTTPS requests will fail with `SSL certificate problem: self signed certificate` unless you turn off SSL certificate verification.
+
+## Ports
+
+All calls must be made over SSL to port 9443. For the API to work, port 9443 must be exposed to incoming traffic or mapped to a different port.
+
+If you are using a [Redis Enterprise Software Docker image]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}}), run the following command to start the Docker image with port 9443 exposed:
+
+```sh
+docker run -p 9443:9443 redislabs/redis
+```
+
+## Versions
+
+All API requests are versioned in order to minimize the impact of backwards-incompatible API changes and to coordinate between different versions operating in parallel.
+
+Specify the version in the request [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier), as shown in the following table:
+
+| Request path | Description |
+|--------------|-------------|
+| POST `/v1/bdbs` | A version 1 request for the `/bdbs` endpoint. |
+| POST `/v2/bdbs` | A version 2 request for the `/bdbs` endpoint. |
+
+When an endpoint supports multiple versions, each version is documented on the corresponding endpoint.  For example, the [bdbs request]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/" >}}) page documents POST requests for [version 1]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#post-bdbs-v1" >}}) and [version 2]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/#post-bdbs-v2" >}}).
+
+## Headers
+
+### Requests
+
+Redis Enterprise REST API requests support the following HTTP headers:
+
+| Header | Supported/Required Values |
+|--------|---------------------------|
+| Accept | `application/json` |
+| Content-Length | Length (in bytes) of request message |
+| Content-Type | `application/json` (required for PUT or POST requests) |
+
+If the client specifies an invalid header, the request will fail with a [`400 Bad Request`](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) status code.
+
+### Responses
+
+Redis Enterprise REST API responses support the following HTTP headers:
+
+| Header | Supported/Required Values |
+|--------|---------------------------|
+| Content-Type | `application/json` |
+| Content-Length | Length (in bytes) of response message |
+
+## JSON requests and responses
+
+The Redis Enterprise Software REST API uses [JavaScript Object Notation (JSON)](http://www.json.org) for requests and responses. See the [RFC 4627 technical specifications](http://www.ietf.org/rfc/rfc4627.txt) for additional information about JSON.
+
+Some responses may have an empty body but indicate the response with standard [HTTP codes](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
+
+Both requests and responses may include zero or more objects.
+
+If the request is for a single entity, the response returns a single JSON object or none. If the request is for a list of entities, the response returns a JSON array with zero or more elements.
+
+If you omit certain JSON object fields from a request, they may be assigned default values, which often indicate that these fields are not in use.
+
+## Response types and error codes
+
+[HTTP status codes](https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes) indicate the result of an API request. This can be `200 OK` if the server accepted the request, or it can be one of many error codes.
+
+The most common responses for a Redis Enterprise API request are:
+
+| Response | Condition/Required handling |
+|----------|-----------------------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | The request failed, generally due to a typo or other mistake. |
+| [401 Unauthorized](https://www.rfc-editor.org/rfc/rfc9110.html#name-401-unauthorized) | The request failed because the authentication information was missing or incorrect. |
+| [403 Forbidden](https://www.rfc-editor.org/rfc/rfc9110.html#name-403-forbidden) | The user cannot access the specified [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier). |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | The [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) does not exist. |
+| [503 Service Unavailable](https://www.rfc-editor.org/rfc/rfc9110.html#name-503-service-unavailable) | The node is not responding or is not a member of the cluster. |
+| [505&nbsp;HTTP&nbsp;Version&nbsp;Not&nbsp;Supported](https://www.rfc-editor.org/rfc/rfc9110.html#name-505-http-version-not-suppor) | An unsupported `x-api-version` was used. See [versions](#versions). |
+
+Some endpoints return different response codes. The request references for these endpoints document these special cases.
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: false
+weight: 80
+url: '/operate/rs/7.4/references/'
+---
+---
+Title: Configure cluster DNS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure DNS to communicate between nodes in your cluster.
+linkTitle: Configure cluster DNS
+weight: $weight
+url: '/operate/rs/7.4/networking/cluster-dns/'
+---
+
+By default, Redis Enterprise Software deployments use DNS to communicate between nodes.  You can also use the [Discovery Service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}), which uses IP addresses to connect and complies with the [Redis Sentinel API]({{< relref "/operate/oss_and_stack/management/sentinel" >}}) supported by Redis Open Source.
+
+Each node in a Redis Enterprise cluster includes a small DNS server to manage internal functions, such as high availability, automatic failover, automatic migration, and so on.
+Nodes should only run the DNS server included with the software.  Running additional DNS servers can lead to unexpected behavior.
+
+## Cluster name and connection management
+
+Whether you're administering Redis Enterprise Software or accessing databases, there are two ways to connect:
+
+- URL-based connections - URL-based connections use DNS to resolve the fully qualified cluster domain name (FQDN).  This means that DNS records might need to be updated when topology changes, such as adding (or removing) nodes from the cluster.  
+
+    Because apps and other client connections rely on the URL (rather than the address), they do not need to be modified when topology changes.  
+
+- IP-based connections - IP-based connections do not require DNS setup, as they rely on the underlying TCP/IP addresses.  As long as topology changes do not change the address of the cluster nodes, no configuration changes are needed, DNS or otherwise.  
+
+    However, changes to IP addresses (or changes to IP address access) impact all connections to the node, including apps and clients.  IP address changes can therefore be unpredictable or time-consuming.
+
+## URL-based connections
+
+The fully qualified domain name (FQDN) is the unique cluster identifier that enables clients to connect to the different components of Redis Enterprise Software.
+The FQDN is a crucial component of the high-availability mechanism because it's used internally to enable and implement automatic and transparent failover of nodes, databases, shards, and endpoints.
+
+{{< note >}}
+Setting the cluster's FQDN is a one-time operation, one that cannot be changed after being set.
+{{< /note >}}
+
+The FQDN must always comply with the IETF's [RFC 952](https://datatracker.ietf.org/doc/html/rfc952) standard
+and section 2.1 of the [RFC 1123](https://datatracker.ietf.org/doc/html/rfc1123) standard.
+
+## Identify the cluster
+
+To identify the cluster, either use DNS to define a fully qualified domain name or use the IP addresses of each node.  
+
+### Define domain using DNS
+
+Use DNS if you:
+
+- have your own domain
+- want to integrate the cluster into that domain
+- can access and update the DNS records for that domain
+
+1. Make sure that the cluster and at least one node (preferably all nodes) in the cluster
+    are correctly configured in the DNS with the appropriate NS entries.
+
+    For example:
+
+    - Your domain is: `mydomain.com`
+    - You would like to name the Redis Enterprise Software cluster `mycluster`
+    - You have three nodes in the cluster:
+        - node1 (IP address 1.1.1.1)
+        - node2 (2.2.2.2)
+        - node3 (3.3.3.3)
+
+1. In the FQDN field, enter the value `mycluster.mydomain.com`
+    and add the following records in the DNS table for `mydomain.com`:
+
+    ``` sh
+    mycluster.mydomain.com        NS  node1.mycluster.mydomain.com
+                                      node2.mycluster.mydomain.com
+                                      node3.mycluster.mydomain.com 
+    
+    node1.mycluster.mydomain.com  A   1.1.1.1
+    
+    node2.mycluster.mydomain.com  A   2.2.2.2
+    
+    node3.mycluster.mydomain.com  A   3.3.3.3
+    ```
+
+### Zero-configuration using mDNS {#zeroconfiguration-using-mdns-development-option-only}
+
+Development and test environments can use [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS), a zero-configuration service designed for small networks.  Production environments should _not_ use mDNS.
+
+mDNS is a standard protocol that provides DNS-like name resolution and service discovery capabilities
+to machines on local networks with minimal to no configuration.
+
+Before adopting mDNS, verify that it's supported by each client you wish to use to connect to your Redis databases.  Also make sure that your network infrastructure permits mDNS/multi-casting between clients and cluster nodes.
+
+Configuring the cluster to support mDNS requires you to assign the cluster a `.local` name.
+
+For example, if you want to name the Redis Enterprise Software cluster `rediscluster`, specify the FQDN name as `rediscluster.local`.
+
+When using the DNS or mDNS option, failover can be done transparently and the DNS is updated automatically to point to the IP address of the new primary node.
+
+## IP-based connections
+
+When you use the IP-based connection option, the FQDN does not need to have any special format
+because clients use IP addresses instead of hostnames to access the databases so you are free to choose whatever name you want.
+Using the IP-based connection option does not require any DNS configuration either.
+
+To administer the cluster you do need to know the IP address of at least one of the nodes in the cluster.
+Once you have the IP address, you can simply connect to port number 8443 (for example: <https://10.0.0.12:8443>).
+However, as the topology of the cluster changes and node with the given IP address is removed,
+you need to remember the IP address of another node participating in this cluster to connect to the Cluster Manager UI and manage the cluster.
+
+Applications connecting to Redis Software databases have the same constraints.
+When using the IP-based connection method, you can use the [Discovery Service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}})
+to discover the database endpoint for a given database name as long as you have an IP address for at least one of the nodes in the cluster.
+The API used for discovery service is compliant with the Redis Sentinel API.
+
+To test your connection, try pinging the service.  For help, see [Connect to your database]({{< relref "/operate/rs/7.4/databases/connect/test-client-connectivity" >}}).
+
+---
+Title: Network port configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This document describes the various network port ranges and their uses.
+linkTitle: Network ports
+weight: $weight
+url: '/operate/rs/7.4/networking/port-configurations/'
+---
+
+All Redis Enterprise Software deployments span multiple physical/virtual nodes. You'll need to keep several ports open between these nodes. This document describes the various port ranges and their uses.
+
+{{< note >}}
+Whenever you create a new database, you must verify that the ports assigned to the new database's endpoints are open. The cluster will not perform this verification for you.
+{{< /note >}}
+
+## Ports and port ranges used by Redis Enterprise Software
+
+Redis Enterprise Software's port usage falls into three general categories:
+
+- Internal: For traffic between or within cluster nodes
+- External: For traffic from client applications or external monitoring resources
+- Active-Active: For traffic to and from clusters hosting Active-Active databases
+
+| Protocol | Port | Configurable | Connection source | Description |
+|----------|------|--------------|-------------------|-------------|
+| TCP | 8001 | <span title="Not configurable">&#x274c; No</span> | Internal, External | Traffic from application to Redis Enterprise Software [Discovery Service]({{< relref "/operate/rs/7.4/databases/durability-ha/discovery-service.md" >}}) |
+| TCP | 8000, 8070, 8071, 9090, 9125 | <span title="Not configurable">&#x274c; No</span> | Internal, External | Metrics exported and managed by the web proxy |
+| TCP | 8443 | <span title="Configurable">&#x2705; Yes</span> | Internal, External | Secure (HTTPS) access to the management web UI |
+| TCP | 9081 | <span title="Configurable">&#x2705; Yes</span> | Internal | CRDB coordinator for Active-Active management (internal) |
+| TCP | 9443 (Recommended), 8080 | <span title="Configurable">&#x2705; Yes</span> | Internal, External, Active-Active | REST API traffic, including cluster management and node bootstrap |
+| TCP | 10050 | <span title="Not configurable">&#x274c; No</span> | Internal | Zabbix monitoring |
+| TCP | 10000-10049, 10051-19999 | <span title="Configurable">&#x2705; Yes</span> | Internal, External, Active-Active | Database traffic |
+| UDP | 53, 5353 | <span title="Not configurable">&#x274c; No</span> | Internal, External | DNS/mDNS traffic |
+| ICMP | * | <span title="Not configurable">&#x274c; No</span> | Internal | Connectivity checking between nodes |
+| TCP | 1968 | <span title="Not configurable">&#x274c; No</span> | Internal | Proxy traffic |
+| TCP | 3333-3345, 36379, 36380 | <span title="Not configurable">&#x274c; No</span> | Internal | Internode communication |
+| TCP | 20000-29999 | <span title="Not configurable">&#x274c; No</span> | Internal | Database shard traffic |
+| TCP | 8002, 8004, 8006 | <span title="Configurable">&#x2705; Yes</span> | Internal | Default system health monitoring (envoy admin, envoy management server, gossip envoy admin)|
+| TCP | 8444, 9080 | <span title="Not configurable">&#x274c; No</span> | Internal | Traffic between web proxy and cnm_http/cm |
+
+## Change port configuration
+
+### Reserve ports
+
+Redis Enterprise Software reserves some ports by default (`system_reserved_ports`). To reserve other ports or port ranges and prevent the cluster from assigning them to database endpoints, configure `reserved_ports` using one of the following methods:
+
+- [rladmin cluster config]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}})
+
+    ```sh
+    rladmin cluster config reserved_ports <list of ports/port ranges>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster config reserved_ports 11000 13000-13010
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster#put-cluster" >}}) REST API request
+
+    ```sh
+    PUT /v1/cluster
+    { "reserved_ports": ["list of ports/port ranges"] }
+    ```
+
+    For example:
+
+    ```sh
+    PUT /v1/cluster
+    { "reserved_ports": ["11000", "13000-13010"] }
+    ```
+
+### Change the Cluster Manager UI port
+
+The Redis Enterprise Software Cluster Manager UI uses port 8443, by default. You can change this to a custom port as long as the new port is not in use by another process.
+
+To change this port, run:
+
+```sh
+rladmin cluster config cm_port <new-port>
+```
+
+After changing the Redis Enterprise Software web UI port, you must connect any new node added to the cluster to the UI with the custom port number:
+`https://newnode.mycluster.example.com:`**`<nonstandard-port-number>`**
+
+### Change the envoy  ports
+
+For system health monitoring, Redis uses the following ports by default:
+
+- Port 8002 for envoy admin
+
+- Port 8004 for envoy management server
+
+- Port 8006 for gossip envoy admin
+
+You can change each envoy port to a custom port using the [`rladmin cluster config`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/config" >}}) command as long as the new port is not in use by another process. When you change `envoy_admin_port`, expect a restart of envoy.
+
+To change the envoy admin port, run:
+
+```sh
+$ rladmin cluster config envoy_admin_port <new-port>
+Updating envoy_admin_port... restarting now
+```
+
+To change the envoy management server port, run:
+
+```sh
+$ rladmin cluster config envoy_mgmt_server_port <new-port>
+Cluster configured successfully
+```
+
+To change the gossip envoy admin port, run:
+
+```sh
+$ rladmin cluster config gossip_envoy_admin_port <new-port>
+Cluster configured successfully
+```
+
+### Change the REST API port
+
+For the REST API, Redis Enterprise Software uses port 9443 (secure) and port 8080 (not secure), by default. You can change this to a custom port as long as the new port is not in use by another process.
+
+To change these ports, run:
+
+```sh
+rladmin cluster config cnm_http_port <new-port>
+```
+
+```sh
+rladmin cluster config cnm_https_port <new-port>
+```
+
+### OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+
+
+### Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+
+## Configure HTTPS
+
+### Require HTTPS for API endpoints
+
+By default, the Redis Enterprise Software API supports communication over HTTP and HTTPS. However, you can turn off HTTP support to ensure that API requests are encrypted.
+
+Before you turn off HTTP support, make sure you migrate any scripts or proxy configurations that use HTTP to the encrypted API endpoint to prevent broken connections.
+
+To turn off HTTP support for API endpoints, run:
+
+```sh
+rladmin cluster config http_support disabled
+```
+
+After you turn off HTTP support, traffic sent to the unencrypted API endpoint is blocked.
+
+
+### HTTP to HTTPS redirection
+Starting with version 6.0.12, you cannot use automatic HTTP to HTTPS redirection.
+To poll metrics from the `metrics_exporter` or to access the Cluster Manager UI, use HTTPS in your request. HTTP requests won't be automatically redirected to HTTPS for those services. 
+
+## Nodes on different VLANs
+
+Nodes in the same cluster must reside on the same VLAN. If you can't
+host the nodes on the same VLAN, then you must open [all ports]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}) between them.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to enable public and private endpoints for databases on
+  a cluster.
+linkTitle: Public and private endpoints
+title: "Enable private and\_public database endpoints"
+weight: $weight
+url: '/operate/rs/7.4/networking/private-public-endpoints/'
+---
+Each node in Redis Enterprise can be configured with [private and external IP addresses]({{< relref "/operate/rs/7.4/networking/multi-ip-ipv6" >}}). By default, Redis Enterprise Software databases expose a single endpoint, e.g. cluster.com (FQDN), using the external IP addresses, making it available to the public network (e.g. the internet). Additionally, the cluster can be configured to expose a private FQDN, which utilizes the private IP addresses for access from the private network only (e.g. VPC or an internal network).
+
+When you create a cluster via the UI, you can configure it to expose private and public endpoints.
+This is common for environments such as cloud platforms and enterprises.
+
+When doing so, the cluster creates an additional FQDN, e.g. internal.cluster.com for private network (e.g. VPC or an internal network), while the cluster.com FQDN can be used by a public network (e.g. the internet).
+
+You can enable public and private endpoints during cluster creation only.
+However, you can still add an additional FQDN in a different domain (cluster.io, for example) after cluster creation.
+
+To enable private and public endpoints:
+
+1. Verify the IP addresses are bound to the server or instance.
+
+1. During cluster setup, turn on **Enable public endpoints support** in the **Cluster** screen's **Configuration** section.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/enable-public-endpoints.png" width="75%" alt="The endpoint support setting appears in the **Configuration section** of the **Cluster** setup screen." >}}
+
+    If this setting is not enabled when the cluster is created, databases on the cluster support only a single endpoint.
+
+1. Select **Next** to proceed to **Node** configuration.
+
+1. In the **Network configuration** section:
+
+    1. Configure the machine's public IP address for external traffic.
+
+    1. Configure the private IP address for both internal and external traffic so it can be used for private database endpoints.
+
+After cluster creation, both sets of endpoints are available for databases in the cluster.
+
+To view and copy public and private endpoints for a database in the cluster, see the database's **Configuration > General** section.
+
+{{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+---
+Title: Manage IP addresses
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Information and requirements for using multiple IP addresses or IPv6 addresses with Redis Enterprise Software.
+linkTitle: Manage IP addresses
+weight: $weight
+url: '/operate/rs/7.4/networking/multi-ip-ipv6/'
+---
+
+Redis Enterprise Software supports servers, instances, and VMs with
+multiple IPv4 or IPv6 addresses.
+
+## Traffic overview
+
+Redis Enterprise Software traffic is divided into internal traffic and external traffic:
+
+- "Internal traffic" refers to internal cluster communications, such as communications between the nodes for cluster management.
+
+- "External traffic" refers to communications between clients and databases and connections to the Cluster Manager UI.
+
+When only one IP address exists on a machine that serves as a Redis Enterprise node, it is used for both internal and external traffic.
+
+## Multiple IP addresses
+
+During node configuration on a machine with multiple IP addresses, you must assign one address for internal traffic and one or more other addresses for external traffic.
+
+If the cluster uses IPv4 for internal traffic, all communication between cluster nodes uses IPv4 addresses. If the cluster uses IPv6 for internal traffic, all communication between cluster nodes uses IPv6 addresses.
+
+To update IP address configuration after cluster setup, see [Change internal IP address](#change-internal-ip-address) or [Configure external IP addresses](#configure-external-ip-addresses).
+
+## Enable IPv6 for internal traffic
+
+IPv6 for internal communication is supported only for new clusters with Redis Enterprise Software version 7.4.2 or later.
+
+If the server has only IPv6 interfaces, IPv6 is automatically used for internal and external traffic. Otherwise, internal traffic uses IPv4 by default. 
+
+To use IPv6 for internal traffic on a machine with both IPv4 and IPv6 interfaces, set `use_internal_ipv6` to `true` when you create a cluster using the [bootstrap REST API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/bootstrap#post-bootstrap" >}}):
+
+```sh
+POST /v1/bootstrap/create_cluster
+{
+    "action": "create_cluster",
+    "cluster": { 
+        "name": "cluster.fqdn" 
+    },
+    "credentials": {
+       "username": "admin_username",
+       "password": "admin_password"
+    },
+    "node": {
+       "identity": {
+          "addr": "2001:DB8::/32",
+          "external_addr": ["2001:0db8:85a3:0000:0000:8a2e:0370:7334"],
+          "use_internal_ipv6": true
+       },
+    },
+    ...
+}
+```
+
+When other IPv6 nodes join a cluster that has `use_internal_ipv6` enabled, they automatically use IPv6 for internal traffic. Do not manually set `use_internal_ipv6` when joining a node to an existing IPv6 cluster, or a `NodeBootstrapError` can occur if the values do not match.
+
+If you try to add a node without an IPv6 interface to a cluster that has `use_internal_ipv6` enabled, a `NodeBootstrapError` occurs.
+
+The host file `/etc/hosts` on each node in the cluster must include the following entry:
+
+```sh
+::1 localhost
+```
+
+## Change internal IP address
+
+Before you change an internal IP address, consider the following:
+
+- Verify the address is valid and bound to an active interface on the node. Failure to do so prevents the node from coming back online and rejoining the cluster.
+
+- Joining a node that only has IPv4 network interfaces to a master node with IPv6 enabled causes a `NodeBootstrapError`.
+
+- Joining a node that only has IPv6 network interfaces to a master node that does not have IPv6 enabled causes a `NodeBootstrapError`.
+
+- You cannot change the internal address from IPv4 to IPv6 or IPv6 to IPv4 in a running cluster. You can only change the internal address within the same protocol as the cluster.
+
+If you need to update the internal IP address in the OS, one option is to remove that node from the cluster, change the IP address, and then add the node back into the cluster.
+
+Alternatively, you can use the following steps to update a node's internal IP address without removing it from the cluster:
+
+1. Turn the node into a replica using [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/node/enslave" >}}):
+
+    ```sh
+    rladmin node <ID> enslave demote_node
+    ```
+
+1. Deactivate the `rlec_supervisor` service on the node:
+
+    ```sh
+    systemctl disable rlec_supervisor 
+    ```
+
+1. Restart the node.
+
+1. Follow the operating system vendor's instructions to change the node's IP address.
+
+1. From a different cluster node, use [`rladmin node addr set`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/node/addr" >}}) to update the first node's IP address:
+
+    ```sh
+    rladmin node <ID> addr set <IP address>
+    ```
+
+1. Enable the `rlec_supervisor` service on the node:
+
+    ```sh
+    systemctl enable rlec_supervisor 
+    ```
+
+1. Restart `rlec_supervisor` or restart the node.
+
+
+    ```sh
+    systemctl start rlec_supervisor
+    ```
+
+1. Verify the node rejoined the cluster:
+
+    ```sh
+    rladmin status nodes
+    ```
+
+Repeat this procedure for other cluster nodes to change their internal IP addresses.
+
+## Configure external IP addresses
+
+You can configure external addresses that are not bound to an active interface, but are otherwise mapped or configured to route traffic to the node (such as AWS Elastic IPs or a load balancer VIP).
+
+You can use [rladmin node external_addr]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/node/external-addr" >}}) to change a node's external IP addresses.
+
+Add an external IP address:
+
+```sh
+rladmin node <ID> external_addr add <IP address>
+```
+
+Set one or more external IP addresses:
+
+```sh
+rladmin node <ID> external_addr set <IP address 1> <IP address N>
+```
+
+
+Remove an external IP address:
+
+```sh
+rladmin node <ID> external_addr remove <IP address>
+```
+
+{{< note >}}
+While [joining a new node to a
+cluster]({{< relref "/operate/rs/7.4/clusters/add-node.md" >}})
+during the node bootstrap process,
+when prompted to provide an IP of an existing node in the cluster,
+if you use the node's IP, provide the node's internal IP address.
+{{< /note >}}
+
+## Known limitations
+
+- Using IPv6 for internal traffic is supported only for new clusters running Redis Enterprise Software version 7.4.2 or later.
+
+- Changing an existing cluster's internal traffic from IPv4 to IPv6 is not supported.
+
+- All nodes must use the same protocol for internal traffic.
+
+- If a Redis Enterprise node's host machine has both IPv4 and IPv6 addresses, internal communication within the node initially uses IPv4 until the bootstrap process finishes.
+---
+Title: AWS Route53 DNS management
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure AWS Route 53 DNS
+linkTitle: AWS Route 53 DNS
+weight: $weight
+url: '/operate/rs/7.4/networking/configuring-aws-route53-dns-redis-enterprise/'
+---
+
+Redis Enterprise Software uses DNS to achieve high availability and fail-over regardless of where it is installed.
+
+
+## What is AWS Route 53?
+
+Route 53 is a scalable DNS service by Amazon Web Service (AWS). It routes user traffic to AWS resources and external sites, offering DNS health checks, traffic management, and failover capabilities. It's integral for high-availability architectures and also provides domain registration services.
+
+## Create a hosted zone
+
+Creating a hosted zone in Amazon Route 53 is a foundational step in managing your domain's DNS settings.
+
+A hosted zone functions as a container for the DNS records of a specific domain. To create one, you first need to:
+
+1. Log into the AWS Management Console
+2. Navigate to the Route 53 dashboard
+3. Select "Create Hosted Zone"
+4. Enter your domain name, and choose public hosted zone
+
+The hosted zone provides you with a set of Name Server (NS) records, which you will need to update at your domain registrar. This process effectively delegates the DNS management of your domain to Route 53, allowing you to create, update, and manage DNS records for your domain within the AWS ecosystem.
+
+{{< image filename="/images/rs/00-CreateHostedZone-en.png" >}}
+
+Once created, it will appear in the list of **Hosted zones**
+
+{{< image filename="/images/rs/03-HostedZoneSelection-en.png" >}}
+
+## Create glue records
+
+A **glue record** is a type of DNS record that helps prevent circular dependencies by providing the IP addresses of your nameservers. To create glue records in Route 53, you first need to set up a hosted zone for your domain. You will create a separate A record for each node in your Redis Enterprise cluster. The **Record name** will be a subdomain definition of the NS record you will define and the **value** should be set to the IP address of the node in your cluster.
+
+{{< image filename="/images/rs/05-NS1Configuration-en.png" >}}
+
+Once complete, it should look something like this
+
+{{< image filename="/images/rs/06-NSList-en.png" >}}
+
+
+## Create nameserver record
+
+When you create a new hosted zone in Route 53 for your domain, a set of NS records is automatically generated. These records list the nameservers assigned by Route 53 to your domain.
+
+You will need to create a new NS record which will point to the glue records created in the previous step.
+
+{{<note>}}
+It is important to make sure that the **Record Name** of the NS record equals the FQDN (Fully Qualified Domain Name) of your Redis Enterprise cluster. If not, DNS resolution will not function correctly.
+{{</note>}}
+
+{{< image filename="/images/rs/07-NSRecord-en.png" >}}
+
+
+## Validate
+
+Once all steps are completed, the configuration should look similar to this
+
+{{< image filename="/images/rs/08-FinalConfig-en.png" >}}
+
+You can test and validate your settings by using the ```dig``` command.
+
+```sh
+dig ns test.demo-rlec.redislabs.com
+
+; <<>> DiG 9.9.5-9+deb8u9-Debian <<>> ns test.demo-rlec.redislabs.com
+;; global options: +cmd
+;; Got answer:
+;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 25061
+;; flags: qr rd ra; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
+
+;; OPT PSEUDOSECTION:
+; EDNS: version: 0, flags:; udp: 4096
+;; QUESTION SECTION:
+;test.demo-rlec.redislabs.com. IN NS
+
+;; ANSWER SECTION:
+test.demo-rlec.redislabs.com. 3409 IN NS node2.test.demo-rlec.redislabs.com.
+test.demo-rlec.redislabs.com. 3409 IN NS node1.test.demo-rlec.redislabs.com.
+test.demo-rlec.redislabs.com. 3409 IN NS node3.test.demo-rlec.redislabs.com.
+
+;; Query time: 31 msec
+;; SERVER: 192.168.1.254#53(192.168.1.254)
+;; WHEN: Tue Feb 14 16:49:13 CET 2017
+;; MSG SIZE  rcvd: 120
+```
+
+You can see that the name are given a prefix of `ns-`. This answer does not come
+from *Route53* but from the cluster nameservers themselves.
+
+---
+Title: Client prerequisites for mDNS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requirements for using the mDNS protocol in development and testing environments.
+linkTitle: mDNS client prerequisites
+weight: $weight
+url: '/operate/rs/7.4/networking/mdns/'
+---
+{{< note >}}
+mDNS is only supported for development and testing environments.
+{{< /note >}}
+
+If you choose to use the mDNS protocol when [you set the cluster name]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}),
+make sure that the configurations and prerequisites for resolving database endpoints are met on the client machines.
+If you have [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}}) databases on the cluster,
+the configurations and prerequisites are also required for the Redis Enterprise Software nodes.
+
+To prepare a client or node for mDNS:
+
+1. Make sure that the clients and cluster nodes are on the same physical network
+    or have the network infrastructure configured to allow multicasting between them.
+1. Install these prerequisite packages:
+
+    - For Ubuntu:
+
+        ```sh
+        apt-get install libnss-mdns
+        ```
+
+    - For RHEL/CentOS 6.x:
+
+        ```sh
+        $ rpm -ivh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
+        $ yum install nss-mdns
+        $ service avahi-daemon start
+        ```
+
+    - For RHEL/CentOS 7:
+
+        ```sh
+        $ rpm -ivh https://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-7-12.noarch.rpm
+        $ yum install nss-mdns
+        $ service avahi-daemon start
+        ```
+
+1. If you are using [mDNS with IPv6 addresses]({{< relref "/operate/rs/7.4/networking/multi-ip-ipv6" >}}),
+    update the hosts line in `/etc/nsswitch.conf` to:
+
+    ```yaml
+    hosts: files mdns4_minimal
+    \[NOTFOUND=return\] mdns
+    ```
+---
+Title: Set up a Redis Enterprise cluster behind a load balancer
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a Redis Enterprise cluster using a load balancer instead of DNS to direct traffic to cluster nodes.
+linkTitle: Cluster load balancer setup
+weight: $weight
+url: '/operate/rs/7.4/networking/cluster-lba-setup/'
+---
+To set up a Redis Enterprise cluster in an environment that doesn't allow DNS, you can use a load balancer (LB) to direct traffic to the cluster nodes.
+
+## DNS role for databases
+
+Normally, Redis Enterprise uses DNS to provide dynamic database endpoints.
+A DNS name such as `redis-12345.clustername.domain` gives clients access to the database resource:
+
+- If multiple proxies are in use, the DNS name resolves to multiple IP addresses so clients can load balance.
+- On failover or topology changes, the DNS name is automatically updated to reflect the live IP addresses.
+
+When DNS cannot be used, clients can still connect to the endpoints with the IP addresses,
+but the benefits of load balancing and automatic updates to IP addresses won't be available.
+
+## Network architecture with load balancer
+
+You can compensate for the lack of DNS resolution with load balancers that can expose services and provide service discovery.
+A load balancer is configured in front of the Redis Enterprise cluster, exposing several logical services:
+
+- Control plane services, such as the Cluster Manager UI
+- Data plane services, such as database endpoints for client application connections
+
+Depending on which Redis Enterprise services you want to access outside the cluster, you may need to configure the load balancers separately.
+One or more virtual IPs (VIPs) are defined on the load balancer to expose Redis Enterprise services.
+The architecture is shown in the following diagram with a 3-node Redis Enterprise cluster with one database (DB1) configured on port 12000:
+
+{{< image filename="/images/rs/cluster-behind-load-balancer-top-down.png" alt="cluster-behind-load-balancer-top-down" >}}
+
+## Set up a cluster with load balancers
+
+### Prerequisites
+
+- [Install]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) the latest version of Redis Enterprise Software on your clusters
+- Configure the cluster with the cluster name (FQDN) even though DNS is not in use.
+    Remember that the same cluster name is used to issue the license keys.
+    We recommend that you use a “.local” suffix in the FQDN.
+
+### Configure load balancers
+
+- Make sure that the load balancer is performing TCP health checks on the cluster nodes.
+- Expose the services that you require through a virtual IP, for example:
+    - Cluster Manager UI on port 8443
+    - Rest API on port 9443 for secure HTTPS connections and port 8080 for HTTP
+    - Database ports 10000-19999
+
+Other ports are shown in the list of [Redis Enterprise network ports]({{< relref "/operate/rs/7.4/networking/port-configurations" >}}).
+
+{{< note >}}
+Sticky, secured connections are needed only for the Redis Enterprise Cluster Manager UI on port 8443.
+
+- Certain load balancers provide specific logic to close idle connections. Either turn off this feature or make sure the applications connecting to Redis use reconnection logic.
+- Make sure the load balancer is fast enough to resolve connections between two clusters or applications that are connected to Redis databases through a load balancer.
+- Choose the standard load balancer that is commonly used in your environment so that you have easy access to in-house expertise for troubleshooting issues.
+{{< /note >}}
+
+### Configure cluster
+
+For clusters behind load balancers, we recommend using the `all-nodes` [proxy policy]({{<relref "/operate/rs/7.4/databases/configure/proxy-policy">}}) and enabling `handle_redirects`.
+
+To allow inbound connections to be terminated on the relevant node inside the cluster, run the following `rladmin` commands on the cluster:
+
+```sh
+# Enable all-nodes proxy policy by default
+rladmin tune cluster default_sharded_proxy_policy all-nodes default_non_sharded_proxy_policy all-nodes
+
+# Redirect where necessary when behind a load balancer
+rladmin cluster config handle_redirects enabled
+```
+
+Optionally configure sparse shard placement to allow closer termination of client connections to where the Redis shard is located:
+
+```sh
+# Enable sparse placement by default
+rladmin tune cluster default_shards_placement sparse
+```
+
+### Configure database
+
+After you update the cluster settings and configure the load balancers, you can go to the Redis Enterprise Cluster Manager UI at `https://load-balancer-virtual-ip:8443/` and [create a new database]({{< relref "/operate/rs/7.4/databases/create.md" >}}).
+
+To create an Active-Active database, use the `crdb-cli` utility. See the [`crdb-cli` reference]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}) for more information about creating Active-Active databases from the command line.
+
+### Update load balancer configuration when cluster configuration changes
+
+When your Redis Enterprise cluster is behind a load balancer, you must update the load balancer when the cluster topology and IP addresses change.
+Some common cases that require you to update the load balancer are:
+
+- Adding new nodes to the Redis Enterprise cluster
+- Removing nodes from the Redis Enterprise cluster
+- Maintenance for Redis Enterprise cluster nodes
+- IP address changes for Redis Enterprise cluster nodes
+
+After these changes, make sure that the Redis connections in your applications can connect to the Redis database,
+especially if they are directly connected on IP addresses that have changed.
+
+## Intercluster communication considerations
+
+Redis Enterprise supports several topologies that allow intercluster replication, such as [Replica Of]({{< relref "/operate/rs/7.4/databases/import-export/replica-of/" >}}) and [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/" >}}) deployment options.
+When your Redis Enterprise software clusters are behind load balancers, you must allow some network services to be open and defined in the load balancers to allow the replication to work.
+
+### Replica Of
+
+For Replica Of communication to work, you must expose database ports locally in each cluster and allow these ports through any firewalls between the clusters.
+
+### Active-Active
+
+For Active-Active communication to work, you must expose several ports, including every database port and several control plane ports as defined in [Network port configurations]({{< relref "/operate/rs/7.4/networking/port-configurations" >}}). Pay attention to services that include "Active-Active" in the connection source column, and allow these ports through any firewalls between the clusters.
+---
+Title: Manage networks
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Networking features and considerations for designing your Redis Enterprise Software deployment.
+hideListLinks: false
+linktitle: Networking
+weight: 39
+url: '/operate/rs/7.4/networking/'
+---
+---
+Title: Maintenance mode for cluster nodes
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prepare a cluster node for maintenance.
+linkTitle: Maintenance mode
+weight: 60
+url: '/operate/rs/7.4/clusters/maintenance-mode/'
+---
+
+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:
+
+1. Checks whether a shut down of the node will cause quorum loss. If so, maintenance mode will not turn on.
+
+    Maintenance mode does not protect against quorum loss. If you activate maintenance mode for the majority of nodes in a cluster and restart them simultaneously, quorum is lost, which can lead to  data loss.
+
+1. If no maintenance mode snapshots already exist or if you use `overwrite_snapshot` when you activate maintenance mode, Redis Enterprise creates a new node snapshot that records the node's shard and endpoint configuration.
+
+1. Marks the node as a quorum node to prevent shards and endpoints from migrating to it.
+
+    At this point, [`rladmin status`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) displays the node's shards field in yellow, which indicates that shards cannot migrate to the node.
+
+    {{< image filename="/images/rs/maintenance_mode.png" >}}
+
+1. Migrates shards and binds endpoints to other nodes, when space is available.
+
+Maintenance mode does not demote a master node by default. The cluster elects a new master node when the original master node restarts. 
+
+Add the `demote_node` option to the `rladmin` command to [demote a master node](#demote-a-master-node) when you activate maintenance mode.
+
+To activate maintenance mode for a node, run the following command:
+
+```sh
+rladmin node <node_id> maintenance_mode on overwrite_snapshot
+```
+
+You can start server maintenance if:
+
+- All shards and endpoints have moved to other nodes
+
+- Enough nodes are still online to maintain quorum
+
+### Prevent replica shard migration
+
+If you do not have enough resources available to move all of the shards to other nodes, you can turn maintenance mode on without migrating the replica shards.
+
+Before you prevent replica shard migration during maintenance mode, consider the following effects:
+
+- Replica shards remain on the node during maintenance.
+
+- If the maintenance node fails, the master shards do not have replica shards to maintain data redundancy and high availability.
+
+- Replica shards that remain on the node can still be promoted during failover to preserve availability.
+
+To activate maintenance mode without replica shard migration, run:
+
+```sh
+rladmin node <node_id> maintenance_mode on evict_ha_replica disabled evict_active_active_replica disabled
+```
+
+### Demote a master node
+
+If maintenance might affect connectivity to the master node, you can demote the master node when you  activate maintenance mode.  This lets the cluster elect a new master node.
+
+To demote a master node when activating maintenance mode, run:
+
+```sh
+rladmin node <node_id> maintenance_mode on demote_node
+```
+
+### Verify maintenance mode activation
+
+To verify maintenance mode for a node, use `rladmin status` and review the node's shards field.  If that value is displayed in yellow (shown earlier), then the node is in maintenance mode.
+
+Avoid activating maintenance mode when it is already active.  Maintenance mode activations stack.  If you activate maintenance mode for a node that is already in maintenance mode, you will have to deactivate maintenance mode twice in order to restore full functionality.
+
+## Deactivate maintenance mode
+
+When you deactivate maintenance mode, Redis Enterprise:
+
+1. Loads a [specified node snapshot](#specify-a-snapshot) or defaults to the latest maintenance mode snapshot.
+
+1. Unmarks the node as a quorum node to allow shards and endpoints to migrate to the node.
+
+1. Restores the shards and endpoints that were in the node at the time of the snapshot.
+
+1. Deletes the snapshot.
+
+To deactivate maintenance mode after server maintenance, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off
+```
+
+By default, a snapshot is required to deactivate maintenance mode.  If the snapshot cannot be restored, deactivation is cancelled and the node remains in maintenance mode.  In such events, it may be necessary to [reset node status](#reset_node_status).
+
+### Specify a snapshot
+
+When you turn off maintenance mode, you can restore the node configuration from a maintenance mode snapshot or any snapshots previously created by [`rladmin node <node_id> snapshot create`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/node/snapshot#node-snapshot-create" >}}). If you do not specify a snapshot, Redis Enterprise uses the latest maintenance mode snapshot by default.
+
+To get a list of available snapshots, run:
+
+```sh
+rladmin node <node_id> snapshot list
+```
+
+To specify a snapshot when you turn maintenance mode off, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off snapshot_name <snapshot_name>
+```
+
+{{<note>}}
+If an error occurs when you turn on maintenance mode, the snapshot is not deleted.
+When you rerun the command, use the snapshot from the initial attempt since it contains the original state of the node.
+{{</note>}}
+
+### Skip shard restoration
+
+You can prevent the migrated shards and endpoints from returning to the original node after you turn off maintenance mode.
+
+To turn maintenance mode off and skip shard restoration, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off skip_shards_restore
+```
+
+### Reset node status
+
+In extreme cases, you may need to reset a node's status.  Run the following commands to do so:
+
+```
+$ rladmin tune node <node_id> max_listeners 100
+$ rladmin tune node <node_id> quorum_only disabled
+```
+
+Use these commands with caution.  For best results, contact Support before running these commands.
+
+## Cluster status example
+
+This example shows how the output of [`rladmin status`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) changes when you turn on maintenance mode for a node.
+
+The cluster status before turning on maintenance mode:
+
+```sh
+redislabs@rp1_node1:/opt$ rladmin status
+CLUSTER NODES:
+NODE:ID   ROLE     ADDRESS       EXTERNAL_ADDRESS     HOSTNAME    SHARDS
+*node:1   master   172.17.0.2                         rp1_node1   2/100
+node:2    slave    172.17.0.4                         rp3_node1   2/100
+node:3    slave    172.17.0.3                         rp2_node1   0/100
+```
+
+The cluster status after turning on maintenance mode:
+
+```sh
+redislabs@rp1_node1:/opt$ rladmin node 2 maintenance_mode on
+Performing maintenance_on action on node:2: 0%
+created snapshot NodeSnapshot<name=maintenance_mode_2019-03-14_09-50-59,time=None,node_uid=2>
+
+node:2 will not accept any more shards
+Performing maintenance_on action on node:2: 100%
+OK
+redislabs@rp1_node1:/opt$ rladmin status
+CLUSTER NODES:
+NODE:ID   ROLE     ADDRESS       EXTERNAL_ADDRESS     HOSTNAME    SHARDS
+*node:1   master   172.17.0.2                         rp1_node1   2/100
+node:2    slave    172.17.0.4                         rp3_node1   0/0
+node:3    slave    172.17.0.3                         rp2_node1   2/100
+```
+
+After turning on maintenance mode for node 2, Redis Enterprise saves a snapshot of its configuration and then moves its shards and endpoints to node 3.
+
+Now node 2 has `0/0` shards because shards cannot migrate to it while it is in maintenance mode.
+
+## Maintenance mode REST API
+
+You can also turn maintenance mode on or off using [REST API requests]({{< relref "/operate/rs/7.4/references/rest-api" >}}) to [<nobr>POST `/nodes/{node_uid}/actions/{action}`</nobr>]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/actions#post-node-action" >}}).
+
+### Activate maintenance mode (REST API)
+
+Use <nobr>`POST /nodes/{node_uid}/actions/maintenance_on`</nobr> to activate maintenance mode:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_on
+{
+    "overwrite_snapshot": true,
+    "evict_ha_replica": true,
+    "evict_active_active_replica": true
+}
+```
+
+You can set `evict_ha_replica` and `evict_active_active_replica` to `false` to [prevent replica shard migration](#prevent-replica-shard-migration).
+
+The `maintenance_on` request returns a JSON response body:
+
+```json
+{
+    "status":"queued",
+    "task_id":"<task-id-guid>"
+}
+```
+
+### Deactivate maintenance mode (REST API)
+
+Use <nobr>`POST /nodes/{node_uid}/actions/maintenance_off`</nobr> deactivate maintenance mode:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_off
+{ "skip_shards_restore": false }
+```
+
+The `skip_shards_restore` boolean flag allows the `maintenance_off` action to [skip shard restoration](#skip-shard-restoration) when set to `true`.
+
+The `maintenance_off` request returns a JSON response body:
+
+```json
+{
+    "status":"queued",
+    "task_id":"<task-id-guid>"
+}
+```
+
+### Track action status
+
+You can send a request to [<nobr>GET `/nodes/{node_uid}/actions/{action}`</nobr>]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/actions#get-node-action" >}}) to track the [status]({{< relref "/operate/rs/7.4/references/rest-api/objects/action" >}}) of the `maintenance_on` and `maintenance_off` actions.
+
+This request returns the status of the `maintenance_on` action:
+
+```sh
+GET https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_on
+```
+
+The response body:
+
+```json
+{
+    "status":"completed",
+    "task_id":"38c7405b-26a7-4379-b84c-cab4b3db706d"
+}
+```
+---
+Title: Recover a failed cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to use the cluster configuration file and database data to recover
+  a failed cluster.
+linktitle: Recover a cluster
+weight: 70
+url: '/operate/rs/7.4/clusters/cluster-recovery/'
+---
+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]({{< relref "/operate/kubernetes/re-clusters/cluster-recovery" >}}).
+{{< /note >}}
+
+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]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+The cluster recovery process includes:
+
+1. Install Redis Enterprise Software on the nodes of the new cluster.
+1. Mount the persistent storage with the recovery files from the original cluster to the nodes of the new cluster.
+1. Recover the cluster configuration on the first node in the new cluster.
+1. Join the remaining nodes to the new cluster.
+1. [Recover the databases]({{< relref "/operate/rs/7.4/databases/recover.md" >}}).
+
+## Prerequisites
+
+- We recommend that you recover the cluster to clean nodes.
+    If you use the original nodes,
+    make sure there are no Redis processes running on any nodes in the new cluster.
+- We recommend that you use clean persistent storage drives for the new cluster.
+    If you use the original storage drives,
+    make sure you back up the files on the original storage drives to a safe location.
+- Identify the cluster configuration file that you want to use as the configuration for the recovered cluster.
+    The cluster configuration file is `/ccs/ccs-redis.rdb` on the persistent storage for each node.
+
+## Recover the cluster
+
+1. (Optional) If you want to recover the cluster to the original cluster nodes, uninstall Redis Enterprise Software from the nodes.
+
+1. [Install Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}) on the new cluster nodes.
+
+    The new servers must have the same basic hardware and software configuration as the original servers, including:
+
+    - The same number of nodes
+    - At least the same amount of memory
+    - The same Redis Enterprise Software version
+    - The same installation user and paths
+
+    {{< note >}}
+The cluster recovery can fail if these requirements are not met.
+    {{< /note >}}
+
+1. Mount the persistent storage drives with the recovery files to the new nodes.
+    These drives must contain the cluster configuration backup files and database persistence files.
+
+    {{< note >}}
+Make sure that the user redislabs has permissions to access the storage location
+of the configuration and persistence files on each of the nodes.
+    {{< /note >}}
+
+    If you use local persistent storage, place all of the recovery files on each of the cluster nodes.
+
+1. To recover the original cluster configuration, run [`rladmin cluster recover`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/recover" >}}) on the first node in the new cluster:
+
+    ```sh
+    rladmin cluster recover filename [ <persistent_path> | <ephemeral_path> ]<filename> node_uid <node_uid> rack_id <rack_id>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster recover filename /tmp/persist/ccs/ccs-redis.rdb node_uid 1 rack_id 5
+    ```
+
+    When the recovery command succeeds,
+    this node is configured as the node from the old cluster that has ID 1.
+
+1. To join the remaining servers to the new cluster, run [`rladmin cluster join`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/join" >}}) from each new node:
+
+    ```sh
+    rladmin cluster join nodes <cluster_member_ip_address> username <username> password <password> replace_node <node_id>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster join nodes 10.142.0.4 username admin@example.com password mysecret replace_node 2
+    ```
+
+1. Run [`rladmin status`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) to verify the recovered nodes are now active and the databases are pending recovery:
+
+    ```sh
+    rladmin status
+    ```
+
+    {{< note >}}
+Make sure that you update your [DNS records]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}})
+with the IP addresses of the new nodes.
+    {{< /note >}}
+
+After the cluster is recovered, you must [recover the databases]({{< relref "/operate/rs/7.4/databases/recover.md" >}}).
+---
+Title: "Redis OSS Cluster API"
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Use the Redis OSS Cluster API to improve performance and keep applications current with cluster topology changes.
+linktitle: "Redis OSS Cluster API"
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/oss-cluster-api/'
+---
+{{< embed-md "oss-cluster-api-intro.md"  >}}
+
+You can use the Redis OSS Cluster API along with other Redis Enterprise Software high availability
+to get high performance with low latency
+and let applications stay current with cluster topology changes, including add node, remove node, and node failover.
+
+For more about working with the OSS Cluster API in Redis Enterprise Software, see [Enable OSS Cluster API]({{< relref "/operate/rs/7.4/databases/configure/oss-cluster-api" >}}). 
+
+To learn how to enable OSS Cluster API in Redis Cloud, see [Clustering Redis databases]({{< relref "/operate/rc/databases/configuration/clustering#cluster-api" >}}).
+---
+Title: Turn off services to free system memory
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turn off services to free memory and improve performance.
+linktitle: Free system memory
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/turn-off-services/'
+---
+The Redis Enterprise Software cluster nodes host a range of services that support the cluster processes.
+In most deployments, either all of these services are required,
+or there are enough memory resources on the nodes for the database requirements.
+
+In a deployment with limited memory resources, certain services can be disabled from API endpoint to free system memory or using the `rladmin` command.
+Before you turn off a service, make sure that your deployment does not depend on that service.
+After you turn off a service, you can re-enable in the same way.
+
+The services that you can turn off are:
+
+- RS Admin Console - `cm_server`
+- Logs in CSV format - `stats_archiver`
+- [LDAP authentication]({{< relref "/operate/rs/7.4/security/access-control/ldap" >}}) - `saslauthd`
+- [Discovery service]({{< relref "/operate/rs/7.4/networking/cluster-dns.md" >}})- `mdns_server`, `pdns_server`
+- [Active-Active databases]({{< relref "/operate/rs/7.4/databases/active-active" >}}) - `crdb_coordinator`, `crdb_worker`
+- Alert Manager - `alert_mgr` (For best results, disable only if you have an alternate alert system.)
+
+To turn off a service with the `rladmin cluster config` command, use the `services` parameter and the name of the service, followed by `disabled`.
+```text
+ rladmin cluster config
+        [ services <service_name> <enabled | disabled> ]
+```
+
+To turn off a service with the API, use the [`PUT /v1/services_configuration`]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/services_configuration#put-cluster-services_config" >}}) endpoint
+with the name of the service and the operating mode (enabled/disabled) in JSON format.
+
+For example:
+- To turn off the Redis Enterprise Cluster Manager UI, use this PUT request:
+
+    ```sh
+    PUT https://[host][:9443]/v1/cluster/services_configuration
+    '{
+        "cm_server":{
+            "operating_mode":"disabled"
+        }
+    }'
+    ```
+
+- To turn off the CRDB services and enable the `stats_archiver` for cluster component statistics, use this PUT request:
+
+    ```sh
+    PUT https://[host][:9443]/v1/cluster/services_configuration
+    '{
+        "crdb_coordinator":{
+            "operating_mode":"disabled"
+        },
+        "crdb_worker":{
+            "operating_mode":"disabled"
+        },
+        "stats_archiver":{
+            "operating_mode":"enabled"
+        }
+    }'
+    ```
+---
+Title: Benchmarking Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use the `memtier_benchmark` tool to perform a performance benchmark of
+  Redis Enterprise Software.
+linkTitle: Benchmark
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/memtier-benchmark/'
+---
+
+Use the `memtier_benchmark` tool to perform a performance benchmark of Redis Enterprise Software.
+
+Prerequisites:
+
+- Redis Enterprise Software installed
+- A cluster configured
+- A database created
+
+For help with the prerequisites, see the [Redis Enterprise Software quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}).
+
+It is recommended to run memtier_benchmark on a separate node that is
+not part of the cluster being tested. If you run it on a node of the
+cluster, be mindful that it affects the performance of both the
+cluster and memtier_benchmark.
+
+```sh
+/opt/redislabs/bin/memtier_benchmark -s $DB_HOST -p $DB_PORT -a $DB_PASSWORD -t 4 -R --ratio=1:1
+```
+
+This command instructs memtier_benchmark to connect to your Redis
+Enterprise database and generates a load doing the following:
+
+- A 50/50 Set to Get ratio
+- Each object has random data in the value
+
+## Populate a database with testing data
+
+If you need to populate a database with some test data for a proof of
+concept, or failover testing, etc. here is an example for you.
+
+```sh
+/opt/redislabs/bin/memtier_benchmark -s $DB_HOST -p $DB_PORT -a $DB_PASSWORD -R -n allkeys -d 500 --key-pattern=P:P --ratio=1:0
+```
+
+This command instructs memtier_benchmark to connect to your Redis
+Enterprise database and generates a load doing the following:
+
+- Write objects only, no reads
+- A 500 byte object
+- Each object has random data in the value
+- Each key has a random pattern, then a colon, followed by a
+    random pattern.
+
+Run this command until it fills up your database to where you want it
+for testing. The easiest way to check is on the database metrics page.
+
+{{< image filename="/images/rs/memtier_metrics_page.png" >}}
+
+Another use for memtier_benchmark is to populate a database with data
+for failure testing.
+---
+Title: Disk sizing for heavy write scenarios
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sizing considerations for persistent disk space for heavy throughput
+  databases.
+linktitle: Disk sizing
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/disk-sizing-heavy-write-scenarios/'
+---
+In extreme write scenarios, when AOF is enabled, the AOF rewrite process
+may require considerably more disk space for database persistence.
+
+To estimate the required persistent disk space in such cases, use the
+formula described below.
+
+**The required persistent disk space for AOF rewrite purposes in extreme
+write scenarios, assuming identical shard sizes:**
+
+**X (1 + 3Y +Y²)**
+where:
+**X** = each shard size
+**Y** = number of shards
+
+Following are examples of database configurations and the persistence
+disk space they would require in this scenario:
+
+|   | Example 1 | Example 2 | Example 3 | Example 4 |
+|---|------------|-----------------|------------|-----------------|
+| Database size (GB) | 10 | 10 | 40 | 40 |
+| Number of shards | 4 | 16 | 5 | 15 |
+| Shard size (GB) | 2.5 | 0.625 | 8 | 2.67 |
+| Required disk space (GB) | 73 | 191 | 328 | 723 |
+
+For disk size requirements in standard usage scenarios, refer to the
+[Hardware
+requirements]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})
+section.
+---
+Title: Cluster environment optimization
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Optimize your cluster environments for better performance.
+linktitle: Environment optimization
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/optimization/'
+---
+Redis Enterprise Software uses various algorithms to optimize
+performance. As part of this process, Redis Enterprise Software examines usage
+and load to adjust its runtime configuration. Depending
+on your specific usage and load, Redis Enterprise Software might take some
+time to adjust for optimal performance.
+
+To ensure optimal performance, you must run your workload several times
+and for a long duration until performance stabilizes.
+
+## Failure detection sensitivity policies
+
+You can optimize your cluster's thresholds and timeouts for different environments using the `failure_detection_sensitivity` cluster policy:
+
+- `high` (previously known as `local-network watchdog_profile`) – high failure detection sensitivity, lower thresholds, and faster failure detection and failover
+
+- `low` (previously known as `cloud watchdog_profile`) – low failure detection sensitivity and higher tolerance for latency variance (also called network jitter)
+
+Depending on which policy you choose, Redis Enterprise Software uses different
+thresholds to make operation-related decisions.
+
+The default policy is `high` failure detection sensitivity for `local-network` environments. If you are
+running Redis Enterprise in a cloud environment, you should change the
+configuration.
+
+## Change failure detection sensitivity
+
+To change the cluster's `failure_detection_sensitivity`, run one of the following [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/tune#tune-cluster" >}}) commands.
+
+- For Redis Enterprise Software version 6.4.2-69 and later, run:
+
+    ```sh
+    rladmin tune cluster failure_detection_sensitivity [ low | high ]
+    ```
+
+- For Redis Enterprise Software version 6.4.2-61 and earlier, run:
+
+    ```sh
+    rladmin tune cluster watchdog_profile [ cloud | local-network ]
+    ```
+
+If Redis Enterprise Software still
+does not meet your performance expectations after following these instructions, [contact support](https://redis.com/company/support/) for help optimizing your environment.
+---
+Title: Use the WAIT command to improve data safety and durability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use the wait command to take full advantage of Redis Enterprise Software's
+  replication-based durability.
+linkTitle: WAIT command
+weight: $weight
+url: '/operate/rs/7.4/clusters/optimize/wait/'
+---
+Redis Enterprise Software comes with the ability to replicate data
+to another replica for high availability and persist in-memory data on
+disk permanently for durability. With the [`WAIT`]({{<relref "/commands/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:
+
+1. Application issues a write.
+1. Proxy communicates with the correct primary shard in the system that contains the given key.
+1. The acknowledgment is sent to proxy after the write operation completes.
+1. The proxy sends the acknowledgment back to the application.
+
+Independently, the write is communicated from the primary shard to the replica, and
+replication acknowledges the write back to the primary shard. These are steps 5 and 6.
+
+Independently, the write to a replica is also persisted to disk and
+acknowledged within the replica. These are steps 7 and 8.
+
+{{< image filename="/images/rs/weak-consistency.png" >}}
+
+## Blocking write operation on replication
+
+With the [`WAIT`]({{<relref "/commands/wait">}}) or [`WAITAOF`]({{<relref "/commands/waitaof">}}) commands, applications can ask to wait for
+acknowledgments only after replication or persistence is confirmed on
+the replica. The flow of a write operation with `WAIT` or `WAITAOF` is:
+
+1. The application issues a write.
+1. The proxy communicates with the correct primary shard in the system that contains the given key.
+1. Replication communicates the update to the replica shard.
+1. If using `WAITAOF` and the AOF every write setting, the replica persists the update to disk before sending the acknowledgment.
+1. The acknowledgment is sent back from the replica all the way to the proxy with steps 5 to 8.
+
+The application only gets the acknowledgment from the write after durability is achieved with replication to the replica for `WAIT` or `WAITAOF` and to the persistent storage for `WAITAOF` only.
+
+{{< image filename="/images/rs/strong-consistency.png" >}}
+
+The `WAIT` command always returns the number of replicas that acknowledged the write commands sent by the current client before the `WAIT` command, both in the case where the specified number of replicas are reached, or when the timeout is reached. In Redis Enterprise Software, the number of replicas is always 1 for databases with high availability enabled.
+
+See the [`WAITAOF`]({{<relref "/commands/waitaof">}}) command for details for enhanced data safety and durability capabilities introduced with Redis 7.2.
+---
+Title: Optimize clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configuration changes and information you can use to optimize your performance
+  and memory usage.
+hideListLinks: false
+linktitle: Optimize
+weight: 50
+url: '/operate/rs/7.4/clusters/optimize/'
+---
+---
+Title: Rack-zone awareness in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Rack-zone awareness ensures high availability in the event of a rack
+  or zone failure.
+linkTitle: Rack-zone awareness
+weight: 70
+url: '/operate/rs/7.4/clusters/configure/rack-zone-awareness/'
+---
+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](#rack-zone-id-rules) to each node. This ID is used to map the node to a
+physical rack or logical zone. The cluster can then ensure that master shards, corresponding replica shards, and associated endpoints are placed on [nodes in different racks or zones](#node-layout-guidelines).
+
+In the event of a rack or zone failure, the replicas and endpoints in the remaining racks and zones are promoted. This ensures high availability when a rack or zone fails.
+
+There is no limitation on the number of racks and zones per cluster. Each
+node can belong to a different rack or multiple nodes can belong to the
+same rack.
+
+Rack-zone awareness affects various cluster, node, and database actions, such as node rebalancing, node removal, node replacement, shard and endpoint migration, and database failover.
+
+## Rack-zone ID rules
+
+The rack-zone ID must comply with the following rules:
+
+- Maximum length of 63 characters.
+- Characters consist of letters, digits, and hyphens ('-'). Underscores ('_') are also accepted as of Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}).
+- ID starts with a letter and ends with a letter or a digit.
+
+{{< note >}}
+Rack-zone IDs are **case-insensitive** (uppercase and lowercase letter are treated as the same).
+{{< /note >}}
+
+## Node layout guidelines
+
+Avoid placing the majority of nodes in one availability zone.
+
+If a Redis Enterprise Software cluster consists of three nodes (the recommended minimum), follow these guidelines:
+
+- For high availability, the three nodes must be distributed across three *distinct* racks or zones.
+
+- When using availability zones, all three zones should exist within the same *region* to avoid potential latency issues.
+
+## Set up rack-zone awareness
+
+To enable rack-zone awareness, you need to configure it for the
+cluster, nodes, and [databases](#enable-database-rack-zone-awareness).
+
+### New cluster
+
+You can set up rack-zone awareness for the cluster and its nodes during [cluster creation]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup" >}}):
+
+1. In the **Cluster** screen's **Configuration** section, enable **Rack zone awareness**.
+
+1. Select **Next** to continue to the **Node** configuration screen.
+
+1. Enter a **Rack-zone ID** for the current node.
+
+1. Finish [cluster setup]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup" >}}).
+
+1. For every [node you add to the cluster]({{< relref "/operate/rs/7.4/clusters/add-node" >}}), assign a different **Rack-zone ID**.
+
+### Existing cluster
+
+If you did not configure rack-zone awareness during cluster creation, you can configure rack-zone awareness for existing clusters using the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}):
+
+1. For each node in the cluster, assign a different rack-zone ID using the REST API to [update the node]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes#put-node" >}}):
+
+    ```sh
+    PUT /v1/nodes/<node-ID>
+    { "rack_id": "rack-zone-ID" }
+    ```
+
+1. [Update the cluster policy]({{< relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) to enable rack-zone awareness:
+
+    ```sh
+    PUT /v1/cluster/policy
+    { "rack_aware": true }
+    ```
+
+## Enable database rack-zone awareness
+
+Before you can enable rack-zone awareness for a database, you must configure rack-zone awareness for the cluster and its nodes. For more information, see [set up rack-zone awareness](#set-up-rack-zone-awareness).
+
+<!--
+To enable rack-zone awareness for a database using the Cluster Manager UI:
+
+1. From **databases**, [create a new database]({{< relref "/operate/rs/7.4/databases/create" >}}) or edit an existing database's **configuration**.
+
+1. Expand the **High availability & durability** section.
+
+1. Enable [**Replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}).
+
+1. Select **Rack-zone awareness**.
+
+    {{<image filename="images/rs/screenshots/databases/config-rack-zone-awareness.png" alt="Select the Rack-zone awareness checkbox to enable rack-zone awareness for the database." >}}
+
+1. **Create** or **Save** your database.
+
+1. [Rearrange database shards](#rearrange-database-shards) to optimize an existing database for rack-zone awareness.
+
+    {{<note>}}
+If you enabled rack-zone awareness during database creation, you can ignore this step.
+    {{</note>}}
+-->
+
+To enable rack-zone awareness for a database, use a [REST API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs#put-bdbs" >}}):
+
+```sh
+PUT /v1/bdbs/<database-ID>
+{ "rack_aware": true }
+```
+
+### Rearrange database shards
+
+After you enable rack-zone awareness for an existing database, you should generate an optimized shard placement blueprint using the [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) and use it to rearrange the shards in different racks or zones.
+
+1. [Generate an optimized shard placement blueprint]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions/optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}):
+
+    1. Send the following `GET` request:
+
+        ```sh
+        GET /v1/bdbs/<database-ID>/actions/optimize_shards_placement
+        ```
+
+    1. Copy the `cluster-state-id` from the response headers.
+
+    1. Copy the JSON response body, which represents the new shard placement blueprint.
+
+1. [Rearrange the database shards]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs/actions/optimize_shards_placement#put-bdbs-rearrange-shards" >}}) according to the new shard placement blueprint:
+
+    1. In the request headers, include the <nobr>`cluster-state-id`</nobr> from the `optimize_shards_placement` response.
+
+    1. Add the following JSON in the request body and replace <nobr>`<shard placement blueprint>`</nobr> with the new blueprint:
+
+        ```sh
+        {
+          "shards_blueprint": <shard placement blueprint>
+        }
+        ```
+
+    1. Send the following `PUT` request to rearrange the shards:
+
+        ```sh
+        PUT /v1/bdbs/<database-ID>
+        ```
+
+## Shard placement without rack-zone awareness
+
+Even if a database has rack-zone awareness turned off, the cluster still ensures that master and replica shards are placed on distinct nodes.
+---
+Title: Cluster settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: You can view and set various cluster settings such as cluster name, email
+  service, time zone, and license.
+linktitle: Cluster settings
+toc: 'true'
+weight: 10
+url: '/operate/rs/7.4/clusters/configure/cluster-settings/'
+---
+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]({{< relref "/operate/rs/7.4/clusters/configure/license-keys.md" >}}).
+
+### View max number of allowed shards
+
+The maximum number of allowed shards, which is determined by the cluster license
+key, appears in the **Max number of shards** field in the **License** section.
+
+### View cluster name
+
+The cluster name appears in the **Cluster name** field in the **License** section. This gives a
+common name that your team or Redis support can refer to. It is
+especially helpful if you have multiple clusters.
+
+### Set time zone
+
+You can change the **Time zone** field to ensure the date, time fields, and log entries in the Cluster Manager UI are shown in your preferred time zone. This setting doesn't affect other system logs or services.
+
+## Alert settings tab
+
+The **Alert Settings** tab lets you configure alerts that are relevant to the entire cluster, such as alerts for cluster utilization, nodes, node utilization, security, and database utilization.
+
+You can also configure email server settings and [send alerts by email]({{< relref "/operate/rs/7.4/clusters/monitoring#send-alerts-by-email" >}}) to relevant users.
+
+### Configure email server settings
+
+To enable email alerts:
+
+1. Enter your email
+server details in the **Email server settings** section.
+
+1. Select a connection security method:
+
+    - TLS/SSL 
+
+    - STARTTLS
+    
+    - None
+
+1. Send a test email to verify your email server settings.
+---
+Title: Configure clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configuration options for your Redis Enterprise cluster.
+hideListLinks: false
+linktitle: Configure
+weight: 50
+url: '/operate/rs/7.4/clusters/configure/'
+---
+You can manage your Redis Enterprise Software clusters with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([rladmin]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}), [redis-cli]({{< relref "/develop/tools/cli" >}}), [crdb-cli]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/7.4/references/rest-api/_index.md" >}})
+
+
+
+---
+Title: Cluster license keys
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The cluster key (or license) enables features and capacity within Redis
+  Enterprise Software
+linktitle: License keys
+weight: 20
+url: '/operate/rs/7.4/clusters/configure/license-keys/'
+---
+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.
+
+Trial mode is limited to 30 days and 4 shards, including master and replica shards. A new Redis Enterprise Software installation starts its 30-day trial period from the day you set up the cluster on the first node.
+
+Trial mode requires a trial license. If you do not provide a license when you create a cluster using the Cluster Manager UI or a [bootstrapping REST API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/bootstrap#post-bootstrap" >}}), a trial cluster license is generated by default.
+
+## View cluster license key
+
+To view the cluster license key, use:
+
+- Cluster Manager UI
+
+    1. Go to **Cluster > Configuration > General > License** to see the cluster license details.
+
+    1. Select **Change** to view the cluster license key.
+
+- REST API - [`GET /v1/license`]({{< relref "/operate/rs/7.4/references/rest-api/requests/license#get-license" >}})
+
+    For a list of returned fields, see the [response section]({{< relref "/operate/rs/7.4/references/rest-api/requests/license#get-response" >}}).
+
+{{<note>}}
+As of version 7.2, Redis Enterprise enforces shard limits by shard types, RAM or flash, instead of the total number of shards. The flash shards limit only appears in the UI if Auto Tiering is enabled.
+{{</note>}}
+
+## Update cluster license
+
+{{< note >}}
+After you add a cluster key, you cannot remove the key to return the cluster to trial mode.
+{{< /note >}}
+
+You can update the cluster license key:
+
+- During cluster setup using the Cluster Manager UI or CLI
+
+- After cluster setup using the Cluster Manager UI:
+
+    1. Go to **Cluster > Configuration > General > License**.
+    
+    1. Select **Change**.
+
+    1. Upload or enter your cluster license key.
+    
+    1. Select **Save**.
+
+You can update an existing cluster key at any time.
+Redis Enterprise checks its validity for the following:
+- Cluster name
+- Activation and expiration dates
+- Shard usage and limits
+- Features
+
+If saving a new cluster key fails, the operation returns an error with the failure's cause.
+In this case, the existing key stays in effect.
+
+## Expired cluster license
+
+When the license is expired:
+
+- You cannot do these actions:
+
+    - Change database settings, including security and configuration options.
+
+    - Add a database.
+
+- You can do these actions:
+
+    - Sign in to the Cluster Manager UI and view settings and metrics at all resolutions for the cluster, nodes, and databases.
+
+    - Change cluster settings, including the license key, security for administrators, and cluster alerts.
+
+    - Fail over when a node fails and explicitly migrate shards between nodes.
+
+    - Upgrade a node to a new version of Redis Enterprise Software.
+ 
+## Monitor cluster license
+
+As of version 7.2, Redis Enterprise exposes the license quotas and the shards consumption metrics in the Cluster Manager UI or via the [Prometheus integration]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}).
+
+The `cluster_shards_limit` metric displays the total shard limit by shard type.
+
+Examples:
+- `cluster_shards_limit{cluster="mycluster.local",shard_type="ram"} 100.0`
+- `cluster_shards_limit{cluster="mycluster.local",shard_type="flash"} 50.0`
+
+The `bdb_shards_used` metric displays the used shard count by database and shard type.
+
+Examples:
+- `bdb_shards_used{bdb="2",cluster="mycluster.local",shard_type="ram"} 86.0`
+- `bdb_shards_used{bdb="3",cluster="mycluster.local",shard_type="flash"} 23.0`
+
+---
+Title: Synchronize cluster node clocks
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sync node clocks to avoid problems with internal custer communication.
+linktitle: Sync node clocks
+weight: 30
+url: '/operate/rs/7.4/clusters/configure/sync-clocks/'
+---
+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.
+
+To synchronize the server clock, run the command that is appropriate for your operating system.
+
+## Set up NTP synchronization
+
+To set up NTP synchronization, see the following sections for instructions for specific operating systems.
+
+### Ubuntu 18.04 and Ubuntu 20.04
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo apt install chrony
+   ```
+   
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Restart the Chrony service: 
+   ```sh
+   sudo systemctl restart chrony
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chrony
+   ```
+   
+For more details, refer to the official [Ubuntu 20.04 documentation](https://ubuntu.com/server/docs/network-ntp).
+
+### RHEL 7
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+    sudo yum install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh 
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [RHEL 7 documentation](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/system_administrators_guide/ch-configuring_ntp_using_the_chrony_suite#sect-Using_chrony).
+
+### RHEL 8 and RHEL 9
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo dnf install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [RHEL 8 and 9 documentation](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_basic_system_settings/configuring-time-synchronization_configuring-basic-system-settings).
+
+### Amazon Linux 2
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo yum install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+    sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [Amazon Linux 2 documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/set-time.html).
+
+If you are using Active-Active databases, you must use [Network Time Service (ntpd)]({{< relref "/operate/rs/7.4/databases/active-active/_index.md#network-time-service-ntp-or-chrony" >}})
+to synchronize OS clocks consistently across clusters to handle conflict resolution according to the OS time.
+---
+Title: Replace a cluster node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replace a node in your cluster that is down.
+linkTitle: Replace node
+weight: 90
+url: '/operate/rs/7.4/clusters/replace-node/'
+---
+A failed node will appear as `Down` ({{< image filename="/images/rs/icons/node-down-icon.png#no-click" alt="Node down icon" class="inline" >}}) in the **Nodes** list.
+
+To replace a failed node: 
+
+1. Prepare a new node identical to the old one.
+
+1.  Install and
+    configure Redis Enterprise Software on the node. See [Install and setup]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) for more information.
+
+    {{< note >}}
+If you are using [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}), make sure the required flash storage is set up on this new node.
+    {{< /note >}}
+
+1. [Add the node]({{< relref "/operate/rs/7.4/clusters/add-node" >}}) to the cluster. Make sure the new node has as much available memory as the faulty
+    node.
+
+    If the new node does not have enough memory, you will be prompted to add a node with enough memory.
+
+1. A message will appear informing you that the cluster has a faulty node
+    and that the new node will replace the faulty node.
+
+    {{< note >}}
+- If there is a faulty node in the cluster to which you are adding a node, Redis Enterprise Software will use the new node to replace the faulty one.
+- Any existing [DNS records]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}) must be updated
+each time a node is added or replaced.
+    {{< /note >}}
+---
+Title: Remove a cluster node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Remove a node from your Redis Enterprise cluster.
+linkTitle: Remove node
+weight: 80
+url: '/operate/rs/7.4/clusters/remove-node/'
+---
+You might want to remove a node from a Redis Enterprise cluster for one of the following reasons:
+
+- To [permanently remove a node](#permanently-remove-a-node) if you no longer need the extra capacity.
+- To [replace a faulty node](#replace-a-faulty-node) with a healthy node.
+- To [replace a healthy node](#replace-a-healthy-node) with a different node.
+
+You can configure [email alerts from the cluster]({{< relref "/operate/rs/7.4/clusters/monitoring#cluster-alerts" >}}) to notify you of cluster changes, including when a node is removed.
+
+{{<warning>}}
+Read through these explanations thoroughly before taking
+any action.
+{{</warning>}}
+
+## Permanently remove a node
+
+Permanently removing a node means you are decreasing cluster capacity.
+Before trying to remove a node, make sure that the cluster has enough
+capacity for all resources without that node, otherwise you cannot remove the node.
+
+If there is not enough capacity in the cluster to facilitate removing
+the node, you can either delete databases or add another node instead of
+the one you would like to remove.
+
+During the removal process, the cluster migrates all resources from the
+node being removed to other nodes in the cluster. In order to ensure
+database connectivity, and database high availability (when replication
+is enabled), the cluster first creates replacement shards or endpoints
+on one of the other nodes in the cluster, initiates failover as needed,
+and only then removes the node.
+
+If a cluster has only two nodes (which is not recommended for production
+deployments) and some databases have replication enabled, you cannot remove a node.
+
+## Replace a faulty node
+
+If the cluster has a faulty node that you would like to replace, you
+only need to add a new node to the cluster. The cluster recognizes the
+existence of a faulty node and automatically replaces the faulty node
+with the new node.
+
+For guidelines, refer to [Replacing a faulty
+node]({{< relref "/operate/rs/7.4/clusters/replace-node.md" >}}).
+
+## Replace a healthy node
+
+If you would like to replace a healthy node with a different node, you
+must first add the new node to the cluster, migrate all the resources
+from the node you would like to remove, and only then remove the node.
+
+For further guidance, refer to [adding a new node to a
+cluster]({{< relref "/operate/rs/7.4/clusters/add-node.md" >}}).
+
+You can migrate resources by using the `rladmin` command-line interface
+(CLI). For guidelines, refer to [`rladmin` command-line interface
+(CLI)]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}).
+
+{{< note >}}
+The [DNS records]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}) must be updated each time a node is added or replaced.
+{{< /note >}}
+
+## Remove a node
+
+To remove a node using the Cluster Manager UI:
+
+1. If you are using the new Cluster Manager UI, switch to the legacy admin console.
+
+    {{<image filename="images/rs/screenshots/switch-to-legacy-ui.png"  width="300px" alt="Select switch to legacy admin console from the dropdown.">}}
+
+1. On the **nodes** page, select the node you want to remove.
+
+1. Click **Remove** at the top of the **node** page.
+
+1. Confirm you want to **Remove** the node when prompted.
+
+1. Redis Enterprise Software examines the node and the cluster and takes the actions required
+    to remove the node.
+
+1. At any point, you can click the **Abort** button to stop the
+    process. When aborted, the current internal action is completed, and
+    then the process stops.
+    
+1. Once the process finishes, the node is no longer shown in
+    the UI.
+
+To remove a node using the REST API, use [`POST /v1/nodes/<node_id>/actions/remove`]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/actions#post-node-action" >}}).
+
+By default, the remove node action completes after all resources migrate off the removed node. Node removal does not wait for migrated shards' persistence files to be created on the new nodes.
+
+To change node removal to wait for the creation of new persistence files for all migrated shards, set `wait_for_persistence` to `true` in the request body or [update the cluster policy]({{<relref "/operate/rs/7.4/references/rest-api/requests/cluster/policy#put-cluster-policy">}}) `persistent_node_removal` to `true` to change the cluster's default behavior.
+
+For example:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/remove
+{
+    "wait_for_persistence": true
+}
+```
+
+{{< note >}}
+If you need to add a removed node back to the cluster,
+you must [uninstall]({{< relref "/operate/rs/7.4/installing-upgrading/uninstalling.md" >}})
+and [reinstall]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) the software on that node.
+{{< /note >}}
+---
+Title: Add a cluster node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Add a node to your existing Redis Enterprise cluster.
+linktitle: Add a node
+weight: 20
+url: '/operate/rs/7.4/clusters/add-node/'
+---
+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.
+
+{{< note >}}
+Before you add a node to the cluster:
+
+- The clocks on all nodes must always be [synchronized]({{< relref "/operate/rs/7.4/clusters/configure/sync-clocks.md" >}}).
+
+    If the clock in the node you are trying to join to the cluster is not synchronized with the nodes already in the cluster,
+    the action fails and an error message is shown indicating that you must synchronize the clocks first.
+
+- You must [update the DNS records]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}})
+    each time a node is added or replaced.
+
+- We recommend that you add nodes one after the other rather than in parallel
+    to avoid errors that occur because the connection to the other nodes in the cluster cannot be verified.
+{{< /note >}}
+
+To add a node to an existing cluster:
+
+1. [Install the Redis Enterprise Software installation package]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) on a clean installation
+    of a [supported operating system]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+1. To connect to the Cluster Manager UI of the new Redis Enterprise Software installation, go to: <https://URL or IP address:8443>
+
+    For example, if you installed Redis Enterprise Software on a machine with IP address 10.0.1.34, go to `https://10.0.1.34:8443`.
+
+    {{< tip >}}
+The management UI uses TLS encryption with a default certificate.
+You can also [replace the TLS certificate]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates" >}})
+with a custom certificate.
+    {{< /tip >}}
+
+1. Select **Join cluster**.
+
+1. For **Cluster identification**, enter the internal IP address or DNS name of a node that is a cluster member.
+
+    If the node only has one IP address, enter that IP address.
+
+1. For **Cluster sign in**, enter the credentials of the cluster administrator.
+
+    The cluster administrator is the user account that you create when you configure the first node in the cluster.
+
+1. Click **Next**.
+
+1. Configure storage and network settings:
+
+    1. Enter a path for [*Ephemeral storage*]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}), or leave the default path.
+
+    1. Enter a path for [*Persistent storage*]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}),
+        or leave the default path.
+
+    1. To enable [*Auto Tiering*]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}),
+        select **Enable flash storage** and enter the path to the flash storage.
+
+    1. If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}), set the **Rack-zone ID** for the new node.
+
+    1. If your machine has multiple IP addresses, assign a single IPv4 type address for **Node-to-node communication (internal traffic)** and multiple IPv4/IPv6 type addresses for **External traffic**.
+
+1. Select **Join cluster**.
+
+The node is added to the cluster.
+You can see it in the list of nodes in the cluster.
+
+If you see an error when you add the node, try adding the node again.
+
+{{< tip >}}
+We recommend that you run the [rlcheck utility]({{< relref "/operate/rs/7.4/references/cli-utilities/rlcheck" >}}) to verify that the node is functioning properly.
+{{< /tip >}}
+
+---
+Title: Set up a new cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to set up a new cluster using the management UI.
+linktitle: Set up cluster
+weight: 10
+url: '/operate/rs/7.4/clusters/new-cluster-setup/'
+---
+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.
+{{< /note >}}
+
+To set up a new cluster, you must first [install the Redis Enterprise Software package]({{< relref "/operate/rs/7.4/installing-upgrading" >}})
+and then set up the cluster as described below.
+After the cluster is created you can [add multiple nodes to the cluster]({{< relref "/operate/rs/7.4/clusters/add-node.md" >}}).
+
+To create a cluster:
+
+1. In a browser, go to `https://<name or IP address of the machine with Redis Enterprise Software installed>:8443`.
+    For example, if you installed Redis Enterprise Software on a machine with IP address 10.0.1.34, go to <https://10.0.1.34:8443>.
+
+    {{< note >}}
+- The management UI uses a [self-signed certificate for TLS encryption]({{< relref "/operate/rs/7.4/security/certificates/updating-certificates" >}}).
+- If the machine has both an internal IP address and an external IP address, use the external IP address to access the setup UI.
+    {{< /note >}}
+
+1. Select **Create new cluster**.
+
+1. Enter an email and password for the administrator account, then select **Next** to proceed to cluster setup.
+
+1. Enter your cluster license key if you have one. Otherwise, the cluster uses the trial license by default.
+
+1. In the **Configuration** section:
+
+    1. For **FQDN (Fully Qualified Domain Name)**, enter a unique name for the cluster.
+
+        See the [instructions for DNS setup]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}})
+        to make sure your cluster is reachable by name.
+
+    1. Choose whether to [**Enable private & public endpoints support**]({{< relref "/operate/rs/7.4/networking/private-public-endpoints.md" >}}).
+
+    1. Choose whether to [**Enable rack-zone awareness**]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}).
+
+1. Click **Next**.
+
+1. Configure storage and network settings:
+
+    1. Enter a path for [*Ephemeral storage*]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}), or leave the default path.
+
+    1. Enter a path for [*Persistent storage*]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}),
+        or leave the default path.
+
+    1. To enable [*Auto Tiering*]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}),
+        select **Enable flash storage** and enter the path to the flash storage.
+
+    1. If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/7.4/clusters/configure/rack-zone-awareness.md" >}}), set the **Rack-zone ID** for the new node.
+
+    1. If your machine has multiple IP addresses, assign a single IPv4 type address for **Node-to-node communication (internal traffic)** and multiple IPv4/IPv6 type addresses for **External traffic**.
+
+1. Select **Create cluster**.
+
+1. Click **OK** to confirm that you are aware of the replacement of the HTTPS TLS certificate on the node,
+    and proceed through the browser warning.
+
+After a short wait, your cluster is created and you can sign in to the Cluster Manager UI.
+
+You can now access any of the management capabilities, including:
+
+- [Creating a new database]({{< relref "/operate/rs/7.4/databases/create.md" >}})
+- [Joining a new node to a cluster]({{< relref "/operate/rs/7.4/clusters/add-node.md" >}})
+---
+Title: Monitoring with metrics and alerts
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Use the metrics that measure the performance of your Redis Enterprise Software clusters, nodes, databases, and shards to track the performance of your databases.
+hideListLinks: true
+linkTitle: Monitoring
+weight: 96
+url: '/operate/rs/7.4/clusters/monitoring/'
+---
+You can use the metrics that measure the performance of your Redis Enterprise Software clusters, nodes, databases, and shards
+to monitor the performance of your databases.
+In the Redis Enterprise Cluster Manager UI, you can see real-time metrics and configure alerts that send notifications based on alert parameters. You can also access metrics and configure alerts through the REST API.
+
+To integrate Redis Enterprise metrics into your monitoring environment, see the integration guides for [Prometheus and Grafana]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}) or [Uptrace]({{< relref "/integrate/uptrace-with-redis-enterprise/" >}}).
+
+Make sure you read the [definition of each metric]({{< relref "/operate/rs/7.4/references/metrics/" >}})
+so that you understand exactly what it represents.
+
+## Real-time metrics
+
+You can see the metrics of the cluster in:
+
+- **Cluster > Metrics**
+- **Node > Metrics** for each node
+- **Database > Metrics** for each database, including the shards for that database
+
+The scale selector at the top of the page allows you to set the X-axis (time) scale of the graph.
+
+To choose which metrics to display in the two large graphs at the top of the page:
+
+1. Hover over the graph you want to show in a large graph.
+1. Click on the right or left arrow to choose which side to show the graph.
+
+We recommend that you show two similar metrics in the top graphs so you can compare them side-by-side.
+
+## Cluster alerts
+
+In **Cluster > Alert Settings**, you can enable alerts for node or cluster events, such as high memory usage or throughput.
+
+Configured alerts are shown:
+
+- As a notification on the status icon ( {{< image filename="/images/rs/icons/icon_warning.png#no-click" alt="Warning" width="18px" class="inline" >}} ) for the node and cluster
+- In the **log**
+- In email notifications, if you configure [email alerts](#send-alerts-by-email)
+
+{{< note >}}
+If you enable alerts for "Node joined" or "Node removed" actions,
+you must also enable "Receive email alerts" so that the notifications are sent.
+{{< /note >}}
+
+To enable alerts for a cluster:
+
+1. In **Cluster > Alert Settings**, click **Edit**. 
+1. Select the alerts that you want to show for the cluster and click **Save**.
+
+## Database alerts
+
+For each database, you can enable alerts for database events, such as high memory usage or throughput.
+
+Configured alerts are shown:
+
+- As a notification on the status icon ( {{< image filename="/images/rs/icons/icon_warning.png#no-click" alt="Warning" width="18px" class="inline" >}} ) for the database
+- In the **log**
+- In emails, if you configure [email alerts](#send-alerts-by-email)
+
+To enable alerts for a database:
+
+1. In **Configuration** for the database, click **Edit**.
+1. Select the **Alerts** section to open it.
+1. Select the alerts that you want to show for the database and click **Save**.
+
+## Send alerts by email
+
+To send cluster and database alerts by email:
+
+1. In **Cluster > Alert Settings**, click **Edit**.
+1. Select **Set an email** to configure the [email server settings]({{< relref "/operate/rs/7.4/clusters/configure/cluster-settings#configuring-email-server-settings" >}}).
+1. In **Configuration** for the database, click **Edit**.
+1. Select the **Alerts** section to open it.
+1. Select **Receive email alerts** and click **Save**.
+1. In **Access Control**, select the [database and cluster alerts]({{< relref "/operate/rs/7.4/security/access-control/manage-users" >}}) that you want each user to receive.
+---
+Title: Alerts and events
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Logged alerts and events
+linkTitle: Alerts and events
+weight: 50
+aliases: 
+    - /operate/rs/clusters/logging/rsyslog-logging/cluster-events/
+    - /operate/rs/clusters/logging/rsyslog-logging/bdb-events/
+    - /operate/rs/clusters/logging/rsyslog-logging/node-events/
+    - /operate/rs/clusters/logging/rsyslog-logging/user-events/
+url: '/operate/rs/7.4/clusters/logging/alerts-events/'
+---
+
+The following alerts and events can appear in `syslog` and the Cluster Manager UI logs.
+
+| Alert/Event                   | 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                   | bdb event; Replica of - error authenticating with the source database                                                                                         |
+| 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.                                                                                      |
+| backup_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| backup_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| backup_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_created                       |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_deleted                       |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_updated                       |                                                                | info                    | bdb event; Indicates that a bdb configuration has been updated                                                                                                 |
+| checks_error                      |                                                                | error                   | node event; Indicates that one or more node checks have failed                                                                                                |
+| cluster_updated                   |                                                                | info                    | cluster event; Indicates that cluster settings have been updated                                                                                              |
+| compression_unsup_err             |                                                                | error                   | bdb event; Replica of - Compression not supported by sync destination                                                                                         |
+| crossslot_err                     |                                                                | error                   | bdb event; Replica of - sharded destination does not support operation executed on source                                                                     |
+| 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.                                                                           |
+| export_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| export_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| export_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| failed                            | Node failed                                                    | critical                | node alert                                                                                                                                                     |
+| 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                   | Replica of - 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.                                                                                 |
+| import_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| import_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| import_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| inconsistent_redis_sw             | Not all databases are running the same open source version     | True: warning, False: info | cluster alert                                                                                                                                                  |
+| 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                                                                                                                                                     |
+| internal_bdb                      | Issues with internal cluster databases                         | True: warning, False: info | cluster alert                                                                                                                                                  |
+| license_added                     |                                                                | info                    | cluster event                                                                                                                                                  |
+| license_deleted                   |                                                                | info                    | cluster event                                                                                                                                                  |
+| license_updated                   |                                                                | info                    | cluster event                                                                                                                                                  |
+| low_throughput                    | Throughput is lower than `<threshold>` RPS (requests per second) | True: warning, False: info | bdb alert; Has threshold parameter in the key/value section of the log entry.                                                                                 |
+| 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.                                                                           |
+| 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 removed                                                   | info                    | cluster event; The remove node is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail.                                  |
+| node_remove_abort_failed          | Node removed                                                   | error                   | cluster event; The remove node 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; The remove node 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; The remove node is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail.                                  |
+| node_remove_request               |                                                                | info                    | node event                                                                                                                                                     |
+| 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                                                                                                                                                  |
+| oom_err                           |                                                                | error                   | bdb event; Replica of - Replication source/target out of memory                                                                                               |
+| 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           |                                                                | error                   | bdb alert                                                                                                                                                      |
+| 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                                                                                                                                                  |
+| user_created                      |                                                                | info                    | user event                                                                                                                                                     |
+| user_deleted                      |                                                                | info                    | user event                                                                                                                                                     |
+| user_updated                      |                                                                | info                    | user event; Indicates that a user configuration has been updated                                                                                              |
+---
+Title: Manage logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Manage logs
+weight: 50
+url: '/operate/rs/7.4/clusters/logging/log-security/'
+---
+Redis Enterprise comes with [a set of logs]({{< relref "/operate/rs/7.4/clusters/logging" >}}) 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.
+
+To do this, modify the syslog or rsyslog configuration on your operating system to send logs in the `$logdir` directory (`/var/opt/redislabs/log` in default installations) to a remote monitoring server of your choice. See [rsyslog logging]({{< relref "/operate/rs/7.4/clusters/logging/rsyslog-logging/" >}}) for additional details.
+
+## Log rotation
+
+Redis Enterprise Software's job scheduler runs `logrotate` every five minutes to examine logs stored on the operating system and rotate them based on the log rotation configuration. You can find the log rotation configuration file at `$pkgconfdir/logrotate.conf` as of Redis Enterprise Software version 7.2 (`pkgconfdir` is `/opt/redislabs/config` by default, but can be changed in a custom installation).
+
+By default, log rotation occurs when a log exceeds 200 MB. We recommend sending log files to a remote logging server so you can maintain them more effectively.
+
+The following log rotation policy is enabled by default in Redis Enterprise Software, but you can modify it as needed.
+
+```sh
+/var/opt/redislabs/log/*.log {
+    su ${osuser} ${osgroup}
+    size 200M
+    missingok
+    copytruncate
+    # 2000 is logrotate's way of saying 'infinite'
+    rotate 2000
+    maxage 7
+    compress
+    notifempty
+    nodateext
+    nosharedscripts
+    prerotate
+        # copy cluster_wd log to another file that will have longer retention
+        if [ "\$1" = "/var/opt/redislabs/log/cluster_wd.log" ]; then
+        	cp -p /var/opt/redislabs/log/cluster_wd.log /var/opt/redislabs/log/cluster_wd.log.long_retention
+        fi
+    endscript
+}
+/var/opt/redislabs/log/cluster_wd.log.long_retention {
+    su ${osuser} ${osgroup}
+    daily
+    missingok
+    copytruncate
+    rotate 30
+    compress
+    notifempty
+    nodateext
+}
+```
+
+- `/var/opt/redislabs/log/*.log` - `logrotate` checks the files under the `$logdir` directory (`/var/opt/redislabs/log/`) and rotates any files that end with the extension `.log`.
+
+- `/var/opt/redislabs/log/cluster_wd.log.long_retention` - The contents of `cluster_wd.log` is copied to `cluster_wd.log.long_retention` before rotation, and this copy is kept for longer than normal (30 days).
+
+- `size 200M` - Rotate log files that exceed 200 MB.
+
+- `missingok` - If there are missing log files, do nothing.
+
+- `copytruncate` - Truncate the original log file to zero sizes after creating a copy.
+
+- `rotate 2000` - Keep up to 2000 (effectively infinite) log files.
+
+- `compress` - gzip log files.
+
+- `maxage 7` - Keep the rotated log files for 7 days.
+
+- `notifempty` - Don't rotate the log file if it is empty.
+
+{{<note>}}
+For large scale deployments, you might need to rotate logs at faster intervals than daily. You can also use a cronjob or external vendor solutions.
+{{</note>}}
+---
+Title: View Redis slow log
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Slow log
+weight: $weight
+url: '/operate/rs/7.4/clusters/logging/redis-slow-log/'
+---
+On the **Databases** \> **Slowlog** page, you can view Slow Log details
+for Redis Enterprise Software databases.
+
+[Redis Slow Log](http://redis.io/commands/slowlog) is one of the best
+tools for debugging and tracing your Redis database, especially if you
+experience high latency and high CPU usage with Redis operations.
+Because Redis is based on a single threaded architecture, Redis Slow Log
+can be much more useful than slow log mechanisms of multi-threaded
+database systems such as MySQL Slow Query Log.
+
+Unlike tools that introduce lock overhead (which complicates the debugging
+process), Redis Slow Log is highly effective at showing the actual processing time of each command.
+
+Redis Enterprise Software includes enhancements to the standard Redis
+Slow Log capabilities that allow you to analyze the execution time
+complexity of each command. This enhancement can help you better analyze
+Redis operations, allowing you to compare the differences between
+execution times of the same command, observe spikes in CPU usage, and
+more.
+
+This is especially useful with complex commands such as
+[ZUNIONSTORE](http://redis.io/commands/zunionstore),
+[ZINTERSTORE](http://redis.io/commands/zinterstore) and
+[ZRANGEBYSCORE](http://redis.io/commands/zrangebyscore).
+
+The enhanced Redis Enterprise Software Slow Log adds the **Complexity info** field to the
+output data.
+
+View the complexity info data by its respective command in the table
+below:
+
+| Command | Value of interest | Complexity |
+|------------|-----------------|-----------------|
+| LINSERT | N - list len | O(N) |
+| LREM | N - list len | O(N) |
+| LTRIM | N - number of removed elements | O(N) |
+| PUBLISH | N - number of channel subscribers</br>M - number of subscribed patterns | O(N+M) |
+| PSUBSCRIBE | N - number of patterns client is subscribed to</br>argc - number of arguments passed to the command | O(argc\*N) |
+| PUNSUBSCRIBE | N - number of patterns client is subscribed to</br>M - total number of subscribed patterns</br>argc - number of arguments passed to the command | O(argc\*(N+M)) |
+| SDIFF | N - total number of elements in all sets | O(N) |
+| SDIFFSTORE | N - total number of elements in all sets | O(N) |
+| SINTER                | N - number of elements in smallest set</br>argc - number of arguments passed to the command | O(argc\*N) |
+| SINTERSTORE           | N - number of elements in smallest set</br>argc - number of arguments passed to the command | O(argc\*N) |
+| SMEMBERS              | N - number of elements in a set | O(N) |
+| SORT                  | N - number of elements in the when no sorting list/set/zset</br>M - number of elements in result | O(N+M\*log(M))O(N) |
+| SUNION                | N - number of elements in all sets | O(N) |
+| SUNIONSTORE           | N - number of elements in all sets | O(N) |
+| UNSUBSCRIBE           | N - total number of clients subscribed to all channels | O(N) |
+| ZADD                  | N - number of elements in the zset | O(log(N)) |
+| ZCOUNT                | N - number of elements in the zset</br>M - number of elements between min and max | O(log(N)+M) |
+| ZINCRBY               | N - number of elements in the zset | O(log(N)) |
+| ZINTERSTORE           | N – number of elements in the smallest zset</br>K – number of zsets</br>M – number of elements in the results set | O(N\*K)+O(M\*log(M)) |
+| ZRANGE                | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZRANGEBYSCORE         | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZRANK                 | N – number of elements in the zset | O(log(N)) |
+| ZREM                  | N – number of elements in the zset</br>argc – number of arguments passed to the command | O(argc\*log(N)) |
+| ZREMRANGEBYRANK       | N – number of elements in the zset</br>argc – number of arguments passed to the command | O(log(N)+M) |
+| ZREMRANGEBYSCORE      | N – number of elements in the zset</br>M – number of elements removed | O(log(N)+M) |
+| ZREVRANGE             | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZREVRANK              | N – number of elements in the zset | O(log(N)) |
+| ZUNIONSTORE           | N – sum of element counts of all zsets</br>M – element count of result | O(N)+O(M\*log(M)) |
+---
+Title: rsyslog logging
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This document explains the structure of Redis Enterprise Software log
+  entries in `rsyslog` and how to use these log entries to identify events.
+hideListLinks: true
+linktitle: rsyslog
+weight: $weight
+url: '/operate/rs/7.4/clusters/logging/rsyslog-logging/'
+---
+
+## Log concepts
+
+Redis Enterprise Software logs information from a variety of components in response to actions and events that occur within the cluster.
+
+In some cases, a single action, such as removing a node from the cluster, may actually consist of several events. These actions may generate multiple log entries.
+
+All log entries displayed in the Cluster Manager UI are also written to `syslog`.  You can configure `rsyslog` to monitor `syslog`. Enabled alerts are logged to `syslog` and appear with other log entries.
+
+You can also [manage your logs]({{< relref "/operate/rs/7.4/clusters/logging/log-security" >}}) with a remote logging server and log rotation.
+
+### Types of log entries
+
+Log entries are categorized into events and alerts. Both types of entries appear in the logs, but alert log entries also include a boolean `"state"` parameter that indicates whether the alert is enabled or disabled.
+
+Log entries include information about the specific event that occurred. See the log entry tables for [alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+### Severity
+
+You can also configure `rsyslog` to add other information, such as the event severity.
+
+Since `rsyslog` entries do not include severity by default, you can follow these steps to enable it:
+
+1. Add the following line to `/etc/rsyslog.conf`:
+    ```
+    $template TraditionalFormatWithPRI,"%pri-text%: %timegenerated% %HOSTNAME% %syslogtag%%msg:::drop-last-lf%\n"
+    ```
+
+2. Modify `$ActionFileDefaultTemplate` to use your new template `$ActionFileDefaultTemplateTraditionalFormatWithPRI`
+
+3. Save these changes and restart `rsyslog` to apply them
+
+You can see the log entries for alerts and events in the `/var/log/messages` file.
+
+**Command components:**
+
+- `%pri­text%` ­adds the severity
+- `%timegenerated%` ­adds the timestamp
+- `%HOSTNAME%` ­adds the machine name
+- `%syslogtag%` adds ­the Redis Enterprise Software message. See the [log entry structure](#log-entry-structure) section for more details.
+- `%msg:::drop­last­lf%n` ­removes duplicated log entries
+
+## Log entry structure
+
+The log entries have the following basic structure:
+
+    event_log[<process id>]:{<list of key-value pairs in any order>}
+
+- **event_log**:­ Plain static text is always shown at the beginning of the entry.
+- **process id­**: The ID of the logging process
+- **list of key-value pairs in any order**:­ A list of key-value pairs that describe the specific event. They can appear in any order. Some key­-value pairs are always shown, and some appear depending on the specific event.
+    - **Key-­value pairs that always appear:**
+        - `"type"`: A unique code­ name for the logged event. For the list of codenames, see the [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) tables.
+        - `"object"`: Defines the object type and ID (if relevant) of the object this event relates to, such as cluster, node with ID, BDB with ID, etc. Has the format of <nobr>`<object type>[:<id>]`</nobr>. 
+        - `"time"`: Unix epoch time but can be ignored in this context.
+    - **Key-­value pairs that might appear depending on the specific entry:**
+        - `"state"`: A boolean where `true` means the alert is enabled, and `false` means the alert is disabled. This is only relevant for alert log entries.
+        - `"global_threshold"`: The value of a threshold for alerts related to cluster or node objects.
+        - `"threshold"`: The value of a threshold for alerts related to a BDB object
+
+## Log entry samples
+
+This section provides examples of log entries that include the [`rsyslog` configuration](#severity) to add the severity, timestamp, and machine name.
+
+### Ephemeral storage passed threshold
+
+#### "Alert on" log entry sample
+
+```
+daemon.warning: Jun 14 14:49:20 node1 event_log[3464]:
+{
+    "storage_util": 90.061643120001, 
+    "global_threshold": "70", 
+    "object": "node:1", 
+    "state": true, 
+    "time": 1434282560, 
+    "type": "ephemeral_storage"
+}
+```
+
+In this example, the storage utilization on node 1 reached the value of ~90%, which triggered the alert for "Ephemeral storage has reached 70% of its capacity."
+
+**Log entry components:**
+
+- `daemon.warning` -­ Severity of entry is `warning`
+- `Jun 14 14:49:20` -­ The timestamp of the event
+- `node1`:­ Machine name
+- `event_log` -­ Static text that always appears
+- `[3464]­` - Process ID
+- `"storage_util":90.061643120001` - Current ephemeral storage utilization
+- `"global_threshold":"70"` - The user-configured threshold above which the alert is raised
+- `"object":"node:1"`­ - The object related to this alert
+- `"state":true­` - Current state of the alert
+- `"time":1434282560­` - Can be ignored
+- `"type":"ephemeral_storage"` - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.info: Jun 14 14:51:35 node1 event_log[3464]: 
+{
+    "storage_util":60.051723520008, 
+    "global_threshold": "70", 
+    "object": "node:1", 
+    "state":false, 
+    "time": 1434283480, 
+    "type": "ephemeral_storage"
+}
+```
+
+This log entry is an example of when the alert for the node with ID 1 "Ephemeral storage has reached 70% of its capacity" has been turned off as result of storage utilization reaching the value of ~60%.
+
+**Log entry components**:
+
+- `daemon.info` -­ Severity of entry is `info`
+- `Jun 14 14:51:35` -­ The timestamp of the event
+- `node1` -­ Machine name
+- `event_log` -­ Static text that always appears
+- `[3464]` -­ Process ID
+- `"storage_util":60.051723520008­` - Current ephemeral storage utilization
+- `"global_threshold":"70"` - The user configured threshold above which the alert is raised (70% in this case)
+- `"object":"node:1"` -­ The object related to this alert
+- `"state":false­` - Current state of the alert
+- `"time":1434283480­` - Can be ignored
+- `"type":"ephemeral_storage"` -­ The code name identifier of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+### Odd number of nodes with a minimum of three nodes alert
+
+#### "Alert on" log entry sample
+
+```
+daemon.warning: Jun 14 15:25:00 node1 event_log[8310]: 
+{
+    "object":"cluster", 
+    "state": true, 
+    "time": 1434284700, 
+    "node_count": 1, 
+    "type":"even_node_count"
+}
+```
+
+This log entry is an example of when the alert for "True high availability requires an odd number of nodes with a minimum of three nodes" has been turned on as result of the cluster having only one node.
+
+**Log entry components:**
+
+- `daemon.warning­` - Severity of entry is warning
+- `Jun 14 15:25:00` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[8310]­` - Process ID
+- `"object":"cluster"­` - The object related to this alert
+- `"state":true` -­ Current state of the alert
+- `"time":1434284700­` - Can be ignored
+- `"node_count":1­` - The number of nodes in the cluster
+- `"type":"even_node_count"­` - The code name identifier of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.warning: Jun 14 15:30:40 node1 event_log[8310]: 
+{
+    "object":"cluster", 
+    "state": false, 
+    "time": 1434285200, 
+    "node_count": 3, 
+    "type":"even_node_count"
+}
+```
+
+This log entry is an example of when the alert for "True high availability requires an odd number of nodes with a minimum of three nodes" has been turned off as result of the cluster having 3 nodes.
+
+**Log entry components:**
+
+- `daemon.warning` - Severity of entry is warning
+- `Jun 14 15:30:40` -­ The timestamp of the event
+- `node1­` - Machine name
+- `event_log­` - Static text that always appears
+- `[8310]` -­ Process ID
+- `"object":"cluster"` -­ The object related to this alert
+- `"state":false­` - Current state of the alert
+- `"time":1434285200­` - Can be ignored
+- `"node_count":3­` - The number of nodes in the cluster
+- `"type":"even_node_count"` -­ The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+### Node has insufficient disk space for AOF rewrite
+
+#### "Alert on" log entry sample
+
+```
+daemon.err: Jun 15 13:51:23 node1 event_log[34252]: 
+{
+    "used": 23457188, 
+    "missing": 604602126, 
+    "object": "node:1", 
+    "free": 9867264, 
+    "needed":637926578, 
+    "state": true, 
+    "time": 1434365483, 
+    "disk": 705667072, 
+    "type":"insufficient_disk_aofrw"
+}
+```
+
+This log entry is an example of when the alert for "Node has insufficient disk space for AOF rewrite" has been turned on as result of not having enough persistent storage disk space for AOF rewrite purposes. It is missing 604602126 bytes.
+
+**Log entry components:**
+
+- `daemon.err`­ - Severity of entry is error
+- `Jun 15 13:51:23` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[34252]` -­ Process ID
+- `"used":23457188­` - The amount of disk space in bytes currently used for AOF files
+- `"missing":604602126­` - The amount of disk space in bytes that is currently missing for AOF rewrite purposes
+- `"object":"node:1″` -­ The object related to this alert
+- `"free":9867264­` - The amount of disk space in bytes that is currently
+    free
+- `"needed":637926578­` - The amount of total disk space in bytes that is needed for AOF rewrite purposes
+- `"state":true­` - Current state of the alert
+- `"time":1434365483` -­ Can be ignored
+- `"disk":705667072­` - The total size in bytes of the persistent storage
+- `"type":"insufficient_disk_aofrw"­` - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.info: Jun 15 13:51:11 node1 event_log[34252]: 
+{
+    "used": 0, "missing":-21614592, 
+    "object": "node:1", 
+    "free": 21614592, 
+    "needed": 0, 
+    "state":false, 
+    "time": 1434365471, 
+    "disk": 705667072, 
+    "type":"insufficient_disk_aofrw"
+}
+```
+
+**Log entry components:**
+
+- `daemon.info­` - Severity of entry is info
+- `Jun 15 13:51:11` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[34252]­` - Process ID
+- `"used":0­` - The amount of disk space in bytes currently used for AOF files
+- `"missing":‐21614592­` - The amount of disk space in bytes that is currently missing for AOF rewrite purposes. In this case, it is not missing because the number is negative.
+- `"object":"node:1″` -­ The object related to this alert
+- `"free":21614592` -­ The amount of disk space in bytes that is currently free
+- `"needed":0­` - The amount of total disk space in bytes that is needed for AOF rewrite purposes. In this case, no space is needed.
+- `"state":false­` - Current state of the alert
+- `"time":1434365471­` - Can be ignored
+- `"disk":705667072­` - The total size in bytes of the persistent storage
+- `"type":"insufficient_disk_aofrw"`­ - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/7.4/clusters/logging/alerts-events" >}}) for more details.
+---
+Title: Logging events
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Management actions performed with Redis Enterprise are logged to make
+  sure system management tasks are appropriately performed or monitored by administrators
+  and for compliance with regulatory standards.
+hideListLinks: true
+linkTitle: Logging
+weight: 95
+url: '/operate/rs/7.4/clusters/logging/'
+---
+Management actions performed with Redis Enterprise are logged to make sure system management tasks are appropriately performed or monitored by administrators and for compliance with regulatory standards.
+
+Log entries contain the
+following information:
+
+1. Who performed the action?
+1. What exactly was the performed action?
+1. When was the action performed?
+1. Did the action succeed or not?
+
+To get the list of logged events, you can use the REST API or
+the **Logs** screen in the UI. The **Logs** screen displays the system and user
+events regarding alerts, notifications, and configuration.
+
+{{<image filename="images/rs/screenshots/cluster/cluster-logs.png" alt="Logs screen in the new Cluster Manager UI.">}}
+
+You can use the **Logs** screen to review what actions a user has performed, such as editing a database's configuration.
+
+- [Redis slow
+    log]({{< relref "/operate/rs/7.4/clusters/logging/redis-slow-log.md" >}})
+- [rsyslog logging]({{< relref "/operate/rs/7.4/clusters/logging/rsyslog-logging/" >}})
+
+## View logs in the UI
+
+Redis Enterprise provides log files for auditing cluster management actions and troubleshooting. You can view these logs in the UI and on the host operating system.
+
+To view event logs in the new Cluster Manager UI, go to **Cluster > Logs**.
+
+## View logs on the server
+
+Server logs can be found by default in the directory `/var/opt/redislabs/log/`.
+
+These log files are used by the Redis support team to troubleshoot issues. The logs you will most frequently interact with is 'event_log.log'. This log file is where logs of configuration actions within Redis are stored and is useful to determine events that occur within Redis Enterprise.
+
+## Configure log timestamps
+
+Redis Enterprise allows you to configure log timestamps. To configure log timestamps in the new Cluster Manager UI:
+
+1. Go to **Cluster > Configuration > General**.
+
+1. Change the **Time zone** for the logs based on your location.
+---
+Title: Manage clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Administrative tasks and information related to the Redis Enterprise
+  cluster.
+hideListLinks: false
+linktitle: Clusters
+weight: 36
+url: '/operate/rs/7.4/clusters/'
+---
+
+You can manage your Redis Enterprise Software clusters with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([rladmin]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}), [redis-cli]({{< relref "/develop/tools/cli" >}}), [crdb-cli]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/7.4/references/rest-api/_index.md" >}})
+---
+Title: Previous releases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Release notes for Redis Enterprise Software 5.6.0 (April 2020) and earlier
+  versions.
+hideListLinks: true
+linkTitle: Previous releases
+weight: 100
+url: '/operate/rs/7.4/release-notes/legacy-release-notes/'
+---
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+---
+Title: Release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: true
+weight: 90
+url: '/operate/rs/7.4/release-notes/'
+---
+
+Here's what changed recently in Redis Enterprise Software:
+
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle" >}}
+---
+Title: What's new in Redis Enterprise Software 6.x?
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: 20
+url: '/operate/rs/7.4/new-features-redis-enterprise/'
+---
+Below are detailed a few of the major features of this release of Redis Enterprise Software
+along with bug fixes and patches.
+
+## Geo-Distributed Active-Active Conflict-free Replicated Databases (CRDB) {#geodistributed-activeactive-conflictfree-replicated-databases-crdb}
+
+Developing globally distributed applications can be challenging, as
+developers have to think about race conditions and complex combinations
+of events under geo-failovers and cross-region write conflicts. Active-Active databases
+simplify developing such applications by directly using built-in smarts
+for handling conflicting writes based on the data type in use. Instead
+of depending on just simplistic "last-writer-wins" type conflict
+resolution, geo-distributed Active-Active databases combines techniques defined in CRDT
+(conflict-free replicated data types) research with Redis types to
+provide smart and automatic conflict resolution based on the data type's
+intent.
+
+For more information, go here. For information, go to [Developing with
+Active-Active databases]({{< relref "/operate/rs/7.4/developing/crdbs" >}}).
+
+## Redis modules
+
+Redis Modules enable you to extend the functionality of Redis Enterprise
+Software. One can add new data types, capabilities, etc. to tailor the
+cluster to a specific use case or need. Once installed, modules benefit
+from the high performance, scalability, and high availability that Redis
+Enterprise is known for.
+
+### Certified modules
+
+Redis developed and certified these modules for use with Redis Enterprise Software:
+
+- [RedisBloom]({{< relref "/operate/modules/redisbloom" >}})
+    - Enables Redis to have a scalable bloom filter as a data type. Bloom
+      filters are probabilistic data structures that quickly determine if something is contained within a set.
+- RedisGraph
+    - RedisGraph is the first queryable Property Graph database to use sparse
+      matrices to represent the adjacency matrix in graphs and linear algebra to query the graph.
+      RedisGraph uses [Cypher](https://www.opencypher.org/) as its query language.
+- [RedisJSON]({{< relref "/operate/modules/redisjson" >}})
+    - Now you have the convenience JSON as a built-in data type and easily
+      able to address nested data via a path.
+- [RediSearch]({{< relref "/operate/modules/redisearch" >}})
+    - This module turns Redis into a distributed in-memory
+      full-text indexing and search beast.
+
+### Custom modules
+
+In addition, Redis Enterprise Software provides the ability to load and
+use custom [Redis modules](https://redislabs.com/community/redis-modules-hub/) or
+of your own creation.
+
+## Support for Docker
+
+Deploying and running your Redis Enterprise Software cluster on Docker
+containers is supported in development systems and
+available to pull from Docker hub. With the official image, you can
+easily and quickly test several containers to build the scalable
+and highly available cluster Redis Enterprise Software is famous for.
+
+For more information go to [quick start with Redis Enterprise Software
+on Docker.]({{< relref "/operate/rs/7.4/installing-upgrading/get-started-docker.md" >}})
+
+## LDAP integration
+
+As part of our continued emphasis on security, administrative user
+accounts in Redis Enterprise Software can now use either built-in
+authentication or authenticate externally via LDAP with saslauthd. The
+accounts can be used for administering resources on the cluster via
+command line, Rest API, or admin console.
+
+For more information see [LDAP
+Integration]({{< relref "/operate/rs/7.4/security/passwords-users-roles.md#setting-up-ldap" >}}).
+---
+Title: Manage installation questions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes Redis Enterprise Software installation questions and how to
+  answer them automatically.
+linkTitle: Manage install questions
+weight: 25
+url: '/operate/rs/7.4/installing-upgrading/install/manage-installation-questions/'
+---
+
+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:
+
+- **Linux swap file** - `Swap is enabled. Do you want to proceed? [Y/N]?`
+
+    We recommend that you [disable Linux swap]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/linux-swap.md" >}}) in the operating system configuration
+    to give Redis Enterprise Software control of the memory allocation.
+
+- **Automatic OS tuning** - `Do you want to automatically tune the system for best performance [Y/N]?`
+
+    To allow the installation process to optimize the OS for Redis Enterprise Software, answer `Y`.
+    The installation process prompts you for additional information.
+
+    The `/opt/redislabs/sbin/systune.sh` file contains details about the tuning process.
+
+- **Network time** - `Do you want to set up NTP time synchronization now [Y/N]?`
+
+    Redis Enterprise Software requires that all cluster nodes have synchronized time.
+    You can either let the installation process configure NTP
+    or you can [configure NTP manually]({{< relref "/operate/rs/7.4/clusters/configure/sync-clocks.md" >}}).
+
+- **Firewall ports** - `Would you like to open RedisLabs cluster ports on the default firewall zone [Y/N]?`
+
+    Redis Enterprise Software requires that all nodes have [specific network ports]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}) open.
+    To open the ports, you can:
+
+    - Answer `Y` to let the installation process open these ports.
+    - Answer `N` and configure the firewall manually for [RHEL/CentOS firewall]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+    - Answer `N` and configure the firewall on the node manually for your OS.
+
+- **Installation verification (rlcheck)** - `Would you like to run rlcheck to verify proper configuration? [Y/N]?`
+
+    Run the `rlcheck` installation verification to make sure that the installation completed successfully.
+    If you want to run this verification at a later time, you can run:
+    
+    ```sh
+    /opt/redislabs/bin/rlcheck
+    ```
+
+- **User already exists** - `The user 'redislabs' already exists, which may lead to problems if it wasn't configured correctly. Would you like to proceed with the installation? (Y/N)?`
+
+- **Group already exists** - `The group 'redislabs' already exists, which may lead to problems if it wasn't configured correctly. Would you like to proceed with the installation? (Y/N)?`
+ 
+## Answer install questions automatically
+
+To perform a silent (or automated) install, answer the questions when you start the [install]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}).  
+
+### Answer yes to all questions
+
+To automatically answer `yes` to all questions (which accepts the default values), run the [installation script]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) with the `-y` parameter:
+
+```bash
+./install.sh -y
+```
+
+### Configure file to answer
+
+Use an answer file to manage your response:
+
+1. Create a text file to serve as an answer file.
+
+    The answer file can contain any of the parameters for the installation questions and indicate the answer for each question with `yes` or `no`.
+
+    For example:
+
+    ```sh
+    ignore_swap=no
+    systune=yes
+    ntp=no
+    firewall=no
+    rlcheck=yes
+    ignore_existing_osuser_osgroup=no
+    ```
+
+    If you use `systune=yes`, the installation answers `yes` to all of the system tuning questions.
+
+1. Run the [installation script]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) with the `-c` command-line option and add the path to the answer file.
+
+    For example:
+
+    ```sh
+    ./install.sh -c /home/user/answers
+    ```
+
+---
+Title: Install Redis Enterprise Software on Linux
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Install Redis Enterprise Software on Linux.
+linkTitle: Install on Linux
+weight: 10
+url: '/operate/rs/7.4/installing-upgrading/install/install-on-linux/'
+---
+
+After you [download a Redis Enterprise Software installation package]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install/download-install-package" >}}), install it on one of the nodes in the cluster.
+
+For installation on machines without an internet connection, see [Offline installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/offline-installation" >}}).
+
+## Install on Linux
+
+To install Redis Enterprise Software, use the command line:
+
+1. Copy the installation package to the node.
+
+1. On the node, change to the directory where the installation package is located and extract the installation files:
+
+    ```sh
+    tar vxf <tarfile name>
+    ```
+
+1.  _(Optional)_ Use the {{< download "GPG key file" "../GPG-KEY-redislabs-packages.gpg" >}} to confirm the authenticity of Ubuntu/Debian or RHEL RPM packages:
+
+    - For Ubuntu:
+        1. Import the key:  
+        ```sh
+        gpg --import <path to GPG key>
+        ```  
+        2. Verify the package signature: 
+        ```sh 
+        dpkg-sig --verify </path-to/package.deb>
+        ```
+
+    - For RHEL:
+        1. Import the key:  
+        ```sh
+        rpm --import <path to GPG key>
+        ```
+        2. Verify the package signature:  
+         ```sh
+         rpm --checksig </path-to/package.rpm>
+         ```
+
+1. To start the installation process, run the installation script. See [installation script options]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) for a list of command-line options you can add to the following command:
+
+    ```sh
+    sudo ./install.sh
+    ```
+
+    {{< note >}}
+- The Redis Enterprise Software files are installed in the default [file locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/file-locations.md" >}}). 
+- By default, Redis Enterprise Software runs on the OS as the `redislabs` user and `redislabs` group. If needed, you can [specify a different user and group]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}}) during the installation.
+- You must either be the root user or use `sudo` to run the installation script.
+    {{< /note >}}
+
+1. Answer the [installation questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions.md" >}}) when shown to complete the installation process.
+
+    {{< note >}}
+To skip the installation questions, use one of the following methods:
+
+- Run `./install.sh -y` to answer yes to all of the questions.
+- Create an [answer file]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions#configure-file-to-answer" >}}) to answer installation questions automatically.
+    {{< /note >}}
+
+1. When installation completes successfully, the output displays the Cluster Manager UI's IP address:
+
+    ```sh
+    Summary:
+    -------
+    ALL TESTS PASSED.
+    2017-04-24 10:54:15 [!] Please logout and login again to make
+    sure all environment changes are applied.
+    2017-04-24 10:54:15 [!] Point your browser at the following
+    URL to continue:
+    2017-04-24 10:54:15 [!] https://<your_ip_here>:8443
+    ```
+
+1. Repeat this process for each node in the cluster.
+
+
+## Auto Tiering installation
+
+If you want to use Auto Tiering for your databases, review the prerequisites, storage requirements, and [other considerations]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}}) for Auto Tiering databases and prepare and format the flash memory.
+
+After you [install on Linux](#install-on-linux), use the `prepare_flash` script to prepare and format flash memory:
+
+```sh
+sudo /opt/redislabs/sbin/prepare_flash.sh
+```
+
+This script finds unformatted disks and mounts them as RAID partitions in `/var/opt/redislabs/flash`.
+
+To verify the disk configuration, run:
+
+```sh
+sudo lsblk
+```
+
+## More info and options
+
+To learn more about customization and find answers to related questions, see:
+
+- [CentOS/RHEL firewall configuration]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/7.4/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/7.4/networking/cluster-lba-setup.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/7.4/networking/mdns.md" >}})
+- [File locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Supported platforms]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms.md" >}})
+
+## Limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Next steps
+
+1. [Create]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup.md" >}})
+    or [join]({{< relref "/operate/rs/7.4/clusters/add-node.md" >}}) an existing Redis Enterprise Software cluster.
+
+1. [Create a database]({{< relref "/operate/rs/7.4/databases/create" >}}).
+
+    For geo-distributed Active-Active replication, create an [Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/create.md" >}}) database.
+
+1. [Add users]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/7.4/security/access-control" >}}).
+---
+Title: Supported platforms
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software is supported on several operating systems,
+  cloud environments, and virtual environments.
+linkTitle: Supported platforms
+weight: 30
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms/'
+---
+{{< embed-md "supported-platforms-embed.md">}}
+---
+Title: Configure AWS EC2 instances for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Considerations for installing and running Redis Enterprise Software on
+  Amazon Elastic Cloud Compute (EC2) instances.
+linkTitle: AWS EC2 configuration
+weight: 80
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/configuring-aws-instances/'
+---
+There are some special considerations for installing
+and running Redis Enterprise Software on Amazon Elastic Cloud Compute (EC2) instances. 
+
+These include:
+
+- [Storage considerations](#storage)
+- [Instance types](#instance-types)
+- [Security group configuration](#security)
+
+## Storage considerations {#storage}
+
+AWS EC2 instances are ephemeral, but your persistent database storage should
+not be. If you require a persistent storage location for your database,
+the storage must be located outside of the instance. When you
+set up an instance, make sure it has a properly sized EBS-backed volume
+connected. When you set up Redis Enterprise Software on the instance, make sure that [the
+persistence storage]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) is configured to use this volume.
+
+{{< note >}}
+After [installing the Redis Enterprise Software package]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) on the instance
+and **before** running through [the setup process]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup.md" >}}),
+you must give the group `redislabs` permission to the EBS volume by
+running the following command from the OS command-line interface (CLI):
+```sh
+chown redislabs:redislabs /< ebs folder name>
+```
+{{< /note >}}
+
+Another feature that may be of importance to you is the use of
+Provisioned IOPS for EBS-backed volumes. Provisioned IOPS guarantee a
+certain level of disk performance. There are two features in Redis Enterprise Software where
+this feature could be critical to use:
+
+1. When using [Auto Tiering]({{< relref "/operate/rs/7.4/databases/auto-tiering/" >}})
+1. When using AOF on every write and there is a high write load. In
+    this case, the provisioned IOPS should be on the nodes used as
+    replicas in the cluster.
+
+## Instance types {#instance-types}
+
+Choose an instance type that has (at minimum) enough free memory and
+disk space to meet the Redis Enterprise Software [hardware
+requirements]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+In addition, some instance types are optimized for EBS-backed volumes
+and some are not. If you are using persistent storage, you should use an
+instance type that is, especially if disk drain rate matters to your database
+implementation.
+
+## Security group configuration {#security}
+
+When configuring the security group:
+
+- Define a custom TCP rule for port 8443 to allow web browser access
+    to the Redis Enterprise Software Cluster Manager UI from the IP address range you use to
+    access the Cluster Manager UI.
+- If you are using the DNS resolving option with Redis Enterprise Software, define a DNS UDP
+    rule for port 53 to allow access to the databases' endpoints by
+    using the [DNS resolving mechanism]({{< relref "/operate/rs/7.4/networking/cluster-dns" >}}).
+- To create a cluster that has multiple nodes all running as instances on AWS,
+    you need to define a security group that has an All TCP rule for all ports, 0 - 65535,
+    and add it to all instances that are part of the cluster.
+    This ensures that all nodes are able to communicate with each other.
+    To limit the number of open ports, you can open only the [ports used by Redis Enterprise Software]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}).
+
+After successfully launching the instances:
+
+1. Install Redis Enterprise Software from the [Linux package or AWS AMI]({{< relref "/operate/rs/7.4/installing-upgrading" >}}).
+2. [Set up the cluster]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup.md" >}}).
+---
+Title: File locations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software file installation locations.
+linkTitle: File locations
+weight: 60
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/file-locations/'
+---
+{{<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.
+{{</warning>}}
+
+## Application directories
+
+The directories that Redis Enterprise Software installs into are:
+
+| **Path** | **Description** |
+|------------|-----------------|
+| /opt/redislabs | Main installation directory for all Redis Enterprise Software binaries |
+| /opt/redislabs/bin | Binaries for all the utilities for command-line access and management, such as [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}) or [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}) |
+| /opt/redislabs/config | System configuration files |
+| /opt/redislabs/lib | System library files |
+| /opt/redislabs/sbin | System binaries for tweaking provisioning |
+
+## Configuration and data directories
+
+The default directories that Redis Enterprise Software uses for data and metadata are:
+
+| **Path** | **Description** |
+|------------|-----------------|
+| /var/opt/redislabs | Default storage location for the cluster data, system logs, backups, and ephemeral, persisted data |
+| /var/opt/redislabs/log | System logs for Redis Enterprise Software |
+| /var/opt/redislabs/run | Socket files for Redis Enterprise Software |
+| /etc/opt/redislabs | Default location for cluster manager configuration and certificates |
+| /tmp | Temporary files |
+
+You can change these file locations for:
+
+- [Ephemeral and persistence storage]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup.md" >}}) during cluster setup
+- [Socket files]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/change-location-socket-files.md" >}}) after cluster setup
+---
+Title: Persistent and ephemeral node storage
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Configure paths for persistent storage and ephemeral storage.
+linktitle: Persistent node storage
+toc: 'true'
+weight: 50
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage/'
+---
+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]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-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.
+{{< /note >}}
+
+## 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.
+
+To set the frequency of syncs, you can configure [persistence]({{< relref "/operate/rs/7.4/databases/configure/database-persistence" >}})
+options for a database.
+    
+The persistent volume must be a storage area network (SAN)
+using an EXT4 or XFS file system and be connected as an external storage volume.
+    
+When using append-only file (AOF) persistence, use flash-based storage
+for the persistent volume.
+
+## Ephemeral storage
+
+Ephemeral storage is optional. If configured, temporary information that does not need to be persisted is stored by the cluster in the ephemeral storage.
+This improves performance and helps reduce the load on the persistent storage.
+
+Ephemeral storage must be a locally attached volume on each node.
+
+## Disk size requirements
+
+For disk size requirements, see:
+
+- [Hardware
+    requirements]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements" >}})
+    for general guidelines regarding the ideal disk size for each type of
+    storage.
+- [Disk size requirements for extreme write
+    scenarios]({{< relref "/operate/rs/7.4/clusters/optimize/disk-sizing-heavy-write-scenarios" >}})
+    for special considerations when dealing with a high rate of write
+    commands.
+---
+Title: Plan Redis Enterprise Software deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Plan a deployment of Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Plan deployment
+weight: 4
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/'
+---
+
+Before installing Redis Enterprise Software, you need to:
+
+- Set up your hardware. See [Hardware requirements]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) and [Persistent and ephemeral node storage 
+]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) for more information.
+
+- Choose your [deployment platform]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+    Redis Enterprise Software supports a variety of platforms, including:
+
+    - Multiple Linux distributions (Ubuntu, Red Hat Enterprise Linux (RHEL), IBM CentOS, Oracle Linux)
+    - [Amazon AWS AMI]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/configuring-aws-instances" >}})
+    - [Docker container]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}}) (for development and testing only)
+    - [Kubernetes]({{< relref "/operate/kubernetes" >}})
+
+    For more details, see [Supported platforms]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+- Open appropriate [network ports]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}) in the firewall to allow connections to the nodes.
+
+- Configure [cluster DNS]({{< relref "/operate/rs/7.4/networking/cluster-dns.md" >}}) so that cluster nodes can reach each other by DNS names.
+- By default, the installation process requires an internet connection to install dependencies and synchronize the operating system clock. To learn more, see [Offline installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/offline-installation" >}}).
+
+## Next steps
+
+After you finish planning your deployment, you can:
+
+- [Download an installation package]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install/download-install-package" >}}).
+
+- [Prepare to install]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install" >}}) Redis Enterprise Software.
+
+- [View installation questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions" >}}) and prepare answers before installation.
+---
+Title: Hardware requirements
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Redis Enterprise Software hardware requirements for development and production
+  environments.
+linkTitle: Hardware requirements
+weight: 20
+url: '/operate/rs/7.4/installing-upgrading/install/plan-deployment/hardware-requirements/'
+---
+{{< embed-md "hardware-requirements-embed.md" >}}
+
+## Sizing considerations
+
+### General database sizing {#general-sizing}
+
+Factors to consider when sizing your database.
+
+- **Dataset size** – Your limit should be greater than your dataset size to leave room for overhead.
+- **Database throughput** – High throughput needs more shards, leading to a higher memory limit.
+- [**Modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) – Using modules with your database consumes more memory.
+- [**Database clustering**]({{< relref "/operate/rs/7.4/databases/durability-ha/clustering" >}}) – Allows you to spread your data into shards across multiple nodes.
+- [**Database replication**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}) – Enabling replication doubles memory consumption.
+
+### Active-Active database sizing {#active-active-sizing}
+
+Additional factors for sizing Active-Active databases:
+
+- [**Active-Active replication**]({{< relref "/operate/rs/7.4/databases/active-active" >}}) – Requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**Database replication backlog**]({{< relref "/operate/rs/7.4/databases/durability-ha/replication#database-replication-backlog" >}}) – For synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/7.4/databases/active-active/manage#replication-backlog" >}}) – For synchronization between clusters. By default, this is set to 1% of the database size.
+
+{{<note>}}
+Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit.
+{{</note>}}
+
+### Sizing databases with Auto Tiering enabled  {#redis-on-flash-sizing}
+
+Additional factors for sizing  databases with Auto Tiering enabled:
+
+- [**Database persistence**]({{< relref "/operate/rs/7.4/databases/configure/database-persistence#redis-on-flash-data-persistence" >}}) – Auto Tiering uses dual database persistence where both the primary and replica shards persist to disk. This may add some processor and network overhead, especially in cloud configurations with network-attached storage.
+
+---
+Title: Customize installation directories
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Customize Redis Enterprise Software installation directories.
+linkTitle: Customize install locations
+weight: 30
+url: '/operate/rs/7.4/installing-upgrading/install/customize-install-directories/'
+---
+
+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.
+
+{{< note >}}
+- When you install with custom directories, the installation does not run as an RPM file.
+- If a `redislabs` directory already exists in the path that you specify, the installation fails.
+- All nodes in a cluster must be installed with the same file locations.
+- Custom installation directories are not supported for databases using Auto Tiering.
+{{< /note >}}
+
+You can specify these file locations:
+
+| Files               | Installer flag | Example parameter | Example file location |
+| ------------------- | -------------- | ----------------- | --------------------- |
+| Binaries files      | --install-dir  | /opt              | /opt/redislabs        |
+| Configuration files | --config-dir   | /etc/opt          | /etc/opt/redislabs    |
+| Data and log files  | --var-dir      | /var/opt          | /var/opt/redislabs    |
+
+These files are not in the custom directories:
+
+- OS files
+    - /etc/cron.d/redislabs
+    - /etc/firewalld/services
+    - /etc/firewalld/services/redislabs-clients.xml
+    - /etc/firewalld/services/redislabs.xml
+    - /etc/ld.so.conf.d/redislabs_ldconfig.conf.tmpl
+    - /etc/logrotate.d/redislabs
+    - /etc/profile.d/redislabs_env.sh
+    - /usr/lib/systemd/system/rlec_supervisor.service.tmpl
+    - /usr/share/selinux/mls/redislabs.pp
+    - /usr/share/selinux/targeted/redislabs.pp
+
+- Installation reference files
+    - /etc/opt/redislabs/redislabs_custom_install_version
+    - /etc/opt/redislabs/redislabs_env_config.sh
+
+To specify directories during [installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}), include installer flags as [command-line options]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) when you run the `install.sh` script. For example:
+
+```sh
+sudo ./install.sh --install-dir <path> --config-dir <path> --var-dir <path>
+```
+ 
+## Limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use custom installation directories.
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+---
+Title: Offline installation
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: If you install Redis Enterprise Software on a machine with no internet
+  connection, you need to perform two tasks manually.
+linkTitle: Offline installation
+weight: 60
+url: '/operate/rs/7.4/installing-upgrading/install/offline-installation/'
+---
+By default, the installation process requires an internet connection to
+enable installing dependency packages and for [synchronizing the
+operating system clock]({{< relref "/operate/rs/7.4/clusters/configure/sync-clocks.md" >}}) 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.
+
+## Set up NTP time synchronization
+
+At the end of the installation, the process asks if you want to set up NTP time synchronization. If you choose `Yes` while you are not connected to the internet, the action fails and displays the appropriate error message, but the installation completes successfully. Despite the successful completion of the installation, you still have to configure all nodes for [NTP time synchronization]({{< relref "/operate/rs/7.4/clusters/configure/sync-clocks.md" >}}).
+---
+Title: Customize system user and group
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Specify the user and group who own all Redis Enterprise Software processes.
+linkTitle: Customize user and group
+weight: 40
+url: '/operate/rs/7.4/installing-upgrading/install/customize-user-and-group/'
+---
+
+By default, Redis Enterprise Software is installed with the user:group `redislabs:redislabs`. See [Access control]({{< relref "/operate/rs/7.4/security/access-control" >}}) for user and group security information.
+
+During installation, you can specify the user and group that own all Redis Enterprise Software processes.
+
+If you specify the user only, then installation is run with the primary group that the user belongs to.
+
+{{< note >}}
+- Custom installation user is supported on Red Hat Enterprise Linux.
+- When you install with custom directories, the installation does not run as an RPM file.
+- You must create the user and group before attempting to install Redis Software.
+- You can specify an LDAP user as the installation user.
+{{< /note >}}
+
+To customize the user or group during [installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}), include the `--os-user` or `--os-group` [command-line options]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) when you run the `install.sh` script. For example:
+
+```sh
+sudo ./install.sh --os-user <user> --os-group <group>
+```
+
+---
+Title: Download a Redis Enterprise Software installation package
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Download a Redis Enterprise Software installation package.
+linkTitle: Download installation package
+weight: 20
+url: '/operate/rs/7.4/installing-upgrading/install/prepare-install/download-install-package/'
+---
+
+To download the installation package for any of the supported platforms:
+
+1. Go to the [Redis download page](https://cloud.redis.io/#/rlec-downloads).
+1. Sign in with your Redis credentials or create a new account.
+1. 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]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/configuring-aws-instances" >}}).
+{{< /note >}}
+---
+Title: Ensure port availability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Make sure required ports are available.
+linkTitle: Ensure port availability
+weight: 40
+url: '/operate/rs/7.4/installing-upgrading/install/prepare-install/port-availability/'
+---
+
+Before [installing Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/install" >}}), make sure all required ports are available.
+
+{{<embed-md "port-availability-embed.md">}}
+
+## Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+## OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+---
+Title: Prepare to install Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prepare to install Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Prepare to install
+weight: 6
+url: '/operate/rs/7.4/installing-upgrading/install/prepare-install/'
+---
+
+Before you install Redis Enterprise Software:
+
+- [Download an installation package]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install/download-install-package" >}}).
+
+- [View installation questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions" >}}) and optionally prepare answers before installation.
+
+- Review the [security considerations]({{< relref "/operate/rs/7.4/security/" >}}) for your deployment.
+
+- Check that you have root-level access to each node, either directly or with `sudo`.
+
+- Check that all [required ports are available]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install/port-availability" >}}).
+
+- [Turn off Linux swap]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/linux-swap.md" >}}) on all cluster nodes.
+
+- If you require the `redislabs` UID (user ID) and GID (group ID) numbers to be the same on all the nodes, create the `redislabs` user and group with the required numbers on each node.
+
+- If you want to use Auto Tiering for your databases, see [Auto Tiering installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux#auto-tiering-installation" >}}).
+
+## Next steps
+
+- View [installation script options]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) before starting the installation.
+
+- [Install Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/install" >}}).
+---
+Title: Install Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Install Redis Enterprise Software on Linux.
+hideListLinks: true
+linkTitle: Install
+weight: 35
+url: '/operate/rs/7.4/installing-upgrading/install/'
+---
+
+After you [plan your deployment]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment" >}}), [download a Redis Enterprise Software installation package]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install/download-install-package" >}}), and finish [installation preparation]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install" >}}):
+
+1. [Install the Redis Enterprise Software package]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}) on one of the nodes in the cluster.
+
+1. Repeat this process for each node in the cluster.
+
+For installation on machines without an internet connection, see [Offline installation]({{< relref "/operate/rs/7.4/installing-upgrading/install/offline-installation" >}}).
+
+## Permissions and access
+
+- Redis Enterprise Software installation creates the `redislabs:redislabs` user and group. 
+
+    Assigning other users to the `redislabs` group is optional. Users belonging to the `redislabs` group have permission to read and execute (e.g. use the `rladmin` status command) but are not allowed to write (or delete) files or directories.
+
+- Redis Enterprise Software is certified to run with permissions set to `750`, an industry standard.
+
+    {{<warning>}}
+Do not reduce permissions to `700`. This configuration has not been tested and is not supported.
+    {{</warning>}}
+
+## More info and options
+
+If you've already installed Redis Enterprise Software, you can also:
+
+- [Upgrade an existing deployment]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading" >}}).
+
+- [Uninstall an existing deployment]({{< relref "/operate/rs/7.4/installing-upgrading/uninstalling.md" >}}).
+
+To learn more about customization and find answers to related questions, see:
+
+- [CentOS/RHEL Firewall configuration]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/7.4/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/7.4/networking/cluster-lba-setup.md" >}})
+- [File locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Supported platforms]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms.md" >}})
+- [Manage installation questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/7.4/networking/mdns.md" >}})
+- [User and group ownership]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}})
+
+## Next steps
+
+After your cluster is set up with nodes, you can:
+
+- [Add users]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/7.4/security/access-control" >}}).
+- [Create databases]({{< relref "/operate/rs/7.4/databases/create" >}}) to use with your applications.
+
+---
+Title: Installation script command-line options
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Command-line options for the install.sh script.
+linkTitle: Installation script options
+weight: 20
+url: '/operate/rs/7.4/installing-upgrading/install/install-script/'
+---
+
+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<br/>See [Manage install questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions" >}})|
+| <nobr>`-c <answer file>`</nobr> | Specify answer file used to respond to install prompts<br/>See [Manage install questions]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions" >}})|
+| <nobr>`-s <socket dir>`</s> | Specify directory for redislabs unix sockets  _(new installs only)_|
+| <nobr>`--install-dir <dir>`</nobr> | Specifies installation directory _(new installs only)_ <br/> See [Customize install locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-install-directories" >}})|  
+| <nobr>`--config-dir <dir>` | Configuration file directory *(new installs only)* <br/>See [Customize install locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-install-directories" >}})|
+| <nobr>`--var-dir <dir>`</nobr> | Var directory used for installation *(new installs only)* <br/>See [Customize install locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-install-directories" >}})|
+| <nobr>`--os-user <user>`| Operating system user account associated with install; default: `redislabs`<br/>See [Customize user and group]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group" >}}) *(new installs only)*|
+|<nobr>`--os-group <group>` | Operating system group associated with install; default: `redislabs`<br/>See [Customize user and group]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group" >}}) *(new installs only)* |
+---
+Title: Redis Enterprise Software product lifecycle
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The product lifecycle of Redis Enterprise Software.
+linkTitle: Product lifecycle
+weight: 100
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/installing-upgrading/product-lifecycle/'
+---
+The Redis Enterprise Software product lifecycle fully reflects the [subscription agreement](https://redis.com/software-subscription-agreement).
+However, for any discrepancy between the two policies, the subscription agreement prevails.
+
+Redis Enterprise modules follow the [modules lifecycle]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}).
+
+## Release numbers
+
+Redis uses a four-place numbering scheme to designate released versions of its products.
+The format is “Major1.Major2.Minor-Build”.
+
+- Major sections of the version number represents fundamental changes and additions in
+    capabilities to Redis  Enterprise Software. The Major1 and Major2 part of the
+    version number are incremented based on the size and scale of the changes in each
+    release.
+- The Minor section of the version number represents quality improvements, fixes to
+    existing capabilities, and new capabilities which are typically minor, feature-flagged, or optional. 
+- Build number is incremented with any changes to the product. Build number is
+    incremented with each build when any change is made to the binaries.
+
+Redis Enterprise Software typically gets two major releases every year but the product shipping cycles may vary.
+Maintenance releases, typically available on the last minor release of the current major1.major2 release are typically made available on a monthly cadence, although cycles may vary.
+
+## End-of-life schedule {#endoflife-schedule}
+
+For Redis Enterprise Software versions 6.2 and later, the end-of-life (EOL) for each major release occurs 24 months after the formal release of the subsequent major version. Monthly maintenance will be provided on the last minor release of the major1.major2 releases.
+This update to the EOL policy allows a lead time of at least 24 months to upgrade to the new release after it is available.
+
+
+| Version - Release date | End of Life (EOL)  |
+| ----------------------------------------- | ------------------ |
+| 7.4 – February 2024				        | - |
+| 7.2 – August 2023				            | February 28, 2026 |
+| 6.4 – February 2023						| August 31, 2025 |
+| 6.2 – August 2021                         | February 28, 2025  |
+| 6.0 – May 2020                            | May 31, 2022  |
+| 5.6 – April 2020                          | October 31, 2021  |
+| 5.4 – December 2018                       | December 31, 2020  |
+| 5.2 – June 2018                           | December 31, 2019  |
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+For detailed upgrade instructions, see [Upgrade a Redis Enterprise Software cluster]({{<relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster">}}).
+---
+LinkTitle: Uninstall
+Title: Uninstall Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+weight: 70
+url: '/operate/rs/7.4/installing-upgrading/uninstalling/'
+---
+
+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]({{<relref "/operate/rs/7.4/clusters/remove-node">}}).
+
+## Uninstall Redis Enterprise Software
+
+To uninstall Redis Enterprise Software from a cluster node:
+
+1. Navigate to the script's location, which is in `/opt/redislabs/bin/` by default.
+
+1. Run the uninstall script as the root user:
+
+    ```sh
+    sudo ./rl_uninstall.sh
+    ```
+
+When you run the uninstall script on a node, it only uninstalls Redis Enterprise Software from that node. To uninstall Redis Enterprise Software for the entire cluster, run the uninstall script on each cluster node.
+---
+Title: Upgrade a cluster's operating system
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a Redis Enterprise Software cluster's operating system to a later
+  major version.
+linkTitle: Upgrade operating system
+toc: 'true'
+weight: 70
+url: '/operate/rs/7.4/installing-upgrading/upgrading/upgrade-os/'
+---
+
+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:
+
+1. [Upgrade all nodes in the cluster]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster" >}}) to a Redis Enterprise Software version that supports the OS's current version and upgrade version.
+
+    To learn which versions of Redis Enterprise Software support specific OS versions, see [Supported platforms]({{< relref "/operate/rs/7.4/references/supported-platforms#supported-platforms" >}}).
+
+1. If the cluster contains databases that use modules:
+
+    1. Update all nodes in the cluster to [Redis Enterprise Software version 7.2.4-52]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases" >}}) or later before you upgrade the OS.
+
+    1. Check the status of modules using [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}):
+
+        ```sh
+        rladmin status modules
+        ```
+
+        The output lists the module versions installed on the cluster and the module versions used by existing databases:
+
+        ```sh
+        CLUSTER MODULES:
+        MODULE                                                                      VERSION                            
+        RedisBloom                                                                  2.6.3                              
+        RediSearch 2                                                                2.8.4                              
+        RedisGears                                                                  2.0.12                             
+        RedisGraph                                                                  2.10.12                            
+        RedisJSON                                                                   2.6.6                              
+        RedisTimeSeries                                                             1.10.6                             
+
+        DATABASE MODULES:
+        DB:ID    NAME       MODULE              VERSION     ARGS                     STATUS                            
+        db:1     db1        RediSearch 2        2.6.9       PARTITIONS AUTO          OK, OLD MODULE VERSION            
+        db:1     db1        RedisJSON           2.4.7                                OK, OLD MODULE VERSION  
+        ```
+
+    1. If any databases use custom modules, manually uploaded modules, or modules marked with `OLD MODULE VERSION`, upload module packages for the OS upgrade version to a cluster node. See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}) for instructions.
+
+        {{<note>}}
+The uploaded module packages have the following requirements:
+
+- The module is compiled for the OS upgrade version.
+    
+- The module version matches the version currently used by databases.
+        {{</note>}}
+
+1. If the cluster uses custom directories, make sure the OS upgrade version also supports custom directories, and specify the same custom directories during installation for all nodes. See [Customize installation directories]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-install-directories" >}}) for details.
+
+## Perform OS rolling upgrade
+
+To upgrade the cluster's operating system, use one of the following rolling upgrade methods:
+
+- [Extra node method](#extra-node-upgrade) - recommended if you have additional resources available
+
+- [Replace node method](#replace-node-upgrade) - recommended if you cannot temporarily allocate additional resources
+
+### Extra node upgrade method {#extra-node-upgrade}
+
+1. Create a node with the OS upgrade version.
+
+1. [Install the cluster's current Redis Enterprise Software version]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}) on the new node using the installation package for the OS upgrade version.
+
+1. [Add the new node]({{< relref "/operate/rs/7.4/clusters/add-node" >}})  to the cluster.
+
+1. [Remove one node]({{< relref "/operate/rs/7.4/clusters/remove-node#remove-a-node" >}}) running the earlier OS version from the cluster.
+
+1. Repeat the previous steps until all nodes with the earlier OS version are removed.
+
+### Replace node upgrade method {#replace-node-upgrade}
+
+1. [Remove a node]({{< relref "/operate/rs/7.4/clusters/remove-node#remove-a-node" >}}) with the earlier OS version from the cluster.
+
+1. Uninstall Redis Enterprise Software from the removed node:
+
+    ```sh
+    sudo ./rl_uninstall.sh
+    ```
+
+1. Either upgrade the existing node to the OS upgrade version, or create a new node with the OS upgrade version.
+
+1. [Install the cluster's current Redis Enterprise Software version]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-on-linux" >}}) on the upgraded node using the installation package for the OS upgrade version.
+
+1. [Add the new node]({{< relref "/operate/rs/7.4/clusters/add-node" >}}) to the cluster.
+
+    If you want to reuse the removed node's ID when you add the node to the cluster, run [`rladmin cluster join`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/join" >}}) with the `replace_node` flag:
+
+    ```sh
+    rladmin cluster join nodes <cluster_member_ip_address> username <username> password <password> replace_node <node_id>
+    ```
+
+1. Verify node health:
+
+    1. Run `rlcheck` on all nodes:
+
+        ```sh
+        rlcheck
+        ```
+
+        The output lists the result of each verification test:
+
+        ```sh
+        ##### Welcome to Redis Enterprise Cluster settings verification utility ####
+        Running test: verify_bootstrap_status
+		                PASS
+        ...
+        Running test: verify_encrypted_gossip
+		                PASS
+        Summary:
+        -------
+        ALL TESTS PASSED.
+        ```
+
+        For healthy nodes, the expected output is `ALL TESTS PASSED`.
+
+    1. Run [`rladmin status`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) on the new node:
+
+        ```sh
+        rladmin status extra all
+        ```
+
+        The expected output is the `OK` status for the cluster, nodes, endpoints, and shards:
+
+        ```sh
+        CLUSTER:
+        OK. Cluster master: 2 (<IP.address>)
+        Cluster health: OK, [0, 0.0, 0.0]
+        failures/minute - avg1 0.00, avg15 0.00, avg60 0.00.
+        ...
+        ```
+
+1. Repeat the previous steps until all nodes with the earlier OS version are replaced.
+---
+Title: Upgrade a Redis Enterprise Software cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a Redis Enterprise Software cluster.
+linkTitle: Upgrade cluster
+toc: 'true'
+weight: 30
+tocEmbedHeaders: true
+url: '/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster/'
+---
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/7.4/installing-upgrading/product-lifecycle">}}) for more information about release numbers and the end-of-life schedule.
+
+## Upgrade prerequisites
+
+Before upgrading a cluster:
+
+- Verify access to [rlcheck]({{< relref "/operate/rs/7.4/references/cli-utilities/rlcheck/" >}}) and [rladmin]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/#use-the-rladmin-shell" >}}) commands
+
+- Verify that you meet the upgrade path requirements for your desired cluster version and review the relevant [release notes]({{< relref "/operate/rs/release-notes" >}}) for any preparation instructions.
+
+- Avoid changing the database configuration or performing other cluster management operations during the upgrade process, as this might cause unexpected results.
+
+- Upgrade the cluster's primary (master) node first. To identify the primary node, use one of the following methods:
+
+    - **Nodes** screen in the new Cluster Manager UI (only available for Redis Enterprise versions 7.2 and later)
+
+    - [`rladmin status nodes`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-nodes" >}}) command
+    
+    - [`GET /nodes/status`]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes/status#get-all-nodes-status" >}}) REST API request
+
+## Upgrade cluster
+
+Starting with the primary (master) node, follow these steps for every node in the cluster. To ensure cluster availability, upgrade each node separately.
+
+1.  Verify node operation with the following commands:
+
+    ``` shell
+    $ rlcheck
+    $ rladmin status extra all
+    ```
+
+2.  Download the Redis Enterprise Software installation package to the machine running the node from the Download Center on [https://cloud.redis.io](https://cloud.redis.io).  
+
+3.  Extract the installation package:
+
+    ```sh
+    tar vxf <tarfile name>
+    ```
+
+    {{<note>}}
+You cannot change the installation path or the user during the upgrade.
+    {{</note>}}
+
+1.  Run the install command. See [installation script options]({{< relref "/operate/rs/7.4/installing-upgrading/install/install-script" >}}) for a list of command-line options you can add to the following command:
+
+    ``` shell
+    sudo ./install.sh
+    ```
+
+    The installation script automatically recognizes the upgrade and responds accordingly.
+
+    The upgrade replaces all node processes, which might briefly interrupt any active connections.
+
+2.  Verify the node was upgraded to the new version and is still operational:
+
+    ``` shell
+    $ rlcheck
+    $ rladmin status extra all
+    ```
+
+3.  Visit the Cluster Manager UI.
+
+    If the Cluster Manager UI was open in a web browser during the upgrade, refresh the browser to reload the console.
+
+After all nodes are upgraded, the cluster is fully upgraded. Certain features introduced in the new version of Redis Enterprise Software only become available after upgrading the entire cluster.
+
+After upgrading from version 6.0.x to 6.2.x, restart `cnm_exec` on each cluster node to enable more advanced state machine handling capabilities:
+
+```sh
+supervisorctl restart cnm_exec
+```
+---
+Title: Upgrade an Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade an Active-Active database.
+linkTitle: Active-Active databases
+weight: 70
+url: '/operate/rs/7.4/installing-upgrading/upgrading/upgrade-active-active/'
+---
+
+When you upgrade an [Active-Active (CRDB) database]({{< relref "/operate/rs/7.4/databases/active-active" >}}), you can also upgrade the CRDB protocol version and feature version.
+
+## CRDB protocol version guidelines
+
+Redis Enterprise Software versions 5.4.2 and later use CRDB protocol version 1 to help support Active-Active features.
+
+CRDB protocol version 1 is backward compatible, which means Redis Enterprise v5.4.2 CRDB instances can understand write operations from instances using the earlier CRDB protocol version 0.
+
+After you upgrade one instance's CRDB protocol to version 1:
+
+- Any instances that use CRDB protocol version 1 can receive updates from both version 1 and version 0 instances.
+
+- However, instances that still use CRDB protocol version 0 cannot receive write updates from version 1 instances.
+
+- After you upgrade an instance from CRDB protocol version 0 to version 1, it automatically receives any missing write operations.
+
+Follow these upgrade guidelines:
+
+- Upgrade all instances of a specific CRDB within a reasonable time frame to avoid temporary inconsistencies between the instances.
+
+- Make sure that you upgrade all instances of a specific CRDB before you do global operations on the CRDB, such as removing instances and adding new instances.
+
+- As of v6.0.20, protocol version 0 is deprecated and support will be removed in a future version.
+
+- To avoid upgrade failures, update all Active-Active databases to protocol version 1 _before_ upgrading Redis Enterprise Software to v6.0.20 or later.
+
+## Feature version guidelines
+
+Starting with version 5.6.0, a new feature version (also called a _feature set version_) helps support new Active-Active features.
+
+When you update the feature version for an Active-Active database, the feature version is updated for all database instances.
+    
+Follow these upgrade guidelines:
+
+- As of v6.0.20, feature version 0 is deprecated and support will be removed in a future version.
+
+- To avoid upgrade failures, update all Active-Active databases to protocol version 1 _before_ upgrading Redis Enterprise Software to v6.0.20 or later.
+
+## Upgrade Active-Active database instance
+
+To upgrade an Active-Active database (CRDB) instance:
+
+1. [Upgrade Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster" >}}) on each node in the clusters where the Active-Active instances are located.
+
+1. To see the status of your Active-Active instances, run: 
+
+    ```sh
+    rladmin status
+    ```
+
+    The statuses of the Active-Active instances on the node can indicate:
+
+    - `OLD REDIS VERSION`
+    - `OLD CRDB PROTOCOL VERSION`
+    - `OLD CRBD FEATURESET VERSION`
+
+    {{< image filename="/images/rs/crdb-upgrade-node.png" >}}
+
+1. To upgrade each Active-Active instance, including the Redis version and CRDB protocol version, run:
+
+    - To upgrade a database without modules:
+
+        ```sh
+        rladmin upgrade db <database_name | database_ID>
+        ```
+    
+    - If the database has modules enabled and new module versions are available in the cluster, run `rladmin upgrade db` with additional parameters to upgrade the module versions when you upgrade the database. See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) for more details.
+
+    If the protocol version is old, read the warning message carefully and confirm.
+
+    {{< image filename="/images/rs/crdb-upgrade-protocol.png" >}}
+
+    The Active-Active instance uses the new Redis version and CRDB protocol version.
+
+    Use the `keep_crdt_protocol_version` option to upgrade the database feature version 
+without upgrading the CRDB protocol version.
+
+    If you use this option, make sure that you upgrade the CRDB protocol soon after with the [`rladmin upgrade db`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/upgrade#upgrade-db" >}}) command.
+
+    You must upgrade the CRDB protocol before you update the CRDB feature set version.
+
+1. If the feature set version is old, you must upgrade all of the Active-Active instances. Then, to update the feature set for each active-active database, run:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --featureset-version yes
+    ```
+
+    You can retrieve the `<CRDB-GUID>` with the following command:
+
+    ```sh
+    crdb-cli crdb list
+    ```
+
+    Look for the fully qualified domain name (CLUSTER-FDQN) of your cluster and use the associated GUID:
+
+    ```sh
+    CRDB-GUID                             NAME    REPL-ID  CLUSTER-FQDN
+    700140c5-478e-49d7-ad3c-64d517ddc486  aatest  1        aatest1.example.com
+    700140c5-478e-49d7-ad3c-64d517ddc486  aatest  2        aatest2.example.com
+    ```
+
+1. Update module information in the CRDB configuration using the following command syntax:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <guid> --default-db-config \
+    '{ "module_list": 
+      [
+        { 
+          "module_name": "<module1_name>",
+          "semantic_version": "<module1_version>" 
+        },
+        { 
+          "module_name": "<module2_name>",
+          "semantic_version": "<module2_version>" 
+        }
+      ]}'
+    ```
+
+    For example:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid 82a80988-f5fe-4fa5-bca0-aef2a0fd60db --default-db-config \
+    '{ "module_list": 
+      [
+        {
+          "module_name": "search",
+          "semantic_version": "2.4.6"
+        },
+        {
+          "module_name": "ReJSON",
+          "semantic_version": "2.4.5"
+        }
+      ]}' 
+    ```
+---
+Title: Upgrade a Redis Enterprise Software database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a Redis Enterprise Software database.
+linkTitle: Upgrade database
+weight: 50
+url: '/operate/rs/7.4/installing-upgrading/upgrading/upgrade-database/'
+---
+
+## Default Redis database versions {#default-db-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]({{< relref "/operate/rs/7.4/references/rest-api/requests/bdbs" >}}) or [`rladmin upgrade db`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/upgrade#upgrade-db" >}}).
+
+Redis Enterprise Software v6.x includes two Redis database versions: 6.0 and 6.2.
+As of version 7.2, Redis Enterprise Software includes three Redis database versions.
+
+To view available Redis database versions:
+
+- In the Cluster Manager UI, see **Redis database versions** on the **Cluster > Configuration** screen.
+
+- Send a [`GET /nodes` REST API request]({{< relref "/operate/rs/7.4/references/rest-api/requests/nodes" >}}) and see `supported_database_versions` in the response.
+
+The default Redis database version differs between Redis Enterprise releases as follows:
+
+| Redis<br />Enterprise | Bundled Redis<br />DB versions | Default DB version<br />(upgraded/new databases) |
+|-------|----------|-----|
+| 7.4.2 | 6.0, 6.2, 7.2 | 7.2 |
+| 7.2.4 | 6.0, 6.2, 7.2 | 7.2 |
+| 6.4.2 | 6.0, 6.2 | 6.2 |
+| 6.2.x | 6.0, 6.2 | 6.0 |
+
+
+The upgrade policy is only relevant for Redis Enterprise Software versions 6.2.4 through 6.2.18. For more information about upgrade policies, see the [6.2 version of this document](https://docs.redis.com/6.2/rs/installing-upgrading/upgrading/#redis-upgrade-policy).
+
+## Upgrade prerequisites
+
+Before upgrading a database:
+
+- Review the relevant [release notes]({{< relref "/operate/rs/release-notes" >}}) for any preparation instructions.
+
+- Verify that the database version meets the minimums specified earlier.
+
+    To determine the database version:
+
+    - Use the Cluster Manager UI to open the **Configuration** tab for the database and select {{< image filename="/images/rs/icons/info-icon.png#no-click" alt="The About database button" width="18px" class="inline" >}} **About**.
+
+    - _(Optional)_ Use the [`rladmin status extra all`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status" >}}) command to display configuration details:
+
+        ```sh
+        rladmin status extra all
+        ```
+    
+        When the database compatibility version is outdated, <nobr>`OLD REDIS VERSION`</nobr> appears in the command output.
+
+- Verify the cluster is fully upgraded and operational.
+
+    Use the Cluster Manager UI to display the **Configuration** tab for the cluster. The tab displays the cluster version information and the Redis database compatibility version.
+
+- Check client compatibility with the database version.
+
+    If you run Redis Stack commands with Go-Redis versions 9 and later or Lettuce versions 6 and later, set the client’s protocol version to RESP2 before upgrading your database to Redis version 7.2 to prevent potential application issues due to RESP3 breaking changes. See [Client prerequisites for Redis 7.2 upgrade]({{< relref "/operate/rs/7.4/references/compatibility/resp#client-prerequisites-for-redis-72-upgrade" >}}) for more details and examples.
+
+- To avoid data loss during the upgrade, [back up your data]({{< relref "/operate/rs/7.4/databases/import-export/schedule-backups" >}}).  
+
+    You can [export the data]({{< relref "/operate/rs/7.4/databases/import-export/export-data" >}}) to an external location, [enable replication]({{< relref "/operate/rs/7.4/databases/durability-ha/replication" >}}), or [enable persistence]({{< relref "/operate/rs/7.4/databases/configure/database-persistence" >}}).
+
+    When choosing how to back up data, keep the following in mind:
+
+    - To reduce downtime when replication is enabled, a failover is performed before restarting the primary (master) database.
+
+    - When persistence is enabled without replication, the database is unavailable during restart because the data is restored from the persistence file. AOF persistence restoration is slower than snapshot restoration.
+
+## Upgrade database
+
+To upgrade a database:
+
+1.  _(Optional)_  Back up the database to minimize the risk of data loss.
+
+1.  Use [`rladmin`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/upgrade" >}}) to upgrade the database. During the upgrade process, the database will restart without losing any data.
+
+    - To upgrade a database without modules:
+
+        ``` shell
+        rladmin upgrade db <database name | database ID>
+        ```
+
+        Example of a successful upgrade:
+
+        ``` shell
+        rladmin> upgrade db demo
+        Monitoring d194c4a3-631c-4726-b799-331b399fc85c
+        active - SMUpgradeBDB init
+        active - SMUpgradeBDB wait_for_version
+        active - SMUpgradeBDB configure_shards
+        completed - SMUpgradeBDB
+        Done
+        ```
+
+    - If the database has modules enabled and new module versions are available in the cluster, run `rladmin upgrade db` with additional parameters to upgrade the module versions when you upgrade the database. See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) for more details.
+
+    - To upgrade the database to a version other than the default version, use the `redis_version` parameter:
+
+        ```sh
+        rladmin upgrade db <database name | database ID> redis_version <version>
+        ```
+
+1. Check the Redis database compatibility version for the database to confirm the upgrade.  
+
+    To do so:
+
+    - Use the Cluster Manager UI to open the **Configuration** tab for the database and select {{< image filename="/images/rs/icons/info-icon.png#no-click" alt="The About database button" width="18px" class="inline" >}} **About**.
+
+    - Use [`rladmin status databases extra all`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/status#status-databases" >}}) to display a list of the databases in your cluster and their current Redis database compatibility version:
+
+        ```sh
+        rladmin status databases extra all
+        ```
+
+    Verify that the Redis version is set to the expected value.
+---
+Title: Upgrade an existing Redis Enterprise Software deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: true
+linkTitle: Upgrade
+weight: 60
+url: '/operate/rs/7.4/installing-upgrading/upgrading/'
+---
+To upgrade Redis Enterprise Software:
+
+1. Verify appropriate [network ports]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}}) are either open or used by Redis Enterprise Software.
+
+1. [Upgrade the software on all nodes of the cluster.]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster" >}})
+
+2. _(Optional)_ [Upgrade each database]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-database" >}}) in the cluster or [upgrade an Active-Active database]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-active-active" >}}) to enable new features and important fixes.
+---
+LinkTitle: Socket file location
+Title: Change socket file locations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Change socket file locations.
+weight: $weight
+url: '/operate/rs/7.4/installing-upgrading/configuring/change-location-socket-files/'
+---
+
+## Default socket file locations
+
+There are two default locations for the socket files in Redis Enterprise Software:
+
+- `/tmp` - In clean installations of Redis Enterprise Software version earlier than 5.2.2
+- `/var/opt/redislabs/run` - In clean installations of Redis Enterprise Software version 5.2.2 and later
+
+    {{<note>}}
+The default location was changed in case you run any maintenance procedures that delete the `/tmp` directory.
+    {{</note>}}
+
+When you upgrade Redis Enterprise Software from an earlier version to 5.2.2 or later, the socket files
+are not moved to the new location by default. You need to either specify a custom location
+for the socket files during [installation]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) or use the [following procedure](#change-socket-file-locations) after installation.
+
+## Change socket file locations
+
+To change the location of the socket files:
+
+1. On each node in the cluster, run:
+
+    ```sh
+    sudo rlutil create_socket_path socket_path=/var/opt/redislabs/run
+    ```
+
+1. Identify the node with the `master` role by running the following command on any node in the cluster:
+
+    ```sh
+    rladmin status nodes
+    ```
+
+1. On the master node, change the socket file location:
+
+    ```sh
+    sudo rlutil set_socket_path socket_path=/var/opt/redislabs/run
+    ```
+
+1. To update the socket file location for all other nodes, restart Redis Enterprise Software on each node in the cluster, one at a time:
+
+    ```sh
+    sudo service rlec_supervisor restart
+    ```
+
+1. Restart each database in the cluster to update the socket file location:
+
+    ```sh
+    rladmin restart db <db name>
+    ```
+
+    {{< warning >}}
+Restarting databases can cause interruptions in data traffic.
+    {{< /warning >}}
+---
+Title: Configure swap for Linux
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turn off Linux swap space.
+linkTitle: Linux swap configuration
+weight: $weight
+url: '/operate/rs/7.4/installing-upgrading/configuring/linux-swap/'
+---
+Linux operating systems use swap space, which is enabled by default, to help manage memory (pages) by
+copying pages from RAM to disk. Due to the way Redis Enterprise Software
+utilizes and manages memory, it is best to prevent OS swapping. For more details, see [memory limits]({{< relref "/operate/rs/7.4/databases/memory-performance/memory-limit.md" >}}). The
+recommendation is to turn off Linux swap completely in the OS.
+
+When you install or build the OS on the machine intended to host your Redis Enterprise Software cluster, avoid configuring swap partitions if possible.
+
+## Turn off swap
+
+To turn off swap in the OS of an existing server, VM, or instance, you
+must have `sudo` access or be a root user to run the following commands:
+
+1. Turn off swap:
+
+    ```sh
+    sudo swapoff -a
+    ```
+
+1. Comment out the swap partitions configured in the OS so swap remains off even after a reboot:
+
+    ```sh
+    sudo sed -i.bak '/ swap / s/^(.*)$/#1/g' /etc/fstab
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure firewall rules for Redis Enterprise Software on CentOS or Red
+  Hat Enterprise Linux (RHEL).
+linkTitle: CentOS/RHEL firewall
+title: Configure CentOS/RHEL firewall
+weight: $weight
+url: '/operate/rs/7.4/installing-upgrading/configuring/centos-rhel-firewall/'
+---
+CentOS and Red Hat Enterprise Linux (RHEL) distributions use [**firewalld**](https://firewalld.org/) by default to manage the firewall and configure [iptables](https://en.wikipedia.org/wiki/Iptables).
+The default configuration assigns the network interfaces to the **public** zone and blocks all ports except port 22, which is used for [SSH](https://en.wikipedia.org/wiki/Secure_Shell).
+
+When you install Redis Enterprise Software on CentOS or RHEL, it automatically creates two firewalld system services:
+
+- A service named **redislabs**, which includes all ports and protocols needed for communication between cluster nodes.
+- A service named **redislabs-clients**, which includes the ports and protocols needed for external communication (outside of the cluster).
+
+These services are defined but not allowed through the firewall by default.
+During Redis Enterprise Software installation, the [installer prompts]({{< relref "/operate/rs/7.4/installing-upgrading/install/manage-installation-questions" >}}) you to confirm auto-configuration of a default (public) zone
+to allow the **redislabs** service.
+
+Although automatic firewall configuration simplifies installation, your deployment might not be secure if you did not use other methods to secure the host machine's network, such as external firewall rules or security groups.
+You can use firewalld configuration tools such as **firewall-cmd** (command line) or **firewall-config** (UI)
+to create more specific firewall policies that allow these two services through the firewall, as necessary.
+
+{{<note>}}
+If databases are created with non-standard [Redis Enterprise Software ports]({{< relref "/operate/rs/7.4/networking/port-configurations" >}}),
+you need to explicitly configure firewalld to make sure those ports are not blocked.
+{{</note>}}
+---
+Title: Additional configuration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: false
+weight: 80
+url: '/operate/rs/7.4/installing-upgrading/configuring/'
+---
+This section describes additional configuration options for Redis Enterprise Software installation.
+
+
+---
+Title: Create a support package
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create a support package that gathers essential information to help debug
+  issues.
+linkTitle: Create support package
+toc: 'true'
+weight: $weight
+url: '/operate/rs/7.4/installing-upgrading/creating-support-package/'
+---
+If you encounter any issues that you are not able to resolve yourself
+and need to [contact Redis support](https://redis.io/support/) for assistance, you can [create a support package](#create-support-package) that gathers all essential information to help debug
+your issues.
+
+{{< note >}}
+The process of creating the support package can take several minutes and generates load on the system.
+{{< /note >}}
+
+## Support package files
+
+The support package is a zip file that contains all cluster configuration and logs.
+
+When downloaded from the Cluster Manager UI, the support package's name is `debuginfo.tar.gz`.
+
+### Database support package files
+
+Cluster and database support packages collect database details in `database_<bdb_uid>` directories, where `<bdb_uid>` is the database ID, and Redis shard details in `<node_uid>` directories.
+
+The following table describes the included files:
+
+| File | Description |
+|------|-------------|
+| ccs-redis.json | Primary node's local cluster configuration store (CCS). |
+| /database_<bdb_uid>/ | Directory that includes files for a specific database.<bdb_uid> is the database ID. |
+| database_<bdb_uid>_ccs_info.txt | Database information from the cluster configuration store (CCS). Includes settings for databases, endpoints, shards, replicas, and CRDB. |
+| database_<bdb_uid>.clientlist | List of clients connected to the database when the support package was created. |
+| database_<bdb_uid>.info | Redis information and statistics for the database. See [`INFO`]({{<relref "/commands/info">}}) for details about the collected fields. |
+| database_<bdb_uid>.rladmin | Database information. See [`rladmin info db`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/info#info-db">}}) for an example of collected fields. Also includes creation time, last changed time, Redis version, memory limit, persistence type, eviction policy, hashing policy, and whether SSL, backups, and email alerts are enabled. |
+| database_<bdb_uid>.slowlog | Contains slowlog output, which includes commands that took longer than 10 milliseconds. Only included if `slowlog_in_sanitized_support` is `true` in cluster settings. |
+| /node_<node_uid>/redis_<shard_uid>.txt | For each shard of the specified database only. Includes shard configuration and [information]({{<relref "/commands/info">}}), slowlog information, and latency information. |
+
+### Node support package files
+
+Cluster and node support packages collect node details in `node_<node_uid>` directories, where `<node_uid>` is the node ID.
+
+The following table describes the included files:
+
+| File | Description |
+|------|-------------|
+| ccs-redis.json | The node's local cluster configuration store (CCS). |
+| /conf/ | Directory that contains configuration files. |
+| /logs/ | Directory that includes logs. |
+| node_<node_uid>.ccs | Includes cluster configuration, node configuration, and DMC proxy configuration. |
+| node_<node_uid>_envoy_config.json | Envoy configuration. |
+| node_<node_uid>.rladmin | Information about the cluster's nodes, databases, endpoints, and shards. See [`rladmin status`]({{<relref "/operate/rs/7.4/references/cli-utilities/rladmin/status">}}) for example output. |
+| node_<node_uid>_sys_info.txt | Node's system information including:<br />• Socket files list<br />• Log files list<br />• Processes running on the node<br />• Disk usage<br />• Persistent files list<br />• Memory usage<br />• Network interfaces<br />• Installed packages<br />• Active iptables<br />• OS and platform<br />• Network connection<br />• Status of Redis processes |
+| redis_<shard_uid>.txt | For each shard of the specified database only. Includes shard configuration and [information]({{<relref "/commands/info">}}), slowlog information, and latency information. |
+
+Each node's `/conf/` directory contains the following files:
+
+- bootstrap_status.json
+- ccs-paths.conf
+- config.json
+- envoy.yaml
+- gossip_envoy.yaml
+- heartbeatd-config.json
+- last_bootstrap.json
+- local_addr.conf
+- node.id
+- node_local_config.json
+- redislabs_env_config.sh
+- socket.conf
+- supervisord_alert_mgr.conf
+- supervisord_cm_server.conf
+- supervisord_crdb_coordinator.conf
+- supervisord_crdb_worker.conf
+- supervisord_mdns_server.conf
+- supervisord_pdns_server.conf
+
+Each node's `/conf/` directory also contains the following key and cert modulus files:
+
+- api_cert.modulus
+- api_key.modulus
+- ccs_internode_encryption_cert.modulus
+- ccs_internode_encryption_key.modulus
+- cm_cert.modulus
+- cm_key.modulus
+- data_internode_encryption_cert.modulus
+- data_internode_encryption_key.modulus
+- gossip_ca_signed_cert.modulus
+- gossip_ca_signed_key.modulus
+- mesh_ca_signed_cert.modulus
+- mesh_ca_signed_key.modulus
+- metrics_exporter_cert.modulus
+- metrics_exporter_key.modulus
+- proxy_cert.modulus
+- proxy_key.modulus
+- syncer_cert.modulus
+- syncer_key.modulus
+
+## Create support package
+
+### Cluster Manager UI method
+
+To create a support package from the Cluster Manager UI:
+
+1. In the navigation menu, select **Support**.
+
+    {{<image filename="images/rs/screenshots/create-support-package.png"  width="60%" alt="Select Support and create a support package.">}}
+
+1. Select **Proceed**.
+
+1. In the **Create support package** dialog, select **Run process**.
+
+1. The package is created and downloaded by your browser.
+
+### Command-line method
+
+If package creation fails with `internal error` or if you cannot access the UI, create a support package for the cluster from the command line on any node in the cluster using the [`rladmin cluster debug_info`]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin/cluster/debug_info" >}}) command: 
+
+```sh
+/opt/redislabs/bin/rladmin cluster debug_info
+```
+
+- If `rladmin cluster debug_info` fails for lack of space in the `/tmp` directory, you can:
+
+    1. Change the storage location where the support package is saved: 
+    
+        ```sh
+        rladmin cluster config debuginfo_path <path>
+        ```
+
+        The `redislabs` user must have write access to the storage location on all cluster nodes.
+
+    1. On any node in the cluster, run:
+        
+        ```sh
+        rladmin cluster debug_info
+        ```
+
+- If `rladmin cluster debug_info` fails for another reason, you can create a support package for the cluster from the command line on each node in the cluster with the command: 
+
+    ```sh
+    /opt/redislabs/bin/debuginfo
+    ```
+
+Upload the tar file to [Redis support](https://redis.com/company/support/). The path to the archive is shown in the command output.
+
+### REST API method
+
+You can also use `debuginfo` [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) requests to create and download support packages.
+
+To download debug info from all nodes and databases:
+
+```sh
+GET /v1/cluster/debuginfo
+```
+
+To download debug info from all nodes:
+
+```sh
+GET /v1/nodes/debuginfo
+```
+
+To download debug info from a specific node, replace `<uid>` in the following request with the node ID:
+
+```sh
+GET /v1/nodes/<uid>/debuginfo
+```
+
+To download debug info from all databases:
+
+```sh
+GET /v1/bdbs/debuginfo
+```
+
+To download debug info from a specific database, replace `<uid>` in the following request with the database ID:
+
+```sh
+GET /v1/bdbs/<uid>/debuginfo
+```
+---
+Title: Install, set up, and upgrade Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Learn how to install, set up, and upgrade Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Install and upgrade
+toc: 'true'
+weight: 35
+url: '/operate/rs/7.4/installing-upgrading/'
+---
+
+You can run self-managed Redis Enterprise Software in an on-premises data center or on your preferred cloud platform. 
+
+If you prefer a fully managed Redis database-as-a-service, available on major public cloud services, consider setting up a [Redis Cloud]({{<relref "/operate/rc">}}) subscription. You can [try Redis Cloud](https://redis.io/try-free/) for free.
+
+## Quickstarts
+
+If you want to try out Redis Enterprise Software, see the following quickstarts:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Docker quickstart for Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+## Install Redis Enterprise Software
+
+To install Redis Enterprise Software on a [supported platform]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/supported-platforms" >}}), you need to:
+
+1. [Plan your deployment]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment" >}}).
+
+1. [Prepare to install]({{< relref "/operate/rs/7.4/installing-upgrading/install/prepare-install" >}}).
+
+1. [Perform the install]({{< relref "/operate/rs/7.4/installing-upgrading/install" >}}).
+
+Depending on your needs, you may also want to [customize the installation](#more-info-and-options).
+
+## Upgrade existing deployment
+
+If you already installed Redis Enterprise Software, you can:
+
+- [Upgrade a cluster]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-cluster" >}})
+
+- [Upgrade a database]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-database" >}})
+
+- [Upgrade an Active-Active database]({{< relref "/operate/rs/7.4/installing-upgrading/upgrading/upgrade-active-active" >}})
+
+## Uninstall Redis Enterprise Software
+
+- [Uninstall existing deployment]({{< relref "/operate/rs/7.4/installing-upgrading/uninstalling" >}})
+
+## More info and options
+
+More information is available to help with customization and related questions:
+
+- [CentOS/RHEL firewall configuration]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/7.4/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/7.4/networking/cluster-lba-setup.md" >}})
+- [File locations]({{< relref "/operate/rs/7.4/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Linux swap space configuration]({{< relref "/operate/rs/7.4/installing-upgrading/configuring/linux-swap.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/7.4/networking/mdns.md" >}})
+- [User and group ownership]({{< relref "/operate/rs/7.4/installing-upgrading/install/customize-user-and-group.md" >}})
+
+## Next steps
+
+After you install Redis Enterprise Software and set up your cluster, you can:
+
+- [Add users]({{< relref "/operate/rs/7.4/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/7.4/security/access-control" >}}).
+
+- [Create databases]({{< relref "/operate/rs/7.4/databases/create" >}}) to use with your applications.
+
+---
+Title: Docker quickstart for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a development or test deployment of Redis Enterprise Software
+  using Docker.
+linkTitle: Docker quickstart
+weight: 2
+url: '/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart/'
+---
+{{< warning >}}
+Docker containers are currently only supported for development and test environments, not for production. Use [Redis Enterprise on Kubernetes]({{< relref "/operate/kubernetes" >}}) for a supported containerized deployment.
+{{< /warning >}}
+
+For testing purposes, you can run Redis Enterprise Software on Docker containers on
+Linux, Windows, or MacOS.
+The [Redis Enterprise Software container](https://hub.docker.com/r/redislabs/redis/)
+acts as a node in a cluster.
+
+To get started with a single Redis Enterprise Software container:
+
+1. [Install Docker](#install-docker) for your operating system
+
+2. [Run the Redis Enterprise Software Docker container](#run-the-container)
+
+3. [Set up a cluster](#set-up-a-cluster)
+
+4. [Create a new database](#create-a-database)
+
+5. [Connect to your database](#connect-to-your-database)
+
+## Install Docker
+
+Follow the Docker installation instructions for your operating system:
+
+- [Linux](https://docs.docker.com/install/#supported-platforms)
+- [MacOS](https://docs.docker.com/docker-for-mac/install/)
+- [Windows](https://store.docker.com/editions/community/docker-ce-desktop-windows)
+
+## Run the container
+
+To download and start the Redis Enterprise Software Docker container, run the following
+[`docker run`](https://docs.docker.com/engine/reference/commandline/run/) command in the terminal or command line for your operating system.
+
+{{< note >}}
+On Windows, make sure Docker is configured to run Linux-based containers.
+{{< /note >}}
+
+```sh
+docker run -d --cap-add sys_resource --name RE -p 8443:8443 -p 9443:9443 -p 12000:12000 redislabs/redis
+```
+
+The example command runs the Docker container with Redis Enterprise Software on `localhost` and opens the following ports: 
+
+- Port 8443 for HTTPS connections
+
+- Port 9443 for [REST API]({{< relref "/operate/rs/7.4/references/rest-api" >}}) connections
+
+- Port 12000 configured Redis database port allowing client connections
+
+You can publish other [ports]({{< relref "/operate/rs/7.4/networking/port-configurations.md" >}})
+with `-p <host_port>:<container_port>` or use the `--network host` option to open all ports to the host network.
+
+## Set up a cluster
+
+{{<embed-md "cluster-setup.md">}}
+
+## Create a database
+
+{{<embed-md "quick-db-setup.md">}}
+
+{{< note >}}
+{{< embed-md "docker-memory-limitation.md" >}}
+{{< /note >}}
+
+## Connect to your database
+
+After you create the Redis database, you can connect to it to begin storing data.
+
+### Use redis-cli inside Docker {#connect-inside-docker}
+
+Every installation of Redis Enterprise Software includes the command-line tool [`redis-cli`]({{< relref "/operate/rs/7.4/references/cli-utilities/redis-cli" >}}) to interact with your Redis database. You can use `redis-cli` to connect to your database from within the same Docker network.
+
+Use [`docker exec`](https://docs.docker.com/engine/reference/commandline/exec/) to start an interactive `redis-cli` session in the running Redis Enterprise Software container:
+
+```sh
+$ docker exec -it redis-cli -h redis-12000.cluster.local -p 12000
+127.0.0.1:12000> SET key1 123
+OK
+127.0.0.1:12000> GET key1
+"123"
+```
+
+### Connect from the host environment {#connect-outside-docker}
+
+The database you created uses port `12000`, which is also mapped from the Docker container back to the host environment. This lets you use any method you have available locally to [connect to a Redis database]({{< relref "/operate/rs/7.4/databases/connect/" >}}). Use `localhost` as the `host` and `12000` as the port.
+
+## Test different topologies
+
+{{< warning >}}
+Docker containers are currently only supported for development and test environments, not for production. Use [Redis Enterprise on Kubernetes]({{< relref "/operate/kubernetes" >}}) for a supported containerized deployment.
+{{< /warning >}}
+
+When deploying Redis Enterprise Software using Docker for testing, several common topologies are available, according to your requirements:
+
+- [Single-node cluster](#single-node) – For local development or functional testing
+
+- [Multi-node cluster on a single host](#multi-node-one-host) – For a small-scale deployment that is similar to production
+
+- [Multi-node cluster with multiple hosts](#multi-node-multi-host) – For more predictable performance or high availability compared to single-host deployments
+
+### Single node {#single-node}
+
+The simplest topology is to run a single-node Redis Enterprise Software cluster with a single container on a single host machine. You can use this topology for local development or functional testing.
+
+Single-node clusters have limited functionality. For example, Redis Enterprise Software can't use replication or protect against failures if the cluster has only one node.
+
+{{< image filename="/images/rs/RS-Docker-container.png" >}}
+
+### Multiple nodes on one host {#multi-node-one-host}
+
+You can create a multi-node Redis Enterprise Software cluster by deploying multiple containers to a single host machine. The resulting cluster is scale minimized but similar to production deployments.
+
+However, this will also have several limitations.  For example, you cannot map the same port on multiple containers on the same host.
+
+{{< image filename="/images/rs/RS-Docker-cluster-single-host.png" >}}
+
+### Multiple nodes and hosts {#multi-node-multi-host}
+
+You can create a multi-node Redis Enterprise Software cluster with multiple containers by deploying each container to a different host machine.
+
+This topology minimizes interference between containers, allowing for the testing of more Redis Enterprise Software features.
+
+{{< image filename="/images/rs/RS-Docker-cluster-multi-host.png" >}}
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a test deployment of Redis Enterprise Software for Linux.
+linkTitle: Quickstart
+title: Redis Enterprise Software quickstart
+weight: 1
+url: '/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart/'
+---
+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:
+
+1. [Ensure port availability](#ensure-port-availability)
+
+1. [Install Redis Enterprise Software](#install-redis-enterprise-software)
+
+1. [Set up a Redis Enterprise Software cluster](#set-up-a-cluster)
+
+1. [Create a new Redis database](#create-a-database)
+
+1. [Connect to your Redis database](#connect-to-your-database)
+
+{{< note >}}
+**This quickstart is designed for local testing only.**
+For production environments, see the [install and setup]({{< relref "/operate/rs/7.4/installing-upgrading#install-redis-enterprise-software" >}}) guide for deployment options and instructions.
+{{< /note >}}
+
+## Ensure port availability
+
+{{<embed-md "port-availability-embed.md">}}
+
+### Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+### OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+
+
+### Configuration for AWS and GCP
+
+For detailed configuration instructions, see your cloud provider's documentation.
+
+1. Create a VPC that you can use with regional subnets.
+
+1. Within this VPC, create firewall rules that allow external and internal access for Redis Enterprise Software.
+
+
+| Ingress/Egress   | Source                                             | Protocol  | Ports                                    | Other protocols  |
+|------------------|----------------------------------------------------|-----------|------------------------------------------|------------------|
+| Ingress          | 0.0.0.0/0                                          | TCP       | 21, 22, 53, 8001, 8443, 9443, 8070, <nobr>10000-19999</nobr> | ICMP             |
+| Ingress          | 0.0.0.0/0                                          | UDP       | 53, 5353                                  |                  |
+| Ingress          | 10.0.0.0/8  (if subnets use 10. ranges) | all       | all                                      |                  | 
+
+
+## Install Redis Enterprise Software
+
+To install Redis Enterprise Software:
+
+1. Download the installation files from the [Redis Enterprise Download Center](https://redis.io/downloads/#software)
+and copy the download package to a machine with a Linux-based OS. 
+
+    {{< note >}}
+You are required to create a free account to access the download center.
+    {{< /note >}}
+
+1. Extract the installation files:
+
+    ```sh
+    tar vxf <downloaded tar file name>
+    ```
+
+1. Run the `install.sh` script in the current directory:
+
+    ```sh
+    sudo ./install.sh -y
+    ```
+
+## Set up a cluster
+
+To set up your machine as a Redis Enterprise Software cluster:
+
+{{< embed-md "cluster-setup.md" >}}
+
+## Create a database
+
+{{<embed-md "quick-db-setup.md">}}
+
+## Connect to your database
+
+After you create the Redis database, you can connect to it and store data.
+See [Test client connection]({{< relref "/operate/rs/7.4/databases/connect/test-client-connectivity" >}}) for connection options and examples.
+
+## Supported web browsers
+
+To use the Redis Enterprise Software Cluster Manager UI, you need a modern browser with JavaScript enabled.
+
+The following browsers have been tested with the current version of the Cluster Manager UI:
+
+- Microsoft Windows, version 10 or later.
+    - [Google Chrome](https://www.google.com/chrome/), version 48 and later
+    - [Microsoft Edge](https://www.microsoft.com/edge), version 20 and later
+    - [Mozilla Firefox](https://www.mozilla.org/firefox/), version 44 and and later
+    - [Opera](https://www.opera.com/), version 35 and later
+
+- Apple macOS:
+    - [Google Chrome](https://www.google.com/chrome/), version 48 and later
+    - [Mozilla Firefox](https://www.mozilla.org/firefox/), version 44 and and later
+    - [Opera](https://www.opera.com/), version 35 and later
+
+- Linux:
+    - [Google Chrome](https://www.google.com/chrome/), version 49 and later
+    - [Mozilla Firefox](https://www.mozilla.org/firefox/), version 44 and and later
+    - [Opera](https://www.opera.com/), version 35 and later
+---
+Title: Redis Enterprise Software quickstarts
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Follow these quickstarts to try out Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Quickstarts
+weight: 10
+url: '/operate/rs/7.4/installing-upgrading/quickstarts/'
+---
+
+Try out Redis Enterprise Software using one of the following quickstarts:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Docker quickstart for Redis Enterprise Software]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+Additional quickstart guides are available to help you:
+
+- Set up a [Auto Tiering cluster]({{< relref "/operate/rs/7.4/databases/auto-tiering/quickstart.md" >}}) to optimize  memory resources.
+
+- Set up an [Active-Active cluster]({{< relref "/operate/rs/7.4/databases/active-active/get-started.md" >}}) to enable high availability.
+
+- [Benchmark]({{< relref "/operate/rs/7.4/clusters/optimize/memtier-benchmark.md" >}}) Redis Enterprise Software performance.
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes where to view the archive of Redis Enterprise Software documentation.
+linkTitle: Archive
+weight: 99
+url: '/operate/rs/7.4/rs-archive/'
+---
+
+Previous versions of Redis Enterprise Software documentation are available on the archived web site:
+
+- [Redis Enterprise Software v7.4 documentation archive](https://docs.redis.com/7.4/rs/)  
+
+- [Redis Enterprise Software v7.2 documentation archive](https://docs.redis.com/7.2/rs/) 
+
+- [Redis Enterprise Software v6.4 documentation archive](https://docs.redis.com/6.4/rs/) 
+
+- [Redis Enterprise Software v6.2 documentation archive](https://docs.redis.com/6.2/rs/) 
+
+- [Redis Enterprise Software v6.0 documentation archive](https://docs.redis.com/6.0/rs/)
+---
+Title: Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The self-managed, enterprise-grade version of Redis.
+hideListLinks: true
+weight: 10
+url: '/operate/rs/7.4/'
+linkTitle: 7.4
+bannerText: This documentation applies to Redis Software versions 7.4.x.
+bannerChildren: true
+---
+
+[Redis Enterprise](https://redis.io/enterprise/) is a self-managed, enterprise-grade version of Redis.
+
+With Redis Enterprise, you get many enterprise-grade capabilities, including:
+- Linear scalability
+- High availability, backups, and recovery
+- Predictable performance
+- 24/7 support
+
+You can run self-managed Redis Enterprise Software in an on-premises data center or on your preferred cloud platform.
+
+If you prefer a fully managed Redis database-as-a-service, available on major public cloud services, consider setting up a [Redis Cloud]({{<relref "/operate/rc">}}) subscription. You can [try Redis Cloud](https://redis.io/try-free/) for free.
+
+## Get started
+Build a small-scale cluster with the Redis Enterprise Software container image.
+- [Linux quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- [Docker quickstart]({{< relref "/operate/rs/7.4/installing-upgrading/quickstarts/docker-quickstart" >}})
+- [Get started with Active-Active]({{< relref "/operate/rs/7.4/databases/active-active/get-started" >}})
+
+## Install & setup
+[Install & set up]({{< relref "/operate/rs/7.4/installing-upgrading" >}}) a Redis Enterprise Software cluster.
+- [Networking]({{< relref "/operate/rs/7.4/networking" >}})
+- [Set up]({{< relref "/operate/rs/7.4/clusters/new-cluster-setup" >}}) & [configure]({{< relref "/operate/rs/7.4/clusters/configure" >}}) a [cluster]({{< relref "/operate/rs/7.4/clusters" >}})
+- [Release notes]({{< relref "/operate/rs/release-notes" >}})
+
+## Databases
+Create and manage a [Redis database]({{< relref "/operate/rs/7.4/databases" >}}) on a cluster.
+- [Create a Redis Enterprise Software database]({{< relref "/operate/rs/7.4/databases/create" >}})
+- [Configure database]({{< relref "/operate/rs/7.4/databases/configure" >}})
+- [Create Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/create" >}})
+- [Edit Active-Active database]({{< relref "/operate/rs/7.4/databases/active-active/manage.md" >}})
+
+## Security
+[Manage secure connections]({{< relref "/operate/rs/7.4/security" >}}) to the cluster and databases.
+- [Access control]({{< relref "/operate/rs/7.4/security/access-control" >}})
+- [Users]({{< relref "/operate/rs/7.4/security/access-control/manage-users" >}}) & [roles]({{< relref "/operate/rs/7.4/security/access-control" >}})
+- [Certificates]({{< relref "/operate/rs/7.4/security/certificates" >}})
+- [TLS]({{< relref "/operate/rs/7.4/security/encryption/tls" >}}) & [Encryption]({{< relref "/operate/rs/7.4/security/encryption" >}})
+
+## Reference
+Use command-line utilities and the REST API to manage the cluster and databases.
+- [rladmin]({{< relref "/operate/rs/7.4/references/cli-utilities/rladmin" >}}), [crdb-cli]({{< relref "/operate/rs/7.4/references/cli-utilities/crdb-cli" >}}), & [other utilities]({{< relref "/operate/rs/7.4/references/cli-utilities" >}})
+- [REST API reference]({{< relref "/operate/rs/7.4/references/rest-api" >}}) & [examples]({{< relref "/operate/rs/7.4/references/rest-api/quick-start" >}})
+- [Redis commands]({{< relref "/commands" >}})
+
+## Archive
+
+You can use the version selector in the navigation menu to view documentation for Redis Enterprise Software versions 7.4 and later.
+
+To view documentation earlier than version 7.4, see the archived website:
+
+- [Redis Enterprise Software v7.2 documentation archive](https://docs.redis.com/7.2/rs/) 
+
+- [Redis Enterprise Software v6.4 documentation archive](https://docs.redis.com/6.4/rs/) 
+
+- [Redis Enterprise Software v6.2 documentation archive](https://docs.redis.com/6.2/rs/) 
+
+- [Redis Enterprise Software v6.0 documentation archive](https://docs.redis.com/6.0/rs/)
+
+## Related info
+- [Redis Cloud]({{< relref "/operate/rc" >}})
+- [Redis Open Source]({{< relref "/operate/oss_and_stack" >}})
+- [Redis Stack]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}})
+- [Glossary]({{< relref "/glossary" >}})
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes internode encryption which improves the security of data in
+  transit.
+linkTitle: Internode encryption
+title: Internode encryption
+weight: 15
+---
+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.
+
+{{<image filename="images/rs/internode-encryption.png" alt="A diagram showing the interaction between data internode encryption, control plane encryption, and various elements of a cluster." >}}
+
+Data internode encryption is disabled by default for individual databases in order to optimize for performance.  Encryption adds latency and overhead; the impact is measurable and varies according to the database, its field types, and the details of the underlying use case. 
+
+You can enable data internode encryption for a database by changing the database configuration settings.  This lets you choose when to favor performance and when to encrypt data.
+
+## Prerequisites
+
+Internode encryption requires certain prerequisites.  
+
+You need to:
+
+- Upgrade all nodes in the cluster to v6.2.4 or later.
+
+- Open port 3342 for the TLS channel used for encrypted communication.
+
+
+## Enable data internode encryption
+
+To enable internode encryption for a database (also called _data internode encryption_), you need to enable the appropriate setting for each database you wish to encrypt.  To do so, you can:
+
+- Use the Cluster Manager UI to enable the **Internode Encryption** setting from the database **Security** screen.
+
+-  Use the `rladmin` command-line utility to set the [data_internode_encryption]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}) setting for the database:
+
+    ``` shell
+    rladmin tune db <database_id> data_internode_encryption enabled
+    ``` 
+
+- Use the Redis Enterprise Software REST API to set the `data_internode_encryption` setting for the database.
+
+    ``` rest
+    put /v1/bdbs/${database_id}
+    { “data_internode_encryption” : true }
+    ```
+
+When you change the data internode encryption setting for a database, all active remote client connections are disconnected.  This restarts the internal (DMC) proxy and disconnects all client connections.
+
+## Change cluster policy
+
+To enable internode encryption for new databases by default, use one of the following methods:
+
+- Cluster Manager UI
+
+    1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+    1. Select **Database defaults**.
+
+    1. Go to **Internode Encryption** and click **Change**.
+
+    1. Select **Enabled** to enable internode encryption for new databases by default.
+
+    1. Click **Change**.
+
+    1. Select **Save**.
+
+- [rladmin tune cluster]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}): 
+    
+    ```sh
+    rladmin tune cluster data_internode_encryption enabled
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "data_internode_encryption": true }
+    ```
+
+## Encryption ciphers and settings
+
+To encrypt internode communications, Redis Enterprise Software uses TLS 1.2 and the following cipher suites:
+
+- ECDHE-RSA-AES256-GCM-SHA384
+- ECDHE-RSA-AES128-GCM-SHA256
+
+As of Redis Enterprise Software v7.4, internode encryption also supports TLS 1.3 with the following cipher suites:
+
+- TLS_AES_128_GCM_SHA256
+- TLS_AES_256_GCM_SHA384
+
+The TLS layer determines which TLS version to use.
+
+No configurable settings are exposed; internode encryption is used internally within a cluster and not exposed to any outside service.
+
+## Certificate authority and rotation
+
+Starting with v6.2.4, internode communication is managed, in part, by two certificates: one for the control plane and one for the data plane.  These certificates are signed by a private certificate authority (CA).  The CA is not exposed outside of the cluster, so it cannot be accessed by external processes or services.  In addition, each cluster generates a unique CA that is not used anywhere else.
+
+The private CA is generated when a cluster is created or upgraded to 6.2.4.  
+
+When nodes join the cluster, the cluster CA is used to generate certificates for the new node, one for each plane.  Certificates signed by the private CA are not shared between clusters and they're not exposed outside the cluster.
+
+All certificates signed by the internal CA expire after ninety (90) days and automatically rotate every thirty (30) days.  Alerts also monitor certificate expiration and trigger when certificate expiration falls below 45 days.  If you receive such an alert, contact support.
+
+You can use the Redis Enterprise Software REST API to rotate certificates manually:
+
+``` rest
+POST /v1/cluster/certificates/rotate
+```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Configure TLS protocol
+title: Configure TLS protocol
+weight: 50
+---
+
+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:
+
+- Control plane - The TLS configuration for cluster administration.
+- Data plane - The TLS configuration for the communication between applications and databases.
+- Discovery service (Sentinel) - The TLS configuration for the [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}).
+
+You can configure TLS protocols with the [Cluster Manager UI](#edit-tls-ui), [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}), or the [REST API]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}).
+
+{{<warning>}}
+- After you set the minimum TLS version, Redis Enterprise Software does not accept communications with TLS versions older than the specified version.
+
+- If you set TLS 1.3 as the minimum TLS version, clients must support TLS 1.3 to connect to Redis Enterprise.
+{{</warning>}}
+
+TLS support depends on the operating system. You cannot enable support for protocols or versions that aren't supported by the operating system running Redis Enterprise Software.  In addition, updates to the operating system or to Redis Enterprise Software can impact protocol and version support.  
+
+If you have trouble enabling specific versions of TLS, verify that they're supported by your operating system and that they're configured correctly.
+
+{{<note>}}
+TLSv1.2 is generally recommended as the minimum TLS version for encrypted communications. Check with your security team to confirm which TLS protocols meet your organization's policies.
+{{</note>}}
+
+### Edit TLS settings in the UI {#edit-tls-ui}
+
+To configure minimum TLS versions using the Cluster Manager UI:
+
+1. Go to **Cluster > Security**, then select the **TLS** tab.
+
+1. Click **Edit**.
+
+1. Select the minimum TLS version for cluster connections, database connections, and the discovery service:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-protocols-edit.png" alt="Cluster > Security > TLS settings in edit mode in the Cluster Manager UI." >}}
+  
+1. Select the TLS mode for the discovery service:
+
+    - **Allowed** - Allows both TLS and non-TLS connections
+    - **Required** - Allows only TLS connections
+    - **Disabled** - Allows only non-TLS connections
+
+1. Click **Save**.
+
+### Control plane TLS
+
+To set the minimum TLS protocol for the control plane using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_control_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+For example:
+
+```sh
+rladmin cluster config min_control_TLS_version 1.2
+```
+
+### Data plane TLS
+
+To set the minimum TLS protocol for the data path using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_data_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+For example:
+
+```sh
+rladmin cluster config min_data_TLS_version 1.2
+```
+
+
+### Discovery service TLS
+
+To enable TLS for the discovery service using `rladmin`:
+
+- Default: Allows both TLS and non-TLS connections
+- Syntax: `rladmin cluster config sentinel_tls_mode <ssl_policy>`
+- `ssl_policy` values available:
+  - `allowed` - Allows both TLS and non-TLS connections
+  - `required` - Allows only TLS connections
+  - `disabled` - Allows only non-TLS connections
+
+To set the minimum TLS protocol for the discovery service using `rladmin`:
+
+- Default minimum TLS protocol: TLSv1.2
+- Syntax: `rladmin cluster config min_sentinel_TLS_version <TLS_Version>`
+- TLS versions available:
+  - For TLSv1.2 - 1.2
+  - For TLSv1.3 - 1.3
+
+To enforce a minimum TLS version for the discovery service, run the following commands:
+
+1. Allow only TLS connections:
+
+    ```sh
+    rladmin cluster config sentinel_tls_mode required
+    ```
+
+1. Set the minimal TLS version:
+
+    ```sh
+    rladmin cluster config min_sentinel_TLS_version 1.2
+    ```
+
+1. Restart the discovery service on all cluster nodes to apply your changes:
+
+    ```sh
+    supervisorctl restart sentinel_service
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows how to configure cipher suites.
+linkTitle: Configure cipher suites
+title: Configure cipher suites
+weight: 60
+---
+
+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 | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.2 communications for cluster administration (control plane) |
+| data_cipher_list | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.2 communications between applications and databases (data plane) |
+| sentinel_cipher_suites | <span title="Yes">&#x2705; Yes</span> | Cipher list for [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) (Sentinel) TLS 1.2 communications |
+
+## TLS 1.3 cipher suites
+
+| Name | Configurable | Description |
+|------------|--------------|-------------|
+| control_cipher_suites_tls_1_3 | <span title="No">&#x274c; No</span> | Cipher list for TLS 1.3 communications for cluster administration (control plane) |
+| data_cipher_suites_tls_1_3 | <span title="Yes">&#x2705; Yes</span> | Cipher list for TLS 1.3 communications between applications and databases (data plane) |
+| sentinel_cipher_suites_tls_1_3 | <span title="No">&#x274c; No</span> | Cipher list for [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) (Sentinel) TLS 1.3 communications |
+
+## Configure cipher suites
+
+You can configure ciphers with the [Cluster Manager UI](#edit-ciphers-ui), [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}), or the [REST API]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}).
+
+{{<warning>}}
+Configuring cipher suites overwrites existing ciphers rather than appending new ciphers to the list.
+{{</warning>}}
+
+When you modify your cipher suites, make sure:
+
+- The configured TLS version matches the required cipher suites.
+- The certificates in use are properly signed to support the required cipher suites.
+
+{{<note>}}
+- Redis Enterprise Software doesn't support static [Diffie–Hellman (`DH`) key exchange](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange) ciphers.
+
+- Support for Ephemeral Diffie–Hellman (ECDHE) key exchange ciphers depends on the operating system version and security policy.
+{{</note>}}
+
+### Edit cipher suites in the UI {#edit-ciphers-ui}
+
+To configure cipher suites using the Cluster Manager UI:
+
+1. Go to **Cluster > Security**, then select the **TLS** tab.
+
+1. In the **Cipher suites lists** section, click **Configure**:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-cipher-suites-view.png" alt="Cipher suites lists as shown in the Cluster Manager UI." >}}
+
+1. Edit the TLS cipher suites in the text boxes:
+
+    {{<image filename="images/rs/screenshots/cluster/security-tls-cipher-suites-edit.png" alt="Edit cipher suites drawer in the Cluster Manager UI." >}}
+
+1. Click **Save**.
+
+### Control plane cipher suites {#control-plane-ciphers-tls-1-2}
+
+As of Redis Enterprise Software version 6.0.12, control plane cipher suites can use the BoringSSL library format for TLS connections to the Cluster Manager UI. See the BoringSSL documentation for a full list of available [BoringSSL configurations](https://github.com/google/boringssl/blob/master/ssl/test/runner/cipher_suites.go#L99-L131).
+
+#### Configure TLS 1.2 control plane cipher suites
+
+To configure TLS 1.2 cipher suites for cluster communication, use the following [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config control_cipher_suites <BoringSSL cipher list>
+```
+
+See the example below to configure cipher suites for the control plane:
+
+```sh
+rladmin cluster config control_cipher_suites ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305
+```
+{{<note>}}
+- The deprecated 3DES and RC4 cipher suites are no longer supported.
+{{</note>}}
+
+
+### Data plane cipher suites {#data-plane-ciphers-tls-1-2}
+
+Data plane cipher suites use the OpenSSL library format in Redis Enterprise Software version 6.0.20 or later. For a list of available OpenSSL configurations, see [Ciphers](https://www.openssl.org/docs/man1.1.1/man1/ciphers.html) (OpenSSL).
+
+#### Configure TLS 1.2 data plane cipher suites
+
+To configure TLS 1.2 cipher suites for communications between applications and databases, use the following [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config  data_cipher_list <OpenSSL cipher list>
+```
+
+See the example below to configure cipher suites for the data plane:
+
+```sh
+rladmin cluster config data_cipher_list AES128-SHA:AES256-SHA
+```
+{{<note>}}
+- The deprecated 3DES and RC4 cipher suites are no longer supported.
+{{</note>}}
+
+#### Configure TLS 1.3 data plane cipher suites
+
+To configure TLS 1.3 cipher suites for communications between applications and databases, use the following [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config data_cipher_suites_tls_1_3 <OpenSSL cipher list>
+```
+
+The following example configures TLS 1.3 cipher suites for the data plane:
+
+```sh
+rladmin cluster config data_cipher_suites_tls_1_3 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
+```
+
+### Discovery service cipher suites {#discovery-service-ciphers-tls-1-2}
+
+Sentinel service cipher suites use the golang.org OpenSSL format for [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) TLS connections in Redis Enterprise Software version 6.0.20 or later. See their documentation for a list of [available configurations](https://golang.org/src/crypto/tls/cipher_suites.go).
+
+#### Configure TLS 1.2 discovery service cipher suites
+
+To configure TLS 1.2 cipher suites for the discovery service cipher suites, use the following [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command syntax:
+
+```sh
+rladmin cluster config  sentinel_cipher_suites <golang cipher list> 
+```
+
+See the example below to configure cipher suites for the sentinel service:
+
+```sh
+rladmin cluster config sentinel_cipher_suites TLS_RSA_WITH_AES_128_CBC_SHA:TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
+```
+---
+Title: Enable TLS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows how to enable TLS.
+linkTitle: Enable TLS
+weight: 40
+---
+
+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]({{< relref "/operate/rs/databases/import-export/replica-of/" >}})
+- Communication to and from your database to other clusters for synchronization using [Active-Active]({{< relref "/operate/rs/databases/active-active/_index.md" >}})
+
+{{<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.
+{{</note>}}
+
+## Enable TLS for client connections {#client}
+
+To enable TLS for client connections:
+
+1. From your database's **Security** tab, select **Edit**.
+
+1. In the **TLS - Transport Layer Security for secure connections** section, make sure the checkbox is selected.
+
+1. In the **Apply TLS for** section, select **Clients and databases + Between databases**.
+
+1. Select **Save**.
+
+To enable mutual TLS for client connections:
+
+1. Select **Mutual TLS (Client authentication)**.
+
+    {{<image filename="images/rs/screenshots/databases/security-mtls-clients-7-8-2.png"  alt="Mutual TLS authentication configuration.">}}
+
+1. For each client certificate, select **+ Add certificate**, paste or upload the client certificate, then select **Done**.
+
+    If your database uses Replica Of, you also need to add the syncer certificates for the participating clusters. See [Enable TLS for Replica Of cluster connections](#enable-tls-for-replica-of-cluster-connections) for instructions.
+
+1. You can configure **Additional certificate validations** to further limit connections to clients with valid certificates.
+
+    Additional certificate validations occur only when loading a [certificate chain](https://en.wikipedia.org/wiki/Chain_of_trust#Computer_security) that includes the [root certificate](https://en.wikipedia.org/wiki/Root_certificate) and intermediate [CA](https://en.wikipedia.org/wiki/Certificate_authority) certificate but does not include a leaf (end-entity) certificate. If you include a leaf certificate, mutual client authentication skips any additional certificate validations.
+
+    1. Select a certificate validation option.
+
+        | Validation option | Description |
+        |-------------------|-------------|
+        | _No validation_ | Authenticates clients with valid certificates. No additional validations are enforced. |
+        | _By Subject Alternative Name_ | A client certificate is valid only if its Common Name (CN) matches an entry in the list of valid subjects. Ignores other [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes. |
+        | _By full Subject Name_ | A client certificate is valid only if its [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes match an entry in the list of valid subjects. |
+
+    1. If you selected **No validation**, you can skip this step. Otherwise, select **+ Add validation** to create a new entry and then enter valid [`Subject`](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.6) attributes for your client certificates. All `Subject` attributes are case-sensitive.
+
+        | Subject attribute<br />(case-sensitive) | Description |
+        |-------------------|-------------|
+        | _Common Name (CN)_ | Name of the client authenticated by the certificate (_required_) |
+        | _Organization (O)_ | The client's organization or company name |
+        | <nobr>_Organizational Unit (OU)_</nobr> | Name of the unit or department within the organization |
+        | _Locality (L)_ | The organization's city |
+        | _State / Province (ST)_ | The organization's state or province |
+        | _Country (C)_ | 2-letter code that represents the organization's country |
+
+        You can only enter a single value for each field, except for the _Organizational Unit (OU)_ field. If your client certificate has a `Subject` with multiple  _Organizational Unit (OU)_ values, press the `Enter` or `Return` key after entering each value to add multiple Organizational Units.
+
+        {{<image filename="images/rs/screenshots/databases/security-mtls-add-cert-validation-multi-ou.png" width="350px" alt="An example that shows adding a certificate validation with multiple organizational units.">}}
+
+        **Breaking change:** If you use the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) instead of the Cluster Manager UI to configure additional certificate validations, note that `authorized_names` is deprecated as of Redis Enterprise v6.4.2. Use `authorized_subjects` instead. See the [BDB object reference]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) for more details.
+
+1. Select **Save**.
+
+By default, Redis Enterprise Software validates client certificate expiration dates.  You can use `rladmin` to turn off this behavior.
+
+```sh
+rladmin tune db < db:id | name > mtls_allow_outdated_certs enabled
+```
+
+## Enable TLS for Active-Active cluster connections
+
+You cannot enable or turn off TLS after the Active-Active database is created, but you can change the TLS configuration.
+
+To enable TLS for Active-Active cluster connections:
+
+1. During [database creation]({{<relref "/operate/rs/databases/active-active/create">}}), expand the **TLS** configuration section.
+
+1. Select **On** to enable TLS.
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/enable-tls-for-active-active-db.png" alt="TLS is enabled on the Cluster Manager UI screen.">}}
+
+1. Click **Create**.
+
+If you also want to require TLS for client connections, you must edit the Active-Active database configuration after creation. See [Enable TLS for client connections](#client) for instructions.
+
+## Enable TLS for Replica Of cluster connections
+
+{{<embed-md "replica-of-tls-config.md">}}
+---
+Title: Transport Layer Security (TLS)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of Transport Layer Security (TLS).
+hideListLinks: true
+linkTitle: TLS
+weight: 10
+---
+[Transport Layer Security (TLS)](https://en.wikipedia.org/wiki/Transport_Layer_Security), a successor to SSL, ensures the privacy of data sent between applications and Redis databases. TLS also secures connections between Redis Enterprise Software nodes.
+
+You can [use TLS authentication]({{< relref "/operate/rs/security/encryption/tls/enable-tls" >}}) for the following types of communication:
+
+- Communication from clients (applications) to your database
+- Communication from your database to other clusters for replication using [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of" >}})
+- Communication to and from your database to other clusters for synchronization using [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}})
+
+## Protocols and ciphers
+
+TLS protocols and ciphers define the overall suite of algorithms that clients are able to connect to the servers with.
+
+You can change the [TLS protocols]({{< relref "/operate/rs/security/encryption/tls/tls-protocols" >}}) and [ciphers]({{< relref "/operate/rs/security/encryption/tls/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.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable PEM encryption to encrypt all private keys on disk.
+linkTitle: Encrypt private keys
+title: Encrypt private keys
+toc: 'true'
+weight: 50
+---
+
+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`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/references/rest-api" >}}).
+
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config encrypt_pkeys enabled
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster
+    { "encrypt_pkeys": true }
+    ```
+
+## Deactivate PEM encryption
+
+To deactivate PEM encryption and decrypt private keys on the disk, use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/references/rest-api" >}}).
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config encrypt_pkeys disabled
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster
+    { "encrypt_pkeys": false }
+    ```
+---
+Title: Encryption in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Encryption in Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Encryption
+toc: 'true'
+weight: 60
+---
+
+Redis Enterprise Software uses encryption to secure communications between clusters, nodes, databases, and clients and to protect [data in transit](https://en.wikipedia.org/wiki/Data_in_transit), [at rest](https://en.wikipedia.org/wiki/Data_at_rest), and [in use](https://en.wikipedia.org/wiki/Data_in_use).
+
+## Encrypt data in transit
+
+### TLS
+
+Redis Enterprise Software uses [Transport Layer Security (TLS)]({{<relref "/operate/rs/security/encryption/tls">}}) to encrypt communications for the following:
+
+- Cluster Manager UI
+
+- Command-line utilities
+
+- REST API
+
+- Internode communication
+
+You can also [enable TLS authentication]({{< relref "/operate/rs/security/encryption/tls/enable-tls" >}}) for the following:
+
+- Communication from clients or applications to your database
+
+- Communication from your database to other clusters for replication using [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}})
+
+- Communication to and from your database to other clusters for [Active-Active]({{< relref "/operate/rs/databases/active-active/_index.md" >}}) synchronization
+
+### Internode encryption
+
+[Internode encryption]({{<relref "/operate/rs/security/encryption/internode-encryption">}}) uses TLS to encrypt data in transit between cluster nodes.
+
+By default, internode encryption is enabled for the control plane, which manages the cluster and databases. If you also want to encrypt replication and proxy communications between database shards on different nodes, [enable data internode encryption]({{< relref "/operate/rs/security/encryption/internode-encryption#enable-data-internode-encryption" >}}).
+
+### Require HTTPS for REST API endpoints
+
+By default, the Redis Enterprise Software API supports communication over HTTP and HTTPS. However, you can [turn off HTTP support]({{< relref "/operate/rs/references/rest-api/encryption" >}}) to ensure that API requests are encrypted.
+
+## Encrypt data at rest
+
+### File system encryption
+
+To encrypt data stored on disk, use file system-based encryption capabilities available on Linux operating systems before you install Redis Enterprise Software.
+
+### Private key encryption
+
+Enable PEM encryption to [encrypt all private keys]({{< relref "/operate/rs/security/encryption/pem-encryption" >}}) on disk.
+
+## Encrypt data in use
+
+### Client-side encryption
+
+Use client-side encryption to encrypt the data an application stores in a Redis database. The application decrypts the data when it retrieves it from the database.
+
+You can add client-side encryption logic to your application or use built-in client functions.
+
+Client-side encryption has the following limitations:
+
+- Operations that must operate on the data, such as increments, comparisons, and searches will not function properly.
+
+- Increases management overhead.
+
+- Reduces performance.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to audit connection events.
+linkTitle: Audit events
+title: Audit connection events
+weight: 15
+---
+
+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.
+
+Example external listeners include:
+
+- [`ncat`](https://nmap.org/ncat/): useful for debugging but not suitable for production environments.
+
+- Imperva Sonar: a third-party service available for purchase separately from Redis Enterprise Software. See [Redis Onboarding Steps](https://docs.imperva.com/bundle/onboarding-databases-to-sonar-reference-guide/page/Redis-Onboarding-Steps_48368215.html) for more information.
+
+For development and testing environments, notifications can be saved to a local file; however, this is neither supported nor intended for production environments.
+
+For performance reasons, auditing is not enabled by default.  In addition, auditing occurs in the background (asynchronously) and is non-blocking by design.  That is, the action that triggered the notification continues without regard to the status of the notification or the listening tool.  
+
+## Enable audit notifications
+
+### Cluster audits
+
+To enable auditing for your cluster, use:
+
+- `rladmin`
+
+    ```
+    rladmin cluster config auditing db_conns \
+       audit_protocol <TCP|local> \
+       audit_address <address> \
+       audit_port <port> \
+       audit_reconnect_interval <interval in seconds> \
+       audit_reconnect_max_attempts <number of attempts>
+    ```
+
+    where:
+
+    - _audit\_protocol_ indicates the protocol used to process notifications.  For production systems, _TCP_ is the only value. 
+
+    - _audit\_address_ defines the TCP/IP address where one can listen for notifications
+
+    - _audit\_port_ defines the port where one can listen for notifications
+   
+    - _audit\_reconnect\_interval_ defines the interval (in seconds) between attempts to reconnect to the listener. Default is 1 second.
+    
+    - _audit\_reconnect\_max\_attempts_ defines the maximum number of attempts to reconnect. Default is 0. (infinite)
+
+    Development systems can set _audit\_protocol_ to `local` for testing and training purposes; however, this setting is _not_ supported for production use.  
+    
+    When `audit_protocol` is set to `local`, `<address>` should be set to a [stream socket](https://man7.org/linux/man-pages/man7/unix.7.html) defined on the machine running Redis Enterprise and _`<port>`_ should not be specified: 
+    
+    ```
+    rladmin cluster config auditing db_conns \
+       audit_protocol local audit_address <output-file>
+    ```
+
+    The output file (and path) must be accessible by the user and group running Redis Enterprise Software.
+
+- the [REST API]({{< relref "/operate/rs/references/rest-api/requests/cluster/auditing-db-conns#put-cluster-audit-db-conns" >}})
+
+    ```
+    PUT /v1/cluster/auditing/db_conns
+    { 
+        "audit_address": "<address>", 
+        "audit_port": <port>, 
+        "audit_protocol": "TCP",
+        "audit_reconnect_interval": <interval>,
+        "audit_reconnect_max_attempts": <max attempts>
+    }
+    ```
+
+    where `<address>` is a string containing the TCP/IP address, `<port>` is a numeric value representing the port, `<interval>` is a numeric value representing the interval in seconds, and `<max attempts>` is a numeric value representing the maximum number of attempts to execute.
+
+### Database audits
+
+Once auditing is enabled for your cluster, you can audit individual databases.  To do so, use:
+
+- `rladmin`
+
+    ```
+    rladmin tune db db:<id|name> db_conns_auditing enabled
+    ```
+
+    where the value of the _db:_ parameter is either the cluster ID of the database or the database name.
+
+    To deactivate auditing, set `db_conns_auditing` to `disabled`.
+
+    Use `rladmin info` to retrieve additional details:
+
+    ```
+    rladmin info db <id|name>
+    rladmin info cluster
+    ```
+
+- the [REST API]({{< relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs" >}})
+
+    ```
+    PUT /v1/bdbs/1
+    { "db_conns_auditing": true }
+    ```
+
+    To deactivate auditing, set `db_conns_auditing` to `false`.
+
+You must enable auditing for your cluster before auditing a database; otherwise, an error appears:
+
+>  _Error setting description: Unable to enable DB Connections Auditing before feature configurations are set.                                                                                                  
+>  Error setting error_code: db_conns_auditing_config_missing_
+
+To resolve this error, enable the protocol for your cluster _before_ attempting to audit a database.
+
+### Policy defaults for new databases
+
+To audit connections for new databases by default, use:
+
+- `rladmin`
+
+    ```
+    rladmin tune cluster db_conns_auditing enabled
+    ```
+
+    To deactivate this policy, set `db_conns_auditing` to `disabled`.
+
+- the [REST API]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}})
+
+    ```
+    PUT /v1/cluster/policy
+    { "db_conns_auditing": true }
+    ```
+
+    To deactivate this policy, set `db_conns_auditing` to `false`.
+
+## Notification examples
+
+Audit event notifications are reported as JSON objects.
+
+### New connection
+
+This example reports a new connection for a database:
+
+``` json
+{
+    "ts":1655821384,
+    "new_conn":
+    {
+        "id":2285001002 ,
+        "srcip":"127.0.0.1",
+        "srcp":"39338",
+        "trgip":"127.0.0.1",
+        "trgp":"12635",
+        "hname":"",
+        "bdb_name":"DB1",
+        "bdb_uid":"5"
+    }
+}
+```
+
+### Authentication request
+
+Here is a sample authentication request for a database:
+
+``` json
+{
+    "ts":1655821384,
+    "action":"auth",
+    "id":2285001002 ,
+    "srcip":"127.0.0.1",
+    "srcp":"39338",
+    "trgip":"127.0.0.1",
+    "trgp":"12635",
+    "hname":"",
+    "bdb_name":"DB1",
+    "bdb_uid":"5",
+    "status":2,
+    "username":"user_one",
+    "identity":"user:1",
+    "acl-rules":"~* +@all"
+}
+```
+
+The `status` field reports the following: 
+
+- Values of 2, 7, or 8 indicate success.
+
+- Values of 3 or 5 indicate that the client authentication is in progress and should conclude later.
+
+- Other values indicate failures.
+
+### Database disconnect
+
+Here's what's reported when a database connection is closed:
+
+``` json
+{
+    "ts":1655821384,
+    "close_conn":
+    {
+        "id":2285001002,
+        "srcip":"127.0.0.1",
+        "srcp":"39338",
+        "trgip":"127.0.0.1",
+        "trgp":"12635",
+        "hname":"",
+        "bdb_name":"DB1",
+        "bdb_uid":"5"
+    }
+}
+```
+
+## Notification field reference
+
+The field value that appears immediately after the timestamp describes the action that triggered the notification.  The following values may appear:
+
+- `new_conn` indicates a new external connection
+- `new_int_conn` indicates a new internal connection 
+- `close_conn` occurs when a connection is closed
+- `"action":"auth"` indicates an authentication request and can refer to new authentication requests or authorization checks on existing connections
+
+In addition, the following fields may also appear in audit event notifications:
+
+| Field&nbsp;name | Description |
+|:---------:|-------------|
+| `acl-rules` | ACL rules associated with the connection, which includes a rule for the `default` user. |
+| `bdb_name` | Destination database name - The name of the database being accessed. | 
+| `bdb_uid` | Destination database ID - The cluster ID of the database being accessed. | 
+| `hname` | Client hostname - The hostname of the client.  Currently empty; reserved for future use. |
+| `id` | Connection ID - Unique connection ID assigned by the proxy. |
+| `identity` | Identity - A unique ID the proxy assigned to the user for the current connection. |
+| `srcip` | Source IP address - Source TCP/IP address of the client accessing the Redis database. |
+| `srcp` | Source port - Port associated with the source IP address accessing the Redis database. Combine the port with the address to uniquely identify the socket. |
+| `status` | Status result code - An integer representing the result of an authentication request. |
+| `trgip` | Target IP address - The IP address of the destination being accessed by the action. |
+| `trgp` | Target port - The port of the destination being accessed by the action.  Combine the port with the destination IP address to uniquely identify the database being accessed. |
+| `ts`  | Timestamp - The date and time of the event, in [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC).  Granularity is within one second. |
+| `username` | Authentication username  - Username associated with the connection; can include `default` for databases that allow default access.  (Passwords are _not_ recorded). |
+
+## Status result codes
+
+The `status` field reports the results of an authentication request as an integer.  Here's what different values mean:
+
+| Error&nbsp;value | Error code | Description | 
+|:-------------:|------------|-------------|
+| `0` | AUTHENTICATION_FAILED | Invalid username and/or password. |
+| `1` | AUTHENTICATION_FAILED_TOO_LONG | Username or password are too long. |
+| `2` | AUTHENTICATION_NOT_REQUIRED | Client tried to authenticate, but authentication isn't necessary. | 
+| `3` | AUTHENTICATION_DIRECTORY_PENDING | Attempting to receive authentication info from the directory in async mode. |
+| `4` | AUTHENTICATION_DIRECTORY_ERROR | Authentication attempt failed because there was a directory connection error. |
+| `5` | AUTHENTICATION_SYNCER_IN_PROGRESS | Syncer SASL handshake. Return SASL response and wait for the next request. | 
+| `6` | AUTHENTICATION_SYNCER_FAILED | Syncer SASL handshake. Returned SASL response and closed the connection. |
+| `7` | AUTHENTICATION_SYNCER_OK | Syncer authenticated. Returned SASL response. |
+| `8` | AUTHENTICATION_OK | Client successfully authenticated. |
+
+---
+Title: Certificate-based authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Certificate-based authentication allows secure, passwordless access to the REST API and databases.
+linkTitle: Certificate-based authentication 
+weight: 70
+---
+
+You can set up certificate-based authentication for specific users to enable secure, passwordless access to the Redis Enterprise Software [REST API]({{<relref "/operate/rs/references/rest-api">}}) and databases.
+
+## Set up certificate-based authentication
+
+To set up certificate-based authentication:
+
+1. [Add the `mtls_trusted_ca` certificate.](#add-cert) 
+
+1. [Configure cluster settings.](#config-cluster)
+
+1. If you want to enable certificate-based authentication for databases, you must [enable mutual TLS for the relevant databases](#enable-mtls-dbs). Otherwise, you can skip this step.
+
+1. [Create certificate auth_method users.](#create-cert-users)
+
+### Add mtls_trusted_ca certificate {#add-cert}
+
+Add a trusted CA certificate `mtls_trusted_ca` to the cluster using an [update cluster certificate]({{<relref "/operate/rs/references/rest-api/requests/cluster/certificates#put-cluster-update_cert">}}) request:
+
+```sh
+PUT /v1/cluster/update_cert
+{
+  "name": "mtls_trusted_ca",
+  "certificate": "<content of certificate PEM file>"
+}
+```
+
+### Configure cluster settings {#config-cluster}
+
+[Update cluster settings]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) with mutual TLS configuration.
+
+For certificate validation by Subject Alternative Name (SAN), use:
+
+```sh
+PUT /v1/cluster
+{
+  "mtls_certificate_authentication": true,
+  "mtls_client_cert_subject_validation_type": "san_cn",
+  "mtls_authorized_subjects": [{
+    "CN": "<Common Name>"
+  }]
+}
+```
+
+For certificate validation by full Subject Name, use:
+
+```sh
+PUT /v1/cluster
+{
+  "mtls_certificate_authentication": true,
+  "mtls_client_cert_subject_validation_type": "full_subject",
+  "mtls_authorized_subjects": [{
+    "CN": "<Common Name>",
+    "OU": [<array of Organizational Unit strings>],
+    "O": "<Organization>",
+    "C": "<2-letter country code>",
+    "L": "<Locality (city)>",
+    "ST": "<State/Province>"
+  }]
+}
+```
+
+Replace the placeholder values `<>` with your client certificate's subject values.
+
+### Enable mutual TLS for databases {#enable-mtls-dbs}
+
+Before you can connect to a database using certificate-based authentication, you must enable mutual TLS (mTLS). See [Enable TLS]({{<relref "/operate/rs/security/encryption/tls/enable-tls">}}) for detailed instructions.
+
+### Create certificate auth_method users {#create-cert-users}
+
+When you [create new users]({{<relref "/operate/rs/references/rest-api/requests/users#post-user">}}), include `"auth_method": "certificate"` and `certificate_subject_line` in the request body :
+
+```sh
+POST /v1/users
+{
+  "auth_method": "certificate",
+  "certificate_subject_line": "CN=<Common Name>, OU=<Organization Unit>, O=<Organization>, L=<Locality>, ST=<State/Province>, C=<Country>"
+}
+```
+
+Replace the placeholder values `<>` with your client certificate's subject values.
+
+## Authenticate REST API requests
+
+To use the REST API with certificate-based authentication, you must provide a client certificate, signed by the trusted CA `mtls_trusted_ca`, and a private key.
+
+The following example uses [cURL](https://curl.se/) to send a [REST API request]({{<relref "/operate/rs/references/rest-api/requests">}}):
+
+```sh
+curl --request <METHOD> --url https://<hostname-or-IP-address>:9443/<API-version>/<API-path> --cert client.pem --key client.key
+```
+
+## Authenticate database connections
+
+To connect to a database with certificate-based authentication, you must provide a client certificate, signed by the trusted CA `mtls_trusted_ca`, and a private key.
+
+The following example shows how to connect to a Redis database with [`redis-cli`]({{<relref "/operate/rs/references/cli-utilities/redis-cli">}}):
+
+```sh
+redis-cli -h <hostname-or-IP-address> -p <port> --tls --cacert <redis_cert>.pem --cert redis_user.crt --key redis_user_private.key
+```
+
+## Limitations
+
+- Certificate-based authentication is not implemented for the Cluster Manager UI.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Monitor certificates on a Redis Enterprise cluster.
+linkTitle: Monitor certificates
+title: Monitor certificates
+weight: 10
+---
+
+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]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}).
+
+Here are some examples of the `node_cert_expiration_seconds` metric:
+
+```sh
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="cm",node="1",path="/etc/opt/redislabs/cm_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="api",node="1",path="/etc/opt/redislabs/api_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="proxy",node="1",path="/etc/opt/redislabs/proxy_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="metrics_exporter",node="1",path="/etc/opt/redislabs/metrics_exporter_cert.pem"} 31104000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="syncer",node="1",path="/etc/opt/redislabs/syncer_cert.pem"} 31104000.0
+```
+
+The following certificates relate to [internode communication TLS encryption]({{< relref "/operate/rs/security/encryption/internode-encryption" >}}) and are automatically rotated by Redis Enterprise Software:
+
+```sh
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="ccs_internode_encryption",node="1",path="/etc/opt/redislabs/ccs_internode_encryption_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="data_internode_encryption",node="1",path="/etc/opt/redislabs/data_internode_encryption_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="mesh_ca_signed",node="1",path="/etc/opt/redislabs/mesh_ca_signed_cert.pem"} 2592000.0
+node_cert_expiration_seconds{cluster="mycluster.local",logical_name="gossip_ca_signed",node="1",path="/etc/opt/redislabs/gossip_ca_signed_cert.pem"} 2592000.0
+```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create self-signed certificates to install on a Redis Enterprise cluster.
+linkTitle: Create certificates
+title: Create certificates
+weight: 10
+---
+
+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](https://en.wikipedia.org/wiki/Certificate_authority) (CA).
+
+## Renew self-signed certificates
+
+As of [v6.2.18-70]({{< relref "/operate/rs/release-notes/rs-6-2-18-releases/rs-6-2-18-70" >}}), Redis Enterprise Software includes a script to generate self-signed certificates.  
+
+By default, the `generate_self_signed_certs.sh` script is located in `/opt/redislabs/utils/`.  
+
+Here, you learn how to use this script to generate new certificates and how to install them.
+
+### Step 1: Generate new certificates 
+
+Sign in to the machine hosting the cluster's master node and then run the following command:
+
+``` bash
+% sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+   -f "<DomainName1 DomainName2>" -d <Days> -t <Type>
+```
+
+where:
+
+- _\<DomainName1>_ is the fully qualified domain name (FQDN) of the cluster.  (This is the name given to the cluster when first created.)
+- _\<DomainName2>_ is an optional FQDN for the cluster.  Multiple domain names are allowed, separated by whitespace.  Quotation marks (`""`) should enclose the full set of names.
+- _\<Days>_ is an integer specifying the number of days the certificate should be valid.  We recommend against setting this longer than a year (365 days).
+
+    _\<Days>_ is optional and defaults to `365`.
+
+- _\<Type>_ is a string identifying the name of the certificate to generate.  
+    
+    The following values are supported:
+
+    | Value | Description |
+    |-------|-------------|
+    | `api` | The REST API |
+    | `cm` | The Cluster Manager UI |
+    | `metrics` | The metrics exporter |
+    | `proxy` | The database endpoint |
+    | `syncer` | The synchronization process |
+    | `all` | Generates all certificates in a single operation |
+
+    _Type_ is optional and defaults to `all`.
+
+When you run the script, it either reports success (`"Self signed cert generated successfully"`) or an error message.  Use the error message to troubleshoot any issues.
+
+The following example generates all self signed certificates for `mycluster.example.com`; these certificates expire one year after the command is run:
+
+``` bash
+$ sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+    -f "mycluster.example.com"`
+```
+
+Suppose you want to create a Cluster Manager UI certificate to support two clusters for a period of two years.  The following example shows how:
+
+``` bash
+$ sudo -u redislabs /opt/redislabs/utils/generate_self_signed_certs.sh \
+    -f "mycluster.example.com anothercluster.example.com" -d 730 -t cm
+```
+
+Here, a certificate file and certificate key are generated to support the following domains:
+
+``` text
+mycluster.example.com
+*.mycluster.example.com
+anothercluster.example.com 
+*.anothercluster.example.com
+```
+
+### Step 2: Locate the new certificate files
+
+When successful, the script generates two .PEM files for each generated certificate: a certificate file and a certificate key, each named after the type of certificate generated (see earlier table for individual certificate names.)
+
+These files can be found in the `/tmp` directory.
+
+``` bash
+$ ls -la /tmp/*.pem
+```
+
+### Step 3: Set permissions
+
+We recommend setting the permissions of your new certificate files to limit read and write access to the file owner and to set group and other user permissions to read access.
+
+``` bash
+$ sudo chmod 644 /tmp/*.pem
+```
+
+### Step 4: Replace existing certificates {#replace-self-signed}
+
+You can use `rladmin` to replace the existing certificates with new certificates:
+
+``` console
+$ rladmin cluster certificate set <CertName> certificate_file \
+   <CertFilename>.pem key_file <KeyFilename>.pem
+```
+
+The following values are supported for the _\<CertName>_ parameter:
+
+| Value | Description |
+|-------|-------------|
+| `api` | The REST API |
+| `cm` | The Cluster Manager UI |
+| `metrics_exporter` | The metrics exporter |
+| `proxy` | The database endpoint |
+| `syncer` | The synchronization process |
+
+You can also use the REST API.  To learn more, see [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates#how-to-update-certificates" >}}).
+
+## Create CA-signed certificates
+
+You can use certificates signed by a [certificate authority](https://en.wikipedia.org/wiki/Certificate_authority) (CA).  
+
+For best results, use the following guidelines to create the certificates.
+
+### TLS certificate guidelines
+
+When you create certificates signed by a certificate authority, you need to create server certificates and client certificates.  The following provide guidelines that apply to both certificates and guidance for each certificate type. 
+
+#### Guidelines for server and client certificates
+
+1.  Include the full [certificate chain](https://en.wikipedia.org/wiki/X.509#Certificate_chains_and_cross-certification) when creating certificate .PEM files for either server or client certificates.   
+
+1.  List (_chain_) certificates in the .PEM file in the following order:
+
+    ``` text    
+    -----BEGIN CERTIFICATE-----    
+    Domain (leaf) certificate
+    -----END CERTIFICATE-----
+    -----BEGIN CERTIFICATE-----
+    Intermediate CA certificate
+    -----END CERTIFICATE----
+    -----BEGIN CERTIFICATE-----
+    Trusted Root CA certificate
+    -----END CERTIFICATE-----
+    ```
+
+#### Server certificate guidelines
+
+Server certificates support clusters.  
+
+In addition to the general guidelines described earlier, the following guidelines apply to server certificates:
+
+1.  Use the cluster's fully qualified domain name (FQDN) as the certificate Common Name (CN).
+
+1.  Set the following values according to the values specified by your security team or certificate authority:
+
+    - Country Name (C)
+    - State or Province Name (ST)
+    - Locality Name (L)
+    - Organization Name (O)
+    - Organization Unit  (OU)
+
+1.  The [Subject Alternative Name](https://en.wikipedia.org/wiki/Subject_Alternative_Name) (SAN) should include the following values based on the FQDN:
+
+    ``` text
+    dns=<cluster-fqdn>
+    dns=*.<cluster-fqdn>
+    dns=internal.<cluster-fqdn>
+    dns=*.internal.<cluster-fqdn>
+    ```
+
+1.  The Extended Key Usage attribute should be set to `TLS Web Client Authentication` and `TLS Web Server Authentication`.
+
+1.  We strongly recommend using a strong hash algorithm, such as <nobr>SHA-256</nobr> or <nobr>SHA-512</nobr>.
+
+    Individual operating systems might limit access to specific algorithms.  For example, Ubuntu 20.04 [limits  access](https://manpages.ubuntu.com/manpages/focal/man7/crypto-policies.7.html) to <nobr>SHA-1</nobr>.  In such cases, Redis Enterprise Software is limited to the features supported by the underlying operating system.
+
+
+#### Client certificate guidelines
+
+Client certificates support database connections.  
+
+In addition to the general guidelines described earlier, the following guidelines apply to client certificates:
+
+1.  The Extended Key Usage attribute should be set to `TLS Web Client Authentication`.
+
+1.  We strongly recommend using a strong hash algorithm, such as <nobr>SHA-256</nobr> or <nobr>SHA-512</nobr>.
+
+    Individual operating systems might limit access to specific algorithms.  For example, Ubuntu 20.04 [limits  access](https://manpages.ubuntu.com/manpages/focal/man7/crypto-policies.7.html) to <nobr>SHA-1</nobr>.  In such cases, Redis Enterprise Software is limited to the features supported by the underlying operating system.
+
+### Create certificates
+
+The actual process of creating CA-signed certificates varies according to the CA.  In addition, your security team may have custom instructions that you need to follow. 
+
+Here, we demonstrate the general process using OpenSSL.  If your CA provides alternate tools, you should use those according to their instructions. 
+
+However you choose to create the certificates, be sure to incorporate the guidelines described earlier.
+
+1.  Create a private key.
+
+    ``` bash
+    $ openssl genrsa -out <key-file-name>.pem 2048
+    ```
+
+1.  Create a certificate signing request.
+
+    ``` bash
+    $ openssl req -new -key <key-file-name>.pem -out \
+       <key-file-name>.csr -config <csr-config-file>.cnf
+    ```
+    _Important:&nbsp;_ The .CNF file is a configuration file.  Check with your security team or certificate authority for help creating a valid configuration file for your environment.
+
+3.  Sign the private key using your certificate authority.
+
+    ```sh
+    $ openssl x509 -req -in <key-file-name>.csr -signkey <key-file-name>.pem -out <cert-name>.pem
+    ```
+
+    The signing process varies for each organization and CA vendor.  Consult your security team and certificate authority for specific instructions describing how to sign a certificate.
+
+4.  Upload the certificate to your cluster.
+
+    You can use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/certificate" >}}) to replace the existing certificates with new certificates:
+
+    ``` console
+    $ rladmin cluster certificate set <cert-name> certificate_file \
+       <cert-name>.pem key_file <key-file-name>.pem
+    ```
+
+    For a list of values supported by the `<cert-name>` parameter, see the [earlier table](#replace-self-signed).
+
+    You can also use the REST API.  To learn more, see [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates#how-to-update-certificates" >}}).
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use OCSP stapling to verify certificates maintained by a third-party
+  CA and authenticate connection attempts between clients and servers.
+linkTitle: Enable OCSP stapling
+title: Enable OCSP stapling
+weight: 50
+---
+
+OCSP ([Online Certificate Status Protocol](https://en.wikipedia.org/wiki/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)](https://en.wikipedia.org/wiki/Certificate_authority).
+
+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](https://en.wikipedia.org/wiki/Certificate_revocation_list) and sends the status back as a signed and timestamped response.
+
+## OCSP stapling overview
+
+ With OCSP enabled, the Redis Enterprise server regularly polls the CA's OCSP responder for the certificate's status. After it receives the response, the server caches this status until its next polling attempt.
+
+ When a client tries to connect to the Redis Enterprise server, they perform a [TLS handshake](https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_handshake) to authenticate the server and create a secure, encrypted connection. During the TLS handshake, [OCSP stapling](https://en.wikipedia.org/wiki/OCSP_stapling) lets the Redis Enterprise server send (or "staple") the cached certificate status to the client.
+
+If the stapled OCSP response confirms the certificate is still valid, the TLS handshake succeeds and the client connects to the server.
+
+The TLS handshake fails and the client blocks the connection to the server if the stapled OCSP response indicates either:
+
+- The certificate has been revoked.
+
+- The certificate's status is unknown. This can happen if the OCSP responder fails to send a response.
+
+## Set up OCSP stapling
+
+You can configure and enable OCSP stapling for your Redis Enterprise cluster with the [Cluster Manager UI](#cluster-manager-ui-method), the [REST API](#rest-api-method), or [`rladmin`](#rladmin-method).
+
+While OCSP is enabled, the server always staples the cached OCSP status when a client tries to connect. It is the client's responsibility to use the stapled OCSP status. Some Redis clients, such as [Jedis](https://github.com/redis/jedis) and [redis-py](https://github.com/redis/redis-py), already support OCSP stapling, but others might require additional configuration.
+
+### Cluster Manager UI method
+
+To set up OCSP stapling with the Redis Enterprise Cluster Manager UI:
+
+1. Go to **Cluster > Security > OCSP**.
+
+1. In the **Responder URI** section, select **Replace Certificate** to update the proxy certificate.
+
+1. Provide the key and certificate signed by your third-party CA, then select **Save**.
+
+1. Configure query settings if you don't want to use their default values:
+
+    | Name | Default value | Description |
+    |------|---------------|-------------|
+    | **Query frequency** | 1 hour | The time interval between OCSP queries to the responder URI. |
+    | **Response timeout** | 1 second | The time interval in seconds to wait for a response before timing out. |
+    | **Recovery frequency** | 1 minute | The time interval between retries after a failed query. |
+    | **Recovery maximum tries** | 5 | The number of retries before the validation query fails and invalidates the certificate. |
+
+1. Select **Enable** to turn on OCSP stapling.
+
+### REST API method
+
+To set up OCSP stapling with the [REST API]({{< relref "/operate/rs/references/rest-api" >}}):
+
+1. Use the REST API to [replace the proxy certificate]({{< relref "/operate/rs/security/certificates/updating-certificates#use-the-rest-api" >}}) with a certificate signed by your third-party CA.
+
+1. To configure and enable OCSP, send a [`PUT` request to the `/v1/ocsp`]({{< relref "/operate/rs/references/rest-api/requests/ocsp#put-ocsp" >}}) endpoint and include an [OCSP JSON object]({{< relref "/operate/rs/references/rest-api/objects/ocsp" >}}) in the request body:
+
+    ```json
+    {
+        "ocsp_functionality": true,
+        "query_frequency": 3600,
+        "response_timeout": 1,
+        "recovery_frequency": 60,
+        "recovery_max_tries": 5
+    }
+    ```
+
+### `rladmin` method
+
+To set up OCSP stapling with the [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command-line utility:
+
+1. Use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/certificate" >}}) to [replace the proxy certificate]({{< relref "/operate/rs/security/certificates/updating-certificates#use-the-cli" >}}) with a certificate signed by your third-party CA.
+
+1. Update the cluster's OCSP settings with the [`rladmin cluster ocsp config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/ocsp#ocsp-config" >}}) command if you don't want to use their default values.
+
+    For example: 
+
+    ```sh
+    rladmin cluster ocsp config recovery_frequency set 30
+    ```
+
+1. Enable OCSP:
+
+    ```sh
+    rladmin cluster ocsp config ocsp_functionality set enabled
+    ```
+---
+Title: Certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of certificates in Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Certificates
+weight: 60
+---
+
+Redis Enterprise Software uses self-signed certificates by default to ensure that the product is secure. These certificates are autogenerated on the first node of each Redis Enterprise Software installation and are copied to all other nodes added to the cluster.
+
+You can replace a self-signed certificate with one signed by a certificate authority of your choice.
+
+## Supported certificates
+
+Here's the list of supported certificates that create secure, encrypted connections to your Redis Enterprise Software cluster:
+
+| Certificate name | Autogenerated | Description |
+|------------------|:---------------:|-------------|
+| `api` | <span title="Yes">&#x2705;</span> | Encrypts [REST API]({{< relref "/operate/rs/references/rest-api/" >}}) requests and responses. |
+| `cm` | <span title="Yes">&#x2705;</span> | Secures connections to the Redis Enterprise Cluster Manager UI. |
+| `ldap_client` | <span title="No">:x:</span> | Secures connections between LDAP clients and LDAP servers. |
+| `metrics_exporter` | <span title="Yes">&#x2705;</span> | Sends Redis Enterprise metrics to external [monitoring tools]({{< relref "/operate/rs/monitoring/" >}}) over a secure connection. |
+| `mtls_trusted_ca` | <span title="No">:x:</span>  | Required to enable certificate-based authentication for secure, passwordless access to the REST API. |
+| `proxy` | <span title="Yes">&#x2705;</span> | Creates secure, encrypted connections between clients and databases. |
+| `syncer` | <span title="Yes">&#x2705;</span> | For [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) or [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}}) databases, encrypts data during the synchronization of participating clusters. |
+
+Certificates that are not autogenerated are optional unless you want to use certain features. For example, you must provide your own `ldap_client` certificate to enable [LDAP authentication]({{<relref "/operate/rs/security/access-control/ldap">}}) or an `mtls_trusted_ca` certificate to enable certificate-based authentication.
+
+## Accept self-signed certificates to access the Cluster Manager UI
+
+When you use the default self-signed certificates and you connect to the Cluster Manager UI over a web browser, you'll see an untrusted connection notification. Depending on your browser, you can allow the connection for each session or add an exception to trust the certificate for all future sessions.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update certificates in a Redis Enterprise cluster.
+linkTitle: Update certificates
+title: Update certificates
+weight: 20
+---
+
+{{<warning>}}
+When you update the certificates, the new certificate replaces the same certificates on all nodes in the cluster.
+{{</warning>}}
+
+## How to update certificates
+
+You can use the [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) command-line interface (CLI) or the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) to update certificates. The Cluster Manager UI lets you update proxy and syncer certificates on the **Cluster > Security > Certificates** screen.
+
+The new certificates are used the next time the clients connect to the database.
+
+When you upgrade Redis Enterprise Software, the upgrade process copies the certificates that are on the first upgraded node to all of the nodes in the cluster.
+
+{{<note>}}
+Don't manually overwrite the files located in `/etc/opt/redislabs`. Instead, upload new certificates to a temporary location on one of the cluster nodes, such as the `/tmp` directory.
+{{</note>}}
+
+### Use the Cluster Manager UI
+
+To replace proxy or syncer certificates using the Cluster Manager UI:
+
+1. Go to **Cluster > Security > Certificates**.
+
+1. Expand the section for the certificate you want to update:
+    - For the proxy certificate, expand **Server authentication**.
+    - For the syncer certificate, expand **Replica Of and Active-Active authentication**.
+
+    {{<image filename="images/rs/screenshots/cluster/security-expand-proxy-cert.png"  alt="Expanded proxy certificate for server authentication.">}}
+
+1. Click **Replace Certificate** to open the dialog.
+
+    {{<image filename="images/rs/screenshots/cluster/security-replace-proxy-cert.png"  alt="Replace proxy certificate dialog.">}}
+
+1. Upload the key file.
+
+1. Upload the new certificate.
+
+1. Click **Save**.
+
+### Use the CLI
+
+To replace certificates with the `rladmin` CLI, run the [`cluster certificate set`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/certificate" >}}) command:
+
+```sh
+ rladmin cluster certificate set <cert-name> certificate_file <cert-file-name>.pem key_file <key-file-name>.pem
+```
+
+Replace the following variables with your own values:
+
+- `<cert-name>` - The name of the certificate you want to replace. See the [certificates table]({{< relref "/operate/rs/security/certificates" >}}) for the list of valid certificate names.
+- `<cert-file-name>` - The name of your certificate file
+- `<key-file-name>` - The name of your key file
+
+For example, to replace the Cluster Manager UI (`cm`) certificate with the private key `key.pem` and the certificate file `cluster.pem`:
+
+```sh
+rladmin cluster certificate set cm certificate_file cluster.pem key_file key.pem
+```
+
+### Use the REST API
+
+To replace a certificate using the REST API, use [`PUT /v1/cluster/update_cert`]({{< relref "/operate/rs/references/rest-api/requests/cluster/certificates#put-cluster-update_cert" >}}):
+
+```sh
+PUT https://[host][:port]/v1/cluster/update_cert
+    '{ "name": "<cert_name>", "key": "<key>", "certificate": "<cert>" }'
+```
+
+Replace the following variables with your own values:
+
+- `<cert_name>` - The name of the certificate to replace. See the [certificates table]({{< relref "/operate/rs/security/certificates" >}}) for the list of valid certificate names.
+- `<key>` - The contents of the \*\_key.pem file
+
+    {{< tip >}}
+
+  The key file contains `\n` end of line characters (EOL) that you cannot paste into the API call.
+  You can use `sed -z 's/\n/\\\n/g'` to escape the EOL characters.
+  {{< /tip >}}
+
+- `<cert>` - The contents of the \*\_cert.pem file
+
+## Replica Of database certificates
+
+This section describes how to update certificates for Replica Of databases.
+
+### Update proxy certificates {#update-ap-proxy-certs}
+
+To update the proxy certificate on clusters running Replica Of databases:
+
+1. Use the Cluster Manager UI, `rladmin`, or the REST API to update the proxy certificate on the source database cluster.
+
+1. From the Cluster Manager UI, update the destination database (_replica_) configuration with the [new certificate]({{< relref "/operate/rs/databases/import-export/replica-of/create#encrypt-replica-database-traffic" >}}).
+
+{{<note>}}
+- Perform step 2 as quickly as possible after performing step 1.  Connections using the previous certificate are rejected after applying the new certificate.  Until both steps are performed, recovery of the database sync cannot be established.
+{{</note>}}
+
+## Active-Active database certificates
+
+### Update proxy certificates {#update-aa-proxy-certs}
+
+To update proxy certificate on clusters running Active-Active databases:
+
+1. Use the Cluster Manager UI, `rladmin`, or the REST API to update proxy certificates on a single cluster, multiple clusters, or all participating clusters.
+
+1. Use the [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) utility to update Active-Active database configuration from the command line. Run the following command once for each Active-Active database residing on the modified clusters:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --force
+    ```
+
+{{<note>}}
+- Perform step 2 as quickly as possible after performing step 1.  Connections using the previous certificate are rejected after applying the new certificate.  Until both steps are performed, recovery of the database sync cannot be established.<br/>
+- Do not run any other `crdb-cli crdb update` operations between the two steps.
+{{</note>}}
+
+### Update syncer certificates {#update-aa-syncer-certs}
+
+To update your syncer certificate on clusters running Active-Active databases, follow these steps:
+
+1. Update your syncer certificate on one or more of the participating clusters using the Cluster Manager UI, `rladmin`, or the REST API. You can update a single cluster, multiple clusters, or all participating clusters.
+
+1. Update the Active-Active database configuration from the command line with the [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) utility. Run this command once for each Active-Active database that resides on the modified clusters:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --force
+    ```
+
+{{<note>}}
+- Run step 2 as quickly as possible after step 1. Between the two steps, new syncer connections that use the ‘old’ certificate will get rejected by the cluster that has been updated with the new certificate (in step 1).<br/>
+- Do not run any other `crdb-cli crdb update` operations between the two steps.<br/>
+{{</note>}}
+---
+Title: Recommended security practices
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Recommended security practices
+hideListLinks: true
+weight: 5
+---
+
+## Deployment security
+
+When deploying Redis Enterprise Software to production, we recommend the following practices:
+
+- **Deploy Redis Enterprise inside a trusted network**:  Redis Enterprise is database software and should be deployed on a trusted network not accessible to the public internet. Deploying Redis Enterprise in a trusted network reduces the likelihood that someone can obtain unauthorized access to your data or the ability to manage your database configuration.
+
+- **Implement anti-virus exclusions**: To ensure that anti-virus solutions that scan files or intercept processes to protect memory do not interfere with Redis Enterprise software, you should ensure that anti-virus exclusions are implemented across all nodes in their Redis Enterprise cluster in a consistent policy. This helps ensure that anti-virus software does not impact the availability of your Redis Enterprise cluster.
+
+    If you are replacing your existing antivirus solution or installing/supporting Redis Enterprise, make sure that the below paths are excluded:
+
+    {{< note >}}
+For antivirus solutions that intercept processes, binary files may have to be excluded directly depending on the requirements of your anti-virus vendor.
+    {{< /note >}}
+
+    | **Path** | **Description** |
+    |------------|-----------------|
+    | /opt/redislabs | Main installation directory for all Redis Enterprise Software binaries |
+    | /opt/redislabs/bin | Binaries for all the utilities for command line access and managements such as "rladmin" or "redis-cli" |
+    | /opt/redislabs/config | System configuration files |
+    | /opt/redislabs/lib | System library files |
+    | /opt/redislabs/sbin | System binaries for tweaking provisioning |
+
+- **Send logs to a remote logging server**: Redis Enterprise is configured to send logs by default to syslog. To send these logs to a remote logging server you must [configure syslog]({{<relref "/operate/rs/clusters/logging/log-security">}}) based the requirements of the remote logging server vendor. Remote logging helps ensure that the logs are not deleted so that you can rotate the logs to prevent your server disk from filling up.
+
+- **Deploy clusters with an odd number of 3 or more nodes**: Redis is an available and partition-tolerant database. We recommend that Redis Enterprise be deployed in a cluster of an odd number of 3 or more nodes so that you are able to successfully failover in the event of a failure.
+
+- **Reboot nodes in a sequence rather than all at once**: It is best practice to frequently maintain reboot schedules. If you reboot too many servers at once, it is possible to cause a quorum failure that results in loss of availability of the database. We recommend that rebooting be done in a phased manner so that quorum is not lost. For example, to maintain quorum in a 3 node cluster, at least 2 nodes must be up at all times. Only one server should be rebooted at any given time to maintain quorum.
+
+- **Implement client-side encryption**: Client-side encryption, or the practice of encrypting data within an application before storing it in a database, such as Redis, is the most widely adopted method to achieve encryption in memory. Redis is an in-memory database and stores data in-memory. If you require encryption in memory, better known as encryption in use, then client side encryption may be the right solution for you. Please be aware that database functions that need to operate on data — such as simple searching functions, comparisons, and incremental operations — don’t work with client-side encryption.
+
+## Cluster security
+
+- **Control the level of access to your system**: Redis Enterprise lets you decide which users can access the cluster, which users can access databases, and which users can access both. We recommend preventing database users from accessing the cluster. See [Access control]({{<relref "/operate/rs/security/access-control">}}) for more information.
+
+- **Enable LDAP authentication**: If your organization uses the Lightweight Directory Access Protocol (LDAP), we recommend enabling Redis Enterprise Software support for role-based LDAP authentication.
+
+- **Require HTTPS for API endpoints**: Redis Enterprise comes with a REST API to help automate tasks. This API is available in both an encrypted and unencrypted endpoint for backward compatibility. You can [disable the unencrypted endpoint]({{<relref "/operate/rs/references/rest-api/encryption#require-https-for-api-endpoints">}}) with no loss in functionality.
+
+## Database security
+
+Redis Enterprise offers several database security controls to help protect your data against unauthorized access and to improve the operational security of your database. The following section details configurable security controls available for implementation.
+
+- **Use strong Redis passwords**: A frequent recommendation in the security industry is to use strong passwords to authenticate users. This helps to prevent brute force password guessing attacks against your database. Its important to check that your password aligns with your organizations security policy.
+
+- **Deactivate default user access**: Redis Enterprise comes with a "default" user for backwards compatibility with applications designed with versions of Redis prior to Redis Enterprise 6. The default user is turned on by default. This allows you to access the database without specifying a username and only using a shared secret. For applications designed to use access control lists, we recommend that you [deactivate default user access]({{<relref "/operate/rs/security/access-control/manage-users/default-user#deactivate-default-user">}}).
+
+- **Configure Transport Layer Security (TLS)**: Similar to the control plane, you can also [configure TLS protocols]({{<relref "/operate/rs/security/encryption/tls/tls-protocols">}}) to help support your security and compliance needs.
+
+- **Enable client certificate authentication**: To prevent unauthorized access to your data, Redis Enterprise databases support the [TLS protocol]({{<relref "/operate/rs/security/encryption/tls#client-certificate-authentication">}}), which includes authentication and encryption. Client certificate authentication can be used to ensure only authorized hosts can access the database.
+
+- **Install trusted certificates**: Redis implements self-signed certificates for the database proxy and replication service, but many organizations prefer to [use their own certificates]({{<relref "/operate/rs/security/certificates/create-certificates">}}).
+
+- **Configure and verify database backups**: Implementing a disaster recovery strategy is an important part of data security. Redis Enterprise supports [database backups to many destinations]({{<relref "/operate/rs/databases/import-export/schedule-backups">}}).
+---
+Title: Rotate passwords
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Rotate user passwords.
+linkTitle: Rotate passwords
+toc: 'true'
+weight: 70
+---
+
+Redis Enterprise Software lets you implement password rotation policies using the [REST API]({{< relref "/operate/rs/references/rest-api" >}}).
+
+You can add a new password for a database user without immediately invalidating the old one (which might cause authentication errors in production).
+
+{{< note >}}
+Password rotation does not work for the default user. [Add additional users]({{< relref "/operate/rs/security/access-control/create-users" >}}) to enable password rotation.
+{{< /note >}}
+
+## Password rotation policies
+
+For user access to the Redis Enterprise Software Cluster Manager UI,
+you can set a [password expiration policy]({{< relref "/operate/rs/security/access-control/manage-passwords/password-expiration" >}}) to prompt the user to change their password.
+
+However, for database connections that rely on password authentication,
+you need to allow for authentication with the existing password while you roll out the new password to your systems.
+
+With the Redis Enterprise Software REST API, you can add additional passwords to a user account for authentication to the database or the Cluster Manager UI and API.
+
+After the old password is replaced in the database connections, you can delete the old password to finish the password rotation process.
+
+{{< warning >}}
+Multiple passwords are only supported using the REST API.
+If you reset the password for a user in the Cluster Manager UI,
+the new password replaces all other passwords for that user.
+{{< /warning >}}
+
+The new password cannot already exist as a password for the user and must meet the [password complexity]({{< relref "/operate/rs/security/access-control/manage-passwords/password-complexity-rules" >}}) requirements, if enabled.
+
+## Rotate password
+
+To rotate the password of a user account:
+
+1. Add an additional password to a user account with [`POST /v1/users/password`]({{< relref "/operate/rs/references/rest-api/requests/users/password#add-password" >}}):
+
+    ```sh
+    POST https://[host][:port]/v1/users/password
+         '{"username":"<username>", "old_password":"<an_existing_password>", "new_password":"<a_new_password>"}'
+    ```
+
+    After you send this request, you can authenticate with both the old and the new password.
+
+1. Update the password in all database connections that connect with the user account.
+1. Delete the original password with [`DELETE /v1/users/password`]({{< relref "/operate/rs/references/rest-api/requests/users/password#update-password" >}}):
+
+    ```sh
+    DELETE https://[host][:port]/v1/users/password
+           '{"username":"<username>", "old_password":"<an_existing_password>"}'
+    ```
+
+    If there is only one valid password for a user account, you cannot delete that password.
+
+## Replace all passwords
+
+You can also replace all existing passwords for a user account with a single password that does not match any existing passwords.
+This can be helpful if you suspect that your passwords are compromised and you want to quickly resecure the account.
+
+To replace all existing passwords for a user account with a single new password, use [`PUT /v1/users/password`]({{< relref "/operate/rs/references/rest-api/requests/users/password#delete-password" >}}):
+
+```sh
+PUT https://[host][:port]/v1/users/password
+    '{"username":"<username>", "old_password":"<an_existing_password>", "new_password":"<a_new_password>"}'
+```
+
+All of the existing passwords are deleted and only the new password is valid.
+
+{{<note>}}
+If you send the above request without specifying it is a `PUT` request, the new password is added to the list of existing passwords.
+{{</note>}}
+---
+Title: Configure password expiration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure password expiration to enforce expiration of a user's password
+  after a specified number of days.
+linkTitle: Password expiration
+toc: 'true'
+weight: 50
+---
+
+## Enable password expiration 
+
+To enforce an expiration of a user's password after a specified number of days:
+
+- Use the Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn on **Expiration**.
+
+    1. Enter the number of days before passwords expire.
+
+    1. Select **Save**.
+
+- Use the `cluster` endpoint of the REST API
+
+    ``` REST
+    PUT https://[host][:port]/v1/cluster
+    {"password_expiration_duration":<number_of_days>}
+    ```
+
+## Deactivate password expiration
+
+To deactivate password expiration:
+
+- Use the Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn off **Expiration**.
+
+    1. Select **Save**.
+
+- Use the `cluster` REST API endpoint to set `password_expiration_duration` to `0` (zero).
+---
+Title: Change the password hashing algorithm
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Change the password hashing algorithm for user passwords in a Redis Enterprise Software cluster.
+linkTitle: Password hashing algorithm
+toc: 'true'
+weight: 95
+---
+
+Redis Enterprise Software securely stores all user passwords using a cryptographic hash function. The default password hashing algorithm is `SHA-256`, but `PBKDF2` is also supported as of Redis Enterprise Software version 7.8.6-13.
+
+You can change the password hashing algorithm using [`rladmin`]({{<relref "/operate/rs/references/cli-utilities/rladmin">}}) or the [REST API]({{<relref "/operate/rs/references/rest-api">}}). When you change the password hashing algorithm, the cluster rehashes the administrator password and passwords for all users, including default users.
+
+## Command-line method
+
+To change the password hashing algorithm from the command line, run [`rladmin cluster change_password_hashing_algorithm`]({{<relref "/operate/rs/references/cli-utilities/rladmin/cluster/change_password_hashing_algorithm">}}):
+
+```sh
+rladmin cluster change_password_hashing_algorithm PBKDF2
+```
+
+## REST API method
+
+You can [change the password hashing algorithm]({{<relref "/operate/rs/references/rest-api/requests/cluster/change_password_hashing_algorithm#patch-change-password-hashing-algorithm">}}) using a REST API request:
+
+```sh
+PATCH /v1/cluster/change_password_hashing_algorithm
+{ "algorithm": "PBKDF2" }
+```
+---
+Title: Update admin credentials for Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update admin credentials for Active-Active databases.
+linkTitle: Update Active-Active admin credentials
+weight: 90
+---
+
+Active-Active databases use administrator credentials to manage operations.
+
+To update the administrator user password on a cluster with Active-Active databases:
+
+1. From the user management page, update the administrator user password on the clusters you want to update.
+
+1. For each participating cluster _and_ each Active-Active database, update the admin user credentials to match the changes in step 1. 
+
+{{<warning>}}
+Do not perform any management operations on the databases until these steps are complete.
+{{</warning>}}
+---
+Title: Configure password complexity rules
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enable password complexity rules and configure minimum password length.
+linkTitle: Password complexity rules
+toc: 'true'
+weight: 30
+---
+
+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.
+
+In addition, the password:
+
+- Cannot contain the user's email address or the reverse of the email address.
+- Cannot have more than three repeating characters.
+
+Password complexity rules apply when a new user account is created and when the password is changed.  Password complexity rules are not applied to accounts authenticated by an external identity provider.  
+
+## Enable password complexity rules
+
+To enable password complexity rules, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, enable **Complexity rules**.
+
+    1. Select **Save**.
+
+- [Update cluster]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) REST API request:
+
+    ```sh
+    PUT https://[host][:port]/v1/cluster
+    { "password_complexity": true }
+    ```
+
+## Change minimum password length
+
+When password complexity rules are enabled, passwords must have at least 8 characters by default.
+
+If you change the minimum password length, the new minimum is enforced for new users and when existing users change their passwords.
+
+To change the minimum password length, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**.
+    
+    1. Click **Edit**.
+
+    1. In the **Password** section, enable **Complexity rules**.
+
+    1. Set the number of characters for **Minimum password length**.
+
+        {{<image filename="images/rs/screenshots/cluster/security-preferences-min-password-length.png" alt="The minimum password length setting appears in the password section of the cluster security preferences screen when complexity rules are enabled." >}}
+
+    1. Click **Save**.
+
+- [Update cluster]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) REST API request:
+
+    ```sh
+    PUT https://[host][:port]/v1/cluster
+    { "password_min_length": <integer between 8-256> }
+    ```
+
+## Deactivate password complexity rules
+
+To deactivate password complexity rules, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. In the **Password** section, turn off **Complexity rules**.
+
+    1. Select **Save**.
+
+- [Update cluster]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) REST API request:
+
+    ```sh
+    PUT https://[host][:port]/v1/cluster
+    { "password_complexity": false }
+    ```
+---
+Title: Set password policies
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set password policies.
+hideListLinks: true
+linkTitle: Set password policies
+toc: 'true'
+weight: 30
+---
+
+Redis Enterprise Software provides several ways to manage the passwords of local accounts, including:
+
+- [Password complexity rules]({{< relref "/operate/rs/security/access-control/manage-passwords/password-complexity-rules" >}})
+
+- [Password expiration]({{< relref "/operate/rs/security/access-control/manage-passwords/password-expiration" >}})
+
+- [Password rotation]({{< relref "/operate/rs/security/access-control/manage-passwords/rotate-passwords" >}})
+
+You can also manage a user's ability to [sign in]({{< relref "/operate/rs/security/access-control/manage-users/login-lockout#user-login-lockout" >}}) and control [session timeout]({{< relref "/operate/rs/security/access-control/manage-users/login-lockout#session-timeout" >}}).
+
+To enforce more advanced password policies, we recommend using [LDAP integration]({{< relref "/operate/rs/security/access-control/ldap" >}}) with an external identity provider, such as Active Directory.
+
+{{<note>}}
+Redis Enterprise Software securely stores all user passwords using a cryptographic hash function. The default password hashing algorithm is `SHA-256`, but you can [change the password hashing algorithm]({{<relref "/operate/rs/security/access-control/manage-passwords/password-hashing-algorithm">}}) to `PBKDF2` as of Redis Enterprise Software version 7.8.6-13.
+{{</note>}}
+---
+Title: Manage user login
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage user login lockout and session timeout.
+linkTitle: Manage user login and session
+toc: 'true'
+weight: 40
+---
+
+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.
+
+## User login lockout
+
+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`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}).
+
+### View login lockout settings
+
+You can view the cluster's user login lockout settings from **Cluster > Security > Preferences > Lockout threshold** in the Cluster Manager UI or with [`rladmin info cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/info#info-cluster" >}}):
+
+```sh
+$ rladmin info cluster | grep login_lockout
+    login_lockout_counter_reset_after: 900
+    login_lockout_duration: 1800
+    login_lockout_threshold: 5
+```
+
+### Configure user login lockout
+
+To change the user login lockout settings using the Cluster Manager UI:
+
+1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+1. In the **Lockout threshold** section, make sure the checkbox is selected.
+
+    {{<image filename="images/rs/screenshots/cluster/security-preferences-lockout-threshold.png" alt="The Lockout threshold configuration section" >}}
+
+1. Configure the following **Lockout threshold** settings:
+
+    1. **Log-in attempts until user is revoked** - The number of failed login attempts allowed before the user account is locked.
+
+    1. **Time between failed login attempts** in seconds, minutes, or hours - The amount of time during which failed login attempts are counted.
+
+    1. For **Unlock method**, select one of the following:
+
+        - **Locked duration** to set how long the user account is locked after excessive failed login attempts.
+
+        - **Only Admin can unlock the user by resetting the password**.
+
+1. Select **Save**.
+
+### Change allowed login attempts
+
+To change the number of failed login attempts allowed before the user account is locked, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold <integer>
+    ```
+
+    For example, to set the lockout threshold to 10 failed login attempts, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 10
+    ```
+
+    If you set the lockout threshold to 0, it turns off account lockout, and the cluster settings show `login_lockout_threshold: disabled`.
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 0
+    ```
+
+### Change time before login attempts reset
+
+To change the amount of time during which failed login attempts are counted, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_counter_reset_after <seconds>
+    ```
+
+    For example, to set the lockout reset to 1 hour, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_counter_reset_after 3600
+    ```
+
+### Change login lockout duration
+
+To change the amount of time that the user account is locked after excessive failed login attempts, use one of the following methods:
+
+- [Cluster Manager UI](#configure-user-login-lockout)
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_duration <login_lockout_duration>
+    ```
+
+    For example, to set the lockout duration to 1 hour, run:
+
+    ```sh
+    rladmin tune cluster login_lockout_duration 3600
+    ```
+
+    If you set the lockout duration to 0, then the account can be unlocked only when an administrator changes the account's password.
+
+    ```sh
+    rladmin tune cluster login_lockout_duration 0
+    ```
+
+    The cluster settings now show `login_lockout_duration: admin-release`.
+
+### Unlock locked user accounts
+
+To unlock a user account in the Cluster Manager UI:
+
+1. Go to **Access Control > Users**. Locked users have a "User is locked out" label:
+
+   {{<image filename="images/rs/screenshots/access-control/users-locked-out.png" alt="The Access Control > Users configuration screen in the Cluster Manager UI" >}}
+
+1. Point to the user you want to unlock, then click **Reset to unlock**:
+
+   {{<image filename="images/rs/screenshots/access-control/users-reset-to-unlock.png" alt="Reset to unlock button appears when you point to a locked user in the list" >}}
+
+1. In the **Reset user password** dialog, enter a new password for the user:
+
+   {{<image filename="images/rs/screenshots/access-control/users-reset-user-password-dialog.png" alt="Reset user password dialog" >}}
+
+1. Select **Save** to reset the user's password and unlock their account.
+
+To unlock a user account or reset a user password with `rladmin`, run:
+
+```sh
+rladmin cluster reset_password <user_email>
+```
+
+To unlock a user account or reset a user password with the REST API, use [`PUT /v1/users`]({{< relref "/operate/rs/references/rest-api/requests/users#put-user" >}}):
+
+```sh
+PUT /v1/users
+{"password": "<new_password>"}
+```
+
+### Turn off login lockout
+
+To turn off user login lockout and allow unlimited login attempts, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. Clear the **Lockout threshold** checkbox.
+
+    1. Select **Save**.
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+    ```sh
+    rladmin tune cluster login_lockout_threshold 0
+    ```
+
+The cluster settings show `login_lockout_threshold: disabled`.
+
+## Configure session timeout
+
+The Redis Enterprise Cluster Manager UI supports session timeouts. By default, users are automatically logged out after 15 minutes of inactivity.
+
+To customize the session timeout, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. Go to **Cluster > Security > Preferences**, then select **Edit**.
+
+    1. For **Session timeout**, select minutes or hours from the list and enter the timeout value.
+
+    1. Select **Save**.
+
+- [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}):
+
+    ```sh
+    rladmin cluster config cm_session_timeout_minutes <number_of_min>
+    ```
+
+    The `<number_of_min>` is the number of minutes after which sessions will time out.
+---
+Title: Manage user security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage user account security settings.
+hideListLinks: false
+linkTitle: Manage user security
+weight: 20
+---
+
+Redis Enterprise supports the following user account security settings:
+
+- Password complexity
+- Password expiration
+- User lockouts
+- Account inactivity timeout
+
+## Manage users and user security
+
+---
+Title: Manage default user
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage a database's default user.
+linkTitle: Manage default user
+toc: 'true'
+weight: 60
+---
+
+When you [create a database]({{< relref "/operate/rs/databases/create" >}}), 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.
+
+{{<image filename="images/rs/screenshots/databases/security-access-control-password-only.png" alt="Select Password-only authentication to require a password to access the database." >}}
+
+## Authenticate as default user
+
+When you configure a password for your database, all connections to the database must authenticate using the [AUTH]({{< relref "/commands/auth" >}}) command. See Redis security's [authentication]({{<relref "/operate/oss_and_stack/management/security/#authentication">}}) section for more information.
+
+```sh
+AUTH <default-database-password>
+```
+
+## Change default database password
+
+To change the default user's password:
+
+1. From the database's **Security** tab, select **Edit**.
+
+1. In the **Access Control** section, select **Password-only authentication** as the **Access method**.
+
+1. Enter and re-enter the new password.
+
+1. Select **Save**.
+
+## Deactivate default user
+
+If you set up [role-based access control]({{< relref "/operate/rs/security/access-control" >}}) with [access control lists]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}) (ACLs) for your database and don't require backwards compatibility with versions earlier than Redis 6, you can [deactivate the default user]({{< relref "/operate/rs/security/access-control/manage-users/default-user" >}}).
+
+{{<warning>}}
+Before you deactivate default user access, make sure the role associated with the database is [assigned to a user]({{< relref "/operate/rs/security/access-control/create-users" >}}). Otherwise, the database will be inaccessible.
+{{</warning>}}
+
+To deactivate the default user:
+
+1. From the database's **Security** tab, select **Edit**.
+
+1. In the **Access Control** section, select **Using ACL only** as the **Access method**.
+
+    {{<image filename="images/rs/screenshots/databases/security-access-control-acl-only.png" alt="Select Using ACL only to deactivate default user access to the database." >}}
+
+1. Choose at least one role and Redis ACL to access the database.
+
+1. Select **Save**.
+---
+Title: Update database ACLs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to use the Cluster Manager UI to update database access
+  control lists (ACLs) to authorize access to roles authorizing LDAP user access.
+weight: 45
+---
+
+To grant LDAP users access to a database, assign the mapped access role to the access control list (ACL) for the database.
+
+1.  In the Cluster Manager UI, go to **Databases**, then select the database from the list.
+
+1.  From the **Security** tab, select the **Edit** button.
+
+1.  In the **Access Control List** section, select **+ Add ACL**.
+
+    {{<image filename="images/rs/screenshots/databases/security-access-control-acl-only.png" alt="Updating a database access control list (ACL)" >}}
+
+1.  Select the appropriate roles and then save your changes.
+
+If you assign multiple roles to an ACL and a user is authorized by more than one of these roles, their access is determined by the first “matching” rule in the list.  
+
+If the first rule gives them read access and the third rule authorizes write access, the user will only be able to read data.  
+
+As a result, we recommend ordering roles so that higher access roles appear before roles with more limited access. 
+
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles.md" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/security/" >}})
+---
+Title: Enable role-based LDAP
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to enable role-based LDAP authentication and authorization
+  using the Cluster Manager UI.
+weight: 25
+---
+
+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.
+
+## Set up LDAP connection
+
+To configure and enable LDAP from the Cluster Manager UI:
+
+1. Go to **Access Control > LDAP > Configuration**.
+
+1. Select **+ Create**.
+
+1. In **Set LDAP**, configure [LDAP server settings](#ldap-server-settings), [bind credentials](#bind-credentials), [authentication query](#authentication-query), and [authorization query](#authorization-query).
+
+   {{<image filename="images/rs/screenshots/access-control/ldap-config.png" alt="The LDAP configuration screen in the Cluster Manager UI" >}}
+
+1. Select **Save & Enable**.
+
+### LDAP server settings
+
+The **LDAP server** settings define the communication settings used for LDAP authentication and authorization. These include:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Protocol type** | Underlying communication protocol; must be _LDAP_, _LDAPS_, or _STARTTLS_ |
+| **Host** | URL of the LDAP server |
+| **Port** | LDAP server port number |
+| **Trusted CA certificate** |  _(LDAPS or STARTTLS protocols only)_ Certificate for the trusted certificate authority (CA) |
+
+When defining multiple LDAP hosts, the organization tree structure must be identical for all hosts.
+
+### Bind credentials
+
+These settings define the credentials for the bind query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Distinguished Name** | Example: `cd=admin,dc=example,dc=org` |
+| **Password** | Example: `admin1` |
+| **Client certificate authentication** |_(LDAPS or STARTTLS protocols only)_ Place checkmark to enable | 
+| **Client public key** | _(LDAPS or STARTTLS protocols only)_ The client public key for authentication |
+| **Client private key** | _(LDAPS or STARTTLS protocols only)_ The client private key for authentication |
+
+### Authentication query
+
+These settings define the authentication query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Search user by** | Either _Template_ or _Query_ |
+| **Template** | _(template search)_ Example: `cn=%u,ou=dev,dc=example,dc=com` |
+| **Base** | _(query search)_ Example: `ou=dev,dc=example,dc=com` |
+| **Filter** | _(query search)_ Example: `(cn=%u)` |
+| **Scope**  | _(query search)_ Must be _baseObject_, _singleLevel_, or _wholeSubtree_ |
+
+In this example, `%u` is replaced by the username attempting to access the Redis Enterprise resource.
+
+### Authorization query
+
+These settings define the group authorization query:
+
+| _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Search groups by** | Either _Attribute_ or _Query_ |
+| **Attribute** | _(attribute search)_ Example: `memberOf` (case-sensitive) |
+| **Base** | _(query search)_ Example: `ou=groups,dc=example,dc=com` |
+| **Filter** | _(query search)_ Example: `(members=%D)` |
+| **Scope**  | _(query search)_ Must be _baseObject_, _singleLevel_, or _wholeSubtree_ |
+
+In this example, `%D` is replaced by the Distinguished Name of the user attempting to access the Redis Enterprise resource.
+
+### Authentication timeout
+
+The **Authentication timeout** setting determines the connection timeout to the LDAP server during user authentication.
+
+By default, the timeout is 5 seconds, which is recommended for most cases.
+ 
+However, if you enable multi-factor authentication (MFA) for your LDAP server, you might need to increase the timeout to provide enough time for MFA verification. You can set it to any integer in the range of 5-60 seconds.
+
+## More info
+
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Software [security and practices]({{< relref "/operate/rs/security/" >}})
+---
+Title: Map LDAP groups to roles
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to map LDAP authorization groups to Redis Enterprise roles
+  using the Cluster Manager UI.
+weight: 35
+---
+
+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:
+
+1. Select **Access Control > LDAP > Mapping**.
+
+    {{<note>}}
+You can map LDAP roles when LDAP configuration is not enabled, but they won't have any effect until you [configure and enable LDAP]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}}).
+    {{</note>}}
+
+    {{<image filename="images/rs/access-control-ldap-mappings-panel.png" alt="Enable LDAP mappings Panel" >}}
+
+1.  Select the **+ Add LDAP Mapping** button to create a new mapping and then enter the following details:
+
+    | _Setting_ | _Description_ | 
+|:----------|:--------------|
+| **Name** | A descriptive, unique name for the mapping |
+| **Distinguished Name** | The distinguished name of the LDAP group to be mapped.  <br/>Example: `cn=admins,ou=groups,dc=example,dc=com` |
+| **Role** | The Redis Software access control role defined for this group |
+| **Email** | _(Optional)_ An address to receive alerts|
+| **Alerts**  | Selections identifying the desired alerts. |
+
+    {{<image filename="images/rs/access-control-ldap-mappings-add.png" alt="Enable LDAP mappings Panel" >}}
+
+1.  When finished, select the **Save** button.
+
+Create a mapping for each LDAP group used to authenticate and/or authorize access to Redis Enterprise Software resources.
+
+The scope of the authorization depends on the access control role:
+
+- If the role authorizes admin management, LDAP users are authorized as cluster management administrators.
+
+- If the role authorizes database access, LDAP users are authorized to use the database to the limits specified in the role.
+
+- To authorize LDAP users to specific databases, update the database access control lists (ACLs) to include the mapped LDAP role.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/security/" >}})
+---
+Title: Migrate to role-based LDAP
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to migrate existing cluster-based LDAP deployments to role-based
+  LDAP.
+weight: 55
+---
+
+Redis Enterprise Software supports LDAP through a [role-based mechanism]({{< relref "/operate/rs/security/access-control/ldap/" >}}), first introduced [in v6.0.20]({{< relref "/operate/rs/release-notes/rs-6-0-20-april-2021" >}}).
+
+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:
+
+1.  Identify accounts per app on the customer end.
+
+1.  Create or identify an LDAP user account on the server that is responsible for LDAP authentication and authorization.
+
+1.  Create or identify an LDAP group that contains the app team members.
+
+1.  Verify or configure the Redis Enterprise ACLs.
+
+1.  Configure each database ACL.
+
+1.  Remove the earlier "external" (LDAP) users from Redis Enterprise.
+
+1.  _(Recommended)_ Update cluster configuration to replace the cluster-based configuration file.
+
+    You can use `rladmin` to update the cluster configuration:
+
+    ``` bash
+    $ touch /tmp/saslauthd_empty.conf
+    $ rladmin cluster config saslauthd_ldap_conf \
+         /tmp/saslauthd_empty.conf
+    ```
+
+    Here, a blank file replaces the earlier configuration.
+
+1.  Use **Access Control > LDAP > Configuration** to enable role-based LDAP.
+
+1.  Map your LDAP groups to access control roles.
+
+1.  Test application connectivity using the LDAP credentials of an app team member.
+
+1.  _(Recommended)_ Turn off default access for the database to avoid anonymous client connections.
+
+ Because deployments and requirements vary, you’ll likely need to adjust these guidelines.
+
+## Test LDAP access
+
+To test your LDAP integration, you can:
+
+- Connect with `redis-cli` and use the [`AUTH` command]({{< relref "/commands/auth" >}}) to test LDAP username/password credentials.
+
+- Sign in to the Cluster Manager UI using LDAP credentials authorized for admin access.
+
+- Use [Redis Insight]({{< relref "/develop/tools/insight" >}}) to access a database using authorized LDAP credentials.
+
+- Use the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) to connect using authorized LDAP credentials.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/security/" >}})
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how Redis Enterprise Software integrates LDAP authentication
+  and authorization. Also describes how to enable LDAP for your deployment of Redis
+  Enterprise Software.
+hideListLinks: true
+linkTitle: LDAP authentication
+title: LDAP authentication
+weight: 50
+---
+
+Redis Enterprise Software supports [Lightweight Directory Access Protocol](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol) (LDAP) authentication and authorization through its [role-based access controls]({{< relref "/operate/rs/security/access-control" >}}) (RBAC).  You can use LDAP to authorize access to the Cluster Manager UI and to control database access.
+
+You can configure LDAP roles using the Redis Enterprise Cluster Manager UI or [REST API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}).
+
+## How it works
+
+Here's how role-based LDAP integration works:
+
+{{<image filename="images/rs/access-control-ldap-diagram.png" alt="LDAP overview" >}}
+
+1.  A user signs in with their LDAP credentials.  
+
+    Based on the LDAP configuration details, the username is mapped to an LDAP Distinguished Name.
+
+1.  A simple [LDAP bind request](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol#Bind_(authenticate)) is attempted using the Distinguished Name and the password.  The sign-in fails if the bind fails.
+
+1.  Obtain the user’s LDAP group memberships.
+
+    Using configured LDAP details, obtain a list of the user’s group memberships.
+
+1.  Compare the user’s LDAP group memberships to those mapped to local roles.
+
+1.  Determine if one of the user's groups is authorized to access the target resource.  If so, the user is granted the level of access authorized to the role.  
+
+To access the Cluster Manager UI, the user needs to belong to an LDAP group mapped to an administrative role.  
+
+For database access, the user needs to belong to an LDAP group mapped to a role listed in the database’s access control list (ACL).  The rights granted to the group determine the user's level of access. 
+
+## Prerequisites 
+
+Before you enable LDAP in Redis Enterprise, you need:
+
+1. The following LDAP details:
+
+    - Server URI, including host, port, and protocol details.  
+    - Certificate details for secure protocols.  
+    - Bind credentials, including Distinguished Name, password, and (optionally) client public and private keys for certificate authentication.  
+    - Authentication query details, whether template or query.  
+    - Authorization query details, whether attribute or query.  
+    - The Distinguished Names of LDAP groups you’ll use to authorize access to Redis Enterprise resources. 
+
+1. The LDAP groups that correspond to the levels of access you wish to authorize.  Each LDAP group will be mapped to a Redis Enterprise access control role.
+
+1. A Redis Enterprise access control role for each LDAP group. Before you enable LDAP, you need to set up [role-based access controls]({{< relref "/operate/rs/security/access-control" >}}) (RBAC).
+
+## Enable LDAP
+
+To enable LDAP:
+
+1.  From **Access Control > LDAP** in the Cluster Manager UI, select the **Configuration** tab and [enable LDAP access]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}}).
+
+    {{<image filename="images/rs/access-control-ldap-panel.png" alt="Enable LDAP Panel" >}}
+
+2.  Map LDAP groups to [access control roles]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles" >}}).
+
+3.  Update database access control lists (ACLs) to [authorize role access]({{< relref "/operate/rs/security/access-control/ldap/update-database-acls" >}}).  
+
+If you already have appropriate roles, you can update them to include LDAP groups.
+
+## More info
+
+- Enable and configure [role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}})
+- Map LDAP groups to [access control roles]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles" >}})
+- Update database ACLs to [authorize LDAP access]({{< relref "/operate/rs/security/access-control/ldap/update-database-acls" >}})
+- Learn more about Redis Enterprise Software [security and practices]({{< relref "/operate/rs/security/" >}})
+
+---
+Title: Create users
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create users and assign access control roles.
+linkTitle: Create users
+weight: 10
+---
+
+## Prerequisites
+
+Before you create other users:
+
+1. Review the [access control overview]({{<relref "/operate/rs/security/access-control">}}) to learn how to use role-based access control (RBAC) to manage users' cluster access and database access.
+
+1. Create roles you can assign to users. See [Create roles with cluster access only]({{<relref "/operate/rs/security/access-control/create-cluster-roles">}}), [Create roles with database access only]({{<relref "/operate/rs/security/access-control/create-db-roles">}}), or [Create roles with combined access]({{<relref "/operate/rs/security/access-control/create-combined-roles">}}) for instructions.
+
+## Add users
+
+To add a user to the cluster:
+
+1. From the **Access Control > Users** tab in the Cluster Manager UI, select **+ Add user**.
+
+    {{<image filename="images/rs/access-control-user-panel.png" alt="Add role with name" >}}
+
+1. Enter the name, email, and password of the new user.
+
+    {{<image filename="images/rs/access-control-user-add.png" alt="Add role with name" >}}
+
+1. Assign a **Role** to the user to grant permissions for cluster management and data access.
+
+    {{<image filename="images/rs/access-control-user-role-select.png" width="300px" alt="Add role to user." >}}
+
+1. Select the **Alerts** the user should receive by email:
+
+    - **Receive alerts for databases** - The alerts that are enabled for the selected databases will be sent to the user. Choose **All databases** or **Customize** to select the individual databases to send alerts for.
+    
+    - **Receive cluster alerts** - The alerts that are enabled for the cluster in **Cluster > Alerts Settings** are sent to the user.
+
+1. Select **Save**.
+
+## Assign roles to users
+
+Assign a role, associated with specific databases and access control lists (ACLs), to a user to grant database access:
+
+1. From the **Access Control > Users** tab in the Cluster Manager UI, you can:
+
+    - Point to an existing user and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit the user.
+    
+    - Select **+ Add user** to [create a new user]({{< relref "/operate/rs/security/access-control/create-users" >}}).
+
+1. Select a role to assign to the user.
+
+    {{<image filename="images/rs/access-control-user-role-select.png" width="300px" alt="Add role to user." >}}
+
+1. Select **Save**.
+
+## Next steps
+
+Depending on the type of the user's assigned role (cluster management role or data access role), the user can now:
+
+- [Connect to a database]({{< relref "/operate/rs/databases/connect" >}}) associated with the role and run limited Redis commands, depending on the role's Redis ACLs.
+
+- Sign in to the Redis Enterprise Software Cluster Manager UI.
+
+- Make a [REST API]({{< relref "/operate/rs/references/rest-api" >}}) request.
+---
+Title: Create roles with cluster access only
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with cluster access only.
+linkTitle: Create roles with cluster access only
+weight: 14
+---
+
+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]({{<relref "/operate/rs/references/rest-api">}}).
+
+1. **DB Viewer** - Read database settings
+1. **DB Member** - Administer databases
+1. **Cluster Viewer** - Read cluster settings
+1. **Cluster Member** - Administer the cluster
+1. **User Manager** - Administer users
+1. **Admin** - Full cluster access
+1. **None** - For data access only - cannot access the Cluster Manager UI or use the REST API
+
+For more details about the privileges granted by each of these roles, see [Cluster Manager UI permissions](#cluster-manager-ui-permissions) or [REST API permissions]({{<relref "/operate/rs/references/rest-api/permissions">}}).
+
+## Cluster Manager UI permissions
+
+Here's a summary of the Cluster Manager UI actions permitted by each default management role:
+
+| Action | DB Viewer | DB Member | Cluster Viewer | Cluster Member | Admin | User Manager |
+|--------|:---------:|:---------:|:--------------:|:-----------:|:------:|:------:|
+| Create, edit, delete users and LDAP mappings | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| Create support package | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> |
+| Edit database configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> |
+| Reset slow log | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> |
+| View cluster configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View cluster logs | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span><br /> | <span title="Allowed">&#x2705; Yes</span><br /> |
+| View cluster metrics | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View database configuration | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View database metrics | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View node configuration | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View node metrics | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View Redis database password | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> |
+| View slow log | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> |
+| View and edit cluster settings | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Not allowed">&#x274c; No</span> | <span title="Allowed">&#x2705; Yes</span> | <span title="Not allowed">&#x274c; No</span> |
+
+## Create roles for cluster access {#create-cluster-role}
+
+You can use the [Cluster Manager UI](#create-roles-ui) or the [REST API](#define-roles-rest-api) to create a role that grants cluster access but does not grant access to any databases.
+
+### Cluster Manager UI method {#create-roles-ui}
+
+To create a role that grants cluster access:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name" >}}
+
+1. Enter a descriptive name for the role.
+
+1. Choose a **Cluster management role** to determine cluster management permissions.
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-create-role-cluster-only.png" alt="Select a cluster management role to set the level of cluster management permissions for the new role." >}}
+    
+1. To prevent database access when using this role, do not add any ACLs.
+
+1. Select **Save**.
+
+You can [assign the new role to users]({{<relref "/operate/rs/security/access-control/create-users#assign-roles-to-users">}}) to grant cluster access.
+
+### REST API method {#define-roles-rest-api}
+
+To [create a role]({{<relref "/operate/rs/references/rest-api/requests/roles#post-role">}}) that grants cluster access:
+
+```sh
+POST /v1/roles
+{ 
+  "name": "<role-name>",
+  "management": "db_viewer | db_member | cluster_viewer | cluster_member | user_manager | admin" 
+}
+```
+---
+Title: Create roles with combined access
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with both cluster and database access.
+linkTitle: Create roles with combined access
+weight: 16
+---
+
+To create a role that grants database access privileges and allows access to the Cluster Management UI and REST API:
+
+1. [Define Redis ACLs](#define-redis-acls) that determine database access privileges.
+
+1. [Create a role with ACLs](#create-role) added and choose a **Cluster management role** other than **None**.
+
+## Define Redis ACLs
+
+You can use the [Cluster Manager UI](#define-acls-ui) or the [REST API](#define-acls-rest-api) to define Redis ACL rules that you can assign to roles.
+
+### Cluster Manager UI method {#define-acls-ui}
+
+To define a Redis ACL rule using the Cluster Manager UI:
+
+1. From **Access Control > Redis ACLs**, you can either:
+
+    - Point to a Redis ACL and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing Redis ACL.
+
+    - Select **+ Add Redis ACL** to create a new Redis ACL.
+
+1. Enter a descriptive name for the Redis ACL. This will be used to associate the ACL rule with the role.
+
+1. Define the ACL rule. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}).
+
+    {{<note>}}
+The **ACL builder** does not support selectors and key permissions. Use **Free text command** to manually define them instead.
+    {{</note>}}
+
+1. Select **Save**.
+
+{{<note>}}
+For multi-key commands on multi-slot keys, the return value is `failure`, but the command runs on the keys that are allowed.
+{{</note>}}
+
+### REST API method {#define-acls-rest-api}
+
+To define a Redis ACL rule using the REST API, use a [create Redis ACL]({{<relref "/operate/rs/references/rest-api/requests/redis_acls#post-redis_acl">}}) request. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}).
+
+Example request:
+
+```sh
+POST /v1/redis_acls
+{ 
+  "name": "Test_ACL_1",
+  "acl": "+@read +FT.INFO +FT.SEARCH"
+}
+```
+
+Example response body:
+
+```json
+{ 
+  "acl": "+@read +FT.INFO +FT.SEARCH",
+  "name": "Test_ACL_1",
+  "uid": 11
+}
+```
+
+To associate the Redis ACL with a role and database, use the `uid` from the response as the `redis_acl_uid` when you add `roles_permissions` to the database. See [Associate a database with roles and Redis ACLs](#associate-roles-acls-rest-api) for an example request.
+
+## Create roles with ACLs and cluster access {#create-role}
+
+You can create a role that grants database access privileges and allows access to the Cluster Management UI and REST API.
+
+### Cluster Manager UI method {#create-roles-ui}
+
+To define a role for combined access using the Cluster Manager UI:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name">}}
+
+1. Enter a descriptive name for the role. This will be used to reference the role when configuring users.
+
+1. Choose a **Cluster management role** other than **None**. For details about permissions granted by each role, see [Cluster Manager UI permissions]({{<relref "/operate/rs/security/access-control/create-cluster-roles#cluster-manager-ui-permissions">}}) and [REST API permissions]({{<relref "/operate/rs/references/rest-api/permissions">}}).
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-create-combined-role-select-cm-role.png" alt="Add role with name">}}
+    
+1. Select **+ Add ACL**.
+
+    {{<image filename="images/rs/access-control-role-acl.png" alt="Add role database acl">}}
+
+1.  Choose a Redis ACL and databases to associate with the role.
+
+    {{<image filename="images/rs/screenshots/access-control/access-control-role-databases.png" alt="Add databases to access">}}
+
+1. Select the check mark {{< image filename="/images/rs/buttons/checkmark-button.png#no-click" alt="The Check button" width="25px" class="inline" >}} to confirm.
+
+1. Select **Save**.
+
+    {{<image filename="images/rs/screenshots/access-control/rbac-save-combined-role.png" alt="Add databases to access">}}
+
+You can [assign the new role to users]({{<relref "/operate/rs/security/access-control/create-users#assign-roles-to-users">}}) to grant database access and access to the Cluster Manager UI and REST API.
+
+### REST API method {#define-roles-rest-api}
+
+To define a role for combined access using the REST API:
+
+1. [Create a role.](#create-role-rest-api)
+
+1. [Associate a database with roles and Redis ACLs.](#associate-roles-acls-rest-api)
+
+#### Create a role {#create-role-rest-api}
+
+To [create a role]({{<relref "/operate/rs/references/rest-api/requests/roles#post-role">}}) using the REST API:
+
+```sh
+POST /v1/roles
+{ 
+  "name": "<role-name>",
+  "management": "db_viewer | db_member | cluster_viewer | cluster_member | admin" 
+}
+```
+
+Example response body:
+
+```json
+{ 
+  "management": "admin",
+  "name": "<role-name>",
+  "uid": 7
+}
+```
+
+To associate the role with a Redis ACL and database, use the `uid` from the response as the `role_uid` when you add `roles_permissions` to the database. See [Associate a database with roles and Redis ACLs](#associate-roles-acls-rest-api) for an example request.
+
+
+#### Associate a database with roles and Redis ACLs {#associate-roles-acls-rest-api}
+
+[Update a database's configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) to add `roles_permissions` with the role and Redis ACL:
+
+```sh
+POST /v1/bdbs/<database-id>
+{
+  "roles_permissions":
+  [
+    {
+      "role_uid": <integer>,
+      "redis_acl_uid": <integer>
+    }
+  ]
+}
+```
+---
+Title: Overview of Redis ACLs in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of Redis ACLs, syntax, and ACL command support in Redis Enterprise Software.
+linkTitle: Redis ACL overview
+weight: 17
+---
+
+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.
+
+## Redis ACL syntax
+
+Redis ACLs are defined by a [Redis syntax]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) where you specify the commands or command categories that are allowed for specific keys.
+
+### Commands and categories
+
+Redis ACL rules can allow or block specific [Redis commands]({{< relref "/commands" >}}) or [command categories]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories).
+
+- `+` includes commands
+
+- `-` excludes commands
+
+- `+@` includes command categories
+
+- `-@` excludes command categories
+
+The following example allows all `read` commands and the `SET` command:
+
+```sh
++@read +SET
+```
+
+Module commands have several ACL limitations:
+
+- [Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) do not have command categories.
+
+- Other [command category]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories) ACLs, such as `+@read` and `+@write`, do not include Redis module commands. `+@all` is the only exception because it allows all Redis commands.
+
+- You have to include individual module commands in a Redis ACL rule to allow them.
+
+    For example, the following Redis ACL rule allows read-only commands and the RediSearch commands `FT.INFO` and `FT.SEARCH`:
+
+    ```sh
+    +@read +FT.INFO +FT.SEARCH
+    ```
+
+### Key patterns
+
+To define access to specific keys or key patterns, use the following prefixes:
+
+- `~` or `%RW~` allows read and write access to keys.
+
+- `%R~` allows read access to keys.
+
+- `%W~` allows write access to keys.
+
+`%RW~`, `%R~`, and `%W~` are only supported for databases with Redis version 7.2 or later.
+
+The following example allows read and write access to all keys that start with "app1" and read-only access to all keys that start with "app2":
+
+```sh
+~app1* %R~app2*
+```
+
+### Pub/sub channels
+
+The `&` prefix allows access to [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) (only supported for databases with Redis version 6.2 or later).
+
+To limit access to specific channels, include `resetchannels` before the allowed channels:
+
+```sh
+resetchannels &channel1 &channel2
+```
+
+### Selectors
+
+[Selectors]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors) let you define multiple sets of rules in a single Redis ACL (only supported for databases with Redis version 7.2 or later). A command is allowed if it matches the base rule or any selector in the Redis ACL.
+
+- `(<rule set>)` creates a new selector.
+
+- `clearselectors` deletes all existing selectors for a user. This action does not delete the base ACL rule.
+
+In the following example, the base rule allows `GET key1` and the selector allows `SET key2`:
+
+```sh
++GET ~key1 (+SET ~key2)
+```
+
+## Default pub/sub permissions
+
+Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access.
+
+The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default:
+
+- For versions 6.4.2 and 7.2, `acl-pubsub-default` is permissive (`allchannels` or `&*`) by default to accommodate earlier Redis versions.
+
+- In future versions, `acl-pubsub-default` will change to restrictive (`resetchannels`). Restrictive permissions block all pub/sub channels by default, unless explicitly permitted by an ACL rule.
+
+If you use ACLs and pub/sub channels, you should review your databases and ACL settings and plan to transition your cluster to restrictive pub/sub permissions in preparation for future Redis Enterprise Software releases.
+
+### Prepare for restrictive pub/sub permissions
+
+To secure pub/sub channels and prepare your cluster for future Redis Enterprise Software releases that default to restrictive pub/sub permissions:
+
+1. Upgrade Redis databases:
+
+    - For Redis Enterprise Software version 6.4.2, upgrade all databases in the cluster to Redis DB version 6.2.
+    
+    - For Redis Enterprise Software version 7.2, upgrade all databases in the cluster to Redis DB version 7.2 or 6.2.
+
+1. Create or update ACLs with permissions for specific channels using the `resetchannels &channel` format.
+
+1. Associate the ACLs with relevant databases.
+
+1. Set default pub/sub permissions (`acl-pubsub-default`) to restrictive. See [Change default pub/sub permissions](#change-default-pubsub-permissions) for details.
+
+1. If any issues occur, you can temporarily change the default pub/sub setting back to permissive. Resolve any problematic ACLs before making pub/sub permissions restrictive again.
+
+{{<note>}}
+When you change the cluster's default pub/sub permissions to restrictive, `&*` is added to the **Full Access** ACL. Before you make this change, consider the following:
+
+- Because pub/sub ACL syntax was added in Redis 6.2, you can't associate the **Full Access** ACL with database versions 6.0 or lower after this change.
+
+- The **Full Access** ACL is not reverted if you change `acl-pubsub-default` to permissive again.
+
+- Every database with the default user enabled uses the **Full Access** ACL.
+{{</note>}}
+
+### Change default pub/sub permissions
+
+As of Redis Enterprise version 6.4.2, you can configure `acl_pubsub_default`, which determines the default pub/sub permissions for all databases in the cluster. You can set `acl_pubsub_default` to the following values:
+
+- `resetchannels` is restrictive and blocks access to all channels by default.
+
+- `allchannels` is permissive and allows access to all channels by default. 
+
+To make default pub/sub permissions restrictive:
+
+1. [Upgrade all databases]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-database" >}}) in the cluster to Redis version 6.2 or later.
+
+1. Set the default to restrictive (`resetchannels`) using one of the following methods:
+
+    - New Cluster Manager UI (only available for Redis Enterprise versions 7.2 and later):
+    
+        1. Navigate to **Access Control > Settings > Pub/Sub ACLs** and select **Edit**.
+        
+        1. For **Default permissions for Pub/Sub ACLs**, select **Restrictive**, then **Save**.
+
+    - [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}):
+
+        ```sh
+        rladmin tune cluster acl_pubsub_default resetchannels
+        ```
+
+    - [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+        ```sh
+        PUT /v1/cluster/policy
+        { "acl_pubsub_default": "resetchannels" }
+        ```
+
+## ACL command support
+
+Redis Enterprise Software does not support certain Redis ACL commands. Instead, you can manage access controls from the Cluster Manager UI.
+
+{{<embed-md "acl-command-compatibility.md">}}
+
+Redis ACLs also have the following differences in Redis Enterprise Software:
+
+- The `MULTI`, `EXEC`, `DISCARD` commands are always allowed, but ACLs are enforced on `MULTI` subcommands.
+
+- Nested selectors are not supported.
+
+    For example, the following selectors are not valid in Redis Enterprise: <nobr>`+GET ~key1 (+SET (+SET ~key2) ~key3)`</nobr>
+
+- Key and pub/sub patterns do not allow the following characters: `'(', ')'`
+
+- The following password configuration syntax is not supported: `'>', '<', '#!', 'resetpass'`
+
+    To configure passwords in Redis Enterprise Software, use one of the following methods:
+
+    - [`rladmin cluster reset_password`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/reset_password" >}}):
+    
+        ```sh
+        rladmin cluster reset_password <user email>
+        ```
+
+    - REST API [`PUT /v1/users`]({{< relref "/operate/rs/references/rest-api/requests/users#put-user" >}}) request and provide `password`
+
+---
+Title: Create roles with database access only 
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create roles with database access only.
+linkTitle: Create roles with database access only 
+weight: 15
+---
+
+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]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}) 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:
+
+1. [Define Redis ACLs](#define-redis-acls) that determine database access privileges.
+
+1. [Create a role with ACLs](#create-roles-with-acls) added and leave the **Cluster management role** as **None**.
+
+## Define Redis ACLs
+
+You can use the [Cluster Manager UI](#define-acls-ui) or the [REST API](#define-acls-rest-api) to define Redis ACL rules that you can assign to roles.
+
+### Cluster Manager UI method {#define-acls-ui}
+
+To define a Redis ACL rule using the Cluster Manager UI:
+
+1. From **Access Control > Redis ACLs**, you can either:
+
+    - Point to a Redis ACL and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing Redis ACL.
+
+    - Select **+ Add Redis ACL** to create a new Redis ACL.
+
+1. Enter a descriptive name for the Redis ACL. This will be used to associate the ACL rule with the role.
+
+1. Define the ACL rule. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}).
+
+    {{<note>}}
+The **ACL builder** does not support selectors and key permissions. Use **Free text command** to manually define them instead.
+    {{</note>}}
+
+1. Select **Save**.
+
+{{<note>}}
+For multi-key commands on multi-slot keys, the return value is `failure`, but the command runs on the keys that are allowed.
+{{</note>}}
+
+### REST API method {#define-acls-rest-api}
+
+To define a Redis ACL rule using the REST API, use a [create Redis ACL]({{<relref "/operate/rs/references/rest-api/requests/redis_acls#post-redis_acl">}}) request. For more information about Redis ACL rules and syntax, see the [Redis ACL overview]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}).
+
+Example request:
+
+```sh
+POST /v1/redis_acls
+{ 
+  "name": "Test_ACL_1",
+  "acl": "+@read +FT.INFO +FT.SEARCH"
+}
+```
+
+Example response body:
+
+```json
+{ 
+  "acl": "+@read +FT.INFO +FT.SEARCH",
+  "name": "Test_ACL_1",
+  "uid": 11
+}
+```
+
+To associate the Redis ACL with a role and database, use the `uid` from the response as the `redis_acl_uid` when you add `roles_permissions` to the database. See [Associate a database with roles and Redis ACLs](#associate-roles-acls-rest-api) for an example request.
+
+## Create roles with ACLs
+
+To create a role that grants database access to users but blocks access to the Redis Enterprise Cluster Manager UI and REST API, set the **Cluster management role** to **None**.
+
+### Cluster Manager UI method {#create-roles-ui}
+
+To define a role for database access using the Cluster Manager UI:
+
+1. From **Access Control** > **Roles**, you can:
+
+    - Point to a role and select {{< image filename="/images/rs/buttons/edit-button.png#no-click" alt="The Edit button" width="25px" class="inline" >}} to edit an existing role.
+
+    - Select **+ Add role** to create a new role.
+
+    {{<image filename="images/rs/access-control-role-panel.png" alt="Add role with name" >}}
+
+1. Enter a descriptive name for the role. This will be used to reference the role when configuring users.
+
+1. Leave **Cluster management role** as the default **None**.
+
+    {{<image filename="images/rs/access-control-role-name.png" alt="Add role with name" >}}
+    
+1. Select **+ Add ACL**.
+
+    {{<image filename="images/rs/access-control-role-acl.png" alt="Add role database acl" >}}
+
+1.  Choose a Redis ACL and databases to associate with the role.
+
+    {{<image filename="images/rs/screenshots/access-control/access-control-role-databases.png" alt="Add databases to access" >}}
+
+1. Select the check mark {{< image filename="/images/rs/buttons/checkmark-button.png#no-click" alt="The Check button" width="25px" class="inline" >}} to confirm.
+
+1. Select **Save**.
+
+    {{<image filename="images/rs/access-control-role-save.png" alt="Add databases to access" >}}
+
+You can [assign the new role to users]({{<relref "/operate/rs/security/access-control/create-users#assign-roles-to-users">}}) to grant database access.
+
+### REST API method {#define-roles-rest-api}
+
+To define a role for database access using the REST API:
+
+1. [Create a role.](#create-role-rest-api)
+
+1. [Associate a database with roles and Redis ACLs.](#associate-roles-acls-rest-api)
+
+#### Create a role {#create-role-rest-api}
+
+To [create a role]({{<relref "/operate/rs/references/rest-api/requests/roles#post-role">}}) using the REST API:
+
+```sh
+POST /v1/roles
+{ 
+  "name": "<role-name>",
+  "management": "none" 
+}
+```
+
+Example response body:
+
+```json
+{ 
+  "management": "none",
+  "name": "<role-name>",
+  "uid": 7
+}
+```
+
+To associate the role with a Redis ACL and database, use the `uid` from the response as the `role_uid` when you add `roles_permissions` to the database. See [Associate a database with roles and Redis ACLs](#associate-roles-acls-rest-api) for an example request.
+
+
+#### Associate a database with roles and Redis ACLs {#associate-roles-acls-rest-api}
+
+[Update a database's configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) to add `roles_permissions` with the role and Redis ACL:
+
+```sh
+POST /v1/bdbs/<database-id>
+{
+  "roles_permissions":
+  [
+    {
+      "role_uid": <integer>,
+      "redis_acl_uid": <integer>
+    }
+  ]
+}
+```
+---
+Title: Access control
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An overview of access control in Redis Enterprise Software.
+hideListLinks: false
+linkTitle: Access control
+weight: 10
+---
+
+Redis Enterprise Software lets you use role-based access control (RBAC) to manage users' access privileges. RBAC requires you to do the following:
+
+1. Create roles and define each role's access privileges.
+
+1. Create users and assign roles to them. The assigned role determines the user's access privileges.
+
+## Cluster access versus database access
+
+Redis Enterprise allows two separate paths of access:
+
+- **Cluster access** allows performing management-related actions, such as creating databases and viewing statistics.
+
+- **Database access** allows performing data-related actions, like reading and writing data in a database.
+
+You can grant cluster access, database access, or both to each role. These roles let you differentiate between users who can access databases and users who can access cluster management, according to your organization's security needs.
+
+The following diagram shows three different options for roles and users:
+
+{{<image filename="images/rs/rbac-diagram.png" alt="Role-based access control diagram.">}}
+
+- Role A was created with permission to access the cluster and perform management-related actions. Because user A was assigned role A, they can access the cluster but cannot access databases.
+
+- Role B was created with permission to access one or more databases and perform data-related actions. Because user B was assigned role B, they cannot access the cluster but can access databases.
+
+- Role C was created with cluster access and database access permissions. Because user C was assigned role C, they can access the cluster and databases.
+
+## Default database access
+
+When you create a database, [default user access]({{< relref "/operate/rs/security/access-control/manage-users/default-user" >}}) is enabled automatically.
+
+If you set up role-based access controls for your database and don't require compatibility with versions earlier than Redis 6, you can [deactivate the default user]({{< relref "/operate/rs/security/access-control/manage-users/default-user" >}}).
+
+{{<warning>}}
+Before you [deactivate default user access]({{< relref "/operate/rs/security/access-control/manage-users/default-user#deactivate-default-user" >}}), make sure the role associated with the database is [assigned to a user]({{< relref "/operate/rs/security/access-control/create-users#assign-roles-to-users" >}}). Otherwise, the database will be inaccessible.
+{{</warning>}}
+
+## More info
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: true
+weight: 60
+---
+
+Redis Enterprise Software provides various features to secure your Redis Enterprise Software deployment:
+
+| Login and passwords | Users and roles | Encryption and TLS | Certificates and audit |
+|---------------------|-----------------|--------------------|-----------------------|
+| [Password attempts and session timeout]({{<relref "/operate/rs/security/access-control/manage-users/login-lockout">}}) | [Cluster and database access explained]({{<relref "/operate/rs/security/access-control">}}) | [Enable TLS]({{<relref "/operate/rs/security/encryption/tls/enable-tls">}}) | [Create certificates]({{<relref "/operate/rs/security/certificates/create-certificates">}}) |
+| [Password complexity]({{<relref "/operate/rs/security/access-control/manage-passwords/password-complexity-rules">}}) | [Create users]({{<relref "/operate/rs/security/access-control/create-users">}}) | [Configure TLS protocols]({{<relref "/operate/rs/security/encryption/tls/tls-protocols">}}) | [Monitor certificates]({{<relref "/operate/rs/security/certificates/monitor-certificates">}}) |
+| [Password expiration]({{<relref "/operate/rs/security/access-control/manage-passwords/password-expiration">}}) | [Create roles]({{<relref "/operate/rs/security/access-control/create-combined-roles">}}) | [Configure cipher suites]({{<relref "/operate/rs/security/encryption/tls/ciphers">}}) | [Update certificates]({{<relref "/operate/rs/security/certificates/updating-certificates">}}) |
+| [Default database access]({{<relref "/operate/rs/security/access-control/manage-users/default-user">}}) | [Redis ACLs]({{<relref "/operate/rs/security/access-control/redis-acl-overview">}}) | [Encrypt private keys on disk]({{<relref "/operate/rs/security/encryption/pem-encryption">}}) | [Enable OCSP stapling]({{<relref "/operate/rs/security/certificates/ocsp-stapling">}}) |
+| [Rotate user passwords]({{<relref "/operate/rs/security/access-control/manage-passwords/rotate-passwords">}}) | [Integrate with LDAP]({{<relref "/operate/rs/security/access-control/ldap">}}) | [Internode encryption]({{<relref "/operate/rs/security/encryption/internode-encryption">}}) | [Audit database connections]({{<relref "/operate/rs/security/audit-events">}}) |
+
+## Recommended security practices
+
+See [Recommended security practices]({{<relref "/operate/rs/security/recommended-security-practices">}}) to learn how to protect Redis Enterprise Software.
+
+## Redis Trust Center
+
+Visit our [Trust Center](https://trust.redis.io/) to learn more about Redis security policies. If you find a suspected security bug, you can [submit a report](https://hackerone.com/redis-vdp?type=team).
+---
+Title: Compatibility with Redis Open Source configuration settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Open Source configuration settings supported by Redis Enterprise.
+linkTitle: Configuration settings
+weight: 50
+---
+
+Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}) only support a subset of [Redis Open Source configuration settings]({{<relref "/operate/oss_and_stack/management/config">}}). Using [`CONFIG GET`]({{< relref "/commands/config-get" >}}) or [`CONFIG SET`]({{< relref "/commands/config-set" >}}) with unsupported configuration settings returns an error.
+
+| Setting | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| activerehashing | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| busy-reply-threshold | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Value must be between 0 and 60000 milliseconds. |
+| hash-max-listpack-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-listpack-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-ziplist-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hash-max-ziplist-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| hll-sparse-max-bytes | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-compress-depth | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-max-listpack-size | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| list-max-ziplist-size | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| lua-time-limit | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Value must be between 0 and 60000 milliseconds. |
+| notify-keyspace-events | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| set-max-intset-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| slowlog-log-slower-than | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Value must be larger than 1000 microseconds. |
+| slowlog-max-len | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Value must be between 128 and 1024. |
+| stream-node-max-bytes | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| stream-node-max-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| tracking-table-max-keys | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | For Redis Software, use an [update database configuration]({{<relref "operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) REST API request or [`rladmin tune db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db">}}) to set `tracking_table_max_keys` instead. |
+| zset-max-listpack-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-listpack-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-ziplist-entries | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| zset-max-ziplist-value | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Connection management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Connection management commands compatibility.
+linkTitle: Connection management
+weight: 10
+---
+
+The following tables show which Redis Open Source [connection management commands]({{< relref "/commands" >}}?group=connection) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [AUTH]({{< relref "/commands/auth" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT CACHING]({{< relref "/commands/client-caching" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT GETNAME]({{< relref "/commands/client-getname" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT GETREDIR]({{< relref "/commands/client-getredir" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT ID]({{< relref "/commands/client-id" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Because Redis Enterprise clustering allows [multiple active proxies]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}), `CLIENT ID` cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies. |
+| [CLIENT INFO]({{< relref "/commands/client-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT KILL]({{< relref "/commands/client-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT LIST]({{< relref "/commands/client-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT NO-EVICT]({{< relref "/commands/client-no-evict" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT <nobr>NO-TOUCH</nobr>]({{< relref "/commands/client-no-touch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT PAUSE]({{< relref "/commands/client-pause" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT REPLY]({{< relref "/commands/client-reply" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLIENT SETINFO]({{< relref "/commands/client-setinfo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT SETNAME]({{< relref "/commands/client-setname" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT TRACKING]({{< relref "/commands/client-tracking" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT TRACKINGINFO]({{< relref "/commands/client-trackinginfo" >}}) |<span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT UNBLOCK]({{< relref "/commands/client-unblock" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CLIENT UNPAUSE]({{< relref "/commands/client-unpause" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ECHO]({{< relref "/commands/echo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HELLO]({{< relref "/commands/hello" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PING]({{< relref "/commands/ping" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [QUIT]({{< relref "/commands/quit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v7.2.0. |
+| [RESET]({{< relref "/commands/reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SELECT]({{< relref "/commands/select" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | 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. |
+---
+Title: Cluster management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Cluster management commands compatible with Redis Enterprise.
+linkTitle: Cluster management
+weight: 10
+---
+
+[Clustering in Redis Enterprise Software]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}) and [Redis Cloud]({{< relref "/operate/rc/databases/configuration/clustering" >}}) differs from the [Redis Open Source cluster]({{<relref "/operate/oss_and_stack/management/scaling">}}) and works with all standard Redis clients.
+
+Redis Enterprise blocks most [cluster commands]({{< relref "/commands" >}}?group=cluster). If you try to use a blocked cluster command, it returns an error.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [ASKING]({{< relref "/commands/asking" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER ADDSLOTS]({{< relref "/commands/cluster-addslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER ADDSLOTSRANGE]({{< relref "/commands/cluster-addslotsrange" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER BUMPEPOCH]({{< relref "/commands/cluster-bumpepoch" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER COUNT-FAILURE-REPORTS]({{< relref "/commands/cluster-count-failure-reports" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER COUNTKEYSINSLOT]({{< relref "/commands/cluster-countkeysinslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER DELSLOTS]({{< relref "/commands/cluster-delslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER DELSLOTSRANGE]({{< relref "/commands/cluster-delslotsrange" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FAILOVER]({{< relref "/commands/cluster-failover" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FLUSHSLOTS]({{< relref "/commands/cluster-flushslots" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER FORGET]({{< relref "/commands/cluster-forget" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER GETKEYSINSLOT]({{< relref "/commands/cluster-getkeysinslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER HELP]({{< relref "/commands/cluster-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER INFO]({{< relref "/commands/cluster-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER KEYSLOT]({{< relref "/commands/cluster-keyslot" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER LINKS]({{< relref "/commands/cluster-links" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MEET]({{< relref "/commands/cluster-meet" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MYID]({{< relref "/commands/cluster-myid" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER MYSHARDID]({{< relref "/commands/cluster-myshardid" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER NODES]({{< relref "/commands/cluster-nodes" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). |
+| [CLUSTER REPLICAS]({{< relref "/commands/cluster-replicas" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER REPLICATE]({{< relref "/commands/cluster-replicate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER RESET]({{< relref "/commands/cluster-reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SAVECONFIG]({{< relref "/commands/cluster-saveconfig" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SET-CONFIG-EPOCH]({{< relref "/commands/cluster-set-config-epoch" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SETSLOT]({{< relref "/commands/cluster-setslot" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SHARDS]({{< relref "/commands/cluster-shards" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CLUSTER SLAVES]({{< relref "/commands/cluster-slaves" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v5.0.0. |
+| [CLUSTER SLOTS]({{< relref "/commands/cluster-slots" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Only supported with the [OSS cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). Deprecated as of Redis v7.0.0. |
+| [READONLY]({{< relref "/commands/readonly" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [READWRITE]({{< relref "/commands/readwrite" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+---
+Title: Data type commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Data type commands compatibility (bitmaps, geospatial indices, hashes,
+  HyperLogLogs, lists, sets, sorted sets, streams, strings).
+linkTitle: Data types
+toc: 'true'
+weight: 10
+---
+
+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
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BITCOUNT]({{< relref "/commands/bitcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITFIELD]({{< relref "/commands/bitfield" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITFIELD_RO]({{< relref "/commands/bitfield_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BITOP]({{< relref "/commands/bitop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span>  |  |
+| [BITPOS]({{< relref "/commands/bitpos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span>  |  |
+| [GETBIT]({{< relref "/commands/getbit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETBIT]({{< relref "/commands/setbit" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Geospatial indices commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [GEOADD]({{< relref "/commands/geoadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEODIST]({{< relref "/commands/geodist" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOHASH]({{< relref "/commands/geohash" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOPOS]({{< relref "/commands/geopos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEORADIUS]({{< relref "/commands/georadius" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUS_RO]({{< relref "/commands/georadius_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUSBYMEMBER]({{< relref "/commands/georadiusbymember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEORADIUSBYMEMBER_RO]({{< relref "/commands/georadiusbymember_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [GEOSEARCH]({{< relref "/commands/geosearch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GEOSEARCHSTORE]({{< relref "/commands/geosearchstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Hash commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [HDEL]({{< relref "/commands/hdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HEXISTS]({{< relref "/commands/hexists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HEXPIRE]({{< relref "/commands/hexpire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HEXPIREAT]({{< relref "/commands/hexpireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HEXPIRETIME]({{< relref "/commands/hexpiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HGET]({{< relref "/commands/hget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HGETALL]({{< relref "/commands/hgetall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HINCRBY]({{< relref "/commands/hincrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HINCRBYFLOAT]({{< relref "/commands/hincrbyfloat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HKEYS]({{< relref "/commands/hkeys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HLEN]({{< relref "/commands/hlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HMGET]({{< relref "/commands/hmget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HMSET]({{< relref "/commands/hmset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v4.0.0. |
+| [HPERSIST]({{< relref "/commands/hpersist" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HPEXPIRE]({{< relref "/commands/hpexpire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HPEXPIREAT]({{< relref "/commands/hpexpireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HPEXPIRETIME]({{< relref "/commands/hpexpiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HPTTL]({{< relref "/commands/hpttl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HRANDFIELD]({{< relref "/commands/hrandfield" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSCAN]({{< relref "/commands/hscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSET]({{< relref "/commands/hset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSETNX]({{< relref "/commands/hsetnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HSTRLEN]({{< relref "/commands/hstrlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HTTL]({{< relref "/commands/httl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [HVALS]({{< relref "/commands/hvals" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## HyperLogLog commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [PFADD]({{< relref "/commands/pfadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFCOUNT]({{< relref "/commands/pfcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFDEBUG]({{< relref "/commands/pfdebug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [PFMERGE]({{< relref "/commands/pfmerge" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PFSELFTEST]({{< relref "/commands/pfselftest" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## List commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BLMOVE]({{< relref "/commands/blmove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BLMPOP]({{< relref "/commands/blmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BLPOP]({{< relref "/commands/blpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BRPOP]({{< relref "/commands/brpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BRPOPLPUSH]({{< relref "/commands/brpoplpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [LINDEX]({{< relref "/commands/lindex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LINSERT]({{< relref "/commands/linsert" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LLEN]({{< relref "/commands/llen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LMOVE]({{< relref "/commands/lmove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LMPOP]({{< relref "/commands/lmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPOP]({{< relref "/commands/lpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPOS]({{< relref "/commands/lpos" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPUSH]({{< relref "/commands/lpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LPUSHX]({{< relref "/commands/lpushx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LRANGE]({{< relref "/commands/lrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LREM]({{< relref "/commands/lrem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LSET]({{< relref "/commands/lset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LTRIM]({{< relref "/commands/ltrim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPOP]({{< relref "/commands/rpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPOPLPUSH]({{< relref "/commands/rpoplpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [RPUSH]({{< relref "/commands/rpush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RPUSHX]({{< relref "/commands/rpushx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Set commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [SADD]({{< relref "/commands/sadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCARD]({{< relref "/commands/scard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SDIFF]({{< relref "/commands/sdiff" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SDIFFSTORE]({{< relref "/commands/sdiffstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTER]({{< relref "/commands/sinter" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTERCARD]({{< relref "/commands/sintercard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SINTERSTORE]({{< relref "/commands/sinterstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SISMEMBER]({{< relref "/commands/sismember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMEMBERS]({{< relref "/commands/smembers" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMISMEMBER]({{< relref "/commands/sismember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SMOVE]({{< relref "/commands/smove" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SPOP]({{< relref "/commands/spop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SRANDMEMBER]({{< relref "/commands/srandmember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SREM]({{< relref "/commands/srem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SSCAN]({{< relref "/commands/sscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNION]({{< relref "/commands/sunion" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNIONSTORE]({{< relref "/commands/sunionstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Sorted set commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BZMPOP]({{< relref "/commands/bzmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BZPOPMAX]({{< relref "/commands/bzpopmax" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [BZPOPMIN]({{< relref "/commands/bzpopmin" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZADD]({{< relref "/commands/zadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZCARD]({{< relref "/commands/zcard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZCOUNT]({{< relref "/commands/zcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZDIFF]({{< relref "/commands/zdiff" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZDIFFSTORE]({{< relref "/commands/zdiffstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINCRBY]({{< relref "/commands/zincrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTER]({{< relref "/commands/zinter" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTERCARD]({{< relref "/commands/zintercard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZINTERSTORE]({{< relref "/commands/zinterstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZLEXCOUNT]({{< relref "/commands/zlexcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZMPOP]({{< relref "/commands/zmpop" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZMSCORE]({{< relref "/commands/zmscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZPOPMAX]({{< relref "/commands/zpopmax" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZPOPMIN]({{< relref "/commands/zpopmin" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANDMEMBER]({{< relref "/commands/zrandmember" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANGE]({{< relref "/commands/zrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANGEBYLEX]({{< relref "/commands/zrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZRANGEBYSCORE]({{< relref "/commands/zrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZRANGESTORE]({{< relref "/commands/zrangestore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZRANK]({{< relref "/commands/zrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREM]({{< relref "/commands/zrem" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYLEX]({{< relref "/commands/zremrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYRANK]({{< relref "/commands/zremrangebyrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREMRANGEBYSCORE]({{< relref "/commands/zremrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZREVRANGE]({{< relref "/commands/zrevrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANGEBYLEX]({{< relref "/commands/zrevrangebylex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANGEBYSCORE]({{< relref "/commands/zrevrangebyscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [ZREVRANK]({{< relref "/commands/zrevrank" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZSCAN]({{< relref "/commands/zscan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZSCORE]({{< relref "/commands/zscore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZUNION]({{< relref "/commands/zunion" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [ZUNIONSTORE]({{< relref "/commands/zunionstore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Stream commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [XACK]({{< relref "/commands/xack" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XADD]({{< relref "/commands/xadd" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XAUTOCLAIM]({{< relref "/commands/xautoclaim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XCLAIM]({{< relref "/commands/xclaim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XDEL]({{< relref "/commands/xdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XGROUP]({{< relref "/commands/xgroup" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XINFO]({{< relref "/commands/xinfo" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XLEN]({{< relref "/commands/xlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XPENDING]({{< relref "/commands/xpending" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XRANGE]({{< relref "/commands/xrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREAD]({{< relref "/commands/xread" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREADGROUP]({{< relref "/commands/xreadgroup" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XREVRANGE]({{< relref "/commands/xrevrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XSETID]({{< relref "/commands/xsetid" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [XTRIM]({{< relref "/commands/xtrim" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## String commands
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [APPEND]({{< relref "/commands/append" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DECR]({{< relref "/commands/decr" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DECRBY]({{< relref "/commands/decrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GET]({{< relref "/commands/get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETDEL]({{< relref "/commands/getdel" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETEX]({{< relref "/commands/getex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | \*Not supported for HyperLogLog. |
+| [GETRANGE]({{< relref "/commands/getrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [GETSET]({{< relref "/commands/getset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Deprecated as of Redis v6.2.0. |
+| [INCR]({{< relref "/commands/incr" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INCRBY]({{< relref "/commands/incrby" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INCRBYFLOAT]({{< relref "/commands/incrbyfloat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LCS]({{< relref "/commands/lcs" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MGET]({{< relref "/commands/mget" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MSET]({{< relref "/commands/mset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MSETNX]({{< relref "/commands/msetnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PSETEX]({{< relref "/commands/psetex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SET]({{< relref "/commands/set" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETEX]({{< relref "/commands/setex" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETNX]({{< relref "/commands/setnx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SETRANGE]({{< relref "/commands/setrange" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| STRALGO | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v7.0.0. |
+| [STRLEN]({{< relref "/commands/strlen" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUBSTR]({{< relref "/commands/substr" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v2.0.0. |
+---
+Title: Server management commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Server management commands compatibility.
+linkTitle: Server management
+toc: 'true'
+weight: 10
+---
+
+The following tables show which Redis Open Source [server management commands]({{< relref "/commands" >}}?group=server) 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]({{< relref "/operate/rs/security/access-control" >}}) and the [Redis Cloud console]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control.md" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Might reply with "unknown user" for LDAP users even if `AUTH` succeeds. |
+| [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL HELP]({{< relref "/commands/acl-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL LIST]({{< relref "/commands/acl-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL LOAD]({{< relref "/commands/acl-load" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL LOG]({{< relref "/commands/acl-log" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL SAVE]({{< relref "/commands/acl-save" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ACL USERS]({{< relref "/commands/acl-users" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+
+## Configuration commands
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [CONFIG GET]({{< relref "/commands/config-get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | [Only supports a subset of configuration settings.]({{< relref "/operate/rs/references/compatibility/config-settings" >}}) |
+| [CONFIG RESETSTAT]({{< relref "/commands/config-resetstat" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [CONFIG REWRITE]({{< relref "/commands/config-rewrite" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [CONFIG SET]({{< relref "/commands/config-set" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | [Only supports a subset of configuration settings.]({{< relref "/operate/rs/references/compatibility/config-settings" >}}) |
+
+
+## General server commands
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [COMMAND]({{< relref "/commands/command" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND COUNT]({{< relref "/commands/command-count" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND DOCS]({{< relref "/commands/command-docs" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND GETKEYS]({{< relref "/commands/command-getkeys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND GETKEYSANDFLAGS]({{< relref "/commands/command-getkeysandflags" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND HELP]({{< relref "/commands/command-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND INFO]({{< relref "/commands/command-info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [COMMAND LIST]({{< relref "/commands/command-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DEBUG]({{< relref "/commands/debug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [FLUSHALL]({{< relref "/commands/flushall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*Can use the [Active-Active flush API request]({{< relref "/operate/rs/references/rest-api/requests/crdbs/flush" >}}). |
+| [FLUSHDB]({{< relref "/commands/flushdb" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*Can use the [Active-Active flush API request]({{< relref "/operate/rs/references/rest-api/requests/crdbs/flush" >}}). |
+| [LOLWUT]({{< relref "/commands/lolwut" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SHUTDOWN]({{< relref "/commands/shutdown" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SWAPDB]({{< relref "/commands/swapdb" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [TIME]({{< relref "/commands/time" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+
+## Module commands
+
+For Redis Enterprise Software, you can [manage Redis modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/" >}}) from the Cluster Manager UI or with [REST API requests]({{< relref "/operate/rs/references/rest-api/requests/modules" >}}).
+
+Redis Cloud manages modules for you and lets you [enable modules]({{< relref "/operate/rc/databases/create-database#modules" >}}) when you create a database.
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [MODULE HELP]({{< relref "/commands/module-help" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE LIST]({{< relref "/commands/module-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MODULE LOAD]({{< relref "/commands/module-load" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE LOADEX]({{< relref "/commands/module-loadex" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MODULE UNLOAD]({{< relref "/commands/module-unload" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## Monitoring commands
+
+Although Redis Enterprise does not support certain monitoring commands, you can use the Cluster Manager UI to view Redis Enterprise Software [metrics]({{< relref "/operate/rs/monitoring" >}}) and [logs]({{< relref "/operate/rs/clusters/logging" >}}) or the Redis Cloud console to view Redis Cloud [metrics]({{< relref "/operate/rc/databases/monitor-performance" >}}) and [logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [DBSIZE]({{< relref "/commands/dbsize" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [INFO]({{< relref "/commands/info" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.<br />Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY GRAPH]({{< relref "/commands/latency-graph" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY HELP]({{< relref "/commands/latency-help" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY HISTOGRAM]({{< relref "/commands/latency-histogram" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [LATENCY HISTORY]({{< relref "/commands/latency-history" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY LATEST]({{< relref "/commands/latency-latest" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LATENCY RESET]({{< relref "/commands/latency-reset" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY HELP]({{< relref "/commands/memory-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) in Redis versions earlier than 7. |
+| [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY STATS]({{< relref "/commands/memory-stats" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) in Redis versions earlier than 7. |
+| [MONITOR]({{< relref "/commands/monitor" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SLOWLOG GET]({{< relref "/commands/slowlog-get" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [SLOWLOG LEN]({{< relref "/commands/slowlog-len" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+| [SLOWLOG RESET]({{< relref "/commands/slowlog-reset" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+
+## Persistence commands
+
+Data persistence and backup commands are not available in Redis Enterprise. Instead, you can [manage data persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}}) and [backups]({{< relref "/operate/rs/databases/import-export/schedule-backups" >}}) from the Redis Enterprise Software Cluster Manager UI and the [Redis Cloud console]({{< relref "/operate/rc/databases/view-edit-database#durability-section" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [BGREWRITEAOF]({{< relref "/commands/bgrewriteaof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [BGSAVE]({{< relref "/commands/bgsave" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [LASTSAVE]({{< relref "/commands/lastsave" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SAVE]({{< relref "/commands/save" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+
+
+## Replication commands
+
+Redis Enterprise automatically manages [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}).
+
+| <span style="min-width: 9em; display: table-cell">Command</span> | Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:--------|:----------------------|:-----------------|:------|
+| [FAILOVER]({{< relref "/commands/failover" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MIGRATE]({{< relref "/commands/migrate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [PSYNC]({{< relref "/commands/psync" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [REPLCONF]({{< relref "/commands/replconf" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [REPLICAOF]({{< relref "/commands/replicaof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [RESTORE-ASKING]({{< relref "/commands/restore-asking" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [ROLE]({{< relref "/commands/role" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SLAVEOF]({{< relref "/commands/slaveof" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Deprecated as of Redis v5.0.0. |
+| [SYNC]({{< relref "/commands/sync" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+---
+Title: Pub/sub commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Pub/sub commands compatibility.
+linkTitle: Pub/sub
+weight: 10
+---
+
+The following table shows which Redis Open Source [pub/sub commands]({{< relref "/commands" >}}?group=pubsub) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [PSUBSCRIBE]({{< relref "/commands/psubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBLISH]({{< relref "/commands/publish" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB CHANNELS]({{< relref "/commands/pubsub-channels" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB NUMPAT]({{< relref "/commands/pubsub-numpat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB NUMSUB]({{< relref "/commands/pubsub-numsub" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB SHARDCHANNELS]({{< relref "/commands/pubsub-shardchannels" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUBSUB SHARDNUMSUB]({{< relref "/commands/pubsub-shardnumsub" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PUNSUBSCRIBE]({{< relref "/commands/punsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SPUBLISH]({{< relref "/commands/spublish" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SSUBSCRIBE]({{< relref "/commands/ssubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUBSCRIBE]({{< relref "/commands/subscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SUNSUBSCRIBE]({{< relref "/commands/sunsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNSUBSCRIBE]({{< relref "/commands/unsubscribe" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Transaction commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Transaction commands compatibility.
+linkTitle: Transactions
+weight: 10
+---
+
+The following table shows which Redis Open Source [transaction commands]({{< relref "/commands" >}}?group=transactions) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [DISCARD]({{< relref "/commands/discard" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXEC]({{< relref "/commands/exec" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MULTI]({{< relref "/commands/multi" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNWATCH]({{< relref "/commands/unwatch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [WATCH]({{< relref "/commands/watch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Compatibility with Redis Open Source commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Open Source commands compatible with Redis Enterprise.
+hideListLinks: true
+linkTitle: Commands
+weight: 30
+---
+
+Learn which Redis Open Source commands are compatible with Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}).
+
+Select a command group for more details about compatibility with standard and Active-Active Redis Enterprise.
+
+{{<table-children columnNames="Command group,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: Scripting commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Scripting and function commands compatibility.
+linkTitle: Scripting
+weight: 10
+---
+
+The following table shows which Redis Open Source [scripting and function commands]({{< relref "/commands" >}}?group=scripting) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+## Function commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [FCALL]({{< relref "/commands/fcall" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FCALL_RO]({{< relref "/commands/fcall_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION DELETE]({{< relref "/commands/function-delete" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION DUMP]({{< relref "/commands/function-dump" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION FLUSH]({{< relref "/commands/function-flush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION HELP]({{< relref "/commands/function-help" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION KILL]({{< relref "/commands/function-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION LIST]({{< relref "/commands/function-list" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION LOAD]({{< relref "/commands/function-load" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION RESTORE]({{< relref "/commands/function-restore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [FUNCTION STATS]({{< relref "/commands/function-stats" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+## Scripting commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [EVAL]({{< relref "/commands/eval" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVAL_RO]({{< relref "/commands/eval_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVALSHA]({{< relref "/commands/evalsha" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EVALSHA_RO]({{< relref "/commands/evalsha_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT DEBUG]({{< relref "/commands/script-debug" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [SCRIPT EXISTS]({{< relref "/commands/script-exists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT FLUSH]({{< relref "/commands/script-flush" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT KILL]({{< relref "/commands/script-kill" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SCRIPT LOAD]({{< relref "/commands/script-load" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+---
+Title: Key commands compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Generic key commands compatible with Redis Enterprise.
+linkTitle: Keys (generic)
+weight: 10
+---
+
+The following table shows which Redis Open Source [key (generic) commands]({{< relref "/commands" >}}?group=generic) are compatible with standard and Active-Active databases in Redis Enterprise Software and Redis Cloud.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [COPY]({{< relref "/commands/copy" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | For Active-Active or clustered databases, the source and destination keys must be in the same hash slot.<br /><br />\*Not supported for stream consumer group info. |
+| [DEL]({{< relref "/commands/del" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [DUMP]({{< relref "/commands/dump" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXISTS]({{< relref "/commands/exists" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIRE]({{< relref "/commands/expire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIREAT]({{< relref "/commands/expireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [EXPIRETIME]({{< relref "/commands/expiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [KEYS]({{< relref "/commands/keys" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [MIGRATE]({{< relref "/commands/migrate" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> |  |
+| [MOVE]({{< relref "/commands/move" >}}) | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | <span title="Not supported">&#x274c; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | Redis Enterprise does not support shared databases due to potential negative performance impacts and blocks any related commands. |
+| [OBJECT ENCODING]({{< relref "/commands/object-encoding" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT FREQ]({{< relref "/commands/object-freq" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT IDLETIME]({{< relref "/commands/object-idletime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [OBJECT REFCOUNT]({{< relref "/commands/object-refcount" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PERSIST]({{< relref "/commands/persist" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIRE]({{< relref "/commands/pexpire" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIREAT]({{< relref "/commands/pexpireat" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PEXPIRETIME]({{< relref "/commands/pexpiretime" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [PTTL]({{< relref "/commands/pttl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RANDOMKEY]({{< relref "/commands/randomkey" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [RENAME]({{< relref "/commands/rename" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active\*</nobr></span> | For Active-Active or clustered databases, the original key and new key must be in the same hash slot.<br /><br />\*Not supported for stream consumer group info. |
+| [RENAMENX]({{< relref "/commands/renamenx" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | For Active-Active or clustered databases, the original key and new key must be in the same hash slot. |
+| [RESTORE]({{< relref "/commands/restore" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported">&#x274c; Active-Active\*</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported">&#x274c; Active-Active\*</nobr></span> | \*Only supported for module keys. |
+| [SCAN]({{< relref "/commands/scan" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SORT]({{< relref "/commands/sort" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [SORT_RO]({{< relref "/commands/sort_ro" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TOUCH]({{< relref "/commands/touch" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TTL]({{< relref "/commands/ttl" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [TYPE]({{< relref "/commands/type" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [UNLINK]({{< relref "/commands/unlink" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+| [WAIT]({{< relref "/commands/wait" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active\*</nobr></span> | <span title="Not supported">&#x274c; Standard**</span><br /><span title="Not supported"><nobr>&#x274c; Active-Active</nobr></span> | \*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.<br></br>\*\*`WAIT` commands are supported on Redis Cloud Flexible subscriptions. |
+| [WAITAOF]({{< relref "/commands/waitaof" >}}) | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> |  |
+
+---
+Title: Client-side caching compatibility with Redis Software and Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Software and Redis Cloud compatibility with client-side caching.
+linkTitle: Client-side caching
+toc: 'true'
+weight: 80
+---
+
+Redis Software and Redis Cloud support [client-side caching]({{<relref "/develop/clients/client-side-caching">}}) for databases with Redis versions 7.4 or later.
+
+## Required database versions
+
+Client-side caching in Redis Software and Redis Cloud requires Redis database versions 7.4 or later.
+
+The following table shows the differences in client-side caching support by product:
+
+| Redis product           | Client-side caching support |
+|-------------------------|-----------------------------|
+| Redis Open Source       | Redis v6.0 and later |
+| Redis Cloud             | Redis database v7.4 and later |
+| Redis Software          | Redis database v7.4 and later |
+
+## Supported RESP versions
+
+Client-side caching in Redis Software and Redis Cloud requires [RESP3]({{< relref "/develop/reference/protocol-spec#resp-versions" >}}).
+
+The following table shows the differences in client-side caching support for RESP by product:
+
+| Redis product with client-side caching  | RESP2 | RESP3 |
+|-------------------------|-------|-------|
+| Redis Open Source       | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Redis Cloud             | <span title="Not supported">&#x274c;</span> | <span title="Supported">&#x2705;</span> |
+| Redis Software          | <span title="Not supported">&#x274c;</span> | <span title="Supported">&#x2705;</span> |
+
+## Two connections mode with REDIRECT not supported
+
+Unlike Redis Open Source, Redis Software and Redis Cloud do not support [two connections mode]({{<relref "/develop/reference/client-side-caching#two-connections-mode">}}) or the `REDIRECT` option for [`CLIENT TRACKING`]({{<relref "/commands/client-tracking">}}).
+
+## Change tracking_table_max_keys for a database
+
+When client-side caching is enabled, Redis uses an invalidation table to track which keys are cached by each connected client.
+
+The configuration setting `tracking-table-max-keys` determines the maximum number of keys stored in the invalidation table and is set to `1000000` keys by default. Redis Software does not support using `CONFIG SET` to change this value, but you can use the REST API or rladmin instead.
+
+To change `tracking_table_max_keys` for a database in a Redis Software cluster:
+
+- [`rladmin tune db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db">}}):
+
+    ```sh
+    rladmin tune db db:<ID> tracking_table_max_keys 2000000
+    ```
+
+    You can use the database name in place of `db:<ID>` in the preceding command.
+
+- [Update database configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) REST API request:
+
+    ```sh
+    PUT /v1/bdbs/<uid> 
+    { "tracking_table_max_keys": 2000000 }
+    ```
+
+## Change default tracking_table_max_keys
+
+The cluster-wide option `default_tracking_table_max_keys_policy` determines the default value of `tracking_table_max_keys` for new databases in a Redis Software cluster. `default_tracking_table_max_keys_policy` is set to `1000000` keys by default.
+
+To change `default_tracking_table_max_keys_policy`, use one of the following methods:
+
+- [`rladmin tune cluster`]({{<relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster">}})
+
+    ```sh
+    rladmin tune cluster default_tracking_table_max_keys_policy 2000000
+    ```
+
+- [Update cluster policy]({{<relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy">}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "default_tracking_table_max_keys_policy": 2000000 }
+    ```
+---
+Title: RESP compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise supports RESP2 and RESP3.
+linkTitle: RESP
+toc: 'true'
+weight: 80
+---
+
+RESP (Redis Serialization Protocol) is the protocol that clients use to communicate with Redis databases. See the [RESP protocol specification]({{< relref "/develop/reference/protocol-spec" >}}) for more information.
+
+## Supported RESP versions
+
+- RESP2 is supported by all Redis Enterprise versions.
+
+- RESP3 is supported by Redis Enterprise 7.2 and later.
+
+{{<note>}}
+Redis Enterprise versions that support RESP3 continue to support RESP2.
+{{</note>}}
+
+
+## Enable RESP3 for a database {#enable-resp3}
+
+To use RESP3 with a Redis Enterprise Software database:
+
+1. Upgrade Redis servers to version 7.2 or later.
+
+    For Active-Active and Replica Of databases:
+ 
+    1. Upgrade all participating clusters to Redis Enterprise version 7.2.x or later.
+ 
+    1. Upgrade all databases to version 7.x or later.
+
+1. Enable RESP3 support for your database (`enabled` by default):
+
+    - [`rladmin tune db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+        ```sh
+        rladmin tune db db:<ID> resp3 enabled
+        ```
+
+        You can use the database name in place of `db:<ID>` in the preceding command.
+
+    - [Update database configuration]({{< relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs" >}}) REST API request:
+
+        ```sh
+        PUT /v1/bdbs/<uid> 
+        { "resp3": true }
+        ```
+
+ ## Deactivate RESP3 for a database {#deactivate-resp3}
+
+ To deactivate RESP3 support for a database:
+
+- [`rladmin tune db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+     ```sh
+    rladmin tune db db:<ID> resp3 disabled
+    ```
+
+    You can use the database name in place of `db:<ID>` in the preceding command.
+
+- [Update database configuration]({{< relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs" >}}) REST API request:
+
+    ```sh
+    PUT /v1/bdbs/<uid> 
+    { "resp3": false }
+    ```
+
+ When RESP3 is deactivated, connected clients that use RESP3 are disconnected from the database.
+
+{{<note>}}
+You cannot use sharded pub/sub if you deactivate RESP3 support. When RESP3 is enabled, you can use sharded pub/sub with either RESP2 or RESP3.
+{{</note>}}
+
+## Change default RESP3 option
+
+The cluster-wide option `resp3_default` determines the default value of the `resp3` option, which enables or deactivates RESP3 for a database, upon upgrading a database to version 7.2. `resp3_default` is set to `enabled` by default.
+
+To change `resp3_default` to `disabled`, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. On the **Databases** screen, select {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="Toggle actions button" width="22px" class="inline" >}} to open a list of additional actions.
+
+    1. Select **Upgrade configuration**.
+
+    1. For **RESP3 support**, select **Disable**.
+
+    1. Click **Save**.
+
+- [`rladmin tune cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}})
+
+    ```sh
+    rladmin tune cluster resp3_default disabled
+    ```
+
+- [Update cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) REST API request:
+
+    ```sh
+    PUT /v1/cluster/policy 
+    { "resp3_default": false }
+    ```
+
+## Client prerequisites for Redis 7.2 upgrade
+
+The Redis clients [Go-Redis](https://redis.uptrace.dev/) version 9 and [Lettuce](https://redis.github.io/lettuce/) versions 6 and later use RESP3 by default. If you use either client to run Redis Stack commands, you should set the client's protocol version to RESP2 before upgrading your database to Redis version 7.2 to prevent potential application issues due to RESP3 breaking changes.
+
+### Go-Redis
+
+For applications using Go-Redis v9.0.5 or later, set the protocol version to RESP2:
+
+```go
+client := redis.NewClient(&redis.Options{
+    Addr:     "<database_endpoint>",
+    Protocol: 2, // Pin the protocol version
+})
+```
+
+### Lettuce
+
+To set the protocol version to RESP2 with Lettuce v6 or later:
+
+```java
+import io.lettuce.core.*;
+import io.lettuce.core.api.*;
+import io.lettuce.core.protocol.ProtocolVersion;
+
+// ...
+RedisClient client = RedisClient.create("<database_endpoint>");
+client.setOptions(ClientOptions.builder()
+        .protocolVersion(ProtocolVersion.RESP2) // Pin the protocol version 	
+        .build());
+// ...
+```
+
+If you are using [LettuceMod](https://github.com/redis-developer/lettucemod/), you need to upgrade to [v3.6.0](https://github.com/redis-developer/lettucemod/releases/tag/v3.6.0).
+---
+Title: Redis Enterprise compatibility with Redis Open Source
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Redis Enterprise compatibility with Redis Open Source.
+hideListLinks: true
+linkTitle: Redis Open Source compatibility
+weight: $weight
+tocEmbedHeaders: true
+---
+Both Redis Enterprise Software and [Redis Cloud]({{< relref "/operate/rc" >}}) are compatible with Redis Open Source. 
+
+{{< embed-md "rc-rs-oss-compatibility.md"  >}}
+
+## RESP compatibility
+
+Redis Enterprise Software and Redis Cloud support RESP2 and RESP3. See [RESP compatibility with Redis Enterprise]({{< relref "/operate/rs/references/compatibility/resp" >}}) for more information.
+
+## Client-side caching compatibility
+
+Redis Software and Redis Cloud support [client-side caching]({{<relref "/develop/clients/client-side-caching">}}) for databases with Redis versions 7.4 or later. See [Client-side caching compatibility with Redis Software and Redis Cloud]({{<relref "/operate/rs/references/compatibility/client-side-caching">}}) for more information about compatibility and configuration options.
+
+## Compatibility with open source Redis Cluster API
+
+Redis Enterprise supports [Redis OSS Cluster API]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api" >}}) if it is enabled for a database. For more information, see [Enable OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}).
+---
+Title: Resource usage metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Resource usage
+weight: $weight
+---
+
+## Connections
+
+Number of connections to the database.
+
+**Components measured**: Cluster, Node, and Database
+
+## CPU usage
+
+Percent of the node CPU used. 
+
+**Components measured**:  Cluster and Node
+
+### Main thread CPU usage 
+
+Percent of the CPU used by the main thread.
+
+**Components measured**: Database and Shard
+
+### Fork CPU usage
+
+CPU usage of Redis child forks.
+
+**Components measured**: Database and Shard
+
+### Total CPU usage 
+
+Percent usage of the CPU for all nodes.
+
+**Components measured**: Database
+
+## Free disk space
+
+Remaining unused disk space.
+
+**Components measured**:  Cluster and Node
+
+## Memory
+### Used memory 
+
+Total memory used by the database, including RAM, [Flash]({{< relref "/operate/rs/databases/auto-tiering" >}}) (if enabled), and [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}) (if enabled).
+
+Used memory does not include:
+
+1. Fragmentation overhead - The ratio of memory seen by the operating system to memory allocated by Redis
+2. Replication buffers at the primary nodes - Set to 10% of used memory and is between 64 MB and 2048 MB
+3. Memory used by Lua scripts - Does not exceed 1 MB
+4. Copy on Write (COW) operation that can be triggered by:
+    - A full replication process
+    - A database snapshot process
+    - AOF rewrite process
+
+Used memory is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+### Free RAM
+
+Available RAM for System use.
+
+**Components measured**:  Cluster and Node
+
+### Memory limit 
+
+Memory size limit of the database, enforced on the [used memory](#used-memory).
+
+**Components measured**: Database
+
+### Memory usage 
+
+Percent of memory used by Redis out of the [memory limit](#memory-limit).
+
+**Components measured**: Database
+## Traffic
+
+### Incoming traffic 
+
+Total incoming traffic to the database in bytes/sec.
+
+All incoming traffic is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Cluster, Node and Database
+
+#### Incoming traffic compressed
+
+Total incoming compressed traffic (in bytes/sec) per [Active-Active]({{< relref "/operate/rs/databases/active-active" >}}) replica database. 
+
+#### Incoming traffic uncompressed
+
+Total incoming uncompressed traffic (in bytes/sec) per [Active-Active]({{< relref "/operate/rs/databases/active-active" >}}) replica database. 
+
+### Outgoing traffic 
+
+Total outgoing traffic from the database in bytes per second.
+
+Outgoing traffic is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Cluster, Node and Database
+
+
+
+
+
+
+
+ ---
+Title: Database operations metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: null
+linkTitle: Database operations
+weight: $weight
+---
+
+## Evicted objects/sec
+
+Number of objects evicted from the database per second.
+
+Objects are evicted from the database according to the [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}).
+
+Object information is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Expired objects/sec
+
+Number of expired objects per second.
+
+Object information is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Hit ratio 
+
+Ratio of the number of operations on existing keys out of the total number of operations. 
+
+**Components measured**: Database and Shard
+
+### Read misses/sec
+
+The number of [read operations](#readssec) per second on keys that do not exist.
+
+Read misses are not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database
+
+### Write misses/sec 
+
+Number of [write operations](#writessec) per second on keys that do not exist.
+
+Write misses are not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}).
+
+**Components measured**: Database and Shard
+
+## Latency 
+
+The total amount of time between sending a Redis operation and receiving a response from the database.
+
+The graph shows average, minimum, maximum, and last latency values for all latency metrics.
+
+**Components measured**: Database
+
+### Reads latency 
+
+[Latency](#latency) of [read operations](#readssec).
+
+**Components measured**: Database
+
+### Writes latency 
+
+[Latency](#latency) per [write operation](#writessec).
+
+**Components measured**: Database
+
+### Other commands latency 
+
+[Latency](#latency) of [other operations](#other-commandssec).
+
+**Components measured**: Database
+
+## Ops/sec
+
+Number of total operations per second, which includes [read operations](#readssec), [write operations](#writessec), and [other operations](#other-commandssec).
+
+**Components measured**: Cluster, Node, Database, and Shard
+
+### Reads/sec
+
+Number of total read operations per second.
+
+To find out which commands are read operations, run the following command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+ACL CAT read
+```
+
+**Components measured**: Database
+
+### Writes/sec
+
+Number of total write operations per second.
+
+To find out which commands are write operations, run the following command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+ACL CAT write
+```
+
+**Components measured**: Database
+
+#### Pending writes min
+
+Minimum number of write operations queued per [Active-Active]({{< relref "/operate/rs/databases/active-active" >}}) replica database. 
+
+#### Pending writes max
+
+Maximum number of write operations queued per [Active-Active]({{< relref "/operate/rs/databases/active-active" >}}) replica database. 
+
+### Other commands/sec 
+
+Number of operations per second that are not [read operations](#readssec) or [write operations](#writessec).
+
+Examples of other operations include [PING]({{< relref "/commands/ping" >}}), [AUTH]({{< relref "/commands/auth" >}}, and [INFO]({{< relref "/commands/info" >}}
+
+**Components measured**: Database
+
+## Total keys 
+
+Total number of keys in the dataset.
+ 
+Does not include replicated keys, even if [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}) is enabled.
+
+Total keys is not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}). 
+
+**Components measured**: Database
+
+
+
+
+
+
+
+
+---
+Title: Prometheus metrics v2 preview
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.
+group: observability
+linkTitle: Prometheus metrics v2
+summary: V2 metrics available to Prometheus as of Redis Enterprise Software version 7.8.2.
+type: integration
+weight: 50
+tocEmbedHeaders: true
+---
+
+{{<banner-article>}}
+While the metrics stream engine is in preview, this document provides only a partial list of v2 metrics. More metrics will be added.
+{{</banner-article>}}
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/operate/rs/monitoring/prometheus_and_grafana">}}) to create dashboards for important metrics.
+
+The v2 metrics in the following tables are available as of Redis Enterprise Software version 7.8.0. For help transitioning from v1 metrics to v2 PromQL, see [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v1-to-v2">}}).
+
+The v2 scraping endpoint also exposes metrics for `node_exporter` version 1.8.1. For more information, see the [Prometheus node_exporter GitHub repository](https://github.com/prometheus/node_exporter).
+
+{{<embed-md "rs-prometheus-metrics-v2.md">}}
+---
+Title: Prometheus metrics v1
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: V1 metrics available to Prometheus.
+group: observability
+linkTitle: Prometheus metrics v1
+summary: You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.
+type: integration
+weight: 48
+tocEmbedHeaders: true
+---
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/operate/rs/monitoring/prometheus_and_grafana">}}) to create dashboards for important metrics.
+
+As of Redis Enterprise Software version 7.8.2, v1 metrics are deprecated but still available. For help transitioning from v1 metrics to v2 PromQL, see [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v1-to-v2">}}).
+
+{{<embed-md "rs-prometheus-metrics-v1.md">}}
+---
+Title: Real-time metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Documents the metrics that are tracked with Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Metrics
+weight: $weight
+---
+
+## Cluster manager metrics
+
+In the Redis Enterprise Cluster Manager UI, you can see real-time performance metrics for clusters, nodes, databases, and shards, and configure alerts that send notifications based on alert parameters. Select the **Metrics** tab to view the metrics for each component. For more information, see [Monitoring with metrics and alerts]({{< relref "/operate/rs/monitoring" >}}).
+
+See the following topics for metrics definitions:
+- [Database operations]({{< relref "/operate/rs/references/metrics/database-operations" >}}) for database metrics
+- [Resource usage]({{< relref "/operate/rs/references/metrics/resource-usage" >}}) for resource and database usage metrics
+- [Auto Tiering]({{< relref "/operate/rs/references/metrics/auto-tiering" >}}) for additional metrics for [Auto Tiering ]({{< relref "/operate/rs/databases/auto-tiering" >}}) databases
+
+## Prometheus metrics
+
+To collect and display metrics data from your databases and other cluster components,
+you can connect your [Prometheus](https://prometheus.io/) and [Grafana](https://grafana.com/) server to your Redis Enterprise Software cluster. We recommend you use Prometheus and Grafana to view metrics history and trends.
+
+See [Prometheus integration]({{< relref "/operate/rs/monitoring/prometheus_and_grafana" >}}) to learn how to connect Prometheus and Grafana to your Redis Enterprise database.
+
+Redis Enterprise version 7.8.2 introduces a preview of the new metrics stream engine that exposes the v2  Prometheus scraping endpoint at `https://<IP>:8070/v2`.
+This new engine exports all time-series metrics to external monitoring tools such as Grafana, DataDog, NewRelic, and Dynatrace using Prometheus.
+
+The new engine enables real-time monitoring, including full monitoring during maintenance operations, providing full visibility into performance during events such as shards' failovers and scaling operations.
+
+For a list of available metrics, see the following references:
+
+- [Prometheus metrics v1]({{<relref "operate/rs/references/metrics/prometheus-metrics-v1">}})
+
+- [Prometheus metrics v2 preview]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v2">}})
+
+If you are already using the existing scraping endpoint for integration, follow [this guide]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v1-to-v2">}}) to transition and try the new engine. It is possible to scrape both existing and new endpoints simultaneously, allowing advanced dashboard preparation and a smooth transition.
+
+## Limitations
+
+### Shard limit
+
+Metrics information is not shown for clusters with more than 128 shards. For large clusters, we recommend you use [Prometheus and Grafana]({{< relref "/operate/rs/monitoring/prometheus_and_grafana" >}}) to view metrics.
+
+### Metrics not shown during shard migration
+
+The following metrics are not measured during [shard migration]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) when using the [internal monitoring systems]({{<relref "/operate/rs/monitoring/v1_monitoring">}}). If you view these metrics while resharding, the graph will be blank.
+
+- [Evicted objects/sec]({{< relref "/operate/rs/references/metrics/database-operations#evicted-objectssec" >}})
+- [Expired objects/sec]({{< relref "/operate/rs/references/metrics/database-operations#expired-objectssec" >}})
+- [Read misses/sec]({{< relref "/operate/rs/references/metrics/database-operations#read-missessec" >}})
+- [Write misses/sec]({{< relref "/operate/rs/references/metrics/database-operations#write-missessec" >}})
+- [Total keys]({{< relref "/operate/rs/references/metrics/database-operations#total-keys" >}})
+- [Incoming traffic]({{< relref "/operate/rs/references/metrics/resource-usage#incoming-traffic" >}})
+- [Outgoing traffic]({{< relref "/operate/rs/references/metrics/resource-usage#outgoing-traffic" >}})
+- [Used memory]({{< relref "/operate/rs/references/metrics/resource-usage#used-memory" >}})
+
+This limitation does not apply to the new [metrics stream engine]({{<relref "/operate/rs/monitoring/metrics_stream_engine">}}).
+---
+Title: Auto Tiering Metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Auto Tiering
+weight: $weight
+---
+
+These metrics are additional metrics for [Auto Tiering ]({{< relref "/operate/rs/databases/auto-tiering" >}}) databases.
+
+#### % Values in RAM
+
+Percent of keys whose values are stored in RAM.
+
+A low percentage alert means most of the RAM is used for holding keys and not much RAM is available for values. This can be due to a high number of small keys or a few large keys. Inserting more keys might cause the database to run out of memory.
+
+If the percent of values in RAM is low for a subset of the database's shards, it might also indicate an unbalanced database.
+
+**Components measured**: Database and Shard
+
+#### Values in flash
+
+Number of keys with values stored in flash, not including [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}).
+
+**Components measured**: Database and Shard
+
+#### Values in RAM
+
+Number of keys with values stored in RAM, not including [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}).
+
+**Components measured**: Database and Shard 
+
+#### Flash key-value operations
+
+Number of operations on flash key values (read + write + del) per second.
+
+**Components measured**: Node
+
+#### Flash bytes/sec
+
+Number of total bytes read and written per second on flash memory.
+
+**Components measured**: Cluster, Node, Database, and Shard
+
+#### Flash I/O operations/sec
+
+Number of input/output operations per second on the flash storage device.
+
+**Components measured**: Cluster and Node
+
+#### RAM:Flash access ratio
+
+Ratio between logical Redis key value operations and actual flash key value operations.
+
+**Components measured**: Database and Shard
+
+#### RAM hit ratio
+
+Ratio of requests processed directly from RAM to total number of requests processed.
+
+**Components measured**: Database and Shard
+
+#### Used flash
+
+Total amount of memory used to store values in flash.
+
+**Components measured**: Database and Shard
+
+#### Free flash
+
+Amount of free space on flash storage. 
+
+**Components measured**: Cluster and Node
+
+#### Flash fragmentation
+
+Ratio between the used logical flash memory and the physical flash memory that is used.
+
+**Components measured**: Database and Shard
+
+#### Used RAM
+
+Total size of data stored in RAM, including keys, values, overheads, and [replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}) (if enabled).
+
+**Components measured**: Database and Shard
+
+#### RAM dataset overhead
+
+Percentage of the [RAM limit](#ram-limit) that is used for anything other than values, such as key names, dictionaries, and other overheads.
+
+**Components measured**: Database and Shard
+
+#### RAM limit
+
+Maximum amount of RAM that can be used in bytes.
+
+**Components measured**: Database
+
+#### RAM usage
+
+Percentage of the [RAM limit](#ram-limit) used.
+
+**Components measured**: Database
+
+#### Storage engine usage
+
+Total count of shards used, filtered by the sorage engine (Speedb / RockSB) per given database.
+
+**Components measured**: Database, Shards
+
+
+
+#### Calculated metrics
+
+These RoF statistics can be calculated from other metrics.
+
+- RoF average key size with overhead
+
+    ([ram_dataset_overhead](#ram-dataset-overhead) * [used_ram](#used-ram))
+                    / ([total_keys]({{< relref "/operate/rs/references/metrics/database-operations#total-keys" >}}) * 2)
+
+- RoF average value size in RAM
+
+    ((1 - [ram_dataset_overhead](#ram-dataset-overhead)) * [used_ram](#used-ram)) / ([values_in_ram](#values-in-ram) * 2)
+
+- RoF average value size in flash
+
+    [used_flash](#used-flash) / [values_in_flash](#values-in-flash)    
+---
+Title: Transition from Prometheus v1 to Prometheus v2
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Transition from v1 metrics to v2 PromQL equivalents.
+group: observability
+linkTitle: Transition from Prometheus v1 to v2
+summary: Transition from v1 metrics to v2 PromQL equivalents.
+type: integration
+weight: 49
+tocEmbedHeaders: true
+---
+
+You can [integrate Redis Enterprise Software with Prometheus and Grafana]({{<relref "/operate/rs/monitoring/prometheus_and_grafana">}}) to create dashboards for important metrics.
+
+As of Redis Enterprise Software version 7.8.2, [PromQL (Prometheus Query Language)](https://prometheus.io/docs/prometheus/latest/querying/basics/) metrics are available. V1 metrics are deprecated but still available. You can use the following tables to transition from v1 metrics to equivalent v2 PromQL. For a list of all available v2 metrics, see [Prometheus metrics v2]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v2">}}).
+
+{{<embed-md "rs-prometheus-metrics-transition-plan.md">}}
+---
+Title: Supported platforms
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software is supported on several operating systems,
+  cloud environments, and virtual environments.
+linkTitle: Supported platforms
+weight: 30
+tocEmbedHeaders: true
+---
+{{<embed-md "supported-platforms-embed.md">}}
+---
+Title: Supported upgrade paths for Redis Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Supported paths to upgrade a Redis Software cluster.
+linkTitle: Upgrade paths
+weight: 30
+tocEmbedHeaders: true
+---
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+For detailed upgrade instructions, see [Upgrade a Redis Enterprise Software cluster]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster">}}).
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers and the end-of-life schedule.
+
+{{<note>}}
+Redis Enterprise for Kubernetes has its own support lifecycle, which accounts for the Kubernetes distribution lifecycle. For details, see [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}}).
+{{</note>}}
+---
+Title: Connecting to Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: null
+---
+To establish a connection to a Redis database, you'll need the following information:
+
+- The hostname or IP address of the Redis server
+- The port number that the Redis server is listening at
+- The database password (when configured with an authentication password which is **strongly recommended**)
+- The SSL certificates (when configured with SSL authentication and encryption - see [this article](/kb/read-more-ssl) for more information)
+
+The combination of `hostname:port` is commonly referred to as the "endpoint." This information is readily obtainable from your Redis Enterprise Cluster and Redis Cloud admin consoles. Unless otherwise specified, our Redis databases are accessible via a single managed endpoint to ensure high availability.
+
+You can connect to a Redis database using a wide variety of tools and libraries depending on your needs. Here's a short list:
+
+- Use one of the many [clients for Redis](redis.io/clients) - see below for client-specific information and examples
+- Code your own Redis client based on the [Redis Serialization Protocol (RESP)](http://redis.io/topics/protocol)
+- Make friends with Redis' own command line tool - `redis-cli` - to quickly connect and manage any Redis database (**tip:** you can also use `telnet` instead)
+- Use tools that provide a [GUI for Redis](/blog/so-youre-looking-for-the-redis-gui)
+
+## Basic connection troubleshooting
+
+Connecting to a remote server can be challenging. Here’s a quick checklist for common pitfalls:
+
+- Verify that the connection information was copy-pasted correctly <- more than 90% of connectivity issues are due to a single missing character.
+- If you're using Redis in the cloud or not inside of a LAN, consider adjusting your client's timeout settings
+- Try disabling any security measures that your database may have been set up with (e.g. Source IP/Subnet lists, Security Groups, SSL, etc...).
+- Try using a command line tool to connect to the database from your server - it is possible that your host and/port are blocked by the network.
+- If you've managed to open a connection, try sending the `INFO` command and act on its reply or error message.
+- Redis Enterprise Software Redis databases only support connecting to the default database (0) and block some administrative commands. To learn more, see:
+    - Redis Enterprise Cluster: [REC compatibility](/redis-enterprise-documentation/rlec-compatibility)
+    - Redis Cloud FAQ: [Are you fully compatible with Redis Open Source](/faqs#are-you-fully-compatible-with-open-source-redis)
+
+If you encounter any difficulties or have questions please feel free to [contact our help desk](mailto:support@redislabs.com).
+---
+Title: Clustering Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: null
+---
+Joining multiple Redis servers into a Redis cluster is a challenging task, especially because Redis supports complex data structures and commands required by modern web applications, in high-throughput and low latency (sub-millisecond) conditions. Some of those challenges are:
+
+- Performing union and intersection operations over List/Set/Sorted Set
+   data types across multiple shards and nodes
+- Maintaining consistency across multi-shard/multi-node architecture,
+   while running (a) a SORT command over a List of Hash keys; or (b) a
+   Redis transaction that includes multiple keys; or (c) a Lua script
+   with multiple keys
+- Creating a simple abstraction layer that hides the complex cluster
+   architecture from the user’s application, without code modifications
+   and while supporting infinite scalability
+- Maintaining a reliable and consistent infrastructure in a cluster
+   configuration
+
+There are several solutions to clustering Redis, most notable of which is the [Redis Open Source cluster](http://redis.io/topics/cluster-spec).
+
+Redis Enterprise Software and Redis Cloud were built from the ground up to provide a Redis cluster of any size while supporting all Redis commands. Your dataset is distributed across multiple shards in multiple nodes of the Redis cluster and is constantly monitored to ensure optimal performance. When needed, more shards and nodes can be added to your dataset so it can scale continuously and limitlessly.
+
+Redis Enterprise clusters provide a single endpoint to connect to, and do not require any code changes or special configuration from the application’s perspective. For more information on setting up and using Redis Enterprise clusters, see [Database clustering]({{< relref "/operate/rs/databases/durability-ha/clustering/" >}}).
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Explains terms used in Redis Enterprise Software and its docs.
+linkTitle: Terminology
+title: Terminology in Redis Enterprise Software
+weight: $weight
+---
+Here are explanations of some of the terms used in Redis Enterprise Software.
+
+## Node
+
+A _node_ is a physical machine, virtual machine, container or cloud
+instance on which the RS installation package was installed and the
+setup process was run in order to make the machine part of the cluster.
+
+Each node is a container for running multiple Redis
+instances, referred to as "shards".
+
+The recommended configuration for a production cluster is an uneven
+number of nodes, with a minimum of three. Note that in some
+configurations, certain functionalities might be blocked. For example,
+if a cluster has only one node you cannot enable database replication,
+which helps to achieve high availability.
+
+A node is made up of several components, as detailed below, and works
+together with the other cluster nodes.
+
+## Redis instance (shard)
+
+As indicated above, each node serves as a container for hosting multiple
+database instances, referred to as "shards".
+
+Redis Enterprise Software supports various database configurations:
+
+- **Standard Redis database** - A single Redis shard with no
+    replication or clustering.
+- **Highly available Redis database** - Every database master shard
+    has a replica shard, so that if the master shard fails the
+    cluster can automatically fail over to the replica with minimal impact. Master and replica shards are always placed on separate
+    nodes to ensure high availability.
+- **Clustered Redis database** - The data stored in the database is
+    split across several shards. The number of shards can be defined by
+    the user. Various performance optimization algorithms define where
+    shards are placed within the cluster. During the lifetime of the
+    cluster, these algorithms might migrate a shard between nodes.
+- **Clustered and highly available Redis database** - Each master shard
+    in the clustered database has a replica shard, enabling failover if
+    the master shard fails.
+
+## Proxy
+
+Each node includes one zero-latency, multi-threaded proxy
+(written in low-level C) that masks the underlying system complexity. The
+proxy oversees forwarding Redis operations to the database shards on
+behalf of a Redis client.
+
+The proxy simplifies the cluster operation, from the application or
+Redis client point of view, by enabling the use of a standard Redis
+client. The zero-latency proxy is built over a cut-through architecture
+and employs various optimization methods. For example, to help ensure
+high-throughput and low-latency performance, the proxy might use
+instruction pipelining even if not instructed to do so by the client.
+
+## Database endpoint
+
+Each database is served by a database endpoint that is part of and
+managed by the proxies. The endpoint oversees forwarding Redis
+operations to specific database shards.
+
+If the master shard fails and the replica shard is promoted to master, the
+master endpoint is updated to point to the new master shard.
+
+If the master endpoint fails, the replica endpoint is promoted to be the
+new master endpoint and is updated to point to the master shard.
+
+Similarly, if both the master shard and the master endpoint fail, then
+both the replica shard and the replica endpoint are promoted to be the new
+master shard and master endpoint.
+
+Shards and their endpoints do not
+have to reside within the same node in the cluster.
+
+In the case of a clustered database with multiple database shards, only
+one master endpoint acts as the master endpoint for all master shards,
+forwarding Redis operations to all shards as needed.
+
+## Cluster manager
+
+The cluster manager oversees all node management-related tasks, and the
+cluster manager in the master node looks after all the cluster related
+tasks.
+
+The cluster manager is designed in a way that is totally decoupled from
+the Redis operation. This enables RS to react in a much faster and
+accurate manner to failure events, so that, for example, a node failure
+event triggers mass failover operations of all the master endpoints
+and master shards that are hosted on the failed node.
+
+In addition, this architecture guarantees that each Redis shard is only
+dealing with processing Redis commands in a shared-nothing architecture,
+thus maintaining the inherent high-throughput and low-latency of each
+Redis process. Lastly, this architecture guarantees that any change in
+the cluster manager itself does not affect the Redis operation.
+
+Some of the primary functionalities of the cluster manager include:
+
+- Deciding where shards are created
+- Deciding when shards are migrated and to where
+- Monitoring database size
+- Monitoring databases and endpoints across all nodes
+- Running the database resharding process
+- Running the database provisioning and de-provisioning processes
+- Gathering operational statistics
+- Enforcing license and subscription limitations
+
+---
+Title: redis-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Run Redis commands.
+hideListLinks: true
+linkTitle: redis-cli (run Redis commands)
+toc: 'true'
+weight: $weight
+---
+
+The `redis-cli` command-line utility lets you interact with a Redis database. With `redis-cli`, you can run [Redis commands]({{< relref "/commands" >}}) directly from the command-line terminal or with [interactive mode](#interactive-mode).
+
+If you want to run Redis commands without `redis-cli`, you can [connect to a database with Redis Insight]({{< relref "/develop/tools/insight" >}}) and use the built-in [CLI]({{< relref "/develop/tools/insight" >}}) prompt instead.
+
+## Install `redis-cli`
+
+When you install Redis Enterprise Software or Redis Open Source, it also installs the `redis-cli` command-line utility.
+
+To learn how to install Redis and `redis-cli`, see the following installation guides:
+
+- [Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack/" >}})
+
+- [Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Redis Enterprise Software with Docker]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+## Connect to a database
+
+To run Redis commands with `redis-cli`, you need to connect to your Redis database.
+
+You can find endpoint and port details in the **Databases** list or the database’s **Configuration** screen.
+
+### Connect remotely
+
+If you have `redis-cli` installed on your local machine, you can use it to connect to a remote Redis database. You will need to provide the database's connection details, such as the hostname or IP address, port, and password.
+
+```sh
+$ redis-cli -h <endpoint> -p <port> -a <password>
+```
+
+You can also provide the password with the `REDISCLI_AUTH` environment variable instead of the `-a` option:
+
+```sh
+$ export REDISCLI_AUTH=<password>
+$ redis-cli -h <endpoint> -p <port>
+```
+
+### Connect over TLS
+
+To connect to a Redis Enterprise Software or Redis Cloud database over TLS:
+
+1. Download or copy the Redis Enterprise server (or proxy) certificates.
+
+    - For Redis Cloud, see [Download certificates]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) for detailed instructions on how to download the server certificates (`redis_ca.pem`) from the [Redis Cloud console](https://cloud.redis.io/).
+
+    - For Redis Enterprise Software, copy the proxy certificate from the Cluster Manager UI (**Cluster > Security > Certificates > Server authentication**) or from a cluster node (`/etc/opt/redislabs/proxy_cert.pem`).
+
+1. Copy the certificate to each client machine.
+
+1. If your database doesn't require client authentication, provide the Redis Enterprise server certificate (`redis_ca.pem` for Cloud or `proxy_cert.pem` for Software) when you connect:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> --tls --cacert <redis_cert>.pem
+    ```
+
+1. If your database requires client authentication, provide your client's private and public keys along with the Redis Enterprise server certificate (`redis_ca.pem` for Cloud or `proxy_cert.pem` for Software) when you connect:
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> --tls --cacert <redis_cert>.pem \
+        --cert redis_user.crt --key redis_user_private.key
+    ```
+
+### Connect with Docker
+
+If your Redis database runs in a Docker container, you can use `docker exec` to run `redis-cli` commands:
+
+```sh
+$ docker exec -it <Redis container name> redis-cli -p <port>
+```
+
+## Basic use
+
+You can run `redis-cli` commands directly from the command-line terminal:
+
+```sh
+$ redis-cli -h <endpoint> -p <port> <Redis command>
+```
+
+For example, you can use `redis-cli` to test your database connection and store a new Redis string in the database:
+
+```sh
+$ redis-cli -h <endpoint> -p 12000 PING
+PONG
+$ redis-cli -h <endpoint> -p 12000 SET mykey "Hello world"
+OK
+$ redis-cli -h <endpoint> -p 12000 GET mykey              
+"Hello world"
+```
+
+For more information, see [Command line usage]({{< relref "/develop/tools/cli" >}}#command-line-usage).
+
+## Interactive mode
+
+In `redis-cli` [interactive mode]({{< relref "/develop/tools/cli" >}}#interactive-mode), you can:
+
+- Run any `redis-cli` command without prefacing it with `redis-cli`.
+- Enter `?` for more information about how to use the `HELP` command and [set `redis-cli` preferences]({{< relref "/develop/tools/cli" >}}#preferences).
+- Enter [`HELP`]({{< relref "/develop/tools/cli" >}}#showing-help-about-redis-commands) followed by the name of a command for more information about the command and its options.
+- Press the `Tab` key for command completion.
+- Enter `exit` or `quit` or press `Control+D` to exit interactive mode and return to the terminal prompt.
+
+This example shows how to start interactive mode and run Redis commands:
+
+```sh
+$ redis-cli -p 12000
+127.0.0.1:12000> PING
+PONG
+127.0.0.1:12000> SET mykey "Hello world"
+OK
+127.0.0.1:12000> GET mykey
+"Hello world"
+```
+
+## Examples
+
+### Check slowlog
+
+Run [`slowlog get`]({{< relref "/commands/slowlog-get" >}}) for a list of recent slow commands:
+
+```sh
+redis-cli -h <endpoint> -p <port> slowlog get <number of entries>
+```
+
+### Scan for big keys
+
+Scan the database for big keys:
+
+```sh
+redis-cli -h <endpoint> -p <port> --bigkeys
+```
+
+See [Scanning for big keys]({{< relref "/develop/tools/cli" >}}#scanning-for-big-keys) for more information.
+
+## More info
+
+- [Redis CLI documentation]({{< relref "/develop/tools/cli" >}})
+- [Redis commands reference]({{< relref "/commands/" >}})
+---
+Title: rlcheck
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Verify nodes.
+hideListLinks: true
+linkTitle: rlcheck (verify nodes)
+weight: $weight
+---
+The `rlcheck` utility runs various [tests](#tests) to check the health of a Redis Enterprise Software node and reports any discovered issues.
+You can use this utility to confirm a successful installation or to verify that the node is functioning properly.
+
+To resolve issues reported by `rlcheck`, [contact Redis support](https://redis.com/company/support/).
+
+## Run rlcheck
+
+You can run `rlcheck` from the node host's command line.
+The output of `rlcheck` shows information specific to the host you run it on.
+
+To run `rlcheck` tests:
+
+1. Sign in to the Redis Enterprise Software host with an account that is a member of the **redislabs** operating system group.
+
+1. Run: 
+
+    ```sh
+    rlcheck
+    ```
+
+## Options
+
+You can run `rlcheck` with the following options:
+
+| Option | Description |
+|--------|-------------|
+| <nobr>`--suppress-tests TEXT`</nobr> | Skip the specified, comma-delimited list of tests. See [Tests](#tests) for the list of tests and descriptions. |
+| <nobr>`--retry-delay INTEGER`</nobr> | Delay between retries, in seconds. |
+| <nobr>`--retry INTEGER`</nobr> | Number of retries after a failure. |
+| <nobr>`--file-path TEXT`</nobr> | Custom path to `rlcheck.log`. |
+| <nobr>`--continue-on-error`</nobr> | Continue to run all tests even if a test fails, then show all errors when complete. |
+| `--help` | Return the list of `rlcheck` options. |
+
+## Tests
+
+`rlcheck` runs the following tests by default:
+
+| Test name | Description |
+|-----------|-------------|
+| verify_owner_and_group | Verifies the owner and group for Redis Enterprise Software files are correct. |
+| verify_bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| verify_services | Verifies all Redis Enterprise Software services are running. |
+| verify_port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| verify_pidfiles | Verifies all active local shards have PID files. |
+| verify_capabilities | Verifies all binaries have the proper capability bits. |
+| verify_existing_sockets | Verifies sockets exist for all processes that require them. |
+| verify_host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />•`transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| verify_tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+| verify_encrypted_gossip | Verifies gossip communication is encrypted. |
+---
+Title: rladmin tune
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures parameters for databases, proxies, nodes, and clusters.
+headerRange: '[1-2]'
+linkTitle: tune
+toc: 'true'
+weight: $weight
+---
+
+Configures parameters for databases, proxies, nodes, and clusters.
+
+## `tune cluster`
+
+Configures cluster parameters.
+
+``` sh
+rladmin tune cluster
+        [ repl_diskless { enabled | disabled } ]
+        [ redis_provision_node_threshold <size> ]
+        [ redis_migrate_node_threshold <size> ]
+        [ redis_provision_node_threshold_percent <percent> ]
+        [ redis_migrate_node_threshold_percent <percent> ]
+        [ max_simultaneous_backups <number> ]
+        [ failure_detection_sensitivity { high | low } ]
+        [ watchdog_profile { cloud | local-network } ]
+        [ slave_ha { enabled | disabled } ]
+        [ slave_ha_grace_period <seconds> ]
+        [ slave_ha_cooldown_period <seconds> ]
+        [ slave_ha_bdb_cooldown_period <seconds> ]
+        [ max_saved_events_per_type <value> ]
+        [ parallel_shards_upgrade <value> ]
+        [ default_concurrent_restore_actions <value> ]
+        [ show_internals { enabled | disabled } ]
+        [ expose_hostnames_for_all_suffixes { enabled | disabled } ]
+        [ redis_upgrade_policy { latest | major } ]
+        [ default_redis_version <value> ]
+        [ default_non_sharded_proxy_policy { single | all-master-shards | all-nodes } ]
+        [ default_sharded_proxy_policy { single | all-master-shards | all-nodes } ]
+        [ default_shards_placement { dense | sparse } ]
+        [ data_internode_encryption { enabled | disabled } ]
+        [ db_conns_auditing { enabled | disabled } ]
+        [ acl_pubsub_default { resetchannels | allchannels } ]
+        [ resp3_default { enabled | disabled } ]
+        [ automatic_node_offload { enabled | disabled } ]
+        [ default_tracking_table_max_keys_policy <value> ]
+        [ default_oss_sharding { enabled | disabled } ]
+ ]
+```
+
+### Parameters
+
+| Parameters                             | Type/Value                        | Description                                                                                                                  |
+|----------------------------------------|-----------------------------------|------------------------------------------------------------------------------------------------------------------------------|
+| acl_pubsub_default | `resetchannels`<br /> `allchannels` | Default pub/sub ACL rule for all databases in the cluster:<br />•`resetchannels` blocks access to all channels (restrictive)<br />•`allchannels` allows access to all channels (permissive) |
+| automatic_node_offload | `enabled`<br />`disabled` | Define whether automatic node offload migration will take place |
+| data_internode_encryption              | `enabled`<br />`disabled`       | Activates or deactivates [internode encryption]({{< relref "/operate/rs/security/encryption/internode-encryption" >}}) for new databases    |
+| db_conns_auditing                      | `enabled`<br /> `disabled`      | Activates or deactivates [connection auditing]({{< relref "/operate/rs/security/audit-events" >}}) by default for new databases of a cluster                                                                  |
+| default_concurrent_restore_actions     | integer<br />`all`              | Default number of concurrent actions when restoring a node from a snapshot (positive integer or "all")                         |
+| default_non_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default [proxy policy]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}) for newly created non-sharded databases' endpoints |
+| default_oss_sharding | `enabled`<br />`disabled` | Default hashing policy to use for new databases. Set to `disabled` by default. This field is for future use only and should not be changed. |
+| default_redis_version                  | version number                    | The default Redis database compatibility version used to create new databases.<br/><br/>  The value parameter should be a version number in the form of "x.y" where _x_ represents the major version number and _y_ represents the minor version number.  The final value corresponds to the desired version of Redis.<br/><br/>You cannot set _default_redis_version_ to a value higher than that supported by the current _redis_upgrade_policy_ value. |
+| default_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default [proxy policy]({{< relref "/operate/rs/databases/configure/proxy-policy" >}}) for newly created sharded databases' endpoints |
+| default_shards_placement | `dense`<br />`sparse` | New databases place shards according to the default [shard placement policy]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy" >}}) |
+| default_tracking_table_max_keys_policy | integer (default: 1000000) | Defines the default value of the client-side caching invalidation table size for new databases. 0 makes the cache unlimited. |
+| expose_hostnames_for_all_suffixes      | `enabled`<br />`disabled`       | Exposes hostnames for all DNS suffixes                                                                                       |
+| failure_detection_sensitivity | `high`<br />`low` | Predefined thresholds and timeouts for failure detection (previously known as `watchdog_profile`)<br />• `high` (previously `local-network`) – high failure detection sensitivity, lower thresholds, faster failure detection and failover<br />• `low` (previously `cloud`) – low failure detection sensitivity, higher tolerance for latency variance (also called network jitter) |
+| login_lockout_counter_reset_after      | time in seconds                   | Time after failed login attempt before the counter resets to 0                                                                   |
+| login_lockout_duration                 | time in seconds                   | Time a locked account remains locked ( "0" means only an admin can unlock the account)                                   |
+| login_lockout_threshold                | integer                           | Number of failed sign-in attempts to trigger locking a user account ("0" means never lock the account)                   |
+| max_saved_events_per_type              | integer                           | Maximum number of events each type saved in CCS per object type                                                              |
+| max_simultaneous_backups               | integer (default: 4)                      | Number of database backups allowed to run at the same time. Combines with `max_redis_forks` (set by [`tune node`](#tune-node)) to determine the number of shard backups allowed to run simultaneously.                                                                                  |
+| parallel_shards_upgrade                | integer<br />`all`              | Number of shards upgraded in parallel during DB upgrade (positive integer or "all")                                          |
+| redis_migrate_node_threshold           | size in MB                        | Memory (in MBs by default or can be specified) needed to migrate a database between nodes                                   |
+| redis_migrate_node_threshold_percent   | percentage                | Memory (in percentage) needed to migrate a database between nodes                                                            |
+| redis_provision_node_threshold         | size in MB                        | Memory (in MBs by default or can be specified) needed to provision a new database                                           |
+| redis_provision_node_threshold_percent | percentage                | Memory (in percentage) needed to provision a new database                                                                    |
+| redis_upgrade_policy                   | `latest`<br />`major`           | When you upgrade or create a new Redis database, this policy determines which version of Redis database compatibility is used.<br /><br />Supported values are:<ul><li><p>`latest`, which applies the most recent Redis compatibility update \(_effective default prior to v6.2.4_)<p></li><li>`major`, which applies the most recent major release compatibility update (_default as of v6.2.4_).</li></ul>                                                                                                                 |
+| repl_diskless                          | `enabled`<br />`disabled`       | Activates or deactivates diskless replication (can be overridden per database)                                              |
+| resp3_default | `enabled` <br /> `disabled` | Determines the default value of the `resp3` option upon upgrading a database to version 7.2 (defaults to `enabled`) |
+| show_internals                         | `enabled`<br />`disabled`       | Controls the visibility of internal databases that are only used for the cluster's management                                |
+| slave_ha                               | `enabled` <br /> `disabled`   | Activates or deactivates [replica high availability]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) in the cluster<br />(enabled by default; use [`rladmin tune db`](#tune-db) to change `slave_ha` for a specific database)<br /><br />Deprecated as of Redis Enterprise Software v7.2.4. |
+| slave_ha_bdb_cooldown_period           | time in seconds (default: 7200) | Time (in seconds) a database must wait after its shards are relocated by [replica high availability]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) before it can go through another shard migration if another node fails (default is 2 hours) |
+| slave_ha_cooldown_period               | time in seconds (default: 3600) | Time (in seconds) [replica high availability]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) must wait after relocating shards due to node failure before performing another shard migration for any database in the cluster (default is 1 hour) |
+| slave_ha_grace_period                  | time in seconds (default: 600) | Time (in seconds) between when a node fails and when [replica high availability]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) starts relocating shards to another node      |
+| watchdog_profile                       | `cloud` <br /> `local-network` | Watchdog profiles with preconfigured thresholds and timeouts (deprecated as of Redis Enterprise Software v6.4.2-69; use <span class="break-all">`failure_detection_sensitivity`</span> instead)<br />• `cloud` is suitable for common cloud environments and has a higher tolerance for latency variance (also called network jitter).<br />• `local-network` is suitable for dedicated LANs and has better failure detection and failover times. |
+
+### Returns
+
+Returns `Finished successfully` if the cluster configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info cluster`]({{< relref "/operate/rs/references/cli-utilities/rladmin/info#info-cluster" >}}) to verify the cluster configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune cluster slave_ha enabled
+Finished successfully
+$ rladmin info cluster | grep slave_ha
+    slave_ha: enabled
+```
+
+## `tune db`
+
+Configures database parameters.
+
+``` sh
+rladmin tune db { db:<id> | <name> }
+        [ slave_buffer <auto | valueMB | hard:soft:time> ]
+        [ client_buffer <value> ]
+        [ repl_backlog <valueMB | auto> ]
+        [ crdt_repl_backlog <valueMB | auto> ]
+        [ repl_timeout <seconds> ]
+        [ repl_diskless { enabled | disabled | default } ]
+        [ master_persistence { enabled | disabled } ]
+        [ maxclients <value> ]
+        [ schedpolicy { cmp | mru | spread | mnp } ]
+        [ max_shard_pipeline <value> ]
+        [ conns <value> ]
+        [ conns_type <value> ]
+        [ max_client_pipeline <value> ]
+        [ max_connections <value> ]
+        [ max_aof_file_size <size> ]
+        [ max_aof_load_time <seconds> ]
+        [ oss_cluster { enabled | disabled } ]
+        [ oss_cluster_api_preferred_ip_type <value> ]
+        [ slave_ha { enabled | disabled } ]
+        [ slave_ha_priority <value> ]
+        [ skip_import_analyze { enabled | disabled } ]
+        [ mkms { enabled | disabled } ]
+        [ continue_on_error ]
+        [ gradual_src_mode { enabled | disabled } ]
+        [ gradual_sync_mode { enabled | disabled | auto } ]
+        [ gradual_sync_max_shards_per_source <value> ]
+        [ module_name <value> ] [ module_config_params <value> ]
+        [ crdt_xadd_id_uniqueness_mode { liberal | semi-strict | strict } ]
+        [ metrics_export_all { enabled | disabled } ]
+        [ syncer_mode { distributed | centralized }]
+        [ syncer_monitoring { enabled | disabled } ]
+        [ mtls_allow_weak_hashing { enabled | disabled } ]
+        [ mtls_allow_outdated_cert { enabled | disabled } ]
+        [ data_internode_encryption { enabled | disabled } ]
+        [ db_conns_auditing { enabled | disabled } ]
+        [ resp3 { enabled | disabled } ]
+        [ tracking_table_max_keys <size> ]
+```
+
+### Parameters
+
+| Parameter                            | Type/Value                       | Description                                                                                                                           |
+|--------------------------------------|----------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| db:id                                | integer                          | ID of the specified database                                                                                                          |
+| name                                 | string                           | Name of the specified database                                                                                                        |
+| client_buffer                        | value in MB hard:soft:time       | Redis client output buffer limits                                                                                                     |
+| conns                                | integer                          | Size of internal connection pool, specified per-thread or per-shard depending on conns_type                                           |
+| conns_type                           | `per-thread`<br /> `per-shard`   | Specifies connection pool size as either per-thread or per-shard                                                                      |
+| continue_on_error                    |                                  | Flag that skips tuning shards that can't be reached                                                                                   |
+| crdt_repl_backlog                    | value in MB<br /> `auto`         | Size of the Active-Active replication buffer                                                                                          |
+| crdt_xadd_id_uniqueness_mode         | `liberal`<br /> `semi-strict`<br /> `strict` | XADD's behavior in an Active-Active database, defined as liberal, semi-strict, or strict (see descriptions below)         |
+| data_internode_encryption            | `enabled`<br /> `disabled`       | Activates or deactivates [internode encryption]({{< relref "/operate/rs/security/encryption/internode-encryption" >}}) for the database               |
+| db_conns_auditing                    | `enabled`<br /> `disabled`       | Activates or deactivates database [connection auditing]({{< relref "/operate/rs/security/audit-events" >}}) for a database                                                                 |
+| gradual_src_mode                     | `enabled`<br /> `disabled`       | Activates or deactivates gradual sync of sources                                                                                      |
+| gradual_sync_max_shards_per_source   | integer                          | Number of shards per sync source that can be replicated in parallel (positive integer)                                                |
+| gradual_sync_mode                    | `enabled`<br /> `disabled`<br /> `auto` | Activates, deactivates, or automatically determines gradual sync of source shards                                              |
+| master_persistence                   | `enabled`<br /> `disabled`       | If enabled, persists the primary shard in addition to replica shards in a replicated and persistent database. |
+| max_aof_file_size                    | size in MB                       | Maximum size (in MB, if not specified) of [AoF]({{< relref "/glossary/_index.md#letter-a" >}}) file (minimum value is 10 GB)              |
+| max_aof_load_time | time in seconds | Time limit in seconds to load a shard from an append-only file (AOF). If exceeded, an AOF rewrite is initiated to decrease future load time.<br />Minimum: 2700 seconds (45 minutes) <br />Default: 3600 seconds (1 hour) |
+| max_client_pipeline                  | integer                          | Maximum commands in the proxy's pipeline per client connection (max value is 2047, default value is 200)                              |
+| max_connections                      | integer                          | Maximum client connections to the database's endpoint (default value is 0, which is unlimited)                                            |
+| max_shard_pipeline                   | integer                          | Maximum commands in the proxy's pipeline per shard connection (default value is 200)                                                  |
+| maxclients                           | integer                          | Controls the maximum client connections between the proxy and shards (default value is 10000)                                         |
+| metrics_export_all                   | `enabled`<br /> `disabled`       | Activates the exporter to expose all shard metrics                                                                                    |
+| mkms                                 | `enabled`<br /> `disabled`       | Activates multi-key multi-slot commands                                                                                               |
+| module_config_params | string | Configures module arguments at runtime. Enclose `module_config_params` within quotation marks. |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf`<br />`rg` | The module to configure with `module_config_params` |
+| mtls_allow_outdated_cert             | `enabled`<br /> `disabled`       | Activates outdated certificates in mTLS connections                                   |
+| mtls_allow_weak_hashing              | `enabled`<br /> `disabled`       | Activates weak hashing (less than 2048 bits) in mTLS connections                       |
+| oss_cluster                          | `enabled`<br /> `disabled`       | Activates OSS cluster API                                                                                                             |
+| oss_cluster_api_preferred_ip_type    | `internal`<br /> `external`      | IP type for the endpoint and database in the OSS cluster API (default is internal)                                     |
+| repl_backlog                         | size in MB<br /> `auto`          | Size of the replication buffer                                                                                        |
+| repl_diskless                        | `enabled`<br /> `disabled`<br /> `default`   | Activates or deactivates diskless replication (defaults to the cluster setting)                                          |
+| repl_timeout                         | time in seconds                  | Replication timeout (in seconds)                                                                                                      |
+| resp3 | `enabled`<br /> `disabled` | Enables or deactivates RESP3 support (defaults to `enabled`) |
+| schedpolicy                          | `cmp`<br /> `mru`<br /> `spread`<br /> `mnp` | Controls how server-side connections are used when forwarding traffic to shards                                           |
+| skip_import_analyze                  | `enabled`<br /> `disabled`       | Skips the analyzing step when importing a database                                                                                    |
+| slave_buffer                         | `auto`<br />value in MB<br /> hard:soft:time | Redis replica output buffer limits<br />• `auto`: dynamically adjusts the buffer limit based on the shard’s current used memory<br />• value in MB: sets the buffer limit in MB<br />• hard:soft:time: sets the hard limit (maximum buffer size in MB), soft limit in MB, and the time in seconds that the soft limit can be exceeded |
+| slave_ha                             | `enabled`<br /> `disabled`       | Activates or deactivates replica high availability (defaults to the cluster setting)                                                      |
+| slave_ha_priority                    | integer                          | Priority of the database in the replica high-availability mechanism                                                                           |
+| syncer_mode                          | `distributed`<br /> `centralized`| Configures syncer to run in distributed or centralized mode. For distributed syncer, the DMC policy must be all-nodes or all-master-nodes |
+| syncer_monitoring                    | `enabled`<br /> `disabled`       | Activates syncer monitoring                                                                                                           |
+| tracking_table_max_keys | integer | The client-side caching invalidation table size. 0 makes the cache unlimited. |
+
+| XADD behavior mode | Description |
+| - | - |
+| liberal | XADD succeeds with any valid ID (not recommended, allows duplicate IDs) |
+| semi-strict | Allows a full ID. Partial IDs are completed with the unique database instance ID (not recommended, allows duplicate IDs). |
+| strict | XADD fails if a full ID is given. Partial IDs are completed using the unique database instance ID. |
+
+### Returns
+
+Returns `Finished successfully` if the database configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/info#info-db" >}}) to verify the database configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune db db:4 repl_timeout 300
+Tuning database: o
+Finished successfully
+$ rladmin info db db:4 | grep repl_timeout
+  repl_timeout: 300 seconds
+```
+
+## `tune node`
+
+Configures node parameters.
+
+``` sh
+tune node  { <id> | all }
+     [ max_listeners <value> ]
+     [ max_redis_forks <value> ]
+     [ max_redis_servers <value> ]
+     [ max_slave_full_syncs <value> ]
+     [ quorum_only { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter            | Type/Value | Description                                                                                                                      |
+|----------------------|------------|----------------------------------------------------------------------------------------------------------------------------------|
+| id                   | integer    | ID of the specified node                                                                                                         |
+| all                  |            | Configures settings for all nodes                                                                                                |
+| max_listeners        | integer    | Maximum number of endpoints that may be bound to the node                                                                        |
+| max_redis_forks      | integer    | Maximum number of background processes forked from shards that may exist on the node at any given time                           |
+| max_redis_servers    | integer    | Maximum number of shards allowed to reside on the node                                                                           |
+| max_slave_full_syncs | integer    | Maximum number of simultaneous replica full-syncs that may be running at any given time (0: Unlimited, -1: Use cluster settings) |
+| quorum_only          | `enabled`<br /> `disabled` | If activated, configures the node as a [quorum-only node]({{< relref "/glossary/_index.md#letter-p" >}})                         |
+
+### Returns
+
+Returns `Finished successfully` if the node configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info node`]({{< relref "/operate/rs/references/cli-utilities/rladmin/info#info-node" >}}) to verify the node configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune node 3 max_redis_servers 120
+Finished successfully
+$ rladmin info node 3 | grep "max redis servers"
+    max redis servers: 120
+```
+
+## `tune proxy`
+
+Configures proxy parameters.
+
+``` sh
+rladmin tune proxy { <id> | all }
+        [ mode { static | dynamic } ]
+        [ threads <value> ]
+        [ max_threads <value> ]
+        [ scale_threshold <value> ]
+        [ scale_duration <seconds> ]
+```
+
+### Parameters
+
+| Parameter       | Type/Value                 | Description                                                                         |
+|-----------------|----------------------------|-------------------------------------------------------------------------------------|
+| id              | integer                    | ID of the specified proxy                                                           |
+| all             |                            | Configures settings for all proxies                                                 |
+| max_threads     | integer, (range:&nbsp;1-255) | Maximum number of threads allowed                                                   |
+| mode            | `static`<br /> `dynamic` | Determines if the proxy automatically adjusts the number of threads based on load size  |
+| scale_duration  | time in seconds, (range:&nbsp;10-300) | Time of scale_threshold CPU utilization before the automatic proxy automatically scales |
+| scale_threshold | percentage, (range:&nbsp;50-99) | CPU utilization threshold that triggers spawning new threads                        |
+| threads         | integer, (range:&nbsp;1-255) | Initial number of threads created at startup                                        |
+
+### Returns
+
+Returns `OK` if the proxy configuration was changed. Otherwise, it returns an error.
+
+Use [`rladmin info proxy`]({{< relref "/operate/rs/references/cli-utilities/rladmin/info#info-proxy" >}}) to verify the proxy configuration was changed.
+
+### Example
+
+``` sh
+$ rladmin tune proxy 2 scale_threshold 75
+Configuring proxies:
+  - proxy:2: ok
+$ rladmin info proxy 2 | grep scale_threshold
+    scale_threshold: 75 (%)
+```
+---
+Title: rladmin cluster change_password_hashing_algorithm
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Changes the password hashing algorithm.
+headerRange: '[1-2]'
+linkTitle: change_password_hashing_algorithm
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Changes the password hashing algorithm for the entire cluster. When you change the hashing algorithm, it rehashes the administrator password and passwords for all users, including default users.
+
+```sh
+rladmin cluster change_password_hashing_algorithm <algorithm>
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| algorithm | SHA-256<br />PBKDF2 | Change to the specified hashing algorithm. The default hashing algorithm is `SHA-256`. |
+
+### Returns
+
+Reports whether the algorithm change succeeded or an error occurred.
+
+### Example
+
+```sh
+$ rladmin cluster change_password_hashing_algorithm PBKDF2
+Please confirm changing the password hashing algorithm
+Please confirm [Y/N]: y
+Algorithm changed
+```
+---
+Title: rladmin cluster master
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Identifies or changes the cluster's master node.
+headerRange: '[1-2]'
+linkTitle: master
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Identifies the cluster's master node. Use `set` to change the cluster's master to a different node.
+
+```sh
+cluster master [ set <node_id> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node_id | integer | Unique node ID |
+
+### Returns
+
+Returns the ID of the cluster's master node. Otherwise, it returns an error message.
+
+### Example
+
+Identify the cluster's master node:
+
+```sh
+$ rladmin cluster master
+Node 1 is the cluster master node
+```
+
+Change the cluster master to node 3:
+
+```sh
+$ rladmin cluster master set 3
+Node 3 set to be the cluster master node
+```
+---
+Title: rladmin cluster recover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Recovers a cluster from a backup file.
+headerRange: '[1-2]'
+linkTitle: recover
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+---
+
+Recovers a cluster from a backup file. The default location of the configuration backup file is `/var/opt/redislabs/persist/ccs/ccs-redis.rdb`.
+
+```sh
+rladmin cluster recover
+        filename <recovery filename>
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ rack_id <ID> ]
+        [ override_rack_id ]
+        [ node_uid <number> ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP address> ]
+        [ external_addr <IP address> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| addr | IP address | Sets a node's internal IP address. If not provided, the node sets the address automatically. (optional) |
+| ccs_persistent_path | filepath | Path to the location of CCS snapshots (default is the same as persistent_path) (optional) |
+| external_addr | IP address | Sets a node's external IP address. If not provided, the node sets the address automatically. (optional) |
+| ephemeral_path | filepath (default:&nbsp;/var/opt/redislabs) | Path to an ephemeral storage location (optional) |
+| filename | filepath | Backup file to use for recovery |
+| flash_enabled | | Enables flash storage (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location in case the node does not support CAPI (required if flash_enabled) |
+| node_uid | integer (default:&nbsp;1) | Specifies which node will recover first and become master (optional) |
+| override_rack_id | | Changes to a new rack, specified by `rack_id` (optional) |
+| persistent_path | filepath | Path to the persistent storage location (optional) |
+| rack_id | string | Switches to the specified rack (optional) |
+
+### Returns
+
+Returns `ok` if the cluster recovered successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster recover filename /tmp/persist/ccs/ccs-redis.rdb node_uid 1 rack_id 5
+Initiating cluster recovery... ok
+```
+---
+Title: rladmin cluster stats_archiver
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Enables/deactivates the stats archiver.
+headerRange: '[1-2]'
+linkTitle: stats_archiver
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Enables or deactivates the stats archiver, which logs statistics in CSV (comma-separated values) format.
+
+```sh
+rladmin cluster stats_archiver { enabled | disabled }
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| enabled | Turn on the stats archiver |
+| disabled | Turn off the stats archiver |
+
+### Returns
+
+Returns the updated status of the stats archiver. 
+
+### Example
+
+```sh
+$ rladmin cluster stats_archiver enabled 
+Status: enabled
+```---
+Title: rladmin cluster reset_password
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Changes the password for a given email.
+headerRange: '[1-2]'
+linkTitle: reset_password
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Changes the password for the user associated with the specified email address.
+
+Enter a new password when prompted. Then enter the same password when prompted a second time to confirm the password change.
+
+```sh
+rladmin cluster reset_password <user email>
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| user email | email address | The email address of the user that needs a password reset |
+
+### Returns
+
+Reports whether the password change succeeded or an error occurred. 
+
+### Example
+
+```sh
+$ rladmin cluster reset_password user@example.com
+New password: 
+New password (again): 
+Password changed.
+```---
+Title: rladmin cluster config
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Updates the cluster's configuration.
+headerRange: '[1-2]'
+linkTitle: config
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Updates the cluster configuration.
+
+```sh
+ rladmin cluster config 
+        [ auditing db_conns audit_protocol { TCP | local } 
+           audit_address <audit_address> audit_port <audit_port> ]
+        [bigstore_driver {speedb | rocksdb} ]
+        [ control_cipher_suites <BoringSSL cipher list> ]
+        [ cm_port <number> ]
+        [ cm_session_timeout_minutes <minutes> ]
+        [ cnm_http_port <number> ]
+        [ cnm_https_port <number> ]
+        [ crdb_coordinator_port <number> ]
+        [ data_cipher_list <openSSL cipher list> ]
+        [ data_cipher_suites_tls_1_3 <openSSL cipher list> ]
+        [ debuginfo_path <filepath> ]
+        [ encrypt_pkeys { enabled | disabled } ]
+        [ envoy_admin_port <new-port> ]
+        [ envoy_mgmt_server_port <new-port> ]
+        [ gossip_envoy_admin_port <new-port> ]
+        [ handle_redirects { enabled | disabled } ]
+        [ handle_metrics_redirects { enabled | disabled } ]
+        [ http_support { enabled | disabled } ]
+        [ ipv6 { enabled | disabled } ]
+        [ min_control_TLS_version { 1.2 | 1.3 } ]
+        [ min_data_TLS_version { 1.2 | 1.3 } ]
+        [ min_sentinel_TLS_version { 1.2 | 1.3 } ]
+        [ reserved_ports <list of ports/port ranges> ]
+        [ s3_url <URL> ]
+        [ s3_ca_cert <filepath> ]
+        [ saslauthd_ldap_conf </tmp/ldap.conf> ]
+        [ sentinel_tls_mode { allowed | required | disabled } ]
+        [ sentinel_cipher_suites <golang cipher list> ]
+        [ services { cm_server | crdb_coordinator | crdb_worker | 
+                     mdns_server | pdns_server | saslauthd | 
+                     stats_archiver } { enabled | disabled } ]
+        [ upgrade_mode { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| audit_address | string | TCP/IP address where a listener can capture [audit event notifications]({{< relref "/operate/rs/security/audit-events" >}}) |
+| audit_port | string | Port where a listener can capture [audit event notifications]({{< relref "/operate/rs/security/audit-events" >}}) |
+| audit_protocol | `tcp`<br/>`local` | Protocol used for [audit event notifications]({{< relref "/operate/rs/security/audit-events" >}})<br/>For production systems, only `tcp` is supported. |
+| control_cipher_suites | list of ciphers | Cipher suites used for TLS connections to the Cluster Manager UI (specified in the format understood by the BoringSSL library)<br />(previously named `cipher_suites`) |
+| cm_port | integer | UI server listening port |
+| cm_session_timeout_minutes | integer | Timeout in minutes for the CM session
+| cnm_http_port | integer | HTTP REST API server listening port |
+| cnm_https_port | integer | HTTPS REST API server listening port |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| data_cipher_list | list of ciphers | Cipher suites used by the the data plane (specified in the format understood by the OpenSSL library) |
+| data_cipher_suites_tls_1_3 |  list of ciphers | Specifies the enabled TLS 1.3 ciphers for the data plane |
+| debuginfo_path | filepath | Local directory to place generated support package files |
+| encrypt_pkeys | `enabled`<br />`disabled` | Enable or turn off encryption of private keys |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| handle_redirects | `enabled`<br />`disabled` | Enable or turn off handling DNS redirects when DNS is not configured and running behind a load balancer |
+| handle_metrics_redirects | `enabled`<br />`disabled` | Enable or turn off handling cluster redirects internally for Metrics API |
+| http_support | `enabled`<br />`disabled` | Enable or turn off using HTTP for REST API connections |
+| ipv6 | `enabled`<br />`disabled` | Enable or turn off IPv6 connections to the Cluster Manager UI |
+| min_control_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the control path |
+| min_data_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the data path |
+| min_sentinel_TLS_version | `1.2`<br />`1.3` | The minimum TLS protocol version that is supported for the discovery service |
+| reserved_ports | list of ports/port ranges | List of reserved ports and/or port ranges to avoid using for database endpoints (for example `reserved_ports 11000 13000-13010`) |
+| s3_url | string | The URL of S3 export and import |
+| s3_ca_cert | string | The CA certificate filepath for S3 export and import |
+| saslauthd_ldap_conf | filepath | Updates LDAP authentication configuration for the cluster |
+| sentinel_cipher_suites | list of ciphers | Cipher suites used by the discovery service (supported ciphers are implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package) |
+| sentinel_tls_mode | `allowed`<br />`required`<br />`disabled` | Define the SSL policy for the discovery service<br />(previously named `sentinel_ssl_policy`) |
+| services | `cm_server`<br />`crdb_coordinator`<br />`crdb_worker`<br />`mdns_server`<br />`pdns_server`<br />`saslauthd`<br />`stats_archiver`<br /><br />`enabled`<br />`disabled` | Enable or turn off selected cluster services |
+| upgrade_mode | `enabled`<br />`disabled` | Enable or turn off upgrade mode on the cluster |
+
+### Returns
+
+Reports whether the cluster was configured successfully. Displays an error message if the configuration attempt fails.
+
+### Example
+
+```sh
+$ rladmin cluster config cm_session_timeout_minutes 20
+Cluster configured successfully
+```
+---
+Title: rladmin cluster ocsp
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages OCSP.
+headerRange: '[1-2]'
+linkTitle: ocsp
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Manages OCSP configuration and verifies the status of a server certificate maintained by a third-party [certificate authority (CA)](https://en.wikipedia.org/wiki/Certificate_authority).
+
+## `ocsp certificate_compatible`
+
+Checks if the proxy certificate contains an OCSP URI.
+
+```sh
+rladmin cluster ocsp certificate_compatible
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the OCSP URI if it exists. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp certificate_compatible
+Success. OCSP URI is http://responder.ocsp.url.com
+```
+
+## `ocsp config`
+
+Displays or updates OCSP configuration. Run the command without the `set` option to display the current configuration of a parameter.
+
+```sh
+rladmin cluster ocsp config <OCSP parameter>
+        [set <value>]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|---------------|-------------|
+| ocsp_functionality | enabled<br></br>disabled | Enables or turns off OCSP for the cluster |
+| query_frequency | integer <nobr>(range: 60-86400)</nobr> <nobr>(default: 3600)</nobr> | The time interval in seconds between OCSP queries to check the certificate's status |
+| recovery_frequency | integer <nobr>(range: 60-86400)</nobr> <nobr>(default: 60)</nobr> | The time interval in seconds between retries after a failed query |
+| recovery_max_tries | integer <nobr>(range: 1-100)</nobr> <nobr>(default: 5)</nobr> | The number of retries before the validation query fails and invalidates the certificate |
+| responder_url | string | The OCSP server URL embedded in the proxy certificate (you cannot manually set this parameter) |
+| response_timeout | integer <nobr>(range: 1-60)</nobr> <nobr>(default: 1)</nobr> | The time interval in seconds to wait for a response before timing out |
+
+### Returns
+
+If you run the `ocsp config` command without the `set` option, it displays the specified parameter's current configuration.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp config recovery_frequency
+Recovery frequency of the OCSP server is 60 seconds
+$ rladmin cluster ocsp config recovery_frequency set 30
+$ rladmin cluster ocsp config recovery_frequency
+Recovery frequency of the OCSP server is 30 seconds
+```
+
+## `ocsp status`
+
+Returns the latest cached status of the certificate's OCSP response.
+
+```sh
+rladmin cluster ocsp status
+```
+### Parameters
+
+None
+
+### Returns
+
+Returns the latest cached status of the certificate's OCSP response.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp status
+OCSP certificate status is: REVOKED
+produced_at: Wed, 22 Dec 2021 12:50:11 GMT
+responder_url: http://responder.ocsp.url.com
+revocation_time: Wed, 22 Dec 2021 12:50:04 GMT
+this_update: Wed, 22 Dec 2021 12:50:11 GMT
+```
+
+## `ocsp test_certificate`
+
+Queries the OCSP server for the certificate's latest status, then caches and displays the response.
+
+```sh
+rladmin cluster ocsp test_certificate
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the latest status of the certificate's OCSP response.
+
+### Example
+
+```sh
+$ rladmin cluster ocsp test_certificate
+Initiating a query to OCSP server
+...OCSP certificate status is: REVOKED
+produced_at: Wed, 22 Dec 2021 12:50:11 GMT
+responder_url: http://responder.ocsp.url.com
+revocation_time: Wed, 22 Dec 2021 12:50:04 GMT
+this_update: Wed, 22 Dec 2021 12:50:11 GMT
+```
+---
+Title: rladmin cluster certificate
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets the cluster certificate.
+headerRange: '[1-2]'
+linkTitle: certificate
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Sets a cluster certificate to a specified PEM file.
+
+```sh
+rladmin cluster certificate
+        set <certificate name>
+        certificate_file <certificate filepath>
+        [ key_file <key filepath> ]
+```
+
+To set a certificate for a specific service, use the corresponding certificate name. See the [certificates table]({{< relref "/operate/rs/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| certificate name | 'cm'<br /> 'api'<br /> 'proxy'<br /> 'syncer'<br /> 'metrics_exporter' | Name of the certificate to update |
+| certificate_file | filepath | Path to the certificate file |
+| key_file | filepath | Path to the key file (optional) |
+
+### Returns
+
+Reports that the certificate was set to the specified file. Returns an error message if the certificate fails to update.
+
+### Example
+
+```sh
+$ rladmin cluster certificate set proxy \
+       certificate_file /tmp/proxy.pem
+Set proxy certificate to contents of file /tmp/proxy.pem
+```
+---
+Title: rladmin cluster create
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates a new cluster.
+headerRange: '[1-2]'
+linkTitle: create
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+---
+
+Creates a new cluster. The node where you run `rladmin cluster create` becomes the first node of the new cluster.
+
+```sh
+cluster create
+        name <cluster name>
+        username <admin email>
+        password <admin password>
+        [ node_uid <node UID> ] 
+        [ rack_aware ]
+        [ rack_id <node rack ID> ]
+        [ license_file <file> ]
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ register_dns_suffix ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP.address> ]
+        [ external_addr <IP.address.1> [<IP.address.2> ... <IP.address.N>] ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| addr | IP address | The node's internal IP address (optional) |
+| ccs_persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the location of CCS snapshots (optional) |
+| ephemeral_path | filepath (default:&nbsp;/var/opt/redislabs) | Path to the ephemeral storage location (optional) |
+| external_addr | list of IP addresses | A space-delimited list of the node's external IP addresses (optional) |
+| flash_enabled | | Enables flash storage (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location (optional) |
+| license_file | filepath | Path to the RLEC license file (optional) |
+| name | string | Cluster name |
+| node_uid | integer | Unique node ID (optional) |
+| password | string | Admin user's password |
+| persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the persistent storage location (optional) |
+| rack_aware | | Activates or deactivates rack awareness (optional) |
+| rack_id | string | The rack's unique identifier (optional) |
+| register_dns_suffix | | Enables database mapping to both internal and external IP addresses (optional) |
+| username | email address | Admin user's email address |
+
+### Returns
+
+Returns `ok` if the new cluster was created successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster create name cluster.local \
+        username admin@example.com \
+        password admin-password
+Creating a new cluster... ok
+```
+---
+Title: rladmin cluster running_actions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Lists all active tasks.
+headerRange: '[1-2]'
+linkTitle: running_actions
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Lists all active tasks running on the cluster.
+
+```sh
+rladmin cluster running_actions
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns details about any active tasks running on the cluster. 
+
+### Example
+
+```sh
+$ rladmin cluster running_actions
+Got 1 tasks:
+1) Task: maintenance_on (ce391d81-8d51-4ce2-8f63-729c7ac2589e) Node: 1 Status: running
+```---
+Title: rladmin cluster debug_info
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates a support package.
+headerRange: '[1-2]'
+linkTitle: debug_info
+tags:
+- configured
+toc: 'true'
+weight: $weight
+---
+
+Downloads a support package to the specified path. If you do not specify a path, it downloads the package to the default path specified in the cluster configuration file.
+
+```sh
+rladmin cluster debug_info
+        [ node <ID> ]
+        [ path <path> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node | integer | Downloads a support package for the specified node |
+| path | filepath | Specifies the location where the support package should download |
+
+### Returns
+
+Reports the progress of the support package download.
+
+### Example
+
+```sh
+$ rladmin cluster debug_info node 1
+Preparing the debug info files package
+Downloading...
+[==================================================]
+Downloading complete. File /tmp/debuginfo.20220511-215637.node-1.tar.gz is saved.
+```
+---
+Title: rladmin cluster join
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Adds a node to an existing cluster.
+headerRange: '[1-2]'
+linkTitle: join
+tags:
+- non-configured
+toc: 'true'
+weight: $weight
+---
+
+Adds a node to an existing cluster.
+
+```sh
+rladmin cluster join
+        nodes <node IP address>
+        username <admin user email>
+        password <admin password>
+        [ ephemeral_path <path> ]
+        [ persistent_path <path> ]
+        [ ccs_persistent_path <path> ]
+        [ rack_id <node rack ID> ]
+        [ override_rack_id ]
+        [ replace_node <node UID> ]
+        [ flash_enabled ]
+        [ flash_path <path> ]
+        [ addr <IP.address> ]
+        [ external_addr <IP.address.1> [<IP.address.2> ... <IP.address.N>] ]
+        [ override_repair ]
+        [ accept_servers { enabled | disabled } ]
+        [ cnm_http_port <port> ]
+```
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| accept_servers | 'enabled'<br />'disabled' | Allows allocation of resources on the new node when enabled (optional) |
+| addr | IP address | Sets a node's internal IP address. If not provided, the node sets the address automatically. (optional) |
+| ccs_persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the CCS snapshot location (the default is the same as persistent_path) (optional) |
+| cnm_http_port | integer | Joins a cluster that has a non-default cnm_http_port (optional) |
+| ephemeral_path | filepath | Path to the ephemeral storage location (optional) |
+| external_addr | list of IP addresses | Sets a node's external IP addresses (space-delimited list). If not provided, the node sets the address automatically. (optional) |
+| flash_enabled |  | Enables flash capabilities for a database (optional) |
+| flash_path | filepath (default:&nbsp;/var/opt/redislabs/flash) | Path to the flash storage location in case the node does not support CAPI (required if flash_enabled) |
+| nodes | IP address | Internal IP address of an existing node in the cluster |
+| override_rack_id |  | Changes to a new rack, specified by `rack_id` (optional) |
+| override_repair |  | Enables joining a cluster with a dead node (optional) |
+| password | string | Admin user's password |
+| persistent_path | filepath (default:&nbsp;/var/opt/redislabs/persist) | Path to the persistent storage location (optional) |
+| rack_id | string | Moves the node to the specified rack (optional) |
+| replace_node | integer | Replaces the specified node with the new node (optional) |
+| username | email address | Admin user's email address |
+
+### Returns
+
+Returns `ok` if the node joined the cluster successfully. Otherwise, it returns an error message.
+
+### Example
+
+```sh
+$ rladmin cluster join nodes 192.0.2.2 \
+        username admin@example.com \
+        password admin-password
+Joining cluster... ok
+```
+---
+Title: rladmin cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage cluster.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: cluster
+toc: 'true'
+weight: $weight
+---
+
+Manages cluster configuration and administration. Most `rladmin cluster` commands are only for clusters that are already configured, while a few others are only for new clusters that have not been configured.
+
+## Commands for configured clusters
+
+{{<table-children columnNames="Command,Description" columnSources="linkTitle,Description" enableLinks="linkTitle" limitTags="configured">}}
+
+## Commands for non-configured clusters
+
+{{<table-children columnNames="Command,Description" columnSources="linkTitle,Description" enableLinks="linkTitle" limitTags="non-configured">}}
+---
+Title: rladmin bind
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages the proxy policy for a specified database endpoint.
+headerRange: '[1-2]'
+linkTitle: bind
+toc: 'true'
+weight: $weight
+---
+
+Manages the proxy policy for a specific database endpoint.
+
+## `bind endpoint exclude`
+
+Defines a list of nodes to exclude from the proxy policy for a specific database endpoint. When you exclude a node, the endpoint cannot bind to the node's proxy.
+
+Each time you run an exclude command, it overwrites the previous list of excluded nodes.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id> exclude
+        <proxy_id1 .. proxy_idN>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| proxy     | list of proxy IDs          | Proxies to exclude                                                           |
+
+### Returns
+
+Returns `Finished successfully` if the list of excluded proxies was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                  NODE      ROLE                      SSL
+db:6     tr02   endpoint:6:1        node:2    all-nodes                 No
+db:6     tr02   endpoint:6:1        node:1    all-nodes                 No
+db:6     tr02   endpoint:6:1        node:3    all-nodes                 No
+$ rladmin bind endpoint 6:1 exclude 2
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:1    all-nodes -2               No
+db:6     tr02   endpoint:6:1       node:3    all-nodes -2               No
+```
+
+## `bind endpoint include`
+
+Defines a list of nodes to include in the proxy policy for the specific database endpoint.
+
+Each time you run an include command, it overwrites the previous list of included nodes.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id> include
+        <proxy_id1 .. proxy_idN>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| proxy     | list of proxy IDs          | Proxies to include                                                           |
+
+### Returns
+
+Returns `Finished successfully` if the list of included proxies was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No
+$ rladmin bind endpoint 6:1 include 3
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID   NAME   ID                NODE      ROLE                          SSL
+db:6    tr02   endpoint:6:1      node:1    all-master-shards +3          No
+db:6    tr02   endpoint:6:1      node:3    all-master-shards +3          No
+```
+
+## `bind endpoint policy`
+
+Changes the overall proxy policy for a specific database endpoint.
+
+```sh
+rladmin bind
+        [ db { db:<id> | <name> } ]
+        endpoint <id>
+        policy { single | all-master-shards | all-nodes }
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Only allows endpoints for the specified database                                               |
+| endpoint  | endpoint ID                    | Changes proxy settings for the specified endpoint                              |
+| policy    | <nobr>'all-master-shards'</nobr><br /> <nobr>'all-nodes'</nobr><br /> 'single' | Changes the [proxy policy](#proxy-policies) to the specified policy |
+
+| Proxy&nbsp;policy<a name="proxy-policies"> | Description |
+| - | - |
+| all-master-shards | Multiple proxies, one on each master node (best for high traffic and multiple master shards)                     |
+| all-nodes | Multiple proxies, one on each node of the cluster (increases traffic in the cluster, only used in special cases) |
+| single | All traffic flows through a single proxy bound to the database endpoint (preferable in most cases)               |
+
+### Returns
+
+Returns `Finished successfully` if the proxy policy was successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the policy changed.
+
+### Example
+
+``` sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:1    all-nodes -2               No
+db:6     tr02   endpoint:6:1       node:3    all-nodes -2               No
+$ rladmin bind endpoint 6:1 policy all-master-shards
+Executing bind endpoint: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No
+```
+---
+Title: rladmin restart
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Restarts Redis Enterprise Software processes for a specific database.
+headerRange: '[1-2]'
+linkTitle: restart
+toc: 'true'
+weight: $weight
+---
+
+Schedules a restart of the Redis Enterprise Software processes on primary and replica instances of a specific database.
+
+``` sh
+rladmin restart db { db:<id> | <name> }
+        [preserve_roles]
+        [discard_data]
+        [force_discard]
+```
+
+### Parameters
+
+| Parameter      | Type/Value                     | Description                                                           |
+|----------------|--------------------------------|-----------------------------------------------------------------------|
+| db             | db:\<id\><br /> name           | Restarts Redis Enterprise Software processes for the specified database                |
+| discard_data   |                                | Allows discarding data if there is no persistence or replication      |
+| force_discard  |                                | Forcibly discards data even if there is persistence or replication    |
+| preserve_roles |                                | Performs an additional failover to maintain shard roles               |
+
+### Returns
+
+Returns `Done` if the restart completed successfully. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin restart db db:5 preserve_roles
+Monitoring 1db07491-35da-4bb6-9bc1-56949f4c312a
+active - SMUpgradeBDB init
+active - SMUpgradeBDB stop_forwarding
+active - SMUpgradeBDB stop_active_expire
+active - SMUpgradeBDB check_slave
+oactive - SMUpgradeBDB stop_active_expire
+active - SMUpgradeBDB second_failover
+completed - SMUpgradeBDB
+Done
+```
+---
+Title: rladmin migrate
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Moves Redis Enterprise Software shards or endpoints to a new node in
+  the same cluster.
+headerRange: '[1-2]'
+linkTitle: migrate
+toc: 'true'
+weight: $weight
+---
+
+Moves Redis Enterprise shards or endpoints to a new node in the same cluster.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/databases/migrate-shards">}}).
+
+## `migrate all_master_shards`
+
+Moves all primary shards of a specified database or node to a new node in the same cluster.
+
+```sh
+rladmin migrate { db { db:<id> | <name> } | node <origin node ID> }
+        all_master_shards
+        target_node <id>
+        [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:6 sort ROLE
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:6   tr02       redis:14   node:3  master  0-4095        3.01MB        OK     
+db:6   tr02       redis:16   node:3  master  4096-8191     3.2MB         OK     
+db:6   tr02       redis:18   node:3  master  8192-12287    3.2MB         OK     
+db:6   tr02       redis:20   node:3  master  12288-16383   3.01MB        OK
+$ rladmin migrate db db:6 all_master_shards target_node 1
+Monitoring 8b0f28e2-4342-427a-a8e3-a68cba653ffe
+queued - migrate_shards
+running - migrate_shards
+Executing migrate_redis with shards_uids ['18', '14', '20', '16']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards node 1
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:6   tr02       redis:14   node:1  master  0-4095        3.22MB        OK     
+db:6   tr02       redis:16   node:1  master  4096-8191     3.22MB        OK     
+db:6   tr02       redis:18   node:1  master  8192-12287    3.22MB        OK     
+db:6   tr02       redis:20   node:1  master  12288-16383   2.99MB        OK  
+```
+## `migrate all_shards`
+
+Moves all shards on a specified node to a new node in the same cluster.
+
+``` sh
+rladmin migrate node <origin node ID>
+            [ max_concurrent_bdb_migrations <value> ]
+            all_shards
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| max_concurrent_bdb_migrations | integer                | Sets the maximum number of concurrent endpoint migrations                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards node 1
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:5   tr01       redis:12   node:1  master  0-16383       3.04MB        OK
+db:6   tr02       redis:15   node:1  slave   0-4095        2.93MB        OK
+db:6   tr02       redis:17   node:1  slave   4096-8191     2.93MB        OK
+db:6   tr02       redis:19   node:1  slave   8192-12287    3.08MB        OK
+db:6   tr02       redis:21   node:1  slave   12288-16383   3.08MB        OK
+$ rladmin migrate node 1 all_shards target_node 2
+Monitoring 71a4f371-9264-4398-a454-ce3ff4858c09
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['21', '15', '17', '19']
+OExecuting migrate_redis with shards_uids ['12']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards node 2
+SHARDS:
+DB:ID  NAME       ID         NODE    ROLE    SLOTS         USED_MEMORY   STATUS
+db:5   tr01       redis:12   node:2  master  0-16383       3.14MB        OK
+db:6   tr02       redis:15   node:2  slave   0-4095        2.96MB        OK
+db:6   tr02       redis:17   node:2  slave   4096-8191     2.96MB        OK
+db:6   tr02       redis:19   node:2  slave   8192-12287    2.96MB        OK
+db:6   tr02       redis:21   node:2  slave   12288-16383   2.96MB        OK
+```
+
+## `migrate all_slave_shards`
+
+Moves all replica shards of a specified database or node to a new node in the same cluster.
+
+```sh
+rladmin migrate { db { db:<id> | <name> } | node <origin node ID> }
+            all_slave_shards
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| node                          | integer                | Limits migration to a specific origin node                                        |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:6 node 2
+SHARDS:
+DB:ID  NAME      ID         NODE    ROLE   SLOTS          USED_MEMORY    STATUS
+db:6   tr02      redis:15   node:2  slave  0-4095         3.06MB         OK
+db:6   tr02      redis:17   node:2  slave  4096-8191      3.06MB         OK
+db:6   tr02      redis:19   node:2  slave  8192-12287     3.06MB         OK
+db:6   tr02      redis:21   node:2  slave  12288-16383    3.06MB         OK
+$ rladmin migrate db db:6 all_slave_shards target_node 3
+Monitoring 5d36a98c-3dc8-435f-8ed9-35809ba017a4
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['15', '17', '21', '19']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards db db:6 node 3
+SHARDS:
+DB:ID  NAME      ID         NODE    ROLE   SLOTS          USED_MEMORY    STATUS
+db:6   tr02      redis:15   node:3  slave  0-4095         3.04MB         OK
+db:6   tr02      redis:17   node:3  slave  4096-8191      3.04MB         OK
+db:6   tr02      redis:19   node:3  slave  8192-12287     3.04MB         OK
+db:6   tr02      redis:21   node:3  slave  12288-16383    3.04MB         OK
+```
+
+## `migrate endpoint_to_shards`
+
+Moves database endpoints to the node where the majority of primary shards are located.
+
+```sh
+rladmin migrate [ db { db:<id> | <name> } ]
+            endpoint_to_shards
+            [ restrict_target_node <id> ]
+            [ commit ]
+            [ max_concurrent_bdb_migrations <value> ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| db                            | db:\<id\><br /> name   | Limits migration to a specific database                                           |
+| restrict_target_node          | integer | Moves the endpoint only if the target node matches the specified node |
+| commit                        |                        | Performs endpoint movement                                                      |
+| max_concurrent_bdb_migrations | integer                | Sets the maximum number of concurrent endpoint migrations                           |
+
+
+### Returns
+
+Returns a list of steps to perform the migration. If the `commit` flag is set, the steps will run and return `Finished successfully` if they were completed. Otherwise, returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the endpoints were moved.
+
+### Example
+
+```sh
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL     
+db:6     tr02   endpoint:6:1       node:3    all-master-shards          No      
+$ rladmin migrate db db:6 endpoint_to_shards
+* Going to bind endpoint:6:1 to node 1
+Dry-run completed, add 'commit' argument to execute
+$ rladmin migrate db db:6 endpoint_to_shards commit
+* Going to bind endpoint:6:1 to node 1
+Executing bind endpoint:6:1: OOO.
+Finished successfully
+$ rladmin status endpoints db db:6
+ENDPOINTS:
+DB:ID    NAME   ID                 NODE      ROLE                       SSL     
+db:6     tr02   endpoint:6:1       node:1    all-master-shards          No      
+```
+
+## `migrate shard`
+
+Moves one or more shards to a new node in the same cluster.
+
+```sh
+rladmin migrate shard <id1.. idN>
+            [ preserve_roles ]
+            target_node <id>
+            [ override_policy ]
+```
+
+### Parameters
+
+| Parameter                     | Type/Value             | Description                                                                     |
+|-------------------------------|------------------------|---------------------------------------------------------------------------------|
+| shard                         | list of shard IDs      | Shards to migrate                                                               |
+| preserve_roles                |                        | Performs an additional failover to guarantee the primary shards' roles are preserved |
+| target_node                   | integer                | Migration target node                                                           |
+| override_policy               |                        | Overrides the rack aware policy and allows primary and replica shards on the same node |
+
+### Returns
+
+Returns `Done` if the migration completed successfully. Otherwise, returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify the migration completed.
+
+### Example
+
+```sh
+$ rladmin status shards db db:5
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:2   master   0-16383   3.01MB         OK
+db:5   tr01        redis:13   node:3   slave    0-16383   3.1MB          OK
+$ rladmin migrate shard 13 target_node 1
+Monitoring d2637eea-9504-4e94-a70c-76df087efcb2
+queued - migrate_shards
+.running - migrate_shards
+Executing migrate_redis with shards_uids ['13']
+Ocompleted - migrate_shards
+Done
+$ rladmin status shards db db:5
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:2   master   0-16383   3.01MB         OK
+db:5   tr01        redis:13   node:1   slave    0-16383   3.04MB         OK
+```
+---
+Title: rladmin recover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Recovers databases in recovery mode.
+headerRange: '[1-2]'
+linkTitle: recover
+toc: 'true'
+weight: $weight
+---
+
+Recovers databases in recovery mode after events such as cluster failure, and restores the databases' configurations and data from stored persistence files. See [Recover a failed database]({{< relref "/operate/rs/databases/recover" >}}) for detailed instructions.
+
+Database persistence files are stored in `/var/opt/redislabs/persist/redis/` by default, but you can specify a different directory to use for database recovery with [`rladmin node <id> recovery_path set <path>`]({{< relref "/operate/rs/references/cli-utilities/rladmin/node/recovery-path" >}}).
+
+## `recover all`
+
+Recovers all databases in recovery mode.
+
+```sh
+rladmin recover all
+        [ only_configuration ]
+```
+
+### Parameters
+
+| Parameters         | Type/Value | Description                                 |
+|--------------------|------------|---------------------------------------------|
+| only_configuration |            | Recover database configuration without data |
+
+### Returns
+
+Returns `Completed successfully` if the database was recovered. Otherwise, returns an error.
+
+### Example
+
+```
+$ rladmin recover all
+  0% [ 0 recovered | 0 failed ] |         | Elapsed Time: 0:00:00[first-db (db:1) recovery] Initiated.[second-db (db:2) recovery] Initiated.
+ 50% [ 0 recovered | 0 failed ] |###      | Elapsed Time: 0:00:04[first-db (db:1) recovery] Completed successfully
+ 75% [ 1 recovered | 0 failed ] |######   | Elapsed Time: 0:00:06[second-db (db:2) recovery] Completed successfully
+100% [ 2 recovered | 0 failed ] |#########| Elapsed Time: 0:00:08
+```
+
+## `recover db`
+
+Recovers a specific database in recovery mode.
+
+```sh
+rladmin recover db { db:<id> | <name> }
+        [ only_configuration ]
+```
+
+### Parameters
+
+| Parameters         | Type/Value           | Description                                 |
+|--------------------|----------------------|---------------------------------------------|
+| db                 | db:\<id\> <br />name | Database to recover                         |
+| only_configuration |                      | Recover database configuration without data |
+
+### Returns
+
+Returns `Completed successfully` if the database was recovered. Otherwise, returns an error.
+
+### Example
+
+```
+$ rladmin recover db db:1
+  0% [ 0 recovered | 0 failed ] |      | Elapsed Time: 0:00:00[demo-db (db:1) recovery] Initiated.
+ 50% [ 0 recovered | 0 failed ] |###   | Elapsed Time: 0:00:00[demo-db (db:1) recovery] Completed successfully
+100% [ 1 recovered | 0 failed ] |######| Elapsed Time: 0:00:02
+```
+
+## `recover list`
+
+Shows a list of all databases that are currently in recovery mode.
+
+```sh
+rladmin recover list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Displays a list of all recoverable databases. If no databases are in recovery mode, returns `No recoverable databases found`.
+
+### Example
+
+```sh
+$ rladmin recover list
+DATABASES IN RECOVERY STATE:
+DB:ID  NAME  TYPE   SHARDS  REPLICATION  PERSISTENCE  STATUS
+db:5   tr01  redis  1       enabled      aof          missing-files
+db:6   tr02  redis  4       enabled      snapshot     ready
+```
+
+## `recover s3_import`
+
+Imports current database snapshot files from an AWS S3 bucket to a directory on the node.
+
+```sh
+rladmin recover s3_import
+                s3_bucket <bucket name>
+                [ s3_prefix <prefix> ]
+                s3_access_key_id <access key>
+                s3_secret_access_key <secret access key>
+                import_path <path>
+```
+
+### Parameters
+
+| Parameters           | Type/Value | Description                                                      |
+|----------------------|------------|------------------------------------------------------------------|
+| s3_bucket            | string     | S3 bucket name                                                   |
+| s3_prefix            | string     | S3 object prefix                                                 |
+| s3_access_key_id     | string     | S3 access key ID                                                 |
+| s3_secret_access_key | string     | S3 secret access key                                             |
+| import_path           | filepath   | Local import path where all database snapshots will be imported  |
+
+### Returns
+
+Returns `Completed successfully` if the database files were imported. Otherwise, returns an error.
+
+### Example
+
+```sh
+rladmin recover s3_import s3_bucket <bucket-name> s3_prefix <s3-prefix>/ s3_access_key_id <access-key> s3_secret_access_key <secret-access-key> import_path /tmp
+```
+---
+Title: rladmin status
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Displays the current cluster status and topology information.
+headerRange: '[1-2]'
+linkTitle: status
+toc: 'true'
+weight: $weight
+---
+
+Displays the current cluster status and topology information.
+
+## `status`
+
+Displays the current status of all nodes, databases, database endpoints, and shards on the cluster.
+
+``` sh
+rladmin status
+        [ extra <parameter> ]
+        [ issues_only]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| issues_only | Filters out all items that have an `OK` status  |
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all databases in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns
+
+Returns tables of the status of all nodes, databases, and database endpoints on the cluster.
+
+If `issues_only` is specified, it only shows instances that do not have an `OK` status.
+
+In the `CLUSTER NODES` section, `*node` indicates which node you are connected to.
+
+For descriptions of the fields returned by `rladmin status extra all`, see the output tables for [nodes](#returns-nodes), [databases](#returns-dbs), [endpoints](#returns-endpoints), and [shards](#returns-shards).
+
+### Example
+
+``` sh
+$ rladmin status extra all
+CLUSTER:
+OK. Cluster master: 1 (198.51.100.2)
+Cluster health: OK, [1, 0.13333333333333333, 0.03333333333333333]
+failures/minute - avg1 1.00, avg15 0.13, avg60 0.03.
+
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS      EXTERNAL_ADDRESS HOSTNAME     MASTERS SLAVES OVERBOOKING_DEPTH SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   SHA    RACK-ID STATUS
+node:1  master 198.51.100.2                  3d99db1fdf4b 4       0      10.91GB           4/100  6     14.91GB/19.54GB 10.91GB/16.02GB 6.2.12-37 5c2106 -       OK    
+node:2  slave  198.51.100.3                  fc7a3d332458 0       0      11.4GB            0/100  6     14.91GB/19.54GB 11.4GB/16.02GB  6.2.12-37 5c2106 -       OK    
+*node:3 slave  198.51.100.4                  b87cc06c830f 0       0      11.4GB            0/100  6     14.91GB/19.54GB 11.4GB/16.02GB  6.2.12-37 5c2106 -       OK    
+
+DATABASES:
+DB:ID NAME      TYPE  STATUS SHARDS PLACEMENT REPLICATION PERSISTENCE ENDPOINT                        EXEC_STATE EXEC_STATE_MACHINE BACKUP_PROGRESS MISSING_BACKUP_TIME REDIS_VERSION
+db:3  database3 redis active 4      dense     disabled    disabled    redis-11103.cluster.local:11103 N/A        N/A                N/A             N/A                 6.0.16       
+
+ENDPOINTS:
+DB:ID     NAME             ID                    NODE       ROLE       SSL        WATCHDOG_STATUS          
+db:3      database3        endpoint:3:1          node:1     single     No         OK                       
+
+SHARDS:
+DB:ID NAME      ID      NODE   ROLE   SLOTS       USED_MEMORY BACKUP_PROGRESS RAM_FRAG WATCHDOG_STATUS STATUS
+db:3  database3 redis:4 node:1 master 0-4095      2.08MB      N/A             4.73MB   OK              OK    
+db:3  database3 redis:5 node:1 master 4096-8191   2.08MB      N/A             4.62MB   OK              OK    
+db:3  database3 redis:6 node:1 master 8192-12287  2.08MB      N/A             4.59MB   OK              OK    
+db:3  database3 redis:7 node:1 master 12288-16383 2.08MB      N/A             4.66MB   OK              OK
+```
+
+## `status databases`
+
+Displays the current status of all databases on the cluster.
+
+``` sh
+rladmin status databases
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all databases in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns {#returns-dbs}
+
+Returns a table of the status of all databases on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows databases that do not have an `OK` status.
+
+The following table describes the fields returned by `rladmin status databases extra all`:
+
+| Field | Description |
+|-------|-------------|
+| DB:ID | Database ID |
+| NAME | Database name |
+| TYPE | Database type: Redis or Memcached |
+| STATUS | Database status |
+| SHARDS | The number of primary shards in the database |
+| PLACEMENT | How the shards are spread across nodes in the cluster, densely or sparsely |
+| REPLICATION | Is replication enabled for the database |
+| PERSISTENCE | Is persistence enabled for the database |
+| ENDPOINT | Database endpoint |
+| EXEC_STATE |  The current state of the state machine |
+| EXEC_STATE_MACHINE | The name of the running state machine |
+| BACKUP_PROGRESS | The database’s backup progress |
+| MISSING_BACKUP_TIME | How long ago a backup was done |
+| REDIS_VERSION | The database’s Redis version |
+
+### Example
+
+``` sh
+$ rladmin status databases sort REPLICATION PERSISTENCE
+DB:ID NAME      TYPE  STATUS SHARDS PLACEMENT REPLICATION PERSISTENCE ENDPOINT                                       
+db:1  database1 redis active 1      dense     disabled    disabled    redis-10269.testdbd11169.localhost:10269
+db:2  database2 redis active 1      dense     disabled    snapshot    redis-13897.testdbd11169.localhost:13897
+db:3  database3 redis active 1      dense     enabled     snapshot    redis-19416.testdbd13186.localhost:19416
+```
+
+## `status endpoints`
+
+Displays the current status of all endpoints on the cluster.
+
+``` sh
+rladmin status endpoints
+        [ node <id> ]
+        [ db { db:<id> | <name> } ]
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| node \<id\> | Only show endpoints for the specified node ID |
+| db db:\<id\> | Only show endpoints for the specified database ID |
+| db \<name\> | Only show endpoints for the specified database name |
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all endpoints in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns {#returns-endpoints}
+
+Returns a table of the status of all endpoints on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows endpoints that do not have an `OK` status.
+
+The following table describes the fields returned by `rladmin status endpoints extra all`:
+
+| Field | Description |
+|-------|-------------|
+| DB:ID | Database ID |
+| NAME | Database name |
+| ID | Endpoint ID |
+| NODE | The node that hosts the endpoint |
+| ROLE | The proxy policy of the database: single, all-master-shards, or all-nodes |
+| SSL | Is SSL enabled |
+| WATCHDOG_STATUS | The shards related to the endpoint are monitored and healthy |
+
+### Example
+
+``` sh
+$ rladmin status endpoints
+DB:ID     NAME             ID                    NODE        ROLE        SSL    
+db:1      database1        endpoint:1:1          node:1      single      No     
+db:2      database2        endpoint:2:1          node:2      single      No     
+db:3      database3        endpoint:3:1          node:3      single      No
+```
+
+## `status modules`
+
+Displays the current status of modules installed on the cluster and modules used by databases. This information is not included in the combined status report returned by [`rladmin status`](#status).
+
+``` sh
+rladmin status modules
+        [ db { db:<id1> | <name1> } ... { db:<idN> | <nameN> } ]
+        [ extra { all | compatible_redis_version | min_redis_version | module_id } ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| db db:\<id\> | Provide a list of database IDs to show only modules used by the specified databases<br />(for example: `rladmin status modules db db:1 db:2`) |
+| db \<name\> | Provide a list of database names to show only modules used by the specified databases<br />(for example: `rladmin status modules db name1 name2`) |
+| extra all | Shows all extra information |
+| extra compatible_redis_version | Shows the compatible Redis database version for the module |
+| extra module_id | Shows module IDs |
+| extra&nbsp;min_redis_version | Shows the minimum compatible Redis database version for each module |
+
+### Returns
+
+Returns the status of modules installed on the cluster and modules used by databases.
+
+### Example
+
+```sh
+$ rladmin status modules extra all                
+CLUSTER MODULES:
+MODULE           VERSION   MIN_REDIS_VERSION  ID                                
+RedisBloom       2.4.5     6.0                1b895a180592cbcae5bd3bff6af24be2  
+RedisBloom       2.6.8     7.1                95264e7c9ac9540268c115c86a94659b  
+RediSearch 2     2.6.12    6.0                2c000539f65272f7a2712ed3662c2b6b  
+RediSearch 2     2.8.9     7.1                dd9a75710db528afa691767e9310ac6f  
+RedisGears       2.0.15    7.1                18c83d024b8ee22e7caf030862026ca6  
+RedisGraph       2.10.12   6.0                5a1f2fdedb8f6ca18f81371ea8d28f68  
+RedisJSON        2.4.7     6.0                28308b101a0203c21fa460e7eeb9344a  
+RedisJSON        2.6.8     7.1                b631b6a863edde1b53b2f7a27a49c004  
+RedisTimeSeries  1.8.11    6.0                8fe09b00f56afe5dba160d234a6606af  
+RedisTimeSeries  1.10.9    7.1                98a492a017ea6669a162fd3503bf31f3  
+
+DATABASE MODULES:
+DB:ID      NAME             MODULE            VERSION  ARGS              STATUS 
+db:1       search-json-db   RediSearch 2      2.8.9    PARTITIONS AUTO   OK     
+db:1       search-json-db   RedisJSON         2.6.8                      OK     
+db:2       timeseries-db    RedisTimeSeries   1.10.9                     OK      
+```
+
+## `status nodes`
+
+Displays the current status of all nodes on the cluster.
+
+``` sh
+rladmin status nodes
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra nodestats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all nodes in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns {#returns-nodes}
+
+Returns a table of the status of all nodes on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows nodes that do not have an `OK` status.
+
+`*node` indicates which node you are connected to.
+
+The following table describes the fields returned by `rladmin status nodes extra all`:
+
+| Field | Description |
+|-------|-------------|
+| NODE:ID | Node ID |
+| ROLE | Is the node a primary (`master`) or secondary (`slave`) node |
+| ADDRESS | The node’s internal IP address |
+| EXTERNAL ADDRESS | The node’s external IP address |
+| HOSTNAME | Node name |
+| MASTERS | The number of primary shards on the node |
+| SLAVES | The number of replica shards on the node |
+| OVERBOOKING_DEPTH | Memory available to create new shards, accounting for the memory reserved for existing shards to grow, even if `shards_overbooking` is enabled. A negative value indicates how much memory is overbooked rather than just showing that no memory is available for new shards. |
+| SHARDS | The number of shards on the node |
+| CORES | The number of cores on the node |
+| FREE_RAM | free_memory/total_memory<br />**free_memory**: the amount of free memory reported by the OS.<br />**total_memory**: the total physical memory available on the node. |
+| PROVISIONAL_RAM | Memory available to create new shards, displayed as available_provisional_memory/total_provisional_memory.<br />**available_provisional_memory**: memory currently available for the creation of new shards.<br />**total_provisional_memory**: memory that would be available to create new shards if the used memory on the node was 0.<br />If the available provisional memory is 0, the node cannot create new shards because the node has reached its shard limit, is in maintenance mode, or is a quorum-only node. |
+| FLASH | The amount of flash memory available on the node, similar to `FREE_RAM` |
+| AVAILABLE_FLASH | Flash memory available to create new shards, similar to `PROVISIONAL_RAM` |
+| VERSION | The cluster version installed on the node |
+| SHA | The node’s SHA hash |
+| RACK-ID | The node’s rack ID |
+| STATUS | The node’s status |
+
+### Example
+
+``` sh
+$ rladmin status nodes sort PROVISIONAL_RAM HOSTNAME
+CLUSTER NODES:
+NODE:ID     ROLE       ADDRESS          EXTERNAL_ADDRESS          HOSTNAME            SHARDS     CORES          FREE_RAM                 PROVISIONAL_RAM          VERSION        STATUS   
+node:1      master     198.51.100.2                                 3d99db1fdf4b        4/100      6              14.74GB/19.54GB          10.73GB/16.02GB          6.2.12-37      OK       
+*node:3     slave      198.51.100.4                                 b87cc06c830f        0/100      6              14.74GB/19.54GB          11.22GB/16.02GB          6.2.12-37      OK       
+node:2      slave      198.51.100.3                                 fc7a3d332458        0/100      6              14.74GB/19.54GB          11.22GB/16.02GB          6.2.12-37      OK       
+```
+
+## `status shards`
+
+Displays the current status of all shards on the cluster.
+
+``` sh
+rladmin status shards
+        [ node <id> ]
+        [ db {db:<id> | <name>} ]
+        [ extra <parameters> ]
+        [ sort <column_titles> ]
+        [ issues_only ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| node \<id\> | Only show shards for the specified node ID |
+| db db:\<id\> | Only show shards for the specified database ID |
+| db \<name\> | Only show shards for the specified database name |
+| extra \<parameter\> | Extra options that show more information |
+| sort \<column_titles\> | Sort results by specified column titles |
+| issues_only | Filters out all items that have an `OK` status  |
+
+
+| Extra parameter | Description |
+|-------------------|-------------|
+| extra all | Shows all `extra` information |
+| extra backups | Shows periodic backup status |
+| extra frag | Shows fragmented memory available after the restart |
+| extra shardstats | Shows shards per node |
+| extra rack_id | Shows `rack_id` if customer is not `rack_aware` |
+| extra redis_version | Shows Redis version of all shards in the cluster |
+| extra state_machine | Shows execution of state machine information  |
+| extra watchdog | Shows watchdog status  |
+
+### Returns {#returns-shards}
+
+Returns a table of the status of all shards on the cluster.
+
+If `sort <column_titles>` is specified, the result is sorted by the specified table columns.
+
+If `issues_only` is specified, it only shows shards that do not have an `OK` status.
+
+The following table describes the fields returned by `rladmin status shards extra all`:
+
+| Field | Description |
+|-------|-------------|
+| DB:ID | Database ID |
+| NAME | Database name |
+| ID | Shard ID |
+| NODE | The node on which the shard resides |
+| ROLE | The shard’s role: primary (`master`) or replica (`slave`) |
+| SLOTS | Redis keys slot range of the shard |
+| USED_MEMORY | Memory used by the shard |
+| BACKUP_PROGRESS | The shard’s backup progress |
+| RAM_FRAG | The shard’s RAM fragmentation caused by deleted data or expired keys. A large value can indicate inefficient memory allocation. |
+| FLASH_FRAG | For Auto Tiering databases, the shard’s flash fragmentation |
+| WATCHDOG_STATUS | The shard is being monitored by the node watchdog and the shard is healthy |
+| STATUS | The shard’s status |
+
+### Example
+
+``` sh
+$ rladmin status shards sort USED_MEMORY ID
+SHARDS:
+DB:ID               NAME                       ID                   NODE               ROLE               SLOTS                           USED_MEMORY                     STATUS          
+db:3                database3                  redis:6              node:1             master             8192-12287                      2.04MB                          OK              
+db:3                database3                  redis:4              node:1             master             0-4095                          2.08MB                          OK              
+db:3                database3                  redis:5              node:1             master             4096-8191                       2.08MB                          OK              
+db:3                database3                  redis:7              node:1             master             12288-16383                     2.08MB                          OK              
+```
+---
+Title: rladmin verify
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prints verification reports for the cluster.
+headerRange: '[1-2]'
+linkTitle: verify
+toc: 'true'
+weight: $weight
+---
+
+Prints verification reports for the cluster.
+
+## `verify balance`
+
+Prints a balance report that displays all of the unbalanced endpoints or nodes in the cluster.
+
+```sh
+rladmin verify balance [ node <ID> ]
+```
+
+The [proxy policy]({{< relref "/operate/rs/databases/configure/proxy-policy#proxy-policies" >}}) determines which nodes or endpoints to report as unbalanced.
+
+A node is unbalanced if:
+- `all-nodes` proxy policy and the node has no endpoint
+
+An endpoint is unbalanced in the following cases:
+- `single` proxy policy and one of the following is true:  
+    - Shard placement is [`sparse`]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy.md#sparse-shard-placement-policy" >}}) and none of the master shards are on the node
+    - Shard placement is [`dense`]({{< relref "/operate/rs/databases/memory-performance/shard-placement-policy.md#dense-shard-placement-policy" >}}) and some master shards are on a different node from the endpoint
+- `all-master-shards` proxy policy and one of the following is true:  
+    - None of the master shards are on the node
+    - Some master shards are on a different node from the endpoint
+
+### Parameters
+
+| Parameter | Type/Value | Description |
+|-----------|------------|-------------|
+| node | integer | Specify a node ID to return a balance table for that node only (optional) |
+
+### Returns
+
+Returns a table of unbalanced endpoints and nodes in the cluster.
+
+### Examples
+
+Verify all nodes:
+
+```sh
+$ rladmin verify balance       
+The table presents all of the unbalanced endpoints/nodes in the cluster
+BALANCE:
+NODE:ID  DB:ID  NAME  ENDPOINT:ID  PROXY_POLICY  LOCAL SHARDS   TOTAL SHARDS
+```
+
+Verify a specific node:
+
+```sh
+$ rladmin verify balance node 1
+The table presents all of the unbalanced endpoints/nodes in the cluster
+BALANCE:
+NODE:ID  DB:ID  NAME  ENDPOINT:ID  PROXY_POLICY  LOCAL SHARDS   TOTAL SHARDS
+```
+
+## `verify rack_aware`
+
+Verifies that the cluster complies with the rack awareness policy and reports any discovered rack collisions, if [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}}) is enabled.
+
+```sh
+rladmin verify rack_aware
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns whether the cluster is rack aware. If rack awareness is enabled, it returns any rack collisions.
+
+### Example
+
+```sh
+$ rladmin verify rack_aware
+
+Cluster policy is not configured for rack awareness.
+```
+---
+Title: rladmin placement
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures the shard placement policy for a database.
+headerRange: '[1-2]'
+linkTitle: placement
+toc: 'true'
+weight: $weight
+---
+
+Configures the shard placement policy for a specified database.
+
+``` sh
+rladmin placement
+        db { db:<id> | <name> }
+        { dense | sparse }
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Configures shard placement for the specified database                                         |
+| dense     |                                | Places new shards on the same node as long as it has resources                                |
+| sparse    |                                | Places new shards on the maximum number of available nodes within the cluster                 |
+
+### Returns
+
+Returns the new shard placement policy if the policy was changed successfully. Otherwise, it returns an error.
+
+Use [`rladmin status databases`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-databases" >}}) to verify that the failover completed.
+
+### Example
+
+``` sh
+$ rladmin status databases
+DATABASES:
+DB:ID  NAME       TYPE   STATUS   SHARDS   PLACEMENT    REPLICATION    PERSISTENCE    ENDPOINT                                
+db:5   tr01       redis  active   1        dense        enabled        aof            redis-12000.cluster.local:12000         
+$ rladmin placement db db:5 sparse
+Shards placement policy is now sparse
+$ rladmin status databases
+DATABASES:
+DB:ID  NAME       TYPE   STATUS   SHARDS   PLACEMENT    REPLICATION    PERSISTENCE    ENDPOINT                                
+db:5   tr01       redis  active   1        sparse       enabled        aof            redis-12000.cluster.local:12000         
+```
+---
+Title: rladmin info
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the current configuration of a cluster, database, node, or proxy.
+headerRange: '[1-2]'
+linkTitle: info
+toc: 'true'
+weight: $weight
+---
+
+Shows the current configuration of specified databases, proxies, clusters, or nodes.
+
+## `info cluster`
+
+Lists the current configuration for the cluster.
+
+```sh
+rladmin info cluster
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns the current configuration for the cluster.
+
+### Example
+
+``` sh
+$ rladmin info cluster
+Cluster configuration:
+    repl_diskless: enabled
+    shards_overbooking: disabled
+    default_non_sharded_proxy_policy: single
+    default_sharded_proxy_policy: single
+    default_shards_placement: dense
+    default_fork_evict_ram: enabled
+    default_provisioned_redis_version: 6.0
+    redis_migrate_node_threshold: 0KB (0 bytes)
+    redis_migrate_node_threshold_percent: 4 (%)
+    redis_provision_node_threshold: 0KB (0 bytes)
+    redis_provision_node_threshold_percent: 12 (%)
+    max_simultaneous_backups: 4
+    slave_ha: enabled
+    slave_ha_grace_period: 600
+    slave_ha_cooldown_period: 3600
+    slave_ha_bdb_cooldown_period: 7200
+    parallel_shards_upgrade: 0
+    show_internals: disabled
+    expose_hostnames_for_all_suffixes: disabled
+    login_lockout_threshold: 5
+    login_lockout_duration: 1800
+    login_lockout_counter_reset_after: 900
+    default_concurrent_restore_actions: 10
+    endpoint_rebind_propagation_grace_time: 15
+    data_internode_encryption: disabled
+    redis_upgrade_policy: major
+    db_conns_auditing: disabled
+    watchdog profile: local-network
+    http support: enabled
+    upgrade mode: disabled
+    cm_session_timeout_minutes: 15
+    cm_port: 8443
+    cnm_http_port: 8080
+    cnm_https_port: 9443
+    bigstore_driver: speedb
+```
+
+## `info db`
+
+Shows the current configuration for databases.
+
+```sh
+rladmin info db [ {db:<id> | <name>} ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| db:id     | ID of the specified database (optional) |
+| name      | Name of the specified database (optional) |
+
+### Returns
+
+Returns the current configuration for all databases.
+
+If `db:<id>` or `<name>` is specified, returns the current configuration for the specified database.
+
+### Example
+
+``` sh
+$ rladmin info db db:1
+db:1 [database1]:
+    client_buffer_limits: 1GB (hard limit)/512MB (soft limit) in 30 seconds
+    slave_buffer: auto
+    pubsub_buffer_limits: 32MB (hard limit)/8MB (soft limit) in 60 seconds
+    proxy_client_buffer_limits: 0KB (hard limit)/0KB (soft limit) in 0 seconds
+    proxy_slave_buffer_limits: 1GB (hard limit)/512MB (soft limit) in 60 seconds
+    proxy_pubsub_buffer_limits: 32MB (hard limit)/8MB (soft limit) in 60 seconds
+    repl_backlog: 1.02MB (1073741 bytes)
+    repl_timeout: 360 seconds
+    repl_diskless: default
+    master_persistence: disabled
+    maxclients: 10000
+    conns: 5
+    conns_type: per-thread
+    sched_policy: cmp
+    max_aof_file_size: 300GB
+    max_aof_load_time: 3600 seconds
+    dedicated_replicaof_threads: 5
+    max_client_pipeline: 200
+    max_shard_pipeline: 2000
+    max_connections: 0
+    oss_cluster: disabled
+    oss_cluster_api_preferred_ip_type: internal
+    gradual_src_mode: disabled
+    gradual_src_max_sources: 1
+    gradual_sync_mode: auto
+    gradual_sync_max_shards_per_source: 1
+    slave_ha: disabled (database)
+    mkms: enabled
+    oss_sharding: disabled
+    mtls_allow_weak_hashing: disabled
+    mtls_allow_outdated_certs: disabled
+    data_internode_encryption: disabled
+    proxy_policy: single
+    db_conns_auditing: disabled
+    syncer_mode: centralized
+```
+
+## `info node`
+
+Lists the current configuration for all nodes.
+
+```sh
+rladmin info node [ <id> ]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| id     | ID of the specified node |
+
+### Returns
+
+Returns the current configuration for all nodes.
+
+If `<id>` is specified, returns the current configuration for the specified node.
+
+### Example
+
+``` sh
+$ rladmin info node 3
+Command Output: node:3
+    address: 198.51.100.17
+    external addresses: N/A
+    recovery path: N/A
+    quorum only: disabled
+    max redis servers: 100
+    max listeners: 100
+```
+
+## `info proxy`
+
+Lists the current configuration for a proxy.
+
+``` sh
+rladmin info proxy { <id> | all }
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| id      | ID of the specified proxy |
+| all       | Show the current configuration for all proxies (optional) |
+
+### Returns
+
+If no parameter is specified or the `all` option is specified, returns the current configuration for all proxies.
+
+If `<id>`is specified, returns the current configuration for the specified proxy.
+
+### Example
+
+``` sh
+$ rladmin info proxy
+proxy:1
+    mode: dynamic
+    scale_threshold: 80 (%)
+    scale_duration: 30 (seconds)
+    max_threads: 8
+    threads: 3
+```
+---
+Title: rladmin help
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows available commands or specific command usage.
+headerRange: '[1-2]'
+linkTitle: help
+toc: 'true'
+weight: $weight
+---
+
+Lists all options and parameters for `rladmin` commands.
+
+``` sh
+rladmin help [command]
+```
+
+### Parameters
+
+| Parameter | Description |
+|-----------|-------------|
+|  command   |  Display help for this `rladmin` command (optional)  |
+
+### Returns
+
+Returns a list of available `rladmin` commands.
+
+If a `command` is specified, returns a list of all the options and parameters for that `rladmin` command.
+
+### Example
+
+```sh
+$ rladmin help
+usage: rladmin [options] [command] [command args]
+
+Options:
+  -y  Assume Yes for all required user confirmations.
+
+Commands:
+  bind      Bind an endpoint
+  cluster   Cluster management commands
+  exit      Exit admin shell
+  failover  Fail-over master to slave
+  help      Show available commands, or use help <command> for a specific command
+  info      Show information about tunable parameters
+  migrate   Migrate elements between nodes
+  node      Node management commands
+  placement Configure shards placement policy
+  recover   Recover databases
+  restart   Restart database shards
+  status    Show status information
+  suffix    Suffix management
+  tune      Tune system parameters
+  upgrade   Upgrade entity version
+  verify    Cluster verification reports
+
+Use "rladmin help [command]" to get more information on a specific command.
+```
+---
+Title: rladmin suffix
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages the DNS suffixes in the cluster.
+headerRange: '[1-2]'
+linkTitle: suffix
+toc: 'true'
+weight: $weight
+---
+
+Manages the DNS suffixes in the cluster.
+
+## `suffix add`
+
+Adds a DNS suffix to the cluster.
+
+``` sh
+rladmin suffix add name <name>
+        [default]
+        [internal]
+        [mdns]
+        [use_aaaa_ns]
+        [slaves <ip>..]
+```
+
+### Parameters
+
+| Parameter | Type/Value       | Description                                                                                   |
+|-----------|------------------|-----------------------------------------------------------------------------------------------|
+| name      | string           | DNS suffix to add to the cluster                                                             |
+| default   |                  | Sets the given suffix as the default. If a default already exists, this overwrites it.  |
+| internal  |                  | Forces the given suffix to use private IPs                                                    |
+| mdns      |                  | Activates multicast DNS support for the given suffix                                           |
+| slaves    | list of IPv4 addresses | The given suffix will notify the frontend DNS servers when a change in the frontend DNS has occurred |
+| use_aaaa_ns |                | Activates IPv6 address support |
+
+### Returns
+
+Returns `Added suffixes successfully` if the suffix was added. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin suffix add name new.rediscluster.local
+Added suffixes successfully
+```
+
+## `suffix delete`
+
+Deletes an existing DNS suffix from the cluster.
+
+``` sh
+rladmin suffix delete name <name>
+```
+
+### Parameters
+
+| Parameter | Type/Value       | Description                                                                                   |
+|-----------|------------------|-----------------------------------------------------------------------------------------------|
+| name      | string           | DNS suffix to delete from the cluster                                                         |
+
+### Returns
+
+Returns `Suffix deleted successfully` if the suffix was deleted. Otherwise, it returns an error.
+
+### Example
+
+``` sh
+$ rladmin suffix delete name new.rediscluster.local
+Suffix deleted successfully
+```
+
+## `suffix list`
+
+Lists the DNS suffixes in the cluster.
+
+```sh
+rladmin suffix list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns a list of the DNS suffixes.
+
+### Example
+
+``` sh
+$ rladmin suffix list
+List of all suffixes:
+cluster.local
+new.rediscluster.local
+```
+---
+Title: rladmin failover
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Fail over primary shards of a database to their replicas.
+headerRange: '[1-2]'
+linkTitle: failover
+toc: 'true'
+weight: $weight
+---
+
+Fails over one or more primary (also known as master) shards of a database and promotes their respective replicas to primary shards.
+
+``` sh
+rladmin failover
+        [db { db:<id> | <name> }]
+        shard <id1 ... idN>
+        [immediate]
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| db        | db:\<id\><br /> name           | Fail over shards for the specified database                                                   |
+| shard     | one or more primary shard IDs  | Primary shard or shards to fail over                                                          |
+| immediate |                                | Perform failover without verifying the replica shards are in full sync with the master shards |
+
+### Returns
+
+Returns `Finished successfully` if the failover completed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the failover completed.
+
+### Example
+
+``` sh
+$ rladmin status shards
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:1   slave    0-16383   3.02MB         OK     
+db:5   tr01        redis:13   node:2   master   0-16383   3.09MB         OK     
+$ rladmin failover shard 13
+Executing shard fail-over: OOO.
+Finished successfully
+$ rladmin status shards
+SHARDS:
+DB:ID  NAME        ID         NODE     ROLE     SLOTS     USED_MEMORY    STATUS
+db:5   tr01        redis:12   node:1   master   0-16383   3.12MB         OK     
+db:5   tr01        redis:13   node:2   slave    0-16383   2.99MB         OK
+```
+---
+Title: rladmin upgrade
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrades the version of a module or Redis Enterprise Software for a database.
+headerRange: '[1-2]'
+linkTitle: upgrade
+toc: 'true'
+weight: $weight
+---
+
+Upgrades the version of a module or Redis Enterprise Software for a database.
+
+## `upgrade db`
+
+Schedules a restart of the primary and replica processes of a database and then upgrades the database to the latest version of Redis Enterprise Software.
+
+For more information, see [Upgrade an existing Redis Software Deployment]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}).
+
+```sh
+rladmin upgrade db { db:<id> | <name> }
+                [ preserve_roles ]
+                [ keep_redis_version ]
+                [ discard_data ]
+                [ force_discard ]
+                [ parallel_shards_upgrade ]
+                [ keep_crdt_protocol_version ]
+                [ redis_version <version> ]
+                [ force ]
+                [ { latest_with_modules | and module module_name <module name> version <version> module_args <arguments string> } ]
+```
+
+As of v6.2.4, the default behavior for `upgrade db` has changed.  It is now controlled by a new parameter that sets the default upgrade policy used to create new databases and to upgrade ones already in the cluster.  To learn more, see [`tune cluster default_redis_version`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}).
+
+As of Redis Enterprise Software version 7.8.2, `upgrade db` will always upgrade modules.
+
+### Parameters
+
+| Parameters                 | Type/Value               | Description                                                                                                            |
+|----------------------------|--------------------------|------------------------------------------------------------------------------------------------------------------------|
+| db                         | db:\<id\> <br />name     | Database to upgrade                                                                                                    |
+| and module | [upgrade module](#upgrade-module) command | Clause that allows the upgrade of a database and a specified Redis module in a single step with only one restart (can be specified multiple times). Deprecated as of Redis Enterprise Software v7.8.2.  |
+| discard_data               |                          | Indicates that data will not be saved after the upgrade                                                                |
+| force                      |                          | Forces upgrade and skips warnings and confirmations                                                                    |
+| force_discard              |                          | Forces `discard_data` if replication or persistence is enabled                                                   |
+| keep_crdt_protocol_version |                          | Keeps the current CRDT protocol version                                                                                |
+| keep_redis_version       |                          | Upgrades to a new patch release, not to the latest major.minor version. Deprecated as of Redis Enterprise Software v7.8.2. To upgrade modules without upgrading the Redis database version, set `redis_version` to the current Redis database version instead. |
+| latest_with_modules        |                          | Upgrades the Redis Enterprise Software version and all modules in the database. As of Redis Enterprise Software version 7.8.2, `upgrade db` will always upgrade modules. |
+| parallel_shards_upgrade    | integer <br />'all'        | Maximum number of shards to upgrade all at once                                                                        |
+| preserve_roles             |                          | Performs an additional failover to guarantee the shards' roles are preserved                                             |
+| redis_version              | Redis version            | Upgrades the database to the specified version instead of the latest version                                               |
+
+### Returns
+
+Returns `Done` if the upgrade completed. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin upgrade db db:5
+Monitoring e39c8e87-75f9-4891-8c86-78cf151b720b
+active - SMUpgradeBDB init
+active - SMUpgradeBDB check_slaves
+.active - SMUpgradeBDB prepare
+active - SMUpgradeBDB stop_forwarding
+oactive - SMUpgradeBDB start_wd
+active - SMUpgradeBDB wait_for_version
+.completed - SMUpgradeBDB
+Done
+```
+
+## `upgrade module`
+
+Upgrades Redis modules in use by a specific database. Deprecated as of Redis Enterprise Software v7.8.2. Use [`upgrade db`](#upgrade-db) instead.
+
+For more information, see [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+```sh
+rladmin upgrade module
+        db_name { db:<id> | <name> }
+        module_name <mod_name>
+        version <version>
+        module_args <args_str>
+```
+
+### Parameters
+
+| Parameters                 | Type/Value               | Description                                                                                                            |
+|----------------------------|--------------------------|------------------------------------------------------------------------------------------------------------------------|
+| db_name                    | db:\<id\> <br />name     | Upgrade a module for the specified database                                                                                     |
+| module_name                | 'ReJSON'<br />'graph'<br />'search'<br />'bf'<br />'rg'<br />'timeseries' | Redis module to upgrade                                       |
+| version                    | module version number    | Upgrades the module to the specified version                                                                               |
+| module_args                | 'keep_args'<br />string    | Module configuration options                                                                                                       |
+
+For more information about module configuration options, see [Module configuration options]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database#module-configuration-options" >}}).
+
+### Returns
+
+Returns `Done` if the upgrade completed. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin upgrade module db_name db:8 module_name graph version 20812 module_args ""
+Monitoring 21ac7659-e44c-4cc9-b243-a07922b2a6cc
+active - SMUpgradeBDB init
+active - SMUpgradeBDB wait_for_version
+Ocompleted - SMUpgradeBDB
+Done
+```
+---
+Title: rladmin node enslave
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Changes a node's resources to replicas.
+headerRange: '[1-2]'
+linkTitle: enslave
+toc: 'true'
+weight: $weight
+---
+
+Changes the resources of a node to replicas.
+
+## `node enslave`
+
+Changes all of the node's endpoints and shards to replicas.
+
+``` sh
+rladmin node <ID> enslave
+        [demote_node]
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's endpoints and shards to replicas             |
+| demote_node           |                                | If the node is a primary node, changes the node to replica                     |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status shards node 2
+SHARDS:
+DB:ID      NAME           ID               NODE         ROLE         SLOTS                  USED_MEMORY            STATUS
+db:6       tr02           redis:14         node:2       master       0-4095                 3.2MB                  OK
+db:6       tr02           redis:16         node:2       master       4096-8191              3.12MB                 OK
+db:6       tr02           redis:18         node:2       master       8192-12287             3.16MB                 OK
+db:6       tr02           redis:20         node:2       master       12288-16383            3.12MB                 OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 slave  192.0.2.12 198.51.100.1      3d99db1fdf4b 1/100  6           14.43GB/19.54GB  10.87GB/16.02GB  6.2.12-37 OK
+node:2  master 192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.43GB/19.54GB  10.88GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.14                   b87cc06c830f 5/120  6           14.43GB/19.54GB  10.83GB/16.02GB  6.2.12-37 OK
+$ rladmin node 2 enslave demote_node
+Performing enslave_node action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 1/100  6           14.72GB/19.54GB  10.91GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.72GB/19.54GB  11.17GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.14                   b87cc06c830f 5/120  6           14.72GB/19.54GB  10.92GB/16.02GB  6.2.12-37 OK
+$ rladmin status shards node 2
+SHARDS:
+DB:ID      NAME             ID               NODE         ROLE       SLOTS                  USED_MEMORY            STATUS
+db:6       tr02             redis:14         node:2       slave      0-4095                 2.99MB                 OK
+db:6       tr02             redis:16         node:2       slave      4096-8191              3.01MB                 OK
+db:6       tr02             redis:18         node:2       slave      8192-12287             2.93MB                 OK
+db:6       tr02             redis:20         node:2       slave      12288-16383            3.06MB                 OK
+```
+
+## `node enslave endpoints_only`
+
+Changes the role for all endpoints on a node to replica.
+
+``` sh
+rladmin node <ID> enslave endpoints_only
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's endpoints to replicas                        |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status endpoints`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-endpoints" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status endpoints
+ENDPOINTS:
+DB:ID         NAME        ID                             NODE            ROLE                                       SSL       
+db:5          tr01        endpoint:5:1                   node:1          single                                     No        
+db:6          tr02        endpoint:6:1                   node:3          all-master-shards                          No        
+$ rladmin node 1 enslave endpoints_only
+Performing enslave_node action on node:1: 100%
+OK
+$ rladmin status endpoints
+ENDPOINTS:
+DB:ID         NAME        ID                             NODE            ROLE                                       SSL       
+db:5          tr01        endpoint:5:1                   node:3          single                                     No        
+db:6          tr02        endpoint:6:1                   node:3          all-master-shards                          No       
+```
+
+## `node enslave shards_only`
+
+Changes the role for all shards of a node to replica.
+
+``` sh
+rladmin node <ID> enslave shards_only
+        [retry_timeout_seconds <seconds>]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Changes all of the node's shards to replicas                          |
+| retry_timeout_seconds | integer                        | Retries on failure until the specified number of seconds has passed.                    |
+
+### Returns
+
+Returns `OK` if the roles were successfully changed. Otherwise, it returns an error.
+
+Use [`rladmin status shards`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards" >}}) to verify that the roles were changed.
+
+### Example
+
+```sh
+$ rladmin status shards node 3
+SHARDS:
+DB:ID      NAME           ID               NODE         ROLE         SLOTS                  USED_MEMORY            STATUS     
+db:5       tr01           redis:12         node:3       master       0-16383                3.04MB                 OK         
+db:6       tr02           redis:15         node:3       master       0-4095                 4.13MB                 OK         
+db:6       tr02           redis:17         node:3       master       4096-8191              4.13MB                 OK         
+db:6       tr02           redis:19         node:3       master       8192-12287             4.13MB                 OK         
+db:6       tr02           redis:21         node:3       master       12288-16383            4.13MB                 OK         
+$ rladmin node 3 enslave shards_only
+Performing enslave_node action on node:3: 100%
+OK
+$ rladmin status shards node 3
+SHARDS:
+DB:ID      NAME             ID               NODE         ROLE       SLOTS                  USED_MEMORY            STATUS     
+db:5       tr01             redis:12         node:3       slave      0-16383                2.98MB                 OK         
+db:6       tr02             redis:15         node:3       slave      0-4095                 4.23MB                 OK         
+db:6       tr02             redis:17         node:3       slave      4096-8191              4.11MB                 OK         
+db:6       tr02             redis:19         node:3       slave      8192-12287             4.19MB                 OK         
+db:6       tr02             redis:21         node:3       slave      12288-16383            4.27MB                 OK
+```
+---
+Title: rladmin node maintenance_mode
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turns quorum-only mode on or off for a node.
+headerRange: '[1-2]'
+linkTitle: maintenance_mode
+toc: 'true'
+weight: $weight
+---
+
+Configures [quorum-only mode]({{< relref "/operate/rs/clusters/maintenance-mode#activate-maintenance-mode" >}}) on a node.
+
+## `node maintenance_mode on`
+
+Migrates shards out of the node and turns the node into a quorum node to prevent shards from returning to it.
+
+```sh
+rladmin node <ID> maintenance_mode on
+        [ keep_slave_shards ]
+        [ evict_ha_replica { enabled | disabled } ]
+        [ evict_active_active_replica { enabled | disabled } ]
+        [ evict_dbs <list of database names or IDs> ]
+        [ demote_node ]
+        [ overwrite_snapshot ]
+        [ max_concurrent_actions <integer> ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Turns the specified node into a quorum node                                              |
+| demote_node           |                                | If the node is a primary node, changes the node to replica                                |
+| evict_ha_replica | `enabled`<br />`disabled` | Migrates the HA replica shards in the node |
+| evict_active_active_replica | `enabled`<br />`disabled` | Migrates the Active-Active replica shards in the node |
+| evict_dbs | list of database names or IDs | Specify databases whose shards should be evicted from the node when entering maintenance mode.<br /><br />Examples:<br />`$ rladmin node 1 maintenance_mode on evict_dbs db:1 db:2`<br />`$ rladmin node 1 maintenance_mode on evict_dbs db_name1 db_name2` |
+| keep_slave_shards     |                                | Keeps replica shards in the node and demotes primary shards to replicas.<br /><br />Deprecated as of Redis Enterprise Software 7.4.2. Use `evict_ha_replica disabled evict_active_active_replica disabled` instead. |
+| max_concurrent_actions | integer | Maximum number of concurrent actions during node maintenance |
+| overwrite_snapshot | | Overwrites the latest existing node snapshot taken when enabling maintenance mode |
+
+### Returns
+
+Returns `OK` if the node was converted successfully. If the cluster does not have enough resources to migrate the shards, the process returns a warning.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the node became a quorum node.
+
+### Example
+
+```sh
+$ rladmin node 2 maintenance_mode on overwrite_snapshot
+Found snapshot from 2024-01-06T11:36:47Z, overwriting the snapshot
+Performing maintenance_on action on node:2: 0%
+created snapshot NodeSnapshot<name=maintenance_mode_2024-01-11_20-25-37,time=None,node_uid=2>
+
+node:2 will not accept any more shards
+Performing maintenance_on action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.21GB/19.54GB  10.62GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 0/0    6           14.21GB/19.54GB  0KB/0KB          6.2.12-37 OK
+node:4  slave  192.0.2.14                   6d754fe12cb9 5/100  6           14.21GB/19.54GB  10.62GB/16.02GB  6.2.12-37 OK
+```
+
+## `node maintenance_mode off`
+
+Turns maintenance mode off and returns the node to its previous state.
+
+```sh
+rladmin node <ID> maintenance_mode off
+        [ { snapshot_name <name> | skip_shards_restore } ]
+        [ max_concurrent_actions <integer> ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Restores the node back to the previous state                                              |
+| max_concurrent_actions | integer | Maximum number of concurrent actions during node maintenance |
+| skip_shards_restore   |                                | Does not restore shards back to the node                                                  |
+| snapshot_name         | string                         | Restores the node back to a state stored in the specified snapshot                        |
+
+### Returns
+
+Returns `OK` if the node was restored successfully.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the node was restored.
+
+### Example
+
+```sh
+$ rladmin node 2 maintenance_mode off
+Performing maintenance_off action on node:2: 0%
+Found snapshot: NodeSnapshot<name=maintenance_mode_2022-05-12_20-25-37,time=2022-05-12T20:25:37Z,node_uid=2>
+Performing maintenance_off action on node:2: 0%
+migrate redis:12 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:12 to node:2: finished
+Performing maintenance_off action on node:2: 0%
+migrate redis:17 to node:2: executing
+
+migrate redis:15 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:17 to node:2: finished
+
+migrate redis:15 to node:2: finished
+Performing maintenance_off action on node:2: 0%
+failover redis:16: executing
+
+failover redis:14: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:16: finished
+
+failover redis:14: finished
+Performing maintenance_off action on node:2: 0%
+failover redis:18: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:18: finished
+
+migrate redis:21 to node:2: executing
+
+migrate redis:19 to node:2: executing
+Performing maintenance_off action on node:2: 0%
+migrate redis:21 to node:2: finished
+
+migrate redis:19 to node:2: finished
+
+failover redis:20: executing
+Performing maintenance_off action on node:2: 0%
+failover redis:20: finished
+Performing maintenance_off action on node:2: 0%
+rebind endpoint:6:1: executing
+Performing maintenance_off action on node:2: 0%
+rebind endpoint:6:1: finished
+Performing maintenance_off action on node:2: 100%
+OK
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME      SHARDS CORES       FREE_RAM        PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b  5/100  6           14.2GB/19.54GB  10.61GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458  5/100  6           14.2GB/19.54GB  10.61GB/16.02GB  6.2.12-37 OK    
+node:4  slave  192.0.2.14                   6d754fe12cb9  0/100  6           14.2GB/19.54GB  10.69GB/16.02GB  6.2.12-37 OK
+```
+---
+Title: rladmin node external_addr
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configures a node's external IP addresses.
+headerRange: '[1-2]'
+linkTitle: external_addr
+toc: 'true'
+weight: $weight
+---
+
+Configures a node's external IP addresses.
+
+## `node external_addr add`
+
+Adds an external IP address that accepts inbound user connections for the node.
+
+```sh
+rladmin node <ID> external_addr
+        add <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Adds an external IP address for the specified node                                               |
+| IP address | IP address                     | External IP address of the node                                                               |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was added. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was added.
+
+### Example
+
+``` sh
+$ rladmin node 1 external_addr add 198.51.100.1
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1      3d99db1fdf4b 5/100  6           14.75GB/19.54GB  11.15GB/16.02GB  6.2.12-37 OK
+node:2  slave  192.0.2.3                   fc7a3d332458 0/100  6           14.75GB/19.54GB  11.24GB/16.02GB  6.2.12-37 OK
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6           14.75GB/19.54GB  11.15GB/16.02GB  6.2.12-37 OK
+```
+
+## `node external_addr set`
+
+Sets one or more external IP addresses that accepts inbound user connections for the node.
+
+```sh
+rladmin node <ID> external_addr
+        set <IP address 1> ... <IP address N>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets external IP addresses for the specified node                                             |
+| IP address | list of IP addresses           | Sets specified IP addresses as external addresses                                                 |
+
+### Returns
+
+Returns `Updated successfully` if the IP addresses were set. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was set.
+
+### Example
+
+``` sh
+$ rladmin node 2 external_addr set 198.51.100.2 198.51.100.3
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS          HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1              3d99db1fdf4b 5/100  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3 198.51.100.2,198.51.100.3 fc7a3d332458 0/100  6     14.75GB/19.54GB 11.23GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                           b87cc06c830f 5/120  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+```
+## `node external_addr remove`
+
+Removes the specified external IP address from the node.
+
+```sh
+rladmin node <ID> external_addr
+        remove <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Removes an external IP address for the specified node                                            |
+| IP address | IP address                     | Removes the specified IP address of the node                                                      |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was removed. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the external IP address was removed.
+
+### Example
+
+``` sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS          HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1              3d99db1fdf4b 5/100  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3 198.51.100.2,198.51.100.3 fc7a3d332458 0/100  6     14.75GB/19.54GB 11.23GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                           b87cc06c830f 5/120  6     14.75GB/19.54GB 11.15GB/16.02GB 6.2.12-37 OK
+$ rladmin node 2 external_addr remove 198.51.100.3
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS   EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.2 198.51.100.1      3d99db1fdf4b 5/100  6           14.74GB/19.54GB  11.14GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.3 198.51.100.2      fc7a3d332458 0/100  6           14.74GB/19.54GB  11.22GB/16.02GB  6.2.12-37 OK    
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6           14.74GB/19.54GB  11.14GB/16.02GB  6.2.12-37 OK    
+```
+---
+Title: rladmin node snapshot
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manages snapshots of the configuration of a node's shards and endpoints.
+headerRange: '[1-2]'
+linkTitle: snapshot
+toc: 'true'
+weight: $weight
+---
+
+Manages snapshots of the configuration of a node's shards and endpoints.
+
+You can create node snapshots and use them to restore the node's shards and endpoints to a configuration from a previous point in time. If you restore a node from a snapshot (for example, after an event such as failover or maintenance), the node's shards have the same placement and roles as when the snapshot was created.
+
+## `node snapshot create`
+
+Creates a snapshot of a node's current configuration, including the placement of shards and endpoints on the node and the shards' roles.
+
+```sh
+rladmin node <ID> snapshot create <name>
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Creates a snapshot of the specified node                    |
+| name                  | string                         | Name of the created snapshot                                |
+
+### Returns
+
+Returns `Done` if the snapshot was created successfully. Otherwise, returns an error.
+
+### Example
+
+```sh
+$ rladmin node 1 snapshot create snap1
+Creating node snapshot 'snap1' for node:1
+Done.
+```
+
+## `node snapshot delete`
+
+Deletes an existing snapshot of a node.
+
+```sh
+rladmin node <ID> snapshot delete <name>
+```
+
+{{<note>}}
+You cannot use this command to delete a snapshot created by maintenance mode. As of Redis Enterprise Software version 7.4.2, only the latest maintenance mode snapshot is kept.
+{{</note>}}
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Deletes a snapshot of the specified node                    |
+| name                  | string                         | Deletes the specified snapshot                                |
+
+### Returns
+
+Returns `Done` if the snapshot was deleted successfully. Otherwise, returns an error.
+
+### Example
+
+```sh
+$ rladmin node 1 snapshot delete snap1
+Deleting node snapshot 'snap1' for node:1
+Done.
+```
+
+## `node snapshot list`
+
+Displays a list of created snapshots for the specified node.
+
+``` sh
+rladmin node <ID> snapshot list
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Displays snapshots of the specified node                    |
+
+### Returns
+
+Returns a list of snapshots of the specified node.
+
+### Example
+
+```sh
+$ rladmin node 2 snapshot list
+Name                                               Node    Time
+snap2                                              2       2022-05-12T19:27:51Z
+```
+
+## `node snapshot restore`
+
+Restores a node's shards and endpoints as close to the stored snapshot as possible.
+
+```sh
+rladmin node <ID> snapshot restore <name>
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                                               |
+|-----------------------|--------------------------------|-------------------------------------------------------------------------------------------|
+| node                  | integer                        | Restore the specified node from a snapshot.                    |
+| restore              | string                           | Name of the snapshot used to restore the node.              |
+
+### Returns
+
+Returns `Snapshot restore completed successfully` if the actions needed to restore the snapshot completed successfully. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin node 2 snapshot restore snap2
+Reading node snapshot 'snap2' for node:2
+Planning restore
+Planned actions:
+* migrate redis:15 to node:2
+* failover redis:14
+* migrate redis:17 to node:2
+* failover redis:16
+* migrate redis:19 to node:2
+* failover redis:18
+* migrate redis:21 to node:2
+* failover redis:20
+Proceed?[Y]es/[N]o? Y
+2022-05-12T19:43:31.486613 Scheduling 8 actions
+[2022-05-12T19:43:31.521422 Actions Status: 8 waiting ]
+* [migrate redis:21 to node:2] waiting => executing
+* [migrate redis:19 to node:2] waiting => executing
+* [migrate redis:17 to node:2] waiting => executing
+* [migrate redis:15 to node:2] waiting => executing
+[2022-05-12T19:43:32.586084 Actions Status: 4 executing | 4 waiting ]
+* [migrate redis:21 to node:2] executing => finished
+* [migrate redis:19 to node:2] executing => finished
+* [migrate redis:17 to node:2] executing => finished
+* [migrate redis:15 to node:2] executing => finished
+* [failover redis:20] waiting => executing
+* [failover redis:18] waiting => executing
+* [failover redis:16] waiting => executing
+* [failover redis:14] waiting => executing
+[2022-05-12T19:43:33.719496 Actions Status: 4 finished | 4 executing ]
+* [failover redis:20] executing => finished
+* [failover redis:18] executing => finished
+* [failover redis:16] executing => finished
+* [failover redis:14] executing => finished
+Snapshot restore completed successfully.
+```
+---
+Title: rladmin node addr set
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets a node's internal IP address.
+headerRange: '[1-2]'
+linkTitle: addr
+toc: 'true'
+weight: $weight
+---
+
+Sets the internal IP address of a node. You can only set the internal IP address when the node is down. See [Change internal IP address]({{< relref "/operate/rs/networking/multi-ip-ipv6#change-internal-ip-address" >}}) for detailed instructions.
+
+```sh
+rladmin node <ID> addr set <IP address>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets the internal IP address of the specified node                                                |
+| addr   | IP address                     | Sets the node's internal IP address to the specified IP address                                      |
+
+### Returns
+
+Returns `Updated successfully` if the IP address was set. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify the internal IP address was changed.
+
+### Example
+
+```sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2                   3d99db1fdf4b 5/100  6     16.06GB/19.54GB 12.46GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.3                   fc7a3d332458 0/100  6     -/19.54GB       -/16.02GB       6.2.12-37 DOWN, last seen 33s ago
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6     16.06GB/19.54GB 12.46GB/16.02GB 6.2.12-37 OK
+$ rladmin node 2 addr set 192.0.2.5
+Updated successfully.
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS HOSTNAME     SHARDS CORES FREE_RAM        PROVISIONAL_RAM VERSION   STATUS
+*node:1 master 192.0.2.2                   3d99db1fdf4b 5/100  6     14.78GB/19.54GB 11.18GB/16.02GB 6.2.12-37 OK
+node:2  slave  192.0.2.5                   fc7a3d332458 0/100  6     14.78GB/19.54GB 11.26GB/16.02GB 6.2.12-37 OK
+node:3  slave  192.0.2.4                   b87cc06c830f 5/120  6     14.78GB/19.54GB 11.18GB/16.02GB 6.2.12-37 OK
+```
+---
+Title: rladmin node recovery_path set
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sets a node's local recovery path.
+headerRange: '[1-2]'
+linkTitle: recovery_path
+toc: 'true'
+weight: $weight
+---
+
+Sets the node's local recovery path, which specifies the directory where [persistence files]({{< relref "/operate/rs/databases/configure/database-persistence" >}}) are stored. You can use these persistence files to [recover a failed database]({{< relref "/operate/rs/databases/recover" >}}).
+
+```sh
+rladmin node <ID> recovery_path set <path>
+```
+
+### Parameters
+
+| Parameter | Type/Value                     | Description                                                                                   |
+|-----------|--------------------------------|-----------------------------------------------------------------------------------------------|
+| node      | integer                        | Sets the recovery path for the specified node                                            |
+| path      | filepath                       | Path to the folder where persistence files are stored                                         |
+
+### Returns
+
+Returns `Updated successfully` if the recovery path was set. Otherwise, it returns an error.
+
+### Example
+
+```sh
+$ rladmin node 2 recovery_path set /var/opt/redislabs/persist/redis
+Updated successfully.
+```
+---
+Title: rladmin node remove
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Removes a node from the cluster.
+headerRange: '[1-2]'
+linkTitle: remove
+toc: 'true'
+weight: $weight
+---
+
+Removes the specified node from the cluster.
+
+```sh
+rladmin node <ID> remove [ wait_for_persistence { enabled | disabled } ]
+```
+
+### Parameters
+
+| Parameter             | Type/Value                     | Description                                                 |
+|-----------------------|--------------------------------|-------------------------------------------------------------|
+| node                  | integer                        | The node to remove from the cluster                    |
+| wait_for_persistence  | `enabled`<br />`disabled`      | Ensures persistence files are available for recovery. The cluster policy `persistent_node_removal` determines the default value. |
+
+### Returns
+
+Returns `OK` if the node was removed successfully. Otherwise, it returns an error.
+
+Use [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) to verify that the node was removed.
+
+### Example
+
+```sh
+$ rladmin status nodes
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.26GB/19.54GB  10.67GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 4/100  6           14.26GB/19.54GB  10.71GB/16.02GB  6.2.12-37 OK    
+node:3  slave  192.0.2.14                   b87cc06c830f 1/120  6           14.26GB/19.54GB  10.7GB/16.02GB   6.2.12-37 OK    
+$ rladmin node 3 remove
+Performing remove action on node:3: 100%
+OK
+CLUSTER NODES:
+NODE:ID ROLE   ADDRESS    EXTERNAL_ADDRESS  HOSTNAME     SHARDS CORES       FREE_RAM         PROVISIONAL_RAM  VERSION   STATUS
+*node:1 master 192.0.2.12 198.51.100.1      3d99db1fdf4b 5/100  6           14.34GB/19.54GB  10.74GB/16.02GB  6.2.12-37 OK    
+node:2  slave  192.0.2.13 198.51.100.2      fc7a3d332458 5/100  6           14.34GB/19.54GB  10.74GB/16.02GB  6.2.12-37 OK
+```
+---
+Title: rladmin node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage nodes.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: node
+toc: 'true'
+weight: $weight
+---
+
+`rladmin node` commands manage nodes in the cluster.
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: rladmin
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Redis Enterprise clusters and databases.
+hideListLinks: true
+linkTitle: rladmin (manage cluster)
+weight: $weight
+---
+
+`rladmin` is a command-line utility that lets you perform administrative tasks such as failover, migration, and endpoint binding on a Redis Enterprise Software cluster. You can also use `rladmin` to edit cluster and database configurations.
+
+Although you can use the Cluster Manager UI for some of these tasks, others are unique to the `rladmin` command-line tool.
+
+## `rladmin` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Use the `rladmin` shell
+
+To open the `rladmin` shell:
+
+1. Sign in to a Redis Enterprise Software node with an account that is a member of the **redislabs** group.
+
+    The `rladmin` binary is located in `/opt/redislabs/bin`. If you don't have this directory in your `PATH`, you may want to add it. Otherwise, you can use `bash -l <username>` to sign in as a user with permissions for that directory.
+
+1. Run: `rladmin`
+
+    {{<note>}}
+If the CLI does not recognize the `rladmin` command,
+run this command to load the necessary configuration first: <nobr>`bash -l`</nobr>
+    {{</note>}}
+
+In the `rladmin` shell, you can:
+
+- Run any `rladmin` command without prefacing it with `rladmin`.
+- Enter `?` to view the full list of available commands.
+- Enter [`help`]({{< relref "/operate/rs/references/cli-utilities/rladmin/help" >}}) followed by the name of a command for a detailed explanation of the command and its usage.
+- Press the `Tab` key for command completion.
+- Enter `exit` or press `Control+D` to exit the `rladmin` shell and return to the terminal prompt.
+---
+Title: Command-line utilities
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reference for Redis Enterprise Software command-line utilities, including rladmin, redis-cli, crdb-cli, and rlcheck.
+hideListLinks: true
+linkTitle: Command-line utilities
+weight: $weight
+---
+
+Redis Enterprise Software includes a set of utilities to help you manage and test your cluster. To use a utility, run it from the command line.
+
+## Public utilities
+
+Administrators can use these CLI tools to manage and test a Redis Enterprise cluster. You can find the binaries in the `/opt/redislabs/bin/` directory.
+
+{{<table-children columnNames="Utility,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Internal utilities
+
+The `/opt/redislabs/bin/` directory also contains utilities used internally by Redis Enterprise Software and for troubleshooting.
+
+{{<warning>}}
+Do not use these tools for normal operations.
+{{</warning>}}
+
+| Utility | Description |
+|---------|-------------|
+| bdb-cli | `redis-cli` connected to a database. |
+| ccs-cli | Inspect Cluster Configuration Store. |
+| cnm-ctl | Manages services for provisioning, migration, monitoring, <br />resharding, rebalancing, deprovisioning, and autoscaling. |
+| consistency_checker | Checks the consistency of Redis instances. |
+| crdbtop | Monitor Active-Active databases. |
+| debug_mode | Enables debug mode. |
+| debuginfo | Collects cluster information. |
+| dmc-cli | Configure and monitor the DMC proxy. |
+| pdns_control | Sends commands to a running PowerDNS nameserver. |
+| redis_ctl | Stops or starts Redis instances. |
+| rl_rdbloader | Load RDB backup files to a server. |
+| rlutil | Maintenance utility. |
+| shard-cli | `redis-cli` connected to a shard. |
+| supervisorctl | Manages the lifecycles of Redis Enterprise services. |
+---
+Title: crdb-cli crdb flush
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Clears all keys from an Active-Active database.
+linkTitle: flush
+weight: $weight
+---
+
+Clears all keys from an Active-Active database.
+
+```sh
+crdb-cli crdb flush --crdb-guid <guid>
+         [ --no-wait ]
+```
+
+This command is irreversible. If the data in your database is important, back it up before you flush the database.
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+| no-wait             |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task clearing the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be cleared and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb flush --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+Task 53cdc59e-ecf5-4564-a8dd-448d71f9e568 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb remove-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Removes a peer replica from an Active-Active database.
+linkTitle: remove-instance
+weight: $weight
+---
+
+Removes a peer replica instance from the Active-Active database and deletes the instance and its data from the participating cluster.
+
+```sh
+crdb-cli crdb remove-instance --crdb-guid <guid>
+         --instance-id <instance-id>
+         [ --force ]
+         [ --no-wait ]
+```
+
+If the cluster cannot communicate with the instance that you want to remove, you can:
+
+1. Use the `--force` option to remove the instance from the Active-Active database without purging the data from the instance.
+
+1. Run [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) from the removed instance to delete the Active-Active database and its data.
+
+### Parameters
+
+| Parameter                    | Value  | Description|
+|------------------------------|--------|------------|
+| crdb-guid         | string | The GUID of the database (required) |
+| instance-id | string | The ID of the local instance to remove (required) |
+| force                        |        | Removes the instance without purging data from the instance. <br>If --force is specified, you must run [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) from the removed instance. |
+| no-wait                      |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is deleting the instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be removed and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb remove-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 --instance-id 2 --force
+Task b1eba5ba-90de-49e9-8678-d66daa1afb51 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb get
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the current configuration of an Active-Active database.
+linkTitle: get
+weight: $weight
+---
+
+Shows the current configuration of an Active-Active database.
+
+```sh
+crdb-cli crdb get --crdb-guid <guid>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+
+### Returns
+
+Returns the current configuration of the database.
+
+### Example
+
+```sh
+$ crdb-cli crdb get --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+CRDB-GUID: d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+Name: database1
+Encryption: False
+Causal consistency: False
+Protocol version: 1
+FeatureSet version: 5
+Modules: []
+Default-DB-Config:
+  memory_size: 1073741824
+  port: 12000
+  replication: True
+  shard_key_regex: [{'regex': '.*\\{(?<tag>.*)\\}.*'}, {'regex': '(?<tag>.*)'}]
+  sharding: True
+  shards_count: 1
+  tls_mode: disabled
+  rack_aware: None
+  data_persistence: None
+  authentication_redis_pass: None
+  authentication_admin_pass: None
+  oss_sharding: None
+  oss_cluster: None
+  proxy_policy: None
+  shards_placement: None
+  oss_cluster_api_preferred_ip_type: None
+  bigstore: None
+  bigstore_ram_size: None
+  aof_policy: None
+  snapshot_policy: None
+  max_aof_load_time: None
+  max_aof_file_size: None
+Instance:
+  Id: 1
+  Cluster:
+    FQDN: cluster1.redis.local
+    URL: https://cluster1.redis.local:9443
+    Replication-Endpoint: <Default>
+    Replication TLS SNI: <Default>
+  Compression: 3
+  DB-Config:
+    authentication_admin_pass: 
+    replication: None
+    rack_aware: None
+    memory_size: None
+    data_persistence: None
+    tls_mode: None
+    authentication_redis_pass: None
+    port: None
+    shards_count: None
+    shard_key_regex: None
+    oss_sharding: None
+    oss_cluster: None
+    proxy_policy: None
+    shards_placement: None
+    oss_cluster_api_preferred_ip_type: None
+    bigstore: None
+    bigstore_ram_size: None
+    aof_policy: None
+    snapshot_policy: None
+    max_aof_load_time: None
+    max_aof_file_size: None
+Instance:
+  Id: 2
+  Cluster:
+    FQDN: cluster2.redis.local
+    URL: https://cluster2.redis.local:9443
+    Replication-Endpoint: <Default>
+    Replication TLS SNI: <Default>
+  Compression: 3
+  DB-Config:
+    authentication_admin_pass: 
+    replication: None
+    rack_aware: None
+    memory_size: None
+    data_persistence: None
+    tls_mode: None
+    authentication_redis_pass: None
+    port: None
+    shards_count: None
+    shard_key_regex: None
+    oss_sharding: None
+    oss_cluster: None
+    proxy_policy: None
+    shards_placement: None
+    oss_cluster_api_preferred_ip_type: None
+    bigstore: None
+    bigstore_ram_size: None
+    aof_policy: None
+    snapshot_policy: None
+    max_aof_load_time: None
+    max_aof_file_size: None
+```
+---
+Title: crdb-cli crdb health-report
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the health report of an Active-Active database.
+linkTitle: health-report
+weight: $weight
+---
+
+Shows the health report of the API management layer of an Active-Active database.
+
+```sh
+crdb-cli crdb health-report --crdb-guid <guid>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid  | string | The GUID of the database (required) |
+
+### Returns
+
+Returns the health report of the API management layer of the database.
+
+### Example
+
+```sh
+$ crdb-cli crdb health-report --crdb-guid d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+[
+  {
+    "active_config_version":1,
+    "cluster_name":"cluster2.redis.local",
+    "configurations":[
+      {
+        "causal_consistency":false,
+        "encryption":false,
+        "featureset_version":5,
+        "instances":[
+          {
+            "cluster":{
+              "name":"cluster1.redis.local",
+              "url":"https:\/\/cluster1.redis.local:9443"
+            },
+            "db_uid":"",
+            "id":1
+          },
+          {
+            "cluster":{
+              "name":"cluster2.redis.local",
+              "url":"https:\/\/cluster2.redis.local:9443"
+            },
+            "db_uid":"1",
+            "id":2
+          }
+        ],
+        "name":"database1",
+        "protocol_version":1,
+        "status":"commit-completed",
+        "version":1
+      }
+    ],
+    "connections":[
+      {
+        "name":"cluster1.redis.local",
+        "status":"ok"
+      },
+      {
+        "name":"cluster2.redis.local",
+        "status":"ok"
+      }
+    ],
+    "guid":"d84f6fe4-5bb7-49d2-a188-8900e09c6f66",
+    "name":"database1",
+    "connection_error":null
+  },
+  {
+    "active_config_version":1,
+    "cluster_name":"cluster1.redis.local",
+    "configurations":[
+      {
+        "causal_consistency":false,
+        "encryption":false,
+        "featureset_version":5,
+        "instances":[
+          {
+            "cluster":{
+              "name":"cluster1.redis.local",
+              "url":"https:\/\/cluster1.redis.local:9443"
+            },
+            "db_uid":"4",
+            "id":1
+          },
+          {
+            "cluster":{
+              "name":"cluster2.redis.local",
+              "url":"https:\/\/cluster2.redis.local:9443"
+            },
+            "db_uid":"",
+            "id":2
+          }
+        ],
+        "name":"database1",
+        "protocol_version":1,
+        "status":"commit-completed",
+        "version":1
+      }
+    ],
+    "connections":[
+      {
+        "name":"cluster1.redis.local",
+        "status":"ok"
+      },
+      {
+        "name":"cluster2.redis.local",
+        "status":"ok"
+      }
+    ],
+    "guid":"d84f6fe4-5bb7-49d2-a188-8900e09c6f66",
+    "name":"database1",
+    "connection_error":null
+  }
+]
+```
+---
+Title: crdb-cli crdb add-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Adds a peer replica to an Active-Active database.
+linkTitle: add-instance
+weight: $weight
+---
+
+Adds a peer replica to an existing Active-Active database in order to host the database on another cluster. This creates an additional active instance of the database on the specified cluster.
+
+```sh
+crdb-cli crdb add-instance --crdb-guid <guid>
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         [ --compression <0-6> ]
+         [ --no-wait ]
+```
+
+### Parameters
+
+| Parameter | Value   | Description |
+|-----------|---------|-------------|
+| crdb-guid | string  | The GUID of the database (required) |
+| instance | strings | The connection information for the new participating cluster (required) |
+| compression | 0-6     | The level of data compression: 0=Compression disabled <br> <br> 6=High compression and resource load (Default: 3) |
+| no-wait | | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is adding the new instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be added and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb add-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 \
+        --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin-password
+Task f809fae7-8e26-4c8f-9955-b74dbbd47949 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb list
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows a list of all Active-Active databases.
+linkTitle: list
+weight: $weight
+---
+
+Shows a list of all Active-Active databases.
+
+```sh
+crdb-cli crdb list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+Returns a list of all Active-Active databases that the cluster participates in. Each database is represented with a unique GUID, the name of the database, an instance ID, and the FQDN of the cluster that hosts the instance.
+
+### Example
+
+```sh
+$ crdb-cli crdb list
+CRDB-GUID                             NAME       REPL-ID  CLUSTER-FQDN
+d84f6fe4-5bb7-49d2-a188-8900e09c6f66  database1  1        cluster1.redis.local
+d84f6fe4-5bb7-49d2-a188-8900e09c6f66  database1  2        cluster2.redis.local
+```
+---
+Title: crdb-cli crdb create
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Creates an Active-Active database.
+linkTitle: create
+weight: $weight
+---
+
+Creates an Active-Active database.
+
+```sh
+crdb-cli crdb create --name <name>
+         --memory-size <maximum_memory>
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         --instance fqdn=<cluster_fqdn>,username=<username>,password=<password>[,url=<url>,replication_endpoint=<endpoint>]
+         [--port <port_number>]
+         [--no-wait]
+         [--default-db-config <configuration>]
+         [--default-db-config-file <filename>]
+         [--compression <0-6>]
+         [--causal-consistency { true | false } ]
+         [--password <password>]
+         [--replication { true | false } ]
+         [--encryption { true | false } ]
+         [--sharding { false | true } ]
+         [--shards-count <number_of_shards>]
+         [--shard-key-regex <regex_rule>]
+         [--oss-cluster { true | false } ]
+         [--bigstore { true | false }]
+         [--bigstore-ram-size <maximum_memory>]
+         [--with-module name=<module_name>,version=<module_version>,args=<module_args>]
+```
+
+### Prerequisites
+
+Before you create an Active-Active database, you must have:
+
+- At least two participating clusters
+- [Network connectivity]({{< relref "/operate/rs/networking/port-configurations" >}}) between the participating clusters
+
+### Parameters
+
+
+| Parameter&nbsp;&&nbsp;options(s)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;                                                                             | Value                                           | Description                                                                                                                                                                                                                  |
+|---------------------------------------------------------------------------------------|-------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| name \<CRDB_name\>                                                                  | string                                          | Name of the Active-Active database (required)                                                                                                                                                                                |
+| memory-size \<maximum_memory\>                                                                | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum database memory (required)                                                                                                                                                                                           |
+| instance<br/>&nbsp;&nbsp; fqdn=\<cluster_fqdn\>,<br/>&nbsp;&nbsp; username=\<username\>,<br/>&nbsp;&nbsp; password=\<password\>         | strings                                         | The connection information for the participating clusters (required for each participating cluster)                                                                                                                          |
+| port \<port_number\>                                                                 | integer                                         | TCP port for the Active-Active database on all participating clusters                                                                                                                                                        |
+| default-db-config \<configuration\>                                                  | string                                          | Default database configuration options                                                                                                                                                                                       |
+| default-db-config-file \<filename\>                                                  | filepath                                        | Default database configuration options from a file                                                                                                                                                                           |
+| no-wait                                                                               |                                                 | Prevents `crdb-cli` from running another command before this command finishes                                                                                                                                                  |
+| compression                                                                           | 0-6                                             | The level of data compression: <br /><br > 0 = No compression <br /><br > 6 = High compression and resource load (Default: 3)                                                                                                            |
+| causal-consistency                                                                    | true <br/> false (*default*)                        | [Causal consistency]({{< relref "/operate/rs/databases/active-active/causal-consistency.md" >}}) applies updates to all instances in the order they were received                                                     |
+| password \<password\>                                                                | string                                          | Password for access to the database                                                                                                                                                                                          |
+| replication                                                                           | true <br/> false (*default*)                        | Activates or deactivates [database replication]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}}) where every master shard replicates to a replica shard                                                       |
+| encryption                                                                            | true <br/> false (*default*)                        | Activates or deactivates encryption                                                                                                                                                                                          |
+| sharding                                                                              | true <br/> false (*default*)                        | Activates or deactivates sharding (also known as [database clustering]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}})). Cannot be updated after the database is created                                   |
+| shards-count \<number_of_shards\>                                                              | integer                                         | If sharding is enabled, this specifies the number of Redis shards for each database instance                                                                                                                                 |
+| oss-cluster                                                                           | true<br/>false (*default*)                               | Activates [OSS cluster API]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api" >}})                                                                                                                                |
+| shard-key-regex \<regex_rule\>                                                       | string                                          | If clustering is enabled, this defines a regex rule (also known as a [hashing policy]({{< relref "/operate/rs/databases/durability-ha/clustering#custom-hashing-policy" >}})) that determines which keys are located in each shard (defaults to `{u'regex': u'.*\\{(?<tag>.*)\\}.*'}, {u'regex': u'(?<tag>.*)'} `) |
+| bigstore                                                                              | true <br/> <br/> false (*default*)                        | If true, the database uses Auto Tiering to add flash memory to the database                                                                                                                                                |
+| bigstore-ram-size \<size\>                                                           | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum RAM limit for  databases with Auto Tiering enabled                                                                                                                                                                           |
+| with-module<br/>&nbsp;&nbsp;name=\<module_name\>,<br/>&nbsp;&nbsp;version=\<module_version\>,<br/>&nbsp;&nbsp;args=\<module_args\> | strings                                         | Creates a database with a specific module                                                                                                                                                                                    |
+| eviction-policy                                                     | noeviction (*default*)<br/>allkeys-lru<br/>allkeys-lfu<br/>allkeys-random<br/>volatile-lru<br/>volatile-lfu<br/>volatile-random<br/>volatile-ttl | Sets [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}})                                                                                                          |
+| proxy-policy                                                                          | all-nodes<br>all-master-shards<br>single        | Sets proxy policy |
+
+
+
+### Returns
+
+Returns the task ID of the task that is creating the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be created and then return the CRDB GUID.
+
+### Examples
+
+```sh
+$ crdb-cli crdb create --name database1 --memory-size 1GB --port 12000 \
+           --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin \
+           --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin
+Task 633aaea3-97ee-4bcb-af39-a9cb25d7d4da created
+  ---> Status changed: queued -> started
+  ---> CRDB GUID Assigned: crdb:d84f6fe4-5bb7-49d2-a188-8900e09c6f66
+  ---> Status changed: started -> finished
+```
+
+To create an Active-Active database with two shards in each instance and with encrypted traffic between the clusters:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --shards-count 2 --encryption true
+```
+
+To create an Active-Active database with two shards and with RediSearch 2.0.6 module:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --shards-count 2 --with-module name=search,version="2.0.6",args="PARTITIONS AUTO"
+```
+
+To create an Active-Active database with two shards and with encrypted traffic between the clusters:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --encryption true --shards-count 2
+```
+
+To create an Active-Active database with 1 shard in each instance and not wait for the response:
+
+```sh
+crdb-cli crdb create --name mycrdb --memory-size 100mb --port 12000 --instance fqdn=cluster1.redis.local,username=admin@redis.local,password=admin --instance fqdn=cluster2.redis.local,username=admin@redis.local,password=admin --no-wait
+```
+---
+Title: crdb-cli crdb delete
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Deletes an Active-Active database.
+linkTitle: delete
+weight: $weight
+---
+
+Deletes an Active-Active database.
+
+```sh
+crdb-cli crdb delete --crdb-guid <guid>
+         [ --no-wait ]
+```
+
+This command is irreversible. If the data in your database is important, back it up before you delete the database.
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| crdb-guid | string | The GUID of the database (required) |
+| no-wait             |        | Does not wait for the task to complete |
+
+### Returns
+
+Returns the task ID of the task that is deleting the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be deleted and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb delete --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35
+Task dfe6cacc-88ff-4667-812e-938fd05fe359 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb update
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Updates the configuration of an Active-Active database.
+linkTitle: update
+weight: $weight
+---
+
+Updates the configuration of an Active-Active database.
+
+```sh
+crdb-cli crdb update --crdb-guid <guid>
+         [--no-wait]
+         [--force]
+         [--default-db-config <configuration> ]
+         [--default-db-config-file <filename>]
+         [--compression <0-6>]
+         [--causal-consistency { true | false } ]
+         [--credentials id=<id>,username=<username>,password=<password> ]
+         [--encryption { true | false } ]
+         [--oss-cluster { true | false } ]
+         [--featureset-version { true | false } ]
+         [--memory-size <maximum_memory>]
+         [--bigstore-ram-size <maximum_memory>]
+         [--update-module name=<name>,featureset_version=<version>]
+```
+
+If you want to change the configuration of the local instance only, use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) instead.
+
+### Parameters
+
+| Parameter                                                           | Value                                                                                                                         | Description                                                                                                                                                              |
+|---------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| crdb-guid \<guid\>                                                 | string                                                                                                                        | GUID of the Active-Active database (required)                                                                                                                            |
+| bigstore-ram-size \<maximum_memory\>                                                  | size in bytes, kilobytes (KB), or gigabytes (GB)                                                                               | Maximum RAM limit for the  databases with Auto Tiering enabled, if activated                                                                                                          |
+| memory-size \<maximum_memory\>                                                                | size in bytes, kilobytes (KB), or gigabytes (GB) | Maximum database memory (required)                                                                                                                                                                                           |
+| causal-consistency                                                  | true <br/>false                                                                                                           | [Causal consistency]({{< relref "/operate/rs/databases/active-active/causal-consistency.md" >}}) applies updates to all instances in the order they were received |
+| compression                                                         | 0-6                                                                                                                           | The level of data compression: <br /><br /> 0 = No compression <br /><br /> 6 = High compression and resource load (Default: 3)                                                        |
+| credentials id=\<id\>,username=\<username\>,password=\<password\> | strings                                                                                                                       | Updates the credentials for access to the instance                                                                                                                       |
+| default-db-config \<configuration\>                                                  |                                                                                                                               | Default database configuration from stdin. For a list of database settings, see the [CRDB database config object]({{<relref "/operate/rs/references/rest-api/objects/crdb/database_config">}}) reference. |
+| default-db-config-file \<filename\>                                | filepath                                                                                                                      | Default database configuration from file                                                                                                                                 |
+| encryption                                                          | true <br/>false                                                                                                           | Activates or deactivates encryption                                                                                                                                      |
+| force                                                               |                                                                                                                               | Force an update even if there are no changes                                                                                                                             |
+| no-wait                                                             |                                                                                                                               | Do not wait for the command to finish                                                                                                                                    |
+| oss-cluster                                                         | true <br/>false                                                                                                           | Activates or deactivates OSS Cluster mode                                                                                                                                |
+| eviction-policy                                                     | noeviction<br/>allkeys-lru<br/>allkeys-lfu<br/>allkeys-random<br/>volatile-lru<br/>volatile-lfu<br/>volatile-random<br/>volatile-ttl | Updates [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}})                                                                                                          |
+| featureset-version                                                  | true<br/>false                                                                                                             | Updates to latest FeatureSet version                                                                                                                                     |
+| update-module name=\<name>,featureset_version=\<version\>         | strings                                                                                                                       | Update a module to the specified version                                                                                                                                 |
+
+### Returns
+
+Returns the task ID of the task that is updating the database.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the database to be updated and then return "finished."
+
+### Examples
+
+The following example changes the maximum database memory:
+
+```sh
+$ crdb-cli crdb update --crdb-guid <crdb-guid> --memory-size 2GB
+Task <task-id> created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+
+The following example shows how to change a default database configuration setting:
+
+```sh
+$ crdb-cli crdb update --crdb-guid <crdb-guid> --default-db-config '{"shards_count": <primary_shards_count>}'
+Task <task-id> created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb purge-instance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Deletes data from a local instance and removes it from the Active-Active
+  database.
+linkTitle: purge-instance
+weight: $weight
+---
+
+Deletes data from a local instance and removes the instance from the Active-Active database.
+
+```sh
+crdb-cli crdb purge-instance --crdb-guid <guid>
+         --instance-id <instance-id>
+         [ --no-wait ]
+```
+
+Once this command finishes, the other replicas must remove this instance with [`crdb-cli crdb remove-instance --force`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/remove-instance" >}}).
+
+### Parameters
+
+| Parameter                 | Value  | Description                                      |
+|---------------------------|--------|--------------------------------------------------|
+| crdb-guid        | string | The GUID of the database (required)              |
+| instance-id  | string | The ID of the local instance (required) |
+| no-wait                   |        | Does not wait for the task to complete           |
+
+### Returns
+
+Returns the task ID of the task that is purging the local instance.
+
+If `--no-wait` is specified, the command exits. Otherwise, it will wait for the instance to be purged and return `finished`.
+
+### Example
+
+```sh
+$ crdb-cli crdb purge-instance --crdb-guid db6365b5-8aca-4055-95d8-7eb0105c0b35 --instance-id 2
+Task add0705c-87f1-4c28-ad6a-ab5d98e00c58 created
+  ---> Status changed: queued -> started
+  ---> Status changed: started -> finished
+```
+---
+Title: crdb-cli crdb commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active databases.
+hideListLinks: true
+linkTitle: crdb
+weight: $weight
+---
+
+Use `crdb-cli crdb` commands to manage Active-Active databases.
+
+## `crdb-cli crdb` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: crdb-cli task status
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shows the status of a specified Active-Active database task.
+linkTitle: status
+weight: $weight
+---
+
+Shows the status of a specified Active-Active database task.
+
+```sh
+crdb-cli task status --task-id <task_id>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| task-id \<task_id\>  | string | An Active-Active database task ID (required) |
+| verbose              | N/A    | Returns detailed information when specified |
+| no-verbose           | N/A    | Returns limited information when specified |
+
+The `--verbose` and `--no-verbose` options are mutually incompatible; specify one or the other.
+
+The `404 Not Found` error indicates an invalid task ID.  Use the [`task list`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/task/list" >}}) command to determine available task IDs.
+
+### Returns
+
+Returns the status of an Active-Active database task.
+
+### Example
+
+```sh
+$ crdb-cli task status --task-id e1c49470-ae0b-4df8-885b-9c755dd614d0
+Task-ID: e1c49470-ae0b-4df8-885b-9c755dd614d0
+CRDB-GUID: 1d7741cc-1110-4e2f-bc6c-935292783d24
+Operation: create_crdb
+Status: finished
+Worker-Name: crdb_worker:1:0
+Started: 2022-10-12T09:33:41Z
+Ended: 2022-10-12T09:33:55Z
+```
+---
+Title: crdb-cli task list
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Lists active and recent Active-Active database tasks.
+linkTitle: list
+weight: $weight
+---
+
+Lists active and recent Active-Active database tasks.
+
+```sh
+crdb-cli task list
+```
+
+### Parameters
+
+None
+
+### Returns
+
+A table listing current and recent Active-Active tasks.  Each entry includes the following:
+
+| Column | Description |
+|--------|-------------|
+| Task ID | String containing the unique ID associated with the task<br/>Example: `e1c49470-ae0b-4df8-885b-9c755dd614d0` |
+| CRDB-GUID | String containing the unique ID associated with the Active-Active database affected by the task<br/>Example: `1d7741cc-1110-4e2f-bc6c-935292783d24` |
+| Operation | String describing the task action<br/>Example: `create_crdb` |
+| Status | String indicating the task status<br/>Example: `finished` |
+| Worker name | String identifying the process handling the task<br/>Example: `crdb_worker:1:0` |
+| Started | TimeStamp value indicating when the task started ([UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time))<br/>Example: `2022-10-12T09:33:41Z` |
+| Ended | TimeStamp value indicating when the task ended (UTC)<br/>Example: ` 2022-10-12T09:33:55Z` |
+
+### Example
+
+```sh
+$ crdb-cli task list
+TASK-ID    CRDB-GUID  OPERATION    STATUS    WORKER-NAME  STARTED    ENDED               
+<task-ID>  <crdb-ID>  <operation>  <result>  <worker-ID>  <started>  <ended>
+```
+---
+Title: crdb-cli task cancel
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Attempts to cancel a specified Active-Active database task.
+linkTitle: cancel
+weight: $weight
+---
+
+Cancels the Active-Active database task specified by the task ID.
+
+```sh
+crdb-cli task cancel --task-id <task_id>
+```
+
+### Parameters
+
+| Parameter           | Value  | Description                         |
+|---------------------|--------|-------------------------------------|
+| task-id \<task_id\>  | string | An Active-Active database task ID (required) |
+
+### Returns
+
+Attempts to cancel an Active-Active database task.
+
+Be aware that tasks may complete before they can be cancelled.
+
+### Example
+
+```sh
+$ crdb-cli task cancel --task-id 2901c2a3-2828-4717-80c0-6f27f1dd2d7c 
+```
+---
+Title: crdb-cli task commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active tasks.
+hideListLinks: true
+linkTitle: task
+weight: $weight
+---
+
+The `crdb-cli task` commands help investigate Active-Active database performance issues.  They should not be used except as directed by Support.
+
+## `crdb-cli task` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Manage Active-Active databases.
+hideListLinks: true
+linkTitle: crdb-cli (manage Active-Active)
+weight: $weight
+---
+
+An [Active-Active database]({{< relref "/operate/rs/databases/active-active/_index.md" >}}) (also known as CRDB or conflict-free replicated database)
+replicates your data across Redis Enterprise Software clusters located in geographically distributed regions.
+Active-Active databases allow read-write access in all locations, making them ideal for distributed applications that require fast response times and disaster recovery.
+
+The Active-Active database on an individual cluster is called an **instance**.
+Each cluster that hosts an instance is called a **participating cluster**.
+
+An Active-Active database requires two or more participating clusters.
+Each instance is responsible for updating the instances that reside on other participating clusters with the transactions it receives.
+Write conflicts are resolved using [conflict-free replicated data types]({{< relref "/operate/rs/databases/active-active" >}}) (CRDTs).
+
+To programmatically maintain an Active-Active database and its instances, you can use the `crdb-cli` command-line tool.
+
+## `crdb-cli` commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Use the crdb-cli
+
+To use the `crdb-cli` tool, use SSH to sign in to a Redis Enterprise host with a user that belongs to the group that Redis Enterprise Software was installed with (Default: **redislabs**).
+If you sign in with a non-root user, you must add `/opt/redislabs/bin/` to your `PATH` environment variables.
+
+`crdb-cli` commands use the syntax: `crdb-cli <command> <arguments>` to let you:
+
+- Create, list, update, flush, or delete an Active-Active database.
+- Add or remove an instance of the Active-Active database on a specific cluster.
+
+Each command creates a task.
+
+By default, the command runs immediately and displays the result in the output.
+
+If you use the <nobr>`--no-wait`</nobr> flag, the command runs in the background so that your application is not delayed by the response.
+
+Use the [`crdb-cli task` commands]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/task/" >}}) to manage Active-Active database tasks.
+
+For each `crdb-cli` command, you can use <nobr>`--help`</nobr> for additional information about the command.
+---
+Title: Benchmark an Auto Tiering enabled database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Benchmark Auto Tiering
+weight: $weight
+---
+Auto Tiering on Redis Enterprise Software lets you use cost-effective Flash memory as a RAM extension for your database.
+
+But what does the performance look like as compared to a memory-only database, one stored solely in RAM?
+
+These scenarios use the `memtier_benchmark` utility to evaluate the performance of a Redis Enterprise Software deployment, including the trial version.  
+
+The `memtier_benchmark` utility is located in `/opt/redislabs/bin/` of Redis Enterprise Software deployments.  To test performance for cloud provider deployments, see the [memtier-benchmark GitHub project](https://github.com/RedisLabs/memtier_benchmark).
+
+For additional, such as assistance with larger clusters, [contact support](https://redislabs.com/company/support/).
+
+
+## Benchmark and performance test considerations
+
+These tests assume you're using a trial version of Redis Enterprise Software and want to test the performance of a Auto Tiering enabled database in the following scenarios:
+
+- Without replication: Four (4) master shards
+- With replication: Two (2) primary and two replica shards
+
+With the trial version of Redis Enterprise Software you can create a cluster of up to four shards using a combination of database configurations, including:
+
+- Four databases, each with a single master shard
+- Two highly available databases with replication enabled (each database has one master shard and one replica shard)
+- One non-replicated clustered database with four master shards
+- One highly available and clustered database with two master shards and two replica shards
+
+## Test environment and cluster setup
+
+For the test environment, you need to:
+
+1. Create a cluster with three nodes.
+1. Prepare the flash memory.
+1. Configure the load generation tool.
+
+### Creating a three-node cluster {#creating-a-threenode-rs-cluster}
+
+This performance test requires a three-node cluster.
+
+You can run all of these tests on Amazon AWS with these hosts:
+
+- 2 x i3.2xlarge (8 vCPU, 61 GiB RAM, up to 10GBit, 1.9TB NMVe SSD)
+
+    These nodes serve RoF data
+
+- 1 x m4.large, which acts as a quorum node
+
+To learn how to install Redis Enterprise Software and set up a cluster, see:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}) for a test installation
+- [Install and upgrade]({{< relref "/operate/rs/installing-upgrading" >}}) for a production installation
+
+These tests use a quorum node to reduce AWS EC2 instance use while maintaining the three nodes required to support a quorum node in case of node failure.  Quorum nodes can be on less powerful instances because they do not have shards or support traffic.
+
+As of this writing, i3.2xlarge instances are required because they support NVMe SSDs, which are required to support RoF.  Auto Tiering requires Flash-enabled storage, such as NVMe SSDs.
+
+For best results, compare performance of a Flash-enabled deployment to the performance in a RAM-only environment, such as a strictly on-premises deployment.
+
+## Prepare the flash memory
+
+After you install RS on the nodes,
+the flash memory attached to the i3.2xlarge instances must be prepared and formatted with the `/opt/redislabs/sbin/prepare_flash.sh` script.
+
+## Set up the load generation tool
+
+The memtier_benchmark load generator tool generates the load on the RoF databases.
+To use this tool, install RS on a dedicated instance that is not part of the RS cluster
+but is in the same region/zone/subnet of your cluster.
+We recommend that you use a relatively powerful instance to avoid bottlenecks at the load generation tool itself.
+
+For these tests, the load generation host uses a c4.8xlarge instance type.
+
+## Database configuration parameters
+
+### Create a Auto Tiering test database
+
+You can use the Redis Enterprise Cluster Manager UI to create a test database.
+We recommend that you use a separate database for each test case with these requirements:
+
+|  **Parameter** | **With replication** | **Without replication** | **Description** |
+|  ------ | ------ | ------ | ------ |
+|  Name | test-1 | test-2 | The name of the test database |
+|  Memory limit | 100 GB | 100 GB | The memory limit refers to RAM+Flash, aggregated across all the shards of the database, including master and replica shards. |
+|  RAM limit | 0.3 | 0.3 | RoF always keeps the Redis keys and Redis dictionary in RAM and additional RAM is required for storing hot values. For the purpose of these tests 30% RAM was calculated as an optimal value. |
+|  Replication | Enabled | Disabled | A database with no replication has only master shards. A database with replication has master and replica shards. |
+|  Data persistence | None | None | No data persistence is needed for these tests. |
+|  Database clustering | Enabled | Enabled | A clustered database consists of multiple shards. |
+|  Number of (master) shards | 2 | 4 | Shards are distributed as follows:<br/>- With replication: One master shard and one replica shard on each node<br/>- Without replication: Two master shards on each node |
+|  Other parameters | Default | Default | Keep the default values for the other configuration parameters. |
+
+## Data population
+
+### Populate the benchmark dataset
+
+The memtier_benchmark load generation tool populates the database.
+To populate the database with N items of 500 Bytes each in size, on the load generation instance run:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-maximum=$N -n allkeys -d 500 --key-pattern=P:P --ratio=1:0
+```
+
+Set up a test database:
+
+|  **Parameter** | **Description** |
+|  ------ | ------ |
+|  Database host<br/>(-s) | The fully qualified name of the endpoint or the IP shown in the RS database configuration |
+|  Database port<br/>(-p) | The endpoint port shown in your database configuration |
+|  Number of items<br/>(–key-maximum) | With replication: 75 Million<br/>Without replication: 150 Million |
+|  Item size<br/>(-d) | 500 Bytes |
+
+## Centralize the keyspace
+
+### With replication {#centralize-with-repl}
+
+To create roughly 20.5 million items in RAM for your highly available clustered database with 75 million items, run:
+
+```sh
+$ memtier_benchmark  -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-minimum=27250000 --key-maximum=47750000 -n allkeys
+--key-pattern=P:P --ratio=0:1
+```
+
+To verify the database values, use **Values in RAM** metric, which is available from the **Metrics** tab of your database in the Cluster Manager UI.
+
+### Without replication {#centralize-wo-repl}
+
+To create 41 million items in RAM without replication enabled and 150 million items, run:
+
+```sh
+$ memtier_benchmark  -s $DB_HOST -p $DB_PORT --hide-histogram
+--key-minimum=54500000 --key-maximum=95500000 -n allkeys
+--key-pattern=P:P --ratio=0:1
+```
+
+## Test runs
+
+### Generate load
+
+#### With replication {#generate-with-repl}
+
+We recommend that you do a dry run and double check the RAM Hit Ratio on the **Metrics** screen in the Cluster Manager UI before you write down the test results.
+
+To test RoF with an 85% RAM Hit Ratio, run:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --pipeline=11 -c 20 -t 1
+-d 500 --key-maximum=75000000 --key-pattern=G:G --key-stddev=5125000
+--ratio=1:1 --distinct-client-seed --randomize --test-time=600
+--run-count=1 --out-file=test.out
+```
+
+#### Without replication {#generate-wo-repl}
+
+Here is the command for 150 million items:
+
+```sh
+$ memtier_benchmark -s $DB_HOST -p $DB_PORT --pipeline=24 -c 20 -t 1
+-d 500 --key-maximum=150000000 --key-pattern=G:G --key-stddev=10250000
+--ratio=1:1 --distinct-client-seed --randomize --test-time=600
+--run-count=1 --out-file=test.out
+```
+
+Where:
+
+|  **Parameter** | **Description** |
+|------------|-----------------|
+|  Access pattern (--key-pattern) and standard deviation (--key-stddev) | Controls the RAM Hit ratio after the centralization process is complete |
+|  Number of threads (-t and -c)\ | Controls how many connections are opened to the database, whereby the number of connections is the number of threads multiplied by the number of connections per thread (-t) and number of clients per thread (-c) |
+|  Pipelining (--pipeline)\ | Pipelining allows you to send multiple requests without waiting for each individual response (-t) and number of clients per thread (-c) |
+|  Read\write ratio (--ratio)\ | A value of 1:1 means that you have the same number of write operations as read operations (-t) and number of clients per thread (-c) |
+
+## Test results
+
+### Monitor the test results
+
+You can either monitor the results in the **Metrics** tab of the Cluster Manager UI or with the `memtier_benchmark` output.  However, be aware that:
+
+- The memtier_benchmark results include the network latency between the load generator instance and the cluster instances.
+
+- The metrics shown in the Cluster Manager UI do _not_ include network latency.
+
+### Expected results
+
+You should expect to see an average throughput of:
+
+- Around 160,000 ops/sec when testing without replication (i.e. Four master shards)
+- Around 115,000 ops/sec when testing with enabled replication (i.e. 2 master and 2 replica shards)
+
+In both cases, the average latency should be below one millisecond.
+---
+Title: Develop with Redis clients
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis client libraries allow you to connect to Redis instances from within
+  your application. This section provides an overview of several recommended Redis
+  clients for popular programming and scripting languages.
+hideListLinks: true
+linkTitle: Redis clients
+weight: 80
+---
+To connect to Redis instances from within your application, use a Redis client library that matches your application's language.
+
+## Official clients
+
+| Language | Client name |
+| :---------- | :------------- |
+| .Net | [NRedisStack]({{< relref "/develop/clients/dotnet" >}}) |
+| Go | [go-redis]({{< relref "/develop/clients/go" >}}) |
+| Java | [Jedis]({{< relref "/develop/clients/jedis" >}}) (Synchronous) and [Lettuce]({{< relref "/develop/clients/lettuce" >}}) (Asynchronous) |
+| Node.js | [node-redis]({{< relref "/develop/clients/nodejs" >}}) |
+| Python | [redis-py]({{< relref "/develop/clients/redis-py" >}}) |
+
+Select a client name to see its quick start.
+
+## Other clients
+
+For a list of community-driven Redis clients, which are available for more programming languages, see
+[Community-supported clients]({{< relref "/develop/clients#community-supported-clients" >}}).
+---
+Title: Permissions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the permissions used with Redis Enterprise Software REST API
+  calls.
+linkTitle: Permissions
+weight: 60
+---
+
+Some Redis Enterprise [REST API requests]({{< relref "/operate/rs/references/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]({{< relref "/operate/rs/security/access-control/create-users" >}}) or a [<nobr>`PUT /v1/users/{uid}`</nobr> API request]({{< relref "/operate/rs/references/rest-api/requests/users#put-user" >}}) 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.
+
+Available management roles include:
+
+- **none**: No REST API permissions.
+- **[db_viewer](#db-viewer-role)**: Can view database info.
+- **[db_member](#db-member-role)**: Can create or modify databases and view their info.
+- **[cluster_viewer](#cluster-viewer-role)**: Can view cluster and database info.
+- **[cluster_member](#cluster-member-role)**: Can modify the cluster and databases and view their info.
+- **[user_manager](#user-manager-role)**: Can modify users and view their info.
+- **[admin](#admin-role)**: Can view and modify all elements of the cluster.
+
+## Permissions list for each role
+
+| Role | Permissions |
+|------|-------------|
+| none | No permissions |
+| <a name="admin-role"></a>admin | [add_cluster_module](#add_cluster_module), [cancel_cluster_action](#cancel_cluster_action), [cancel_node_action](#cancel_node_action), [config_ldap](#config_ldap), [config_ocsp](#config_ocsp), [create_bdb](#create_bdb), [create_crdb](#create_crdb), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_redis_acl](#create_redis_acl), [create_role](#create_role), [delete_bdb](#delete_bdb), [delete_cluster_module](#delete_cluster_module), [delete_crdb](#delete_crdb), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [install_new_license](#install_new_license), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [start_cluster_action](#start_cluster_action), [start_node_action](#start_node_action), [test_ocsp_status](#test_ocsp_status), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_cluster](#update_cluster), [update_crdb](#update_crdb), [update_ldap_mapping](#update_ldap_mapping), [update_node](#update_node), [update_proxy](#update_proxy), [update_redis_acl](#update_redis_acl), [update_role](#update_role), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_ocsp_config](#view_ocsp_config), [view_ocsp_status](#view_ocsp_status), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info) |
+| <a name="cluster-member-role"></a>cluster_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="cluster-viewer-role"></a>cluster_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="db-member-role"></a>db_member | [create_bdb](#create_bdb), [create_crdb](#create_crdb), [delete_bdb](#delete_bdb), [delete_crdb](#delete_crdb), [edit_bdb_module](#edit_bdb_module), [failover_shard](#failover_shard), [flush_crdb](#flush_crdb), [migrate_shard](#migrate_shard), [purge_instance](#purge_instance), [reset_bdb_current_backup_status](#reset_bdb_current_backup_status), [reset_bdb_current_export_status](#reset_bdb_current_export_status), [reset_bdb_current_import_status](#reset_bdb_current_import_status), [start_bdb_export](#start_bdb_export), [start_bdb_import](#start_bdb_import), [start_bdb_recovery](#start_bdb_recovery), [update_bdb](#update_bdb), [update_bdb_alerts](#update_bdb_alerts), [update_bdb_with_action](#update_bdb_with_action), [update_crdb](#update_crdb), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_debugging_info](#view_debugging_info), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="db-viewer-role"></a>db_viewer | [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_nodes_alerts](#view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_recovery_plan](#view_bdb_recovery_plan), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_license](#view_license), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action) |
+| <a name="user-manager-role"></a>user_manager | [config_ldap](#config_ldap), [create_ldap_mapping](#create_ldap_mapping), [create_new_user](#create_new_user), [create_role](#create_role), [create_redis_acl](#create_redis_acl), [delete_ldap_mapping](#delete_ldap_mapping), [delete_redis_acl](#delete_redis_acl), [delete_role](#delete_role), [delete_user](#delete_user), [install_new_license](#install_new_license), [update_ldap_mapping](#update_ldap_mapping), [update_proxy](#update_proxy), [update_role](#update_role), [update_redis_acl](#update_redis_acl), [update_user](#update_user), [view_all_bdb_stats](#view_all_bdb_stats), [view_all_bdbs_alerts](#view_all_bdbs_alerts), [view_all_bdbs_info](#view_all_bdbs_info), [view_all_ldap_mappings_info](#view_all_ldap_mappings_info), [view_all_nodes_alerts](view_all_nodes_alerts), [view_all_nodes_checks](#view_all_nodes_checks), [view_all_nodes_info](#view_all_nodes_info), [view_all_nodes_stats](#view_all_nodes_stats), [view_all_proxies_info](#view_all_proxies_info), [view_all_redis_acls_info](#view_all_redis_acls_info), [view_all_roles_info](#view_all_roles_info), [view_all_shard_stats](#view_all_shard_stats), [view_all_users_info](#view_all_users_info), [view_bdb_alerts](#view_bdb_alerts), [view_bdb_info](#view_bdb_info), [view_bdb_stats](#view_bdb_stats), [view_cluster_alerts](#view_cluster_alerts), [view_cluster_info](#view_cluster_info), [view_cluster_keys](#view_cluster_keys), [view_cluster_modules](#view_cluster_modules), [view_cluster_stats](#view_cluster_stats), [view_crdb](#view_crdb), [view_crdb_list](#view_crdb_list), [view_crdb_task](#view_crdb_task), [view_crdb_task_list](#view_crdb_task_list), [view_endpoint_stats](#view_endpoint_stats), [view_ldap_config](#view_ldap_config), [view_ldap_mapping_info](#view_ldap_mapping_info), [view_license](#view_license), [view_logged_events](#view_logged_events), [view_node_alerts](#view_node_alerts), [view_node_check](#view_node_check), [view_node_info](#view_node_info), [view_node_stats](#view_node_stats), [view_proxy_info](#view_proxy_info), [view_redis_acl_info](#view_redis_acl_info), [view_redis_pass](#view_redis_pass), [view_role_info](#view_role_info), [view_shard_stats](#view_shard_stats), [view_status_of_all_node_actions](#view_status_of_all_node_actions), [view_status_of_cluster_action](#view_status_of_cluster_action), [view_status_of_node_action](#view_status_of_node_action), [view_user_info](#view_user_info)
+ |
+
+## Roles list per permission
+
+| Permission | Roles |
+|------------|-------|
+| <a name="add_cluster_module"></a>add_cluster_module| admin |
+| <a name="cancel_cluster_action"></a>cancel_cluster_action | admin |
+| <a name="cancel_node_action"></a>cancel_node_action | admin |
+| <a name="config_ldap"></a>config_ldap | admin<br />user_manager |
+| <a name="config_ocsp"></a>config_ocsp | admin |
+| <a name="create_bdb"></a>create_bdb | admin<br />cluster_member<br />db_member |
+| <a name="create_crdb"></a>create_crdb | admin<br />cluster_member<br />db_member |
+| <a name="create_ldap_mapping"></a>create_ldap_mapping | admin<br />user_manager |
+| <a name="create_new_user"></a>create_new_user | admin<br />user_manager |
+| <a name="create_redis_acl"></a>create_redis_acl | admin<br />user_manager |
+| <a name="create_role"></a>create_role | admin<br />user_manager |
+| <a name="delete_bdb"></a>delete_bdb | admin<br />cluster_member<br />db_member |
+| <a name="delete_cluster_module"></a>delete_cluster_module | admin |
+| <a name="delete_crdb"></a>delete_crdb | admin<br />cluster_member<br />db_member |
+| <a name="delete_ldap_mapping"></a>delete_ldap_mapping | admin<br />user_manager |
+| <a name="delete_redis_acl"></a>delete_redis_acl | admin<br />user_manager |
+| <a name="delete_role"></a>delete_role | admin<br />user_manager |
+| <a name="delete_user"></a>delete_user | admin<br />user_manager |
+| <a name="edit_bdb_module"></a>edit_bdb_module | admin<br />cluster_member<br />db_member |
+| <a name="failover_shard"></a>failover_shard | admin<br />cluster_member<br />db_member |
+| <a name="flush_crdb"></a>flush_crdb | admin<br />cluster_member<br />db_member |
+| <a name="install_new_license"></a>install_new_license | admin<br />user_manager |
+| <a name="migrate_shard"></a>migrate_shard | admin<br />cluster_member<br />db_member |
+| <a name="purge_instance"></a>purge_instance | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_backup_status"></a>reset_bdb_current_backup_status | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_export_status"></a>reset_bdb_current_export_status | admin<br />cluster_member<br />db_member |
+| <a name="reset_bdb_current_import_status"></a>reset_bdb_current_import_status | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_export"></a>start_bdb_export | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_import"></a>start_bdb_import | admin<br />cluster_member<br />db_member |
+| <a name="start_bdb_recovery"></a>start_bdb_recovery | admin<br />cluster_member<br />db_member |
+| <a name="start_cluster_action"></a>start_cluster_action | admin |
+| <a name="start_node_action"></a>start_node_action | admin |
+| <a name="test_ocsp_status"></a>test_ocsp_status | admin |
+| <a name="update_bdb"></a>update_bdb | admin<br />cluster_member<br />db_member |
+| <a name="update_bdb_alerts"></a>update_bdb_alerts | admin<br />cluster_member<br />db_member |
+| <a name="update_bdb_with_action"></a>update_bdb_with_action | admin<br />cluster_member<br />db_member |
+| <a name="update_cluster"></a>update_cluster | admin |
+| <a name="update_crdb"></a>update_crdb | admin<br />cluster_member<br />db_member |
+| <a name="update_ldap_mapping"></a>update_ldap_mapping | admin<br />user_manager |
+| <a name="update_node"></a>update_node | admin |
+| <a name="update_proxy"></a>update_proxy | admin<br />user_manager |
+| <a name="update_redis_acl"></a>update_redis_acl | admin<br />user_manager |
+| <a name="update_role"></a>update_role | admin<br />user_manager |
+| <a name="update_user"></a>update_user | admin<br />user_manager |
+| <a name="view_all_bdb_stats"></a>view_all_bdb_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_bdbs_alerts"></a>view_all_bdbs_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_bdbs_info"></a>view_all_bdbs_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_ldap_mappings_info"></a>view_all_ldap_mappings_info | admin<br />user_manager |
+| <a name="view_all_nodes_alerts"></a>view_all_nodes_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_nodes_checks"></a>view_all_nodes_checks | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_nodes_info"></a>view_all_nodes_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_nodes_stats"></a>view_all_nodes_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_proxies_info"></a>view_all_proxies_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_redis_acls_info"></a>view_all_redis_acls_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_roles_info"></a>view_all_roles_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_shard_stats"></a>view_all_shard_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_all_users_info"></a>view_all_users_info | admin<br />user_manager |
+| <a name="view_bdb_alerts"></a>view_bdb_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |<a
+| <a name="view_bdb_info"></a>view_bdb_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_bdb_recovery_plan"></a>view_bdb_recovery_plan | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_bdb_stats"></a>view_bdb_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_cluster_alerts"></a>view_cluster_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_cluster_info"></a>view_cluster_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_cluster_keys"></a>view_cluster_keys | admin<br />cluster_member<br />user_manager |
+| <a name="view_cluster_modules"></a>view_cluster_modules | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_cluster_stats"></a>view_cluster_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_crdb"></a>view_crdb | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_crdb_list"></a>view_crdb_list | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_crdb_task"></a>view_crdb_task | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_crdb_task_list"></a>view_crdb_task_list | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_debugging_info"></a>view_debugging_info | admin<br />cluster_member<br />db_member<br />user_manager |
+| <a name="view_endpoint_stats"></a>view_endpoint_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_ldap_config"></a>view_ldap_config | admin<br />user_manager |
+| <a name="view_ldap_mapping_info"></a>view_ldap_mapping_info | admin<br />user_manager |
+| <a name="view_license"></a>view_license | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_logged_events"></a>view_logged_events | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />user_manager |
+| <a name="view_node_alerts"></a>view_node_alerts | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_node_check"></a>view_node_check | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_node_info"></a>view_node_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_node_stats"></a>view_node_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_ocsp_config"></a>view_ocsp_config | admin |
+| <a name="view_ocsp_status"></a>view_ocsp_status | admin |
+| <a name="view_proxy_info"></a>view_proxy_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_redis_acl_info"></a>view_redis_acl_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_redis_pass"></a>view_redis_pass | admin<br />cluster_member<br />db_member<br />user_manager |
+| <a name="view_role_info"></a>view_role_info | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_shard_stats"></a>view_shard_stats | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_status_of_all_node_actions"></a>view_status_of_all_node_actions | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_status_of_cluster_action"></a>view_status_of_cluster_action | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_status_of_node_action"></a>view_status_of_node_action | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+| <a name="view_user_info"></a>view_user_info | admin<br />user_manager |
+---
+Title: Redis Enterprise Software REST API quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software REST API quick start
+linkTitle: Quick start
+weight: 20
+---
+
+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.
+
+| Type | Description |
+|------|-------------|
+| [Authentication]({{< relref "/operate/rs/references/rest-api#authentication" >}}) | Use [Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication) with your cluster username (email) and password |
+| [Ports]({{< relref "/operate/rs/references/rest-api#ports" >}}) | All calls are made to port 9443 by default |
+| [Versions]({{< relref "/operate/rs/references/rest-api#versions" >}}) | Specify the version in the request [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) |
+| [Headers]({{< relref "/operate/rs/references/rest-api#headers" >}}) | `Accept` and `Content-Type` should be `application/json` |
+| [Response types and error codes]({{< relref "/operate/rs/references/rest-api#response-types-and-error-codes" >}}) | A response of `200 OK` means success; otherwise, the request failed due to an error |  
+
+For more information, see [Redis Enterprise Software REST API]({{< relref "/operate/rs/references/rest-api/" >}}).
+
+## cURL example requests
+
+[cURL](https://curl.se/) is a command-line tool that allows you to send HTTP requests from a terminal.
+
+You can use the following options to build a cURL request:
+
+| Option | Description |
+|--------|-------------|
+| -X     | Method (GET, PUT, PATCH, POST, or DELETE) |
+| -H     | Request header, can be specified multiple times |
+| -u     | Username and password information |
+| -d     | JSON data for PUT or POST requests |
+| -F     | Form data for PUT or POST requests, such as for the [`POST /v1/modules`]({{< relref "/operate/rs/references/rest-api/requests/modules/#post-module" >}}) or [`POST /v2/modules`]({{< relref "/operate/rs/references/rest-api/requests/modules/#post-module-v2" >}}) endpoint |
+| -k     | Turn off SSL  verification |
+| -i     | Show headers and status code as well as the response body |
+
+See the [cURL documentation](https://curl.se/docs/) for more information.
+
+### GET request
+
+Use the following cURL command to get a list of databases with the [GET `/v1/bdbs/`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#get-all-bdbs" >}}) endpoint.
+
+```sh
+$ curl -X GET -H "accept: application/json" \
+              -u "[username]:[password]" \
+              https://[host][:port]/v1/bdbs -k -i
+
+HTTP/1.1 200 OK
+server: envoy
+date: Tue, 14 Jun 2022 19:24:30 GMT
+content-type: application/json
+content-length: 2833
+cluster-state-id: 42
+x-envoy-upstream-service-time: 25
+
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+```
+
+In the response body, the `uid` is the database ID. You can use the database ID to view or update the database using the API.
+
+For more information about the fields returned by [GET `/v1/bdbs/`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#get-all-bdbs" >}}), see the [`bdbs` object]({{< relref "/operate/rs/references/rest-api/objects/bdb/" >}}).
+
+### PUT request
+
+Once you have the database ID, you can use [PUT `/v1/bdbs/`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#put-bdbs" >}}) to update the configuration of the database.
+
+For example, you can pass the database `uid` 1 as a URL parameter and use the `-d` option to specify the new `name` when you send the request. This changes the database's `name` from `tr01` to `database1`:
+
+```sh
+$ curl -X PUT -H "accept: application/json" \
+            -H "content-type: application/json" \
+            -u "cameron.bates@redis.com:test123" \
+            https://[host]:[port]/v1/bdbs/1 \
+            -d '{ "name": "database1" }' -k -i
+HTTP/1.1 200 OK
+server: envoy
+date: Tue, 14 Jun 2022 20:00:25 GMT
+content-type: application/json
+content-length: 2933
+cluster-state-id: 43
+x-envoy-upstream-service-time: 159
+
+{
+    ...
+    "name" : "database1",
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+For more information about the fields you can update with [PUT `/v1/bdbs/`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#put-bdbs" >}}), see the [`bdbs` object]({{< relref "/operate/rs/references/rest-api/objects/bdb/" >}}).
+
+## Client examples
+
+You can also use client libraries to make API requests in your preferred language.
+
+To follow these examples, you need:
+
+- A [Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}) node
+- Python 3 and the [requests](https://pypi.org/project/requests/) Python library
+- [node.js](https://nodejs.dev/) and [node-fetch](https://www.npmjs.com/package/node-fetch)
+
+### Python
+
+```python
+import json
+import requests
+
+# Required connection information - replace with your host, port, username, and password
+host = "[host]"
+port = "[port]"
+username = "[username]"
+password = "[password]"
+
+# Get the list of databases using GET /v1/bdbs
+bdbs_uri = "https://{}:{}/v1/bdbs".format(host, port)
+
+print("GET {}".format(bdbs_uri))
+get_resp = requests.get(bdbs_uri,
+        auth = (username, password),
+        headers = { "accept" : "application/json" },
+        verify = False)
+
+print("{} {}".format(get_resp.status_code, get_resp.reason))
+for header in get_resp.headers.keys():
+    print("{}: {}".format(header, get_resp.headers[header]))
+
+print("\n" + json.dumps(get_resp.json(), indent=4))
+
+# Rename all databases using PUT /v1/bdbs
+for bdb in get_resp.json():
+    uid = bdb["uid"] # Get the database ID from the JSON response
+
+    put_uri = "{}/{}".format(bdbs_uri, uid)
+    new_name = "database{}".format(uid)
+    put_data = { "name" : new_name }
+
+    print("PUT {} {}".format(put_uri, json.dumps(put_data)))
+
+    put_resp = requests.put(put_uri,
+        data = json.dumps(put_data),
+        auth = (username, password),
+        headers = { "content-type" : "application/json" },
+        verify = False)
+
+    print("{} {}".format(put_resp.status_code, put_resp.reason))
+    for header in put_resp.headers.keys():
+        print("{}: {}".format(header, put_resp.headers[header]))
+
+    print("\n" + json.dumps(put_resp.json(), indent=4))
+```
+
+See the [Python requests library documentation](https://requests.readthedocs.io/en/latest/) for more information.
+
+#### Output
+
+```sh
+$ python rs_api.py
+python rs_api.py
+GET https://[host]:[port]/v1/bdbs
+InsecureRequestWarning: Unverified HTTPS request is being made to host '[host]'.
+Adding certificate verification is strongly advised.
+See: https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+  warnings.warn(
+200 OK
+server: envoy
+date: Wed, 15 Jun 2022 15:49:43 GMT
+content-type: application/json
+content-length: 2832
+cluster-state-id: 89
+x-envoy-upstream-service-time: 27
+
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+
+PUT https://[host]:[port]/v1/bdbs/1 {"name": "database1"}
+InsecureRequestWarning: Unverified HTTPS request is being made to host '[host]'.
+Adding certificate verification is strongly advised.
+See: https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html#ssl-warnings
+  warnings.warn(
+200 OK
+server: envoy
+date: Wed, 15 Jun 2022 15:49:43 GMT
+content-type: application/json
+content-length: 2933
+cluster-state-id: 90
+x-envoy-upstream-service-time: 128
+
+{
+    ...
+    "name" : "database1",
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+### node.js
+
+```js
+import fetch, { Headers } from 'node-fetch';
+import * as https from 'https';
+
+const HOST = '[host]';
+const PORT = '[port]';
+const USERNAME = '[username]';
+const PASSWORD = '[password]';
+
+// Get the list of databases using GET /v1/bdbs
+const BDBS_URI = `https://${HOST}:${PORT}/v1/bdbs`;
+const USER_CREDENTIALS = Buffer.from(`${USERNAME}:${PASSWORD}`).toString('base64');
+const AUTH_HEADER = `Basic ${USER_CREDENTIALS}`;
+
+console.log(`GET ${BDBS_URI}`);
+
+const HTTPS_AGENT = new https.Agent({
+    rejectUnauthorized: false
+});
+
+const response = await fetch(BDBS_URI, {
+    method: 'GET',
+    headers: {
+        'Accept': 'application/json',
+        'Authorization': AUTH_HEADER
+    },
+    agent: HTTPS_AGENT
+});
+
+const responseObject = await response.json();
+console.log(`${response.status}: ${response.statusText}`);
+console.log(responseObject);
+
+// Rename all databases using PUT /v1/bdbs
+for (const database of responseObject) {
+    const DATABASE_URI = `${BDBS_URI}/${database.uid}`;
+    const new_name = `database${database.uid}`;
+
+    console.log(`PUT ${DATABASE_URI}`);
+
+    const response = await fetch(DATABASE_URI, {
+        method: 'PUT',
+        headers: {
+            'Authorization': AUTH_HEADER,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            'name': new_name
+        }),
+        agent: HTTPS_AGENT
+    });
+
+    console.log(`${response.status}: ${response.statusText}`);
+    console.log(await(response.json()));
+}
+```
+
+See the [node-fetch documentation](https://www.npmjs.com/package/node-fetch) for more info.
+
+#### Output
+
+```sh
+$ node rs_api.js
+GET https://[host]:[port]/v1/bdbs
+200: OK
+[
+    {
+        ...
+        "name": "tr01",
+        ...
+        "slave_ha" : false,
+        ...
+        "uid": 1,
+        "version": "6.0.16",
+        "wait_command": true
+    }
+]
+PUT https://[host]:[port]/v1/bdbs/1
+200: OK
+{
+    ...
+    "name" : "tr01",
+    ...
+    "slave_ha" : true,
+    ...
+    "uid" : 1,
+    "version" : "6.0.16",
+    "wait_command" : true
+}
+```
+
+## More info
+
+- [Redis Enterprise Software REST API]({{< relref "/operate/rs/references/rest-api/" >}})
+- [Redis Enterprise Software REST API requests]({{< relref "/operate/rs/references/rest-api/requests/" >}})
+---
+Title: DB metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the DB metrics used with Redis Enterprise Software REST API
+  calls.
+linkTitle: DB metrics
+weight: $weight
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| avg_latency | float | Average latency of operations on the DB (microseconds). Only returned when there is traffic. |
+| avg_other_latency | float | Average latency of other (non read/write) operations (microseconds). Only returned when there is traffic. |
+| avg_read_latency | float | Average latency of read operations (microseconds). Only returned when there is traffic. |
+| avg_write_latency | float | Average latency of write operations (microseconds). Only returned when there is traffic. |
+| big_del_flash | float | Rate of key deletes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_del_ram | float | Rate of key deletes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| big_fetch_flash | float | Rate of key reads/updates for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_fetch_ram | float | Rate of key reads/updates for keys in RAM (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_flash | float | Rate of key operations on flash. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_redis | float | Rate of Redis operations on keys. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_flash | float | Rate of key writes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_ram | float | Rate of key writes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| bigstore_io_dels | float | Rate of key deletions from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_read_bytes | float | Throughput of I/O read operations against backend flash |for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_reads | float | Rate of key reads from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_write_bytes | float | Throughput of I/O write operations against backend flash |for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_writes | float | Rate of key writes from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards of the DB (BigRedis) (ops/sec). Only returned when BigRedis is enabled. |
+| bigstore_kv_ops | float | Rate of value read/write/del operations against backend flash for all shards of the DB (BigRedis) (key access/sec). Only returned when BigRedis is enabled |
+| bigstore_objs_flash | float | Value count on flash (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_objs_ram | float | Value count in RAM (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| conns | float | Number of client connections to the DB’s endpoints |
+| disk_frag_ratio | float | Flash fragmentation ratio (used/required). Only returned when BigRedis is enabled. |
+| egress_bytes | float | Rate of outgoing network traffic to the DB’s endpoint (bytes/sec) |
+| evicted_objects | float | Rate of key evictions from DB (evictions/sec) |
+| expired_objects | float | Rate keys expired in DB (expirations/sec) |
+| fork_cpu_system | float | % cores utilization in system mode for all Redis shard fork child processes of this database |
+| fork_cpu_user | float | % cores utilization in user mode for all Redis shard fork child processes of this database |
+| ingress_bytes | float | Rate of incoming network traffic to the DB’s endpoint (bytes/sec) |
+| instantaneous_ops_per_sec | float | Request rate handled by all shards of the DB (ops/sec) |
+| last_req_time | date, ISO_8601 format | Last request time received to the DB (ISO format 2015-07-05T22:16:18Z). Returns 1/1/1970 when unavailable. |
+| last_res_time | date, ISO_8601 format | Last response time received from DB (ISO format 2015-07-05T22:16:18Z). Returns 1/1/1970 when unavailable. |
+| main_thread_cpu_system | float | % cores utilization in system mode for all Redis shard main threads of this database |
+| main_thread_cpu_user | float | % cores utilization in user mode for all Redis shard main threads of this database |
+| mem_frag_ratio | float | RAM fragmentation ratio (RSS/allocated RAM) |
+| mem_not_counted_for_evict | float | Portion of used_memory (in bytes) not counted for eviction and OOM errors |
+| mem_size_lua | float | Redis Lua scripting heap size (bytes) |
+| monitor_sessions_count | float | Number of client connected in monitor mode to the DB |
+| no_of_expires | float | Number of volatile keys in the DB |
+| no_of_keys | float | Number of keys in the DB |
+| other_req | float | Rate of other (non read/write) requests on DB (ops/sec) |
+| other_res | float | Rate of other (non read/write) responses on DB (ops/sec) |
+| pubsub_channels | float | Count the pub/sub channels with subscribed clients |
+| pubsub_patterns | float | Count the pub/sub patterns with subscribed clients |
+| ram_overhead | float | Non values RAM overhead (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| read_hits | float | Rate of read operations accessing an existing key (ops/sec) |
+| read_misses | float | Rate of read operations accessing a nonexistent key (ops/sec) |
+| read_req | float | Rate of read requests on DB (ops/sec) |
+| read_res | float | Rate of read responses on DB (ops/sec) |
+| shard_cpu_system | float | % cores utilization in system mode for all Redis shard processes of this database |
+| shard_cpu_user | float | % cores utilization in user mode for the Redis shard process |
+| total_connections_received | float | Rate of new client connections to the DB (connections/sec) |
+| total_req | float | Rate of all requests on DB (ops/sec) |
+| total_res | float | Rate of all responses on DB (ops/sec) |
+| used_bigstore | float | Flash used by DB (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| used_memory | float | Memory used by DB (in BigRedis this includes flash) (bytes) |
+| used_ram | float | RAM used by DB (BigRedis) (bytes). Only returned when BigRedis is enabled. |
+| write_hits | float | Rate of write operations accessing an existing key (ops/sec) |
+| write_misses | float | Rate of write operations accessing a nonexistent key (ops/sec) |
+| write_req | float | Rate of write requests on DB (ops/sec) |
+| write_res | float | Rate of write responses on DB (ops/sec) |---
+Title: Node metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node metrics used with Redis Enterprise Software REST API
+  calls.
+linkTitle: node metrics
+weight: $weight
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| available_flash | float | Available flash on the node (bytes) |
+| available_memory | float | Available RAM on the node (bytes) |
+| avg_latency | float | Average latency of requests handled by endpoints on the node (micro-sec); returned only when there is traffic |
+| bigstore_free | float | Free space of backend flash (used by flash DB's BigRedis) (bytes); returned only when BigRedis is enabled |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (ops/sec); returned only when BigRedis is enabled |
+| bigstore_kv_ops | float | Rate of value read/write operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (ops/sec); returned only when BigRedis is enabled |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) on the node (bytes/sec); returned only when BigRedis is enabled |
+| conns | float | Number of clients connected to endpoints on the node |
+| cpu_idle | float | CPU idle time portion (0-1, multiply by 100 to get percent) |
+| cpu_system | float | CPU time portion spent in kernel (0-1, multiply by 100 to get percent) |
+| cpu_user | float | CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| cur_aof_rewrites | float | Number of current AOF rewrites by shards on this node |
+| egress_bytes | float | Rate of outgoing network traffic to the node (bytes/sec) |
+| ephemeral_storage_avail | float | Disk space available to Redis Enterprise processes on configured ephemeral disk (bytes) |
+| ephemeral_storage_free | float | Free disk space on configured ephemeral disk (bytes) |
+| free_memory | float | Free memory on the node (bytes) |
+| ingress_bytes | float | Rate of incoming network traffic to the node (bytes/sec) |
+| persistent_storage_avail | float | Disk space available to Redis Enterprise processes on configured persistent disk (bytes) |
+| persistent_storage_free | float | Free disk space on configured persistent disk (bytes) |
+| provisional_flash | float | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| provisional_memory | float | Amount of RAM available for new shards on this node, taking into account overbooking, max Redis servers, reserved memory, and provision and migration thresholds (bytes) |
+| total_req | float | Request rate handled by endpoints on the node (ops/sec) |
+---
+Title: Cluster metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster metrics used with Redis Enterprise Software REST
+  API calls.
+linkTitle: cluster metrics
+weight: $weight
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| available_flash | float | Sum of available flash in all nodes (bytes) |
+| available_memory | float | Sum of available memory in all nodes (bytes) |
+| avg_latency | float | Average latency of requests handled by all cluster endpoints (micro-sec); returned only when there is traffic |
+| bigstore_free | float | Sum of free space of backend flash (used by flash DB's BigRedis) on all cluster nodes (bytes); only returned when BigRedis is enabled |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| bigstore_kv_ops | float | Rate of value read/write operations against back-end flash for all shards which are part of a flash based DB (BigRedis) in cluster (ops/sec); only returned when BigRedis is enabled |
+| bigstore_throughput | float | Throughput I/O operations against backend flash for all shards which are part of a flash-based DB (BigRedis) in the cluster (bytes/sec); only returned when BigRedis is enabled |
+| conns | float | Total number of clients connected to all cluster endpoints |
+| cpu_idle | float | CPU idle time portion, the value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent) |
+| cpu_system | float | CPU time portion spent in kernel on the cluster, the value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent) |
+| cpu_user | float | CPU time portion spent by users-pace processes on the cluster. The value is weighted between all nodes based on number of cores in each node (0-1, multiply by 100 to get percent). |
+| egress_bytes | float | Sum of rate of outgoing network traffic on all cluster nodes (bytes/sec) |
+| ephemeral_storage_avail | float | Sum of disk space available to Redis Enterprise processes on configured ephemeral disk on all cluster nodes (bytes) |
+| ephemeral_storage_free | float | Sum of free disk space on configured ephemeral disk on all cluster nodes (bytes) |
+| free_memory | float | Sum of free memory in all cluster nodes (bytes) |
+| ingress_bytes | float | Sum of rate of incoming network traffic on all cluster nodes (bytes/sec) |
+| persistent_storage_avail | float | Sum of disk space available to Redis Enterprise processes on configured persistent disk on all cluster nodes (bytes) |
+| persistent_storage_free | float | Sum of free disk space on configured persistent disk on all cluster nodes (bytes) |
+| provisional_flash | float | Sum of provisional flash in all nodes (bytes) |
+| provisional_memory | float | Sum of provisional memory in all nodes (bytes) |
+| total_req | float | Request rate handled by all endpoints on the cluster (ops/sec) |
+---
+Title: Statistics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains metrics for clusters, databases, nodes, or shards
+hideListLinks: true
+linkTitle: statistics
+weight: $weight
+---
+
+## Statistics overview
+
+Clusters, databases, nodes, and shards collect various statistics at regular time intervals. View the statistics for these objects using `GET stats` requests to their respective endpoints:
+- [Cluster stats]({{< relref "/operate/rs/references/rest-api/requests/cluster/stats" >}})
+- [Database stats]({{< relref "/operate/rs/references/rest-api/requests/bdbs/stats" >}})
+- [Node stats]({{< relref "/operate/rs/references/rest-api/requests/nodes/stats" >}})
+- [Shard stats]({{< relref "/operate/rs/references/rest-api/requests/shards/stats" >}})
+
+View endpoint stats using `GET` requests, see:
+- [Endpoint stats]({{< relref "/operate/rs/references/rest-api/requests/endpoints-stats" >}})
+
+### Response object
+
+Statistics returned from API requests always contain the following fields:
+- `interval`: a string that represents the statistics time interval. Valid values include: 
+    - 1sec
+    - 10sec
+    - 5min
+    - 15min
+    - 1hour
+    - 12hour
+    - 1week
+- `stime`: a timestamp that represents the beginning of the interval, in the format "2015-05-27T12:00:00Z"
+- `etime`: a timestamp that represents the end of the interval, in the format "2015-05-27T12:00:00Z"
+
+The statistics returned by the API also contain fields that represent the values of different metrics for an object during the specified time interval.
+
+More details about the metrics relevant to each object:
+- [Cluster metrics]({{< relref "/operate/rs/references/rest-api/objects/statistics/cluster-metrics" >}})
+- [DB metrics]({{< relref "/operate/rs/references/rest-api/objects/statistics/db-metrics" >}})
+- [Node metrics]({{< relref "/operate/rs/references/rest-api/objects/statistics/node-metrics" >}})
+- [Shard metrics]({{< relref "/operate/rs/references/rest-api/objects/statistics/shard-metrics" >}})
+
+{{<note>}}
+Certain statistics are not documented because they are for internal use only and should be ignored. Some statistics will only appear in API responses when they are relevant.
+{{</note>}}
+
+### Optional URL parameters
+
+There are several optional URL parameters you can pass to the various `GET stats` requests to filter the returned statistics.
+
+- `stime`: limit the start of the time range of the returned statistics
+- `etime`: limit the end of the time range of the returned statistics
+- `metrics`: only return the statistics for the specified metrics (comma-separated list)
+
+## Maximum number of samples per interval
+
+The system retains a maximum number of most recent samples for each interval.
+
+| Interval | Max samples |
+|----------|-------------|
+| 1sec     | 10 |
+| 10sec    | 30 |
+| 5min     | 12 |
+| 15min    | 96 |
+| 1hour    | 168 |
+| 12hour   | 62 |
+| 1week    | 53 |
+
+The actual number of samples returned by a `GET stats` request depends on how many samples are available and any filters applied by the optional URL parameters. For example, newly created objects (clusters, nodes, databases, or shards) or a narrow time filter range will return fewer samples.
+
+{{<note>}}
+To reduce load generated by stats collection, relatively inactive databases or shards (less than 5 ops/sec) do not collect 1sec stats at one second intervals. Instead, they collect 1sec stats every 2-5 seconds but still retain the same maximum number of samples.
+{{</note>}}
+---
+Title: Shard metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the shard metrics used with Redis Enterprise Software REST
+  API calls.
+linkTitle: shard metrics
+weight: $weight
+---
+
+| Metric name | Type | Description |
+|-------------|------|-------------|
+| aof_rewrite_inprog | float | The number of simultaneous AOF rewrites that are in progress |
+| avg_ttl | float | Estimated average time to live of a random key (msec) |
+| big_del_flash | float | Rate of key deletes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_del_ram | float | Rate of key deletes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| big_fetch_flash | float | Rate of key reads/updates for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_fetch_ram | float | Rate of key reads/updates for keys in RAM (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_flash | float | Rate of key operations on flash. Can be used to compute the ratio of I/O operations (key access/sec). Only returned when BigRedis is enabled. |
+| big_io_ratio_redis | float | Rate of Redis operations on keys. Can be used to compute the ratio of I/O operations) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_flash | float | Rate of key writes for keys on flash (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| big_write_ram | float | Rate of key writes for keys in RAM (BigRedis) (key access/sec); this includes write misses (new keys created). Only returned when BigRedis is enabled. |
+| bigstore_io_dels | float | Rate of key deletions from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_read_bytes | float | Throughput of I/O read operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_reads | float | Rate of key reads from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_write_bytes | float | Throughput of I/O write operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| bigstore_io_writes | float | Rate of key writes from flash (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_iops | float | Rate of I/O operations against backend flash for all shards of the DB (BigRedis) (ops/sec). Only returned when BigRedis is enabled. |
+| bigstore_kv_ops | float | Rate of value read/write/del operations against backend flash for all shards of the DB (BigRedis) (key access/sec). Only returned when BigRedis is enabled. |
+| bigstore_objs_flash | float | Key count on flash (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_objs_ram | float | Key count in RAM (BigRedis). Only returned when BigRedis is enabled. |
+| bigstore_throughput | float | Throughput of I/O operations against backend flash for all shards of the DB (BigRedis) (bytes/sec). Only returned when BigRedis is enabled. |
+| blocked_clients | float | Count the clients waiting on a blocking call |
+| connected_clients | float | Number of client connections to the specific shard |
+| disk_frag_ratio | float | Flash fragmentation ratio (used/required). Only returned when BigRedis is enabled. |
+| evicted_objects | float | Rate of key evictions from DB (evictions/sec) |
+| expired_objects | float | Rate keys expired in DB (expirations/sec) |
+| fork_cpu_system | float | % cores utilization in system mode for the Redis shard fork child process |
+| fork_cpu_user | float | % cores utilization in user mode for the Redis shard fork child process |
+| last_save_time | float | Time of the last RDB save |
+| main_thread_cpu_system | float | % cores utilization in system mode for the Redis shard main thread |
+| main_thread_cpu_user | float | % cores utilization in user mode for the Redis shard main thread |
+| mem_frag_ratio | float | RAM fragmentation ratio (RSS/allocated RAM) |
+| mem_not_counted_for_evict | float | Portion of used_memory (in bytes) not counted for eviction and OOM errors |
+| mem_size_lua | float | Redis Lua scripting heap size (bytes) |
+| no_of_expires | float | Number of volatile keys on the shard |
+| no_of_keys | float | Number of keys in DB |
+| pubsub_channels | float | Count the pub/sub channels with subscribed clients |
+| pubsub_patterns | float | Count the pub/sub patterns with subscribed clients |
+| rdb_changes_since_last_save | float | Count changes since last RDB save |
+| read_hits | float | Rate of read operations accessing an existing key (ops/sec) |
+| read_misses | float | Rate of read operations accessing a nonexistent key (ops/sec) |
+| shard_cpu_system | float | % cores utilization in system mode for the Redis shard process |
+| shard_cpu_user | float | % cores utilization in user mode for the Redis shard process |
+| total_req | float | Rate of operations on DB (ops/sec) |
+| used_memory | float | Memory used by shard (in BigRedis this includes flash) (bytes) |
+| used_memory_peak | float | The largest amount of memory used by this shard (bytes) |
+| used_memory_rss | float | Resident set size of this shard (bytes) |
+| write_hits | float | Rate of write operations accessing an existing key (ops/sec) |
+| write_misses | float | Rate of write operations accessing a nonexistent key (ops/sec) |
+---
+Title: Alert settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the alert_settings object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: alert_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cluster_certs_about_to_expire | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Cluster certificate will expire in x days |
+| cluster_even_node_count | boolean (default: false) | True high availability requires an odd number of nodes in the cluster |
+| cluster_flash_overcommit | boolean (default: false) | Flash memory committed to databases is larger than cluster total flash memory |
+| cluster_inconsistent_redis_sw | boolean (default: false) | Some shards in the cluster are running different versions of Redis software |
+| cluster_inconsistent_rl_sw | boolean (default: false) | Some nodes in the cluster are running different versions of Redis Enterprise software |
+| cluster_internal_bdb | boolean (default: false) | Issues with internal cluster databases |
+| cluster_license_about_to_expire | <span class="break-all">[cluster_alert_settings_with_threshold]({{<relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold">}})</span> object | Cluster license will expire in x days. This alert is enabled by default. Its default threshold is 7 days before license expiration. |
+| cluster_multiple_nodes_down | boolean (default: false) | Multiple cluster nodes are down (this might cause data loss) |
+| cluster_node_joined | boolean (default: false) | New node joined the cluster |
+| cluster_node_remove_abort_completed | boolean (default: false) | Cancel node remove operation completed |
+| cluster_node_remove_abort_failed | boolean (default: false) | Cancel node remove operation failed |
+| cluster_node_remove_completed | boolean (default: false) | Node removed from the cluster |
+| cluster_node_remove_failed | boolean (default: false) | Failed to remove a node from the cluster |
+| cluster_ocsp_query_failed | boolean (default: false) | Failed to query the OCSP server |
+| cluster_ocsp_status_revoked | boolean (default: false) | OCSP certificate status is REVOKED |
+| cluster_ram_overcommit | boolean (default: false) | RAM committed to databases is larger than cluster total RAM |
+| cluster_too_few_nodes_for_replication | boolean (default: false) | Replication requires at least 2 nodes in the cluster |
+| node_aof_slow_disk_io | boolean (default: false) | AOF reaching disk I/O limits
+| node_checks_error | boolean (default: false) | Some node checks have failed |
+| node_cpu_utilization | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node CPU utilization has reached the threshold value (% of the utilization limit) |
+| node_ephemeral_storage | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node ephemeral storage has reached the threshold value (% of the storage limit) |
+| node_failed | boolean (default: false) | Node failed |
+| node_free_flash | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node flash storage has reached the threshold value (% of the storage limit) |
+| node_insufficient_disk_aofrw | boolean (default: false) | Insufficient AOF disk space |
+| node_internal_certs_about_to_expire | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object| Internal certificate on node will expire in x days |
+| node_memory | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node memory has reached the threshold value (% of the memory limit) |
+| node_net_throughput | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node network throughput has reached the threshold value (bytes/s) |
+| node_persistent_storage | <span class="break-all">[cluster_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/cluster/cluster_alert_settings_with_threshold" >}})</span> object | Node persistent storage has reached the threshold value (% of the storage limit) |
+---
+Title: Cluster alert settings with threshold object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster_alert_settings_with_threshold object used with
+  Redis Enterprise Software REST API calls.
+linkTitle: cluster_alert_settings_with_threshold
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| enabled    | boolean (default:&nbsp;false)  | Alert enabled or disabled |
+| threshold  | string                    | Threshold for alert going on/off |
+---
+Title: Cluster object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a cluster
+hideListLinks: true
+linkTitle: cluster
+weight: $weight
+---
+
+An API object that represents the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| alert_settings | [alert_settings]({{< relref "/operate/rs/references/rest-api/objects/cluster/alert_settings" >}}) object | Cluster and node alert settings |
+| bigstore_driver | 'speedb'<br />'rocksdb' | Storage engine for Auto Tiering |
+| cluster_ssh_public_key | string | Cluster's autogenerated SSH public key |
+| cm_port | integer, (range:&nbsp;1024-65535) | UI HTTPS listening port |
+| <span class="break-all">cm_session_timeout_minutes</span> | integer (default:&nbsp;15) | The timeout (in minutes) for the session to the CM |
+| <span class="break-all">cnm_http_max_threads_per_worker</span> | integer (default: 10) | Maximum number of threads per worker in the `cnm_http` service (deprecated) |
+| cnm_http_port | integer, (range:&nbsp;1024-65535) | API HTTP listening port |
+| cnm_http_workers | integer (default: 1) | Number of workers in the `cnm_http` service |
+| cnm_https_port | integer, (range:&nbsp;1024-65535) | API HTTPS listening port |
+| control_cipher_suites | string | Specifies the enabled ciphers for the control plane. The ciphers are specified in the format understood by the BoringSSL library. |
+| <span class="break-all">control_cipher_suites_tls_1_3</span> | string | Specifies the enabled TLS 1.3 ciphers for the control plane. The ciphers are specified in the format understood by the BoringSSL library. (read-only) |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| crdt_rest_client_retries | integer | Maximum number of retries for the REST client used by the Active-Active management API |
+| crdt_rest_client_timeout | integer | Timeout for REST client used by the Active-Active management API |
+| created_time | string | Cluster creation date (read-only) |
+| data_cipher_list | string | Specifies the enabled ciphers for the data plane. The ciphers are specified in the format understood by the OpenSSL library. |
+| <span class="break-all">data_cipher_suites_tls_1_3</span> | string | Specifies the enabled TLS 1.3 ciphers for the data plane. |
+| debuginfo_path | string | Path to a local directory used when generating support packages |
+| <span class="break-all">default_non_sharded_proxy_policy</span> | string (default:&nbsp;single) | Default proxy_policy for newly created non-sharded databases' endpoints (read-only) |
+| <span class="break-all">default_sharded_proxy_policy</span> | string (default:&nbsp;all-master-shards) | Default proxy_policy for newly created sharded databases' endpoints (read-only) |
+| email_alerts | boolean (default:&nbsp;false) | Send node/cluster email alerts (requires valid SMTP and email_from settings) |
+| email_from | string | Sender email for automated emails |
+| encrypt_pkeys | boolean (default:&nbsp;false) | Enable or turn off encryption of private keys |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| <span class="break-all">envoy_max_downstream_connections</span> | integer, (range:&nbsp;100-2048) | The max downstream connections envoy is allowed to open |
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| handle_redirects | boolean (default:&nbsp;false) | Handle API HTTPS requests and redirect to the master node internally |
+| http_support | boolean (default:&nbsp;false) | Enable or turn off HTTP support |
+| min_control_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the control path |
+| min_data_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the data path |
+| min_sentinel_TLS_version | '1.2'<br />'1.3' | The minimum version of TLS protocol which is supported at the data path |
+| mtls_authorized_subjects | array | {{<code>}}[{<br />  "CN": string,<br />  "O": string,<br />  "OU": [array of strings],<br />  "L": string,<br />  "ST": string,<br />  "C": string<br />}, ...]{{</code>}} A list of valid subjects used for additional certificate validations during TLS client authentication. All subject attributes are case-sensitive.<br />**Required subject fields**:<br />"CN" for Common Name<br />**Optional subject fields:**<br />"O" for Organization<br />"OU" for Organizational Unit (array of strings)<br />"L" for Locality (city)<br />"ST" for State/Province<br />"C" for 2-letter country code |
+| <span class="break-all">mtls_certificate_authentication</span> | boolean | Require authentication of client certificates for mTLS connections to the cluster. The API_CA certificate should be configured as a prerequisite. |
+| <span class="break-all">mtls_client_cert_subject_validation_type</span> | `disabled`<br />`san_cn`<br />`full_subject` | Enables additional certificate validations that further limit connections to clients with valid certificates during TLS client authentication.<br />Values:<br />**disabled**: Authenticates clients with valid certificates. No additional validations are enforced.<br />**san_cn**: A client certificate is valid only if its Common Name (CN) matches an entry in the list of valid subjects. Ignores other Subject attributes.<br />**full_subject**: A client certificate is valid only if its Subject attributes match an entry in the list of valid subjects. |
+| name | string | Cluster's fully qualified domain name (read-only) |
+| password_complexity | boolean (default:&nbsp;false) | Enforce password complexity policy |
+| <span class="break-all">password_expiration_duration</span> | integer (default:&nbsp;0) | The number of days a password is valid until the user is required to replace it |
+| password_min_length | integer, (range: 8-256) (default: 8) | The minimum length required for a password. |
+| proxy_certificate | string | Cluster's proxy certificate |
+| <span class="break-all">proxy_max_ccs_disconnection_time</span> | integer | Cluster-wide proxy timeout policy between proxy and CCS |
+| rack_aware | boolean | Cluster operates in a rack-aware mode (read-only) |
+| reserved_ports | array of strings | List of reserved ports and/or port ranges to avoid using for database endpoints (for example `"reserved_ports": ["11000", "13000-13010"]`) |
+| s3_ca_cert | string | Filepath to the PEM-encoded CA certificate to use for validating TLS connections to the S3 server |
+| s3_url | string | Specifies the URL for S3 export and import |
+| saslauthd_ldap_conf | string | saslauthd LDAP configuration |
+| sentinel_cipher_suites | array | Specifies the list of enabled ciphers for the sentinel service. The supported ciphers are those implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package. |
+| <span class="break-all">sentinel_cipher_suites_tls_1_3<span> | string | Specifies the list of enabled TLS 1.3 ciphers for the discovery (sentinel) service. The supported ciphers are those implemented by the [cipher_suites.go](<https://golang.org/src/crypto/tls/cipher_suites.go>) package.(read-only) |
+| sentinel_tls_mode | 'allowed'<br />'disabled' <br />'required' | Determines whether the discovery service allows, blocks, or requires TLS connections (previously named `sentinel_ssl_policy`)<br />**allowed**: Allows both TLS and non-TLS connections<br />**disabled**: Allows only non-TLS connections<br />**required**: Allows only TLS connections |
+| slave_ha | boolean (default:&nbsp;false) | Enable the replica high-availability mechanism (read-only) |
+| <span class="break-all">slave_ha_bdb_cooldown_period</span> | integer (default:&nbsp;86400) | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database (read-only) |
+| <span class="break-all">slave_ha_cooldown_period</span> | integer (default:&nbsp;3600) | Time in seconds between runs of the replica high-availability mechanism on different nodes (read-only) |
+| <span class="break-all">slave_ha_grace_period</span> | integer (default:&nbsp;900) | Time in seconds between a node failure and when the replica high-availability mechanism starts relocating shards (read-only) |
+| <span class="break-all">slowlog_in_sanitized_support</span> | boolean | Whether to include slowlogs in the sanitized support package |
+| smtp_host | string | SMTP server for automated emails |
+| smtp_password | string | SMTP server password |
+| smtp_port | integer | SMTP server port for automated emails |
+| smtp_tls_mode | 'none'<br />'starttls'<br />'tls' | Specifies which TLS mode to use for SMTP access |
+| smtp_use_tls | boolean (default:&nbsp;false) | Use TLS for SMTP access (deprecated as of Redis Enterprise v4.3.3, use smtp_tls_mode field instead) |
+| smtp_username | string | SMTP server username (pattern does not allow special characters &,\<,>,") |
+| syncer_certificate | string | Cluster's syncer certificate |
+| upgrade_mode | boolean (default:&nbsp;false) | Is cluster currently in upgrade mode |
+| use_external_ipv6 | boolean (default:&nbsp;true) | Should redislabs services listen on ipv6 |
+| use_ipv6 | boolean (default:&nbsp;true) | Should redislabs services listen on ipv6 (deprecated as of Redis Enterprise v6.4.2, replaced with use_external_ipv6) |
+| wait_command | boolean (default:&nbsp;true) | Supports Redis wait command (read-only) |
+---
+Title: LDAP mapping object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a mapping between an LDAP group and roles
+linkTitle: ldap_mapping
+weight: $weight
+---
+
+An API object that represents an [LDAP mapping]({{< relref "/operate/rs/security/access-control/ldap/map-ldap-groups-to-roles" >}}) between an LDAP group and [roles]({{< relref "/operate/rs/references/rest-api/objects/role" >}}).
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | LDAP mapping's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API (read-only) |
+| bdbs_email_alerts | complex object | UIDs of databases that associated email addresses will receive alerts for |
+| cluster_email_alerts | boolean | Activate cluster email alerts for an associated email |
+| dn | string | An LDAP group's distinguished name |
+| email | string | Email address used for alerts (if set) |
+| email_alerts | boolean (default:&nbsp;true) | Activate email alerts for an associated email |
+| name | string | Role's name |
+| role_uids | array of integers | List of role UIDs associated with the LDAP group |
+---
+Title: Cluster identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cluster_identity object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: cluster_identity
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| name          | string                | Fully qualified cluster name. Limited to 64 characters and must comply with the IETF's RFC 952 standard and section 2.1 of the RFC 1123 standard. |
+| nodes         | array of strings       | Array of IP addresses of existing cluster nodes |
+| wait_command  | boolean (default:&nbsp;true) | Supports Redis wait command |
+---
+Title: Identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the identity object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: identity
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Assumed node's UID to join cluster. Used to replace a dead node with a new one. |
+| accept_servers | boolean (default:&nbsp;true) | If true, no shards will be created on the node |
+| addr | string | Internal IP address of node |
+| external_addr | complex object | External IP addresses of node. `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| name | string | Node's name |
+| override_rack_id | boolean | When replacing an existing node in a rack-aware cluster, allows the new node to be located in a different rack |
+| rack_id | string | Rack ID, overrides cloud config |
+| use_internal_ipv6 | boolean (default:&nbsp;false) | Node uses IPv6 for internal communication |
+---
+Title: Credentials object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the credentials object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: credentials
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| password   | string       | Admin password |
+| username   | string       | Admin username (pattern does not allow special characters &,\<,>,") |
+---
+Title: Limits object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the limits object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: limits
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| max_listeners      | integer (default:&nbsp;100)    | Max allowed listeners on node |
+| max_redis_servers  | integer (default:&nbsp;100)    | Max allowed Redis servers on node |
+---
+Title: Paths object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the paths object used with Redis Enterprise Software REST API
+  calls.
+linkTitle: paths
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bigstore_path | string | Bigredis storage path |
+| ccs_persistent_path | string | Persistent storage path of CCS |
+| ephemeral_path | string | Ephemeral storage path |
+| persistent_path | string | Persistent storage path |
+---
+Title: Policy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the policy object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: policy
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| default_fork_evict_ram | boolean (default:&nbsp;false) | If true, the databases should evict data from RAM to ensure successful replication or persistence |
+| default_non_sharded_proxy_policy | **'single'** <br />'all-master-shards'<br />'all-nodes' | Default proxy_policy for newly created non-sharded databases' endpoints |
+| default_sharded_proxy_policy | 'single'<br /> **'all-master-shards'** <br />'all-nodes' | Default proxy_policy for newly created sharded databases' endpoints |
+| default_shards_placement | 'dense'<br /> **'sparse'** | Default shards_placement for newly created databases |
+| rack_aware | boolean | Cluster rack awareness |
+| shards_overbooking | boolean (default:&nbsp;true) | If true, all databases' memory_size settings are ignored during shards placement |
+---
+Title: Node identity object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node_identity object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: node_identity
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bigstore_driver | 'rocksdb' | Bigstore driver name or none (deprecated) |
+| bigstore_enabled | boolean | Bigstore enabled or disabled |
+| identity | [identity]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/identity" >}}) object | Node identity |
+| limits | [limits]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/limits" >}}) object | Node limits |
+| paths | [paths]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/paths" >}}) object | Storage paths object |
+---
+Title: Bootstrap object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for bootstrap configuration
+hideListLinks: true
+linkTitle: bootstrap
+weight: $weight
+---
+
+A bootstrap configuration object.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| action | 'create_cluster'<br />'join_cluster'<br />'recover_cluster' | Action to perform |
+| cluster | [cluster_identity]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/cluster_identity" >}}) object | Cluster to join or create |
+| cnm_https_port | integer | Port to join a cluster with non-default cnm_https port |
+| crdb_coordinator_port | integer, (range:&nbsp;1024-65535) (default:&nbsp;9081) | CRDB coordinator port |
+| credentials | [credentials]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/credentials" >}}) object | Cluster admin credentials |
+| dns_suffixes | {{<code>}}
+[{
+  "name": string,
+  "cluster_default": boolean,
+  "use_aaaa_ns": boolean,
+  "use_internal_addr": boolean,
+  "slaves": array
+}, ...]
+{{</code>}} | Explicit configuration of DNS suffixes<br />**name**: DNS suffix name<br />**cluster_default**: Should this suffix be the default cluster suffix<br />**use_aaaa_ns**: Should AAAA records be published for NS records<br />**use_internal_addr**: Should internal cluster IPs be published for databases<br />**slaves**: List of replica servers that should be published as NS and notified |
+| envoy_admin_port | integer, (range:&nbsp;1024-65535) | Envoy admin port. Changing this port during runtime might result in an empty response because envoy serves as the cluster gateway.|
+| envoy_mgmt_server_port | integer, (range:&nbsp;1024-65535) | Envoy management server port|
+| gossip_envoy_admin_port | integer, (range:&nbsp;1024-65535) | Gossip envoy admin port|
+| license | string | License string. If not provided, a trial license is set by default. |
+| max_retries | integer | Max number of retries in case of recoverable errors |
+| node | [node_identity]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/node_identity" >}}) object | Node description |
+| policy | [policy]({{< relref "/operate/rs/references/rest-api/objects/bootstrap/policy" >}}) object | Policy object |
+| recovery_filename | string | Name of backup file to recover from |
+| required_version | string | This node can only join the cluster if all nodes in the cluster have a version greater than the required_version (deprecated as of Redis Enterprise Software v7.8.6) |
+| retry_time | integer | Max waiting time between retries (in seconds) |
+
+
+---
+Title: Check result object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains the results of a cluster check
+linkTitle: check_result
+weight: $weight
+---
+
+Cluster check result
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cluster_test_result | boolean | Indication if any of the tests failed |
+| nodes | {{<code>}}
+[{
+  "node_uid": integer,
+  "result": boolean,
+  "error": string
+}, ...]
+{{</code>}} | Nodes results |
+---
+Title: CRDB task object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a CRDB task
+linkTitle: crdb_task
+weight: $weight
+---
+
+An object that represents an Active-Active (CRDB) task.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| id | string | CRDB task ID (read only) |
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) (read-only) |
+| errors | {{<code>}}
+[{
+  "cluster_name": string,
+  "description": string,
+  "error_code": string
+}, ...] {{</code>}} | Details for errors that occurred on a cluster |
+| status | 'queued' <br />'started' <br />'finished' <br />'failed' | CRDB task status (read only) |
+---
+Title: Entra ID agent manager object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the entraid_agent_mgr object used with Redis Enterprise Software REST API calls.
+linkTitle: entraid_agent_mgr
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the Entra ID agent manager processes |
+---
+Title: MDNS server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the mdns_server object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: mdns_server
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the multicast DNS server |
+---
+Title: CRDB worker object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the crdb_worker object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: crdb_worker
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CRDB worker processes |
+---
+Title: LDAP agent manager object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the ldap_agent_mgr object used with Redis Enterprise Software REST API calls.
+linkTitle: ldap_agent_mgr
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the LDAP agent manager processes |
+---
+Title: Stats archiver object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the stats_archiver object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: stats_archiver
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the stats archiver service |
+---
+Title: CRDB coordinator object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the crdb_coordinator object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: crdb_coordinator
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CRDB coordinator process |
+---
+Title: CM server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cm_server object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: cm_server
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the CM server |
+---
+Title: PDNS server object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the pdns_server object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: pdns_server
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the PDNS server |
+---
+Title: Alert manager object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the alert_mgr object used with Redis Enterprise Software REST API calls.
+linkTitle: alert_mgr
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| operating_mode | 'disabled'<br />'enabled' | Enable/disable the alert manager processes |
+---
+Title: Services configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for optional cluster services settings
+hideListLinks: true
+linkTitle: services_configuration
+weight: $weight
+---
+
+Optional cluster services settings
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| alert_mgr | [alert_mgr]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/alert_mgr" >}}) object | Whether to enable/disable the alert manager processes |
+| cm_server | [cm_server]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/cm_server" >}}) object | Whether to enable/disable the CM server |
+| crdb_coordinator | [crdb_coordinator]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/crdb_coordinator" >}}) object | Whether to enable/disable the CRDB coordinator process |
+| crdb_worker | [crdb_worker]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/crdb_worker" >}}) object | Whether to enable/disable the CRDB worker processes |
+| entraid_agent_mgr | [entraid_agent_mgr]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/entraid_agent_mgr" >}}) object | Whether to enable/disable the Entra ID agent manager process |
+| ldap_agent_mgr | [ldap_agent_mgr]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/ldap_agent_mgr" >}}) object | Whether to enable/disable the LDAP agent manager processes |
+| mdns_server | [mdns_server]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/mdns_server" >}}) object | Whether to enable/disable the multicast DNS server |
+| pdns_server | [pdns_server]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/pdns_server" >}}) object | Whether to enable/disable the PDNS server |
+| stats_archiver | [stats_archiver]({{< relref "/operate/rs/references/rest-api/objects/services_configuration/stats_archiver" >}}) object | Whether to enable/disable the stats archiver service |
+---
+Title: Alert object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains alert info
+linkTitle: alert
+weight: $weight
+---
+
+You can view, configure, and enable various alerts for the cluster.
+
+Alerts are bound to a cluster object (such as a [BDB]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) or [node]({{< relref "/operate/rs/references/rest-api/objects/node" >}})), and the cluster's state determines whether the alerts turn on or off.
+
+  Name  | Type/Value | Description | Writable
+|-------|------------|-------------|----------|
+| change_time | string | Timestamp when alert state last changed | |
+| change_value | object | Contains data relevant to the evaluation time when the alert went on/off (thresholds, sampled values, etc.) | |
+| enabled | boolean | If true, alert is enabled | x |
+| severity | 'DEBUG'<br />'INFO'<br />'WARNING'<br />'ERROR'<br />'CRITICAL' | The alert's severity | |
+| state | boolean | If true, alert is currently triggered | |
+| threshold | string | Represents an alert threshold when applicable | x |
+---
+Title: Cluster Manager settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: A REST API object that represents Cluster Manager UI settings
+linkTitle: cm_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| timezone | string | Configurable [time zone](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) for the Cluster Manager UI. The default time zone is UTC. |
+---
+Title: JWT authorize object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for user authentication or a JW token refresh request
+linkTitle: jwt_authorize
+weight: $weight
+---
+
+An API object for user authentication or a JW token refresh request.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| password | string | The user’s password (required) |
+| ttl | integer (range: 1-86400) (default: 300) | Time to live - The amount of time in seconds the token will be valid |
+| username | string | The user’s username (required) |
+---
+Title: Node object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a node in the cluster
+linkTitle: node
+weight: $weight
+---
+
+An API object that represents a node in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Cluster unique ID of node (read-only) |
+| accept_servers | boolean (default:&nbsp;true) | The node only accepts new shards if `accept_servers` is `true` |
+| addr | string | Internal IP address of node |
+| architecture | string | Hardware architecture (read-only) |
+| bigredis_storage_path | string | Flash storage path (read-only) |
+| bigstore_driver | 'ibm-capi-ga1'<br />'ibm-capi-ga2'<br />'ibm-capi-ga4'<br />'speedb'<br />'rocksdb' | Bigstore driver name or none (deprecated as of Redis Enterprise v7.2, use the [cluster object]({{< relref "/operate/rs/references/rest-api/objects/cluster" >}})'s bigstore_driver instead) |
+| bigstore_enabled | boolean | If true, bigstore is enabled (read-only) |
+| bigstore_size | integer | Storage size of bigstore storage (read-only) |
+| cores | integer | Total number of CPU cores (read-only) |
+| ephemeral_storage_path | string | Ephemeral storage path (read-only) |
+| ephemeral_storage_size | number | Ephemeral storage size (bytes) (read-only) |
+| external_addr | complex object | External IP addresses of node. `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| max_listeners | integer | Maximum number of listeners on the node |
+| max_redis_servers | integer | Maximum number of shards on the node |
+| os_family | 'rhel'<br />'ubuntu'<br />'amzn' | Operating system family (read-only) |
+| os_name | string | Operating system name (read-only) |
+| os_semantic_version | string | Full version number (read-only) |
+| os_version | string | Installed OS version (human-readable) (read-only) |
+| persistent_storage_path | string | Persistent storage path (read-only) |
+| persistent_storage_size | number | Persistent storage size (bytes) (read- only) |
+| public_addr | string | Public IP address of node (deprecated as of Redis Enterprise v4.3.3, use external_addr instead) |
+| rack_id | string | Rack ID where node is installed |
+| recovery_path | string | Recovery files path |
+| shard_count | integer | Number of shards on the node (read-only) |
+| shard_list | array of integers | Cluster unique IDs of all node shards |
+| software_version | string | Installed Redis Enterprise cluster software version (read-only) |
+| status | 'active'<br />'decommissioning'<br />'down'<br />'provisioning' | Node status (read-only) |
+| supported_database_versions | {{<code>}}
+[{
+  "db_type": string,
+  "version": string
+}, ...]
+{{</code>}} | Versions of Redis Open Source databases supported by Redis Enterprise Software on the node (read-only)<br />**db_type**: Type of database<br />**version**: Version of database |
+| system_time | string | System time (UTC) (read-only) |
+| total_memory | integer | Total memory of node (bytes) (read-only) |
+| uptime | integer | System uptime (seconds) (read-only) |
+| use_internal_ipv6 | boolean (default:&nbsp;false) | Node uses IPv6 for internal communication. Value is taken from bootstrap identity (read-only) |
+---
+Title: Cluster settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for cluster resource management settings
+linkTitle: cluster_settings
+weight: $weight
+---
+
+Cluster resources management policy
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| acl_pubsub_default | `resetchannels`<br /> `allchannels` | Default pub/sub ACL rule for all databases in the cluster:<br />•`resetchannels` blocks access to all channels (restrictive)<br />•`allchannels` allows access to all channels (permissive) |
+| auto_recovery | boolean (default:&nbsp;false) | Defines whether to use automatic recovery after shard failure |
+| automatic_node_offload | boolean (default:&nbsp;true) | Defines whether the cluster will automatically migrate shards from a node, in case the node is overbooked |
+| bigstore_migrate_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| bigstore_migrate_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| bigstore_provision_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| bigstore_provision_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| data_internode_encryption | boolean | Enable/deactivate encryption of the data plane internode communication |
+| db_conns_auditing | boolean | [Audit connections]({{< relref "/operate/rs/security/audit-events" >}}) for new databases by default if set to true. |
+| default_concurrent_restore_actions | integer | Default number of restore actions allowed at the same time. Set to 0 to allow any number of simultaneous restore actions. |
+| default_fork_evict_ram | boolean | If true, the bdbs should evict data from RAM to ensure successful replication or persistence |
+| default_non_sharded_proxy_policy | `single`<br /><br />`all-master-shards`</nobr><br /><br />`all-nodes` | Default proxy_policy for newly created non-sharded databases' endpoints |
+| default_oss_sharding | boolean (default: false) | Default hashing policy to use for new databases. This field is for future use only and should not be changed. |
+| default_provisioned_redis_version | string | Default Redis version |
+| default_sharded_proxy_policy | `single`<br /><br />`all-master-shards`<br /><br />`all-nodes` | Default proxy_policy for newly created sharded databases' endpoints |
+| default_shards_placement | `dense`<br />`sparse` | Default shards_placement for a newly created databases |
+| default_tracking_table_max_keys_policy | integer (default: 1000000) | Defines the default value of the client-side caching invalidation table size for new databases. 0 makes the cache unlimited. |
+| endpoint_rebind_propagation_grace_time | integer | Time to wait between the addition and removal of a proxy |
+| failure_detection_sensitivity | `high`<br />`low` | Predefined thresholds and timeouts for failure detection (previously known as <span class="break-all">`watchdog_profile`</span>)<br />• `high` (previously `local-network`) – high failure detection sensitivity, lower thresholds, faster failure detection and failover<br />• `low` (previously `cloud`) – low failure detection sensitivity, higher tolerance for latency variance (also called network jitter) |
+| hide_user_data_from_log | boolean (default: false) | Set to `true` to enable the `hide-user-data-from-log` Redis configuration setting, which avoids logging user data |
+| login_lockout_counter_reset_after | integer | Number of seconds that must elapse between failed sign in attempts before the lockout counter is reset to 0. |
+| login_lockout_duration | integer | Duration (in secs) of account lockout. If set to 0, the account lockout will persist until released by an admin. |
+| login_lockout_threshold | integer | Number of failed sign in attempts allowed before locking a user account |
+| max_saved_events_per_type | integer | Maximum saved events per event type |
+| max_simultaneous_backups | integer (default: 4) | Maximum number of backup processes allowed at the same time |
+| parallel_shards_upgrade | integer | Maximum number of shards to upgrade in parallel |
+| persistence_cleanup_scan_interval | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the Redis cleanup schedule |
+| persistent_node_removal | boolean | When removing a node, wait for persistence files to be created for all migrated shards |
+| rack_aware | boolean | Cluster operates in a rack-aware mode |
+| redis_migrate_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| redis_migrate_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before automatic migration of shards from it to free more memory |
+| redis_provision_node_threshold | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| redis_provision_node_threshold_p | integer | Minimum free memory (excluding reserved memory) allowed on a node before new shards can no longer be added to it |
+| redis_upgrade_policy | **`major`** <br />`latest` | Create/upgrade Redis Enterprise software on databases in the cluster by compatibility with major versions or latest versions of Redis Open Source |
+| resp3_default | boolean (default:&nbsp;true) | Determines the default value of the `resp3` option upon upgrading a database to version 7.2 |
+| shards_overbooking | boolean | If true, all databases' memory_size is ignored during shards placement |
+| show_internals | boolean | Show internal databases (and their shards and endpoints) REST APIs |
+| slave_ha | boolean | Enable the replica high-availability mechanism. Deprecated as of Redis Enterprise Software v7.2.4. |
+| slave_ha_bdb_cooldown_period | integer | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database |
+| slave_ha_cooldown_period | integer | Time in seconds between runs of the replica high-availability mechanism on different nodes on the same database |
+| slave_ha_grace_period | integer | Time in seconds between a node failure and when the replica high-availability mechanism starts relocating shards |
+---
+Title: Module object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a Redis module
+linkTitle: module
+weight: $weight
+---
+
+Represents a [Redis module]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}).
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | string | Cluster unique ID of module |
+| architecture | string | Architecture used to compile the module |
+| author | string | Module creator |
+| capabilities | array of strings | List of capabilities supported by this module |
+| capability_name | string | Short description of module functionality |
+| command_line_args | string | Command line arguments passed to the module |
+| compatible_redis_version | string | Redis version required by this module |
+| config_command | string | Name of command to configure module arguments at runtime |
+| dependencies | object dependencies | Module dependencies |
+| description | string | Short description of the module
+| display_name | string | Name of module for display purposes |
+| email | string | Author's email address |
+| homepage | string | Module's homepage |
+| is_bundled | boolean | Whether module came bundled with a version of Redis Enterprise |
+| license | string | Module is distributed under this license
+| min_redis_pack_version | string | Minimum Redis Enterprise Software cluster version required by this module |
+| min_redis_version | string | Minimum Redis database version required by this module. Only relevant for Redis databases earlier than v7.4. |
+| module_file | string | Module filename |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name<br/> |
+| os | string | Operating system used to compile the module |
+| os_list | array of strings | List of supported operating systems |
+| semantic_version | string | Module's semantic version |
+| sha256 | string | SHA256 of module binary |
+| version | integer | Module's version |
+---
+Title: Suffix object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a DNS suffix
+linkTitle: suffix
+weight: $weight
+---
+
+An API object that represents a DNS suffix in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| default | boolean | Suffix is the default suffix for the cluster (read-only) |
+| internal | boolean | Does the suffix point to internal IP addresses (read-only) |
+| mdns | boolean | Support for multicast DNS (read-only) |
+| name | string | Unique suffix name that represents its zone (read-only) |
+| slaves | array of strings | Frontend DNS servers to be updated by this suffix |
+| use_aaaa_ns | boolean | Suffix uses AAAA NS entries (read-only) |---
+Title: Database connection auditing configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for database connection auditing settings
+linkTitle: db_conns_auditing_config
+weight: $weight
+---
+
+Database connection auditing configuration
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| audit_address | string | TCP/IP address where one can listen for notifications. |
+| audit_port | integer | Port where one can listen for notifications. |
+| audit_protocol | `TCP`<br />`local` | Protocol used to process notifications. For production systems, `TCP` is the only valid value. |
+| audit_reconnect_interval | integer | Interval (in seconds) between attempts to reconnect to the listener. Default is 1 second. |
+| audit_reconnect_max_attempts | integer | Maximum number of attempts to reconnect. Default is 0 (infinite). |
+---
+Title: LDAP object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that contains the cluster's LDAP configuration
+linkTitle: ldap
+weight: $weight
+---
+
+An API object that represents the cluster's [LDAP]({{< relref "/operate/rs/security/access-control/ldap" >}}) configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bind_dn | string | DN used when binding with the LDAP server to run queries |
+| bind_pass | string | Password used when binding with the LDAP server to run queries |
+| ca_cert | string | PEM-encoded CA certificate(s) used to validate TLS connections to the LDAP server |
+| cache_ttl | integer (default:&nbsp;300) | Maximum TTL (in seconds) of cached entries |
+| control_plane | boolean (default:&nbsp;false) | Use LDAP for user authentication/authorization in the control plane |
+| data_plane | boolean (default:&nbsp;false) | Use LDAP for user authentication/authorization in the data plane |
+| directory_timeout_s | integer (range:&nbsp;5-60) (default:&nbsp;5) | The connection timeout to the LDAP server when authenticating a user, in seconds |
+| dn_group_attr | string | The name of an attribute of the LDAP user entity that contains a list of the groups that user belongs to. (Mutually exclusive with "dn_group_query") |
+| dn_group_query | complex object | An LDAP search query for mapping from a user DN to the groups the user is a member of. The substring "%D" in the filter will be replaced with the user's DN. (Mutually exclusive with "dn_group_attr") |
+| starttls | boolean (default:&nbsp;false) | Use StartTLS negotiation for the LDAP connection |
+| uris | array of strings | URIs of LDAP servers that only contain the schema, host, and port |
+| user_dn_query | complex object | An LDAP search query for mapping from a username to a user DN. The substring "%u" in the filter will be replaced with the username. (Mutually exclusive with "user_dn_template") |
+| user_dn_template | string | A string template that maps between the username, provided to the cluster for authentication, and the LDAP DN. The substring "%u" will be replaced with the username. (Mutually exclusive with "user_dn_query") |
+---
+Title: CRDB cluster info object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents Active-Active cluster info
+linkTitle: cluster_info
+weight: $weight
+---
+
+Configuration details for a cluster that is part of an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| credentials | {{<code>}}
+{
+  "username": string,
+  "password": string
+} {{</code>}} | Cluster access credentials (required) |
+| name | string | Cluster fully qualified name, used to uniquely identify the cluster. Typically this is the same as the hostname used in the URL, although in some configruations the URL may point to a different name/address. (required) |
+| replication_endpoint | string | Address to use for peer replication. If not specified, it is assumed that standard cluster naming conventions apply. |
+| replication_tls_sni | string | Cluster SNI for TLS connections |
+| url | string | Cluster access URL (required) |
+---
+Title: CRDB health report configuration object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the database configuration to include in an
+  Active-Active database health report.
+linkTitle: health_report_configuration
+weight: $weight
+---
+
+An object that represents the database configuration to include in an Active-Active database health report.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| causal_consistency | boolean | Enables causal consistency across Active-Active replicas |
+| encryption | boolean | Intercluster encryption |
+| featureset_version | integer | CRDB active FeatureSet version |
+| instances | {{<code>}}[{
+  // Unique instance ID
+  "id": integer,
+  // Local database instance ID
+  "db_uid": string,
+  "cluster": {
+    // Cluster FQDN
+    "name": string
+    // Cluster access URL
+    "url": string
+  }
+}, ...] {{</code>}} | Local database instances  |
+| name | string | Name of database |
+| protocol_version | integer | CRDB active protocol version |
+| status | string | Current status of the configuration.<br/>Possible values:<br/>**posted:**  Configuration was posted to all replicas<br/>**ready:** All replicas have finished processing posted configuration (create a database)<br/>**committed**: Posted configuration is now active on all replicas<br/>**commit-completed:** All replicas have finished processing committed configuration (database is active)<br/>**failed:** Configuration failed to post |
+| version | integer | Database configuration version |
+---
+Title: CRDB health report object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents an Active-Active database health report.
+hideListLinks: true
+linkTitle: health_report
+weight: $weight
+---
+
+An object that represents an Active-Active database health report.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| active_config_version | integer | Active configuration version |
+| cluster_name | string | Name of local Active-Active cluster |
+| configurations | array of [health_report_configuration]({{< relref "/operate/rs/references/rest-api/objects/crdb/health_report/health_report_configuration" >}}) objects | Stored database configurations |
+| connection_error | string | Error string if remote cluster is not available |
+| connections | {{<code>}}
+[{
+  "name": string,
+  "replication_links": [ 
+    {
+      "link_uid": "bdb_uid:replica_uid", 
+      "status": "up | down" 
+    } ],
+  "status": string
+}, ...] {{</code>}} | Connections to other clusters and their statuses. A replication link's `bdb_uid` is the unique ID of a local database instance ([bdb]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}})) in the current cluster. The `replica_uid` is the unique ID of the database's remote replica, located in the connected cluster. |
+| name | string | Name of the Active-Active database |
+---
+Title: CRDB database config object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the database configuration
+linkTitle: database_config
+weight: $weight
+---
+
+An object that represents the database configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| aof_policy | **'appendfsync-every-sec'** <br />'appendfsync-always' | Policy for Append-Only File data persistence |
+| authentication_admin_pass | string | Administrative databases access token |
+| authentication_redis_pass | string | Redis AUTH password (deprecated as of Redis Enterprise v7.2, replaced with multiple passwords feature in version 6.0.X) |
+| bigstore | boolean (default: false) | Database driver is Auto Tiering |
+| bigstore_ram_size | integer (default: 0) | Memory size of RAM size |
+| data_persistence | 'disabled'<br />'snapshot'<br />**'aof'** | Database on-disk persistence policy. For snapshot persistence, a [snapshot_policy]({{< relref "/operate/rs/references/rest-api/objects/bdb/snapshot_policy" >}}) must be provided |
+| enforce_client_authentication | **'enabled'** <br />'disabled' | Require authentication of client certificates for SSL connections to the database. If enabled, a certificate should be provided in either <span class="break-all">`authentication_ssl_client_certs`</span> or <span class="break-all">`authentication_ssl_crdt_certs`</span> |
+| max_aof_file_size | integer | Maximum AOF file size in bytes |
+| max_aof_load_time | integer (default: 3600) | Maximum AOF reload time in seconds |
+| memory_size | integer (default: 0) | Database memory size limit in bytes. 0 is unlimited. |
+| oss_cluster | boolean (default: false) | Enables OSS Cluster mode |
+| oss_cluster_api_preferred_ip_type | 'internal'<br />'external' | Indicates preferred IP type in OSS cluster API |
+| oss_sharding | boolean (default: false) | An alternative to `shard_key_regex` for using the common case of the OSS shard hashing policy |
+| port | integer | TCP port for database access |
+| proxy_policy | 'single'<br />'all-master-shards'<br />'all-nodes' | The policy used for proxy binding to the endpoint |
+| rack_aware | boolean (default: false) | Require the database to be always replicated across multiple racks |
+| replication | boolean (default: true) | Database replication |
+| sharding | boolean (default:&nbsp;false) | Cluster mode (server-side sharding). When true, shard hashing rules must be provided by either `oss_sharding` or `shard_key_regex` |
+| shard_key_regex | `[{ "regex": string }, ...]` | Custom keyname-based sharding rules (required if sharding is enabled)<br /><br />To use the default rules you should set the value to:<br />`[{"regex": ".*\\{(?<tag>.*)\\}.*"}, {"regex": "(?<tag>.*)"}]` |
+| shards_count | integer (range: 1-512) (default: 1) | Number of database shards |
+| shards_placement | 'dense'<br />'sparse' | Control the density of shards<br />Values:<br />**'dense'**: Shards reside on as few nodes as possible <br /> **'sparse'**: Shards reside on as many nodes as possible |
+| snapshot_policy | array of [snapshot_policy]({{< relref "/operate/rs/references/rest-api/objects/bdb/snapshot_policy" >}}) objects | Policy for snapshot-based data persistence. A dataset snapshot will be taken every N secs if there are at least M writes changes in the dataset. |
+| tls_mode | 'enabled'<br /> **'disabled'** <br />'replica_ssl' | Encrypt communication |
+---
+Title: CRDB instance info object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents Active-Active instance info
+linkTitle: instance_info
+weight: $weight
+---
+
+An object that represents Active-Active instance info.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| id | integer | Unique instance ID |
+| cluster | [CRDB cluster_info]({{< relref "/operate/rs/references/rest-api/objects/crdb/cluster_info" >}}) object | |
+| compression | integer | Compression level when syncing from this source |
+| db_config | [CRDB database_config]({{< relref "/operate/rs/references/rest-api/objects/crdb/database_config" >}}) object | Database configuration |
+| db_uid | string | ID of local database instance. This field is likely to be empty for instances other than the local one. |
+---
+Title: CRDB modify request object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object to update an Active-Active database
+linkTitle: modify_request
+weight: $weight
+---
+
+An object to update an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| add_instances | array of [CRDB instance_info]({{< relref "/operate/rs/references/rest-api/objects/crdb/instance_info" >}}) objects | List of new CRDB instances |
+| crdb | [CRDB]({{< relref "/operate/rs/references/rest-api/objects/crdb" >}}) object | An object that represents an Active-Active database |
+| force_update | boolean | (Warning: This flag can cause unintended and dangerous changes) Force the configuration update and increment the configuration version even if there is no change to the configuration parameters. If you use force, you can mistakenly cause the other instances to update to the configuration version even though it was not changed. |
+| remove_instances | array of integers | List of unique instance IDs |
+| remove_instances.force_remove | boolean | Force removal of instance from the Active-Active database. Before we remove an instance from an Active-Active database, all of the operations that the instance received from clients must be propagated to the other instances. This is the safe method to remove an instance from the Active-Active database. If the instance does not have connectivity to other instances, the propagation fails and removal fails. To remove an instance that does not have connectivity to other instances, you must use the force flag. The removed instance keeps its data and configuration for the instance. After you remove an instance by force, you must use the purge_instances API on the removed instance. |
+---
+Title: CRDB object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents an Active-Active database
+hideListLinks: true
+linkTitle: crdb
+weight: $weight
+---
+
+An object that represents an Active-Active database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| guid | string | The global unique ID of the Active-Active database |
+| causal_consistency | boolean | Enables causal consistency across CRDT instances |
+| default_db_config| [CRDB database_config]({{< relref "/operate/rs/references/rest-api/objects/crdb/database_config" >}}) object | Default database configuration |
+| encryption | boolean | Encrypt communication |
+| featureset_version | integer | Active-Active database active FeatureSet version
+| instances | array of [CRDB instance_info]({{< relref "/operate/rs/references/rest-api/objects/crdb/instance_info" >}}) objects | |
+| local_databases | {{<code>}}[{
+  "bdb_uid": string,
+  "id": integer
+}, ...] {{</code>}} | Mapping of instance IDs for local databases to local BDB IDs |
+| name | string | Name of Active-Active database |
+| protocol_version | integer | Active-Active database active protocol version |
+---
+Title: OCSP object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the cluster's OCSP configuration
+linkTitle: ocsp
+weight: $weight
+---
+
+An API object that represents the cluster's OCSP configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| ocsp_functionality | boolean (default:&nbsp;false) | Enables or turns off OCSP for the cluster |
+| query_frequency | integer <nobr>(range: 60-86400)</nobr> (default:&nbsp;3600) | The time interval in seconds between OCSP queries to check the certificate’s status |
+| recovery_frequency | integer <nobr>(range: 60-86400)</nobr> (default:&nbsp;60) | The time interval in seconds between retries after the OCSP responder returns an invalid status for the certificate |
+| recovery_max_tries | integer <nobr>(range: 1-100)</nobr> (default:&nbsp;5) | The number of retries before the validation query fails and invalidates the certificate |
+| responder_url | string | The OCSP server URL embedded in the proxy certificate (if available) (read-only) |
+| response_timeout | integer <nobr>(range: 1-60)</nobr> (default:&nbsp;1) | The time interval in seconds to wait for a response before timing out |
+---
+Title: Certificate rotation job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the cert_rotation_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: cert_rotation_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression              | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the certificate rotation schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+| expiry_days_before_rotation  | integer, (range:&nbsp;1-90) (default:&nbsp;60) | Number of days before a certificate expires before rotation |
+---
+Title: Rotate CCS job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the rotate_ccs_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: rotate_ccs_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the CCS rotation schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+| file_suffix | string (default:&nbsp;5min) | String added to the end of the rotated RDB files |
+| rotate_max_num | integer, (range:&nbsp;1-100) (default:&nbsp;24) | The maximum number of saved RDB files |
+---
+Title: BDB usage report job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb_usage_report_job_settings object used with Redis Enterprise Software REST API calls.
+linkTitle: bdb_usage_report_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the database usage report schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+| file_retention_days | integer, 1-1000 (default: 365) | Number of days after a file is closed before it is deleted |
+---
+Title: Redis cleanup job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the redis_cleanup_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: redis_cleanup_job_settings
+weight: $weight
+---
+
+Deprecated and replaced with `persistence_cleanup_scan_interval`.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the Redis cleanup schedule |
+---
+Title: Log rotation job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the log_rotation_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: log_rotation_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the log rotation schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+---
+Title: Backup job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the backup_job_settings object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: backup_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the backup schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+---
+Title: Node checks job settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the node_checks_job_settings object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: node_checks_job_settings
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cron_expression | string | [CRON expression](https://en.wikipedia.org/wiki/Cron#CRON_expression) that defines the node checks schedule |
+| enabled | boolean (default: true) | Indicates whether this job is enabled |
+---
+Title: Job scheduler object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for job scheduler settings
+hideListLinks: true
+linkTitle: job_scheduler
+weight: $weight
+---
+
+An API object that represents the job scheduler settings in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| backup_job_settings | [backup_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/backup_job_settings" >}}) object | Backup job settings |
+| <span class="break-all">bdb_usage_report_job_settings</span> | <span class="break-all">[bdb_usage_report_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/bdb_usage_report_job_settings" >}})</span> object | Job settings for database usage reports |
+| <span class="break-all">cert_rotation_job_settings</span> | <span class="break-all">[cert_rotation_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/cert_rotation_job_settings" >}})</span> object | Job settings for internal certificate rotation |
+| <span class="break-all">log_rotation_job_settings</span> | <span class="break-all">[log_rotation_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/log_rotation_job_settings" >}})</span> object | Log rotation job settings |
+| <span class="break-all">node_checks_job_settings</span> | <span class="break-all">[node_checks_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/node_checks_job_settings" >}})</span> object | Node checks job settings |
+| <span class="break-all">redis_cleanup_job_settings</span> | <span class="break-all">[redis_cleanup_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/redis_cleanup_job_settings" >}})</span> object | Redis cleanup job settings (deprecated as of Redis Enterprise v6.4.2, replaced with persistence_cleanup_scan_interval) |
+| rotate_ccs_job_settings | [rotate_ccs_job_settings]({{< relref "/operate/rs/references/rest-api/objects/job_scheduler/rotate_ccs_job_settings" >}}) object | Rotate CCS job settings |
+---
+Title: User object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An API object that represents a Redis Enterprise user
+linkTitle: user
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | User's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API request (read-only) |
+| auth_method | **'regular'**<br />'certificate'<br />'entraid' | User's authentication method |
+| bdbs_email_alerts | complex object | UIDs of databases that user will receive alerts for |
+| certificate_subject_line | string | The certificate’s subject line as defined by RFC2253. Used for certificate-based authentication users only. |
+| cluster_email_alerts | boolean | Activate cluster email alerts for a user |
+| email | string | User's email (pattern matching only ASCII characters) |
+| email_alerts | boolean (default:&nbsp;true) | Activate email alerts for a user |
+| name | string | User's name (pattern does not allow non-ASCII and special characters &,\<,>,") |
+| password | string | User's password. If `password_hash_method` is set to `1`, the password should be hashed using SHA-256. The format before hashing is `username:clustername:password`. | 
+| password_hash_method | '1' | Used when password is passed pre-hashed to specify the hashing method |
+| password_issue_date | string | The date in which the password was set (read-only) |
+| role | 'admin'<br />'cluster_member'<br />'cluster_viewer'<br />'db_member'<br /> **'db_viewer'** <br />'user_manager'<br />'none' | User's [role]({{< relref "/operate/rs/references/rest-api/permissions#roles" >}}) |
+| role_uids | array of integers | UIDs of user's roles for role-based access control |
+| status | 'active'<br />'locked'<br />'password_expired' | User sign-in status (read-only)<br />**active**: able to sign in<br />**locked**: unable to sign in<br />**password_expired**: unable to sign in because the password expired |
+---
+Title: BDB alert settings with threshold object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb_alert_settings_with_threshold object used with Redis
+  Enterprise Software REST API calls.
+linkTitle: bdb_alert_settings_with_threshold
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| enabled    | boolean (default:&nbsp;false)  | Alert enabled or disabled |
+| threshold  | string                         | Threshold for alert going on/off |
+---
+Title: Database alerts settings object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object for database alerts configuration
+hideListLinks: true
+linkTitle: db_alerts_settings
+weight: $weight
+---
+
+An API object that represents the database alerts configuration.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| bdb_backup_delayed | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Periodic backup has been delayed for longer than specified threshold value (minutes) |
+| bdb_crdt_src_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB source sync lag is higher than specified threshold value (seconds) |
+| bdb_crdt_src_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB source sync had a connection error while trying to connect to replica source |
+| bdb_crdt_src_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | CRDB sync encountered in general error |
+| bdb_high_latency | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Latency is higher than specified threshold value (microsec) |
+| bdb_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync lag is higher than specified threshold value (seconds) (deprecated as of Redis Enterprise v5.0.1) |
+| bdb_high_throughput | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Throughput is higher than specified threshold value (requests / sec) |
+| bdb_long_running_action | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | An alert for state machines that are running for too long |
+| bdb_low_throughput | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Throughput is lower than specified threshold value (requests / sec) |
+| bdb_ram_dataset_overhead | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Dataset RAM overhead of a shard has reached the threshold value (% of its RAM limit) |
+| bdb_ram_values | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Percent of values kept in a shard's RAM is lower than (% of its key count) |
+| bdb_replica_src_high_syncer_lag | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of source sync lag is higher than specified threshold value (seconds) |
+| bdb_replica_src_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of source sync has connection error while trying to connect replica source |
+| bdb_replica_src_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync encountered in general error |
+| bdb_shard_num_ram_values | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Number of values kept in a shard's RAM is lower than (values) |
+| bdb_size | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Dataset size has reached the threshold value \(% of the memory limit) |
+| bdb_syncer_connection_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync has connection error while trying to connect replica source (deprecated as of Redis Enterprise v5.0.1) |
+| bdb_syncer_general_error | [bdb_alert_settings_with_threshold]({{< relref "/operate/rs/references/rest-api/objects/db_alerts_settings/bdb_alert_settings_with_threshold" >}}) object | Replica of sync encountered in general error (deprecated as of Redis Enterprise v5.0.1) |
+---
+Title: BDB dataset import sources object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb dataset_import_sources object used with Redis Enterprise
+  Software REST API calls.
+linkTitle: dataset_import_sources
+weight: $weight
+---
+
+You can import data to a database from the following location types:
+
+-   HTTP/S
+-   FTP
+-   SFTP
+-   Amazon S3
+-   Google Cloud Storage
+-   Microsoft Azure Storage
+-   NAS/Local Storage
+
+The source file to import should be in the [RDB]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}) format. It can also be in a compressed (gz) RDB file.
+
+Supply an array of dataset import source objects to import data from multiple files.
+
+## Basic parameters
+
+For all import location objects, you need to specify the location type via the `type` field.
+
+| Location type | "type" value |
+|---------------|--------------|
+| FTP/S | "url" |
+| SFTP | "sftp" |
+| Amazon S3 | "s3" |
+| Google Cloud Storage | "gs" |
+| Microsoft Azure Storage | "abs" |
+| NAS/Local Storage | "mount_point" |
+
+## Location-specific parameters
+
+Any additional required parameters may differ based on the import location type.
+
+### FTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| url | string | A URI that represents the FTP/S location with the following format: `ftp://user:password@host:port/path/`. The user and password can be omitted if not needed. |
+
+### SFTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| key | string | SSH private key to secure the SFTP server connection. If you do not specify an SSH private key, the autogenerated private key of the cluster is used and you must add the SSH public key of the cluster to the SFTP server configuration. (optional) |
+| sftp_url | string | SFTP URL in the format: `sftp://user:password@host[:port]/path/filename.rdb`. The default port number is 22 and the default path is '/'. |
+
+### AWS S3
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| access_key_id | string | The AWS Access Key ID with access to the bucket |
+| bucket_name | string | S3 bucket name |
+| filename | string | RDB filename, including the file extension. |
+| region_name | string | Amazon S3 region name (optional) |
+| secret_access_key | string | The AWS Secret Access that matches the Access Key ID |
+| subdir | string | Path to the backup directory in the S3 bucket (optional) |
+
+### Google Cloud Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| bucket_name | string | Cloud Storage bucket name |
+| client_email | string | Email address for the Cloud Storage client ID |
+| client_id | string | Cloud Storage client ID with access to the Cloud Storage bucket |
+| filename | string | RDB filename, including the file extension. |
+| private_key | string | Private key for the Cloud Storage matching the private key ID |
+| private_key_id | string | Cloud Storage private key ID with access to the Cloud Storage bucket |
+| subdir | string | Path to the backup directory in the Cloud Storage bucket (optional) |
+
+### Azure Blob Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| account_key | string | Access key for the storage account |
+| account_name | string | Storage account name with access to the container |
+| container | string | Blob Storage container name |
+| filename | string | RDB filename, including the file extension. |
+| sas_token | string | Token to authenticate with shared access signature |
+| subdir | string | Path to the backup directory in the Blob Storage container (optional) |
+
+{{<note>}}
+`account_key` and `sas_token` are mutually exclusive
+{{</note>}}
+
+### NAS/Local Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| path | string | Path to the locally mounted filename to import. You must create the mount point on all nodes, and the `redislabs:redislabs` user must have read permissions on the local mount point.
+---
+Title: BDB status field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb status field used with Redis Enterprise Software REST
+  API calls.
+linkTitle: status
+weight: $weight
+---
+
+The BDB status field is a read-only field that represents the database status.
+
+Possible status values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'active' | Database is active and no special action is in progress | 'active-change-pending' <br />'import-pending' <br />'delete-pending' |
+| 'active-change-pending' | |'active' |
+| 'creation-failed' | Initial database creation failed | |
+| 'delete-pending' | Database deletion is in progress | |
+| 'import-pending' | Dataset import is in progress | 'active' |
+| 'pending' | Temporary status during database creation | 'active'<br />'creation-failed' |
+| 'recovery' | Not currently relevant (intended for future use) | |
+
+{{< image filename="/images/rs/rest-api-bdb-status.png#no-click" alt="BDB status" >}}
+---
+Title: BDB backup/export location object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb backup_location/export_location object used with Redis
+  Enterprise Software REST API calls.
+linkTitle: backup_location/export_location
+weight: $weight
+---
+
+You can back up or export a database's dataset to the following types of locations:
+
+-   FTP/S
+-   SFTP
+-   Amazon S3
+-   Google Cloud Storage
+-   Microsoft Azure Storage
+-   NAS/Local Storage
+
+## Basic parameters
+
+For all backup/export location objects, you need to specify the location type via the `type` field.
+
+| Location type | "type" value |
+|---------------|--------------|
+| FTP/S | "url" |
+| SFTP | "sftp" |
+| Amazon S3 | "s3" |
+| Google Cloud Storage | "gs" |
+| Microsoft Azure Storage | "abs" |
+| NAS/Local Storage | "mount_point" |
+
+## Location-specific parameters
+
+Any additional required parameters may differ based on the backup/export location type.
+
+### FTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| url | string | A URI that represents a FTP/S location with the following format: `ftp://user:password@host:port/path/`. The user and password can be omitted if not needed. |
+
+### SFTP
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| key | string | SSH private key to secure the SFTP server connection. If you do not specify an SSH private key, the autogenerated private key of the cluster is used, and you must add the SSH public key of the cluster to the SFTP server configuration. (optional) |
+| sftp_url | string | SFTP URL in the format: `sftp://user:password@host[:port][/path/]`. The default port number is 22 and the default path is '/'. |
+
+### AWS S3
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| access_key_id | string | The AWS Access Key ID with access to the bucket |
+| bucket_name | string | S3 bucket name |
+| region_name | string | Amazon S3 region name (optional) |
+| secret_access_key | string | The AWS Secret Access Key that matches the Access Key ID |
+| subdir | string | Path to the backup directory in the S3 bucket (optional) |
+
+### Google Cloud Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| bucket_name | string | Cloud Storage bucket name |
+| client_email | string | Email address for the Cloud Storage client ID |
+| client_id | string | Cloud Storage client ID with access to the Cloud Storage bucket |
+| private_key | string | Cloud Storage private key that matches the private key ID |
+| private_key_id | string | Cloud Storage private key ID with access to the Cloud Storage bucket |
+| subdir | string | Path to the backup directory in the Cloud Storage bucket (optional) |
+
+### Azure Blob Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| account_key | string | Access key for the storage account |
+| account_name | string | Storage account name with access to the container |
+| container | string | Blob Storage container name |
+| sas_token | string | Token to authenticate with shared access signature |
+| subdir | string | Path to the backup directory in the Blob Storage container (optional) |
+
+{{<note>}}
+`account_key` and `sas_token` are mutually exclusive
+{{</note>}}
+
+### NAS/Local Storage
+
+| Key name | Type | Description |
+|----------|------|-------------|
+| path | string | Path to the local mount point. You must create the mount point on all nodes, and the `redislabs:redislabs` user must have read and write permissions on the local mount point. |
+---
+Title: Syncer sources object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the syncer_sources object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: syncer_sources
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Unique ID of this source |
+| client_cert | string | Client certificate to use if encryption is enabled |
+| client_key | string | Client key to use if encryption is enabled |
+| compression | integer, <nobr>(range: 0-6)</nobr> | Compression level for the replication link |
+| encryption | boolean | Encryption enabled/disabled |
+| lag | integer | Lag in milliseconds between source and destination (while synced) |
+| last_error | string | Last error encountered when syncing from the source |
+| last_update | string | Time when we last received an update from the source |
+| rdb_size | integer | The source's RDB size to be transferred during the syncing phase |
+| rdb_transferred | integer | Number of bytes transferred from the source's RDB during the syncing phase |
+| replication_tls_sni | string | Replication TLS server name indication |
+| server_cert | string | Server certificate to use if encryption is enabled |
+| status | string | Sync status of this source |
+| uri | string | Source Redis URI |
+---
+Title: Snapshot policy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the snapshot_policy object used with Redis Enterprise Software
+  REST API calls.
+linkTitle: snapshot_policy
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| secs   | integer | Interval in seconds between snapshots |
+| writes | integer | Number of write changes required to trigger a snapshot |
+---
+Title: BDB replica sync field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb replica_sync field used with Redis Enterprise Software
+  REST API calls.
+linkTitle: replica_sync
+weight: $weight
+---
+
+The BDB `replica_sync` field relates to the [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/create.md" >}}) feature, which enables the creation of a Redis database (single- or multi-shard) that synchronizes data from another Redis database (single- or multi-shard).
+
+You can use the `replica_sync` field to enable, disable, or pause the [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/create.md" >}}) sync process. The BDB `crdt_sync` field has a similar purpose for the Redis CRDB.
+
+Possible BDB sync values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'disabled' | (default value) Disables the sync process and represents that no sync is currently configured or running. | 'enabled' |
+| 'enabled' | Enables the sync process and represents that the process is currently active. | 'stopped' <br />'paused' |
+| 'paused' | Pauses the sync process. The process is configured but is not currently executing any sync commands. | 'enabled' <br />'stopped' |
+| 'stopped' | An unrecoverable error occurred during the sync process, which caused the system to stop the sync. | 'enabled' |
+
+{{< image filename="/images/rs/rest-api-bdb-sync.png#no-click" alt="BDB sync" >}}
+
+When the sync is in the 'stopped' or 'paused' state, then the `last_error` field in the relevant source entry in the `sync_sources` "status" field contains the detailed error message.
+---
+Title: BDB replica sources status field
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the bdb replica_sources status field used with Redis Enterprise
+  Software REST API calls.
+linkTitle: replica_sources status
+weight: $weight
+---
+
+The `replica_sources` status field relates to the [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/create.md" >}}) feature, which enables the creation of a Redis database (single- or multi-shard) that synchronizes data from another Redis database (single- or multi-shard).
+
+The status field represents the Replica Of sync status for a specific sync source.
+
+Possible status values:
+
+| Status | Description | Possible next status |
+|--------|-------------|----------------------|
+| 'out-of-sync' | Sync process is disconnected from source and trying to reconnect | 'syncing' |
+| 'syncing' | Sync process is in progress | 'in-sync' <br />'out-of-sync' |
+| 'in-sync' | Sync process finished successfully, and new commands are syncing on a regular basis | 'syncing' <br />'out-of-sync'
+
+{{< image filename="/images/rs/rest-api-replica-sources-status.png#no-click" alt="Replica sources status" >}}
+---
+Title: BDB object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a database
+hideListLinks: true
+linkTitle: bdb
+weight: $weight
+---
+
+An API object that represents a managed database in the cluster.
+
+| Name | Type/Value & Description |
+|------|-------------------------|
+| uid | integer; Cluster unique ID of database. Can be set during creation but cannot be updated. |
+| account_id | integer; SM account ID |
+| action_uid | string; Currently running action's UID (read-only) |
+| aof_policy | Policy for Append-Only File data persistence<br />Values:<br />**'appendfsync-every-sec'** <br />'appendfsync-always' |
+| authentication_admin_pass | string; Password for administrative access to the BDB (used for SYNC from the BDB) |
+| authentication_redis_pass | string; Redis AUTH password authentication.  <br/>Use for Redis databases only.  Ignored for memcached databases. (deprecated as of Redis Enterprise v7.2, replaced with multiple passwords feature in version 6.0.X) |
+| authentication_sasl_pass | string; Binary memcache SASL password |
+| authentication_sasl_uname | string; Binary memcache SASL username (pattern does not allow special characters &,\<,>,") |
+| authentication_ssl_client_certs | {{<code>}}[{<br />  "client_cert": string<br />}, ...]{{</code>}} List of authorized client certificates<br />**client_cert**: X.509 PEM (base64) encoded certificate |
+| authentication_ssl_crdt_certs | {{<code>}}[{<br />  "client_cert": string<br />}, ...]{{</code>}} List of authorized CRDT certificates<br />**client_cert**: X.509 PEM (base64) encoded certificate |
+| authorized_names | array of strings; Additional certified names (deprecated as of Redis Enterprise v6.4.2; use authorized_subjects instead) |
+| authorized_subjects | {{<code>}}[{<br />  "CN": string,<br />  "O": string,<br />  "OU": [array of strings],<br />  "L": string,<br />  "ST": string,<br />  "C": string<br />}, ...]{{</code>}} A list of valid subjects used for additional certificate validations during TLS client authentication. All subject attributes are case-sensitive.<br />**Required subject fields**:<br />"CN" for Common Name<br />**Optional subject fields:**<br />"O" for Organization<br />"OU" for Organizational Unit (array of strings)<br />"L" for Locality (city)<br />"ST" for State/Province<br />"C" for 2-letter country code |
+| auto_upgrade | boolean (default:&nbsp;false); Upgrade the database automatically after a cluster upgrade |
+| avoid_nodes | array of strings; Cluster node UIDs to avoid when placing the database's shards and binding its endpoints |
+| background_op | Deprecated as of Redis Enterprise Software v7.8.2. Use [`GET /v1/actions/bdb/<bdb_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions/bdb">}}) instead.<br />{{<code>}}[{<br />  "status": string,<br />  "name": string,<br />  "error": object,<br />  "progress": number<br />}, ...]{{</code>}} (read-only); **progress**: Percent of completed steps in current operation |
+| backup | boolean (default:&nbsp;false); Policy for periodic database backup |
+| backup_failure_reason | Reason of last failed backup process (read-only)<br />Values:<br />'no-permission'<br />'wrong-file-path'<br />'general-error' |
+| backup_history | integer (default:&nbsp;0); Backup history retention policy (number of days, 0 is forever) |
+| backup_interval | integer; Interval in seconds in which automatic backup will be initiated |
+| backup_interval_offset | integer; Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval) |
+| backup_location | [complex object]({{< relref "/operate/rs/references/rest-api/objects/bdb/backup_location" >}});  Target for automatic database backups. <br />Call `GET`&nbsp;`/jsonschema` to retrieve the object's structure. |
+| backup_progress | number, <nobr>(range: 0-100)</nobr>;  Database scheduled periodic backup progress (percentage) (read-only) |
+| backup_status | Status of scheduled periodic backup process (read-only)<br />Values:<br />'exporting'<br />'succeeded'<br />'failed' |
+| bigstore | boolean (default:&nbsp;false);  Database bigstore option |
+| bigstore_ram_size | integer (default:&nbsp;0);  Memory size of bigstore RAM part. |
+| bigstore_ram_weights | {{<code>}}[{<br />  "shard_uid": integer,<br />  "weight": number<br />}, ...]{{</code>}} List of shard UIDs and their bigstore RAM weights;<br /> **shard_uid**: Shard UID;<br /> **weight**: Relative weight of RAM distribution |
+| client_cert_subject_validation_type | Enables additional certificate validations that further limit connections to clients with valid certificates during TLS client authentication.<br />Values:<br />**disabled**: Authenticates clients with valid certificates. No additional validations are enforced.<br />**san_cn**: A client certificate is valid only if its Common Name (CN) matches an entry in the list of valid subjects. Ignores other Subject attributes.<br />**full_subject**: A client certificate is valid only if its Subject attributes match an entry in the list of valid subjects. |
+| conns | integer (default&nbsp;5);  Number of internal proxy connections |
+| conns_type | Connections limit type<br />Values:<br />**‘per-thread’**<br />‘per-shard’ |
+| crdt | boolean (default:&nbsp;false);  Use CRDT-based data types for multi-master replication |
+| crdt_causal_consistency | boolean (default:&nbsp;false);  Causal consistent CRDB. |
+| crdt_config_version | integer;  Replica-set configuration version, for internal use only. |
+| crdt_featureset_version | integer;  CRDB active FeatureSet version |
+| crdt_ghost_replica_ids | string;  Removed replicas IDs, for internal use only. |
+| crdt_guid | string;  GUID of CRDB this database belongs to, for internal use only. |
+| crdt_modules | string;  CRDB modules information. The string representation of a JSON list, containing hashmaps. |
+| crdt_protocol_version | integer;  CRDB active Protocol version |
+| crdt_repl_backlog_size | string;  Active-Active replication backlog size ('auto' or size in bytes) |
+| crdt_replica_id | integer;  Local replica ID, for internal use only. |
+| crdt_replicas | string;  Replica set configuration, for internal use only. |
+| crdt_sources | array of [syncer_sources]({{< relref "/operate/rs/references/rest-api/objects/bdb/syncer_sources" >}}) objects; Remote endpoints/peers of CRDB database to sync from. See the 'bdb -\> replica_sources' section |
+| crdt_sync | Enable, disable, or pause syncing from specified crdt_sources. Applicable only for Active-Active databases. See [replica_sync]({{< relref "/operate/rs/references/rest-api/objects/bdb/replica_sync" >}}) for more details.<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| <span class="break-all">crdt_sync_connection_alarm_timeout_seconds</span> | integer (default: 0); If the syncer takes longer than the specified number of seconds to connect to an Active-Active database, raise a connection alarm |
+| crdt_sync_dist | boolean;  Enable/disable distributed syncer in master-master |
+| crdt_syncer_auto_oom_unlatch | boolean (default:&nbsp;true);  Syncer automatically attempts to recover synchronisation from peers after this database throws an Out-Of-Memory error. Otherwise, the syncer exits |
+| crdt_xadd_id_uniqueness_mode | XADD strict ID uniqueness mode. CRDT only.<br />Values:<br />‘liberal’<br />**‘strict’**<br />‘semi-strict’ |
+| created_time | string;  The date and time the database was created (read-only) |
+| data_internode_encryption | boolean;  Should the data plane internode communication for this database be encrypted |
+| data_persistence | Database on-disk persistence policy. For snapshot persistence, a [snapshot_policy]({{< relref "/operate/rs/references/rest-api/objects/bdb/snapshot_policy" >}}) must be provided<br />Values:<br />**'disabled'** <br />'snapshot'<br />'aof' |
+| dataset_import_sources | [complex object]({{< relref "/operate/rs/references/rest-api/objects/bdb/dataset_import_sources" >}});  Array of source file location description objects to import from when performing an import action. This is write-only and cannot be read after set. <br />Call `GET /v1/jsonschema` to retrieve the object's structure. |
+| db_conns_auditing | boolean;  Enables/deactivates [database connection auditing]({{< relref "/operate/rs/security/audit-events" >}}) |
+| default_user | boolean (default:&nbsp;true); Allow/disallow a default user to connect |
+| disabled_commands | string (default: ); Redis commands which are disabled in db |
+| dns_address_master | string;  Database private address endpoint FQDN (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| email_alerts | boolean (default:&nbsp;false);  Send email alerts for this DB |
+| endpoint | string;  Latest bound endpoint. Used when reconfiguring an endpoint via update |
+| endpoint_ip | complex object;  External IP addresses of node hosting the BDB's endpoint. `GET`&nbsp;`/jsonschema` to retrieve the object's structure. (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| endpoint_node | integer;  Node UID hosting the BDB's endpoint (read-only) (deprecated as of Redis Enterprise v4.3.3) |
+| endpoints | array; List of database access endpoints (read-only)<br />**uid**: Unique identification of this source<br />**dns_name**: Endpoint’s DNS name<br />**port**: Endpoint’s TCP port number<br />**addr**: Endpoint’s accessible addresses<br />**proxy_policy**: The policy used for proxy binding to the endpoint<br />**exclude_proxies**: List of proxies to exclude<br />**include_proxies**: List of proxies to include<br />**addr_type**: Indicates if the endpoint is based on internal or external IPs<br /><span class="break-all">**oss_cluster_api_preferred_ip_type**</span>: Indicates preferred IP type in the OSS cluster API: internal/external<br /><span class="break-all">**oss_cluster_api_preferred_endpoint_type**</span>: Indicates preferred endpoint type in the OSS cluster API: ip/hostname |
+| enforce_client_authentication | Require authentication of client certificates for SSL connections to the database. If set to 'enabled', a certificate should be provided in either authentication_ssl_client_certs or authentication_ssl_crdt_certs<br />Values:<br />**'enabled'** <br />'disabled' |
+| eviction_policy | Database eviction policy (Redis style).<br />Values:<br />'volatile-lru'<br />'volatile-ttl'<br />'volatile-random'<br />'allkeys-lru'<br />'allkeys-random'<br />'noeviction'<br />'volatile-lfu'<br />'allkeys-lfu'<br />**Redis DB default**: 'volatile-lru'<br />**memcached DB default**: 'allkeys-lru' |
+| export_failure_reason | Reason of last failed export process (read-only)<br />Values:<br />'no-permission'<br />'wrong-file-path'<br /> 'general-error' |
+| export_progress | number, <nobr>(range: 0-100)</nobr>; Database manually triggered export progress (percentage) (read-only) |
+| export_status | Status of manually triggered export process (read-only)<br />Values:<br />'exporting'<br />'succeeded'<br />'failed' |
+| generate_text_monitor | boolean;  Enable/disable generation of syncer monitoring information |
+| gradual_src_max_sources | integer (default:&nbsp;1); Sync a maximum N sources in parallel (gradual_src_mode should be enabled for this to take effect) |
+| gradual_src_mode | Indicates if gradual sync (of sync sources) should be activated<br />Values:<br />'enabled'<br />'disabled' |
+| gradual_sync_max_shards_per_source | integer (default:&nbsp;1); Sync a maximum of N shards per source in parallel (gradual_sync_mode should be enabled for this to take effect) |
+| gradual_sync_mode | Indicates if gradual sync (of source shards) should be activated ('auto' for automatic decision)<br />Values:<br />'enabled'<br />'disabled'<br />'auto' |
+| hash_slots_policy | The policy used for hash slots handling<br />Values:<br/> **'legacy'**: slots range is '1-4096'<br /> **'16k'**: slots range is '0-16383' |
+| implicit_shard_key | boolean (default:&nbsp;false); Controls the behavior of what happens in case a key does not match any of the regex rules. <br /> **true**: if a key does not match any of the rules, the entire key will be used for the hashing function <br /> **false**: if a key does not match any of the rules, an error will be returned. |
+| import_failure_reason | Import failure reason (read-only)<br />Values:<br />'download-error'<br />'file-corrupted'<br />'general-error'<br />'file-larger-than-mem-limit:\<n bytes of expected dataset>:\<n bytes configured bdb limit>'<br />'key-too-long'<br />'invalid-bulk-length'<br />'out-of-memory' |
+| import_progress | number, <nobr>(range: 0-100)</nobr>; Database import progress (percentage) (read-only) |
+| import_status | Database import process status (read-only)<br />Values:<br />'idle'<br />'initializing'<br />'importing'<br />'succeeded'<br />'failed' |
+| internal | boolean (default:&nbsp;false); Is this a database used by the cluster internally |
+| last_backup_time | string; Time of last successful backup (read-only) |
+| last_changed_time | string; Last administrative configuration change (read-only) |
+| last_export_time | string; Time of last successful export (read-only) |
+| max_aof_file_size | integer; Maximum size for shard's AOF file (bytes). Default 300GB, (on bigstore DB 150GB) |
+| max_aof_load_time | integer (default:&nbsp;3600); Maximum time shard's AOF reload should take (seconds). |
+| max_client_pipeline | integer (default:&nbsp;200); Maximum number of pipelined commands per connection. Maximum value is 2047. |
+| max_connections | integer (default:&nbsp;0); Maximum number of client connections allowed (0 unlimited) |
+| max_pipelined | integer (default:&nbsp;2000); Determines the maximum number of commands in the proxy’s pipeline per shard connection. |
+| master_persistence | boolean (default:&nbsp;false); If true, persists the primary shard in addition to replica shards in a replicated and persistent database. |
+| memory_size | integer (default:&nbsp;0); Database memory limit (0 is unlimited), expressed in bytes. |
+| metrics_export_all | boolean; Enable/disable exposing all shard metrics through the metrics exporter |
+| mkms | boolean (default:&nbsp;true); Are MKMS (Multi Key Multi Slots) commands supported? |
+| module_list | {{<code>}}[{<br />  "module_id": string,<br />  "module_args": [<br />    u'string',<br />    u'null'],<br />  "module_name": string,<br />  "semantic_version": string<br />}, ...]{{</code>}} List of modules associated with the database<br /><br />**module_id**: Module UID (deprecated; use `module_name` instead)<br />**module_args**: Module command-line arguments (pattern does not allow special characters &,\<,>,")<br />**module_name**: Module's name<br />**semantic_version**: Module's semantic version (deprecated; use `module_args` instead)<br /><br />**module_id** and **semantic_version** are optional as of Redis Enterprise Software v7.4.2 and deprecated as of v7.8.2. |
+| mtls_allow_outdated_certs | boolean; An optional mTLS relaxation flag for certs verification |
+| mtls_allow_weak_hashing | boolean; An optional mTLS relaxation flag for certs verification |
+| name | string; Database name. Only letters, numbers, or hyphens are valid characters. The name must start and end with a letter or number. |
+| oss_cluster | boolean (default:&nbsp;false); OSS Cluster mode option. Cannot be enabled with `'hash_slots_policy': 'legacy'` |
+| <span class="break-all">oss_cluster_api_preferred_endpoint_type</span> | Endpoint type in the OSS cluster API<br />Values:<br />**‘ip’**<br />‘hostname’ |
+| <span class="break-all">oss_cluster_api_preferred_ip_type</span> | Internal/external IP type in OSS cluster API. Default value for new endpoints<br />Values:<br />**'internal'** <br />'external' |
+| oss_sharding | boolean (default:&nbsp;false); An alternative to `shard_key_regex` for using the common case of the OSS shard hashing policy |
+| port | integer; TCP port on which the database is available. Generated automatically if omitted and returned as 0 |
+| proxy_policy | The default policy used for proxy binding to endpoints<br />Values:<br />'single'<br />'all-master-shards'<br />'all-nodes' |
+| rack_aware | boolean (default:&nbsp;false); Require the database to always replicate across multiple racks |
+| recovery_wait_time | integer (default:&nbsp;-1); Defines how many seconds to wait for the persistence file to become available during auto recovery. After the wait time expires, auto recovery completes with potential data loss. The default `-1` means to wait forever. |
+| redis_version | string; Version of the redis-server processes: e.g. 6.0, 5.0-big |
+| repl_backlog_size | string; Redis replication backlog size ('auto' or size in bytes) |
+| replica_sources | array of [syncer_sources]({{< relref "/operate/rs/references/rest-api/objects/bdb/syncer_sources" >}}) objects; Remote endpoints of database to sync from. See the 'bdb -\> replica_sources' section |
+| [replica_sync]({{< relref "/operate/rs/references/rest-api/objects/bdb/replica_sync" >}}) | Enable, disable, or pause syncing from specified replica_sources<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| <span class="break-all">replica_sync_connection_alarm_timeout_seconds</span> | integer (default: 0); If the syncer takes longer than the specified number of seconds to connect to a replica, raise a connection alarm |
+| replica_sync_dist | boolean; Enable/disable distributed syncer in replica-of |
+| replication | boolean (default:&nbsp;false); In-memory database replication mode |
+| resp3 | boolean (default:&nbsp;true); Enables or deactivates RESP3 support |
+| roles_permissions | {{<code>}}[{<br />  "role_uid": integer,<br />  "redis_acl_uid": integer<br />}, ...]{{</code>}} |
+| sched_policy | Controls how server-side connections are used when forwarding traffic to shards.<br />Values:<br />**cmp**: Closest to max_pipelined policy. Pick the connection with the most pipelined commands that has not reached the max_pipelined limit.<br />**mru**: Try to use most recently used connections.<br />**spread**: Try to use all connections.<br />**mnp**: Minimal pipeline policy. Pick the connection with the least pipelined commands. |
+| shard_block_crossslot_keys | boolean (default:&nbsp;false); In Lua scripts, prevent use of keys from different hash slots within the range owned by the current shard |
+| shard_block_foreign_keys | boolean (default:&nbsp;true); In Lua scripts, `foreign_keys` prevent use of keys which could reside in a different shard (foreign keys) |
+| shard_key_regex | Custom keyname-based sharding rules.<br />`[{"regex": string}, ...]`<br />To use the default rules you should set the value to: <br />`[{"regex": ".*\\{(?<tag>.*)\\}.*"}, {"regex": "(?<tag>.*)"}]` |
+| shard_list | array of integers; Cluster unique IDs of all database shards. |
+| sharding | boolean (default:&nbsp;false); Cluster mode (server-side sharding). When true, shard hashing rules must be provided by either `oss_sharding` or `shard_key_regex` |
+| shards_count | integer, <nobr>(range: 1-512)</nobr> (default:&nbsp;1); Number of database server-side shards |
+| shards_placement | Control the density of shards <br />Values:<br />**'dense'**: Shards reside on as few nodes as possible <br /> **'sparse'**: Shards reside on as many nodes as possible |
+| skip_import_analyze | Enable/disable skipping the analysis stage when importing an RDB file<br />Values:<br />'enabled'<br />'disabled' |
+| slave_buffer | Redis replica output buffer limits<br />Values:<br />'auto'<br />value in MB<br />hard:soft:time |
+| slave_ha | boolean; Enable replica high availability mechanism for this database (default takes the cluster setting) |
+| slave_ha_priority | integer; Priority of the BDB in replica high availability mechanism |
+| snapshot_policy | array of [snapshot_policy]({{< relref "/operate/rs/references/rest-api/objects/bdb/snapshot_policy" >}}) objects; Policy for snapshot-based data persistence. A dataset snapshot will be taken every N secs if there are at least M writes changes in the dataset |
+| ssl | boolean (default:&nbsp;false); Require SSL authenticated and encrypted connections to the database (deprecated as of Redis Enterprise v5.0.1) |
+| [status]({{< relref "/operate/rs/references/rest-api/objects/bdb/status" >}}) | Database lifecycle status (read-only)<br />Values:<br />'pending'<br />'active'<br />'active-change-pending'<br />'delete-pending'<br />'import-pending'<br />'creation-failed'<br />'recovery' |
+| support_syncer_reconf | boolean; Determines whether the syncer handles its own configuration changes. If false, the DMC restarts the syncer upon a configuration change. |
+| sync | (deprecated as of Redis Enterprise v5.0.1, use [replica_sync]({{< relref "/operate/rs/references/rest-api/objects/bdb/replica_sync" >}}) or crdt_sync instead) Enable, disable, or pause syncing from specified sync_sources<br />Values:<br />'enabled'<br /> **'disabled'** <br />'paused'<br />'stopped' |
+| sync_dedicated_threads | integer (range:&nbsp;0-10) (default:&nbsp;5); Number of dedicated Replica Of threads |
+| sync_sources | {{<code>}}[{<br />  "uid": integer,<br />  "uri": string,<br />  "compression": integer,<br />  "status": string,<br />  "rdb_transferred": integer,<br />  "rdb_size": integer,<br />  "last_update": string,<br />  "lag": integer,<br />  "last_error": string<br />}, ...]{{</code>}} (deprecated as of Redis Enterprise v5.0.1, instead use replica_sources or crdt_sources) Remote endpoints of database to sync from. See the 'bdb -\> replica_sources' section<br />**uid**: Numeric unique identification of this source<br />**uri**: Source Redis URI<br />**compression**: Compression level for the replication link<br />**status**: Sync status of this source<br />**rdb_transferred**: Number of bytes transferred from the source's RDB during the syncing phase<br />**rdb_size**: The source's RDB size to be transferred during the syncing phase<br />**last_update**: Time last update was received from the source<br />**lag**: Lag in millisec between source and destination (while synced)<br />**last_error**: Last error encountered when syncing from the source |
+| syncer_log_level | Minimum syncer log level to log. Only logs with this level or higher will be logged.<br />Values:<br />‘crit’<br />‘error’<br />‘warn’<br />**‘info’**<br />‘trace’<br />‘debug’ |
+| syncer_mode | The syncer for replication between database instances is either on a single node (centralized) or on each node that has a proxy according to the proxy policy (distributed). (read-only)<br />Values:<br />'distributed'<br />'centralized' |
+| tags | {{<code>}}[{<br />  "key": string,<br />  "value": string<br />}, ...]{{</code>}} Optional list of tag objects attached to the database. Each tag requires a key-value pair.<br />**key**: Represents the tag's meaning and must be unique among tags (pattern does not allow special characters &,\<,>,")<br />**value**: The tag's value.|
+| tls_mode | Require TLS-authenticated and encrypted connections to the database<br />Values:<br />'enabled'<br /> **'disabled'** <br />'replica_ssl' |
+| tracking_table_max_keys | integer; The client-side caching invalidation table size. 0 makes the cache unlimited. |
+| type | Type of database<br />Values:<br />**'redis'** <br />'memcached' |
+| use_nodes | array of strings; Cluster node UIDs to use for database shards and bound endpoints |
+| version | string; Database compatibility version: full Redis/memcached version number, such as 6.0.6. This value can only change during database creation and database upgrades.|
+| wait_command | boolean (default:&nbsp;true); Supports Redis wait command (read-only) |
+---
+Title: BDB group object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a group of databases with a shared memory pool
+linkTitle: bdb_group
+weight: $weight
+---
+
+An API object that represents a group of databases that share a memory pool.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid          | integer          | Cluster unique ID of the database group |
+| members      | array of strings | A list of UIDs of member databases (read-only) |
+| memory_size  | integer          | The common memory pool size limit for all databases in the group, expressed in bytes |
+---
+Title: Action object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents cluster actions
+linkTitle: action
+weight: $weight
+---
+
+The cluster allows you to invoke general maintenance actions such as rebalancing or taking a node offline by moving all of its entities to other nodes.
+
+Actions are implemented as tasks in the cluster. Every task has a unique `task_id` assigned by the cluster, a task name which describes the task, a status, and additional task-specific parameters.
+
+The REST API provides a simplified interface that allows callers to invoke actions and query their status without a specific `task_id`.
+
+The action lifecycle is based on the following status and status transitions:
+
+{{< image filename="/images/rs/rest-api-action-cycle.png#no-click" alt="Action lifecycle" >}}
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress        | float <nobr>(range: 0-100)</nobr> | Represents percent completed (As of v7.4.2, the return value type changed to 'float' to provide improved progress indication) |
+| status          | queued | Requested operation and added it to the queue to await processing |
+|                 | starting | Picked up operation from the queue and started processing |
+|                 | running | Currently executing operation |
+|                 | cancelling | Operation cancellation is in progress |
+|                 | cancelled | Operation cancelled |
+|                 | completed | Operation completed |
+|                 | failed | Operation failed |
+
+When a task fails, the `error_code` and `error_message` fields describe the error.
+
+Possible `error_code` values:
+
+ Code                    | Description                                    |
+|-------------------------|------------------------------------------------|
+| internal_error          | An internal error that cannot be mapped to a more precise error code
+| insufficient_resources  | The cluster does not have sufficient resources to complete the required operation
+
+---
+Title: State machine object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a state machine.
+linkTitle: state-machine
+weight: $weight
+---
+
+A state machine object tracks the status of database actions.
+
+A state machine contains the following attributes:
+
+| Name        | Type/Value | Description |
+|-------------|------------|-------------|
+| action_uid  | string     | A globally unique identifier of the action |
+| object_name | string     | Name of the object being manipulated by the state machine |
+| status      | pending    | Requested state machine has not started |
+|             | active     | State machine is currently running |
+|             | completed  | Operation complete |
+|             | failed     | Operation or state machine failed |
+| name        | string     | Name of the running (or failed) state machine |
+| state       | string     | Current state within the state machine, when known |
+| error       | string     | A descriptive error string for failed state machine, when known |
+---
+Title: Role object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a role
+linkTitle: role
+weight: $weight
+---
+
+An API object that represents a role.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Role's unique ID |
+| account_id | integer | SM account ID |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the GET /actions/{uid} API (read-only) |
+| management | 'admin'<br />'db_member'<br />'db_viewer'<br />'cluster_member'<br />'cluster_viewer'<br />'user_manager'<br />'none' | [Management role]({{< relref "/operate/rs/references/rest-api/permissions#roles" >}}) |
+| name | string | Role's name |
+---
+Title: Redis ACL object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a Redis access control list (ACL)
+linkTitle: redis_acl
+weight: $weight
+---
+
+An API object that represents a Redis [access control list (ACL)]({{< relref "/operate/rs/security/access-control/create-db-roles" >}})
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Object's unique ID |
+| account_id | integer | SM account ID |
+| acl | string | Redis ACL's string |
+| action_uid | string | Action UID. If it exists, progress can be tracked by the `GET`&nbsp;`/actions/{uid}` API (read-only) |
+| name | string | Redis ACL's name |
+| min_version | string | Minimum database version that supports this ACL. Read only |
+| max_version | string | Maximum database version that supports this ACL. Read only |
+
+---
+Title: Proxy object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a proxy in the cluster
+linkTitle: proxy
+weight: $weight
+---
+
+An API object that represents a [proxy](https://en.wikipedia.org/wiki/Proxy_server) in the cluster.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | integer | Unique ID of the proxy (read-only) |
+| backlog | integer | TCP listen queue backlog |
+| client_keepcnt | integer | Client TCP keepalive count |
+| client_keepidle | integer | Client TCP keepalive idle |
+| client_keepintvl | integer | Client TCP keepalive interval |
+| conns | integer | Number of connections |
+| duration_usage_threshold | integer, <nobr>(range: 10-300)</nobr> | Max number of threads |
+| dynamic_threads_scaling | boolean | Automatically adjust the number of threads|
+| ignore_bdb_cconn_limit | boolean | Ignore client connection limits |
+| ignore_bdb_cconn_output_buff_limits | boolean | Ignore buffer limit |
+| log_level | `crit`<br />`error`<br />`warn`<br />`info`<br />`trace`<br />`debug` | Minimum log level to log. Only logs with this level or greater will be logged. |
+| max_listeners | integer | Max number of listeners |
+| max_servers | integer | Max number of Redis servers |
+| max_threads | integer, <nobr>(range: 1-256)</nobr> | Max number of threads |
+| max_worker_client_conns | integer | Max client connections per thread |
+| max_worker_server_conns | integer | Max server connections per thread |
+| max_worker_txns | integer | Max in-flight transactions per thread |
+| threads | integer, <nobr>(range: 1-256)</nobr> | Number of threads |
+| threads_usage_threshold | integer, <nobr>(range: 50-99)</nobr> | Max number of threads |
+---
+Title: Sync object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the sync object used with Redis Enterprise Software REST API
+  calls.
+linkTitle: sync
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | integer        | Number of bytes remaining in current sync |
+| status    | 'in_progress'<br />'idle'<br />'link_down' | Indication of the shard's current sync status |
+---
+Title: Loading object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the loading object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: loading
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | number, (range: 0-100) | Percentage of bytes already loaded |
+| status    | 'in_progress'<br />'idle' | Status of the load of a dump file (read-only) |
+---
+Title: Backup object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the backup object used with Redis Enterprise Software REST
+  API calls.
+linkTitle: backup
+weight: $weight
+---
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| progress  | number, (range: 0-100) | Shard backup progress (percentage) |
+| status    | 'exporting'<br />'succeeded'<br />'failed' | Status of scheduled periodic backup process |
+---
+Title: Shard object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents a database shard
+hideListLinks: true
+linkTitle: shard
+weight: $weight
+---
+
+An API object that represents a Redis shard in a database.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| uid | string | Cluster unique ID of shard |
+| assigned_slots | string | Shards hash slot range |
+| backup | [backup]({{< relref "/operate/rs/references/rest-api/objects/shard/backup" >}}) object | Current status of scheduled periodic backup process |
+| bdb_uid | integer | The ID of the database this shard belongs to |
+| bigstore_ram_weight | number | Shards RAM distribution weight |
+| detailed_status | 'busy'<br />'down'<br />'importing'<br />'loading'<br />'ok'<br />'timeout'<br />'trimming'<br />'unknown' | A more detailed status of the shard |
+| loading | [loading]({{< relref "/operate/rs/references/rest-api/objects/shard/loading" >}}) object | Current status of dump file loading |
+| node_uid | string | The ID of the node this shard is located on |
+| redis_info | redis_info object | A sub-dictionary of the [Redis INFO command]({{< relref "/commands/info" >}}) |
+| report_timestamp | string | The time in which the shard's info was collected (read-only) |
+| role | 'master'<br />'slave' | Role of this shard |
+| status | 'active'<br />'inactive'<br />'trimming' | The current status of the shard |
+| sync | [sync]({{< relref "/operate/rs/references/rest-api/objects/shard/sync.md" >}}) object | Shard's current sync status and progress |
+---
+Title: OCSP status object
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: An object that represents the cluster's OCSP status
+linkTitle: ocsp_status
+weight: $weight
+---
+
+An API object that represents the cluster's OCSP status.
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| cert_status | string | Indicates the proxy certificate's status: GOOD/REVOKED/UNKNOWN (read-only) |
+| responder_url | string | The OCSP responder URL this status came from (read-only) |
+| next_update | string | The expected date and time of the next certificate status update (read-only) |
+| produced_at | string | The date and time when the OCSP responder signed this response (read-only) |
+| revocation_time | string | The date and time when the certificate was revoked or placed on hold (read-only) |
+| this_update | string | The most recent time that the responder confirmed the current status (read-only) |
+---
+Title: Redis Enterprise REST API objects
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the objects used with Redis Enterprise Software REST API calls.
+hideListLinks: true
+linkTitle: Objects
+weight: 40
+---
+
+Certain [REST API requests]({{< relref "/operate/rs/references/rest-api/requests" >}}) require you to include specific objects in the request body. Many requests also return objects in the response body.
+
+Both REST API requests and responses represent these objects as [JSON](https://www.json.org).
+
+{{< table-children columnNames="Object,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Suffixes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: DNS suffixes requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: suffixes
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-suffixes) | `/v1/suffixes` | Get all DNS suffixes |
+
+## Get all suffixes {#get-all-suffixes}
+
+	GET /v1/suffixes
+
+Get all DNS suffixes in the cluster.
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/suffixes 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+The response body contains a JSON array with all suffixes, represented as [suffix objects]({{< relref "/operate/rs/references/rest-api/objects/suffix" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "name": "cluster.fqdn",
+        "// additional fields..."
+    },
+    {
+        "name": "internal.cluster.fqdn",
+        "// additional fields..."
+    }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Migrate shards requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to migrate database shards
+headerRange: '[1-2]'
+linkTitle: migrate
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-multi-shards) | `/v1/shards/actions/migrate` | Migrate multiple shards |
+| [POST](#post-shard) | `/v1/shards/{uid}/actions/migrate` | Migrate a specific shard |
+
+## Migrate multiple shards {#post-multi-shards}
+
+    POST /v1/shards/actions/migrate
+
+Migrates the list of given shard UIDs to the node specified by `target_node_uid`. The shards can be from multiple databases. This request is asynchronous.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/databases/migrate-shards">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [migrate_shard]({{< relref "/operate/rs/references/rest-api/permissions#migrate_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-multi-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/actions/migrate
+
+#### Example JSON body
+
+```json
+{
+  "shard_uids": ["2","4","6"],
+  "target_node_uid": 9,
+  "override_rack_policy": false,
+  "preserve_roles": false,
+  "max_concurrent_bdb_migrations": 3
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body {#post-multi-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| shard_uids | array of strings | List of shard UIDs to migrate. |
+| target_node_uid | integer | UID of the node to where the shards should migrate. |
+| override_rack_policy | boolean | If true, overrides and ignores rack-aware policy violations. |
+| dry_run | boolean | Determines whether the migration is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. |
+| preserve_roles | boolean | If true, preserves the migrated shards' roles after migration. |
+| max_concurrent_bdb_migrations | integer | The number of concurrent databases that can migrate shards. |
+
+### Response {#post-multi-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Migrate was triggered"
+}
+```
+
+### Status codes {#post-multi-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Conflicting parameters. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | A list of shard UIDs is required and not given, a specified shard does not exist, or a node UID is required and not given. |
+| [500 Internal Server Error](https://www.rfc-editor.org/rfc/rfc9110.html#name-500-internal-server-error) | Migration failed. |
+
+
+## Migrate shard {#post-shard}
+
+    POST /v1/shards/{int: uid}/actions/migrate
+
+Migrates the shard with the given `shard_uid` to the node specified by `target_node_uid`. If the shard is already on the target node, nothing happens. This request is asynchronous.
+
+For more information about shard migration use cases and considerations, see [Migrate database shards]({{<relref "/operate/rs/databases/migrate-shards">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [migrate_shard]({{< relref "/operate/rs/references/rest-api/permissions#migrate_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/1/actions/migrate
+
+#### Example JSON body
+
+```json
+{
+    "target_node_uid": 9,
+    "override_rack_policy": false,
+    "preserve_roles": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard to migrate. |
+
+
+#### Request body {#post-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| target_node_uid | integer | UID of the node to where the shard should migrate. |
+| override_rack_policy | boolean | If true, overrides and ignores rack-aware policy violations. |
+| dry_run | boolean | Determines whether the migration is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. |
+| preserve_roles | boolean | If true, preserves the migrated shards' roles after migration. |
+
+### Response {#post-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Migrate was triggered"
+}
+```
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist, or node UID is required and not given. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy. |
+---
+Title: Shard failover requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to fail over database shards
+headerRange: '[1-2]'
+linkTitle: failover
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-multi-shards) | `/v1/shards/actions/failover` | Fail over multiple shards |
+| [POST](#post-shard) | `/v1/shards/{uid}/actions/failover` | Fail over a specific shard |
+
+## Fail over multiple shards {#post-multi-shards}
+
+    POST /v1/shards/actions/failover
+
+Performs failover on the primary shards specified by `shard_uids` in the request body, and promotes their replicas to primary shards. This request is asynchronous.
+
+The cluster automatically manages failover to ensure high availability. Use this failover REST API request only for testing and planned maintenance.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [failover_shard]({{< relref "/operate/rs/references/rest-api/permissions#failover_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-multi-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/actions/failover
+
+#### Example JSON body
+
+```json
+{
+    "shard_uids": ["2","4","6"]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body {#post-multi-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| shard_uids | array of strings | List of primary shard UIDs to fail over. The shards must belong to the same database. |
+| dead_uids | array of strings | Primary shards to avoid stopping. Optional. |
+| dead_nodes | array of strings | Nodes that should not be drained or used for promoted replica shards. Optional. |
+| dry_run | boolean | Determines whether the failover is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. Optional. |
+| force_rebind | boolean | Rebind after promotion. Optional. |
+| redis_version_upgrade | string | New version of the promoted primary shards. Optional. |
+
+### Response {#post-multi-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Failover was triggered"
+}
+```
+
+### Status codes {#post-multi-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Shard is a replica or the specified failover shards are not in the same database. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | A list of shard UIDs is required and not given, or a specified shard does not exist. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy. |
+
+### Error codes {#put-multi-error-codes}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_busy | Database is currently busy. |
+| failover_shards_different_bdb | All failover shards should be in the same database. |
+| shard_is_slave | Shard is a replica. |
+| shard_not_exist | Shard does not exist. |
+| shard_uids_required | List of shard UIDs is required and not given. |
+
+## Fail over shard {#post-shard}
+
+    POST /v1/shards/{int: uid}/actions/failover
+
+Performs failover on the primary shard with the specified `shard_uid`, and promotes its replica shard to a primary shard. This request is asynchronous.
+
+The cluster automatically manages failover to ensure high availability. Use this failover REST API request only for testing and planned maintenance.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [failover_shard]({{< relref "/operate/rs/references/rest-api/permissions#failover_shard" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/shards/1/actions/failover
+
+#### Example JSON body
+
+```json
+{
+    "force_rebind": true
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard to fail over. |
+
+
+#### Request body {#post-request-body}
+
+The request body is a JSON object that can contain the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dead_uid | string | Primary shard to avoid stopping. Optional. |
+| dead_nodes | array of strings | Nodes that should not be drained or used for promoted replica shards. Optional. |
+| dry_run | boolean | Determines whether the failover is actually done. If true, will just do a dry run. If the dry run succeeds, the request returns a `200 OK` status code.  Otherwise, it returns a JSON object with an error code and description. Optional. |
+| force_rebind | boolean | Rebind after promotion. Optional. |
+| redis_version_upgrade | string | New version of the promoted primary shards. Optional. |
+
+### Response {#post-response} 
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Example JSON body
+
+```json
+{
+    "action_uid": "e5e24ddf-a456-4a7e-ad53-4463cd44880e",
+    "description": "Failover was triggered"
+}
+```
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Shard is a replica. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Specified shard does not exist. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy. |
+
+### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_busy | Database is currently busy. |
+| shard_is_slave | Shard is a replica. |
+| shard_not_exist | Shard does not exist. |
+---
+Title: Shard actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to perform shard actions
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+---
+
+## Migrate
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-multi-shards">}}) | `/v1/shards/actions/migrate` | Migrate multiple shards |
+| [POST]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/migrate#post-shard">}}) | `/v1/shards/{uid}/actions/migrate` | Migrate a specific shard |
+---
+Title: Latest shards stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent shard statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards-stats-last) | `/v1/shards/stats/last` | Get most recent stats for all shards |
+| [GET](#get-shard-stats-last) | `/v1/shards/stats/last/{uid}` | Get most recent stats for a specific shard |
+
+## Get latest stats for all shards {#get-all-shards-stats-last}
+
+	GET /v1/shards/stats/last
+
+Get most recent statistics for all shards.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_shard_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_shard_stats" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/last?interval=1sec&stime=015-05-27T08:27:35Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response} 
+
+Returns most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all shards.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:28:36Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+   },
+   "2": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:40Z",
+      "etime": "2015-05-28T08:28:45Z",
+      "// additional fields..."
+   }
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | No shards exist |
+
+## Get latest shard stats {#get-shard-stats-last}
+
+	GET /v1/shards/stats/last/{int: uid}
+
+Get most recent statistics for a specific shard.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_shard_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_shard_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/last/1?interval=1sec&stime=2015-05-28T08:27:35Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns the most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the specified shard.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:27:36Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+   }
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Shard isn't currently active |
+---
+Title: Shards stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Shard statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards-stats) | `/v1/shards/stats` | Get stats for all shards |
+| [GET](#get-shard-stats) | `/v1/shards/stats/{uid}` | Get stats for a specific shard |
+
+## Get all shards stats {#get-all-shards-stats}
+
+	GET /v1/shards/stats
+
+Get statistics for all shards.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_shard_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_shard_stats" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| parent_uid | integer | Only return shard from the given BDB ID (optional) |
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| metrics | list | Comma-separated list of [metric names]({{< relref "/operate/rs/references/rest-api/objects/statistics/shard-metrics" >}}) for which we want statistics (default is all) (optional) |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all shards.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "status": "active",
+    "uid": "1",
+    "node_uid": "1",
+    "assigned_slots": "0-8191",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:35Z",
+      "etime": "2015-05-28T08:27:40Z",
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "read_hits": 0.0,
+      "pubsub_patterns": 0.0,
+      "no_of_keys": 0.0,
+      "mem_size_lua": 35840.0,
+      "last_save_time": 1432541051.0,
+      "sync_partial_ok": 0.0,
+      "connected_clients": 9.0,
+      "avg_ttl": 0.0,
+      "write_misses": 0.0,
+      "used_memory": 5651440.0,
+      "sync_full": 0.0,
+      "expired_objects": 0.0,
+      "total_req": 0.0,
+      "blocked_clients": 0.0,
+      "pubsub_channels": 0.0,
+      "evicted_objects": 0.0,
+      "no_of_expires": 0.0,
+      "interval": "1sec",
+      "write_hits": 0.0,
+      "read_misses": 0.0,
+      "sync_partial_err": 0.0,
+      "rdb_changes_since_last_save": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:27:40Z",
+      "etime": "2015-05-28T08:27:45Z",
+      "// additional fields..."
+      }
+    ]
+  },
+  {
+    "uid": "2",
+    "status": "active",
+    "node_uid": "1",
+    "assigned_slots": "8192-16383",
+    "intervals": [
+      {
+        "interval": "1sec",
+        "stime": "2015-05-28T08:27:35Z",
+        "etime": "2015-05-28T08:27:40Z",
+        "// additional fields..."
+      },
+      {
+        "interval": "1sec",
+        "stime": "2015-05-28T08:27:40Z",
+        "etime": "2015-05-28T08:27:45Z",
+        "// additional fields..."
+      }
+    ]
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | No shards exist |
+
+## Get shard stats {#get-shard-stats}
+
+	GET /v1/shards/stats/{int: uid}
+
+Get statistics for a specific shard.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_shard_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_shard_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the shard requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the specified shard.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "status": "active",
+  "node_uid": "1",
+  "role": "master",
+  "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:24:13Z",
+      "etime": "2015-05-28T08:24:18Z",
+      "avg_ttl": 0.0,
+      "blocked_clients": 0.0,
+      "connected_clients": 9.0,
+      "etime": "2015-05-28T08:24:18Z",
+      "evicted_objects": 0.0,
+      "expired_objects": 0.0,
+      "last_save_time": 1432541051.0,
+      "used_memory": 5651440.0,
+      "mem_size_lua": 35840.0,
+      "used_memory_peak": 5888264.0,
+      "used_memory_rss": 5888264.0,
+      "no_of_expires": 0.0,
+      "no_of_keys": 0.0,
+      "pubsub_channels": 0.0,
+      "pubsub_patterns": 0.0,
+      "rdb_changes_since_last_save": 0.0,
+      "read_hits": 0.0,
+      "read_misses": 0.0,
+      "stime": "2015-05-28T08:24:13Z",
+      "sync_full": 0.0,
+      "sync_partial_err": 0.0,
+      "sync_partial_ok": 0.0,
+      "total_req": 0.0,
+      "write_hits": 0.0,
+      "write_misses": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:24:18Z",
+      "etime": "2015-05-28T08:24:23Z",
+
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard does not exist |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Shard isn't currently active |
+---
+Title: Shard requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database shards
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: shards
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-shards) | `/v1/shards` | Get all shards |
+| [GET](#get-shard) | `/v1/shards/{uid}` | Get a specific shard |
+
+## Get all shards {#get-all-shards}
+
+	GET /v1/shards
+
+Get information about all shards in the cluster.
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| extra_info_keys | list of strings | A list of extra keys to be fetched (optional) |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [shard objects]({{<relref "/operate/rs/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "role": "master",
+    "assigned_slots": "0-16383",
+    "bdb_uid": 1,
+    "detailed_status": "ok",
+    "loading": {
+      "status": "idle"
+    },
+    "node_uid": "1",
+    "redis_info": {
+			"connected_clients": 14,
+			"used_memory_rss": 12263424
+		},
+    "report_timestamp": "2024-06-28T18:44:01Z",
+    "status": "active"
+  },
+  {
+    "uid": 2,
+    "role": "slave",
+    // additional fields...
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+
+## Get shard {#get-shard}
+
+	GET /v1/shards/{int: uid}
+
+Gets information about a single shard.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/shards/1?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the requested shard. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| extra_info_keys | list of strings | A list of extra keys to be fetched (optional) |
+
+### Response {#get-response} 
+
+Returns a [shard object]({{<relref "/operate/rs/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+{
+  "assigned_slots": "0-16383",
+  "bdb_uid": 1,
+  "detailed_status": "ok",
+  "loading": {
+    "status": "idle"
+  },
+  "node_uid": "1",
+  "redis_info": {
+		"connected_clients": 14,
+		"used_memory_rss": 12263424
+	},
+  "role": "master",
+  "report_timestamp": "2024-06-28T18:44:01Z",
+  "status": "active",
+  "uid": "1"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Shard UID does not exist. |
+---
+Title: Cluster debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /cluster/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-debuginfo) | `/v1/cluster/debuginfo` | Get debug info from all nodes and databases |
+
+## Get cluster debug info {#get-cluster-debuginfo}
+
+	GET /v1/cluster/debuginfo
+
+Downloads a tar file that contains debug info from all nodes and databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info for all nodes.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Change password hashing algorithm requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to change the hashing algorithm for user passwords.
+headerRange: '[1-2]'
+linkTitle: change_password_hashing_algorithm
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PATCH](#patch-change-password-hashing-algorithm) | `/v1/cluster/change_password_hashing_algorithm` | Change the hashing policy for user passwords |
+
+## Change password hashing algorithm {#patch-change-password-hashing-algorithm}
+
+	PATCH /v1/cluster/change_password_hashing_algorithm
+
+Changes the password hashing algorithm for the entire cluster. When you change the hashing algorithm, it rehashes the administrator password and passwords for all users, including default users.
+
+The hashing algorithm options are `SHA-256` or `PBKDF2`. The default hashing algorithm is `SHA-256`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#patch-request} 
+
+#### Example HTTP request
+
+	PATCH /v1/cluster/change_password_hashing_algorithm
+
+#### Example JSON body
+
+```json
+{ "algorithm": "PBKDF2" }
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a JSON object `{ "algorithm": "<option>" }` in the request body. The hashing algorithm options are `SHA-256` or `PBKDF2`.
+
+### Response {#patch-response} 
+
+Returns a status code that indicates the success or failure of the update.
+
+### Status codes {#patch-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Supported algorithm must be provided, or this algorithm is already set |
+---
+Title: Cluster services configuration requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster services configuration requests
+headerRange: '[1-2]'
+linkTitle: services_configuration
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-services_config) | `/v1/cluster/services_configuration` | Get cluster services settings |
+| [PUT](#put-cluster-services_config) | `/v1/cluster/services_configuration` | Update cluster services settings |
+
+## Get cluster services configuration {#get-cluster-services_config}
+
+	GET /v1/cluster/services_configuration
+
+Get cluster services settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/services_configuration 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [services configuration object]({{< relref "/operate/rs/references/rest-api/objects/services_configuration" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "mdns_server": {
+         "operating_mode": "enabled"
+     },
+     "// additional services..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Update cluster services configuration {#put-cluster-services_config}
+
+	PUT /v1/cluster/services_configuration
+
+Update the cluster services settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/services_configuration 
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "// additional services..."
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [services configuration object]({{< relref "/operate/rs/references/rest-api/objects/services_configuration" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [services configuration object]({{< relref "/operate/rs/references/rest-api/objects/services_configuration" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "cm_server": {
+         "operating_mode": "disabled"
+     },
+     "mdns_server": {
+         "operating_mode": "enabled"
+     },
+     "// additional services..."
+}
+```
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Rotate cluster certificates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Rotate cluster certificates requests
+headerRange: '[1-2]'
+linkTitle: rotate
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-cluster-certificates-rotate) | `/v1/cluster/certificates/rotate` | Regenerate all internal cluster certificates |
+
+## Rotate cluster certificates {#post-cluster-certificates-rotate}
+
+	POST /v1/cluster/certificates/rotate
+
+Regenerates all _internal_ cluster certificates.
+
+The certificate rotation will be performed on all nodes within the cluster. If
+"name" is provided, only rotate the specified certificate on all nodes within the cluster.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/cluster/certificates/rotate
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#post-response} 
+
+Responds with a `200 OK` status code if the internal certificates successfully rotate across the entire cluster.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Failed, not all nodes have been updated. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Unsupported internal certificate rotation. |
+---
+Title: Cluster certificates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster certificates requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: certificates
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-certificates) | `/v1/cluster/certificates` | Get cluster certificates |
+| [PUT](#put-cluster-update_cert) | `/v1/cluster/update_cert` | Update a cluster certificate |
+| [DELETE](#delete-cluster-certificate) | `/v1/cluster/certificates/{certificate_name}` | Delete cluster certificate |
+
+## Get cluster certificates {#get-cluster-certificates}
+
+	GET /v1/cluster/certificates
+
+Get the cluster's certificates.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/certificates 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the cluster's certificates and keys.
+
+#### Example JSON body
+
+```json
+{
+    "api_cert": "-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----",
+    "api_key": "-----BEGIN RSA PRIVATE KEY-----...-----END RSA PRIVATE KEY-----"
+    "// additional certificates..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+
+## Update cluster certificate {#put-cluster-update_cert}
+
+```sh
+PUT /v1/cluster/update_cert
+```
+
+Replaces an existing certificate on all nodes within the cluster with a new certificate. The new certificate must pass validation before it can replace the old certificate.
+
+See the [certificates table]({{< relref "/operate/rs/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/cluster/update_cert
+```
+
+#### Example JSON body
+
+```json
+{
+    "name": "certificate1",
+    "key": "-----BEGIN RSA PRIVATE KEY-----\n[key_content]\n-----END RSA PRIVATE KEY-----",
+    "certificate": "-----BEGIN CERTIFICATE-----\n[cert_content]\n-----END CERTIFICATE-----",
+}
+```
+
+Replace `[key_content]` with the content of the private key and `[cert_content]` with the content of the certificate.
+
+### Response {#put-response}
+
+Responds with the `200 OK` status code if the certificate replacement succeeds across the entire cluster.
+
+Otherwise, retry the certificate update in case the failure was due to a temporary issue in the cluster.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Failed, invalid certificate. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Failed, unknown certificate. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Failed, invalid certificate. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Failed, expired certificate. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Failed, not all nodes have been updated. |
+
+
+## Delete cluster certificate {#delete-cluster-certificate}
+
+	DELETE /v1/cluster/certificates/{string: certificate_name}
+
+Removes the specified cluster certificate from both CCS and disk
+across all nodes. Only optional certificates can be deleted through
+this endpoint. See the [certificates table]({{< relref "/operate/rs/security/certificates" >}}) for the list of cluster certificates and their descriptions.
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/certificates/<certificate_name>
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates the certificate deletion success or failure.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Operation successful |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Failed, requested deletion of an unknown certificate |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Failed, requested deletion of a required certificate |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed, error while deleting certificate from disk |
+---
+Title: Check all cluster nodes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that run checks on all cluster nodes.
+headerRange: '[1-2]'
+linkTitle: check
+toc: 'true'
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-check) | `/v1/cluster/check` | Runs checks on all cluster nodes |
+
+## Check all nodes {#get-cluster-check}
+
+	GET /v1/cluster/check
+
+Runs the following checks on all cluster nodes:
+
+| Check name | Description |
+|-----------|-------------|
+| bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| services | Verifies all Redis Enterprise Software services are running. |
+| port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| pidfiles | Verifies all active local shards have PID files. |
+| capabilities | Verifies all binaries have the proper capability bits. |
+| existing_sockets | Verifies sockets exist for all processes that require them. |
+| host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />• `transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_checks]({{< relref "/operate/rs/references/rest-api/permissions#view_all_nodes_checks" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/check
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+### Response {#get-response} 
+
+Returns a JSON array with results from all nodes.
+
+When errors occur, the server returns a JSON object with `result: false` and an `error` field that provides additional information for each node that had an error. If an error occurs during a check, the `error` field only includes a message for the first check that fails on each node.
+
+Possible `error` messages:
+
+- "bootstrap request to cnm_http failed,resp_code: ...,resp_content: ..."
+- "process ... is not running or not responding (...)"
+- "could not communicate with 'supervisorctl': ..."
+- "connectivity check failed retrieving ports for testing"
+
+#### Example JSON body
+
+```json
+{
+  "cluster_test_result": false,
+  "nodes": [
+    {
+      "node_uid": "1",
+      "result": true
+    },
+    {
+      "node_uid": "2",
+      "result": true
+    },
+    {
+      "node_uid": "3",
+      "result": false,
+      "error": "process alert_mgr is not running or not responding ([Errno 111] Connection refused)"
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+---
+Title: Cluster LDAP requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: LDAP configuration requests
+headerRange: '[1-2]'
+linkTitle: ldap
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-ldap) | `/v1/cluster/ldap` | Get LDAP configuration |
+| [PUT](#put-cluster-ldap) | `/v1/cluster/ldap` | Set/update LDAP configuration |
+| [DELETE](#delete-cluster-ldap) | `/v1/cluster/ldap` | Delete LDAP configuration |
+
+## Get LDAP configuration {#get-cluster-ldap}
+
+	GET /v1/cluster/ldap
+
+Get the LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ldap_config]({{< relref "/operate/rs/references/rest-api/permissions#view_ldap_config" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/ldap 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [LDAP object]({{< relref "/operate/rs/references/rest-api/objects/ldap" >}}).
+
+#### Example JSON body
+
+```json
+{
+   "bind_dn": "rl_admin",
+   "bind_pass": "***",
+   "ca_cert": "",
+   "control_plane": false,
+   "data_plane": false,
+   "dn_group_attr": "MemberOf",
+   "dn_group_query": {},
+   "starttls": false,
+   "uris": ["ldap://ldap.example.org:636"],
+   "user_dn_query": {},
+   "user_dn_template": "cn=%u, ou=users,dc=example,dc=org"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+
+## Update LDAP configuration {#put-cluster-ldap}
+
+	PUT /v1/cluster/ldap
+
+Set or update the cluster LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ldap]({{< relref "/operate/rs/references/rest-api/permissions#config_ldap" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	POST /v1/cluster/ldap 
+
+#### Example JSON body
+
+```json
+{
+    "uris": [
+       "ldap://ldap.redislabs.com:389"
+    ],
+    "bind_dn": "rl_admin",
+    "bind_pass": "secret",
+    "user_dn_template": "cn=%u,dc=example,dc=org",
+    "dn_group_attr": "MemberOf",
+    "directory_timeout_s": 5
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP object]({{< relref "/operate/rs/references/rest-api/objects/ldap" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#put-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| illegal_fields_combination | An unacceptable combination of fields was specified for the configuration object (e.g.: two mutually-exclusive fields), or a required field is missing.| 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, LDAP config has been set. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+
+## Delete LDAP configuration {#delete-cluster-ldap}
+
+	DELETE /v1/cluster/ldap
+
+Clear the LDAP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ldap]({{< relref "/operate/rs/references/rest-api/permissions#config_ldap" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/ldap 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+---
+Title: Cluster module capabilities requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis module capabilities requests
+headerRange: '[1-2]'
+linkTitle: module-capabilities
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-module-capabilities) | `/v1/cluster/module-capabilities` | List possible Redis module capabilities |
+
+## List Redis module capabilities {#get-cluster-module-capabilities}
+
+	GET /v1/cluster/module-capabilities
+
+List possible Redis module capabilities.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_modules]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_modules" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/module-capabilities 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains a list of capability names and descriptions.
+
+#### Example JSON body
+
+```json
+{
+  "all_capabilities": [
+    {"name": "types", "desc": "module has its own types and not only operate on existing redis types"},
+    {"name": "no_multi_key", "desc": "module has no methods that operate on multiple keys"}
+    "// additional capabilities..."
+  ]
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+---
+Title: Auditing database connections requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Auditing database connections requests
+headerRange: '[1-2]'
+linkTitle: auditing/db_conns
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Get database connection auditing settings |
+| [PUT](#put-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Update database connection auditing settings |
+| [DELETE](#delete-cluster-audit-db-conns) | `/v1/cluster/auditing/db_conns` | Delete database connection auditing settings |
+
+## Get database auditing settings {#get-cluster-audit-db-conns}
+
+	GET /v1/cluster/auditing/db_conns
+
+Gets the configuration settings for [auditing database connections]({{< relref "/operate/rs/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/auditing/db_conns 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [database connection auditing configuration object]({{< relref "/operate/rs/references/rest-api/objects/db-conns-auditing-config" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_protocol": "TCP",
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_auditing_unsupported_by_capability | Not all nodes support DB Connections Auditing capability  | 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+
+## Update database auditing {#put-cluster-audit-db-conns}
+
+	PUT /v1/cluster/auditing/db_conns
+
+Updates the configuration settings for [auditing database connections]({{< relref "/operate/rs/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/auditing/db_conns
+
+#### Example JSON body
+
+```json
+{
+    "audit_protocol": "TCP",
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [database connection auditing configuration object]({{< relref "/operate/rs/references/rest-api/objects/db-conns-auditing-config" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [database connection auditing configuration object]({{< relref "/operate/rs/references/rest-api/objects/db-conns-auditing-config" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "audit_address": "127.0.0.1",
+    "audit_port": 12345,
+    "audit_protocol": "TCP",
+    "audit_reconnect_interval": 1,
+    "audit_reconnect_max_attempts": 0
+}
+```
+
+### Error codes {#put-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_auditing_unsupported_by_capability | Not all nodes support DB Connections Auditing capability  | 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+
+## Delete database auditing settings {#delete-cluster-audit-db-conns}
+
+	DELETE /v1/cluster/auditing/db_conns
+
+Resets the configuration settings for [auditing database connections]({{< relref "/operate/rs/security/audit-events" >}}).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/cluster/auditing/db_conns 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates whether the database connection auditing settings reset successfully or failed to reset.
+
+### Error codes {#delete-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_conns_audit_config_not_found | Unable to find the auditing configuration |
+| cannot_delete_audit_config_when_policy_enabled | Auditing cluster policy is 'enabled' when trying to delete the auditing configuration |
+| cannot_delete_audit_config_when_bdb_enabled | One of the databases has auditing configuration 'enabled' when trying to delete the auditing configuration |
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Configuration not found |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Feature not supported for all nodes |
+---
+Title: Cluster alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-alerts) | `/v1/cluster/alerts` | Get all cluster alerts |
+| [GET](#get-alert) | `/v1/cluster/alerts/{alert}` | Get a specific cluster alert |
+
+## Get all cluster alerts {#get-all-alerts}
+
+	GET /v1/cluster/alerts
+
+Get all alert states for the cluster object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster’s alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-all-response} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "cluster_too_few_nodes_for_replication": {
+        "change_time": "2014-12-22T11:48:00Z",
+        "change_value": {
+            "state": false
+        },
+       "enabled": true,
+       "state": "off",
+       "severity": "WARNING",
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get cluster alert {#get-alert}
+
+	GET /v1/cluster/alerts/{alert}
+
+Get a cluster alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/alerts/cluster_too_few_nodes_for_replication 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster’s alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "change_time": "2014-12-22T11:48:00Z",
+    "change_value": {
+        "state": false
+    },
+   "enabled": true,
+   "state": "off",
+   "severity": "WARNING",
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert does not exist |
+---
+Title: Cluster actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster action requests
+headerRange: '[1-2]'
+linkTitle: actions
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-cluster-actions) | `/v1/cluster/actions` | Get the status of all actions  |
+| [GET](#get-cluster-action) | `/v1/cluster/actions/{action}` | Get the status of a specific action |
+| [POST](#post-cluster-action) | `/v1/cluster/actions/{action}` | Initiate a cluster-wide action |
+| [DELETE](#delete-cluster-action) | `/v1/cluster/actions/{action}` | Cancel action or remove action status |
+
+## Get all cluster actions {#get-all-cluster-actions}
+
+	GET /v1/cluster/actions
+
+Get the status of all currently executing, queued, or completed cluster actions.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+    GET /v1/cluster/actions
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [action objects]({{< relref "/operate/rs/references/rest-api/objects/action" >}}). 
+
+#### Example JSON body
+
+```json
+{
+    "actions": [
+        {
+            "name": "action_name",
+            "status": "queued",
+            "progress": 0.0
+        }
+    ]
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Get cluster action {#get-cluster-action}
+
+	GET /v1/cluster/actions/{action}
+
+Get the status of a currently executing, queued, or completed cluster action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The action to check. |
+
+### Response {#get-response} 
+
+Returns an [action object]({{< relref "/operate/rs/references/rest-api/objects/action" >}}). 
+
+#### Example JSON body
+
+```json
+{
+    "name": "action_name",
+     "status": "queued",
+    "progress": 0.0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Initiate cluster-wide action {#post-cluster-action}
+
+	POST /v1/cluster/actions/{action}
+
+Initiate a cluster-wide action.
+
+The API allows only a single instance of any action type to be
+invoked at the same time, and violations of this requirement will
+result in a `409 CONFLICT` response.
+
+The caller is expected to query and process the results of the
+previously executed instance of the same action, which will be
+removed as soon as the new one is submitted.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [start_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#start_cluster_action" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+    POST /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action required. |
+
+Supported cluster actions:
+
+- `change_master`: Promotes a specified node to become the primary node of the cluster, which coordinates cluster-wide operations. Include the `node_uid` of the node you want to promote in the request body.
+
+    ```sh
+    POST /v1/cluster/actions/change_master
+    {
+        "node_uid": "2"
+    }
+    ```
+
+### Response {#post-response} 
+
+The body content may provide additional action details. Currently, it is not used. 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, action was initiated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad action or content provided. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | A conflicting action is already in progress. |
+
+## Cancel action {#delete-cluster-action}
+
+	DELETE /v1/cluster/actions/{action}
+
+Cancel a queued or executing cluster action, or remove the status of
+a previously executed and completed action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [cancel_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#cancel_cluster_action" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+    DELETE /v1/cluster/actions/action_name
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action to cancel, currently no actions are supported. |
+
+### Response {#delete-response} 
+
+Returns a status code.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action will be cancelled when possible. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action unknown or not currently running. |
+---
+Title: Cluster policy requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster policy requests
+headerRange: '[1-2]'
+linkTitle: policy
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-policy) | `/v1/cluster/policy` | Get cluster policy settings |
+| [PUT](#put-cluster-policy) | `/v1/cluster/policy` | Update cluster policy settings |
+
+## Get cluster policy {#get-cluster-policy}
+
+	GET /v1/cluster/policy
+
+Gets the cluster's current policy settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/policy 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [cluster settings object]({{< relref "/operate/rs/references/rest-api/objects/cluster_settings" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "db_conns_auditing": false,
+    "default_non_sharded_proxy_policy": "single",
+    "default_provisioned_redis_version": "6.0",
+    "default_sharded_proxy_policy": "single",
+    "default_shards_placement": "dense",
+    "redis_upgrade_policy": "major",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+
+## Update cluster policy {#put-cluster-policy}
+
+	PUT /v1/cluster/policy
+
+Update cluster policy settings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster/policy
+
+#### Example JSON body
+
+```json
+{
+    "default_shards_placement": "sparse",
+    "default_sharded_proxy_policy": "all-nodes"
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [cluster settings object]({{< relref "/operate/rs/references/rest-api/objects/cluster_settings" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns a status code that indicates the success or failure of the cluster settings update.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Failed to set parameters |
+---
+Title: Cluster last stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent cluster statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-stats-last) | `/v1/cluster/stats/last` | Get most recent cluster stats |
+
+## Get latest cluster stats {#get-cluster-stats-last}
+
+	GET /v1/cluster/stats/last
+
+Get the most recent cluster statistics.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster/stats/last?interval=1sec&stime=2015-10-14T06:44:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+Returns the most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the cluster.
+
+#### Example JSON body
+
+```json
+{
+    "conns": 0.0,
+    "cpu_idle": 0.8424999999988358,
+    "cpu_system": 0.01749999999992724,
+    "cpu_user": 0.08374999999978172,
+    "egress_bytes": 7403.0,
+    "ephemeral_storage_avail": 151638712320.0,
+    "ephemeral_storage_free": 162375925760.0,
+    "etime": "2015-10-14T06:44:01Z",
+    "free_memory": 5862400000.0,
+    "ingress_bytes": 7469.0,
+    "interval": "1sec",
+    "persistent_storage_avail": 151638712320.0,
+    "persistent_storage_free": 162375925760.0,
+    "stime": "2015-10-14T06:44:00Z",
+    "total_req": 0.0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal server error |
+---
+Title: Cluster stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster-stats) | `/v1/cluster/stats` | Get cluster stats |
+
+## Get cluster stats {#get-cluster-stats}
+
+```sh
+GET /v1/cluster/stats
+```
+
+Get cluster statistics.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/cluster/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the cluster.
+
+#### Example JSON body
+
+```json
+{
+  "intervals": [
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T12:00:00Z",
+      "etime": "2015-05-28T12:59:59Z",
+      "conns": 0.0,
+      "cpu_idle": 0.8533959401503577,
+      "cpu_system": 0.01602159448549579,
+      "cpu_user": 0.08721123782294203,
+      "egress_bytes": 1111.2184745131947,
+      "ephemeral_storage_avail": 3406676307.1449075,
+      "ephemeral_storage_free": 4455091440.360014,
+      "free_memory": 2745470765.673594,
+      "ingress_bytes": 220.84083194769272,
+      "interval": "1week",
+      "persistent_storage_avail": 3406676307.1533995,
+      "persistent_storage_free": 4455091440.088265,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T13:00:00Z",
+      "etime": "2015-05-28T13:59:59Z",
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X GET
+        https://[host][:port]/v1/cluster/stats?interval=1hour
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/cluster/stats?interval=1hour"
+auth = ("[username]", "[password]")
+
+response = requests.request("GET", url, auth=auth)
+
+print(response.text)
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal server error |
+---
+Title: Cluster requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster settings requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: cluster
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cluster) | `/v1/cluster` | Get cluster info |
+| [PUT](#put-cluster) | `/v1/cluster` | Update cluster settings |
+
+## Get cluster info {#get-cluster}
+
+	GET /v1/cluster
+
+Get cluster info.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/cluster 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a [cluster object]({{< relref "/operate/rs/references/rest-api/objects/cluster" >}}).
+
+#### Example JSON body
+
+```json
+{
+   "name": "my-rlec-cluster",
+   "alert_settings": { "..." },
+   "created_time": "2015-04-29T09:09:25Z",
+   "email_alerts": false,
+   "email_from": "",
+   "rack_aware": false,
+   "smtp_host": "",
+   "smtp_password": "",
+   "smtp_port": 25,
+   "smtp_tls_mode": "none",
+   "smtp_username": ""
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Update cluster settings {#put-cluster}
+
+	PUT /v1/cluster
+
+Update cluster settings.
+
+If called with the `dry_run` URL query string, the function will
+validate the [cluster object]({{< relref "/operate/rs/references/rest-api/objects/cluster" >}}), but will not apply the requested
+changes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/cluster 
+
+#### Example JSON body
+
+```json
+{
+    "email_alerts": true,
+    "alert_settings": {
+        "node_failed": true,
+        "node_memory": {
+            "enabled": true,
+            "threshold": "80"
+        }
+    }
+}
+```
+
+The above request will enable email alerts and alert reporting for node failures and node removals.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run | string | Validate but don't apply the new cluster settings |
+
+#### Request body
+
+Include a [cluster object]({{< relref "/operate/rs/references/rest-api/objects/cluster" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+#### Example JSON body
+
+```json
+{
+    "name": "mycluster.mydomain.com",
+    "email_alerts": true,
+    "alert_settings": {
+        "node_failed": true,
+        "node_memory": {
+            "enabled": true,
+            "threshold": "80"
+        }
+    },
+    "// additional fields..."
+}
+```
+
+### Error codes {#put-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| bad_nginx_conf | • Designated port is already bound.<br></br>• nginx configuration is illegal. | 
+| bad_debuginfo_path | • Debuginfo path doesn't exist.<br></br>• Debuginfo path is inaccessible. | 
+| config_edit_conflict | Cluster config was edited by another source simultaneously. | 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided. |
+
+---
+Title: Bootstrap validation requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Boostrap validation requests
+headerRange: '[1-2]'
+linkTitle: validate
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bootstrap-validate) | `/v1/bootstrap/validate/{action}` | Perform bootstrap validation |
+
+## Bootstrap validation {#post-bootstrap-validate}
+
+	POST /v1/bootstrap/validate/{action}
+
+Perform bootstrap validation.
+
+Unlike actual bootstrapping, this request blocks and immediately
+returns with a response.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/bootstrap/validate/join_cluster
+
+#### Request body
+
+The request must contain a [bootstrap configuration object]({{< relref "/operate/rs/references/rest-api/objects/bootstrap" >}}), similar to the one used for actual bootstrapping.
+
+### Response {#post-response} 
+
+If an error occurs, the call returns a `bootstrap_status` JSON object that contains the following fields:
+
+| Field | Description |
+|-------|-------------|
+| state | Current bootstrap state.<br></br>`idle`: No bootstrapping started.<br></br>`initiated`: Bootstrap request received.<br></br>`creating_cluster`: In the process of creating a new cluster.<br></br>`joining_cluster`: In the process of joining an existing cluster.<br></br>`error`: The last bootstrap action failed.<br></br>`completed`: The last bootstrap action completed successfully.|
+| start_time | Bootstrap process start time |
+| end_time | Bootstrap process end time |
+| error_code | If state is `error`, this error code describes the type of error encountered. |
+| error_details | An error-specific object that may contain additional information about the error. A common field in use is `message` which provides a more verbose error message.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, validation was successful. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Validation failed, bootstrap status is returned as body. |
+---
+Title: Bootstrap requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Bootstrap requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: bootstrap
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bootstrap) | `/v1/boostrap` | Get the local node's bootstrap status |
+| [POST](#post-bootstrap) | `/v1/bootstrap/{action}` | Initiate bootstrapping |
+
+## Get bootstrap status {#get-bootstrap}
+
+```sh
+GET /v1/bootstrap
+```
+
+Get the local node's bootstrap status.
+
+This request is accepted as soon the cluster software is installed and before the node is part of an active cluster.
+
+Once the node is part of an active cluster, authentication is required.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bootstrap
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+The JSON response object contains a `bootstrap_status` object and a `local_node_info` object.
+
+The `bootstrap_status` object contains the following information:
+
+| Field | Description |
+|-------|-------------|
+| state | Current bootstrap state.<br></br>`idle`: No bootstrapping started.<br></br>`initiated`: Bootstrap request received.<br></br>`creating_cluster`: In the process of creating a new cluster.<br></br>`recovering_cluster`: In the process of recovering a cluster.<br /><br />`joining_cluster`: In the process of joining an existing cluster.<br></br>`error`: The last bootstrap action failed.<br></br>`completed`: The last bootstrap action completed successfully.|
+| start_time | Bootstrap process start time |
+| end_time | Bootstrap process end time |
+| error_code | If state is `error`, this error code describes the type of error encountered. |
+| error_details | An error-specific object that may contain additional information about the error. A common field in use is `message` which provides a more verbose error message.
+
+The `local_node_info` object is a subset of a [node object]({{< relref "/operate/rs/references/rest-api/objects/node" >}}) that provides information about the node configuration.
+
+#### Example JSON body
+
+```json
+{
+    "bootstrap_status": {
+        "start_time": "2014-08-29T11:19:49Z",
+        "end_time": "2014-08-29T11:19:49Z",
+        "state": "completed"
+    },
+    "local_node_info": {
+        "uid": 3,
+        "software_version": "0.90.0-1",
+        "cores": 2,
+        "ephemeral_storage_path": "/var/opt/redislabs/tmp",
+        "ephemeral_storage_size": 1018889.8304,
+        "os_version": "Ubuntu 14.04 LTS",
+        "persistent_storage_path": "/var/opt/redislabs/persist/redis",
+        "persistent_storage_size": 1018889.8304,
+        "total_memory": 24137,
+        "uptime": 50278,
+        "available_addrs": [{
+                                 "address": "172.16.50.122",
+                                 "format": "ipv4",
+                                 "if_name": "eth0",
+                                 "private": true
+                             },
+                             {
+                                 "address": "10.0.3.1",
+                                 "format": "ipv4",
+                                 "if_name": "lxcbr0",
+                                 "private": true
+                             },
+                             {
+                                 "address": "172.17.0.1",
+                                 "format": "ipv4",
+                                 "if_name": "docker0",
+                                 "private": true
+                             },
+                            {
+                                 "address": "2001:db8:0:f101::1",
+                                 "format": "ipv6",
+                                 "if_name": "eth0",
+                                 "private": false
+                            }]
+    }
+}
+```
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| config_error | An error related to the bootstrap configuration provided (e.g. bad JSON). |
+| connect_error | Failed to connect to cluster (e.g. FQDN DNS could not resolve, no/wrong node IP provided, etc. |
+| access_denied | Invalid credentials supplied. |
+| invalid_license | The license string provided is invalid. Additional info can be fetched from the `error_details` object, which includes the violation code in case the license is valid but its terms are violated. |
+| repair_required | Cluster is in degraded mode and can only accept replacement nodes. When this happens, `error_details` contains two fields: `failed_nodes` and `replace_candidate`. The `failed_nodes` field is an array of objects, each describing a failed node with at least a `uid` field and an optional `rack_id`. `replace_candidate` is the UID of the node most suitable for replacement. |
+| insufficient_node_memory | An attempt to replace a dead node fails because the replaced node does not have enough memory. When this happens, error_details contains a required_memory field which indicates the node memory requirement. |
+| insufficient_node_flash | An attempt to replace a dead node fails because the replaced node does not have enough flash. When this happens, `error_details` contains a `required_flash` field which indicates the node flash requirement. |
+| time_not_sync | An attempt to join a node with system time not synchronized with the rest of the cluster. |
+| rack_id_required | An attempt to join a node with no `rack_id` in a rack-aware cluster. In addition, a `current_rack_ids` field will include an array of currently used rack ids. |
+| socket_directory_mismatch | An attempt to join a node with a socket directory setting that differs from the cluster |
+| node_config_mismatch | An attempt to join a node with a configuration setting (e.g. confdir, osuser, installdir) that differs from the cluster |
+| path_error | A needed path does not exist or is not accessable. |        
+| internal_error | A different, unspecified internal error was encountered. |
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Start bootstrapping {#post-bootstrap}
+
+```sh
+POST /v1/bootstrap/{action}
+```
+
+Initiate bootstrapping.
+
+The request must contain a bootstrap configuration JSON object, as
+described in [Object attributes]({{< relref "/operate/rs/references/rest-api/objects/" >}}) or a minimal subset.
+
+Bootstrapping is permitted only when the current bootstrap state is
+`idle` or `error` (in which case the process will restart with the new
+configuration).
+
+This request is asynchronous - once the request has been accepted,
+the caller is expected to poll bootstrap status while waiting for it to
+complete.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bootstrap/create_cluster
+```
+
+#### Example JSON body
+
+##### Join cluster
+```json
+{
+    "action": "join_cluster",
+    "cluster": {
+       "nodes":[ "1.1.1.1", "2.2.2.2" ]
+    },
+    "node": {
+       "paths": {
+          "persistent_path": "/path/to/persistent/storage",
+          "ephemeral_path": "/path/to/ephemeral/storage",
+          "bigstore_path": "/path/to/bigstore/storage"
+       },
+       "bigstore_driver": "speedb",
+       "identity": {
+          "addr":"1.2.3.4",
+          "external_addr":["2001:0db8:85a3:0000:0000:8a2e:0370:7334", "3.4.5.6"]
+       }
+    },
+    "credentials": {
+       "username": "my_username",
+       "password": "my_password"
+    }
+}
+```
+
+##### Create cluster
+```json
+{
+    "action": "create_cluster",
+    "cluster": {
+       "nodes": [],
+       "name": "my.cluster"
+    },
+    "node": {
+       "paths": {
+          "persistent_path": "/path/to/persistent/storage",
+          "ephemeral_path": "/path/to/ephemeral/storage",
+          "bigstore_path": "/path/to/bigredis/storage"
+       },
+       "identity": {
+          "addr":"1.2.3.4",
+          "external_addr":["2001:0db8:85a3:0000:0000:8a2e:0370:7334", "3.4.5.6"]
+       },
+       "bigstore_driver": "rocksdb"
+    },
+    "license": "----- LICENSE START -----\ndi+iK...KniI9\n----- LICENSE END -----\n",
+    "credentials": {
+       "username": "my_username",
+       "password": "my_password"
+    }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [bootstrap object]({{< relref "/operate/rs/references/rest-api/objects/bootstrap" >}}) in the request body.
+
+### Response {#post-response}
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Request received and processing begins. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Bootstrap already in progress (check state) |
+---
+Title: License requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: License requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: license
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-license) | `/v1/license` | Get license details |
+| [PUT](#put-license) | `/v1/license` | Update the license |
+
+## Get license {#get-license}
+
+	GET /v1/license
+
+Returns the license details, including license string, expiration,
+and supported features.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_license]({{< relref "/operate/rs/references/rest-api/permissions#view_license" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/license 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the license details:
+
+| Name | Type/Value | Description |
+|------|------------|-------------|
+| license | string | License data |
+| cluster_name | string | The cluster name (FQDN) |
+| expired | boolean | If the cluster key is expired (`true` or `false`) |
+| activation_date | string | The date of the cluster key activation |
+| expiration_date | string | The date of the cluster key expiration |
+| key | string | License key |
+| features | array of strings | Features supported by the cluster |
+| owner | string | License owner |
+| shards_limit | integer | The total number of shards allowed by the cluster key |
+| ram_shards_limit | integer | The number of RAM shards allowed by the cluster key (as of v7.2) |
+| ram_shards_in_use | integer | The number of RAM shards in use |
+| flash_shards_limit | integer | The number of flash shards (Auto Tiering) allowed by the cluster key (as of v7.2) |
+| flash_shards_in_use | integer | The number of flash shards in use |
+
+#### Example JSON body
+
+```json
+{
+    "license": "----- LICENSE START -----\\ndi+iK...KniI9\\n----- LICENSE END -----\\n",
+    "expired": true,
+    "activation_date":"2018-12-31T00:00:00Z",
+    "expiration_date":"2019-12-31T00:00:00Z",
+    "ram_shards_in_use": 0,
+    "ram_shards_limit": 300,
+    "flash_shards_in_use": 0,
+    "flash_shards_limit": 100,
+    "shards_limit": 400,
+    "features": ["bigstore"],
+    "owner": "Redis",
+    "cluster_name": "mycluster.local",
+    "key": "----- LICENSE START -----\\ndi+iK...KniI9\\n----- LICENSE END -----\\n"
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | License is returned in the response body. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No license is installed. |
+
+## Update license {#put-license}
+
+	PUT /v1/license
+
+Validate and install a new license string.
+
+If you do not provide a valid license, the cluster behaves as if the license was deleted. See [Expired cluster license]({{< relref "/operate/rs/clusters/configure/license-keys#expired-cluster-license" >}}) for a list of available actions and restrictions.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [install_new_license]({{< relref "/operate/rs/references/rest-api/permissions#install_new_license" >}}) |
+
+### Request {#put-request} 
+
+The request must be a JSON object with a single key named "license".
+
+#### Example HTTP request
+
+	PUT /v1/license 
+
+#### Example JSON body
+
+```json
+{
+    "license": "----- LICENSE START -----\ndi+iK...KniI9\n----- LICENSE END -----\n"
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include a JSON object that contains the new `license` string in the request body.
+
+### Response {#put-response} 
+
+Returns an error if the new license is not valid.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | License installed successfully. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Invalid request, either bad JSON object or corrupted license was supplied. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | License violation. A response body provides more details on the specific cause. |
+---
+Title: Node debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /nodes/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-all-nodes) | `/v1/nodes/debuginfo` | Get debug info from all nodes |
+| [GET](#get-debuginfo-node) | `/v1/nodes/{node_uid}/debuginfo` | Get debug info from a specific node |
+
+## Get debug info from all nodes {#get-debuginfo-all-nodes}
+
+	GET /v1/nodes/debuginfo
+
+Downloads a tar file that contains debug info from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/debuginfo
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+
+## Get node debug info {#get-debuginfo-node}
+
+	GET /v1/nodes/{int: node_uid}/debuginfo
+
+Downloads a tar file that contains debug info from a specific node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/1/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Node status requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that return a node's hostname and role.
+headerRange: '[1-2]'
+linkTitle: status
+toc: 'true'
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-status) | `/v1/nodes/status` | Get the status of all nodes |
+| [GET](#get-node-status) | `/v1/nodes/{uid}/status` | Get a node's status |
+
+## Get all node statuses {#get-all-nodes-status}
+
+	GET /v1/nodes/status
+
+Gets the status of all nodes. Includes each node's hostname and role in the cluster:
+
+- Primary nodes return `"role": "master"`
+
+- Replica nodes return `"role": "slave"`
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_info]({{< relref "/operate/rs/references/rest-api/permissions#view_node_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/status
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+For each node in the cluster, returns a JSON object that contains each node's hostname, role, and other status details.
+
+If a maintenance snapshot exists due to an in-progress or improperly stopped [node maintenance]({{<relref "/operate/rs/clusters/maintenance-mode">}}) process, the response includes a `maintenance_snapshot` field.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "cores": 8,
+        "free_provisional_ram": 0,
+        "free_ram": 3499368448,
+        "hostname": "3d99db1fdf4b",
+        "maintenance_snapshot": {
+            "created_time": "2024-09-06 20:47:23",
+            "name": "maintenance_mode_2024-09-06_20-47-23",
+            "node_uid": "1"
+        },
+        "master_shards": [],
+        "node_overbooking_depth": 0,
+        "node_status": "active",
+        "role": "master",
+        "slave_shards": [],
+        "software_version": "7.4.6-22",
+        "software_version_sha": "6c37b1483b5fb6110c8055c1526aa58eec1d29d3519e92310859101419248831",
+        "total_memory": 6219673600,
+        "total_provisional_ram": 0
+    },
+    "2": {
+        "hostname": "fc7a3d332458",
+        "role": "slave",
+        // additional fields
+    },
+    "3": {
+        "hostname": "b87cc06c830f",
+        "role": "slave",
+        // additional fields
+    }
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+
+## Get node status {#get-node-status}
+
+	GET /v1/nodes/{int: uid}/status
+
+Gets the status of a node. Includes the node's hostname and role in the cluster:
+
+- Primary nodes return `"role": "master"`
+
+- Replica nodes return `"role": "slave"`
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_info]({{< relref "/operate/rs/references/rest-api/permissions#view_node_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/1/status
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The node's unique ID. |
+
+
+### Response {#get-response} 
+
+Returns a JSON object that contains the node's hostname, role, and other status details.
+
+If a maintenance snapshot exists due to an in-progress or improperly stopped [node maintenance]({{<relref "/operate/rs/clusters/maintenance-mode">}}) process, the response includes a `maintenance_snapshot` field.
+
+#### Example JSON body
+
+```json
+{
+    "cores": 8,
+    "free_provisional_ram": 0,
+    "free_ram": 3504422912,
+    "hostname": "3d99db1fdf4b",
+    "maintenance_snapshot": {
+        "created_time": "2024-09-06 20:47:23",
+        "name": "maintenance_mode_2024-09-06_20-47-23",
+        "node_uid": "1"
+    },
+    "master_shards": [],
+    "node_overbooking_depth": 0,
+    "node_status": "active",
+    "role": "master",
+    "slave_shards": [],
+    "software_version": "7.4.6-22",
+    "software_version_sha": "6c37b1483b5fb6110c8055c1526aa58eec1d29d3519e92310859101419248831",
+    "total_memory": 6219673600,
+    "total_provisional_ram": 0
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+---
+Title: Check node requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requests that run checks on a cluster node.
+headerRange: '[1-2]'
+linkTitle: check
+toc: 'true'
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-node-check) | `/v1/nodes/check/{uid}` | Runs checks on a cluster node |
+
+## Check node {#get-node-check}
+
+	GET /v1/nodes/check/{int: uid}
+
+Runs the following checks on a cluster node:
+
+| Check name | Description |
+|-----------|-------------|
+| bootstrap_status | Verifies the local node's bootstrap process completed without errors. |
+| services | Verifies all Redis Enterprise Software services are running. |
+| port_range | Verifies the [`ip_local_port_range`](https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html) doesn't conflict with the ports Redis Enterprise might assign to shards. |
+| pidfiles | Verifies all active local shards have PID files. |
+| capabilities | Verifies all binaries have the proper capability bits. |
+| existing_sockets | Verifies sockets exist for all processes that require them. |
+| host_settings | Verifies the following:<br />• Linux `overcommit_memory` setting is 1.<br />• `transparent_hugepage` is disabled.<br />• Socket maximum connections setting `somaxconn` is 1024. |
+| tcp_connectivity | Verifies this node can connect to all other alive nodes. |
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_check]({{< relref "/operate/rs/references/rest-api/permissions#view_node_check" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/check/1
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The node's unique ID. |
+
+
+### Response {#get-response} 
+
+Returns a JSON object with the node's check results.
+
+When errors occur, the server returns a JSON object with `result: false` and an `error` field that provides additional information. If an error occurs during a check, the `error` field only includes a message for the first check that fails.
+
+Possible `error` messages:
+
+- "bootstrap request to cnm_http failed,resp_code: ...,resp_content: ..."
+- "process ... is not running or not responding (...)"
+- "could not communicate with 'supervisorctl': ..."
+- "connectivity check failed retrieving ports for testing"
+
+#### Example JSON body
+
+```json
+{
+    "node_uid": 1,
+    "result": true
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+---
+Title: Node alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-alerts) | `/v1/nodes/alerts` | Get all alert states for all nodes |
+| [GET](#get-node-alerts) | `/v1/nodes/alerts/{uid}` | Get all alert states for a node |
+| [GET](#get-node-alert) | `/v1/nodes/alerts/{uid}/{alert}` | Get node alert state |
+
+## Get all alert states {#get-all-nodes-alerts}
+
+	GET /v1/nodes/alerts
+
+Get all alert states for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_all_nodes_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-all-response} 
+
+Returns a hash of node UIDs and the [alert states]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) for each node.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "node_cpu_utilization": {
+            "change_time": "2014-12-22T10:42:00Z",
+            "change_value": {
+                "cpu_util": 2.500000000145519,
+                "global_threshold": "1",
+                "state": true
+            },
+            "enabled": true,
+            "state": true,
+            "severity": "WARNING"
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get node alert states {#get-node-alerts}
+
+	GET /v1/nodes/alerts/{int: uid}
+
+Get all alert states for a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_node_alerts" >}}) |
+
+### Request {#get-request-all-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts/1 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response-all-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states for a specific node.
+
+#### Example JSON body
+
+```json
+{
+   "node_cpu_utilization": {
+        "change_time": "2014-12-22T10:42:00Z",
+        "change_value": {
+            "cpu_util": 2.500000000145519,
+            "global_threshold": "1",
+            "state": true
+        },
+        "enabled": true,
+        "state": true,
+        "severity": "WARNING",
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified node does not exist |
+
+## Get node alert state {#get-node-alert}
+
+	GET /v1/nodes/alerts/{int: uid}/{alert}
+
+Get a node alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_node_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/nodes/alerts/1/node_cpu_utilization 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ignore_settings | boolean | Retrieve updated alert state regardless of the cluster's alert_settings. When not present, a disabled alert will always be retrieved as disabled with a false state. (optional) |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "change_time": "2014-12-22T10:42:00Z",
+    "change_value": {
+        "cpu_util": 2.500000000145519,
+        "global_threshold": "1",
+        "state": true
+    },
+    "enabled": true,
+    "state": true,
+    "severity": "WARNING",
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or node does not exist |
+---
+Title: Node snapshot requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node snapshot requests
+headerRange: '[1-2]'
+linkTitle: snapshots
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-snapshots) | `/v1/nodes/{uid}/snapshots` | Get node snapshots |
+| [DELETE](#delete-snapshot) | `/v1/nodes/{uid}/snapshots/{snapshot_name}` | Delete a node snapshot |
+
+## Get node snapshots {#get-snapshots}
+
+```sh
+GET /v1/nodes/{int: uid}/snapshots
+```
+
+Get all cluster node snapshots of the specified node.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_node_info]({{< relref "/operate/rs/references/rest-api/permissions#view_node_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/snapshots
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+### Response {#get-response}
+
+Returns an array of node snapshot JSON objects.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "created_time": "2024-01-10 20:55:54",
+        "name": "nightly_snapshot_1",
+        "node_uid": "1"
+    },
+    {
+        "created_time": "2024-01-11 20:55:54",
+        "name": "nightly_snapshot_2",
+        "node_uid": "1"
+    }
+]
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+
+## Delete node snapshot {#delete-snapshot}
+
+```sh
+DELETE /v1/nodes/{int: uid}/snapshots/{snapshot_name}
+```
+
+Delete a cluster node snapshot. Snapshots created by maintenance mode are not deleted.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_node]({{< relref "/operate/rs/references/rest-api/permissions#update_node" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/nodes/1/snapshots/nightly_snapshot_19
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated node. |
+| snapshot_name | string | The unique name of the snapshot to delete. |
+
+### Response {#delete-response}
+
+Returns a JSON object that represents the deleted node snapshot.
+
+#### Example JSON body
+
+```json
+{
+    "created_time": "2024-01-11 20:55:54",
+    "name": "nightly_snapshot_19",
+    "node_uid": "1"
+}
+```
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Node snapshot is a maintenance snapshot and cannot be deleted |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node uid does not exist |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Snapshot name does not exist for this node uid |
+---
+Title: Node actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node action requests
+headerRange: '[1-2]'
+linkTitle: actions
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-actions) | `/v1/nodes/actions` | Get status of all actions on all nodes|
+| [GET](#get-node-actions) | `/v1/nodes/{node_uid}/actions` | Get status of all actions on a specific node |
+| [GET](#get-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Get status of an action on a specific node |
+| [POST](#post-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Initiate node action |
+| [DELETE](#delete-node-action) | `/v1/nodes/{node_uid}/actions/{action}` | Cancel action or remove action status |
+
+## Get all actions {#get-all-nodes-actions}
+
+```sh
+GET /v1/nodes/actions
+```
+
+Get the status of all currently executing, pending, or completed
+actions on all nodes.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_status_of_all_node_actions]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_all_node_actions" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/actions
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a list of [action objects]({{< relref "/operate/rs/references/rest-api/objects/action" >}}).
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+
+## Get node actions statuses {#get-node-actions}
+
+```sh
+GET /v1/nodes/{node_uid}/actions
+```
+
+Get the status of all actions on a specific node.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_status_of_node_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_node_action" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request-all-actions}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/actions
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The action to check. |
+
+### Response {#get-response-all-actions}
+
+Returns a JSON object that includes a list of [action objects]({{< relref "/operate/rs/references/rest-api/objects/action" >}}) for the specified node.
+
+If no actions are available, the response will include an empty array.
+
+#### Example JSON body
+
+```json
+{
+    "actions": [
+        {
+            "name": "remove_node",
+            "node_uid": "1",
+            "status": "running",
+            "progress": 10
+        }
+    ]
+}
+```
+
+### Error codes {#get-error-codes-all-actions}
+
+| Code | Description |
+|------|-------------|
+| internal_error | An internal error that cannot be mapped to a more precise error code has been encountered. |
+| insufficient_resources | The cluster does not have sufficient resources to complete the required operation. |
+
+### Status codes {#get-status-codes-all-actions}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Get node action status {#get-node-action}
+
+```sh
+GET /v1/nodes/{node_uid}/actions/{action}
+```
+
+Get the status of a currently executing, queued, or completed action on a specific node.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+Returns an [action object]({{< relref "/operate/rs/references/rest-api/objects/action" >}}) for the specified node.
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| internal_error | An internal error that cannot be mapped to a more precise error code has been encountered. |
+| insufficient_resources | The cluster does not have sufficient resources to complete the required operation. |
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides details about an ongoing action. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run). |
+
+## Initiate node action {#post-node-action}
+
+```sh
+POST /v1/nodes/{node_uid}/actions/{action}
+```
+
+Initiate a node action.
+
+The API allows only a single instance of any action type to be
+invoked at the same time, and violations of this requirement will
+result in a `409 CONFLICT` response.
+
+The caller is expected to query and process the results of the
+previously executed instance of the same action, which will be
+removed as soon as the new one is submitted.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_node_action]({{< relref "/operate/rs/references/rest-api/permissions#start_node_action" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action required. |
+
+Currently supported actions are:
+
+- `remove`: Removes the node from the cluster after migrating all bound resources to other nodes. As soon as a successful remove request is received, the cluster will no longer automatically migrate resources, such as shards and endpoints, to the node even if the remove task fails at some point.
+
+    - By default, the remove node action completes after all resources migrate off the removed node. Node removal does not wait for migrated shards' persistence files to be created on the new nodes.
+    
+        To change node removal to wait for the creation of new persistence files for all migrated shards, set `wait_for_persistence` to `true` in the request body or [update the cluster policy]({{<relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy">}}) `persistent_node_removal` to `true` to change the cluster's default behavior.
+
+        ```sh
+        POST /v1/nodes/<node_id>/actions/remove
+        {
+            "wait_for_persistence": true
+        }
+        ```
+
+- `maintenance_on`: Creates a snapshot of the node, migrates shards to other nodes, and prepares the node for maintenance. See [maintenance mode]({{< relref "/operate/rs/clusters/maintenance-mode" >}}) for more information.
+
+    - As of Redis Enterprise Software version 7.4.2, a new node snapshot is created only if no maintenance mode snapshots already exist or if you set `"overwrite_snapshot": true` in the request body.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true
+        }
+        ```
+
+    - If there aren't enough resources to migrate shards out of the maintained node, set `"evict_ha_replica": false` and `"evict_active_active_replica": false` in the request body to keep the replica shards in place but demote any master shards. Use these two parameters instead of `keep_slave_shards`, which is deprecated as of Redis Enterprise Software version 7.4.2.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true,
+            "evict_ha_replica": false,
+            "evict_active_active_replica": false
+        }
+        ```
+
+    - To specify databases whose shards should be evicted from the node when entering maintenance mode, set `"evict_dbs": ["List of database ID strings"]` in the request body.
+
+        ```sh
+        POST /v1/nodes/1/actions/maintenance_on
+        {
+            "overwrite_snapshot": true,
+            "evict_dbs": ["1", "3"] 
+        }
+        ```
+
+- `maintenance_off`: Restores node to its previous state before maintenance started. See [maintenance mode]({{< relref "/operate/rs/clusters/maintenance-mode" >}}) for more information.
+
+    - By default, it uses the latest node snapshot.
+
+    - Use `"snapshot_name":`&nbsp;`"..."` in the request body to restore the state from a specific snapshot.
+
+    - To avoid restoring shards at the node, use `"skip_shards_restore":`&nbsp;`true`.
+
+- `enslave_node`: Turn node into a replica.
+
+### Response {#post-response}
+
+The body content may provide additional action details.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action initiated successfully. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Only a single instance of any action type can be invoked at the same time. |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -X POST -u "[username]:[password]" -d "{}"
+            https://[host][:port]/v1/nodes/1/actions/remove
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][port]/v1/nodes/1/actions/remove"
+
+payload = json.dumps({})
+headers = {
+  'Content-Type': 'application/json',
+}
+auth = ("[username]", "[password]")
+
+response = requests.request("POST", url, auth=auth, headers=headers, data=payload)
+
+print(response.text)
+```
+
+## Cancel action {#delete-node-action}
+
+```sh
+DELETE /v1/nodes/{node_uid}/actions/{action}
+```
+
+Cancel a queued or executing node action, or remove the status of a
+previously executed and completed action.
+
+### Permissions
+
+| Permission name |
+|-----------------|
+| [cancel_node_action]({{< relref "/operate/rs/references/rest-api/permissions#cancel_node_action" >}}) |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/nodes/1/actions/remove
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| action | string | The name of the action to cancel. |
+
+### Response {#delete-response}
+
+Returns a status code.
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action will be cancelled when possible. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action unknown or not currently running. |
+---
+Title: Latest node stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent node statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-stats-last) | `/v1/nodes/stats/last` | Get latest stats for all nodes |
+| [GET](#get-node-stats-last) | `/v1/nodes/stats/last/{uid}` | Get latest stats for a single node |
+
+## Get latest stats for all nodes {#get-all-nodes-stats-last}
+
+```sh
+GET /v1/nodes/stats/last
+```
+
+Get latest statistics for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_nodes_stats" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/last?interval=1sec&stime=2015-10-14T06:29:43Z
+```
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all nodes.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+         "conns": 0.0,
+         "cpu_idle": 0.922500000015134,
+         "cpu_system": 0.007499999999708962,
+         "cpu_user": 0.01749999999810825,
+         "cur_aof_rewrites": 0.0,
+         "egress_bytes": 7887.0,
+         "ephemeral_storage_avail": 75821363200.0,
+         "ephemeral_storage_free": 81189969920.0,
+         "etime": "2015-10-14T06:29:44Z",
+         "free_memory": 2956963840.0,
+         "ingress_bytes": 4950.0,
+         "interval": "1sec",
+         "persistent_storage_avail": 75821363200.0,
+         "persistent_storage_free": 81189969920.0,
+         "stime": "2015-10-14T06:29:43Z",
+         "total_req": 0.0
+     },
+     "2": {
+         "conns": 0.0,
+         "cpu_idle": 0.922500000015134,
+         "// additional fields..."
+     }
+}
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No nodes exist |
+
+## Get latest node stats {#get-node-stats-last}
+
+```sh
+GET /v1/nodes/stats/last/{int: uid}
+```
+
+Get the latest statistics of a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_node_stats" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/last/1?interval=1sec&stime=2015-10-13T09:01:54Z
+```
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week. Default: 1sec. (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601)format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601)format (optional) |
+
+### Response {#get-response}
+
+Returns the most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the specified node.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+         "conns": 0.0,
+         "cpu_idle": 0.8049999999930151,
+         "cpu_system": 0.02750000000014552,
+         "cpu_user": 0.12000000000080036,
+         "cur_aof_rewrites": 0.0,
+         "egress_bytes": 2169.0,
+         "ephemeral_storage_avail": 75920293888.0,
+         "ephemeral_storage_free": 81288900608.0,
+         "etime": "2015-10-13T09:01:55Z",
+         "free_memory": 3285381120.0,
+         "ingress_bytes": 3020.0,
+         "interval": "1sec",
+         "persistent_storage_avail": 75920293888.0,
+         "persistent_storage_free": 81288900608.0,
+         "stime": "2015-10-13T09:01:54Z",
+         "total_req": 0.0
+    }
+}
+```
+
+### Error codes {#get-error-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Node isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Mode is in recovery state |
+---
+Title: Node stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes-stats) | `/v1/nodes/stats` | Get stats for all nodes |
+| [GET](#get-node-stats) | `/v1/nodes/stats/{uid}` | Get stats for a single node |
+
+## Get all nodes stats {#get-all-nodes-stats}
+
+```sh
+GET /v1/nodes/stats
+```
+
+Get statistics for all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_nodes_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_nodes_stats" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional)  |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all nodes.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+   ]
+  },
+  {
+    "uid": "2",
+    "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+   ]
+  }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No nodes exist |
+
+## Get node stats {#get-node-stats}
+
+```sh
+GET /v1/nodes/stats/{int: uid}
+```
+
+Get statistics for a node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_node_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_node_stats" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for the specified node.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "intervals": [
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:11Z",
+      "etime": "2015-05-28T08:40:12Z",
+      "conns": 0.0,
+      "cpu_idle": 0.5499999999883585,
+      "cpu_system": 0.03499999999985448,
+      "cpu_user": 0.38000000000101863,
+      "egress_bytes": 0.0,
+      "ephemeral_storage_avail": 2929315840.0,
+      "ephemeral_storage_free": 3977830400.0,
+      "free_memory": 893485056.0,
+      "ingress_bytes": 0.0,
+      "persistent_storage_avail": 2929315840.0,
+      "persistent_storage_free": 3977830400.0,
+      "total_req": 0.0
+    },
+    {
+      "interval": "1sec",
+      "stime": "2015-05-28T08:40:12Z",
+      "etime": "2015-05-28T08:40:13Z",
+      "cpu_idle": 1.2,
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Node isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Node is in recovery state |
+---
+Title: Nodes requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Node requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: nodes
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-nodes) | `/v1/nodes` | Get all cluster nodes |
+| [GET](#get-node) | `/v1/nodes/{uid}` | Get a single cluster node |
+| [PUT](#put-node) | `/v1/nodes/{uid}` | Update a node |
+
+## Get all nodes {#get-all-nodes}
+
+```sh
+GET /v1/nodes
+```
+
+Get all cluster nodes.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_nodes_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_nodes_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [node objects]({{< relref "/operate/rs/references/rest-api/objects/node" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+      "uid": 1,
+      "status": "active",
+      "uptime": 262735,
+      "total_memory": 6260334592,
+      "software_version": "0.90.0-1",
+      "ephemeral_storage_size": 20639797248,
+      "persistent_storage_path": "/var/opt/redislabs/persist",
+      "persistent_storage_size": 20639797248,
+      "os_version": "Ubuntu 14.04.2 LTS",
+      "ephemeral_storage_path": "/var/opt/redislabs/tmp",
+      "architecture": "x86_64",
+      "shard_count": 23,
+      "public_addr": "",
+      "cores": 4,
+      "rack_id": "",
+      "supported_database_versions": [
+        {
+          "db_type": "memcached",
+          "version": "1.4.17"
+        },
+        {
+          "db_type": "redis",
+          "version": "2.6.16"
+        },
+        {
+          "db_type": "redis",
+          "version": "2.8.19"
+        }
+      ],
+      "shard_list": [1, 3, 4],
+      "addr": "10.0.3.61"
+    },
+    {
+      "uid": 1,
+      "status": "active",
+      "// additional fields..."
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get node {#get-node}
+
+```sh
+GET /v1/nodes/{int: uid}
+```
+
+Get a single cluster node.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_node_info]({{< relref "/operate/rs/references/rest-api/permissions#view_node_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/nodes/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the node requested. |
+
+### Response {#get-response}
+
+Returns a [node object]({{< relref "/operate/rs/references/rest-api/objects/node" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "node:1",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Node UID does not exist |
+
+## Update node {#put-node}
+
+```sh
+PUT /v1/nodes/{int: uid}
+```
+
+Update a [node object]({{< relref "/operate/rs/references/rest-api/objects/node" >}}).
+
+Currently, you can edit the following attributes:
+
+- `addr`
+
+- `external_addr`
+
+- `recovery_path`
+
+- `accept_servers`
+
+{{<note>}}
+You can only update the `addr` attribute for offline nodes. Otherwise, the request returns an error.
+{{</note>}}
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_node]({{< relref "/operate/rs/references/rest-api/permissions#update_node" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/nodes/1
+```
+
+#### Example JSON body
+
+```json
+{
+    "addr": "10.0.0.1",
+    "external_addr" : [
+        "192.0.2.24"
+    ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Media type of request/response body |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated node. |
+
+
+#### Body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| addr | string | Internal IP address of node |
+| external_addr | JSON array | External IP addresses of the node |
+| recovery_path | string | Path for recovery files |
+| accept_servers | boolean | If true, no shards will be created on the node |
+
+### Response {#put-response}
+
+If the request is successful, the body will be empty. Otherwise, it may contain a JSON object with an error code and error message.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Update request cannot be processed. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided. |
+
+#### Error codes {#put-error-codes}
+
+| Code | Description |
+|------|-------------|
+| node_not_found | Node does not exist |
+| node_not_offline | Attempted to change node address while it is online |
+| node_already_populated | The node contains shards or endpoints, cannot disable accept_servers |
+| invalid_oss_cluster_port_mapping | Cannot enable "accept_servers" since there are databases with "oss_cluster_port_mapping" that do not have a port configuration for the current node |
+| node_already_has_rack_id | Attempted to change node's rack_id when it already has one |
+---
+Title: Redis access control list (ACL) requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis access control list (ACL) requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: redis_acls
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-redis_acls) | `/v1/redis_acls` | Get all Redis ACLs |
+| [GET](#get-redis_acl) | `/v1/redis_acls/{uid}` | Get a single Redis ACL |
+| [PUT](#put-redis_acl) | `/v1/redis_acls/{uid}` | Update a Redis ACL |
+| [POST](#post-redis_acl) | `/v1/redis_acls` | Create a new Redis ACL |
+| [DELETE](#delete-redis_acl) | `/v1/redis_acls/{uid}` | Delete a Redis ACL |
+
+## Get all Redis ACLs {#get-all-redis_acls}
+
+```sh
+GET /v1/redis_acls
+```
+
+Get all Redis ACL objects.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_redis_acls_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_redis_acls_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/redis_acls
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [Redis ACL objects]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+     "uid": 1,
+     "name": "Full Access",
+     "acl": "+@all ~*"
+    },
+    {
+     "uid": 2,
+     "name": "Read Only",
+     "acl": "+@read ~*"
+    },
+    {
+     "uid": 3,
+     "name": "Not Dangerous",
+     "acl": "+@all -@dangerous ~*"
+    },
+    {
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Get Redis ACL {#get-redis_acl}
+
+```sh
+GET /v1/redis_acls/{int: uid}
+```
+
+Get a single Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_redis_acl_info]({{< relref "/operate/rs/references/rest-api/permissions#view_redis_acl_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/redis_acls/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The object's unique ID. |
+
+### Response {#get-response}
+
+Returns a [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | redis_acl does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Update Redis ACL {#put-redis_acl}
+
+```sh
+PUT /v1/redis_acls/{int: uid}
+```
+
+Update an existing Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_redis_acl]({{< relref "/operate/rs/references/rest-api/permissions#update_redis_acl" >}}) | admin<br />user_manager |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/redis_acls/17
+```
+
+#### Example JSON body
+
+```json
+{
+     "acl": "~* +@geo -@dangerous"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the updated [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}) but don't apply the update. |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The Redis ACL's unique ID. |
+
+#### Request body
+
+Include a [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns the updated [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo -@dangerous"
+}
+```
+
+### Error codes {#put-error-codes}
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.|
+| name_already_exists | An object of the same type and name exists|
+| invalid_param | A parameter has an illegal value|
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, redis_acl was updated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existent redis_acl. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Cannot change a read-only object |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+## Create Redis ACL {#post-redis_acl}
+
+```sh
+POST /v1/redis_acls
+```
+
+Create a new Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_redis_acl]({{< relref "/operate/rs/references/rest-api/permissions#create_redis_acl" >}}) | admin<br />user_manager |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/redis_acls
+```
+
+#### Example JSON body
+
+```json
+{
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the new [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}) but don't apply the update. |
+
+#### Request body
+
+Include a [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}) in the request body.
+
+### Response {#post-response}
+
+Returns the newly created [Redis ACL object]({{< relref "/operate/rs/references/rest-api/objects/redis_acl" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Geo",
+     "acl": "~* +@geo"
+}
+```
+
+### Error codes {#post-error-codes}
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version. |
+| name_already_exists | An object of the same type and name exists |
+| missing_field | A needed field is missing |
+| invalid_param | A parameter has an illegal value |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, redis_acl is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+
+### Examples
+
+#### cURL
+
+```sh
+curl -k -u "[username]:[password]" -X POST \
+     -H 'Content-Type: application/json' \
+     -d '{ "name": "Geo", "acl": "~* +@geo" }' \
+     https://[host][:port]/v1/redis_acls
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/redis_acls"
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+payload = json.dumps({
+    "name": "Geo",
+    "acl": "~* +@geo"
+})
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+           auth=auth, headers=headers, payload=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete Redis ACL {#delete-redis_acl}
+
+```sh
+DELETE /v1/redis_acls/{int: uid}
+```
+
+Delete a Redis ACL object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_redis_acl]({{< relref "/operate/rs/references/rest-api/permissions#delete_redis_acl" >}}) | admin<br />user_manager |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/redis_acls/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The redis_acl unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code that indicates the Redis ACL deletion success or failure.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the redis_acl is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Cannot delete a read-only object |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support redis_acl yet. |
+---
+Title: Roles requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Roles requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: roles
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-roles) | `/v1/roles` | Get all roles |
+| [GET](#get-role) | `/v1/roles/{uid}` | Get a single role |
+| [PUT](#put-role) | `/v1/roles/{uid}` | Update an existing role |
+| [POST](#post-role) | `/v1/roles` | Create a new role |
+| [DELETE](#delete-role) | `/v1/roles/{uid}` | Delete a role |
+
+## Get all roles {#get-all-roles}
+
+```sh
+GET /v1/roles
+```
+
+Get all roles' details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_roles_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_roles_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/roles
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [role objects]({{< relref "/operate/rs/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": 1,
+        "name": "Admin",
+        "management": "admin"
+    },
+    {
+        "uid": 2,
+        "name": "Cluster Member",
+        "management": "cluster_member"
+    },
+    {
+        "uid": 3,
+        "name": "Cluster Viewer",
+        "management": "cluster_viewer"
+    },
+    {
+        "uid": 4,
+        "name": "DB Member",
+        "management": "db_member"
+    },
+    {
+        "uid": 5,
+        "name": "DB Viewer",
+        "management": "db_viewer"
+    },
+    {
+        "uid": 6,
+        "name": "None",
+        "management": "none"
+    },
+    {
+        "uid": 17,
+        "name": "DBA",
+        "management": "admin"
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Get role
+
+```sh
+GET /v1/roles/{int: uid}
+```
+
+Get the details of a single role.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_role_info]({{< relref "/operate/rs/references/rest-api/permissions#view_role_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/roles/1
+```
+
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The role's unique ID. |
+
+### Response {#get-response}
+
+Returns a [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Role does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Update role {#put-role}
+
+```sh
+PUT /v1/roles/{int: uid}
+```
+
+Update an existing role's details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_role]({{< relref "/operate/rs/references/rest-api/permissions#update_role" >}}) | admin<br />user_manager |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/roles/17
+```
+
+#### Example JSON body
+
+```json
+{
+     "management": "cluster_member"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the updated [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}) but don't apply the update. |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The role's unique ID. |
+
+#### Body
+
+Include a [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns a [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}) with the updated fields.
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "cluster_member"
+}
+```
+
+### Error codes {#put-error-codes}
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.|
+| name_already_exists | An object of the same type and name exists.|
+| change_last_admin_role_not_allowed | At least one user with admin role should exist.|
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, role is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existant role. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+## Create role {#post-role}
+
+```sh
+POST /v1/roles
+```
+
+Create a new role.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_role]({{< relref "/operate/rs/references/rest-api/permissions#create_role" >}}) | admin<br />user_manager |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/roles
+```
+
+#### Example JSON body
+
+```json
+{
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the new [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}) but don't apply the update. |
+
+#### Body
+
+Include a [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}) in the request body.
+
+### Response {#post-response}
+
+Returns the newly created [role object]({{< relref "/operate/rs/references/rest-api/objects/role" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "DBA",
+     "management": "admin"
+}
+```
+
+### Error codes {#post-error-codes}
+
+Possible `error_code`values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version. |
+| name_already_exists | An object of the same type and name exists |
+| missing_field | A needed field is missing |
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, role is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+
+### Examples
+
+#### cURL
+
+```sh
+curl -k -u "[username]:[password]" -X POST \
+     -H 'Content-Type: application/json' \
+     -d '{ "name": "DBA", "management": "admin" }' \
+     https://[host][:port]/v1/roles
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/roles"
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+payload = json.dumps({
+    "name": "DBA",
+    "management": "admin"
+})
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+           auth=auth, headers=headers, payload=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete role {#delete-role}
+
+```sh
+DELETE /v1/roles/{int: uid}
+```
+
+Delete a role object.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_role]({{< relref "/operate/rs/references/rest-api/permissions#delete_role" >}}) | admin<br />user_manager |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/roles/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The role unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code to indicate role deletion success or failure.
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the role is deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Role does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support roles yet. |
+---
+Title: Suffix requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: DNS suffix requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: suffix
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-suffix) | `/v1/suffix/{name}` | Get a single DNS suffix |
+
+## Get suffix {#get-suffix}
+
+	GET /v1/suffix/{string: name}
+
+Get a single DNS suffix.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/suffix/cluster.fqdn 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| name | string | The unique name of the suffix requested. |
+
+### Response {#get-response} 
+
+Returns a [suffix object]({{< relref "/operate/rs/references/rest-api/objects/suffix" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "name": "cluster.fqdn",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Suffix name does not exist |
+---
+Title: Database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API /bdbs/debuginfo requests.
+headerRange: '[1-2]'
+linkTitle: debuginfo
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo-bdb) | `/v1/bdbs/debuginfo` | Get debug info from all databases |
+| [GET](#get-debuginfo-bdb) | `/v1/bdbs/{bdb_uid}/debuginfo` | Get debug info from a specific database |
+
+## Get debug info from all databases {#get-all-debuginfo-bdb}
+
+	GET /v1/bdbs/debuginfo
+
+Downloads a tar file that contains debug info from all databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/debuginfo
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+
+
+## Get database debug info {#get-debuginfo-bdb}
+
+	GET /v1/bdbs/{int: bdb_uid}/debuginfo
+
+Downloads a tar file that contains debug info from the database specified by `bdb_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/1/debuginfo
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Replica syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica syncer state requests
+headerRange: '[1-2]'
+linkTitle: replica
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state/replica` | Get a CRDB replica's syncer state |
+
+## Get replica syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state/replica
+```
+
+Get a CRDB replica's syncer state as JSON.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state/replica
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: CRDT syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: CRDT syncer state requests
+headerRange: '[1-2]'
+linkTitle: crdt
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state/crdt` |  Get a CRDB's syncer state |
+
+## Get CRDB syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state/crdt
+```
+
+Get a CRDB's syncer state as JSON.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager|
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state/crdt
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: Syncer state requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Syncer state requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: syncer_state
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-syncer-state) | `/v1/bdbs/{uid}/syncer_state` | Get a CRDB's syncer state |
+
+## Get syncer state {#get-syncer-state}
+
+```sh
+GET /v1/bdbs/{int: uid}/syncer_state
+```
+
+Get a CRDB's syncer state as JSON.
+
+{{<warning>}}
+This endpoint is deprecated as of Redis Enterprise Software version 7.2.4 and will be removed in a future release. Use [`/v1/bdbs/<uid>/syncer_state/crdt`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/syncer_state/crdt" >}}) instead.
+{{</warning>}}
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/syncer_state
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster. |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the syncer state.
+
+#### Example JSON body
+
+```json
+{
+    "DB": 22,
+    "RunID": 1584086516,
+    // additional fields...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | OK |
+| [404 Not Found](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Syncer state key does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+| [503 Service Unavailable](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | Redis connection error, service unavailable |
+---
+Title: Database replica sources alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replica source alert requests
+headerRange: '[1-2]'
+linkTitle: replica_sources/alerts
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-replica-sources-alerts) | `/v1/bdbs/replica_sources/alerts` | Get all replica sources alert states for all BDBs |
+| [GET](#get-bdbs-replica-sources-alerts) | `/v1/bdbs/replica_sources/alerts/{uid}` | Get all replica sources alert states for a BDB |
+| [GET](#get-bdbs-replica_source-all-alerts) | `/v1/bdbs/replica_sources/alerts/{uid}/{replica_src_id}` | Get all alert states for a replica source |
+| [GET](#get-bdbs-replica-source-alert) | `/v1/bdbs/replica_sources/alerts/{uid}/{replica_src_id}/{alert}` | Get a replica source alert state |
+
+## Get all DBs replica sources alert states {#get-all-bdbs-replica-sources-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts
+
+Get all alert states for all replica sources of all BDBs.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a hash of alert UIDs and the alerts states for each BDB.
+
+See [REST API alerts overview]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) for a description of the alert state object.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "replica_src_syncer_connection_error": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get DB replica source alert states {#get-bdbs-replica-sources-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}
+
+Get all alert states for all replica sources of a specific bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-all-replica-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#get-response-all-replica-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "replica_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-replica-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get replica source alert states {#get-bdbs-replica_source-all-alerts}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}/{int: replica_src_id}
+
+Get all alert states for a specific replica source of a bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-replica-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1/2 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| replica_src_id | integer | The ID of the replica source in this BDB |
+
+### Response {#get-response-replica-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "replica_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-replica-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get replica source alert state {#get-bdbs-replica-source-alert}
+
+	GET /v1/bdbs/replica_sources/alerts/{int: uid}/{int: replica_src_id}/{alert}
+
+Get a replica source alert state of a specific bdb.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alert} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/replica_sources/alerts/1/2/replica_src_syncer_connection_error 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| replica_src_id | integer | The ID of the replica source in this BDB |
+| alert | string | The alert name |
+
+### Response {#get-response-alert} 
+
+Returns an [alert state object]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes-alert} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+---
+Title: Database shards requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database shards
+headerRange: '[1-2]'
+linkTitle: shards
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdb-shards) | `/v1/bdbs/{bdb_uid}/shards` | Get the status of a database's shards |
+
+## Get database shards {#get-bdb-shards}
+
+	GET /v1/bdbs/{int: bdb_uid}/shards
+
+Gets the status for all shards that belong to the specified database.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/1/shards?extra_info_keys=used_memory_rss&extra_info_keys=connected_clients
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the database. |
+
+### Response {#get-response} 
+
+The response body contains a JSON array with all shards, represented as [shard objects]({{<relref "/operate/rs/references/rest-api/objects/shard">}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": "1",
+		"role": "master",
+		"assigned_slots": "0-8191",
+        "bdb_uid": 1,
+        "detailed_status": "ok",
+        "loading": {
+            "status": "idle"
+        },
+        "node_uid": "1",
+        "redis_info": {
+			"connected_clients": 14,
+            "used_memory_rss": 12460032
+        },
+        "report_timestamp": "2024-09-13T15:28:10Z",
+        "status": "active"
+    },
+    {
+        "uid": 2,
+        "role": "slave",
+        // additional fields...
+    }
+]
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | bdb uid does not exist. |
+---
+Title: Database passwords requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database password requests
+headerRange: '[1-2]'
+linkTitle: passwords
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Update database password |
+| [POST](#post-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Add database password |
+| [DELETE](#delete-bdbs-password) | `/v1/bdbs/{uid}/passwords` | Delete database password |
+
+## Update database password {#put-bdbs-password}
+
+	PUT /v1/bdbs/{int: uid}/passwords
+
+Set a single password for the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "new password"
+}
+```
+
+The above request resets the password of the bdb to ‘new password’.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to update the password. |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | New password |
+
+### Response {#put-response} 
+
+Returns a status code that indicates password update success or failure.
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was changed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+
+## Add database password {#post-bdbs-password}
+
+	POST /v1/bdbs/{int: uid}/passwords
+
+Add a password to the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "password to add"
+}
+```
+
+The above request adds a password to the bdb.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to add password. |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | Password to add |
+
+### Response {#post-response} 
+
+Returns a status code that indicates password creation success or failure.
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was added. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+
+## Delete database password {#delete-bdbs-password}
+
+	DELETE /v1/bdbs/{int: uid}/passwords
+
+Delete a password from the bdb's default user (i.e., for `AUTH`&nbsp;`<password>` authentications).
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/bdbs/1/passwords 
+
+#### Example JSON body
+
+```json
+{
+    "password": "password to delete"
+}
+```
+
+The above request deletes a password from the bdb.
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to delete password. |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| password | string | Password to delete |
+
+### Response {#delete-response} 
+
+Returns a status code that indicates password deletion success or failure.
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The password was deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | A nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+---
+Title: Database availability requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to check database availability
+headerRange: '[1-2]'
+linkTitle: availability
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-db-endpoint-availability) | `/v1/local/bdbs/{uid}/endpoint/availability` | Verifies local database endpoint availability |
+| [GET](#get-db-availability) | `/v1/bdbs/{uid}/availability` | Verifies database availability |
+
+## Get database endpoint availability {#get-db-endpoint-availability}
+
+```sh
+GET /v1/local/bdbs/{uid}/endpoint/availability
+```
+
+Verifies the local database endpoint is available. This request does not redirect to the primary node.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-endpoint-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/local/bdbs/1/endpoint/availability
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#get-endpoint-response}
+
+Returns the status code `200 OK` if the local database endpoint is available.
+
+If the local database endpoint is unavailable, returns an error status code and a JSON object that contains `error_code` and `description` fields.
+
+### Error codes {#get-endpoint-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `description` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_quorum | Master healthcheck failed (no quorum in the cluster) |
+| db_not_found | Database does not exist in the cluster |
+| bdb_endpoint_unavailable | Local database endpoint is not available | 
+
+### Status codes {#get-endpoint-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Database endpoint is available. |
+| [503 Service Unavailable](https://www.rfc-editor.org/rfc/rfc9110.html#name-503-service-unavailable) | Database endpoint is unavailable. |
+
+
+## Get database availability {#get-db-availability}
+
+```sh
+GET /v1/bdbs/{uid}/availability
+```
+
+Gets the availability status of a database.
+
+- If the OSS Cluster API is enabled, verifies all endpoints for this database are available.
+
+- Otherwise, verifies the database has at least one available endpoint.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-db-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/availability
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#get-db-response}
+
+Returns the status code `200 OK` if the database is available.
+
+If the database is unavailable, returns an error status code and a JSON object that contains `error_code` and `description` fields.
+
+### Error codes {#get-db-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `description` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_quorum | Master healthcheck failed (no quorum in the cluster) |
+| db_not_found | Database does not exist in the cluster |
+| bdb_unavailable | Database is not available | 
+
+### Status codes {#get-db-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Database is available. |
+| [503 Service Unavailable](https://www.rfc-editor.org/rfc/rfc9110.html#name-503-service-unavailable) | Database is unavailable or doesn't have quorum. |
+---
+Title: CRDB peer stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active peer instance statistics requests
+headerRange: '[1-2]'
+linkTitle: peer_stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-peer_stats) | `/v1/bdbs/{bdb_uid}/peer_stats` | Get stats for all CRDB peer instances |
+| [GET](#get-bdbs-peer_stats) | `/v1/bdbs/{bdb_uid}/peer_stats/{uid}` | Get stats for a specific CRDB peer instance |
+
+## Get all CRDB peer stats {#get-all-bdbs-peer_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/peer_stats
+```
+
+Get statistics for all peer instances of a local CRDB instance.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/peer_stats?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local CRDB instance. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all CRDB peer instances.
+
+#### Example JSON body
+
+```json
+{ "peer_stats": [
+     {
+         "intervals": [
+             {
+                 "egress_bytes": 0.0,
+                 "egress_bytes_decompressed": 0.0,
+                 "etime": "2017-10-22T19:30:00Z",
+                 "ingress_bytes": 18528,
+                 "ingress_bytes_decompressed": 185992,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.244,
+                 "pending_local_writes_max": 0.0,
+                 "pending_local_writes_min": 0.0,
+                 "stime": "2017-10-22T19:25:00Z"
+             },
+             {
+                 "egress_bytes": 0.0,
+                 "egress_bytes_decompressed": 0.0,
+                 "etime": "2017-10-22T19:35:00Z",
+                 "ingress_bytes": 18,
+                 "ingress_bytes_decompressed": 192,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.0,
+                 "pending_local_writes_max": 0.0,
+                 "pending_local_writes_min": 0.0,
+                 "stime": "2017-10-22T19:30:00Z"
+             }
+         ],
+         "uid": "3"
+     }
+   ]
+ }
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Database is not a CRDB. |
+
+## Get CRDB peer stats {#get-bdbs-peer_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/peer_stats/{int: uid}
+```
+
+Get statistics for a specific CRDB peer instance.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/peer_stats/3?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local CRDB instance. |
+| uid | integer | The peer instance uid, as specified in the CRDB instance list. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for a specific CRDB peer instance.
+
+#### Example JSON body
+
+```json
+{
+    "intervals": [
+        {
+            "egress_bytes": 0.0,
+            "egress_bytes_decompressed": 0.0,
+            "etime": "2017-10-22T19:30:00Z",
+            "ingress_bytes": 18528,
+            "ingress_bytes_decompressed": 185992,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.244,
+            "pending_local_writes_max": 0.0,
+            "pending_local_writes_min": 0.0,
+            "stime": "2017-10-22T19:25:00Z"
+        },
+        {
+            "egress_bytes": 0.0,
+            "egress_bytes_decompressed": 0.0,
+            "etime": "2017-10-22T19:35:00Z",
+            "ingress_bytes": 18,
+            "ingress_bytes_decompressed": 192,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.0,
+            "pending_local_writes_max": 0.0,
+            "pending_local_writes_min": 0.0,
+            "stime": "2017-10-22T19:30:00Z"
+        }
+    ],
+    "uid": "3"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or peer does not exist. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Database is not a CRDB. |
+---
+Title: Database alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database alert requests
+headerRange: '[1-2]'
+linkTitle: alerts
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-alerts) | `/v1/bdbs/alerts` | Get all alert states for all databases |
+| [GET](#get-bdbs-alerts) | `/v1/bdbs/alerts/{uid}` | Get all alert states for a specific database |
+| [GET](#get-bdbs-alert) | `/v1/bdbs/alerts/{uid}/{alert}` | Get a specific database alert state |
+| [POST](#post-bdbs-alerts) | `/v1/bdbs/alerts/{uid}` | Update a database’s alerts configuration |
+
+## Get all database alerts {#get-all-bdbs-alerts}
+
+	GET /v1/bdbs/alerts
+
+Get all alert states for all databases.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a hash of alert UIDs and the [alerts]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) states for each database.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "bdb_size": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get database alerts {#get-bdbs-alerts}
+
+	GET /v1/bdbs/alerts/{int: uid}
+
+Get all alert states for a database.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "bdb_size": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get database alert {#get-bdbs-alert}
+
+	GET /v1/bdbs/alerts/{int: uid}/{alert}
+
+Get a database alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/alerts/1/bdb_size 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| alert | string | The alert name |
+
+### Response {#get-response} 
+
+Returns an [alert object]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+
+## Update database alert {#post-bdbs-alerts}
+
+	POST /v1/bdbs/alerts/{int: uid}
+
+Updates a database's alerts configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb_alerts" >}}) |
+
+### Request {#post-request} 
+
+If passed with the dry_run URL query string, the function will validate the alert thresholds, but not commit them.
+
+#### Example HTTP request
+
+	POST /v1/bdbs/alerts/1 
+
+#### Example JSON body
+
+```json
+{
+     "bdb_size":{
+         "threshold":"80",
+         "enabled":true
+     },
+     "bdb_high_syncer_lag":{
+         "threshold":"",
+         "enabled":false
+     },
+     "bdb_low_throughput":{
+         "threshold":"1",
+         "enabled":true
+     },
+     "bdb_high_latency":{
+         "threshold":"3000",
+         "enabled":true
+     },
+     "bdb_high_throughput":{
+         "threshold":"1",
+         "enabled":true
+     },
+     "bdb_backup_delayed":{
+         "threshold":"1800",
+         "enabled":true
+     }
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | Database ID |
+| dry_run | string | Validate the alert thresholds but do not apply them |
+
+#### Request body
+
+The request must contain a single JSON object with one or many database [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+### Response {#post-response} 
+
+The response includes the updated database [alerts]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified database was not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, database alerts updated. |
+---
+Title: Resume database traffic requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to resume traffic for a database
+headerRange: '[1-2]'
+linkTitle: resume_traffic
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-resume-traffic) | `/v1/bdbs/{uid}/actions/resume_traffic` | Resume database traffic |
+
+## Resume database traffic {#post-bdbs-actions-resume-traffic}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/resume_traffic
+```
+
+Resume traffic handling for the database.
+
+Use this action to resume read and write traffic on a database, where traffic was previously paused using the [`stop_traffic`]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/stop_traffic">}}) action.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb_with_action]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb_with_action" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/resume_traffic
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#post-response}
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | The request is accepted and is being processed. The database state will be `active-change-pending` until the request has been fully processed. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Attempting to perform an action on a nonexistent database. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Attempting to change a database while it is busy with another configuration change. This is a temporary condition, and the request should be reattempted later. |
+---
+Title: Import reset status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database import status requests
+headerRange: '[1-2]'
+linkTitle: import_reset_status
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-import-reset-status) | `/v1/bdbs/{uid}/actions/import_reset_status` | Reset database import status |
+
+## Reset database import status {#put-bdbs-actions-import-reset-status}
+
+	PUT /v1/bdbs/{int: uid}/actions/import_reset_status
+
+Reset the database’s `import_status` to idle if a backup is not in progress and clears the value of the `import_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_import_status]({{< relref "/operate/rs/references/rest-api/permissions#reset_bdb_current_import_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/import_reset_status
+```
+
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Stop database traffic requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to stop traffic for a database
+headerRange: '[1-2]'
+linkTitle: stop_traffic
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-stop-traffic) | `/v1/bdbs/{uid}/actions/stop_traffic` | Stop database traffic |
+
+## Stop database traffic {#post-bdbs-actions-stop-traffic}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/stop_traffic
+```
+
+Stop handling traffic for the database.
+
+Use this action to stop read and write traffic on a database. To resume traffic afterward, use the [`resume_traffic`]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/resume_traffic">}}) action.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb_with_action]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb_with_action" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/stop_traffic
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#post-response}
+
+Returns a JSON object with an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | The request is accepted and is being processed. The database state will be `active-change-pending` until the request has been fully processed. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Attempting to perform an action on a nonexistent database. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Attempting to change a database while it is busy with another configuration change. This is a temporary condition, and the request should be reattempted later. |
+---
+Title: Recover database requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for database recovery
+headerRange: '[1-2]'
+linkTitle: recover
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdbs-actions-recover) | `/v1/bdbs/{uid}/actions/recover` | Get database recovery plan  |
+| [POST](#post-bdbs-actions-recover) | `/v1/bdbs/{uid}/actions/recover` | Recover database  |
+
+## Get recovery plan {#get-bdbs-actions-recover}
+
+```sh
+GET /v1/bdbs/{int: uid}/actions/recover
+```
+
+Fetches the recovery plan for a database. The recovery plan provides information about the recovery status, such as whether recovery is possible, and details on available files to use for recovery.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_recovery_plan]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_recovery_plan" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/actions/recover
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database. |
+
+### Response {#get-response}
+
+Returns a JSON object that represents the database's recovery plan, including recovery files and status.
+
+#### Example response body
+
+```json
+{
+  "data_files": [
+    {
+      "filename": "appendonly-1.aof",
+      "last_modified": 1721164863.8883622,
+      "node_uid": "1",
+      "shard_role": "master",
+      "shard_slots": "1-2048",
+      "shard_uid": "1",
+      "size": 88
+    },
+    {
+      "filename": "appendonly-2.aof",
+      "last_modified": 1721164863.8883622,
+      "node_uid": "2",
+      "shard_role": "slave",
+      "shard_slots": "2049-4096",
+      "shard_uid": "2",
+      "size": 88
+    }
+  ],
+  "status": "ready"
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Database UID does not exist. |
+
+## Recover database {#post-bdbs-actions-recover}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/recover
+```
+
+Initiates [recovery for a database]({{<relref "operate/rs/databases/recover">}}) in a recoverable state where all the database's files are available after [cluster recovery]({{<relref "/operate/rs/clusters/cluster-recovery">}}).
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_recovery]({{< relref "/operate/rs/references/rest-api/permissions#start_bdb_recovery" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+The request body can either be empty or include a recovery plan.
+
+If the request body is empty, the database will be recovered automatically:
+
+- Databases with no persistence are recovered with no data.
+
+- Persistent files such as AOF or RDB will be loaded from their expected storage locations where replica or primary shards were last active.
+
+- If persistent files are not found where expected but can be located on other cluster nodes, they will be used.
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/recover
+```
+
+#### Example request body
+
+```json
+{
+  "data_files": [
+    {
+      "filename": "appendonly-1.aof",
+      "node_uid": "1",
+      "shard_slots": "1-2048"
+    },
+    {
+      "filename": "appendonly-2.aof",
+      "node_uid": "2",
+      "shard_slots": "2049-4096"
+    }
+  ],
+  "ignore_errors": false,
+  "recover_without_data": false
+}
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to recover. |
+
+### Response {#post-response}
+
+Returns a status code. Also returns a JSON object with an `action_uid` in the request body if successful.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | The request is accepted and is being processed. When the database is recovered, its status will become `active`. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Attempting to perform an action on a nonexistent database. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy with another action, recovery is already in progress, or is not in a recoverable state. |
+---
+Title: Rebalance database requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to rebalance database shards
+headerRange: '[1-2]'
+linkTitle: rebalance
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-rebalance) | `/v1/bdbs/{uid}/actions/rebalance` | Rebalance database shards |
+
+## Rebalance database shards {#put-bdbs-actions-rebalance}
+
+```sh
+PUT /v1/bdbs/{int: uid}/actions/rebalance
+```
+
+Distributes the database's shards across nodes based on the database's shard placement policy. See [Shard placement policy]({{<relref "/operate/rs/databases/memory-performance/shard-placement-policy">}}) for more information about shard placement and available policies.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/rebalance
+```
+
+Dry-run example:
+
+```sh
+PUT /v1/bdbs/1/actions/rebalance?only_failovers=true&dry_run=true
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to rebalance. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run | boolean | If true, returns the blueprint of the rebalanced database without actually changing the database. Default is false. |
+| only_failovers | boolean | If true, only runs failovers and no migrations. Default is false. |
+| max_operations | integer | Optional. The number of operations to do. Only works if `only_failovers` is true. If not provided, uses the number of the database's primary-replica pairs. |
+
+### Response {#put-response}
+
+- If `dry_run` is `false`, returns an `action_uid`. You can track the action's progress with a [`GET /v1/actions/<action_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions#get-action">}}) request.
+
+- If `dry_run` is `true`, returns the balanced shards' blueprint.
+
+  You can rearrange shards according to this blueprint if you use it in the `shards_blueprint` field of a [rearrange database shards]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/optimize_shards_placement#put-bdbs-rearrange-shards">}}) request.
+  
+  You should also pass the rebalance shards' `cluster-state-id` response header as a request header of the rearrange database shards request to make sure the optimized shard placement is relevant for the current cluster state. The cluster will reject the update if its state changed since the optimal shards placement blueprint was generated.
+
+#### Example response
+
+If `dry_run` is `false`:
+
+```sh
+{
+    "action_uid": "21ad01d5-55aa-4ec6-b5c0-44dc95176486"
+}
+```
+
+If `dry_run` is `true`:
+
+```sh
+[
+  {
+    "nodes": [
+      {
+        "node_uid": "3",
+        "role": "master"
+      },
+      {
+        "node_uid": "1",
+        "role": "slave"
+      }
+    ],
+    "slot_range": "5461-10922"
+  },
+  {
+    "nodes": [
+      {
+        "node_uid": "3",
+        "role": "master"
+      },
+      {
+        "node_uid": "1",
+        "role": "slave"
+      }
+    ],
+    "slot_range": "10923-16383"
+  },
+  {
+    "nodes": [
+      {
+        "node_uid": "3",
+        "role": "master"
+      },
+      {
+        "node_uid": "1",
+        "role": "slave"
+      }
+    ],
+    "slot_range": "0-5460"
+  }
+]
+```
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | When `dry_run` is false: The request is accepted and is being processed. When the database is recovered, its status will become active.<br />When `dry_run` is true: No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Bad request. Invalid input parameters. |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | Attempting to perform an action on a nonexistent database. |
+| [406 Not Acceptable](https://www.rfc-editor.org/rfc/rfc9110.html#name-406-not-acceptable) | Not enough resources in the cluster to host the database. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Database is currently busy with another action, recovery is already in progress, or is not in a recoverable state. |
+| [500 Internal Server Error](https://www.rfc-editor.org/rfc/rfc9110.html#name-500-internal-server-error) | Internal server error. |
+---
+Title: Export resets status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database export status requests
+headerRange: '[1-2]'
+linkTitle: export_reset_status
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-export-reset-status) | `/v1/bdbs/{uid}/actions/export_reset_status` | Reset database export status |
+
+## Reset database export status {#put-bdbs-actions-export-reset-status}
+
+	PUT /v1/bdbs/{int: uid}/actions/export_reset_status
+
+Resets the database's `export_status` to idle if an export is not in progress and clears the value of the `export_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_export_status]({{< relref "/operate/rs/references/rest-api/permissions#reset_bdb_current_export_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/export_reset_status
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Backup reset status database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Reset database backup status requests
+headerRange: '[1-2]'
+linkTitle: backup_reset_status
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-bdbs-actions-backup-reset-status) | `/v1/bdbs/{uid}/actions/backup_reset_status` | Reset database backup status |
+
+## Reset database backup status {#put-bdbs-actions-backup-reset-status}
+
+```sh
+PUT /v1/bdbs/{int: uid}/actions/backup_reset_status
+```
+
+Resets the database's `backup_status` to idle if a backup is not in progress and clears the value of the `backup_failure_reason` field.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [reset_bdb_current_backup_status]({{< relref "/operate/rs/references/rest-api/permissions#reset_bdb_current_backup_status" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/actions/backup_reset_status
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#put-response}
+
+Returns a status code.
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Optimize shards placement database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Optimize shard placement requests
+headerRange: '[1-2]'
+linkTitle: optimize_shards_placement
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-bdbs-actions-optimize-shards-placement) | `/v1/bdbs/{uid}/actions/optimize_shards_placement` | Get optimized shards placement for a database  |
+
+
+## Get optimized shards placement {#get-bdbs-actions-optimize-shards-placement}
+
+```sh
+GET /v1/bdbs/{int: uid}/actions/optimize_shards_placement
+```
+
+Get optimized shards placement for the given database.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/actions/optimize_shards_placement
+```
+
+#### Query parameters
+
+Include query parameters in a `GET` request to generate an optimized shard placement blueprint for a database, using settings that are different from the database's current configuration.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| avoid_nodes | list of integers | Comma-separated list of cluster node IDs to avoid when placing the database’s shards and binding its endpoints (for example, `avoid_nodes=1,2`) |
+| memory_size | integer (default:&nbsp;0) | Database memory limit (0 is unlimited), expressed in bytes |
+| shards_count | integer, <nobr>(range: 1-512)</nobr> (default:&nbsp;1) | Number of database server-side shards |
+| shards_placement | `dense` <br />`sparse` | Control the density of shards <br /> `dense`: Shards reside on as few nodes as possible <br /> `sparse`: Shards reside on as many nodes as possible |
+| bigstore_ram_size | integer (default:&nbsp;0) | Memory size of bigstore RAM part, expressed in bytes |
+| replication | `enabled`<br />`disabled` | In-memory database replication mode |
+
+The following example request includes `shards_count` and `memory_size` as query parameters:
+
+```sh
+GET /v1/bdbs/1/actions/optimize_shards_placement?shards_count=10&memory_size=10000
+```
+
+### Response {#get-response}
+
+To rearrange the database shards, you can submit the blueprint returned in this response body as the `shards_blueprint` field in the [`PUT`&nbsp;`/v1/bdbs/{uid}`](#put-bdbs-rearrange-shards) request.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "5461-10922"
+    },
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "10923-16383"
+    },
+    {
+        "nodes": [
+            {
+                "node_uid": "3",
+                "role": "master"
+            },
+            {
+                "node_uid": "1",
+                "role": "slave"
+            }
+        ],
+        "slot_range": "0-5460"
+    }
+]
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Length | 352 | Length of the request body in octets |
+| cluster-state-id | 30 | Cluster state ID |
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database UID does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not enough resources in the cluster to host the database |
+
+## Rearrange database shards {#put-bdbs-rearrange-shards}
+
+Use the blueprint returned by the [`GET`&nbsp;`/v1/bdbs/{uid}/actions/optimize_shards_placement`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/actions/optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}) request as the value of the `shards_blueprint` field to rearrange the database shards.
+
+To ensure that the optimized shard placement is relevant for the current cluster state, pass the `cluster-state-id`, taken from the response header of the `GET` request, in the [`PUT`&nbsp;`/v1/bdbs/{uid}`]({{< relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs" >}}) request headers.
+
+The cluster will reject the update if its state was changed since the optimal shards placement was obtained.
+
+### Request
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| cluster-state-id | 30 | Cluster state ID |
+
+#### Example JSON body
+
+```json
+{
+  "shards_blueprint": [
+    {
+      "nodes": [
+        {
+          "node_uid": "2",
+          "role": "master"
+        }
+      ],
+      "slot_range": "0-8191"
+    },
+    "..."
+  ]
+}
+```
+
+{{<warning>}}
+If you submit such an optimized blueprint, it may cause strain on the cluster and its resources. Use with caution.
+{{</warning>}}
+---
+Title: Import database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Import database requests
+headerRange: '[1-2]'
+linkTitle: import
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-import) | `/v1/bdbs/{uid}/actions/import` | Initiate manual dataset import |
+
+## Initiate manual dataset import {#post-bdbs-actions-import}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/import
+```
+
+Initiate a manual import process.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_import]({{< relref "/operate/rs/references/rest-api/permissions#start_bdb_import" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/import
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Length | 0 | Length of the request body in octets |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+#### Body
+
+The request _may_ contain a subset of the [BDB JSON object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}), which includes the following import-related attributes:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dataset_import_sources | array of [dataset_import_sources]({{< relref "/operate/rs/references/rest-api/objects/bdb/dataset_import_sources" >}}) objects | Details for the import sources. Call [`GET /v1/jsonschema`]({{< relref "/operate/rs/references/rest-api/requests/jsonschema#get-jsonschema" >}}) on the bdb object and review the `dataset_import_sources` field to retrieve the object's structure.  |
+| email_notification | boolean | Enable/disable an email notification on import failure/ completion. (optional) |
+
+{{<note>}}
+Other attributes are not allowed and will cause the request to fail.
+{{</note>}}
+
+##### Example JSON body
+
+General example:
+
+```json
+{
+    "dataset_import_sources": [
+        {
+            "type": "url",
+            "url": "http://..."
+        },
+        {
+            "type": "url",
+            "url": "redis://..."
+        }
+    ],
+    "email_notification": true
+}
+```
+
+This request initiates an import process using `dataset_import_sources` values that were previously configured for the database.
+
+FTP example:
+
+```json
+{
+  "dataset_import_sources": [
+    {
+      "type": "url",
+      "url": "ftp://<ftp_user>:<ftp_password>@example.com/<path>/<filename>.rdb.gz"
+    }
+  ]
+}
+```
+
+SFTP example:
+
+```json
+{
+  "dataset_import_sources": [
+    {
+      "type": "sftp",
+      "sftp_url": "sftp://<sftp_user>@example.com/<path>/<filename>.rdb"
+    }
+  ]
+}
+```
+
+AWS S3 example:
+
+```json
+{
+  "dataset_import_sources": [
+    {
+      "type": "s3",
+      "bucket_name": "backups",
+      "subdir": "test-db",
+      "filename": "<filename>.rdb",
+      "access_key_id": "XXXXXXXXXXXXX",
+      "secret_access_key": "XXXXXXXXXXXXXXXX"
+    }
+  ]
+}
+```
+
+Google Cloud Storage example:
+
+```json
+{
+  "dataset_import_sources": [
+    {
+      "type": "gs",
+      "bucket_name": "backups",
+      "client_id": "XXXXXXXX",
+      "client_email": "cloud-storage-client@my-project-id.iam.gserviceaccount.com",
+      "subdir": "test-db",
+      "filename": "<filename>.rdb",
+      "private_key_id": "XXXXXXXXXXXXX",
+      "private_key": "XXXXXXXXXXXXXXXX"
+    }
+  ]
+}
+```
+
+Azure Blob Storage example:
+
+```json
+{
+  "dataset_import_sources": [
+    {
+      "type": "abs",
+      "container": "backups",
+      "subdir": "test-db",
+      "filename": "<filename>.rdb",
+      "account_name": "name",
+      "account_key": "XXXXXXXXXXXXXXXX" // Or you can use "sas_token": "XXXXXXXXXXXXXXXXXX" instead
+    }
+  ]
+}
+```
+
+### Response {#post-response}
+
+Returns a status code.
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. In order to monitor progress, the `import_status`, `import_progress`, and `import_failure_reason` attributes can be consulted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Export database action requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Export database requests
+headerRange: '[1-2]'
+linkTitle: export
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-actions-export) | `/v1/bdbs/{uid}/actions/export` | Initiate database export |
+
+## Initiate database export {#post-bdbs-actions-export}
+
+```sh
+POST /v1/bdbs/{int: uid}/actions/export
+```
+
+Initiate a database export.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [start_bdb_export]({{< relref "/operate/rs/references/rest-api/permissions#start_bdb_export" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs/1/actions/export
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+
+#### Body
+
+The request body should contain a JSON object with the following export parameters:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| export_location | [backup_location/export_location]({{< relref "/operate/rs/references/rest-api/objects/bdb/backup_location" >}}) object | Details for the export destination. Call [`GET /v1/jsonschema`]({{< relref "/operate/rs/references/rest-api/requests/jsonschema#get-jsonschema" >}}) on the bdb object and review the `backup_location` field to retrieve the object's structure.  |
+| email_notification | boolean | Enable/disable an email notification on export failure/ completion. (optional) |
+
+##### Example JSON body
+
+```json
+{
+    "export_location": {
+        "type": "url",
+        "url": "ftp://..."
+    },
+    "email_notification": true
+}
+```
+
+The above request initiates an export operation to the specified location.
+
+### Response {#post-response}
+
+Returns a status code.
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. In order to monitor progress, the BDB's `export_status`, `export_progress`, and `export_failure_reason` attributes can be consulted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to perform an action on a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Not all the modules loaded to the database support 'backup_restore' capability |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database is currently busy with another action. In this context, this is a temporary condition and the request should be reattempted later. |
+---
+Title: Database actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database action requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+---
+
+## Backup
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./backup_reset_status#put-bdbs-actions-backup-reset-status" >}}) | `/v1/bdbs/{uid}/actions/backup_reset_status` | Reset database backup status |
+
+## Export
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./export_reset_status#put-bdbs-actions-export-reset-status" >}}) | `/v1/bdbs/{uid}/actions/export_reset_status` | Reset database export status |
+| [POST]({{< relref "./export#post-bdbs-actions-export" >}}) | `/v1/bdbs/{uid}/actions/export` | Initiate database export |
+
+## Import
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{< relref "./import_reset_status#put-bdbs-actions-import-reset-status" >}}) | `/v1/bdbs/{uid}/actions/import_reset_status` | Reset database import status |
+| [POST]({{< relref "./import#post-bdbs-actions-import" >}}) | `/v1/bdbs/{uid}/actions/import` | Initiate manual dataset import |
+
+## Optimize shards placement
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}) | `/v1/bdbs/{uid}/actions/optimize_shards_placement` | Get optimized shards placement for a database  |
+
+## Rebalance
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/rebalance#put-bdbs-actions-rebalance">}}) | `/v1/bdbs/{uid}/actions/rebalance` | Rebalance database shards |
+
+## Recover
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/recover#get-bdbs-actions-recover">}}) | `/v1/bdbs/{uid}/actions/recover` | Get database recovery plan  |
+| [POST]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/recover#post-bdbs-actions-recover">}}) | `/v1/bdbs/{uid}/actions/recover` | Recover database  |
+
+## Resume traffic
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/resume_traffic#post-bdbs-actions-resume-traffic">}}) | `/v1/bdbs/{uid}/actions/resume_traffic` | Resume database traffic |
+
+## Stop traffic
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/stop_traffic#post-bdbs-actions-stop-traffic">}}) | `/v1/bdbs/{uid}/actions/stop_traffic` | Stop database traffic |
+---
+Title: Database upgrade requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database upgrade requests
+headerRange: '[1-2]'
+linkTitle: upgrade
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdbs-upgrade) | `/v1/bdbs/{uid}/upgrade` | Upgrade database |
+
+## Upgrade database {#post-bdbs-upgrade}
+
+	POST /v1/bdbs/{int: uid}/upgrade
+
+Upgrade a database.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_bdb_with_action]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb_with_action" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/upgrade 
+
+#### Example JSON body
+
+```json
+{
+    "swap_roles": true,
+    "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| force_restart | boolean | Restart shards even if no version change (default: false) |
+| keep_redis_version | boolean | Keep current Redis version (default: false). Deprecated as of Redis Enterprise Software v7.8.2. To upgrade modules without upgrading the Redis database version, set `redis_version` to the current Redis database version instead. |
+| keep_crdt_protocol_version | boolean | Keep current crdt protocol version (default: false)  |
+| may_discard_data | boolean | Discard data in a non-replicated, non-persistent bdb (default: false) |
+| force_discard | boolean | Discard data even if the bdb is replicated and/or persistent (default: false) |
+| preserve_roles | boolean | Preserve shards' master/replica roles (requires an extra failover) (default: false) |
+| parallel_shards_upgrade | integer | Max number of shards to upgrade in parallel (default: all) |
+| modules | list of modules | List of dicts representing the modules that will be upgraded. As of Redis Enterprise Software v7.8.2, `current_module` and `new_module` are deprecated.<br></br>Each dict includes:<br></br>• `current_module`: uid of a module to upgrade (deprecated)<br></br>• `new_module`: uid of the module we want to upgrade to (deprecated)<br></br>• `new_module_args`: args list for the new module (no defaults for the three module-related parameters).
+| redis_version | version number | Upgrades the database to the specified Redis version instead of the latest version. To upgrade modules without upgrading the Redis database version, set `redis_version` to the current Redis database version instead. |
+| latest_with_modules | boolean | Upgrades the database to the latest Redis version and latest supported versions of modules available in the cluster. (default: true as of v7.8.2) Deprecated as of Redis Enterprise Software v7.8.2. |
+
+### Response {#post-response} 
+
+Returns the upgraded [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "replication": true,
+    "data_persistence": "aof",
+    "// additional fields..."
+}
+```
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, bdb upgrade initiated (`action_uid` can be used to track progress) |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Malformed or bad command |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | New module version capabilities don't comply with the database configuration |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Internal error |
+---
+Title: Database modules config requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure Redis module requests
+headerRange: '[1-2]'
+linkTitle: config
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdb-modules-config) | `/v1/bdbs/{uid}/modules/config` | Configure module |
+
+## Configure module {#post-bdb-modules-config}
+
+	POST /v1/bdbs/{string: uid}/modules/config
+
+Use the module runtime configuration command (if defined) to configure new arguments for the module.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/modules/config
+
+#### Example JSON body
+
+```json
+{
+  "modules": [
+    {
+      "module_name": "search",
+      "module_args": "MINPREFIX 3 MAXEXPANSIONS 1000"
+    }
+  ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list of JSON objects | List of modules (module_name) and their new configuration settings (module_args) |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name |
+| module_args | string | Module command line arguments (pattern does not allow special characters &,<,>,”) |
+
+### Response {#post-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_not_exist | Database with given UID doesn't exist in cluster | 
+| missing_field | "module_name" or "module_args" are not defined in request | 
+| invalid_schema | JSON object received is not a dict object | 
+| param_error | "module_args" parameter was not parsed properly | 
+| module_not_exist | Module with given "module_name" does not exist for the database | 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Module does not support runtime configuration of arguments. |
+---
+Title: Database upgrade modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade Redis module requests
+headerRange: '[1-2]'
+linkTitle: upgrade
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-bdb-modules-upgrade) | `/v1/bdbs/{uid}/modules/upgrade` | Upgrade module |
+
+## Upgrade module {#post-bdb-modules-upgrade}
+
+	POST /v1/bdbs/{string: uid}/modules/upgrade
+
+Upgrades module version on a specific BDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/bdbs/1/modules/upgrade
+
+#### Example JSON body
+
+```json
+{
+     "modules": [
+         {"module_name": "ReJson",
+         "current_semantic_version": "2.2.1",
+         "new_module": "aa3648d79bd4082d414587c42ea0b234"}
+     ],
+     "// Optional fields to fine-tune restart and failover behavior:",
+     "preserve_roles": true,
+     "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list | List of dicts representing the modules that will be upgraded. Each dict must include: <br></br> • **current_module**: uid of a module to upgrade <br></br> • **new_module**: UID of the module we want to upgrade to <br></br> • **new_module_args**: args list for the new module |
+| preserve_roles | boolean | Preserve shards’ master/replica roles (optional) |
+| may_discard_data | boolean | Discard data in a non-replicated non-persistent bdb (optional) |
+
+### Response {#post-response} 
+
+Returns the upgraded [module object]({{< relref "/operate/rs/references/rest-api/objects/module" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "module_id": "aa3648d79bd4082d414587c42ea0b234",
+    "module_name": "ReJson",
+    "semantic_version": "2.2.2"
+    "// additional fields..."
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| missing_module | Module is not present in cluster.| 
+| module_downgrade_unsupported | Module downgrade is not allowed.| 
+| redis_incompatible_version | Module min_redis_version is bigger than the current Redis version.| 
+| redis_pack_incompatible_version | Module min_redis_pack_version is bigger than the current Redis Enterprise version.| 
+| unsupported_module_capabilities | New version of module does support all the capabilities needed for the database configuration| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb or node not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+---
+Title: Database modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis module requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: modules
+weight: $weight
+---
+
+## Configure module
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{< relref "/operate/rs/references/rest-api/requests/bdbs/modules/config#post-bdb-modules-config" >}}) | `/v1/bdbs/{uid}/modules/config` | Configure module |
+
+## Upgrade module
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST]({{< relref "/operate/rs/references/rest-api/requests/bdbs/modules/upgrade#post-bdb-modules-upgrade" >}}) | `/v1/bdbs/{uid}/modules/upgrade` | Upgrade module |---
+Title: Database syncer source stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Syncer source statistics requests
+headerRange: '[1-2]'
+linkTitle: sync_source_stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-sync_source_stats) | `/v1/bdbs/{bdb_uid}/sync_source_stats` | Get stats for all syncer sources |
+| [GET](#get-bdbs-sync_source_stats) | `/v1/bdbs/{bdb_uid}/sync_source_stats/{uid}` | Get stats for a specific syncer instance |
+
+## Get all syncer source stats {#get-all-bdbs-sync_source_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/sync_source_stats
+```
+
+Get stats for all syncer sources of a local database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/sync_source_stats?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local database. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | Optional end time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all syncer sources.
+
+#### Example JSON body
+
+```json
+{ "sync_source_stats": [
+     {
+         "intervals": [
+             {
+                 "etime": "2017-10-22T19:30:00Z",
+                 "ingress_bytes": 18528,
+                 "ingress_bytes_decompressed": 185992,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.244,
+                 "stime": "2017-10-22T19:25:00Z"
+             },
+             {
+                 "etime": "2017-10-22T19:35:00Z",
+                 "ingress_bytes": 18,
+                 "ingress_bytes_decompressed": 192,
+                 "interval": "5min",
+                 "local_ingress_lag_time": 0.0,
+                 "stime": "2017-10-22T19:30:00Z"
+             }
+         ],
+         "uid": "1"
+     }
+   ]
+ }
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database does not exist. |
+
+## Get syncer instance stats {#get-bdbs-sync_source_stats}
+
+```sh
+GET /v1/bdbs/{bdb_uid}/sync_source_stats/{int: uid}
+```
+
+Get stats for a specific syncer (Replica Of) instance.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1/sync_source_stats/1?interval=5min
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | integer | The unique ID of the local database. |
+| uid | integer | The sync_source uid. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Optional start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | Optional end time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for a specific syncer instance.
+
+#### Example JSON body
+
+```json
+{
+    "intervals": [
+        {
+            "etime": "2017-10-22T19:30:00Z",
+            "ingress_bytes": 18528,
+            "ingress_bytes_decompressed": 185992,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.244,
+            "stime": "2017-10-22T19:25:00Z"
+        },
+        {
+            "etime": "2017-10-22T19:35:00Z",
+            "ingress_bytes": 18,
+            "ingress_bytes_decompressed": 192,
+            "interval": "5min",
+            "local_ingress_lag_time": 0.0,
+            "stime": "2017-10-22T19:30:00Z"
+        }
+    ],
+    "uid": "1"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or sync_source do not exist. |
+---
+Title: Latest database stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Most recent database statistics requests
+headerRange: '[1-2]'
+linkTitle: last
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-stats-last) | `/v1/bdbs/stats/last` | Get most recent stats for all databases |
+| [GET](#get-bdbs-stats-last) | `/v1/bdbs/stats/last/{uid}` | Get most recent stats for a specific database |
+
+## Get latest stats for all databases {#get-all-bdbs-stats-last}
+
+```sh
+GET /v1/bdbs/stats/last
+```
+
+Get the most recent statistics for all databases.
+
+#### Required permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+1. Without metrics filter (returns all metrics by default)
+    ```
+    GET /v1/bdbs/stats/last
+    ```
+
+2. With metrics filter
+    ```
+    GET /v1/bdbs/stats/last?metrics=no_of_keys,used_memory
+    ```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| metrics | string | Comma-separated list of metric names for which we want statistics (default is all). (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all databases.
+
+#### Example JSON body
+
+1. Without metrics filter (returns all metrics by default)
+    ```json
+    {
+    "1": {
+        "stime": "2015-05-28T08:06:37Z",
+        "etime": "2015-05-28T08:06:44Z",
+        "conns": 0.0,
+        "egress_bytes": 0.0,
+        "etime": "2015-05-28T08:06:44Z",
+        "evicted_objects": 0.0,
+        "expired_objects": 0.0,
+        "ingress_bytes": 0.0,
+        "instantaneous_ops_per_sec": 0.0,
+        "last_req_time": "1970-01-01T00:00:00Z",
+        "last_res_time": "1970-01-01T00:00:00Z",
+        "used_memory": 5651336.0,
+        "mem_size_lua": 35840.0,
+        "monitor_sessions_count": 0.0,
+        "no_of_keys": 0.0,
+        "other_req": 0.0,
+        "other_res": 0.0,
+        "read_hits": 0.0,
+        "read_misses": 0.0,
+        "read_req": 0.0,
+        "read_res": 0.0,
+        "total_connections_received": 0.0,
+        "total_req": 0.0,
+        "total_res": 0.0,
+        "write_hits": 0.0,
+        "write_misses": 0.0,
+        "write_req": 0.0,
+        "write_res": 0.0
+    },
+    "2": {
+        "stime": "2015-05-28T08:06:37Z",
+        "etime": "2015-05-28T08:06:44Z",
+
+        "// additional fields..."
+    },
+
+    "// Additional BDBs..."
+    }
+    ```
+
+2. With metrics filter
+    ```json
+    {
+    "1": {
+      "etime": "2015-05-28T08:06:44Z",
+      "used_memory": 5651576.0,
+      "no_of_keys": 0.0,
+      "stime": "2015-05-28T08:06:37Z"
+    },
+    "2": {
+      "etime": "2015-05-28T08:06:44ZZ",
+      "used_memory": 5651440.0,
+      "no_of_keys": 0.0,
+      "stime": "2015-05-28T08:06:37Z"
+    },
+
+    "// Additional BDBs.."
+    }
+    ```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No bdbs exist |
+
+## Get latest database stats {#get-bdbs-stats-last}
+
+```sh
+GET /v1/bdbs/stats/last/{int: uid}
+```
+
+Get the most recent statistics for a specific database.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats/last/1?metrics=no_of_keys,used_memory
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the requested BDB. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| metrics | string | Comma-separated list of metric names for which we want statistics (default is all). (optional) |
+
+### Response {#get-response}
+
+Returns the most recent [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for a specific database.
+
+#### Example JSON body
+
+```json
+{
+   "1": {
+     "etime": "2015-06-23T12:05:08Z",
+     "used_memory": 5651576.0,
+     "no_of_keys": 0.0,
+     "stime": "2015-06-23T12:05:03Z"
+   }
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | bdb isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | bdb is in recovery state |
+---
+Title: Database stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-stats) | `/v1/bdbs/stats` | Get stats for all databases |
+| [GET](#get-bdbs-stats) | `/v1/bdbs/stats/{uid}` | Get stats for a specific database |
+
+## Get all database stats {#get-all-bdbs-stats}
+
+```sh
+GET /v1/bdbs/stats
+```
+
+Get statistics for all databases.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-all-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for all databases.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "uid": "1",
+    "intervals": [
+      {
+         "interval": "1hour",
+         "stime": "2015-05-27T12:00:00Z",
+         "etime": "2015-05-28T12:59:59Z",
+         "avg_latency": 0.0,
+         "conns": 0.0,
+         "egress_bytes": 0.0,
+         "etime": "2015-05-28T00:00:00Z",
+         "evicted_objects": 0.0,
+         "expired_objects": 0.0,
+         "ingress_bytes": 0.0,
+         "instantaneous_ops_per_sec": 0.00011973180076628352,
+         "last_req_time": "1970-01-01T00:00:00Z",
+         "last_res_time": "1970-01-01T00:00:00Z",
+         "used_memory": 5656299.362068966,
+         "mem_size_lua": 35840.0,
+         "monitor_sessions_count": 0.0,
+         "no_of_keys": 0.0,
+         "other_req": 0.0,
+         "other_res": 0.0,
+         "read_hits": 0.0,
+         "read_misses": 0.0,
+         "read_req": 0.0,
+         "read_res": 0.0,
+         "total_connections_received": 0.0,
+         "total_req": 0.0,
+         "total_res": 0.0,
+         "write_hits": 0.0,
+         "write_misses": 0.0,
+         "write_req": 0.0,
+         "write_res": 0.0
+      },
+      {
+         "interval": "1hour",
+         "interval": "1hour",
+         "stime": "2015-05-27T13:00:00Z",
+         "etime": "2015-05-28T13:59:59Z",
+         "avg_latency": 599.08,
+         "// additional fields..."
+      }
+    ]
+  },
+  {
+    "uid": "2",
+    "intervals": [
+      {
+        "interval": "1hour",
+        "stime": "2015-05-27T12:00:00Z",
+        "etime": "2015-05-28T12:59:59Z",
+        "avg_latency": 0.0,
+        "// additional fields..."
+      },
+      {
+        "interval": "1hour",
+        "stime": "2015-05-27T13:00:00Z",
+        "etime": "2015-05-28T13:59:59Z",
+
+        "// additional fields..."
+      }
+    ]
+  }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | No bdbs exist |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X GET
+        https://[host][:port]/v1/bdbs/stats?interval=1hour
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/bdbs/stats?interval=1hour"
+auth = ("[username]", "[password]")
+
+response = requests.request("GET", url, auth=auth)
+
+print(response.text)
+```
+
+## Get database stats {#get-bdbs-stats}
+
+```sh
+GET /v1/bdbs/stats/{int: uid}
+```
+
+Get statistics for a specific database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_stats" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/stats/1?interval=1hour&stime=2014-08-28T10:00:00Z
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the BDB requested. |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response}
+
+Returns [statistics]({{< relref "/operate/rs/references/rest-api/objects/statistics" >}}) for a specific database.
+
+#### Example JSON body
+
+```json
+{
+  "uid": "1",
+  "intervals": [
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T12:00:00Z",
+      "etime": "2015-05-28T12:59:59Z",
+      "avg_latency": 0.0,
+      "conns": 0.0,
+      "egress_bytes": 0.0,
+      "evicted_objects": 0.0,
+      "pubsub_channels": 0,
+      "pubsub_patterns": 0,
+      "expired_objects": 0.0,
+      "ingress_bytes": 0.0,
+      "instantaneous_ops_per_sec": 0.00011973180076628352,
+      "last_req_time": "1970-01-01T00:00:00Z",
+      "last_res_time": "1970-01-01T00:00:00Z",
+      "used_memory": 5656299.362068966,
+      "mem_size_lua": 35840.0,
+      "monitor_sessions_count": 0.0,
+      "no_of_keys": 0.0,
+      "other_req": 0.0,
+      "other_res": 0.0,
+      "read_hits": 0.0,
+      "read_misses": 0.0,
+      "read_req": 0.0,
+      "read_res": 0.0,
+      "total_connections_received": 0.0,
+      "total_req": 0.0,
+      "total_res": 0.0,
+      "write_hits": 0.0,
+      "write_misses": 0.0,
+      "write_req": 0.0,
+      "write_res": 0.0
+    },
+    {
+      "interval": "1hour",
+      "stime": "2015-05-27T13:00:00Z",
+      "etime": "2015-05-28T13:59:59Z",
+      "// additional fields..."
+    }
+  ]
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb does not exist |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | bdb isn't currently active |
+| [503 Service Unavailable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.4) | bdb is in recovery state |
+---
+Title: Database requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: bdbs
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs) | `/v1/bdbs` | Get all databases |
+| [GET](#get-bdbs) | `/v1/bdbs/{uid}` | Get a single database |
+| [PUT](#put-bdbs) | `/v1/bdbs/{uid}` | Update database configuration |
+| [PUT](#put-bdbs-action) | `/v1/bdbs/{uid}/{action}` | Update database configuration and perform additional action |
+| [POST](#post-bdbs-v1) | `/v1/bdbs` | Create a new database |
+| [POST](#post-bdbs-v2) | `/v2/bdbs` | Create a new database |
+| [DELETE](#delete-bdbs) | `/v1/bdbs/{uid}` | Delete a database |
+
+## Get all databases {#get-all-bdbs}
+
+```sh
+GET /v1/bdbs
+```
+
+Get all databases in the cluster.
+
+### Permissions
+
+| Permission name | Roles   |
+|-----------------|---------|
+| [view_all_bdbs_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdbs_info" >}}) |  admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs?fields=uid,name
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| fields | string | Comma-separated list of field names to return (by default all fields are returned). (optional) |
+
+### Response {#get-all-response}
+
+The response body contains a JSON array with all databases, represented as [BDB objects]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Body
+
+```json
+[
+    {
+        "uid": 1,
+        "name": "name of database #1",
+        "// additional fields..."
+    },
+    {
+        "uid": 2,
+        "name": "name of database #2",
+        "// additional fields..."
+    }
+]
+```
+
+#### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+### Example requests
+
+#### cURL
+
+```sh
+$ curl -k -X GET -u "[username]:[password]" \
+       -H "accept: application/json" \
+       https://[host][:port]/v1/bdbs?fields=uid,name
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/bdbs?fields=uid,name"
+auth = ("[username]", "[password]")
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+response = requests.request("GET", url, auth=auth, headers=headers)
+
+print(response.text)
+```
+
+## Get a database {#get-bdbs}
+
+```sh
+GET /v1/bdbs/{int: uid}
+```
+
+Get a single database.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_bdb_info]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database requested. |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| fields | string | Comma-separated list of field names to return (by default all fields are returned). (optional) |
+
+### Response {#get-response}
+
+Returns a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "// additional fields..."
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database UID does not exist |
+
+## Update database configuration {#put-bdbs}
+
+```sh
+PUT /v1/bdbs/{int: uid}
+```
+Update the configuration of an active database.
+
+If called with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) against the existing database, but will not invoke the state machine that will update it.
+
+This is the basic version of the update request. See [Update database and perform action](#put-bdbs-action) to send an update request with an additional action.
+
+To track this request's progress, poll the [`/actions/<action_uid>` endpoint]({{< relref "/operate/rs/references/rest-api/requests/bdbs/actions" >}}) with the action_uid returned in the response body.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |      | Validate the new [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) but don't apply the update. |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database for which update is requested. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) with updated fields in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "replication": true,
+    "data_persistence": "aof"
+}
+```
+
+The above request attempts to modify a database configuration to enable in-memory data replication and append-only file data persistence.
+
+### Response {#put-response}
+
+Returns the updated [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "replication": true,
+    "data_persistence": "aof",
+    "// additional fields..."
+}
+```
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'active-change-pending' until the request has been fully processed. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Attempting to change a database while it is busy with another configuration change. In this context, this is a temporary condition, and the request should be reattempted later. |
+
+#### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| rack_awareness_violation | • Non rack-aware cluster.<br />• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed.|
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| insufficient_resources | Shards count exceeds shards limit per bdb. |
+| not_supported_action_on_crdt | `reset_admin_pass` action is not allowed on CRDT enabled BDB. |
+| name_violation | CRDT database name cannot be changed. |
+| bad_shards_blueprint | The sharding blueprint is broken or doesn’t fit the BDB. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| replication_node_violation | Not enough nodes for replication. |
+| replication_size_violation | Database limit too small for replication. |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| crdt_sharding_violation | CRDB created without sharding cannot be changed to use sharding
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+## Update database and perform action {#put-bdbs-action}
+
+```sh
+PUT /v1/bdbs/{int: uid}/{action}
+```
+Update the configuration of an active database and perform an additional action.
+
+If called with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) against the existing database, but will not invoke the state machine that will update it.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_bdb_with_action]({{< relref "/operate/rs/references/rest-api/permissions#update_bdb_with_action" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#put-request-action}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/bdbs/1/reset_admin_pass
+```
+The above request resets the admin password after updating the database.
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to update. |
+| action | string | Additional action to perform. Currently supported actions are: `flush`, `reset_admin_pass`. |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |       | Validate the new [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) but don't apply the update. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) with updated fields in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "replication": true,
+    "data_persistence": "aof"
+}
+```
+
+The above request attempts to modify a database configuration to enable in-memory data replication and append-only file data persistence.
+
+{{<note>}}
+To change the shard hashing policy, you must flush all keys from the database.
+{{</note>}}
+
+### Response {#put-response-action}
+
+If the request succeeds, the response body returns the updated [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}). If an error occurs, the response body may include an error code and message with more details.
+
+#### Status codes {#put-status-codes-action}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'active-change-pending' until the request has been fully processed. |
+| [403&nbsp;Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | redislabs license expired. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a nonexistent database. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Attempting to change a database while it is busy with another configuration change. In this context, this is a temporary condition, and the request should be reattempted later. |
+
+#### Error codes {#put-error-codes-action}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| rack_awareness_violation | • Non rack-aware cluster.<br />• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed.|
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| insufficient_resources | Shards count exceeds shards limit per bdb. |
+| not_supported_action_on_crdt | `reset_admin_pass` action is not allowed on CRDT enabled BDB. |
+| name_violation | CRDT database name cannot be changed. |
+| bad_shards_blueprint | The sharding blueprint is broken or doesn’t fit the BDB. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| replication_node_violation | Not enough nodes for replication. |
+| replication_size_violation | Database limit too small for replication. |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| crdt_sharding_violation | CRDB created without sharding cannot be changed to use sharding
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+## Create database v1 {#post-bdbs-v1}
+
+```sh
+POST /v1/bdbs
+```
+Create a new database in the cluster.
+
+The request must contain a single JSON [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) with the configuration parameters for the new database.
+
+The following parameters are required to create the database:
+
+| Parameter | Type/Value | Description |
+|----------|------------|-------------|
+| name     | string     | Name of the new database |
+| memory_size | integer | Size of the database, in bytes |
+
+If passed with the `dry_run` URL query string, the function will validate the [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}), but will not invoke the state machine that will create it.
+
+To track this request's progress, poll the [`/actions/<action_uid>` endpoint]({{< relref "/operate/rs/references/rest-api/requests/bdbs/actions" >}}) with the `action_uid` returned in the response body.
+
+The cluster will use default configuration for any missing database field. The cluster creates a database UID if it is missing.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_bdb]({{< relref "/operate/rs/references/rest-api/permissions#create_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#post-request-v1}
+
+#### Example HTTP request
+
+```sh
+POST /v1/bdbs
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run |    | Validate the new [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) but don't create the database. |
+
+#### Body
+
+Include a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) in the request body.
+
+The following parameters are required to create the database:
+
+| Paramter | Type/Value | Description |
+|----------|------------|-------------|
+| name     | string     | Name of the new database |
+| memory_size | integer | Size of the database, in bytes |
+
+The `uid` of the database is auto-assigned by the cluster because it was not explicitly listed in this request. If you specify the database ID (`uid`), then you must specify the database ID for every subsequent database and make sure that the database ID does not conflict with an existing database. If you do not specify the database ID, then the it is automatically assigned in sequential order.
+
+Defaults are used for all other configuration parameters.
+
+#### Example JSON body
+
+```json
+{
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824
+}
+```
+
+The above request is an attempt to create a Redis database with a user-specified name and a memory limit of 1GB.
+
+### Response {#post-response-v1}
+
+The response includes the newly created [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824,
+    "// additional fields..."
+}
+```
+
+#### Error codes {#post-error-codes-v1}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| uid_exists | The specified database UID is already in use. |
+| missing_db_name | DB name is a required property. |
+| missing_memory_size | Memory Size is a required property. |
+| missing_module | Modules missing from the cluster. |
+| port_unavailable | The specified database port is reserved or already in use. |
+| invalid_sharding | Invalid sharding configuration was specified. |
+| bad_shards_blueprint | The sharding blueprint is broken. |
+| not_rack_aware | Cluster is not rack-aware and a rack-aware database was requested. |
+| invalid_version | An invalid database version was requested. |
+| busy | The request failed because another request is being processed at the same time on the same database. |
+| invalid_data_persistence | Invalid data persistence configuration. |
+| invalid_proxy_policy | Invalid proxy_policy value. |
+| invalid_sasl_credentials | SASL credentials are missing or invalid. |
+| invalid_replication | Not enough nodes to perform replication. |
+| insufficient_resources | Not enough resources in cluster to host the database. |
+| rack_awareness_violation | • Rack awareness violation.<br/>• Not enough nodes in unique racks. |
+| invalid_certificate | SSL client certificate is missing or malformed. |
+| certificate_expired | SSL client certificate has expired. |
+| duplicated_certs | An SSL client certificate appears more than once. |
+| replication_violation | CRDT database must use replication. |
+| eviction_policy_violation | LFU eviction policy is not supported on bdb version<4 |
+| invalid_oss_cluster_configuration | BDB configuration does not meet the requirements for OSS cluster mode |
+| memcached_cannot_use_modules | Cannot create a memcached database with modules. |
+| missing_backup_interval | BDB backup is enabled but backup interval is missing. |
+| wrong_cluster_state_id | The given CLUSTER-STATE-ID does not match the current one
+| invalid_bdb_tags | Tag objects with the same key parameter were passed. |
+| unsupported_module_capabilities | Not all modules configured for the database support the capabilities needed for the database configuration. |
+| redis_acl_unsupported | Redis ACL is not supported for this database. |
+
+#### Status codes {#post-status-codes-v1}
+
+| Code | Description |
+|------|-------------|
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | redislabs license expired. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Database with the same UID already exists. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid configuration parameters provided. |
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, database is being created. |
+
+## Create database v2 {#post-bdbs-v2}
+
+```sh
+POST /v2/bdbs
+```
+Create a new database in the cluster. See [`POST /v1/bdbs`]({{< relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1" >}}) for more information.
+
+The database's configuration should be under the "bdb" field.
+
+This endpoint allows you to specify a recovery_plan to recover a database. If you include a recovery_plan within the request body, the database will be loaded from the persistence files according to the recovery plan. The recovery plan must match the number of shards requested for the database.
+
+The persistence files must exist in the locations specified by the recovery plan. The persistence files must belong to a database with the same shard settings as the one being created (slot range distribution and shard_key_regex); otherwise, the operation will fail or yield unpredictable results.
+
+If you create a database with a shards_blueprint and a recovery plan, the shard placement may not fully follow the shards_blueprint.
+
+### Request {#post-request-v2}
+
+#### Example HTTP request
+
+```sh
+POST /v2/bdbs
+```
+
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+| Content-type | application/json |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| dry_run |    | Validate the new [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) but don't create the database. |
+
+#### Body
+
+Include a JSON object that contains a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) and an optional `recovery_plan` object in the request body.
+
+##### Example JSON body
+
+```json
+{
+    "bdb": {
+        "name": "test-database",
+        "type": "redis",
+        "memory_size": 1073741824,
+        "shards_count": 1
+    },
+    "recovery_plan": {
+        "data_files": [
+            {
+                "shard_slots": "0-16383",
+                "node_uid": "1",
+                "filename": "redis-4.rdb"
+            }
+        ]
+    }
+}
+```
+
+### Response {#post-response-v2}
+
+The response includes the newly created [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "test-database",
+    "type": "redis",
+    "memory_size": 1073741824,
+    "shards_count": 1,
+    "// additional fields..."
+}
+```
+
+## Delete database {#delete-bdbs}
+
+```sh
+DELETE /v1/bdbs/{int: uid}
+```
+Delete an active database.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_bdb]({{< relref "/operate/rs/references/rest-api/permissions#delete_bdb" >}}) | admin<br />cluster_member<br />db_member |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/bdbs/1
+```
+#### Headers
+
+| Key | Value |
+|-----|-------|
+| Host | The domain name or IP of the cluster |
+| Accept | application/json |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database to delete. |
+
+### Response {#delete-response}
+
+Returns a status code that indicates the database deletion success or failure.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request is accepted and is being processed. The database state will be 'delete-pending' until the request has been fully processed. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Attempting to delete an internal database. |
+| [404&nbsp;Not&nbsp;Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent database. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | Either the database is not in 'active' state and cannot be deleted, or it is busy with another configuration change. In the second case, this is a temporary condition, and the request should be re-attempted later. |
+---
+Title: Database CRDT sources alerts requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Conflict-free replicated data type (CRDT) source alert requests
+headerRange: '[1-2]'
+linkTitle: crdt_sources/alerts
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-bdbs-crdt-sources-alerts) | `/v1/bdbs/crdt_sources/alerts` | Get all CRDT sources alert states for all CRDB databases |
+| [GET](#get-bdbs-crdt-sources-alerts) | `/v1/bdbs/crdt_sources/alerts/{uid}` | Get all CRDT sources alert states for a database |
+| [GET](#get-bdbs-crdt-source-all-alerts) | `/v1/bdbs/crdt_sources/alerts/{uid}/{crdt_src_id}` | Get all alert states for a CRDT source |
+| [GET](#get-bdbs-crdt-source-alert) | `/v1/bdbs/crdt_sources/alerts/{uid}/{crdt_src_id}/{alert}` | Get a database alert state |
+
+## Get all CRDB CRDT source alert states {#get-all-bdbs-crdt-sources-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts
+
+Get all alert states for all CRDT sources of all CRDBs.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_bdbs_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_all_bdbs_alerts" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a hash of alert UIDs and the [alerts states]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) for each local BDB of CRDB.
+
+#### Example JSON body
+
+```json
+{
+    "1": {
+        "crdt_src_syncer_connection_error": {
+            "enabled": true,
+            "state": true,
+            "threshold": "80",
+            "change_time": "2014-08-29T11:19:49Z",
+            "severity": "WARNING",
+            "change_value": {
+                "state": true,
+                "threshold": "80",
+                "memory_util": 81.2
+            }
+        },
+        "..."
+    },
+    "..."
+}
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get all BDB CRDT sources alert states {#get-bdbs-crdt-sources-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}
+
+Get all alert states for all crdt sources for a specific local bdb of a CRDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-all-crdt-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+
+### Response {#get-response-all-crdt-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states.
+
+#### Example JSON body
+
+```json
+{
+    "crdt_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-all-crdt-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get all CRDT source alert states {#get-bdbs-crdt-source-all-alerts}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}/{int: crdt_src_id}
+
+Get all alert states for specific crdt source for a specific local BDB
+of a CRDB.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-crdt-alerts} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1/2 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| crdt_src_id | integer | The ID of the crdt source in this BDB |
+
+### Response {#get-response-crdt-alerts} 
+
+Returns a hash of [alert objects]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}) and their states. 
+
+#### Example JSON body
+
+```json
+{
+    "crdt_src_syncer_connection_error": {
+        "enabled": true,
+        "state": true,
+        "threshold": "80",
+        "severity": "WARNING",
+        "change_time": "2014-08-29T11:19:49Z",
+        "change_value": {
+            "state": true,
+            "threshold": "80",
+            "memory_util": 81.2
+        }
+    },
+    "..."
+}
+```
+
+### Status codes {#get-status-codes-crdt-alerts} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified bdb does not exist |
+
+## Get database alert state {#get-bdbs-crdt-source-alert}
+
+	GET /v1/bdbs/crdt_sources/alerts/{int: uid}/{int: crdt_src_id}/{alert}
+
+Get a BDB alert state.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_bdb_alerts]({{< relref "/operate/rs/references/rest-api/permissions#view_bdb_alerts" >}}) |
+
+### Request {#get-request-alert} 
+
+#### Example HTTP request
+
+	GET /v1/bdbs/crdt_sources/alerts/1/2/crdt_src_syncer_connection_error 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the database |
+| crdt_src_id | integer | The ID of the crdt source in this BDB |
+| alert | string | The alert name |
+
+### Response {#get-response-alert} 
+
+Returns an [alert object]({{< relref "/operate/rs/references/rest-api/objects/alert" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "enabled": true,
+    "state": true,
+    "threshold": "80",
+    "severity": "WARNING",
+    "change_time": "2014-08-29T11:19:49Z",
+    "change_value": {
+        "state": true,
+        "threshold": "80",
+        "memory_util": 81.2
+    }
+}
+```
+
+### Status codes {#get-status-codes-alert} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad request |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Specified alert or bdb does not exist |
+---
+Title: CRDB flush requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Flush Active-Active database requests
+headerRange: '[1-2]'
+linkTitle: flush
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-crdbs-flush) | `/v1/crdbs/{crdb_guid}/flush` | Flush an Active-Active database |
+
+## Flush an Active-Active database {#put-crdbs-flush}
+
+```sh
+PUT /v1/crdbs/{crdb_guid}/flush
+```
+
+Flush an Active-Active database.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79/flush
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+### Response {#put-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Configuration cannot be accepted, typically because it was already committed. |
+---
+Title: CRDB health report requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database health report requests
+headerRange: '[1-2]'
+linkTitle: health_report
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-crdbs-health) | `/v1/crdbs/{crdb_guid}/health_report` | Get a health report for an Active-Active database |
+
+## Get health report {#get-crdbs-health}
+
+	GET /v1/crdbs/{crdb_guid}/health_report
+
+Get a health report for an Active-Active database.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/crdbs/{crdb_guid}/health_report
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instance_id | integer | The request retrieves information from the specified Active-Active database instance. If this instance doesn’t exist, the request retrieves information from all instances. (optional) |
+
+### Response {#get-response} 
+
+Returns a JSON array of [CRDB health report objects]({{< relref "/operate/rs/references/rest-api/objects/crdb/health_report" >}}).
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+---
+Title: CRDB purge requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Purge removed Active-Active database requests
+headerRange: '[1-2]'
+linkTitle: purge
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [PUT](#put-crdbs-purge) | `/v1/crdbs/{crdb_guid}/purge` | Purge data from an instance that was forcibly removed from the Active-Active database |
+
+## Purge data from removed instance {#put-crdbs-purge}
+
+	PUT /v1/crdbs/{crdb_guid}/purge
+
+Purge the data from an instance that was removed from the
+Active-Active database by force.
+
+When you force the removal of an instance from an Active-Active
+database, the removed instance keeps the data and configuration
+according to the last successful synchronization.
+
+To delete the data and configuration from the forcefully removed
+instance you must use this API (Must be executed locally on the
+removed instance).
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+    PUT /v1/crdbs/1/purge
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instances | array of integers | Array of unique instance IDs |
+
+### Response {#put-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration, instance, or Active-Active database not found. |
+---
+Title: CRDB updates requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Update Active-Active configuration requests
+headerRange: '[1-2]'
+linkTitle: updates
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-crdbs-updates) | `/v1/crdbs/{crdb_guid}/updates` | Modify Active-Active confgurarion |
+
+## Modify Active-Active configuration {#post-crdbs-updates}
+
+	POST /v1/crdbs/{crdb_guid}/updates
+
+Modify Active-Active configuration.
+
+{{<warning>}}
+This is a very powerful API request and can cause damage if used incorrectly.
+{{</warning>}}
+
+In order to add or remove instances, you must use this API. For simple configuration updates, it is recommended to use PATCH on /crdbs/{crdb_guid} instead.
+
+Updating default_db_config affects both existing and new instances that may be added.
+
+When you update db_config, it changes the configuration of the database that you specify. This field overrides corresponding fields (if any) in default_db_config.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+    POST /v1/crdbs/1/updates
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+Include a [CRDB modify_request object]({{< relref "/operate/rs/references/rest-api/objects/crdb/modify_request" >}}) with updated fields in the request body.
+
+### Response {#post-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The posted Active-Active database contains invalid parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration, instance or Active-Active database not found. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+---
+Title: CRDBs requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: crdbs
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-crdbs) | `/v1/crdbs` | Get all Active-Active databases |
+| [GET](#get-crdb) | `/v1/crdbs/{crdb_guid}` | Get a specific Active-Active database |
+| [PATCH](#patch-crdbs) | `/v1/crdbs/{crdb_guid}` | Update an Active-Active database |
+| [POST](#post-crdb) | `/v1/crdbs` | Create a new Active-Active database |
+| [DELETE](#delete-crdb) | `/v1/crdbs/{crdb_guid}` | Delete an Active-Active database |
+
+## Get all Active-Active databases {#get-all-crdbs}
+
+```sh
+GET /v1/crdbs
+```
+
+Get a list of all Active-Active databases on the cluster.
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/crdbs
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [CRDB objects]({{< relref "/operate/rs/references/rest-api/objects/crdb" >}}).
+
+##### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | A list of Active-Active database. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+
+## Get an Active-Active database {#get-crdb}
+
+```sh
+GET /v1/crdbs/{crdb_guid}
+```
+
+Get a specific Active-Active database.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+ GET /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| instance_id | integer | Instance from which to get the Active-Active database information |
+
+### Response {#get-response}
+
+Returns a [CRDB object]({{< relref "/operate/rs/references/rest-api/objects/crdb" >}}).
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Active-Active database information is returned. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Database or configuration does not exist. |
+
+## Update an Active-Active database {#patch-crdbs}
+
+```sh
+PATCH /v1/crdbs/{crdb_guid}
+```
+
+Update an Active-Active database's configuration.
+
+In order to add or remove instances, use [<nobr>`POST crdbs/{crdb_guid}/updates`</nobr>]({{< relref "/operate/rs/references/rest-api/requests/crdbs/updates#post-crdbs-updates" >}}) instead.
+
+### Request {#patch-request}
+
+#### Example HTTP request
+
+```sh
+ PATCH /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+#### Request body
+
+Include a [CRDB object]({{< relref "/operate/rs/references/rest-api/objects/crdb" >}}) with updated fields in the request body.
+
+### Response {#patch-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#patch-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The posted Active-Active database contains invalid parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+
+## Create an Active-Active database {#post-crdb}
+
+```sh
+POST /v1/crdbs
+```
+
+Create a new Active-Active database.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+ POST /v1/crdbs
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### Request body
+
+Include a [CRDB object]({{< relref "/operate/rs/references/rest-api/objects/crdb" >}}), which defines the Active-Active database, in the request body.
+
+##### Example body
+
+```json
+{
+    "default_db_config":
+    {
+        "name": "sample-crdb",
+        "memory_size": 214748365
+    },
+    "instances":
+    [
+        {
+            "cluster":
+            {
+                "url": "http://<cluster1_FQDN>:9443",
+                "credentials":
+                {
+                    "username": "<username>",
+                    "password": "<password>"
+                },
+                "name": "cluster-1"
+            },
+            "compression": 6
+        },
+        {
+            "cluster":
+            {
+                "url": "http://<cluster2_FQDN>:9443",
+                "credentials":
+                {
+                    "username": "<username>",
+                    "password": "<password>"
+                },
+                "name": "cluster-2"
+            },
+            "compression": 6
+        }
+    ],
+    "name": "sample-crdb"
+}
+```
+
+This JSON body creates an Active-Active database without TLS and with two participating clusters.
+
+### Response {#post-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The request has been accepted. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request is invalid or malformed. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The posted Active-Active database cannot be accepted. |
+
+## Delete an Active-Active database {#delete-crdb}
+
+```sh
+DELETE /v1/crdbs/{crdb_guid}
+```
+
+Delete an Active-Active database.
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+ DELETE /v1/crdbs/552bbccb-99f3-4142-bd17-93d245f0bc79
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Task-ID | string | Specified task ID |
+| X-Result-TTL | integer | Time (in seconds) to keep task result |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| crdb_guid | string | Globally unique Active-Active database ID (GUID) |
+
+### Response {#delete-response}
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Action was successful. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Configuration or Active-Active database not found. |
+| [406&nbsp;Not&nbsp;Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The Active-Active GUID is invalid or the Active-Active database was already deleted. |
+---
+Title: Logs requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Cluster event logs requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: logs
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-logs) | `/v1/logs` | Get cluster events log |
+
+## Get cluster events log {#get-logs}
+
+	GET /v1/logs
+
+Get cluster events log.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_logged_events]({{< relref "/operate/rs/references/rest-api/permissions#view_logged_events" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/logs?order=desc 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| stime | ISO_8601 | Start time before which we don't want events. (optional) |
+| etime | ISO_8601 | End time after which we don't want events. (optional) |
+| order | string | desc/asc - get events in descending or ascending order. Defaults to asc. |
+| limit | integer | Maximum number of events to return. (optional) |
+| offset | integer | Skip offset events before returning first one (useful for pagination). (optional) |
+
+### Response {#get-response} 
+
+Returns a JSON array of events.
+
+#### Example JSON body
+
+```json
+[
+  {
+    "time": "2014-08-29T11:19:49Z",
+    "type": "bdb_name_updated",
+    "severity": "INFO",
+    "bdb_uid": "1",
+    "old_val": "test",
+    "new_val": "test123"
+  },
+  {
+    "time": "2014-08-29T11:18:48Z",
+    "type": "cluster_bdb_created",
+    "severity": "INFO",
+    "bdb_uid": "1",
+    "bdb_name": "test"
+  },
+  {
+    "time": "2014-08-29T11:17:49Z",
+    "type": "cluster_node_joined",
+    "severity": "INFO",
+    "node_uid": 2
+  }
+]
+```
+
+#### Event object
+
+| Field | Description |
+|-------|-------------|
+| time | Timestamp when event happened. |
+| type | Event type. Additional fields may be available for certain event types. |
+| additional fields | Additional fields may be present based on event type.|
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: JSON schema requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: API object JSON schema requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: jsonschema
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-jsonschema) | `/v1/jsonschema` | Get JSON schema of API objects |
+
+## Get object JSON schema {#get-jsonschema}
+
+	GET /v1/jsonschema
+
+Get the JSON schema of various [Redis Enterprise REST API objects]({{< relref "/operate/rs/references/rest-api/objects" >}}).
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/jsonschema?object=bdb 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| object | string | Optional. The API object name: 'cluster', 'node', 'bdb' etc. |
+
+### Response {#get-response} 
+
+Returns the JSON schema of the specified API object.
+
+#### Example JSON body
+
+```json
+{
+     "type": "object",
+     "description": "An API object that represents a managed database in the cluster.",
+     "properties": {
+          "...."
+     },
+     "...."
+}
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Invalid object. |
+---
+Title: LDAP mappings requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: LDAP mappings requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: ldap_mappings
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-ldap_mappings) | `/v1/ldap_mappings` | Get all LDAP mappings |
+| [GET](#get-ldap_mapping) | `/v1/ldap_mappings/{uid}` | Get a single LDAP mapping |
+| [PUT](#put-ldap_mapping) | `/v1/ldap_mappings/{uid}` | Update an LDAP mapping |
+| [POST](#post-ldap_mappings) | `/v1/ldap_mappings` | Create a new LDAP mapping |
+| [DELETE](#delete-ldap_mappings) | `/v1/ldap_mappings/{uid}` | Delete an LDAP mapping |
+
+## Get all LDAP mappings {#get-all-ldap_mappings}
+
+	GET /v1/ldap_mappings
+
+Get all LDAP mappings.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_all_ldap_mappings_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_ldap_mappings_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/ldap_mappings 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response} 
+
+Returns a JSON array of [LDAP mapping objects]({{< relref "/operate/rs/references/rest-api/objects/ldap_mapping" >}}).
+
+#### Example JSON body
+
+```json
+[
+  {
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+  }
+]
+```
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get LDAP mapping {#get-ldap_mapping}
+
+	GET /v1/ldap_mappings/{int: uid}
+
+Get a specific LDAP mapping.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ldap_mapping_info]({{< relref "/operate/rs/references/rest-api/permissions#view_ldap_mapping_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ldap_mappings/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The object's unique ID. |
+
+### Response {#get-response} 
+
+Returns an [LDAP mapping object]({{< relref "/operate/rs/references/rest-api/objects/ldap_mapping" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+}
+```
+
+### Error codes {#get-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| ldap_mapping_not_exist | An object does not exist| 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | ldap_mapping does not exist. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+
+## Update LDAP mapping {#put-ldap_mapping}
+
+	PUT /v1/ldap_mappings/{int: uid}
+
+Update an existing ldap_mapping object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [update_ldap_mapping]({{< relref "/operate/rs/references/rest-api/permissions#update_ldap_mapping" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/ldap_mappings/17 
+
+#### Example JSON body
+
+```json
+{
+    "dn": "OU=ops,DC=redislabs,DC=com",
+    "email": "ops@redislabs.com",
+    "email_alerts": true,
+    "bdbs_email_alerts": ["1","2"],
+    "cluster_email_alerts": true
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP mapping object]({{< relref "/operate/rs/references/rest-api/objects/ldap_mapping" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops,DC=redislabs,DC=com",
+     "email": "ops@redislabs.com",
+     "role_uids": ["1"],
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "cluster_email_alerts": true
+}
+```
+
+### Error codes {#put-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| name_already_exists | An object of the same type and name exists| 
+| ldap_mapping_not_exist | An object does not exist| 
+| invalid_dn_param | A dn parameter has an illegal value| 
+| invalid_name_param | A name parameter has an illegal value| 
+| invalid_role_uids_param | A role_uids parameter has an illegal value| 
+| invalid_account_id_param | An account_id parameter has an illegal value| 
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, LDAP mapping is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existing LDAP mapping. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mapping yet. |
+
+## Create LDAP mapping {#post-ldap_mappings}
+
+	POST /v1/ldap_mappings
+
+Create a new LDAP mapping.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [create_ldap_mapping]({{< relref "/operate/rs/references/rest-api/permissions#create_ldap_mapping" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/ldap_mappings 
+
+#### Example JSON body
+
+```json
+{
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+Include an [LDAP mapping object]({{< relref "/operate/rs/references/rest-api/objects/ldap_mapping" >}}) in the request body.
+
+### Response {#post-response} 
+
+#### Example JSON body
+
+```json
+{
+     "uid": 17,
+     "name": "Admins",
+     "dn": "OU=ops.group,DC=redislabs,DC=com",
+     "email": "ops.group@redislabs.com",
+     "role_uids": ["1"]
+}
+```
+
+### Error codes {#post-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| name_already_exists | An object of the same type and name exists| 
+| missing_field | A needed field is missing| 
+| invalid_dn_param | A dn parameter has an illegal value| 
+| invalid_name_param | A name parameter has an illegal value| 
+| invalid_role_uids_param | A role_uids parameter has an illegal value| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, an LDAP-mapping object is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+
+## Delete LDAP mapping {#delete-ldap_mappings}
+
+	DELETE /v1/ldap_mappings/{int: uid}
+
+Delete an LDAP mapping object.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [delete_ldap_mapping]({{< relref "/operate/rs/references/rest-api/permissions#delete_ldap_mapping" >}}) |
+
+### Request {#delete-request} 
+
+#### Example HTTP request
+
+	DELETE /v1/ldap_mappings/1 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The ldap_mapping unique ID. |
+
+### Response {#delete-response} 
+
+Returns a status code. If an error occurs, the response body may include a more specific error code and message.
+
+### Error codes {#delete-error-codes} 
+
+Possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| unsupported_resource | The cluster is not yet able to handle this resource type. This could happen in a partially upgraded cluster, where some of the nodes are still on a previous version.| 
+| ldap_mapping_not_exist | An object does not exist| 
+
+### Status codes {#delete-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the ldap_mapping is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+| [501 Not Implemented](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.2) | Cluster doesn't support LDAP mappings yet. |
+---
+Title: All nodes database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/all/bdb requests.
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo-bdb) | `/v1/debuginfo/all/bdb/{bdb_uid}` | Get debug info for a database from all nodes |
+
+## Get database debug info for all nodes {#get-all-debuginfo-bdb}
+
+	GET /v1/debuginfo/all/bdb/{int: bdb_uid}
+
+Downloads a tar file that contains debug info for the specified database (`bdb_uid`) from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/all/bdb/1 
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: All nodes debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/all requests.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: all
+weight: $weight
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/cluster/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-debuginfo) | `/v1/debuginfo/all` | Get debug info for all nodes |
+
+## Get debug info for all nodes {#get-all-debuginfo}
+
+	GET /v1/debuginfo/all
+
+Downloads a tar file that contains debug info from all nodes.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-all-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/all 
+
+### Response {#get-all-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info for all nodes.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-all-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Current node database debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/node/bdb requests.
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-node-bdb) | `/v1/debuginfo/node/bdb/{bdb_uid}` | Get debug info for the current node regarding a specific database |
+
+## Get database debug info for current node {#get-debuginfo-node-bdb}
+
+	GET /v1/debuginfo/node/bdb/{int: bdb_uid}
+
+Downloads a tar file that contains debug info for the specified database (`bdb_uid`) from the current node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/node/bdb/1 
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Current node debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the Redis Enterprise Software REST API debuginfo/node requests.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: node
+weight: $weight
+---
+
+{{<banner-article>}}
+This REST API path is deprecated as of Redis Enterprise Software version 7.4.2. Use the new path [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/nodes/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-debuginfo-node) | `/v1/debuginfo/node` | Get debug info for the current node |
+
+## Get debug info for current node {#get-debuginfo-node}
+
+	GET /v1/debuginfo/node
+
+Downloads a tar file that contains debug info for the current node.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_debugging_info]({{< relref "/operate/rs/references/rest-api/permissions#view_debugging_info" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/debuginfo/node 
+
+### Response {#get-response} 
+
+Downloads the debug info in a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+#### Response headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Content-Type | application/x-gzip | Media type of request/response body |
+| Content-Length | 653350 | Length of the response body in octets |
+| Content-Disposition | attachment; filename=debuginfo.tar.gz | Display response in browser or download as attachment |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get debug info. |
+---
+Title: Debug info requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Debug info requests
+hideListLinks: true
+linkTitle: debuginfo
+weight: $weight
+---
+
+{{<banner-article>}}
+These REST API paths are deprecated as of Redis Enterprise Software version 7.4.2. Use the new paths [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/cluster/debuginfo" >}}), [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/nodes/debuginfo" >}}), and [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+{{</banner-article>}}
+
+Downloads a support package, which includes logs and information about the cluster, nodes, databases, and shards, as a tar file called `filename.tar.gz`. Extract the files from the tar file to access the debug info.
+
+## Get debug info for all nodes in the cluster
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./all#get-all-debuginfo" >}}) | `/v1/debuginfo/all` | Gets debug info for all nodes |
+| [GET]({{< relref "./all/bdb#get-all-debuginfo-bdb" >}}) | `/v1/debuginfo/all/bdb/{bdb_uid}` | Gets debug info for a database from all nodes |
+
+## Get debug info for the current node
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET]({{< relref "./node#get-debuginfo-node" >}}) | `/v1/debuginfo/node` | Gets debug info for the current node |
+| [GET]({{< relref "./node/bdb#get-debuginfo-node-bdb" >}}) | `/v1/debuginfo/node/bdb/{bdb_uid}` | Gets debug info for a database from the current node |
+---
+Title: Job scheduler requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for the job scheduler
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: job_scheduler
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-job-scheduler) | `/v1/job_scheduler` | Get job scheduler settings |
+| [PUT](#put-job-scheduler) | `/v1/job_scheduler` | Update job scheduler settings |
+
+## Get job scheduler settings {#get-job-scheduler}
+
+```sh
+GET /v1/job_scheduler
+```
+
+Get job scheduler information.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/job_scheduler
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+Returns a [job_scheduler object]({{<relref "/operate/rs/references/rest-api/objects/job_scheduler">}}).
+
+#### Example JSON body
+
+```json
+{
+  "backup_job_settings": {
+    "cron_expression": "*/5 * * * *",
+    "enabled": true
+  },
+  "bdb_usage_report_job_settings": {
+    "cron_expression": "0 */1 * * *",
+    "enabled": false,
+    "file_retention_days": 365
+  },
+  "cert_rotation_job_settings": {
+    "cron_expression": "0 * * * *",
+    "enabled": true,
+    "expiry_days_before_rotation": 60
+  },
+  "log_rotation_job_settings": {
+    "cron_expression": "*/5 * * * *",
+    "enabled": true
+  },
+  "node_checks_job_settings": {
+    "cron_expression": "0 * * * *",
+    "enabled": true
+  },
+  "redis_cleanup_job_settings": {
+    "cron_expression": "0 * * * *"
+  },
+  "rotate_ccs_job_settings": {
+    "cron_expression": "*/5 * * * *",
+    "enabled": true,
+    "file_suffix": "5min",
+    "rotate_max_num": 24
+  }
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+
+## Update job scheduler settings {#put-job-scheduler}
+
+```sh
+PUT /v1/job_scheduler
+```
+
+Update job scheduler settings.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/job_scheduler
+```
+
+#### Example JSON body
+
+```json
+{
+   "backup_job_settings": {
+     "cron_expression": "*/10 * * * *"
+   }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Body
+
+Include a [job_scheduler object]({{<relref "/operate/rs/references/rest-api/objects/job_scheduler">}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns a [job_scheduler object]({{<relref "/operate/rs/references/rest-api/objects/job_scheduler">}}) with the updated fields.
+
+#### Example JSON body
+
+```json
+{
+    "backup_job_settings": {
+        "cron_expression": "*/10 * * * *",
+        "enabled": true
+    },
+    "bdb_usage_report_job_settings": {
+        "cron_expression": "0 */1 * * *",
+        "enabled": false,
+        "file_retention_days": 365
+    },
+    "cert_rotation_job_settings": {
+        "cron_expression": "0 * * * *",
+        "enabled": true,
+        "expiry_days_before_rotation": 60
+    },
+    "log_rotation_job_settings": {
+        "cron_expression": "*/5 * * * *",
+        "enabled": true
+    },
+    "node_checks_job_settings": {
+        "cron_expression": "0 * * * *",
+        "enabled": true
+    },
+    "rotate_ccs_job_settings": {
+        "cron_expression": "*/5 * * * *",
+        "enabled": true,
+        "file_suffix": "5min",
+        "rotate_max_num": 24
+    }
+}
+```
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Bad content provided. |
+| [409 Conflict](https://www.rfc-editor.org/rfc/rfc9110.html#name-409-conflict) | Attempting to configure the job_scheduler while it is busy with another configuration change. In this context, this is a temporary condition and the request should be re-attempted later. |
+---
+Title: Refresh JWT requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Refresh JW token requests
+headerRange: '[1-2]'
+linkTitle: refresh_jwt
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-refresh_jwt) | `/v1/users/refresh_jwt` | Get a new authentication token |
+
+## Get a new authentication token {#post-refresh_jwt}
+
+    POST /v1/users/refresh_jwt
+
+Generate a new JSON Web Token (JWT) for authentication.
+
+Takes a valid token and returns the new token generated by the request.
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/users/refresh_jwt 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Authorization | JWT eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.<br></br>eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJ<br></br>leHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0e<br></br>dFzcLElMOHsshaqQk2HUNgdsUKxMU | Valid JSON Web Token (JWT) |
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| ttl | integer | Time to live - The amount of time in seconds the token will be valid (optional) |
+
+### Response {#post-response} 
+
+Returns a JSON object that contains the generated access token.
+
+#### Example JSON body
+
+```json
+ {
+     "access_token": "eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJleHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0edFzcLElMOHsshaqQk2HUNgdsUKxMU"
+ }
+```
+
+
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | A new token is given. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The token is invalid or password has expired. |
+---
+Title: User password requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: User password requests
+headerRange: '[1-2]'
+linkTitle: password
+weight: $weight
+---
+
+| Method                     | Path                 | Description                 |
+|----------------------------|----------------------|-----------------------------|
+| [PUT](#update-password)    | `/v1/users/password` | Change an existing password |
+| [POST](#add-password)      | `/v1/users/password` | Add a new password          |
+| [DELETE](#delete-password) | `/v1/users/password` | Delete a password           |
+
+## Update password {#update-password}
+    
+    PUT /v1/users/password
+    
+Reset the password list of an internal user to include a new password.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+    PUT /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "a password that exists in the current list",
+      "new_password": "the new (single) password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON object with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username     | string | Affected user (required) |
+| old_password | string | A password that exists in the current list (required) |
+| new_password | string | The new password (required) |
+
+### Response {#put-response}
+
+Returns a status code to indicate password update success or failure.
+
+### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only work when the password_complexity feature is enabled). |
+| new_password_same_as_current | The given new password is identical to one of the already existing passwords. |
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, password changed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to reset password to a non-existing user. |
+
+## Add password {#add-password}
+
+    POST /v1/users/password
+
+Add a new password to an internal user's passwords list.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "an existing password",
+      "new_password": "a password to add"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON object with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username     | string | Affected user (required) |
+| old_password | string | A password that exists in the current list (required) |
+| new_password | string | The new (single) password (required) |
+
+### Response {#post-response}
+
+Returns a status code to indicate password creation success or failure. If an error occurs, the response body may include a more specific error code and message.
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only work when the password_complexity feature is enabled). |
+| new_password_same_as_current | The given new password is identical to one of the already existing passwords. |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, new password was added to the list of valid passwords. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to add a password to a non-existing user. |
+
+## Delete password {#delete-password}
+    DELETE /v1/users/password
+
+Delete a password from an internal user's passwords list.
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+    DELETE /v1/users/password
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "johnsmith",
+      "old_password": "an existing password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+The request must contain a single JSON with the following fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| username | string | Affected user (required) |
+| old_password | string | Existing password to be deleted (required) |
+
+### Response {#delete-response}
+
+### Error codes {#delete-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| cannot_delete_last_password | Cannot delete the last password of a user |
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, new password was deleted from the list of valid passwords. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing parameters. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a password to a non-existing user. |
+---
+Title: Users requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: User requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: users
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-users) | `/v1/users` | Get all users |
+| [GET](#get-user) | `/v1/users/{uid}` | Get a single user |
+| [PUT](#put-user) | `/v1/users/{uid}` | Update a user's configuration |
+| [POST](#post-user) | `/v1/users` | Create a new user |
+| [DELETE](#delete-user) | `/v1/users/{uid}` | Delete a user |
+
+## Get all users {#get-all-users}
+
+```sh
+GET /v1/users
+```
+
+Get a list of all users.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_users_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_users_info" >}}) | admin<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/users
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [user objects]({{< relref "/operate/rs/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+        "uid": 1,
+        "password_issue_date": "2017-03-02T09:43:34Z",
+        "email": "user@example.com",
+        "name": "John Doe",
+        "email_alerts": true,
+        "bdbs_email_alerts": ["1","2"],
+        "role": "admin",
+        "auth_method": "regular",
+        "status": "active"
+    },
+    {
+        "uid": 2,
+        "password_issue_date": "2017-03-02T09:43:34Z",
+        "email": "user2@example.com",
+        "name": "Jane Poe",
+        "email_alerts": true,
+        "role": "db_viewer",
+        "auth_method": "regular",
+        "status": "active"
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get user {#get-user}
+
+```sh
+GET /v1/users/{int: uid}
+```
+
+Get a single user's details.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_user_info]({{< relref "/operate/rs/references/rest-api/permissions#view_user_info" >}}) | admin<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/users/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+### Response {#get-response}
+
+Returns a [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}) that contains the details for the specified user ID.
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "password_issue_date": "2017-03-07T15:11:08Z",
+    "role": "db_viewer",
+    "email_alerts": true,
+    "bdbs_email_alerts": ["1","2"],
+    "email": "user@example.com",
+    "name": "John Doe",
+    "auth_method": "regular",
+    "status": "active"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success. |
+| [403 Forbidden](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.4) | Operation is forbidden. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | User does not exist. |
+
+## Update user {#put-user}
+
+```sh
+PUT /v1/users/{int: uid}
+```
+
+Update an existing user's configuration.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_user]({{< relref "/operate/rs/references/rest-api/permissions#update_user" >}}) | admin<br />user_manager |
+
+Any user can change their own name, password, or alert preferences.
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/users/1
+```
+
+#### Example JSON body
+
+```json
+{
+     "email_alerts": false,
+     "role_uids": [ 2, 4 ]
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the updated [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}) but don't apply the update. |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+
+#### Request body
+
+Include a [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns the updated [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "password_issue_date": "2017-03-07T15:11:08Z",
+     "email": "user@example.com",
+     "name": "Jane Poe",
+     "email_alerts": false,
+     "role": "db_viewer",
+     "role_uids": [ 2, 4 ],
+     "auth_method": "regular"
+}
+```
+
+{{<note>}}
+For [RBAC-enabled clusters]({{< relref "/operate/rs/security/access-control" >}}), the returned user details include `role_uids` instead of `role`.
+{{</note>}}
+
+### Error codes {#put-error-codes}
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only works when the password_complexity feature is enabled).|
+| new_password_same_as_current | The given new password is identical to the old password.|
+| email_already_exists | The given email is already taken.|
+| change_last_admin_role_not_allowed | At least one user with admin role should exist.|
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the user is updated. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to change a non-existing user. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+
+## Create user {#post-user}
+
+```sh
+POST /v1/users
+```
+
+Create a new user.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [create_new_user]({{< relref "/operate/rs/references/rest-api/permissions#create_new_user" >}}) | admin<br />user_manager |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/users
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Query parameters
+
+| Field   | Type | Description |
+|---------|------|---------------|
+| dry_run |  | Validate the new [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}) but don't apply the update. |
+
+#### Body
+
+Include a single [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}) in the request body. The user object must have an email, password, and role.
+
+{{<note>}}
+For [RBAC-enabled clusters]({{< relref "/operate/rs/security/access-control" >}}), use `role_uids` instead of `role` in the request body.
+{{</note>}}
+
+`email_alerts` can be configured either as:
+
+- `true` - user will receive alerts for all databases configured in `bdbs_email_alerts`. The user will receive alerts for all databases by default if `bdbs_email_alerts` is not configured. `bdbs_email_alerts` can be a list of database UIDs or `[‘all’]` meaning all databases.
+
+- `false` - user will not receive alerts for any databases
+
+##### Example JSON body
+
+```json
+{
+     "email": "newuser@example.com",
+     "password": "my-password",
+     "name": "Pat Doe",
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "role_uids": [ 3, 4 ],
+     "auth_method": "regular"
+}
+```
+
+### Response {#post-response}
+
+Returns the newly created [user object]({{< relref "/operate/rs/references/rest-api/objects/user" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "password_issue_date": "2017-03-07T15:11:08Z",
+     "email": "newuser@example.com",
+     "name": "Pat Doe",
+     "email_alerts": true,
+     "bdbs_email_alerts": ["1","2"],
+     "role": "db_viewer",
+     "role_uids": [ 3, 4 ],
+     "auth_method": "regular"
+}
+```
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information.
+
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_not_complex | The given password is not complex enough (Only works when the password_complexity feature is enabled).|
+| email_already_exists | The given email is already taken.|
+| name_already_exists | The given name is already taken.|
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, user is created. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [409 Conflict](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.10) | User with the same email already exists. |
+
+### Examples
+
+#### cURL
+
+```sh
+$ curl -k -X POST -u '[username]:[password]' \
+       -H 'Content-Type: application/json' \
+       -d '{ "email": "newuser@example.com", \
+           "password": "my-password", \
+           "name": "Pat Doe", \
+           "email_alerts": true, \
+           "bdbs_email_alerts": ["1","2"], \
+           "role_uids": [ 3, 4 ], \
+           "auth_method": "regular" }' \
+       'https://[host][:port]/v1/users'
+```
+
+#### Python
+
+```python
+import requests
+import json
+
+url = "https://[host][:port]/v1/users"
+auth = ("[username]", "[password]")
+
+payload = json.dumps({
+  "email": "newuser@example.com",
+  "password": "my-password",
+  "name": "Pat Doe",
+  "email_alerts": True,
+  "bdbs_email_alerts": [
+    "1",
+    "2"
+  ],
+  "role_uids": [
+    3,
+    4
+  ],
+  "auth_method": "regular"
+})
+
+headers = {
+  'Content-Type': 'application/json'
+}
+
+response = requests.request("POST", url, auth=auth, headers=headers, data=payload, verify=False)
+
+print(response.text)
+```
+
+## Delete user {#delete-user}
+
+```sh
+DELETE /v1/users/{int: uid}
+```
+
+Delete a user.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [delete_user]({{< relref "/operate/rs/references/rest-api/permissions#delete_user" >}}) | admin<br />user_manager |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/users/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The user's unique ID |
+
+### Response {#delete-response}
+
+Returns a status code to indicate the success or failure of the user deletion.
+
+### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the user is deleted. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+---
+Title: Authorize user requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Users authorization requests
+headerRange: '[1-2]'
+linkTitle: authorize
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-authorize) | `/v1/users/authorize` | Authorize a user |
+
+## Authorize user {#post-authorize}
+
+    POST /v1/users/authorize
+
+Generate a JSON Web Token (JWT) for a user to use as authorization to access the REST API.
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+    POST /v1/users/authorize
+
+#### Example JSON body
+
+  ```json
+  {
+      "username": "user@redislabs.com",
+      "password": "my_password"
+  }
+  ```
+
+#### Request headers
+| Key    | Value            | Description         |
+|--------|------------------|---------------------|
+| Host   | cnm.cluster.fqdn | Domain name         |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include a [JWT authorize object]({{< relref "/operate/rs/references/rest-api/objects/jwt_authorize" >}}) with a valid username and password in the request body.
+
+### Response {#post-response}
+
+Returns a JSON object that contains the generated access token.
+
+#### Example JSON body
+
+  ```json
+  {
+      "access_token": "eyJ5bGciOiKIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpYXViOjE0NjU0NzU0ODYsInVpZFI1IjEiLCJleHAiOjE0NjU0Nz30OTZ9.2xYXumd1rDoE0edFzcLElMOHsshaqQk2HUNgdsUKxMU"
+  }
+  ```
+
+### Error codes {#post-error-codes}
+
+When errors are reported, the server may return a JSON object with
+`error_code` and `message` fields that provide additional information.
+The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| password_expired | The password has expired and must be changed. |
+
+### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | The user is authorized. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | The request could not be understood by the server due to malformed syntax. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | The user is unauthorized. |---
+Title: Endpoints stats requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Endpoint statistics requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: endpoints/stats
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-endpoints-stats) | `/v1/endpoints/stats` | Get stats for all endpoints |
+
+## Get all endpoints stats {#get-endpoints-stats}
+
+	GET /v1/endpoints/stats
+
+Get statistics for all endpoint-proxy links.
+
+{{<note>}}
+This method will return both endpoints and listeners stats for backwards
+compatability.
+{{</note>}}
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_endpoint_stats]({{< relref "/operate/rs/references/rest-api/permissions#view_endpoint_stats" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/endpoints/stats?interval=1hour&stime=2014-08-28T10:00:00Z 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Query parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| interval | string | Time interval for which we want stats: 1sec/10sec/5min/15min/1hour/12hour/1week (optional) |
+| stime | ISO_8601 | Start time from which we want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+| etime | ISO_8601 | End time after which we don't want the stats. Should comply with the [ISO_8601](https://en.wikipedia.org/wiki/ISO_8601) format (optional) |
+
+### Response {#get-response} 
+
+The `uid` format in the response is: `"BDB_UID:ENDPOINT_UID:PROXY_UID"`
+
+For example: `{"uid": "1:2:3"}` means `BDB_UID=1`, `ENDPOINT_UID=2`, and `PROXY_UID=3`
+
+#### Example JSON body
+
+```json
+[
+   {
+      "uid" : "365:1:1",
+      "intervals" : [
+         {
+            "interval" : "10sec",
+            "total_req" : 0,
+            "egress_bytes" : 0,
+            "cmd_get" : 0,
+            "monitor_sessions_count" : 0,
+            "auth_errors" : 0,
+            "acc_latency" : 0,
+            "stime" : "2017-01-12T14:59:50Z",
+            "write_res" : 0,
+            "total_connections_received" : 0,
+            "cmd_set" : 0,
+            "read_req" : 0,
+            "max_connections_exceeded" : 0,
+            "acc_write_latency" : 0,
+            "write_req" : 0,
+            "other_res" : 0,
+            "cmd_flush" : 0,
+            "acc_read_latency" : 0,
+            "other_req" : 0,
+            "conns" : 0,
+            "write_started_res" : 0,
+            "cmd_touch" : 0,
+            "read_res" : 0,
+            "auth_cmds" : 0,
+            "etime" : "2017-01-12T15:00:00Z",
+            "total_started_res" : 0,
+            "ingress_bytes" : 0,
+            "last_res_time" : 0,
+            "read_started_res" : 0,
+            "acc_other_latency" : 0,
+            "total_res" : 0,
+            "last_req_time" : 0,
+            "other_started_res" : 0
+         }
+      ]
+   },
+   {
+      "intervals" : [
+         {
+            "acc_read_latency" : 0,
+            "other_req" : 0,
+            "etime" : "2017-01-12T15:00:00Z",
+            "auth_cmds" : 0,
+            "total_started_res" : 0,
+            "write_started_res" : 0,
+            "cmd_touch" : 0,
+            "conns" : 0,
+            "read_res" : 0,
+            "total_res" : 0,
+            "other_started_res" : 0,
+            "last_req_time" : 0,
+            "read_started_res" : 0,
+            "last_res_time" : 0,
+            "ingress_bytes" : 0,
+            "acc_other_latency" : 0,
+            "egress_bytes" : 0,
+            "interval" : "10sec",
+            "total_req" : 0,
+            "acc_latency" : 0,
+            "auth_errors" : 0,
+            "cmd_get" : 0,
+            "monitor_sessions_count" : 0,
+            "read_req" : 0,
+            "max_connections_exceeded" : 0,
+            "total_connections_received" : 0,
+            "cmd_set" : 0,
+            "acc_write_latency" : 0,
+            "write_req" : 0,
+            "stime" : "2017-01-12T14:59:50Z",
+            "write_res" : 0,
+            "cmd_flush" : 0,
+            "other_res" : 0
+         }
+      ],
+      "uid" : "333:1:2"
+   }
+]
+```
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+---
+Title: Database actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Database actions requests
+headerRange: '[1-2]'
+linkTitle: bdb
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-db-actions) | `/v1/actions/bdb/{bdb_uid}` | Get the status of a specific database's actions |
+
+## Get database actions {#get-db-actions}
+
+```
+GET /v1/actions/bdb/{bdb_uid}
+```
+
+Get the status of all currently executing, pending, or completed state-machine-related actions for a specific database. This API tracks short-lived API requests that return `action_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions/bdb/1
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| bdb_uid | string | Unique database ID |
+
+### Response {#get-response}
+
+Returns an array of JSON objects with attributes from [actions]({{< relref "/operate/rs/references/rest-api/objects/action" >}}) and [state machines]({{< relref "/operate/rs/references/rest-api/objects/state-machine" >}}).
+
+Each action contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+[
+    {
+        "action_uid": "8afc7f70-f3ae-4244-a5e9-5133e78b2e97",
+        "heartbeat": 1703067908,
+        "name": "SMUpdateBDB",
+        "object_name": "bdb:1",
+        "pending_ops": {},
+        "progress": 50.0,
+        "state": "proxy_policy",
+        "status": "active"
+    }
+]
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about state-machine actions |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found |
+---
+Title: Actions requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Actions requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: actions
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-actions) | `/v1/actions` | Get all actions |
+| [GET](#get-action) | `/v1/actions/{uid}` | Get a single action |
+
+## Get all actions {#get-all-actions}
+
+```
+GET /v1/actions
+```
+
+Get the status of all running, pending, or completed actions on all clusters, nodes, and databases. This API tracks long-lived API requests that return either a `task_id` or an `action_uid`.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions
+```
+
+### Response {#get-all-response}
+
+Returns a JSON array of [action objects]({{< relref "/operate/rs/references/rest-api/objects/action" >}}), which represent tasks, and an array of [state-machine objects]({{< relref "/operate/rs/references/rest-api/objects/state-machine" >}}).
+
+| Field | Type/Value | Description |
+|-------|------------|-------------|
+| action_uid | string | The action's globally unique identifier |
+| name | string | Name of the running or failed state machine |
+| progress | float (range: 0-100) | Percent of completed steps for the action |
+| status | "pending"<br />"active"<br />"completed"<br />"failed" | The action's status |
+| node_uid | string | UID of the node where the operation runs (optional) |
+| object_name | string | The object that the action runs on (optional) |
+| state | string | The current state of the state machine (optional)  |
+| pending_ops | JSON object | List of operations that are waiting to run (optional)<br />{{<code>}}"pending_ops": {<br />  "3": {<br />    "heartbeat": integer,<br />    "snapshot": { ... },<br />    "last_sample_time": integer,<br />    "op_name": string,<br />    "status_code": string,<br />    "status_description": string,<br />    "progress": float<br />  }<br />}{{</code>}}<br />`pending_ops` is a map where the key is the `shard_id`, and the value is a map that can include the following optional fields:<br />**heartbeat**: The time, in seconds since the Unix epoch, since the last change in the progress of the operation.<br />**snapshot**: A map of properties stored by the operation that are needed to run.<br />**last_sample_time**: The time, in seconds since the Unix epoch, when the last snapshot of the operation was taken.<br />**op_name**: The name of the operation from the state machine that is running.<br />**status_code**: The code for the operation's current status.<br />**status_description**: The operation's current status.<br />**progress**: The operation's progress in percentage (1 to 100). |
+
+Regardless of an action’s source, each action in the response contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+{
+  "actions": [
+    {
+      "action_uid": "159ca2f8-7bf3-4cda-97e8-4eb560665c28",
+      "name": "retry_bdb",
+      "node_uid": "2",
+      "progress": "100",
+      "status": "completed",
+      "task_id": "159ca2f8-7bf3-4cda-97e8-4eb560665c28"
+    },
+    {
+      "action_uid": "661697c5-c747-41bd-ab81-ffc8fd13c494",
+      "name": "retry_bdb",
+      "node_uid": "1",
+      "progress": "100",
+      "status": "completed",
+      "task_id": "661697c5-c747-41bd-ab81-ffc8fd13c494"
+    }
+  ],
+  "state-machines": [
+    {
+      "action_uid": "a10586b1-60bc-428e-9bc6-392eb5f0d8ae",
+      "heartbeat": 1650378874,
+      "name": "SMCreateBDB",
+      "object_name": "bdb:1",
+      "progress": 100,
+      "status": "completed"
+    }
+  ]
+}
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run).|
+
+## Get a specific action {#get-action}
+
+```
+GET /v1/actions/{uid}
+```
+
+Get the status of a specific action.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_status_of_cluster_action]({{< relref "/operate/rs/references/rest-api/permissions#view_status_of_cluster_action" >}}) |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```
+GET /v1/actions/{uid}
+```
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | string | The action_uid to check |
+
+### Response {#get-response}
+
+Returns an [action object]({{< relref "/operate/rs/references/rest-api/objects/action" >}}).
+
+| Field | Type/Value | Description |
+|-------|------------|-------------|
+| action_uid | string | The action's globally unique identifier |
+| name | string | Name of the running or failed state machine |
+| progress | float (range: 0-100) | Percent of completed steps for the action |
+| status | "pending"<br />"active"<br />"completed"<br />"failed" | The action's status |
+| node_uid | string | UID of the node where the operation runs (optional) |
+| object_name | string | The object that the action runs on (optional) |
+| state | string | The current state of the state machine (optional)  |
+| pending_ops | JSON object | List of operations that are waiting to run (optional)<br />{{<code>}}"pending_ops": {<br />  "3": {<br />    "heartbeat": integer,<br />    "snapshot": { ... },<br />    "last_sample_time": integer,<br />    "op_name": string,<br />    "status_code": string,<br />    "status_description": string,<br />    "progress": float<br />  }<br />}{{</code>}}<br />`pending_ops` is a map where the key is the `shard_id`, and the value is a map that can include the following optional fields:<br />**heartbeat**: The time, in seconds since the Unix epoch, since the last change in the progress of the operation.<br />**snapshot**: A map of properties stored by the operation that are needed to run.<br />**last_sample_time**: The time, in seconds since the Unix epoch, when the last snapshot of the operation was taken.<br />**op_name**: The name of the operation from the state machine that is running.<br />**status_code**: The code for the operation's current status.<br />**status_description**: The operation's current status.<br />**progress**: The operation's progress in percentage (1 to 100). |
+
+Regardless of an action’s source, each action contains the following attributes: `name`, `action_uid`, `status`, and `progress`.
+
+#### Example JSON body
+
+```json
+{
+  "action_uid": "159ca2f8-7bf3-4cda-97e8-4eb560665c28",
+  "name": "retry_bdb",
+  "node_uid": "2",
+  "progress": "100",
+  "status": "completed",
+  "task_id": "159ca2f8-7bf3-4cda-97e8-4eb560665c28"
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, response provides info about an ongoing action |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Action does not exist (i.e. not currently running and no available status of last run) |
+---
+Title: CRDB tasks requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Active-Active database task status requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: crdb_tasks
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-crdb_task) | `/v1/crdb_tasks/{task_id}` | Get the status of an executed task |
+
+## Get task status {#get-crdb_task}
+
+	GET /v1/crdb_tasks/{task_id}
+
+Get the status of an executed task.
+
+The status of a completed task is kept for 500 seconds by default.
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+    GET /v1/crdb_tasks/1
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| X-Result-TTL | integer | Task time to live |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| task_id | string | Task ID |
+
+### Response {#get-response} 
+
+Returns a [CRDB task object]({{< relref "/operate/rs/references/rest-api/objects/crdb_task" >}}).
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Task status. |
+| [401 Unauthorized](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.2) | Unauthorized request. Invalid credentials |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Task not found. |
+---
+Title: OCSP status requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP status requests
+headerRange: '[1-2]'
+linkTitle: status
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-status) | `/v1/ocsp/status` | Get OCSP status |
+
+## Get OCSP status {#get-status}
+
+	GET /v1/ocsp/status
+
+Gets the latest cached status of the proxy certificate’s OCSP response.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ocsp_status]({{< relref "/operate/rs/references/rest-api/permissions#view_ocsp_status" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ocsp/status 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [OCSP status object]({{< relref "/operate/rs/references/rest-api/objects/ocsp_status" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "responder_url": "http://responder.ocsp.url.com",
+    "cert_status": "REVOKED",
+    "produced_at": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "this_update": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "next_update": "Wed, 22 Dec 2021 14:50:00 GMT",
+    "revocation_time": "Wed, 22 Dec 2021 12:50:04 GMT"
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability | 
+| invalid_ocsp_response | The server returned a response that is not OCSP-compatible |
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |---
+Title: OCSP test requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP test requests
+headerRange: '[1-2]'
+linkTitle: test
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-test) | `/v1/ocsp/test` | Test OCSP |
+
+## Test OCSP {#post-test}
+
+	POST /v1/ocsp/test
+
+Queries the OCSP server for the proxy certificate’s latest status and returns the response as JSON. It caches the response if the OCSP feature is enabled.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [test_ocsp_status]({{< relref "/operate/rs/references/rest-api/permissions#test_ocsp_status" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/ocsp/test 
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#post-response} 
+
+Returns an [OCSP status object]({{< relref "/operate/rs/references/rest-api/objects/ocsp_status" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "responder_url": "http://responder.ocsp.url.com",
+    "cert_status": "REVOKED",
+    "produced_at": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "this_update": "Wed, 22 Dec 2021 12:50:11 GMT",
+    "next_update": "Wed, 22 Dec 2021 14:50:00 GMT",
+    "revocation_time": "Wed, 22 Dec 2021 12:50:04 GMT"
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_responder_url | Tried to test OCSP status with no responder URL configured |
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability |
+| task_queued_for_too_long | OCSP polling task was in status “queued” for over 5 seconds |
+| invalid_ocsp_response | The server returned a response that is not compatible with OCSP |
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success querying the OCSP server |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature is not supported in all nodes |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | `responder_url` is not configured or polling task failed |
+---
+Title: OCSP requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: OCSP requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: ocsp
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-ocsp) | `/v1/ocsp` | Get OCSP configuration |
+| [PUT](#put-ocsp) | `/v1/ocsp` | Update OCSP configuration |
+
+## Get OCSP configuration {#get-ocsp}
+
+	GET /v1/ocsp
+
+Gets the cluster's OCSP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [view_ocsp_config]({{< relref "/operate/rs/references/rest-api/permissions#view_ocsp_config" >}}) |
+
+### Request {#get-request} 
+
+#### Example HTTP request
+
+	GET /v1/ocsp 
+
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response} 
+
+Returns an [OCSP configuration object]({{< relref "/operate/rs/references/rest-api/objects/ocsp" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "ocsp_functionality": true,
+    "responder_url": "http://responder.ocsp.url.com",
+    "query_frequency": 3800,
+    "response_timeout": 2,
+    "recovery_frequency": 80,
+    "recovery_max_tries": 20
+}
+```
+
+### Error codes {#get-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability | 
+
+### Status codes {#get-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |
+
+## Update OCSP configuration {#put-ocsp}
+
+	PUT /v1/ocsp
+
+Updates the cluster's OCSP configuration.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [config_ocsp]({{< relref "/operate/rs/references/rest-api/permissions#config_ocsp" >}}) |
+
+### Request {#put-request} 
+
+#### Example HTTP request
+
+	PUT /v1/ocsp 
+
+#### Example JSON body
+
+```json
+{
+    "ocsp_functionality": true,
+    "query_frequency": 3800,
+    "response_timeout": 2,
+    "recovery_frequency": 80,
+    "recovery_max_tries": 20
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### Request body
+
+Include an [OCSP configuration object]({{< relref "/operate/rs/references/rest-api/objects/ocsp" >}}) with updated fields in the request body.
+
+### Response {#put-response} 
+
+Returns the updated [OCSP configuration object]({{< relref "/operate/rs/references/rest-api/objects/ocsp" >}}).
+
+### Error codes {#put-error-codes} 
+
+When errors occur, the server returns a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| invalid_schema | An illegal parameter or a parameter with an illegal value |
+| no_responder_url | Tried to enable OCSP with no responder URL configured |
+| ocsp_unsupported_by_capability | Not all nodes support OCSP capability |
+
+### Status codes {#put-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, OCSP config has been set |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Feature not supported in all nodes |
+---
+Title: Proxy requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Proxy requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: proxies
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-all-proxies) | `/v1/proxies` | Get all proxies |
+| [GET](#get-proxy) | `/v1/proxies/{uid}` | Get a proxy |
+| [PUT](#put-proxy) | `/v1/proxies/{uid}` | Update a proxy |
+| [PUT](#put-all-proxies) | `/v1/proxies` | Update all proxies |
+
+## Get all proxies {#get-all-proxies}
+
+```sh
+GET /v1/proxies
+```
+
+Get all the proxies in the cluster.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_all_proxies_info]({{< relref "/operate/rs/references/rest-api/permissions#view_all_proxies_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-all-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/proxies
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-all-response}
+
+Returns a JSON array of [proxy objects]({{< relref "/operate/rs/references/rest-api/objects/proxy" >}}).
+
+#### Example JSON body
+
+```json
+[
+    {
+         "uid": 1,
+         "client_keepintvl": 30,
+         "max_worker_server_conns": 16384,
+         "client_keepcnt": 6,
+         "max_threads": 64,
+         "ignore_bdb_cconn_output_buff_limits": false,
+         "dynamic_threads_scaling": false,
+         "max_worker_client_conns": 16384,
+         "max_servers": 4096,
+         "client_keepidle": 180,
+         "duration_usage_threshold": 30,
+         "max_worker_txns": 65536,
+         "threads": 3,
+         "max_listeners": 1024,
+         "conns": 500000,
+         "ignore_bdb_cconn_limit": false,
+         "threads_usage_threshold": 80,
+         "backlog": 1024
+    },
+    {
+        "uid": 2,
+        "threads": 3,
+        // additional fields...
+    }
+]
+```
+
+### Status codes {#get-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get proxy {#get-proxy}
+
+```sh
+GET /v1/proxies/{int: uid}
+```
+
+Get a single proxy's info.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_proxy_info]({{< relref "/operate/rs/references/rest-api/permissions#view_proxy_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/proxies/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The proxy's unique node ID |
+
+### Response {#get-response}
+
+Returns a [proxy object]({{< relref "/operate/rs/references/rest-api/objects/proxy" >}}).
+
+#### Example JSON body
+
+```json
+{
+     "uid": 1,
+     "client_keepintvl": 30,
+     "max_worker_server_conns": 16384,
+     "client_keepcnt": 6,
+     "max_threads": 64,
+     "ignore_bdb_cconn_output_buff_limits": false,
+     "dynamic_threads_scaling": false,
+     "max_worker_client_conns": 16384,
+     "max_servers": 4096,
+     "client_keepidle": 180,
+     "duration_usage_threshold": 30,
+     "max_worker_txns": 65536,
+     "threads": 3,
+     "max_listeners": 1024,
+     "conns": 500000,
+     "ignore_bdb_cconn_limit": false,
+     "threads_usage_threshold": 80,
+     "backlog": 1024
+}
+```
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Proxy UID does not exist |
+
+## Update proxy {#put-proxy}
+
+```sh
+PUT /v1/proxies/{int: uid}
+```
+
+Updates a proxy object, notifies the proxy, and waits for acknowledgment (ACK) unless the node is dead.
+
+Automatically restarts the proxy service if `allow_restart` is `true` and any updated parameters require a restart for the changes to take effect. For example, a restart is required if you change `threads` to a lower number.
+
+However, if `allow_restart` is `false`, such changes only take effect after the next proxy restart.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_proxy]({{< relref "/operate/rs/references/rest-api/permissions#update_proxy" >}}) | admin<br />user_manager |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/proxies/1
+```
+
+#### Example JSON body
+
+```json
+{
+  "allow_restart": true,
+  "proxy": {
+    "threads": 8
+  }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Request body media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The unique ID of the updated proxy. Corresponds to the node ID. |
+
+#### Request body
+
+Include a JSON object in the request body. The JSON object can contain the boolean field `allow_restart` and a [proxy object]({{< relref "/operate/rs/references/rest-api/objects/proxy" >}}) with updated fields.
+
+### Response {#put-response}
+
+Returns a status code to indicate the success or failure of the proxy update.
+
+### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Proxy does not exist |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Error while waiting for confirmation from proxy |
+| [504 Gateway Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.5) | Timeout while waiting for confirmation from proxy |
+
+## Update all proxies {#put-all-proxies}
+
+```sh
+PUT /v1/proxies
+```
+
+Updates all the proxy objects, notifies the proxies, and waits for acknowledgment (ACK) unless the node is dead.
+
+Automatically restarts the relevant proxy services if `allow_restart` is `true` and any updated parameters require a restart for the changes to take effect.
+
+However, if `allow_restart` is `false`, such changes only take effect after the next proxy restart.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_proxy]({{< relref "/operate/rs/references/rest-api/permissions#update_proxy" >}}) | admin<br />user_manager |
+
+### Request {#put-all-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/proxies
+```
+
+#### Example JSON body
+
+```json
+{
+  "allow_restart": true,
+  "proxy": {
+    "threads": 8,
+    "max_threads": 12
+  }
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+| Content-Type | application/json | Request body media type |
+
+#### Request body
+
+Include a JSON object in the request body. The JSON object can contain the boolean field `allow_restart` and a [proxy object]({{< relref "/operate/rs/references/rest-api/objects/proxy" >}}) with updated fields.
+
+### Response {#put-all-response}
+
+Returns a status code to indicate the success or failure of the proxy updates.
+
+### Status codes {#put-all-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error, the request has been processed |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad content provided |
+| [500 Internal Server Error](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Error while waiting for confirmation from proxy |
+| [504 Gateway Timeout](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.5) | Timeout while waiting for confirmation from proxy |
+---
+Title: Configure module requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure module requests
+headerRange: '[1-2]'
+linkTitle: config/bdb
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-modules-config-bdb) | `/v1/modules/config/bdb/{uid}` | Configure module |
+
+## Configure module {#post-modules-config-bdb}
+
+	POST /v1/modules/config/bdb/{string: uid}
+
+Use the module runtime configuration command (if defined) to configure new arguments for the module.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/modules/config/bdb/1
+
+#### Example JSON body
+
+```json
+{
+  "modules": [
+    {
+      "module_name": "search",
+      "module_args": "MINPREFIX 3 MAXEXPANSIONS 1000"
+    }
+  ]
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list of JSON objects | List of modules (module_name) and their new configuration settings (module_args) |
+| module_name | `search`<br />`ReJSON`<br />`graph`<br />`timeseries`<br />`bf` | Module's name |
+| module_args | string | Module command line arguments (pattern does not allow special characters &,<,>,”) |
+
+### Response {#post-response} 
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with `error_code` and `message` field that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| db_not_exist | Database with given UID doesn't exist in cluster | 
+| missing_field | "module_name" or "module_args" are not defined in request | 
+| invalid_schema | JSON object received is not a dict object | 
+| param_error | "module_args" parameter was not parsed properly | 
+| module_not_exist | Module with given "module_name" does not exist for the database | 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | Module does not support runtime configuration of arguments. |
+---
+Title: Upgrade module requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade module requests
+headerRange: '[1-2]'
+linkTitle: upgrade/bdb
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [POST](#post-modules-upgrade-bdb) | `/v1/modules/upgrade/bdb/{uid}` | Upgrade module |
+
+## Upgrade module {#post-modules-upgrade-bdb}
+
+	POST /v1/modules/upgrade/bdb/{string: uid}
+
+Upgrades the module version on a specific database. Deprecated as of Redis Enterprise Software v7.8.2. Use [`POST /v1/bdbs/<uid>/upgrade`]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) instead.
+
+#### Required permissions
+
+| Permission name |
+|-----------------|
+| [edit_bdb_module]({{< relref "/operate/rs/references/rest-api/permissions#edit_bdb_module" >}}) |
+
+### Request {#post-request} 
+
+#### Example HTTP request
+
+	POST /v1/modules/upgrade/bdb/1
+
+#### Example JSON body
+
+```json
+{
+     "modules": [
+         {"module_name": "ReJson",
+         "current_semantic_version": "2.2.1",
+         "new_module": "aa3648d79bd4082d414587c42ea0b234"}
+     ],
+     "// Optional fields to fine-tune restart and failover behavior:",
+     "preserve_roles": true,
+     "may_discard_data": false
+}
+```
+
+#### Request headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Request body
+
+| Field | Type | Description |
+|-------|------|-------------|
+| modules | list | List of dicts representing the modules that will be upgraded. Each dict must include: <br></br> • **current_module**: UID of a module to upgrade <br></br> • **new_module**: UID of the module we want to upgrade to <br></br> • **new_module_args**: args list for the new module |
+| preserve_roles | boolean | Preserve shards’ master/replica roles (optional) |
+| may_discard_data | boolean | Discard data in a non-replicated non-persistent database (optional) |
+
+### Response {#post-response} 
+
+Returns the upgraded [module object]({{< relref "/operate/rs/references/rest-api/objects/module" >}}).
+
+#### Example JSON body
+
+```json
+{
+    "uid": 1,
+    "name": "name of database #1",
+    "module_id": "aa3648d79bd4082d414587c42ea0b234",
+    "module_name": "ReJson",
+    "semantic_version": "2.2.2"
+    "// additional fields..."
+}
+```
+
+### Error codes {#post-error-codes} 
+
+When errors are reported, the server may return a JSON object with    `error_code` and `message` field that provide additional information.    The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| missing_module | Module is not present in cluster.| 
+| module_downgrade_unsupported | Module downgrade is not allowed.| 
+| redis_incompatible_version | Module min_redis_version is bigger than the current Redis version.| 
+| redis_pack_incompatible_version | Module min_redis_pack_version is bigger than the current Redis Enterprise version.| 
+| unsupported_module_capabilities | New version of module does support all the capabilities needed for the database configuration| 
+
+### Status codes {#post-status-codes} 
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, module updated on bdb. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | bdb or node not found. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Bad or missing configuration parameters. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The requested configuration is invalid. |
+---
+Title: Modules requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis modules requests
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: modules
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#list-modules) | `/v1/modules` | List available modules |
+| [GET](#get-module) | `/v1/modules/{uid}` | Get a specific module |
+| [POST](#post-module) | `/v1/modules` | Upload a new module (deprecated) |
+| [POST](#post-module-v2) | `/v2/modules` | Upload a new module |
+| [DELETE](#delete-module) | `/v1/modules/{uid}` | Delete a module (deprecated) |
+| [DELETE](#delete-module-v2) | `/v2/modules/{uid}` | Delete a module |
+
+## List modules {#list-modules}
+
+```sh
+GET /v1/modules
+```
+
+List available modules, i.e. modules stored within the CCS.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_modules]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_modules" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#list-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | 127.0.0.1:9443 | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+### Response {#list-response}
+
+Returns a JSON array of [module objects]({{< relref "/operate/rs/references/rest-api/objects/module" >}}).
+
+#### Status codes {#list-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+
+## Get module {#get-module}
+
+```sh
+GET /v1/modules/{string: uid}
+```
+
+Get specific available modules, i.e. modules stored within the CCS.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_modules]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_modules" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | 127.0.0.1:9443 | Domain name |
+| Accept | \*/\* | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#get-response}
+
+Returns a [module object]({{< relref "/operate/rs/references/rest-api/objects/module" >}}).
+
+### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | No error |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Module does not exist. |
+
+## Upload module v1 {#post-module}
+
+```sh
+POST /v1/modules
+```
+
+{{<note>}}
+`POST /v1/modules` is deprecated as of Redis Enterprise Software version 7.2. Use [`POST /v2/modules`](#post-module-v2) instead.
+{{</note>}}
+
+Uploads a new module to the cluster.
+
+The request must contain a Redis module, bundled using [RedisModule
+Packer](https://github.com/RedisLabs/RAMP). For modules in Redis Stack, download the module from the [download center](https://redis.io/downloads/).
+
+See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster#rest-api-method" >}}) for more information.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | string | Domain name |
+| Accept | \*/\* | Accepted media type |
+| Content-Length | integer | Length of the request body in octets |
+| Expect | 100-continue | Requires particular server behaviors |
+| Content-Type | multipart/form-data | Media type of request/response body |
+
+### Response {#post-response}
+
+Returns a status code. If an error occurs, the response body may include an error code and message with more details.
+
+#### Error codes {#post-error-codes}
+
+The server may return a JSON object with `error_code` and `message` fields that provide additional information. The following are possible `error_code` values:
+
+| Code | Description |
+|------|-------------|
+| no_module | Module wasn't provided or could not be found |
+| invalid_module | Module either corrupted or packaged files are wrong |
+| module_exists | Module already in system |
+| min_redis_pack_version | Module isn't supported yet in this Redis pack |
+| unsupported_module_capabilities | The module does not support required capabilities|
+| os_not_supported | This module is not supported for this operating system |
+| dependencies_not_supported | This endpoint does not support dependencies, see v2 |
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Either missing module file or an invalid module file. |
+
+### Examples
+
+#### cURL
+
+```sh
+$ curl -k -u "[username]:[password]" -X POST
+       -F "module=@/tmp/rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip"
+       https://[host][:port]/v1/modules
+```
+
+#### Python
+
+```python
+import requests
+
+url = "https://[host][:port]/v1/modules"
+
+files=[
+    ('module',
+        ('rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip',
+        open('/tmp/rejson.Linux-ubuntu18.04-x86_64.2.0.8.zip','rb'),
+        'application/zip')
+    )
+]
+auth=("[username]", "[password]")
+
+response = requests.request("POST", url,
+                            auth=auth, files=files, verify=False)
+
+print(response.text)
+```
+
+## Upload module v2 {#post-module-v2}
+
+```sh
+POST /v2/modules
+```
+
+Asynchronously uploads a new module to the cluster.
+
+The request must contain a Redis module bundled using [RedisModule Packer](https://github.com/RedisLabs/RAMP).
+
+For modules in Redis Stack, download the module from the [download center](https://redis.io/downloads/). See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster#rest-api-method" >}}) for more information.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#post-request-v2}
+
+#### Example HTTP request
+
+```sh
+POST /v2/modules
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | string| Domain name |
+| Accept | \*/\* | Accepted media type |
+| Content-Length | integer | Length of the request body in octets |
+| Expect | 100-continue | Requires particular server behaviors |
+| Content-Type | multipart/form-data; | Media type of request/response body |
+
+### Response {#post-response-v2}
+
+Returns a [module object]({{< relref "/operate/rs/references/rest-api/objects/module" >}}) with an additional `action_uid` field.
+
+You can use the `action_uid` to track the progress of the module upload.
+
+#### Example JSON body
+
+```json
+{
+   "action_uid":"dfc0152c-8449-4b1c-9184-480ea7cb526c",
+   "author":"RedisLabs",
+   "capabilities":[
+      "types",
+      "crdb",
+      "failover_migrate",
+      "persistence_aof",
+      "persistence_rdb",
+      "clustering",
+      "backup_restore"
+   ],
+   "command_line_args":"Plugin gears_python CreateVenv 1",
+   "config_command":"RG.CONFIGSET",
+   "dependencies":{
+      "gears_jvm":{
+         "sha256":"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+         "url":"http://example.com/redisgears_plugins/jvm_plugin/gears-jvm.linux-centos7-x64.0.1.0.tgz"
+      },
+      "gears_python":{
+         "sha256":"22dca9cd75484cb15b8130db37f5284e22e3759002154361f72f6d2db46ee682",
+         "url":"http://example.com/redisgears-python.linux-centos7-x64.1.2.1.tgz"
+      }
+   },
+   "description":"Dynamic execution framework for your Redis data",
+   "display_name":"RedisGears",
+   "email":"user@example.com",
+   "homepage":"http://redisgears.io",
+   "is_bundled":false,
+   "license":"Redis Source Available License Agreement",
+   "min_redis_pack_version":"6.0.0",
+   "min_redis_version":"6.0.0",
+   "module_name":"rg",
+   "semantic_version":"1.2.1",
+   "sha256":"2935ea53611803c8acf0015253c5ae1cd81391bbacb23e14598841e1edd8d28b",
+   "uid":"98f255d5d33704c8e4e97897fd92e32d",
+   "version":10201
+}
+```
+
+### Error codes {#post-error-codes-v2}
+
+The server may return a JSON object with `error_code` and `message` fields that provide additional information.
+
+Possible `error_code` values include [`/v1/modules` error codes](#post-error-codes) and the following:
+
+| Code | Description |
+|------|-------------|
+| invalid_dependency_data | Provided dependencies have an unexpected format |
+
+### Status codes {#post-status-codes-v2}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, scheduled module upload. |
+| [400 Bad Request](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.1) | Module name or version does not exist. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Dependency not found. |
+| [500 Internal Server Error](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.5.1) | Failed to get dependency. |
+
+## Delete module v1 {#delete-module}
+
+```sh
+DELETE /v1/modules/{string: uid}
+```
+
+{{<note>}}
+`DELETE /v1/modules` is deprecated as of Redis Enterprise Software version 7.2. Use [`DELETE /v2/modules`](#delete-module-v2) instead.
+{{</note>}}
+
+Delete a module.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#delete-request}
+
+#### Example HTTP request
+
+```sh
+DELETE /v1/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#delete-response}
+
+Returns a status code to indicate module deletion success or failure.
+
+#### Error codes {#delete-error-codes}
+
+| Code | Description |
+|------|-------------|
+| dependencies_not_supported | You can use the following API endpoint to delete this module with its dependencies: [`/v2/modules/<uid>`](#delete-module-v2) |
+
+#### Status codes {#delete-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, the module is deleted. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent module. |
+| [406 Not Acceptable](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.7) | The request is not acceptable. |
+
+## Delete module v2 {#delete-module-v2}
+
+```sh
+DELETE /v2/modules/{string: uid}
+```
+
+Delete a module.
+
+#### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#delete-request-v2}
+
+#### Example HTTP request
+
+```sh
+DELETE /v2/modules/1
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+#### URL parameters
+
+| Field | Type | Description |
+|-------|------|-------------|
+| uid | integer | The module's unique ID. |
+
+### Response {#delete-response-v2}
+
+Returns a JSON object with an `action_uid` that allows you to track the progress of module deletion.
+
+#### Status codes {#delete-status-codes-v2}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.2.1) | Success, scheduled module deletion. |
+| [404 Not Found](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5) | Attempting to delete a nonexistent module. |
+---
+Title: Cluster Manager settings requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests for Cluster Manager UI settings
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: cm_settings
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-cm-settings) | `/v1/cm_settings` | Get Cluster Manager UI settings |
+| [PUT](#put-cm-settings) | `/v1/cm_settings` | Update Cluster Manager UI settings |
+
+## Get CM settings {#get-cm-settings}
+
+```sh
+GET /v1/cm_settings
+```
+
+Get Cluster Manager UI settings.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [view_cluster_info]({{< relref "/operate/rs/references/rest-api/permissions#view_cluster_info" >}}) | admin<br />cluster_member<br />cluster_viewer<br />db_member<br />db_viewer<br />user_manager |
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/cm_settings
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+### Response {#get-response}
+
+Returns a [cm_settings object]({{<relref "/operate/rs/references/rest-api/objects/cm_settings">}}).
+
+#### Example JSON body
+
+```json
+{
+    "timezone": "UTC"
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+
+## Update CM settings {#put-cm-settings}
+
+```sh
+PUT /v1/cm_settings
+```
+
+Update Cluster Manager UI settings.
+
+### Permissions
+
+| Permission name | Roles |
+|-----------------|-------|
+| [update_cluster]({{< relref "/operate/rs/references/rest-api/permissions#update_cluster" >}}) | admin |
+
+### Request {#put-request}
+
+#### Example HTTP request
+
+```sh
+PUT /v1/cm_settings
+```
+
+#### Example JSON body
+
+```json
+{
+    "timezone": "US/Pacific"
+}
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Body
+
+Include a [cm_settings object]({{<relref "/operate/rs/references/rest-api/objects/cm_settings">}}) with updated fields in the request body.
+
+### Response {#put-response}
+
+Returns a [cm_settings object]({{<relref "/operate/rs/references/rest-api/objects/cm_settings">}}) with the updated fields.
+
+#### Example JSON body
+
+```json
+{
+    "timezone": "US/Pacific"
+}
+```
+
+#### Status codes {#put-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success, time zone config has been set. |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | Bad or missing configuration parameters. |
+---
+Title: Services requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: REST API requests to list or modify Redis Enterprise services.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: services
+weight: $weight
+---
+
+| Method | Path | Description |
+|--------|------|-------------|
+| [GET](#get-local-services) | `/v1/local/services` | List Redis Enterprise services on the local node |
+| [POST](#post-local-services) | `/v1/local/services` | Modify or perform operations on local processes |
+| [POST](#post-services) | `/v1/services` | Apply cluster-wide changes to services |
+
+{{<warning>}}
+This API is dangerous and should only be run with guidance from [Redis support](https://redis.io/support/).
+
+Stop, start, or restart optional services only. Changing the status of required services can negatively affect cluster behavior and cause a complete loss of the cluster and its data.
+
+For a list of optional services, see the [services configuration object reference]({{<relref "/operate/rs/references/rest-api/objects/services_configuration">}}) or use a [`GET /v1/cluster/services_configuration`]({{<relref "/operate/rs/references/rest-api/requests/cluster/services_configuration#get-cluster-services_config">}}) request.
+{{</warning>}}
+
+## Get local services {#get-local-services}
+
+```sh
+GET /v1/local/services
+```
+
+Lists all Redis Enterprise services currently running on the local node and relevant metadata.
+
+### Request {#get-request}
+
+#### Example HTTP request
+
+```sh
+GET /v1/local/services
+```
+
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+### Response {#get-response}
+
+Returns a JSON object that describes all Redis Enterprise services currently running on the local node and relevant metadata.
+
+Possible `status` values: 
+- RESTARTING
+- RUNNING
+- STARTING
+- STOPPED
+
+#### Example JSON response body
+
+```json
+{
+    "alert_mgr": {
+        "start_time": "2024-05-13T18:38:00Z",
+        "status": "RUNNING",
+        "uptime": "3 days, 0:58:59"
+    },
+    "ccs": {
+        "start_time": "2024-05-13T18:38:59Z",
+        "status": "RUNNING",
+        "uptime": "3 days, 0:58:00"
+    },
+    ...
+}
+```
+
+#### Status codes {#get-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error |
+
+## Modify local services {#post-local-services}
+
+```sh
+POST /v1/local/services
+```
+
+Modify Redis Enterprise services or perform operations that directly interact with processes. For cluster-wide changes that are not node-specific, use [`POST /v1/services`](#post-services) instead.
+
+Supported `operation_type` values:
+
+- stop
+- start
+- restart
+
+{{<warning>}}
+This API is dangerous and should only be run with guidance from [Redis support](https://redis.io/support/).
+
+Stop, start, or restart optional services only. Changing the status of required services can negatively affect cluster behavior and cause a complete loss of the cluster and its data.
+
+For a list of optional services, see the [services configuration object reference]({{<relref "/operate/rs/references/rest-api/objects/services_configuration">}}) or use a [`GET /v1/cluster/services_configuration`]({{<relref "/operate/rs/references/rest-api/requests/cluster/services_configuration#get-cluster-services_config">}}) request.
+{{</warning>}}
+
+### Request {#post-local-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/local/services
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Example JSON request body
+
+```json
+{
+  "operation_type": "restart",
+  "services": [
+    "alert_mgr"
+  ]
+}
+```
+
+### Response {#post-local-response}
+
+Returns a JSON object that shows whether the operation ran successfully or failed for each requested service.
+
+#### Example JSON response body
+
+```json
+{
+    "alert_mgr": true,
+    "metrics_exporter": true
+}
+```
+
+
+#### Status codes {#post-local-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+
+## Apply cluster-wide service changes {#post-services}
+
+```sh
+POST /v1/services
+```
+
+Makes cluster-wide changes that are not node-specific on Redis Enterprise services. The master node handles these changes. For operations that directly interact with processes, use [`POST /v1/local/services`](#post-local-services) instead.
+
+Supported `operation_type` values:
+
+- stop
+- start
+- restart
+
+{{<warning>}}
+This API is dangerous and should only be run with guidance from [Redis support](https://redis.io/support/).
+
+Stop, start, or restart optional services only. Changing the status of required services can negatively affect cluster behavior and cause a complete loss of the cluster and its data.
+
+For a list of optional services, see the [services configuration object reference]({{<relref "/operate/rs/references/rest-api/objects/services_configuration">}}) or use a [`GET /v1/cluster/services_configuration`]({{<relref "/operate/rs/references/rest-api/requests/cluster/services_configuration#get-cluster-services_config">}}) request.
+{{</warning>}}
+
+### Request {#post-request}
+
+#### Example HTTP request
+
+```sh
+POST /v1/services
+```
+
+#### Headers
+
+| Key | Value | Description |
+|-----|-------|-------------|
+| Host | cnm.cluster.fqdn | Domain name |
+| Accept | application/json | Accepted media type |
+
+
+#### Example JSON request body
+
+```json
+{
+  "operation_type": "restart",
+  "services": [
+    "alert_mgr"
+  ]
+}
+```
+
+### Response {#post-response}
+
+Returns a JSON object that shows whether the operation ran successfully or failed for each requested service.
+
+#### Example JSON response body
+
+```json
+{
+    "alert_mgr": true,
+    "metrics_exporter": true
+}
+```
+
+
+#### Status codes {#post-status-codes}
+
+| Code | Description |
+|------|-------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | No error. |
+---
+Title: Redis Enterprise REST API requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the requests supported by the Redis Enterprise Software REST
+  API calls.
+hideListLinks: true
+linkTitle: Requests
+weight: 30
+---
+
+A REST API request requires the following components:
+- [HTTP method](https://restfulapi.net/http-methods/) (`GET`, `PUT`, `PATCH`, `POST`, `DELETE`)
+- Base URL
+- Endpoint
+
+Some requests may also require:
+- URL parameters
+- [Query parameters](https://en.wikipedia.org/wiki/Query_string)
+- [JSON](http://www.json.org) request body
+- [Permissions]({{< relref "/operate/rs/references/rest-api/permissions" >}})
+
+{{< table-children columnNames="Request,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Encrypt REST API requests
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Encrypt requests
+weight: 30
+---
+
+## 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.
+
+Before you turn off HTTP support, be sure to migrate any scripts or proxy configurations that use HTTP to the encrypted API endpoint to prevent broken connections.
+
+To turn off HTTP support for API endpoints, run:
+
+```sh
+rladmin cluster config http_support disabled
+```
+---
+Title: REST API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Documents the REST API available to Redis Enterprise Software deployments.
+hideListLinks: true
+weight: $weight
+---
+Redis Enterprise Software provides a REST API to help you automate common tasks.
+
+Here, you'll find the details of the API and how to use it.  
+
+For more info, see:
+
+- Supported [request endpoints]({{< relref "/operate/rs/references/rest-api/requests" >}}), organized by path
+- Supported [objects]({{< relref "/operate/rs/references/rest-api/objects" >}}), both request and response
+- Built-in roles and associated [permissions]({{< relref "/operate/rs/references/rest-api/permissions" >}})
+- [Redis Enterprise Software REST API quick start]({{< relref "/operate/rs/references/rest-api/quick-start" >}}) with examples
+
+## Authentication
+
+Authentication to the Redis Enterprise Software API occurs via [Basic Auth](https://en.wikipedia.org/wiki/Basic_access_authentication). Provide your username and password as the basic auth credentials.
+
+If the username and password is incorrect or missing, the request will fail with a [`401 Unauthorized`](https://www.rfc-editor.org/rfc/rfc9110.html#name-401-unauthorized) status code.
+
+Example request using [cURL](https://curl.se/):
+
+``` bash
+curl -u "demo@redislabs.com:password" \
+    https://localhost:9443/v1/bdbs
+```
+
+For more examples, see the [Redis Enterprise Software REST API quick start]({{< relref "/operate/rs/references/rest-api/quick-start" >}}).
+
+### Permissions
+
+By default, the admin user is authorized for access to all endpoints. Use [role-based access controls]({{< relref "/operate/rs/security/access-control" >}}) and [role permissions]({{< relref "/operate/rs/references/rest-api/permissions" >}}) to manage access.
+
+If a user attempts to access an endpoint that is not allowed in their role, the request will fail with a [`403 Forbidden`](https://www.rfc-editor.org/rfc/rfc9110.html#name-403-forbidden) status code. For more details on which user roles can access certain endpoints, see [Permissions]({{< relref "/operate/rs/references/rest-api/permissions" >}}).
+
+### Certificates
+
+The Redis Enterprise Software REST API uses [Self-signed certificates]({{< relref "/operate/rs/security/certificates" >}}) to ensure the product is secure. When you use the default self-signed certificates, the HTTPS requests will fail with `SSL certificate problem: self signed certificate` unless you turn off SSL certificate verification.
+
+## Ports
+
+All calls must be made over SSL to port 9443. For the API to work, port 9443 must be exposed to incoming traffic or mapped to a different port.
+
+If you are using a [Redis Enterprise Software Docker image]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}), run the following command to start the Docker image with port 9443 exposed:
+
+```sh
+docker run -p 9443:9443 redislabs/redis
+```
+
+## Versions
+
+All API requests are versioned in order to minimize the impact of backwards-incompatible API changes and to coordinate between different versions operating in parallel.
+
+Specify the version in the request [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier), as shown in the following table:
+
+| Request path | Description |
+|--------------|-------------|
+| POST `/v1/bdbs` | A version 1 request for the `/bdbs` endpoint. |
+| POST `/v2/bdbs` | A version 2 request for the `/bdbs` endpoint. |
+
+When an endpoint supports multiple versions, each version is documented on the corresponding endpoint.  For example, the [bdbs request]({{< relref "/operate/rs/references/rest-api/requests/bdbs/" >}}) page documents POST requests for [version 1]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#post-bdbs-v1" >}}) and [version 2]({{< relref "/operate/rs/references/rest-api/requests/bdbs/#post-bdbs-v2" >}}).
+
+## Headers
+
+### Requests
+
+Redis Enterprise REST API requests support the following HTTP headers:
+
+| Header | Supported/Required Values |
+|--------|---------------------------|
+| Accept | `application/json` |
+| Content-Length | Length (in bytes) of request message |
+| Content-Type | `application/json` (required for PUT or POST requests) |
+
+If the client specifies an invalid header, the request will fail with a [`400 Bad Request`](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) status code.
+
+### Responses
+
+Redis Enterprise REST API responses support the following HTTP headers:
+
+| Header | Supported/Required Values |
+|--------|---------------------------|
+| Content-Type | `application/json` |
+| Content-Length | Length (in bytes) of response message |
+
+## JSON requests and responses
+
+The Redis Enterprise Software REST API uses [JavaScript Object Notation (JSON)](http://www.json.org) for requests and responses. See the [RFC 4627 technical specifications](http://www.ietf.org/rfc/rfc4627.txt) for additional information about JSON.
+
+Some responses may have an empty body but indicate the response with standard [HTTP codes](https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
+
+Both requests and responses may include zero or more objects.
+
+If the request is for a single entity, the response returns a single JSON object or none. If the request is for a list of entities, the response returns a JSON array with zero or more elements.
+
+If you omit certain JSON object fields from a request, they may be assigned default values, which often indicate that these fields are not in use.
+
+## Response types and error codes
+
+[HTTP status codes](https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes) indicate the result of an API request. This can be `200 OK` if the server accepted the request, or it can be one of many error codes.
+
+The most common responses for a Redis Enterprise API request are:
+
+| Response | Condition/Required handling |
+|----------|-----------------------------|
+| [200 OK](https://www.rfc-editor.org/rfc/rfc9110.html#name-200-ok) | Success |
+| [400 Bad Request](https://www.rfc-editor.org/rfc/rfc9110.html#name-400-bad-request) | The request failed, generally due to a typo or other mistake. |
+| [401 Unauthorized](https://www.rfc-editor.org/rfc/rfc9110.html#name-401-unauthorized) | The request failed because the authentication information was missing or incorrect. |
+| [403 Forbidden](https://www.rfc-editor.org/rfc/rfc9110.html#name-403-forbidden) | The user cannot access the specified [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier). |
+| [404 Not Found](https://www.rfc-editor.org/rfc/rfc9110.html#name-404-not-found) | The [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) does not exist. |
+| [503 Service Unavailable](https://www.rfc-editor.org/rfc/rfc9110.html#name-503-service-unavailable) | The node is not responding or is not a member of the cluster. |
+| [505&nbsp;HTTP&nbsp;Version&nbsp;Not&nbsp;Supported](https://www.rfc-editor.org/rfc/rfc9110.html#name-505-http-version-not-suppor) | An unsupported `x-api-version` was used. See [versions](#versions). |
+
+Some endpoints return different response codes. The request references for these endpoints document these special cases.
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: false
+weight: 80
+---
+---
+Title: Configure cluster DNS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure DNS to communicate between nodes in your cluster.
+linkTitle: Configure cluster DNS
+weight: $weight
+---
+
+By default, Redis Enterprise Software deployments use DNS to communicate between nodes.  You can also use the [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}), which uses IP addresses to connect and complies with the [Redis Sentinel API]({{< relref "/operate/oss_and_stack/management/sentinel" >}}) supported by Redis Open Source.
+
+Each node in a Redis Enterprise cluster includes a small DNS server to manage internal functions, such as high availability, automatic failover, automatic migration, and so on.
+Nodes should only run the DNS server included with the software.  Running additional DNS servers can lead to unexpected behavior.
+
+## Cluster name and connection management
+
+Whether you're administering Redis Enterprise Software or accessing databases, there are two ways to connect:
+
+- URL-based connections - URL-based connections use DNS to resolve the fully qualified cluster domain name (FQDN).  This means that DNS records might need to be updated when topology changes, such as adding (or removing) nodes from the cluster.  
+
+    Because apps and other client connections rely on the URL (rather than the address), they do not need to be modified when topology changes.  
+
+- IP-based connections - IP-based connections do not require DNS setup, as they rely on the underlying TCP/IP addresses.  As long as topology changes do not change the address of the cluster nodes, no configuration changes are needed, DNS or otherwise.  
+
+    However, changes to IP addresses (or changes to IP address access) impact all connections to the node, including apps and clients.  IP address changes can therefore be unpredictable or time-consuming.
+
+## URL-based connections
+
+The fully qualified domain name (FQDN) is the unique cluster identifier that enables clients to connect to the different components of Redis Enterprise Software.
+The FQDN is a crucial component of the high-availability mechanism because it's used internally to enable and implement automatic and transparent failover of nodes, databases, shards, and endpoints.
+
+{{< note >}}
+Setting the cluster's FQDN is a one-time operation, one that cannot be changed after being set.
+{{< /note >}}
+
+The FQDN must always comply with the IETF's [RFC 952](https://datatracker.ietf.org/doc/html/rfc952) standard
+and section 2.1 of the [RFC 1123](https://datatracker.ietf.org/doc/html/rfc1123) standard.
+
+## Identify the cluster
+
+To identify the cluster, either use DNS to define a fully qualified domain name or use the IP addresses of each node.  
+
+### Define domain using DNS
+
+Use DNS if you:
+
+- have your own domain
+- want to integrate the cluster into that domain
+- can access and update the DNS records for that domain
+
+1. Make sure that the cluster and at least one node (preferably all nodes) in the cluster
+    are correctly configured in the DNS with the appropriate NS entries.
+
+    For example:
+
+    - Your domain is: `mydomain.com`
+    - You would like to name the Redis Enterprise Software cluster `mycluster`
+    - You have three nodes in the cluster:
+        - node1 (IP address 1.1.1.1)
+        - node2 (2.2.2.2)
+        - node3 (3.3.3.3)
+
+1. In the FQDN field, enter the value `mycluster.mydomain.com`
+    and add the following records in the DNS table for `mydomain.com`:
+
+    ``` sh
+    mycluster.mydomain.com        NS  node1.mycluster.mydomain.com
+                                      node2.mycluster.mydomain.com
+                                      node3.mycluster.mydomain.com 
+    
+    node1.mycluster.mydomain.com  A   1.1.1.1
+    
+    node2.mycluster.mydomain.com  A   2.2.2.2
+    
+    node3.mycluster.mydomain.com  A   3.3.3.3
+    ```
+
+### Zero-configuration using mDNS {#zeroconfiguration-using-mdns-development-option-only}
+
+Development and test environments can use [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS), a zero-configuration service designed for small networks.  Production environments should _not_ use mDNS.
+
+mDNS is a standard protocol that provides DNS-like name resolution and service discovery capabilities
+to machines on local networks with minimal to no configuration.
+
+Before adopting mDNS, verify that it's supported by each client you wish to use to connect to your Redis databases.  Also make sure that your network infrastructure permits mDNS/multi-casting between clients and cluster nodes.
+
+Configuring the cluster to support mDNS requires you to assign the cluster a `.local` name.
+
+For example, if you want to name the Redis Enterprise Software cluster `rediscluster`, specify the FQDN name as `rediscluster.local`.
+
+When using the DNS or mDNS option, failover can be done transparently and the DNS is updated automatically to point to the IP address of the new primary node.
+
+## IP-based connections
+
+When you use the IP-based connection option, the FQDN does not need to have any special format
+because clients use IP addresses instead of hostnames to access the databases so you are free to choose whatever name you want.
+Using the IP-based connection option does not require any DNS configuration either.
+
+To administer the cluster you do need to know the IP address of at least one of the nodes in the cluster.
+Once you have the IP address, you can simply connect to port number 8443 (for example: <https://10.0.0.12:8443>).
+However, as the topology of the cluster changes and node with the given IP address is removed,
+you need to remember the IP address of another node participating in this cluster to connect to the Cluster Manager UI and manage the cluster.
+
+Applications connecting to Redis Software databases have the same constraints.
+When using the IP-based connection method, you can use the [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}})
+to discover the database endpoint for a given database name as long as you have an IP address for at least one of the nodes in the cluster.
+The API used for discovery service is compliant with the Redis Sentinel API.
+
+To test your connection, try pinging the service.  For help, see [Connect to your database]({{< relref "/operate/rs/databases/connect/test-client-connectivity" >}}).
+
+---
+Title: Network port configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This document describes the various network port ranges and their uses.
+linkTitle: Network ports
+weight: $weight
+---
+
+All Redis Enterprise Software deployments span multiple physical/virtual nodes. You'll need to keep several ports open between these nodes. This document describes the various port ranges and their uses.
+
+{{< note >}}
+Whenever you create a new database, you must verify that the ports assigned to the new database's endpoints are open. The cluster will not perform this verification for you.
+{{< /note >}}
+
+## Ports and port ranges used by Redis Enterprise Software
+
+Redis Enterprise Software's port usage falls into three general categories:
+
+- Internal: For traffic between or within cluster nodes
+- External: For traffic from client applications or external monitoring resources
+- Active-Active: For traffic to and from clusters hosting Active-Active databases
+
+| Protocol | Port | Configurable | Connection source | Description |
+|----------|------|--------------|-------------------|-------------|
+| TCP | 8001 | <span title="Not configurable">&#x274c; No</span> | Internal, External | Traffic from application to Redis Enterprise Software [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}) |
+| TCP | 8070 | <span title="Not configurable">&#x274c; No</span> | External | Metrics exported and managed by the web proxy |
+| TCP | 3347-3349, 8000, 8071, 9091, 9125 | <span title="Not configurable">&#x274c; No</span> | Internal | Internal metrics ports |
+| TCP | 8443 | <span title="Configurable">&#x2705; Yes</span> | Internal, External | Secure (HTTPS) access to the management web UI |
+| TCP | 9081 | <span title="Configurable">&#x2705; Yes</span> | Internal | CRDB coordinator for Active-Active management (internal) |
+| TCP | 9443, 8080 | <span title="Configurable">&#x2705; Yes</span> | Internal, External, Active-Active | REST API traffic, including cluster management and node bootstrap |
+| TCP | 10050 | <span title="Not configurable">&#x274c; No</span> | Internal | Zabbix monitoring |
+| TCP | 10000-10049, 10051-19999 | <span title="Configurable">&#x2705; Yes</span> | Internal, External, Active-Active | Database traffic |
+| UDP | 53, 5353 | <span title="Not configurable">&#x274c; No</span> | Internal, External | DNS/mDNS traffic |
+| TCP | 1968 | <span title="Not configurable">&#x274c; No</span> | Internal | Proxy traffic |
+| TCP | 3333-3345, 3350, 36379 | <span title="Not configurable">&#x274c; No</span> | Internal | Internode communication |
+| TCP | 20000-29999 | <span title="Not configurable">&#x274c; No</span> | Internal | Database shard traffic |
+| TCP | 8002, 8004, 8006 | <span title="Configurable">&#x2705; Yes</span> | Internal | Default system health monitoring (envoy admin, envoy management server, gossip envoy admin)|
+| TCP | 8444, 9080 | <span title="Not configurable">&#x274c; No</span> | Internal | Traffic between web proxy and cnm_http/cm |
+
+## Change port configuration
+
+### Reserve ports
+
+Redis Enterprise Software reserves some ports by default (`system_reserved_ports`). To reserve other ports or port ranges and prevent the cluster from assigning them to database endpoints, configure `reserved_ports` using one of the following methods:
+
+- [rladmin cluster config]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}})
+
+    ```sh
+    rladmin cluster config reserved_ports <list of ports/port ranges>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster config reserved_ports 11000 13000-13010
+    ```
+
+- [Update cluster settings]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}) REST API request
+
+    ```sh
+    PUT /v1/cluster
+    { "reserved_ports": ["list of ports/port ranges"] }
+    ```
+
+    For example:
+
+    ```sh
+    PUT /v1/cluster
+    { "reserved_ports": ["11000", "13000-13010"] }
+    ```
+
+### Change the Cluster Manager UI port
+
+The Redis Enterprise Software Cluster Manager UI uses port 8443, by default. You can change this to a custom port as long as the new port is not in use by another process.
+
+To change this port, run:
+
+```sh
+rladmin cluster config cm_port <new-port>
+```
+
+After changing the Redis Enterprise Software web UI port, you must connect any new node added to the cluster to the UI with the custom port number:
+`https://newnode.mycluster.example.com:`**`<nonstandard-port-number>`**
+
+### Change the envoy  ports
+
+For system health monitoring, Redis uses the following ports by default:
+
+- Port 8002 for envoy admin
+
+- Port 8004 for envoy management server
+
+- Port 8006 for gossip envoy admin
+
+You can change each envoy port to a custom port using the [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) command as long as the new port is not in use by another process. When you change `envoy_admin_port`, expect a restart of envoy.
+
+To change the envoy admin port, run:
+
+```sh
+$ rladmin cluster config envoy_admin_port <new-port>
+Updating envoy_admin_port... restarting now
+```
+
+To change the envoy management server port, run:
+
+```sh
+$ rladmin cluster config envoy_mgmt_server_port <new-port>
+Cluster configured successfully
+```
+
+To change the gossip envoy admin port, run:
+
+```sh
+$ rladmin cluster config gossip_envoy_admin_port <new-port>
+Cluster configured successfully
+```
+
+### Change the REST API port
+
+For the REST API, Redis Enterprise Software uses port 9443 (secure) and port 8080 (not secure), by default. You can change this to a custom port as long as the new port is not in use by another process.
+
+To change these ports, run:
+
+```sh
+rladmin cluster config cnm_http_port <new-port>
+```
+
+```sh
+rladmin cluster config cnm_https_port <new-port>
+```
+
+### OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+
+
+### Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+
+## Configure HTTPS
+
+### Require HTTPS for API endpoints
+
+By default, the Redis Enterprise Software API supports communication over HTTP and HTTPS. However, you can turn off HTTP support to ensure that API requests are encrypted.
+
+Before you turn off HTTP support, make sure you migrate any scripts or proxy configurations that use HTTP to the encrypted API endpoint to prevent broken connections.
+
+To turn off HTTP support for API endpoints, run:
+
+```sh
+rladmin cluster config http_support disabled
+```
+
+After you turn off HTTP support, traffic sent to the unencrypted API endpoint is blocked.
+
+
+### HTTP to HTTPS redirection
+Starting with version 6.0.12, you cannot use automatic HTTP to HTTPS redirection.
+To poll metrics from the `metrics_exporter` or to access the Cluster Manager UI, use HTTPS in your request. HTTP requests won't be automatically redirected to HTTPS for those services. 
+
+## Nodes on different VLANs
+
+Nodes in the same cluster must reside on the same VLAN. If you can't
+host the nodes on the same VLAN, then you must open [all ports]({{< relref "/operate/rs/networking/port-configurations.md" >}}) between them.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes how to enable public and private endpoints for databases on
+  a cluster.
+linkTitle: Public and private endpoints
+title: "Enable private and\_public database endpoints"
+weight: $weight
+---
+Each node in Redis Enterprise can be configured with [private and external IP addresses]({{< relref "/operate/rs/networking/multi-ip-ipv6.md" >}}). By default, Redis Enterprise Software databases expose a single endpoint, e.g. cluster.com (FQDN), using the external IP addresses, making it available to the public network (e.g. the internet). Additionally, the cluster can be configured to expose a private FQDN, which utilizes the private IP addresses for access from the private network only (e.g. VPC or an internal network).
+
+When you create a cluster via the UI, you can configure it to expose private and public endpoints.
+This is common for environments such as cloud platforms and enterprises.
+
+When doing so, the cluster creates an additional FQDN, e.g. internal.cluster.com for private network (e.g. VPC or an internal network), while the cluster.com FQDN can be used by a public network (e.g. the internet).
+
+You can enable public and private endpoints during cluster creation only.
+However, you can still add an additional FQDN in a different domain (cluster.io, for example) after cluster creation.
+
+To enable private and public endpoints:
+
+1. Verify the IP addresses are bound to the server or instance.
+
+1. During cluster setup, turn on **Enable public endpoints support** in the **Cluster** screen's **Configuration** section.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/enable-public-endpoints.png" width="75%" alt="The endpoint support setting appears in the **Configuration section** of the **Cluster** setup screen." >}}
+
+    If this setting is not enabled when the cluster is created, databases on the cluster support only a single endpoint.
+
+1. Select **Next** to proceed to **Node** configuration.
+
+1. In the **Network configuration** section:
+
+    1. Configure the machine's public IP address for external traffic.
+
+    1. Configure the private IP address for both internal and external traffic so it can be used for private database endpoints.
+
+After cluster creation, both sets of endpoints are available for databases in the cluster.
+
+To view and copy public and private endpoints for a database in the cluster, see the database's **Configuration > General** section.
+
+{{<image filename="images/rs/screenshots/databases/config-general-endpoints.png" width="75%" alt="View public and private endpoints from the General section of the database's Configuration screen." >}}
+---
+Title: Manage IP addresses
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Information and requirements for using multiple IP addresses or IPv6
+  addresses with Redis Enterprise Software.
+linkTitle: Manage IP addresses
+weight: $weight
+---
+Redis Enterprise Software supports servers, instances, and VMs with
+multiple IPv4 or IPv6 addresses.
+
+## Traffic overview
+
+Redis Enterprise Software traffic is divided into internal traffic and external traffic:
+
+- "Internal traffic" refers to internal cluster communications, such as communications between the nodes for cluster management.
+
+- "External traffic" refers to communications between clients and databases and connections to the Cluster Manager UI.
+
+When only one IP address exists on a machine that serves as a Redis Enterprise node, it is used for both internal and external traffic.
+
+## Multiple IP addresses
+
+During node configuration on a machine with multiple IP addresses, you must assign one address for internal traffic and one or more other addresses for external traffic.
+
+If the cluster uses IPv4 for internal traffic, all communication between cluster nodes uses IPv4 addresses. If the cluster uses IPv6 for internal traffic, all communication between cluster nodes uses IPv6 addresses.
+
+To update IP address configuration after cluster setup, see [Change internal IP address](#change-internal-ip-address) or [Configure external IP addresses](#configure-external-ip-addresses).
+
+## Enable IPv6 for internal traffic
+
+IPv6 for internal communication is supported only for new clusters with Redis Enterprise Software version 7.4.2 or later.
+
+If the server has only IPv6 interfaces, IPv6 is automatically used for internal and external traffic. Otherwise, internal traffic uses IPv4 by default. 
+
+To use IPv6 for internal traffic on a machine with both IPv4 and IPv6 interfaces, set `use_internal_ipv6` to `true` when you create a cluster using the [bootstrap REST API request]({{< relref "/operate/rs/references/rest-api/requests/bootstrap#post-bootstrap" >}}):
+
+```sh
+POST /v1/bootstrap/create_cluster
+{
+    "action": "create_cluster",
+    "cluster": { 
+        "name": "cluster.fqdn" 
+    },
+    "credentials": {
+       "username": "admin_username",
+       "password": "admin_password"
+    },
+    "node": {
+       "identity": {
+          "addr": "2001:DB8::/32",
+          "external_addr": ["2001:0db8:85a3:0000:0000:8a2e:0370:7334"],
+          "use_internal_ipv6": true
+       },
+    },
+    ...
+}
+```
+
+When other IPv6 nodes join a cluster that has `use_internal_ipv6` enabled, they automatically use IPv6 for internal traffic. Do not manually set `use_internal_ipv6` when joining a node to an existing IPv6 cluster, or a `NodeBootstrapError` can occur if the values do not match.
+
+If you try to add a node without an IPv6 interface to a cluster that has `use_internal_ipv6` enabled, a `NodeBootstrapError` occurs.
+
+The host file `/etc/hosts` on each node in the cluster must include the following entry:
+
+```sh
+::1 localhost
+```
+
+## Change internal IP address
+
+Before you change an internal IP address, consider the following:
+
+- Verify the address is valid and bound to an active interface on the node. Failure to do so prevents the node from coming back online and rejoining the cluster.
+
+- Joining a node that only has IPv4 network interfaces to a master node with IPv6 enabled causes a `NodeBootstrapError`.
+
+- Joining a node that only has IPv6 network interfaces to a master node that does not have IPv6 enabled causes a `NodeBootstrapError`.
+
+- You cannot change the internal address from IPv4 to IPv6 or IPv6 to IPv4 in a running cluster. You can only change the internal address within the same protocol as the cluster.
+
+If you need to update the internal IP address in the OS, one option is to remove that node from the cluster, change the IP address, and then add the node back into the cluster.
+
+Alternatively, you can use the following steps to update a node's internal IP address without removing it from the cluster:
+
+1. Turn the node into a replica using [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/node/enslave" >}}):
+
+    ```sh
+    rladmin node <ID> enslave demote_node
+    ```
+
+1. Deactivate the `rlec_supervisor` service on the node:
+
+    ```sh
+    systemctl disable rlec_supervisor 
+    ```
+
+1. Restart the node.
+
+1. Follow the operating system vendor's instructions to change the node's IP address.
+
+1. From a different cluster node, use [`rladmin node addr set`]({{< relref "/operate/rs/references/cli-utilities/rladmin/node/addr" >}}) to update the first node's IP address:
+
+    ```sh
+    rladmin node <ID> addr set <IP address>
+    ```
+
+1. Enable the `rlec_supervisor` service on the node:
+
+    ```sh
+    systemctl enable rlec_supervisor 
+    ```
+
+1. Restart `rlec_supervisor` or restart the node.
+
+
+    ```sh
+    systemctl start rlec_supervisor
+    ```
+
+1. Verify the node rejoined the cluster:
+
+    ```sh
+    rladmin status nodes
+    ```
+
+Repeat this procedure for other cluster nodes to change their internal IP addresses.
+
+## Configure external IP addresses
+
+You can configure external addresses that are not bound to an active interface, but are otherwise mapped or configured to route traffic to the node (such as AWS Elastic IPs or a load balancer VIP).
+
+You can use [rladmin node external_addr]({{< relref "/operate/rs/references/cli-utilities/rladmin/node/external-addr" >}}) to change a node's external IP addresses.
+
+Add an external IP address:
+
+```sh
+rladmin node <ID> external_addr add <IP address>
+```
+
+Set one or more external IP addresses:
+
+```sh
+rladmin node <ID> external_addr set <IP address 1> <IP address N>
+```
+
+
+Remove an external IP address:
+
+```sh
+rladmin node <ID> external_addr remove <IP address>
+```
+
+{{< note >}}
+While [joining a new node to a
+cluster]({{< relref "/operate/rs/clusters/add-node.md" >}})
+during the node bootstrap process,
+when prompted to provide an IP of an existing node in the cluster,
+if you use the node's IP, provide the node's internal IP address.
+{{< /note >}}
+
+## Known limitations
+
+- Using IPv6 for internal traffic is supported only for new clusters running Redis Enterprise Software version 7.4.2 or later.
+
+- Changing an existing cluster's internal traffic from IPv4 to IPv6 is not supported.
+
+- All nodes must use the same protocol for internal traffic.
+
+- If a Redis Enterprise node's host machine has both IPv4 and IPv6 addresses, internal communication within the node initially uses IPv4 until the bootstrap process finishes.
+---
+Title: AWS Route53 DNS management
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to configure AWS Route 53 DNS
+linkTitle: AWS Route 53 DNS
+weight: $weight
+---
+Redis Enterprise Software uses DNS to achieve high availability and fail-over regardless of where it is installed.
+
+
+## What is AWS Route 53?
+
+Route 53 is a scalable DNS service by Amazon Web Service (AWS). It routes user traffic to AWS resources and external sites, offering DNS health checks, traffic management, and failover capabilities. It's integral for high-availability architectures and also provides domain registration services.
+
+## Create a hosted zone
+
+Creating a hosted zone in Amazon Route 53 is a foundational step in managing your domain's DNS settings.
+
+A hosted zone functions as a container for the DNS records of a specific domain. To create one, you first need to:
+
+1. Log into the AWS Management Console
+2. Navigate to the Route 53 dashboard
+3. Select "Create Hosted Zone"
+4. Enter your domain name, and choose public hosted zone
+
+The hosted zone provides you with a set of Name Server (NS) records, which you will need to update at your domain registrar. This process effectively delegates the DNS management of your domain to Route 53, allowing you to create, update, and manage DNS records for your domain within the AWS ecosystem.
+
+{{< image filename="/images/rs/00-CreateHostedZone-en.png" >}}
+
+Once created, it will appear in the list of **Hosted zones**
+
+{{< image filename="/images/rs/03-HostedZoneSelection-en.png" >}}
+
+## Create glue records
+
+A **glue record** is a type of DNS record that helps prevent circular dependencies by providing the IP addresses of your nameservers. To create glue records in Route 53, you first need to set up a hosted zone for your domain. You will create a separate A record for each node in your Redis Enterprise cluster. The **Record name** will be a subdomain definition of the NS record you will define and the **value** should be set to the IP address of the node in your cluster.
+
+{{< image filename="/images/rs/05-NS1Configuration-en.png" >}}
+
+Once complete, it should look something like this
+
+{{< image filename="/images/rs/06-NSList-en.png" >}}
+
+
+## Create nameserver record
+
+When you create a new hosted zone in Route 53 for your domain, a set of NS records is automatically generated. These records list the nameservers assigned by Route 53 to your domain.
+
+You will need to create a new NS record which will point to the glue records created in the previous step.
+
+{{<note>}}
+It is important to make sure that the **Record Name** of the NS record equals the FQDN (Fully Qualified Domain Name) of your Redis Enterprise cluster. If not, DNS resolution will not function correctly.
+{{</note>}}
+
+{{< image filename="/images/rs/07-NSRecord-en.png" >}}
+
+
+## Validate
+
+Once all steps are completed, the configuration should look similar to this
+
+{{< image filename="/images/rs/08-FinalConfig-en.png" >}}
+
+You can test and validate your settings by using the ```dig``` command.
+
+```sh
+dig ns test.demo-rlec.redislabs.com
+
+; <<>> DiG 9.9.5-9+deb8u9-Debian <<>> ns test.demo-rlec.redislabs.com
+;; global options: +cmd
+;; Got answer:
+;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 25061
+;; flags: qr rd ra; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
+
+;; OPT PSEUDOSECTION:
+; EDNS: version: 0, flags:; udp: 4096
+;; QUESTION SECTION:
+;test.demo-rlec.redislabs.com. IN NS
+
+;; ANSWER SECTION:
+test.demo-rlec.redislabs.com. 3409 IN NS node2.test.demo-rlec.redislabs.com.
+test.demo-rlec.redislabs.com. 3409 IN NS node1.test.demo-rlec.redislabs.com.
+test.demo-rlec.redislabs.com. 3409 IN NS node3.test.demo-rlec.redislabs.com.
+
+;; Query time: 31 msec
+;; SERVER: 192.168.1.254#53(192.168.1.254)
+;; WHEN: Tue Feb 14 16:49:13 CET 2017
+;; MSG SIZE  rcvd: 120
+```
+
+You can see that the name are given a prefix of `ns-`. This answer does not come
+from *Route53* but from the cluster nameservers themselves.
+
+---
+Title: Client prerequisites for mDNS
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Requirements for using the mDNS protocol in development and testing environments.
+linkTitle: mDNS client prerequisites
+weight: $weight
+---
+{{< note >}}
+mDNS is only supported for development and testing environments.
+{{< /note >}}
+
+If you choose to use the mDNS protocol when [you set the cluster name]({{< relref "/operate/rs/networking/cluster-dns" >}}),
+make sure that the configurations and prerequisites for resolving database endpoints are met on the client machines.
+If you have [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}}) databases on the cluster,
+the configurations and prerequisites are also required for the Redis Enterprise Software nodes.
+
+To prepare a client or node for mDNS:
+
+1. Make sure that the clients and cluster nodes are on the same physical network
+    or have the network infrastructure configured to allow multicasting between them.
+1. Install these prerequisite packages:
+
+    - For Ubuntu:
+
+        ```sh
+        apt-get install libnss-mdns
+        ```
+
+    - For RHEL/CentOS 6.x:
+
+        ```sh
+        $ rpm -ivh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
+        $ yum install nss-mdns
+        $ service avahi-daemon start
+        ```
+
+    - For RHEL/CentOS 7:
+
+        ```sh
+        $ rpm -ivh https://dl.fedoraproject.org/pub/epel/7/x86_64/Packages/e/epel-release-7-12.noarch.rpm
+        $ yum install nss-mdns
+        $ service avahi-daemon start
+        ```
+
+1. If you are using [mDNS with IPv6 addresses]({{< relref "/operate/rs/networking/multi-ip-ipv6.md" >}}),
+    update the hosts line in `/etc/nsswitch.conf` to:
+
+    ```yaml
+    hosts: files mdns4_minimal
+    \[NOTFOUND=return\] mdns
+    ```
+---
+Title: Set up a Redis Enterprise cluster behind a load balancer
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a Redis Enterprise cluster using a load balancer instead of DNS to direct traffic to cluster nodes.
+linkTitle: Cluster load balancer setup
+weight: $weight
+---
+To set up a Redis Enterprise cluster in an environment that doesn't allow DNS, you can use a load balancer (LB) to direct traffic to the cluster nodes.
+
+## DNS role for databases
+
+Normally, Redis Enterprise uses DNS to provide dynamic database endpoints.
+A DNS name such as `redis-12345.clustername.domain` gives clients access to the database resource:
+
+- If multiple proxies are in use, the DNS name resolves to multiple IP addresses so clients can load balance.
+- On failover or topology changes, the DNS name is automatically updated to reflect the live IP addresses.
+
+When DNS cannot be used, clients can still connect to the endpoints with the IP addresses,
+but the benefits of load balancing and automatic updates to IP addresses won't be available.
+
+## Network architecture with load balancer
+
+You can compensate for the lack of DNS resolution with load balancers that can expose services and provide service discovery.
+A load balancer is configured in front of the Redis Enterprise cluster, exposing several logical services:
+
+- Control plane services, such as the Cluster Manager UI
+- Data plane services, such as database endpoints for client application connections
+
+Depending on which Redis Enterprise services you want to access outside the cluster, you may need to configure the load balancers separately.
+One or more virtual IPs (VIPs) are defined on the load balancer to expose Redis Enterprise services.
+The architecture is shown in the following diagram with a 3-node Redis Enterprise cluster with one database (DB1) configured on port 12000:
+
+{{< image filename="/images/rs/cluster-behind-load-balancer-top-down.png" alt="cluster-behind-load-balancer-top-down" >}}
+
+## Set up a cluster with load balancers
+
+### Prerequisites
+
+- [Install]({{< relref "/operate/rs/installing-upgrading" >}}) the latest version of Redis Enterprise Software on your clusters
+- Configure the cluster with the cluster name (FQDN) even though DNS is not in use.
+    Remember that the same cluster name is used to issue the license keys.
+    We recommend that you use a “.local” suffix in the FQDN.
+
+### Configure load balancers
+
+- Make sure that the load balancer is performing TCP health checks on the cluster nodes.
+- Expose the services that you require through a virtual IP, for example:
+    - Cluster Manager UI on port 8443
+    - Rest API on port 9443 for secure HTTPS connections and port 8080 for HTTP
+    - Database ports 10000-19999
+
+Other ports are shown in the list of [Redis Enterprise network ports]({{< relref "/operate/rs/networking/port-configurations" >}}).
+
+{{< note >}}
+Sticky, secured connections are needed only for the Redis Enterprise Cluster Manager UI on port 8443.
+
+- Certain load balancers provide specific logic to close idle connections. Either turn off this feature or make sure the applications connecting to Redis use reconnection logic.
+- Make sure the load balancer is fast enough to resolve connections between two clusters or applications that are connected to Redis databases through a load balancer.
+- Choose the standard load balancer that is commonly used in your environment so that you have easy access to in-house expertise for troubleshooting issues.
+{{< /note >}}
+
+### Configure cluster
+
+For clusters behind load balancers, we recommend using the `all-nodes` [proxy policy]({{<relref "/operate/rs/databases/configure/proxy-policy">}}) and enabling `handle_redirects`.
+
+To allow inbound connections to be terminated on the relevant node inside the cluster, run the following `rladmin` commands on the cluster:
+
+```sh
+# Enable all-nodes proxy policy by default
+rladmin tune cluster default_sharded_proxy_policy all-nodes default_non_sharded_proxy_policy all-nodes
+
+# Redirect where necessary when behind a load balancer
+rladmin cluster config handle_redirects enabled
+```
+
+Optionally configure sparse shard placement to allow closer termination of client connections to where the Redis shard is located:
+
+```sh
+# Enable sparse placement by default
+rladmin tune cluster default_shards_placement sparse
+```
+
+### Configure database
+
+After you update the cluster settings and configure the load balancers, you can go to the Redis Enterprise Cluster Manager UI at `https://load-balancer-virtual-ip:8443/` and [create a new database]({{< relref "/operate/rs/databases/create.md" >}}).
+
+To create an Active-Active database, use the `crdb-cli` utility. See the [`crdb-cli` reference]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for more information about creating Active-Active databases from the command line.
+
+### Update load balancer configuration when cluster configuration changes
+
+When your Redis Enterprise cluster is behind a load balancer, you must update the load balancer when the cluster topology and IP addresses change.
+Some common cases that require you to update the load balancer are:
+
+- Adding new nodes to the Redis Enterprise cluster
+- Removing nodes from the Redis Enterprise cluster
+- Maintenance for Redis Enterprise cluster nodes
+- IP address changes for Redis Enterprise cluster nodes
+
+After these changes, make sure that the Redis connections in your applications can connect to the Redis database,
+especially if they are directly connected on IP addresses that have changed.
+
+## Intercluster communication considerations
+
+Redis Enterprise supports several topologies that allow intercluster replication, such as [Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of/" >}}) and [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) deployment options.
+When your Redis Enterprise software clusters are behind load balancers, you must allow some network services to be open and defined in the load balancers to allow the replication to work.
+
+### Replica Of
+
+For Replica Of communication to work, you must expose database ports locally in each cluster and allow these ports through any firewalls between the clusters.
+
+### Active-Active
+
+For Active-Active communication to work, you must expose several ports, including every database port and several control plane ports as defined in [Network port configurations]({{< relref "/operate/rs/networking/port-configurations" >}}). Pay attention to services that include "Active-Active" in the connection source column, and allow these ports through any firewalls between the clusters.
+---
+Title: Manage networks
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Networking features and considerations for designing your Redis Enterprise Software deployment.
+hideListLinks: false
+linktitle: Networking
+weight: 39
+---
+---
+Title: Maintenance mode for cluster nodes
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prepare a cluster node for maintenance.
+linkTitle: Maintenance mode
+weight: 60
+---
+
+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:
+
+1. Checks whether a shut down of the node will cause quorum loss. If so, maintenance mode will not turn on.
+
+    Maintenance mode does not protect against quorum loss. If you activate maintenance mode for the majority of nodes in a cluster and restart them simultaneously, quorum is lost, which can lead to  data loss.
+
+1. If no maintenance mode snapshots already exist or if you use `overwrite_snapshot` when you activate maintenance mode, Redis Enterprise creates a new node snapshot that records the node's shard and endpoint configuration.
+
+1. Marks the node as a quorum node to prevent shards and endpoints from migrating to it.
+
+    At this point, [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) displays the node's shards field in yellow, which indicates that shards cannot migrate to the node.
+
+    {{< image filename="/images/rs/maintenance_mode.png" >}}
+
+1. Migrates shards and binds endpoints to other nodes, when space is available.
+
+Maintenance mode does not demote a master node by default. The cluster elects a new master node when the original master node restarts. 
+
+Add the `demote_node` option to the `rladmin` command to [demote a master node](#demote-a-master-node) when you activate maintenance mode.
+
+To activate maintenance mode for a node, run the following command:
+
+```sh
+rladmin node <node_id> maintenance_mode on overwrite_snapshot
+```
+
+You can start server maintenance if:
+
+- All shards and endpoints have moved to other nodes
+
+- Enough nodes are still online to maintain quorum
+
+### Prevent replica shard migration
+
+If you do not have enough resources available to move all of the shards to other nodes, you can turn maintenance mode on without migrating the replica shards.
+
+Before you prevent replica shard migration during maintenance mode, consider the following effects:
+
+- Replica shards remain on the node during maintenance.
+
+- If the maintenance node fails, the master shards do not have replica shards to maintain data redundancy and high availability.
+
+- Replica shards that remain on the node can still be promoted during failover to preserve availability.
+
+To activate maintenance mode without replica shard migration, run:
+
+```sh
+rladmin node <node_id> maintenance_mode on evict_ha_replica disabled evict_active_active_replica disabled
+```
+
+### Demote a master node
+
+If maintenance might affect connectivity to the master node, you can demote the master node when you  activate maintenance mode.  This lets the cluster elect a new master node.
+
+To demote a master node when activating maintenance mode, run:
+
+```sh
+rladmin node <node_id> maintenance_mode on demote_node
+```
+
+### Verify maintenance mode activation
+
+To verify maintenance mode for a node, use `rladmin status` and review the node's shards field.  If that value is displayed in yellow (shown earlier), then the node is in maintenance mode.
+
+Avoid activating maintenance mode when it is already active.  Maintenance mode activations stack.  If you activate maintenance mode for a node that is already in maintenance mode, you will have to deactivate maintenance mode twice in order to restore full functionality.
+
+## Deactivate maintenance mode
+
+When you deactivate maintenance mode, Redis Enterprise:
+
+1. Loads a [specified node snapshot](#specify-a-snapshot) or defaults to the latest maintenance mode snapshot.
+
+1. Unmarks the node as a quorum node to allow shards and endpoints to migrate to the node.
+
+1. Restores the shards and endpoints that were in the node at the time of the snapshot.
+
+1. Deletes the snapshot.
+
+To deactivate maintenance mode after server maintenance, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off
+```
+
+By default, a snapshot is required to deactivate maintenance mode.  If the snapshot cannot be restored, deactivation is cancelled and the node remains in maintenance mode.  In such events, it may be necessary to [reset node status](#reset_node_status).
+
+### Specify a snapshot
+
+When you turn off maintenance mode, you can restore the node configuration from a maintenance mode snapshot or any snapshots previously created by [`rladmin node <node_id> snapshot create`]({{< relref "/operate/rs/references/cli-utilities/rladmin/node/snapshot#node-snapshot-create" >}}). If you do not specify a snapshot, Redis Enterprise uses the latest maintenance mode snapshot by default.
+
+To get a list of available snapshots, run:
+
+```sh
+rladmin node <node_id> snapshot list
+```
+
+To specify a snapshot when you turn maintenance mode off, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off snapshot_name <snapshot_name>
+```
+
+{{<note>}}
+If an error occurs when you turn on maintenance mode, the snapshot is not deleted.
+When you rerun the command, use the snapshot from the initial attempt since it contains the original state of the node.
+{{</note>}}
+
+### Skip shard restoration
+
+You can prevent the migrated shards and endpoints from returning to the original node after you turn off maintenance mode.
+
+To turn maintenance mode off and skip shard restoration, run:
+
+```sh
+rladmin node <node_id> maintenance_mode off skip_shards_restore
+```
+
+### Reset node status
+
+In extreme cases, you may need to reset a node's status.  Run the following commands to do so:
+
+```
+$ rladmin tune node <node_id> max_listeners 100
+$ rladmin tune node <node_id> quorum_only disabled
+```
+
+Use these commands with caution.  For best results, contact Support before running these commands.
+
+## Cluster status example
+
+This example shows how the output of [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) changes when you turn on maintenance mode for a node.
+
+The cluster status before turning on maintenance mode:
+
+```sh
+redislabs@rp1_node1:/opt$ rladmin status
+CLUSTER NODES:
+NODE:ID   ROLE     ADDRESS       EXTERNAL_ADDRESS     HOSTNAME    SHARDS
+*node:1   master   172.17.0.2                         rp1_node1   2/100
+node:2    slave    172.17.0.4                         rp3_node1   2/100
+node:3    slave    172.17.0.3                         rp2_node1   0/100
+```
+
+The cluster status after turning on maintenance mode:
+
+```sh
+redislabs@rp1_node1:/opt$ rladmin node 2 maintenance_mode on
+Performing maintenance_on action on node:2: 0%
+created snapshot NodeSnapshot<name=maintenance_mode_2019-03-14_09-50-59,time=None,node_uid=2>
+
+node:2 will not accept any more shards
+Performing maintenance_on action on node:2: 100%
+OK
+redislabs@rp1_node1:/opt$ rladmin status
+CLUSTER NODES:
+NODE:ID   ROLE     ADDRESS       EXTERNAL_ADDRESS     HOSTNAME    SHARDS
+*node:1   master   172.17.0.2                         rp1_node1   2/100
+node:2    slave    172.17.0.4                         rp3_node1   0/0
+node:3    slave    172.17.0.3                         rp2_node1   2/100
+```
+
+After turning on maintenance mode for node 2, Redis Enterprise saves a snapshot of its configuration and then moves its shards and endpoints to node 3.
+
+Now node 2 has `0/0` shards because shards cannot migrate to it while it is in maintenance mode.
+
+## Maintenance mode REST API
+
+You can also turn maintenance mode on or off using [REST API requests]({{< relref "/operate/rs/references/rest-api" >}}) to [<nobr>POST `/nodes/{node_uid}/actions/{action}`</nobr>]({{< relref "/operate/rs/references/rest-api/requests/nodes/actions#post-node-action" >}}).
+
+### Activate maintenance mode (REST API)
+
+Use <nobr>`POST /nodes/{node_uid}/actions/maintenance_on`</nobr> to activate maintenance mode:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_on
+{
+    "overwrite_snapshot": true,
+    "evict_ha_replica": true,
+    "evict_active_active_replica": true
+}
+```
+
+You can set `evict_ha_replica` and `evict_active_active_replica` to `false` to [prevent replica shard migration](#prevent-replica-shard-migration).
+
+The `maintenance_on` request returns a JSON response body:
+
+```json
+{
+    "status":"queued",
+    "task_id":"<task-id-guid>"
+}
+```
+
+### Deactivate maintenance mode (REST API)
+
+Use <nobr>`POST /nodes/{node_uid}/actions/maintenance_off`</nobr> deactivate maintenance mode:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_off
+{ "skip_shards_restore": false }
+```
+
+The `skip_shards_restore` boolean flag allows the `maintenance_off` action to [skip shard restoration](#skip-shard-restoration) when set to `true`.
+
+The `maintenance_off` request returns a JSON response body:
+
+```json
+{
+    "status":"queued",
+    "task_id":"<task-id-guid>"
+}
+```
+
+### Track action status
+
+You can send a request to [<nobr>GET `/nodes/{node_uid}/actions/{action}`</nobr>]({{< relref "/operate/rs/references/rest-api/requests/nodes/actions#get-node-action" >}}) to track the [status]({{< relref "/operate/rs/references/rest-api/objects/action" >}}) of the `maintenance_on` and `maintenance_off` actions.
+
+This request returns the status of the `maintenance_on` action:
+
+```sh
+GET https://<hostname>:9443/v1/nodes/<node_id>/actions/maintenance_on
+```
+
+The response body:
+
+```json
+{
+    "status":"completed",
+    "task_id":"38c7405b-26a7-4379-b84c-cab4b3db706d"
+}
+```
+---
+Title: Recover a failed cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to use the cluster configuration file and database data to recover
+  a failed cluster.
+linktitle: Recover a cluster
+weight: 70
+---
+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]({{< relref "/operate/kubernetes/re-clusters/cluster-recovery" >}}).
+{{< /note >}}
+
+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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+The cluster recovery process includes:
+
+1. Install Redis Enterprise Software on the nodes of the new cluster.
+1. Mount the persistent storage with the recovery files from the original cluster to the nodes of the new cluster.
+1. Recover the cluster configuration on the first node in the new cluster.
+1. Join the remaining nodes to the new cluster.
+1. [Recover the databases]({{< relref "/operate/rs/databases/recover.md" >}}).
+
+## Prerequisites
+
+- We recommend that you recover the cluster to clean nodes.
+    If you use the original nodes,
+    make sure there are no Redis processes running on any nodes in the new cluster.
+- We recommend that you use clean persistent storage drives for the new cluster.
+    If you use the original storage drives,
+    make sure you back up the files on the original storage drives to a safe location.
+- Identify the cluster configuration file that you want to use as the configuration for the recovered cluster.
+    The cluster configuration file is `/ccs/ccs-redis.rdb` on the persistent storage for each node.
+
+## Recover the cluster
+
+1. (Optional) If you want to recover the cluster to the original cluster nodes, uninstall Redis Enterprise Software from the nodes.
+
+1. [Install Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on the new cluster nodes.
+
+    The new servers must have the same basic hardware and software configuration as the original servers, including:
+
+    - The same number of nodes
+    - At least the same amount of memory
+    - The same Redis Enterprise Software version
+    - The same installation user and paths
+
+    {{< note >}}
+The cluster recovery can fail if these requirements are not met.
+    {{< /note >}}
+
+1. Mount the persistent storage drives with the recovery files to the new nodes.
+    These drives must contain the cluster configuration backup files and database persistence files.
+
+    {{< note >}}
+Make sure that the user redislabs has permissions to access the storage location
+of the configuration and persistence files on each of the nodes.
+    {{< /note >}}
+
+    If you use local persistent storage, place all of the recovery files on each of the cluster nodes.
+
+1. To recover the original cluster configuration, run [`rladmin cluster recover`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/recover" >}}) on the first node in the new cluster:
+
+    ```sh
+    rladmin cluster recover filename [ <persistent_path> | <ephemeral_path> ]<filename> node_uid <node_uid> rack_id <rack_id>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster recover filename /tmp/persist/ccs/ccs-redis.rdb node_uid 1 rack_id 5
+    ```
+
+    When the recovery command succeeds,
+    this node is configured as the node from the old cluster that has ID 1.
+
+1. To join the remaining servers to the new cluster, run [`rladmin cluster join`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/join" >}}) from each new node:
+
+    ```sh
+    rladmin cluster join nodes <cluster_member_ip_address> username <username> password <password> replace_node <node_id>
+    ```
+
+    For example:
+
+    ```sh
+    rladmin cluster join nodes 10.142.0.4 username admin@example.com password mysecret replace_node 2
+    ```
+
+1. Run [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) to verify the recovered nodes are now active and the databases are pending recovery:
+
+    ```sh
+    rladmin status
+    ```
+
+    {{< note >}}
+Make sure that you update your [DNS records]({{< relref "/operate/rs/networking/cluster-dns" >}})
+with the IP addresses of the new nodes.
+    {{< /note >}}
+
+After the cluster is recovered, you must [recover the databases]({{< relref "/operate/rs/databases/recover.md" >}}).
+---
+Title: "Redis OSS Cluster API"
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- rc
+description: Use the Redis OSS Cluster API to improve performance and keep applications current with cluster topology changes.
+linktitle: "Redis OSS Cluster API"
+weight: $weight
+---
+{{< embed-md "oss-cluster-api-intro.md"  >}}
+
+You can use the Redis OSS Cluster API along with other Redis Enterprise Software high availability
+to get high performance with low latency
+and let applications stay current with cluster topology changes, including add node, remove node, and node failover.
+
+For more about working with the OSS Cluster API in Redis Enterprise Software, see [Enable OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}). 
+
+To learn how to enable OSS Cluster API in Redis Cloud, see [Clustering Redis databases]({{< relref "/operate/rc/databases/configuration/clustering#cluster-api" >}}).
+---
+Title: Turn off services to free system memory
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turn off services to free memory and improve performance.
+linktitle: Free system memory
+weight: $weight
+---
+The Redis Enterprise Software cluster nodes host a range of services that support the cluster processes.
+In most deployments, either all of these services are required,
+or there are enough memory resources on the nodes for the database requirements.
+
+In a deployment with limited memory resources, certain services can be disabled from API endpoint to free system memory or using the `rladmin` command.
+Before you turn off a service, make sure that your deployment does not depend on that service.
+After you turn off a service, you can re-enable in the same way.
+
+The services that you can turn off are:
+
+- RS Admin Console - `cm_server`
+- Logs in CSV format - `stats_archiver`
+- [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap" >}}) - `saslauthd`
+- [Discovery service]({{< relref "/operate/rs/networking/cluster-dns.md" >}})- `mdns_server`, `pdns_server`
+- [Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) - `crdb_coordinator`, `crdb_worker`
+- Alert Manager - `alert_mgr` (For best results, disable only if you have an alternate alert system.)
+
+To turn off a service with the `rladmin cluster config` command, use the `services` parameter and the name of the service, followed by `disabled`.
+```text
+ rladmin cluster config
+        [ services <service_name> <enabled | disabled> ]
+```
+
+To turn off a service with the API, use the [`PUT /v1/services_configuration`]({{< relref "/operate/rs/references/rest-api/requests/cluster/services_configuration#put-cluster-services_config" >}}) endpoint
+with the name of the service and the operating mode (enabled/disabled) in JSON format.
+
+For example:
+- To turn off the Redis Enterprise Cluster Manager UI, use this PUT request:
+
+    ```sh
+    PUT https://[host][:9443]/v1/cluster/services_configuration
+    '{
+        "cm_server":{
+            "operating_mode":"disabled"
+        }
+    }'
+    ```
+
+- To turn off the CRDB services and enable the `stats_archiver` for cluster component statistics, use this PUT request:
+
+    ```sh
+    PUT https://[host][:9443]/v1/cluster/services_configuration
+    '{
+        "crdb_coordinator":{
+            "operating_mode":"disabled"
+        },
+        "crdb_worker":{
+            "operating_mode":"disabled"
+        },
+        "stats_archiver":{
+            "operating_mode":"enabled"
+        }
+    }'
+    ```
+---
+Title: Benchmarking Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use the `memtier_benchmark` tool to perform a performance benchmark of
+  Redis Enterprise Software.
+linkTitle: Benchmark
+weight: $weight
+---
+
+Use the `memtier_benchmark` tool to perform a performance benchmark of Redis Enterprise Software.
+
+Prerequisites:
+
+- Redis Enterprise Software installed
+- A cluster configured
+- A database created
+
+For help with the prerequisites, see the [Redis Enterprise Software quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}).
+
+It is recommended to run memtier_benchmark on a separate node that is
+not part of the cluster being tested. If you run it on a node of the
+cluster, be mindful that it affects the performance of both the
+cluster and memtier_benchmark.
+
+```sh
+/opt/redislabs/bin/memtier_benchmark -s $DB_HOST -p $DB_PORT -a $DB_PASSWORD -t 4 -R --ratio=1:1
+```
+
+This command instructs memtier_benchmark to connect to your Redis
+Enterprise database and generates a load doing the following:
+
+- A 50/50 Set to Get ratio
+- Each object has random data in the value
+
+## Populate a database with testing data
+
+If you need to populate a database with some test data for a proof of
+concept, or failover testing, etc. here is an example for you.
+
+```sh
+/opt/redislabs/bin/memtier_benchmark -s $DB_HOST -p $DB_PORT -a $DB_PASSWORD -R -n allkeys -d 500 --key-pattern=P:P --ratio=1:0
+```
+
+This command instructs memtier_benchmark to connect to your Redis
+Enterprise database and generates a load doing the following:
+
+- Write objects only, no reads
+- A 500 byte object
+- Each object has random data in the value
+- Each key has a random pattern, then a colon, followed by a
+    random pattern.
+
+Run this command until it fills up your database to where you want it
+for testing. The easiest way to check is on the database metrics page.
+
+{{< image filename="/images/rs/memtier_metrics_page.png" >}}
+
+Another use for memtier_benchmark is to populate a database with data
+for failure testing.
+---
+Title: Disk sizing for heavy write scenarios
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sizing considerations for persistent disk space for heavy throughput
+  databases.
+linktitle: Disk sizing
+weight: $weight
+---
+In extreme write scenarios, when AOF is enabled, the AOF rewrite process
+may require considerably more disk space for database persistence.
+
+To estimate the required persistent disk space in such cases, use the
+formula described below.
+
+**The required persistent disk space for AOF rewrite purposes in extreme
+write scenarios, assuming identical shard sizes:**
+
+**X (1 + 3Y +Y²)**
+where:
+**X** = each shard size
+**Y** = number of shards
+
+Following are examples of database configurations and the persistence
+disk space they would require in this scenario:
+
+|   | Example 1 | Example 2 | Example 3 | Example 4 |
+|---|------------|-----------------|------------|-----------------|
+| Database size (GB) | 10 | 10 | 40 | 40 |
+| Number of shards | 4 | 16 | 5 | 15 |
+| Shard size (GB) | 2.5 | 0.625 | 8 | 2.67 |
+| Required disk space (GB) | 73 | 191 | 328 | 723 |
+
+For disk size requirements in standard usage scenarios, refer to the
+[Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})
+section.
+---
+Title: Cluster environment optimization
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Optimize your cluster environments for better performance.
+linktitle: Environment optimization
+weight: $weight
+---
+Redis Enterprise Software uses various algorithms to optimize
+performance. As part of this process, Redis Enterprise Software examines usage
+and load to adjust its runtime configuration. Depending
+on your specific usage and load, Redis Enterprise Software might take some
+time to adjust for optimal performance.
+
+To ensure optimal performance, you must run your workload several times
+and for a long duration until performance stabilizes.
+
+## Failure detection sensitivity policies
+
+You can optimize your cluster's thresholds and timeouts for different environments using the `failure_detection_sensitivity` cluster policy:
+
+- `high` (previously known as `local-network watchdog_profile`) – high failure detection sensitivity, lower thresholds, and faster failure detection and failover
+
+- `low` (previously known as `cloud watchdog_profile`) – low failure detection sensitivity and higher tolerance for latency variance (also called network jitter)
+
+Depending on which policy you choose, Redis Enterprise Software uses different
+thresholds to make operation-related decisions.
+
+The default policy is `high` failure detection sensitivity for `local-network` environments. If you are
+running Redis Enterprise in a cloud environment, you should change the
+configuration.
+
+## Change failure detection sensitivity
+
+To change the cluster's `failure_detection_sensitivity`, run one of the following [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-cluster" >}}) commands.
+
+- For Redis Enterprise Software version 6.4.2-69 and later, run:
+
+    ```sh
+    rladmin tune cluster failure_detection_sensitivity [ low | high ]
+    ```
+
+- For Redis Enterprise Software version 6.4.2-61 and earlier, run:
+
+    ```sh
+    rladmin tune cluster watchdog_profile [ cloud | local-network ]
+    ```
+
+If Redis Enterprise Software still
+does not meet your performance expectations after following these instructions, [contact support](https://redis.com/company/support/) for help optimizing your environment.
+---
+Title: Use the WAIT command to improve data safety and durability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Use the wait command to take full advantage of Redis Enterprise Software's
+  replication-based durability.
+linkTitle: WAIT command
+weight: $weight
+---
+Redis Enterprise Software comes with the ability to replicate data
+to another replica for high availability and persist in-memory data on
+disk permanently for durability. With the [`WAIT`]({{<relref "/commands/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:
+
+1. Application issues a write.
+1. Proxy communicates with the correct primary shard in the system that contains the given key.
+1. The acknowledgment is sent to proxy after the write operation completes.
+1. The proxy sends the acknowledgment back to the application.
+
+Independently, the write is communicated from the primary shard to the replica, and
+replication acknowledges the write back to the primary shard. These are steps 5 and 6.
+
+Independently, the write to a replica is also persisted to disk and
+acknowledged within the replica. These are steps 7 and 8.
+
+{{< image filename="/images/rs/weak-consistency.png" >}}
+
+## Blocking write operation on replication
+
+With the [`WAIT`]({{<relref "/commands/wait">}}) or [`WAITAOF`]({{<relref "/commands/waitaof">}}) commands, applications can ask to wait for
+acknowledgments only after replication or persistence is confirmed on
+the replica. The flow of a write operation with `WAIT` or `WAITAOF` is:
+
+1. The application issues a write.
+1. The proxy communicates with the correct primary shard in the system that contains the given key.
+1. Replication communicates the update to the replica shard.
+1. If using `WAITAOF` and the AOF every write setting, the replica persists the update to disk before sending the acknowledgment.
+1. The acknowledgment is sent back from the replica all the way to the proxy with steps 5 to 8.
+
+The application only gets the acknowledgment from the write after durability is achieved with replication to the replica for `WAIT` or `WAITAOF` and to the persistent storage for `WAITAOF` only.
+
+{{< image filename="/images/rs/strong-consistency.png" >}}
+
+The `WAIT` command always returns the number of replicas that acknowledged the write commands sent by the current client before the `WAIT` command, both in the case where the specified number of replicas are reached, or when the timeout is reached. In Redis Enterprise Software, the number of replicas is always 1 for databases with high availability enabled.
+
+See the [`WAITAOF`]({{<relref "/commands/waitaof">}}) command for details for enhanced data safety and durability capabilities introduced with Redis 7.2.
+---
+Title: Optimize clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configuration changes and information you can use to optimize your performance
+  and memory usage.
+hideListLinks: false
+linktitle: Optimize
+weight: 50
+---
+---
+Title: Rack-zone awareness in Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Rack-zone awareness ensures high availability in the event of a rack
+  or zone failure.
+linkTitle: Rack-zone awareness
+weight: 70
+---
+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](#rack-zone-id-rules) to each node. This ID is used to map the node to a
+physical rack or logical zone. The cluster can then ensure that master shards, corresponding replica shards, and associated endpoints are placed on [nodes in different racks or zones](#node-layout-guidelines).
+
+In the event of a rack or zone failure, the replicas and endpoints in the remaining racks and zones are promoted. This ensures high availability when a rack or zone fails.
+
+There is no limitation on the number of racks and zones per cluster. Each
+node can belong to a different rack or multiple nodes can belong to the
+same rack.
+
+Rack-zone awareness affects various cluster, node, and database actions, such as node rebalancing, node removal, node replacement, shard and endpoint migration, and database failover.
+
+## Rack-zone ID rules
+
+The rack-zone ID must comply with the following rules:
+
+- Maximum length of 63 characters.
+- Characters consist of letters, digits, and hyphens ('-'). Underscores ('_') are also accepted as of Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}).
+- ID starts with a letter and ends with a letter or a digit.
+
+{{< note >}}
+Rack-zone IDs are **case-insensitive** (uppercase and lowercase letter are treated as the same).
+{{< /note >}}
+
+## Node layout guidelines
+
+Avoid placing the majority of nodes in one availability zone.
+
+If a Redis Enterprise Software cluster consists of three nodes (the recommended minimum), follow these guidelines:
+
+- For high availability, the three nodes must be distributed across three *distinct* racks or zones.
+
+- When using availability zones, all three zones should exist within the same *region* to avoid potential latency issues.
+
+## Set up rack-zone awareness
+
+To enable rack-zone awareness, you need to configure it for the
+cluster, nodes, and [databases](#enable-database-rack-zone-awareness).
+
+### New cluster
+
+You can set up rack-zone awareness for the cluster and its nodes during [cluster creation]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}):
+
+1. In the **Cluster** screen's **Configuration** section, enable **Rack zone awareness**.
+
+1. Select **Next** to continue to the **Node** configuration screen.
+
+1. Enter a **Rack-zone ID** for the current node.
+
+1. Finish [cluster setup]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}).
+
+1. For every [node you add to the cluster]({{< relref "/operate/rs/clusters/add-node" >}}), assign a different **Rack-zone ID**.
+
+### Existing cluster
+
+If you did not configure rack-zone awareness during cluster creation, you can configure rack-zone awareness for existing clusters using the [REST API]({{< relref "/operate/rs/references/rest-api" >}}):
+
+1. For each node in the cluster, assign a different rack-zone ID using the REST API to [update the node]({{< relref "/operate/rs/references/rest-api/requests/nodes#put-node" >}}):
+
+    ```sh
+    PUT /v1/nodes/<node-ID>
+    { "rack_id": "rack-zone-ID" }
+    ```
+
+1. [Update the cluster policy]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy" >}}) to enable rack-zone awareness:
+
+    ```sh
+    PUT /v1/cluster/policy
+    { "rack_aware": true }
+    ```
+
+## Enable database rack-zone awareness
+
+Before you can enable rack-zone awareness for a database, you must configure rack-zone awareness for the cluster and its nodes. For more information, see [set up rack-zone awareness](#set-up-rack-zone-awareness).
+
+<!--
+To enable rack-zone awareness for a database using the Cluster Manager UI:
+
+1. From **databases**, [create a new database]({{< relref "/operate/rs/databases/create" >}}) or edit an existing database's **configuration**.
+
+1. Expand the **High availability & durability** section.
+
+1. Enable [**Replication**]({{< relref "/operate/rs/databases/durability-ha/replication" >}}).
+
+1. Select **Rack-zone awareness**.
+
+    {{<image filename="images/rs/screenshots/databases/config-rack-zone-awareness.png" alt="Select the Rack-zone awareness checkbox to enable rack-zone awareness for the database." >}}
+
+1. **Create** or **Save** your database.
+
+1. [Rearrange database shards](#rearrange-database-shards) to optimize an existing database for rack-zone awareness.
+
+    {{<note>}}
+If you enabled rack-zone awareness during database creation, you can ignore this step.
+    {{</note>}}
+-->
+
+To enable rack-zone awareness for a database, use a [REST API request]({{< relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs" >}}):
+
+```sh
+PUT /v1/bdbs/<database-ID>
+{ "rack_aware": true }
+```
+
+### Rearrange database shards
+
+After you enable rack-zone awareness for an existing database, you should generate an optimized shard placement blueprint using the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) and use it to rearrange the shards in different racks or zones.
+
+1. [Generate an optimized shard placement blueprint]({{< relref "/operate/rs/references/rest-api/requests/bdbs/actions/optimize_shards_placement#get-bdbs-actions-optimize-shards-placement" >}}):
+
+    1. Send the following `GET` request:
+
+        ```sh
+        GET /v1/bdbs/<database-ID>/actions/optimize_shards_placement
+        ```
+
+    1. Copy the `cluster-state-id` from the response headers.
+
+    1. Copy the JSON response body, which represents the new shard placement blueprint.
+
+1. [Rearrange the database shards]({{< relref "/operate/rs/references/rest-api/requests/bdbs/actions/optimize_shards_placement#put-bdbs-rearrange-shards" >}}) according to the new shard placement blueprint:
+
+    1. In the request headers, include the <nobr>`cluster-state-id`</nobr> from the `optimize_shards_placement` response.
+
+    1. Add the following JSON in the request body and replace <nobr>`<shard placement blueprint>`</nobr> with the new blueprint:
+
+        ```sh
+        {
+          "shards_blueprint": <shard placement blueprint>
+        }
+        ```
+
+    1. Send the following `PUT` request to rearrange the shards:
+
+        ```sh
+        PUT /v1/bdbs/<database-ID>
+        ```
+
+## Shard placement without rack-zone awareness
+
+Even if a database has rack-zone awareness turned off, the cluster still ensures that master and replica shards are placed on distinct nodes.
+---
+Title: Cluster settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: You can view and set various cluster settings such as cluster name, email
+  service, time zone, and license.
+linktitle: Cluster settings
+toc: 'true'
+weight: 10
+---
+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]({{< relref "/operate/rs/clusters/configure/license-keys.md" >}}).
+
+### View max number of allowed shards
+
+The maximum number of allowed shards, which is determined by the cluster license
+key, appears in the **Max number of shards** field in the **License** section.
+
+### View cluster name
+
+The cluster name appears in the **Cluster name** field in the **License** section. This gives a
+common name that your team or Redis support can refer to. It is
+especially helpful if you have multiple clusters.
+
+### Set time zone
+
+You can change the **Time zone** field to ensure the date, time fields, and log entries in the Cluster Manager UI are shown in your preferred time zone. This setting doesn't affect other system logs or services.
+
+## Alert settings tab
+
+The **Alert Settings** tab lets you configure alerts that are relevant to the entire cluster, such as alerts for cluster utilization, nodes, node utilization, security, and database utilization.
+
+You can also configure email server settings and [send alerts by email]({{< relref "/operate/rs/monitoring/v1_monitoring#send-alerts-by-email" >}}) to relevant users.
+
+### Configure email server settings
+
+To enable email alerts:
+
+1. Enter your email
+server details in the **Email server settings** section.
+
+1. Select a connection security method:
+
+    - TLS/SSL 
+
+    - STARTTLS
+    
+    - None
+
+1. Send a test email to verify your email server settings.
+---
+Title: Configure clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configuration options for your Redis Enterprise cluster.
+hideListLinks: false
+linktitle: Configure
+weight: 50
+---
+You can manage your Redis Enterprise Software clusters with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([rladmin]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}), [redis-cli]({{< relref "/develop/tools/cli" >}}), [crdb-cli]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/references/rest-api/_index.md" >}})
+
+
+
+---
+Title: Cluster license keys
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The cluster key (or license) enables features and capacity within Redis
+  Enterprise Software
+linktitle: License keys
+weight: 20
+---
+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.
+
+Trial mode is limited to 30 days and 4 shards, including master and replica shards. A new Redis Enterprise Software installation starts its 30-day trial period from the day you set up the cluster on the first node.
+
+Trial mode requires a trial license. If you do not provide a license when you create a cluster using the Cluster Manager UI or a [bootstrapping REST API request]({{< relref "/operate/rs/references/rest-api/requests/bootstrap#post-bootstrap" >}}), a trial cluster license is generated by default.
+
+## View cluster license key
+
+To view the cluster license key, use:
+
+- Cluster Manager UI
+
+    1. Go to **Cluster > Configuration > General > License** to see the cluster license details.
+
+    1. Select **Change** to view the cluster license key.
+
+- REST API - [`GET /v1/license`]({{< relref "/operate/rs/references/rest-api/requests/license#get-license" >}})
+
+    For a list of returned fields, see the [response section]({{< relref "/operate/rs/references/rest-api/requests/license#get-response" >}}).
+
+{{<note>}}
+As of version 7.2, Redis Enterprise enforces shard limits by shard types, RAM or flash, instead of the total number of shards. The flash shards limit only appears in the UI if Auto Tiering is enabled.
+{{</note>}}
+
+## Update cluster license
+
+{{< note >}}
+After you add a cluster key, you cannot remove the key to return the cluster to trial mode.
+{{< /note >}}
+
+You can update the cluster license key:
+
+- During cluster setup using the Cluster Manager UI or CLI
+
+- After cluster setup using the Cluster Manager UI:
+
+    1. Go to **Cluster > Configuration > General > License**.
+    
+    1. Select **Change**.
+
+    1. Upload or enter your cluster license key.
+    
+    1. Select **Save**.
+
+You can update an existing cluster key at any time.
+Redis Enterprise checks its validity for the following:
+- Cluster name
+- Activation and expiration dates
+- Shard usage and limits
+- Features
+
+If saving a new cluster key fails, the operation returns an error with the failure's cause.
+In this case, the existing key stays in effect.
+
+## Expired cluster license
+
+When the license is expired:
+
+- You cannot do these actions:
+
+    - Change database settings, including security and configuration options.
+
+    - Add a database.
+
+- You can do these actions:
+
+    - Sign in to the Cluster Manager UI and view settings and metrics at all resolutions for the cluster, nodes, and databases.
+
+    - Change cluster settings, including the license key, security for administrators, and cluster alerts.
+
+    - Fail over when a node fails and explicitly migrate shards between nodes.
+
+    - Upgrade a node to a new version of Redis Enterprise Software.
+
+## Configure license expiration alert
+
+By default, a cluster license alert is scheduled to occur 7 days before the cluster license expiration date.
+
+{{<image filename="images/rs/screenshots/cluster/cluster-license-expiration-alert.png" alt="An alert appears in the Cluster Manager UI that says 'Your license will expire on day-month-year time. Contact support to renew your license.'" >}}
+
+You can adjust the threshold value of the cluster license expiration alert based on how far in advance you want to be notified of the license expiration. The value should be within a reasonable range that allows your organization enough time to take action, such as renewing the license, before it expires.
+
+To change the cluster license alert settings, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. On the **Cluster > Configuration** screen, select the **Alerts Settings** tab.
+
+    1. Click **Edit**.
+
+    1. In the **Cluster utilization** section, enable the alert setting "License expiry notifications will be sent \<value\> days before the license expires" and enter a new value in the box.
+
+        {{<image filename="images/rs/screenshots/cluster/cluster-config-alert-settings-utilization.png" alt="Cluster utilization alert settings." >}}
+
+    1. Click **Save**.
+
+
+- [Update cluster]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) REST API request:
+
+    The following example changes the cluster license alert to occur 30 days before the cluster license expiration date:
+
+    ```sh
+    PUT /v1/cluster
+    {
+        "alert_settings": {
+            "cluster_license_about_to_expire": {
+                "enabled": true,
+                "threshold": "30"
+            }
+        }
+    }
+    ```
+
+## Monitor cluster license
+
+As of version 7.2, Redis Enterprise exposes the license quotas and the shards consumption metrics in the Cluster Manager UI or via the [Prometheus integration]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}}).
+
+The `cluster_shards_limit` metric displays the total shard limit by shard type.
+
+Examples:
+- `cluster_shards_limit{cluster="mycluster.local",shard_type="ram"} 100.0`
+- `cluster_shards_limit{cluster="mycluster.local",shard_type="flash"} 50.0`
+
+The `bdb_shards_used` metric displays the used shard count by database and shard type.
+
+Examples:
+- `bdb_shards_used{bdb="2",cluster="mycluster.local",shard_type="ram"} 86.0`
+- `bdb_shards_used{bdb="3",cluster="mycluster.local",shard_type="flash"} 23.0`
+
+---
+Title: Synchronize cluster node clocks
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Sync node clocks to avoid problems with internal custer communication.
+linktitle: Sync node clocks
+weight: 30
+---
+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.
+
+To synchronize the server clock, run the command that is appropriate for your operating system.
+
+## Set up NTP synchronization
+
+To set up NTP synchronization, see the following sections for instructions for specific operating systems.
+
+### Ubuntu 18.04 and Ubuntu 20.04
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo apt install chrony
+   ```
+   
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Restart the Chrony service: 
+   ```sh
+   sudo systemctl restart chrony
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chrony
+   ```
+   
+For more details, refer to the official [Ubuntu 20.04 documentation](https://ubuntu.com/server/docs/network-ntp).
+
+### RHEL 7
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+    sudo yum install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh 
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [RHEL 7 documentation](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/system_administrators_guide/ch-configuring_ntp_using_the_chrony_suite#sect-Using_chrony).
+
+### RHEL 8 and RHEL 9
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo dnf install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+   sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [RHEL 8 and 9 documentation](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_basic_system_settings/configuring-time-synchronization_configuring-basic-system-settings).
+
+### Amazon Linux 2
+
+1. Install Chrony, a replacement for NTP:
+   ```sh
+   sudo yum install chrony
+   ```
+
+1. Edit the Chrony configuration file:
+   ```sh
+    sudo nano /etc/chrony.conf
+   ```
+
+1. Add `server pool.ntp.org` to the file, replace `pool.ntp.org` with your own NTP server, then save.
+
+1. Enable and start the Chrony service:
+   ```sh
+   sudo systemctl enable chronyd && sudo systemctl start chronyd
+   ```
+
+1. Check the Chrony service status:
+   ```sh
+   sudo systemctl status chronyd
+   ```
+
+For more details, refer to the official [Amazon Linux 2 documentation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/set-time.html).
+
+If you are using Active-Active databases, you must use [Network Time Service (ntpd)]({{< relref "/operate/rs/databases/active-active/_index.md#network-time-service-ntp-or-chrony" >}})
+to synchronize OS clocks consistently across clusters to handle conflict resolution according to the OS time.
+---
+Title: Replace a cluster node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Replace a node in your cluster that is down.
+linkTitle: Replace node
+weight: 90
+---
+A failed node will appear as `Down` ({{< image filename="/images/rs/icons/node-down-icon.png#no-click" alt="Node down icon" class="inline" >}}) in the **Nodes** list.
+
+To replace a failed node: 
+
+1. Prepare a new node identical to the old one.
+
+1.  Install and
+    configure Redis Enterprise Software on the node. See [Install and setup]({{< relref "/operate/rs/installing-upgrading" >}}) for more information.
+
+    {{< note >}}
+If you are using [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}), make sure the required flash storage is set up on this new node.
+    {{< /note >}}
+
+1. [Add the node]({{< relref "/operate/rs/clusters/add-node" >}}) to the cluster. Make sure the new node has as much available memory as the faulty
+    node.
+
+    If the new node does not have enough memory, you will be prompted to add a node with enough memory.
+
+1. A message will appear informing you that the cluster has a faulty node
+    and that the new node will replace the faulty node.
+
+    {{< note >}}
+- If there is a faulty node in the cluster to which you are adding a node, Redis Enterprise Software will use the new node to replace the faulty one.
+- Any existing [DNS records]({{< relref "/operate/rs/networking/cluster-dns" >}}) must be updated
+each time a node is added or replaced.
+    {{< /note >}}
+---
+Title: Remove a node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Remove a node from your Redis Enterprise cluster.
+linkTitle: Remove node
+weight: 80
+---
+You might want to remove a node from a Redis Enterprise cluster for one of the following reasons:
+
+- To [permanently remove a node](#permanently-remove-a-node) if you no longer need the extra capacity.
+- To [replace a faulty node](#replace-a-faulty-node) with a healthy node.
+- To [replace a healthy node](#replace-a-healthy-node) with a different node.
+
+You can configure [email alerts from the cluster]({{< relref "/operate/rs/monitoring/v1_monitoring#cluster-alerts" >}}) to notify you of cluster changes, including when a node is removed.
+
+{{<warning>}}
+Read through these explanations thoroughly before taking
+any action.
+{{</warning>}}
+
+## Permanently remove a node
+
+Permanently removing a node means you are decreasing cluster capacity.
+Before trying to remove a node, make sure that the cluster has enough
+capacity for all resources without that node, otherwise you cannot remove the node.
+
+If there is not enough capacity in the cluster to facilitate removing
+the node, you can either delete databases or add another node instead of
+the one you would like to remove.
+
+During the removal process, the cluster migrates all resources from the
+node being removed to other nodes in the cluster. In order to ensure
+database connectivity, and database high availability (when replication
+is enabled), the cluster first creates replacement shards or endpoints
+on one of the other nodes in the cluster, initiates failover as needed,
+and only then removes the node.
+
+If a cluster has only two nodes (which is not recommended for production
+deployments) and some databases have replication enabled, you cannot remove a node.
+
+## Replace a faulty node
+
+If the cluster has a faulty node that you would like to replace, you
+only need to add a new node to the cluster. The cluster recognizes the
+existence of a faulty node and automatically replaces the faulty node
+with the new node.
+
+For guidelines, refer to [Replacing a faulty
+node]({{< relref "/operate/rs/clusters/replace-node.md" >}}).
+
+## Replace a healthy node
+
+If you would like to replace a healthy node with a different node, you
+must first add the new node to the cluster, migrate all the resources
+from the node you would like to remove, and only then remove the node.
+
+For further guidance, refer to [adding a new node to a
+cluster]({{< relref "/operate/rs/clusters/add-node.md" >}}).
+
+You can migrate resources by using the `rladmin` command-line interface
+(CLI). For guidelines, refer to [`rladmin` command-line interface
+(CLI)]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}).
+
+{{< note >}}
+The [DNS records]({{< relref "/operate/rs/networking/cluster-dns" >}}) must be updated each time a node is added or replaced.
+{{< /note >}}
+
+## Remove a node
+
+To remove a node using the Cluster Manager UI:
+
+1. On the **Nodes** screen, click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="More actions button" width="22px" class="inline" >}} for the node you want to remove.
+
+    {{<image filename="images/rs/screenshots/nodes/secondary-nodes-more-actions.png" alt="Click the more actions button for a node to access node actions.">}}
+
+1. Select **Remove node** from the list.
+
+1. If there are shards on the node, select **Confirm node removal**.
+
+    {{<image filename="images/rs/screenshots/nodes/confirm-node-removal-selected.png" alt="The Confirm node removal checkbox is selected, and the Remove button is clickable.">}}
+
+    If the node has no shards, the **Confirm node removal** checkbox does not appear.
+
+1. Click **Remove**.
+
+    Redis Enterprise Software examines the node and the cluster, then takes the actions required to remove the node, such as migrating shards to other nodes. After the process finishes, the node is no longer shown in the UI.
+
+    {{<note>}}
+At any point, you can click the **Cancel removal** button to stop the process. When cancelled, the current internal action is completed, and then the process stops.
+    {{</note>}}
+
+To remove a node using the REST API, use [`POST /v1/nodes/<node_id>/actions/remove`]({{< relref "/operate/rs/references/rest-api/requests/nodes/actions#post-node-action" >}}).
+
+By default, the remove node action completes after all resources migrate off the removed node. Node removal does not wait for migrated shards' persistence files to be created on the new nodes.
+
+To change node removal to wait for the creation of new persistence files for all migrated shards, set `wait_for_persistence` to `true` in the request body or [update the cluster policy]({{<relref "/operate/rs/references/rest-api/requests/cluster/policy#put-cluster-policy">}}) `persistent_node_removal` to `true` to change the cluster's default behavior.
+
+For example:
+
+```sh
+POST https://<hostname>:9443/v1/nodes/<node_id>/actions/remove
+{
+    "wait_for_persistence": true
+}
+```
+
+{{< note >}}
+If you need to add a removed node back to the cluster,
+you must [uninstall]({{< relref "/operate/rs/installing-upgrading/uninstalling.md" >}})
+and [reinstall]({{< relref "/operate/rs/installing-upgrading" >}}) the software on that node.
+{{< /note >}}
+---
+Title: Add a node
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Add a node to your existing Redis Enterprise cluster.
+linktitle: Add a node
+weight: 20
+---
+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:
+
+- The clocks on all nodes must always be [synchronized]({{< relref "/operate/rs/clusters/configure/sync-clocks.md" >}}).
+
+    If the clock in the node you are trying to join to the cluster is not synchronized with the nodes already in the cluster,
+    the action fails and an error message is shown indicating that you must synchronize the clocks first.
+
+- You must [update the DNS records]({{< relref "/operate/rs/networking/cluster-dns" >}})
+    each time a node is added or replaced.
+
+- We recommend that you add nodes one after the other rather than in parallel
+    to avoid errors that occur because the connection to the other nodes in the cluster cannot be verified.
+
+## Add node
+
+To add a node to an existing cluster:
+
+1. [Install the Redis Enterprise Software installation package]({{< relref "/operate/rs/installing-upgrading" >}}) on a clean installation
+    of a [supported operating system]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+1. To connect to the Cluster Manager UI of the new Redis Enterprise Software installation, go to: <https://URL or IP address:8443>
+
+    For example, if you installed Redis Enterprise Software on a machine with IP address 10.0.1.34, go to `https://10.0.1.34:8443`.
+
+    {{< tip >}}
+The management UI uses TLS encryption with a default certificate.
+You can also [replace the TLS certificate]({{< relref "/operate/rs/security/certificates/updating-certificates" >}})
+with a custom certificate.
+    {{< /tip >}}
+
+1. Select **Join cluster**.
+
+1. For **Cluster identification**, enter the internal IP address or DNS name of a node that is a cluster member.
+
+    If the node only has one IP address, enter that IP address.
+
+1. For **Cluster sign in**, enter the credentials of the cluster administrator.
+
+    The cluster administrator is the user account that you create when you configure the first node in the cluster.
+
+1. Click **Next**.
+
+1. Configure storage and network settings:
+
+    1. Enter a path for [*Ephemeral storage*]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}), or leave the default path.
+
+    1. Enter a path for [*Persistent storage*]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}),
+        or leave the default path.
+
+    1. To enable [*Auto Tiering*]({{< relref "/operate/rs/databases/auto-tiering/" >}}),
+        select **Enable flash storage** and enter the path to the flash storage.
+
+    1. If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}), set the **Rack-zone ID** for the new node.
+
+    1. If your machine has multiple IP addresses, assign a single IPv4 type address for **Node-to-node communication (internal traffic)** and multiple IPv4/IPv6 type addresses for **External traffic**.
+
+1. Select **Join cluster**.
+
+The node is added to the cluster.
+You can see it in the list of nodes in the cluster.
+
+If you see an error when you add the node, try adding the node again.
+
+## Verify node
+
+We recommend that you verify the node is functioning properly using one of the following methods:
+
+- Cluster Manager UI method:
+
+    1. On the **Nodes** screen, click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="More actions button" width="22px" class="inline" >}} for the node you want to verify.
+    
+    1. Select **Verify node** from the list.
+
+    {{<image filename="images/rs/screenshots/nodes/secondary-nodes-more-actions.png" alt="Click the more actions button for a node to access node actions.">}}
+
+- Command-line method:
+
+    Run the [`rlcheck`]({{< relref "/operate/rs/references/cli-utilities/rlcheck" >}}) utility from the node's command line.
+---
+Title: Set up a new cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to set up a new cluster using the management UI.
+linktitle: Set up cluster
+weight: 10
+---
+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.
+{{< /note >}}
+
+To set up a new cluster, you must first [install the Redis Enterprise Software package]({{< relref "/operate/rs/installing-upgrading" >}})
+and then set up the cluster as described below.
+After the cluster is created you can [add multiple nodes to the cluster]({{< relref "/operate/rs/clusters/add-node.md" >}}).
+
+To create a cluster:
+
+1. In a browser, go to `https://<name or IP address of the machine with Redis Enterprise Software installed>:8443`.
+    For example, if you installed Redis Enterprise Software on a machine with IP address 10.0.1.34, go to <https://10.0.1.34:8443>.
+
+    {{< note >}}
+- The management UI uses a [self-signed certificate for TLS encryption]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+- If the machine has both an internal IP address and an external IP address, use the external IP address to access the setup UI.
+    {{< /note >}}
+
+1. Select **Create new cluster**.
+
+1. Enter an email and password for the administrator account, then select **Next** to proceed to cluster setup.
+
+1. Enter your cluster license key if you have one. Otherwise, the cluster uses the trial license by default.
+
+1. In the **Configuration** section:
+
+    1. For **FQDN (Fully Qualified Domain Name)**, enter a unique name for the cluster.
+
+        See the [instructions for DNS setup]({{< relref "/operate/rs/networking/cluster-dns" >}})
+        to make sure your cluster is reachable by name.
+
+    1. Choose whether to [**Enable private & public endpoints support**]({{< relref "/operate/rs/networking/private-public-endpoints.md" >}}).
+
+    1. Choose whether to [**Enable rack-zone awareness**]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}).
+
+1. Click **Next**.
+
+1. Configure storage and network settings:
+
+    1. Enter a path for [*Ephemeral storage*]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}), or leave the default path.
+
+    1. Enter a path for [*Persistent storage*]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}),
+        or leave the default path.
+
+    1. To enable [*Auto Tiering*]({{< relref "/operate/rs/databases/auto-tiering/" >}}),
+        select **Enable flash storage** and enter the path to the flash storage.
+
+    1. If the cluster is configured to support [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}), set the **Rack-zone ID** for the new node.
+
+    1. If your machine has multiple IP addresses, assign a single IPv4 type address for **Node-to-node communication (internal traffic)** and multiple IPv4/IPv6 type addresses for **External traffic**.
+
+1. Select **Create cluster**.
+
+1. Click **OK** to confirm that you are aware of the replacement of the HTTPS TLS certificate on the node,
+    and proceed through the browser warning.
+
+After a short wait, your cluster is created and you can sign in to the Cluster Manager UI.
+
+You can now access any of the management capabilities, including:
+
+- [Creating a new database]({{< relref "/operate/rs/databases/create.md" >}})
+- [Joining a new node to a cluster]({{< relref "/operate/rs/clusters/add-node.md" >}})
+---
+Title: Change node roles
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Change node roles to demote the primary node to a secondary node or promote a secondary node to become the primary node.
+linkTitle: Change node roles
+weight: 65
+---
+
+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
+
+To demote the primary node to a secondary node using the Cluster Manager UI:
+
+1. On the **Nodes** screen, click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="More actions button" width="22px" class="inline" >}} for the node you want to promote.
+
+    {{<image filename="images/rs/screenshots/nodes/primary-node-more-actions.png" alt="Click the more actions button for a node to access node actions.">}}
+
+1. Select **Set as a secondary node** from the list.
+
+1. Select one of the options to determine the new primary node:
+
+    - **Automatically**: The cluster decides which node becomes the new primary node.
+
+    - **Choose specific node**: You can manually select which node becomes the new primary node.
+
+    {{<image filename="images/rs/screenshots/nodes/primary-node-set-as-secondary-dialog.png" alt="The Set as a secondary node dialog has two options to select the new primary node, either automatically or manually.">}}
+
+1. Click **Confirm**.
+
+## Promote secondary node
+
+To promote a secondary node to become the primary node using the Cluster Manager UI:
+
+1. On the **Nodes** screen, click {{< image filename="/images/rs/buttons/button-toggle-actions-vertical.png#no-click" alt="More actions button" width="22px" class="inline" >}} for the node you want to promote.
+
+    {{<image filename="images/rs/screenshots/nodes/secondary-nodes-more-actions.png" alt="Click the more actions button for a node to access node actions.">}}
+
+1. Select **Set as the primary node** from the list.
+
+1. Click **Confirm**.
+
+After this node becomes the primary node, all cluster management traffic is directed to it.
+---
+Title: Alerts and events
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Logged alerts and events
+linkTitle: Alerts and events
+weight: 50
+---
+
+The following alerts and events can appear in `syslog` and the Cluster Manager UI logs.
+
+| Alert/Event                   | 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                   | bdb event; Replica of - error authenticating with the source database                                                                                         |
+| 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.                                                                                      |
+| backup_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| backup_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| backup_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_created                       |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_deleted                       |                                                                | info                    | bdb event                                                                                                                                                      |
+| bdb_updated                       |                                                                | info                    | bdb event; Indicates that a bdb configuration has been updated                                                                                                 |
+| checks_error                      |                                                                | error                   | node event; Indicates that one or more node checks have failed                                                                                                |
+| cluster_updated                   |                                                                | info                    | cluster event; Indicates that cluster settings have been updated                                                                                              |
+| compression_unsup_err             |                                                                | error                   | bdb event; Replica of - Compression not supported by sync destination                                                                                         |
+| crossslot_err                     |                                                                | error                   | bdb event; Replica of - sharded destination does not support operation executed on source                                                                     |
+| 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.                                                                           |
+| export_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| export_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| export_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| failed                            | Node failed                                                    | critical                | node alert                                                                                                                                                     |
+| 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                   | Replica of - 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.                                                                                 |
+| import_failed                     |                                                                | error                   | bdb event                                                                                                                                                      |
+| import_started                    |                                                                | info                    | bdb event                                                                                                                                                      |
+| import_succeeded                  |                                                                | info                    | bdb event                                                                                                                                                      |
+| inconsistent_redis_sw             | Not all databases are running the same open source version     | True: warning, False: info | cluster alert                                                                                                                                                  |
+| 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                                                                                                                                                     |
+| internal_bdb                      | Issues with internal cluster databases                         | True: warning, False: info | cluster alert                                                                                                                                                  |
+| license_added                     |                                                                | info                    | cluster event                                                                                                                                                  |
+| license_deleted                   |                                                                | info                    | cluster event                                                                                                                                                  |
+| license_updated                   |                                                                | info                    | cluster event                                                                                                                                                  |
+| low_throughput                    | Throughput is lower than `<threshold>` RPS (requests per second) | True: warning, False: info | bdb alert; Has threshold parameter in the key/value section of the log entry.                                                                                 |
+| 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.                                                                           |
+| 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 removed                                                   | info                    | cluster event; The remove node is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail.                                  |
+| node_remove_abort_failed          | Node removed                                                   | error                   | cluster event; The remove node 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; The remove node 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; The remove node is a process that can fail and can also be aborted. If aborted, the abort can succeed or fail.                                  |
+| node_remove_request               |                                                                | info                    | node event                                                                                                                                                     |
+| 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                                                                                                                                                  |
+| oom_err                           |                                                                | error                   | bdb event; Replica of - Replication source/target out of memory                                                                                               |
+| 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           |                                                                | error                   | bdb alert                                                                                                                                                      |
+| 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                                                                                                                                                  |
+| user_created                      |                                                                | info                    | user event                                                                                                                                                     |
+| user_deleted                      |                                                                | info                    | user event                                                                                                                                                     |
+| user_updated                      |                                                                | info                    | user event; Indicates that a user configuration has been updated                                                                                              |
+---
+Title: Manage logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linktitle: Manage logs
+weight: 50
+---
+Redis Enterprise comes with [a set of logs]({{< relref "/operate/rs/clusters/logging" >}}) 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.
+
+To do this, modify the syslog or rsyslog configuration on your operating system to send logs in the `$logdir` directory (`/var/opt/redislabs/log` in default installations) to a remote monitoring server of your choice. See [rsyslog logging]({{< relref "/operate/rs/clusters/logging/rsyslog-logging/" >}}) for additional details.
+
+## Log rotation
+
+Redis Enterprise Software's job scheduler runs `logrotate` every five minutes to examine logs stored on the operating system and rotate them based on the log rotation configuration. You can find the log rotation configuration file at `$pkgconfdir/logrotate.conf` as of Redis Enterprise Software version 7.2 (`pkgconfdir` is `/opt/redislabs/config` by default, but can be changed in a custom installation).
+
+By default, log rotation occurs when a log exceeds 200 MB. We recommend sending log files to a remote logging server so you can maintain them more effectively.
+
+The following log rotation policy is enabled by default in Redis Enterprise Software, but you can modify it as needed.
+
+```sh
+${logdir}/*.log {
+    su ${osuser} ${osgroup}
+    maxsize 200M
+    daily
+    missingok
+    copytruncate
+    rotate 10
+    maxage 7
+    compress
+    notifempty
+    nodateext
+    nosharedscripts
+    prerotate
+        # copy cluster_wd log to another file that will have longer retention
+        if [ "\$1" = "${logdir}/cluster_wd.log" ]; then
+            cp -p ${logdir}/cluster_wd.log ${logdir}/cluster_wd.log.long_retention
+        fi
+    endscript
+}
+${logdir}/cluster_wd.log.long_retention {
+    su ${osuser} ${osgroup}
+    daily
+    missingok
+    copytruncate
+    rotate 30
+    compress
+    notifempty
+    nodateext
+}
+```
+
+- `${logdir}/*.log`: `logrotate` checks the files under the `$logdir` directory (`/var/opt/redislabs/log/`) and rotates any files that end with the extension `.log`.
+
+- `${logdir}/cluster_wd.log.long_retention`: `cluster_wd.log` is copied to `cluster_wd.log.long_retention` before rotation. This copy is kept longer than usual, which is 30 days by default.
+
+- `maxsize 200M`: Rotate log files that exceed 200 MB.
+
+- `daily`: Rotate logs every day regardless of their size.
+
+- `missingok`: If there are missing log files, do nothing.
+
+- `copytruncate`: Truncate the original log file to zero sizes after creating a copy.
+
+- `rotate 10`: Save a maximum of 10 rotated log files. To keep effectively infinite log files, use `rotate 2000` instead.
+
+- `compress`: gzip log files.
+
+- `maxage 7`: Keep the rotated log files for 7 days.
+
+- `notifempty`: Don't rotate the log file if it is empty.
+
+{{<note>}}
+For large scale deployments, you might need to rotate logs at faster intervals than daily. You can also use a cronjob or external vendor solutions.
+{{</note>}}
+---
+Title: View and manage Redis slow log
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: Slow log
+weight: $weight
+---
+
+[Redis slow log]({{<relref "/commands/slowlog">}}) is one of the best
+tools for debugging and tracing your Redis database, especially if you
+experience high latency and high CPU usage with Redis operations.
+Because Redis is based on a single threaded architecture, Redis slow log
+can be much more useful than slow log mechanisms of multi-threaded
+database systems such as MySQL slow query log.
+
+Unlike tools that introduce lock overhead, which complicates the debugging
+process, Redis slow log is highly effective at showing the actual processing time of each command.
+
+## Redis Software slow log enhancements 
+
+Redis Software includes enhancements to the standard Redis
+slow log capabilities that allow you to analyze the execution time
+complexity of each command. This enhancement can help you better analyze
+Redis operations, allowing you to compare the differences between
+execution times of the same command, observe spikes in CPU usage, and
+more.
+
+This is especially useful with complex commands such as
+[ZUNIONSTORE]({{<relref "/commands/zunionstore">}}),
+[ZINTERSTORE]({{<relref "/commands/zinterstore">}}), and
+[ZRANGEBYSCORE]({{<relref "/commands/zrangebyscore">}}).
+
+The enhanced Redis Software slow log adds the **Complexity info** field to the
+output data.
+
+View the complexity info data by its respective command in the table
+below:
+
+| Command | Value of interest | Complexity |
+|------------|-----------------|-----------------|
+| LINSERT | N - list len | O(N) |
+| LREM | N - list len | O(N) |
+| LTRIM | N - number of removed elements | O(N) |
+| PUBLISH | N - number of channel subscribers</br>M - number of subscribed patterns | O(N+M) |
+| PSUBSCRIBE | N - number of patterns client is subscribed to</br>argc - number of arguments passed to the command | O(argc\*N) |
+| PUNSUBSCRIBE | N - number of patterns client is subscribed to</br>M - total number of subscribed patterns</br>argc - number of arguments passed to the command | O(argc\*(N+M)) |
+| SDIFF | N - total number of elements in all sets | O(N) |
+| SDIFFSTORE | N - total number of elements in all sets | O(N) |
+| SINTER                | N - number of elements in smallest set</br>argc - number of arguments passed to the command | O(argc\*N) |
+| SINTERSTORE           | N - number of elements in smallest set</br>argc - number of arguments passed to the command | O(argc\*N) |
+| SMEMBERS              | N - number of elements in a set | O(N) |
+| SORT                  | N - number of elements in the when no sorting list/set/zset</br>M - number of elements in result | O(N+M\*log(M))O(N) |
+| SUNION                | N - number of elements in all sets | O(N) |
+| SUNIONSTORE           | N - number of elements in all sets | O(N) |
+| UNSUBSCRIBE           | N - total number of clients subscribed to all channels | O(N) |
+| ZADD                  | N - number of elements in the zset | O(log(N)) |
+| ZCOUNT                | N - number of elements in the zset</br>M - number of elements between min and max | O(log(N)+M) |
+| ZINCRBY               | N - number of elements in the zset | O(log(N)) |
+| ZINTERSTORE           | N – number of elements in the smallest zset</br>K – number of zsets</br>M – number of elements in the results set | O(N\*K)+O(M\*log(M)) |
+| ZRANGE                | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZRANGEBYSCORE         | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZRANK                 | N – number of elements in the zset | O(log(N)) |
+| ZREM                  | N – number of elements in the zset</br>argc – number of arguments passed to the command | O(argc\*log(N)) |
+| ZREMRANGEBYRANK       | N – number of elements in the zset</br>argc – number of arguments passed to the command | O(log(N)+M) |
+| ZREMRANGEBYSCORE      | N – number of elements in the zset</br>M – number of elements removed | O(log(N)+M) |
+| ZREVRANGE             | N – number of elements in the zset</br>M – number of results | O(log(N)+M) |
+| ZREVRANK              | N – number of elements in the zset | O(log(N)) |
+| ZUNIONSTORE           | N – sum of element counts of all zsets</br>M – element count of result | O(N)+O(M\*log(M)) |
+
+## View slow log
+
+To view slow log entries for Redis Software databases, use one of the following methods:
+
+- Cluster Manager UI:
+
+    1. To access the slow log in the Cluster Manager UI, your [cluster management role]({{<relref "/operate/rs/security/access-control/create-cluster-roles">}}) must be Admin, Cluster Member, or DB Member.
+    
+    1. Select a database from the **Databases** list.
+
+    1. On the database's **Configuration** screen, select the **Slowlog** tab.
+
+- Command line:
+
+    Use [`redis-cli`]({{<relref "/operate/rs/references/cli-utilities/redis-cli">}}) to run [`SLOWLOG GET`]({{<relref "/commands/slowlog-get">}}):
+
+    ```sh
+    redis-cli -h <endpoint> -p <port> SLOWLOG GET <count>
+    ```
+
+## Change slow log threshold
+
+The slow log includes all database commands that take longer than ten milliseconds (10,000 microseconds) by default. You can use [`redis-cli`]({{<relref "/operate/rs/references/cli-utilities/redis-cli">}}) to view or change this threshold.
+
+To check the current threshold, run [`CONFIG GET`]({{<relref "/commands/config-get">}}):
+
+```sh
+redis-cli -h <endpoint> -p <port> CONFIG GET slowlog-log-slower-than
+```
+
+To change the threshold, run [`CONFIG SET`]({{<relref "/commands/config-set">}}):
+
+```sh
+redis-cli -h <endpoint> -p <port> CONFIG SET slowlog-log-slower-than <value_in_microseconds>
+```
+
+## Change maximum entries
+
+The slow log retains the last 128 entries by default. You can use [`redis-cli`]({{<relref "/operate/rs/references/cli-utilities/redis-cli">}}) to view or change the maximum number of entries.
+
+To check the current maximum, run [`CONFIG GET`]({{<relref "/commands/config-get">}}):
+
+```sh
+redis-cli -h <endpoint> -p <port> CONFIG GET slowlog-max-len
+```
+
+To change the maximum, run [`CONFIG SET`]({{<relref "/commands/config-set">}}):
+
+```sh
+redis-cli -h <endpoint> -p <port> CONFIG SET slowlog-max-len <value>
+```
+---
+Title: rsyslog logging
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: This document explains the structure of Redis Enterprise Software log
+  entries in `rsyslog` and how to use these log entries to identify events.
+hideListLinks: true
+linktitle: rsyslog
+weight: $weight
+---
+
+## Log concepts
+
+Redis Enterprise Software logs information from a variety of components in response to actions and events that occur within the cluster.
+
+In some cases, a single action, such as removing a node from the cluster, may actually consist of several events. These actions may generate multiple log entries.
+
+All log entries displayed in the Cluster Manager UI are also written to `syslog`.  You can configure `rsyslog` to monitor `syslog`. Enabled alerts are logged to `syslog` and appear with other log entries.
+
+You can also [manage your logs]({{< relref "/operate/rs/clusters/logging/log-security" >}}) with a remote logging server and log rotation.
+
+### Types of log entries
+
+Log entries are categorized into events and alerts. Both types of entries appear in the logs, but alert log entries also include a boolean `"state"` parameter that indicates whether the alert is enabled or disabled.
+
+Log entries include information about the specific event that occurred. See the log entry tables for [alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+### Severity
+
+You can also configure `rsyslog` to add other information, such as the event severity.
+
+Since `rsyslog` entries do not include severity by default, you can follow these steps to enable it:
+
+1. Add the following line to `/etc/rsyslog.conf`:
+    ```
+    $template TraditionalFormatWithPRI,"%pri-text%: %timegenerated% %HOSTNAME% %syslogtag%%msg:::drop-last-lf%\n"
+    ```
+
+2. Modify `$ActionFileDefaultTemplate` to use your new template `$ActionFileDefaultTemplateTraditionalFormatWithPRI`
+
+3. Save these changes and restart `rsyslog` to apply them
+
+You can see the log entries for alerts and events in the `/var/log/messages` file.
+
+**Command components:**
+
+- `%pri­text%` ­adds the severity
+- `%timegenerated%` ­adds the timestamp
+- `%HOSTNAME%` ­adds the machine name
+- `%syslogtag%` adds ­the Redis Enterprise Software message. See the [log entry structure](#log-entry-structure) section for more details.
+- `%msg:::drop­last­lf%n` ­removes duplicated log entries
+
+## Log entry structure
+
+The log entries have the following basic structure:
+
+    event_log[<process id>]:{<list of key-value pairs in any order>}
+
+- **event_log**:­ Plain static text is always shown at the beginning of the entry.
+- **process id­**: The ID of the logging process
+- **list of key-value pairs in any order**:­ A list of key-value pairs that describe the specific event. They can appear in any order. Some key­-value pairs are always shown, and some appear depending on the specific event.
+    - **Key-­value pairs that always appear:**
+        - `"type"`: A unique code­ name for the logged event. For the list of codenames, see the [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) tables.
+        - `"object"`: Defines the object type and ID (if relevant) of the object this event relates to, such as cluster, node with ID, BDB with ID, etc. Has the format of <nobr>`<object type>[:<id>]`</nobr>. 
+        - `"time"`: Unix epoch time but can be ignored in this context.
+    - **Key-­value pairs that might appear depending on the specific entry:**
+        - `"state"`: A boolean where `true` means the alert is enabled, and `false` means the alert is disabled. This is only relevant for alert log entries.
+        - `"global_threshold"`: The value of a threshold for alerts related to cluster or node objects.
+        - `"threshold"`: The value of a threshold for alerts related to a BDB object
+
+## Log entry samples
+
+This section provides examples of log entries that include the [`rsyslog` configuration](#severity) to add the severity, timestamp, and machine name.
+
+### Ephemeral storage passed threshold
+
+#### "Alert on" log entry sample
+
+```
+daemon.warning: Jun 14 14:49:20 node1 event_log[3464]:
+{
+    "storage_util": 90.061643120001, 
+    "global_threshold": "70", 
+    "object": "node:1", 
+    "state": true, 
+    "time": 1434282560, 
+    "type": "ephemeral_storage"
+}
+```
+
+In this example, the storage utilization on node 1 reached the value of ~90%, which triggered the alert for "Ephemeral storage has reached 70% of its capacity."
+
+**Log entry components:**
+
+- `daemon.warning` -­ Severity of entry is `warning`
+- `Jun 14 14:49:20` -­ The timestamp of the event
+- `node1`:­ Machine name
+- `event_log` -­ Static text that always appears
+- `[3464]­` - Process ID
+- `"storage_util":90.061643120001` - Current ephemeral storage utilization
+- `"global_threshold":"70"` - The user-configured threshold above which the alert is raised
+- `"object":"node:1"`­ - The object related to this alert
+- `"state":true­` - Current state of the alert
+- `"time":1434282560­` - Can be ignored
+- `"type":"ephemeral_storage"` - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.info: Jun 14 14:51:35 node1 event_log[3464]: 
+{
+    "storage_util":60.051723520008, 
+    "global_threshold": "70", 
+    "object": "node:1", 
+    "state":false, 
+    "time": 1434283480, 
+    "type": "ephemeral_storage"
+}
+```
+
+This log entry is an example of when the alert for the node with ID 1 "Ephemeral storage has reached 70% of its capacity" has been turned off as result of storage utilization reaching the value of ~60%.
+
+**Log entry components**:
+
+- `daemon.info` -­ Severity of entry is `info`
+- `Jun 14 14:51:35` -­ The timestamp of the event
+- `node1` -­ Machine name
+- `event_log` -­ Static text that always appears
+- `[3464]` -­ Process ID
+- `"storage_util":60.051723520008­` - Current ephemeral storage utilization
+- `"global_threshold":"70"` - The user configured threshold above which the alert is raised (70% in this case)
+- `"object":"node:1"` -­ The object related to this alert
+- `"state":false­` - Current state of the alert
+- `"time":1434283480­` - Can be ignored
+- `"type":"ephemeral_storage"` -­ The code name identifier of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+### Odd number of nodes with a minimum of three nodes alert
+
+#### "Alert on" log entry sample
+
+```
+daemon.warning: Jun 14 15:25:00 node1 event_log[8310]: 
+{
+    "object":"cluster", 
+    "state": true, 
+    "time": 1434284700, 
+    "node_count": 1, 
+    "type":"even_node_count"
+}
+```
+
+This log entry is an example of when the alert for "True high availability requires an odd number of nodes with a minimum of three nodes" has been turned on as result of the cluster having only one node.
+
+**Log entry components:**
+
+- `daemon.warning­` - Severity of entry is warning
+- `Jun 14 15:25:00` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[8310]­` - Process ID
+- `"object":"cluster"­` - The object related to this alert
+- `"state":true` -­ Current state of the alert
+- `"time":1434284700­` - Can be ignored
+- `"node_count":1­` - The number of nodes in the cluster
+- `"type":"even_node_count"­` - The code name identifier of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.warning: Jun 14 15:30:40 node1 event_log[8310]: 
+{
+    "object":"cluster", 
+    "state": false, 
+    "time": 1434285200, 
+    "node_count": 3, 
+    "type":"even_node_count"
+}
+```
+
+This log entry is an example of when the alert for "True high availability requires an odd number of nodes with a minimum of three nodes" has been turned off as result of the cluster having 3 nodes.
+
+**Log entry components:**
+
+- `daemon.warning` - Severity of entry is warning
+- `Jun 14 15:30:40` -­ The timestamp of the event
+- `node1­` - Machine name
+- `event_log­` - Static text that always appears
+- `[8310]` -­ Process ID
+- `"object":"cluster"` -­ The object related to this alert
+- `"state":false­` - Current state of the alert
+- `"time":1434285200­` - Can be ignored
+- `"node_count":3­` - The number of nodes in the cluster
+- `"type":"even_node_count"` -­ The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+### Node has insufficient disk space for AOF rewrite
+
+#### "Alert on" log entry sample
+
+```
+daemon.err: Jun 15 13:51:23 node1 event_log[34252]: 
+{
+    "used": 23457188, 
+    "missing": 604602126, 
+    "object": "node:1", 
+    "free": 9867264, 
+    "needed":637926578, 
+    "state": true, 
+    "time": 1434365483, 
+    "disk": 705667072, 
+    "type":"insufficient_disk_aofrw"
+}
+```
+
+This log entry is an example of when the alert for "Node has insufficient disk space for AOF rewrite" has been turned on as result of not having enough persistent storage disk space for AOF rewrite purposes. It is missing 604602126 bytes.
+
+**Log entry components:**
+
+- `daemon.err`­ - Severity of entry is error
+- `Jun 15 13:51:23` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[34252]` -­ Process ID
+- `"used":23457188­` - The amount of disk space in bytes currently used for AOF files
+- `"missing":604602126­` - The amount of disk space in bytes that is currently missing for AOF rewrite purposes
+- `"object":"node:1″` -­ The object related to this alert
+- `"free":9867264­` - The amount of disk space in bytes that is currently
+    free
+- `"needed":637926578­` - The amount of total disk space in bytes that is needed for AOF rewrite purposes
+- `"state":true­` - Current state of the alert
+- `"time":1434365483` -­ Can be ignored
+- `"disk":705667072­` - The total size in bytes of the persistent storage
+- `"type":"insufficient_disk_aofrw"­` - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+
+#### "Alert off" log entry sample
+
+```
+daemon.info: Jun 15 13:51:11 node1 event_log[34252]: 
+{
+    "used": 0, "missing":-21614592, 
+    "object": "node:1", 
+    "free": 21614592, 
+    "needed": 0, 
+    "state":false, 
+    "time": 1434365471, 
+    "disk": 705667072, 
+    "type":"insufficient_disk_aofrw"
+}
+```
+
+**Log entry components:**
+
+- `daemon.info­` - Severity of entry is info
+- `Jun 15 13:51:11` - The timestamp of the event
+- `node1­` - Machine name
+- `event_log` -­ Static text that always appears
+- `[34252]­` - Process ID
+- `"used":0­` - The amount of disk space in bytes currently used for AOF files
+- `"missing":‐21614592­` - The amount of disk space in bytes that is currently missing for AOF rewrite purposes. In this case, it is not missing because the number is negative.
+- `"object":"node:1″` -­ The object related to this alert
+- `"free":21614592` -­ The amount of disk space in bytes that is currently free
+- `"needed":0­` - The amount of total disk space in bytes that is needed for AOF rewrite purposes. In this case, no space is needed.
+- `"state":false­` - Current state of the alert
+- `"time":1434365471­` - Can be ignored
+- `"disk":705667072­` - The total size in bytes of the persistent storage
+- `"type":"insufficient_disk_aofrw"`­ - The code name of this specific event. See [logged alerts and events]({{< relref "/operate/rs/clusters/logging/alerts-events" >}}) for more details.
+---
+Title: Logging events
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Management actions performed with Redis Enterprise are logged to make
+  sure system management tasks are appropriately performed or monitored by administrators
+  and for compliance with regulatory standards.
+hideListLinks: true
+linkTitle: Logging
+weight: 95
+---
+Management actions performed with Redis Enterprise are logged to make sure system management tasks are appropriately performed or monitored by administrators and for compliance with regulatory standards.
+
+Log entries contain the
+following information:
+
+1. Who performed the action?
+1. What exactly was the performed action?
+1. When was the action performed?
+1. Did the action succeed or not?
+
+To get the list of logged events, you can use the REST API or
+the **Logs** screen in the UI. The **Logs** screen displays the system and user
+events regarding alerts, notifications, and configuration.
+
+{{<image filename="images/rs/screenshots/cluster/cluster-logs.png" alt="Logs screen in the new Cluster Manager UI.">}}
+
+You can use the **Logs** screen to review what actions a user has performed, such as editing a database's configuration.
+
+- [Redis slow
+    log]({{< relref "/operate/rs/clusters/logging/redis-slow-log.md" >}})
+- [rsyslog logging]({{< relref "/operate/rs/clusters/logging/rsyslog-logging/" >}})
+
+## View logs in the UI
+
+Redis Enterprise provides log files for auditing cluster management actions and troubleshooting. You can view these logs in the UI and on the host operating system.
+
+To view event logs in the new Cluster Manager UI, go to **Cluster > Logs**.
+
+## View logs on the server
+
+Server logs can be found by default in the directory `/var/opt/redislabs/log/`.
+
+These log files are used by the Redis support team to troubleshoot issues. The logs you will most frequently interact with is 'event_log.log'. This log file is where logs of configuration actions within Redis are stored and is useful to determine events that occur within Redis Enterprise.
+
+## Configure log timestamps
+
+Redis Enterprise allows you to configure log timestamps. To configure log timestamps in the new Cluster Manager UI:
+
+1. Go to **Cluster > Configuration > General**.
+
+1. Change the **Time zone** for the logs based on your location.
+---
+Title: Manage clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Administrative tasks and information related to the Redis Enterprise
+  cluster.
+hideListLinks: false
+linktitle: Clusters
+weight: 36
+---
+
+You can manage your Redis Enterprise Software clusters with several different tools:
+
+- Cluster Manager UI (the web-based user interface)
+- Command-line tools ([rladmin]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}), [redis-cli]({{< relref "/develop/tools/cli" >}}), [crdb-cli]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}))
+- [REST API]({{< relref "/operate/rs/references/rest-api/_index.md" >}})
+---
+Title: Redis Enterprise Software release notes 6.2.18-49 (October 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: New REST API endpoint to check whether a node is a primary or a replica.
+  Added metrics to track certificate expiration time.
+linkTitle: 6.2.18-49 (October 2022)
+toc: 'true'
+weight: 72
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.2.18](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | `766d2f8448fc28d0ea67cac20387a9e3` |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 | `7e31fb3e3416b404513dad508669f836` |
+
+## New features and enhancements
+
+- The [`/nodes/status`]({{< relref "/operate/rs/references/rest-api/requests/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:
+
+- [RediSearch v2.4.11]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.4-release-notes#v2411-july-2022" >}})
+- [RedisJSON v2.2.0]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.2-release-notes#v220-july-2022" >}})
+- [RedisBloom v2.2.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/redisbloom-2.2-release-notes/#v2218-july-2022)
+- [RedisGraph v2.8.17]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.8-release-notes#v2817-july-2022" >}})
+- [RedisTimeSeries v1.6.17]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.6-release-notes#v1617-july-2022" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database. 
+
+## Known upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.---
+Title: Redis Enterprise Software release notes 6.2.18-58 (November 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: UI support for custom REST API port. Added info level for troubleshooting
+  redis_mgr.
+linkTitle: 6.2.18-58 (November 2022)
+toc: 'true'
+weight: 71
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.2.18](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | `d8283a3475a70823641249e3cfe3ab6e` |
+| RedHat Enterprise Linux (RHEL) 8<br/>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:
+
+- [RediSearch v2.4.14]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.4-release-notes#v2414-august-2022" >}})
+- [RedisGraph v2.8.19]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.8-release-notes#v2819-august-2022" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database. 
+
+## Resolved issues
+
+- RS85369 - Fixes umask validation during installation to allow for temporary umask change
+- RS77339 - Fixes the “FROM” email addresses of email alerts
+- RS86005 - Fixes  `bdbs/<int:uid>/actions/recover` API to return the bdb status and not the `recovery_plan`
+
+## Known upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+---
+Title: Redis Enterprise Software release notes 6.2.18-43 (September 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: Database auditing. Private key encryption. Active-Active database support
+  for MEMORY USAGE command. Improvements to crdb-cli.
+linkTitle: 6.2.18-43 (September 2022)
+toc: 'true'
+weight: 73
+---
+
+[Redis Enterprise Software version 6.2.18](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+This version of Redis Enterprise Software offers:
+
+- RedisJSON on Active-Active General Availability 
+- Database connection auditing
+- Private key encryption
+- Active-Active support for `memory usage` command
+- `crdb-cli` improvements
+- Compatibility with open source Redis v6.2.6
+- Additional enhancements and fixes
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (6.2.18-43 September release) |
+|:--------|:-------------|
+| Ubuntu 16 | `055973eb7009073b0c199ec1dfd81018` |
+| Ubuntu 18 | `8c37c6ae10b0ae4956e3c11db80d18ce` |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | `c770a66d9bfdd8734f1208d64aa67784` |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 | `85eb6339f837205d83f215e32c1d028f` |
+
+## New features and enhancements
+
+#### General Availability of Active-Active databases with RedisJSON
+
+Active-Active databases now support Index, query, and full-text search of nested JSON documents when combining RedisJSON with RediSearch.
+
+#### Database connection auditing
+
+You can now [audit database connection]({{< relref "/operate/rs/security/audit-events" >}}) and authentication events to track and troubleshoot activity.  Administrators can now use third-party systems to track and analyze connection events in realtime.  
+
+#### Private key encryption
+
+When enabled, private key encryption encrypts private keys stored in the cluster configuration store (CCS).  Private keys are encrypted using a secure, self-contained internal process.  Databases must be at least version 6.2.2 or later to use this feature.
+
+#### Active-Active support for MEMORY USAGE command
+
+Redis Enterprise Active-Active databases now support the [MEMORY USAGE]({{< relref "/commands/memory-usage" >}}) command, which simplifies troubleshooting and lets applications detect anomalous behavior and dangerous trends.
+To learn more, see  [`Active-Active with RedisJSON`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/active-active" >}}).
+
+MEMORY USAGE reports the RAM memory use, in bytes, of a key and its value.  The result includes the memory allocated for the data value and the administrative overhead associated with the key.
+
+#### `crdb-cli` improvements
+
+The `crdb-cli` utility used to manage Active-Active databases now allows greater visibility into management operations to make it easier to investigate and troubleshoot problems. You can now use:
+
+- `crdb-cli task list` to retrieve details about current and previous tasks for all Active-Active databases on a cluster
+
+- `crdb-cli task --task-id <task-id>` to get detailed information about a specific task.
+
+To learn more, see [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}})
+
+#### Redis modules 
+
+Redis Enterprise Software v6.2.18-43 (September release) includes the following Redis modules:
+
+- [RediSearch v2.4.11]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.4-release-notes#v2411-july-2022" >}})
+- [RedisJSON v2.2.0]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.2-release-notes#v220-july-2022" >}})
+- [RedisBloom v2.2.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/redisbloom-2.2-release-notes/#v2218-july-2022)
+- [RedisGraph v2.8.17]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.8-release-notes#v2817-july-2022" >}})
+- [RedisTimeSeries v1.6.17]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.6-release-notes#v1617-july-2022" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database. 
+
+#### Additional enhancements
+
+- Added support for the MODULE LIST command on Active-Active databases
+- Enhanced validity checks of the input parameters of the CRDB-CLI tool
+- The Syncer lag calculation has been improved and fixes multiple miscalculations
+- Support package includes additional information for Active-Active databases
+- Added the ability to retrieve the syncer mode (centralized / distributed) by running   
+
+    `rladmin info db [{db:<id> | <name>}]`  
+
+    To learn more, see [Distributed sychronization]({{< relref "/operate/rs/databases/active-active/synchronization-mode" >}})   
+
+## Version changes 
+
+### Breaking changes
+
+RS84006 - When using the REST API to create a database, this specific set of conditions can lead to an error:
+
+- sharding is enabled
+- oss_sharding and implicit_shard_key are both deactivated
+- A shard_key_regex is _not_ defined
+
+If this occurs, the database endpoint returns `(error) ERR key "test" does not match any rule`.
+
+To address this issue, do one of the following:
+
+- Explicitly define shard_key_regex
+- Enable oss_sharding or implicit_shard_key (enabling both also works) 
+
+
+### Prerequisites and notes 
+
+-  You can [upgrade to v6.2.18]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) from Redis Enterprise Software v6.0 and later. 
+
+- Refer to [v6.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021" >}}) for important notes regarding changes made to the upgrade policy and how those changes might impact your experience. 
+
+- Upgrades from versions earlier than v6.0 are not supported.
+
+- If you plan to upgrade your cluster to RHEL 8, see the [v6.2.8 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021" >}}) for known limitations.
+
+### Deprecations
+
+#### Active-Active database persistence
+
+The snapshot option for [data persistence on Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}manage/#data-persistence) will be deprecated in a future version of Redis Enterprise Software.  If you have an Active-Active database using snapshot persistence, we strongly encourage you to switch to AOF persistence.  Use `crdb-cli` to do so:
+```text
+crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+#### TLS 1.0 and TLS 1.1 
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.  
+
+Please verify that all clients, apps, and connections support TLS 1.2.  Support for the earlier protocols will be removed in a future release.
+
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols.  Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+#### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+### Product lifecycle updates 
+
+Redis Enterprise Software v6.0.x reached end-of-life (EOL) on May 31, 2022.
+
+EOL of Redis Enterprise Software 6.2.x was reset to occur 18 months after the release of version 6.4, in accordance with the updated EOL policy.  The new EOL date is August 31, 2024.
+
+To learn more, see the Redis Enterprise Software [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}), which details the release number and the end-of-life schedule for Redis Enterprise Software.
+
+For Redis modules information and lifecycle, see [Module lifecycle]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}).
+
+## Resolved issues 
+
+- RS64002 - Fixes email alerts for LDAP mappings. 
+- RS79519 - fixes a bug that prevented Administrators from editing an Active-Active database using the API with username instead of email as their identifier.
+- RS78039 - fixes a bug that caused the sync between two shards to pause when resetting a shard's data which can be when performing full sync or importing an RDB.
+- RS73454 - Updates internal timeouts to enable faster resharding.
+- RS75783 - Fixes failover due to false identification of dead nodes when master node goes down.
+- RS75206, RS52686 - Fixes backup_interval_offset in case where the user chose an offset that is higher than backup_interval; Fixes the UI from resetting backup_interval_offset after manual DB configuration.
+- RS75176 - Fixes rare case of stuck state machine during “maintenance off”.
+- RS57200 - Add an IP address to "failed_authentication_attempt" errors.
+- RS56615 - Changed rladmin tune db db_name max_aof_load_time to receive the value in seconds; Added max_aof_load_time option to rladmin help tune.
+- RS54745 - Fixes the Rest API to reject BDB creation using negative integers as a uid.
+- RS46092 - Fixes rlcheck failure when somaxconn policy is a value other than 1024.
+- RS68965, RS80615 - Adds internode encryption ports 3340-3344 to rlcheck connectivity.
+- RS63302 - Adds umask validation for root user when installing.
+- RS46947 - Fixes removal of old installations in install.sh.
+
+## Known limitations
+
+### Feature limitations
+
+- RS81463 A shard might crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+- RS54131 Running the `QUIT` command on a TLS connected database closes connection and does not return a `+OK` reply
+
+### Upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with open source Redis. The following [Open Source Redis](https://github.com/redis/redis) [CVEs](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+- [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement LCS. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+- [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16) security fixes for [recent CVEs](https://github.com/redis/redis/security/advisories). Redis Enterprise has already included the fixes for the relevant CVEs. Some CVEs announced for Open Source Redis do not affect Redis Enterprise due to different and additional functionality available in Redis Enterprise that is not available in Open Source Redis.
+---
+Title: Redis Enterprise Software release notes 6.2.18-65 (December 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: Added To field to test email server alerts. New flag to skip cluster
+  resource validation during imports. Improved error messages.
+linkTitle: 6.2.18-65 (December 2022)
+toc: 'true'
+weight: 70
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.2.18](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | `b51d13e30f4a7e1a134982342b8865b0` |
+| RedHat Enterprise Linux (RHEL) 8<br/>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:
+
+- [RediSearch v2.4.16]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.4-release-notes#v2416-november-2022" >}})
+- [RedisGraph v2.8.20]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.8-release-notes#v2820-september-2022" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database. 
+
+## Resolved issues
+
+- RS87191 - Fixes syncer stop due to cross slot violation error in Auto Tiering
+
+## Known upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.---
+Title: Redis Enterprise Software release notes 6.2.18-70 (January 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: New script to generate new self-signed certificates for renewal. Improved
+  logs. Deactivate alert_mgr using rladmin.
+linkTitle: 6.2.18-70 (January 2023)
+toc: 'true'
+weight: 69
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.2.18](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | `e14fcf6973418602f2b64a55a0bc8374` |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | `f61d0d8f0bb5ad90a470482d6575eb27` |
+
+## New features and enhancements
+
+- Added a new script to generate new self-signed certificates for renewal. For details, see [Certificates]({{< relref "/operate/rs/security/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`]({{< relref "/operate/rs/clusters/optimize/turn-off-services" >}}) (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:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+---
+Title: Redis Enterprise Software release notes 6.2.18
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: Database auditing. Private key encryption. Active-Active database support
+  for MEMORY USAGE command.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: 6.2.18 releases
+toc: 'true'
+weight: 73
+---
+
+[Redis Enterprise Software version 6.2.18](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+This version of Redis Enterprise Software offers:
+
+- RedisJSON on Active-Active General Availability 
+- Database connection auditing
+- Private key encryption
+- Active-Active support for `memory usage` command
+- `crdb-cli` improvements
+- Compatibility with open source Redis v6.2.6
+- Additional enhancements and fixes
+
+## Detailed release notes
+
+For more detailed release notes, select a build version from the following table:
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+
+## Deprecations
+
+### Active-Active database persistence
+
+The snapshot option for [data persistence on Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}manage/#data-persistence) will be deprecated in a future version of Redis Enterprise Software. If you have an Active-Active database using snapshot persistence, switch to AOF persistence. Use `crdb-cli` to do so:
+```text
+crdb-cli crdb update --crdb-guid <CRDB_GUID> --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+### TLS 1.0 and TLS 1.1 
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.  
+
+Please verify that all clients, apps, and connections support TLS 1.2.  Support for the earlier protocols will be removed in a future release.
+
+Certain operating systems, such as RHEL 8, have removed support for the earlier protocols. Redis Enterprise Software does not support connection protocols that are not supported by the underlying operating system.
+
+### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+## Known limitations
+    
+### Feature limitations
+
+- RS54131 Running the `QUIT` command on a TLS connected database closes connection and does not return a `+OK` reply
+
+- An intermittent issue can occur where a CRDB process becomes stuck in a restart loop. If this issue occurs while upgrading to Redis Enterprise Software version 6.2.18, please upgrade to the latest version [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}) or [contact support](https://redis.com/company/support/).
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+- RS51144, RS102128 - Active-Active: To start successfully, the syncer (`crdt-syncer`) must connect to all sources. In multi-cluster configurations (more than 2 A-A clusters participating), in some cases, if one or more of the clusters is not available, A-A replication will be down.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+### Upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.2.18, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+---
+Title: Redis Enterprise Software Release Notes 6.2.10 (February 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.5
+description: Python 3 support.  RHEL 8.5 support.
+linkTitle: 6.2.10 (February 2022)
+weight: 75
+---
+
+[Redis Enterprise Software version 6.2.10](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+The following table shows the MD5 checksums for the available packages.
+
+|Package| MD5 Checksum |
+|:------|:-------------|
+| Ubuntu 16 | `531cea69a58fbc1125bc5f76ba01da7f` |
+| Ubuntu 18 | `ec9ac6e0111dc85605d3b98e83f50150` |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | `2f7572caab9600417ef8b4ee474d6768` |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 | `377a539ee050515e1e0640dec1e04129` |
+| K8s Ubuntu | `099192416a70a12790535bdcd78a6e87` |
+| K8s RHEL   | `f267abe81770ddf36f022232f4c2cb2e` |
+
+## Features and enhancements
+
+- Upgrade the Redis Enterprise infrastructure to [Python v3.9](https://www.python.org/).
+
+- [Red Hat Enterprise Linux (RHEL) v8.5](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/8.5_release_notes/index) and [Red Hat Enterprise Linux (RHEL) v8.6](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/8.6_release_notes/index) is now a [supported platform]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms" >}}).
+
+- [Oracle Linux v8](https://docs.oracle.com/en/operating-systems/oracle-linux/8/) is now a [supported platform]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms" >}}).
+
+- Compatibility with [open source Redis 6.2.5](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES).
+
+- Compatibility with the [security fixes](https://github.com/redis/redis/releases/tag/6.2.6) of the latest [open source Redis 6.2.6](https://github.com/redis/redis/releases/tag/6.2.6).
+
+- Enhancements and bug fixes.
+
+## Version changes 
+
+### Prerequisites and notes 
+
+-  You can [upgrade to v6.2.10]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) from Redis Enterprise Software v6.0 and later. 
+
+- Refer to [v6.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021" >}}) for important notes regarding changes made to the upgrade.
+
+- Upgrades from versions earlier than v6.0 are not supported.
+
+- If you plan to upgrade your cluster to RHEL 8, refer to [v6.2.8 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021" >}}) for known limitations.
+
+- If you are using Active-Active or Active-Passive (ReplicaOf) databases and experience synchronization issues as a result of the upgrade, see RS67434 details in [Resolved issues](#resolved-issues) for help resolving the problem.
+
+### Product lifecycle updates 
+
+Redis Enterprise Software v6.0.x will reach end of life (EOF) on May 31, 2022.
+
+To learn more, see the Redis Enterprise Software [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}), which details the release number and the end-of-life schedule for Redis Enterprise Software.
+
+For Redis modules information and lifecycle, see [Module lifecycle]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}).
+
+## Redis modules 
+
+Redis Enterprise Software v6.2.10 includes the following Redis modules:
+
+- [RediSearch v2.2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch" >}})
+- [RedisJSON v2.0.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson" >}})
+- [RedisBloom v2.2.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/)
+- [RedisGraph v2.4.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph" >}})
+- [RedisTimeSeries v1.4.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries" >}})
+
+Starting with Redis Enterprise Software v6.2.10 build 121, the included modules versions are:
+
+- [RediSearch v2.4.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch" >}})
+- [RedisJSON v2.0.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson" >}})
+- [RedisBloom v2.2.14]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/)
+- [RedisGraph v2.8.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph" >}})
+- [RedisTimeSeries v1.6.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries" >}})
+
+For help upgrading a module, see [Add a module to a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}#upgrading-the-module-for-the-database). 
+
+## Interface enhancements
+
+- When choosing RedisJSON, the user interface (UI) now suggests RedisSearch as well. To learn more, see the [RedisJSON preview announcement](https://redis.com/blog/redisjson-public-preview-performance-benchmarking/), which details the benefits of combining [RedisJSON](http://redisjson.io/) and [RediSearch](http://redisearch.io/).
+- Adds the ability to sort the columns of the node list (RS48256).
+- When creating a new geo-distributed (Active-Active) database, an endpoint port is no longer required.  The system assigns one if none if provided (RS27632).
+
+## Additional enhancements
+
+- Added an option to run a connectivity health check for the management layer of Active-Active databases. Run the following REST API command:
+
+    ```sh
+    GET https:/[host][:port]/v1/crdbs/<crdb_guid>/health_report
+    ```
+
+- Added TLS handshake error messages to the DMC proxy log (RS59346).
+
+## Resolved issues 
+
+- RS58219 - Fixes a UI error message that showed a path instead of a relevant error message.
+- RS44958 - Fixes incorrect description for the graph "incoming traffic" in Active-Active (geo-distributed) database UI Metrics.
+- RS66280 - Fixes the lexicographic [SORT]({{< relref "/commands/sort" >}}) command on Active-Active databases (e.g. `SORT mylist ALPHA`). The SORT command should only run on keys mapped to the same slot.
+- RS64575 - Fixes a bug in the replication between primary and replica shards of a destination Active-active database in the scenario of using Replica-Of from a single to an Active-Active database, where the syncer process went down during the full sync.
+- RS65370 - Adds logic to remove old syncer entries in the cluster configuration during upgrades.
+- RS67434 - Version 6.2.10 fixes the mTLS handshake between the [syncer process]({{< relref "/operate/rs/databases/active-active" >}}#syncer-process) and the [proxy (DMC)](https://docs.redis.com/latest//rs/references/terminology/#proxy), where the proxy presented a leaf certificate without its full chain to the syncer. After upgrading to 6.2.10, syncer connections using invalid certificates will break the synchronization between Active-Active instances or deployments using Replica Of when TLS is enabled. To ensure certificates are valid before upgrading do the following: 
+
+    - For Active-Active databases, run the following command from one of the clusters:
+        
+        `crdb-cli crdb update --crdb-guid <CRDB-GUID> --force`
+         
+    - For Active-Passive (Replica Of) databases: use the admin console to verify that the destination syncer has the correct certificate for the source proxy (DMC).  For details, see [Configure TLS for Replica Of]({{< relref "/operate/rs/databases/import-export/replica-of" >}}create/#configure-tls-on-replica-database).
+
+### Issues resolved in build 96
+
+- RS67133 - An issue in Redis Enterprise Software affected replication in replica databases using RedisGraph, RediSearch, and RedisGears in specific scenarios.  The problem appeared when importing an RDB file or while synchronizing target Active-Passive (ReplicaOf) databases. 
+
+    This issue is fixed in Redis Enterprise Software v6.2.10-96 and RedisGraph v2.8.11.  We recommend upgrading to these versions at your earliest opportunity.  (Failure to upgrade can lead to data loss.)  
+    
+    Once the upgrades are complete, secondary shards might need to be restarted.  You can use `rlutil` to restart secondary shards:
+
+    ``` sh
+    rlutil redis_restart redis=<shard-id1>,<shard-id2>,...
+    ```
+
+### Issues resolved in build 100
+
+- RS74171 - A new command was added as part of Redis 6.2: [XAUTOCLAIM]({{< relref "/commands/xautoclaim" >}}). When used in an Active-Active configuration, this command may cause Redis shards to crash, potentially resulting in data loss. The issue is fixed in Redis Enterprise Software version 6.2.12. Additionally, we recommend enabling AOF persistence for all Active-Active configurations.
+
+### Issues resolved in build 121
+
+- RS68668, RS72082 - Improvements for internode encryption certification rotation
+- RS72304 - Avoid starting a master shard when both master and replica shards crash and the replica did not finish recovery
+- RS74469 - Fix for some Redis Active-Active + Redis Streams scenarios that could lead to shard crash during backup; failure to backup
+
+### Issues resolved in build 129
+
+- RS77003 - Add grace time to job scheduler to allow certificate rotation in case of failure due to scheduling conflicts.
+- RS71112 - Update validation during db configuration to not fail due to ports associated with nodes that are no longer in the cluster. This was done to allow db configuration during adding and removing nodes as part of load balancing.
+- RS78486 - Fix known issue from 6.2.10 build 100 - When using rladmin tune db to change the replica buffer size, the command appears to succeed, but the change does not take effect. 
+
+## Known limitations
+
+- RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+- RS78364 - When using `rladmin tune db` to change the replica buffer size, the command appears to succeed, but the change does not take effect. This issue was introduced in build 100; it will be fixed in a future build of Redis Enterprise Software v6.2.10 and in the next release (v6.2.12).
+
+- RS63258 - Redis Enterprise Software is not currently supported on RHEL 8 with FIPS enabled.
+
+    FIPS changes system-generated keys, which can limit secure access to the cluster or the admin console via port 8443.
+
+- RS63375 - RHEL 7 clusters cannot be directly upgraded to RHEL 8 when hosting databases using modules.
+
+    Due to binary differences in modules between the two operating systems, you cannot directly update RHEL 7 clusters to RHEL 8 when those clusters host databases using modules.  Instead, you need to create a new cluster on RHEL 8 and then migrate existing data from your RHEL 7 cluster. This does not apply to clusters that do not use modules.
+
+All [known limitations]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021.md#known-limitations" >}}) listed in the v6.2.4 release notes have been addressed.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Known issues
+
+- The `ZRANGESTORE` command, with a special `zset-max-ziplist-entries` configuration can crash Redis 6.2. See [Redis repository 10767](https://github.com/redis/redis/pull/10767) for more details.
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+## Security
+
+### Open Source Redis Security fixes compatibility
+
+As part of Redis commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with open source Redis. The following [Open Source Redis](https://github.com/redis/redis) [CVE’s](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+- [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement LCS. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+- [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)security fixes for [recent CVE’s](https://github.com/redis/redis/security/advisories). Redis Enterprise has already included the fixes for the relevant CVE’s. Some CVE’s announced for Open Source Redis do not affect Redis Enterprise due to different and additional functionality available in Redis Enterprise that is not available in Open Source Redis.
+
+---
+Title: Redis Enterprise Software Release Notes 6.0.20 (April 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.0.9
+description: Role-based LDAP integration.  Enhanced client mutual authentication.  Active-Active
+  improvements for eviction policies, migration, and the BITFIELD data type.
+linkTitle: 6.0.20 (April 2021)
+weight: 77
+---
+[Redis Enterprise Software version 6.0.20](https://redislabs.com/redis-enterprise-software/download-center/software/)
+is now available! This version includes the following new features and
+improvements:
+
+-   A [new integration for LDAP]({{< relref "/operate/rs/security/access-control/ldap" >}}) authentication and
+    authorization into RS role-based access controls (RBAC). You can now use
+    LDAP to authorize access to the admin console and to authorize database
+    access.
+
+-   An enhanced [clients mutual authentication]({{< relref "/operate/rs/security/encryption/tls" >}})
+    mechanism, adding the ability to authenticate client connections using a
+    Certificate Authority (CA).
+
+-   Support of [Redis eviction
+    policies]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}})
+    on
+    [Active-Active]({{< relref "/operate/rs/databases/active-active/create.md" >}})
+    Redis databases.
+
+-   A new [migration process for Active-Active]({{< relref "/operate/rs/databases/import-export/migrate-to-active-active.md" >}})
+    Redis database using the Active-Passive (Replica Of) mechanism.
+
+-   Support for the [BITFIELD data type on Active-Active]({{< relref "/operate/rs/databases/active-active/develop/data-types/strings.md" >}})
+    Redis databases.
+
+And other functional and stability improvements.
+
+## Version information
+
+### Upgrade instructions
+
+-   Follow [these instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+    for upgrading to Redis Software 6.0.20 from Redis Software 5.6.0 and above.
+
+    -   Note that upgrades from earlier Redis Software versions are not supported.
+
+-   For Active-Active deployments, this release requires that you [upgrade the CRDB featureset version]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}).
+
+-   Upgrades of Active-Active databases to Redis Software 6.0.20, will require all their
+    instances to run with protocol version 1 and featureset version 1 or above.
+    Active-Active databases running on protocol version 0 and/or featureset
+    version 0 will block the upgrade.
+
+### Product lifecycle information
+
+-   End of Life (EOL) for Redis Enterprise Software 6.0 and earlier 
+    versions, can be found
+    [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+
+-   EOL for Redis modules can be found
+    [here]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle#modules-endoflife-schedule" >}}).
+
+### Deprecation Notice
+
+-   Upgrades to the next Redis Software will be enabled from version 6.0 and above.
+
+-   Support for the SASL-based LDAP mechanism was deprecated in v6.0.20.  As of v6.2.12, support has been removed and the feature is obsolete.
+
+-   Starting with Redis Software version 6.0.12, Envoy replaces Nginx for internal cluster administration.
+    Support for Nginx is considered deprecated, it will be removed in a future
+    version.
+
+## New Features
+
+#### New LDAP integration
+
+Redis Enterprise Software integrates Lightweight Directory Access Protocol
+(LDAP) authentication and authorization into its [role-based access controls]({{< relref "/operate/rs/security/access-control" >}})
+(RBAC). You can now use LDAP to authorize access to the admin console and to
+manage database access.
+
+#### Clients Mutual TLS authentication using a Certificate Authority (CA)
+
+Redis Enterprise Software adds the ability to use a Certificate Authority (CA)
+for client authentications, allowing clients to rotate their certificates
+without the need to load new certificates to your database.
+
+#### Redis eviction policies on Active-Active Redis databases
+
+All Redis [eviction policies]({{< relref "/operate/rs/databases/memory-performance/eviction-policy.md" >}})
+are now supported on Active-Active Redis databases. You can create new
+Active-Active databases or edit existing ones using the UI console to enable it.
+
+-   Note that eviction is not supported yet for Active-Active Redis databases
+    running with Auto Tiering .
+
+#### Migration to an Active-Active Redis database
+
+Redis Enterprise Software adds the ability to easily [migrate your Redis
+database to an Active-Active]({{< relref "/operate/rs/databases/import-export/migrate-to-active-active.md" >}})
+Redis database using the Active-Passive (Replica Of) mechanism.
+
+#### BITFIELD on Active-Active Redis databases
+
+Redis Enterprise Software adds the ability to use the BITFIELD data type on
+Active-Active Redis databases. Please read more about [developing for Active-Active with BITFIELD]({{< relref "/operate/rs/databases/active-active/develop/data-types/strings.md" >}})
+to understand the conflict resolution and limitations.
+
+## Redis modules
+
+The following GA releases of Redis modules are bundled with Redis Software 6.0.20:
+(Please read the below updates for 6.0.20-97)
+
+-   [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version
+    [2.0.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.0-release-notes.md" >}})
+
+-   [RedisJSON](https://redislabs.com/redis-enterprise/redis-json/), version
+    [1.0.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+
+-   [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version
+    [2.2.14]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.2-release-notes.md" >}})
+
+-   [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/),
+    version
+    [1.4.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.4-release-notes.md" >}})
+
+-   [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version
+    [2.2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}})
+
+To use the updated modules with a database, you must [upgrade the module on the
+database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Additional capabilities
+
+-   Redis Software 6.0.20 includes open source Redis 6.0.9. For more information about Redis
+    6.0.9, check out the [release notes](https://raw.githubusercontent.com/redis/redis/6.0.9/00-RELEASENOTES).
+
+-   Redis Software 6.0.20 adds new `rladmin` commands for setting Ciphers suites and minimal
+    TLS version for:
+
+    -   Control plane: setting Envoy
+
+    -   Data plane: setting the Proxy for clients connections
+
+    -   Sentinel discovery service
+
+-   Starting with Redis Software 6.0.20, new clusters will be set with minimal TLS version v1.2
+
+
+All known bugs around setting ciphers were fixed.  To learn more, see [Configure cipher suites]({{< relref "/operate/rs/security/encryption/tls/ciphers" >}}).
+
+-   Starting with Redis Software 6.0.20, the [syncer process]({{< relref "/operate/rs/databases/active-active" >}}#syncer-process)
+    was improved to automatically recover and resume synchronisation after
+    reaching out-of-memory.
+
+-   Envoy updated and verified with multiple security headers.
+
+-   Starting with Redis Software 6.0.20:
+
+    -   The replication backlog size of new databases is allocated dynamically according to shard size.
+
+    -   The Active-Active replication backlog size of new Active-Active databases is allocated dynamically according to shard size.
+
+## Important fixes
+
+-   RS50905, RS54809, 54940 - Fix in Redis preventing missing process PID
+
+-   RS53639 - Fix to avoid stuck state machine when assigning incorrect Redis
+    ACL with the allkeys alias or \~\* and also with \~\<somekey\>
+
+-   RS47983 - Fixed dependencies with installation using custom directories
+
+-   RS54382 - Fixed missing API documentation
+
+-   RS52433, RS53417, RS42195, RS42194, RS30526, RS46821, RS48928 - Fixed
+    security headers for Envoy
+    
+## Starting 6.0.20-69
+    
+-   RS55504 - Fixed issue that caused RediSearch cursor to break.
+
+## Starting 6.0.20-97
+-   RS57659 - Fixed force removing an Active-Active instance which is hosted on an inaccessible cluster
+-   RS57315 - Fixed creation and editing of an Active-Active database with LDAP users of the new RBAC LDAP integration. This applies to UI access and REST API and does not apply to LDAP users for database access via Redis Clients
+-   RS57073 - Fixed a bug caused in the shard migration process which could leave unattended shards on the node
+-   RS56508 - Fixed backwards compatibility of client certificate when upgrading from earlier versions and using a certificate chain with Extended Key Usage extension being set to “TLS Web Server Authentication” instead of “TLS Web Client Authentication”
+-   RS49289 - Fixed updating the log rotation config file according to the custom config path that was set during the installation
+-   The bundled RedisGraph module was upgraded to v2.4.6
+-   The bundled RedisTimeSeries module was upgraded to v1.4.9
+-   The bundled RediSearch module was upgraded to v2.0.8
+
+## Known limitations
+
+
+-RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+-   RS59983 - Clients may get disconnected by the proxy when one client sends an UNSUBSCRIBE command without being subscribed to any channel and disconnect before the response returns back from the server (from the proxy).
+-   RS60068 - The pdns might not resolve the master node after master node change. Restarting the pdns service is required in this case. 
+-   RS61114 - Active-Active synchronization will fail in the following scenario: a new syncer connection is established AND a partial sync (psync) was initiated AND a cron job runs before the first ACK of the psync was received.
+-   RS55504 - Bug RS6.0.20-66 (Build #66) causes RediSearch cursor to break. Please upgrade to a higher build when running with RediSearch.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+#### Upgrade
+
+-   [Redis Software 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}})
+    introduced new Active-Active Redis Database capabilities that improve its
+    compatibility with open source Redis. Now the string data-type in
+    Active-Active Redis Database is implicitly and dynamically typed, just like
+    open source Redis. To use the new capabilities on nodes that are upgraded
+    from version RS 5.4.2 or lower, you must 
+    [upgrade the Active-Active Redis Database protocol]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}).
+
+-   When you upgrade an Active-Active Redis with active AOF from [Redis Software 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}})
+    or earlier to version [Redis Software 5.4.4]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-4-june-2019.md" >}})
+    or later:
+
+    -   If replication is enabled, you must run the BGREWRITEAOF command on all
+        replica shards after the upgrade.
+
+    -   If replication is not enabled, you must run the BGREWRITEAOF command on
+        all shards after the upgrade.
+
+-   Node upgrade fails if the SSL certificates were configured in version 5.0.2
+    or above by manually updating the certificates on the disk instead of
+    [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For help with this issue, contact Support.
+
+-   Starting from [Redis Software 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}),
+    to preserve the current Redis major.minor version during database upgrade
+    you must use the keep_redis_version option instead of keep_current_version.
+
+#### Redis commands 
+
+-   The capability of disabling specific Redis commands does not work on
+    commands specific to Redis modules.
+
+-   CLIENT UNBLOCK command is not supported in RS 5.4 and above
+
+-   Starting from RS 5.4.2 and after upgrading the CRDB, TYPE commands for
+    string data-type in CRDBs return "string" (OSS Redis standard).
+    
+#### Security
+
+-   As part of Redis commitment to security, the following [Open Source Redis](https://github.com/redis/redis) [CVE's](https://github.com/redis/redis/security/advisories) have been addressed in Redis Enterprise 6.0.20: 
+ 
+    -   [CVE-2021-32626](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32626) - Lua scripts can overflow the heap-based Lua stack. This has been addressed in Redis Enterprise 6.0.20-62
+
+    -   [CVE-2021-32627](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32627) - Integer overflow issue with Streams. This has been addressed in Redis Enterprise 6.0.20-1
+
+    -   [CVE-2021-32628](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32628) - Vulnerability in handling large ziplists. This has been addressed in Redis Enterprise 6.0.20-1
+
+    -   [CVE-2021-32687](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32687) - Integer overflow issue with intsets. This has been addressed in Redis Enterprise 6.0.20-89
+
+-   The following [Open Source Redis](https://github.com/redis/redis) [CVE's](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+    -   [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement `LCS`. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+    -   [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+---
+Title: Redis Enterprise Software release notes 7.2.4-92 (November 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: New Cluster Manager UI enhancements - LDAP configuration improvements.
+  New `capability_name` field added to module REST API object. Automatic removal of
+  deprecated, predefined roles and ACLs upon cluster upgrade, unless they are associated
+  with any users or databases.
+linkTitle: 7.2.4-92 (November 2023)
+weight: 69
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software), 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:
+
+- New Cluster Manager UI enhancements
+
+- New `capability_name` field in module REST API object 
+
+- Automatic removal of deprecated, predefined roles and ACLs upon cluster upgrade, unless they are associated with any users or databases
+
+## New in this release
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - Improved [LDAP configuration]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap" >}}) and moved it from **Cluster > Security > LDAP** to **Access Control > LDAP > Configuration**
+
+- New `capability_name` field added to [module REST API object]({{< relref "/operate/rs/references/rest-api/objects/module" >}})
+
+- The following predefined roles and ACLs are removed automatically when you upgrade the cluster, unless they are associated with any users or databases, as planned in the Redis Enterprise Software version 7.2.4-52 [deprecation notice]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#access-control-deprecations" >}}):
+
+    - Custom roles (not management roles): Cluster Member, Cluster Viewer, DB Member, DB Viewer, None.
+
+    - Redis ACLs: Not Dangerous and Read Only.
+
+#### Redis modules
+
+Redis Enterprise Software versions 7.2.4-92 and 7.2.4-86 include the following Redis Stack modules:
+
+- [RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)
+
+- [RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)
+
+- [RedisTimeSeries 1.10.6](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.6)
+
+- [RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)
+
+- [RedisGears 2.0.12](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.12-m13)
+
+### Resolved issues
+
+The following issues were resolved in ​Redis Enterprise Software version 7.2.4-92:
+
+- RS114368 - Cluster upgrades should no longer show a warning that the `redislabs` user or group already exists.
+
+- RS114185 - Resolved a [known issue]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-92#known-issues" >}}) regarding cluster upgrade failures due to a `Failed to get default_suffix` error, which appears in `dmcproxy.log`.
+
+The following issues were resolved in ​Redis Enterprise Software version 7.2.4-86:
+
+- RS109744 - Node removal sometimes got stuck in a `starting` state when `wait_for_persistence` was enabled.
+
+- RS110481 - Importing a database mid-upgrade failed when the primary (master) node had the new version.
+
+- RS111363 - Fixed an issue in the legacy UI, where you could not update and save your changes on the **settings > preferences** tab even though these settings were visible.
+
+- RS39744 - The `/opt/redislabs` directory was not created with `redislabs` user and group.
+
+- RS111648 - In `cnm_exec.log`, replaced "root" with the module utils log name.
+
+- RS112517 - Fixed an issue in the `prepare_flash` script that reduced Auto Tiering performance on Ubuntu 20.
+
+- RS104189 - Added timeout to `/shards` API to prevent long response times if a shard is stuck.
+
+- RS108771 - Fixed migration issue when a node containing the source shard was down.
+
+- RS105989 - Fixed node removal failure during cluster upgrade.
+
+- RS112568 - Fixed migration and node removal scenarios where a node contained a module that was not spread to all cluster nodes.
+
+- RS110204 - Fixed failure to change the primary (master) node when requested during an upgrade if a shard was down.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Release date** | Aug<br />2023 | Feb<br />2023 | Sept<br />2022 | Aug<br />2022 | Feb<br />2022 | Oct<br />2021 | Aug<br />2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | – | Feb<br />2025 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 |
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[8](#table-note-8)</sup> | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+8. <a name="table-note-8" style="display: block; height: 80px; margin-top: -80px;"></a>Redis Enterprise Software [6.4.2-103]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-103" >}}) and later supports RHEL 8.8.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-92 November release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 17166732725284728162180d92e3fa72 |
+| Ubuntu 20 | d4bd75933d95bbd18d487b9834180517 |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | 78447b4643fafb5dcec37c2981ca7b59 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 6dc4f3ba3d789d8e02f7a963128b79a4 |
+| Amazon Linux 2 | f829ecba9874ed30229736617ad8f0f8 |
+
+## Known issues
+
+- RS114185 - During an upgrade to Redis Enterprise Software version 7.2.4-86, the proxy might not start due to a `Failed to get default_suffix` error, which appears in `dmcproxy.log`.
+
+    As a workaround, start `dmcproxy` manually:
+
+    ```sh
+    supervisorctl restart dmcproxy
+    ```
+    This issue was fixed in Redis Enterprise Software version 7.2.4-92.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-92 and 7.2.4-86 support open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4-109 (May 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Bug fixes.
+linkTitle: 7.2.4-109 (May 2024)
+weight: 67
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Bug fixes
+
+## New in this release
+
+### Enhancements
+
+#### Redis modules
+
+Redis Enterprise Software versions 7.2.4-109 includes the following Redis Stack modules:
+
+- [RediSearch 2.8.9]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes" >}})
+
+- [RedisJSON 2.6.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes" >}})
+
+- [RedisTimeSeries 1.10.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes" >}})
+
+- [RedisBloom 2.6.11]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes" >}})
+
+- [RedisGears 2.0.17](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.17-m18)
+
+### Resolved issues
+
+- RS121673: Search commands no longer return an error after fixing incorrect configuration.
+
+- RS123237: CRDT syncer prevents potential data mismatches or data loss due to missing keys when removing and re-adding a cluster in an Active-Active setup with at least three participating clusters after removing older clusters without re-adding them.
+
+- RS122221: `redis-server` creates PID file only after binding to a socket.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-109 May release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | ae041ffa0eee0652afe69767683a64e4 |
+| Ubuntu 20 | 9e33c630f357a657eed8f084eec70d8d |
+| Red Hat Enterprise Linux (RHEL) 7 | 8f3c56ad8ae2a790a31e2253eaaa1ccc |
+| Red Hat Enterprise Linux (RHEL) 8 | 974c6815bfd53bf74e349b2beae1780f |
+| Amazon Linux 2 | 70c7a8560ee96d72065132e77cb79fe0 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-109 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4-64 (September 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Improved cluster recovery with manually uploaded modules. Support package
+  contains supervisorctl status. Configure port range using rladmin and REST API.
+  License API returns the number of used shards (RAM & flash).
+linkTitle: 7.2.4-64 (September 2023)
+weight: 71
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Improved cluster recovery with manually uploaded modules
+
+- Support package enhancements
+
+- Configurable port range
+
+- License API enhancements
+
+## New in this release
+
+### Enhancements
+
+- Cluster recovery with manually uploaded modules 
+
+    - For clusters containing databases with manually uploaded modules, [cluster recovery]({{< relref "/operate/rs/clusters/cluster-recovery" >}}) is now seamlessly integrated.
+
+- Support package now contains `supervisorctl` status when created by the [`rladmin` command]({{< relref "/operate/rs/installing-upgrading/creating-support-package#command-line-method" >}}) (RS107879).
+
+- Port range (`reserved_ports`) is now configurable using [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) or the [REST API]({{< relref "/operate/rs/references/rest-api/requests/cluster#put-cluster" >}}).
+
+    - Removed `rlutil reserved_ports`, which was deprecated in Redis Enterprise Software [version 7.2.4-52]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#api-deprecations" >}}).
+
+- [License REST API requests]({{< relref "/operate/rs/references/rest-api/requests/license" >}}) return the number of used shards (RAM & flash).
+
+#### Redis modules
+
+Redis Enterprise Software version 7.2.4-64 includes the following Redis Stack modules (no changes since [Redis Enterprise Software version 7.2.4-52]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}}):
+
+- [RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)
+
+- [RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)
+
+- [RedisTimeSeries 1.10.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.4)
+
+- [RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)
+
+- [RedisGears 2.0.11](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.11-m12)
+
+### Resolved issues
+
+- RS107986 - Allow ports lower than 1024 when configuring [auditing]({{< relref "/operate/rs/security/audit-events" >}}) using `rladmin`.
+
+- RS105335 - Added error handling to [`CLIENT NO-TOUCH`]({{< relref "/commands/client-no-touch" >}}) to return an error if the Redis database version is earlier than 7.2.0 or the command is restricted by ACL rules (handles `CLIENT NO-TOUCH` [command limitations](https://docs.redis.com/latest/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52/#command-limitations)).
+
+- RS105137 - Fixed audit reconnect issue: sometimes the proxy failed to reconnect to a restarted audit listener.
+
+- RS108394 - Added API validation to prevent configuring Replica Of with TLS without providing a server certificate.
+
+- RS108233 - Proceed with the upgrade even if an empty `saslauthd` configuration exists.
+
+- RS107730 - Fixed a bug where the `failed_authentication_attempt` event log always contained 127.0.0.1 instead of the real client IP address.
+
+- RS107727 - Fixed permission issue for `/etc/cron.d/redislabs` file in Red Hat.
+
+- RS108230 - Removed unused test certificate and key files from the `redis-enterprise` package.
+
+- RS107718 - When `cm_server` is disabled through `optional_services`, envoy (the cluster’s reverse proxy) now stops listening on the `cm_server` port.
+
+- RS107909 - Added `os_family`, which groups operating systems into categories, to node properties and upgrade logic. Fixed the [known limitation]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#modules-cannot-load-in-oracle-linux-7--8" >}}) for upgrades and module uploads for the following operating systems: Rocky Linux, Oracle Linux 7, Oracle Linux 8, CentOS 7, and CentOS 8.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | – | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-64 September release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | eed1a8ba22a9eb2ae6e23d557961e9a7 |
+| Ubuntu 20 | 49b29512123fcd9dd402b53b380e8c78 |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | d90a75b56fe1bc628d2ac27bc137af41 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | d9d98b0859b2d6fe8a7802cb6f44f132 |
+| Amazon Linux 2 | b9f1c99b39bb8084583b10d1546f80e1 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-64 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4-122 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Internal fixes and improvements.
+linkTitle: 7.2.4-122 (March 2025)
+weight: 66
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Internal fixes and improvements
+
+## New in this release
+
+#### Redis modules
+
+Redis Enterprise Software versions 7.2.4-122 includes the following Redis Stack modules:
+
+- [RediSearch 2.8]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes" >}})
+
+- [RedisJSON 2.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes" >}})
+
+- [RedisTimeSeries 1.10]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes" >}})
+
+- [RedisBloom 2.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes" >}})
+
+- [RedisGears 2.0](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.17-m18)
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-122 March release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | ce855ba32bce9c9b1880e3a604d7c722 |
+| Ubuntu 20 | 74fed091eda2241fae06456b3aef2cbf |
+| Red Hat Enterprise Linux (RHEL) 7 | f2c5538b109397eb8cea293924e6ba70 |
+| Red Hat Enterprise Linux (RHEL) 8 | 21660961b8810aa82bdee5ef00f8be82 |
+| Amazon Linux 2 | 0060c27b44dd5f5a1e5037a8b415378f |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-122 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4-105 (February 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: LDAP authentication timeout is configurable using the REST API. RHEL
+  8.9 support.
+linkTitle: 7.2.4-105 (February 2024)
+weight: 68
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Configurable LDAP authentication timeout
+
+- RHEL 8.9 support
+
+## New in this release
+
+### Enhancements
+
+- LDAP authentication timeout `directory_timeout_s` is now configurable using a [`PUT /v1/cluster/ldap`]({{< relref "/operate/rs/references/rest-api/requests/cluster/ldap#put-cluster-ldap" >}}) REST API request.
+
+- Added support for RHEL 8.9.
+
+#### Redis modules
+
+Redis Enterprise Software versions 7.2.4-105 includes the following Redis Stack modules:
+
+- [RediSearch 2.8.9](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.9)
+
+- [RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)
+
+- [RedisTimeSeries 1.10.6](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.6)
+
+- [RedisBloom 2.6.11](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.11)
+
+- [RedisGears 2.0.17](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.17-m18)
+
+### Resolved issues
+
+- RS106070: Cluster upgrade will fail and display an error to the user after a timeout is exceeded.
+
+- RS107974: Increased retry count for join requests in case the local CCS isn’t available.
+
+- RS118229: Fixed an issue in the new Cluster Manager UI where a database could not be scaled up to use the maximum shards available for a trial license.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Release date** | Aug<br />2023 | Feb<br />2023 | Sept<br />2022 | Aug<br />2022 | Feb<br />2022 | Oct<br />2021 | Aug<br />2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | – | Feb<br />2025 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 |
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.9| <span title="Supported">&#x2705;</span></span><sup>[9](#table-note-9)</sup> | – | – | – | – | – | – |
+| 8.8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[8](#table-note-8)</sup> | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+8. <a name="table-note-8" style="display: block; height: 80px; margin-top: -80px;"></a>Redis Enterprise Software [6.4.2-103]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-103" >}}) and later supports RHEL 8.8.
+
+9. <a name="table-note-9" style="display: block; height: 80px; margin-top: -80px;"></a>Redis Enterprise Software [7.2.4-105]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-105" >}}) and later supports RHEL 8.9.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-105 February release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 8d78258f76d0968437c0b6bc4e1c5e12 |
+| Ubuntu 20 | 48bcb267f6d154989726b556e93f64aa |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | 2d5ad0090de6f5ef513cbf4e07da9ed5 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 974c6815bfd53bf74e349b2beae1780f |
+| Amazon Linux 2 | bf296f206da39830f3c4d8d46e2193c1 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-105 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4-52 (August 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Redis 7.0 and 7.2 features. Auto Tiering (enhanced successor to Redis
+  on Flash). RESP3 support. Sharded pub/sub. Preview of the new Cluster Manager UI.
+  Redis Stack 7.2 features. Three Redis database versions. License file structure
+  updates. Redis ACL selectors and enhanced key-based permissions. New INFO fields.
+  Log rotation enhancements. Multi-OS upgrade support for clusters with modules.
+linkTitle: 7.2.4-52 (August 2023)
+weight: 72
+---
+
+​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+
+- Redis 7.0 and 7.2 features
+
+- Auto Tiering (enhanced successor to Redis on Flash)
+
+- RESP3 support
+
+- Sharded pub/sub
+
+- A preview of the new Cluster Manager UI (admin console)
+
+- Redis Stack 7.2 features
+
+- Three Redis database versions: 7.2, 6.2, 6.0
+
+- License file structure updates
+
+- Redis ACL selectors and enhanced key-based permissions
+
+- New INFO fields
+
+- Log rotation enhancements
+
+- Multi-OS upgrade support for clusters with modules
+
+## New in this release
+
+### New features
+
+#### Redis 7.0 features
+
+The following Redis 7.0 features are now supported:
+
+- [Redis functions]({{< relref "/develop/interact/programmability/functions-intro" >}})
+
+    In Redis Enterprise Software, [`FUNCTION STATS`]({{< relref "/commands/function-stats" >}}) returns an extra parameter, an array called `all_running_scripts`, to reflect multiple functions running at the same time.
+
+- [Multipart AOF]({{< relref "/operate/oss_and_stack/management/persistence" >}}#append-only-file) (append-only files)
+
+- New commands
+
+- Sharded `PUBSUB` (see [Sharded pub/sub](#sharded-pubsub) for details)
+
+#### Redis 7.2 features
+
+The following Redis 7.2 features are now supported:
+
+- Various performance improvements
+
+- `CONFIG SET` for locale
+
+- Connection layer modularization
+
+- Encoding improvements: listpack for sets and lists
+
+- Observability: authentication metrics (exposed by `INFO` command)
+
+- Stream consumer group improvements
+
+- Commands: `ZRANK`, `ZREVRANK` new `WITHSCORE` option
+
+- Shard IDs in cluster shards topology
+
+- Introduce shard ID to Redis cluster
+
+- Support `CLIENT NO-TOUCH` command
+
+- `WAIT AOF`
+
+#### Auto Tiering - Redis on Flash evolution doubles throughput and reduces latency {#auto-tiering}
+
+Redis Enterprise version 7.2 introduces Auto Tiering as an enhanced successor to Redis on Flash, which allows you to provision larger databases at a lower cost by extending the RAM with flash drives.
+
+Redis Enterprise Auto Tiering replaces RocksDB with [Speedb](https://www.speedb.io/) as its storage engine, doubling the throughput and reducing latencies, achieved using the same infrastructure resources. For example, a 1 TB database with 50K ops/sec can now serve 100K ops/sec based on the same infrastructure.
+
+To switch existing databases to use Speedb for Auto Tiering and improve performance:
+
+1. Upgrade the cluster to Redis Enterprise Software version 7.2.4.
+
+1. Upgrade each database with Auto Tiering enabled to Redis database version 7.2.
+
+For more information about Auto Tiering, see:
+
+- [Auto Tiering overview]({{< relref "/operate/rs/databases/auto-tiering" >}})
+
+- [Auto Tiering quick start]({{< relref "/operate/rs/databases/auto-tiering/quickstart" >}})
+
+#### RESP3 support
+
+Support for RESP3 and the [`HELLO`]({{< relref "/commands/hello" >}}) command was added in Redis Enterprise 7.2.
+
+To use RESP3 with Redis Enterprise:
+
+1. Upgrade Redis servers to version 7.2 or later.
+
+    For Active-Active and Replica Of databases:
+ 
+    1. Upgrade all participating clusters to Redis Enterprise version 7.2.x or later.
+ 
+    1. Upgrade all databases to version 7.x or later.
+
+1. Enable RESP3 support for your database (`enabled` by default):
+
+    ```sh
+    rladmin tune db db:<ID> resp3 enabled
+    ```
+
+If you run Redis Stack commands with Redis clients [Go-Redis](https://redis.uptrace.dev/) version 9 or [Lettuce](https://redis.github.io/lettuce/) versions 6 and later, see [client prerequisites](#client-prerequisites-for-redis-72-upgrade) before you upgrade to Redis 7.2 to learn how to prevent potential application issues due to RESP3 breaking changes.
+
+#### Sharded pub/sub
+
+[Sharded pub/sub]({{< relref "/develop/interact/pubsub" >}}#sharded-pubsub) is now supported.
+
+You cannot use sharded pub/sub if you [deactivate RESP3 support]({{< relref "/operate/rs/references/compatibility/resp#deactivate-resp3" >}}).
+
+#### New Cluster Manager UI preview
+
+A preview of the new Cluster Manager UI (admin console) is available in Redis Enterprise Software version 7.2.4.
+
+To try out the new UI:
+
+- On the sign-in screen:
+
+    1. Enter your credentials.
+
+    1. Select **Sign in the new interface**.
+
+- Sign in directly from the new UI's sign-in screen at <nobr>`https://<hostname or IP address>:8443/new`</nobr>
+
+- If you are currently signed in to the legacy UI:
+
+    1. Select **Switch to the new Admin Console** to expand the banner at the top of the screen.
+    
+    1. Click the **Try it now** button to open the new UI in another tab.
+
+##### New UI benefits
+
+- User-driven design
+
+- Provides full functionality to complete tasks entirely in the UI
+
+- New attributes and improved feature visibility
+
+- Provides configuration flexibility while highlighting the recommended path
+
+- Addresses the needs of different personas and use cases
+
+- Quicker troubleshooting and easier maintenance
+
+##### New UI highlights
+
+- More configurable database attributes, including replica high availability, shards placement, and proxy policy.
+
+- Nodes indicate whether it’s a primary or secondary node.
+
+- Modules show the databases that are using them.
+
+- Certificates show expiration and validity, and you can upload and copy certificates.
+
+- Cluster license displays the number of shards that are used out of the number of shards that are licensed to the cluster. The new UI allows you to paste or upload a new license.
+
+- Role-based access control (RBAC) has explanations to improve clarity. 
+
+- Access Control List (ACLs) now support defining ACLs for modules.
+
+- The databases screen has more information per database for faster troubleshooting. It also allows you to filter databases and compare database metrics.
+
+- The cluster name, user, and user role are shown in the upper right for quickly identifying the cluster from any screen. You can also **Change user password** from the dropdown menu.
+
+- Auto Tiering licensing and a toggle for the storage engine used in Auto Tiering enabled databases (available only in the new UI).
+
+- Input validations.
+
+##### New UI limitations
+
+The following features are not supported in this preview but will be added in future releases. Until then, temporarily switch to the legacy UI to do the following:
+
+- Provision and configure Active-Active databases (viewing is available).
+
+- Search and export the event log.
+
+- Remove a node from the UI.
+
+Additional limitations:
+
+- Although Redis supports memcached databases, the new UI only allows view and delete. Memcached users are advised to migrate to Redis to enjoy the full benefits of Redis and its UI.
+
+To open the legacy admin console when signed in to the new UI, select your username, then select **Switch to legacy Admin Console** from the list:
+
+{{<image filename="images/rs/screenshots/switch-to-legacy-ui.png"  width="300px" alt="Select switch to legacy admin console from the dropdown.">}}
+
+##### Future UI enhancements
+
+- Configure default database settings and database upgrade settings
+
+- Security preferences related to password and login management
+
+- LDAP improvements
+
+- IPv6 support
+
+- ACL improvements, such as ACLv2 smart validations
+
+- And more
+
+{{<note>}}
+With the release of the new Cluster Manager UI, the legacy UI is considered deprecated and will eventually be phased out. New functionality will only be implemented in the new Cluster Manager UI, and the old UI will no longer be maintained except for critical bug fixes.
+{{</note>}}
+
+#### Redis Stack 7.2 features
+
+Redis Enterprise Software version 7.2.4 supports features included in Redis Stack version 7.2.
+
+The following sections include a few highlights. For more details, see the [Redis Stack 7.2 release notes](https://github.com/redis-stack/redis-stack/releases/tag/v7.2.0-v0).
+
+##### Search and query
+
+- Introduces [Geo Polygon]({{< relref "commands/ft.search#examples" >}}) Search. Geo range queries now accept the [`GEOSHAPE`]({{< relref "commands/ft.create#required-arguments" >}}) field type, which supports polygon shapes using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry). `GEOSHAPE` supports `POLYGON` and `POINT` as shape formats and polygon operations.
+
+- Performance improvements for `SORT BY` operations using [`FT.SEARCH`]({{< relref "commands/ft.search#optional-arguments" >}}) and [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate#optional-arguments" >}}).
+
+- New `FORMAT` for improved readability and future support for better error handling responses on `FT.SEARCH` and `FT.AGGREGATE` in RESP3 only.
+
+##### JSON
+
+JSON introduces two new commands:
+
+ - [JSON.MERGE]({{< relref "commands/json.merge" >}}) merges a given JSON value into matching paths to update, delete, or expand the JSON values at the matching paths.
+
+ - [JSON.MSET]({{< relref "commands/json.mset" >}}) sets or updates one or more JSON values according to specified key-path-value triplets.
+
+##### Triggers and functions preview
+
+A preview of triggers and functions is available.
+
+Triggers and functions provide support for running JavaScript functions inside the Redis process. These functions can be executed on-demand, by an event-driven trigger, or by a stream processing trigger.
+
+Try it out with the [triggers and functions quick start]({{< relref "operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/quick_start_ri" >}}).
+
+{{<note>}}
+- The preview version of triggers and functions is not intended for production use since the API might change in the future and potentially cause application issues when upgrading to a later version.
+
+- During preview, triggers and functions are not supported for databases with Auto Tiering enabled (previously known as Redis on Flash).
+{{</note>}}
+
+##### Module versions
+
+Redis Enterprise Software version 7.2.4 includes the following Redis Stack modules:
+
+- [RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)
+
+- [RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)
+
+- [RedisTimeSeries 1.10.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.4)
+
+- [RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)
+
+- [RedisGears 2.0.11](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.11-m12)
+
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+### Enhancements
+
+#### Three Redis database versions
+
+Redis Enterprise Software version 6.x includes two Redis database versions: 6.0 and 6.2. As of version 7.2, Redis Enterprise Software includes three Redis database versions: 6.0, 6.2, and 7.2.
+
+To view available Redis database versions:
+
+- In the Cluster Manager UI, see **Redis database versions** on the **Cluster > Configuration** screen.
+
+- Send a [`GET /nodes` REST API request]({{< relref "/operate/rs/references/rest-api/requests/nodes" >}}) and see `supported_database_versions` in the response.
+
+The default Redis database version, which is used when you upgrade an existing database or create a new one, differs between Redis Enterprise releases as follows:
+
+| Redis<br />Enterprise | Bundled Redis<br />DB versions | Default DB version<br />(upgraded/new databases) |
+|-------|----------|-----|
+| 7.2 | 6.0, 6.2, 7.2 | 7.2 |
+| 6.4.2 | 6.0, 6.2 | 6.2 |
+| 6.2.x | 6.0, 6.2 | 6.0 |
+
+For Redis Enterprise Software version 7.2.4, `default_redis_version` is 7.2 for both `major` and `latest` upgrade policies.
+
+#### Updated Redis Enterprise license format
+
+Redis Enterprise Software version 7.2.4 includes updates to its license format, which add separate shard limits for RAM and flash shards used for Auto Tiering.
+
+For more information, see [Cluster license keys]({{< relref "/operate/rs/clusters/configure/license-keys" >}}).
+
+#### Redis ACL selectors and key-based permissions
+
+Redis ACLs in Redis Enterprise version 7.2 support key permissions and selectors.
+
+Key permissions:
+
+- `%R~<pattern>`: Grants read access to keys that match the given pattern.
+
+- `%W~<pattern>`: Grants write access to keys that match the given pattern.
+
+- `%RW~<pattern>`: Alias for `~<pattern>`. Grants read and write access to keys that match the given pattern.
+
+    See [key permissions]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#key-permissions) for more information.
+
+Selectors let you define multiple sets of rules in a single Redis ACL (only supported for databases with Redis version 7.2 or later). A command is allowed if it matches the base rule or any selector in the Redis ACL. See [selectors]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors) for more information.
+
+- `(<rule list>)`: Creates a new selector.
+
+- `clearselectors`: Deletes all existing selectors for a user. This action does not delete the base ACL rule.
+
+Redis ACLs have the following differences in Redis Enterprise Software:
+
+- Nested selectors are not supported.
+
+    For example, the following selectors are not valid in Redis Enterprise: <nobr>`+GET ~key1 (+SET (+SET ~key2) ~key3)`</nobr>
+
+- Key and pub/sub patterns do not allow the following characters: `'(', ')'`
+
+- The following password syntax is not supported: `'>', '<', '#!', 'resetpass'`
+
+    To change passwords in Redis Enterprise Software, use one of the following methods:
+
+    - Cluster Manager UI (admin console)
+
+    - [`rladmin cluster reset_password`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/reset_password" >}}):
+    
+        ```sh
+        rladmin cluster reset_password <user email>
+        ```
+
+    - REST API [`PUT /v1/users`]({{< relref "/operate/rs/references/rest-api/requests/users#put-user" >}}) request and provide `password`
+
+- The **ACL builder** does not support selectors and key permissions. Use **Free text command** to manually define them instead.
+
+#### New INFO fields
+
+The [`INFO`]({{< relref "/commands/info" >}}) command includes new fields:
+
+- Under the `STATS` section:
+
+    - `current_eviction_exceeded_time` - Redis Enterprise reply is always “0”
+
+    - `total_eviction_exceeded_time` - Redis Enterprise reply is always “0”
+
+    - `current_active_defrag_time` - Redis Enterprise reply is always “0”
+
+    - `total_active_defrag_time` - Redis Enterprise reply is always “0”
+
+- Under the `MEMORY` section:
+
+    - `maxmemory_policy` - The value of the `maxmemory-policy` configuration directive
+
+The `INFO` command can now accept multiple section arguments (requires Redis database version 7 or later).
+
+#### Log rotation enhancements
+
+- The `logrotate` tool rotates logs that exceed 200 MB.
+
+- `logrotate` runs every five minutes instead of once a day.
+
+- The job scheduler runs `logrotate` instead of the OS.
+
+- Every cluster upgrade overwrites the log rotation configuration.
+
+- You can edit the log rotation configuration at `$pkgconfdir/logrotate.conf` (`pkgconfdir` is `/opt/redislabs/config` by default, but can be changed in a custom installation). Note that the configuration file moved since last version.
+
+- You can change how often the `logrotate` tool runs using the job scheduler REST API request <nobr>`PUT /v1/job_scheduler`</nobr>.
+
+#### Multi-OS upgrade support for clusters with modules {#os-upgrades-with-modules}
+
+Starting from Redis Enterprise version 7.2, all future 7.2.x upgrades are supported for clusters containing databases with modules in combination with Operating System (OS) upgrades.
+
+### Resolved issues
+
+- RS54131 - `+OK` reply not received on TLS-enabled database
+
+- RS101525 - Cluster provides wrong number of database connections on Grafana
+
+- RS104028 - Fix the self-signed certificate script: error generating certificates with multiple FQDNs
+
+- RS87920 - Proxy log is full of the warning message “Failed to check status of running child syncer process 0 : No child processes“
+
+- RS99916 - Fixed the UI log to include the names of LDAP users at login
+
+- RS84273 - When an LDAP user with a Redis `admin` role viewed the log in the UI, they received `db_viewer` permissions instead of `admin`, which limited log visibility
+
+- RS62552 - Fixed database authentication failures for LDAP users when the password contains the `%` character
+
+## Version changes 
+
+### Breaking changes
+
+- Differences when using the `UNWATCH` command within a `MULTI` command sequence:
+
+    - Redis Enterprise: `UNWATCH` is not allowed within a `MULTI` command sequence and returns an error.
+
+    - OSS: `UNWATCH` is allowed within a `MULTI` sequence but has no effect.
+
+- When sending a `PUBSUB SHARDNUMSUB` command in OSS Cluster mode in Redis Enterprise, Redis Enterprise checks the hash slots of the requested channels. Redis Enterprise responds with a `CROSSSLOT` error if the channels don’t hash to the same slot, or a `MOVED` error if the channels hash to a different node.
+
+{{<embed-md "r7.2-combined-breaking-changes.md">}}
+
+#### Client prerequisites for Redis 7.2 upgrade
+
+The Redis clients [Go-Redis](https://redis.uptrace.dev/) version 9 and [Lettuce](https://redis.github.io/lettuce/) versions 6 and later use RESP3 by default. If you use either client to run Redis Stack commands, you should set the client's protocol version to RESP2 before upgrading your database to Redis version 7.2 to prevent potential application issues due to RESP3 breaking changes.
+
+For applications using Go-Redis v9.0.5 or later, set the protocol version to RESP2:
+
+```go
+client := redis.NewClient(&redis.Options{
+    Addr:     "<database_endpoint>",
+    Protocol: 2, // Pin the protocol version
+})
+```
+
+To set the protocol version to RESP2 with Lettuce v6 or later:
+
+```java
+import io.lettuce.core.*;
+import io.lettuce.core.api.*;
+import io.lettuce.core.protocol.ProtocolVersion;
+
+// ...
+RedisClient client = RedisClient.create("<database_endpoint>");
+client.setOptions(ClientOptions.builder()
+        .protocolVersion(ProtocolVersion.RESP2) // Pin the protocol version 	
+        .build());
+// ...
+```
+
+If you are using [LettuceMod](https://github.com/redis-developer/lettucemod/), you need to upgrade to [v3.6.0](https://github.com/redis-developer/lettucemod/releases/tag/v3.6.0).
+
+### Deprecations
+
+#### Command deprecations
+
+- [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) is deprecated as of Redis 7.0
+
+- [`JSON.RESP`]({{< relref "commands/json.resp" >}}) is deprecated as of Redis Stack 7.2.
+
+- [`QUIT`]({{< relref "/commands/quit" >}}) is deprecated as of Redis 7.2
+
+#### API deprecations
+
+Fields deprecated as of Redis Enterprise v4.3.3:
+
+- `smtp_use_tls` (replaced with `smtp_tls_mode`)
+
+- `dns_address_master`
+
+- `endpoint_node`
+
+- `endpoint_ip`
+
+- `public_addr` (replaced with `external_addr`)
+
+Fields deprecated as of Redis Enterprise v4.4.2:
+
+- `default_shards_overbooking` (replaced with `shards_overbooking`)
+
+Fields deprecated as of Redis Enterprise v6.4.2:
+
+- `use_ipv6` (replaced with `use_external_ipv6`)
+
+- `redis_cleanup_job_settings` (replaced with `persistence_cleanup_scan_interval`)
+
+Fields deprecated as of Redis Enterprise v5.0.1:
+
+- `bdb_high_syncer_lag` (replaced with `replica_src_high_syncer_lag` and `crdt_src_high_syncer_lag`)
+
+- `bdb_syncer_connection_error`
+
+- `bdb_syncer_general_error`
+
+- `sync_sources` (replaced with `replica_sources` and `crdt_sources`)
+
+- `sync` (replaced with `replica_sync` and `crdt_sync`)
+
+- `ssl` (replaced with `tls_mode`)
+
+Fields deprecated as of Redis Enterprise v7.2.4:
+
+- `node.bigstore_driver` (replaced with `cluster.bigstore_driver`)
+
+- `auth_method`
+
+- `authentication_redis_pass` (replaced with multiple passwords feature in version 6.0.X)
+
+- `slave_ha` cluster policy
+
+Other deprecated fields:
+
+- `import/rdb_url` (deprecated as of Redis Enterprise v4.X)
+
+- `logrotate_dir` (to be replaced with `logrotate_config` or removed)
+
+Deprecated CLI commands:
+
+- `rlutil change_master` (deprecated as of Redis Enterprise v6.2.18, replaced with `rladmin change_master`)
+
+- `rlutil reserved_ports` (deprecated as of Redis Enterprise v7.2, replaced with `rladmin cluster config reserved_ports`)
+
+REST API requests deprecated as of Redis Enterprise v7.2:
+
+- `POST /v1/modules` (replaced with `POST /v2/modules`)
+
+- `DELETE /v1/modules` (replaced with `DELETE /v2/modules`)
+
+#### Access control deprecations
+
+- The following predefined roles and Redis ACLs are no longer available for new Redis Enterprise Software version 7.2.4 clusters:
+
+    - Custom roles (not management roles): Cluster Member, Cluster Viewer, DB Member, DB Viewer, None.
+
+    - Redis ACLs: Not Dangerous and Read Only.
+      
+- In upcoming maintenance releases, the deprecated roles and ACLs will be removed automatically when you upgrade to Redis Enterprise Software version 7.2.4, unless they are associated with any users or databases in the cluster.
+
+- A deprecation notice for SASL-based LDAP was included in [previous Redis Enterprise Software release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021" >}}#deprecation-notices). When you upgrade to Redis Enterprise Software version 7.2.4, all existing "external" users (previously used to support SASL-based LDAP) will be removed.
+
+#### Legacy UI
+
+With the release of the new Cluster Manager UI, the legacy UI is considered deprecated and will eventually be phased out. New functionality will only be implemented in the new Cluster Manager UI, and the old UI will no longer be maintained except for critical bug fixes.
+
+#### RedisGraph
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+#### RHEL and CentOS 7.0-7.9
+
+Support for RHEL and CentOS 7.0-7.9 is considered deprecated and will be removed in a future release.
+
+#### Oracle Linux 7
+
+Oracle Linux 7 support is considered deprecated and will be removed in a future release.
+
+#### Amazon Linux 1
+
+Amazon Linux 1 support is considered deprecated and will be removed in a future release.
+
+#### Ubuntu 16.04
+
+The deprecation of Ubuntu 16.04 was announced in the [Redis Enterprise Software 6.4.2 release notes]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases#deprecations" >}}). As of Redis Enterprise Software 7.2.4, Ubuntu 16.04 is no longer supported.
+
+#### RC4 encryption cipher
+
+The RC4 encryption cipher is considered deprecated in favor of stronger ciphers. Support for RC4 by the [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) will be removed in a future release.
+
+#### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+#### TLS 1.0 and TLS 1.1
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.
+Please verify that all clients, apps, and connections support TLS 1.2. Support for the earlier protocols will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols. Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+### Upcoming changes
+
+#### Prepare for restrictive pub/sub permissions
+
+Redis database version 6.2 introduced pub/sub ACL rules that determine which [pub/sub channels]({{< relref "/develop/interact/pubsub" >}}) a user can access.
+
+The configuration option `acl-pubsub-default`, added in Redis Enterprise Software version 6.4.2, determines the cluster-wide default level of access for all pub/sub channels. Redis Enterprise Software uses the following pub/sub permissions by default:
+
+- For versions 6.4.2 and 7.2, `acl-pubsub-default` is permissive (`allchannels` or `&*`) by default to accommodate earlier Redis versions.
+
+- In future versions, `acl-pubsub-default` will change to restrictive (`resetchannels`). Restrictive permissions block all pub/sub channels by default, unless explicitly permitted by an ACL rule.
+
+If you use ACLs and pub/sub channels, you should review your databases and ACL settings and plan to transition your cluster to restrictive pub/sub permissions in preparation for future Redis Enterprise Software releases.
+
+When you change the cluster's default pub/sub permissions to restrictive, `&*` is added to the **Full Access** ACL. Before you make this change, consider the following:
+
+- Because pub/sub ACL syntax was added in Redis 6.2, you can't associate the **Full Access** ACL with database versions 6.0 or lower after this change.
+
+- The **Full Access** ACL is not reverted if you change `acl-pubsub-default` to permissive again.
+
+- Every database with the default user enabled uses the **Full Access** ACL.
+
+To secure pub/sub channels and prepare your cluster for future Redis Enterprise Software releases that default to restrictive pub/sub permissions:
+
+1. Upgrade Redis databases:
+
+    - For Redis Enterprise Software version 6.4.2, upgrade all databases in the cluster to Redis DB version 6.2.
+
+    - For Redis Enterprise Software version 7.2.4, upgrade all databases in the cluster to Redis DB version 7.2 or 6.2.
+
+1. Create or update ACLs with permissions for specific channels using the `resetchannels &channel` format.
+
+1. Associate the ACLs with relevant databases.
+
+1. Set default pub/sub permissions (`acl-pubsub-default`) to restrictive. See [Change default pub/sub permissions](#change-default-pubsub-permissions) for details.
+
+1. If any issues occur, you can temporarily change the default pub/sub setting back to permissive. Resolve any problematic ACLs before making pub/sub permissions restrictive again.
+
+#### Upcoming command request and reponse changes
+
+Open source Redis version 7.2 changes the request and response policies for several commands. Because the GA release of Redis Enterprise version 7.2 does not include these policy changes, commands might behave differently from open source Redis. However, these changes will be included in a future Redis Enterprise maintenance release:
+
+- [`RANDOMKEY`]({{< relref "/commands/randomkey" >}}) and [`SCAN`]({{< relref "/commands/scan" >}}) will change from no response policy to a `SPECIAL` response policy.
+
+- [`MSETNX`]({{< relref "/commands/msetnx" >}}) currently has a `MULTI_SHARD` request policy and `AGG_MIN` response policy. Both will change to no policy.
+
+For more information about request and response policies, see [Redis command tips]({{< relref "/develop/reference/command-tips" >}}).
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | – | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-52 August release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 7c7e465c8e129a03ee9f585137b2a1d9 |
+| Ubuntu 20 | 631f27311b19806955fde012953ff9c9 |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | ae76798b1b7243313b4f4cba6ede88d7 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 48936b25aefa2921d38aea84ad06134d |
+| Amazon Linux 2 | 3e8180d7a9ebc3784ab6080234edefd5 |
+
+## Known issues
+
+#### Legacy UI known issues
+
+When using the legacy UI, you cannot update and save your changes on the **settings > preferences** tab even though these settings are visible. This issue will be fixed in the next maintenance release.
+
+As a workaround, use the new Cluster Manager UI to update these settings from the **Cluster > Security > Preferences** tab.
+
+#### Pub/sub channel ACL limitations
+
+In Redis Enterprise Software version 6.4.2, you could use `&channel` syntax in Redis ACL rules to allow access to specific pub/sub channels even when default pub/sub permissions were permissive (`&allchannels` or `&*`), allowing all channels by default. However, `&allchannels &channel` is not valid syntax.
+
+As of Redis Enterprise Software version 7.2.4, you cannot create Redis ACLs with this combination of rules. You can only use `&channel` to allow access to specific channels if the default pub/sub permissions are restrictive (`resetchannels`).
+
+Associating an ACL that contains the invalid syntax <nobr>`&allchannels &channel`</nobr> (created before version 7.2) with a user and database might leave the database in a pending state, unable to function.
+
+To prevent this issue:
+
+1. Review all existing ACL rules.
+
+1. For each rule containing `&channel`, either:
+
+    - Add the `resetchannels` prefix to restrict access to all channels by default.
+    
+    - Delete the rule if not needed.
+
+## Known limitations
+
+#### Command limitations
+
+- [`CLIENT NO-TOUCH`]({{< relref "/commands/client-no-touch" >}}) might not run correctly in the following cases:
+
+    - The Redis database version is earlier than 7.2.0.
+
+    - The `CLIENT NO-TOUCH` command is forbidden by ACL rules.
+
+    Before sending this command, clients should verify the database version is 7.2.0 or later and that using this command is allowed. 
+
+- You cannot use [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}) to unsubscribe from a shard channel if the regex changed while subscribed.
+
+- Using [`XREADGROUP BLOCK`]({{< relref "/commands/xreadgroup" >}}) with `>` to return all new streams will cause the Redis database to freeze until the shard is restarted. ([#12031](https://github.com/redis/redis/pull/12301))
+
+- Because a rejected command does not record the duration for command stats, an error will appear after it is reprocessed that will cause the Redis database to freeze until the shard is restarted. ([#12247](https://github.com/redis/redis/pull/12247))
+
+#### Modules cannot load in Oracle Linux 7 & 8
+
+Databases hosted on Oracle Linux 7 & 8 cannot load modules.
+
+As a temporary workaround, you can change the node's `os_name` in the Cluster Configuration Store (CCS):
+
+```sh
+ccs-cli hset node:<ID> os_name rhel
+```
+
+#### Cluster recovery with manually uploaded modules
+
+For clusters containing databases with manually uploaded modules, [cluster recovery]({{< relref "/operate/rs/clusters/cluster-recovery" >}}) requires an extra step.
+
+After installing Redis Enterprise Software on the cluster nodes, upload compatible modules to `modulesdir` (`/opt/redislabs/lib/modules`) before continuing the recovery process.
+
+This limitation will be removed in a future maintenance release.
+
+## Security
+
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-52 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.0 includes all of the CVE fixes from previous versions.
+
+Redis 7.0.x:
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.2.4
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Redis 7.0 and 7.2 features. Auto Tiering (enhanced successor to Redis
+  on Flash). RESP3 support. Sharded pub/sub. Preview of the new Cluster Manager UI.
+  Redis Stack 7.2 features. Three Redis database versions. License file structure
+  updates. Redis ACL selectors and enhanced key-based permissions. New INFO fields.
+  Log rotation enhancements. Multi-OS upgrade support for clusters with modules.
+hideListLinks: true
+linkTitle: 7.2.4 releases
+toc: 'true'
+weight: 71
+---
+
+​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+ 
+- Redis 7.0 and 7.2 features
+
+- Auto Tiering (enhanced successor to Redis on Flash)
+
+- RESP3 support
+
+- Sharded pub/sub
+
+- A preview of the new Cluster Manager UI (admin console)
+
+- Redis Stack 7.2 features
+
+- Three Redis database versions: 7.2, 6.2, 6.0
+
+- License file structure updates
+
+- Redis ACL selectors and enhanced key-based permissions
+
+- New INFO fields
+
+- Log rotation enhancements
+
+- Multi-OS upgrade support for clusters with modules
+
+## Detailed release notes
+
+For more detailed release notes, select a build version from the following table:
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+
+## Version changes
+
+### Breaking changes
+
+For a list of potentially breaking changes introduced in version 7.2, see:
+
+- [Breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#breaking-changes" >}})
+
+- [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}})
+
+To prevent potential application issues due to RESP3 breaking changes, see [Client prerequisites for Redis 7.2 upgrade]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#client-prerequisites-for-redis-72-upgrade" >}}).
+
+### Deprecations
+
+#### Command deprecations
+
+- [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) is deprecated as of Redis 7.0
+
+- [`JSON.RESP`]({{< relref "commands/json.resp" >}}) is deprecated as of Redis Stack 7.2.
+
+- [`QUIT`]({{< relref "/commands/quit" >}}) is deprecated as of Redis 7.2
+
+#### API deprecations
+
+Fields deprecated as of Redis Enterprise v4.3.3:
+
+- `smtp_use_tls` (replaced with `smtp_tls_mode`)
+
+- `dns_address_master`
+
+- `endpoint_node`
+
+- `endpoint_ip`
+
+- `public_addr` (replaced with `external_addr`)
+
+Fields deprecated as of Redis Enterprise v4.4.2:
+
+- `default_shards_overbooking` (replaced with `shards_overbooking`)
+
+Fields deprecated as of Redis Enterprise v6.4.2:
+
+- `use_ipv6` (replaced with `use_external_ipv6`)
+
+- `redis_cleanup_job_settings` (replaced with `persistence_cleanup_scan_interval`)
+
+Fields deprecated as of Redis Enterprise v5.0.1:
+
+- `bdb_high_syncer_lag` (replaced with `replica_src_high_syncer_lag` and `crdt_src_high_syncer_lag`)
+
+- `bdb_syncer_connection_error`
+
+- `bdb_syncer_general_error`
+
+- `sync_sources` (replaced with `replica_sources` and `crdt_sources`)
+
+- `sync` (replaced with `replica_sync` and `crdt_sync`)
+
+- `ssl` (replaced with `tls_mode`)
+
+Fields deprecated as of Redis Enterprise v7.2.4:
+
+- `node.bigstore_driver` (replaced with `cluster.bigstore_driver`)
+
+- `auth_method`
+
+- `authentication_redis_pass` (replaced with multiple passwords feature in version 6.0.X)
+
+- `slave_ha` cluster policy
+
+Other deprecated fields:
+
+- `import/rdb_url` (deprecated as of Redis Enterprise v4.X)
+
+- `logrotate_dir` (to be replaced with `logrotate_config` or removed)
+
+Deprecated CLI commands:
+
+- `rlutil change_master` (deprecated as of Redis Enterprise v6.2.18, replaced with `rladmin change_master`)
+
+- `rlutil reserved_ports` (deprecated as of Redis Enterprise v7.2.4, replaced with `rladmin cluster config reserved_ports`)
+
+REST API requests deprecated as of Redis Enterprise v7.2.4:
+
+- `POST /v1/modules` (replaced with `POST /v2/modules`)
+
+- `DELETE /v1/modules` (replaced with `DELETE /v2/modules`)
+
+#### Access control deprecations
+
+- The following predefined roles and Redis ACLs are not available after upgrading to Redis Enterprise Software version 7.2.4 if they are not associated with any users or databases in the cluster:
+
+    - Custom roles (not management roles): Cluster Member, Cluster Viewer, DB Member, DB Viewer, None.
+
+    - Redis ACLs: Not Dangerous and Read Only.
+
+- A deprecation notice for SASL-based LDAP was included in [previous Redis Enterprise Software release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021" >}}#deprecation-notices). When you upgrade to Redis Enterprise Software version 7.2.4, all existing "external" users (previously used to support SASL-based LDAP) will be removed.
+
+#### Legacy UI
+
+With the release of the new Cluster Manager UI, the legacy UI is considered deprecated and will eventually be phased out. New functionality will only be implemented in the new Cluster Manager UI, and the old UI will no longer be maintained except for critical bug fixes.
+
+#### RedisGraph
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+#### RHEL and CentOS 7.0-7.9
+
+Support for RHEL and CentOS 7.0-7.9 is considered deprecated and will be removed in a future release.
+
+#### Oracle Linux 7
+
+Oracle Linux 7 support is considered deprecated and will be removed in a future release.
+
+#### Amazon Linux 1
+
+Amazon Linux 1 support is considered deprecated and will be removed in a future release.
+
+#### Ubuntu 16.04
+
+The deprecation of Ubuntu 16.04 was announced in the [Redis Enterprise Software 6.4.2 release notes]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases#deprecations" >}}). As of Redis Enterprise Software 7.2.4, Ubuntu 16.04 is no longer supported.
+
+#### RC4 encryption cipher
+
+The RC4 encryption cipher is considered deprecated in favor of stronger ciphers. Support for RC4 by the [discovery service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) will be removed in a future release.
+
+#### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+#### TLS 1.0 and TLS 1.1
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.
+Please verify that all clients, apps, and connections support TLS 1.2. Support for the earlier protocols will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols. Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | – | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+## Known issues
+
+- RS114185 - During an upgrade to [Redis Enterprise Software version 7.2.4-86]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-92" >}}), the proxy might not start due to a `Failed to get default_suffix` error, which appears in `dmcproxy.log`.
+
+    As a workaround, start `dmcproxy` manually:
+
+    ```sh
+    supervisorctl restart dmcproxy
+    ```
+
+    This issue was fixed in [Redis Enterprise Software version 7.2.4-92]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-92" >}}).
+
+
+- RS123142 - In an Active-Active setup with at least three participating clusters, removing and re-adding a cluster after removing older clusters without re-adding them can cause missing keys and potentially lead to data loss or data inconsistency.
+
+    This issue will be fixed in a future maintenance release. To prevent this issue, avoid adding clusters until you upgrade to the upcoming maintenance release when available.
+
+## Known limitations
+
+#### Command limitations
+
+- [`CLIENT NO-TOUCH`]({{< relref "/commands/client-no-touch" >}}) might not run correctly in the following cases:
+
+    - The Redis database version is earlier than 7.2.0.
+
+    - The `CLIENT NO-TOUCH` command is forbidden by ACL rules.
+
+    Before sending this command, clients should verify the database version is 7.2.0 or later and that using this command is allowed. 
+
+- You cannot use [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}) to unsubscribe from a shard channel if the regex changed while subscribed.
+
+- Using [`XREADGROUP BLOCK`]({{< relref "/commands/xreadgroup" >}}) with `>` to return all new streams will cause the Redis database to freeze until the shard is restarted. ([#12031](https://github.com/redis/redis/pull/12301))
+
+- Because a rejected command does not record the duration for command stats, an error will appear after it is reprocessed that will cause the Redis database to freeze until the shard is restarted. ([#12247](https://github.com/redis/redis/pull/12247))
+
+#### Modules cannot load in Oracle Linux 7 & 8
+
+Databases hosted on Oracle Linux 7 & 8 cannot load modules.
+
+As a temporary workaround, you can change the node's `os_name` in the Cluster Configuration Store (CCS):
+
+```sh
+ccs-cli hset node:<ID> os_name rhel
+```
+
+This limitation was fixed in [Redis Enterprise Software version 7.2.4-64]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-64" >}}).
+
+#### Cluster recovery with manually uploaded modules
+
+For clusters containing databases with manually uploaded modules, [cluster recovery]({{< relref "/operate/rs/clusters/cluster-recovery" >}}) requires an extra step.
+
+After installing Redis Enterprise Software on the cluster nodes, upload compatible modules to `modulesdir` (`/opt/redislabs/lib/modules`) before continuing the recovery process.
+
+This limitation was fixed in [Redis Enterprise Software version 7.2.4-64]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-64" >}}).
+
+#### Cannot create Redis v6.x Active-Active databases with modules
+
+You cannot create Active-Active databases that use Redis version 6.0 or 6.2 with modules. Databases that use Redis version 7.2 do not have this limitation.
+
+This limitation will be fixed in a maintenance release for Redis Enterprise version 7.4.2.
+
+#### Modules prevent nodes from joining upgraded clusters on RHEL clones
+
+If you upgrade an existing cluster to Redis Enterprise Software version 7.2.4 and any existing databases use earlier module versions, new nodes will fail to join the cluster on operating systems that are RHEL clones. RHEL, Ubuntu, and Amazon Linux are not affected by this issue.
+
+For a workaround for affected operating systems, [contact support](https://redis.io/support/).
+
+This limitation will be fixed in a future release.
+---
+Title: Redis Enterprise Software release notes 7.2.4-72 (October 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: New Cluster Manager UI enhancements - database upgrade configuration,
+  database defaults, user lockout parameters, and TLS configuration improvements.
+linkTitle: 7.2.4-72 (October 2023)
+weight: 70
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.2.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- New Cluster Manager UI enhancements
+
+## New in this release
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - [Database upgrade configuration]({{< relref "/operate/rs/databases/configure/db-upgrade" >}}) - cluster-wide policies that affect default database upgrades
+
+    - [Database defaults]({{< relref "/operate/rs/databases/configure/db-defaults" >}}) - cluster-wide policies that determine default settings when creating new databases
+
+    - [User lockout parameters]({{< relref "/operate/rs/security/access-control/manage-users/login-lockout" >}}) - locks user accounts after excessive failed login attempts
+
+    - [TLS configuration]({{< relref "/operate/rs/security/encryption/tls/enable-tls" >}}) improvements
+
+#### Redis modules
+
+Redis Enterprise Software version 7.2.4-72 includes the following Redis Stack modules (no changes since [Redis Enterprise Software version 7.2.4-52]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}}):
+
+- [RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)
+
+- [RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)
+
+- [RedisTimeSeries 1.10.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.4)
+
+- [RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)
+
+- [RedisGears 2.0.11](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.11-m12)
+
+### Resolved issues
+
+- RS107463 - Fixed "user with that email already exists" error for API requests that create a user with `email` set to an empty string.
+
+- RS109810 - Added missing information for `sys_info` files in 7.2.4 cluster support packages.
+
+- RS108515 - Added missing license fields to support packages.
+
+- RS102497 - Removed ICMP communication from installation, upgrade, and `rladmin status`.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Release date** | Aug<br />2023 | Feb<br />2023 | Sept<br />2022 | Aug<br />2022 | Feb<br />2022 | Oct<br />2021 | Aug<br />2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | – | Feb<br />2025 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 |
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | – | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.2.4-72 October release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 8a26e0983daa266d39e1f45248f5be3b |
+| Ubuntu 20 | dccab4ee04daffa2354e1faa3fbd14d2 |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | 79ded85fd19cb675b363ed7be3543082 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 0b5681f346761e4ff38efc266608857f |
+| Amazon Linux 2 | b5cc186da8b84329e9838339a8736397 |
+
+## Known issues
+
+- RS110481 - Importing a database mid-upgrade fails when the master node has the new version.
+    
+    As a workaround, either finish the upgrade before retrying the import, or move the master node to an old node, then perform the upgrade.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.2.4-64 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software Release Notes 6.0.12 (January 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.0.6
+description: Distribute synchronization across nodes for Active-Active and Active-Passive
+  databases. Disable internal services to free memory. User accounts support password
+  rotation. Module depdencies automatically installed. Syncer process recovery.
+linkTitle: 6.0.12 (January 2021)
+weight: 78
+---
+[Redis Enterprise Software (RS) 6.0.12](https://redislabs.com/download-center/#downloads) is now available!
+This version includes the following new features and improvements:
+
+- [Synchronization]({{< relref "/operate/rs/databases/active-active" >}}#syncer-process) can now be [distributed across the nodes]({{< relref "/operate/rs/databases/active-active/synchronization-mode.md" >}}) of Active-Active or Active-Passive databases
+- You can [disable several internal RS services]({{< relref "/operate/rs/clusters/optimize/turn-off-services.md" >}}) to free up more memory
+- User accounts can have multiple passwords to allow for [password rotation]({{< relref "/operate/rs/security/access-control/manage-passwords/rotate-passwords" >}})
+- [Dependencies are automatically installed]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster#rest-api-method" >}}) when you add modules to a cluster
+- [Envoy replaces NGINX]({{< relref "/operate/rs/networking/port-configurations.md" >}}) for internal cluster administration
+- Automatic recovery of the [syncer process]({{< relref "/operate/rs/databases/active-active" >}}#syncer-process)s from out-of-memory (preview mode)
+
+And other functional and stability improvements.
+
+## Version information
+
+### Upgrade instructions
+
+- Follow [these instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 6.0.12 from RS 5.4.0 and above.
+- For Active-Active deployments, this release requires that you [upgrade the CRDB featureset version]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}).
+
+### Product lifecycle information
+
+- End of Life (EOL) for Redis Enterprise Software 6.0 and previous RS versions, can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+- EOL for Redis modules can be found [here]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle#modules-endoflife-schedule" >}}).
+
+### Deprecation Notice
+
+- Support for RS 5.4.X ended on December 31, 2020.
+- Support for Red Hat Enterprise Linux 6 and Oracle Linux 6 and Ubuntu 14.04 (Trusty) operating systems platforms ended on November 30, 2020.
+- This is the last RS version that supports direct upgrades from versions below 5.6.0.
+- This is the last RS version that supports Active-Active protocol version below 1 and featureset version below 1.
+
+## New Features
+
+#### Distributed Syncer
+
+The syncer process now supports running in a [distributed mode]({{< relref "/operate/rs/databases/active-active/synchronization-mode.md" >}}). This option can improve the latency for Active-Active databases with a very high throughput profile. You can configure a replicated database to use distributed synchronization so that any available proxy endpoint can manage synchronization traffic.
+
+#### Disabling RS services to free memory
+
+Redis Software users can now use the REST API to [disable the following services]({{< relref "/operate/rs/clusters/optimize/turn-off-services.md" >}}):
+
+- cm_server
+- mdns_server
+- pdns_server
+- stats_archiver
+- saslauthd
+- crdb_coordinator
+- crdb_worker
+
+Once disabled, services are not monitored and controlled by the supervisord.
+
+{{< warning >}}
+This feature can cause unintended results if the cluster relies on the disabled services.
+To make sure you understand the impact of disabled services, test the system in a lab environment before you deploy in production.
+{{< /warning >}}
+
+#### Support for multiple passwords
+
+For users of Redis 6 and RS 6.0 and above, you can now add more security to your password management by maintaining multiple passwords for a user to allow seamless password rotation.
+
+As of RS 6.0, you can assign specific data access permissions (Redis ACLs) and cluster administration permissions to users.
+Password rotation is especially helpful so that you can do a rolling update of the passwords in the application clients that connect to the Redis databases.
+
+In this version, you can only configure multiple passwords [using the REST API]({{< relref "/operate/rs/security/access-control/manage-passwords/rotate-passwords" >}}).
+
+#### Redis Modules dependencies management
+
+RedisGears GA and RedisAI GA require Redis Software to fetch and manage external dependencies.
+Modules declare dependencies at release time in their ramp file.
+
+In this version of RS, these dependencies are installed by Redis Software when the module is added to the cluster.
+The master node downloads the required dependencies and prompts the other nodes to copy the dependencies from the master node.
+When all dependency requirements are satisfied, the module installation is complete.
+New nodes to the cluster also automatically install the dependencies.
+
+#### Syncer automatic recovery from out-of-memory (Preview mode)
+
+For Active-Active databases, the syncer process gracefully recovers from an out of memory (OOM) state.
+
+Although Active-Active synchronization is bi-directional, in each direction we can define a source instance and a destination instance.
+When a destination instance (that is, the instance running the syncer process) gets OOM, the syncer process attempts to automatically recover the data synchronization when memory becomes available.
+
+This is a configurable option and currently under preview mode. This behavior will be GA and set as default in the next RS version.
+
+To enable the syncer automatic recovery, do these steps on each participating cluster:
+
+1. [Upgrade the featureset version]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}) to `3`.
+1. Enable the syncer automatic recovery using the REST API:
+
+    ```sh
+    curl -v -k -u <username>:<password> -X PUT -H “Content-Type: application/json” -d ‘{crdt_syncer_auto_oom_unlatch”:true}’ http://<cluster_address>:8080/v1/bdbs/<database_ID>
+    ```
+
+The syncer process restarts to with automatic recovery on.
+
+## Redis modules
+
+The following GA releases of Redis modules are bundled with RS 6.0.12:
+
+- [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version [2.0.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.0-release-notes.md" >}})
+- [RedisJSON](https://redislabs.com/redis-enterprise/redis-json/), version [1.0.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+- [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version [2.2.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph" >}})
+- [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/), version [1.4.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries" >}})
+- [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version [2.2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}})
+
+To use the updated modules with a database, you must [upgrade the module on the database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Additional capabilities
+
+- RS 6.0.12 includes open source Redis 6.0.6. For more information about Redis 6.0.6, check out the [release notes](https://raw.githubusercontent.com/redis/redis/6.0.6/00-RELEASENOTES).
+- The bundled Nginx version was updated from version 1.16.0 to 1.18.0.
+- The crdb-cli syntax to remove an instance is changed from
+`remove-instance [--ordered|--unordered]` to `remove-instance [--force|--no-force]`.
+
+## Important fixes
+
+- RS45627, RS47382 - Fixed bugs causing clients to disconnect when using XREAD and XREADGROUP commands in blocking mode on other clients’ connections.
+- RS44656 - Fixed a bug causing TLS mode for clients connections to toggle between ‘all communication’ to ‘for crdb communication only’ when performing a global configuration change.
+- RS42587 - Fixed a bug in the web UI console if the FQDN of the cluster is a substring of the FQDN of a participating cluster
+- RS49404 - Fixed a bug in for upgrades with custom directories that prevent users from creating databases via the web UI console.
+- RS43961 - bigkeys command fixed to handle non-printable key names
+- RS45707 - Fixed a bug that caused RCP (Redis Cloud Pro) databases to reject connections while resharding the database.
+- RS51144 - Fixed a bug in the syncer process that was stopping synchronization between all instances in some scenarios of network disconnection of one or more participating clusters.
+
+with 6.0.12-58:
+- RS50865 - Fixed a bug causing rladmin change master node to fail when performed after a prior successful master change.
+- RS51359 - Fixed a memory leak on replica shards in Active-Active databases with replication and AOF for persistence.
+- RS52363 - Updated PUB/SUB max message value size from 64KB to 512MB 
+
+## Known limitations
+
+-RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+#### Upgrade
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis Database capabilities that improve its compatibility with open source Redis. Now the string data-type in Active-Active Redis Database is implicitly and dynamically typed, just like open source Redis. To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower, you must [upgrade the Active-Active Redis Database protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- When you upgrade an Active-Active Redis with active AOF from version [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) or earlier to version [RS 5.4.4]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-4-june-2019.md" >}}) or later:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}). For assistance with this issue, contact Support.
+- Starting from [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}), to preserve the current Redis major.minor version during database upgrade you must use the keep_redis_version option instead of keep_current_version.
+
+#### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis modules.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and above
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE commands for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 6.2.8 (October 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.3
+description: RHEL 8 support. Set backup start time.
+linkTitle: 6.2.8 (October 2021)
+weight: 75
+---
+
+[Redis Enterprise Software version 6.2.8](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+## Features and enhancements
+
+This version features:
+
+- Support for Red Hat Linux Edition (RHEL) 8
+- You can now set the start time for [12- and 24-hour backups]({{< relref "/operate/rs/databases/import-export/schedule-backups.md" >}}) 
+- Compatibility with version of [open source Redis 6.2.3](https://github.com/redis/redis/releases/tag/6.2.3) (starting with [Redis Enterprise Software v6.2.4]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021.md" >}}))
+- Compatibility with the security fixes of the latest [open source Redis 6.2.6](https://github.com/redis/redis/releases/tag/6.2.6)
+- Enhancements and bug fixes
+
+## Version changes
+
+### Prerequisites and notes
+
+- You can [upgrade to v6.2.8]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) from Redis Enterprise Software v6.0 and later. 
+
+- Refer to the [v6.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021.md" >}}) for important notes regarding the upgrade process.
+
+- When upgrading a cluster from Redis Enterprise 6.0.8 and earlier to 6.2.8 only, the DMC proxy might crash when proxy certificates contain additional text as comments.  Redis removes these comments during upgrade, but a change to the v6.2.8 internal upgrade action sequence might cause this problem. 
+
+
+    If you plan to upgrade from a pre-6.0.8 release to 6.2.8, check whether your proxy certificate includes additional comments and manually remove them.  The change was reverted in 6.2.10.
+
+- Upgrades from versions earlier than v6.0 are not supported.
+
+### Product lifecycle updates
+
+As of 31 October 2021, Redis Enterprise Software v5.6.0 is end of life (EOF).
+
+To learn more, see the Redis Enterprise Software [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}), which details the release number and the end-of-life schedule for Redis Enterprise Software.
+
+Redis Enterprise modules have individual release numbers [and lifecycles]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle.md" >}}).
+
+### Redis modules
+
+Redis Enterprise Software v6.2.8 includes the following Redis modules:
+
+- [RediSearch v2.0.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.0-release-notes.md" >}})
+- [RedisJSON v1.0.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+- [RedisBloom v2.2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}}) 
+- [RedisGraph v2.4.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.4-release-notes.md" >}})
+- [RedisTimeSeries v1.4.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.4-release-notes.md" >}})
+
+To learn more, see [Upgrade the module for a database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Resolved issues
+
+### User interface fixes
+
+- RS58804 - Display an error message in case of a login attempt with an LDAP user
+- RS56680 - Notify that SASLAUTHD should be disabled prior to enabling LDAP 
+- RS55844 - Use the correct password and mask it on LDAP password update
+- RS60877 - Fixed reset of Active-Active database compression level, in cases where the compression level wasn’t set to default, when changing any other configuration via the DB configuration page
+- RS43999 - Fixed UI database configuration to allow changes when SFTP SSH key is customized
+- RS59861 - Fixed the UI to display an explanation error message when password complexity does not meet requirements
+- RS57734 - Fixed inaccessible UI after cluster upgrade due to missing certificate
+- RS43041 - Mask secret keys for backup destination for view and edit in the UI
+
+### Additional fixes
+
+- RS60068 / RS59146 - Fixed unresolved endpoint due to PDNS issues
+- RS52812 - Expand API wrapper to return API 405 errors as JSON/XML
+- RS57666 - Fixed false shard migration message when the shard fails to bind the port
+- RS57444, RS55294, RS4903 - Fixed false “backup finished successfully” message when the backup failed due to restricted access to the backup destination
+
+### Fixes on build #53
+- RS67829 - Fixed a bug that caused Modules' auxiliary field not to get replicated between the primary and the replica shards. Applicable for RediSearch, RedisGraph and RedisGears and happening only at following scenarios:
+         - (A) On the destination databases of a Replica Of upon a full sync operation
+         - (B) Upon import operation
+
+## Known limitations
+
+-RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+- RS63258 - Redis Enterprise Software 6.2.8 is not supported on RHEL 8 with FIPS enabled.
+
+    FIPS changes system-generated keys, which can limit secure access to the cluster or the admin console via port 8443.
+
+- RS63375 - RHEL 7 clusters cannot be directly upgraded to RHEL 8 when hosting databases using modules.
+
+    Due to binary differences in modules between the two operating systems, you cannot directly update RHEL 7 clusters to RHEL 8 when those clusters host databases using modules.  Instead, you need to create a new cluster on RHEL 8 and then migrate existing data from your RHEL 7 cluster. This does not apply to clusters that do not use modules.
+
+All [known limitations]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021.md#known-limitations" >}}) from v6.2.4 have been fixed. 
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Known issues 
+
+- A new command was added as part of Redis 6.2: [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}). When used in an Active-Active configuration, this command may cause Redis shards to crash, potentially resulting in data loss. The issue is fixed in Redis Enterprise Software version 6.2.12. Additionally, we recommend enabling AOF persistence for all Active-Active configurations.
+
+- The `ZRANGESTORE` command, with a special `zset-max-ziplist-entries` configuration can crash Redis 6.2. See [Redis repository 10767](https://github.com/redis/redis/pull/10767) for more details.
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+## Security
+
+### Open source Redis security fix compatibility
+
+As part of its commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with open source Redis.
+
+The following [open source Redis](https://github.com/redis/redis) [CVEs](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+- [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement `LCS`. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+- [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+Some CVEs announced for Open Source Redis do not affect Redis Enterprise due to functionality that is either different from (or not available in) open source Redis.
+---
+Title: Redis Enterprise Software Release Notes 6.0 (May 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6
+description: ACL and RBAC improvements for database access.  Active-Active databases
+  support Redis Streams.
+linkTitle: 6.0 (May 2020)
+weight: 80
+---
+[Redis Enterprise Software (RS) 6.0](https://redislabs.com/download-center/#downloads) is now available!
+This new version bundles open-source Redis 6, implements enhanced Access Control List (ACL) capabilities using Role-Based Access Control (RBAC) for database access, and adds the support of Redis Streams on Active-Active databases.
+
+## Version information
+
+### Upgrade instructions
+
+Follow [these instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 6.0 from RS 5.4.0 and above.
+For Active-Active deployments, this release requires that you [upgrade the CRDB featureset version]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}).
+
+### End of life
+
+End of Life (EOL) for Redis Enterprise Software 6.0 and previous RS versions, can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+EOL for Redis Modules can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+
+- Support for Red Hat Enterprise Linux 6 and Oracle Linux 6 [operating systems platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}) will end on November 30, 2020.
+- Support for Ubuntu 14.04 (Trusty Tahr) [operating systems platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}) will end on November 30, 2020.
+
+## New features
+
+### Open source Redis 6
+
+RS 6.0 bundles latest open source Redis 6.
+For more information, check out the [Diving into Redis 6](https://redislabs.com/blog/diving-into-redis-6/) article.
+
+### Access control list (ACL)
+
+Based on OSS Redis 6, RS 6.0 offers the ability to manage and control connections to your databases using users and their data access permissions in terms of commands they can execute and keys they can access.
+
+In OSS Redis, the ACLs are managed separately per user for each database. In Redis Enterprise Software, Redis ACLs are managed for the databases at the cluster.
+For more information, check out the [Redis Enterprise Software user management documentation]({{< relref "/operate/rs/security/access-control/create-db-roles" >}}).
+
+### Role-based access control (RBAC)
+
+RS 6.0 leverages Redis ACLs to implement role-based access control that easily scale and manage data access permissions. Using roles minimizes the overhead involved in managing a cluster with many databases, multiple users, and various access control lists.
+For more information, check out the [Redis Enterprise Software user management documentation]({{< relref "/operate/rs/security/access-control" >}}).
+
+### Active-Active support for Redis Streams
+
+RS 6.0 adds support for Redis streams on Active-Active geo-distributed databases using conflict-free replicated data type (CRDT). You can now use all Redis streams commands including consumer groups on Active-Active databases. To enable it, [upgrade your Active-Active database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}) featureset version to the latest (featureset version = 2) as part of the upgrade process.
+For more information, check out [Redis Streams on Active Active databases]({{< relref "/operate/rs/databases/active-active/develop/data-types/strings.md" >}}).
+
+## Redis modules
+
+The following GA releases of Redis Modules are bundled in RS 6.0:
+
+- [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version [2.2.2]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}}) (updated)
+- [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version [2.0.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md" >}}) (updated)
+- [RedisJson](https://redislabs.com/redis-enterprise/redis-json/), version [1.0.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+- [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version [1.6.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-1.6-release-notes.md" >}}) (updated)
+- [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/), version [1.2.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.2-release-notes.md" >}}) (updated)
+
+To use the updated modules with a database, you must [upgrade the module on the database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Additional capabilities
+
+- Added the ability to configure a storage service that uses the S3 protocol. Configuration for [backup location]({{< relref "/operate/rs/databases/import-export/schedule-backups.md" >}}) and for [import]({{< relref "/operate/rs/databases/import-export/import-data.md" >}}) and [export]({{< relref "/operate/rs/databases/import-export/export-data.md" >}}) locations of [RDB files]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}) is possible. The storage service must have a valid SSL certificate. To connect to an S3-compatible storage location, run: `rladmin cluster config s3_url <url>`
+
+- The crdb-cli tool was updated so it is now displaying the Active-Active database’s featureset version and the protocol version per instance. For example:
+
+    ```sh
+    $ crdb-cli crdb list --verbose
+    CRDB-GUID               NAME                REPL-ID	PROTOCOL    FEATURESET    DB-ID     CLUSTER-FQDN
+    969122be-...	loremipsum1           1	      0 	   	 0	    bdb:1       cluster1.local
+    969122be-...	loremipsum1           2	      0 	   	 0	    bdb:1       cluster2.local
+    ```
+
+- Added REST API and rladmin commands to modify the timeout for [automatically disconnecting an inactive admin console session]({{< relref "/operate/rs/security/access-control/manage-users/login-lockout#session-timeout" >}}).
+    - Using the rladmin run: `rladmin cluster config cm_session_timeout_minutes <int_value>`
+    - Using the REST API:
+
+        ```sh
+        curl --request PUT \
+        --url https://localhost:9443/v1/cluster \
+        --header 'content-type: application/json' \
+        --data '{
+            "cm_session_timeout_minutes": 10
+        }'
+        ```
+
+- Added `no_of_expires` metrics for database metrics and for shard metrics. You can access this metric from the REST API:
+    - `no_of_expires` shows the current number of volatile keys in the database.
+    - `expired_objects` shows the rate of keys expired in DB (expirations/sec).
+
+- Added the ability to customize the welcome message on the login page in the admin console console.
+
+## Important fixes
+
+- RS39121, RS35335 - Optimized the XREAD and XREADGROUP commands so when using them in a non blocking fashion (without BLOCK keyword) they use the shared connection instead of a dedicated connection.
+- RS26448 - Fixed ‘ram overhead’ metric calculation for ROF databases using AOF.
+- RS31190 - Fixed a bug that causes databases with OSS Cluster API enabled to override the ‘preferred IP type’ attribute from ‘external’ to ‘internal’ (the default value).
+- RS34009 - Updated the modules loading procedure for clusters with FIPS compliance enabled.
+- RS38233 - Improved the Redis cleanup job handling the persistent directory
+- RS39228 - Fixed a bug in the WAIT command that in some cases was  released after a longer period than requested.
+- RS39749 - Fixed a bug that blocked eviction while LUA scripts were in progress.
+- RS43996 - Fixed a bug when aborting an upgrade to RS 6.0.
+
+## Known limitations
+
+-RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+### Active-Active databases
+- RS51359 - Active-Active databases, using replication and Append Only File (AOF) for [database persistence]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}), are suffering from memory leaks on replica shards, causing them to grow bigger than the master shards. Customers are advised to upgrade to RS 6.0.12 ***TBD***. Meanwhile you can use snapshots for database persistence or restart the replica shards ***TBD***.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+### Upgrade
+
+- RS 5.4.2 introduced new Active-Active Redis Database capabilities that improve its compatibility with open source Redis. Now the string data-type in Active-Active Redis Database is implicitly and dynamically typed, just like open source Redis. To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower, you must upgrade the Active-Active Redis Database protocol.
+- When you upgrade an Active-Active Redis with active AOF from version RS 5.4.2 or lower to version RS 5.4.4 or higher:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+- Starting from RS 5.4.2, to preserve the current Redis major.minor version during database upgrade you must use the keep_redis_version option instead of keep_current_version.
+- Dynatrace agent installed on the cluster nodes can hamper the working on Envoy process leading to failure of UI and REST API. Prior upgrading we recommend removing Dynatrace completely or try upgrading to newer versions. 
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- Starting from RS 5.4.2 and after you upgrade an Active-Active database, TYPE commands for string data-type in Active-Active databases return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 6.0.8 (September 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.0.5
+description: RediSearch 2.0 support. Improved rladmin support for module upgrades.
+linkTitle: 6.0.8 (September 2020)
+weight: 79
+---
+[Redis Enterprise Software (RS) 6.0.8](https://redislabs.com/download-center/#downloads) is now available!
+This version includes the new RediSearch 2.0 module, open source Redis 6.0.5, changes the rladmin tool for upgrading modules, and includes bug fixes.
+
+## Version information
+
+### Upgrade instructions
+
+Follow [these instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 6.0.8 from RS 5.4.0 and above.
+For Active-Active deployments, this release requires that you [upgrade the CRDB featureset version]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}).
+
+### End of life
+
+End of Life (EOL) for Redis Enterprise Software 6.0 and previous RS versions, can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+EOL for Redis Modules can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+
+- Support for Red Hat Enterprise Linux 6 and Oracle Linux 6 [operating systems platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}) will end on November 30, 2020.
+- Support for Ubuntu 14.04 (Trusty Tahr) [operating systems platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}) will end on November 30, 2020.
+
+## New features
+
+### Open source Redis 6
+
+RS 6.0 includes open source Redis 6.0.5.
+For more information about Redis 6.0.5, check out the [release notes](https://raw.githubusercontent.com/redis/redis/6.0.5/00-RELEASENOTES).
+
+### Upgrading Redis modules via rladmin
+
+The [`rladmin` CLI]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) introduces several updates to the commands for upgrading modules.
+It is now easier to upgrade your modules to the latest module version.
+Find out more [here]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Redis modules
+
+The following GA releases of Redis Modules are bundled in RS 6.0:
+
+- [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version [2.0]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch" >}}) (updated)
+- [RedisJSON](https://redislabs.com/redis-enterprise/redis-json/), version [1.0.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+- [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version [2.0.19]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.0-release-notes.md" >}}) (updated)
+- [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/), version [1.2.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.2-release-notes.md" >}}) (updated)
+- [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version [2.2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}}) (updated)
+
+To use the updated modules with a database, you must [upgrade the module on the database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+## Additional capabilities
+
+- [Shard level metrics]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions#shard-metrics" >}}) have been added to the metrics_exporter and are now available from Prometheus. You can find all of the metrics [here]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}}).
+
+- RS DEB packages (for Ubuntu) and RPM packages (for RHEL) are now signed with a GPG key so customers can verify that the package is authentic and has not been tampered with. You can access the GPG on the [installaion page]({{< relref "/operate/rs/installing-upgrading#installing-rs-on-linux" >}}).
+
+- The [`crdb-cli`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) history log is now being added to support packages.
+
+## Important fixes
+
+- RS33193 - Improved log files handling in the proxy for large files.
+- RS43572 - Fixed a bug causing the UI to fail when enabling SMTP STARTLS.
+- RS46062 - Fixed missing metrics of Active-Active databases in Grafana.
+- RS44758 - Fixed non responding button for saving a new user via the UI.
+With build 6.0.8-32:
+- RS45627, RS47382 - Fixed bugs causing clients to disconnect when using XREAD and XREADGROUP commands in blocking mode on other clients’ connections.
+
+## Known limitations
+
+-RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+### Active-Active databases
+- RS44656 - A bug causing TLS mode for clients connections to toggle between ‘all communication’ to ‘for crdb communication only’ when performing a global configuration change. ***TBD***
+- RS51359 - Active-Active databases, using replication and Append Only File (AOF) for [Database persistence]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}), are suffering from memory leaks on replica shards, causing them to grow bigger than the master shards. Customers are advised to upgrade to RS 6.0.12 ***TBD***. Meanwhile you can use snapshots for database persistence or restart the replica shards ***TBD***.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+### Upgrade
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis Database capabilities that improve its compatibility with open source Redis. Now the string data-type in Active-Active Redis Database is implicitly and dynamically typed, just like open source Redis. To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower, you must [upgrade the Active-Active Redis Database protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- When you upgrade an Active-Active Redis with active AOF from version [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) or lower to version [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-4-june-2019.md" >}}) or higher:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For assistance with this issue, contact [Support](https://redislabs.com/support).
+- Starting from [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}), to preserve the current Redis major.minor version during database upgrade you must use the keep_redis_version option instead of keep_current_version.
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- Starting from RS 5.4.2 and after you upgrade an Active-Active database, TYPE commands for string data-type in Active-Active databases return "string" (OSS Redis standard).
+---
+Title: RLEC 4.4 Release Notes (December 2016)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 4.4 (December 2016)
+weight: 95
+---
+If you are upgrading from a previous version, make sure to review the
+[upgrade
+instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+before beginning the upgrade process.
+
+You can upgrade to this version from any 4.3 version. If you have a
+version older than 4.3 you must first upgrade to 4.3 and only then
+upgrade to this version.
+
+## New features
+
+- Databases can now be configured to have multiple proxies for
+    improved performance. Note that when you upgrade the cluster to this
+    version and then upgrade existing databases, the databases will be
+    updated to use the Single proxy policy and Dense shard placement
+    policy. For additional details, refer to [Multiple active
+    proxies]({{< relref "/operate/rs/databases/configure/proxy-policy.md" >}}).
+- Support for Redis version 3.2 added. When you install or upgrade the
+    cluster the new default version for Redis databases will be 3.2 and
+    when you upgrade the databases they will be updated to this version.
+    If you would like to change the default version to Redis 3.0, refer
+    to the instruction in the [Upgrading
+    databases]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+    If you would like to upgrade existing databases to the latest 3.0
+    minor version, refer to the Known Issues section below.
+- The cluster can now be configured to support both private and public
+    IPs to connect to database endpoints through both public and private
+    networks. For additional details, refer to [Private and Public
+    Endpoints]({{< relref "/operate/rs/networking/private-public-endpoints.md" >}}).
+- **rladmin status** command output has been enhanced to include an
+    indication on which node rladmin is running by adding the '\*' sign
+    next to the node entry, and to show the host name of the machine the
+    node is running on.
+- Users can now be assigned security roles to control what level of
+    the databases or cluster the users can view and/or edit.
+
+## Changes
+
+- As result of adding the support for multiple proxies for a database,
+    the following changes have been made:
+    - When you upgrade the cluster to this version and then upgrade
+          existing databases, the databases will be updated to use the
+          Single proxy policy and Dense shard placement policy.
+    - **rladmin status** command output has been updated.
+    - **failover \[db \<db:id \| name\>\] endpoint \<id1 .. idN\>**
+          and **migrate \[db \<db:id \| name\> \| node \<origin
+          node:id\>\] endpoint \<id\> target_node \<id\>** commands are
+          no longer relevant for databases using the **single \|
+          all-master-shards \| all-nodes** proxy policy. Instead proxies
+          can be bound or unbounded to databases as needed.
+    - New **rladmin** commands were added, such as **bind** and
+          **placement**.
+- RLEC has been updated to remove the need to use **sudo** in runtime.
+    You still need to be root or use **sudo** when initially installing
+    RLEC.
+- You no longer need to be root or use **sudo** to run the rladmin
+    command, now it is preferred to be a non-privileged user that is
+    member of the *redislabs* group to run the command.
+- All cluster services are now run using the supervisor mechanism. As
+    a result starting, stopping and restarting RLEC services should be
+    done using **supervisorctl** command from the OS CLI.
+- Linux OS vm.swappiness is now advised to be set to zero, for more
+    information see [Disabling Swap in
+    Linux]({{< relref "/operate/rs/installing-upgrading/configuring/linux-swap.md" >}}).
+
+## Important fixed issues since 4.3.0
+
+- RLEC-7542 - Add ability to create and manage role based user
+    security
+- RLEC-8283 - The cluster recovery process does not work properly
+    when the cluster that needs to be recovered does not have a node
+    with ID 1.
+- RLEC-8284 - Add functionality to rladmin to mark a node as a quorum
+    only node
+- RLEC-8498 - Backup fails under rare conditions
+- RLEC-8579 - rladmin supports uppercase for external_addr value
+- RLEC-8656 - Fixed conflict with SELinux
+- RLEC-8687 - Fixed issue where strong password requirements were not
+    honored correctly.
+- RLEC-8694 - DMC failed while creating DB with 75 (150 replicated)
+    shards
+- RLEC-8700 - Fixed issue with network split scenario
+- RLEC-8833 - Fixed issue where in some cases endpoint were not
+    getting new IPs after node replacement.
+- RLEC-9069 - Fixed issue related to RHEL 7 and IPv6.
+- RLEC-9156 - Fixed issue causing a full resync of data when a source
+    or destination failure occurred.
+- RLEC-9173 - Issue with writing data after master and replica failed
+- RLEC-9235 - Issue with SSL connection error and self signed
+    certificates
+- RLEC-9491 - Fixed alerting issue due to incorrect measurement
+- RLEC-9534 - Fixed issue with node remove command after RLEC
+    uninstalled
+- RLEC-9658 - Failed to import backup file from FTP server.
+- RLEC-9737 - Fixed issue with backup process to use ephemeral
+    storage when needed
+- RLEC-9761 - UI had incorrect value increments
+- RLEC-9827 - Server with a high number of cores and running RHEL can
+    have issues running systune.sh
+- RLEC-9853 - Fixed issues with logrotate on RHEL 7.1 so it runs as
+    non-privileged user
+- RLEC-9858 - If proxy crashed, in some cases this would prevent
+    completion of redis failover process
+- RLEC-9893 - DB recovery process doesn't recognize original rack
+    name when in uppercase
+- RLEC-9905 - x.509 certificate signed by custom CA cannot be loaded
+    in UI
+- RLEC-9925 - master endpoint and shards goes down if co-hosted with
+    master of the cluster and the node goes down (single proxy policy)
+- RLEC-9926 - Master shard could remain down if on the same node as
+    the master of the cluster and the entire node goes down
+- RLEC-10340 - Fixed a typo that crashed rladmin status output in
+    some cases
+
+Changes in 4.4.2-42:
+
+- RLEC-11941 - Upgrade to 4.4.2-35 on RHEL6 - leash failed when
+    python2.6 is installed
+- RLEC-11994 - RLEC 4.4.2-35: the UI doesn't display the DBs with
+    replication
+
+Changes in 4.4.2 - 49
+
+- RLEC-11209 - Unable to run upgrade due to running_actions check
+- RLEC-12647 - Backup to S3 with periods in bucket name are failing
+    in some cases
+
+## Known issues
+
+- **Issue:** When upgrading to this version from a previous RLEC
+    version, **rladmin status** output will show the database status as
+    having an old version. When you upgrade the Redis database (using
+    **rladmin upgrade db** command) the Redis version will be updated to
+    3.2 even if you updated the cluster's Redis default version to 3.0.
+    **Workaround:** If you would like to cancel the old version
+    indication in **rladmin status** without upgrading the Redis version
+    to 3.2 you should run the **rladmin upgrade db** command with the
+    **keep_current_version** flag which will ensure the database is
+    upgraded to the latest 3.0 version supported by RLEC.
+- **Issue:** RLEC-9200 - in a database configured with multiple
+    proxies, if a client sends the MONITOR, CLIENT LIST or CLIENT KILL
+    commands, only commands from clients connected from the same proxy
+    are returned instead of all commands from all connections.
+    **Workaround:** If you would like to get a result across all
+    clients, you need to send the monitor command to all proxies and
+    aggregate them.
+- **Issue:** RLEC-9296 - Different actions in the cluster, like node
+    failure or taking a node offline, might cause the Proxy policy to
+    change Manual.
+    **Workaround:** You can use the **rladmin bind \[db \<db:id \|
+    name\>\] endpoint \<id\> policy \<single \| all-master-shards \|
+    all-nodes\>** command to set the policy back to the required policy,
+    which will ensure all needed proxies are bounded. Note that existing
+    client connections might disconnected as result of this process.
+- **Issue:** RLEC-8787 - In some cases when using the replica-of
+    feature, if the source database(s) are larget than the target
+    database, the memory limit on the target database is not enforced
+    and that used memory of the target database can go over the memory
+    limit set.
+    **Workaround:** You should make sure that the total memory limit of all
+    source databases is not bigger than the memory limit of the target
+    database.
+- **Issue:** RLEC-8487 - Some Redis processes stay running after
+    purging RLEC from the machine and causes an attempt to reinstall
+    RLEC to fail.
+    **Workaround:** Run the purge process for a second time and ensure
+    that the Redis processes were removed.
+- **Issue:** RLEC-8747 - When upgrading to this version, if the UI is
+    open in the browser the UI might not work properly after the
+    upgrade.
+    **Workaround:** Refresh the browser and the UI will return to work
+    properly.
+- **Issue:** In the Replica Of process, if the target database does
+    not have replication enabled and it is restarted or fails for any
+    reason, the data on the target database might not be in sync with
+    the source database, although the status of the Replica Of process
+    indicates that it is.
+    **Workaround:** You must manually stop and restart the
+    synchronization process in order to ensure the databases are in
+    sync.
+- **Issue:** In the Replica Of process, if the source database is
+    resharded while the Replica Of process is active, the
+    synchronization process will fail.
+    **Workaround:** You must manually stop and restart the
+    synchronization process after the resharding of the source database
+    is done.
+- **Issue:** In the Replica Of process, if there is very high
+    traffic on the database the Replica Of process might be restarted
+    frequently due to the "replica buffer" being exceeded. In this case,
+    you will often see the status of the Replica Of process display as
+    "Syncing".
+    **Workaround:** You must manually increase the "replica buffer" size
+    through rladmin. To find the appropriate buffer size please contact
+    support at: <support@redislabs.com>.
+- **Issue:** In a cluster that is configured to support rack-zone
+    awareness, if the user forces migration of a master or replica shard
+    through rladmin to a node on the same rack-zone as its corresponding
+    master or replica shard, and later runs the rebalance process, the
+    rebalance process will not migrate the shards to ensure rack-zone
+    awareness compliance.
+    **Workaround:** In the scenario described above, you must use
+    rladmin to manually migrate the shard to a node on a valid rack-zone
+    in order to ensure rack-zone awareness compliance.
+- **Issue:** DNS doesn't change after having removed the external IP
+    address.
+    **Workaround:** Unbind IP from affected node and then bind it back.
+- **Issue**: CCS gets an error and won't start
+    if /var/opt/redislabs/persist/ does not exist.
+    **Workaround**: Make sure this directory is not deleted and
+    continues to exist.
+---
+Title: Redis Enterprise Pack 5.0 Release Notes (November 2017)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.0 (November 2017)
+weight: 93
+---
+Redis Enterprise Software 5.0 is now available. Key features include
+Geo-Distributed Active-Active Conflict-free Replicated Databases (CRDB),
+LDAP integration, Redis Module integration, and support for the Redis
+Cluster API.
+
+## Overview
+
+If you are upgrading from a previous version, make sure to review the
+upgrade instructions before beginning the upgrade process.
+
+You can upgrade to RS 5.0 from RS 4.4.2 and above. If you have a version
+older than this, you must first upgrade to at least 4.4.2.
+
+## New features
+
+### Support for Redis Cluster API
+
+The Redis Cluster API support in Redis Enterprise Software (RS) provides
+a simple mechanism for Cluster enabled Redis clients to learn and know
+the cluster topology. This enables clients to connect directly to an RS
+proxy on the node hosting the master shard for the data being operated
+on. The result is that for all but the initial call to get the cluster
+topology or reacquire the location of the master shard, the client will
+connect to the RS endpoint proxy where the master shard is located.
+[Learn more about the Cluster API
+implementation]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api.md" >}}).
+
+### Geo-distributed Active-Active conflict-free replicated databases (CRDB) {#geodistributed-activeactive-conflictfree-replicated-databases-crdb}
+
+Developing globally distributed applications can be challenging, as
+developers have to think about race conditions and complex combinations
+of events under geo-failovers and cross-region write conflicts. CRDBs
+simplify developing such applications by directly using built-in smarts
+for handling conflicting writes based on the data type in use. Instead
+of depending on just simplistic "last-writer-wins" type conflict
+resolution, geo-distributed CRDBs combines techniques defined in CRDT
+(conflict-free replicated data types) research with Redis types to
+provide smart and automatic conflict resolution based on the data type's
+intent.
+
+For more information, go here. For information, go to [Developing with
+CRDBs]({{< relref "/operate/rs/databases/active-active" >}}develop/develop-for-aa/).
+
+### Redis modules
+
+Redis Modules enable you to extend the functionality of Redis Enterprise
+Pack. One can add new data types, capabilities, etc. to tailor the
+cluster to a specific use case or need. Once installed, modules benefit
+from the high performance, scalability, and high availability that Redis
+Enterprise is known for.
+
+#### Redis modules
+
+Redis has developed and certified the following modules for use with 
+Redis Enterprise Pack:
+
+- [RediSearch]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}})
+    - This module turns RS into a supercharged distributed in-memory
+      full-text indexing and search beast.
+- [ReJSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+    - Now you have the convenience JSON as a built-in data type and
+      easily able to address nested data via a path.
+- [RedisBloom]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+    - Enables RS to have a scalable bloom filter as a data type. Bloom
+      filters are probabilistic data structures that
+      quickly determine if values are in a set.
+
+#### Custom modules
+
+In addition, Redis Enterprise Pack provides the ability to load and use
+custom [Redis modules](https://redislabs.com/community/redis-modules-hub/) or of
+your own creation.
+
+## Support for Docker
+
+Deploying and running your Redis Enterprise Software cluster on Docker
+containers is supported in development systems and
+available to pull from Docker hub. With the official image, you can
+easily and quickly test several containers to build the scalable
+and highly available cluster Redis Enterprise Software is famous for.
+
+For more information, go to [quick start with Redis Enterprise on
+Docker]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}).
+
+## LDAP Integration
+
+As part of our continued emphasis on security, administrative user
+accounts in Redis Enterprise Pack can now use either built-in
+authentication or authenticate externally via LDAP with saslauthd. The
+accounts can be used for administering resources on the cluster via
+command line, Rest API, or admin console.
+
+For more information see [LDAP
+Integration]({{< relref "/operate/rs/security/access-control/ldap" >}}).
+
+## Additional capabilities
+
+Support for additional Redis commands and features:
+
+- Support for Redis version 4.0.2
+- Support added for RHEL/CentOS 6.9 and 7.4
+
+## Information
+
+- In the node bootstrap API, the structure of the JSON has changed for
+    adding an external IP during the bootstrap process.
+- End-of-Life for RHEL/CentOS 6.5 and 6.6 have been reached, so those
+    versions are no longer supported.
+- Modules are not supported in Redis Enterprise Pack 5.0 for
+    RHEL/CentOS 6.x
+
+## Important fixes
+
+### 5.0.0-31 {#5-0-031}
+
+- RP9299 - Issue with reliability of metric ingress
+- RP9680 - Redis Enterprise Pack starting before /etc/rc.local script
+    executed
+- RP12363 - In some cases, flash drives do not mount following a
+    stop/start of the node
+- RP12493 - Allow change to debug package creation location
+- RP13079 - DNS doesn't change after having removed the external IP
+    address in some cases
+- RP13933 - rladmin balance sometimes shows incorrect information
+- RP14060 - pubsub stats aren't reflected correctly by the stats
+    archiver
+- RP14939 - Add license checks to all needed entry points in the
+    cluster
+- RP15090 - Problem in log rotate script causes other logs to not
+    rotate
+- RP15104 - rlutil check fix doesn't work sometimes
+- RP15130 - Fixed permission on two logs with incorrect ownership
+- RP15160 - Allow option to change ports for API and CM in NGINX
+- RP15164 - Allow unix socket folder to be configurable at build time
+- RP15499 - rladmin command not responding on a cluster with large
+    number of shards
+- RP15853 - When trying to add a new db the 'activate' button was
+    changed to 'update' and was grayed out.
+- RP15861 - Allow unix socket folder to be configurable at install
+    time
+- RP16115 - TTL bug with Replica Of and import
+- RP16447 - DMC client connection reports incorrect number of
+    connections to monitoring applications.
+- RP16481 - In some cases, resource_mgr uses incorrect directories
+    to compute persistent and ephemeral storage
+---
+Title: Redis Enterprise Software 5.2.2 (August 2018)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.2.2 (August 2018)
+weight: 89
+---
+Redis Enterprise Software (RS) 5.2.2 is now available.
+
+RS 5.2.2 is a minor version that includes important fixes and minor enhancements to Redis Enterprise 5.2.
+
+## Overview
+
+If you are upgrading from a previous version, make sure to review the upgrade instructions before beginning the upgrade process. You can upgrade to RS 5.2.2 from RS 4.5 and above. If you have a version older than 4.5, you should first upgrade to version 5.0 (or at least 4.5).
+
+## New capabilities
+
+Support for Redis version 4.0.10
+RediSearch Enterprise, which is installed with Redis Enterprise Software by default, has been updated to a newer version (1.4.0)
+
+## Important fixes
+
+- RED-21080 – Fixed the memory limit calculation for RoF databases
+- RED-20825 – Updated the ‘RAM limit’ of RoF databases to a range between 10% and 100%
+- RED-20506 – Fixed high CPU and File Descriptors utilization by the node watchdog process (node_wd)
+- RED-20275 – Fixed wrong metrics values while importing a dataset into an RoF database
+- RED-20214 – Fixed obstacles to login to the UI when using an LDAP integration
+- RED-20162 – Fixed known limitation of being able to activate “Require SSL for All Communication” to Redis Enterprise CRDBs via Rest API without providing a certificate
+- RED-19758 – Upgraded NGINX from 1.10.3 to 1.13.12
+- RED-19415, RED-18945 – Improved support for Lettuce client with OSS Cluster enabled
+- RED-19287 – Fixed a scenario of a stuck shard migration process
+- RED-18459 – Updated the data persistence (AOF / Snapshot) of RoF databases to be handled, by default, by the replica shard/s
+- RED-20541– Improved handling of aof file when its tail is corrupted (using aof-load-corrupt-tail flag)
+- RED-21936 – Improved handling of CRDB configuration update when URL parameter was supplied at creation time
+- RED-19760 – Added the capability to control the minimum TLS version that can be used for encrypting the Discovery Service data
+
+## Known limitations
+
+- When updating the general settings of a cluster, the ‘username’ and ‘password’ fields in the email server settings cannot be left empty. In case one wants to update the general settings and prefer to leave the ‘username’ and ‘password’ fields empty, the REST API should be used.
+- An issue prevents the user from defining ‘min_data_TLS_version’ on the source cluster when working with Replica Of or CRDB.
+---
+Title: RLEC 4.3.0-230 Release Notes (August 2, 2016)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 4.3.0-230 (August 2, 2016)
+weight: 96
+---
+If you are upgrading from a previous version, make sure to review the
+[upgrade
+instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+before running through the upgrade process.
+
+You can upgrade to this version from any 4.2 version. If you have a
+version older than 4.2 you should first upgrade to 4.2 and only then
+upgrade to this version.
+
+### New features
+
+- Various improvements to internal performance and stability were
+    implemented.
+- RLEC Flash functionality added. For additional details, refer to
+    [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}})
+    and contact <support@redislabs.com> if you are interested in this
+    functionality.
+- Support for Redis version 3.0 added. When you install or upgrade the
+    cluster the new default version for Redis databases will be 3.0 and
+    when you upgrade the databases they will be updated to this version.
+    If you would like to change the default version to Redis 2.8 refer
+    to the instruction in the [Upgrading
+    databases]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+    section. If you would like to upgrade existing databases to the
+    latest 2.8 minor version, refer to the Known Issues section below.
+- Complete cluster failure recovery instructions added. For additional
+    details, refer to [Cluster
+    Recovery]({{< relref "/operate/rs/clusters/cluster-recovery.md" >}}).
+- Major improvements made to database replication performance process
+    by using diskless replication between master and replica shards. The
+    data between the master and replica shards is streamed directly,
+    instead of using the default file-on-disk mechanism. This behavior
+    can be changed for the entire cluster or per database through
+    rladmin.
+- Major enhancements made to rladmin command line interface to add new
+    administration functionalities.
+- rlcheck installation verification utility added to facilitate
+    checking node health. For additional details, refer to [rlcheck
+    installation verification
+    utility]({{< relref "/operate/rs/references/cli-utilities/rlcheck" >}}).
+- Added the ability to allow the user to configure how machine IP
+    addresses are used in Node Configuration setup in the management UI.
+    For additional details, refer to [Initial setup - creating a new
+    cluster.]({{< relref "/operate/rs/clusters/new-cluster-setup" >}})
+- Connection to database endpoint can now be encrypted with SSL. For
+    additional details, refer to [Securing client connection with
+    SSL]({{< relref "/operate/rs/security/encryption/tls" >}}).
+- Added support for running the cluster on the following operating
+    systems and versions: RHEL/CentOS 6.6, 7.1, 7.2, RHEL 6.7, Oracle
+    Linux 6.5.
+
+### Changes
+
+- Environment configuration profile with name "default" has been
+    changed to "cloud" and the default value has been changed to
+    "local-network". For additional details, refer to [Performance
+    optimization]({{< relref "/operate/rs/clusters/optimize/optimization.md" >}})
+    section.
+- In the REST API, when creating a database and not setting the
+    database replication parameter to "true", the default value assigned
+    by the cluster has changed from "true" to "false".
+- rladmin syntax updates can affect commands written for prior
+    versions of RLEC. In this version commands that are run directly
+    from the operating system CLI prompt (not through the rladmin
+    prompt) no longer require quotation marks for text with special
+    characters.
+- Option added to the *Replica-of* process that allows gradual
+    "shard-by- shard" replication of a sharded database, reducing the
+    load on internal buffers. This optimization setting can be
+    configured on the target database using the gradual_sync_mode
+    parameter in rladmin.
+- The functionality for taking a node offline was removed from the UI.
+
+### Fixed issues
+
+- RLEC-7110 - node does not recover properly after restart in case
+    ephemeral storage is not available yet
+- RLEC-7502 - log rotate job not working properly on RHEL operating
+    system
+- RLEC-7599 - issues running on a server with no IPv6 kernel support
+- RLEC-7561, RLEC-7597 - issues connecting to database endpoint as
+    result of cluster name containing capital letters
+- RLEC-7245 - on machines with multiple IPs sometimes the wrong IP
+    address is chosen for internal traffic
+- RLEC-6815 - wrong log entry is added when enabling cluster alert
+    regarding database version compatibility
+- RLEC-7652 - database is down in certain failover scenarios only
+    when the database is completely empty
+- RLEC-7737 - issue where in a specific scenario after node restarts,
+    a database with replication both master and replica shards are
+    reported as down
+- RLEC-7712 - in some cases, the Replica Of process may fail when
+    Redis password is set
+- RLEC-7726 - node object "avg_latency" statistic is not returned in
+    the REST API
+- RLEC-7358 - install script issue when running on LVM disks
+- RLEC-8086 - port 9443 missing from redislabs-clients.xml
+- RLEC-7281 - rotation of internal log files not working properly
+- RLEC-8279 - updates to a user definition might cause password reset
+    to be required
+- RLEC-8512 - when upgrading an existing cluster that has uppercase
+    letters in the cluster name (FQDN) the cluster might not function
+    properly after the upgrade and attempts to connect to a database
+    might fail
+- RLEC-8371 - email alerts do not work when using Amazon SES service
+- In certain scenarios the node upgrade process may fail if the node
+    is in the offline state
+
+### Known issues
+
+- **Issue**: When upgrading to this version from a previous RLEC
+    version, rladmin status output will show the database status as
+    having an old version. When you upgrade the Redis database (using
+    rladmin upgrade db command) the Redis version will be updated to 3.0
+    even if you updated the cluster's Redis default version to
+    2.8.
+    
+    **Workaround**: If you would like to cancel the old version
+    indication in rladmin status without upgrading the Redis version to
+    3.0 you should first change the cluster default version to 2.8
+    (using rladmin tune cluster command), and then trigger the Redis
+    process to be restarted by migrating the database shards (using
+    rladmin migrate db command).
+
+- **Issue**: RLEC-8486 - On Ubuntu, when uninstalling RLEC using the
+    apt-get purge command, some of the Redis processes on the machine
+    might continue running.
+    
+    **Workaround**: If you encounter this issue
+    you must manually kill the Redis processes.
+
+- **Issue**: RLEC-8283 - The cluster recovery process does not work
+    properly when the cluster that needs to be recovered does not have a
+    node with ID 1.
+    
+    **Workaround**: If you encounter this issue please
+    [contact Redis support](https://redislabs.com/company/support/)
+
+- **Issue**: In the Replica Of process, if the target database does
+    not have replication enabled and it is restarted or fails for any
+    reason, the data on the target database might not be in sync with
+    the source database, although the status of the Replica Of process
+    indicates that it is.
+    
+    **Workaround**: You must manually stop and
+    restart the synchronization process in order to ensure the databases
+    are in sync.
+
+- **Issue**: In the Replica Of process, if the source database is
+    resharded while the Replica Of process is active, the
+    synchronization process will fail.
+
+    **Workaround**: You must manually
+    stop and restart the synchronization process after the resharding of
+    the source database is done.
+
+- **Issue**: In the Replica Of process, high database traffic might restart the Replica Of process due to the "replica buffer" being exceeded. In this case
+    you will often see the status of the Replica Of process display as
+    "Syncing".
+    
+    **Workaround**: You must manually increase the "replica
+    buffer" size through rladmin. In order to find the appropriate
+    buffer size please [contact Redis support](https://redislabs.com/company/support/)
+
+- **Issue**: In a cluster that is configured to support rack-zone
+    awareness, if the user forces migration of a master or replica shard
+    through rladmin to a node on the same rack-zone as its corresponding
+    master or replica shard, and later runs the rebalance process, the
+    rebalance process will not migrate the shards to ensure rack-zone
+    awareness compliance.
+    
+    **Workaround**: In the scenario described
+    above, you must use rladmin to manually migrate the shard, to a node
+    on a valid rack-zone in order to ensure rack-zone awareness
+    compliance.
+---
+Title: Redis Enterprise Software 5.0.2 (2018 March)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.0.2 (2018 March)
+weight: 92
+---
+Redis Enterprise Software 5.0.2 is now available. Key features include
+functional and performance updates for CRDB, changes to module
+deployment, and general fixes.
+
+## Overview
+
+If you are upgrading from a previous version, make sure to review the
+upgrade instructions before beginning the upgrade process.
+
+You can upgrade to RS 5.0.2 from RS 4.4.2 and above. If you have a
+version older than 4.4.2, you must first upgrade to at least 5.0.
+
+{{< note >}}
+Starting from RS 5.0.2, ports 3338 and 3339 should also be opened
+on each node for the purpose of internal cluster communication.
+For more information, check the ['network port
+configurations']({{< relref "/operate/rs/networking/port-configurations.md" >}})
+page
+{{< /note >}}
+
+## New features
+
+### CRDBs
+
+- The ability to add and remove participating clusters from a CRDB
+- Communications between participating clusters can be encrypted using
+    SSL/TLS
+- Imports can be done to an existing database without flushing the
+    existing data beforehand.
+
+### Modules
+
+- Redis Enterprise Modules are installed with Redis Enterprise
+    Software by default
+- RedisBloom and RediSearch Enterprise have been updated to newer
+    versions
+
+### Other
+
+- Discovery Service supports encryption using SSL/TLS
+- Starting from version 5.0.2 build #30, Redis Enterprise Software is
+    supported on RHEL 7.5
+
+## Important fixes
+
+- RS16153 -- Supervisord version update
+- RS16667 - Fixed issue with 'rladmin status' timeout
+- RS17746 - Fixed upgrade issue when -s option used
+- RS17997, RS18088 - Upgrade issues when using non-default socket
+    file path
+- RS8584 -- Endpoint migration provided misleading plan message
+- RS17696 - Fixed issues with Multi-proxy and intermittent network
+    issues
+- RS17362 - Upgrade fails under some circumstances
+- RS18351 - Listener active after node has been declared dead
+- RS18874 - Fixed OOM issue due to redis_mgr high memory consumption
+- RS19002 - Fixed wrong message when an upgrade of a quorum node with
+    all-nodes policy takes place
+
+**Important Fixes in Build #30:**
+
+- RS19701 - Fixed high CPU usage on large scale clusters
+- RS19869- Added support for Redis
+    version 4.0.9
+- RS20153- Fixed Redis important security issues related to the Lua
+    scripting engine
+- RS19852- Fixed proxy crash which might happen for SSL-enabled
+    DBs
+
+## Known limitations
+
+- Since Redis Enterprise CRDBs have counters, unlike traditional Redis
+    databases, they must be handled differently when importing. There is
+    a special type of import because of importing counter data types.
+    When performing the import through the admin console, you will be prompted
+    to confirm you want to add the data to the CRDB or stop and go flush
+    the database.
+- This version of RS comes with a pre-bundled python which might
+    over-ride your default installed python version, this can be solved
+    by changing your PATH environment variable.
+- Uploading a Redis Module through the admin console, can be performed only
+    when the admin console is connected to the master node.
+- Write operations are not allowed for database which was created with
+    password of exactly 50-characters.
+---
+Title: Redis Enterprise Software Release Notes 5.4.2 (April 2019)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4.2 (April 2019)
+weight: 86
+---
+[Redis Enterprise Software (RS) 5.4.2](https://redislabs.com/redis-enterprise/software/downloads/#downloads) is now available.
+This release improves the compatibility of Active-Active Redis (CRDB) with open source Redis, adds SFTP and Mount Points as backup destinations, email alerting and a number of other enhancements and bug fixes.
+
+## Overview
+
+Follow these [instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 5.4.2 from RS 5.0 and above.
+If you have a version older than 5.0, you must first upgrade to version 5.2 (or at least 5.0).
+
+## New features
+
+### Active-Active Redis (CRDB) {#activeactive-redis-crdb}
+
+RS 5.4.2 introduces new Active-Active Redis (CRDB) capabilities which improve its compatibility with open source Redis.
+This simplifies the progress of migration from open source Redis to Active-Active Redis:
+
+1. The string data-type in CRDB is now implicitly and dynamically typed, just like open source Redis.
+1. Geospatial data is now supported in CRDB.
+
+These changes required upgrading the internal structures of CRDB and the communication protocol between the CRDB replicas.
+To take advantage of these updates with existing CRDBs you must [upgrade the CRDB protocol]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}#upgrading-crdbs/).
+
+### New backup destinations - SFTP and mount point
+
+The storage options for [periodic database backup]({{< relref "/operate/rs/databases/import-export/schedule-backups" >}}), [data export](https://docs.redis.com/latest/rs/databases/import-export/export-data.md), and [data import](https://docs.redis.com/latest/rs/databases/import-export/import-data/) are extended to include:
+
+- SFTP - a secured and well accepted protocol
+- A local mount path that can point to network storage
+
+These new options are in addition to the existing backup locations of FTP, AWS S3 and OpenStack Swift.
+
+### Email alerts per database (per team member)
+
+Improved distribution of [email alerts]({{< relref "/operate/rs/security/access-control/create-users" >}}) for cluster or database alerts.
+The cluster administrator can define, for each team member, the specific databases to receive alerts for, and whether to get the cluster alerts.
+
+### Optional client authentication (TLS)
+
+You can now fine tune the [TLS configuration]({{< relref "/operate/rs/security/encryption/tls" >}}), and ease certificates management by excluding client authentication enforcement,
+so that the database clients, such as applications or other clusters, can connect to your database without authentication.
+
+### Node maintenance mode
+
+When you do hardware or operating system maintenance on a server that hosts an Redis Enterprise node,
+it is important that you move all of the shards on that node to another node to protect the data.
+Starting with RS 5.4.2 you can use [maintenance mode]({{< relref "/operate/rs/clusters/maintenance-mode" >}}) to handle this process simply and efficiently.
+
+## Additional capabilities
+
+- Support for open source Redis version 5.0.4
+- Viewer roles were further limited to improve security compliance. The DB Viewer and Cluster Viewer roles cannot view the Redis password of a database. The DB Viewer role also cannot view the ‘log’ screen.
+
+    {{< note >}}
+These improvements are also included in the REST API and are breaking-changes.
+If you use the relevant API requests with a DB Viewer or Cluster Viewer role, make sure that you update it accordingly.
+    {{< /note >}}
+
+- External user credentials for periodic backup destinations are now hidden.
+    In REST API responses the password is hashed and in the admin console the password is displayed as asterisks.
+
+## Information
+
+- For Redis Enterprise Software 5.4 End of Life (EOL), as well as for previous Redis Enterprise Software versions, see [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}).
+
+## Important fixes
+
+- RS26985 - Fixed a failure of a DB with all-nodes policy, when a node is rebooted
+- RS26433 - Fixed a scenario in which the CRDB sync stopped on one of the participating clusters
+- RS25968 - Fixed a redis crash on RoF cluster
+- RS25835 - Fixed a failure in periodic backup when AOF rewrite is in progress on the same shard
+- RS25558 - Enabled updating absolute path in periodic backup FTP setup
+- RS25381 - Fixed a race condition while updating a database parameter
+- RS24188 - Fixed a failure during database upgrade
+- RS23508 - Fixed a failure in ‘rladmin status’ command
+- RS22485 - Fixed irregularities in service after increasing the size of a database which uses OSS cluster API
+
+## Known limitations
+
+### Upgrade
+
+- Before you upgrade a database with RediSearch Module to Redis 5.0,
+    the RediSearch [Module must be upgraded]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 and above by updating the certificates on the disk instead of using the new API.
+    For assistance with this issue, see [SSL/TLS certificate updates]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}) in our documentation or [contact Redis support](https://redislabs.com/company/support/).
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment.
+    The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- The rladmin option to use to preserve the current Redis major.minor version during database upgrade is now `keep_redis_version`, instead of `keep_current_version`.
+
+### Cluster API
+
+- The API for node removal was updated. It must include json data, and "Content-Type: application/json" header. For example:
+
+    ```sh
+    curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:passsword https://localhost:9443/v1/nodes/3/actions/remove --data "{}"
+    ```
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on Redis Module specific commands.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and RS 5.4.2
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE command for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Pack 4.5 Release Notes (May 2017)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 4.5 (May 2017)
+weight: 94
+---
+If you are upgrading from a previous version, make sure to review the
+upgrade instructions before beginning the upgrade process.
+
+You can upgrade to this version from any 4.4 version. If you have a
+version older than 4.4 you must first upgrade to 4.4 or higher, and only
+then upgrade to this version.
+
+## New features
+
+### The new discovery service with supportfor Redis Sentinel API
+
+The Discovery Service provides an IP-based connection management service
+used when connecting to Redis Enterprise Pack databases. When used in
+conjunction with Redis Enterprise Pack's other high availability
+features, the Discovery Service assists an application cope 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.
+
+Discovery Service is an alternative for applications that do not want to
+depend on DNS name resolution for their connectivity. Discovery Service
+and DNS based connectivity are not mutually exclusive. They can be used
+side by side in a given cluster where some clients can use Discovery
+Service based connection while others can use DNS name resolution when
+connecting to databases.
+
+### Building large databases with RAM and Flash memory in Auto Tiering v2.0
+
+With Redis Enterprise Pack 4.5, Auto Tiering v2 is production
+ready. RFv2 brings performance, reliability, and stability enhancements
+as well as many features customers have been waiting for.
+
+Auto Tiering offers users of Redis Enterprise Pack and
+Redis Cloud Private the unique ability to operate a Redis
+database that spans both RAM and flash memory (SSD), but remains
+separate from Redis Enterprise Pack's persistence mechanisms. Whilst
+keys are always stored in RAM, RoF intelligently manages the location of
+their values (RAM vs Flash) in the database via a LRU-based
+(least-recently-used) mechanism. Hot values will be in RAM and
+infrequently used, while warm values will be ejected to flash memory.
+This enables you to have much larger datasets with RAM-like latency and
+performance, but at dramatically lower cost than an all-RAM database.
+
+### Additional capabilities
+
+Support for additional Redis commands and features:
+
+- The Redis TOUCH command is now supported
+- Redis version upgraded to 3.2.8
+- Support for OBJECT in Lua scripts
+
+Support has been added RHEL 7.3 with this version.
+
+## Important fixes
+
+- RP10106 - SSL Certificate should not need to be signed with a
+    stronger hashing algorithm to be accepted
+- RP10465 - failover times can be higher under certain scenarios in
+    local watchdog profile
+- RP10633 - Improve install.sh and answers file
+- RP11880 - Improved replica sync and add node robustness
+- RP8689 - Minimized impact when changing RAM-Flash limit on Redis
+    Enterprise Flash
+- RP12063 - Improved Redis Flash data import/population performance
+- RP11608 - Improvements to databases.txt creation in support package
+- RP11941 - Eliminated warning and errors during upgrade on RHEL6
+    with leash and python2.6 is installed
+- RP11994 - Databases under certain cases may not display in UI even
+    though they are in the cluster metadata and safely operating.
+- RP12438 - Email alerts with Amazon SES may fail under certain
+    conditions.
+- RP12538 - Redis failover was initiated by node_wd during sync to
+    new replica
+- RP10264 - Improved debuginfo package for better supportability
+
+Important fixes in RP 4.5.0-22
+
+- RP12667 - NGINX security improvements, improved TLS and SSL related
+    warnings on security scans.
+- RP12690 - Added simpler ability to recover cluster from AWS S3
+- RP13359 - Advanced memory allocation and booking enhancements
+
+Important fixes in RP 4.5.0-31
+
+- RP13060 - Client may experience reconnect issues after failover of
+    the endpoint.
+- RP13711 - Disabling IPv6 may cause startup of node services to fail
+    (NGINX) on RHEL 7
+- RP12747 - Calculation can be incorrect for memory quota for
+    databases
+
+Important fixes in RP 4.5.0-35
+
+- RP12844 - cnm_exec crashes on "not enough arguments for format
+    string"
+
+Important fixes in RP 4.5.0-43
+
+- RP9846 - In UI, Used Memory may show incorrect values
+- RP12211 - UI fails import from a Redis OSS DB with password
+- RP13356 - Enable failover when license expires
+- RP14692 - rladmin status command may crash during backup
+- RP14541 - In rare cases, DMC log grew quickly and caused stability
+    issues
+- RP15107 - When using Auto Tiering, it may cause DMC proxy
+    crashes
+
+Important fixes in RP 4.5.0-47
+
+- Multiple important Auto Tiering updates.
+
+Important fixes in RP 4.5.0-51
+
+- 15161 - Make Unix socket folder configurable at install time
+- 15164 - Make Unix socket folder configurable at build time
+- 16082 - Make Unix socket folder configurable at runtime
+- Fixed an issue where on import of data, TTL information was set
+    incorrectly
+---
+Title: RLEC 4.0.0-49 Release Notes (June 18, 2015)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 4.0.0-49 (June 18, 2015)
+weight: 98
+---
+If you are upgrading from a previous version, make sure to review the
+[upgrade
+instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+before running through the upgrade process.
+
+In addition, when running the install.sh script to upgrade the software,
+you might be prompted to approve changes to a configuration file named
+ccs-redis.conf. It is crucial that you choose Yes when asked whether to
+update this file.
+
+## New features
+
+- Support for Red Hat Enterprise Linux (RHEL) and CentOS 6.5 and 7
+    operating systems.
+- Support for additional AWS AMIs for Ubuntu and Amazon Linux, on
+    multiple AWS regions.
+- Support for additional browsers and operating systems for the
+    management UI.
+- Replica Of feature which enables creating a Redis database that
+    keeps synchronizing data from another Redis database.
+- Rack-zone awareness feature which enables mapping nodes to
+    racks/zones to ensure a more sophisticated high-availability
+    mechanism.
+- Database-related alerts and email alerts.
+- Auto-configuration of synchronization of cluster server clocks with
+    NTP as part of installation script.
+- Database Export functionality.
+- Email alerts on database Export and Import.
+
+## Changes
+
+- Database Backup Now functionality replaced with Export
+    functionality.
+- Database performance improvements to increase throughput and reduce
+    latency.
+- Improvement to AOF rewrite mechanism to deal with extreme-write
+    scenarios and limited disk space configurations.
+- Enhancements to rladmin CLI to support additional commands.
+
+## Fixed issues
+
+- Cluster stability improvements related to removing nodes and taking
+    nodes offline.
+- rladmin CLI bug fixes.
+
+## Known issues
+
+- **Issue**: RLEC-6819 - Uninstall on Red Hat Enterprise Linux does
+    not stop all services and if you try to install the software again
+    on the same machine the new installation might use prior
+    installation data.
+    
+    **Workaround**: Before installing the software
+    again restart the machine or verify that all services are down.
+
+- **Issue**: In the replica of process, if the source database is
+    resharded while the replica of process is active, the
+    synchronization process will fail.
+    
+    **Workaround**: You need to
+    manually stop and restart the synchronization process after
+    resharding of the source database is done.
+
+- **Issue**: In the replica of process, high database traffic might cause the replica of process to restart frequently
+    as result of the "replica buffer" being exceeded. In this case you see
+    the status of the replica of process as "Syncing"
+    frequently.
+    
+    **Workaround**: You need to manually reconfigure the
+    "replica buffer" through rladmin and set the buffer size to a new
+    size. In order to find the appropriate buffer size please contact
+    support at: <support@redislabs.com>.
+
+- **Issue**: In a cluster that is configured to support rack-zone
+    awareness, if the user forces migration of a master or replica shard,
+    through rladmin, to a node on the same rack-zone as its
+    corresponding master or replica shard, and later runs the rebalance
+    process, the rebalance process will not migrate the shards to ensure
+    rack-zone awareness compliance.
+    
+    **Workaround**: In the scenario
+    described above, you need to manually migrate the shard, through
+    rladmin, to a node on a valid rack-zone in order to ensure rack-zone
+    awareness compliance.
+
+- **Issue**: In case you deploy a cluster and use the DNS option for
+    the cluster name (see details in [How to set the Cluster Name
+    (FQDN)]({{< relref "/operate/rs/networking/cluster-dns" >}}),
+    do not configure the DNS entries for the cluster nodes, and try to
+    configure a database that is a replica of another database within
+    the cluster, then the UI allows you to configure the source database
+    but the replica of process fails in runtime.
+    
+    **Workaround**: The
+    configuration indicated in this issue is not a valid cluster
+    configuration. If you choose to use the DNS option for the cluster
+    name then you must configure DNS entries for the nodes, otherwise
+    the cluster does not operate correctly. You have to either update
+    the DNS accordingly, or recreate the cluster and use the mDNS option
+    for the cluster name as described in [How to set the Cluster Name
+    (FQDN)]({{< relref "/operate/rs/networking/cluster-dns" >}}).
+    
+- **Issue**: When taking a node offline or removing a node, if the
+    node being taken offline or removed is currently serving as the web
+    server for the web browser being used to view the management UI,
+    then the management UI appears down while the node is
+    down.
+    
+    **Workaround**: If you are using the cluster name in order to
+    connect to the management UI in the browser, and the cluster name is
+    registered in your external DNS or you are using the mDNS option,
+    then the DNS entries will be updated to point to another node in the
+    cluster after a few seconds and the UI will open properly. If you
+    are not using the cluster name but rather the node IP in order to
+    connect to the management UI in the web browser, you have to use the
+    IP of another node in the cluster to access the management UI.
+---
+Title: RLEC 0.99.5-11 Release Notes (January 5, 2015)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 0.99.5-11 (January 5, 2015)
+weight: null
+---
+### New features
+
+Initial release, everything is new!
+
+### Changes
+
+Initial release, no changes!
+
+### Fixed issues
+
+None.
+
+### Known issues
+
+- **Issue:** When taking a node offline or removing a node, if the
+    node being taken offline or removed is currently serving as the web
+    server for the web browser being used to view the management UI, the
+    management UI appears down while the node is down.
+    **Workaround:** If you are using the cluster name in order to
+    connect to the management UI in the browser, and the cluster name is
+    registered in your external DNS or you are using the mDNS option,
+    then the DNS entries will be updated to point to another node in the
+    cluster after a few seconds and the UI will open properly. If you
+    are not using the cluster name but rather the node IP in order to
+    connect to the management UI in the web browser, you have to use the
+    IP of another node in the cluster to access the management UI.
+---
+Title: Redis Enterprise Software Release Notes 5.2 (June 2018)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.2 (June 2018)
+weight: 91
+---
+Redis Enterprise Software (RS) 5.2 is now available. Key features
+include new data types and casual consistency for active-active (also
+known as the Redis CRDT or CRDB Conflict-free Replicated Database), as
+well as enhanced security features.
+
+## Overview
+
+If you are upgrading from a previous version, make sure to review the
+upgrade instructions before beginning the upgrade process. You can
+upgrade to RS 5.2 from RS 4.5 and above. If you have a version older
+than 4.5, you should first upgrade to version 5.0 (or at least
+4.5).
+
+## New features
+
+### Active-Active Redis (CRDB) supports sorted sets and lists {#activeactive-redis-crdb-supports-sorted-sets-and-lists}
+
+RS 5.2 adds active-active Redis (CRDB) support for Sorted Sets and
+Lists. Now all major Redis data types are supported with CRDT, so you
+can use Redis Enterprise in an active-active manner for all your Redis
+use cases, with seamless conflict resolution. [Click here]({{< relref "/operate/rs/databases/active-active" >}}develop/develop-for-aa/)
+for more information about how to develop applications with
+geo-replicated CRDBs.
+
+### Causal consistency in Active-Active Redis (CRDB) {#causal-consistency-in-activeactive-redis-crdb}
+
+casual consistency in active-active Redis (CRDB) guarantees that the
+order of operations on a specific key will be maintained across all CRDB
+instances. For instance, if operations A and B were applied on the same
+key, and B was performed after the effect of A was observed by the CRDB
+instance that initiated B, then all CRDB instances would 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. Such capability is
+important for various applications, e.g. social network status updates
+or chat applications (assuring that the chronology of messages doesn't
+get mixed up). For more information, [click
+here]({{< relref "/operate/rs/databases/active-active/causal-consistency.md" >}}).
+
+### Enhanced security features
+
+- **Admin action audit trail**
+
+Management actions performed with Redis Software are audited in order
+to fulfill two major objectives: (1) make sure that system management tasks
+are appropriately performed and/or monitored by the Administrator(s),
+and (2) facilitate compliance with regulatory standards such as HIPAA,
+SOC2, PCI, etc.
+
+In order to fulfill both objectives, audit records contain the
+following information: (1) who performed the action, (2) what exactly
+was the performed action, (3) when the action was performed, and (4)
+whether  the action succeeded.
+
+To get the list of audit records/events, one can use the REST API or
+the Log page in the UI; the Log page displays the system and user events
+regarding alerts, notifications and
+configurations.
+
+- **Ability to disable TLS versions**
+
+Version 5.2 introduces the option to set the minimum TLS version that
+can be used for encrypting the various flows. You can do so using the
+REST API or the following rladmin commands:
+
+- For the management UI and the REST API:
+
+```sh
+rladmin> cluster config min_control_TLS_version [version, e.g. 1.2]
+```
+
+- For the data path encryption:
+
+```sh
+rladmin> cluster config min_data_TLS_version [version, e.g. 1.2]
+```
+
+Note that communications that use older TLS versions will not be
+allowed.
+
+- **HTTPS enforcement**
+
+With this feature, you can restrict REST API  access to only those
+using HTTPS. In order to do so, use the REST API or the following
+rladmin command:
+
+```sh
+rladmin> cluster config http_support [disabled | enabled]
+```
+
+## Additional capabilities
+
+- Support for Redis version 4.0.9
+- Fixes for Redis important security issues related to the Lua
+    scripting engine
+
+## Information
+
+- The end-of-service-life (EOSL) for Redis Enterprise Software 4.4.X
+    is June 30th, 2018, in accordance with our [published
+    policy]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+    We recommend that customers running version 4.4 or below
+    upgrade to the latest version.
+
+## Important fixes
+
+- RS19755 - Added the ability to enforce HTTPS communication when
+    accessing REST API
+- RS19571 - Fixed RHEL installation when FIPS mode is
+    enabled
+- RS19490 - Fixed a failure while upgrading from 4.5 to
+    5.0.2
+- RS19475 - Added the ability to disable TLS versions for the
+    control and data paths
+- RS18712 - Fixed a failure in endpoint failover
+
+- RS17208 - Added an option to disable Redis commands via Rest
+    API
+- RS14973 - Updated NGINX.conf template to turn off exposing the
+    server version
+- RS11181 - Set file permissions of log files, redis-conf files, rdb
+    files and their rotations to "640"
+
+## Known limitations
+
+- After creating Redis Enterprise CRDBs which "Require SSL for CRDB
+    communication only," one can set definitions via Rest API to
+    activate "Require SSL for All Communication" without providing a
+    certificate. In such case, connections to the cluster will be
+    blocked.
+---
+Title: Redis Enterprise Software Release Notes 5.4.14 (February 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4.14 (February 2020)
+weight: 82
+---
+[Redis Enterprise Software (RS) 5.4.14](https://redislabs.com/redis-enterprise/software/downloads/#downloads) is now available.
+This release bundles OSS Redis 5.0.7 and includes new Redis Modules versions, several enhancements, and bug fixes.
+
+## Overview
+
+Follow these [instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 5.4.14 from RS 5.0.2 and above.
+
+## New features
+
+- Version [5.0.7](https://raw.githubusercontent.com/antirez/redis/5.0/00-RELEASENOTES) of OSS Redis is merged into RS 5.4.14.
+- The following GA releases of Redis Modules are bundled in RS 5.4.14:
+    - [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version 2.2.1 (updated, [release notes]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisbloom/redisbloom-2.2-release-notes.md#redisbloom-221-january-2020))
+    - [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version 2.0.1 (updated, [release notes]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisgraph/redisgraph-2.0-release-notes.md#redisgraph-20-ga-201---january-2020))
+    - [RedisJSON](https://redislabs.com/redis-enterprise/redis-json/), version 1.0.4 (update, [release notes]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisjson/redisjson-1.0-release-notes))
+    - [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version 1.4.25 (updated, [release notes]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisearch/redisearch-1.4-release-notes.md#redisearch-1425-march-2020))
+    - [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/), version 1.2.3 (updated, [release notes]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redistimeseries/redistimeseries-1.2-release-notes))
+
+## Additional capabilities
+
+- Added the ability to retrieve license details with a REST API command.
+    Now you can get your license details from the admin console (settings > general) or from the REST API command:
+
+    `GET https://localhost:9443/v1/license`
+
+    The REST API response includes:
+
+    - license - The cluster’s name (FQDN) in the key string
+    - expired - If the cluster key is expired (True or False)
+    - activation_date - The date of the cluster key activation
+    - expiration_date - The date of the cluster key expiration
+    - shards_limit - The number of shards allowed by the cluster key
+- Added Flush command in the UI console for Active-Active databases. The command flushes the data from all participating clusters.
+- Updated `rladmin upgrade module` command so module arguments are optional. When you upgrade the module for a database, you can either:
+    - Specify the module arguments to replace the existing arguments
+    - Specify the `keep_module_args` flag to use the existing arguments
+
+    Examples:
+
+    1. To upgrade the version of RediSearch to 10017 and replace the module arguments:
+
+        `rladmin upgrade module db_name MyAwesomeDB module_name ft version 10017 module_args "PARTITIONS AUTO"`
+
+    1. To upgrade RedisBloom to version 10100 and remove the current module arguments:
+
+        `rladmin upgrade module db_name MyDB module_name bf version 10100 module_args " "`
+
+    1. To upgrade RedisJSON to 10002 and use the current module arguments:
+
+        `rladmin upgrade module db_name MyDB module_name ReJSON version 10002 keep_module_args`
+
+- Upgraded `js-yaml` version to 3.13.1, and `lodash` version to 4.17.15 (RS31819)
+- Added an alert for actions that run for an extended period of time. For example, a notification is sent when an action like updating database property runs for more than a configurable threshold. Default value is set to 24 hours.
+
+## Information
+
+- End of Life (EOL) for Redis Enterprise Software 5.4, as well as for Redis Modules and previous RS versions, can be found [here](https://docs.redis.com/latest/rs/installing-upgrading/product-lifecycle).
+- Google Chrome browser on macOS Catalina requires self-signed certificate generated after June 2019 to include the extendedKeyUsage field in order to connect to the RS admin console.
+    If you use a self-signed certificate that does not include this field, [update the self-signed certificate]({{< relref "operate/rs/security/certificates/updating-certificates" >}}).
+- When you upgrade an Active-Active Redis with active AOF from version RS 5.4.2 or lower to version RS 5.4.4 or higher:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+
+## Important fixes
+
+- RS23396 - Improved the disconnection mechanism in case of inactive UI session
+- RS27924 - Added descriptive error messages in the UI console when validating the license
+- RS29968 - Improved internal mechanism to better support high scale of clients connections
+- RS35675 - Updated the upgrade process of Active-Active Redis databases to save causal consistency and encryption flags
+- RS36922 - Fixed an issue in a specific cluster upgrade scenario from versions earlier than RS 5.4.0 to RS 5.4.0 or higher
+
+## Known limitations
+
+### Upgrade
+
+- When you upgrade a cluster from version 5.0.2-20 to version 5.4.14, you must first upgrade to version 5.2.2 and then to version 5.4.14.
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis (CRDB) capabilities
+    that improve its compatibility with open source Redis.
+    Now the string data-type in Active-Active Redis (CRDB) is implicitly and dynamically typed, just like open source Redis.
+    To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower,
+    you must [upgrade the CRDB protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- Before you upgrade a database with RediSearch Module to Redis 5.0,
+    you must [upgrade the RediSearch Module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above
+    by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For assistance with this issue, [contact Redis support](https://redislabs.com/company/support/).
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment.
+    The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- Starting from RS 5.4.2, to preserve the current Redis major.minor version during database upgrade you must use the `keep_redis_version` option instead of `keep_current_version`.
+
+### Cluster API
+
+- The API for removing a node is updated in RS 5.4.2 or higher. The API call must include json data and the "Content-Type: application/json" header. For example:
+
+    `curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:password https://localhost:9443/v1/nodes/3/actions/remove --data "{}"`
+
+### Discovery service
+
+- For [Redis Sentinel (Discovery Service)]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}), every database name must be unique across the cluster.
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and above
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE command for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 5.3 BETA (July 2018)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.3 beta(July 2018)
+weight: 90
+---
+Redis Enterprise Software (RS) 5.3 is now available.
+
+RS 5.3 is a preview version that includes all the capabilities of Redis Enterprise 5.2, plus support for Redis 5.0 with the new data type, which is called Streams.
+
+## New features
+
+RS 5.3 adds support for Redis 5.0 and is based on its latest Release Candidate (RC3). Redis 5.0 exposes the new Redis Streams data type, which provides a super fast in-memory abstraction of an append-only log. For more information and usage examples, check out the Streams documentation here.
+
+## Preview considerations
+
+As a preview version, we do not support upgrading to RS 5.3 from any previous version or upgrading from RS 5.3 to any future version. In addition, we do not commit to fixing bugs in RS 5.3.
+
+## Known limitations
+
+The RS 5.3 preview version does not support Enterprise Modules (- RediSearch, ReJSON and ReBloom), Auto Tiering or active-active Redis (CRDB).
+---
+Title: RLEC 4.2.1-30 Release Notes (October 18, 2015)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 4.2.1-30 (October 18, 2015)
+weight: 97
+---
+If you are upgrading from a previous version, make sure to review the
+[upgrade
+instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+before running through the upgrade process.
+
+## New features
+
+- rsyslog logging support - RLEC now writes by default to syslog,
+    which enables monitoring through rsyslog.
+- Profile support for tuning cloud and non-cloud environments --
+    enables the administrator to configure RLEC to run with different
+    performance profiles that are optimized for either cloud or
+    non-cloud environments. For additional details, refer to the
+    [Performance
+    optimization]({{< relref "/operate/rs/clusters/optimize/optimization.md" >}})
+    section.
+- SLA for AOF rewrite - enables the administrator to configure
+    database parameters, by running the rladmin tune command, related to
+    when AOF rewrite is triggered based on the time it would take to
+    load the database from the AOF file, and on the maximum AOF rewrite
+    file size. In addition, updates to the AOF rewrite mechanism
+    minimize chances of the disk getting full.
+- New warning and alerts related to AOF rewrite mechanism - a warning
+    is shown during the setup process in case the disk size is lower
+    than twice the size of the RAM. New cluster level alerts added to
+    alert when node available disk space is lower than the needed disk
+    space for AOF rewrite purposes, and when node performance is
+    degraded due to reaching disk I/O limits.
+- Replica Of support for multiple sources - the Replica Of feature is
+    enhanced to support creating a database that is a replica of
+    multiple source databases. For additional details, refer to the Replica Of section.
+- Cross cluster Replica Of - the Replica Of feature now supports
+    defining a database that is a replica of databases that belong to a
+    different RLEC cluster. For additional details, refer to the
+    Replica Of section.
+- Multi-IP support - on a node that has multiple IPs, enables the
+    administrator to specify which IP address is used for internal
+    traffic and which IP addresses are used for external traffic. For
+    additional details, refer to [Multi-IP &
+    IPv6]({{< relref "/operate/rs/networking/multi-ip-ipv6.md" >}})
+    support.
+- IPv6 support for external traffic - on a node that has multiple
+    IPs, external IP addresses can be of IPv6 type. For additional
+    details, refer to [Multi-IP &
+    IPv6]({{< relref "/operate/rs/networking/multi-ip-ipv6.md" >}})
+    support section.
+- Support for OpenStack Object Store ("Swift") location for import /
+    export / backup. For additional details, refer to [Database
+    backup]({{< relref "/operate/rs/databases/import-export/schedule-backups.md" >}})
+    and [Importing data to a
+    database]({{< relref "/operate/rs/databases/import-export/import-data.md" >}})
+    sections.
+- Import of a sharded database - support for importing data of a
+    sharded database by indicating multiple files paths. For additional
+    details, refer to the [Importing data to a
+    database]({{< relref "/operate/rs/databases/import-export/import-data.md" >}})
+    section.
+- Enable running the install script in silent mode using "-y"
+    parameter for default answers ("Y") or "-c" for file path parameters
+    for custom answers. For additional details, refer to [Accessing and
+    installing the setup
+    package]({{< relref "/operate/rs/installing-upgrading" >}})
+    section.
+- New rladmin command-line-interface "info" command allows for
+    fetching current value of tunable parameters.
+
+## Changes
+
+- rladmin command-line-interface can only be run under user root or
+    redislabs. For additional details, refer to the [rladmin
+    command-line
+    interface (CLI)](https://docs.redis.com/latest/rs/references/rladmin/)
+    section.
+- Import / export / backup to/from Amazon S3 requires supplying the
+    credentials per usage instance; it does not use central cloud
+    credentials that used to be supplied in the Settings -\> General
+    page.
+- Fields related to storing Amazon S3 Cloud credentials have been
+    removed from Settings -\> General page.
+- Performance optimization in the database resharding mechanism.
+- Persistent and ephemeral storage cluster level alerts are enabled by
+    default and set to 70%.
+- Various enhancements to rladmin command-line-interface (CLI) to
+    support new commands.
+- Redis version updated to 2.8.21 that addresses
+    [CVE-2015-4335/DSA-3279 - Redis Lua Sandbox
+    Escape](https://groups.google.com/forum/#!msg/redis-db/4Y6OqK8gEyk/Dg-5cejl-eUJ).
+- Port 3336 added to the list of ports being used by RLEC.
+- Node "Network utilization" alert measured in percentages (%) has
+    been updated to "Network throughput" alert measured in MBps. If the
+    alert was defined then it will be disabled when upgrading to this
+    version and the user needs to reconfigure it with a new value.
+- Performance improvements to the database Import to make the process
+    much faster.
+- Enhancements to the support package to include additional details.
+- Removed support for SSL 2.0/3.0 protocols due to security
+    vulnerabilities.
+- Disabled "dofile" functionality in Redis to solve a possible
+    security vulnerability.
+- rladmin CLI "tune watchdog profile" command syntax updated to "tune
+    cluster watchdog_profile".
+
+## Fixed issues
+
+- Support for relative path for backup and import functionalities.
+- Fix issue with TLS configuration of email server settings.
+- Email alerts not sent for database export and import processes.
+- Fix erroneous entries in the Log page.
+- Sometimes a wrong value is reported in the UI for node used
+    ephemeral storage space.
+- Sometime the wrong Replica Of Lag value is reported in the UI.
+- RLEC-6875 - email server settings not working when using port 587.
+- RLEC-5498 - Improve rladmin response time when a node is down.
+- Validation of Replica Of source definition did not fail in the UI
+    and would only fail in runtime if it was using the Cluster Name
+    (FQDN) and the FQDN was not properly configured in the DNS.
+- Various improvements to error messages reported by rladmin.
+
+## Known issues
+
+- **Issue**: Connecting from a client to a database endpoint with
+    mixed upper case and lower case letters can result in a slow
+    response from the database.
+    
+    **Workaround**: The cluster name (FQDN)
+    should consist of only lower-case letters. When connecting from a
+    client to a database endpoint, only lower case letters should be
+    used in the endpoint.
+
+- **Issue**: When upgrading a node to a new RLEC version (refer to
+    [Upgrading
+    nodes]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+    while the node is in the offline state (refer to [Taking a node
+    offline]({{< relref "/operate/rs/clusters/remove-node.md" >}}),
+    the upgrade process succeeds but might result in an unstable
+    cluster.
+    
+    **Workaround**: Do not try to upgrade a node while it is in
+    the offline state.
+
+- **Issue**: In Red Hat Enterprise Linux, and CentOS operating
+    systems, the process used for cleaning up internal log files does
+    not work, thereby allowing the log files to grow and possibly result
+    in disk space issues.
+    
+    **Workaround**: On each machine that functions
+    as a node in the cluster, create a file named "redislabs", and save
+    it in the following location: "/etc/logrotate.d/" (e.g.
+    "/etc/logrotate.d/redislabs").
+    The file should contain the following text:
+    ```
+    /var/opt/redislabs/log/\*.log {
+    daily
+    missingok
+    copytruncate
+    rotate 7
+    compress
+    notifempty
+    }
+    ```
+    The file's permissions should be root:root, 644.
+    Afterwards, from the operating system command line interface (CLI)
+    run the following commands:
+    ```
+    yum install policycoreutils-python
+    semanage fcontext -a -t var_log_t '/var/opt/redislabs/log(/.\*)?'
+    restsorecon -R /var/opt/redislabs/log
+    ```
+
+- **Issue**: In the Replica Of process, if the target database does
+    not have replication enabled and it is restarted or fails for any
+    reason, the data on target database might not be in sync with the
+    source database, although the status of the Replica Of process
+    indicates it is.
+    
+    **Workaround**: You need to manually stop and
+    restart the synchronization process in order to ensure the databases
+    are in sync.
+
+- **Issue**: In the Replica Of process, if the source database is
+    resharded while the replica of process is active, the
+    synchronization process will fail.
+    
+    **Workaround**: You need to
+    manually stop and restart the synchronization process after
+    resharding of the source database is done.
+- **Issue**: In the replica of process, high database traffic might restart the Replica of process as result of the "replica buffer" being exceeded. In this case you see
+    the status of the replica of process as "Syncing"
+    frequently.
+    
+    **Workaround**: You need to manually reconfigure the
+    "replica buffer" through rladmin and set the buffer size to a new
+    size. In order to find the appropriate buffer size please contact
+    support at: <support@redislabs.com>.
+
+- **Issue**: In a cluster that is configured to support rack-zone
+    awareness, if the user forces migration of a master or replica shard,
+    through rladmin, to a node on the same rack-zone as its
+    corresponding master or replica shard, and later runs the rebalance
+    process, the rebalance process will not migrate the shards to ensure
+    rack-zone awareness compliance.
+    
+    **Workaround**: In the scenario
+    described above, you need to manually migrate the shard, through
+    rladmin, to a node on a valid rack-zone in order to ensure rack-zone
+    awareness
+    compliance.
+---
+Title: RLEC 0.99.5-24 Release Notes (February 15, 2015)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 0.99.5-24 (February 15, 2015)
+weight: 99
+---
+If you are upgrading from a previous version, make sure to review the
+[upgrade
+instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}})
+before running through the upgrade process.
+
+If you are upgrading from version 0.99.5-11:
+
+1. You must restart the services after the upgrade by running the
+    following command with user root (sudo su). From the operating
+    system's CLI, run the following command:
+    cnm_ctl restart
+1. After the upgrade, rladmin status command will report that the
+    databases are from an old version. It is recommended that you
+    upgrade the databases as soon as possible, as described in the
+    [upgrade
+    instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}).
+
+## New features
+
+None.
+
+## Changes
+
+- Enhancements to memtier_benchmark tool that is included in the
+    installation package. You can find more details in the [GitHub
+    project.](https://github.com/RedisLabs/memtier_benchmark)
+
+## Fixed issues
+
+- Improvements and fixes related to node failover, remove node and
+    take node offline functionality.
+
+## Known issues
+
+- **Issue:** When taking a node offline or removing a node, if the
+    node being taken offline or removed is currently serving as the web
+    server for the web browser being used to view the management UI, the
+    management UI appears down while the node is down.
+    **Workaround:** If you are using the cluster name in order to
+    connect to the management UI in the browser, and the cluster name is
+    registered in your external DNS or you are using the mDNS option,
+    then the DNS entries will be updated to point to another node in the
+    cluster after a few seconds and the UI will open properly. If you
+    are not using the cluster name but rather the node IP in order to
+    connect to the management UI in the web browser, you have to use the
+    IP of another node in the cluster to access the management UI.
+---
+Title: Redis Enterprise Software Release Notes 5.5 Preview (April 2019)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Preview release.  Databases support multiple modules.
+linkTitle: 5.5 preview (April 2019)
+weight: 81
+---
+Redis Enterprise Software (RS) 5.5 Preview Edition is now available.
+
+RS 5.5 is a preview version that includes all the capabilities of Redis Enterprise 5.4,
+plus support for creation of Redis databases with multiple modules and support for these modules:
+
+- RediSearch (GA)
+- RedisGraph (GA)
+- RedisBloom (GA)
+- RedisJSON (GA)
+- RedisAI (Preview Version)
+- RedisTimeSeries (Preview Version)
+- RedisGears (Preview Version)
+
+## New features
+
+RS 5.5 lets you create Redis databases with multiple Redis modules.
+
+{{< video "/images/rs/multiple-modules.mp4" "Adding multiple modules" >}}
+
+## Preview considerations
+
+This preview version is a standalone version and is not supported for production environments.
+You cannot upgrade to it from a lower version or upgrade from it to a higher version.
+Unexpected behaviors/issues found in this release will be addressed in future releases.
+
+This preview version is not supported for networks that are isolated from the internet.
+
+## Installation instructions
+
+To set up a cluster with nodes that can host databases with multiple modules, you must follow this procedure on each node in the cluster:
+
+1. [Install RS 5.5]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}}).
+1. To install the modules, run: `sudo ./install-modules.sh`
+1. Either:
+    - Set up the node as the [first node in the cluster]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}).
+    - [Join the node to an existing cluster]({{< relref "/operate/rs/clusters/add-node" >}}).
+---
+Title: Redis Enterprise Software Release Notes 5.4.6 (July 2019)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4.6 (July 2019)
+weight: 84
+---
+
+[Redis Enterprise Software (RS) 5.4.6](https://redislabs.com/redis-enterprise/software/downloads/#downloads) is now available.
+This release includes the latest version of Redis 5 (5.0.5), bundles the GA release of the new RedisTimeSeries module,
+and adds other enhancements and bug fixes.
+
+## Overview
+
+Follow these [instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 5.4.6 from RS 5.0 and above.
+If you have a version older than 5.0, you must first upgrade to version 5.2 (or at least 5.0).
+
+## New features
+
+### Time series
+
+New GA release of the [RedisTimeSeries](https://redislabs.com/blog/redistimeseries-ga-making-4th-dimension-truly-immersive/) (version v1.0.0) module is bundled in RS 5.4.6.
+
+### Modules versions
+
+Updated versions of GA modules:
+
+- RedisTimeSeries  - v1.0.0 (new module)
+- RedisBloom   -  v2.0.0 (version update)
+- RediSearch  -  v1.4.11 (version update)
+- RedisGraph  -  v1.2.2 (no change)
+- RedisJSON  -  v1.0.3 (no change)
+
+## Additional capabilities
+
+- Latest version of Redis 5 (5.0.5) was merged into RS 5.4.6.
+- If a user subscribes to a channel during recovery of a Active-Active Redis (CRDB) from an Append Only File (AOF), the user receives only the new messages.
+    (Fixes known limitation from RS 5.4.4)
+- CROSSSLOT behavior now matches Redis OSS behavior for accessing multiple keys in a single command.
+    Now, when you use CRC16 hash function (default), you can pass a command for different keys/tags that are mapped to the same slot. (RS23189)
+- Cluster upgrade process was improved so that the duration of the cluster upgrade process reduced.
+
+## Information
+
+- End of Life (EOL) for Redis Enterprise Software 5.4, as well as for Redis Modules and previous RS versions,
+    can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}).
+
+## Important fixes
+
+- RS28679 - Syncer and peers related statistics for Active-Active Redis (CRDB),
+    which are already available with the REST API, are exposed through Prometheus.
+- RS28946 - Metrics exporter related minor memory leak fix.
+- RS26312 - Ports handling during installation fix.
+- RS31703 - Fixed performance issue with MSET command.
+
+## Known limitations
+
+### Upgrade
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis (CRDB) capabilities
+    that improve its compatibility with open source Redis.
+    Now the string data-type in Active-Active Redis (CRDB) is implicitly and dynamically typed, just like open source Redis.
+    To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower,
+    you must [upgrade the CRDB protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- Before you upgrade a database with RediSearch Module to Redis 5.0,
+    you must [upgrade the RediSearch Module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above
+    by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For assistance with this issue, [contact Redis support](https://redislabs.com/company/support/).
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment.
+    The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- Starting from RS 5.4.2, to preserve the current Redis major.minor version during database upgrade you must use the `keep_redis_version` option instead of `keep_current_version`.
+
+### Cluster API
+
+- The API for removing a node is updated in RS 5.4.2 or higher. The API call must include json data and the "Content-Type: application/json" header. For example:
+
+    ```sh
+    curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:passsword https://localhost:9443/v1/nodes/3/actions/remove --data "{}"
+    ```
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and above
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE command for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 5.4 (December 2018)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4 (December 2018)
+weight: 88
+---
+Redis Enterprise Software (RS) 5.4 is now available. RS 5.4 adds support for Redis 5.0 (GA) with the new Redis Streams data type.
+
+## Overview
+
+You can upgrade to RS 5.4 from RS 5.0 and above according to the [upgrade instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}). If you have a version older than 5.0, you should first upgrade to version 5.2 (or at least 5.0).
+
+## New features
+
+### Redis 5.0 GA - Redis Streams
+
+RS 5.4 adds support for Redis 5.0 (GA version- 5.0.2), which introduces the new [Redis Streams]({{< relref "/develop/data-types/streams" >}}) data type. Redis Streams models a log data structure in-memory and implements additional powerful operations, such as Consumer Groups.
+
+### Redis graph module
+
+Starting from RS 5.4, Redis Graph, a new Redis Enterprise Module that introduces the world's fastest graph database, is an integral part of Redis Enterprise package.
+
+RedisGraph is the first queryable [Property Graph](https://github.com/opencypher/openCypher/blob/master/docs/property-graph-model.adoc) database to use [sparse matrices](https://en.wikipedia.org/wiki/Sparse_matrix) to represent the [adjacency matrix](https://en.wikipedia.org/wiki/Adjacency_matrix) in graphs and [linear algebra](http://faculty.cse.tamu.edu/davis/GraphBLAS.html) to query the graph.
+
+### Active-Active Redis (CRDB) - Creation in non-clustering mode {#activeactive-redis-crdb-creation-in-nonclustering-mode}
+
+In RS 5.4 you can [create Active-Active databases (CRDBs)]({{< relref "/operate/rs/databases/active-active/create.md" >}}) in a non-clustering mode. As a result, the following creation options are allowed:
+
+1. Clustering mode - Creates a CRDB that consists of any number of shards in a clustering mode and is subject to [multi-key commands limitations]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}).
+1. Non-clustering mode - Creates a CRDB that consists of one shard only in a non-clustering mode so that [multi-key command limitations]({{< relref "/operate/rs/databases/durability-ha/clustering.md" >}}) do not apply.
+
+### High availability for replica shards
+
+When [replica high availability]({{< relref "/operate/rs/databases/configure/replica-ha.md" >}}) is enabled and a master shard fails, a replica (formerly _slave_) shard is automatically promoted to a master shard to maintain data availability. This creates a single point of failure until a new replica shard is manually created.
+
+RS 5.4 expands the high availability capabilities by adding the ability to automatically avoid this single point of failure by configuring the cluster to automatically migrate the replica shard to another available node. In practice, replica migration creates a new replica shard and replicates the data from the master shard to the new replica shard.
+
+*_Note that just as is the case with the Redis open-source project, Redis is in the process of changing the "master-replica" terminology to "master-replica" everywhere, including within our documentation._
+
+## Additional capabilities
+
+- Support for new operating systems- Ubuntu 18.04 and RHEL 7.6.
+
+## Product version lifecycle
+
+- The End of Life (EOL) for Redis Enterprise Software 4.5.X was November 30th, 2018, in accordance with our [published policy]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}). We recommend that customers with version 4.5 or below upgrade to the latest version.
+
+## Important fixes
+
+- RS23616 - Fixed a failure when updating the memory limit of RoF database.
+- RS22871 - Fixed a certificate verify failure after nodes upgrade.
+- RS2862 - Improved admin console performance in case multiple browsers or windows are directed to the admin console.
+- RS22751 - Fixed an issue in the backup process which caused temporary service outage.
+- RS22636 - Fixed Redis process failure when a ReJSON Module's command is executed.
+- RS22601 - Fixed a failure during shard migration procedure.
+- RS22478 - Fixed a failure in replica-of process between two databases with ReBloom Module.
+- RS21974 - SMTP username and password are not mandatory in the email server settings when there is no need for authentication.
+- RS21801 - Fixed admin console issues when cluster is configured with FIPS compliance.
+- RS21772 - Fixed a failure when trying to update a database's endpoint policy to all-master-shards.
+- RS19842 - Updated permissions of some internal files.
+- RS19433 - Improved RAM eviction process for RoF databases.
+- RS18875 - Added the ability to upgrade database gradually, few shards at a time.
+- RS15207 - Fixed a failure during re-shard operation.
+
+## Known limitations
+
+### Installation
+
+- In default Ubuntu 18.04 installations, port 53 is in use by systemd-resolved (DNS server). In such a case, the system configuration must be changed to make this port available before running RS installation.
+
+### Upgrade
+
+- Before you upgrade a database with the RediSearch module to Redis 5.0, you must [upgrade the RediSearch module on that DB]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to 1.4.2 or higher. We recommend that you upgrade the RediSearch module before you upgrade the cluster to RS 5.4.
+- Node upgrade fails if SSL certificates were configured in version 5.0.2 and above by updating the certificates on the disk instead of using the new API. For assistance with this issue, please [contact Redis support](https://redislabs.com/company/support/).
+
+### Cluster API
+
+- Removed the deprecated argument `backup_path` from cluster API. To create or update BDBs, please use `backup_location`.
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on Redis Module specific commands.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- The length of the socket_path variable, which is defined in a node, cannot exceed 88 characters.
+- CLIENT UNBLOCK command is not supported in RS 5.4.
+---
+Title: Redis Enterprise Software Release Notes 5.6.0 (April 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 5.0.8
+description: Install improvements for RHEL 6 and 7. Active-Active support for HyperLogLog.
+  Auto Tiering now supports RedisJSON. Active-Active default changes for high availability
+  and OSS Cluster API support. Backup support for Google Cloud Storage and Azure Blob
+  storage.
+linkTitle: 5.6.0 (April 2020)
+weight: 80
+---
+[Redis Enterprise Software (RS) 5.6.0](https://redislabs.com/download-center/) is now available. This major version release includes:
+
+- Improved installation process to be customizable
+- Support for the HyperLogLog data type in Active-Active databases
+- RedisJSON support in databases with Auto Tiering enabled
+- Support for Redis OSS Cluster API for Active-Active and Replica Of databases
+- Replica HA enabled by default for Active-Active databases
+- Cloud backup locations support
+- Support for Red Hat Enterprise Linux version 7.7, 7.8
+- Additional enhancements, and minor bug fixes
+
+## Information
+
+### Upgrade
+
+- Follow [these instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 5.6.0 from RS 5.0.2 and above.
+- For Active-Active databases, you must upgrade the [feature set version]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}#upgrade-activeactive-databases).
+
+### End of life
+
+- End of Life (EOL) for Redis Enterprise Software 5.6 and previous RS versions can be found [here]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}).
+    EOL for Redis Modules can be found [here]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}#modules-endoflife-schedule).
+- Support of Red Hat Enterprise Linux 6 and Oracle Linux 6 [operating systems platforms]({{< relref "/operate/rs/references/supported-platforms" >}}) will end on November 30, 2020.
+- Support of OpenStack Object Storage ("Swift") for [backup, import and export location](https://docs.redis.com/latest/rs/databases/import-export/import-data/) will end on November 30, 2020.
+
+## New features
+
+### Redis Software installer
+
+Redis Enterprise Software installer adds the ability to specify custom installation paths and a custom installation user, group, or both on RHEL versions 6 and 7.
+
+When you run the installer you can specify the installation, the configuration and the var as well as the user and the group:
+
+```sh
+sudo ./install.sh --install-dir <path> --config-dir <path> --var-dir <path> --os-user <user> --os-group <group>
+```
+
+For more information, check out the [Redis Enterprise Software installer documentation](https://docs.redis.com/latest/rs/installing-upgrading/).
+
+### Hyperloglog on Active-Active
+
+RS 5.6.0 adds the support of [HyperLogLog](http://www.antirez.com/news/75) data structure for [Active-Active Redis]({{< relref "/operate/rs/databases/import-export/replica-of" >}}) databases.
+
+Because HyperLogLog is a counting data structure by nature, conflicts can occur when deleting entries. For efficiency, performance and memory considerations, conflicts between instances are resolved with DEL (delete) operations winning over ADD operations that took place in concurrent or before the DEL operation.
+
+For more information, check out the [HyperLogLog on Active-Active documentation]({{< relref "/operate/rs/databases/active-active" >}}develop/hyperloglog-active-active.md).
+
+### RedisJSON on Auto Tiering
+
+RS 5.6.0 adds support for [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) databases with [Redis Modules](https://docs.redis.com/latest/modules). [RedisJSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}) is the first module to be available to run on a database with Auto Tiering enabled.
+
+Using RedisJSON on Auto Tiering allows you to benefit from high performance redis with high data volume at lower costs.
+
+### OSS Cluster API support
+
+For more information, check out the [OSS Cluster API documentation]({{< relref "/operate/rs/databases/configure/oss-cluster-api.md" >}}).
+
+**Support for Active-Active and Replica Of databases**
+
+You can configure [Active-Active]({{< relref "/operate/rs/databases/import-export/replica-of" >}}) databases to use the [OSS Cluster API](https://docs.redis.com/latest/rs/clusters/optimize/oss-cluster-api/) using the admin console.
+The OSS Cluster API improves the performance of user operations against your database.
+
+You can also create or modify an Active-Active Redis database in OSS Cluster mode using the `crdb-cli` tool with the `--oss-cluster` option to apply the changes to all of the instances.
+
+**Create and edit database using the admin console**
+
+You can configure OSS Cluster API for databases using the admin console.
+
+For Active-Active databases, you can create the database with OSS Cluster API enabled for all of its instances.
+When you enable OSS Cluster after the Active-Active database is created, the change applies only to the local instance.
+
+### Replica HA defaults for Active-Active
+
+To enhance the availability and the consistency of [Active-Active geo-distributed Redis]({{< relref "/operate/rs/databases/active-active" >}}),
+[Replica HA]({{< relref "/operate/rs/databases/configure/replica-ha" >}}) is enabled by default for all existing and new Active-Active Redis Databases.
+
+To disable Replica HA for for a local instance of an Active-Active database, run this command on the instance: `rladmin tune db <bdb_uid> slave_ha disabled`
+
+### Cloud backup locations support
+
+Redis Enterprise 5.6.0 adds the ability to configure Azure Blob Storage and Google Cloud Storage as backup, import, and export locations.
+
+### Red Hat Enterprise Linux 7.7, 7.8
+
+Redis Enterprise 5.6.0 adds RHEL 7.7, 7.8 to its [supported platforms]({{< relref "/operate/rs/references/supported-platforms" >}}).
+
+## Redis modules
+
+The following GA releases of Redis Modules are bundled in RS 5.6.0:
+
+- [RedisBloom](https://redislabs.com/redis-enterprise/redis-bloom/), version [2.2.1]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisbloom/redisbloom-2.2-release-notes)
+- [RedisGraph](https://redislabs.com/redis-enterprise/redis-graph/), version [2.0.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisgraph/redisgraph-2.0-release-notes)
+- [RedisJson](https://redislabs.com/redis-enterprise/redis-json/), version [1.0.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisjson/redisjson-1.0-release-notes)
+- [RediSearch](https://redislabs.com/redis-enterprise/redis-search/), version [1.6.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redisearch/redisearch-1.6-release-notes) (updated)
+- [RedisTimeSeries](https://redislabs.com/redis-enterprise/redis-time-series/), version [1.2.3]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}release-notes/redistimeseries/redistimeseries-1.2-release-notes)
+
+## Additional capabilities
+
+- OSS Redis version [5.0.8](https://raw.githubusercontent.com/antirez/redis/5.0/00-RELEASENOTES)  is merged into RS 5.6.0.
+- Starting RS 5.6.0, to upgrade modules during database upgrade you must use the module_args option instead of keep_module_args or <argument> or “ ” (for no arguments). The module_args option must follow with one of the following (Always in quotation marks): “keep_args” or “ “ or “<argument>”.
+For more info and examples, check out [upgrading Redis Modules documentation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) .
+- rladmin adds the ability to demote the cluster master node when setting it to [maintenance mode]({{< relref "/operate/rs/clusters/maintenance-mode.md" >}}) by using the `demote_node` option:
+
+```sh
+rladmin node <node_uid> maintenance_mode on demote_node
+```
+
+- The `SENTINEL MASTER` command output format was updated to be aligned with OSS equivalent output.
+
+## Important fixes
+
+- RS38315, RS33747 - Added the LUA script name (SHA) and its arguments to the warning message indicating the LUA script has been running for more than 5 seconds.
+- RS38706 - Fixed a bug which caused a stuck state machine in some scenarios of restoring DB from RDB.
+- RS34309 - Improved internal passwords handling.
+- RS38498 - Fixed a bug in the upgrade process of a database to avoid failure when saving large RDB (Redis Database Backup) file.
+- RS38706 - Fixed a bug that caused a stuck state machine after restoring a snapshot of an Active-Active database.
+- RS43996 - Fixed a bug in the upgrade process when using ./install.sh -y and firewalld is not running.
+- RS45777 - Fixed a bug that caused clients on a shared connection to the proxy to get disonnected. Disconnections occured in case a response for a request of an already disconnected client was received.
+With build 5.6.0-39:
+- RS45627, RS47382 - Fixed bugs causing clients to disconnect when using XREAD and XREADGROUP commands in blocking mode on other clients’ connections.
+- RS44656 - Fixed a bug causing TLS mode for clients connections to toggle between ‘all communication’ to ‘for crdb communication only’ when performing a global configuration change.
+
+## Known limitations
+
+### Active-Active databases
+
+- RS51359 - Active-Active databases, using replication and Append Only File (AOF) for [database persistence]({{<relref "/operate/rs/databases/configure/database-persistence">}}), are suffering from memory leaks on replica shards, causing them to grow bigger than the master shards. Customers are advised to upgrade to RS 6.0.12. Meanwhile, you can use a snapshot for database persistence or restart the replica shards.
+
+### Upgrade notes
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis Database capabilities that improve its compatibility with open source Redis.
+    Now the string data-type in Active-Active Redis Database is implicitly and dynamically typed, just like open source Redis.
+    To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower,
+    you must [upgrade the Active-Active Redis Database protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- When you upgrade an Active-Active Redis with active AOF from version [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) or lower to version [RS 5.4.4]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-4-june-2019.md" >}}) or higher:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For assistance with this issue, contact Support.
+- Starting from [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}), to preserve the current Redis major.minor version during database upgrade you must use the keep_redis_version option instead of keep_current_version.
+- Google Chrome browser on macOS Catalina requires a self-signed certificate generated after June 2019 to include the extendedKeyUsage field in order to connect to the RS admin console. If you use a self-signed certificate that does not include this field, [update the self-signed certificate]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+
+### Modules upgrade
+
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment. The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- Before you upgrade a database with RediSearch Module to Redis 5.0, you must [upgrade the RediSearch Module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+
+### Cluster API
+
+- The API for removing a node is updated in [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) or higher. The API call must include json data and the "Content-Type: application/json" header. For example:
+
+    ```sh
+    curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:password https://localhost:9443/v1/nodes/3/actions/remove --data "{}"
+    ```
+
+### Discover service
+
+- For [Redis Sentinel (Discovery Service)]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}), every database name must be unique across the cluster.
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and above
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE commands for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 5.4.10 (December 2019)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4.10 (December 2019)
+weight: 83
+---
+
+[Redis Enterprise Software (RS) 5.4.10](https://redislabs.com/redis-enterprise/software/downloads/#downloads) is now available.
+This release includes an improved synchronization mechanism for Active-Active Redis and Replica-of, several enhancements, and bug fixes.
+
+## Overview
+
+Follow these [instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) for upgrading to RS 5.4.10 from RS 5.0 and above.
+
+## New features
+
+### Synchronization mechanism in Active-Active Redis and Replica-of
+
+RS 5.4.10 incorporates the improved [Redis synchronization mechanism]({{< relref "/operate/rs/databases/active-active" >}}#syncer-process) ([PSYNC2]({{< relref "/operate/oss_and_stack/management/replication" >}})) for Active-Active Redis (CRDB) and Replica-of.
+
+As a result, failure scenarios in any A-A replica (and the source database of Replica-of), require only partial synchronization between the cross-region replicas instead of full synchronization that can be costly in time and bandwidth.
+
+### RS on RHEL 7 supports OpenSSL 1.0.2 and up
+
+To keep RS secure and keep our internal libraries up-to-date, starting from RS 5.4.10 our RHEL 7 installations require a minimum of OpenSSL 1.0.2.
+
+When you install or upgrade RS 5.4.10 on RHEL 7 with older version of OpenSLL, the installation fails with the error:
+
+```sh
+Error: Package: redislabs-5.4.10-1.rhel7.x86_64 (/redislabs-5.4.10-1.rhel7.x86_64)
+        Requires: libcrypto.so.10(OPENSSL_1.0.2)(64bit)
+```
+
+If you see this error, upgrade to OpenSSL 1.0.2 or higher before you install RS.
+
+## Additional capabilities
+
+- The following new GA releases of Redis Modules are bundled in RS 5.4.10:
+    - RedisBloom, version 2.0.3
+    - RedisSearch, version 1.4.18
+    - RedisJson, version 1.0.4
+    - RedisGraph, version 1.2.2
+    - RedisTimeSeries, version 1.0.3
+- Version 5.0.5 of Redis OSS, along with a fix to a corruption related to the HyperLogLog (that is part of [Redis 5.0.6](https://raw.githubusercontent.com/antirez/redis/5.0/00-RELEASENOTES)) are merged into RS 5.4.10.
+- Using REST API, you can retrieve various license details such as activation date, expiration date,and the number of licensed shards. To get these details, run:
+
+    `curl -v -u <user>:<password> https://localhost:9443/v1/license`
+
+- Updated PDNS version from 4.1.5 to 4.1.13.
+
+## Information
+
+- End of Life (EOL) for Redis Enterprise Software 5.4, as well as for Redis Modules and previous RS versions, can be found [here](https://docs.redis.com/latest/rs/installing-upgrading/product-lifecycle).
+- Google Chrome browser on macOS Catalina requires self-signed certificate generated after June 2019 to include the extendedKeyUsage field in order to connect to the RS admin console.
+    If you use a self-signed certificate that does not include this field, [update the self-signed certificate]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+- When you upgrade an Active-Active Redis with active AOF from version RS 5.4.2 or lower to version RS 5.4.4 or higher:
+    - If replication is enabled, you must run the BGREWRITEAOF command on all replica shards after the upgrade.
+    - If replication is not enabled, you must run the BGREWRITEAOF command on all shards after the upgrade.
+
+## Important fixes
+
+- The titles of the ‘rladmin status nodes’ command output were updated from ‘RAM’ to ‘FREE_RAM’ (the amount of RAM in the node that is currently not used) and from ‘AVAILABLE_RAM’ to ‘PROVISIONAL_RAM’ (the amount of RAM in the node that can be provisioned).
+- RS31492 - Upgraded dependent libraries: [python-cryptography to version 2.7](https://github.com/redislabsdev/Redis-Enterprise/pull/4209/commits/3b5a408696b91a0b545f670ce35bb920d5a4beb4); [NGINX to version 1.16.0](https://github.com/redislabsdev/Redis-Enterprise/pull/4209/commits/4ab171d4467bd91c6b38cec81da3c52a6113a787); [PyYaml to version 5.1.2](https://github.com/redislabsdev/Redis-Enterprise/pull/4209/commits/11e814ae0d14c85b248bc7451edbbbcb71f3858f); [python-requests to version 2.22.0](https://github.com/redislabsdev/Redis-Enterprise/pull/4209/commits/0e2ab74b4e2b2dc9872a86fbdb5593f5354eb103); [urllib3 to version 1.25.3](https://github.com/redislabsdev/Redis-Enterprise/pull/4209/commits/038e44163d7dc1fed4e3b67cb252a84583c2f44a)
+- RS31187 - Upgraded the internal Python interpreter to version 2.7.16
+- RS33042 - Fixed Support Package to contain complete SLOWLOG information
+- RS32699 - Avoided unnecessary restart and failover of Redis processes when Active-Active database is upgraded
+- RS32061 - Improved support of the Redis WAIT command
+- RS31759 - Fixed failure during database import
+- RS31747 - Fixed failure in upgrade from version 5.0.0-31 to 5.4.6-11
+- RS30063 - Fixed the upgrade process when WatchdogAPI fails to bind to its port
+- RS31477 - Fixed wrong calculation of node’s ‘AVAILABLE_RAM’ (‘PROVISIONAL_RAM’) as displayed the output of ‘rladmin status nodes’ command
+- RS30165 - Fixed failover scenario that did not take place during node restart
+- RS29250 - REST API documentation was updated to include the SFTP and Mount Point backup/export options
+- RS27327 - Improved the backup timing when using the database parameter of ‘backup_interval_offset’ through the REST API
+- RS33883 - HCSAN command in Active-Active Redis updated to return Integer instead of a String.
+- Fixed a limitation so Redis 5 and Redis 4 can be selected as the Redis version to use CRDB and RoF
+
+## Known limitations
+
+### Upgrade
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis (CRDB) capabilities
+    that improve its compatibility with open source Redis.
+    Now the string data-type in Active-Active Redis (CRDB) is implicitly and dynamically typed, just like open source Redis.
+    To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower,
+    you must [upgrade the CRDB protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- Before you upgrade a database with RediSearch Module to Redis 5.0,
+    you must [upgrade the RediSearch Module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above
+    by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}).
+    For assistance with this issue, [contact Redis support](https://redislabs.com/company/support/).
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment.
+    The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- Starting from RS 5.4.2, to preserve the current Redis major.minor version during database upgrade you must use the `keep_redis_version` option instead of `keep_current_version`.
+
+### Cluster API
+
+- The API for removing a node is updated in RS 5.4.2 or higher. The API call must include json data and the "Content-Type: application/json" header. For example:
+
+    `curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:password https://localhost:9443/v1/nodes/3/actions/remove --data "{}"`
+
+### Discovery service
+
+- For [Redis Sentinel (Discovery Service)]({{< relref "/operate/rs/databases/durability-ha/discovery-service.md" >}}), every database name must be unique across the cluster.
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4 and above
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE command for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Redis Enterprise Software Release Notes 5.4.4 (June 2019)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+linkTitle: 5.4.4 (June 2019)
+weight: 85
+---
+Redis Enterprise Software (RS) 5.4.4 is now available.
+This release enables the functionality of Active-Active Redis (CRDB) combined with RoF (Auto Tiering),
+supports the creation of Redis databases with multiple modules,
+and adds other enhancements and bug fixes.
+
+## Overview
+
+Follow these [instructions for upgrading]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) to RS 5.4.4 from RS 5.0 and above.
+If you have a version older than 5.0, you must first upgrade to version 5.2 (or at least 5.0).
+
+## New features
+
+### Active-Active Redis with RoF {#activeactive-redis-with-rof}
+
+RS 5.4.4 lets you create Active-Active Redis databases (CRDBs) with Auto Tiering and get the benefits of geo-distributed Redis databases along with the significant cost savings of using Auto Tiering.
+
+{{< note >}}
+You must select **Redis 5** as the Redis version to use CRDB and RoF.
+{{< /note >}}
+
+### Support for multiple modules
+
+RS 5.4.4 supports the creation and management of Redis databases with a combination of any of the following GA modules:
+
+- RediSearch (GA)
+- RedisGraph (GA)
+- RedisBloom (GA)
+- RedisJSON (GA)
+
+{{< video "/images/rs/multiple-modules.mp4" "Adding multiple modules" >}}
+
+To upgrade databases with multiple modules, you can use the `rladmin upgrade` command.
+
+{{< note >}}
+The syntax for the `rladmin upgrade` command now requires that the module_args parameter be written inside quotation marks.
+{{< /note >}}
+
+- To upgrade only the modules within an existing database, for example with RedisBloom (bf) and RedisJSON:
+
+    ```sh
+    rladmin upgrade module db_name db1 module_name bf version 10003 module_args "" module_name ReJSON version 10001 module_args ""
+    ```
+
+- To upgrade a database with its modules, for example db1 with RediSearch and RedisGraph:
+
+    ```sh
+    rladmin upgrade db db1 and module module_name redisearch version 103 module_args "ON_TIMEOUT FAIL NOGC" and module module_name graph version 10016 module_args ""
+    ```
+
+You can also upgrade the modules with the REST API.
+
+- To upgrade multiple modules, enter the details of each module in the `modules` parameter:
+
+    ```sh
+    curl -X POST -u "demo@redislabs.com:password" -H "Content-Type: application/json" -d '{"modules":[{"module_name": "ReJSON", "current_module": "<module_uid>", "new_module": "<module_uid>", "new_module_args": "", "current_semantic_version":"1.0.4"}, {"module_name":"ft","current_module":"<module_uid>","new_module": "<module_uid>","current_semantic_version":"1.4.3", "new_module_args":"PARTITIONS AUTO"}], "force_restart":true}' https://127.0.0.1:9443/v1/bdbs/2/modules/upgrade
+    ```
+
+- To upgrade a single module, you can either:
+    - Enter the details of the module in the `modules` parameter
+    - Enter the details of the module without the `modules` parameter, as in previous releases
+
+## Additional capabilities
+
+- Support for persistence of AOF every 1 second in Active-Active Redis (CRDB), in addition to AOF every write.
+    We recommend that you use AOF every 1 second for the best performance during the initial CRDB sync of a new replica.
+- NGINX version updated to 1.14.2
+
+## Information
+
+- Stay up to date with the [End of Life (EOL) Policy]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}) for RS 5.4 and all previous RS versions.
+
+## Important fixes
+
+- RS26508 - Fixed redis-cli failure for a specific CRDB data type.
+- RS29191 - Fixed a failure when removing a replica from a CRDB.
+- RS29097 - Fixed a misconfiguration when using SFTP backup and encounter a node failure.
+- RS28286 - Updated `SETEX` and `PSETEX` commands output of CRDB to match Redis outputs.
+- RS26984 - Fixed metrics_exporter reports for node and shard level metrics.
+- RS19854 - Fixed uploading a Redis Module so you can upload a Redis Module when the admin console is connected to any node.
+- RS29238 - Improved the compression performance in CRDB.
+
+## Known limitations
+
+### Upgrade
+
+- [RS 5.4.2]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-2-april-2019.md" >}}) introduced new Active-Active Redis (CRDB) capabilities that improve its compatibility with open source Redis. Now the string data-type in CRDB is implicitly and dynamically typed, just like open source Redis. To use the new capabilities on nodes that are upgraded from version RS 5.4.2 or lower, you must [upgrade the CRDB protocol]({{< relref "/operate/rs/installing-upgrading/upgrading#upgrading-crdbs" >}}).
+- Before you upgrade a database with RediSearch Module to Redis 5.0, you must [upgrade the RediSearch Module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to version 1.4.2 or above.
+- Node upgrade fails if the SSL certificates were configured in version 5.0.2 or above by manually updating the certificates on the disk instead of [updating them through the API]({{< relref "/operate/rs/security/certificates/updating-certificates" >}}). For assistance with this issue, [contact Redis support](https://redislabs.com/company/support/).
+- We recommend that you test module upgrade commands in a test environment before you upgrade modules in a production environment. The module upgrade arguments are not validated during the upgrade process and incorrect arguments can cause unexpected downtime.
+- Starting from RS 5.4.2, to preserve the current Redis major.minor version during database upgrade you must use the `keep_redis_version` option instead of `keep_current_version`.
+
+### Subscriptions
+
+- If a user subscribes to a channel during recovery of a CRDB from AOF, the user receives old messages that are stored in the AOF file.
+
+### Cluster API
+
+- The API for removing a node is updated in RS 5.4.2 or higher. The API call must include json data and the "Content-Type: application/json" header. For example:
+
+    ```sh
+    curl -X POST -H "Content-Type: application/json" -i -k -u user@redislabs.com:passsword https://localhost:9443/v1/nodes/3/actions/remove --data "{}"
+
+    ```
+
+### Redis commands
+
+- The capability of disabling specific Redis commands does not work on commands specific to Redis Modules.
+- The CLIENT ID command cannot guarantee incremental IDs between clients that connect to different nodes under multi proxy policies.
+- CLIENT UNBLOCK command is not supported in RS 5.4.x
+- Starting from RS 5.4.2 and after upgrading the CRDB, TYPE command for string data-type in CRDBs return "string" (OSS Redis standard).
+---
+Title: Previous releases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Release notes for Redis Enterprise Software 5.6.0 (April 2020) and earlier
+  versions.
+hideListLinks: true
+linkTitle: Previous releases
+weight: 100
+---
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+---
+Title: Redis Enterprise Software Release Notes 6.2.4 (August 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2
+description: Internode encryption. Nginx replaced by envoy.  New upgrade policies/behavior.
+linkTitle: 6.2.4 (August 2021)
+weight: 76
+---
+
+[Redis Enterprise Software version 6.2.4](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+This version offers:
+
+- Encryption of all communications within cluster nodes 
+- Security enhancements
+- Bug fixes
+- Compatibility with the latest version of open source Redis 6.2.3
+
+## Version changes
+
+### Prerequisites and notes
+
+You can [upgrade to v6.2.4]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) from Redis Enterprise Software v6.0 and later. 
+
+Keep the following in mind:
+
+- Upgrades from versions earlier than v6.0 are not supported
+
+- The new internode encryption feature requires port 3342 to be open on all machines in the cluster.
+
+- [In v6.0.20]({{< relref "/operate/rs/release-notes/rs-6-0-20-april-2021.md" >}}), Redis Enterprise Software replaced Nginx with envoy to improve internal security and communication.  As of v6.2.4, Nginx is no longer provided with Redis Enterprise Software.
+
+### Database upgrade default changes
+
+The default behavior of the `upgrade db` command has changed.  It is now controlled by a new cluster policy (`redis_upgrade_policy`), which defines the policy for creating new databases and upgrading existing databases.  The policy supports the following values:
+
+- When set to `major`, the policy allows databases to be created or updated to versions of Redis compatible with open source Redis major releases.  This allows for longer upgrade cycles by supporting Redis versions across multiple Redis Enterprise Software releases.  
+
+    This is the default value for Redis Enterprise Software.
+
+- When set to `latest`, the policy creates new databases and upgrades existing ones to be compatible with the latest (most recent) version of open source Redis, which was the default behavior of earlier versions of Redis Enterprise Software.  This is no longer the default behavior.
+
+    Setting the upgrade policy to `latest` ensures that the most recent Redis features are available to new databases and ones that are upgraded.  It also requires more frequent upgrades, as open source Redis is updated more frequently than Redis Enterprise Software.
+
+The Redis Enterprise Software 6.2.4 package includes compatibility with the most recent major Redis release (v6.0) and the latest (most recent) update to Redis (v6.2.3).  
+
+By default, compatibility with v6.0 will be installed.  To change this, use `rladmin` to set the upgrade policy and the default Redis version:
+
+``` shell
+$ rladmin tune cluster redis_upgrade_policy latest
+$ rladmin tune cluster default_redis_version 6.2
+```
+
+To learn more, see the [upgrade instructions]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}).
+
+### Product lifecycle updates
+
+Redis Enterprise Software v5.6.0 will reach end of life (EOF) on October 31, 2021.
+
+To learn more, see the Redis Enterprise Software [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle.md" >}}), which details the release number and the end-of-life schedule for Redis Enterprise Software.
+
+Redis Enterprise modules have individual release numbers [and lifecycles]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle.md" >}}).
+
+### Deprecation notices
+
+- [In v6.0.20]({{< relref "/operate/rs/release-notes/rs-6-0-20-april-2021.md" >}}), the SASL-based LDAP mechanism was deprecated in favor of a new [RBAC-based approach]({{< relref "/operate/rs/security/access-control/ldap" >}}).  As of v6.2.12, support for the older mechanism has been removed.
+
+    For help migrating to the LDAP-based mechanism, see [Migrate to role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/migrate-to-role-based-ldap" >}}).
+    
+- [OpenStack Object Storage](https://wiki.openstack.org/wiki/Swift) ("Swift") has reached end-of-life.  Consequently, you can no longer use ObjectStack Swift as a target for database backup or export operations.  
+
+## Features and enhancements
+
+### Internode encryption
+
+Internode encryption (INE) encrypts all communication between nodes in a cluster; it is available for the control plane and the data plane. 
+
+#### Control plane internode encryption
+
+Control plane internode encryption encrypts all management communication within a cluster.  It is enabled by default for all new clusters and upgraded clusters.
+
+#### Data plane internode encryption
+
+Data plane internode encryption encrypts communication between nodes within a cluster, such as database replication between nodes.  
+
+Data plane internode encryption is available for new or fully upgraded clusters.  It is not enabled by default.  
+
+You can enable data plane internode encryption by:
+
+- Setting the cluster policy to enable data plane internode encryption by default for new databases
+    
+    ``` shell
+    rladmin tune cluster data_internode_encryption enabled
+    ```
+         
+- Enabling it for individual existing databases
+
+    ``` shell
+    rladmin tune db <db:id | name> data_internode_encryption enabled
+    ```
+
+### Internal certificate management
+
+Internode encryption relies on internal certificates signed by a unique, private CA certificate created for your deployment.  The private CA generates and signs leaf certificates for internode encryption only.  It's generated when you install or upgrade to Redis Enterprise 6.2.4.  It's used only within the cluster and is not exposed outside of the cluster.  
+
+The leaf certificates expire regularly; they're automatically rotated before expiration and alerts are issued as needed.
+
+### Open source Redis compatibility
+
+[Redis 6.2](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) introduced new commands, feature improvements, and security fixes; it addresses many customer requests.
+
+Redis Enterprise Software supports all new commands, except [RESET]({{< relref "/commands/reset" >}}) and [FAILOVER]({{< relref "/commands/failover" >}}.  (Redis Enterprise takes a different approach to connectivity; it also separates control plane operations from data plane operations.)
+
+To learn more, see Redis Enterprise Software [compatibility with open source]({{< relref "/operate/rs/references/compatibility" >}}).
+
+### Redis modules
+
+Redis Enterprise Software v6.2.4 includes the following Redis modules:
+
+- [RediSearch v2.0.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.0-release-notes.md" >}})
+- [RedisJSON v1.0.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-1.0-release-notes.md" >}})
+- [RedisBloom v2.2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.2-release-notes.md" >}}) 
+- [RedisGraph v2.4.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.4-release-notes.md" >}})
+- [RedisTimeSeries v1.4.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.4-release-notes.md" >}})
+
+### Internode encryption for modules 
+         
+To utilize data plane encryption for existing databases with modules, update the module to the latest version prior to enabling data plane encryption. 
+
+For help, see [Upgrade the module for a database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}).
+
+### Module-related enhancements
+
+Added the capability to update current module arguments for an existing database. 
+In earlier versions, you could do this only when upgrading a module.
+To learn more, see [`rladmin upgrade`]({{< relref "/operate/rs/references/cli-utilities/rladmin/upgrade" >}}).
+
+## Resolved issues
+
+- RS39954 - Changed the UI status indication for the 
+[default user]({{< relref "/operate/rs/references/cli-utilities/rladmin/upgrade" >}}) from `Active/Inactive` to `Enabled/Disabled` 
+
+- RS42626 - Increased the max length for modules commands from 23 characters to 64 characters
+
+- RS54732 - Fixed incorrect reporting of number database connections, which caused the number of connections to be reported as a 20 digit number
+
+- RS52265 - Fixed excessive log lines reporting when an Active-Active database is on featureset `0`. [Upgrade the featureset]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}) version to the latest.
+
+- RS56122 - Fixed a bug that was causing AOF files to grow when the replicas of two Active-Active databases became disconnected during full synchronization
+
+- RS58184 - Fixed a bug when trying to create an Active-Active database with expired syncer certificates; participating clusters were creating replicas even though the create operation failed.
+
+- RS48988 - Add the username description in the log upon an unauthorized REST API request
+
+## Known limitations
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Known issues 
+
+- A new command was added as part of Redis 6.2: [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}). When used in an Active-Active configuration, this command may cause Redis shards to crash, potentially resulting in data loss. The issue is fixed in Redis Enterprise Software version 6.2.12. Additionally, we recommend enabling AOF persistence for all Active-Active configurations.
+
+- The `ZRANGESTORE` command, with a special `zset-max-ziplist-entries` configuration can crash Redis 6.2. See [Redis repository 10767](https://github.com/redis/redis/pull/10767) for more details.
+
+- RS81463 - A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+## Security
+
+-   The following [Open Source Redis](https://github.com/redis/redis) [CVE's](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+    -   [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement `LCS`. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+    -   [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+    -   [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+---
+Title: Redis Enterprise Software release notes 6.4.2-43 (March 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Ubuntu 20.04 support. Safe node removal. Allow gossip_envoy port configuration.
+linkTitle: 6.4.2-43 (March 2023)
+weight: 71
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | eed4083b0b4c066d31ea9b8ba60a34f5 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 7fd4321f6a5502c76197fc039f44ffa3 |
+
+## New features and enhancements
+
+#### Support for Ubuntu 20
+
+Added operating system support for Ubuntu 20.04.
+
+#### Validate client certificates by subject attributes
+
+- Added the ability to enter multiple `Organizational Unit (OU)` values to a certificate validation's subject entry. Subject validation only succeeds if all `OU` values match.
+
+- Validation fails if the certificate’s subject contains an extra field which is missing from the certificate’s configured subject (empty field).
+
+#### Safe node removal (RS92095)
+
+As of this release, the node removal task waits for persistence files to be created on a new node before finishing removal. For more information, see [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) and [`rladmin node remove`](https://docs.redis.com/latest/rs/references/cli-utilities/rladmin/node/remove/).
+
+#### Allow port configuration for gossip_envoy service (RS72028) 
+
+You can use the REST API to configure the `gossip_envoy_admin_port` during bootstrapping or runtime. See the [cluster object reference]({{< relref "/operate/rs/references/rest-api/objects/cluster" >}}) for more details.
+
+Support for `rladmin` will be added in a future 6.4.2 maintenance release.
+
+#### Redis Stack v6.2.6
+
+Redis Enterprise Software v6.4.2 includes the new features delivered in the latest [Redis Stack release (v6.2.6)](https://redis.com/blog/introducing-redis-stack-6-2-6-and-7-0-6/ ):
+
+- [RediSearch v2.6.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch" >}}redisearch-2.6-release-notes/#v264-december-2022)
+
+- [RedisJSON v2.4.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson" >}}redisjson-2.4-release-notes/#v245-february-2023)
+
+- [RedisBloom v2.4.3]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/redisbloom-2.4-release-notes/#v24-ga-v243-november-2022)
+
+- [RedisGraph v2.10.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph" >}}redisgraph-2.10-release-notes/#v2105-december-2022)
+
+- [RedisTimeSeries v1.8.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries" >}}redistimeseries-1.8-release-notes/#v185-january-2023)
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+## Resolved issues
+
+- RS95344 - Fix custom installation linkage bug for files related to Active-Active
+
+- RS91554 - Enhance visibility of `redis_mgr` 
+
+- RS90496 - Improve cross-node communication to support failovers
+
+- RS93004 - Allow positive `audit_port` configuration
+
+- RS58918 - Reduce the number of clients blocked by flushing a database. Only the client that requested the flush will be blocked until the action finishes. Other clients won't be affected.
+
+- RS85447 - When creating a database, the memory size is total memory for the database, not the total dataset size. Therefore, if you enable replication and the database has two shards, each shard will have half of the allocated memory size.
+
+- RS90556 -  `Heartbeatd` - upgrade [`sysinfo`](https://crates.io/crates/sysinfo) dependency 0.19.1 -> 0.27.7
+
+- RS93566 - Added [`rlcheck`]({{< relref "/operate/rs/references/cli-utilities/rlcheck" >}}) validation step to verify that all needed modules (modules used during the initial creation of any CRDBs on the cluster) are actually available on the cluster. In some cases, if a specific module version is required, the user will need to upload it in order to upgrade the cluster. After the upgrade is complete, you can delete the required module.
+
+## Known limitations
+
+### Feature limitations
+
+#### Resharding fails for rack-aware databases with no replication
+
+When a database is configured as [rack-aware]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}}) and replication is turned off, the resharding operation fails.
+
+RS97971 - This limitation will be fixed in a future 6.4.2 maintenance release.    
+
+Workaround:
+
+Before resharding your database, turn off rack awareness:
+
+```sh
+curl -k -u "<user>:<password>" -H "Content-type: application/json" -d '{"rack_aware": false}' -X PUT "https://localhost:9443/v1/bdbs/<bdb_uid>"
+```
+
+After the resharding process is complete, you can re-enable rack awareness:
+
+```sh
+curl -k -u "<user>:<password>" -H "Content-type: application/json" -d '{"rack_aware": true}' -X PUT "https://localhost:9443/v1/bdbs/<bdb_uid>"
+```
+
+### Operating system limitations
+
+#### RHEL 7 and RHEL 8
+
+RS95344 - CRDB database will not start on Redis Enterprise v6.4.2 with a custom installation path.
+
+For a workaround, use the following commands to add the relevant CRDB files to the Redis library:
+
+```sh
+$ yum install -y chrpath
+$ find $installdir -name "crdt.so" | xargs -n1 -I {} /bin/bash -c 'chrpath -r ${libdir} {}'
+```
+
+This limitation will be fixed in a future 6.4.2 maintenance release.
+
+#### Ubuntu 20.04
+
+By default, you cannot use the SHA1 hash algorithm ([OpenSSL’s default security level is set to 2](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes)). The operating system will reject SHA1 certificates even if the `mtls_allow_weak_hashing` option is enabled. You need to replace SHA1 certificates with newer certificates that use SHA-256. Note that the certificates provided with Redis Enterprise Software use SHA-256.  
+
+
+#### Ubuntu 16, 18, 20
+
+RS95824 - An error occurs when running `rl_rdbconvert` manually.
+
+As a workaround, run the following command:
+
+```sh
+LD_LIBRARY_PATH=$libdir rl_rdbconvert
+```
+---
+Title: Redis Enterprise Software release notes 6.4.2-110 (May 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: RedisGraph v2.10.15. RedisBloom v2.4.8. Bug fixes.
+linkTitle: 6.4.2-110 (May 2024)
+weight: 65
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- RedisGraph v2.10.15
+
+  {{<note>}}
+Redis has announced the end of life for RedisGraph. See the [announcement](https://redis.io/blog/redisgraph-eol/) for details.
+  {{</note>}}
+
+- RedisBloom v2.4.8
+
+- Bug fixes
+
+## New in this release
+
+### Enhancements
+
+#### Redis modules
+
+Redis Enterprise Software version 6.4.2-110 includes the following Redis Stack modules:
+
+- [RediSearch v2.6.12]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes" >}})
+
+- [RedisJSON v2.4.7]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes" >}})
+
+- [RedisBloom v2.4.8]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes" >}})
+
+- [RedisGraph v2.10.15]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes" >}})
+
+- [RedisTimeSeries v1.8.11]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes" >}})
+
+### Resolved issues
+
+- RS123237: CRDT syncer prevents potential data mismatches or data loss due to missing keys when removing and re-adding a cluster in an Active-Active setup with at least three participating clusters after removing older clusters without re-adding them.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (6.4.2-110 May release) |
+|---------|---------------------------------------|
+| Ubuntu 16 | e61aab4bbb6837230451b70f8e0aa056 |
+| Ubuntu 18 | 3180ea41e744acca860257dcef6c49c4 |
+| Red Hat Enterprise Linux (RHEL) 7 | aaf0c1110f5ecc9ce55bf2935f2bcb73 |
+| Red Hat Enterprise Linux (RHEL) 8 | d69894c4bc0860274973a4d78d53cb5d |
+| Amazon Linux 2 | 19ac38908e47bd59c5890d1fc3bdba17 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 6.4.2-110 supports open source Redis 6.2 and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 6.4.2-94 (July 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Look-ahead mechanism for planner attempts. Package OS compatibility validation.
+linkTitle: 6.4.2-94 (July 2023)
+toc: 'true'
+weight: 67
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | f9df1080427660bab601f1690ee7ffca |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>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.
+
+  With this update, the algorithm efficiently finds a legal placement while reducing the calculation time significantly. These changes ensure a smoother and faster experience when managing databases with a large number of shards and dense shard placement policy.
+
+- RS62197 - Added validation of the operating system (OS) version before installation. The installer automatically validates the OS type and version and verifies the correct binary is used for the corresponding system. This prevents missing dependencies which may cause issues later on.
+
+  The validation applies to major versions of all operating systems. If the check fails, the installation process halts with an appropriate error message.
+
+
+#### 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 v7)](https://redis.com/blog/introducing-redis-stack-6-2-6-and-7-0-6/):
+
+- [RediSearch v2.6.9]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes" >}})
+
+- [RedisJSON v2.4.7]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes" >}})
+
+- [RedisBloom v2.4.5]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes" >}})
+
+- [RedisGraph v2.10.10]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes" >}})
+
+- [RedisTimeSeries v1.8.10]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+## Resolved issues
+
+- RS100903 - Fixed a v6.4.2 issue: when a database client requests [`SLOWLOG GET [count]`]({{< relref "/commands/slowlog-get" >}}, the proxy ignores “count” and always replies with 128 records
+
+- RS95394 - Fixed Replica Of sync causing high DMC memory usage on source cluster when TLS is enabled "for Replica Of Only".
+
+- RS102905 - Fixed invalid character that could potentially cause failure in generating support package for Active-Active databases.
+
+- RS92430 - Optimized internal certification rotation process benefiting mainly clusters.
+
+- RS99495 - Updated UI title property to "Redis Enterprise"
+---
+Title: Redis Enterprise Software release notes 6.4.2-81 (June 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Email alerts for database backup failures and replica high availability
+  shard relocation failures.
+linkTitle: 6.4.2-81 (June 2023)
+toc: 'true'
+weight: 68
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | 1e51c5fdf22c0b6988565444ba08c6cd |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 96dc036339fe18fb218e8d4c8ff50c99 |
+| Amazon Linux 2 | 1a549bdb360c9e22ef764faeadbd4c90 |
+
+## New features and enhancements
+
+- RS77279 - Database backup failures and replica high availability ([replica HA]({{< relref "/operate/rs/databases/configure/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)](https://redis.com/blog/introducing-redis-stack-6-2-6-and-7-0-6/):
+
+- [RediSearch v2.6.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}})
+
+- [RedisJSON v2.4.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+
+- [RedisBloom v2.4.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+
+- [RedisGraph v2.10.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph" >}})
+
+- [RedisTimeSeries v1.8.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+## Resolved issues
+
+- RS101204 - Fixed high memory consumption that was caused by the `persistence_mgr` service when AOF persistence is configured for every second.
+
+- RS39322 , RS35526  - [`rlcheck`]({{< relref "/operate/rs/references/cli-utilities/rlcheck" >}}) no longer requires root privileges and can run with the `redislabs` group and user.
+
+- RS97315, RS100853  - Fixed the robustness of the support package process when collecting the shard configuration.
+
+- RS65110 - Fixed firewalld SELinux configuration.
+
+- RS101691 - Clean false error messages at the end of installation. 
+
+## Known limitations
+
+### Feature limitations
+
+- RS78430 - When [tuning module arguments]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}), typos or unsupported arguments can cause shards to get stuck after restarting.
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+### Operating system limitations
+
+#### Ubuntu 20.04
+
+By default, you cannot use the SHA1 hash algorithm ([OpenSSL’s default security level is set to 2](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes)). The operating system will reject SHA1 certificates even if the `mtls_allow_weak_hashing` option is enabled. You need to replace SHA1 certificates with newer certificates that use SHA-256. Note that the certificates provided with Redis Enterprise Software use SHA-256.
+---
+Title: Redis Enterprise Software release notes 6.4.2-115 (Oct 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: RediSearch v2.6.23. RedisBloom v2.4.12. RedisTimeSeries v1.8.15.
+linkTitle: 6.4.2-115 (Oct 2024)
+weight: 64
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- RediSearch v2.6.23
+
+- RedisBloom v2.4.12
+
+- RedisTimeSeries v1.8.15
+
+## New in this release
+
+### Enhancements
+
+#### Redis modules
+
+Redis Enterprise Software version 6.4.2-115 includes the following Redis Stack modules:
+
+- [RediSearch v2.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes" >}})
+
+- [RedisJSON v2.4]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes" >}})
+
+- [RedisBloom v2.4]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes" >}})
+
+- [RedisGraph v2.10]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes" >}})
+
+- [RedisTimeSeries v1.8]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes" >}})
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (6.4.2-115 Oct release) |
+|---------|---------------------------------------|
+| Ubuntu 16 | 5fb2186abb6c87efebd987ebf827b949 |
+| Ubuntu 18 | e8a938c7125fbc7d7f85f0e19d4afafb |
+| Red Hat Enterprise Linux (RHEL) 7 | dc646920043bd888299726027d9e9216 |
+| Red Hat Enterprise Linux (RHEL) 8 | 54574ca69f2966f7361f281f1ea3b312 |
+| Amazon Linux 2 | 8315ba719f1549e8bf423a9db004d49c |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 6.4.2-115 supports open source Redis 6.2 and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow can occur when handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` can occur when parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 6.4.2-121 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Internal fixes and improvements.
+linkTitle: 6.4.2-121 (March 2025)
+weight: 63
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Internal fixes and improvements
+
+## New in this release
+
+#### Redis modules
+
+Redis Enterprise Software version 6.4.2-121 includes the following Redis Stack modules:
+
+- [RediSearch v2.6]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes" >}})
+
+- [RedisJSON v2.4]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes" >}})
+
+- [RedisBloom v2.4]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes" >}})
+
+- [RedisGraph v2.10]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes" >}})
+
+- [RedisTimeSeries v1.8]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes" >}})
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (6.4.2-121 March release) |
+|---------|---------------------------------------|
+| Ubuntu 16 | 251324d7ee04b524e0e08d3ddb6e2723 |
+| Ubuntu 18 | fb7e0931e75174cc8433cb7f4c9b3b15 |
+| Ubuntu 20 | 1e6abb275aa9a44246571313a46f391a |
+| Red Hat Enterprise Linux (RHEL) 7 | 3da1cf1c73c2bb116b4d09456f8693bd |
+| Red Hat Enterprise Linux (RHEL) 8 | 8b06790eb63d769216e87c183a5a64e1 |
+| Amazon Linux 2 | 3ff40b912c0f5de632fa3a144f6a77e9 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 6.4.2-121 supports open source Redis 6.2 and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow can occur when handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` can occur when parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 6.4.2-69 (May 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Amazon Linux 2 support. Configure envoy ports using rladmin. Added option
+  to avoid specific nodes when using the optimized shards placement API. Added failure_detection_sensitivity
+  to replace watchdog_profile.
+linkTitle: 6.4.2-69 (May 2023)
+toc: 'true'
+weight: 69
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | 4d53fcce8c80910a05ed37ab64b57a7a |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 88dc6a4d96b948b086f785dc42786d03 |
+| Amazon Linux 2 | 7ed06bc0b35494e4a5c084528d6e8b9f |
+
+## New features and enhancements
+
+- Amazon Linux 2 support
+
+- Enhanced installation logs (RS69079, RS69571, RS77857, RS89760)
+
+- Added support for `rladmin` envoy port configuration (RS95483)
+
+- Support the option to avoid specific nodes when using optimized shards placement API  (RS98795)
+
+- Check port availability before installation and upgrade (RS80815)
+
+- Added `failure_detection_sensitivity` policy to [cluster policy REST API requests]({{< relref "/operate/rs/references/rest-api/requests/cluster/policy" >}}). See the [`watchdog_profile` deprecation notice](#watchdog_profile) for more details.
+
+#### 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)](https://redis.com/blog/introducing-redis-stack-6-2-6-and-7-0-6/):
+
+- [RediSearch v2.6.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}})
+
+- [RedisJSON v2.4.7]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+
+- [RedisBloom v2.4.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+
+- [RedisGraph v2.10.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph" >}})
+
+- [RedisTimeSeries v1.8.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+## Version changes
+
+### Deprecations
+
+#### watchdog_profile
+
+The `watchdog_profile` setting is deprecated and will be removed in a future release. Instead, use the `failure_detection_sensitivity` policy for predefined thresholds and timeouts:
+
+```sh
+rladmin tune cluster failure_detection_sensitivity [ high | low ]
+```
+
+The `failure_detection_sensitivity` policy has the following options:
+
+- `high` (previously known as `local-network watchdog_profile`) – high failure detection sensitivity, lower thresholds, and faster failure detection and failover
+
+- `low` (previously known as `cloud watchdog_profile`) – low failure detection sensitivity and higher tolerance for latency variance (also called network jitter)
+
+#### Ubuntu 16.04
+
+Ubuntu 16 support is deprecated, and support will be removed in a future release.
+
+#### Active-Active database persistence
+
+The RDB snapshot option for [Active-Active database persistence]({{< relref "/operate/rs/databases/active-active/manage#data-persistence" >}}) is deprecated and will be removed in a future release.
+
+Please plan to reconfigure any Active-Active databases to use append-only file (AOF) persistence with the following command:
+
+```sh
+crdb-cli crdb update --crdb-guid <CRDB_GUID> \
+    --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+## Resolved issues
+
+- RS97528 - Prevent [self-signed certificate]({{< relref "/operate/rs/security/certificates/create-certificates" >}}) script error on Ubuntu 20.04 by changing the user instructions.
+
+- RS99643 - Fix [`cipher_suites`]({{< relref "/operate/rs/security/encryption/tls/ciphers" >}}) configuration to allow default cipher suites according to the control plane, data plane, and discovery service.
+
+- RS99696 - Fix  [`HINCRBYFLOT`](https://github.com/redis/redis/security/advisories/GHSA-hjv8-vjf6-wcr6) CVE
+
+- RS54226 - During upgrades, a CRDB worker process would intermittently get stuck in a restart loop. This issue is now fixed. 
+
+## Known limitations
+
+### Feature limitations
+
+- RS78430 -  When [tuning module arguments]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}), any typo or use of unsupported arguments can cause shards to get stuck after restart.
+
+### Operating system limitations
+
+#### Ubuntu 20.04
+
+By default, you cannot use the SHA1 hash algorithm ([OpenSSL’s default security level is set to 2](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes)). The operating system will reject SHA1 certificates even if the `mtls_allow_weak_hashing` option is enabled. You need to replace SHA1 certificates with newer certificates that use SHA-256. Note that the certificates provided with Redis Enterprise Software use SHA-256.
+---
+Title: Redis Enterprise Software release notes 6.4.2-61 (April 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Amazon Linux 2 support. Fixed known limitations for custom installation
+  on RHEL 7 and RHEL 8, running rl_rdbconvert manually, and resharding rack-aware
+  databases with no replication.
+linkTitle: 6.4.2-61 (April 2023)
+weight: 70
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+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<br/>Oracle Enterprise Linux (OL) 7 | 477f1d3161ea16e8d52c41eb61d92637 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 1170af43f88bf5f9095890916c0fe74d |
+| Amazon Linux 2 (Release Candidate) | e246ae158db32e0a483a23392b2a7f47 |
+
+## New features and enhancements
+
+- Amazon Linux 2 supported as a release candidate (RC)
+
+    {{<note>}}
+A database with modules cannot reside on an Amazon Linux 2 (release candidate) node. Support will be added in a future maintenance release.
+    {{</note>}}
+
+- Add node ID indication to [`debug_info` package]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/debug_info" >}}) (RS95360)
+
+- Add support for underscore `_` as a valid character for [rack awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}}) (RS87458)
+
+- When updating a [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}), the version property is immutable. Any validation will be performed according to the BDB object version that was set during upgrade or install (RS93294)
+
+#### 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)](https://redis.com/blog/introducing-redis-stack-6-2-6-and-7-0-6/):
+
+- [RediSearch v2.6.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}})
+
+- [RedisJSON v2.4.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})
+
+- [RedisBloom v2.4.5]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}})
+
+- [RedisGraph v2.10.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph" >}})
+
+- [RedisTimeSeries v1.8.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database.
+
+## Version changes
+
+### Deprecations
+
+#### Ubuntu 16.04
+
+Ubuntu 16 support is deprecated and will be removed in a future release.
+
+#### Active-Active database persistence
+
+The RDB snapshot option for [Active-Active database persistence]({{< relref "/operate/rs/databases/active-active/manage#data-persistence" >}}) is deprecated and will be removed in a future release.
+
+Please plan to reconfigure any Active-Active databases to use append-only file (AOF) persistence with the following command:
+
+```sh
+crdb-cli crdb update --crdb-guid <CRDB_GUID> \
+    --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+## Resolved issues
+
+- RS95344 - Fixed known limitation for RHEL 7 and RHEL 8 where CRDB databases fail to start when installed using custom installation paths
+
+- RS88010 - Roll back node configuration when the [remove node]({{< relref "/operate/rs/clusters/remove-node" >}}) operation fails
+
+- RS95824 - Fixed an issue with running `rl_rdbconvert` on Ubuntu
+
+- RS97971 - Fixed known limitation for the edge case where resharding fails for rack-aware databases with no replication
+
+## Known limitations
+
+### Operating system limitations
+
+#### Ubuntu 20.04
+
+By default, you cannot use the SHA1 hash algorithm ([OpenSSL’s default security level is set to 2](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes)). The operating system will reject SHA1 certificates even if the `mtls_allow_weak_hashing` option is enabled. You need to replace SHA1 certificates with newer certificates that use SHA-256. Note that the certificates provided with Redis Enterprise Software use SHA-256.
+
+#### Modules not supported for Amazon Linux 2 release candidate
+
+A database with modules cannot reside on an Amazon Linux 2 (release candidate) node. Support will be added in a future maintenance release.
+---
+Title: Redis Enterprise Software release notes 6.4.2-30 (February 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.7
+description: Pub/sub ACLs & default permissions. Validate client certificates by subject
+  attributes.
+linkTitle: 6.4.2-30 (February 2023)
+weight: 72
+---
+
+​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software) 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](https://github.com/redis/redis)
+
+- 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<br/>Oracle Enterprise Linux (OL) 7 | c1537855dcfe7a7cedf9031ce01e2b9b |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>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.
+
+See [Enable TLS]({{< relref "/operate/rs/security/encryption/tls/enable-tls" >}}) for more information.
+
+
+#### Default pub/sub ACL permissions
+
+Redis is continuously enhancing its ACL (access control list) functionality and coverage. Redis version 6.2 enhances [ACLs]({{<relref "/operate/oss_and_stack/management/security/acl">}}) to allow and disallow pub/sub channels. 
+
+Part of protecting pub/sub channels requires changing the default access from permissive to restrictive, which blocks all pub/sub channels unless specifically permitted by an ACL rule. To allow this transition across all databases in the cluster, Redis Enterprise Software 6.4.2 provides a new configuration option `acl-pubsub-default` that sets the cluster-wide default for all channels to either permitted or restricted.
+
+The 6.4.2 installation-provided value of `acl-pubsub-default` is permissive (`allchannels`) to comply with earlier Redis versions. After you upgrade all databases in the cluster to Redis DB version 6.2 (or later in future versions), you can use `rladmin` or the REST API to change the value to restrictive (`resetchannels`).
+
+To allow certain users to access specific pub/sub channels, define the appropriate ACL. Redis Enterprise Software 6.4.2 enhances the admin console (UI), CLI, and REST API to support pub/sub channel ACL definitions.
+
+If you use ACLs and pub/sub channels, we recommend you review your databases and ACL settings and plan to change your cluster to restricted mode. This will help you prepare for future Redis Enterprise Software releases that use restrictive `resetchannels` as the new default for `acl-pubsub-default`.
+
+#### Redis modules 
+
+Redis Enterprise Software v6.4.2 includes the following Redis modules:
+
+- [RediSearch v2.4.16]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.4-release-notes#v2416-november-2022" >}})
+
+- [RedisJSON v2.2.0]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.2-release-notes#v220-july-2022" >}})
+
+- [RedisBloom v2.2.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/redisbloom-2.2-release-notes/#v2218-july-2022)
+
+- [RedisGraph v2.8.20]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.8-release-notes#v2820-september-2022" >}})
+
+- [RedisTimeSeries v1.6.17]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.6-release-notes#v1617-july-2022" >}})
+
+See [Upgrade modules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to learn how to upgrade a module for a database. 
+
+#### Installations, upgrades, and troubleshooting
+
+- Added the ability for `install.sh` to run even if “upgrade mode” is already enabled to allow reruns in case of a previous run failure (RS77319)
+
+- Added log messages to the `redis_mgr` process (RS77891), the job_scheduler process (RS82673), and the `install.sh` script (RS82673)
+
+- Improved `rladmin` error messages for certificate validation (RS79933)
+
+- Added internode encryption ports to command-line utility `rlcheck` validation (RS68965)
+
+- Added an alert to notify when a node operation (such as maintenance mode) failed, aborted, or was canceled. The alert is enabled by default (RS76089)
+
+## Version changes 
+
+### Breaking changes
+
+- REST API: the `authorized_names` field of the [BDB object]({{< relref "/operate/rs/references/rest-api/objects/bdb" >}}) is deprecated. Use the new `authorized_subjects` field instead.
+
+### New default Redis DB version
+
+Both Redis Enterprise Software versions 6.2.x and 6.4.x package two Redis DB versions: Redis DB 6.0 and Redis DB 6.2. Until now, the default Redis DB version for creating new databases and upgrading existing databases was 6.0 (enforced by the `redis_upgrade_policy` parameter).
+
+To allow customers more flexibility in future upgrades, starting with Redis Enterprise Software 6.4.2, the default Redis DB version for new and upgraded databases is now 6.2 for all upgrade policies (`redis_upgrade_policy=major` and `redis_upgrade_policy=latest`). 
+
+| Redis<br />Enterprise | Bundled Redis<br />DB versions | Default DB version<br />(upgraded/new databases) |
+|-------|----------|-----|
+| 6.2.x | 6.0, 6.2 | 6.0 |
+| 6.4.2 | 6.0, 6.2 | 6.2 |
+
+You can override the default version with [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune" >}}#tune-cluster); however, we recommend that you don't change this setting.
+
+### Deprecations
+
+#### Ubuntu 16.04
+
+Ubuntu 16 support is considered deprecated and will be removed in a future release. Ubuntu 16.04 LTS (Xenial) has reached the end of its free initial five-year security maintenance period as of April 30, 2021.
+
+#### Active-Active database persistence
+
+The snapshot option for Active-Active database persistence is deprecated. We advise customers running Active-Active databases, configured with snapshot data persistence, to reconfigure their data persistence mode to use the AOF (Append Only File) option with the following command:
+
+```sh
+crdb-cli crdb update --crdb-guid <CRDB_GUID> \
+    --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+#### TLS 1.0 and TLS 1.1
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.
+Please verify that all clients, apps, and connections support TLS 1.2. Support for the earlier protocols will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols. Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+#### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+## Resolved issues
+
+- RS72866 - Improved performance for client connections which use TLS
+
+- RS78241 - Fixed shard placement to always respect rack-zone restrictions and avoid a state where a primary (master) and replica are on the same rack, even if temporarily
+
+- RS78144 - Removed the dependency on system-wide `ldconfig` so non-interactive processes will use their own dynamic libraries without impacting external services
+
+- RS78028 - Fixed race condition during rolling upgrade that might result in shards repeatedly restarting
+
+- RS77964 - Fixed module deletion to remove the old directory with the module
+
+- RS75259 - Fixed node to prevent using plain text communication instead of TLS after losing connectivity
+
+- RS69616 - Fixed validation for internode communication ports
+
+- RS83535 - Fixed `sentinel_service` to start on RHEL 8 with DISA STIG profile 
+
+- RS87191 - Fixed a cross slot error when using Auto Tiering with Replica Of, in case a key on the source database swapped from RAM to flash and expired while it was also part of Lua script execution
+
+## Known limitations
+
+### Feature limitations
+
+- RS101204 - High memory consumption caused by the `persistence_mgr` service when AOF persistence is configured for every second. Monitor RAM usage of the process. In case of high usage, the temporary workaround is to restart the service by running `supervisorctl restart persistence_mgr`. A permanent fix is to install or upgrade to the 6.4.2 June maintenance release.
+
+### Upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.4.2-30, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+
+This limitation has been fixed and resolved as of [v6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+### Operating system limitations
+
+#### RHEL 7 and RHEL 8
+
+If you have a custom installation with a non-default `$installdir` and use Active-Active or Auto Tiering features, failures might occur when you upgrade. This issue will be fixed in a future maintenance release. 
+
+#### RHEL 8
+
+Due to module binary differences between RHEL 7 and RHEL 8, you cannot upgrade RHEL 7 clusters to RHEL 8 when they host databases using modules. Instead, you need to create a new cluster on RHEL 8 and then migrate existing data from your RHEL 7 cluster. This does not apply to clusters that do not use modules.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). The following open source Redis [CVEs](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+- [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) — Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement LCS. Additional information about the open source Redis fix is on the [Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+- [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) — Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on the [Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) — Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on the [Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) — Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on the [Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) — Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the `proto-max-bulk-len CONFIG` is blocked in Redis Enterprise. Additional information about the open source Redis fix is on the [Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+Redis Enterprise has already included the fixes for the relevant CVEs. Some CVEs announced for open source Redis do not affect Redis Enterprise due to different and additional functionality available in Redis Enterprise that is not available in open source Redis.
+---
+Title: Redis Enterprise Software release notes 6.4.2
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: Pub/sub ACLs & default permissions. Validate client certificates by subject
+  attributes. Ubuntu 20.04 support.
+headerRange: '[1-2]'
+hideListLinks: true
+linkTitle: 6.4.2 releases
+toc: 'true'
+weight: 72
+---
+
+​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software) 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 access control lists (ACLs)
+
+- Enhanced TLS performance when Redis returns large arrays in responses
+
+- Compatibility with [open source Redis](https://github.com/redis/redis) 6.2.7 and 6.2.10.
+
+- Additional enhancements and bug fixes
+
+## Detailed release notes
+
+For more detailed release notes, select a build version from the following table:
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+
+## Deprecations
+
+### Ubuntu 16.04
+
+Ubuntu 16 support is considered deprecated and will be removed in a future release. Ubuntu 16.04 LTS (Xenial) has reached the end of its free initial five-year security maintenance period as of April 30, 2021.
+
+### Active-Active database persistence
+
+The RDB snapshot option for [Active-Active database persistence]({{< relref "/operate/rs/databases/active-active/manage#data-persistence" >}}) is deprecated and will be removed in a future release.
+
+Please plan to reconfigure any Active-Active databases to use append-only file (AOF) persistence with the following command:
+
+```sh
+crdb-cli crdb update --crdb-guid <CRDB_GUID> \
+    --default-db-config '{"data_persistence": "aof", "aof_policy":"appendfsync-every-sec"}'
+```
+
+### TLS 1.0 and TLS 1.1
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.
+Please verify that all clients, apps, and connections support TLS 1.2. Support for the earlier protocols will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols. Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+### 3DES encryption cipher
+
+The 3DES encryption cipher is considered deprecated in favor of stronger ciphers like AES.
+Please verify that all clients, apps, and connections support the AES cipher. Support for 3DES will be removed in a future release.
+Certain operating systems, such as RHEL 8, have already removed support for 3DES. Redis Enterprise Software cannot support cipher suites that are not supported by the underlying operating system.
+
+## Known limitations
+
+### Feature limitations
+
+- RS97971 - [Resharding fails for rack-aware databases with no replication](#resharding-fails-for-rack-aware-databases-with-no-replication) (fixed and resolved as part of [v6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}})).
+
+- RS101204 - High memory consumption caused by the `persistence_mgr` service when AOF persistence is configured for every second (fixed and resolved as part of [v6.4.2-81]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-81" >}})).
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+- RS51144, RS102128 - Active-Active: To start successfully, the syncer (`crdt-syncer`) must connect to all sources. In multi-cluster configurations (more than 2 A-A clusters participating), in some cases, if one or more of the clusters is not available, A-A replication will be down.
+
+- RS123142 - In an Active-Active setup with at least three participating clusters, removing and re-adding a cluster after removing older clusters without re-adding them can cause missing keys and potentially lead to data loss or data inconsistency.
+
+    This issue will be fixed in a future maintenance release. To prevent this issue, avoid adding clusters until you upgrade to the upcoming maintenance release when available.
+
+#### Resharding fails for rack-aware databases with no replication
+
+When a database is configured as [rack-aware]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}}) and replication is turned off, the resharding operation fails.
+
+RS97971 - This limitation was fixed and resolved as part of [v6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}).   
+
+Workaround:
+
+Before resharding your database, turn off rack awareness:
+
+```sh
+curl -k -u "<user>:<password>" -H "Content-type: application/json" -d '{"rack_aware": false}' -X PUT "https://localhost:9443/v1/bdbs/<bdb_uid>"
+```
+
+After the resharding process is complete, you can re-enable rack awareness:
+
+```sh
+curl -k -u "<user>:<password>" -H "Content-type: application/json" -d '{"rack_aware": true}' -X PUT "https://localhost:9443/v1/bdbs/<bdb_uid>"
+```
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+### Upgrade limitations
+
+Before you upgrade a cluster that hosts Active-Active databases with modules to v6.4.2-30, perform the following steps:
+
+1. Use `crdb-cli` to verify that the modules (`modules`) and their versions (in `module_list`) are as they appear in the database configuration and in the default database configuration:
+
+    ```sh
+    crdb-cli crdb get --crdb-guid <crdb-guid>
+    ```
+
+1. From the admin console's **redis modules** tab, validate that these modules with their specific versions are loaded to the cluster.
+
+1. If one or more of the modules/versions are missing or if you need help, [contact Redis support](https://redis.com/company/support/) before taking additional steps.
+
+This limitation has been fixed and resolved as of [v6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+### Operating system limitations
+
+#### RHEL 7 and RHEL 8
+
+RS95344 - CRDB database will not start on Redis Enterprise v6.4.2 with a custom installation path.
+
+For a workaround, use the following commands to add the relevant CRDB files to the Redis library:
+
+```sh
+$ yum install -y chrpath
+$ find $installdir -name "crdt.so" | xargs -n1 -I {} /bin/bash -c 'chrpath -r ${libdir} {}'
+```
+
+This limitation has been fixed and resolved as of [v6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}).
+
+#### RHEL 8
+
+Due to module binary differences between RHEL 7 and RHEL 8, you cannot upgrade RHEL 7 clusters to RHEL 8 when they host databases using modules. Instead, you need to create a new cluster on RHEL 8 and then migrate existing data from your RHEL 7 cluster. This does not apply to clusters that do not use modules.
+
+#### Ubuntu 20.04
+
+By default, you cannot use the SHA1 hash algorithm ([OpenSSL’s default security level is set to 2](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes)). The operating system will reject SHA1 certificates even if the `mtls_allow_weak_hashing` option is enabled. You need to replace SHA1 certificates with newer certificates that use SHA-256. Note that the certificates provided with Redis Enterprise Software use SHA-256.  
+
+#### Modules not supported for Amazon Linux 2 release candidate
+
+A database with modules cannot reside on an Amazon Linux 2 (release candidate) node. Support was added as part of [v6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+---
+Title: Redis Enterprise Software release notes 6.4.2-103 (October 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.10
+description: RHEL 8.8 support. RediSearch v2.6.12. RedisGraph v2.10.12. RedisTimeSeries
+  v1.8.11 Log when CCS schema changes. Bug fixes.
+linkTitle: 6.4.2-103 (October 2023)
+weight: 66
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- RHEL 8.8 support
+
+- RediSearch v2.6.12, RedisGraph v2.10.12, and RedisTimeSeries v1.8.11
+
+- Log when CCS schema changes
+
+- Bug fixes
+
+## New in this release
+
+### Enhancements
+
+- RHEL 8.8 support
+
+- Log when CCS schema changes due to schema upgrade
+
+#### Redis modules
+
+Redis Enterprise Software version 6.4.2-103 includes the following Redis Stack modules:
+
+- [RediSearch v2.6.12]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes" >}})
+
+- [RedisJSON v2.4.7]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes" >}})
+
+- [RedisBloom v2.4.5]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes" >}})
+
+- [RedisGraph v2.10.12]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes" >}})
+
+- [RedisTimeSeries v1.8.11]({{< relref "operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes" >}})
+
+### Resolved issues
+
+- RS109744 - Fixed an issue where node removal sometimes got stuck in a `starting` state when `wait_for_persistence` was enabled.
+
+- RS76441 - For databases created before Redis Enterprise Software v6.0.20, `crdt_syncer_auto_oom_unlatch` was `EMPTY` and `disabled` by default. `crdt_syncer_auto_oom_unlatch` is now enabled by default for new databases.
+
+## Version changes 
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|--------|--------|--------|--------|-------|
+| **Release date** | Aug<br />2023 | Feb<br />2023 | Sept<br />2022 | Aug<br />2022 | Feb<br />2022 | Oct<br />2021 | Aug<br />2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | – | Feb<br />2025 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 |
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 8.8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[8](#table-note-8)</sup> | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require OpenSSL 1.0.2 and [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+8. <a name="table-note-8" style="display: block; height: 80px; margin-top: -80px;"></a>Redis Enterprise Software [6.4.2-103]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-103" >}}) and later supports RHEL 8.8.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (6.4.2-103 October release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 6544fd5d1625ab9da7b0d99f195fe4f1 |
+| Ubuntu 20 | d623c8458a28f09a1e6ae0c0a8650023 |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | 06cc49ddbf560c516c52ae721c2806cd |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 2d799af5ee03c0a94660a60cd99ea361 |
+| Amazon Linux 2 | f2c5c2b5e879b8fd6792336f757593e2 |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+
+Redis Enterprise 6.4.2-103 supports open source Redis 6.2 and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Software release notes 7.8.2-60 (December 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Bug fixes, including a fix for a RHEL 8 OpenSSL dependency issue that caused frequent restarts of the `cm_server` and prevented access to the Redis Software Cluster Manager UI after upgrading to Redis Software version 7.8.2-34.
+linkTitle: 7.8.2-60 (December 2024)
+weight: 89
+aliases: /operate/rs/release-notes/rs-7-8-releases/rs-7-8-2-tba/
+---
+
+This is a maintenance release for ​[​Redis Software version 7.8.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Bug fixes, including a fix for a RHEL 8 OpenSSL dependency issue that caused frequent restarts of the `cm_server` and prevented access to the Redis Software Cluster Manager UI after upgrading to Redis Software version 7.8.2-34.
+
+## New in this release
+
+### Redis database versions
+
+Redis Software version 7.8.2 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS142899: Fixed a RHEL 8 OpenSSL dependency issue that caused frequent restarts of the `cm_server` and prevented access to the Cluster Manager UI after upgrading to Redis Software version 7.8.2-34.
+
+- RS126364: Fixed a memory leak in the DMC proxy process.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.2-60 Dec release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">c2913aaf2641273bd35ef3564b2e51b0911c3e3ef7b552735efd6372edc4425d</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">351b0bc249973d6fe93d3bb19f2dd1d2275128459e4542c052587341f883152f</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">361dad6fba36e5da3975ebf060d1ebe8bbb3839a2a22d11e98761667f497a6a2</span> |
+| Amazon Linux 2 | <span class="break-all">bad3f9cff028a51b71c666e73fe5a2fd81ab863cce69f418d55e75a5faa24aa9</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.2-60 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Software release notes 7.8.2-34 (November 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Redis Community Edition 7.4 features. Hash field expiration. Client-side caching support. Metrics stream engine preview. New APIs to check database availability, rebalance shards, fail over shards, and control database traffic. Cluster Manager UI enhancements for node actions, database tags, and database configuration. User manager role. Log rotation based on both size and time. Module management enhancements. Configurable minimum password length. Configurable license expiration alert threshold.
+linkTitle: 7.8.2-34 (November 2024)
+weight: 90
+---
+
+​[​Redis Software version 7.8.2](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+
+- Redis Community Edition 7.4 features
+
+- Hash field expiration
+
+- Client-side caching support
+
+- Metrics stream engine preview
+
+- New APIs to check database availability, rebalance shards, fail over shards, and control database traffic
+
+- Cluster Manager UI enhancements for node actions, database tags, and database configuration
+
+- User manager role
+
+- Log rotation based on both size and time
+
+- Module management enhancements
+
+- Configurable minimum password length
+
+- Configurable license expiration alert threshold
+
+## New in this release
+
+### New features
+
+- Redis Community Edition and Redis Stack 7.4 features are now available when you [create]({{<relref "/operate/rs/databases/create">}}) or [upgrade]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-database">}}) a database with database version 7.4, including:
+
+    - [Hash field expiration]({{<relref "/develop/data-types/hashes#field-expiration">}})
+    
+    - New vector data types to reduce ‌memory usage
+    
+    - Time series insertion filters
+
+    - See the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74/) and [Redis Community Edition 7.4 release notes]({{<relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisce/redisce-7.4-release-notes.md">}}) for details.
+
+- Client-side caching support:
+
+    - Client-side caching allows Redis clients to store a subset of data in a local cache and avoid sending repeated read requests to the Redis database.
+    
+    - When used to cache frequently accessed data, this technique can improve performance by decreasing network traffic, latency, and load on the database.
+
+    - Supported for Redis databases with Redis versions 7.4 and later.
+    
+    - For more information, see the [client-side caching introduction]({{<relref "/develop/clients/client-side-caching">}}) and [client-side caching compatibility with Redis Software]({{<relref "/operate/rs/references/compatibility/client-side-caching">}}).
+
+- Database availability API:
+
+    - Verifies whether a Redis Software database is available to perform read and write operations and can respond to queries from client applications. 
+
+    - Load balancers and automated monitoring tools can use this API to monitor database availability.
+
+    - See [Check database availability]({{<relref "/operate/rs/monitoring/db-availability">}}) and the [REST API reference]({{<relref "/operate/rs/references/rest-api/requests/bdbs/availability">}}) for details.
+
+- Metrics stream engine preview:
+
+    - The new metrics stream engine's exporter-based infrastructure provides access to more accurate, real-time data. This enhanced, scalable monitoring system allows you to set up more effective alerts and respond to issues faster.
+
+    - Exposes a new `/v2` Prometheus scraping endpoint that you can use to export metrics to external monitoring tools such as Grafana, DataDog, NewRelic, and Dynatrace.
+
+    - Exports raw data instead of aggregated data to improve monitoring at scale and accuracy compared to v1 Prometheus metrics.
+
+    - For an initial list of metrics exported by the new metrics stream engine, see [Prometheus metrics v2]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions">}}). While the metrics stream engine is in preview, this document provides only a partial list. More metrics will be added.
+
+    - V1 Prometheus metrics are deprecated but still available. To transition to the new metrics stream engine, either migrate your existing dashboards using [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2">}}) now, or wait to use new preconfigured dashboards when they become available in a future release.
+
+    - The new metrics stream engine resolved some known issues and bugs:
+
+        - RS31923: Added missing types to Prometheus metrics.
+
+        - RS80626: Added DMC thread utilization metrics to the metrics exporter.
+
+        - RS113028: Upgraded the node exporter dependency to version 1.7.0.
+
+        - RS103537: Fixed an issue with missing indications when a node went down. You can see the node's metrics up until it went down and can monitor `node_metrics_up` to get an indication that it is down.
+
+        - RS103251: Metrics are now available during state machine operations.
+
+        - RS74732: Fixed an issue where a replica CRDB's stats were missing after removing and then re-adding the replica CRDB instance.
+
+        - RS65948: Fixed an issue where the metrics exporter generated duplicate stats headers when the cluster had both regular databases and Active-Active databases.
+
+- [Rebalance shard placement REST API request]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/rebalance">}}), which distributes the database's shards across nodes based on the database's shard placement policy. See [Shard placement policy]({{<relref "/operate/rs/databases/memory-performance/shard-placement-policy">}}) for more information about shard placement and available policies.
+
+- [Shard failover REST API requests]({{<relref "/operate/rs/references/rest-api/requests/shards/actions/failover">}}), which perform failover on specified primary shards and promotes their replicas to primary shards.
+
+- REST API requests to [stop traffic]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/stop_traffic">}}) or [resume traffic]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/resume_traffic">}}) to a database.
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - Perform node actions from the **Nodes** screen to [verify nodes]({{<relref "/operate/rs/clusters/add-node#verify-node">}}), [set a node as primary or secondary]({{<relref "/operate/rs/clusters/change-node-role">}}), [remove nodes]({{<relref "/operate/rs/clusters/remove-node">}}), and manage node alert settings.
+
+    - Categorize databases with [custom tags]({{<relref "/operate/rs/databases/configure/db-tags">}}). When you add new tags to a database, the keys and values already used by existing tags will appear as suggestions.
+
+    - Moved several settings on the database configuration screen:
+    
+        - The eviction setting now appears in the [**Capacity**]({{<relref "/operate/rs/databases/configure#capacity">}}) section.
+
+        - [**High availability**]({{<relref "/operate/rs/databases/configure#high-availability">}}) and [**Durability**]({{<relref "/operate/rs/databases/configure#durability">}}) have separate sections.
+
+    - Improved error messages on the sign-in screen for locked out users versus incorrect or expired passwords.
+
+    - Flush an Active-Active database.
+
+- A new **User Manager** role designed for user administration is available for [role-based access control]({{<relref "/operate/rs/security/access-control">}}).
+
+    - This management role allows assigned users to create, edit, and delete users using the Cluster Manager UI and REST API.
+
+    - For more details about the privileges granted by the **User Manager** role, see [Cluster Manager UI permissions]({{<relref "/operate/rs/security/access-control/create-cluster-roles#cluster-manager-ui-permissions">}}) and [REST API permissions]({{<relref "/operate/rs/references/rest-api/permissions#user-manager-role">}}).
+
+- When you upgrade a database, the upgrade process also attempts to upgrade database modules by default.
+
+    - [`rladmin upgrade db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db">}}) will always upgrade the database's modules.
+
+    - If you [upgrade a database]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) using the REST API, you can set `"latest_with_modules": false` in the request body to prevent module upgrades.
+
+- Added support for [log rotation]({{<relref "/operate/rs/clusters/logging/log-security#log-rotation">}}) based on both size and time.
+
+- [Minimum password length]({{<relref "/operate/rs/security/access-control/manage-passwords/password-complexity-rules#change-minimum-password-length">}}), previously hardcoded as 8 characters, is now configurable in the Cluster Manager UI and the REST API.
+
+- The [cluster license expiration alert threshold]({{<relref "/operate/rs/clusters/configure/license-keys#configure-license-expiration-alert">}}), which determines how far in advance you want to be notified of the license expiration, is configurable in the Cluster Manager UI and the REST API.
+
+- The Cluster Manager UI's time zone can be configured with an [update CM settings REST API request]({{<relref "/operate/rs/references/rest-api/requests/cm_settings#put-cm-settings">}}).
+
+- Timeouts for raising connection alarms can be configured with an [update database configuration REST API request]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}):
+
+    - `crdt_sync_connection_alarm_timeout_seconds`: if the syncer takes longer than the specified number of seconds to connect to an Active-Active database, raise a connection alarm.
+
+    - `replica_sync_connection_alarm_timeout_seconds`: if the syncer takes longer than the specified number of seconds to connect to a replica, raise a connection alarm.
+
+- Reserved the following ports:
+
+    | Port | Process name | Usage | 
+    |------|--------------|-------|
+    | 3347 | cert_exporter | Reports cluster certificate metrics |
+    | 3348 | process_exporter | Reports process metrics for DMC and Redis processes |
+    | 3349 | cluster_wd_exporter | Reports cluster watchdog metrics |
+    | 3350 | db_controller | Internode communication |
+    | 9091 | node_exporter | Reports host node metrics related to CPU, memory, disk, and more |
+    | 9125 | statsd_exporter | Reports push metrics related to the DMC and syncer, and some cluster and node metrics |
+
+### Redis database versions
+
+Redis Software version 7.8.2 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS123645: Fixed inconsistent behavior for shard creation when you enable sharding. Now, when creating a database with sharding enabled, you must always provide a `shard_key_regex`.
+
+- RS130444: Fixed an issue that prevented creating or editing users without an email address in the Cluster Manager UI.
+
+- RS121796: The "multiple endpoint" configuration database default setting should also enable sharding when selected.
+
+- RS128768: Fixed an issue that prevented metric graph timestamp details from displaying in the Cluster Manager UI.
+
+- RS127120: Fixed an issue where `crdt_replicas` were not properly updated when flushing an Active-Active database.
+
+- RS127054: Fixed an issue where the install script incorrectly reported "Port 53 is occupied" instead of the correct value of the occupied port.
+
+- RS125934: Fixed validation that prevented updating the Active-Active database configuration if existing TLS certificates expired.
+
+- RS125412: Fixed an issue where deleted external IP addresses were still listed as available during node configuration when joining a cluster.
+
+- RS122012: Fixed an issue that sent a cutoff email message for long-running alerts.
+
+- RS121726: Block the `remove_shards` option for `rlutil`. You can use Replica Of to decrease the shard count instead.
+
+- RS121076: Added a 5-minute connection timeout when promoting a replica shard to a primary role.
+
+- RS118103: Removed the inaccurate shard `BACKUP_PROGRESS` column from the `rladmin status` command's output.
+
+- RS116990: Fixed an issue with flash-enabled databases where `FLUSHDB` could cause shard crashes in versions 7.0 and 7.2, and cause clients to stop responding in earlier versions.
+
+- RS114923: Fixed an issue where the legacy RDB parser could generate an `XGROUP CREATE` command with an incorrect `ENTRIESREAD` value when syncing a source RDB to a database with Redis version 7.0 or later.
+
+- RS114258: Fixed an issue where an Active-Active database instance could lose keys during partial syncing if the destination shard was stale.
+
+- RS133653: Fixed a validation issue where expired client certificates prevented updates to database configuration unrelated to TLS.
+
+- RS126235: Fixed an issue where database updates could time out and enter a change pending state due to outdated shard data.
+
+- RS125128: Improved real-time logging for installation and upgrade for better visibility.
+
+- RS119958: Removed the log file limit that caused the debuginfo script to fail with the error "/bin/tar: Argument list too long" in Auto Tiering clusters and improved RocksDB log file rotation.
+
+- RS137396: Providing an email address is no longer mandatory when creating new ACL users in the Cluster Manager UI.
+
+- RS134238: Improved database sorting performance in the Cluster Manager UI.
+
+- RS129418: Improved log rotation mechanism for Auto Tiering clusters to reduce excessive logs.
+
+- RS137231: Fixed an issue where database shards could become stuck during migration due to outdated node data.
+
+## Version changes
+
+- Added validation to verify the LDAP server URI contains a host and port when updating LDAP configuration.
+
+- The value of the `oss_sharding` API field had no effect in previous versions of Redis Software. However, `oss_sharding` is now set to take effect as part of future plans. Until further notice, set this field to `false` to avoid unintended impacts.
+
+### Breaking changes
+
+Redis Software version 7.8.2 introduces the following breaking changes:
+
+- When you upgrade a database, the upgrade process also attempts to upgrade database modules by default.
+
+    - The default value of `latest_with_modules` has changed to `true`.
+
+    - [`rladmin upgrade db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db">}}) will always upgrade the database's modules.
+
+    - When you [upgrade a database]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) using the REST API, you can set `"latest_with_modules": false` in the request body to prevent module upgrades.
+
+### Redis database version 7.4 breaking changes {#redis-74-breaking-changes}
+
+When new major 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 Software and update any applications that connect to your database to handle these changes.
+
+Confirm your Redis database version (`redis_version`) using the Cluster Manager UI or run the following [`INFO`]({{< relref "/commands/info" >}}) command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+#### Security behavior changes
+
+- [#13108](https://github.com/redis/redis/pull/13108) Lua: LRU eviction for scripts generated with `EVAL`. 
+
+#### Other general behavior changes
+
+- [#13133](https://github.com/redis/redis/pull/13133) Lua: allocate VM code with jemalloc instead of libc and count it as used memory.
+
+- [#12171](https://github.com/redis/redis/pull/12171) `ACL LOAD`: do not disconnect all clients.
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+### Deprecations
+
+#### API deprecations
+
+- Deprecated `background_op` field from BDB REST API object. Use [`GET /v1/actions/bdb/<bdb_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions/bdb">}}) instead.
+
+- Deprecated the following fields for [upgrade database]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade">}}) REST API requests:
+
+    - `keep_redis_version`; use `redis_version` instead
+
+    - `current_module`; use `new_module_args` instead
+
+    - `new_module`; use `new_module_args` instead
+
+- Deprecated the following `module_list` fields for [create database]({{<relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1">}}) REST API requests:
+
+    - `module_id`; use `module_name` instead
+
+    - `semantic_version`; use module_args instead
+
+- `min_redis_version` is only relevant to Redis database versions earlier than 7.4 and is replaced with `compatible_redis_version` in [module REST API]({{<relref "/operate/rs/references/rest-api/requests/modules">}}) responses.
+
+- Deprecated the [`rladmin upgrade modules`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-module">}}) command. Use [`rladmin upgrade db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db">}}) instead.
+
+- Deprecated [`POST /v1/modules/upgrade/bdb/<uid>`]({{<relref "/operate/rs/references/rest-api/requests/modules/upgrade#post-modules-upgrade-bdb">}}) REST API request. Use [`POST /v1/bdbs/<uid>/upgrade`]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) to upgrade modules instead.
+
+#### V1 Prometheus metrics deprecation
+
+ V1 Prometheus metrics are deprecated but still available. To transition to the new metrics stream engine, either migrate your existing dashboards using [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2">}}) now, or wait to use new preconfigured dashboards when they become available in a future release.
+
+#### Download center modules deprecation
+
+New Redis modules will not be available for download from the Redis download center.
+
+#### Legacy UI not supported
+
+The legacy UI was deprecated in favor of the new Cluster Manager UI in Redis Software version 7.2.4 and is no longer supported as of Redis Software version 7.8.2.
+
+#### Redis 6.0 databases not supported
+
+Redis database version 6.0 was deprecated in Redis Software version 7.4.2 and is no longer supported as of Redis Software version 7.8.2.
+
+To prepare for the removal of Redis database version 6.0 before you upgrade to Redis Software version 7.8.2:
+
+- For Redis Software 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Software 7.2.4 and 7.4.2 clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### Ubuntu 18.04 not supported
+
+Ubuntu 18.04 was deprecated in Redis Software version 7.2.4 and is no longer supported as of Redis Software version 7.8.2.
+
+### Upcoming changes
+
+#### Default image change for Redis Software containers
+
+Starting with version 7.8, Redis Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.2-34 Nov release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">17500356d8338e4f8fd8a37e7b39a190d05ca66d35ae6c4aa3aa8cbc7bb99864</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">caa2ccd24749ae1fb904841df50a8b69b69c74441458649ca49b9b617e286191</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">31f9d07beb7dfd9239083ecad99ecbfe3cdfcf96673881ebed08171d8194bff3</span> |
+| Amazon Linux 2 | <span class="break-all">a737ca86d800caf9ca266d5771fbcffd3f973a7fb8e63e7b819681322ff6ed67</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.2-34 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Enterprise Software release notes 7.8.6-60 (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Bug fixes for an LDAP connection issue caused by setting LDAP bind credentials that include `<` in the Cluster Manager UI and an issue where migrated shards can appear stuck on multiple nodes. Deprecated required_version in the bootstrap cluster API.
+linkTitle: 7.8.6-60 (April 2025)
+weight: 83
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.8.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Bug fixes for an LDAP connection issue caused by setting LDAP bind credentials that include `<` in the Cluster Manager UI and an issue where migrated shards can appear stuck on multiple nodes.
+
+## New in this release
+
+### Redis database versions
+
+Redis Software version 7.8.6 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS155783: Fixed an issue where using the special character `<` when setting LDAP bind credentials in the Cluster Manager UI caused LDAP connection failures.
+
+- RS144215: Fixed an issue where a shard's status might not update correctly after migration, causing it to appear stuck on multiple nodes even if the migration completed successfully.
+
+## Version changes
+
+### Deprecations
+
+#### API deprecations
+
+- Deprecated the `required_version` option for the bootstrap cluster API.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.6-60 April release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">490a54371f3f958991079bec5a350297d62c12f5820fceb821fe0caf7a33945e</span> |
+| Ubuntu 22 | <span class="break-all">e28c4c59771078ce5cc16043e676f24b37428174bc927f69e44eb688e861ebd1</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">2315099f7c41a0113dd2e4de8914c264366018140f42645b874560ccc04c60c3</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">a76e61d02bc5b1d86afe0cd97939a762ce2e9f91d10b70f6f6dbe34efe4cc81d</span> |
+| Amazon Linux 2 | <span class="break-all">6c8d2b3266ff99b4acef7632555e9cd44d7642f6d2cd703143c5ae7106677107</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.6-60 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.4.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Enterprise Software release notes 7.8.6-36 (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Bug fixes, including a fix for an issue where new workers might use an outdated certificate after a certificate update.
+linkTitle: 7.8.6-36 (April 2025)
+weight: 84
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.8.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Bug fixes, including a fix for an issue where new workers might use an outdated certificate after a certificate update.
+
+## New in this release
+
+### Redis database versions
+
+Redis Software version 7.8.6 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS154601: Fixed an issue where new workers created after the proxy certificate was updated might use the old certificate.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.6-36 April release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">876dff68a00333f868a758a5abd23be509bcb1065c1a32c05260ace20ef72199</span> |
+| Ubuntu 22 | <span class="break-all">180ea7d0ef9e8e313ff7d3f4f38b9f3049baa15cc6a62f929f524fe7403aac11</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">66138bd6d19f264b29d04718383542b0141eb5b9f6ffebbf1c5890a3dd51e078</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">869bd603cf8d4b6ac991a5c34c460c2c8f11af55a53508afbf621a67917c11f3</span> |
+| Amazon Linux 2 | <span class="break-all">2622c195c80ee41c625f45f703cf2fa48202d3325330aba1d90645ad6f232b27</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.6-36 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.4.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Software release notes 7.8.4-95 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Bug fixes for server restart failures during upgrades, connectivity checks for optional services, swapped shard status and watchdog status values in `rladmin`, process exporter crashes, and a syncer issue for Active-Active databases that have the OSS Cluster API enabled.
+linkTitle: 7.8.4-95 (March 2025)
+weight: 86
+---
+
+This is a maintenance release for ​[​Redis Software version 7.8.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Bug fixes for server restart failures during upgrades, connectivity checks for optional services, swapped shard status and watchdog status values in `rladmin`, process exporter crashes, and a syncer issue for Active-Active databases that have the OSS Cluster API enabled
+
+## New in this release
+
+### Redis database versions
+
+Redis Software version 7.8.4 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS134225: Fixed an issue where the server restart could fail during cluster upgrade due to a timeout.
+
+- RS138625: Fixed an issue where `rlcheck` reported `verify_tcp_connectivity` as failed for optional services that were not enabled instead of skipping the checks.
+
+- RS146525: Fixed an `rladmin status` issue that swapped the shard `STATUS` and `WATCHDOG_STATUS` values.
+
+- RS143339: Fixed an issue where an ambiguous path could cause the process exporter to crash with the error: "`flag provided but not defined: -remove-empty-groups`".
+
+- RS150588: Fixed a syncer issue that could cause data inconsistency or loss in Active-Active databases when the OSS Cluster API is enabled.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.4-95 March release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">f7b98686e0b0a6dd72cef0c59b0d5a6126e716251e8606df2e0296e714e89854</span> |
+| Ubuntu 22 | <span class="break-all">b2bda6ed49edcae32cac5bf67dcdcc3fc1baca47945b3c0a9e7c5a11bee4839f</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">cecaa7aa9db1a2b93b91389bd7b5958af26d2cfb5c4fc5d393dbc83370156aad</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">8f62996176ba58a073b66c0623f3a280c7fe0f25358d727df375021354d4464f</span> |
+| Amazon Linux 2 | <span class="break-all">baea0cdada0ac42d38035b8ca826eabc2077256e2633b8cea5ff5010ff0ac53d</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.4-95 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.4.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Software release notes 7.8.4-66 (February 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Ubuntu 22 support. Bug fixes for crashes, unexpected restarts, and incorrect type for the automatically calculated replica buffer.
+linkTitle: 7.8.4-66 (February 2025)
+weight: 87
+---
+
+This is a maintenance release for ​[​Redis Software version 7.8.4](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Ubuntu 22 support
+
+- Bug fixes for crashes, unexpected restarts, and incorrect type for the automatically calculated replica buffer
+
+## New in this release
+
+### New features
+
+- Added support for Ubuntu 22. See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+### Redis database versions
+
+Redis Software version 7.8.4 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS146125: Fixed an issue with the CCS cached context that could cause crashes.
+
+- RS145856: Fixed the automatically calculated replica buffer's type from float to integer.
+
+- RS146282: Fixed a missing Prisma dependency for OpenSSL 1.0 that caused unexpected `cm_server` restarts on Ubuntu 20.
+
+- RS103760: Added a check that blocks upgrading Redis Software on a node while there are running state machines to prevent data loss or unavailability.
+
+- RS148302: Fixed a dependency issue that can cause the installation of Redis Software version 7.8.4 to fail.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.4-66 Feb release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">5b14894713d118688a9b21d63edd5208cd6b0d5a2a035ecd67589d33d5ddfbbb</span> |
+| Ubuntu 22 | <span class="break-all">fb4dda7c75c6ded114073edd0632257cc56c52e92ce1e8d286070d5adc593431</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">1d6b0579c6af5e57e045b051bd0026638ac0eb224266b19a8d4be1e1135d05ea</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">fa74e1864eb72aafe6428ee3aa7bc0fb491b637d4bdf11be785f67fbca7130e6</span> |
+| Amazon Linux 2 | <span class="break-all">748268cb234d828c0dc1542ac0e0d4ff74363a2008ee473c08abe1d949bc850d</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.4-66 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Enterprise Software release notes 7.8.6-13 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Configurable hashing algorithm for user passwords. Dry run option to validate REST API requests for users and roles.
+linkTitle: 7.8.6-13 (March 2025)
+weight: 85
+---
+
+​[​Redis Enterprise Software version 7.8.6](https://redis.io/downloads/#software) is now available! This release includes API enhancements that warranted a new minor version instead of a maintenance release for version 7.8.4. However, you can upgrade from 7.8.2 or 7.8.4 to 7.8.6 without issue.
+
+## Highlights
+
+This version offers:
+
+- Configurable hashing algorithm for user passwords
+
+- Dry run option to validate REST API requests for users and roles
+
+## New in this release
+
+### New features
+
+- The hashing algorithm for user passwords is now configurable using [`rladmin`]({{<relref "/operate/rs/references/cli-utilities/rladmin">}}) or the [REST API]({{<relref "/operate/rs/references/rest-api">}}). When you [change the hashing algorithm]({{<relref "/operate/rs/security/access-control/manage-passwords/password-hashing-algorithm">}}), it rehashes the administrator password and passwords for all users, including default users.
+
+    The hashing algorithm options are `SHA-256` or `PBKDF2`. The default hashing algorithm is `SHA-256`.
+
+    To change the password hashing algorithm, use one of the following methods:
+
+    - [`rladmin cluster change_password_hashing_algorithm`]({{<relref "/operate/rs/references/cli-utilities/rladmin/cluster/change_password_hashing_algorithm">}}):
+
+        ```sh
+        rladmin cluster change_password_hashing_algorithm PBKDF2
+        ```
+
+    - [Change password hashing algorithm REST API request]({{<relref "/operate/rs/references/rest-api/requests/cluster/change_password_hashing_algorithm#patch-change-password-hashing-algorithm">}}):
+
+        ```sh
+        PATCH /v1/cluster/change_password_hashing_algorithm
+        { "algorithm": "PBKDF2" }
+        ```
+
+### Enhancements
+
+- If you create or update users or roles using the [REST API]({{<relref "/operate/rs/references/rest-api">}}), you can use the `dry_run` query parameter to validate the request without actually applying the update.
+
+    - [Create role]({{<relref "/operate/rs/references/rest-api/requests/roles#post-role">}}) example request:
+
+        ```sh
+        POST /v1/roles?dry_run
+        ```
+
+    - [Update role]({{<relref "/operate/rs/references/rest-api/requests/roles#put-role">}}) example request: 
+
+        ```sh
+        PUT /v1/roles/<uid>?dry_run
+        ```
+
+    - [Create user]({{<relref "/operate/rs/references/rest-api/requests/users#post-user">}}) example request:
+
+        ```sh
+        POST /v1/users?dry_run
+        ```
+
+    - [Update user]({{<relref "/operate/rs/references/rest-api/requests/users#put-user">}}) example request: 
+
+        ```sh
+        PUT /v1/users/<uid>?dry_run
+        ```
+
+### Redis database versions
+
+Redis Software version 7.8.6 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS147991: Fixed an issue where the creation of too many Replica Of workers could cause the DMC proxy to restart repeatedly.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.6-13 March release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">8fa5336a6b487f4082353f7abad924a86b4ce2719e700ea0c8766718a2066020</span> |
+| Ubuntu 22 | <span class="break-all">0013ad5d97b3480b9d8237ec22f15d0aa7d08f3caa75312e5d2597583229b2fa</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">e66cc1661540028f941189e41a17a32b17797c82abf90237f7da9491ea20a1c0</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">d588491fa96cc652aa92d43902efa490a90fbfe8967c649ea54284c7986f37bd</span> |
+| Amazon Linux 2 | <span class="break-all">baea0cdada0ac42d38035b8ca826eabc2077256e2633b8cea5ff5010ff0ac53d</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.6-13 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.4.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Software release notes 7.8.4-18 (December 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Certificate-based authentication for the REST API. Dry run option to validate Redis ACL REST API requests.
+linkTitle: 7.8.4-18 (December 2024)
+weight: 88
+---
+
+​[​Redis Enterprise Software version 7.8.4](https://redis.io/downloads/#software) is now available! This release includes API enhancements that warranted a new minor version instead of a maintenance release for version 7.8.2. However, you can upgrade from 7.8.2 to 7.8.4 without issue.
+
+## Highlights
+
+This version offers:
+
+- Certificate-based authentication for the REST API
+
+- Dry run option to validate Redis ACL REST API requests
+
+## New in this release
+
+### New features
+
+- Certificate-based authentication for the REST API
+
+    - Added support for certificate-based authentication to enable secure, passwordless access to the Redis Software REST API.
+
+    - Certificate-based authentication can be used in addition to basic authentication with a username and password.
+
+    - To set up certificate-based authentication, use [REST API]({{<relref "/operate/rs/references/rest-api">}}) requests to do the following:
+
+        1. Configure a trusted CA certificate `mtls_trusted_ca` using an [update cluster certificate]({{<relref "/operate/rs/references/rest-api/requests/cluster/certificates#put-cluster-update_cert">}}) request:
+
+            ```sh
+            PUT /v1/cluster/update_cert
+            {
+              "name": "mtls_trusted_ca",
+              "certificate": "<content of certificate PEM file>"
+            }
+            ```
+
+        1. [Update cluster settings]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) with mutual TLS configuration:
+
+            ```sh
+            PUT /v1/cluster
+            {
+              "mtls_certificate_authentication": true,
+              "mtls_client_cert_subject_validation_type": "san_cn",
+              "mtls_authorized_subjects": [{
+                "CN": "test",
+                "OU": [],
+                "O": "",
+                "C": "",
+                "L": "",
+                "ST": ""
+              }]
+            }
+            ```
+
+        1. Include `"auth_method": "certificate"` and `certificate_subject_line` in the request body when you [create new users]({{<relref "/operate/rs/references/rest-api/requests/users#post-user">}}) or [update existing users]({{<relref "/operate/rs/references/rest-api/requests/users#put-user">}}):
+
+            ```sh
+            POST /v1/users | PUT /v1/users/<user-id>
+            {
+              "auth_method": "certificate",
+              "certificate_subject_line": "<subject of the user's client certificate>"
+            }
+            ```
+
+    - Limitations: 
+
+        - Certificate-based authentication is not implemented for the Cluster Manager UI.
+
+### Enhancements
+
+- If you create or update a Redis ACL using the REST API, you can use the `dry_run` query parameter to validate the request without actually applying the update.
+
+    - [Create Redis ACL]({{<relref "/operate/rs/references/rest-api/requests/redis_acls#post-redis_acl">}}) example request:
+
+        ```sh
+        POST /v1/redis_acls?dry_run
+        ```
+
+    - [Update Redis ACL]({{<relref "/operate/rs/references/rest-api/requests/redis_acls#put-redis_acl">}}) example request: 
+
+        ```sh
+        PUT /v1/redis_acls/<uid>?dry_run
+        ```
+
+### Redis database versions
+
+Redis Software version 7.8.4 includes three Redis database versions: 7.4, 7.2, and 6.2.
+
+The [default Redis database version]({{<relref "/operate/rs/databases/configure/db-defaults#database-version">}}) is 7.4.
+
+### Redis module feature sets
+
+Redis Software comes packaged with several modules. As of version 7.8.2, Redis Software includes three feature sets, compatible with different Redis database versions.
+
+The following table shows which Redis modules are compatible with each Redis database version included in this release.
+
+| Redis database version | Compatible Redis modules |
+|------------------------|--------------------------|
+| 7.4 | [RediSearch 2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.10-release-notes.md" >}})<br />[RedisJSON 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.8-release-notes.md" >}})<br />[RedisTimeSeries 1.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.12-release-notes.md" >}})<br />[RedisBloom 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.8-release-notes.md" >}}) |
+| 7.2 | [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})<br />[RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})<br />[RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})<br />[RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) |
+| 6.2 | [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})<br />[RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})<br />[RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})<br />[RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})<br />[RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})<sup>[1](#module-note-1)</sup>  |
+
+1. <a name="module-note-1"></a>RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS137337: Maintenance mode tasks are no longer incorrectly marked as `aborted` when the primary node is demoted.
+
+- RS125921: Fixed a PDNS server script to ensure the symbolic links are not expanded.
+
+- RS142457: Fixed an issue in the Cluster Manager UI where incorrect FQDN information was shown for Active-Active databases in Kubernetes.
+
+- RS134410: Removed dependency test files that contain TLS keys from the Python install for Kubernetes.
+
+- RS136270: Changed the owner and group of the `rlec_supervisor.service` file to `root:root` instead of `redislabs:redislabs` to improve security.
+
+- RS142166: Fixed the representation of available RAM.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.8.4-18 Dec release) |
+|---------|---------------------------------------|
+| Ubuntu 20 | <span class="break-all">1aee0b6cee72b6ceae73951611ac2073d8905189174c731561f1228c16cbcc3a</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">cceb563d56221d391667dd302ac334b5d98e3a8dc59bc479a79fe9b83c1634d6</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">396b2eeafe9b4a75aa8579b4d618ca7f2df8619b1256aeec7863c80ecba7703a</span> |
+| Amazon Linux 2 | <span class="break-all">56e18f73fb8507fec476d9b59a00ed1b5fcc52b80005a749b869650641e6f6f6</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Software has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Software due to different or additional functionality available in Redis Software that is not available in open source Redis.
+
+Redis Software 7.8.4-18 supports open source Redis 7.4, 7.2, and 6.2. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+---
+Title: Redis Software release notes 7.8.x
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.4.0
+description: Redis Community Edition 7.4 features. Hash field expiration. Client-side caching support. Metrics stream engine preview. New APIs to check database availability, rebalance shards, fail over shards, and control database traffic. Cluster Manager UI enhancements for node actions, database tags, and database configuration. User manager role. Log rotation based on both size and time. Module management enhancements. Configurable minimum password length. Configurable license expiration alert threshold.
+hideListLinks: true
+linkTitle: 7.8.x releases
+toc: 'true'
+weight: 69
+---
+
+​[​Redis Software version 7.8](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+
+- Redis Community Edition 7.4 features
+
+- Hash field expiration
+
+- Client-side caching support
+
+- Metrics stream engine preview
+
+- New APIs to check database availability, rebalance shards, fail over shards, and control database traffic
+
+- Cluster Manager UI enhancements for node actions, database tags, and database configuration
+
+- User manager role
+
+- Log rotation based on both size and time
+
+- Module management enhancements
+
+- Configurable minimum password length
+
+- Configurable license expiration alert threshold
+
+## Detailed release notes
+
+For more detailed release notes, select a build version from the following table:
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,Redis Open Source compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+
+## Version changes
+
+- Added validation to verify the LDAP server URI contains a host and port when updating LDAP configuration.
+
+- The value of the `oss_sharding` API field had no effect in previous versions of Redis Software. However, `oss_sharding` is now set to take effect as part of future plans. Until further notice, set this field to `false` to avoid unintended impacts.
+
+### Breaking changes
+
+Redis Software version 7.8.2 introduces the following breaking changes:
+
+- When you upgrade a database, the upgrade process also attempts to upgrade database modules by default.
+
+    - The default value of `latest_with_modules` has changed to `true`.
+
+    - [`rladmin upgrade db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db">}}) will always upgrade the database's modules.
+
+    - When you [upgrade a database]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) using the REST API, you can set `"latest_with_modules": false` in the request body to prevent module upgrades.
+
+#### Redis database version 7.4 breaking changes {#redis-74-breaking-changes}
+
+When new major 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 Software and update any applications that connect to your database to handle these changes.
+
+Confirm your Redis database version (`redis_version`) using the Cluster Manager UI or run the following [`INFO`]({{< relref "/commands/info" >}}) command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+##### Security behavior changes
+
+- [#13108](https://github.com/redis/redis/pull/13108) Lua: LRU eviction for scripts generated with `EVAL`. 
+
+##### Other general behavior changes
+
+- [#13133](https://github.com/redis/redis/pull/13133) Lua: allocate VM code with jemalloc instead of libc and count it as used memory.
+
+- [#12171](https://github.com/redis/redis/pull/12171) `ACL LOAD`: do not disconnect all clients.
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+### Deprecations
+
+#### API deprecations
+
+- Deprecated `background_op` field from BDB REST API object. Use [`GET /v1/actions/bdb/<bdb_uid>`]({{<relref "/operate/rs/references/rest-api/requests/actions/bdb">}}) instead.
+
+- Deprecated the following fields for [upgrade database]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade">}}) REST API requests:
+
+    - `keep_redis_version`; use `redis_version` instead
+
+    - `current_module`; use `new_module_args` instead
+
+    - `new_module`; use `new_module_args` instead
+
+- Deprecated the following `module_list` fields for [create database]({{<relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1">}}) REST API requests:
+
+    - `module_id`; use `module_name` instead
+
+    - `semantic_version`; use module_args instead
+
+- `min_redis_version` is only relevant to Redis database versions earlier than 7.4 and is replaced with `compatible_redis_version` in [module REST API]({{<relref "/operate/rs/references/rest-api/requests/modules">}}) responses.
+
+- Deprecated the [`rladmin upgrade modules`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-module">}}) command. Use [`rladmin upgrade db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db">}}) instead.
+
+- Deprecated [`POST /v1/modules/upgrade/bdb/<uid>`]({{<relref "/operate/rs/references/rest-api/requests/modules/upgrade#post-modules-upgrade-bdb">}}) REST API request. Use [`POST /v1/bdbs/<uid>/upgrade`]({{<relref "/operate/rs/references/rest-api/requests/bdbs/upgrade#post-bdbs-upgrade">}}) to upgrade modules instead.
+
+- Deprecated the `required_version` option for the bootstrap cluster API.
+
+#### V1 Prometheus metrics deprecation
+
+ V1 Prometheus metrics are deprecated but still available. To transition to the new metrics stream engine, either migrate your existing dashboards using [Prometheus v1 metrics and equivalent v2 PromQL]({{<relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-v1-to-v2">}}) now, or wait to use new preconfigured dashboards when they become available in a future release.
+
+#### Download center modules deprecation
+
+New Redis modules will not be available for download from the Redis download center.
+
+#### Legacy UI not supported
+
+The legacy UI was deprecated in favor of the new Cluster Manager UI in Redis Software version 7.2.4 and is no longer supported as of Redis Software version 7.8.2.
+
+#### Redis 6.0 databases not supported
+
+Redis database version 6.0 was deprecated in Redis Software version 7.4.2 and is no longer supported as of Redis Software version 7.8.2.
+
+To prepare for the removal of Redis database version 6.0 before you upgrade to Redis Software version 7.8.2:
+
+- For Redis Software 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Software 7.2.4 and 7.4.2 clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### Ubuntu 18.04 not supported
+
+Ubuntu 18.04 was deprecated in Redis Software version 7.2.4 and is no longer supported as of Redis Software version 7.8.2.
+
+### Upcoming changes
+
+#### Default image change for Redis Software containers
+
+Starting with version 7.8, Redis Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+## Known limitations
+
+#### Upload modules before OS upgrade
+
+If the cluster contains any databases that use modules, you must upload module packages for the target OS version to a node in the existing cluster before you upgrade the cluster's operating system.
+
+See [Upgrade a cluster's operating system]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os">}}) for detailed upgrade instructions.
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Software cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached end-of-life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Query results might include hash keys with lazily expired fields
+
+If one or more fields of a hash key expire after an `FT.SEARCH` or `FT.AGGREGATE` query begins, Redis does not account for these lazily expired fields. As a result, keys with expired fields might still be included in the query results, leading to potentially incorrect or inconsistent results.
+---
+Title: Redis Enterprise Software release notes 6.2.12 (August 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 6.2.6
+description: OCSP Support.  Password & session configuration changes.  RHEL 8.6 support.
+linkTitle: 6.2.12 (August 2022)
+weight: 74
+---
+
+[Redis Enterprise Software version 6.2.12](https://redislabs.com/redis-enterprise-software/download-center/software/) is now available! 
+
+This version of Redis Enterprise Software offers:
+
+- OCSP stapling of the server proxy certificate
+- Password and session configuration settings via the admin console
+- Compatibility with open source Redis v6.2.6
+- Support for Red Hat Enterprise Linux (RHEL) v8.6
+- Additional enhancements and fixes
+
+The following table shows the MD5 checksums for the available packages.
+
+|Package| MD5 Checksum |
+|:------|:-------------|
+| Ubuntu 16 | `e702c906f200940e06ef031e6b8006d9` |
+| Ubuntu 18 | `7ea70067e8828b59336380df087fe03d` |
+| RedHat Enterprise Linux (RHEL) 7<br/>Oracle Enterprise Linux (OL) 7 | `8ffda6186f70354b9d10c1ce43938c3c` |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 | `334fe7979a7376b28fcf48913403bfb7` |
+
+## Features and enhancements
+
+- Server side OCSP Stapling
+
+    [Online Certificate Status Protocol](https://en.wikipedia.org/wiki/Online_Certificate_Status_Protocol) (OCSP) helps verify the status of certificates managed by a third-party [certificate authority](https://en.wikipedia.org/wiki/Certificate_authority) (CA).  It tells you whether certificates are valid, revoked, or unknown.
+
+    Redis Enterprise Software v6.2.12 implements OCSP stapling, which allows clients to validate the status of a server proxy certificate.  When OCSP is enabled, the Redis Enterprise server regularly polls the CA OCSP responder to determine a certificate's status.  The response is cached until the next polling attempt; the cached value is served to clients during the [TLS handshake](https://en.wikipedia.org/wiki/Transport_Layer_Security#TLS_handshake).
+
+    To learn more, see [Enable OCSP stapling]({{< relref "/operate/rs/security/certificates/ocsp-stapling" >}}). 
+
+- Session and security attributes in the admin console
+
+    You can now use the admin console to configure [password complexity rules]({{< relref "/operate/rs/security/access-control/manage-passwords" >}}#password-complexity-rules), [user login lockout]({{< relref "/operate/rs/security" >}}access-control/manage-users/login-lockout/#user-login-lockout), and [session timeout]({{< relref "/operate/rs/security" >}}access-control/manage-users/login-lockout/#session-timeout).  
+    
+- Mount point import enhancement
+
+    When importing data, Redis Enterprise copies files to a temporary directory on the node. For mount point import sources only, Redis Enterprise now reads files directly from the mount point. Because this import method does not copy files to a temporary directory, nodes do not require extra disk space. This new behavior is enabled by default and does not require configuration.
+
+## Version changes 
+
+### Prerequisites and notes 
+
+-  You can [upgrade to v6.2.12]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) from Redis Enterprise Software v6.0 and later. 
+
+- Refer to [v6.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021" >}}) for important notes regarding changes made to the upgrade policy and how those changes might impct your experience. 
+
+- Upgrades from versions earlier than v6.0 are not supported.
+
+- If you are using the earlier cluster-based LDAP mechanism, you _must_ migrate to the role-based mechanism _before_ upgrading to v6.2.12.  For details, see [Migrate to role-based LDAP]({{< relref "/operate/rs/security/access-control/ldap/migrate-to-role-based-ldap" >}}).
+
+- If you plan to upgrade your cluster to RHEL 8, see the [v6.2.8 release notes]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021" >}}) for known limitations.
+
+### Future deprecation notice
+
+#### TLS 1.0 and TLS 1.1 
+
+TLS 1.0 and TLS 1.1 connections are considered deprecated in favor of TLS 1.2 or later.  
+
+Please verify that all clients, apps, and connections support TLS 1.2.  Support for the earlier protocols will be removed in a future release.
+
+Certain operating systems, such as RHEL 8, have already removed support for the earlier protocols.  Redis Enterprise Software cannot support connection protocols that are not supported by the underlying operating system.
+
+### Product lifecycle updates 
+
+Redis Enterprise Software v6.0.x will reach end of life (EOL) on May 31, 2022.
+
+To learn more, see the Redis Enterprise Software [product lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}), which details the release number and the end-of-life schedule for Redis Enterprise Software.
+
+For Redis modules information and lifecycle, see [Module lifecycle]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}).
+
+## Redis modules 
+
+Redis Enterprise Software v6.2.12 includes the following Redis modules:
+
+- [RediSearch v2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch" >}})
+- [RedisJSON v2.0.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson" >}})
+- [RedisBloom v2.2.17]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}release-notes/)
+- [RedisGraph v2.8.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph" >}})
+- [RedisTimeSeries v1.6.16]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries" >}})
+
+For help upgrading a module, see [Add a module to a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}#upgrading-the-module-for-the-database). 
+
+## Interface enhancements
+
+- Allow creation and editing of sharded databases with a single shard.  This lets you prepare for future scaling by ensuring your apps work in clustering mode, regardless of the actual number of configured shards
+- Enhanced the slowlog in the UI to display unprintable characters in RESTORE commands
+- Added support for custom paths when bootstrapping the cluster via the UI
+- Improve readability of geo-distributed log entries in the UI
+
+## Additional enhancements
+
+- Added support for the MODULE LIST command on Active-Active databases
+- Enhanced validity checks of the input parameters of the CRDB-CLI tool
+
+## Resolved issues 
+
+- RS38320 A failed task leaves the nodes list outdated in the UI
+- RS73768, RS72082 Increased certificate rotation timeout to allow it to finish 
+- RS72466, RS68668 Fix false positive alerts for certification expiration
+- RS69256 Change pre-bootstrap default TLS version to 1.2
+- RS67133 Fixed replication for command RESTOREMODAUX 
+- RS66468 Fixed “Test regex keys” in the UI
+- RS58156 Fixed the installation to abort and alert when encountering issues in NTP
+- RS67935 Fixed releasing 30MB of memory when deleting an Active-Active database
+- RS64276 Fixed high memory consumption of the DMC output buffers when running CLIENT LIST
+
+## Known limitations
+
+- RS81463 A shard may crash when resharding an Active-Active database with Auto Tiering . Specifically, the shard will crash when volatile keys or Active-Active tombstone keys reside in Flash memory.
+
+- RS54131 Returning +OK reply from the QUIT command on a TLS enabled database
+
+- RS40641 - API requests are redirected to an internal IP in case the request arrives from a node which is not the master. To avoid this issue, use [`rladmin cluster config`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/config" >}}) to configure `handle_redirects` or `handle_metrics_redirects`.
+
+### Installation limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Security
+
+### Open Source Redis Security fixes compatibility
+
+As part of Redis commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with open source Redis. The following [Open Source Redis](https://github.com/redis/redis) [CVEs](https://github.com/redis/redis/security/advisories) do not affect Redis Enterprise:
+
+- [CVE-2022-24834](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-24834) - Redis Enterprise versions 6.2.12 and later are not impacted by the CVE that was found and fixed in open source Redis. A fix to prevent Lua scripts from causing heap overflow was implemented in Redis Enterprise version 6.2.12. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 7.0.12, Redis 6.2.13, Redis 6.0.20)
+
+- [CVE-2021-32625](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32625) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis since Redis Enterprise does not implement LCS. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.4, Redis 6.0.14)
+
+- [CVE-2021-32672](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32672) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the LUA debugger is unsupported in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32675](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32675) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proxy in Redis Enterprise does not forward unauthenticated requests. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-32762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-32762) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the memory allocator used in Redis Enterprise is not vulnerable. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16)
+
+- [CVE-2021-41099](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-41099) - Redis Enterprise is not impacted by the CVE that was found and fixed in open source Redis because the proto-max-bulk-len CONFIG is blocked in Redis Enterprise. Additional information about the open source Redis fix is on [the Redis GitHub page](https://github.com/redis/redis/releases) (Redis 6.2.6, Redis 6.0.16) security fixes for [recent CVEs](https://github.com/redis/redis/security/advisories).
+
+Redis Enterprise has already included the fixes for the relevant CVEs. Some CVEs announced for open source Redis do not affect Redis Enterprise due to different and additional functionality available in Redis Enterprise that is not available in open source Redis.
+---
+Title: Redis Enterprise Software release notes 7.4.6-102 (October 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.4
+description: Updated module feature sets with later versions of RediSearch and RedisTimeSeries.
+linkTitle: 7.4.6-102 (October 2024)
+weight: 64
+aliases: 
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Updated module feature sets with later versions of RediSearch and RedisTimeSeries
+
+## New in this release
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release.
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+## Version changes
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+#### RedisGraph end of life
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.6-102 October release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">f4e6af466b565e59d2e3fb1f5f0c70b7903564a0f1a45cc5a6816caf20059f93</span> |
+| Ubuntu 20 | <span class="break-all">9f10ed232a5655fdc5b46d2dd98157449484fb03290c8c71994cf29b50c4b4a7</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">412a2244e5fd464382acccf811a221671c120fcb51d00bf6bc3089b6f9ad034e</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">b4fc25f6a812fe05ab990049f7f6f8a22932c5d8c507c475455802009ed5acca</span> |
+| Amazon Linux 2 | <span class="break-all">ab3dafdc46823548a6a4a2870be1db21cd2d907533bd0fddf59a895b94c00863</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.6-102 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.2-129 (April 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Fixes for bugs and known limitations that affect Redis Enterprise Software v7.4.2-126.
+linkTitle: 7.4.2-129 (April 2024)
+weight: 69
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software). This version fixes several issues that affect [version 7.4.2-126]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-126">}}).
+
+## Highlights
+
+This version offers:
+
+- Fixes for bugs and known limitations that affect Redis Enterprise Software [version 7.4.2-126]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-126">}})
+
+## New in this release
+
+### Resolved issues
+
+- RS121899: Upgraded the `boto3` library from version 1.26.65 to 1.34.76 to fix a [known memory leak](https://github.com/boto/boto3/issues/3614).
+
+- RS122241: Changed file permissions to allow `firewalld` configuration to add the `redislabs` service on RHEL 9.
+
+- RS121673: Search commands no longer return an error after fixing incorrect configuration.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.4.2-129 April release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 6f4b3ffa5769322bf1496dc35670b317 |
+| Ubuntu 20 | 794952d515d99a16dd584450517f47da |
+| Red Hat Enterprise Linux (RHEL) 8 | de59c2d2e5bf6cc2e4e3542761e0e476 |
+| Red Hat Enterprise Linux (RHEL) 9 | 5247575205a6b6ba5b4d35ccc9d2cfa3 |
+| Amazon Linux 2 | 02881466864c4eaa349487edce73050b |
+---
+Title: Redis Enterprise Software release notes 7.4.2-169 (May 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Configuration options for cluster management API workers and threads. Reduced Cluster Configuration Store CPU usage.
+linkTitle: 7.4.2-169 (May 2024)
+weight: 68
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Configuration options for cluster management API workers and threads
+
+- Reduced Cluster Configuration Store CPU usage
+
+- Bug fixes
+
+## New in this release
+
+### Enhancements
+
+- Allow configuring `cnm_http_workers` and `cnm_http_max_threads_per_worker` using a [`PUT /v1/cluster`]({{<relref "/operate/rs/references/rest-api/requests/cluster#put-cluster">}}) REST API request. You can update these settings if the API load is higher than the cluster can handle by default. Configuring more workers than the default will consume more memory.
+
+- Reduced Cluster Configuration Store CPU usage, following the addition of the internal caching mechanism in the resource management calculations.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0.20](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21)
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})
+
+### Resolved issues
+
+- RS123237: CRDT syncer prevents potential data mismatches or data loss due to missing keys when removing and re-adding a cluster in an Active-Active setup with at least three participating clusters after removing older clusters without re-adding them.
+
+- RS93876: When resharding is performed with `shards_blueprint`, improved the order of resharding to avoid stuck state machines due to low memory.
+
+- RS119350: Avoid removing roles bound to LDAP mappings during cluster upgrade even if the roles aren't assigned to any users.
+
+- RS123561: Improved the installation validation process by identifying an occupied DNS port.
+
+- RS122365: Improved platform and module readiness checks by ignoring operating systems that are no longer part of the cluster.
+
+- RS96400: DMC management threads properly terminate instead of maintaining a blocking connection if they can't reach the CCS after a predefined time.
+
+- RS117188: Replaced the policy cache mechanism. Cache data from the versions file.
+
+- RS120425: Skip [`rlcheck`]({{<relref "/operate/rs/references/cli-utilities/rlcheck">}}) `ccs_dns` check when `pdns_server` is not enabled.
+
+- RS118252: For databases with OSS Cluster API enabled, endpoints can bind to nodes that have master shards even if `max_listeners=0`.
+
+- RS115382: Updated DMC to disconnect the client with an error if the token size exceeds `MAX_KEY_BULK_SIZE`.
+
+- RS110798: Reduced `cluster_wd` request latency, fixing communication errors on large clusters.
+
+- RS119705: On in-place upgrades, minimize DMC downtime by performing CCS schema upgrade before services are restarted.
+
+- RS117224: Avoid RAM eviction during scripts.
+
+- RS122062: Use `os_family` instead of `os_name` when creating module platforms during cluster upgrade, fixing join requests for operating systems like CentOS and Oracle Linux.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.4.2-169 May release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 20ff0c73c6df04921355e2b256672f8e |
+| Ubuntu 20 | 1bdfad0d0a435bf6bcc648034bcc6bd6 |
+| Red Hat Enterprise Linux (RHEL) 8 | 5a7ebdce87aff285ea78d5a29ccbafc5 |
+| Red Hat Enterprise Linux (RHEL) 9 | 06dae1500cca622a6f61f51f107685df |
+| Amazon Linux 2 | 1eb64a1e1c10c17d126494b3bfc5f090 |
+
+## Security
+
+**Source available Redis security fixes compatibility**
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) from [source available Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for Redis do not affect Redis Enterprise due to different or additional functionality in Redis Enterprise.
+
+Redis Enterprise 7.4.2 supports Redis 7.2, 6.2, and 6.0. Below is the list of Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow can occur while handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result in remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow can occur while handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.2-126 (April 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: Redis database version selection during database creation in the Cluster Manager UI. New Redis logo.
+linkTitle: 7.4.2-126 (April 2024)
+weight: 70
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Redis database version selection during database creation in the Cluster Manager UI
+
+- New Redis logo
+
+## New in this release
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - You can choose the Redis database version during [database creation]({{<relref "/operate/rs/databases/create">}}).
+
+    - Updated the Redis logo.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0.19](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.19-m20)
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.16]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})
+
+### Resolved issues
+
+- RS113727: Added `automatic_node_offload` policy, which defines whether the cluster can automatically migrate shards from a node if the node is overbooked and is enabled by default. During an upgrade, don't offload even if the policy is enabled.
+
+- RS113828: Removed legacy function that adjusted existing users to role-based access control.
+
+- RS115636: Delete tasks with "aborted" status from the resource manager result queue.
+
+- RS122225: Improved descriptions in Cluster Manager UI logs for database upgrade, check node error, and upgrade mode.
+
+- RS122031: Improved performance of database search in the Cluster Manager UI.
+
+- RS121866: Block scripts that contain write commands from running on stale CRDB servers.
+
+- RS122570: Improved error message when unable to locate a requested CRDB-compatible module during Active-Active database creation.
+
+- RS120820: When using OSS Cluster API, improved availability during failover, database migration, database upgrade, and node optimization.
+
+- RS117388: Improved `rladmin status` output for stale shards.
+
+## Version changes
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.4.2-126 April release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | 0cca90f27f368d35b9ca08e4016047c7 |
+| Ubuntu 20 | 1933107157365c1c1b38b69b9644b47 |
+| Red Hat Enterprise Linux (RHEL) 8 | 4eb11678fa80cddca17fc7cfb94b9289 |
+| Red Hat Enterprise Linux (RHEL) 9 | 217b6669ff8ac5bbcc2fc8fbc2930c59 |
+| Amazon Linux 2 | d0f472f173f09c56a14c57f17d146deb |
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.2 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.6-77 (September 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.4
+description: Updated module feature sets. Bug fixes.
+linkTitle: 7.4.6-77 (September 2024)
+weight: 65
+aliases: 
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Updated module feature sets
+
+- Bug fixes
+
+## New in this release
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release.
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS133928: Updated LDAP URI validation to allow escape characters.
+
+- RS128184: Fixed an issue that sometimes prevented a new node from joining the cluster after removing a node.
+
+- RS132653: Fixed an issue that caused shard crashes when resharding Active-Active databases with Redis version 6.0.
+
+- RS131360: Changed key eviction for Active-Active databases to delete a key instead of expiring it.
+
+## Version changes
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+#### RedisGraph end of life
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.6-77 September release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">2a1c5b9a1efcf2be79e8485171b50b948b7ff10da36ca7bd95aeb572770e6862</span> |
+| Ubuntu 20 | <span class="break-all">816f13736ef774d77745279817aa792d64d6375f3b0c8313717a46f339e733d2</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">c22979928937ae08f65e83cc459cde98340ffae1eb0f414b8ed111a047feb5f1</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">e794d0a973b150449e532cd21280f920d8eba1eb47fba39157f5b10bb3842cd1</span> |
+| Amazon Linux 2 | <span class="break-all">d5f55646a0356e3844c42eabda855f220a9f38ccfd839397709a41864e1a4470</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.6-77 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.6-22 (July 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.4
+description: Support for SHA-384 certificates in client authentication. New parameters for optimize_shard_placement and recover database REST API requests.
+linkTitle: 7.4.6-22 (July 2024)
+weight: 66
+aliases: /operate/rs/release-notes/rs-7-4-6-releases/rs-7-4-6-22/
+---
+
+​[​Redis Enterprise Software version 7.4.6](https://redis.io/downloads/#software) 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:
+
+- Support for SHA-384 certificates in client authentication
+
+- New parameters for `optimize_shard_placement` and `recover` database REST API requests
+
+## New in this release
+
+### Enhancements
+
+- Added support for SHA-384 certificates when using mutual TLS for client authentication.
+
+- Added an option to the [optimize_shards_placement]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/optimize_shards_placement">}}) REST API request to consider replication when calculating the database’s optimized shard placement.
+
+- Added `shard_uid` and `shard_role` for each persistence file in the response body of the [recover]({{<relref "/operate/rs/references/rest-api/requests/bdbs/actions/recover">}}) REST API request. When the database has master_persistence enabled, these fields help identify the primary shard's persistence file, which is most up-to-date and recommended for recovery.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0.20 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release.
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS118231: Fixed an issue where configuration changes to `slave_buffer` failed due to shard connection issues but incorrectly reported success.
+
+- RS117757: Increased the number of connections reserved for admin clients to 64 to prevent connection limit issues.
+
+- RS129900: Fixed an issue that prevented creating a database with modules that were uploaded during a cluster upgrade.
+
+- RS128254: Fixed a TLS protocol version compatibility issue with cluster upgrades by setting new nodes to TLS protocol version 1.2 if the cluster's current TLS protocol version is no longer supported.
+
+- RS125593: Added validation to verify the LDAP server URI contains a host and port when updating LDAP configuration.
+
+## Version changes
+
+- Added validation to verify the LDAP server URI contains a host and port when updating LDAP configuration.
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.2 clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with version 7.6, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.6-22 July release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">3bf13415cf013869b6417165c6bc2966cade201a08ac7c2a4a7286990fca03df</span> |
+| Ubuntu 20 | <span class="break-all">c0951fc688e8b02aeec06b0e98baf77988edef7fd2dc828b6af4126ecb9753ae</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">4667c579c52f899a4992cfe5d97e7b4f70ae9f34f5ae9bf75f10cfe2869a80d4</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">6c37b1483b5fb6110c8055c1526aa58eec1d29d3519e92310859101419248831</span> |
+| Amazon Linux 2 | <span class="break-all">5782ac40b18b813f1fd6244f45c7107bfe00baccf3e0f3439149bdd0cbbfd806</span> |
+
+## Known issues
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.6-22 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.2-216 (July 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: region_name field for new AWS S3 regions. Bug fixes.
+linkTitle: 7.4.2-216 (July 2024)
+weight: 67
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- `region_name` field for new AWS S3 regions
+
+- Bug fixes
+
+## New in this release
+
+### Enhancements
+
+- Added the `region_name` field in the REST API to import, export, and back up data in new AWS S3 regions.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0.20 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21)
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.18]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})
+
+### Resolved issues
+
+- RS124753: Fixed a bug with databases created using a recovery plan with replication enabled where shards did not write persistence files.
+
+- RS126290: Allow editing an existing Replica Of source's proxy certificate in the Cluster Manager UI.
+
+- RS126476: Fixed unexpected database audit connection errors in the DMC proxy log.
+
+- RS126382: Log info when a node fails to join the cluster.
+
+- RS126655: Fixed database RAM limit display issue in the Cluster Manager UI.
+
+- RS125930: Fixed a bug where the cluster rejected certificate chains with unknown extensions due to a cryptography bug.
+
+- RS118231: Fixed output of `rladmin tune db` when updating buffer limits fails due to unreachable shards.
+
+- RS128091: Fixed a bug in `XREADGROUP` on CRDB that prevented it from resetting the idle time of a consumer in `XINFO`.
+
+## Version changes
+
+### Product lifecycle updates
+
+After August 31, 2024, Redis Enterprise Software versions 6.2.4 and 6.2.8 will not be included in [supported upgrade paths]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}) for Redis Enterprise Software versions beyond 7.4.x. Redis Enterprise Software versions 6.2.10, 6.2.12 and 6.2.18 continue to be part of the upgrade path.
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.2-216 July release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">d20e3cc11bf97d8feb20e3c24e9530b2aae28bf7450dd498674d44014f3fa079</span> |
+| Ubuntu 20 | <span class="break-all">724ef7cbd78612252a246ff66a43c3bdf8aa0102086df8c25e825edce9dcb01f</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">1d8e0d16ff802c6a87fc1f9290ae4c27e71f170e1573349d179d9ef042accec2</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">7717999ebebd7dd4d66db7cbd92b0439f95dadeddee1990da8c9bf7cdec84b71</span> |
+| Amazon Linux 2 | <span class="break-all">99b57ab72bbbcacdf9363d5b8eddfeaf6a23930a97cb6724334c4742810fcf5f</span> |
+
+## Security
+
+**Source available Redis security fixes compatibility**
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) from [source available Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for Redis do not affect Redis Enterprise due to different or additional functionality in Redis Enterprise.
+
+Redis Enterprise 7.4.2 supports Redis 7.2, 6.2, and 6.0. Below is the list of Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) A specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup. (Redis 6.2.14)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow can occur while handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result in remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow can occur while handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.6-188 (January 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.4
+description: Bug fix for a memory leak in the DMC proxy process.
+linkTitle: 7.4.6-188 (January 2025)
+weight: 63
+aliases: 
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- A bug fix for a memory leak in the DMC proxy process
+
+## New in this release
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release.
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+### Resolved issues
+
+- RS126364: Fixed a memory leak in the DMC proxy process.
+
+## Version changes
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+#### RedisGraph end of life
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.6-188 January release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">452446126776a93a6ac943f6b9ed0a274a2b48eb18d5ec057d15459e6148caa2</span> |
+| Ubuntu 20 | <span class="break-all">91c245d39007fc1c5ad86dc991286ce30d837289f541518bfee5249ccb3864bb</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">995bfa4aad1f1ab4611fbe83d1d3cbb2ddc45b9fa6d53900267385e6e5c4d162</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">b4fc25f6a812fe05ab990049f7f6f8a22932c5d8c507c475455802009ed5acca</span> |
+| Amazon Linux 2 | <span class="break-all">042b016fd9fac8fac95d51e9fbfece6f4ab5e705146e7423ea23b68ce872c76f</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.6-188 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.2-54 (February 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: New Cluster Manager UI enhancements, including Active-Active database
+  management. Full TLS 1.3 support. Automatic recovery configuration. Full IPv6 support,
+  including for internal traffic. Maintenance mode enhancements. Module management
+  enhancements. RHEL 9 support.
+linkTitle: 7.4.2-54 (February 2024)
+weight: 72
+---
+
+​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+
+- New Cluster Manager UI enhancements, including Active-Active database management
+
+- Full TLS 1.3 support
+
+- Automatic recovery configuration
+
+- Full IPv6 support, including for internal traffic
+
+- Maintenance mode enhancements
+
+- Module management enhancements
+
+- RHEL 7 and Oracle Linux 7, which were previously deprecated, are no longer supported
+
+- RHEL 9 support
+
+## New in this release
+
+### New features
+
+- Added full support for TLS 1.3:
+
+    - TLS 1.3 cipher suites are now configurable for database connections. See [Configure cipher suites]({{< relref "/operate/rs/security/encryption/tls/ciphers" >}}) for details.
+
+    - TLS 1.3 can be set as the minimum TLS version. See [Configure TLS protocol]({{< relref "/operate/rs/security/encryption/tls/tls-protocols" >}}) for details.
+
+- Automatic recovery of databases from persistence files is configurable using the REST API. See [Configure automatic recovery]({{< relref "/operate/rs/databases/recover#configure-automatic-recovery" >}}) for details.
+
+- New clusters fully support IPv6, including for internal traffic. See [Enable IPv6 for internal traffic]({{< relref "/operate/rs/networking/multi-ip-ipv6#enable-ipv6-for-internal-traffic" >}}) for details.
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - [Create]({{< relref "/operate/rs/databases/active-active/create" >}}) and [manage]({{< relref "/operate/rs/databases/active-active/manage" >}}) Active-Active databases.
+
+    - [Configure database defaults]({{< relref "/operate/rs/databases/configure/db-defaults" >}}): endpoint configuration, database proxy, and shards placement.
+
+    - Configure [TLS cipher suites]({{< relref "/operate/rs/security/encryption/tls/ciphers#edit-ciphers-ui" >}}) and [minimum TLS protocol]({{< relref "/operate/rs/security/encryption/tls/tls-protocols#edit-tls-ui" >}}).
+
+    - Configure LDAP [authentication timeout]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap#authentication-timeout" >}}).
+
+- [Maintenance mode]({{< relref "/operate/rs/clusters/maintenance-mode" >}}) enhancements:
+
+    - Only the latest maintenance mode snapshot is kept.
+    
+    - Use the `overwrite_snapshot` option to create a new snapshot when you turn on maintenance mode.
+
+    - `keep_slave_shards` is deprecated. Use `evict_ha_replica` and `evict_active_active_replica` instead.
+    
+    - View or delete node snapshots using [`/v1/nodes/{node_uid}/snapshots`]({{< relref "/operate/rs/references/rest-api/requests/nodes/snapshots" >}}) REST API requests.
+
+- Added support for RHEL 9.
+
+- Improved `actions` REST API:
+
+    - Improved `progress` field returned by [`GET /v1/actions`]({{< relref "/operate/rs/references/rest-api/requests/actions" >}}) requests.
+
+    - New request to get the status of all currently executing, pending, or completed actions for a specific database: [`GET /v1/actions/bdb/<bdb_uid>`]({{< relref "/operate/rs/references/rest-api/requests/actions/bdb" >}})
+
+- [`GET /v1/users`]({{< relref "/operate/rs/references/rest-api/requests/users#get-all-users" >}}) REST API requests include a new `status` field in the response, which indicates whether the user can sign in:
+
+    - `active`: user can sign in
+
+    - `locked`: user cannot sign in
+
+- Replaced the use of processes for `job_scheduler`, `cnm_http`, and `crdb_coordinator` with threads, which results in significant memory optimization.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.9](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.9)
+
+- [RedisJSON 2.6.8](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.8)
+
+- [RedisTimeSeries 1.10.9](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.9)
+
+- [RedisBloom 2.6.11](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.11)
+
+- [RedisGears 2.0.17](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.17-m18)
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.12](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.12)
+
+- [RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)
+
+- [RedisTimeSeries 1.8.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.11)
+
+- [RedisBloom 2.4.8](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.8)
+
+- [RedisGraph v2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.12)
+
+### Resolved issues
+
+- RS57417: Azure OSS cluster with Private Link should no longer return public IPs in response to `CLUSTER` commands.
+
+- RS106159: If RESP3 is not supported, `HELLO` requests now return an unknown command error instead of a protocol error.
+
+- RS107538: Fixed an issue where DMC proxy perpetually restarted due to a CCS inconsistency.
+
+## Version changes 
+
+### Breaking changes
+
+- Renamed `sentinel_ssl_policy` field. The new name is `sentinel_tls_mode`.
+
+    - You can only change the discovery service policy using `sentinel_tls_mode`.
+
+    - When retrieving the value of the current policy using [`GET /v1/cluster`]({{< relref "/operate/rs/references/rest-api/requests/cluster#get-cluster" >}}), both fields are returned for backward compatibility.
+
+- Port 3345 is now reserved for internal use.
+- Type of `progress` field returned by [`GET /v1/actions`]({{< relref "/operate/rs/references/rest-api/requests/actions" >}}) request modified from `integer` to `float`.
+
+### Deprecations
+
+#### API deprecations
+
+- The replica HA cluster policy is deprecated.
+
+- The maintenance mode option `keep_slave_shards` is deprecated in `rladmin` and the REST API. Use `evict_ha_replica` and `evict_active_active_replica` instead.
+
+- `/v1/debuginfo` REST API paths are deprecated. Use the new paths [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/cluster/debuginfo" >}}), [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/nodes/debuginfo" >}}), and [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.2 clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### Operating system retirements
+
+- RHEL 7 and Oracle Linux 7 were previously announced as deprecated in the [Redis Enterprise Software 7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#deprecations" >}}). As of Redis Enterprise Software 7.4.2, RHEL 7 and Oracle Linux 7 are no longer supported.
+
+#### Security retirements
+
+- The RC4 encryption cipher, which was previously deprecated in favor of stronger ciphers, is no longer supported.
+
+- The 3DES encryption cipher, which was previously deprecated in favor of stronger ciphers like AES, is no longer supported. Verify that all clients, applications, and connections support the AES cipher.
+
+- TLS 1.0 and TLS 1.1 connections, which were previously deprecated in favor of TLS 1.2 or later, are no longer supported. Verify that all clients, applications, and connections support TLS 1.2 or later.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Platform support ended in this version of Redis Enterprise Software.
+
+| Redis Enterprise | 7.4.2 | 7.2.4 | 6.4.2 | 6.2.18 | 6.2.12 | 6.2.10 | 6.2.8 | 6.2.4 |
+|------------------|-------|-------|-------|--------|--------|--------|--------|-------|
+| **Release date** | Feb<br />2024 | Aug<br />2023 | Feb<br />2023 | Sept<br />2022 | Aug<br />2022 | Feb<br />2022 | Oct<br />2021 | Aug<br />2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | – | July<br />2025 | Feb<br />2025 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 | Aug<br />2024 |
+| **Ubuntu**<sup>[1](#table-note-1)</sup> |
+| 20.04 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[6](#table-note-6)</sup> | – | – | – | – | – |
+| 18.04 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported"><span title="Supported">&#x2705;</span></span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 16.04 | – | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **RHEL & CentOS**<sup>[2](#table-note-2)</sup>
+| 9.0-9.3 | <span title="Supported">&#x2705;</span> | – | – | – | – | – | – | – |
+| 8.9| <span title="Supported">&#x2705;</span> | – | – | – | – | – | – | – |
+| 8.8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[8](#table-note-8)</sup> | – | – | – | – | – |
+| 8.7 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – | – |
+| 8.5-8.6 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 8.0-8.4 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| 7.0-7.9 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Oracle Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – |
+| 7 | <span title="End of life">&#x274c;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rocky Linux**<sup>[3](#table-note-3)</sup> |
+| 8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| **Amazon Linux** |
+| 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span><sup>[7](#table-note-7)</sup> | – | – | – | – | – |
+| 1 | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Docker**<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Kubernetes**<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>RHEL and CentOS deployments require [firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Based on the corresponding RHEL version.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes" >}}).
+
+6. <a name="table-note-6" style="display: block; height: 80px; margin-top: -80px;"></a>Ubuntu 20.04 support was added in Redis Enterprise Software [6.4.2-43]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43" >}}).
+
+7. <a name="table-note-7" style="display: block; height: 80px; margin-top: -80px;"></a>A release candidate for Amazon Linux 2 support was added in Redis Enterprise Software [6.4.2-61]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61" >}}). Official support for Amazon Linux 2 was added in Redis Enterprise Software [6.4.2-69]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-69" >}}).
+
+8. <a name="table-note-8" style="display: block; height: 80px; margin-top: -80px;"></a>Redis Enterprise Software [6.4.2-103]({{< relref "/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-103" >}}) and later supports RHEL 8.8.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.4.2-54 February release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | d22100b9ce51f602b7b93751bc0ab439 |
+| Ubuntu 20 | 784f3d07eafc99104da124d69f49b617 |
+| RedHat Enterprise Linux (RHEL) 8<br/>Oracle Enterprise Linux (OL) 8 <br/>Rocky Enterprise Linux | 107c1ce8510fd16026bac4179bb2aaa8 |
+| RedHat Enterprise Linux (RHEL) 9 | d5fe1b085147b6ee1fc6f70aa43b263f |
+| Amazon Linux 2 | 62b3dfb977750a3879c7e83c66a7726c |
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Cannot create Redis v6.x Active-Active databases with modules
+
+You cannot create Active-Active databases that use Redis version 6.0 or 6.2 with modules. Databases that use Redis version 7.2 do not have this limitation.
+
+This limitation will be fixed in a future maintenance release.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.2-54 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.2-104 (March 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: New Cluster Manager UI enhancements to change passwords from the sign-in
+  screen, view locked user accounts, and unlock user accounts with password reset.
+linkTitle: 7.4.2-104 (March 2024)
+weight: 71
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.2](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- New Cluster Manager UI enhancements for password management and identifying locked user accounts
+
+## New in this release
+
+### Enhancements
+
+- New Cluster Manager UI enhancements:
+
+    - You can change your password from the sign-in screen.
+    
+    - Added a “User is locked out” label to the **Access Control > Users** screen to help administrators identify and manage locked users.
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6.11]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0.17](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.17-m18)
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}})
+
+### Resolved issues
+
+- RS112165: `metrics_exporter` now reports the `bdb_crdt_syncer_status` metric during database out-of-memory events.
+
+- RS115577: Changed `connect_timeout` and `read_timeout` values for S3 from 30 to 60 seconds.
+
+- RS98042: The master node now logs all `replace_node` errors.
+
+- RS118147: Dynamically allocate buffer size for OSS cluster port mapping configuration.
+
+- RS114971: Update `endpoint` when `oss_cluster_api_preferred_ip_type` changes.
+
+- RS121248: Fixed a known issue that prevented creating Active-Active databases that use Redis version 6.0 or 6.2 with modules.
+
+## Version changes
+
+- Removed the restriction that prevented adding nodes to a cluster with an expired cluster license, which sometimes caused issues for Kubernetes deployments.
+
+    To avoid issues due to an expired cluster license, we recommend replacing the license before the expiration date. See [Update cluster license]({{< relref "/operate/rs/clusters/configure/license-keys#update-cluster-license" >}}) for Cluster Manager UI instructions or use a [`PUT /v1/license`]({{< relref "/operate/rs/references/rest-api/requests/license#put-license" >}}) REST API request.
+
+### Breaking changes
+
+- [#1131](https://github.com/RedisJSON/RedisJSON/issues/1131), [#1143](https://github.com/RedisJSON/RedisJSON/pull/1143): RedisJSON v2.6.9 reverts JSONPath default path value from `$` to `.` under RESP3.
+
+### Deprecations
+
+#### API deprecations
+
+- The BDB REST API object's `background_op` field is deprecated. Use [`GET v1/actions/bdb/<bdb_uid>`]({{< relref "/operate/rs/references/rest-api/requests/actions/bdb" >}}) instead.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | July 2025 | Feb 2025 | Aug 2024 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Downloads
+
+The following table shows the MD5 checksums for the available packages:
+
+| Package | MD5 checksum (7.4.2-104 March release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | a65c8505f5e0e1bdff63fb778b010856 |
+| Ubuntu 20 | 7c3e0aef16147c26fd5f1089e6f68dc2 |
+| Red Hat Enterprise Linux (RHEL) 8 | 31df503bafdf43330be74267075401e3 |
+| Red Hat Enterprise Linux (RHEL) 9 | 52199b917ebaab05352227c4c9c008ac |
+| Amazon Linux 2 | 3823405fe934ce590aa6a9c71001168e |
+
+## Known issues
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` due to excessive RocksDB log files.
+
+- RS122570: REST API `POST /crdbs` responds with a confusing error message if the cluster does not have the requested CRDB-compatible module that complies with the requested featureset.
+
+## Known limitations
+
+#### Firewalld configuration fails on RHEL 9 due to file permissions
+
+When you install Redis Enterprise Software version 7.4.2 on RHEL 9, `firewalld` configuration fails to add the `redislabs` service if `/etc/firewalld/services/redislabs-clients.xml` and `/etc/firewalld/services/redislabs.xml` are owned by `redislabs` instead of `root`.
+
+As a workaround:
+
+1. Change the files' owner and group to `root`: 
+
+    ```sh
+    $ chown root:root /etc/firewalld/services/redislabs-clients.xml
+    $ chown root:root /etc/firewalld/services/redislabs.xml
+    ```
+
+1. Add the `redislabs` service to `firewalld`:
+
+    ```sh
+    $ systemctl daemon-reload
+    $ systemctl restart firewalls
+    $ /bin/firewall-cmd --add-service=redislabs
+    ```
+
+This limitation will be fixed in a future maintenance release.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.2-104 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` command can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.6-232 (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.4
+description: Internal fixes and improvements.
+linkTitle: 7.4.6-232 (March 2025)
+weight: 62
+---
+
+This is a maintenance release for ​[​Redis Enterprise Software version 7.4.6](https://redis.io/downloads/#software).
+
+## Highlights
+
+This version offers:
+
+- Internal fixes and improvements
+
+## New in this release
+
+#### Redis module feature sets
+
+Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions.
+
+Bundled Redis modules compatible with Redis database version 7.2:
+
+- [RediSearch 2.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}})
+
+- [RedisJSON 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}})
+
+- [RedisTimeSeries 1.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}})
+
+- [RedisBloom 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}})
+
+- [RedisGears 2.0 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release.
+
+Bundled Redis modules compatible with Redis database versions 6.0 and 6.2:
+
+- [RediSearch 2.6]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}})
+
+- [RedisJSON 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}})
+
+- [RedisTimeSeries 1.8]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}})
+
+- [RedisBloom 2.4]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}})
+
+- [RedisGraph v2.10]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details.
+
+## Version changes
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+#### RedisGraph end of life
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+## Downloads
+
+The following table shows the SHA256 checksums for the available packages:
+
+| Package | SHA256 checksum (7.4.6-232 March release) |
+|---------|---------------------------------------|
+| Ubuntu 18 | <span class="break-all">b1657f0a9298899e8f671686c981dcc2be2f7fc339e46fde8d8545f402de1f76</span> |
+| Ubuntu 20 | <span class="break-all">bd30669650d3ae7b4a768365bf3166d9a466fb8aa7067d84a3e6162d2004ca77</span> |
+| Red Hat Enterprise Linux (RHEL) 8 | <span class="break-all">4b50b6648a601e20425d64d0a32cb18f5e25010e2b2f43afe5e0accc32db9a48</span> |
+| Red Hat Enterprise Linux (RHEL) 9 | <span class="break-all">12ff65d14d4dea143748ea9f2b91904dd94167a67c7955cc70cfe810fc8f56f8</span> |
+| Amazon Linux 2 | <span class="break-all">8d7a6fb648b844aa176d5200be8c6388aa1efe2d520af54155733441c40c146d</span> |
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Security
+
+#### Open source Redis security fixes compatibility
+
+As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs.
+
+Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis.
+
+Redis Enterprise 7.4.6-232 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version.
+
+Redis 7.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1)
+
+Redis 7.0.x:
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution.
+
+- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13)
+
+- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11)
+
+- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8)
+
+- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5)
+
+- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0)
+
+Redis 6.2.x:
+
+- (CVE-2025-21605) An unauthenticated client can cause unlimited growth of output buffers until the server runs out of memory or is terminated, which can lead to denial-of-service.
+
+- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution.
+
+- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes.
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11)
+
+- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9)
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13)
+
+- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7)
+
+- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7)
+
+- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6)
+
+- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5)
+
+- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6)
+
+- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6)
+
+- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6)
+
+- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6)
+
+- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6)
+
+- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6)
+
+- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4)
+
+- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3)
+
+- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3)
+
+Redis 6.0.x:
+
+- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20)
+
+- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19)
+
+- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18)
+
+- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18)
+
+- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17)
+---
+Title: Redis Enterprise Software release notes 7.4.x
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+compatibleOSSVersion: Redis 7.2.0
+description: New Cluster Manager UI enhancements, including Active-Active database
+  management. Full TLS 1.3 support. Automatic recovery configuration. Full IPv6 support,
+  including for internal traffic. Maintenance mode enhancements. Module management
+  enhancements. RHEL 9 support.
+hideListLinks: true
+linkTitle: 7.4.x releases
+toc: 'true'
+weight: 70
+---
+
+​[​Redis Enterprise Software version 7.4](https://redis.io/downloads/#software) is now available!
+
+## Highlights
+
+This version offers:
+ 
+- New Cluster Manager UI enhancements, including Active-Active database management
+
+- Full TLS 1.3 support
+
+- Automatic recovery configuration
+
+- Full IPv6 support, including for internal traffic
+
+- Maintenance mode enhancements
+
+- Module management enhancements
+
+- RHEL 7 and Oracle Linux 7, which were previously deprecated, are no longer supported
+
+- RHEL 9 support
+
+## Detailed release notes
+
+For more detailed release notes, select a build version from the following table:
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,OSS&nbsp;Redis compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle">}}
+
+## Version changes
+
+### Product lifecycle updates
+
+#### End-of-life policy extension
+
+The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}).
+
+#### Supported upgrade paths
+
+Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#supported-upgrade-paths">}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required.
+
+The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x.
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers.
+
+### Deprecations
+
+#### API deprecations
+
+- The replica HA cluster policy is deprecated.
+
+- The maintenance mode option `keep_slave_shards` is deprecated in `rladmin` and the REST API. Use `evict_ha_replica` and `evict_active_active_replica` instead.
+
+- `/v1/debuginfo` REST API paths are deprecated. Use the new paths [`/v1/cluster/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/cluster/debuginfo" >}}), [`/v1/nodes/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/nodes/debuginfo" >}}), and [`/v1/bdbs/debuginfo`]({{< relref "/operate/rs/references/rest-api/requests/bdbs/debuginfo" >}}) instead.
+
+#### Legacy UI deprecation
+
+The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release.
+
+#### Redis 6.0 database deprecation
+
+Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release.
+
+To prepare for the future removal of Redis 6.0:
+
+- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes.
+
+- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes.
+
+#### End of triggers and functions preview
+
+The [triggers and functions]({{<relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions">}}) (RedisGears) preview has been discontinued.
+
+- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages.
+
+- Any JavaScript functions stored in Redis will be removed. 
+
+- JavaScript-based triggers will be blocked.
+
+- Lua functions and scripts will not be affected.
+
+If your database currently uses triggers and functions, you need to: 
+
+1. Adjust your applications to accommodate these changes.
+
+1. Delete all triggers and functions libraries from your existing database:
+
+    1. Run `TFUNCTION LIST`.
+
+    1. Copy all library names.
+
+    1. Run `TFUNCTION DELETE` for each library in the list.
+
+    If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears.
+
+1. Migrate your database to a new database without the RedisGears module.
+
+#### RedisGraph end of life
+
+Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025.
+
+See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details.
+
+#### Operating system retirements
+
+- RHEL 7 and Oracle Linux 7 were previously announced as deprecated in the [Redis Enterprise Software 7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#deprecations" >}}). As of Redis Enterprise Software 7.4.2, RHEL 7 and Oracle Linux 7 are no longer supported.
+
+#### Security retirements
+
+- The RC4 encryption cipher, which was previously deprecated in favor of stronger ciphers, is no longer supported.
+
+- The 3DES encryption cipher, which was previously deprecated in favor of stronger ciphers like AES, is no longer supported. Verify that all clients, applications, and connections support the AES cipher.
+
+- TLS 1.0 and TLS 1.1 connections, which were previously deprecated in favor of TLS 1.2 or later, are no longer supported. Verify that all clients, applications, and connections support TLS 1.2 or later.
+
+### Upcoming changes
+
+#### Default image change for Redis Enterprise Software containers
+
+Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu.
+
+This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes">}}) product and use Ubuntu-specific commands.
+
+To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`.
+
+### Supported platforms
+
+The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility.
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Enterprise<br />major versions | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>
+[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+## Known issues
+
+- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors.
+
+- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN).
+
+- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering.
+
+- RS122570: REST API `POST /crdbs` responds with a confusing error message if the cluster does not have the requested CRDB-compatible module that complies with the requested featureset.
+
+    This issue was fixed in [Redis Enterprise Software version 7.4.2-126]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-126">}}).
+
+- RS123142: In an Active-Active setup with at least three participating clusters, removing and re-adding a cluster after removing older clusters without re-adding them can cause missing keys and potentially lead to data loss or data inconsistency.
+
+    To prevent this issue, avoid adding clusters until you upgrade to the upcoming maintenance release when available.
+
+    This issue was fixed in [Redis Enterprise Software version 7.4.2-169]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-169">}}).
+
+## Known limitations
+
+#### New Cluster Manager UI limitations
+
+The following legacy UI features are not yet available in the new Cluster Manager UI:
+
+- Remove a node.
+
+    Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions.
+
+- Purge an Active-Active instance.
+
+    Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead.
+
+- Search and export the log.
+
+#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+#### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+#### Cannot create Redis v6.x Active-Active databases with modules
+
+You cannot create Active-Active databases that use Redis version 6.0 or 6.2 with modules. Databases that use Redis version 7.2 do not have this limitation.
+
+This limitation was fixed in [Redis Enterprise Software version 7.4.2-104]({{< relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-104" >}}).
+
+#### Firewalld configuration fails on RHEL 9 due to file permissions
+
+When you install Redis Enterprise Software version 7.4.2 on RHEL 9, `firewalld` configuration fails to add the `redislabs` service if `/etc/firewalld/services/redislabs-clients.xml` and `/etc/firewalld/services/redislabs.xml` are owned by `redislabs` instead of `root`.
+
+As a workaround:
+
+1. Change the files' owner and group to `root`: 
+
+    ```sh
+    $ chown root:root /etc/firewalld/services/redislabs-clients.xml
+    $ chown root:root /etc/firewalld/services/redislabs.xml
+    ```
+
+1. Add the `redislabs` service to `firewalld`:
+
+    ```sh
+    $ systemctl daemon-reload
+    $ systemctl restart firewalls
+    $ /bin/firewall-cmd --add-service=redislabs
+    ```
+
+This limitation was fixed in [Redis Enterprise Software version 7.4.2-129]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-129">}}).
+---
+Title: Release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: true
+weight: 90
+---
+
+Here's what changed recently in Redis Enterprise Software:
+
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes,Redis Open Source compatibility" columnSources="LinkTitle,Description,compatibleOSSVersion" enableLinks="LinkTitle" >}}
+---
+Title: What's new in Redis Enterprise Software 6.x?
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+draft: true
+weight: 20
+---
+Below are detailed a few of the major features of this release of Redis Enterprise Software
+along with bug fixes and patches.
+
+## Geo-Distributed Active-Active Conflict-free Replicated Databases (CRDB) {#geodistributed-activeactive-conflictfree-replicated-databases-crdb}
+
+Developing globally distributed applications can be challenging, as
+developers have to think about race conditions and complex combinations
+of events under geo-failovers and cross-region write conflicts. Active-Active databases
+simplify developing such applications by directly using built-in smarts
+for handling conflicting writes based on the data type in use. Instead
+of depending on just simplistic "last-writer-wins" type conflict
+resolution, geo-distributed Active-Active databases combines techniques defined in CRDT
+(conflict-free replicated data types) research with Redis types to
+provide smart and automatic conflict resolution based on the data type's
+intent.
+
+For more information, go here. For information, go to [Developing with
+Active-Active databases]({{< relref "/operate/rs/developing/crdbs" >}}).
+
+## Redis modules
+
+Redis Modules enable you to extend the functionality of Redis Enterprise
+Software. One can add new data types, capabilities, etc. to tailor the
+cluster to a specific use case or need. Once installed, modules benefit
+from the high performance, scalability, and high availability that Redis
+Enterprise is known for.
+
+### Certified modules
+
+Redis developed and certified these modules for use with Redis Enterprise Software:
+
+- [RedisBloom]({{< relref "/operate/modules/redisbloom" >}})
+    - Enables Redis to have a scalable bloom filter as a data type. Bloom
+      filters are probabilistic data structures that quickly determine if something is contained within a set.
+- RedisGraph
+    - RedisGraph is the first queryable Property Graph database to use sparse
+      matrices to represent the adjacency matrix in graphs and linear algebra to query the graph.
+      RedisGraph uses [Cypher](https://www.opencypher.org/) as its query language.
+- [RedisJSON]({{< relref "/operate/modules/redisjson" >}})
+    - Now you have the convenience JSON as a built-in data type and easily
+      able to address nested data via a path.
+- [RediSearch]({{< relref "/operate/modules/redisearch" >}})
+    - This module turns Redis into a distributed in-memory
+      full-text indexing and search beast.
+
+### Custom modules
+
+In addition, Redis Enterprise Software provides the ability to load and
+use custom [Redis modules](https://redislabs.com/community/redis-modules-hub/) or
+of your own creation.
+
+## Support for Docker
+
+Deploying and running your Redis Enterprise Software cluster on Docker
+containers is supported in development systems and
+available to pull from Docker hub. With the official image, you can
+easily and quickly test several containers to build the scalable
+and highly available cluster Redis Enterprise Software is famous for.
+
+For more information go to [quick start with Redis Enterprise Software
+on Docker.]({{< relref "/operate/rs/installing-upgrading/get-started-docker.md" >}})
+
+## LDAP integration
+
+As part of our continued emphasis on security, administrative user
+accounts in Redis Enterprise Software can now use either built-in
+authentication or authenticate externally via LDAP with saslauthd. The
+accounts can be used for administering resources on the cluster via
+command line, Rest API, or admin console.
+
+For more information see [LDAP
+Integration]({{< relref "/operate/rs/security/passwords-users-roles.md#setting-up-ldap" >}}).
+---
+Title: Manage installation questions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes Redis Enterprise Software installation questions and how to
+  answer them automatically.
+linkTitle: Manage install questions
+weight: 25
+---
+
+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:
+
+- **Linux swap file** - `Swap is enabled. Do you want to proceed? [Y/N]?`
+
+    We recommend that you [disable Linux swap]({{< relref "/operate/rs/installing-upgrading/configuring/linux-swap.md" >}}) in the operating system configuration
+    to give Redis Enterprise Software control of the memory allocation.
+
+- **Automatic OS tuning** - `Do you want to automatically tune the system for best performance [Y/N]?`
+
+    To allow the installation process to optimize the OS for Redis Enterprise Software, answer `Y`.
+    The installation process prompts you for additional information.
+
+    The `/opt/redislabs/sbin/systune.sh` file contains details about the tuning process.
+
+- **Network time** - `Do you want to set up NTP time synchronization now [Y/N]?`
+
+    Redis Enterprise Software requires that all cluster nodes have synchronized time.
+    You can either let the installation process configure NTP
+    or you can [configure NTP manually]({{< relref "/operate/rs/clusters/configure/sync-clocks.md" >}}).
+
+- **Firewall ports** - `Would you like to open RedisLabs cluster ports on the default firewall zone [Y/N]?`
+
+    Redis Enterprise Software requires that all nodes have [specific network ports]({{< relref "/operate/rs/networking/port-configurations.md" >}}) open.
+    To open the ports, you can:
+
+    - Answer `Y` to let the installation process open these ports.
+    - Answer `N` and configure the firewall manually for [RHEL/CentOS firewall]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall" >}}).
+    - Answer `N` and configure the firewall on the node manually for your OS.
+
+- **Installation verification (rlcheck)** - `Would you like to run rlcheck to verify proper configuration? [Y/N]?`
+
+    Run the `rlcheck` installation verification to make sure that the installation completed successfully.
+    If you want to run this verification at a later time, you can run:
+    
+    ```sh
+    /opt/redislabs/bin/rlcheck
+    ```
+
+- **User already exists** - `The user 'redislabs' already exists, which may lead to problems if it wasn't configured correctly. Would you like to proceed with the installation? (Y/N)?`
+
+- **Group already exists** - `The group 'redislabs' already exists, which may lead to problems if it wasn't configured correctly. Would you like to proceed with the installation? (Y/N)?`
+ 
+## Answer install questions automatically
+
+To perform a silent (or automated) install, answer the questions when you start the [install]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}).  
+
+### Answer yes to all questions
+
+To automatically answer `yes` to all questions (which accepts the default values), run the [installation script]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) with the `-y` parameter:
+
+```bash
+./install.sh -y
+```
+
+### Configure file to answer
+
+Use an answer file to manage your response:
+
+1. Create a text file to serve as an answer file.
+
+    The answer file can contain any of the parameters for the installation questions and indicate the answer for each question with `yes` or `no`.
+
+    For example:
+
+    ```sh
+    ignore_swap=no
+    systune=yes
+    ntp=no
+    firewall=no
+    rlcheck=yes
+    ignore_existing_osuser_osgroup=no
+    ```
+
+    If you use `systune=yes`, the installation answers `yes` to all of the system tuning questions.
+
+1. Run the [installation script]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) with the `-c` command-line option and add the path to the answer file.
+
+    For example:
+
+    ```sh
+    ./install.sh -c /home/user/answers
+    ```
+
+---
+Title: Install Redis Enterprise Software on Linux
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Install Redis Enterprise Software on Linux.
+linkTitle: Install on Linux
+weight: 10
+---
+
+After you [download a Redis Enterprise Software installation package]({{< relref "/operate/rs/installing-upgrading/install/prepare-install/download-install-package" >}}), install it on one of the nodes in the cluster.
+
+For installation on machines without an internet connection, see [Offline installation]({{< relref "/operate/rs/installing-upgrading/install/offline-installation" >}}).
+
+## Install on Linux
+
+To install Redis Enterprise Software, use the command line:
+
+1. Copy the installation package to the node.
+
+1. On the node, change to the directory where the installation package is located and extract the installation files:
+
+    ```sh
+    tar vxf <tarfile name>
+    ```
+
+1.  _(Optional)_ Use the {{< download "GPG key file" "../GPG-KEY-redislabs-packages.gpg" >}} to confirm the authenticity of Ubuntu/Debian or RHEL RPM packages:
+
+    - For Ubuntu:
+        1. Import the key:  
+        ```sh
+        gpg --import <path to GPG key>
+        ```  
+        2. Verify the package signature: 
+        ```sh 
+        dpkg-sig --verify </path-to/package.deb>
+        ```
+
+    - For RHEL:
+        1. Import the key:  
+        ```sh
+        rpm --import <path to GPG key>
+        ```
+        2. Verify the package signature:  
+         ```sh
+         rpm --checksig </path-to/package.rpm>
+         ```
+
+1. To start the installation process, run the installation script. See [installation script options]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) for a list of command-line options you can add to the following command:
+
+    ```sh
+    sudo ./install.sh
+    ```
+
+    {{< note >}}
+- The Redis Enterprise Software files are installed in the default [file locations]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/file-locations.md" >}}). 
+- By default, Redis Enterprise Software runs on the OS as the `redislabs` user and `redislabs` group. If needed, you can [specify a different user and group]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}}) during the installation.
+- You must either be the root user or use `sudo` to run the installation script.
+    {{< /note >}}
+
+1. Answer the [installation questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions.md" >}}) when shown to complete the installation process.
+
+    {{< note >}}
+To skip the installation questions, use one of the following methods:
+
+- Run `./install.sh -y` to answer yes to all of the questions.
+- Create an [answer file]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions#configure-file-to-answer" >}}) to answer installation questions automatically.
+    {{< /note >}}
+
+1. When installation completes successfully, the output displays the Cluster Manager UI's IP address:
+
+    ```sh
+    Summary:
+    -------
+    ALL TESTS PASSED.
+    2017-04-24 10:54:15 [!] Please logout and login again to make
+    sure all environment changes are applied.
+    2017-04-24 10:54:15 [!] Point your browser at the following
+    URL to continue:
+    2017-04-24 10:54:15 [!] https://<your_ip_here>:8443
+    ```
+
+1. Repeat this process for each node in the cluster.
+
+
+## Auto Tiering installation
+
+If you want to use Auto Tiering for your databases, review the prerequisites, storage requirements, and [other considerations]({{< relref "/operate/rs/databases/auto-tiering/" >}}) for Auto Tiering databases and prepare and format the flash memory.
+
+After you [install on Linux](#install-on-linux), use the `prepare_flash` script to prepare and format flash memory:
+
+```sh
+sudo /opt/redislabs/sbin/prepare_flash.sh
+```
+
+This script finds unformatted disks and mounts them as RAID partitions in `/var/opt/redislabs/flash`.
+
+To verify the disk configuration, run:
+
+```sh
+sudo lsblk
+```
+
+## More info and options
+
+To learn more about customization and find answers to related questions, see:
+
+- [CentOS/RHEL firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/networking/cluster-lba-setup.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/networking/mdns.md" >}})
+- [File locations]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Supported platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}})
+
+## Limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use [custom installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}).
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+
+## Next steps
+
+1. [Create]({{< relref "/operate/rs/clusters/new-cluster-setup.md" >}})
+    or [join]({{< relref "/operate/rs/clusters/add-node.md" >}}) an existing Redis Enterprise Software cluster.
+
+1. [Create a database]({{< relref "/operate/rs/databases/create" >}}).
+
+    For geo-distributed Active-Active replication, create an [Active-Active]({{< relref "/operate/rs/databases/active-active/create.md" >}}) database.
+
+1. [Add users]({{< relref "/operate/rs/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/security/access-control" >}}).
+---
+Title: Supported platforms
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+linkTitle: Supported platforms
+weight: 30
+tocEmbedHeaders: true
+---
+{{< embed-md "supported-platforms-embed.md">}}
+---
+Title: Configure AWS EC2 instances for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Considerations for installing and running Redis Enterprise Software on
+  Amazon Elastic Cloud Compute (EC2) instances.
+linkTitle: AWS EC2 configuration
+weight: 80
+---
+There are some special considerations for installing
+and running Redis Enterprise Software on Amazon Elastic Cloud Compute (EC2) instances. 
+
+These include:
+
+- [Storage considerations](#storage)
+- [Instance types](#instance-types)
+- [Security group configuration](#security)
+
+## Storage considerations {#storage}
+
+AWS EC2 instances are ephemeral, but your persistent database storage should
+not be. If you require a persistent storage location for your database,
+the storage must be located outside of the instance. When you
+set up an instance, make sure it has a properly sized EBS-backed volume
+connected. When you set up Redis Enterprise Software on the instance, make sure that [the
+persistence storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) is configured to use this volume.
+
+{{< note >}}
+After [installing the Redis Enterprise Software package]({{< relref "/operate/rs/installing-upgrading" >}}) on the instance
+and **before** running through [the setup process]({{< relref "/operate/rs/clusters/new-cluster-setup.md" >}}),
+you must give the group `redislabs` permission to the EBS volume by
+running the following command from the OS command-line interface (CLI):
+```sh
+chown redislabs:redislabs /< ebs folder name>
+```
+{{< /note >}}
+
+Another feature that may be of importance to you is the use of
+Provisioned IOPS for EBS-backed volumes. Provisioned IOPS guarantee a
+certain level of disk performance. There are two features in Redis Enterprise Software where
+this feature could be critical to use:
+
+1. When using [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}})
+1. When using AOF on every write and there is a high write load. In
+    this case, the provisioned IOPS should be on the nodes used as
+    replicas in the cluster.
+
+## Instance types {#instance-types}
+
+Choose an instance type that has (at minimum) enough free memory and
+disk space to meet the Redis Enterprise Software [hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+In addition, some instance types are optimized for EBS-backed volumes
+and some are not. If you are using persistent storage, you should use an
+instance type that is, especially if disk drain rate matters to your database
+implementation.
+
+## Security group configuration {#security}
+
+When configuring the security group:
+
+- Define a custom TCP rule for port 8443 to allow web browser access
+    to the Redis Enterprise Software Cluster Manager UI from the IP address range you use to
+    access the Cluster Manager UI.
+- If you are using the DNS resolving option with Redis Enterprise Software, define a DNS UDP
+    rule for port 53 to allow access to the databases' endpoints by
+    using the [DNS resolving mechanism]({{< relref "/operate/rs/networking/cluster-dns" >}}).
+- To create a cluster that has multiple nodes all running as instances on AWS,
+    you need to define a security group that has an All TCP rule for all ports, 0 - 65535,
+    and add it to all instances that are part of the cluster.
+    This ensures that all nodes are able to communicate with each other.
+    To limit the number of open ports, you can open only the [ports used by Redis Enterprise Software]({{< relref "/operate/rs/networking/port-configurations.md" >}}).
+
+After successfully launching the instances:
+
+1. Install Redis Enterprise Software from the [Linux package or AWS AMI]({{< relref "/operate/rs/installing-upgrading" >}}).
+2. [Set up the cluster]({{< relref "/operate/rs/clusters/new-cluster-setup.md" >}}).
+---
+Title: File locations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Redis Enterprise Software file installation locations.
+linkTitle: File locations
+weight: 60
+---
+{{<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.
+{{</warning>}}
+
+## Application directories
+
+The directories that Redis Enterprise Software installs into are:
+
+| **Path** | **Description** |
+|------------|-----------------|
+| /opt/redislabs | Main installation directory for all Redis Enterprise Software binaries |
+| /opt/redislabs/bin | Binaries for all the utilities for command-line access and management, such as [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) or [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) |
+| /opt/redislabs/config | System configuration files |
+| /opt/redislabs/lib | System library files |
+| /opt/redislabs/sbin | System binaries for tweaking provisioning |
+
+## Configuration and data directories
+
+The default directories that Redis Enterprise Software uses for data and metadata are:
+
+| **Path** | **Description** |
+|------------|-----------------|
+| /var/opt/redislabs | Default storage location for the cluster data, system logs, backups, and ephemeral, persisted data |
+| /var/opt/redislabs/log | System logs for Redis Enterprise Software |
+| /var/opt/redislabs/run | Socket files for Redis Enterprise Software |
+| /etc/opt/redislabs | Default location for cluster manager configuration and certificates |
+| /tmp | Temporary files |
+
+You can change these file locations for:
+
+- [Ephemeral and persistence storage]({{< relref "/operate/rs/clusters/new-cluster-setup.md" >}}) during cluster setup
+- [Socket files]({{< relref "/operate/rs/installing-upgrading/configuring/change-location-socket-files.md" >}}) after cluster setup
+---
+Title: Persistent and ephemeral node storage
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Configure paths for persistent storage and ephemeral storage.
+linktitle: Persistent node storage
+toc: 'true'
+weight: 50
+---
+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]({{< relref "/operate/rs/installing-upgrading/install/customize-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.
+{{< /note >}}
+
+## 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.
+
+To set the frequency of syncs, you can configure [persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}})
+options for a database.
+    
+The persistent volume must be a storage area network (SAN)
+using an EXT4 or XFS file system and be connected as an external storage volume.
+    
+When using append-only file (AOF) persistence, use flash-based storage
+for the persistent volume.
+
+## Ephemeral storage
+
+Ephemeral storage is optional. If configured, temporary information that does not need to be persisted is stored by the cluster in the ephemeral storage.
+This improves performance and helps reduce the load on the persistent storage.
+
+Ephemeral storage must be a locally attached volume on each node.
+
+## Disk size requirements
+
+For disk size requirements, see:
+
+- [Hardware
+    requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}})
+    for general guidelines regarding the ideal disk size for each type of
+    storage.
+- [Disk size requirements for extreme write
+    scenarios]({{< relref "/operate/rs/clusters/optimize/disk-sizing-heavy-write-scenarios" >}})
+    for special considerations when dealing with a high rate of write
+    commands.
+---
+Title: Plan Redis Enterprise Software deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Plan a deployment of Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Plan deployment
+weight: 4
+---
+
+Before installing Redis Enterprise Software, you need to:
+
+- Set up your hardware. See [Hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) and [Persistent and ephemeral node storage 
+]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) for more information.
+
+- Choose your [deployment platform]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+    Redis Enterprise Software supports a variety of platforms, including:
+
+    - Multiple Linux distributions (Ubuntu, Red Hat Enterprise Linux (RHEL), IBM CentOS, Oracle Linux)
+    - [Amazon AWS AMI]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/configuring-aws-instances" >}})
+    - [Docker container]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) (for development and testing only)
+    - [Kubernetes]({{< relref "/operate/kubernetes" >}})
+
+    For more details, see [Supported platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}}).
+
+- Open appropriate [network ports]({{< relref "/operate/rs/networking/port-configurations.md" >}}) in the firewall to allow connections to the nodes.
+
+- Configure [cluster DNS]({{< relref "/operate/rs/networking/cluster-dns.md" >}}) so that cluster nodes can reach each other by DNS names.
+- By default, the installation process requires an internet connection to install dependencies and synchronize the operating system clock. To learn more, see [Offline installation]({{< relref "/operate/rs/installing-upgrading/install/offline-installation" >}}).
+
+- [Configure different mount points for data and log directories]({{<relref "/operate/rs/installing-upgrading/install/customize-install-directories#config-diff-data-log-dirs">}}).
+
+## Next steps
+
+After you finish planning your deployment, you can:
+
+- [Download an installation package]({{< relref "/operate/rs/installing-upgrading/install/prepare-install/download-install-package" >}}).
+
+- [Prepare to install]({{< relref "/operate/rs/installing-upgrading/install/prepare-install" >}}) Redis Enterprise Software.
+
+- [View installation questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions" >}}) and prepare answers before installation.
+---
+Title: Hardware requirements
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Redis Enterprise Software hardware requirements for development and production
+  environments.
+linkTitle: Hardware requirements
+weight: 20
+---
+{{< embed-md "hardware-requirements-embed.md" >}}
+
+## Sizing considerations
+
+### General database sizing {#general-sizing}
+
+Factors to consider when sizing your database.
+
+- **Dataset size** – Your limit should be greater than your dataset size to leave room for overhead.
+- **Database throughput** – High throughput needs more shards, leading to a higher memory limit.
+- [**Modules**]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) – Using modules with your database consumes more memory.
+- [**Database clustering**]({{< relref "/operate/rs/databases/durability-ha/clustering" >}}) – Allows you to spread your data into shards across multiple nodes.
+- [**Database replication**]({{< relref "/operate/rs/databases/durability-ha/replication" >}}) – Enabling replication doubles memory consumption.
+
+### Active-Active database sizing {#active-active-sizing}
+
+Additional factors for sizing Active-Active databases:
+
+- [**Active-Active replication**]({{< relref "/operate/rs/databases/active-active" >}}) – Requires double the memory of regular replication, which can be up to two times (2x) the original data size per instance.
+- [**Database replication backlog**]({{< relref "/operate/rs/databases/durability-ha/replication#database-replication-backlog" >}}) – For synchronization between shards. By default, this is set to 1% of the database size.
+- [**Active-Active replication backlog**]({{< relref "/operate/rs/databases/active-active/manage#replication-backlog" >}}) – For synchronization between clusters. By default, this is set to 1% of the database size.
+
+{{<note>}}
+Active-Active databases have a lower threshold for activating the eviction policy, because it requires propagation to all participating clusters. The eviction policy starts to evict keys when one of the Active-Active instances reaches 80% of its memory limit.
+{{</note>}}
+
+### Sizing databases with Auto Tiering enabled  {#redis-on-flash-sizing}
+
+Additional factors for sizing  databases with Auto Tiering enabled:
+
+- [**Database persistence**]({{< relref "/operate/rs/databases/configure/database-persistence#redis-on-flash-data-persistence" >}}) – Auto Tiering uses dual database persistence where both the primary and replica shards persist to disk. This may add some processor and network overhead, especially in cloud configurations with network-attached storage.
+
+---
+Title: Customize installation directories
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Customize Redis Enterprise Software installation directories.
+linkTitle: Customize install locations
+weight: 30
+---
+
+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.
+
+- If a `redislabs` directory already exists in the path that you specify, the installation fails.
+
+- All nodes in a cluster must be installed with the same file locations.
+
+- Custom installation directories are not supported for databases using Auto Tiering.
+
+- [Configure different mount points for data and log directories](#config-diff-data-log-dirs).
+
+## Specify file locations
+
+You can specify these file locations:
+
+| Files               | Installer flag | Example parameter | Example file location |
+| ------------------- | -------------- | ----------------- | --------------------- |
+| Binaries files      | --install-dir  | /opt              | /opt/redislabs        |
+| Configuration files | --config-dir   | /etc/opt          | /etc/opt/redislabs    |
+| Data and log files  | --var-dir      | /var/opt          | /var/opt/redislabs    |
+
+These files are not in the custom directories:
+
+- OS files
+    - /etc/cron.d/redislabs
+    - /etc/firewalld/services
+    - /etc/firewalld/services/redislabs-clients.xml
+    - /etc/firewalld/services/redislabs.xml
+    - /etc/ld.so.conf.d/redislabs_ldconfig.conf.tmpl
+    - /etc/logrotate.d/redislabs
+    - /etc/profile.d/redislabs_env.sh
+    - /usr/lib/systemd/system/rlec_supervisor.service.tmpl
+    - /usr/share/selinux/mls/redislabs.pp
+    - /usr/share/selinux/targeted/redislabs.pp
+
+- Installation reference files
+    - /etc/opt/redislabs/redislabs_custom_install_version
+    - /etc/opt/redislabs/redislabs_env_config.sh
+
+To specify directories during [installation]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}), include installer flags as [command-line options]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) when you run the `install.sh` script. For example:
+
+```sh
+sudo ./install.sh --install-dir <path> --config-dir <path> --var-dir <path>
+```
+
+## Configure different mount points for data and log directories {#config-diff-data-log-dirs}
+
+To configure different mount points for data and log directories, use symbolic links:
+
+1. Create a symbolic link for the data directory:
+
+    ```sh
+    ln -s /var/opt/redislabs/data </path/to/data/mount/point>
+    ```
+
+1. Create a symbolic link for the log directory:
+
+    ```sh
+    ln -s /var/opt/redislabs/log </path/to/log/mount/point>
+    ```
+
+## Limitations
+
+Several Redis Enterprise Software installation reference files are installed to the directory `/etc/opt/redislabs/` even if you use custom installation directories.
+
+As a workaround to install Redis Enterprise Software without using any root directories, do the following before installing Redis Enterprise Software:
+
+1. Create all custom, non-root directories you want to use with Redis Enterprise Software.
+
+1. Mount `/etc/opt/redislabs` to one of the custom, non-root directories.
+---
+Title: Offline installation
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: If you install Redis Enterprise Software on a machine with no internet
+  connection, you need to perform two tasks manually.
+linkTitle: Offline installation
+weight: 60
+---
+By default, the installation process requires an internet connection to
+enable installing dependency packages and for [synchronizing the
+operating system clock]({{< relref "/operate/rs/clusters/configure/sync-clocks.md" >}}) 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.
+
+## Set up NTP time synchronization
+
+At the end of the installation, the process asks if you want to set up NTP time synchronization. If you choose `Yes` while you are not connected to the internet, the action fails and displays the appropriate error message, but the installation completes successfully. Despite the successful completion of the installation, you still have to configure all nodes for [NTP time synchronization]({{< relref "/operate/rs/clusters/configure/sync-clocks.md" >}}).
+---
+Title: Customize system user and group
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Specify the user and group who own all Redis Enterprise Software processes.
+linkTitle: Customize user and group
+weight: 40
+---
+
+By default, Redis Enterprise Software is installed with the user:group `redislabs:redislabs`. See [Access control]({{< relref "/operate/rs/security/access-control" >}}) for user and group security information.
+
+During installation, you can specify the user and group that own all Redis Enterprise Software processes.
+
+If you specify the user only, then installation is run with the primary group that the user belongs to.
+
+{{< note >}}
+- Custom installation user is supported on Red Hat Enterprise Linux.
+- When you install with custom directories, the installation does not run as an RPM file.
+- You must create the user and group before attempting to install Redis Software.
+- You can specify an LDAP user as the installation user.
+{{< /note >}}
+
+To customize the user or group during [installation]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}), include the `--os-user` or `--os-group` [command-line options]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) when you run the `install.sh` script. For example:
+
+```sh
+sudo ./install.sh --os-user <user> --os-group <group>
+```
+
+---
+Title: Download a Redis Enterprise Software installation package
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Download a Redis Enterprise Software installation package.
+linkTitle: Download installation package
+weight: 20
+---
+
+To download the installation package for any of the supported platforms:
+
+1. Go to the [Redis download page](https://cloud.redis.io/#/rlec-downloads).
+1. Sign in with your Redis credentials or create a new account.
+1. 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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/configuring-aws-instances" >}}).
+{{< /note >}}
+---
+Title: Ensure port availability
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Make sure required ports are available.
+linkTitle: Ensure port availability
+weight: 40
+---
+
+Before [installing Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/install" >}}), make sure all required ports are available.
+
+{{<embed-md "port-availability-embed.md">}}
+
+## Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+## OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+---
+Title: Prepare to install Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Prepare to install Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Prepare to install
+weight: 6
+---
+
+Before you install Redis Enterprise Software:
+
+- [Download an installation package]({{< relref "/operate/rs/installing-upgrading/install/prepare-install/download-install-package" >}}).
+
+- [View installation questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions" >}}) and optionally prepare answers before installation.
+
+- Review the [security considerations]({{< relref "/operate/rs/security/" >}}) for your deployment.
+
+- Check that you have root-level access to each node, either directly or with `sudo`.
+
+- Check that all [required ports are available]({{< relref "/operate/rs/installing-upgrading/install/prepare-install/port-availability" >}}).
+
+- [Turn off Linux swap]({{< relref "/operate/rs/installing-upgrading/configuring/linux-swap.md" >}}) on all cluster nodes.
+
+- If you require the `redislabs` UID (user ID) and GID (group ID) numbers to be the same on all the nodes, create the `redislabs` user and group with the required numbers on each node.
+
+- If you want to use Auto Tiering for your databases, see [Auto Tiering installation]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux#auto-tiering-installation" >}}).
+
+## Next steps
+
+- View [installation script options]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) before starting the installation.
+
+- [Install Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/install" >}}).
+---
+Title: Install Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Install Redis Enterprise Software on Linux.
+hideListLinks: true
+linkTitle: Install
+weight: 35
+---
+
+After you [plan your deployment]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment" >}}), [download a Redis Enterprise Software installation package]({{< relref "/operate/rs/installing-upgrading/install/prepare-install/download-install-package" >}}), and finish [installation preparation]({{< relref "/operate/rs/installing-upgrading/install/prepare-install" >}}):
+
+1. [Install the Redis Enterprise Software package]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on one of the nodes in the cluster.
+
+1. Repeat this process for each node in the cluster.
+
+For installation on machines without an internet connection, see [Offline installation]({{< relref "/operate/rs/installing-upgrading/install/offline-installation" >}}).
+
+## Permissions and access
+
+- Redis Enterprise Software installation creates the `redislabs:redislabs` user and group. 
+
+    Assigning other users to the `redislabs` group is optional. Users belonging to the `redislabs` group have permission to read and execute (e.g. use the `rladmin` status command) but are not allowed to write (or delete) files or directories.
+
+- Redis Enterprise Software is certified to run with permissions set to `750`, an industry standard.
+
+    {{<warning>}}
+Do not reduce permissions to `700`. This configuration has not been tested and is not supported.
+    {{</warning>}}
+
+- Redis Enterprise Software requires `umask` to be `0022` during installation to correctly set permissions for the installed directories and files.
+
+## More info and options
+
+If you've already installed Redis Enterprise Software, you can also:
+
+- [Upgrade an existing deployment]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}).
+
+- [Uninstall an existing deployment]({{< relref "/operate/rs/installing-upgrading/uninstalling.md" >}}).
+
+To learn more about customization and find answers to related questions, see:
+
+- [CentOS/RHEL Firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/networking/cluster-lba-setup.md" >}})
+- [File locations]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Supported platforms]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms.md" >}})
+- [Manage installation questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/networking/mdns.md" >}})
+- [User and group ownership]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}})
+
+## Next steps
+
+After your cluster is set up with nodes, you can:
+
+- [Add users]({{< relref "/operate/rs/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/security/access-control" >}}).
+- [Create databases]({{< relref "/operate/rs/databases/create" >}}) to use with your applications.
+
+---
+Title: Installation script command-line options
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Command-line options for the install.sh script.
+linkTitle: Installation script options
+weight: 20
+---
+
+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<br/>See [Manage install questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions" >}})|
+| <nobr>`-c <answer file>`</nobr> | Specify answer file used to respond to install prompts<br/>See [Manage install questions]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions" >}})|
+| <nobr>`-s <socket dir>`</s> | Specify directory for redislabs unix sockets  _(new installs only)_|
+| <nobr>`--install-dir <dir>`</nobr> | Specifies installation directory _(new installs only)_ <br/> See [Customize install locations]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}})|  
+| <nobr>`--config-dir <dir>` | Configuration file directory *(new installs only)* <br/>See [Customize install locations]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}})|
+| <nobr>`--var-dir <dir>`</nobr> | Var directory used for installation *(new installs only)* <br/>See [Customize install locations]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}})|
+| <nobr>`--os-user <user>`| Operating system user account associated with install; default: `redislabs`<br/>See [Customize user and group]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group" >}}) *(new installs only)*|
+|<nobr>`--os-group <group>` | Operating system group associated with install; default: `redislabs`<br/>See [Customize user and group]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group" >}}) *(new installs only)* |
+---
+Title: Redis Enterprise Software product lifecycle
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The product lifecycle of Redis Enterprise Software.
+linkTitle: Product lifecycle
+weight: 100
+tocEmbedHeaders: true
+---
+The Redis Enterprise Software product lifecycle fully reflects the [subscription agreement](https://redis.com/software-subscription-agreement).
+However, for any discrepancy between the two policies, the subscription agreement prevails.
+
+Redis Enterprise modules follow the [modules lifecycle]({{< relref "/operate/oss_and_stack/stack-with-enterprise/modules-lifecycle" >}}).
+
+## Release numbers
+
+Redis uses a four-place numbering scheme to designate released versions of its products.
+The format is “Major1.Major2.Minor-Build”.
+
+- Major sections of the version number represents fundamental changes and additions in
+    capabilities to Redis  Enterprise Software. The Major1 and Major2 part of the
+    version number are incremented based on the size and scale of the changes in each
+    release.
+- The Minor section of the version number represents quality improvements, fixes to
+    existing capabilities, and new capabilities which are typically minor, feature-flagged, or optional. 
+- Build number is incremented with any changes to the product. Build number is
+    incremented with each build when any change is made to the binaries.
+
+Redis Enterprise Software typically gets two major releases every year but the product shipping cycles may vary.
+Maintenance releases, typically available on the last minor release of the current major1.major2 release are typically made available on a monthly cadence, although cycles may vary.
+
+## End-of-life schedule {#endoflife-schedule}
+
+For Redis Enterprise Software versions 6.2 and later, the end-of-life (EOL) for each major release occurs 24 months after the formal release of the subsequent major version. Monthly maintenance will be provided on the last minor release of the major1.major2 releases.
+This update to the EOL policy allows a lead time of at least 24 months to upgrade to the new release after it is available.
+
+
+| Version - Release date | End of Life (EOL)  |
+| ----------------------------------------- | ------------------ |
+| 7.8 – November 2024				        | - |
+| 7.4 – February 2024				        | November 30, 2026 |
+| 7.2 – August 2023				            | February 28, 2026 |
+| 6.4 – February 2023						| August 31, 2025 |
+| 6.2 – August 2021                         | February 28, 2025  |
+| 6.0 – May 2020                            | May 31, 2022  |
+| 5.6 – April 2020                          | October 31, 2021  |
+| 5.4 – December 2018                       | December 31, 2020  |
+| 5.2 – June 2018                           | December 31, 2019  |
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+For detailed upgrade instructions, see [Upgrade a Redis Enterprise Software cluster]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster">}}).
+
+{{<note>}}
+Redis Enterprise for Kubernetes has its own support lifecycle, which accounts for the Kubernetes distribution lifecycle. For details, see [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}}).
+{{</note>}}
+---
+LinkTitle: Uninstall
+Title: Uninstall Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+weight: 70
+---
+
+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]({{<relref "/operate/rs/clusters/remove-node">}}).
+
+## Uninstall Redis Enterprise Software
+
+To uninstall Redis Enterprise Software from a cluster node:
+
+1. Navigate to the script's location, which is in `/opt/redislabs/bin/` by default.
+
+1. Run the uninstall script as the root user:
+
+    ```sh
+    sudo ./rl_uninstall.sh
+    ```
+
+When you run the uninstall script on a node, it only uninstalls Redis Enterprise Software from that node. To uninstall Redis Enterprise Software for the entire cluster, run the uninstall script on each cluster node.
+---
+Title: Upgrade a cluster's operating system
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a Redis Enterprise Software cluster's operating system to a later
+  major version.
+linkTitle: Upgrade operating system
+toc: 'true'
+weight: 70
+---
+
+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:
+
+1. [Upgrade all nodes in the cluster]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster" >}}) to a Redis Enterprise Software version that supports the OS's current version and upgrade version.
+
+    To learn which versions of Redis Enterprise Software support specific OS versions, see [Supported platforms]({{< relref "/operate/rs/references/supported-platforms#supported-platforms" >}}).
+
+1. If the cluster contains any databases that use modules:
+
+    1. Update all nodes in the cluster to [Redis Enterprise Software version 7.2.4-52]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases" >}}) or later before you upgrade the OS.
+
+    1. Check the status of modules using [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}):
+
+        ```sh
+        rladmin status modules
+        ```
+
+        The output lists the module versions installed on the cluster and the module versions used by existing databases:
+
+        ```sh
+        CLUSTER MODULES:
+        MODULE                                                                      VERSION                            
+        RedisBloom                                                                  2.6.3                              
+        RediSearch 2                                                                2.8.4                              
+        RedisGears                                                                  2.0.12                             
+        RedisGraph                                                                  2.10.12                            
+        RedisJSON                                                                   2.6.6                              
+        RedisTimeSeries                                                             1.10.6                             
+
+        DATABASE MODULES:
+        DB:ID    NAME       MODULE              VERSION     ARGS                     STATUS                            
+        db:1     db1        RediSearch 2        2.6.9       PARTITIONS AUTO          OK, OLD MODULE VERSION            
+        db:1     db1        RedisJSON           2.4.7                                OK, OLD MODULE VERSION  
+        ```
+
+    1. Upload module packages for the target OS version to a node in the existing cluster. See [Install a module on a cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}) for instructions.
+
+        {{<note>}}
+The uploaded module packages have the following requirements:
+
+- The module is compiled for the target OS version.
+    
+- The module version matches the version currently used by databases.
+        {{</note>}}
+
+1. If the cluster uses custom directories, make sure the OS upgrade version also supports custom directories, and specify the same custom directories during installation for all nodes. See [Customize installation directories]({{< relref "/operate/rs/installing-upgrading/install/customize-install-directories" >}}) for details.
+
+## Perform OS rolling upgrade
+
+To upgrade the cluster's operating system, use one of the following rolling upgrade methods:
+
+- [Extra node method](#extra-node-upgrade) - recommended if you have additional resources available
+
+- [Replace node method](#replace-node-upgrade) - recommended if you cannot temporarily allocate additional resources
+
+### Extra node upgrade method {#extra-node-upgrade}
+
+1. Complete all [prerequisites](#prerequisites) before starting the rolling upgrade.
+
+1. Create a node with the OS upgrade version.
+
+1. [Install the cluster's current Redis Enterprise Software version]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on the new node using the installation package for the OS upgrade version.
+
+1. [Add the new node]({{< relref "/operate/rs/clusters/add-node" >}})  to the cluster.
+
+1. [Remove one node]({{< relref "/operate/rs/clusters/remove-node#remove-a-node" >}}) running the earlier OS version from the cluster.
+
+1. Repeat the previous steps until all nodes with the earlier OS version are removed. If the final node to remove from the cluster is the primary node, [demote it]({{<relref "/operate/rs/clusters/change-node-role#demote-primary-node">}}) to a secondary node before you remove it.
+
+### Replace node upgrade method {#replace-node-upgrade}
+
+1. Complete all [prerequisites](#prerequisites) before starting the rolling upgrade.
+
+1. [Remove a node]({{< relref "/operate/rs/clusters/remove-node#remove-a-node" >}}) with the earlier OS version from the cluster.
+
+1. Uninstall Redis Enterprise Software from the removed node:
+
+    ```sh
+    sudo ./rl_uninstall.sh
+    ```
+
+1. Either upgrade the existing node to the OS upgrade version, or create a new node with the OS upgrade version.
+
+1. [Install the cluster's current Redis Enterprise Software version]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on the upgraded node using the installation package for the OS upgrade version.
+
+1. [Add the new node]({{< relref "/operate/rs/clusters/add-node" >}}) to the cluster.
+
+    If you want to reuse the removed node's ID when you add the node to the cluster, run [`rladmin cluster join`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/join" >}}) with the `replace_node` flag:
+
+    ```sh
+    rladmin cluster join nodes <cluster_member_ip_address> username <username> password <password> replace_node <node_id>
+    ```
+
+1. Verify node health:
+
+    1. Run `rlcheck` on all nodes:
+
+        ```sh
+        rlcheck
+        ```
+
+        The output lists the result of each verification test:
+
+        ```sh
+        ##### Welcome to Redis Enterprise Cluster settings verification utility ####
+        Running test: verify_bootstrap_status
+		                PASS
+        ...
+        Running test: verify_encrypted_gossip
+		                PASS
+        Summary:
+        -------
+        ALL TESTS PASSED.
+        ```
+
+        For healthy nodes, the expected output is `ALL TESTS PASSED`.
+
+    1. Run [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) on the new node:
+
+        ```sh
+        rladmin status extra all
+        ```
+
+        The expected output is the `OK` status for the cluster, nodes, endpoints, and shards:
+
+        ```sh
+        CLUSTER:
+        OK. Cluster master: 2 (<IP.address>)
+        Cluster health: OK, [0, 0.0, 0.0]
+        failures/minute - avg1 0.00, avg15 0.00, avg60 0.00.
+        ...
+        ```
+
+1. Repeat the previous steps until all nodes with the earlier OS version are replaced. If the final node to remove from the cluster is the primary node, [demote it]({{<relref "/operate/rs/clusters/change-node-role#demote-primary-node">}}) to a secondary node before you remove it.
+---
+Title: Upgrade a Redis Software cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a cluster to a later version of Redis Software.
+linkTitle: Upgrade cluster
+toc: 'true'
+weight: 30
+tocEmbedHeaders: true
+---
+
+Before you upgrade a cluster to a later Redis Software version, review the [supported upgrade paths](#supported-upgrade-paths) and [prerequisites](#upgrade-prerequisites).
+
+To upgrade a cluster's Redis Software version, use one of the following methods:
+
+- [In-place upgrade](#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](#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.
+
+{{<embed-md "rs-upgrade-paths.md">}}
+
+See the [Redis Enterprise Software product lifecycle]({{<relref "/operate/rs/installing-upgrading/product-lifecycle">}}) for more information about release numbers and the end-of-life schedule.
+
+{{<note>}}
+Redis Enterprise for Kubernetes has its own support lifecycle, which accounts for the Kubernetes distribution lifecycle. For details, see [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}}).
+{{</note>}}
+
+## Upgrade prerequisites
+
+Before upgrading a cluster:
+
+- Verify access to [rlcheck]({{< relref "/operate/rs/references/cli-utilities/rlcheck/" >}}) and [rladmin]({{< relref "/operate/rs/references/cli-utilities/rladmin/#use-the-rladmin-shell" >}}) commands
+
+- Verify that you meet the upgrade path requirements for the target cluster version and review the relevant [release notes]({{< relref "/operate/rs/release-notes" >}}) for any preparation instructions.
+
+- [Upgrade your databases]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-database">}}) to a version that is supported by the target Redis Enterprise Software version before upgrading the cluster. We recommend you upgrade the databases to the latest supported version if possible. Make sure to test the upgrade in a non-production environment to determine any impact.
+
+- Avoid changing the database configuration or performing other cluster management operations during the cluster upgrade process, as this might cause unexpected results.
+
+- Upgrade the cluster's primary (master) node first. To identify the primary node, use one of the following methods:
+
+    - **Nodes** screen in the new Cluster Manager UI (only available for Redis Enterprise versions 7.2 and later)
+
+    - [`rladmin status nodes`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-nodes" >}}) command
+    
+    - [`GET /nodes/status`]({{< relref "/operate/rs/references/rest-api/requests/nodes/status#get-all-nodes-status" >}}) REST API request
+
+## In-place upgrade
+
+Starting with the primary node, follow these steps for every node in the cluster. To ensure cluster availability, upgrade each node separately.
+
+1. Complete all [prerequisites](#upgrade-prerequisites) before starting the upgrade.
+
+1.  Verify node operation with the following commands:
+
+    ``` shell
+    $ rlcheck
+    $ rladmin status extra all
+    ```
+
+    {{<warning>}}
+Do not proceed if any shard, node, or endpoint is not `OK`.
+    {{</warning>}}
+
+2.  Download the Redis Enterprise Software installation package to the machine running the node from the Download Center on [https://cloud.redis.io](https://cloud.redis.io).  
+
+3.  Extract the installation package:
+
+    ```sh
+    tar vxf <tarfile name>
+    ```
+
+    {{<note>}}
+You cannot change the installation path or the user during the upgrade.
+    {{</note>}}
+
+1.  Run the install command. See [installation script options]({{< relref "/operate/rs/installing-upgrading/install/install-script" >}}) for a list of command-line options you can add to the following command:
+
+    ``` shell
+    sudo ./install.sh
+    ```
+
+    The installation script automatically recognizes the upgrade and responds accordingly.
+
+    The upgrade replaces all node processes, which might briefly interrupt any active connections.
+
+2.  Verify the node was upgraded to the new version and is still operational:
+
+    ``` shell
+    $ rlcheck
+    $ rladmin status extra all
+    ```
+
+3.  Visit the Cluster Manager UI.
+
+    If the Cluster Manager UI was open in a web browser during the upgrade, refresh the browser to reload the console.
+
+## Rolling upgrade
+
+To perform a rolling upgrade of the cluster, use one of the following methods:
+
+- [Extra node method](#extra-node-upgrade) - recommended if you have additional resources available
+
+- [Replace node method](#replace-node-upgrade) - recommended if you cannot temporarily allocate additional resources
+
+### Extra node upgrade method {#extra-node-upgrade}
+
+1. Complete all [prerequisites](#upgrade-prerequisites) before starting the rolling upgrade.
+
+1. [Install a later version of Redis Software]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on a new node.
+
+1. [Add the new node]({{< relref "/operate/rs/clusters/add-node" >}}) to the cluster.
+
+1. [Promote the first new node]({{<relref "/operate/rs/clusters/change-node-role/#promote-secondary-node">}}) to become the primary node.
+
+1. [Remove one node]({{< relref "/operate/rs/clusters/remove-node#remove-a-node" >}}) running the earlier Redis Software version from the cluster.
+
+1. Repeat the previous steps until all nodes with the earlier Redis Software version are removed. If the final node to remove from the cluster is the primary node, [demote it]({{<relref "/operate/rs/clusters/change-node-role#demote-primary-node">}}) to a secondary node before you remove it.
+
+### Replace node upgrade method {#replace-node-upgrade}
+
+1. Complete all [prerequisites](#upgrade-prerequisites) before starting the rolling upgrade.
+
+1. [Remove a node]({{< relref "/operate/rs/clusters/remove-node#remove-a-node" >}}) with the earlier Redis Software version from the cluster.
+
+1. Uninstall Redis Enterprise Software from the removed node:
+
+    ```sh
+    sudo ./rl_uninstall.sh
+    ```
+
+1. [Install a later version of Redis Software]({{< relref "/operate/rs/installing-upgrading/install/install-on-linux" >}}) on the removed node or a new node.
+
+1. [Add the new node]({{< relref "/operate/rs/clusters/add-node" >}}) to the cluster.
+
+    If you want to reuse the removed node's ID when you add the node to the cluster, run [`rladmin cluster join`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/join" >}}) with the `replace_node` flag:
+
+    ```sh
+    rladmin cluster join nodes <cluster_member_ip_address> username <username> password <password> replace_node <node_id>
+    ```
+
+1. [Promote the first new node]({{<relref "/operate/rs/clusters/change-node-role/#promote-secondary-node">}}) to become the primary node.
+
+1. Verify node health:
+
+    1. Run `rlcheck` on all nodes:
+
+        ```sh
+        rlcheck
+        ```
+
+        The output lists the result of each verification test:
+
+        ```sh
+        ##### Welcome to Redis Enterprise Cluster settings verification utility ####
+        Running test: verify_bootstrap_status
+		                PASS
+        ...
+        Running test: verify_encrypted_gossip
+		                PASS
+        Summary:
+        -------
+        ALL TESTS PASSED.
+        ```
+
+        For healthy nodes, the expected output is `ALL TESTS PASSED`.
+
+    1. Run [`rladmin status`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) on the new node:
+
+        ```sh
+        rladmin status extra all
+        ```
+
+        The expected output is the `OK` status for the cluster, nodes, endpoints, and shards:
+
+        ```sh
+        CLUSTER:
+        OK. Cluster master: 2 (<IP.address>)
+        Cluster health: OK, [0, 0.0, 0.0]
+        failures/minute - avg1 0.00, avg15 0.00, avg60 0.00.
+        ...
+        ```
+
+1. Repeat the previous steps until all nodes with the earlier Redis Software version are replaced. If the final node to remove from the cluster is the primary node, [demote it]({{<relref "/operate/rs/clusters/change-node-role#demote-primary-node">}}) to a secondary node before you remove it.
+
+## After cluster upgrade
+
+After all nodes are upgraded, the cluster is fully upgraded. Certain features introduced in the new version of Redis Software only become available after upgrading the entire cluster.
+
+After upgrading from version 6.0.x to 6.2.x, restart `cnm_exec` on each cluster node to enable more advanced state machine handling capabilities:
+
+```sh
+supervisorctl restart cnm_exec
+```
+---
+Title: Upgrade an Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade an Active-Active database.
+linkTitle: Active-Active databases
+weight: 70
+---
+
+When you upgrade an [Active-Active (CRDB) database]({{< relref "/operate/rs/databases/active-active" >}}), you can also upgrade the CRDB protocol version and feature version.
+
+## CRDB protocol version guidelines
+
+Redis Enterprise Software versions 5.4.2 and later use CRDB protocol version 1 to help support Active-Active features.
+
+CRDB protocol version 1 is backward compatible, which means Redis Enterprise v5.4.2 CRDB instances can understand write operations from instances using the earlier CRDB protocol version 0.
+
+After you upgrade one instance's CRDB protocol to version 1:
+
+- Any instances that use CRDB protocol version 1 can receive updates from both version 1 and version 0 instances.
+
+- However, instances that still use CRDB protocol version 0 cannot receive write updates from version 1 instances.
+
+- After you upgrade an instance from CRDB protocol version 0 to version 1, it automatically receives any missing write operations.
+
+Follow these upgrade guidelines:
+
+- Upgrade all instances of a specific CRDB within a reasonable time frame to avoid temporary inconsistencies between the instances.
+
+- Make sure that you upgrade all instances of a specific CRDB before you do global operations on the CRDB, such as removing instances and adding new instances.
+
+- As of v6.0.20, protocol version 0 is deprecated and support will be removed in a future version.
+
+- To avoid upgrade failures, update all Active-Active databases to protocol version 1 _before_ upgrading Redis Enterprise Software to v6.0.20 or later.
+
+## Feature version guidelines
+
+Starting with version 5.6.0, a new feature version (also called a _feature set version_) helps support new Active-Active features.
+
+When you update the feature version for an Active-Active database, the feature version is updated for all database instances.
+    
+Follow these upgrade guidelines:
+
+- As of v6.0.20, feature version 0 is deprecated and support will be removed in a future version.
+
+- To avoid upgrade failures, update all Active-Active databases to protocol version 1 _before_ upgrading Redis Enterprise Software to v6.0.20 or later.
+
+## Upgrade Active-Active database instance
+
+To upgrade an Active-Active database (CRDB) instance:
+
+1. [Upgrade Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster" >}}) on each node in the clusters where the Active-Active instances are located.
+
+1. To see the status of your Active-Active instances, run: 
+
+    ```sh
+    rladmin status
+    ```
+
+    The statuses of the Active-Active instances on the node can indicate:
+
+    - `OLD REDIS VERSION`
+    - `OLD CRDB PROTOCOL VERSION`
+    - `OLD CRBD FEATURESET VERSION`
+
+    {{< image filename="/images/rs/crdb-upgrade-node.png" >}}
+
+1. To upgrade each Active-Active instance and its modules, including the Redis version and CRDB protocol version, run:
+
+    ```sh
+    rladmin upgrade db <database_name | database_ID>
+    ```
+
+    If the protocol version is old, read the warning message carefully and confirm.
+
+    {{< image filename="/images/rs/crdb-upgrade-protocol.png" >}}
+
+    The Active-Active instance uses the new Redis version and CRDB protocol version.
+
+    Use the `keep_crdt_protocol_version` option to upgrade the database feature version 
+without upgrading the CRDB protocol version.
+
+    If you use this option, make sure that you upgrade the CRDB protocol soon after with the [`rladmin upgrade db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db" >}}) command.
+
+    You must upgrade the CRDB protocol before you update the CRDB feature set version.
+
+1. If the feature set version is old, you must upgrade all of the Active-Active instances. Then, to update the feature set for each active-active database, run:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <CRDB-GUID> --featureset-version yes
+    ```
+
+    You can retrieve the `<CRDB-GUID>` with the following command:
+
+    ```sh
+    crdb-cli crdb list
+    ```
+
+    Look for the fully qualified domain name (CLUSTER-FDQN) of your cluster and use the associated GUID:
+
+    ```sh
+    CRDB-GUID                             NAME    REPL-ID  CLUSTER-FQDN
+    700140c5-478e-49d7-ad3c-64d517ddc486  aatest  1        aatest1.example.com
+    700140c5-478e-49d7-ad3c-64d517ddc486  aatest  2        aatest2.example.com
+    ```
+
+1. Update module information in the CRDB configuration using the following command syntax:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid <guid> --default-db-config \
+    '{ "module_list": 
+      [
+        { 
+          "module_name": "<module1_name>",
+          "semantic_version": "<module1_version>" 
+        },
+        { 
+          "module_name": "<module2_name>",
+          "semantic_version": "<module2_version>" 
+        }
+      ]}'
+    ```
+
+    For example:
+
+    ```sh
+    crdb-cli crdb update --crdb-guid 82a80988-f5fe-4fa5-bca0-aef2a0fd60db --default-db-config \
+    '{ "module_list": 
+      [
+        {
+          "module_name": "search",
+          "semantic_version": "2.4.6"
+        },
+        {
+          "module_name": "ReJSON",
+          "semantic_version": "2.4.5"
+        }
+      ]}' 
+    ```
+---
+Title: Upgrade a Redis Enterprise Software database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Upgrade a Redis Enterprise Software database.
+linkTitle: Upgrade database
+weight: 50
+---
+
+## Default Redis database versions {#default-db-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]({{< relref "/operate/rs/references/rest-api/requests/bdbs" >}}) or [`rladmin upgrade db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/upgrade#upgrade-db" >}}).
+
+Redis Enterprise Software v6.x includes two Redis database versions: 6.0 and 6.2.
+As of version 7.2, Redis Enterprise Software includes three Redis database versions.
+
+To view available Redis database versions:
+
+- In the Cluster Manager UI, see **Redis database versions** on the **Cluster > Configuration** screen.
+
+- Send a [`GET /nodes` REST API request]({{< relref "/operate/rs/references/rest-api/requests/nodes" >}}) and see `supported_database_versions` in the response.
+
+The default Redis database version differs between Redis Enterprise releases as follows:
+
+<a name="db-versions-table"></a>
+| Redis<br />Software | Bundled Redis<br />DB versions | Default DB version<br />(upgraded/new databases) |
+|-------|----------|-----|
+| 7.8.x | 6.2, 7.2, 7.4 | 7.4 |
+| 7.4.x | 6.0, 6.2, 7.2 | 7.2 |
+| 7.2.4 | 6.0, 6.2, 7.2 | 7.2 |
+| 6.4.2 | 6.0, 6.2 | 6.2 |
+| 6.2.x | 6.0, 6.2 | 6.0 |
+
+
+The upgrade policy is only relevant for Redis Enterprise Software versions 6.2.4 through 6.2.18. For more information about upgrade policies, see the [6.2 version of this document](https://docs.redis.com/6.2/rs/installing-upgrading/upgrading/#redis-upgrade-policy).
+
+## Upgrade prerequisites
+
+Before upgrading a database:
+
+- Review the relevant [release notes]({{< relref "/operate/rs/release-notes" >}}) for any preparation instructions.
+
+- Verify that both the [current database version and the target database version are supported](#db-versions-table) by the cluster's Redis Enterprise Software version.
+
+    To determine the current database version:
+
+    - Use the Cluster Manager UI to open the **Configuration** tab for the database and select {{< image filename="/images/rs/icons/info-icon.png#no-click" alt="The About database button" width="18px" class="inline" >}} **About**.
+
+    - _(Optional)_ Use the [`rladmin status extra all`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status" >}}) command to display configuration details:
+
+        ```sh
+        rladmin status extra all
+        ```
+    
+        When the database compatibility version is outdated, <nobr>`OLD REDIS VERSION`</nobr> appears in the command output.
+
+- Verify the cluster is fully upgraded and operational.
+
+    Use the Cluster Manager UI to display the **Configuration** tab for the cluster. The tab displays the cluster version information and the Redis database compatibility version.
+
+- Check client compatibility with the database version.
+
+    If you run Redis Stack commands with Go-Redis versions 9 and later or Lettuce versions 6 and later, set the client’s protocol version to RESP2 before upgrading your database to Redis version 7.2 to prevent potential application issues due to RESP3 breaking changes. See [Client prerequisites for Redis 7.2 upgrade]({{< relref "/operate/rs/references/compatibility/resp#client-prerequisites-for-redis-72-upgrade" >}}) for more details and examples.
+
+- To avoid data loss during the upgrade, [back up your data]({{< relref "/operate/rs/databases/import-export/schedule-backups" >}}).  
+
+    You can [export the data]({{< relref "/operate/rs/databases/import-export/export-data" >}}) to an external location, [enable replication]({{< relref "/operate/rs/databases/durability-ha/replication" >}}), or [enable persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}}).
+
+    When choosing how to back up data, keep the following in mind:
+
+    - To reduce downtime when replication is enabled, a failover is performed before restarting the primary (master) database.
+
+    - When persistence is enabled without replication, the database is unavailable during restart because the data is restored from the persistence file. AOF persistence restoration is slower than snapshot restoration.
+
+## Upgrade database
+
+To upgrade a database:
+
+1. Complete all [prerequisites](#upgrade-prerequisites) before starting the upgrade.
+
+1.  _(Optional)_  Back up the database to minimize the risk of data loss.
+
+1.  Use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin/upgrade" >}}) to upgrade the database. During the upgrade process, the database will restart without losing any data.
+
+    - To upgrade a database and its modules:
+
+        ``` shell
+        rladmin upgrade db <database name | database ID>
+        ```
+
+        Example of a successful upgrade:
+
+        ``` shell
+        rladmin> upgrade db demo
+        Monitoring d194c4a3-631c-4726-b799-331b399fc85c
+        active - SMUpgradeBDB init
+        active - SMUpgradeBDB wait_for_version
+        active - SMUpgradeBDB configure_shards
+        completed - SMUpgradeBDB
+        Done
+        ```
+
+    - To upgrade the database to a version other than the default version, use the `redis_version` parameter:
+
+        ```sh
+        rladmin upgrade db <database name | database ID> redis_version <version>
+        ```
+
+1. Check the Redis database compatibility version for the database to confirm the upgrade.  
+
+    To do so:
+
+    - Use the Cluster Manager UI to open the **Configuration** tab for the database and select {{< image filename="/images/rs/icons/info-icon.png#no-click" alt="The About database button" width="18px" class="inline" >}} **About**.
+
+    - Use [`rladmin status databases extra all`]({{< relref "/operate/rs/references/cli-utilities/rladmin/status#status-databases" >}}) to display a list of the databases in your cluster and their current Redis database compatibility version:
+
+        ```sh
+        rladmin status databases extra all
+        ```
+
+    Verify that the Redis version is set to the expected value.
+---
+Title: Upgrade an existing Redis Software deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: How to upgrade a cluster's Redis Software version, database version, and operating system.
+hideListLinks: true
+linkTitle: Upgrade
+weight: 60
+---
+
+## Upgrade Redis Software
+
+To upgrade Redis Software:
+
+1. Verify appropriate [network ports]({{< relref "/operate/rs/networking/port-configurations.md" >}}) are either open or used by Redis Software.
+
+1. Complete all [prerequisites]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#upgrade-prerequisites">}}) before starting the upgrade.
+
+1. Upgrade the software on all nodes of the cluster using one of the following methods:
+    
+    - [In-place upgrade]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#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]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster#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.
+
+## Upgrade Redis database
+
+[Upgrade each database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-database" >}}) in the cluster or [upgrade an Active-Active database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}}) to enable new features and important fixes.
+
+## Upgrade operating system
+
+To upgrade the cluster's operating system:
+
+1. Complete all [prerequisites]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os#prerequisites">}})  before starting the upgrade.
+
+2. Use one of the following rolling upgrade methods:
+
+    - [Extra node method]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os#extra-node-upgrade">}}) - Recommended if you have additional resources available.
+
+    - [Replace node method]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-os#replace-node-upgrade">}}) - Recommended if you cannot temporarily allocate additional resources.---
+LinkTitle: Socket file location
+Title: Change socket file locations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Change socket file locations.
+weight: $weight
+---
+
+## Default socket file locations
+
+There are two default locations for the socket files in Redis Enterprise Software:
+
+- `/tmp` - In clean installations of Redis Enterprise Software version earlier than 5.2.2
+- `/var/opt/redislabs/run` - In clean installations of Redis Enterprise Software version 5.2.2 and later
+
+    {{<note>}}
+The default location was changed in case you run any maintenance procedures that delete the `/tmp` directory.
+    {{</note>}}
+
+When you upgrade Redis Enterprise Software from an earlier version to 5.2.2 or later, the socket files are not moved to the new location by default. You need to specify the socket file location [during installation](#during-install).
+
+## Specify socket file location during install {#during-install}
+
+To specify the socket file location during a new installation, follow the [Install Redis Enterprise Software on Linux]({{<relref "/operate/rs/installing-upgrading/install/install-on-linux">}}) instructions, but use the `-s` [installation script option]({{<relref "/operate/rs/installing-upgrading/install/install-script">}}):
+
+```sh
+sudo ./install.sh -s </path/to/socket/files>
+```
+
+## Change socket file location for an existing cluster {#after-cluster-setup}
+
+Directly changing the socket file location directly is not supported for bootstrapped nodes. If you need to change the socket file location for an existing cluster, use one of the following methods instead:
+
+- [Replace nodes](#replace-nodes)
+
+- [Migrate the cluster using Replica Of](#migrate-replica-of)
+
+### Replace nodes {#replace-nodes}
+
+To change the socket file location for all nodes in a cluster, follow these steps:
+
+1. Install Redis Enterprise Software on a new node with the new socket file location. Follow the [Install Redis Enterprise Software on Linux]({{<relref "/operate/rs/installing-upgrading/install/install-on-linux">}}) instructions, but use the -s [installation script option]({{<relref "/operate/rs/installing-upgrading/install/install-script">}}):
+
+    ```sh
+    sudo ./install.sh -s </path/to/socket/files>
+    ```
+
+1. [Add the new node]({{<relref "/operate/rs/clusters/add-node">}}) to the existing cluster.
+
+1. [Remove a node]({{<relref "/operate/rs/clusters/remove-node#remove-a-node">}}) with the old socket file location.
+
+1. Repeat the previous steps until all nodes with the old socket file location have been replaced.
+
+### Migrate cluster using Replica Of {#migrate-replica-of}
+
+To migrate an existing cluster to a new cluster with a different socket file location:
+
+1. Create a new cluster with the new socket file location. To do so, follow the [Install Redis Enterprise Software on Linux]({{<relref "/operate/rs/installing-upgrading/install/install-on-linux">}}) instructions, but use the `-s` [installation script option]({{<relref "/operate/rs/installing-upgrading/install/install-script">}}):
+
+    ```
+    sudo ./install.sh -s </path/to/socket/files>
+    ```
+
+1. Use Replica Of to migrate your databases from the original cluster to the new cluster. For detailed steps, see the procedure to [configure Replica Of with different Redis Enterprise clusters]({{<relref "/operate/rs/databases/import-export/replica-of/create#different-cluster">}}).
+---
+Title: Configure swap for Linux
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Turn off Linux swap space.
+linkTitle: Linux swap configuration
+weight: $weight
+---
+Linux operating systems use swap space, which is enabled by default, to help manage memory (pages) by
+copying pages from RAM to disk. Due to the way Redis Enterprise Software
+utilizes and manages memory, it is best to prevent OS swapping. For more details, see [memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit.md" >}}). The
+recommendation is to turn off Linux swap completely in the OS.
+
+When you install or build the OS on the machine intended to host your Redis Enterprise Software cluster, avoid configuring swap partitions if possible.
+
+## Turn off swap
+
+To turn off swap in the OS of an existing server, VM, or instance, you
+must have `sudo` access or be a root user to run the following commands.
+
+Turn off swap:
+
+```sh
+sudo swapoff -a
+```
+
+To ensure swap remains off even after a reboot:
+
+1. Open `/etc/fstab` in a text editor and locate the entry that defines the swap space.
+
+    Example swap space entries:
+
+    ```sh
+    /swapfile   none    swap    sw      0       0
+    ```
+
+    ```sh
+    UUID=1d5e1de7-226d-4f60-a99c-f7a31a045c59 none            swap    defaults        0 0
+    ```
+
+1. Comment out the swap space entry, then save the file.
+
+    Example swap space entries commented out:
+
+    ```sh
+    #/swapfile   none    swap    sw      0       0
+    ```
+
+    ```sh
+    #UUID=1d5e1de7-226d-4f60-a99c-f7a31a045c59 none            swap    defaults        0 0
+    ```
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Configure firewall rules for Redis Enterprise Software on CentOS or Red
+  Hat Enterprise Linux (RHEL).
+linkTitle: CentOS/RHEL firewall
+title: Configure CentOS/RHEL firewall
+weight: $weight
+---
+CentOS and Red Hat Enterprise Linux (RHEL) distributions use [**firewalld**](https://firewalld.org/) by default to manage the firewall and configure [iptables](https://en.wikipedia.org/wiki/Iptables).
+The default configuration assigns the network interfaces to the **public** zone and blocks all ports except port 22, which is used for [SSH](https://en.wikipedia.org/wiki/Secure_Shell).
+
+When you install Redis Enterprise Software on CentOS or RHEL, it automatically creates two firewalld system services:
+
+- A service named **redislabs**, which includes all ports and protocols needed for communication between cluster nodes.
+- A service named **redislabs-clients**, which includes the ports and protocols needed for external communication (outside of the cluster).
+
+These services are defined but not allowed through the firewall by default.
+During Redis Enterprise Software installation, the [installer prompts]({{< relref "/operate/rs/installing-upgrading/install/manage-installation-questions" >}}) you to confirm auto-configuration of a default (public) zone
+to allow the **redislabs** service.
+
+Although automatic firewall configuration simplifies installation, your deployment might not be secure if you did not use other methods to secure the host machine's network, such as external firewall rules or security groups.
+You can use firewalld configuration tools such as **firewall-cmd** (command line) or **firewall-config** (UI)
+to create more specific firewall policies that allow these two services through the firewall, as necessary.
+
+{{<note>}}
+If databases are created with non-standard [Redis Enterprise Software ports]({{< relref "/operate/rs/networking/port-configurations" >}}),
+you need to explicitly configure firewalld to make sure those ports are not blocked.
+{{</note>}}
+---
+Title: Additional configuration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: null
+hideListLinks: false
+weight: 80
+---
+This section describes additional configuration options for Redis Enterprise Software installation.
+
+
+---
+Title: Create a support package
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Create a support package that gathers essential information to help debug
+  issues.
+linkTitle: Create support package
+toc: 'true'
+weight: $weight
+---
+If you encounter any issues that you are not able to resolve yourself
+and need to [contact Redis support](https://redis.io/support/) for assistance, you can [create a support package](#create-support-package) that gathers all essential information to help debug
+your issues.
+
+{{< note >}}
+The process of creating the support package can take several minutes and generates load on the system.
+{{< /note >}}
+
+## Support package files
+
+The support package is a zip file that contains all cluster configuration and logs.
+
+When downloaded from the Cluster Manager UI, the support package's name is `debuginfo.tar.gz`.
+
+### Database support package files
+
+Cluster and database support packages collect database details in `database_<bdb_uid>` directories, where `<bdb_uid>` is the database ID, and Redis shard details in `<node_uid>` directories.
+
+The following table describes the included files:
+
+| File | Description |
+|------|-------------|
+| ccs-redis.json | Primary node's local cluster configuration store (CCS). |
+| /database_<bdb_uid>/ | Directory that includes files for a specific database.<bdb_uid> is the database ID. |
+| database_<bdb_uid>_ccs_info.txt | Database information from the cluster configuration store (CCS). Includes settings for databases, endpoints, shards, replicas, and CRDB. |
+| database_<bdb_uid>.clientlist | List of clients connected to the database when the support package was created. |
+| database_<bdb_uid>.info | Redis information and statistics for the database. See [`INFO`]({{<relref "/commands/info">}}) for details about the collected fields. |
+| database_<bdb_uid>.rladmin | Database information. See [`rladmin info db`]({{<relref "/operate/rs/references/cli-utilities/rladmin/info#info-db">}}) for an example of collected fields. Also includes creation time, last changed time, Redis version, memory limit, persistence type, eviction policy, hashing policy, and whether SSL, backups, and email alerts are enabled. |
+| database_<bdb_uid>.slowlog | Contains slowlog output, which includes commands that took longer than 10 milliseconds. Only included if `slowlog_in_sanitized_support` is `true` in cluster settings. |
+| /node_<node_uid>/redis_<shard_uid>.txt | For each shard of the specified database only. Includes shard configuration and [information]({{<relref "/commands/info">}}), slowlog information, and latency information. |
+
+### Node support package files
+
+Cluster and node support packages collect node details in `node_<node_uid>` directories, where `<node_uid>` is the node ID.
+
+The following table describes the included files:
+
+| File | Description |
+|------|-------------|
+| ccs-redis.json | The node's local cluster configuration store (CCS). |
+| /conf/ | Directory that contains configuration files. |
+| /logs/ | Directory that includes logs. |
+| node_<node_uid>.ccs | Includes cluster configuration, node configuration, and DMC proxy configuration. |
+| node_<node_uid>_envoy_config.json | Envoy configuration. |
+| node_<node_uid>.rladmin | Information about the cluster's nodes, databases, endpoints, and shards. See [`rladmin status`]({{<relref "/operate/rs/references/cli-utilities/rladmin/status">}}) for example output. |
+| node_<node_uid>_sys_info.txt | Node's system information including:<br />• Socket files list<br />• Log files list<br />• Processes running on the node<br />• Disk usage<br />• Persistent files list<br />• Memory usage<br />• Network interfaces<br />• Installed packages<br />• Active iptables<br />• OS and platform<br />• Network connection<br />• Status of Redis processes |
+| redis_<shard_uid>.txt | For each shard of the specified database only. Includes shard configuration and [information]({{<relref "/commands/info">}}), slowlog information, and latency information. |
+
+Each node's `/conf/` directory contains the following files:
+
+- bootstrap_status.json
+- ccs-paths.conf
+- config.json
+- envoy.yaml
+- gossip_envoy.yaml
+- heartbeatd-config.json
+- last_bootstrap.json
+- local_addr.conf
+- node.id
+- node_local_config.json
+- redislabs_env_config.sh
+- socket.conf
+- supervisord_alert_mgr.conf
+- supervisord_cm_server.conf
+- supervisord_crdb_coordinator.conf
+- supervisord_crdb_worker.conf
+- supervisord_mdns_server.conf
+- supervisord_pdns_server.conf
+
+Each node's `/conf/` directory also contains the following key and cert modulus files:
+
+- api_cert.modulus
+- api_key.modulus
+- ccs_internode_encryption_cert.modulus
+- ccs_internode_encryption_key.modulus
+- cm_cert.modulus
+- cm_key.modulus
+- data_internode_encryption_cert.modulus
+- data_internode_encryption_key.modulus
+- gossip_ca_signed_cert.modulus
+- gossip_ca_signed_key.modulus
+- mesh_ca_signed_cert.modulus
+- mesh_ca_signed_key.modulus
+- metrics_exporter_cert.modulus
+- metrics_exporter_key.modulus
+- proxy_cert.modulus
+- proxy_key.modulus
+- syncer_cert.modulus
+- syncer_key.modulus
+
+## Create support package
+
+### Cluster Manager UI method
+
+To create a support package from the Cluster Manager UI:
+
+1. In the navigation menu, select **Support**.
+
+    {{<image filename="images/rs/screenshots/create-support-package/support-package-dialog.png"  width="60%" alt="Select Support from the navigation menu and create a support package.">}}
+
+1. Click **Proceed**.
+
+1. In the **Generate support package** dialog, select one of the following options:
+
+    - **Full package including all nodes and databases**: Creates a support package with information about all nodes and databases in the cluster.
+
+    - **For Databases**: Creates a support package that includes database information.
+
+        - Select **All Databases** from the **Database name (Database ID)** list to include information about all databases in the cluster.
+
+        - Select a specific database from the **Database name (Database ID)** list to include information about that database only.
+
+        {{<image filename="images/rs/screenshots/create-support-package/generate-support-package-select-db.png"  width="60%" alt="The list of databases you can include in the support package.">}}
+
+    - **For Nodes**: Creates a support package that includes node information.
+
+        - Select **All Nodes** from the **Node ID (IP Addresses)** list to include information about all nodes in the cluster.
+
+        - Select a specific node from the **Node ID (IP Addresses)** list to include information about that node only.
+
+        {{<image filename="images/rs/screenshots/create-support-package/generate-support-package-select-node.png"  width="60%" alt="The list of nodes you can include in the support package.">}}
+
+1. Click **Generate package**.
+
+1. The package is created and downloaded by your browser.
+
+    {{<image filename="images/rs/screenshots/create-support-package/support-package-created-alert.png"  width="60%" alt="An alert appears that says, 'Support package created, attach it to your request in the Redis Support portal'. The Redis Support portal is a button you can click to contact Redis Support.">}}
+
+### Command-line method
+
+If package creation fails with `internal error` or if you cannot access the UI, create a support package for the cluster from the command line on any node in the cluster using the [`rladmin cluster debug_info`]({{< relref "/operate/rs/references/cli-utilities/rladmin/cluster/debug_info" >}}) command: 
+
+```sh
+/opt/redislabs/bin/rladmin cluster debug_info
+```
+
+- If `rladmin cluster debug_info` fails for lack of space in the `/tmp` directory, you can:
+
+    1. Change the storage location where the support package is saved: 
+    
+        ```sh
+        rladmin cluster config debuginfo_path <path>
+        ```
+
+        The `redislabs` user must have write access to the storage location on all cluster nodes.
+
+    1. On any node in the cluster, run:
+        
+        ```sh
+        rladmin cluster debug_info
+        ```
+
+- If `rladmin cluster debug_info` fails for another reason, you can create a support package for the cluster from the command line on each node in the cluster with the command: 
+
+    ```sh
+    /opt/redislabs/bin/debuginfo
+    ```
+
+Upload the tar file to [Redis support](https://redis.com/company/support/). The path to the archive is shown in the command output.
+
+### REST API method
+
+You can also use `debuginfo` [REST API]({{< relref "/operate/rs/references/rest-api" >}}) requests to create and download support packages.
+
+To download debug info from all nodes and databases:
+
+```sh
+GET /v1/cluster/debuginfo
+```
+
+To download debug info from all nodes:
+
+```sh
+GET /v1/nodes/debuginfo
+```
+
+To download debug info from a specific node, replace `<uid>` in the following request with the node ID:
+
+```sh
+GET /v1/nodes/<uid>/debuginfo
+```
+
+To download debug info from all databases:
+
+```sh
+GET /v1/bdbs/debuginfo
+```
+
+To download debug info from a specific database, replace `<uid>` in the following request with the database ID:
+
+```sh
+GET /v1/bdbs/<uid>/debuginfo
+```
+---
+Title: Install, set up, and upgrade Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Learn how to install, set up, and upgrade Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Install and upgrade
+toc: 'true'
+weight: 35
+---
+
+You can run self-managed Redis Enterprise Software in an on-premises data center or on your preferred cloud platform. 
+
+If you prefer a fully managed Redis database-as-a-service, available on major public cloud services, consider setting up a [Redis Cloud]({{<relref "/operate/rc">}}) subscription. You can [try Redis Cloud](https://redis.io/try-free/) for free.
+
+## Quickstarts
+
+If you want to try out Redis Enterprise Software, see the following quickstarts:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Docker quickstart for Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+## Install Redis Enterprise Software
+
+To install Redis Enterprise Software on a [supported platform]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/supported-platforms" >}}), you need to:
+
+1. [Plan your deployment]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment" >}}).
+
+1. [Prepare to install]({{< relref "/operate/rs/installing-upgrading/install/prepare-install" >}}).
+
+1. [Perform the install]({{< relref "/operate/rs/installing-upgrading/install" >}}).
+
+Depending on your needs, you may also want to [customize the installation](#more-info-and-options).
+
+## Upgrade existing deployment
+
+If you already installed Redis Enterprise Software, you can:
+
+- [Upgrade a cluster]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster" >}})
+
+- [Upgrade a database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-database" >}})
+
+- [Upgrade an Active-Active database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active" >}})
+
+## Uninstall Redis Enterprise Software
+
+- [Uninstall existing deployment]({{< relref "/operate/rs/installing-upgrading/uninstalling" >}})
+
+## More info and options
+
+More information is available to help with customization and related questions:
+
+- [CentOS/RHEL firewall configuration]({{< relref "/operate/rs/installing-upgrading/configuring/centos-rhel-firewall.md" >}})
+- [Change socket file location]({{< relref "/operate/rs/installing-upgrading/configuring/change-location-socket-files.md" >}})
+- [Cluster DNS configuration]({{< relref "/operate/rs/networking/cluster-dns.md" >}})
+- [Cluster load balancer setup]({{< relref "/operate/rs/networking/cluster-lba-setup.md" >}})
+- [File locations]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/file-locations.md" >}})
+- [Linux swap space configuration]({{< relref "/operate/rs/installing-upgrading/configuring/linux-swap.md" >}})
+- [mDNS client prerequisites]({{< relref "/operate/rs/networking/mdns.md" >}})
+- [User and group ownership]({{< relref "/operate/rs/installing-upgrading/install/customize-user-and-group.md" >}})
+
+## Next steps
+
+After you install Redis Enterprise Software and set up your cluster, you can:
+
+- [Add users]({{< relref "/operate/rs/security/access-control/create-users" >}}) to the cluster with specific permissions.  To begin, start with [Access control]({{< relref "/operate/rs/security/access-control" >}}).
+
+- [Create databases]({{< relref "/operate/rs/databases/create" >}}) to use with your applications.
+
+---
+Title: Docker quickstart for Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a development or test deployment of Redis Enterprise Software
+  using Docker.
+linkTitle: Docker quickstart
+weight: 2
+aliases: /operate/rs/installing-upgrading/get-started-docker/
+---
+{{< warning >}}
+Docker containers are currently only supported for development and test environments, not for production. Use [Redis Enterprise on Kubernetes]({{< relref "/operate/kubernetes" >}}) for a supported containerized deployment.
+{{< /warning >}}
+
+For testing purposes, you can run Redis Enterprise Software on Docker containers on
+Linux, Windows, or MacOS.
+The [Redis Enterprise Software container](https://hub.docker.com/r/redislabs/redis/)
+acts as a node in a cluster.
+
+To get started with a single Redis Enterprise Software container:
+
+1. [Install Docker](#install-docker) for your operating system
+
+2. [Run the Redis Enterprise Software Docker container](#run-the-container)
+
+3. [Set up a cluster](#set-up-a-cluster)
+
+4. [Create a new database](#create-a-database)
+
+5. [Connect to your database](#connect-to-your-database)
+
+## Install Docker
+
+Follow the Docker installation instructions for your operating system:
+
+- [Linux](https://docs.docker.com/install/#supported-platforms)
+- [MacOS](https://docs.docker.com/docker-for-mac/install/)
+- [Windows](https://store.docker.com/editions/community/docker-ce-desktop-windows)
+
+## Run the container
+
+To download and start the Redis Enterprise Software Docker container, run the following
+[`docker run`](https://docs.docker.com/engine/reference/commandline/run/) command in the terminal or command line for your operating system.
+
+{{< note >}}
+On Windows, make sure Docker is configured to run Linux-based containers.
+{{< /note >}}
+
+```sh
+docker run -d --cap-add sys_resource --name RE -p 8443:8443 -p 9443:9443 -p 12000:12000 redislabs/redis
+```
+
+The example command runs the Docker container with Redis Enterprise Software on `localhost` and opens the following ports: 
+
+- Port 8443 for HTTPS connections
+
+- Port 9443 for [REST API]({{< relref "/operate/rs/references/rest-api" >}}) connections
+
+- Port 12000 configured Redis database port allowing client connections
+
+You can publish other [ports]({{< relref "/operate/rs/networking/port-configurations.md" >}})
+with `-p <host_port>:<container_port>` or use the `--network host` option to open all ports to the host network.
+
+## Set up a cluster
+
+{{<embed-md "cluster-setup.md">}}
+
+## Create a database
+
+{{<embed-md "rs-quick-db-setup-7-8.md">}}
+
+{{< note >}}
+{{< embed-md "docker-memory-limitation.md" >}}
+{{< /note >}}
+
+## Connect to your database
+
+After you create the Redis database, you can connect to it to begin storing data.
+
+### Use redis-cli inside Docker {#connect-inside-docker}
+
+Every installation of Redis Enterprise Software includes the command-line tool [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) to interact with your Redis database. You can use `redis-cli` to connect to your database from within the same Docker network.
+
+Use [`docker exec`](https://docs.docker.com/engine/reference/commandline/exec/) to start an interactive `redis-cli` session in the running Redis Enterprise Software container:
+
+```sh
+$ docker exec -it redis-cli -h redis-12000.cluster.local -p 12000
+127.0.0.1:12000> SET key1 123
+OK
+127.0.0.1:12000> GET key1
+"123"
+```
+
+### Connect from the host environment {#connect-outside-docker}
+
+The database you created uses port `12000`, which is also mapped from the Docker container back to the host environment. This lets you use any method you have available locally to [connect to a Redis database]({{< relref "/operate/rs/databases/connect/" >}}). Use `localhost` as the `host` and `12000` as the port.
+
+## Test different topologies
+
+{{< warning >}}
+Docker containers are currently only supported for development and test environments, not for production. Use [Redis Enterprise on Kubernetes]({{< relref "/operate/kubernetes" >}}) for a supported containerized deployment.
+{{< /warning >}}
+
+When deploying Redis Enterprise Software using Docker for testing, several common topologies are available, according to your requirements:
+
+- [Single-node cluster](#single-node) – For local development or functional testing
+
+- [Multi-node cluster on a single host](#multi-node-one-host) – For a small-scale deployment that is similar to production
+
+- [Multi-node cluster with multiple hosts](#multi-node-multi-host) – For more predictable performance or high availability compared to single-host deployments
+
+### Single node {#single-node}
+
+The simplest topology is to run a single-node Redis Enterprise Software cluster with a single container on a single host machine. You can use this topology for local development or functional testing.
+
+Single-node clusters have limited functionality. For example, Redis Enterprise Software can't use replication or protect against failures if the cluster has only one node.
+
+{{< image filename="/images/rs/RS-Docker-container.png" >}}
+
+### Multiple nodes on one host {#multi-node-one-host}
+
+You can create a multi-node Redis Enterprise Software cluster by deploying multiple containers to a single host machine. The resulting cluster is scale minimized but similar to production deployments.
+
+However, this will also have several limitations.  For example, you cannot map the same port on multiple containers on the same host.
+
+{{< image filename="/images/rs/RS-Docker-cluster-single-host.png" >}}
+
+### Multiple nodes and hosts {#multi-node-multi-host}
+
+You can create a multi-node Redis Enterprise Software cluster with multiple containers by deploying each container to a different host machine.
+
+This topology minimizes interference between containers, allowing for the testing of more Redis Enterprise Software features.
+
+{{< image filename="/images/rs/RS-Docker-cluster-multi-host.png" >}}
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Set up a test deployment of Redis Enterprise Software for Linux.
+linkTitle: Quickstart
+title: Redis Enterprise Software quickstart
+weight: 1
+---
+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:
+
+1. [Ensure port availability](#ensure-port-availability)
+
+1. [Install Redis Enterprise Software](#install-redis-enterprise-software)
+
+1. [Set up a Redis Enterprise Software cluster](#set-up-a-cluster)
+
+1. [Create a new Redis database](#create-a-database)
+
+1. [Connect to your Redis database](#connect-to-your-database)
+
+{{< note >}}
+**This quickstart is designed for local testing only.**
+For production environments, see the [install and setup]({{< relref "/operate/rs/installing-upgrading#install-redis-enterprise-software" >}}) guide for deployment options and instructions.
+{{< /note >}}
+
+## Ensure port availability
+
+{{<embed-md "port-availability-embed.md">}}
+
+### Update `sysctl.conf` to avoid port collisions
+
+{{<embed-md "port-collision-avoidance.md">}}
+
+### OS conflicts with port 53
+
+{{<embed-md "port-53.md">}}
+
+
+### Configuration for AWS and GCP
+
+For detailed configuration instructions, see your cloud provider's documentation.
+
+1. Create a VPC that you can use with regional subnets.
+
+1. Within this VPC, create firewall rules that allow external and internal access for Redis Enterprise Software.
+
+
+| Ingress/Egress   | Source                                             | Protocol  | Ports                                    | Other protocols  |
+|------------------|----------------------------------------------------|-----------|------------------------------------------|------------------|
+| Ingress          | 0.0.0.0/0                                          | TCP       | 21, 22, 53, 8001, 8443, 9443, 8070, <nobr>10000-19999</nobr> | ICMP             |
+| Ingress          | 0.0.0.0/0                                          | UDP       | 53, 5353                                  |                  |
+| Ingress          | 10.0.0.0/8  (if subnets use 10. ranges) | all       | all                                      |                  | 
+
+
+## Install Redis Enterprise Software
+
+To install Redis Enterprise Software:
+
+1. Download the installation files from the [Redis Enterprise Download Center](https://redis.io/downloads/#software)
+and copy the download package to a machine with a Linux-based OS. 
+
+    {{< note >}}
+You are required to create a free account to access the download center.
+    {{< /note >}}
+
+1. Extract the installation files:
+
+    ```sh
+    tar vxf <downloaded tar file name>
+    ```
+
+1. Run the `install.sh` script in the current directory:
+
+    ```sh
+    sudo ./install.sh -y
+    ```
+
+## Set up a cluster
+
+To set up your machine as a Redis Enterprise Software cluster:
+
+{{< embed-md "cluster-setup.md" >}}
+
+## Create a database
+
+{{<embed-md "rs-quick-db-setup-7-8.md">}}
+
+## Connect to your database
+
+After you create the Redis database, you can connect to it and store data.
+See [Test client connection]({{< relref "/operate/rs/databases/connect/test-client-connectivity" >}}) for connection options and examples.
+
+## Supported web browsers
+
+To use the Redis Enterprise Software Cluster Manager UI, you need a modern browser with JavaScript enabled.
+ 
+The Cluster Manager UI is officially supported for the latest version of [Google Chrome](https://www.google.com/chrome/), as well as the three previous and three subsequent versions.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+
+---
+Title: Redis Enterprise Software quickstarts
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Follow these quickstarts to try out Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Quickstarts
+weight: 10
+---
+
+Try out Redis Enterprise Software using one of the following quickstarts:
+
+- [Redis Enterprise Software quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+
+- [Docker quickstart for Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+
+Additional quickstart guides are available to help you:
+
+- Set up a [Auto Tiering cluster]({{< relref "/operate/rs/databases/auto-tiering/quickstart.md" >}}) to optimize  memory resources.
+
+- Set up an [Active-Active cluster]({{< relref "/operate/rs/databases/active-active/get-started.md" >}}) to enable high availability.
+
+- [Benchmark]({{< relref "/operate/rs/clusters/optimize/memtier-benchmark.md" >}}) Redis Enterprise Software performance.
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: Describes where to view the archive of Redis Enterprise Software documentation.
+linkTitle: Archive
+weight: 99
+---
+
+Previous versions of Redis Enterprise Software documentation are available on the archived web site:
+
+- [Redis Enterprise Software v7.4 documentation archive](https://docs.redis.com/7.4/rs/)  
+
+- [Redis Enterprise Software v7.2 documentation archive](https://docs.redis.com/7.2/rs/) 
+
+- [Redis Enterprise Software v6.4 documentation archive](https://docs.redis.com/6.4/rs/) 
+
+- [Redis Enterprise Software v6.2 documentation archive](https://docs.redis.com/6.2/rs/) 
+
+- [Redis Enterprise Software v6.0 documentation archive](https://docs.redis.com/6.0/rs/)
+---
+LinkTitle: Get started
+Title: Get started with monitoring Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Use Prometheus and Grafana to collect and visualize Redis Enterprise Software metrics.
+group: observability
+summary: You can use Prometheus and Grafana to collect and visualize your Redis Enterprise
+  Software metrics.
+type: integration
+weight: 5
+tocEmbedHeaders: true
+---
+
+{{<embed-md "rs-prometheus-grafana-quickstart.md">}}
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+db_type: database
+description: Verify if a Redis Software database is available to perform read and write operations and can respond to queries from client applications.
+linkTitle: Check database availability
+title: Check database availability for monitoring and load balancers
+toc: 'true'
+weight: 80
+aliases: /operate/rs/databases/durability-ha/db-availability/
+---
+
+You can use the [database availability API]({{<relref "/operate/rs/references/rest-api/requests/bdbs/availability">}}) to verify whether a Redis Software database is available to perform read and write operations and can respond to queries from client applications. Load balancers and automated monitoring tools can use this API to monitor database availability.
+
+{{<note>}}
+Database availability does not guarantee data availability.
+{{</note>}}
+
+## Check database availability for monitoring
+
+To monitor database availability, use the following REST API request:
+
+```sh
+GET /v1/bdbs/<database_id>/availability
+```
+
+If the OSS Cluster API is enabled, this request verifies all endpoints for this database are available. Otherwise, it verifies the database has at least one available endpoint.
+
+Returns the status code 200 OK if the database is available.
+
+If the database is unavailable, returns an error status code and a JSON object that contains [`error_code` and `description` fields]({{<relref "/operate/rs/references/rest-api/requests/bdbs/availability#get-db-error-codes">}}).
+
+## Check local database endpoint availability for load balancers
+
+To check database availability when using a load balancer and the recommended `all-nodes` proxy policy, use the local database endpoints for each node:
+
+```sh
+GET /v1/local/bdbs/<database_id>/endpoint/availability
+```
+
+Returns the status code 200 OK if the local database endpoint is available.
+
+If the local database endpoint is unavailable, returns an error status code and a JSON object that contains [`error_code` and `description` fields]({{<relref "/operate/rs/references/rest-api/requests/bdbs/availability#get-endpoint-error-codes">}}).
+
+## Availability by database status
+
+The following table shows the relationship between a database's status and availability. For more details about the database status values, see [BDB status field]({{<relref "/operate/rs/references/rest-api/objects/bdb/status">}}).
+
+| Database status | Availability |
+|-----------------|--------------|
+| active          | <span title="Available">&#x2705;</span> Available |
+| active-change-pending | <span title="Available">&#x2705;</span> Available |
+| creation-failed | <span title="Not available">:x:</span> Not available |
+| delete-pending  | <span title="Availability not guaranteed" class="font-serif">:warning:</span> Availability not guaranteed |
+| import-pending  | <span title="Available">&#x2705;</span> Available |
+| pending         | <span title="Available">&#x2705;</span> Available |
+| recovery        | <span title="Not available">:x:</span> Not available |
+---
+Title: Metrics stream engine preview for monitoring v2
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Preview the new metrics stream engine for monitoring Redis Enterprise Software.
+hideListLinks: true
+linkTitle: Metrics stream engine preview for monitoring v2
+weight: 60
+---
+
+A preview of the new metrics stream engine is available as of [Redis Enterprise Software version 7.8.2]({{<relref "/operate/rs/release-notes/rs-7-8-releases">}}).
+
+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]({{< relref "/operate/rs/monitoring/prometheus_and_grafana" >}}).
+
+Filter [Libraries and tools]({{<relref "/integrate">}}) by "observability" for additional tools and guides.
+
+## Prometheus metrics v2
+
+For a list of all available v2 metrics, see [Prometheus metrics v2]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v2">}}).
+
+The v2 scraping endpoint also exposes metrics for `node_exporter` version 1.8.1. For more information, see the [Prometheus node_exporter GitHub repository](https://github.com/prometheus/node_exporter).
+
+## Transition from Prometheus v1 to Prometheus v2
+
+If you are already using the existing scraping endpoint for integration, follow [this guide]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v1-to-v2">}}) to transition and try the new engine. It is possible to scrape both existing and new endpoints simultaneously, allowing advanced dashboard preparation and a smooth transition.
+---
+Title: Metrics and alerts for monitoring v1
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Monitor Redis Enterprise Software clusters and databases using internal monitoring systems and external monitoring tools.
+hideListLinks: true
+linkTitle: Monitoring v1
+weight: 50
+---
+
+The current approach to monitoring Redis Enterprise Software includes:
+
+- Internal monitoring systems:
+
+    - [Statistics APIs]({{<relref "/operate/rs/references/rest-api/objects/statistics">}}), which collect various statistics at regular time intervals for clusters, nodes, databases, shards, and endpoints.
+
+    - Cluster manager metrics and alerts.
+
+- The v1 Prometheus scraping endpoint to integrate with external monitoring tools such as [Prometheus and Grafana]({{<relref "/operate/rs/monitoring/prometheus_and_grafana">}}).
+
+## Cluster manager metrics
+
+You can see the metrics of the cluster in:
+
+- **Cluster > Metrics**
+- **Node > Metrics** for each node
+- **Database > Metrics** for each database, including the shards for that database
+
+The scale selector at the top of the page allows you to set the X-axis (time) scale of the graph.
+
+To choose which metrics to display in the two large graphs at the top of the page:
+
+1. Hover over the graph you want to show in a large graph.
+1. Click on the right or left arrow to choose which side to show the graph.
+
+We recommend that you show two similar metrics in the top graphs so you can compare them side-by-side.
+
+See the following topics for metrics definitions:
+- [Database operations]({{< relref "/operate/rs/references/metrics/database-operations" >}}) for database metrics
+- [Resource usage]({{< relref "/operate/rs/references/metrics/resource-usage" >}}) for resource and database usage metrics
+- [Auto Tiering]({{< relref "/operate/rs/references/metrics/auto-tiering" >}}) for additional metrics for [Auto Tiering ]({{< relref "/operate/rs/databases/auto-tiering" >}}) databases
+
+## Cluster alerts
+
+In **Cluster > Alert Settings**, you can enable alerts for node or cluster events, such as high memory usage or throughput.
+
+Configured alerts are shown:
+
+- As a notification on the status icon ( {{< image filename="/images/rs/icons/icon_warning.png#no-click" alt="Warning" width="18px" class="inline" >}} ) for the node and cluster
+- In the **log**
+- In email notifications, if you configure [email alerts](#send-alerts-by-email)
+
+{{< note >}}
+If you enable alerts for "Node joined" or "Node removed" actions,
+you must also enable "Receive email alerts" so that the notifications are sent.
+{{< /note >}}
+
+To enable alerts for a cluster:
+
+1. In **Cluster > Alert Settings**, click **Edit**. 
+1. Select the alerts that you want to show for the cluster and click **Save**.
+
+## Database alerts
+
+For each database, you can enable alerts for database events, such as high memory usage or throughput.
+
+Configured alerts are shown:
+
+- As a notification on the status icon ( {{< image filename="/images/rs/icons/icon_warning.png#no-click" alt="Warning" width="18px" class="inline" >}} ) for the database
+- In the **log**
+- In emails, if you configure [email alerts](#send-alerts-by-email)
+
+To enable alerts for a database:
+
+1. In **Configuration** for the database, click **Edit**.
+1. Select the **Alerts** section to open it.
+1. Select the alerts that you want to show for the database and click **Save**.
+
+## Send alerts by email
+
+To send cluster and database alerts by email:
+
+1. In **Cluster > Alert Settings**, click **Edit**.
+1. Select **Set an email** to configure the [email server settings]({{< relref "/operate/rs/clusters/configure/cluster-settings#configuring-email-server-settings" >}}).
+1. In **Configuration** for the database, click **Edit**.
+1. Select the **Alerts** section to open it.
+1. Select **Receive email alerts** and click **Save**.
+1. In **Access Control**, select the [database and cluster alerts]({{< relref "/operate/rs/security/access-control/manage-users" >}}) that you want each user to receive.
+---
+Title: Redis Enterprise Software observability and monitoring guidance
+alwaysopen: false
+categories:
+- docs
+- integrate
+- rs
+description: Using monitoring and observability with Redis Enterprise 
+group: observability
+linkTitle: Observability and monitoring
+summary: Observe Redis Enterprise resources and database perfomance indicators.
+type: integration
+weight: 45
+tocEmbedHeaders: true
+---
+
+{{<embed-md "rs-observability.md">}}
+---
+Title: Monitoring with metrics and alerts
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+- kubernetes
+description: Use the metrics that measure the performance of your Redis Enterprise Software clusters, nodes, databases, and shards to track the performance of your databases.
+hideListLinks: true
+linkTitle: Monitoring
+weight: 70
+aliases: /operate/rs/clusters/monitoring/
+---
+
+You can use the metrics that measure the performance of your Redis Enterprise Software clusters, nodes, databases, and shards
+to monitor the performance of your databases.
+
+## View metrics and configure alerts
+
+In the Redis Enterprise Cluster Manager UI, you can view metrics, configure alerts, and send notifications based on alert parameters. You can also access metrics and configure alerts through the REST API.
+
+See [Metrics and alerts for monitoring v1]({{<relref "/operate/rs/monitoring/v1_monitoring">}}) for more information.
+
+## Metrics stream engine preview
+
+A preview of the new metrics stream engine is available as of [Redis Enterprise Software version 7.8.2]({{<relref "/operate/rs/release-notes/rs-7-8-releases">}}). This new engine exposes the v2 Prometheus scraping endpoint at `https://<IP>:8070/v2`, exports all time-series metrics to external monitoring tools, and enables real-time monitoring.
+
+See [Metrics stream engine preview for monitoring v2]({{<relref "/operate/rs/monitoring/metrics_stream_engine">}}) for more information.
+
+## Integrate with external monitoring tools
+
+To integrate Redis Enterprise metrics into your monitoring environment, see the integration guides for [Prometheus and Grafana]({{< relref "/operate/rs/monitoring/prometheus_and_grafana" >}}).
+
+Filter [Libraries and tools]({{<relref "/integrate">}}) by "observability" for additional tools and guides.
+
+## Metrics reference
+
+Make sure you read the [definition of each metric]({{< relref "/operate/rs/references/metrics/" >}})
+so that you understand exactly what it represents.
+---
+Title: Redis Enterprise Software
+alwaysopen: false
+categories:
+- docs
+- operate
+- rs
+description: The self-managed, enterprise-grade version of Redis.
+hideListLinks: true
+weight: 10
+linkTitle: Redis Software
+---
+
+[Redis Enterprise](https://redis.io/enterprise/) is a self-managed, enterprise-grade version of Redis.
+
+With Redis Enterprise, you get many enterprise-grade capabilities, including:
+- Linear scalability
+- High availability, backups, and recovery
+- Predictable performance
+- 24/7 support
+
+You can run self-managed Redis Enterprise Software in an on-premises data center or on your preferred cloud platform.
+
+If you prefer a fully managed Redis database-as-a-service, available on major public cloud services, consider setting up a [Redis Cloud]({{<relref "/operate/rc">}}) subscription. You can [try Redis Cloud](https://redis.io/try-free/) for free.
+
+## Get started
+Build a small-scale cluster with the Redis Enterprise Software container image.
+- [Linux quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- [Docker quickstart]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+- [Get started with Active-Active]({{< relref "/operate/rs/databases/active-active/get-started" >}})
+
+## Install & setup
+[Install & set up]({{< relref "/operate/rs/installing-upgrading" >}}) a Redis Enterprise Software cluster.
+- [Networking]({{< relref "/operate/rs/networking" >}})
+- [Set up]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}) & [configure]({{< relref "/operate/rs/clusters/configure" >}}) a [cluster]({{< relref "/operate/rs/clusters" >}})
+- [Release notes]({{< relref "/operate/rs/release-notes" >}})
+
+## Databases
+Create and manage a [Redis database]({{< relref "/operate/rs/databases" >}}) on a cluster.
+- [Create a Redis Enterprise Software database]({{< relref "/operate/rs/databases/create" >}})
+- [Configure database]({{< relref "/operate/rs/databases/configure" >}})
+- [Create Active-Active database]({{< relref "/operate/rs/databases/active-active/create" >}})
+- [Edit Active-Active database]({{< relref "/operate/rs/databases/active-active/manage.md" >}})
+
+## Security
+[Manage secure connections]({{< relref "/operate/rs/security" >}}) to the cluster and databases.
+- [Access control]({{< relref "/operate/rs/security/access-control" >}})
+- [Users]({{< relref "/operate/rs/security/access-control/manage-users" >}}) & [roles]({{< relref "/operate/rs/security/access-control" >}})
+- [Certificates]({{< relref "/operate/rs/security/certificates" >}})
+- [TLS]({{< relref "/operate/rs/security/encryption/tls" >}}) & [Encryption]({{< relref "/operate/rs/security/encryption" >}})
+
+## Reference
+Use command-line utilities and the REST API to manage the cluster and databases.
+- [rladmin]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}), [crdb-cli]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}), & [other utilities]({{< relref "/operate/rs/references/cli-utilities" >}})
+- [REST API reference]({{< relref "/operate/rs/references/rest-api" >}}) & [examples]({{< relref "/operate/rs/references/rest-api/quick-start" >}})
+- [Redis commands]({{< relref "/commands" >}})
+
+## Archive
+
+You can use the version selector in the navigation menu to view documentation for Redis Enterprise Software versions 7.4 and later.
+
+To view documentation earlier than version 7.4, see the archived website:
+
+- [Redis Enterprise Software v7.2 documentation archive](https://docs.redis.com/7.2/rs/) 
+
+- [Redis Enterprise Software v6.4 documentation archive](https://docs.redis.com/6.4/rs/) 
+
+- [Redis Enterprise Software v6.2 documentation archive](https://docs.redis.com/6.2/rs/) 
+
+- [Redis Enterprise Software v6.0 documentation archive](https://docs.redis.com/6.0/rs/)
+
+
+## Related info
+- [Redis Cloud]({{< relref "/operate/rc" >}})
+- [Redis Open Source]({{< relref "/operate/oss_and_stack" >}})
+- [Redis Stack]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}})
+- [Glossary]({{< relref "/glossary" >}})
+
+## Continue learning with Redis University
+
+See the [Get started with Redis Software learning path](https://university.redis.io/learningpath/an0mgw5bjpjfbe?_gl=1*4gjdoe*_gcl_au*MTkyMTIyOTY3Mi4xNzM5MTk5Mjc4) for courses.
+---
+Title: Upgrade Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  OperatorHub.
+linkTitle: OpenShift OperatorHub
+weight: 40
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-redis-enterprise-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-olm/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 or later involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the Redis Enterprise operator
+
+1. Select the **Redis Enterprise Operator** from the **Operators**>**Installed Operators** page.
+
+2. Select the **Subscription** tab.
+
+3. Verify your **Update approval** is set to "Manual".
+
+4. To upgrade to the latest version, set your **Update Channel** to ‘production’. To upgrade to an older version, specify the desired version for your **Update Channel**.
+
+5. Select **Upgrade available** shown under **Upgrade status**.
+
+6. When the "Review manual InstallPlan" section appears, select **Preview installPlan** and then **Approve** after reviewing the details. This will start the operator upgrade.
+
+You can monitor the upgrade from the **Installed Operators** page. A new Redis Enterprise Operator will appear in the list, with the status "Installing". OpenShift will delete the old operator, showing the "Cannot update" status during deletion.
+
+## Security context constraints
+
+Upgrades to versions 7.22.0-6 and later run in **unprivileged mode** without any additional permissions or capabilities. If you don't specifally require additional capabilities, we recommend you maintain the default unprivileged mode, as its more secure. After upgrading, remove the existing `redis-enterprise-scc-v2` SCC and unbind it from the REC service account.
+
+To enable privileged mode, see [Enable privileged mode > OpenShift upgrades]({{<relref "/operate/kubernetes/security/enable-privileged-mode#openshift-upgrades">}}).
+
+## Upgrade the Redis Enterprise cluster
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+## Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. To upgrade your REDB, specify your new database version in the `spec.redisVersion` field in the REDB custom resources. Supported database versions for operator versions include `"7.2"` and `"7.4"` (note this value is a string). 
+
+To upgrade your REAADB, see [Upgrade an Active-Active database]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active/">}}) for details on the `rladmin` and `crdb-cli` commands required. Reach out to Redis support if you have additional questions.
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+---
+Title: Upgrade Redis Enterprise with OpenShift CLI 
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  CLI.
+linkTitle: OpenShift CLI
+weight: 20
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6 or later. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/openshift-cli/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator versions 7.8.2-6 and later  involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+#### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+For OpenShift environments, the name of the bundle is `openshift.bundle.yaml`, and so the `curl` command to run is:
+
+```sh
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/openshift.bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+If you are using OpenShift, run this instead:
+
+```sh
+oc apply -f openshift.bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+oc get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+ We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+ {{< /warning >}}
+
+## Security context constraints
+
+Upgrades to versions 7.22.0-6 and later run in **unprivileged mode** without any additional permissions or capabilities. If you don't specifally require additional capabilities, we recommend you maintain the default unprivileged mode, as its more secure. After upgrading, remove the existing `redis-enterprise-scc-v2` SCC and unbind it from the REC service account.
+
+To enable privileged mode, see [Enable privileged mode > OpenShift upgrades]({{<relref "/operate/kubernetes/security/enable-privileged-mode#openshift-upgrades">}}).
+
+## Upgrade the Redis Enterprise cluster
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. To upgrade your REDB, specify your new database version in the `spec.redisVersion` field in the REDB custom resources. Supported database versions for operator versions include `"7.2"` and `"7.4"` (note this value is a string). 
+
+To upgrade your REAADB, see [Upgrade an Active-Active database]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active/">}}) for details on the `rladmin` and `crdb-cli` commands required. Reach out to Redis support if you have additional questions.
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+
+---
+Title: Upgrade Redis Enterprise for Kubernetes 7.8.2-6
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via the
+  operator.
+linkTitle: Kubernetes
+weight: 10
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster-rec)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## Prerequisites
+
+The following steps ensure you have the minimum versions of all components necessary to upgrade to 7.8.2-6. **Without these minimum versions, the upgrade will freeze and require manual recovery.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported by 7.8.2-6. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster/) for detailed steps.
+
+### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}).
+
+### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatibile with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+You can download the bundle for the latest release with the following `curl` command:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+Upgrade the bundle and operator with a single command, passing in the bundle YAML file:
+
+```sh
+kubectl apply -f bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+kubectl get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+{{< /warning >}}
+
+## Upgrade the Redis Enterprise cluster (REC)
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the [Redis Enterprise for Kubernetes release notes]({{<relref "/operate/kubernetes/release-notes/7-8-2-releases">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Upgrade an REC with an Active-Active database
+
+We recommend upgrading all participating clusters to the same operator version.
+
+If you are upgrading from a preview version of the Active-Active controller, you can remove the following environment variables: `ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED`, `REMOTE_CLUSTER_CONTROLLER_ENABLED`, and `ENABLE_ALPHA_FEATURES`.
+
+### Edit `redisEnterpriseImageSpec` in the REC spec
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    kubectl edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `kubectl get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ kubectl get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+kubectl rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. To upgrade your REDB, specify your new database version in the `spec.redisVersion` field in the REDB custom resources. Supported database versions for operator versions include `"7.2"` and `"7.4"` (note this value is a string). 
+
+To upgrade your REAADB, see [Upgrade an Active-Active database]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active/">}}) for details on the `rladmin` and `crdb-cli` commands required. Reach out to Redis support if you have additional questions.
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.---
+Title: Upgrade Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Information about upgrading your Redis Enterprise cluster on Kubernetes.
+hideListLinks: true
+linkTitle: Upgrade
+weight: 15
+---
+
+The upgrade process includes updating three components:
+
+  1. Upgrade the Redis Enterprise operator
+  2. Upgrade the Redis Enterprise cluster (REC)
+  3. Upgrade Redis Enterprise databases (REDB)
+
+If you are using OpenShift, see [Upgrade Redis Enterprise with OpenShift CLI]({{<relref "/operate/kubernetes/upgrade/openshift-cli">}}) or [Upgrade Redis Enterprise with OpenShift OperatorHub]({{<relref "/operate/kubernetes/upgrade/upgrade-olm">}}).
+
+For all other Kubernetes distributions, see [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/upgrade/upgrade-redis-cluster" >}}).
+
+## Upgrade compatibility
+
+When upgrading, both your Kubernetes version and Redis operator version need to be supported at all times.
+
+{{<warning>}}If your current Kubernetes distribution is not [supported]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}}), upgrade to a supported distribution before upgrading. {{</warning>}}
+
+## RHEL9-based image
+
+Redis Enterprise images are now based on Red Hat Enterprise Linux 9 (RHEL9). This means upgrades require:
+
+- [Cluster version of 7.4.2-2 or later](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/).
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+For detailed steps, see the relevant upgrade page:
+
+- [OpenShift CLI]({{<relref "/operate/kubernetes/upgrade/openshift-cli">}})
+- [OpenShift OperatorHub]({{<relref "/operate/kubernetes/upgrade/upgrade-olm">}})
+- [Kubernetes]({{<relref "/operate/kubernetes/upgrade/upgrade-redis-cluster" >}})---
+Title: Recover a Redis Enterprise cluster on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to recover a Redis Enterprise cluster on Kubernetes.
+linkTitle: Recover a Redis cluster
+weight: 20
+---
+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:
+
+1. Recreates a fresh Redis Enterprise cluster
+1. Mounts the persistent storage with the recovery files from the original cluster to the nodes of the new cluster
+1. Recovers the cluster configuration on the first node in the new cluster
+1. Joins the remaining nodes to the new cluster.
+
+{{<warning>}}Redis Enterprise for Kubernetes 7.2.4-2 introduces a new limitation. You cannot recover or upgrade your cluster if there are databases with old module versions or manually uploaded modules. See the [Redis Enterprise Software 7.2.4 known limitations]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}}) for more details.{{</warning>}}
+
+## Prerequisites
+
+- For cluster recovery, the cluster must be [deployed with persistence]({{< relref "/operate/kubernetes/recommendations/persistent-volumes" >}}).
+
+## Recover a cluster
+
+1. Edit the REC resource to set the `clusterRecovery` flag to `true`.
+
+    ```sh
+    kubectl patch rec <cluster-name> --type merge --patch '{"spec":{"clusterRecovery":true}}'
+    ```
+
+
+1. Wait for the cluster to recover until it is in the "Running" state.
+
+    To see the state of the cluster, run:
+
+    ```sh
+    watch "kubectl describe rec | grep State"
+    ```
+
+1. To recover the database, see [Recover a failed database]({{< relref "/operate/rs/databases/recover" >}}).---
+Title: Delete custom resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article explains how to delete Redis Enterprise clusters and Redis
+  Enterprise databases from your Kubernetes environment.
+linkTitle: Delete custom resources
+weight: 70
+---
+
+## Multi-namespace management
+
+Before you can delete a namespace, you must remove the Redis custom resources ([REDB](#delete-a-database-redb), [REC](#delete-a-redis-enterprise-cluster-rec), and [operator](#delete-operator-from-one-namespace)) residing within a namespace before you can delete that namespace. Deleting namespace containing an REDB may cause errors or data loss.
+
+## Delete a database (REDB)
+
+To delete a database managed by the Redis Enterprise Kubernetes operator, run `kubectl delete redb <your-db-name>` from your K8s cluster.
+
+When you delete a database, your data and the REDB custom resource are also deleted.
+
+## Delete a Redis Enterprise cluster (REC)
+
+To delete a Redis Enterprise cluster managed by the operator:
+
+1. Delete all the databases in your cluster.
+
+2. Run `kubectl delete rec <your-rec-name>` from your K8s cluster.
+
+When you delete your cluster, your databases and the REC custom resource are also deleted. However, persistent volume claims (PVCs) for your cluster are not deleted in the process. If you want to delete your PVCs, you'll have to delete them manually.
+
+## Delete the operator
+
+There are two ways to delete the operator. You can delete the entire operator bundle, but this will also delete any cluster-wide resources created by the operator. To only delete resources within a specific namespace and leave other cluster-wide resources intact, you need to delete each resource manually.
+
+Whether you decide to delete the entire bundle or just resources from a specific namespace, it's important to delete the operator ConfigMap (`operator-environment-config`).
+
+```sh
+kubectl delete cm operator-environment-config
+```
+
+### Delete operator bundle
+
+To delete the operator from your K8s cluster, you can delete the operator bundle with:
+
+- `kubectl delete -f bundle.yaml` for non-OpenShift K8s deployments
+- `kubectl delete -f openshift.bundle.yaml` for OpenShift deployments 
+
+This will remove the operator and its custom resource definitions (CRDs) from your K8s cluster.
+
+{{< warning >}} The Redis Enterprise CRDs are non-namespaced resources, meaning they are shared across your entire K8s cluster. Deleting CRDs in one namespace will delete custom resources in every other namespace across the K8s cluster.{{</warning>}}
+
+### Delete operator from one namespace
+
+If you have Redis Enterprise clusters running in different namespaces on the same K8s cluster, deleting the entire operator bundle might cause data loss.
+
+To safely delete the operator from one namespace without affecting the others, delete the operator files individually, excluding the CRD files:
+
+```sh
+kubectl delete -f role.yaml
+kubectl delete -f role_binding.yaml
+kubectl delete -f service_account.yaml
+kubectl delete -f admission-service.yaml
+kubectl delete -f operator.yaml
+```
+
+You will also need to remove [the `namespaceSelector` section from the validating webhook]({{< relref "/operate/kubernetes/deployment/quick-start#webhook" >}}).
+
+## Delete an Active-Active database (REAADB)
+
+1. On one of the existing participating clusters, delete the REEADB (substituting `<reaadb-name>` with your database name).
+
+  ```sh
+  kubectl delete reaadb <reaadb-name>
+  ```
+
+2. Verify the REAADB no longer exists. 
+
+  ```sh
+  kubectl get reaadb -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Delete a remote cluster (RERC)
+
+1. Verify the RERC you want to delete isn't listed as a participating cluster in any REAADB resources.
+
+    If an RERC is still listed as a participating cluster in any database, the deletion will be blocked.
+
+2. On one of the existing participating clusters, delete the RERC (substituting `<rerc-name>` with your database name).
+
+  ```sh
+  kubectl delete rerc <rerc-name>
+  ```
+
+3. Verify the RERC no longer exists.
+
+  ```sh
+  kubectl get rerc -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Troubleshoot REDB deletion
+
+The operator attaches a finalizer to the Redis Enterprise database (REDB) object. This makes sure the database is deleted before the REDB custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REDB resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REDB has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch redb <your-db-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"finalizer.redisenterprisedatabases.app.redislabs.com"}]'
+```
+
+## Troubleshoot REC deletion
+
+The operator attaches a finalizer to the Redis Enterprise cluster (REC) object. This makes sure the Redis cluster is deleted before the REC custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REC resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REC has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch rec <your-rec-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"redbfinalizer.redisenterpriseclusters.app.redislabs.com"}]'
+```
+---
+Title: Connect to the admin console
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Connect to the Redis Enterprise admin console to manage your Redis Enterprise
+  cluster.
+linkTitle: Connect to the admin console
+weight: 10
+---
+
+The username and password for the Redis Enterprise Software [admin console]({{< relref "/operate/rs/" >}}) are stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/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. 
+{{</note>}}
+
+1. Switch to the namespace with your Redis Enterprise cluster (REC).
+
+    ```sh
+    kubectl config set-context --current --namespace=<namespace-of-rec>
+    ```
+
+1. Find your cluster name from your list of secrets.
+
+    ```sh
+    kubectl get secret
+    ```
+
+    In this example, the cluster name is `rec`.
+
+1. Extract and decode your credentials from the secret.
+
+    ```sh
+    kubectl get secret <cluster-name> -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <cluster-name> -o jsonpath='{.data.password}' | base64 --decode
+    ```
+
+1. Find the port for the REC UI service in the `spec:ports` section of the service definition file.
+
+    ```sh
+    kubectl get service/<cluster-name>-ui -o yaml
+    ```
+
+    {{<note>}}
+    The default port is 8443.
+    {{</note>}}
+
+1. Use `kubectl port-forward` to forward your local port to the service port.
+
+    ```sh
+    kubectl port-forward service/<cluster-name>-ui <local-port>:<service-port>
+   ```
+
+1. View the admin console from a web browser on your local machine at `https://localhost:8443`.
+
+---
+Title: Expand PersistentVolumeClaim (PVC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Expand your persistent volume claim by editing the REC.
+linkTitle: Expand PVC
+weight: 82
+---
+
+This article outlines steps to increase the size of the persistent volume claim for your Redis Enterprise cluster (REC).
+
+{{<note>}} This feature is only supported in versions 7.4.2-12 and above. {{</note>}}
+
+[PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) are created by the Redis Enterprise operator and used by the RedisEnterpriseCluster (REC). PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) with the following steps, if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+This process involves deleting and recreating the REC StatefulSet with a larger persistent volume size. The pods owned by the StatefulSet are not restarted or affected by the deletion and recreation process, except when they are left without an owner momentarily.
+
+{{<note>}}Shrinking (reducing the size) of your PVC is not allowed. This process only allows you to expand (size up) your PVC.{{</note>}}
+
+## Prerequisites
+
+{{<warning>}}Do not change any other REC fields related to the StatefulSet while resizing is in progress.
+{{</warning>}}
+
+- PVC expansion must be supported and enabled by the StorageClass and underlying storage driver of the REC PVCs.
+  - The relevant StorageClass is the one associated with the REC PVCs. The StorageClass for existing PVCs cannot be changed.
+- The StorageClass must be configured with `allowVolumeExpansion: true`.
+- Your storage driver must support online expansion.
+- We highly recommend you backup your databases before beginning this PVC expansion process.
+
+{{<warning>}} OpenShift users should be aware that (`ClusterResourceQuota`) can limit the PVC expansion. Check your quota before resizing using `oc describe clusterresourcequota <quota-name>`.{{</warning>}}
+
+## Expand REC PVC
+
+1. Enable the REC persistent volume resize flag.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+    ```
+
+1. Set the value of `volumeSize` to your desired size.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+          volumeSize: <new-size>Gi
+    ```
+
+1. Apply the changes to the REC, replacing `<your-rec.yaml>` with the name of your REC.
+
+  ```sh
+  kubectl apply -f <your-rec.yaml>
+  ```
+
+After applying the REC changes, the PVCs will begin to expand to the new size.
+
+Once all the PVCs finish the resizing process, the operator will delete and recreate the StatefulSet with the new volume size.
+
+### Track progress
+
+You can track the progress by monitoring the status of the REC and PersistentVolumeClaim objects.
+
+The REC status will correspond to the status of one or more PVCs, and will reflect if the resizing is successful or failed.
+
+While the resizing is in progress, the status will be:
+
+```yaml
+status:
+  persistenceStatus:
+    status: Resizing
+    succeeded: 2/3
+```
+
+When the resizing is complete, the status becomes Provisioned and the new volume size is available for use by the REC pods.
+
+```yaml
+status:
+  persistenceStatus:
+    status: Provisioned
+    succeeded: 3/3
+```
+
+### Troubleshooting
+
+If an error occurs during this process:
+
+- Examine the status and events of the REC and PVC objects.
+
+  ```sh
+  kubectl describe pvc
+  ```
+
+  ```sh
+  kubectl get events
+  ```
+
+- Examine the logs of the operator pods.
+
+  ```sh
+  kubectl logs <operator_pod_name>
+  ```
+---
+Title: Connect the Prometheus operator to Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article describes how to configure a Prometheus operator custom
+  resource to allow it to export metrics from Redis Enterprise for Kubernetes.
+linkTitle: Export metrics to Prometheus
+weight: 92
+---
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can connect your [Prometheus](https://prometheus.io/) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+
+## Prerequisites
+
+Before connecting Redis Enterprise to Prometheus on your Kubernetes cluster, make sure you've done the following:
+
+- [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/deployment/quick-start" >}}) (version 6.2.10-4 or newer)
+- [Deploy the Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md) (version 0.19.0 or newer)
+- [Create a Redis Enterprise cluster]({{< relref "/operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}})
+
+## Create a `ServiceMonitor` custom resource
+
+Below is an example `ServiceMonitor` custom resource file. By specifying the service label (`app: redis.io/service=prom-metrics`) in the `selector.matchLabels` section, you can point the Prometheus operator to the correct Redis Enterprise service (`<rec_name>-prom`).
+
+You'll need to configure the following fields to connect Prometheus to Redis Enterprise:
+
+| Section | Field | Value |
+|---|---|---|
+| `spec.endpoints` | `port` | Name of exposed port (`prometheus`) |
+| `spec.namespaceSelector` | `matchNames` | Namespace for your REC |
+| `spec.selector` | `matchLabels` | REC service label (`app: redis.io/service=prom-metrics`) |
+
+Apply the file in the same namespace as your Redis Enterprise cluster (REC).
+    {{<note>}}If Redis Enterprise and Prometheus are deployed in different namespaces, you'll also need to add the [`serviceMonitorNamespaceSelector`](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api.md#namespaceselector) field to your Prometheus resource. See the [Prometheus operator documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources) for more details on cross-namespace `ServiceMonitor` configuration.{{</note>}}
+
+
+```YAML
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: redis-enterprise
+spec:
+  endpoints:
+  - interval: 15s
+    port: prometheus
+    scheme: https
+    tlsConfig:
+      insecureSkipVerify: true
+  namespaceSelector:
+    matchNames:
+    - <your_REC_namespace>
+  selector:
+    matchLabels:
+      redis.io/service: prom-metrics
+```
+
+For more info about configuring the `ServiceMonitor` resource, see the [`ServiceMonitorSpec` API documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api-reference/api.md#monitoring.coreos.com/v1.ServiceMonitorSpec).
+
+## More info
+
+- github.com/prometheus-operator
+  - [Getting started](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md)
+  - [Running exporters](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/running-exporters.md)
+  - [Related resources](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources)
+  - [Troubleshooting ServiceMonitor changes](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/troubleshooting.md)
+- redis.io/docs
+  - [Metrics in Prometheus]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}})
+  - [Monitoring and metrics]({{< relref "/operate/rs/monitoring/" >}})
+---
+Title: Manage databases in multiple namespaces
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces
+  within your Kubernetes cluster. This article shows you how to configure your Redis
+  Enterprise cluster to connect to databases in multiple namespaces
+linktitle: Manage multiple namespaces
+weight: 17
+---
+
+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]({{< relref "/operate/kubernetes/architecture/deployment-options" >}}).
+
+{{<note>}}
+Multi-namespace installations now support Active-Active databases (REAADB) with certain configuration requirements. For details, see [Multi-namespace Active-Active databases](#multi-namespace-active-active-databases).
+{{</note>}}
+
+## Prerequisites
+
+Before configuring a multi-namespace deployment, you must have a running [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/deployment/quick-start" >}}). See more information in the [deployment]({{< relref "/operate/kubernetes/deployment/" >}}) section.
+
+## Create role and role binding for managed namespaces
+
+Both the operator and the RedisEnterpriseCluster (REC) resource need access to each namespace the REC will manage. For each **managed** namespace, create a `role.yaml` and `role_binding.yaml` file within the managed namespace, as shown in the examples below.
+
+{{<note>}}These will need to be reapplied each time you [upgrade]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster" >}}). {{</note>}}
+
+Replace `<rec-namespace>` with the namespace the REC resides in.
+Replace `<service-account-name>` with your own value (defaults to the REC name).
+
+`role.yaml` example: 
+
+```yaml
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups:
+      - app.redislabs.com
+    resources: ["redisenterpriseclusters", "redisenterpriseclusters/status", "redisenterpriseclusters/finalizers",
+                "redisenterprisedatabases", "redisenterprisedatabases/status", "redisenterprisedatabases/finalizers",
+                "redisenterpriseremoteclusters", "redisenterpriseremoteclusters/status",
+                "redisenterpriseremoteclusters/finalizers",
+                "redisenterpriseactiveactivedatabases", "redisenterpriseactiveactivedatabases/status",
+                "redisenterpriseactiveactivedatabases/finalizers"]
+    verbs: ["delete", "deletecollection", "get", "list", "patch", "create", "update", "watch"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["update", "get", "read", "list", "listallnamespaces", "watch", "watchlist",
+            "watchlistallnamespaces", "create","patch","replace","delete","deletecollection"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create"]
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["get", "watch", "list", "update", "patch", "create", "delete"]
+```
+
+`role_binding.yaml` example:
+
+```yaml
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: <rec-namespace>
+- kind: ServiceAccount
+  name: <service-account-name>
+  namespace: <rec-namespace>
+roleRef:
+  kind: Role
+  name: redb-role
+  apiGroup: rbac.authorization.k8s.io
+```
+
+Apply the files, replacing `<managed-namespace>` with your own values:
+
+```sh
+kubectl apply -f role.yaml -n <managed-namespace>
+kubectl apply -f role_binding.yaml -n <managed-namespace>
+```
+
+{{<note>}}
+If the REC is configured to watch a namespace without setting the role and role binding permissions, or a namespace that is not yet created, the operator will fail and halt normal operations.
+{{</note>}}
+
+## Update Redis Enterprise operator ConfigMap
+
+There are two methods of updating the operator ConfigMap (`operator-environment-config`) to specify which namespaces to manage.
+
+- Method 1: Configure the operator to watch for a namespace label and add this label to managed namespaces (available in versions 6.4.2-4 or later).
+- Method 2: Configure the operator with an explicit list of namespaces to manage.
+
+You can create this ConfigMap manually before deployment, or it will be created automatically after the operator was deployed.
+
+{{<warning>}}
+Only configure the operator to watch a namespace after the namespace is created and configured with the role/role_binding as explained above. If configured to watch a namespace without setting those permissions or a namespace that is not created yet, the operator will fail and not perform normal operations.
+{{</warning>}}
+
+### Method 1: Namespace label (available in versions 6.4.2-4 or later)
+
+1. Create the `cluster_role_binding.yaml` and `cluster_role.yaml` files. Replace the `<rec-namespace>` with the namespace the Redis Enterprise cluster (REC) resides in.
+
+  `operator_cluster_role.yaml` example:
+
+  ```yaml
+    apiVersion: rbac.authorization.k8s.io/v1
+    kind: ClusterRole
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    rules:
+      - apiGroups: [""]
+        resources: ["namespaces"]
+        verbs: ["list", "watch"]
+  ```
+
+  `operator_cluster_role_binding.yaml` example:
+
+  ```yaml
+    kind: ClusterRoleBinding
+    apiVersion: rbac.authorization.k8s.io/v1
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    subjects:
+    - kind: ServiceAccount
+      name: redis-enterprise-operator
+      namespace: <rec-namespace>
+    roleRef:
+      kind: ClusterRole
+      name: redis-enterprise-operator-consumer-ns
+      apiGroup: rbac.authorization.k8s.io
+  ```
+
+2. Apply the files.
+
+  ```sh
+  kubectl apply -f operator_cluster_role.yaml
+  kubectl apply -f operator_cluster_role_binding.yaml 
+  ```
+
+3. Patch the ConfigMap in the REC namespace (`<rec-namespace>`) to identify the managed namespaces with your label (`<label-name>`).
+
+  ```sh
+   kubectl patch ConfigMap/operator-environment-config \
+  -n <rec-namespace> \
+  --type merge \
+  -p '{"data": {"REDB_NAMESPACES_LABEL": "<label-name>"}}'
+  ```
+
+4. For each managed namespace, apply the same label. Replace `<managed-namespace>` with the namespace the REC will manage. Replace `<label-name>` with the value used in the previous step. If you specify a value for `<label-value>`, both the label name and value in managed namespaces must match to be detected by the operator. If the `<label-value>` is empty, only the label name needs to match on managed namespaces and the value is disregarded.
+
+
+  ```sh
+  kubectl label namespace <managed-namespace> <label-name>=<label-value>
+  ```
+
+{{<note>}}
+The operator restarts when it detects a namespace label was added or removed.
+{{</note>}}
+
+### Method 2: Explicit namespace list
+
+Patch the `operator-environment-config` in the REC namespace with a new environment variable (`REDB_NAMESPACES`).
+
+```sh
+kubectl patch ConfigMap/operator-environment-config \ 
+-n <rec-namespace> \
+--type merge \
+-p '{"data":{"REDB_NAMESPACES": "<comma,separated,list,of,namespaces,to,watch"}}'
+```
+
+## Multi-namespace Active-Active databases
+
+You can also deploy `RedisEnterpriseActiveActiveDatabase` (REAADB) objects in consumer namespaces separate from the Redis Enterprise operator or cluster (REC) namespace.
+
+To do this:
+
+1. Configure each participating cluster’s operator to watch the relevant consumer namespace. See [multi-namespace operator setup](#update-redis-enterprise-operator-configmap).
+2. Ensure all Active-Active prerequisites are met as described in [Configure Active-Active]({{<relref "/operate/kubernetes/active-active/create-reaadb/">}}).
+3. In your REAADB custom resource, specify the target consumer namespace using `metadata.namespace`. For each participating cluster, use the `namespace` field under `spec.participatingClusters` to indicate the namespace where the REAADB should be deployed.
+4. If you are using a [global database secret]({{<relref "operate/kubernetes/active-active/global-db-secret/">}}), deploy the secret in each consumer namespace.
+
+{{<note>}}
+Apply the REAADB object to only one Kubernetes cluster. Based on the specified participating clusters and namespaces, the operator automatically creates the necessary resources in the other clusters.
+{{</note>}}
+
+For example:
+
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseActiveActiveDatabase
+metadata:
+  name: consumer-reaadb
+  namespace: consumer-namespace-main
+spec:
+  participatingClusters:
+    - name: participating-cluster-main
+    - name: participating-cluster-peer
+      namespace: consumer-namespace-peer
+  globalConfigurations:
+    <your global configurations>
+```
+
+{{<warning>}}
+Configure the operator to watch a namespace only after the namespace exists and the required `Role` and `RoleBinding` resources have been applied. If the operator is configured to watch a namespace that lacks these permissions or does not exist, it will fail and halt normal operations.
+{{</warning>}}
+---
+Title: Redis Enterprise clusters (REC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise clusters (REC).
+hideListLinks: false
+linkTitle: Redis Enterprise clusters (REC)
+weight: 30
+---
+
+This section contains articles to help you manage your Redis Enterprise clusters (REC).
+
+
+
+---
+Title: Use Auto Tiering on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Deploy a cluster with Auto Tiering on Kubernetes.
+linkTitle: Auto Tiering
+weight: 16
+---
+
+## Prerequisites
+
+Redis Enterprise Software for Kubernetes supports using Auto Tiering (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+{{<note>}}
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+{{</note>}}
+
+Before creating your Redis clusters or databases, these SSDs must be:
+
+- [locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+- formatted and mounted on the nodes that will run Redis Enterprise pods
+- dedicated to Auto Tiering and not shared with other parts of the database, (e.g. durability, binaries)
+- [provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+  - You can use a [local volume provisioner](https://github.com/kubernetes-sigs/sig-storage-local-static-provisioner/blob/master/README.md) to do this [dynamically](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#dynamic)
+- a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource with a unique name
+
+For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+## Create a Redis Enterprise cluster
+
+To deploy a Redis Enterprise cluster (REC) with Auto Tiering, you'll need to specify the following in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/reference/redis_enterprise_cluster_api" >}}):
+
+- enable Auto Tiering (`enabled: true`)
+- flash storage driver (`bigStoreDriver`)
+  - `rocksdb` or `speedb`(default)
+- storage class name (`storageClassName`)
+- minimal flash disk size (`flashDiskSize`)
+
+{{<note>}} Clusters upgraded to version 7.2.4-2 from an earlier version will change the `bigStoreDriver` (previously called `flashStorageEngine`) to the new default `speedb`, regardless of previous configuration. {{</note>}}
+
+{{<warning>}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+Here is an example of an REC custom resource with these attributes:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: "rec"
+spec:
+  
+  nodes: 3
+  redisOnFlashSpec:
+    enabled: true
+    bigStoreDriver: speedb
+    storageClassName: local-scsi
+    flashDiskSize: 100G
+```
+
+### Create a Redis Enterprise database
+
+By default, any new database will use RAM only. To create a Redis Enterprise database (REDB) that can use flash storage, specify the following in the `redisEnterpriseCluster` section of the REDB custom resource definition:
+
+- `isRof: true` enables Auto Tiering
+- `rofRamSize` defines the RAM capacity for the database
+
+Below is an example REDB custom resource:
+
+```YAML
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: autoteiring-redb
+spec:
+  redisEnterpriseCluster:
+    name: rec
+  isRof: true
+  memorySize: 2GB
+  rofRamSize: 0.5GB
+```
+
+{{< note >}}
+This example defines both `memorySize` and `rofRamSize`. When using Auto Tiering, `memorySize` refers to the total combined memory size (RAM + flash) allocated for the database. `rofRamSize` specifies only the RAM capacity for the database. `rofRamSize` must be at least 10% of `memorySize`.
+{{< /note >}}
+---
+Title: Create Active-Active databases with crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section shows how to set up an Active-Active Redis Enterprise database
+  on Kubernetes using the Redis Enterprise Software operator.
+linkTitle: Create Active-Active with crdb-cli
+weight: 99
+---
+{{<note>}} Versions 6.4.2 and later support the Active-Active database controller. This controller allows you to create Redis Enterprise Active-Active databases (REAADB) and Redis Enterprise remote clusters (RERC) with custom resources. We recommend using the [REAADB method for creating Active-Active databases]({{< relref "/operate/kubernetes/active-active/create-reaadb" >}}).{{</note>}}
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read-and-write access to the same dataset from different Kubernetes clusters. For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.
+
+This process consists of:
+
+1. Documenting values to be used in later steps. It's important these values are correct and consistent.
+1. Editing the Redis Enterprise cluster (REC) spec file to include the `ActiveActive` section. This will be slightly different depending on the K8s distribution you are using.
+1. Creating the database with the `crdb-cli` command. These values must match up with values in the REC resource spec.
+
+## Prerequisites
+
+Before creating Active-Active databases, you'll need admin access to two or more working Kubernetes clusters that each have:
+
+- Routing for external access with an [ingress resources]({{< relref "/operate/kubernetes/networking/ingress" >}}) (or [route resources]({{< relref "/operate/kubernetes/networking/routes" >}}) on OpenShift).
+- A working [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/reference/redis_enterprise_cluster_api" >}}) with a unique name.
+- Enough memory resources available for the database (see [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}})).
+
+{{<note>}} The `activeActive` field and the `ingressOrRouteSpec` field cannot coexist in the same REC. If you configured your ingress via the `ingressOrRouteSpec` field in the REC, create your Active-Active database with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource.{{</note>}}
+
+## Document required parameters
+
+The most common mistake when setting up Active-Active databases is incorrect or inconsistent parameter values. The values listed in the resource file must match those used in the crdb-cli command.
+
+- **Database name** `<db-name>`:
+  - Description: Combined with ingress suffix to create the Active-Active database hostname
+  - Format: string
+  - Example value: `myaadb`
+  - How you get it: you choose
+  - The database name requirements are:
+       - Maximum of 63 characters
+       - Only letter, number, or hyphen (-) characters
+       - Starts with a letter; ends with a letter or digit.
+       - Database name is not case-sensitive
+
+You'll need the following information for each participating Redis Enterprise cluster (REC):
+
+{{<note>}}
+You'll need to create DNS aliases to resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address for the ingress controller’s LoadBalancer (or routes in Openshift) for each database. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as *.ijk.example.com).
+{{</note>}}
+
+- **REC hostname** `<rec-hostname>`:
+  - Description: Hostname used to identify your Redis Enterprise cluster in the `crdb-cli` command. This MUST be different from other participating clusters.
+  - Format: `<rec-name>.<namespace>.svc.cluster.local`
+  - Example value: `rec01.ns01.svc.cluster.local`
+  - How to get it: List all your Redis Enterprise clusters
+      ```bash
+      kubectl get rec
+      ```
+- **API hostname** `<api-hostname>`:
+  - Description: Hostname used to access the Redis Enterprise cluster API from outside the K8s cluster
+  - Format: string
+  - Example value: `api.ijk.example.com`
+- **Ingress suffix** `<ingress-suffix>`:
+  - Description: Combined with database name to create the Active-Active database hostname
+  - Format: string
+  - Example value: `-cluster.ijk.example.com`
+- [**REC admin credentials**]({{< relref "/operate/kubernetes/security/manage-rec-credentials" >}}) `<username> <password>`:
+  - Description: Admin username and password for the REC stored in a secret
+  - Format: string
+  - Example value: username: `user@example.com`, password: `something`
+  - How to get them:
+    ```sh
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.password}' | base64 --decode
+    ```
+- **Replication hostname** `<replication-hostname>`:
+  - Description: Hostname used inside the ingress for the database
+  - Format: `<db-name><ingress-suffix>`
+  - Example value: `myaadb-cluster.ijk.example.com`
+  - How to get it: Combine `<db-name>` and `<ingress-suffix`> values you documented above.
+- **Replication endpoint** `<replication-endpoint>`:
+  - Description: Endpoint used externally to contact the database
+  - Format: `<db-name><ingress-suffix>:443`
+  - Example value: `myaadb-cluster.ijk.example.com:443`
+  - How to get it:`<replication-hostname>:443`
+
+## Add `activeActive` section to the REC resource file
+
+From inside your K8s cluster, edit your Redis Enterprise cluster (REC) resource to add the following to the `spec` section. Do this for each participating cluster.
+
+ The operator uses the API hostname (`<api-hostname>`) to create an ingress to the Redis Enterprise cluster's API; this only happens once per cluster. Every time a new Active-Active database instance is created on this cluster, the operator creates a new ingress route to the database with the ingress suffix (`<ingress-suffix>`). The hostname for each new database will be in the format <nobr>`<db-name><ingress-suffix>`</nobr>.
+
+### Using ingress controller
+
+1. If your cluster uses an [ingress controller]({{< relref "/operate/kubernetes/networking/ingress" >}}), add the following to the `spec` section of your REC resource file.
+
+  Nginx:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+       kubernetes.io/ingress.class: nginx
+      nginx.ingress.kubernetes.io/backend-protocol: HTTPS
+      nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+HAproxy:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+      kubernetes.io/ingress.class: haproxy
+       ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+2. After the changes are saved and applied, you can verify a new ingress was created for the API.
+
+    ```sh
+    $ kubectl get ingress
+    NAME   HOSTS                            ADDRESS                                 PORTS   AGE
+    rec01  api.abc.cde.example.com  225161f845b278-111450635.us.cloud.com   80      24h
+    ```
+
+3. Verify you can access the API from outside the K8s cluster.
+
+    ```sh
+   curl -k -L -i -u <username>:<password> https://<api-hostname>/v1/cluster
+    ```
+
+    If the API call fails, create a DNS alias that resolves your API hostname (`<api-hostname>`) to the IP address for the ingress controller's LoadBalancer.
+
+4. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address of the ingress controller’s LoadBalancer. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+#### If using Istio Gateway and VirtualService
+
+No changes are required to the REC spec if you are using [Istio]({{< relref "/operate/kubernetes/networking/istio-ingress" >}}) in place of an ingress controller. The `activeActive` section added above creates ingress resources. The two custom resources used to configure Istio (Gateway and VirtualService) replace the need for ingress resources.
+
+{{<warning>}}
+These custom resources are not controlled by the operator and will need to be configured and maintained manually.
+{{</warning>}}
+
+For each cluster, verify the VirtualService resource has two `- match:` blocks in the `tls` section. The hostname under `sniHosts:` should match your `<replication-hostname>`.
+
+### Using OpenShift routes
+
+1. Make sure your Redis Enterprise cluster (REC) has a different name (`<rec-name.namespace>`) than any other participating clusters. If not, you'll need to manually rename the REC or move it to a different namespace.
+            You can check your new REC name with:
+    ```sh
+    oc get rec -o jsonpath='{.items[0].metadata.name}'
+    ```
+
+    If the rec name was modified, reapply [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml) to the namespace to reestablish security privileges.
+    
+    ```sh
+    oc apply -f scc.yaml
+    oc adm policy add-scc-to-group redis-enterprise-scc-v2  system:serviceaccounts:<namespace>
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the route IP address. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. If your cluster uses [OpenShift routes]({{< relref "/operate/kubernetes/networking/routes" >}}), add the following to the `spec` section of your Redis Enterprise cluster (REC) resource file.
+
+      ```sh
+      activeActive:
+        apiIngressUrl: <api-hostname>
+        dbIngressSuffix: <ingress-suffix>
+        method: openShiftRoute
+      ```
+
+1. Make sure you have DNS aliases that resolve to the routes IP for both the API hostname (`<api-hostname>`) and the replication hostname (`<replication-hostname>`) for each database. To avoid entering each database individually, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. After the changes are saved and applied, you can see that a new route was created for the API.
+
+    ```sh
+    $ oc get route
+    NAME    HOST/PORT                       PATH    SERVICES  PORT  TERMINATION   WILDCARD
+    rec01   api-openshift.apps.abc.example.com rec01   api             passthrough   None
+    ```
+
+## Create an Active-Active database with `crdb-cli`
+
+The `crdb-cli` command can be run from any Redis Enterprise pod hosted on any participating K8s cluster. You'll need the values for the [required parameters]({{< relref "/operate/kubernetes/active-active/create-aa-crdb-cli#document-required-parameters" >}}) for each Redis Enterprise cluster.
+
+```sh
+crdb-cli crdb create \
+  --name <db-name> \
+  --memory-size <mem-size> \
+  --encryption yes \
+  --instance fqdn=<rec-hostname-01>,url=https://<api-hostname-01>,username=<username-01>,password=<password-01>,replication_endpoint=<replication-endpoint-01>,replication_tls_sni=<replication-hostname-01> \
+  --instance fqdn=<rec-hostname-02>,url=https://<api-hostname-02>,username=<username-02>,password=<password-02>,replication_endpoint=<replication-endpoint-02>,replication_tls_sni=<replication-hostname-02>
+```
+
+To create a database that syncs between more than two instances, add additional `--instance` arguments.
+
+See the [`crdb-cli` reference]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for more options.
+
+## Test your database
+
+The easiest way to test your Active-Active database is to set a key-value pair in one database and retrieve it from the other.
+
+You can connect to your databases with the instructions in [Manage databases]({{< relref "/operate/kubernetes/re-databases/db-controller#connect-to-a-database" >}}). Set a test key with `SET foo bar` in the first database. If your Active-Active deployment is working properly, when connected to your second database, `GET foo` should output `bar`.
+---
+Title: Set global database secret
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' to set the
+  global database secret.
+linkTitle: Global database secret
+weight: 50
+---
+{{<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.{{</note>}}
+
+## 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.
+
+To edit other global configruations, see [global configuration]({{< relref "/operate/kubernetes/active-active/global-config" >}})
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the database password.
+
+  This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+  ```yaml
+  apiVersion: v1
+  data:
+    password: bXktcGFzcw
+  kind: Secret
+  metadata:
+    name: my-db-secret
+  type: Opaque
+  ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    example-aadb-1   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit Redis Enterprise remote clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Edit the configuration details of an existing RERC with Redis Enterprise
+  for Kubernetes.
+linkTitle: Edit RERC
+weight: 60
+---
+{{<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.{{</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.
+
+The RERC controller periodically connects to the local REC endpoint via its external address, to ensure it’s setup correctly. For this to work, the external load balancer must support [NAT hairpinning](https://en.wikipedia.org/wiki/Network_address_translation#NAT_loopback). In some cloud environments, this may involve disabling IP preservation for the load balancer target groups.
+
+For more details, see the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}).
+
+## Edit RERC
+
+Use the `kubectl patch rerc <rerc-name> --type merge --patch` command to patch the local RERC custom resource with your changes. For a full list of available fields, see the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}).
+
+The following example edits the `dbFqdnSuffix` field for the RERC named `rerc-ohare`.
+
+```sh
+kubectl patch rerc rerc-ohare --type merge --patch \
+'{"spec":{"dbFqdnSuffix": "-example2-cluster-rec-chicago-ns-illinois.example.com"}}'
+```
+
+## Update RERC secret
+
+If the credentials are changed or updated for a REC participating cluster, you need to manually edit the RERC secret and apply it to all participating clusters.
+
+1. On the local cluster, update the secret with new credentials and name it with the following convention:  `redis-enterprise-<rerc-name>`.
+
+    A secret for a remote cluster named `rerc-ohare` would be similar to the following:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: PHNvbWUgcGFzc3dvcmQ+
+      username: PHNvbWUgdXNlcj4
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+    ```
+
+1. Apply the file.
+
+    ```sh
+    kubectl apply -f <secret-file>
+    ```
+
+1. Watch the RERC to verify the status is "Active" and the spec status is "Valid."
+
+      ```sh
+      kubectl get rerc <rerc-name>
+      ```
+
+    The output should look like this:
+  
+      ```sh
+       NAME        STATUS   SPEC STATUS   LOCAL
+        rerc-ohare   Active   Valid         true
+      ```
+      
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/logs/" >}}).
+
+1. Verify the status of each REAADB using that RERC is "Active" and the spec status is "Valid."
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up
+    ```
+
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/logs/" >}}).
+
+1. Repeat the above steps on all other participating clusters.---
+Title: Prepare participating clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Prepare your participating RECs to be part of an Active-Active database
+  deployment.
+linkTitle: Prepare clusters
+weight: 10
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/deployment/quick-start#enable-the-admission-controller/" >}}).
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/networking/ingressorroutespec" >}}) and [create DNS records]({{< relref "/operate/kubernetes/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+Next you'll [collect credentials](#collect-rec-credentials) for your participating clusters and create secrets for the RedisEnterprsieRemoteCluster (RERC) to use.
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+## Collect REC credentials
+
+To communicate with other clusters, all participating clusters will need access to the admin credentials for all other clusters.
+
+1. Create a file to hold the admin credentials for all participating RECs (such as `all-rec-secrets.yaml`).
+
+1. Within that file, create a new secret for each participating cluster named `redis-enterprise-<rerc-name>`.
+
+    The example below shows a file (`all-rec-secrets.yaml`) holding secrets for two participating clusters:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Get the REC credentials secret for each participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    The admin credentials secret for an REC named `rec-chicago` would be similar to this:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-chicago
+    type: Opaque
+    ```
+
+1. Add the username and password to the new secret for that REC and namespace.
+
+    This example shows the collected secrets file (`all-rec-secrets.yaml`) for `rerc-ohare` (representing `rec-chicago` in namespace `ns-illinois`) and `rerc-reagan` (representing `rec-arlington` in namespace `ns-virginia`).
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: KLmndo123456
+      username: PQrst789010
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <all-rec-secrets-file>
+    ```
+
+   If the admin credentials for any of the clusters changes, the file will need to be updated and reapplied to all clusters.
+
+## Next steps
+
+Now you are ready to [create your Redis Enterprise Active-Active database]({{< relref "/operate/kubernetes/active-active/create-reaadb" >}}).
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+---
+Title: Set global database configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' and through
+  this the database configurations are set.
+linkTitle: Global configuration
+weight: 50
+---
+{{<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.{{</note>}}
+
+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]({{<relref "/operate/kubernetes/reference/redis_enterprise_active_active_database_api">}}) contains a full list of available fields.
+
+## Edit global configurations
+
+1. Edit or patch the REAADB custom resource with your global configuration changes.
+
+    The example command below patches the REAADB named `reaadb-boeing` to set the global memory size to 200MB:
+
+    ```sh
+    kubectl patch reaadb reaadb-boeing --type merge --patch \
+    '{"spec": {"globalConfigurations": {"memorySize": "200mb"}}}'
+    ```
+
+1. Verify the status is `active` and the spec status is `Valid`.
+
+    This example shows the status for the `reaadb-boeing` database.
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid    
+    ```
+
+1. View the global configurations on each participating cluster to verify they are synced.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o yaml
+    ```
+
+## Edit global configuration secrets
+
+This section edits the secrets under the REAADB `.spec.globalConfigurations` section. For more information and all available fields, see the [REAADB API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_active_active_database_api">}}).
+
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the relevant data.
+
+    This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+    ```yaml
+    apiVersion: v1
+     data:
+      password: bXktcGFzcw
+    kind: Secret
+    metadata:
+      name: my-db-secret
+    type: Opaque
+    ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.---
+Title: Edit participating clusters for Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Steps to add or remove a participating cluster to an existing Active-Active
+  database with Redis Enterprise for Kubernetes.
+linkTitle: Edit participating clusters
+weight: 40
+---
+{{<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.{{</note>}}
+
+## Add a participating cluster
+
+Use the following steps to add a participating cluster to an existing Redis Enterprise Active-Active database (REAADB) for Kubernetes.
+
+### Prerequisites
+
+To prepare the Redis Enterprise cluster (REC) to participate in an Active-Active database, perform the following tasks from [Prepare participating clusters]({{< relref "/operate/kubernetes/active-active/prepare-clusters" >}}):
+
+- Make sure the cluster meets the hardware and naming requirements.
+- Enable the Active-Active controllers.
+- Configure external routing.
+- Configure `ValidatingWebhookConfiguration`.
+
+### Collect REC credentials
+
+To communicate with other clusters, all participating clusters need access to the admin credentials for all other clusters.
+
+1. Get the REC credentials secret for the new participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    This example shows an admin credentials secret for an REC named `rec-boston`:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-boston
+    type: Opaque
+    ```
+
+1. Create a secret for the new participating cluster named `redis-enterprise-<rerc>` and add the username and password.
+
+    The example below shows a secret file for a remote cluster named `rerc-logan` .
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-logan
+    type: Opaque
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <rec-secret-file>
+    ```
+
+ If the admin credentials for any of the clusters change, update and reapply the file to all clusters.
+
+### Create RERC
+
+1. From one of the existing participating clusters, create a `RedisEnterpriseRemoteCluster` (RERC) custom resource for the new participating cluster.
+
+    This example shows an RERC custom resource for an REC named `rec-boston` in the namespace `ns-massachusetts`. 
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-logan
+    spec:
+      recName: rec-boston
+      recNamespace: ns-massachusetts
+      apiFqdnUrl: test-example-api-rec-boston-ns-massachusetts.example.com
+      dbFqdnSuffix: -example-cluster-rec-boston-ns-massachusetts.example.com
+      secretName: redis-enterprise-rerc-logan
+    ```
+
+1. Create the RERC custom resource.
+
+    ```sh
+    kubectl create -f <new-RERC-file>
+    ```
+
+1. Check the status of the newly created RERC custom resource.
+
+    ```sh
+    kubectl get rerc <RERC-name>
+    ```
+
+    The output should look like this:
+
+    ```sh
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-logan   Active   Valid         true
+    ```
+
+### Edit REAADB spec
+
+1. Patch the REAADB spec to add the new RERC name to the `participatingClusters`, replacing `<reaadb-name>` and `<rerc-name>` with your own values.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> < --type merge --patch '{"spec": {"participatingClusters": [{"name": "<rerc-name>"}]}}'
+    ```
+
+1. View the REAADB `participatingClusters` status to verify the cluster was added.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.participatingClusters}'
+    ```
+
+    The output should look like this:
+
+    ```sh
+    [{"id":1,"name":"rerc-ohare"},{"id":2,"name":"rerc-reagan"},{"id":3,"name":"rerc-logan"}]
+    ```
+
+## Remove a participating cluster
+
+1. On an existing participating cluster,remove the desired cluster from the `participatingCluster` section of the REAADB spec.
+
+    ```sh
+    kubectl edit reaadb <reaadb-name>
+    ```
+
+1. On each of the other participating clusters, verify the status is `active` and the spec status is `Valid` and the cluster was removed.
+
+   ```sh
+   kubectl get reaadb <reaadb-name -o=jasonpath=`{.status}`
+   ```
+   
+    The output should look like this:
+    
+    ```sh
+    {... ,"participatingClusters":[{"id":1,"name":"rerc1"},{"id":2,"name":"rerc2"}],"redisEnterpriseCluster":"rec1","specStatus":"Valid","status":"active"}
+    ```
+
+1. On the removed participating cluster, list all REAADB resources on the cluster to verify they were deleted.
+
+
+    ```sh
+    kubectl get reaadb -o+jasonpath=`{range.items[*]}{.metadata.name}`
+    ```
+---
+Title: Create Active-Active database (REAADB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: Create database
+weight: 30
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/deployment/quick-start#enable-the-admission-controller/" >}}).
+   {{<note>}}These are installed and enabled by default on clusters created via the OpenShift OperatorHub. {{</note>}}
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/networking/ingressorroutespec" >}}) and [create DNS records]({{< relref "/operate/kubernetes/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+4. [Prepare participating clusters]({{< relref "/operate/kubernetes/active-active/prepare-clusters" >}})
+   * RERC name (`<rerc-name`>)
+   * RERC secret name (`redis-enterprise-<rerc-name>`)
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+## Create `RedisEnterpriseRemoteCluster` resources {#create-rerc}
+
+1. Create a `RedisEnterpriseRemoteCluster` (RERC) custom resource file for each participating Redis Enterprise cluster (REC).
+
+   Below are examples of RERC resources for two participating clusters. Substitute your own values to create your own resource.
+
+    Example RERC (`rerc-ohare`) for the REC named `rec-chicago` in the namespace `ns-illinois`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-ohare
+    spec:
+      recName: rec-chicago
+      recNamespace: ns-illinois
+      apiFqdnUrl: api-rec-chicago-ns-illinois.example.com
+      dbFqdnSuffix: -db-rec-chicago-ns-illinois.example.com
+      secretName: redis-enterprise-rerc-ohare
+    ```
+
+    Example RERC (`rerc-raegan`) for the REC named `rec-arlington` in the namespace `ns-virginia`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-reagan
+    spec:
+      recName: rec-arlington
+      recNamespace: ns-virginia
+      apiFqdnUrl: test-example-api-rec-arlington-ns-virginia.example.com
+      dbFqdnSuffix: -example-cluster-rec-arlington-ns-virginia.example.com
+      secretName: redis-enterprise-rerc-reagan
+    ```
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise remote cluster from each RERC custom resource file.
+  
+   ```sh
+   kubectl create -f <rerc-file>
+   ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, then your configurations are correct.
+  
+    ```sh
+    kubectl get rerc <rerc-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get rerc rerc-ohare
+
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-ohare   Active   Valid         true
+    ```
+  
+    In case of errors, review the RERC custom resource events and the Redis Enterprise operator logs.
+
+## Create `RedisEnterpriseActiveActiveDatabase` resource {#create-reaadb}
+
+1. Create a `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource file meeting the naming requirements and listing the names of the RERC custom resources created in the last step.
+
+    Naming requirements:
+    * less than 63 characters
+    * contains only lowercase letters, numbers, or hyphens
+    * starts with a letter
+    * ends with a letter or digit
+
+    Example REAADB named `reaadb-boeing` linked to the REC named `rec-chicago` with two participating clusters and a global database configuration with shard count set to 3:
+
+     ```yaml
+     apiVersion: app.redislabs.com/v1alpha1
+     kind: RedisEnterpriseActiveActiveDatabase
+     metadata:
+       name: reaadb-boeing
+     spec:
+       globalConfigurations:
+         databaseSecretName: <my-secret>
+         memorySize: 200MB
+         shardCount: 3
+       participatingClusters:
+           - name: rerc-ohare
+           - name: rerc-reagan
+     ```
+
+     {{<note>}}Sharding is disabled on Active-Active databases created with a `shardCount` of 1. Sharding cannot be enabled after database creation. {{</note>}}
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise Active-Active database from the REAADB custom resource file.
+  
+    ```sh
+    kubectl create -f <reaadb-file>
+    ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, your configurations are correct.
+  
+    ```sh
+    kubectl get reaadb <reaadb-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up             
+    ```
+
+  
+    In case of errors, review the REAADB custom resource events and the Redis Enterprise operator logs.
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+
+---
+Title: Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Content related to Active-Active Redis Enterprise databases for Kubernetes.
+hideListLinks: true
+linkTitle: Active-Active databases
+weight: 40
+---
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters.
+
+## Active-Active setup methods
+
+There are two methods for creating an Active-Active database with Redis Enterprise for Kubernetes:
+
+- The `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource is available for versions 6.4.2 and later.
+- The `crdb-cli` method is available for versions 6.4.2 or earlier.
+
+
+We recommend creating new Active-Active databases using the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. This allows you to manage your Active-Active database with the operator and ensures you have the latest features and functionality.
+
+### Active-Active controller method
+
+Versions 6.4.2-6 or later fully support the Active-Active controller. 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.
+
+This setup method includes the following steps:
+
+1. Gather REC credentials and [prepare participating clusters]({{< relref "/operate/kubernetes/active-active/prepare-clusters" >}}).
+2. Create [`RedisEnterpriseRemoteCluster` (RERC)]({{< relref "/operate/kubernetes/active-active/create-reaadb#create-rerc" >}}) resources.
+3. Create [`RedisEnterpriseActiveActiveDatabase` (REAADB)]({{< relref "/operate/kubernetes/active-active/create-reaadb#create-reaadb" >}}) resource.
+
+### `crdb-cli` method
+
+For versions 6.4.2 or earlier, this Active-Active setup method includes the following steps:
+
+1. Install and configure an ingress.
+2. Gather configuration details.
+3. Add the `ActiveActive` field to the REC spec.
+4. Create the database with the `crdb-cli` tool.
+
+## Redis Enterprise Active-Active controller for Kubernetes
+
+{{<note>}}These features are supported for general availability in releases 6.4.2-6 and later.{{</note>}}
+
+[Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases give you read-and-write access to Redis Enterprise clusters (REC) in different Kubernetes clusters or namespaces. Active-Active deployments managed by the Redis Enterprise operator require two additional custom resources: Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC).
+
+To create an Active-Active Redis Enterprise deployment for Kubernetes with these new features, first [prepare participating clusters]({{< relref "/operate/kubernetes/active-active/prepare-clusters" >}}) then [create an Active-Active database]({{< relref "/operate/kubernetes/active-active/create-reaadb" >}}).
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+
+### REAADB custom resource
+
+Redis Enterprise Active-Active database (REAADB) contains a link to the RERC for each participating cluster, and provides configuration and status to the management plane.
+
+For a full list of fields and options, see the [REAADB API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_active_active_database_api">}}).
+
+### RERC custom resource
+
+Redis Enterprise remote cluster (RERC) custom resource contains configuration details for all the participating clusters.
+
+For a full list of fields and options, see the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}).
+
+### Limitations
+
+* Existing Redis databases cannot be migrated to a REAADB. (DOC-3594)
+* Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)
+    Workaround: Fix the problems with the REAADB and reapply.
+* The `<rec-name>/<rec-namespace>` value must be unique for each RERC resource. (RED-96302)
+* Only global database options are supported, no support for specifying configuration per location.
+* No support for migration from old (`crdb-cli`) Active-Active database method to new Active-Active controller.
+* No support for REAADB with participating clusters co-located within the same Kubernetes cluster, except for a single designated local participating cluster.
+
+## More info
+
+For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Describes where to view the archive of Redis Enterprise for Kubernetes
+  documentation.
+linkTitle: Archive
+weight: 99999999999
+---
+
+The Redis Enterprise for Kubernetes documentation is versioned. You are looking at the documentation for the latest release.
+
+- View the [7.8.6 docs](https://redis.io/docs/latest/operate/kubernetes/7.8.6/) for Redis Enterprise for Kubernetes version 7.8.6-1.
+- View the [7.8.4 docs](https://redis.io/docs/latest/operate/kubernetes/7.8.4/) for Redis Enterprise for Kubernetes versions 7.8.2-6, 7.8.4-8, and 7.8.4-9.
+- View the [7.4.6 docs](https://redis.io/docs/latest/operate/kubernetes/7.4.6/) for Redis Enterprise for Kubernetes versions 7.4.6-2 and 7.4.6-6.
+
+Older versions of Redis Enterprise for Kubernetes documentation are available on the archived web site:
+
+- [Redis Enterprise for Kubernetes v7.4 documentation archive](https://docs.redis.com/7.4/kubernetes/) 
+
+- [Redis Enterprise for Kubernetes v7.2 documentation archive](https://docs.redis.com/7.2/kubernetes/)  
+
+- [Redis Enterprise for Kubernetes v6.x documentation archive](https://docs.redis.com/6.4/kubernetes/)
+---
+Title: Manage Redis Enterprise cluster (REC) credentials
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: Manage REC credentials
+weight: 93
+---
+Redis Enterprise for Kubernetes uses a custom resource called [`RedisEnterpriseCluster`]({{< relref "/operate/kubernetes/reference/redis_enterprise_cluster_api" >}}) to create a Redis Enterprise cluster (REC). During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+{{<note>}}
+This procedure is only supported for operator versions 6.0.20-12 and above.
+{{</note>}}
+
+## Retrieve the current username and password
+
+The credentials can be used to access the Redis Enterprise admin console or the API. Connectivity must be configured to the REC [pods](https://kubernetes.io/docs/concepts/workloads/pods/) using an appropriate service (or port forwarding).
+
+1. Inspect the random username and password created by the operator during creation with the `kubectl get secret` command.
+
+    ```sh
+    kubectl get secret rec -o jsonpath='{.data}'
+    ```
+
+    The command outputs the encoded password and username, similar to the example below.
+
+      ```sh
+      map[password:MTIzNDU2NzgK username:ZGVtb0BleGFtcGxlLmNvbQo=]
+      ```
+
+1. Decode the password and username with the `echo` command and the password from the previous step.
+
+    ```bash
+    echo MTIzNDU2NzgK | base64 --decode
+    ```
+
+    This outputs the password and username in plain text. In this example, the plain text password is `12345678` and the username is `demo@example.com`.
+
+## Change the Redis Enterprise cluster (REC) credentials
+
+### Change the REC password for the current username
+
+1. Access a [pod](https://kubernetes.io/docs/concepts/workloads/pods/) running a Redis Enterprise cluster.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+2. Add a new password for the existing user.
+
+```bash
+REC_USER="`cat /opt/redislabs/credentials/username`" \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`" \
+curl -k --request POST \
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"$REC_PASSWORD\", \
+  \"new_password\":\"<NEW PASSWORD>\"}"
+```
+
+3. From outside the pod, update the REC credential secret.
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --save-config \
+  --dry-run=client \
+  --from-literal=username=<current-username> \
+  --from-literal=password=<new-password> \
+  -o yaml | \
+kubectl apply -f -
+```
+
+4. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+5. Access a pod running a Redis Enterprise cluster again.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+6. Remove the previous password to ensure only the new one applies.
+
+```sh
+REC_USER="`cat /opt/redislabs/credentials/username`"; \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`"; \
+curl -k --request DELETE \ 
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"<OLD PASSWORD\"}"
+```
+
+{{<note>}} The username for the K8s secret is the email displayed on the Redis Enterprise admin console. {{</note>}}
+
+### Change both the REC username and password
+
+1. [Connect to the admin console]({{< relref "/operate/kubernetes/re-clusters/connect-to-admin-console.md" >}})
+
+2. [Add another admin user]({{< relref "/operate/rs/security/access-control/create-users" >}}) and choose a new password.
+
+3. Specify the new username in the `username` field of your REC custom resource spec.
+
+4. Update the REC credential secret:
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --save-config \
+  --dry-run=client \
+  --from-literal=username=<new-username> \
+  --from-literal=password=<new-password> \
+  -o yaml | \
+kubectl apply -f -
+```
+
+5. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+6. Delete the previous admin user from the cluster.
+
+{{<note>}}
+The operator may log errors in the time between updating the username in the REC spec and the secret update.
+{{</note>}}
+
+### Update the credentials secret in Vault
+
+If you store your secrets with Hashicorp Vault, update the secret for the REC credentials with the following key-value pairs:
+
+```sh
+username:<desired_username>, password:<desired_password>
+```
+
+For more information about Vault integration with the Redis Enterprise Cluster see [Integrating Redis Enterprise for Kubernetes with Hashicorp Vault](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/vault/README.md).
+---
+Title: Enable internode encryption
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable encryption for communication between REC nodes in your K8s cluster.
+linkTitle: Internode encryption
+weight: 99
+---
+
+Internode encryption provides added security by encrypting communication between nodes in your Redis Enterprise cluster (REC).
+
+Enable internode encryption in the `spec` section of your REC custom resource file.
+
+```yaml
+spec:
+    dataInternodeEncryption: true
+```
+
+This change will apply to all databases created in the REC. You can override the cluster-wide setting for individual databases.
+
+Edit your Redis Enterprise database (REDB) custom resource file to disable internode encryption for only that database.
+
+```yaml
+spec: 
+    dataInternodeEncryption: false
+```
+
+To learn more about internode encryption, see [Internode encryption for Redis Enterprise Software]({{< relref "/operate/rs/security/encryption/internode-encryption.md" >}}).
+---
+Title: Manage Redis Enterprise cluster (REC) certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install your own certificates to be used by the Redis Enterprise cluster's
+  operator.
+linkTitle: Manage REC certificates
+weight: 94
+---
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes added to the cluster. For the list of of certificates used by Redis Enterprise Software and the traffic they encrypt, see the [certificates table]({{< relref "/operate/rs/security/certificates" >}}).
+
+To install and use your own certificates with Kubernetes on your Redis Enterprise cluster, they need to be stored in [secrets](https://kubernetes.io/docs/concepts/configuration/secret/). The REC custom resource also needs to be configured with those secret names to read and use the certificates.
+
+## Create a secret to hold the new certificate
+
+Create the [secret](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-kubectl/) with the required fields shown below.
+
+  ```sh
+  kubectl create secret generic <secret-name> \
+    --from-file=certificate=</PATH/TO/certificate.pem> \
+    --from-file=key=</PATH/TO/key.pem> \
+    --from-literal=name=<proxy | api | cm | syncer | metrics_exporter>
+  ```
+
+## Update certificates in the REC custom resource
+
+Edit the Redis Enterprise cluster (REC) custom resource to add a `certificates` subsection under the `spec` section. You are only required to add the fields for the certificates you are installing.
+
+```yaml
+spec:
+  certificates:
+    apiCertificateSecretName: <apicert-secret-name>
+    cmCertificateSecretName: <cmcert-secret-name>
+    syncerCertificateSecretName: <syncercert-secret-name>
+    metricsExporterCertificateSecretName: <metricscert-secret-name>
+    proxyCertificateSecretName: <proxycert-secret-name>
+```
+
+### Update certificates through the API
+
+Alternatively, you can also update the REC certificates via the API:
+
+```API
+PUT /v1/cluster/update_cert
+{
+   "certificate": <certificate>, 
+   "key": <cert-key>,
+   "name": <cert-name> 
+}
+```
+
+### Verify the certificate was updated
+
+Check the operator logs and use the API to verify the certificate has been updated.
+
+  ```api
+  GET /v1/cluster/certificates
+  ```
+
+## More info
+
+- [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates" >}})
+- [Install your own certificates]({{< relref "/operate/rs/security/certificates/create-certificates" >}})
+- [Glossary/Transport Layer Security (TLS)]({{< relref "/glossary#letter-t" >}})
+---
+Title: Enable LDAP authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable LDAP authentication for Redis Enterprise for Kubernetes.
+linkTitle: Enable LDAP
+weight: 95
+---
+
+## LDAP support for Redis Enterprise Software
+
+Redis Enterprise Software supports LDAP authentication and authorization through [role-based access controls]({{< relref "/operate/rs/security/access-control/" >}}) (RBAC). You can map LDAP groups to [Redis Enterprise roles]({{< relref "/operate/rs/security/access-control" >}}) to control access to your database and the Cluster Manager UI. For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+
+Redis Enterprise for Kubernetes supports enabling and configuring LDAP authentication using the `RedisEnterpriseCluster` (REC) custom resource. Currently, the Redis Enterprise cluster (REC) only supports configuration related to the LDAP server, such as server addresses, connection details, credentials, and query configuration.
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+## Enable LDAP 
+
+To enable LDAP for your REC, use the `.spec.ldap` field in the `RedisEnterpriseCluster` custom resource.
+
+The following `RedisEnterpriseCluster` example resource enables a basic LDAP configuration:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  ldap:
+    protocol: LDAP
+    servers:
+    - host: openldap.openldap.svc
+      port: 389
+    bindCredentialsSecretName: ldap-bind-credentials
+    cacheTTLSeconds: 600
+    enabledForControlPlane: true
+    enabledForDataPlane: true
+    authenticationQuery:
+      template: cn=%u,ou=default,dc=example,dc=org
+    authorizationQuery:
+      attribute: memberOf
+```
+
+Refer to the `RedisEnterpriseCluster` [API reference](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#ldapspec) for full details on the available fields.
+
+### Bind credentials
+
+For LDAP servers that require authentication for client queries, store the bind credentials in a secret and reference them in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to store the bind credentials.
+    
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <bind-secret-name> \
+        --from-literal=dn='<disinguished-name>' \
+        --from-literal=password=<password>
+    ```
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `dn` key with the distinguished name for the user performing the query (such as `cn=admin,dc=example,dc=org`).
+    - Include a `password` key with the bind password.
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.ldap.bindCredentialsSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        bindCredentialsSecretName: <bind-secret-name>
+    ```
+
+### LDAPS or STARTTLS protocols
+
+In addition to plain LDAP protocol, Redis Enterprise Software also supports LDAPS and STARTTLS protocols for secure communication with the LDAP server.
+
+To enable one of these protocols, edit the `spec.ldap.protocol` field in the `RedisEnterpriseCluster` custom resource:
+
+#### Enable `LDAPS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: LDAPS
+  ```
+
+  Default port: 636
+
+#### Enable `STARTTLS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: STARTTLS
+  ```
+
+  Default port: 389
+
+### CA certificate
+
+To use a custom CA certificate for validating the LDAP server certificate, store the CA certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the CA certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <ca-secret-name> \
+        --from-file=cert=<ca-cert>.pem
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `cert` key with a PEM-encoded CA certificate (such as `cacert.pem`).
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `spec.ldap.caCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        caCertificateSecretName: <ca-secret-name>
+    ```
+
+### Client certificates
+
+To use an LDAP client certificate, store the certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the client certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <client-secret-name> \
+      --from-literal=name=ldap_client \
+      --from-file=certificate=<client-cert-file> \
+      --from-file=key=<private-key-file>
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `name` key explicitly set to `ldap_client`.
+    - Include a `certificate` key for the public key (such as `cert.pem`).
+    - Include a `key` key for the private key (such as `key.pem`).
+    
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.certificates.ldapClientCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource, substituting your own values for `<placeholders>`.
+
+    ```yaml
+    spec:
+      certificates:
+        ldapClientCertificateSecretName: <client-secret-name>
+    ```
+
+## Known limitations
+
+Redis Enterprise Software can't resolve DNS names with a `.local` suffix.
+  If your LDAP server is in the same Kubernetes cluster and exposed via a Service object, *avoid* addresses such as `openldap.openldap.svc.cluster.local`. Instead, *use short-form addresses* such as `openldap.openldap.svc`.
+
+## Next steps
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+---
+categories:
+- docs
+- operate
+- kubernetes
+description: Add client certificates to your REDB custom resource.
+linkTitle: Add client certificates
+title: Add client certificates
+weight: 95
+---
+
+For each client certificate you want to use with your database, you need to create a Kubernetes secret to hold it. You can then reference that secret in your Redis Enterprise database (REDB) custom resource spec.
+
+## Create a secret to hold the new certificate
+
+1. [Create the secret config file](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-config-file/) with the required fields shown below.
+
+    ```yaml
+    apiVersion: v1
+    kind: Secret
+    type: Opaque
+    metadata:
+      name: <client-cert-secret>
+      namespace: <your-rec-namespace>
+    data:
+      cert: <client-certificate>
+    ```
+  
+1. Apply the file to create the secret resource.
+
+    ```bash
+    kubectl apply -f <client-cert-secret>.yaml
+    ```
+
+## Edit the REDB resource
+
+1. Add the secret name to the REDB custom resource (`redb.yaml`) with the `clientAuthenticationCertificates` property in the `spec` section.
+
+  ```yaml
+   spec:
+      clientAuthenticationCertificates:
+      - <client-cert-secret>
+  ```---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Security settings and configuration for Redis Enterprise for Kubernetes
+hideListLinks: false
+linkTitle: Security
+weight: 50
+---
+
+This section contains security settings and configuration for Redis Enterprise for Kubernetes.
+
+
+---
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable adding additional capabilities to the security context for the Redis Enterprise container by enabling `allowAutoAdjustment`.
+linkTitle: Enable privileged mode
+title: Enable privileged mode
+weight: 98
+---
+
+[Security settings for Kubernetes pods](https://kubernetes.io/docs/tasks/configure-pod-container/security-context/) are configured in the [`SecurityContext`](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#securitycontext-v1-core). The `allowPrivilegeEscalation` field controls if a container can gain more privileges than its parent process.
+
+If `allowPrivilegeEscalation` is set to `true` the container can have additional [Linux capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html) (such as `SYS_RESOURCE`) and is considered to be running in **privileged mode**.
+
+Redis Enterprise for Kubernetes 7.22.0-6 introduces the ability to run in **unprivileged mode**, where all capabilities are dropped from the Redis Enterprise container and `allowPrivilegeEscalation` is set to `false`. All other security-related settings remain the same as in privileged mode. Unprivileged mode is the default for installations and upgrades of the Redis Enterprise operator for versions 7.22.0-6 and later.
+
+## Default behavior
+
+**Unprivileged mode** is the default for installations and upgrades of the Redis Enterprise operator for versions 7.22.0-6 and later. This default behavior is in effect if REC spec has `allowAutoAdjustment` set to `false` or removed.
+
+The REC security context will look like this in unprivileged mode:
+
+```yaml
+securityContext:
+  allowPrivilegeEscalation: false
+  capabilities:
+    drop:
+    - ALL
+  privileged: false
+  readOnlyRootFilesystem: false
+```
+
+## Enable privileged mode
+
+To allow the Redis Enterprise container additional capabilities, you can enable **privileged mode**. Note that changing the following value on a running cluster will trigger a rolling update.
+
+To enable **privileged mode**, set `allowAutoAdjustment` to `true`.
+
+```yaml
+spec:
+  securityContext:
+    resourceLimits:
+      allowAutoAdjustment: true
+```
+
+Allowing automatic resource limit adjustment will result in the security context looking like this:
+
+```yaml
+securityContext:
+  allowPrivilegeEscalation: true
+  capabilities:
+    add:
+    - SYS_RESOURCE
+    drop:
+    - ALL
+  privileged: false
+  readOnlyRootFilesystem: false
+```
+
+OpenShift users upgrading to 7.22.0-6 need to make changes to your existing SCC (security context constraint).
+
+## OpenShift upgrades
+
+If running in **unprivileged mode**, remove the custom `redis-enterprise-scc-v2` SCC and unbind it from the REC service account after completing your upgrade.
+
+```sh
+oc delete scc/redis-enterprise-scc-v2
+```
+
+```sh
+oc adm policy remove-scc-from-user redis-enterprise-scc-v2 -z <service-account-name>
+```
+
+If running in **privileged mode**, manually reapply the [security context constraints (SCC)](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/deployment/openshift/openshift-cli#deploy-the-operator" >}})).
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+
+## New OpenShift installations
+
+New installations of Redis Enterprise for Kubernetes 7.22.0-6 and later automatically run in **unprivileged mode**, using a built-in `nonroot-v2` which is less permissive and more secure.
+
+To enable **privileged mode** after installation, apply and grant permissions to the `redis-enterprise-scc-v2` SCC.
+
+1. Apply the `scc.yaml` file.
+
+   {{<warning>}}
+Do not edit this file.
+    {{</warning>}}
+
+    ```sh
+    oc apply -f openshift/scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io "redis-enterprise-scc-v2" configured
+    ```
+
+1. Provide the operator permissions for the pods.
+
+    ```sh
+    oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+      system:serviceaccount:<my-project>:<rec>
+    ```
+
+## SYS_RESOURCE
+
+The `SYS_RESOURCE` capability may be required if processes in the container need to raise resource limits, such as the maximum number of open file descriptors.
+
+Some Redis Enterprise processes require the ability to open at least 100,000 file descriptors. If the default limit is lower and the container lacks the `SYS_RESOURCE` capability, the process may fail repeatedly, rendering the cluster unusable. To use unprivileged mode, configure your Kubernetes worker nodes to ensure a default file descriptor limit of at least 100,000.
+
+If you are already running a Redis Enterprise Cluster on Kubernetes, your worker nodes are likely configured correctly. In this case, it is safe to upgrade the operator and use unprivileged mode.
+
+Based on our testing, all major cloud providers configure Kubernetes worker nodes with file descriptor limits well above the required minimum. These setups are compatible with unprivileged mode. The only known exception is clusters created with [Kubespray](hhttps://kubespray.io/#/), which sets default file descriptor limits below the required 100,000. If you use Kubespray with default settings, you must run the operator in privileged mode.
+---
+Title: Upgrade Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  OperatorHub.
+linkTitle: OpenShift OperatorHub
+weight: 40
+url: '/operate/kubernetes/7.8.4/upgrade/upgrade-olm/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-redis-enterprise-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-olm/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 or later involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the Redis Enterprise operator
+
+1. Select the **Redis Enterprise Operator** from the **Operators**>**Installed Operators** page.
+
+2. Select the **Subscription** tab.
+
+3. Verify your **Update approval** is set to "Manual".
+
+4. To upgrade to the latest version, set your **Update Channel** to ‘production’. To upgrade to an older version, specify the desired version for your **Update Channel**.
+
+5. Select **Upgrade available** shown under **Upgrade status**.
+
+6. When the "Review manual InstallPlan" section appears, select **Preview installPlan** and then **Approve** after reviewing the details. This will start the operator upgrade.
+
+You can monitor the upgrade from the **Installed Operators** page. A new Redis Enterprise Operator will appear in the list, with the status "Installing". OpenShift will delete the old operator, showing the "Cannot update" status during deletion.
+
+## Reapply the SCC
+
+
+If you are using OpenShift, you must manually reappply the [security context constraints (SCC)](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.8.4/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+## Upgrade the Redis Enterprise Cluster 
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+## Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions for this operator version include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+---
+Title: Upgrade Redis Enterprise with OpenShift CLI 
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  CLI.
+linkTitle: OpenShift CLI
+weight: 20
+url: '/operate/kubernetes/7.8.4/upgrade/openshift-cli/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6 or later. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/openshift-cli/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator versions 7.8.2-6 and later  involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+#### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+For OpenShift environments, the name of the bundle is `openshift.bundle.yaml`, and so the `curl` command to run is:
+
+```sh
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/openshift.bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+If you are using OpenShift, run this instead:
+
+```sh
+oc apply -f openshift.bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+oc get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+ We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+ {{< /warning >}}
+
+### Reapply the SCC
+
+If you are using OpenShift, you will also need to manually reapply the [security context constraints](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.8.4/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+
+If you are upgrading from operator version 6.4.2-6 or before, see the ["after upgrading"](#after-upgrading) section to delete the old SCC and role binding after all clusters are running 6.4.2-6 or later.
+
+## Upgrade the Redis Enterprise Cluster 
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+
+---
+Title: Upgrade Redis Enterprise for Kubernetes 7.8.2-6
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via the
+  operator.
+linkTitle: Kubernetes
+weight: 10
+aliases: [
+  operate/kubernetes/re-clusters/upgrade-redis-cluster/,
+]
+url: '/operate/kubernetes/7.8.4/upgrade/upgrade-redis-cluster/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster-rec)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## Prerequisites
+
+The following steps ensure you have the minimum versions of all components necessary to upgrade to 7.8.2-6. **Without these minimum versions, the upgrade will freeze and require manual recovery.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported by 7.8.2-6. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster/) for detailed steps.
+
+### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}).
+
+### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatibile with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+You can download the bundle for the latest release with the following `curl` command:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+Upgrade the bundle and operator with a single command, passing in the bundle YAML file:
+
+```sh
+kubectl apply -f bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+kubectl get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+{{< /warning >}}
+
+## Upgrade the Redis Enterprise cluster (REC)
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the [Redis Enterprise for Kubernetes release notes]({{<relref "/operate/kubernetes/release-notes/7-8-2-releases">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Upgrade an REC with an Active-Active database
+
+We recommend upgrading all participating clusters to the same operator version.
+
+If you are upgrading from a preview version of the Active-Active controller, you can remove the following environment variables: `ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED`, `REMOTE_CLUSTER_CONTROLLER_ENABLED`, and `ENABLE_ALPHA_FEATURES`.
+
+### Edit `redisEnterpriseImageSpec` in the REC spec
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    kubectl edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `kubectl get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ kubectl get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+kubectl rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions for operator version 7.8.2-6 include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconsilliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+---
+Title: Upgrade Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Information about upgrading your Redis Enterprise cluster on Kubernetes.
+hideListLinks: true
+linkTitle: Upgrade
+weight: 15
+url: '/operate/kubernetes/7.8.4/upgrade/'
+---
+
+The upgrade process includes updating three components:
+
+  1. Upgrade the Redis Enterprise operator
+  2. Upgrade the Redis Enterprise cluster (REC)
+  3. Upgrade Redis Enterprise databases (REDB)
+
+If you are using OpenShift, see [Upgrade Redis Enterprise with OpenShift CLI]({{<relref "/operate/kubernetes/7.8.4/upgrade/openshift-cli">}}) or [Upgrade Redis Enterprise with OpenShift OperatorHub]({{<relref "/operate/kubernetes/7.8.4/upgrade/upgrade-olm">}}).
+
+For all other Kubernetes distributions, see [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/7.8.4/upgrade/upgrade-redis-cluster" >}}).
+
+## Upgrade compatibility
+
+When upgrading, both your Kubernetes version and Redis operator version need to be supported at all times.
+
+{{<warning>}}If your current Kubernetes distribution is not [supported]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions.md">}}), upgrade to a supported distribution before upgrading. {{</warning>}}
+
+## RHEL9-based image
+
+Redis Enterprise images are now based on Red Hat Enterprise Linux 9 (RHEL9). This means upgrades require:
+
+- [Cluster version of 7.4.2-2 or later](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/).
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+For detailed steps, see the relevant upgrade page:
+
+- [OpenShift CLI]({{<relref "/operate/kubernetes/7.8.4/upgrade/openshift-cli">}})
+- [OpenShift OperatorHub]({{<relref "/operate/kubernetes/7.8.4/upgrade/upgrade-olm">}})
+- [Kubernetes]({{<relref "/operate/kubernetes/7.8.4/upgrade/upgrade-redis-cluster" >}})
+---
+Title: Recover a Redis Enterprise cluster on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to recover a Redis Enterprise cluster on Kubernetes.
+linkTitle: Recover a Redis cluster
+weight: 20
+url: '/operate/kubernetes/7.8.4/re-clusters/cluster-recovery/'
+---
+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:
+
+1. Recreates a fresh Redis Enterprise cluster
+1. Mounts the persistent storage with the recovery files from the original cluster to the nodes of the new cluster
+1. Recovers the cluster configuration on the first node in the new cluster
+1. Joins the remaining nodes to the new cluster.
+
+{{<warning>}}Redis Enterprise for Kubernetes 7.2.4-2 introduces a new limitation. You cannot recover or upgrade your cluster if there are databases with old module versions or manually uploaded modules. See the [Redis Enterprise Software 7.2.4 known limitations]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}}) for more details.{{</warning>}}
+
+## Prerequisites
+
+- For cluster recovery, the cluster must be [deployed with persistence]({{< relref "/operate/kubernetes/7.8.4/recommendations/persistent-volumes.md" >}}).
+
+## Recover a cluster
+
+1. Edit the REC resource to set the `clusterRecovery` flag to `true`.
+
+    ```sh
+    kubectl patch rec <cluster-name> --type merge --patch '{"spec":{"clusterRecovery":true}}'
+    ```
+
+
+1. Wait for the cluster to recover until it is in the "Running" state.
+
+    To see the state of the cluster, run:
+
+    ```sh
+    watch "kubectl describe rec | grep State"
+    ```
+
+1. To recover the database, see [Recover a failed database]({{< relref "/operate/rs/databases/recover.md" >}}).
+---
+Title: Delete custom resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article explains how to delete Redis Enterprise clusters and Redis
+  Enterprise databases from your Kubernetes environment.
+linkTitle: Delete custom resources
+weight: 70
+aliases: [
+  /operate/kubernetes/delete-custom-resources/,
+]
+url: '/operate/kubernetes/7.8.4/re-clusters/delete-custom-resources/'
+---
+
+## Multi-namespace management
+
+Before you can delete a namespace, you must remove the Redis custom resources ([REDB](#delete-a-database-redb), [REC](#delete-a-redis-enterprise-cluster-rec), and [operator](#delete-operator-from-one-namespace)) residing within a namespace before you can delete that namespace. Deleting namespace containing an REDB may cause errors or data loss.
+
+## Delete a database (REDB)
+
+To delete a database managed by the Redis Enterprise Kubernetes operator, run `kubectl delete redb <your-db-name>` from your K8s cluster.
+
+When you delete a database, your data and the REDB custom resource are also deleted.
+
+## Delete a Redis Enterprise cluster (REC)
+
+To delete a Redis Enterprise cluster managed by the operator:
+
+1. Delete all the databases in your cluster.
+
+2. Run `kubectl delete rec <your-rec-name>` from your K8s cluster.
+
+When you delete your cluster, your databases and the REC custom resource are also deleted. However, persistent volume claims (PVCs) for your cluster are not deleted in the process. If you want to delete your PVCs, you'll have to delete them manually.
+
+## Delete the operator
+
+There are two ways to delete the operator. You can delete the entire operator bundle, but this will also delete any cluster-wide resources created by the operator. To only delete resources within a specific namespace and leave other cluster-wide resources intact, you need to delete each resource manually.
+
+Whether you decide to delete the entire bundle or just resources from a specific namespace, it's important to delete the operator ConfigMap (`operator-environment-config`).
+
+```sh
+kubectl delete cm operator-environment-config
+```
+
+### Delete operator bundle
+
+To delete the operator from your K8s cluster, you can delete the operator bundle with:
+
+- `kubectl delete -f bundle.yaml` for non-OpenShift K8s deployments
+- `kubectl delete -f openshift.bundle.yaml` for OpenShift deployments 
+
+This will remove the operator and its custom resource definitions (CRDs) from your K8s cluster.
+
+{{< warning >}} The Redis Enterprise CRDs are non-namespaced resources, meaning they are shared across your entire K8s cluster. Deleting CRDs in one namespace will delete custom resources in every other namespace across the K8s cluster.{{</warning>}}
+
+### Delete operator from one namespace
+
+If you have Redis Enterprise clusters running in different namespaces on the same K8s cluster, deleting the entire operator bundle might cause data loss.
+
+To safely delete the operator from one namespace without affecting the others, delete the operator files individually, excluding the CRD files:
+
+```sh
+kubectl delete -f role.yaml
+kubectl delete -f role_binding.yaml
+kubectl delete -f service_account.yaml
+kubectl delete -f admission-service.yaml
+kubectl delete -f operator.yaml
+```
+
+You will also need to remove [the `namespaceSelector` section from the validating webhook]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start#webhook" >}}).
+
+## Delete an Active-Active database (REAADB)
+
+1. On one of the existing participating clusters, delete the REEADB (substituting `<reaadb-name>` with your database name).
+
+  ```sh
+  kubectl delete reaadb <reaadb-name>
+  ```
+
+2. Verify the REAADB no longer exists. 
+
+  ```sh
+  kubectl get reaadb -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Delete a remote cluster (RERC)
+
+1. Verify the RERC you want to delete isn't listed as a participating cluster in any REAADB resources.
+
+    If an RERC is still listed as a participating cluster in any database, the deletion will be blocked.
+
+2. On one of the existing participating clusters, delete the RERC (substituting `<rerc-name>` with your database name).
+
+  ```sh
+  kubectl delete rerc <rerc-name>
+  ```
+
+3. Verify the RERC no longer exists.
+
+  ```sh
+  kubectl get rerc -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Troubleshoot REDB deletion
+
+The operator attaches a finalizer to the Redis Enterprise database (REDB) object. This makes sure the database is deleted before the REDB custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REDB resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REDB has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch redb <your-db-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"finalizer.redisenterprisedatabases.app.redislabs.com"}]'
+```
+
+## Troubleshoot REC deletion
+
+The operator attaches a finalizer to the Redis Enterprise cluster (REC) object. This makes sure the Redis cluster is deleted before the REC custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REC resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REC has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch rec <your-rec-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"redbfinalizer.redisenterpriseclusters.app.redislabs.com"}]'
+```
+---
+Title: Connect to the admin console
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Connect to the Redis Enterprise admin console to manage your Redis Enterprise
+  cluster.
+linkTitle: Connect to the admin console
+weight: 10
+url: '/operate/kubernetes/7.8.4/re-clusters/connect-to-admin-console/'
+---
+
+The username and password for the Redis Enterprise Software [admin console]({{< relref "/operate/rs/" >}}) are stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/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. 
+{{</note>}}
+
+1. Switch to the namespace with your Redis Enterprise cluster (REC).
+
+    ```sh
+    kubectl config set-context --current --namespace=<namespace-of-rec>
+    ```
+
+1. Find your cluster name from your list of secrets.
+
+    ```sh
+    kubectl get secret
+    ```
+
+    In this example, the cluster name is `rec`.
+
+1. Extract and decode your credentials from the secret.
+
+    ```sh
+    kubectl get secret <cluster-name> -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <cluster-name> -o jsonpath='{.data.password}' | base64 --decode
+    ```
+
+1. Find the port for the REC UI service in the `spec:ports` section of the service definition file.
+
+    ```sh
+    kubectl get service/<cluster-name>-ui -o yaml
+    ```
+
+    {{<note>}}
+    The default port is 8443.
+    {{</note>}}
+
+1. Use `kubectl port-forward` to forward your local port to the service port.
+
+    ```sh
+    kubectl port-forward service/<cluster-name>-ui <local-port>:<service-port>
+   ```
+
+1. View the admin console from a web browser on your local machine at `https://localhost:8443`.
+
+---
+Title: Expand PersistentVolumeClaim (PVC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Expand your persistent volume claim by editing the REC.
+linkTitle: Expand PVC
+weight: 82
+url: '/operate/kubernetes/7.8.4/re-clusters/expand-pvc/'
+---
+
+This article outlines steps to increase the size of the persistent volume claim for your Redis Enterprise cluster (REC).
+
+{{<note>}} This feature is only supported in versions 7.4.2-12 and above. {{</note>}}
+
+[PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) are created by the Redis Enterprise operator and used by the RedisEnterpriseCluster (REC). PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) with the following steps, if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+This process involves deleting and recreating the REC StatefulSet with a larger persistent volume size. The pods owned by the StatefulSet are not restarted or affected by the deletion and recreation process, except when they are left without an owner momentarily.
+
+{{<note>}}Shrinking (reducing the size) of your PVC is not allowed. This process only allows you to expand (size up) your PVC.{{</note>}}
+
+## Prerequisites
+
+{{<warning>}}Do not change any other REC fields related to the StatefulSet while resizing is in progress.
+{{</warning>}}
+
+- PVC expansion must be supported and enabled by the StorageClass and underlying storage driver of the REC PVCs.
+  - The relevant StorageClass is the one associated with the REC PVCs. The StorageClass for existing PVCs cannot be changed.
+- The StorageClass must be configured with `allowVolumeExpansion: true`.
+- Your storage driver must support online expansion.
+- We highly recommend you backup your databases before beginning this PVC expansion process.
+
+{{<warning>}} OpenShift users should be aware that (`ClusterResourceQuota`) can limit the PVC expansion. Check your quota before resizing using `oc describe clusterresourcequota <quota-name>`.{{</warning>}}
+
+## Expand REC PVC
+
+1. Enable the REC persistent volume resize flag.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+    ```
+
+1. Set the value of `volumeSize` to your desired size.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+          volumeSize: <new-size>Gi
+    ```
+
+1. Apply the changes to the REC, replacing `<your-rec.yaml>` with the name of your REC.
+
+  ```sh
+  kubectl apply -f <your-rec.yaml>
+  ```
+
+After applying the REC changes, the PVCs will begin to expand to the new size.
+
+Once all the PVCs finish the resizing process, the operator will delete and recreate the StatefulSet with the new volume size.
+
+### Track progress
+
+You can track the progress by monitoring the status of the REC and PersistentVolumeClaim objects.
+
+The REC status will correspond to the status of one or more PVCs, and will reflect if the resizing is successful or failed.
+
+While the resizing is in progress, the status will be:
+
+```yaml
+status:
+  persistenceStatus:
+    status: Resizing
+    succeeded: 2/3
+```
+
+When the resizing is complete, the status becomes Provisioned and the new volume size is available for use by the REC pods.
+
+```yaml
+status:
+  persistenceStatus:
+    status: Provisioned
+    succeeded: 3/3
+```
+
+### Troubleshooting
+
+If an error occurs during this process:
+
+- Examine the status and events of the REC and PVC objects.
+
+  ```sh
+  kubectl describe pvc
+  ```
+
+  ```sh
+  kubectl get events
+  ```
+
+- Examine the logs of the operator pods.
+
+  ```sh
+  kubectl logs <operator_pod_name>
+  ```
+---
+Title: Connect the Prometheus operator to Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article describes how to configure a Prometheus operator custom
+  resource to allow it to export metrics from Redis Enterprise for Kubernetes.
+linkTitle: Export metrics to Prometheus
+weight: 92
+url: '/operate/kubernetes/7.8.4/re-clusters/connect-prometheus-operator/'
+---
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can connect your [Prometheus](https://prometheus.io/) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+
+## Prerequisites
+
+Before connecting Redis Enterprise to Prometheus on your Kubernetes cluster, make sure you've done the following:
+
+- [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md" >}}) (version 6.2.10-4 or newer)
+- [Deploy the Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md) (version 0.19.0 or newer)
+- [Create a Redis Enterprise cluster]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}})
+
+## Create a `ServiceMonitor` custom resource
+
+Below is an example `ServiceMonitor` custom resource file. By specifying the service label (`app: redis.io/service=prom-metrics`) in the `selector.matchLabels` section, you can point the Prometheus operator to the correct Redis Enterprise service (`<rec_name>-prom`).
+
+You'll need to configure the following fields to connect Prometheus to Redis Enterprise:
+
+| Section | Field | Value |
+|---|---|---|
+| `spec.endpoints` | `port` | Name of exposed port (`prometheus`) |
+| `spec.namespaceSelector` | `matchNames` | Namespace for your REC |
+| `spec.selector` | `matchLabels` | REC service label (`app: redis.io/service=prom-metrics`) |
+
+Apply the file in the same namespace as your Redis Enterprise cluster (REC).
+    {{<note>}}If Redis Enterprise and Prometheus are deployed in different namespaces, you'll also need to add the [`serviceMonitorNamespaceSelector`](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api.md#namespaceselector) field to your Prometheus resource. See the [Prometheus operator documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources) for more details on cross-namespace `ServiceMonitor` configuration.{{</note>}}
+
+
+```YAML
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: redis-enterprise
+spec:
+  endpoints:
+  - interval: 15s
+    port: prometheus
+    scheme: https
+    tlsConfig:
+      insecureSkipVerify: true
+  namespaceSelector:
+    matchNames:
+    - <your_REC_namespace>
+  selector:
+    matchLabels:
+      redis.io/service: prom-metrics
+```
+
+For more info about configuring the `ServiceMonitor` resource, see the [`ServiceMonitorSpec` API documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api-reference/api.md#monitoring.coreos.com/v1.ServiceMonitorSpec).
+
+## More info
+
+- github.com/prometheus-operator
+  - [Getting started](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md)
+  - [Running exporters](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/running-exporters.md)
+  - [Related resources](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources)
+  - [Troubleshooting ServiceMonitor changes](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/troubleshooting.md)
+- redis.io/docs
+  - [Metrics in Prometheus]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}})
+  - [Monitoring and metrics]({{< relref "/operate/rs/monitoring/" >}})
+---
+Title: Manage databases in multiple namespaces
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces
+  within your Kubernetes cluster. This article shows you how to configure your Redis
+  Enterprise cluster to connect to databases in multiple namespaces
+linktitle: Manage multiple namespaces
+weight: 17
+url: '/operate/kubernetes/7.8.4/re-clusters/multi-namespace/'
+---
+
+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]({{< relref "/operate/kubernetes/7.8.4/architecture/deployment-options.md" >}}).
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REAADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Prerequisites
+
+Before configuring a multi-namespace deployment, you must have a running [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md" >}}). See more information in the [deployment]({{< relref "/operate/kubernetes/7.8.4/deployment/" >}}) section.
+
+## Create role and role binding for managed namespaces
+
+Both the operator and the RedisEnterpriseCluster (REC) resource need access to each namespace the REC will manage. For each **managed** namespace, create a `role.yaml` and `role_binding.yaml` file within the managed namespace, as shown in the examples below.
+
+{{<note>}}These will need to be reapplied each time you [upgrade]({{< relref "/operate/kubernetes/7.8.4/upgrade/upgrade-redis-cluster.md" >}}). {{</note>}}
+
+Replace `<rec-namespace>` with the namespace the REC resides in.
+Replace `<service-account-name>` with your own value (defaults to the REC name).
+
+`role.yaml` example: 
+
+```yaml
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups:
+      - app.redislabs.com
+    resources: ["redisenterpriseclusters", "redisenterpriseclusters/status", "redisenterpriseclusters/finalizers",
+                "redisenterprisedatabases", "redisenterprisedatabases/status", "redisenterprisedatabases/finalizers",
+                "redisenterpriseremoteclusters", "redisenterpriseremoteclusters/status",
+                "redisenterpriseremoteclusters/finalizers",
+                "redisenterpriseactiveactivedatabases", "redisenterpriseactiveactivedatabases/status",
+                "redisenterpriseactiveactivedatabases/finalizers"]
+    verbs: ["delete", "deletecollection", "get", "list", "patch", "create", "update", "watch"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["update", "get", "read", "list", "listallnamespaces", "watch", "watchlist",
+            "watchlistallnamespaces", "create","patch","replace","delete","deletecollection"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create"]
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["get", "watch", "list", "update", "patch", "create", "delete"]
+```
+
+`role_binding.yaml` example:
+
+```yaml
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: <rec-namespace>
+- kind: ServiceAccount
+  name: <service-account-name>
+  namespace: <rec-namespace>
+roleRef:
+  kind: Role
+  name: redb-role
+  apiGroup: rbac.authorization.k8s.io
+```
+
+Apply the files, replacing `<managed-namespace>` with your own values:
+
+```sh
+kubectl apply -f role.yaml -n <managed-namespace>
+kubectl apply -f role_binding.yaml -n <managed-namespace>
+```
+
+{{<note>}}
+If the REC is configured to watch a namespace without setting the role and role binding permissions, or a namespace that is not yet created, the operator will fail and halt normal operations.
+{{</note>}}
+
+
+## Update Redis Enterprise operator ConfigMap
+
+There are two methods of updating the operator ConfigMap (`operator-environment-config`) to specify which namespaces to manage.
+
+- Method 1: Configure the operator to watch for a namespace label and add this label to managed namespaces (available in versions 6.4.2-4 or later).
+- Method 2: Configure the operator with an explicit list of namespaces to manage.
+
+You can create this ConfigMap manually before deployment, or it will be created automatically after the operator was deployed.
+
+
+### Method 1: Namespace label (available in versions 6.4.2-4 or later)
+
+1. Create the `cluster_role_binding.yaml` and `cluster_role.yaml` files. Replace the `<rec-namespace>` with the namespace the Redis Enterprise cluster (REC) resides in.
+
+  `operator_cluster_role.yaml` example:
+
+  ```yaml
+    apiVersion: rbac.authorization.k8s.io/v1
+    kind: ClusterRole
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    rules:
+      - apiGroups: [""]
+        resources: ["namespaces"]
+        verbs: ["list", "watch"]
+  ```
+
+  `operator_cluster_role_binding.yaml` example:
+
+  ```yaml
+    kind: ClusterRoleBinding
+    apiVersion: rbac.authorization.k8s.io/v1
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    subjects:
+    - kind: ServiceAccount
+      name: redis-enterprise-operator
+      namespace: <rec-namespace>
+    roleRef:
+      kind: ClusterRole
+      name: redis-enterprise-operator-consumer-ns
+      apiGroup: rbac.authorization.k8s.io
+  ```
+
+2. Apply the files.
+
+  ```sh
+  kubectl apply -f operator_cluster_role.yaml
+  kubectl apply -f operator_cluster_role_binding.yaml 
+  ```
+
+3. Patch the ConfigMap in the REC namespace (`<rec-namespace>`) to identify the managed namespaces with your label (`<label-name>`).
+
+  ```sh
+   kubectl patch ConfigMap/operator-environment-config \
+  -n <rec-namespace> \
+  --type merge \
+  -p '{"data": {"REDB_NAMESPACES_LABEL": "<label-name>"}}'
+  ```
+
+4. For each managed namespace, apply the same label. Replace `<managed-namespace>` with the namespace the REC will manage. Replace `<label-name>` with the value used in the previous step. If you specify a value for `<label-value>`, both the label name and value in managed namespaces must match to be detected by the operator. If the `<label-value>` is empty, only the label name needs to match on managed namespaces and the value is disregarded.
+
+
+  ```sh
+  kubectl label namespace <managed-namespace> <label-name>=<label-value>
+  ```
+
+{{<note>}}
+The operator restarts when it detects a namespace label was added or removed.
+{{</note>}}
+
+### Method 2: Explicit namespace list
+
+Patch the `operator-environment-config` in the REC namespace with a new environment variable (`REDB_NAMESPACES`).
+
+```sh
+kubectl patch ConfigMap/operator-environment-config \ 
+-n <rec-namespace> \
+--type merge \
+-p '{"data":{"REDB_NAMESPACES": "<comma,separated,list,of,namespaces,to,watch"}}'
+```
+
+{{<warning>}}
+Only configure the operator to watch a namespace after the namespace is created and configured with the role/role_binding as explained above. If configured to watch a namespace without setting those permissions or a namespace that is not created yet, the operator will fail and not perform normal operations.
+{{</warning>}}
+---
+Title: Redis Enterprise clusters (REC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise clusters (REC).
+hideListLinks: false
+linkTitle: Redis Enterprise clusters (REC)
+weight: 30
+url: '/operate/kubernetes/7.8.4/re-clusters/'
+---
+
+This section contains articles to help you manage your Redis Enterprise clusters (REC).
+
+
+
+---
+Title: Use Auto Tiering on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Deploy a cluster with Auto Tiering on Kubernetes.
+linkTitle: Auto Tiering
+weight: 16
+url: '/operate/kubernetes/7.8.4/re-clusters/auto-tiering/'
+---
+
+## Prerequisites
+
+Redis Enterprise Software for Kubernetes supports using Auto Tiering (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+{{<note>}}
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+{{</note>}}
+
+Before creating your Redis clusters or databases, these SSDs must be:
+
+- [locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+- formatted and mounted on the nodes that will run Redis Enterprise pods
+- dedicated to Auto Tiering and not shared with other parts of the database, (e.g. durability, binaries)
+- [provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+  - You can use a [local volume provisioner](https://github.com/kubernetes-sigs/sig-storage-local-static-provisioner/blob/master/README.md) to do this [dynamically](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#dynamic)
+- a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource with a unique name
+
+For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+## Create a Redis Enterprise cluster
+
+To deploy a Redis Enterprise cluster (REC) with Auto Tiering, you'll need to specify the following in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api" >}}):
+
+- enable Auto Tiering (`enabled: true`)
+- flash storage driver (`bigStoreDriver`)
+  - `rocksdb` or `speedb`(default)
+- storage class name (`storageClassName`)
+- minimal flash disk size (`flashDiskSize`)
+
+{{<note>}} Clusters upgraded to version 7.2.4-2 from an earlier version will change the `bigStoreDriver` (previously called `flashStorageEngine`) to the new default `speedb`, regardless of previous configuration. {{</note>}}
+
+{{<warning>}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+Here is an example of an REC custom resource with these attributes:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: "rec"
+spec:
+  
+  nodes: 3
+  redisOnFlashSpec:
+    enabled: true
+    bigStoreDriver: speedb
+    storageClassName: local-scsi
+    flashDiskSize: 100G
+```
+
+### Create a Redis Enterprise database
+
+By default, any new database will use RAM only. To create a Redis Enterprise database (REDB) that can use flash storage, specify the following in the `redisEnterpriseCluster` section of the REDB custom resource definition:
+
+- `isRof: true` enables Auto Tiering
+- `rofRamSize` defines the RAM capacity for the database
+
+Below is an example REDB custom resource:
+
+```YAML
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: autoteiring-redb
+spec:
+  redisEnterpriseCluster:
+    name: rec
+  isRof: true
+  memorySize: 2GB
+  rofRamSize: 0.5GB
+```
+
+{{< note >}}
+This example defines both `memorySize` and `rofRamSize`. When using Auto Tiering, `memorySize` refers to the total combined memory size (RAM + flash) allocated for the database. `rofRamSize` specifies only the RAM capacity for the database. `rofRamSize` must be at least 10% of `memorySize`.
+{{< /note >}}
+---
+Title: Create Active-Active databases with crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section shows how to set up an Active-Active Redis Enterprise database
+  on Kubernetes using the Redis Enterprise Software operator.
+linkTitle: Create Active-Active with crdb-cli
+weight: 99
+url: '/operate/kubernetes/7.8.4/active-active/create-aa-crdb-cli/'
+---
+{{<note>}} Versions 6.4.2 and later support the Active-Active database controller. This controller allows you to create Redis Enterprise Active-Active databases (REAADB) and Redis Enterprise remote clusters (RERC) with custom resources. We recommend using the [REAADB method for creating Active-Active databases]({{< relref "/operate/kubernetes/7.8.4/active-active/create-reaadb.md" >}}).{{</note>}}
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read-and-write access to the same dataset from different Kubernetes clusters. For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/7.8.4/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.
+
+This process consists of:
+
+1. Documenting values to be used in later steps. It's important these values are correct and consistent.
+1. Editing the Redis Enterprise cluster (REC) spec file to include the `ActiveActive` section. This will be slightly different depending on the K8s distribution you are using.
+1. Creating the database with the `crdb-cli` command. These values must match up with values in the REC resource spec.
+
+## Prerequisites
+
+Before creating Active-Active databases, you'll need admin access to two or more working Kubernetes clusters that each have:
+
+- Routing for external access with an [ingress resources]({{< relref "/operate/kubernetes/7.8.4/networking/ingress.md" >}}) (or [route resources]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}) on OpenShift).
+- A working [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api" >}}) with a unique name.
+- Enough memory resources available for the database (see [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})).
+
+{{<note>}} The `activeActive` field and the `ingressOrRouteSpec` field cannot coexist in the same REC. If you configured your ingress via the `ingressOrRouteSpec` field in the REC, create your Active-Active database with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource.{{</note>}}
+
+## Document required parameters
+
+The most common mistake when setting up Active-Active databases is incorrect or inconsistent parameter values. The values listed in the resource file must match those used in the crdb-cli command.
+
+- **Database name** `<db-name>`:
+  - Description: Combined with ingress suffix to create the Active-Active database hostname
+  - Format: string
+  - Example value: `myaadb`
+  - How you get it: you choose
+  - The database name requirements are:
+       - Maximum of 63 characters
+       - Only letter, number, or hyphen (-) characters
+       - Starts with a letter; ends with a letter or digit.
+       - Database name is not case-sensitive
+
+You'll need the following information for each participating Redis Enterprise cluster (REC):
+
+{{<note>}}
+You'll need to create DNS aliases to resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address for the ingress controller’s LoadBalancer (or routes in Openshift) for each database. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as *.ijk.example.com).
+{{</note>}}
+
+- **REC hostname** `<rec-hostname>`:
+  - Description: Hostname used to identify your Redis Enterprise cluster in the `crdb-cli` command. This MUST be different from other participating clusters.
+  - Format: `<rec-name>.<namespace>.svc.cluster.local`
+  - Example value: `rec01.ns01.svc.cluster.local`
+  - How to get it: List all your Redis Enterprise clusters
+      ```bash
+      kubectl get rec
+      ```
+- **API hostname** `<api-hostname>`:
+  - Description: Hostname used to access the Redis Enterprise cluster API from outside the K8s cluster
+  - Format: string
+  - Example value: `api.ijk.example.com`
+- **Ingress suffix** `<ingress-suffix>`:
+  - Description: Combined with database name to create the Active-Active database hostname
+  - Format: string
+  - Example value: `-cluster.ijk.example.com`
+- [**REC admin credentials**]({{< relref "/operate/kubernetes/7.8.4/security/manage-rec-credentials.md" >}}) `<username> <password>`:
+  - Description: Admin username and password for the REC stored in a secret
+  - Format: string
+  - Example value: username: `user@example.com`, password: `something`
+  - How to get them:
+    ```sh
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.password}' | base64 --decode
+    ```
+- **Replication hostname** `<replication-hostname>`:
+  - Description: Hostname used inside the ingress for the database
+  - Format: `<db-name><ingress-suffix>`
+  - Example value: `myaadb-cluster.ijk.example.com`
+  - How to get it: Combine `<db-name>` and `<ingress-suffix`> values you documented above.
+- **Replication endpoint** `<replication-endpoint>`:
+  - Description: Endpoint used externally to contact the database
+  - Format: `<db-name><ingress-suffix>:443`
+  - Example value: `myaadb-cluster.ijk.example.com:443`
+  - How to get it:`<replication-hostname>:443`
+
+## Add `activeActive` section to the REC resource file
+
+From inside your K8s cluster, edit your Redis Enterprise cluster (REC) resource to add the following to the `spec` section. Do this for each participating cluster.
+
+ The operator uses the API hostname (`<api-hostname>`) to create an ingress to the Redis Enterprise cluster's API; this only happens once per cluster. Every time a new Active-Active database instance is created on this cluster, the operator creates a new ingress route to the database with the ingress suffix (`<ingress-suffix>`). The hostname for each new database will be in the format <nobr>`<db-name><ingress-suffix>`</nobr>.
+
+### Using ingress controller
+
+1. If your cluster uses an [ingress controller]({{< relref "/operate/kubernetes/7.8.4/networking/ingress.md" >}}), add the following to the `spec` section of your REC resource file.
+
+  Nginx:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+       kubernetes.io/ingress.class: nginx
+      nginx.ingress.kubernetes.io/backend-protocol: HTTPS
+      nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+HAproxy:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+      kubernetes.io/ingress.class: haproxy
+       ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+2. After the changes are saved and applied, you can verify a new ingress was created for the API.
+
+    ```sh
+    $ kubectl get ingress
+    NAME   HOSTS                            ADDRESS                                 PORTS   AGE
+    rec01  api.abc.cde.example.com  225161f845b278-111450635.us.cloud.com   80      24h
+    ```
+
+3. Verify you can access the API from outside the K8s cluster.
+
+    ```sh
+   curl -k -L -i -u <username>:<password> https://<api-hostname>/v1/cluster
+    ```
+
+    If the API call fails, create a DNS alias that resolves your API hostname (`<api-hostname>`) to the IP address for the ingress controller's LoadBalancer.
+
+4. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address of the ingress controller’s LoadBalancer. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+#### If using Istio Gateway and VirtualService
+
+No changes are required to the REC spec if you are using [Istio]({{< relref "/operate/kubernetes/7.8.4/networking/istio-ingress.md" >}}) in place of an ingress controller. The `activeActive` section added above creates ingress resources. The two custom resources used to configure Istio (Gateway and VirtualService) replace the need for ingress resources.
+
+{{<warning>}}
+These custom resources are not controlled by the operator and will need to be configured and maintained manually.
+{{</warning>}}
+
+For each cluster, verify the VirtualService resource has two `- match:` blocks in the `tls` section. The hostname under `sniHosts:` should match your `<replication-hostname>`.
+
+### Using OpenShift routes
+
+1. Make sure your Redis Enterprise cluster (REC) has a different name (`<rec-name.namespace>`) than any other participating clusters. If not, you'll need to manually rename the REC or move it to a different namespace.
+            You can check your new REC name with:
+    ```sh
+    oc get rec -o jsonpath='{.items[0].metadata.name}'
+    ```
+
+    If the rec name was modified, reapply [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml) to the namespace to reestablish security privileges.
+    
+    ```sh
+    oc apply -f scc.yaml
+    oc adm policy add-scc-to-group redis-enterprise-scc-v2  system:serviceaccounts:<namespace>
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the route IP address. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. If your cluster uses [OpenShift routes]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}), add the following to the `spec` section of your Redis Enterprise cluster (REC) resource file.
+
+      ```sh
+      activeActive:
+        apiIngressUrl: <api-hostname>
+        dbIngressSuffix: <ingress-suffix>
+        method: openShiftRoute
+      ```
+
+1. Make sure you have DNS aliases that resolve to the routes IP for both the API hostname (`<api-hostname>`) and the replication hostname (`<replication-hostname>`) for each database. To avoid entering each database individually, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. After the changes are saved and applied, you can see that a new route was created for the API.
+
+    ```sh
+    $ oc get route
+    NAME    HOST/PORT                       PATH    SERVICES  PORT  TERMINATION   WILDCARD
+    rec01   api-openshift.apps.abc.example.com rec01   api             passthrough   None
+    ```
+
+## Create an Active-Active database with `crdb-cli`
+
+The `crdb-cli` command can be run from any Redis Enterprise pod hosted on any participating K8s cluster. You'll need the values for the [required parameters]({{< relref "/operate/kubernetes/7.8.4/active-active/create-aa-crdb-cli#document-required-parameters" >}}) for each Redis Enterprise cluster.
+
+```sh
+crdb-cli crdb create \
+  --name <db-name> \
+  --memory-size <mem-size> \
+  --encryption yes \
+  --instance fqdn=<rec-hostname-01>,url=https://<api-hostname-01>,username=<username-01>,password=<password-01>,replication_endpoint=<replication-endpoint-01>,replication_tls_sni=<replication-hostname-01> \
+  --instance fqdn=<rec-hostname-02>,url=https://<api-hostname-02>,username=<username-02>,password=<password-02>,replication_endpoint=<replication-endpoint-02>,replication_tls_sni=<replication-hostname-02>
+```
+
+To create a database that syncs between more than two instances, add additional `--instance` arguments.
+
+See the [`crdb-cli` reference]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for more options.
+
+## Test your database
+
+The easiest way to test your Active-Active database is to set a key-value pair in one database and retrieve it from the other.
+
+You can connect to your databases with the instructions in [Manage databases]({{< relref "/operate/kubernetes/7.8.4/re-databases/db-controller#connect-to-a-database" >}}). Set a test key with `SET foo bar` in the first database. If your Active-Active deployment is working properly, when connected to your second database, `GET foo` should output `bar`.
+---
+Title: Set global database secret
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' to set the
+  global database secret.
+linkTitle: Global database secret
+weight: 50
+url: '/operate/kubernetes/7.8.4/active-active/global-db-secret/'
+---
+{{<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.{{</note>}}
+
+## 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.
+
+To edit other global configruations, see [global configuration]({{< relref "/operate/kubernetes/7.8.4/active-active/global-config.md" >}})
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the database password.
+
+  This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+  ```yaml
+  apiVersion: v1
+  data:
+    password: bXktcGFzcw
+  kind: Secret
+  metadata:
+    name: my-db-secret
+  type: Opaque
+  ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    example-aadb-1   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit Redis Enterprise remote clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Edit the configuration details of an existing RERC with Redis Enterprise
+  for Kubernetes.
+linkTitle: Edit RERC
+weight: 60
+url: '/operate/kubernetes/7.8.4/active-active/edit-rerc/'
+---
+{{<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.{{</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.
+
+The RERC controller periodically connects to the local REC endpoint via its external address, to ensure it’s setup correctly. For this to work, the external load balancer must support [NAT hairpinning](https://en.wikipedia.org/wiki/Network_address_translation#NAT_loopback). In some cloud environments, this may involve disabling IP preservation for the load balancer target groups.
+
+For more details, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}).
+
+## Edit RERC
+
+Use the `kubectl patch rerc <rerc-name> --type merge --patch` command to patch the local RERC custom resource with your changes. For a full list of available fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}).
+
+The following example edits the `dbFqdnSuffix` field for the RERC named `rerc-ohare`.
+
+```sh
+kubectl patch rerc rerc-ohare --type merge --patch \
+'{"spec":{"dbFqdnSuffix": "-example2-cluster-rec-chicago-ns-illinois.example.com"}}'
+```
+
+## Update RERC secret
+
+If the credentials are changed or updated for a REC participating cluster, you need to manually edit the RERC secret and apply it to all participating clusters.
+
+1. On the local cluster, update the secret with new credentials and name it with the following convention:  `redis-enterprise-<rerc-name>`.
+
+    A secret for a remote cluster named `rerc-ohare` would be similar to the following:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: PHNvbWUgcGFzc3dvcmQ+
+      username: PHNvbWUgdXNlcj4
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+    ```
+
+1. Apply the file.
+
+    ```sh
+    kubectl apply -f <secret-file>
+    ```
+
+1. Watch the RERC to verify the status is "Active" and the spec status is "Valid."
+
+      ```sh
+      kubectl get rerc <rerc-name>
+      ```
+
+    The output should look like this:
+  
+      ```sh
+       NAME        STATUS   SPEC STATUS   LOCAL
+        rerc-ohare   Active   Valid         true
+      ```
+      
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.8.4/logs/" >}}).
+
+1. Verify the status of each REAADB using that RERC is "Active" and the spec status is "Valid."
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up
+    ```
+
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.8.4/logs/" >}}).
+
+1. Repeat the above steps on all other participating clusters.
+---
+Title: Prepare participating clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Prepare your participating RECs to be part of an Active-Active database
+  deployment.
+linkTitle: Prepare clusters
+weight: 10
+url: '/operate/kubernetes/7.8.4/active-active/prepare-clusters/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.8.4/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.8.4/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+Next you'll [collect credentials](#collect-rec-credentials) for your participating clusters and create secrets for the RedisEnterprsieRemoteCluster (RERC) to use.
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+## Collect REC credentials
+
+To communicate with other clusters, all participating clusters will need access to the admin credentials for all other clusters.
+
+1. Create a file to hold the admin credentials for all participating RECs (such as `all-rec-secrets.yaml`).
+
+1. Within that file, create a new secret for each participating cluster named `redis-enterprise-<rerc-name>`.
+
+    The example below shows a file (`all-rec-secrets.yaml`) holding secrets for two participating clusters:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Get the REC credentials secret for each participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    The admin credentials secret for an REC named `rec-chicago` would be similar to this:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-chicago
+    type: Opaque
+    ```
+
+1. Add the username and password to the new secret for that REC and namespace.
+
+    This example shows the collected secrets file (`all-rec-secrets.yaml`) for `rerc-ohare` (representing `rec-chicago` in namespace `ns-illinois`) and `rerc-reagan` (representing `rec-arlington` in namespace `ns-virginia`).
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: KLmndo123456
+      username: PQrst789010
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <all-rec-secrets-file>
+    ```
+
+   If the admin credentials for any of the clusters changes, the file will need to be updated and reapplied to all clusters.
+
+## Next steps
+
+Now you are ready to [create your Redis Enterprise Active-Active database]({{< relref "/operate/kubernetes/7.8.4/active-active/create-reaadb.md" >}}).
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+---
+Title: Set global database configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' and through
+  this the database configurations are set.
+linkTitle: Global configuration
+weight: 50
+url: '/operate/kubernetes/7.8.4/active-active/global-config/'
+---
+{{<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.{{</note>}}
+
+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]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_active_active_database_api">}}) contains a full list of available fields.
+
+## Edit global configurations
+
+1. Edit or patch the REAADB custom resource with your global configuration changes.
+
+    The example command below patches the REAADB named `reaadb-boeing` to set the global memory size to 200MB:
+
+    ```sh
+    kubectl patch reaadb reaadb-boeing --type merge --patch \
+    '{"spec": {"globalConfigurations": {"memorySize": "200mb"}}}'
+    ```
+
+1. Verify the status is `active` and the spec status is `Valid`.
+
+    This example shows the status for the `reaadb-boeing` database.
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid    
+    ```
+
+1. View the global configurations on each participating cluster to verify they are synced.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o yaml
+    ```
+
+## Edit global configuration secrets
+
+This section edits the secrets under the REAADB `.spec.globalConfigurations` section. For more information and all available fields, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_active_active_database_api">}}).
+
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the relevant data.
+
+    This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+    ```yaml
+    apiVersion: v1
+     data:
+      password: bXktcGFzcw
+    kind: Secret
+    metadata:
+      name: my-db-secret
+    type: Opaque
+    ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit participating clusters for Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Steps to add or remove a participating cluster to an existing Active-Active
+  database with Redis Enterprise for Kubernetes.
+linkTitle: Edit participating clusters
+weight: 40
+url: '/operate/kubernetes/7.8.4/active-active/edit-clusters/'
+---
+{{<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.{{</note>}}
+
+## Add a participating cluster
+
+Use the following steps to add a participating cluster to an existing Redis Enterprise Active-Active database (REAADB) for Kubernetes.
+
+### Prerequisites
+
+To prepare the Redis Enterprise cluster (REC) to participate in an Active-Active database, perform the following tasks from [Prepare participating clusters]({{< relref "/operate/kubernetes/7.8.4/active-active/prepare-clusters.md" >}}):
+
+- Make sure the cluster meets the hardware and naming requirements.
+- Enable the Active-Active controllers.
+- Configure external routing.
+- Configure `ValidatingWebhookConfiguration`.
+
+### Collect REC credentials
+
+To communicate with other clusters, all participating clusters need access to the admin credentials for all other clusters.
+
+1. Get the REC credentials secret for the new participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    This example shows an admin credentials secret for an REC named `rec-boston`:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-boston
+    type: Opaque
+    ```
+
+1. Create a secret for the new participating cluster named `redis-enterprise-<rerc>` and add the username and password.
+
+    The example below shows a secret file for a remote cluster named `rerc-logan` .
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-logan
+    type: Opaque
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <rec-secret-file>
+    ```
+
+ If the admin credentials for any of the clusters change, update and reapply the file to all clusters.
+
+### Create RERC
+
+1. From one of the existing participating clusters, create a `RedisEnterpriseRemoteCluster` (RERC) custom resource for the new participating cluster.
+
+    This example shows an RERC custom resource for an REC named `rec-boston` in the namespace `ns-massachusetts`. 
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-logan
+    spec:
+      recName: rec-boston
+      recNamespace: ns-massachusetts
+      apiFqdnUrl: test-example-api-rec-boston-ns-massachusetts.example.com
+      dbFqdnSuffix: -example-cluster-rec-boston-ns-massachusetts.example.com
+      secretName: redis-enterprise-rerc-logan
+    ```
+
+1. Create the RERC custom resource.
+
+    ```sh
+    kubectl create -f <new-RERC-file>
+    ```
+
+1. Check the status of the newly created RERC custom resource.
+
+    ```sh
+    kubectl get rerc <RERC-name>
+    ```
+
+    The output should look like this:
+
+    ```sh
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-logan   Active   Valid         true
+    ```
+
+### Edit REAADB spec
+
+1. Patch the REAADB spec to add the new RERC name to the `participatingClusters`, replacing `<reaadb-name>` and `<rerc-name>` with your own values.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> < --type merge --patch '{"spec": {"participatingClusters": [{"name": "<rerc-name>"}]}}'
+    ```
+
+1. View the REAADB `participatingClusters` status to verify the cluster was added.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.participatingClusters}'
+    ```
+
+    The output should look like this:
+
+    ```sh
+    [{"id":1,"name":"rerc-ohare"},{"id":2,"name":"rerc-reagan"},{"id":3,"name":"rerc-logan"}]
+    ```
+
+## Remove a participating cluster
+
+1. On an existing participating cluster,remove the desired cluster from the `participatingCluster` section of the REAADB spec.
+
+    ```sh
+    kubectl edit reaadb <reaadb-name>
+    ```
+
+1. On each of the other participating clusters, verify the status is `active` and the spec status is `Valid` and the cluster was removed.
+
+   ```sh
+   kubectl get reaadb <reaadb-name -o=jasonpath=`{.status}`
+   ```
+   
+    The output should look like this:
+    
+    ```sh
+    {... ,"participatingClusters":[{"id":1,"name":"rerc1"},{"id":2,"name":"rerc2"}],"redisEnterpriseCluster":"rec1","specStatus":"Valid","status":"active"}
+    ```
+
+1. On the removed participating cluster, list all REAADB resources on the cluster to verify they were deleted.
+
+
+    ```sh
+    kubectl get reaadb -o+jasonpath=`{range.items[*]}{.metadata.name}`
+    ```
+---
+Title: Create Active-Active database (REAADB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: Create database
+weight: 30
+url: '/operate/kubernetes/7.8.4/active-active/create-reaadb/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+   {{<note>}}These are installed and enabled by default on clusters created via the OpenShift OperatorHub. {{</note>}}
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.8.4/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.8.4/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+4. [Prepare participating clusters]({{< relref "/operate/kubernetes/7.8.4/active-active/prepare-clusters.md" >}})
+   * RERC name (`<rerc-name`>)
+   * RERC secret name (`redis-enterprise-<rerc-name>`)
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+## Create `RedisEnterpriseRemoteCluster` resources {#create-rerc}
+
+1. Create a `RedisEnterpriseRemoteCluster` (RERC) custom resource file for each participating Redis Enterprise cluster (REC).
+
+   Below are examples of RERC resources for two participating clusters. Substitute your own values to create your own resource.
+
+    Example RERC (`rerc-ohare`) for the REC named `rec-chicago` in the namespace `ns-illinois`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-ohare
+    spec:
+      recName: rec-chicago
+      recNamespace: ns-illinois
+      apiFqdnUrl: api-rec-chicago-ns-illinois.example.com
+      dbFqdnSuffix: -db-rec-chicago-ns-illinois.example.com
+      secretName: redis-enterprise-rerc-ohare
+    ```
+
+    Example RERC (`rerc-raegan`) for the REC named `rec-arlington` in the namespace `ns-virginia`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-reagan
+    spec:
+      recName: rec-arlington
+      recNamespace: ns-virginia
+      apiFqdnUrl: test-example-api-rec-arlington-ns-virginia.example.com
+      dbFqdnSuffix: -example-cluster-rec-arlington-ns-virginia.example.com
+      secretName: redis-enterprise-rerc-reagan
+    ```
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise remote cluster from each RERC custom resource file.
+  
+   ```sh
+   kubectl create -f <rerc-file>
+   ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, then your configurations are correct.
+  
+    ```sh
+    kubectl get rerc <rerc-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get rerc rerc-ohare
+
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-ohare   Active   Valid         true
+    ```
+  
+    In case of errors, review the RERC custom resource events and the Redis Enterprise operator logs.
+
+## Create `RedisEnterpriseActiveActiveDatabase` resource {#create-reaadb}
+
+1. Create a `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource file meeting the naming requirements and listing the names of the RERC custom resources created in the last step.
+
+    Naming requirements:
+    * less than 63 characters
+    * contains only lowercase letters, numbers, or hyphens
+    * starts with a letter
+    * ends with a letter or digit
+
+    Example REAADB named `reaadb-boeing` linked to the REC named `rec-chicago` with two participating clusters and a global database configuration with shard count set to 3:
+
+     ```yaml
+     apiVersion: app.redislabs.com/v1alpha1
+     kind: RedisEnterpriseActiveActiveDatabase
+     metadata:
+       name: reaadb-boeing
+     spec:
+       globalConfigurations:
+         databaseSecretName: <my-secret>
+         memorySize: 200MB
+         shardCount: 3
+       participatingClusters:
+           - name: rerc-ohare
+           - name: rerc-reagan
+     ```
+
+     {{<note>}}Sharding is disabled on Active-Active databases created with a `shardCount` of 1. Sharding cannot be enabled after database creation. {{</note>}}
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise Active-Active database from the REAADB custom resource file.
+  
+    ```sh
+    kubectl create -f <reaadb-file>
+    ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, your configurations are correct.
+  
+    ```sh
+    kubectl get reaadb <reaadb-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up             
+    ```
+
+  
+    In case of errors, review the REAADB custom resource events and the Redis Enterprise operator logs.
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+
+---
+Title: Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Content related to Active-Active Redis Enterprise databases for Kubernetes.
+hideListLinks: true
+linkTitle: Active-Active databases
+weight: 40
+url: '/operate/kubernetes/7.8.4/active-active/'
+---
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters.
+
+## Active-Active setup methods
+
+There are two methods for creating an Active-Active database with Redis Enterprise for Kubernetes:
+
+- The `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource is available for versions 6.4.2 and later.
+- The `crdb-cli` method is available for versions 6.4.2 or earlier.
+
+
+We recommend creating new Active-Active databases using the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. This allows you to manage your Active-Active database with the operator and ensures you have the latest features and functionality.
+
+### Active-Active controller method
+
+Versions 6.4.2-6 or later fully support the Active-Active controller. 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.
+
+This setup method includes the following steps:
+
+1. Gather REC credentials and [prepare participating clusters]({{< relref "/operate/kubernetes/7.8.4/active-active/prepare-clusters.md" >}}).
+2. Create [`RedisEnterpriseRemoteCluster` (RERC)]({{< relref "/operate/kubernetes/7.8.4/active-active/create-reaadb#create-rerc" >}}) resources.
+3. Create [`RedisEnterpriseActiveActiveDatabase` (REAADB)]({{< relref "/operate/kubernetes/7.8.4/active-active/create-reaadb#create-reaadb" >}}) resource.
+
+### `crdb-cli` method
+
+For versions 6.4.2 or earlier, this Active-Active setup method includes the following steps:
+
+1. Install and configure an ingress.
+2. Gather configuration details.
+3. Add the `ActiveActive` field to the REC spec.
+4. Create the database with the `crdb-cli` tool.
+
+## Redis Enterprise Active-Active controller for Kubernetes
+
+{{<note>}}These features are supported for general availability in releases 6.4.2-6 and later.{{</note>}}
+
+[Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases give you read-and-write access to Redis Enterprise clusters (REC) in different Kubernetes clusters or namespaces. Active-Active deployments managed by the Redis Enterprise operator require two additional custom resources: Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC).
+
+To create an Active-Active Redis Enterprise deployment for Kubernetes with these new features, first [prepare participating clusters]({{< relref "/operate/kubernetes/7.8.4/active-active/prepare-clusters.md" >}}) then [create an Active-Active database]({{< relref "/operate/kubernetes/7.8.4/active-active/create-reaadb.md" >}}).
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+
+### REAADB custom resource
+
+Redis Enterprise Active-Active database (REAADB) contains a link to the RERC for each participating cluster, and provides configuration and status to the management plane.
+
+For a full list of fields and options, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_active_active_database_api">}}).
+
+### RERC custom resource
+
+Redis Enterprise remote cluster (RERC) custom resource contains configuration details for all the participating clusters.
+
+For a full list of fields and options, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}).
+
+### Limitations
+
+* Existing Redis databases cannot be migrated to a REAADB. (DOC-3594)
+* Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)
+    Workaround: Fix the problems with the REAADB and reapply.
+* The `<rec-name>/<rec-namespace>` value must be unique for each RERC resource. (RED-96302)
+* Only global database options are supported, no support for specifying configuration per location.
+* No support for migration from old (`crdb-cli`) Active-Active database method to new Active-Active controller.
+* No support for REAADB with participating clusters co-located within the same Kubernetes cluster, except for a single designated local participating cluster.
+
+## More info
+
+For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Describes where to view the archive of Redis Enterprise for Kubernetes
+  documentation.
+linkTitle: Archive
+weight: 99999999999
+url: '/operate/kubernetes/7.8.4/kubernetes-archive/'
+---
+
+Previous versions of Redis Enterprise for Kubernetes documentation are available on the archived web site:
+
+- [Redis Enterprise for Kubernetes v7.4 documentation archive](https://docs.redis.com/7.4/kubernetes/) 
+
+- [Redis Enterprise for Kubernetes v7.2 documentation archive](https://docs.redis.com/7.2/kubernetes/)  
+
+- [Redis Enterprise for Kubernetes v6.x documentation archive](https://docs.redis.com/6.4/kubernetes/)
+---
+Title: Manage Redis Enterprise cluster (REC) credentials
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: Manage REC credentials
+weight: 93
+url: '/operate/kubernetes/7.8.4/security/manage-rec-credentials/'
+---
+Redis Enterprise for Kubernetes uses a custom resource called [`RedisEnterpriseCluster`]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api" >}}) to create a Redis Enterprise cluster (REC). During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+{{<note>}}
+This procedure is only supported for operator versions 6.0.20-12 and above.
+{{</note>}}
+
+## Retrieve the current username and password
+
+The credentials can be used to access the Redis Enterprise admin console or the API. Connectivity must be configured to the REC [pods](https://kubernetes.io/docs/concepts/workloads/pods/) using an appropriate service (or port forwarding).
+
+1. Inspect the random username and password created by the operator during creation with the `kubectl get secret` command.
+
+    ```sh
+    kubectl get secret rec -o jsonpath='{.data}'
+    ```
+
+    The command outputs the encoded password and username, similar to the example below.
+
+      ```sh
+      map[password:MTIzNDU2NzgK username:ZGVtb0BleGFtcGxlLmNvbQo=]
+      ```
+
+1. Decode the password and username with the `echo` command and the password from the previous step.
+
+    ```bash
+    echo MTIzNDU2NzgK | base64 --decode
+    ```
+
+    This outputs the password and username in plain text. In this example, the plain text password is `12345678` and the username is `demo@example.com`.
+
+## Change the Redis Enterprise cluster (REC) credentials
+
+### Change the REC password for the current username
+
+1. Access a [pod](https://kubernetes.io/docs/concepts/workloads/pods/) running a Redis Enterprise cluster.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+2. Add a new password for the existing user.
+
+```bash
+REC_USER="`cat /opt/redislabs/credentials/username`" \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`" \
+curl -k --request POST \
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"$REC_PASSWORD\", \
+  \"new_password\":\"<NEW PASSWORD>\"}"
+```
+
+3. From outside the pod, update the REC credential secret.
+
+3a. Save the existing username to a text file.
+
+```sh
+echo -n "<current_username>" > username 
+```
+
+3b. Save the new password to a text file.
+
+```sh
+echo -n "<new_password>" > password
+```
+
+3c. Update the REC credential secret.
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --from-file=./username \
+  --from-file=./password --dry-run \
+  -o yaml | \
+kubectl apply -f 
+```
+
+4. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+5. Access a pod running a Redis Enterprise cluster again.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+6. Remove the previous password to ensure only the new one applies.
+
+```sh
+REC_USER="`cat /opt/redislabs/credentials/username`"; \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`"; \
+curl -k --request DELETE \ 
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"<OLD PASSWORD\"}"
+```
+
+{{<note>}} The username for the K8s secret is the email displayed on the Redis Enterprise admin console. {{</note>}}
+
+### Change both the REC username and password
+
+1. [Connect to the admin console]({{< relref "/operate/kubernetes/7.8.4/re-clusters/connect-to-admin-console.md" >}})
+
+2. [Add another admin user]({{< relref "/operate/rs/security/access-control/create-users" >}}) and choose a new password.
+
+3. Specify the new username in the `username` field of your REC custom resource spec.
+
+4. Update the REC credential secret:
+
+4a. Save the new username to a text file.
+
+```sh
+echo -n "<new_username>" > username
+```
+
+4b. Save the new password to a text file.
+
+```sh
+echo -n "<new_password>" > password
+```
+
+4c. Update the REC credential secret.
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --save-config \
+  --dry-run=client \
+  --from-file=./username --from-file=./password \
+  -o yaml | \
+kubectl apply -f
+```
+
+5. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+6. Delete the previous admin user from the cluster.
+
+{{<note>}}
+The operator may log errors in the time between updating the username in the REC spec and the secret update.
+{{</note>}}
+
+### Update the credentials secret in Vault
+
+If you store your secrets with Hashicorp Vault, update the secret for the REC credentials with the following key-value pairs:
+
+```sh
+username:<desired_username>, password:<desired_password>
+```
+
+For more information about Vault integration with the Redis Enterprise Cluster see [Integrating Redis Enterprise for Kubernetes with Hashicorp Vault](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/vault/README.md).
+---
+Title: Enable internode encryption
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable encryption for communication between REC nodes in your K8s cluster.
+linkTitle: Internode encryption
+weight: 99
+url: '/operate/kubernetes/7.8.4/security/internode-encryption/'
+---
+
+Internode encryption provides added security by encrypting communication between nodes in your Redis Enterprise cluster (REC).
+
+Enable internode encryption in the `spec` section of your REC custom resource file.
+
+```yaml
+spec:
+    dataInternodeEncryption: true
+```
+
+This change will apply to all databases created in the REC. You can override the cluster-wide setting for individual databases.
+
+Edit your Redis Enterprise database (REDB) custom resource file to disable internode encryption for only that database.
+
+```yaml
+spec: 
+    dataInternodeEncryption: false
+```
+
+To learn more about internode encryption, see [Internode encryption for Redis Enterprise Software]({{< relref "/operate/rs/security/encryption/internode-encryption.md" >}}).
+---
+Title: Manage Redis Enterprise cluster (REC) certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install your own certificates to be used by the Redis Enterprise cluster's
+  operator.
+linkTitle: Manage REC certificates
+weight: 94
+url: '/operate/kubernetes/7.8.4/security/manage-rec-certificates/'
+---
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes added to the cluster. For the list of of certificates used by Redis Enterprise Software and the traffic they encrypt, see the [certificates table]({{< relref "/operate/rs/security/certificates" >}}).
+
+To install and use your own certificates with Kubernetes on your Redis Enterprise cluster, they need to be stored in [secrets](https://kubernetes.io/docs/concepts/configuration/secret/). The REC custom resource also needs to be configured with those secret names to read and use the certificates.
+
+## Create a secret to hold the new certificate
+
+Create the [secret](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-kubectl/) with the required fields shown below.
+
+  ```sh
+  kubectl create secret generic <secret-name> \
+    --from-file=certificate=</PATH/TO/certificate.pem> \
+    --from-file=key=</PATH/TO/key.pem> \
+    --from-literal=name=<proxy | api | cm | syncer | metrics_exporter>
+  ```
+
+## Update certificates in the REC custom resource
+
+Edit the Redis Enterprise cluster (REC) custom resource to add a `certificates` subsection under the `spec` section. You are only required to add the fields for the certificates you are installing.
+
+```yaml
+spec:
+  certificates:
+    apiCertificateSecretName: <apicert-secret-name>
+    cmCertificateSecretName: <cmcert-secret-name>
+    syncerCertificateSecretName: <syncercert-secret-name>
+    metricsExporterCertificateSecretName: <metricscert-secret-name>
+    proxyCertificateSecretName: <proxycert-secret-name>
+```
+
+### Update certificates through the API
+
+Alternatively, you can also update the REC certificates via the API:
+
+```API
+PUT /v1/cluster/update_cert
+{
+   "certificate": <certificate>, 
+   "key": <cert-key>,
+   "name": <cert-name> 
+}
+```
+
+### Verify the certificate was updated
+
+Check the operator logs and use the API to verify the certificate has been updated.
+
+  ```api
+  GET /v1/cluster/certificates
+  ```
+
+## More info
+
+- [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates" >}})
+- [Install your own certificates]({{< relref "/operate/rs/security/certificates/create-certificates" >}})
+- [Glossary/Transport Layer Security (TLS)]({{< relref "/glossary#letter-t" >}})
+---
+Title: Enable LDAP authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable LDAP authentication for Redis Enterprise for Kubernetes.
+linkTitle: Enable LDAP
+weight: 95
+url: '/operate/kubernetes/7.8.4/security/ldap/'
+---
+
+## LDAP support for Redis Enterprise Software
+
+Redis Enterprise Software supports LDAP authentication and authorization through [role-based access controls]({{< relref "/operate/rs/security/access-control/" >}}) (RBAC). You can map LDAP groups to [Redis Enterprise roles]({{< relref "/operate/rs/security/access-control" >}}) to control access to your database and the Cluster Manager UI. For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+
+Redis Enterprise for Kubernetes supports enabling and configuring LDAP authentication using the `RedisEnterpriseCluster` (REC) custom resource. Currently, the Redis Enterprise cluster (REC) only supports configuration related to the LDAP server, such as server addresses, connection details, credentials, and query configuration.
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+## Enable LDAP 
+
+To enable LDAP for your REC, use the `.spec.ldap` field in the `RedisEnterpriseCluster` custom resource.
+
+The following `RedisEnterpriseCluster` example resource enables a basic LDAP configuration:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  ldap:
+    protocol: LDAP
+    servers:
+    - host: openldap.openldap.svc
+      port: 389
+    bindCredentialsSecretName: ldap-bind-credentials
+    cacheTTLSeconds: 600
+    enabledForControlPlane: true
+    enabledForDataPlane: true
+    authenticationQuery:
+      template: cn=%u,ou=default,dc=example,dc=org
+    authorizationQuery:
+      attribute: memberOf
+```
+
+Refer to the `RedisEnterpriseCluster` [API reference](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#ldapspec) for full details on the available fields.
+
+### Bind credentials
+
+For LDAP servers that require authentication for client queries, store the bind credentials in a secret and reference them in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to store the bind credentials.
+    
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <bind-secret-name> \
+        --from-literal=dn='<disinguished-name>' \
+        --from-literal=password=<password>
+    ```
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `dn` key with the distinguished name for the user performing the query (such as `cn=admin,dc=example,dc=org`).
+    - Include a `password` key with the bind password.
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.ldap.bindCredentialsSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        bindCredentialsSecretName: <bind-secret-name>
+    ```
+
+### LDAPS or STARTTLS protocols
+
+In addition to plain LDAP protocol, Redis Enterprise Software also supports LDAPS and STARTTLS protocols for secure communication with the LDAP server.
+
+To enable one of these protocols, edit the `spec.ldap.protocol` field in the `RedisEnterpriseCluster` custom resource:
+
+#### Enable `LDAPS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: LDAPS
+  ```
+
+  Default port: 636
+
+#### Enable `STARTTLS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: STARTTLS
+  ```
+
+  Default port: 389
+
+### CA certificate
+
+To use a custom CA certificate for validating the LDAP server certificate, store the CA certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the CA certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <ca-secret-name> \
+        --from-file=cert=<ca-cert>.pem
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `cert` key with a PEM-encoded CA certificate (such as `cacert.pem`).
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `spec.ldap.caCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        caCertificateSecretName: <ca-secret-name>
+    ```
+
+### Client certificates
+
+To use an LDAP client certificate, store the certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the client certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <client-secret-name> \
+      --from-literal=name=ldap_client \
+      --from-file=certificate=<client-cert-file> \
+      --from-file=key=<private-key-file>
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `name` key explicitly set to `ldap_client`.
+    - Include a `certificate` key for the public key (such as `cert.pem`).
+    - Include a `key` key for the private key (such as `key.pem`).
+    
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.certificates.ldapClientCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource, substituting your own values for `<placeholders>`.
+
+    ```yaml
+    spec:
+      certificates:
+        ldapClientCertificateSecretName: <client-secret-name>
+    ```
+
+## Known limitations
+
+Redis Enterprise Software can't resolve DNS names with a `.local` suffix.
+  If your LDAP server is in the same Kubernetes cluster and exposed via a Service object, *avoid* addresses such as `openldap.openldap.svc.cluster.local`. Instead, *use short-form addresses* such as `openldap.openldap.svc`.
+
+## Next steps
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+---
+categories:
+- docs
+- operate
+- kubernetes
+description: Add client certificates to your REDB custom resource.
+linkTitle: Add client certificates
+title: Add client certificates
+weight: 95
+url: '/operate/kubernetes/7.8.4/security/add-client-certificates/'
+---
+
+For each client certificate you want to use with your database, you need to create a Kubernetes secret to hold it. You can then reference that secret in your Redis Enterprise database (REDB) custom resource spec.
+
+## Create a secret to hold the new certificate
+
+1. [Create the secret config file](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-config-file/) with the required fields shown below.
+
+    ```yaml
+    apiVersion: v1
+    kind: Secret
+    type: Opaque
+    metadata:
+      name: <client-cert-secret>
+      namespace: <your-rec-namespace>
+    data:
+      cert: <client-certificate>
+    ```
+  
+1. Apply the file to create the secret resource.
+
+    ```bash
+    kubectl apply -f <client-cert-secret>.yaml
+    ```
+
+## Edit the REDB resource
+
+1. Add the secret name to the REDB custom resource (`redb.yaml`) with the `clientAuthenticationCertificates` property in the `spec` section.
+
+  ```yaml
+   spec:
+      clientAuthenticationCertificates:
+      - <client-cert-secret>
+  ```
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Security settings and configuration for Redis Enterprise for Kubernetes
+hideListLinks: false
+linkTitle: Security
+weight: 50
+url: '/operate/kubernetes/7.8.4/security/'
+---
+
+This section contains security settings and configuration for Redis Enterprise for Kubernetes.
+
+
+---
+Title: Configure Istio for external routing
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure Istio as an ingress controller for access to your Redis Enterprise
+  databases from outside the Kubernetes cluster.
+linkTitle: Istio ingress routing
+weight: 20
+url: '/operate/kubernetes/7.8.4/networking/istio-ingress/'
+---
+
+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.
+
+## Install and configure Istio for Redis Enterprise
+
+1. [Download](https://istio.io/latest/docs/setup/getting-started/) and [install](https://istio.io/latest/docs/setup/getting-started/) Istio (see instructions from Istio's [Getting Started](https://istio.io/latest/docs/setup/getting-started/) guide).
+
+    Once the installation is complete, all the deployments, pods, and services will be deployed in a namespace called `istio-system`. This namespace contains a `LoadBalancer` type service called `service/istio-ingressgateway` that exposes the external IP address.
+
+1. Find the `EXTERNAL-IP` for the `istio-ingressgateway` service.
+
+    ```sh
+    kubectl get svc istio-ingressgateway -n istio-system
+
+    NAME                   TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)                                                                      AGE
+    istio-ingressgateway   LoadBalancer   10.34.67.89   10.145.78.91   15021:12345/TCP,80:67891/TCP,443:23456/TCP,31400:78901/TCP,15443:10112/TCP   3h8m
+    ```
+
+1. Create a DNS entry that resolves your chosen database hostname (or a wildcard `*` followed by your domain) to the Istio `EXTERNAL-IP`. Use this hostname to access your database from outside the cluster.
+
+    In this example, any hostname that ends with `.istio.k8s.my.example.com` will resolve to the Istio LoadBalancer's external IP of `10.145.78.91`. Substitute your own values accordingly.
+
+1. Verify the record was created successfully.
+
+    ```sh
+    dig api.istio.k8s.my.example.com
+    ```
+
+    Look in the `ANSWER SECTION` for the record you just created.
+
+    ```sh
+    ;; ANSWER SECTION:
+    api.istio.k8s.my.example.com 0 IN    A       10.145.78.91
+    ```
+
+## Create custom resources
+
+### `Gateway` custom resource
+
+1. On a different namespace from `istio-system`, create a `Gateway` custom resource file (`redis-gateway.yaml` in this example).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - Replace `<selector-label>` with the label set on your Istio ingress gateway pod (most common is `istio: ingress`).
+    - TLS passthrough mode is required to allow secure access to the database.
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: Gateway
+    metadata:
+      name: redis-gateway
+    spec:
+      selector:
+        istio: <selector-label>
+      servers:
+      - hosts:
+        - '*.istio.k8s.my.example.com'
+        port:
+          name: https
+          number: 443
+          protocol: HTTPS
+        tls:
+          mode: PASSTHROUGH
+    ```
+
+
+
+1. Apply the `Gateway` custom resource file to create the Ingress gateway.
+
+    ```sh
+    kubectl apply -f redis-gateway.yaml
+    ```
+
+1. Verify the gateway was created successfully.
+
+      ```sh
+      kubectl get gateway
+
+      NAME            AGE
+      redis-gateway   3h33m
+      ```
+
+### `VirtualService` custom resource
+
+1. On a different namespace than `istio-system`, create the `VirtualService` custom resource file (`redis-vs.yaml` in this example).
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: VirtualService
+    metadata:
+      name: redis-vs
+    spec:
+      gateways:
+      - redis-gateway
+      hosts:
+      - "*.istio.k8s.my.example.com"
+      tls:
+      - match:
+        - port: 443
+          sniHosts:
+          - api.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: rec1
+            port:
+              number: 9443
+      - match:
+        - port: 443
+          sniHosts:
+          - db1.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: db1
+    ```
+
+    This creates both a route to contact the API server on the REC (`rec1`) and a route to contact one of the databases (`db1`).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - The gateway's metadata name must be similar to the gateway's spec name (`redis-gateway` in this example).
+   
+1. Apply `VirtualService` custom resource file to create the virtual service.
+
+    ```sh
+    kubectl apply -f redis-vs.yaml
+    ```
+
+1. Verify the virtual service was created successfully.
+
+    ```sh
+    kubectl get vs
+
+    NAME       GATEWAYS            HOSTS                              AGE
+    redis-vs   ["redis-gateway"]   ["*.istio.k8s.my.example.com"]   3h33m
+    ```
+
+1. [Deploy the operator]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md" >}}), Redis Enterprise Cluster (REC), and Redis Enterprise Database (REDB) on the same namespace as the gateway and virtual service.
+
+## Test your external access to the database
+
+To [test your external access]({{< relref "/operate/kubernetes/7.8.4/networking/ingress.md" >}}) to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).
+
+See [Test your access with Openssl]({{< relref "/operate/kubernetes/7.8.4/networking/ingress#test-your-access-with-openssl" >}}) or [Test your access with Python]({{< relref "/operate/kubernetes/7.8.4/networking/ingress#test-your-access-with-python" >}}) for more info.
+---
+Title: Use OpenShift routes for external database access
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: OpenShift routes
+weight: 15
+url: '/operate/kubernetes/7.8.4/networking/routes/'
+---
+
+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](https://docs.openshift.com/container-platform/4.13/networking/routes/route-configuration.html).
+
+## 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.
+
+  By default, the DMC Proxy uses a self-signed certificate.  You can retrieve it from the Redis Enterprise admin console and save it as a file (for example, named "ca.pem") on the client machine.
+
+* Your database also needs TLS encryption enabled.
+
+## Create OpenShift route
+
+1. Select the **Networking/Routes** section of the OpenShift web console.
+
+1. Select **Create route** and fill out the following fields:
+
+   * **Name**: Choose any name you want as the first part of your generated hostname
+   * **Hostname**: Leave blank
+   * **Path**: Leave as is ("/")
+   * **Service**: Select the service for the database you want to access
+   * **TLS Termination**: Choose "passthrough"
+   * **Insecure Traffic**: Select "None"
+
+1. Select **Create**.
+
+1. Find the hostname for your new route. After route creation, it appears in the "Host" field.
+
+1. Verify you have a DNS entry to resolve the hostname for your new route to the cluster's load balancer.
+
+## Access database
+
+Access the database from outside the cluster using `redis-cli` or `openssl`.
+
+To connect with `redis-cli`:
+  
+   ```sh
+   redis-cli -h <hostname> -p 443 --tls --cacert ./ca.pem --sni <hostname>
+   ```
+
+Replace the `<hostname>` value with the hostname for your new route.
+
+To connect with `openssl`:
+
+   ```sh
+   openssl s_client -connect <hostname>:443 -crlf -CAfile ./ca.pem -servername <hostname>
+   ```
+---
+Title: Configure Ingress for external routing
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure an ingress controller to access your Redis Enterprise databases
+  from outside the Kubernetes cluster.
+linkTitle: Ingress routing
+weight: 5
+url: '/operate/kubernetes/7.8.4/networking/ingress/'
+---
+
+## Prerequisites
+
+Before creating an Ingress, you'll need:
+
+ - A RedisEnterpriseDatabase (REDB) with TLS enabled for client connections
+ - A supported Ingress controller with `ssl-passthrough` enabled
+    - [Ingress-NGINX Controller](https://kubernetes.github.io/ingress-nginx/deploy/)
+        - Be sure to use the `kubernetes/ingress-nginx` controller and NOT the `nginxinc/kubernetes-ingress` controller.
+    - [HAProxy Ingress](https://haproxy-ingress.github.io/docs/getting-started/)
+    - To use Istio for your Ingress resources, see [Configure Istio for external routing]({{< relref "/operate/kubernetes/7.8.4/networking/istio-ingress.md" >}})
+
+{{<note>}}Make sure your Ingress controller has `ssl-passthrough`enabled. This is enabled by default for HAProxy, but disabled by default for NGINX. See the [NGINX User Guide](https://kubernetes.github.io/ingress-nginx/user-guide/tls/#ssl-passthrough) for details. {{</note>}}
+
+## Create an Ingress resource
+
+1. Retrieve the hostname of your Ingress controller's `LoadBalancer` service.
+
+    ``` sh
+    $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                        -n <ingress-ctrl-namespace>
+    ```
+
+    Below is example output for an HAProxy running on a K8s cluster hosted by AWS.  
+
+    ``` sh
+    NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+    haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+    ```
+
+1. Choose the hostname you will use to access your database (this value will be represented in this article with `<my-db-hostname>`).  
+
+1. Create a DNS entry that resolves your chosen database hostname to the IP address for the Ingress controller's LoadBalancer.  
+
+1. Create the Ingress resource YAML file.  
+
+    ``` YAML
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    metadata:
+      name: rec-ingress
+      annotations:
+        <controller-specific-annotations-below>
+    spec:
+      rules:
+      - host: <my-db-hostname>
+        http:
+          paths:
+          - path: /
+            pathType: ImplementationSpecific
+            backend:
+              service:
+                name: <db-name>
+                port:
+                  name: redis
+    ```  
+
+    For HAProxy, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: haproxy
+     ingress.kubernetes.io/ssl-passthrough: "true"
+    ```
+
+    For NGINX, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: nginx
+    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    ```  
+
+    The `ssl-passthrough` annotation is required to allow access to the database. The specific format changes depending on your Ingress controller and any additional customizations. See [NGINX Configuration annotations](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) and [HAProxy Ingress Options](https://www.haproxy.com/documentation/kubernetes/latest/configuration/ingress/) for updated annotation formats.  
+
+## Test your external access  
+
+To test your external access to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).  
+
+#### Test your access with Openssl  
+
+1. Get the default CA certificate from the `redis-enterprise-node` container on any of the Redis Enterprise pods.  
+
+    ``` sh
+    $ kubectl exec -it <pod-name> -c redis-enterprise-node \
+                    -- cat /etc/opt/redislabs/proxy_cert.pem
+    ```  
+
+1. Run the following `openssl` command, substituting your own values for `<my-db-hostname>`.  
+
+    ``` sh
+    $ openssl s_client \
+      -connect <my-db-hostname>:443 \
+      -crlf -CAfile ./proxy_cert.pem \
+      -servername <my-db-hostname>
+    ```  
+
+    If you are connected to the database, you will receive `PONG` back, as shown below:  
+
+    ``` sh
+    ...
+     Verify return code: 0 (ok)
+    ---
+
+    PING
+    +PONG
+    ```  
+
+#### Test your access with Python  
+
+You can use the code below to test your access with Python, substituting your own values for `<my-db-hostname>` and `<file-path>`.  
+
+``` python
+import redis
+
+r = redis.StrictRedis(host='<my-db-hostname>',
+              port=443, db=0, ssl=True,
+              ssl_ca_certs='/<file-path>/proxy_cert.pem')
+
+
+print(r.info())
+```
+
+Your output should look something like this:  
+
+``` sh
+$ /Users/example-user/Documents/Projects/test_client/venv3.7/bin/python \
+    /Users/example-user/Documents/Projects/test_client/test_ssl.py
+{
+    'redis_version': '5.0.5',
+    'redis_git_sha1': 0,
+    'redis_git_dirty': 0,
+    'redis_build_id': 0,
+    'redis_mode': 'standalone',
+    'os': 'Linux 4.14.154-128.181.amzn2.x86_64 x86_64',
+    'arch_bits': 64,
+    'multiplexing_api': 'epoll',
+    'gcc_version': '7.4.0',
+    'process_id': 1,
+    'run_id': '3ce7721b096517057d28791aab555ed8ac02e1de',
+    'tcp_port': 10811,
+    'uptime_in_seconds': 316467,
+    'uptime_in_days': 3,
+    'hz': 10,
+    'lru_clock': 0,
+    'config_file': '',
+    'connected_clients': 1,
+    'client_longest_output_list': 0,
+    'client_biggest_input_buf': 0,
+    'blocked_clients': 0,
+    'used_memory': 12680016,
+    'used_memory_human': '12.9M',
+    'used_memory_rss': 12680016,
+    'used_memory_peak': 13452496,
+    'used_memory_peak_human': '12.82M',
+    'used_memory_lua': 151552,
+    'mem_fragmentation_ratio': 1,
+    'mem_allocator': 'jemalloc-5.1.0',
+    'loading': 0,
+    'rdb_changes_since_last_save': 0,
+    'rdb_bgsave_in_progress': 0,
+    'rdb_last_save_time': 1577753916,
+    'rdb_last_bgsave_status': 'ok',
+    'rdb_last_bgsave_time_sec': 0,
+    'rdb_current_bgsave_time_sec': -1,
+    'aof_enabled': 0,
+    'aof_rewrite_in_progress': 0,
+    'aof_rewrite_scheduled': 0,
+    'aof_last_rewrite_time_sec': -1,
+    'aof_current_rewrite_time_sec': -1,
+    'aof_last_bgrewrite_status': 'ok',
+    'aof_last_write_status': 'ok',
+    'total_connections_received': 4,
+    'total_commands_processed': 6,
+    'instantaneous_ops_per_sec': 14,
+    'total_net_input_bytes': 0,
+    'total_net_output_bytes': 0,
+    'instantaneous_input_kbps': 0.0,
+    'instantaneous_output_kbps': 0.0,
+    'rejected_connections': 0,
+    'sync_full': 1,
+    'sync_partial_ok': 0,
+    'sync_partial_err': 0,
+    'expired_keys': 0,
+    'evicted_keys': 0,
+    'keyspace_hits': 0,
+    'keyspace_misses': 0,
+    'pubsub_channels': 0,
+    'pubsub_patterns': 0,
+    'latest_fork_usec': 0,
+    'migrate_cached_sockets': 0,
+    'role': 'master',
+    'connected_slaves': 1,
+    'slave0': {
+        'ip': '0.0.0.0',
+        'port': 0,
+        'state': 'online',
+        'offset': 0,
+        'lag': 0
+    },
+    'master_repl_offset': 0,
+    'repl_backlog_active': 0,
+    'repl_backlog_size': 1048576,
+    'repl_backlog_first_byte_offset': 0,
+    'repl_backlog_histlen': 0,
+    'used_cpu_sys': 0.0,
+    'used_cpu_user': 0.0,
+    'used_cpu_sys_children': 0.0,
+    'used_cpu_user_children': 0.0,
+    'cluster_enabled': 0
+}
+
+Process finished with exit code 0
+```
+---
+Title: Networking
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+linkTitle: Networking
+weight: 40
+url: '/operate/kubernetes/7.8.4/networking/'
+---
+
+Redis Enterprise for Kubernetes supports several ways to route external traffic to your RedisEnterpriseCluster:
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}) to route external traffic.
+- The RedisEnterpriseActiveActiveDatabase (REAADB) requires any of the above routing methods to be configured in the RedisEnterpriseCluster (REC) with the `ingressOrRouteSpec` field.
+
+## External routing using Redis Enterprise for Kubernetes
+
+Every time a RedisEnterpriseDatabase (REDB), Redis Enterprise Active-Active database (REAADB), or Redis Enterprise cluster (REC) is created, the Redis Enterprise operator automatically creates a [service](https://kubernetes.io/docs/concepts/services-networking/service/) to allow requests to be routed to that resource.
+
+Redis Enterprise supports three [types of services](https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types) for accessing databases: `ClusterIP`, `headless`, or `LoadBalancer`.
+
+By default, the operator creates a `ClusterIP` type service, which exposes a cluster-internal IP and that can only be accessed from within the K8s cluster. For requests to be routed from outside the K8s cluster, you need an [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) (or [route](https://docs.openshift.com/container-platform/4.12/networking/routes/route-configuration.html) if you are using OpenShift). See [kubernetes.io](https://kubernetes.io/docs/) for more details on [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) and [Ingress controllers](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/).
+
+* To use NGINX or HAProxy Ingress controllers, see [Ingress routing]({{< relref "/operate/kubernetes/7.8.4/networking/ingress.md" >}}).
+* To use OpenShift routes, see [OpenShift routes]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}).
+* To use Istio as an Ingress controller, see [Istio Ingress routing]({{< relref "/operate/kubernetes/7.8.4/networking/istio-ingress.md" >}})
+
+## `ingressOrRouteSpec` for Active-Active databases
+
+Versions 6.4.2 or later of Redis Enterprise for Kubernetes include a feature for ingress configuration. The `ingressOrRouteSpec` field is available in the RedisEnterpriseCluster spec to automatically create an Ingress (or route) for the API service and databases (REAADB) on that REC. See [REC external routing]({{< relref "/operate/kubernetes/7.8.4/networking/ingressorroutespec.md" >}}) for more details.
+
+This feature only supports automatic Ingress creation for Active-Active databases created and managed with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. Use with the standard Redis Enterprise database (REDB) is not currently supported.
+
+## REC domain name
+
+The RedisEnterpriseCluster does not support custom domain names. Domain names for the REC are in the following format: `<rec-name>.<namespace>.svc.cluster.local`.
+---
+Title: Establish external routing on the RedisEnterpriseCluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: REC external routing
+weight: 30
+url: '/operate/kubernetes/7.8.4/networking/ingressorroutespec/'
+---
+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:
+* [HAProxy](https://haproxy-ingress.github.io/)
+* [NGINX](https://kubernetes.github.io/ingress-nginx/)
+* [Istio](https://istio.io/latest/docs/setup/getting-started/)
+
+OpenShift users can use [routes]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}) instead of an Ingress.
+
+Install your chosen Ingress controller, making sure `ssl-passthrough` is enabled. `ssl-passthrough` is turned off by default for NGINX but enabled by default for HAProxy.
+
+## Configure DNS
+
+1. Choose the hostname (FQDN) you will use to access your database according to the recommended naming conventions below, replacing `<placeholders>` with your own values.
+
+     REC API hostname: `api-<rec-name>-<rec-namespace>.<subdomain>`
+     REAADB hostname: `-db-<rec-name>-<rec-namespace>.<subdomain>`
+     
+     We recommend using a wildcard (`*`) in place of the database name, followed by the hostname suffix.
+
+1. Retrieve the `EXTERNAL-IP` of your Ingress controller's `LoadBalancer` service.
+
+     ``` sh
+     $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                         -n <ingress-ctrl-namespace>
+     ```
+
+     Below is example output for an HAProxy ingress controller running on a K8s cluster hosted by AWS.  
+
+     ``` sh
+     NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+     haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+     ```
+
+1. Create DNS records to resolve your chosen REC API hostname and database hostname to the `EXTERNAL-IP` found in the previous step.
+
+## Edit the REC spec
+
+Edit the RedisEnterpriseCluster (REC) spec to add the `ingressOrRouteSpec` field, replacing `<placeholders>` below with your own values.
+
+### NGINX or HAproxy ingress controllers
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `ingress`.
+* Set `ssl-passthrough` to "true".
+* Add any additional annotations required for your ingress controller. See [NGINX docs](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) or [HAproxy docs](https://haproxy-ingress.github.io/docs/configuration/keys/) for more information.
+
+```sh
+kubectl patch rec  <rec-name> --type merge --patch "{\"spec\": \
+    {\"ingressOrRouteSpec\": \
+      {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\", \
+      \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+      \"ingressAnnotations\": \
+       {\"<kubernetes | github>.io/ingress.class\": \
+       \"<ingress-controller>\", \
+       \"<ingress-controller-annotation>/ssl-passthrough\": \ \"true\"}, \
+      \"method\": \"ingress\"}}}"
+```
+
+### OpenShift routes
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `openShiftRoute`.
+
+```sh
+kubectl patch rec <rec-name> --type merge --patch "{\"spec\": \
+     {\"ingressOrRouteSpec\": \
+     {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\" \ 
+     \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+     \"method\": \"openShiftRoute\"}}}"
+```
+
+OpenShift routes do not require any `ingressAnnotations` in the `ingressOrRouteSpec`.
+---
+Title: Control node selection
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how Redis Enterprise cluster
+  pods can be scheduled to only be placed on specific nodes or node pools.
+linkTitle: Node selection
+weight: 80
+url: '/operate/kubernetes/7.8.4/recommendations/node-selection/'
+---
+
+Many Kubernetes cluster deployments have different kinds of nodes that have
+different CPU and memory resources available for scheduling cluster workloads.
+Redis Enterprise for Kubernetes has various abilities to control the scheduling
+Redis Enterprise cluster node pods through properties specified in the
+Redis Enterprise cluster custom resource definition (CRD).
+
+A Redis Enterprise cluster (REC) is deployed as a StatefulSet which manages the Redis Enterprise cluster node pods.
+The scheduler chooses a node to deploy a new Redis Enterprise cluster node pod on when:
+
+- The cluster is created
+- The cluster is resized
+- A pod fails
+
+Here are the ways that you can control the pod scheduling:
+
+## Using node selectors
+
+The [`nodeSelector`]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#spec">}})
+property of the cluster specification uses the same values and structures as
+the [Kubernetes `nodeSelector`](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector).
+In general, node labels are a simple way to make sure that specific nodes are used for Redis Enterprise pods.
+For example, if nodes 'n1' and 'n2' are labeled as "high memory":
+
+```sh
+kubectl label nodes n1 memory=high
+kubectl label nodes n2 memory=high
+```
+
+The Redis Enterprise cluster CRD can request to be scheduled on these nodes:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     memory: high
+```
+
+Then, when the operator creates the StatefulSet associated with the pod, the nodeSelector
+section is part of the pod specification. When the scheduler attempts to
+create new pods, it needs to satisfy the node selection constraints.
+
+
+## Using node pools
+
+A node pool is a common part of the underlying infrastructure of the Kubernetes cluster deployment and provider.
+Often, node pools are similarly-configured classes of nodes such as nodes with the same allocated amount of memory and CPU.
+Implementors often label these nodes with a consistent set of labels.
+
+On Google Kubernetes Engine (GKE), all node pools have the label `cloud.google.com/gke-nodepool` with a value of the name used during configuration.
+On Microsoft Azure Kubernetes System (AKS), you can create node pools with a specific set of labels. Other managed cluster services may have similar labeling schemes.
+
+You can use the `nodeSelector` section to request a specific node pool by label values. For example, on GKE:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     cloud.google.com/gke-nodepool: 'high-memory'
+```
+
+## Using node taints
+
+You can use multiple node taints with a set of tolerations to control Redis Enterprise cluster node pod scheduling.
+The `podTolerations` property of the cluster specification specifies a list of pod tolerations to use.
+The value is a list of [Kubernetes tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/#concepts).
+
+For example, if the cluster has a single node pool, the node taints can control the allowed workloads for a node.
+You can add taints to the node, for example nodes n1, n2, and n3, reserve a set of nodes for the Redis Enterprise cluster:
+
+```sh
+kubectl taint nodes n1 db=rec:NoSchedule
+kubectl taint nodes n2 db=rec:NoSchedule
+kubectl taint nodes n3 db=rec:NoSchedule
+```
+
+This prevents any pods from being scheduled onto the nodes unless the pods can tolerate the taint `db=rec`.
+
+You can then add the toleration for this taint to the cluster specification:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podTolerations:
+  - key: db
+    operator: Equal     
+    value: rec
+    effect: NoSchedule
+```
+
+A set of taints can also handle more complex use cases.
+For example, a `role=test` or `role=dev` taint can be used to designate a node as dedicated for testing or development workloads via pod tolerations.
+
+## Using pod anti-affinity
+
+By default, the Redis Enterprise node pods are not allowed to be placed on the same node for the same cluster:
+
+```yaml
+podAntiAffinity:
+  requiredDuringSchedulingIgnoredDuringExecution:
+  - labelSelector:
+      matchLabels:
+        app: redis-enterprise
+        redis.io/cluster: rec
+        redis.io/role: node
+    topologyKey: kubernetes.io/hostname
+```
+
+Each pod has the three labels above where `redis.io/cluster` is the label for the name of your cluster.
+
+You can change this rule to restrict or include nodes that the Redis Enterprise cluster node pods can run on.
+For example, you can delete the `redis.io/cluster` label so that even Redis Enterprise node pods from different clusters cannot be scheduled on the same Kubernetes node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          app: redis-enterprise
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+or you can prevent Redis Enterprise nodes from being schedule with other workloads.
+For example, if all database workloads have the label 'local/role: database', you
+can use this label to avoid scheduling two databases on the same node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  extraLabels:
+     local/role: database
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          local/role: database
+          app: redis-enterprise
+          redis.io/cluster: rec
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+In this case, any pods that are deployed with the label `local/role: database` cannot be scheduled on the same node.
+
+
+## Using rack awareness
+
+You can configure Redis Enterprise with rack-zone awareness to increase availability
+during partitions or other rack (or region) related failures.
+
+{{%note%}}When creating your rack-zone ID, there are some constraints to consider; see [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness#rack-zone-id-rules" >}}) for more info. {{%/note%}}
+
+
+Rack-zone awareness is a single property in the Redis Enterprise cluster CRD named `rackAwarenessNodeLabel`.
+This value for this label is commonly `topology.kubernetes.io/zone` as documented in
+['Running in multiple zones'](https://kubernetes.io/docs/setup/best-practices/multiple-zones/#nodes-are-labeled).
+
+You can check the value for this label in your nodes with the command:
+
+```sh
+$kubectl get nodes -o custom-columns="name:metadata.name","rack\\zone:metadata.labels.failure-domain\.beta\.kubernetes\.io/zone"
+
+name                                            rack\zone
+ip-10-0-x-a.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-b.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-c.eu-central-1.compute.internal    eu-central-1b
+ip-10-0-x-d.eu-central-1.compute.internal    eu-central-1b
+```
+
+### Enabling the cluster role
+
+For the operator to read the cluster node information, you must create a cluster role for the operator and then bind the role to the service account.
+
+Here's a cluster role:
+
+```yaml
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+rules:
+  # needed for rack awareness
+  - apiGroups: [""]
+    resources: ["nodes"]
+    verbs: ["list", "get", "watch"]
+```
+
+And here's how to apply the role:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role.yaml
+```
+
+The binding is typically to the `redis-enterprise-operator` service account:
+
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+subjects:
+- kind: ServiceAccount
+  namespace: OPERATOR_NAMESPACE
+  name: redis-enterprise-operator
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator
+  apiGroup: rbac.authorization.k8s.io
+```
+
+and it can be applied by running:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role_binding.yaml
+```
+
+Once the cluster role and the binding have been applied, you can configure Redis Enterprise clusters to use rack awareness labels.
+
+### Configuring rack awareness
+
+You can configure the node label to read for the rack zone by setting the `rackAwarenessNodeLabel` property:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  nodes: 3
+  rackAwarenessNodeLabel: topology.kubernetes.io/zone
+```
+
+{{< note >}}
+When you use the `rackAwarenessNodeLabel` property, the operator will change the topologyKey for the anti-affinity rule to the label name used unless you have specified the `podAntiAffinity` property as well. If you use `rackAwarenessNodeLabel` and `podAntiAffinity` together, you must make sure that the `topologyKey` in your pod anti-affinity rule is set to the node label name.
+{{< /note >}}
+---
+Title: Size and scale a Redis Enterprise cluster deployment on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about sizing and scaling Redis Enterprise
+  in a Kubernetes deployment.
+linkTitle: Sizing and scaling
+weight: 50
+url: '/operate/kubernetes/7.8.4/recommendations/sizing-on-kubernetes/'
+---
+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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## Sizing and scaling cluster nodes
+
+### Setting the number of cluster nodes
+
+Define the number of cluster nodes in redis-enterprise-cluster.yaml file.
+
+    spec:
+
+        nodes: 3
+
+The number of nodes in the cluster must be an uneven number
+equal to or greater than 3. Refer to the article [Highly Available Redis](https://redislabs.com/redis-enterprise/technology/highly-available-redis/)
+for a detailed explanation on this topic.
+
+Set the number of cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling out
+
+To scale out a Redis Enterprise Cluster deployment, increase the number of nodes
+in the spec. For example, to scale the cluster out from 3 nodes to 5 nodes,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+    spec:
+
+        nodes: 5
+
+To apply the new cluster configuration run:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{<warning>}} Decreasing the number of nodes is not supported.{{</warning>}}
+
+### Sizing compute resources
+
+To set the compute resources required for each node,
+use the redisEnterpriseNodeResources spec field.
+
+Under redisEnterpriseNodeResources spec, set the following fields
+according to the provided guidelines.
+
+- limits – specifies the maximum compute resources for a Redis node
+- requests – specifies the minimum compute resources for a Redis node
+
+For example:
+
+    redisEnterpriseNodeResources:
+
+        limits:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+        requests:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+The default values, if unspecified, are 2 cores (2000m) and 4GB (4Gi).
+
+Set the compute resources for cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling up node compute resources
+
+To scale up nodes in an existing Redis Enterprise Cluster deployment,
+adjust the cpu and memory parameters in the spec. For example,
+to scale nodes up to the recommended amount of compute resources,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+redisEnterpriseNodeResources:
+
+    limits:
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+    requests
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+Then, apply the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{< warning >}}
+When adjusting compute resources, make sure the ratio of persistent volume size and the new memory size are in accordance to the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}). 
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.8.4/re-clusters/expand-pvc">}}) for details.
+{{< /warning >}}
+---
+Title: Manage node resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Recommendations on managing node resources and setting eviction thresholds
+  with Redis Enterprise for Kubernetes.
+linktitle: Manage resources
+weight: 17
+url: '/operate/kubernetes/7.8.4/recommendations/node-resources/'
+---
+ 
+
+
+## Node eviction thresholds
+
+ Kubernetes uses [node-pressure eviction](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/) to terminate pods and free up node resources. Redis Enterprise for Kubernetes works best when you use the recommendations below.
+
+Eviction thresholds are managed by [kubelet arguments](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/).
+
+Redis recommends setting a high [soft eviction threshold](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds). This changes the node condition early enough to alert the administrator.
+
+We also recommend setting the [`eviction-soft-grace-period`](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds) high enough for the administrator to scale the cluster.
+
+For more information about configuring eviction thresholds on specific platforms, see [Freeing node resources](https://docs.openshift.com/container-platform/4.9/nodes/nodes/nodes-nodes-garbage-collection.html) for OpenShift or [Cluster architecture](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable) for GKE.
+
+### Monitor node conditions
+
+Redis recommends monitoring the node conditions. If both `MemoryPressure` and `DiskPressure` are true, the eviction threshold was met.
+
+```sh
+> kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+
+For more information about monitoring node conditions, see [Node conditions](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#node-conditions) on [kubernetes.io](https://kubernetes.io/docs/home/).
+
+## Resource quotas
+
+Kubernetes uses the `ResourceQuota` object to limit resource consumption per namespace. This lets you limit the number of objects created by a namespace or the amount of compute resources consumed by a namespace. 
+
+The resource settings for Redis Enterprise for Kubernetes are defined in the `operator.yaml` and the [`RedisEnterpriseCluster`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#redisenterpriseclusterspec) custom resource.
+
+The following settings are the minimum workloads for the operator to function.
+
+```yaml
+  resources:
+    limits:
+      cpu: 0.5
+      memory: 256Mi
+    requests:
+      cpu: 0.5
+      memory: 256Mi
+```
+For more details on using resource quotas, see the [Kubernetes documentation](https://kubernetes.io/docs/concepts/policy/resource-quotas/).
+
+
+---
+Title: Use persistent volumes in Redis Enterprise clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section covers details about how persistent volumes are sized and
+  specified for Redis Enterprise cluster deployments.
+linkTitle: Persistent volumes
+weight: 40
+url: '/operate/kubernetes/7.8.4/recommendations/persistent-volumes/'
+---
+## 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.
+
+{{<warning>}}
+NFS, NFS-like, and multi-read-write/shared storage options are not supported. These types of storage are often slow and can cause locking behaviors that are incompatible with the requirements of database storage.
+{{</warning>}}
+
+## REC `persistentSpec` field 
+To deploy a Redis Enterprise cluster with Redis Enterprise operator the
+spec should include a *persistentSpec* section, in the
+*redis-enterprise-cluster.yaml* file:
+
+    spec:
+      nodes: 3
+      persistentSpec:
+       enabled: true
+       storageClassName: "standard"
+       volumeSize: "23Gi” #optional
+
+Persistence storage is a requirement for production deployments.
+
+{{< note >}}
+For **production deployments** of Redis Enterprise Cluster on Kubernetes,
+the Redis Enterprise Cluster (REC) must be deployed with persistence enabled.
+The REC deployment files in the [Kubernetes documentation](https://github.com/RedisLabs/redis-enterprise-k8s-docs) contain this declaration by default.
+{{< /note >}}
+
+## Volume size
+
+*volumeSize* is an optional definition. By default, if the definition is
+omitted, operator allocates five times (5x) the amount of memory (RAM)
+defined for nodes (see example below), which is the recommended
+persistent storage size as described in the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) article.
+
+To explicitly specify the persistent storage size, use the *volumeSize*
+property as described in the example above.
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.8.4/re-clusters/expand-pvc">}}) for details.
+
+{{< note >}}
+We recommend that you omit the volumeSize definition from the REC declaration
+so that the Redis Enterprise Cluster deployment on Kubernetes use the default volume size.
+{{< /note >}}
+
+## Storage class name
+
+*storageClassName* determines the Storage Class resource, which is
+defined by the Kubernetes cluster administrator, to be used for
+persistent storage.
+
+Different Kubernetes distributions and different deployments use
+different Storage Class resources.
+
+In order to determine the Storage Class resources available for your K8s
+deployment, use the following command:
+
+    kubectl get StorageClass
+
+Typically, AWS provides “gp2” as the Storage Class name while GKE uses “standard.”
+Azure provides two Storage Classes: "default" using HDDs, and "managed-premium" using SSDs.
+
+Below is an example of a response to the command.
+
+|                         |                                                         |
+| ----------------------- | ------------------------------------------------------- |
+| *Name:*                 | *gp2*                                                   |
+| *IsDefaultClass:*       | *Yes*                                                   |
+| *Annotations:*          | *storageclass.beta.kubernetes.io/is-default-class=true* |
+| *Provisioner:*          | *kubernetes.io/aws-ebs*                                 |
+| *Parameters:*           | *encrypted=false,kmsKeyId=,type=gp2*                    |
+| *AllowVolumeExpansion:* | *\<unset\>*                                             |
+| *MountOptions:*         | *\<none\>*                                              |
+| *ReclaimPolicy:*        | *Delete*                                                |
+| *VolumeBindingMode:*    | *Immediate*                                             |
+| *Events:*               | *\<none\>*                                              |
+
+{{< note >}}
+storageClassName must be specified for this deployment type.
+{{< /note >}}
+
+{{< warning >}}
+The storage class cannot be changed after deployment. Trying to change this value after deployment could result in unexpected and potentially damaging behavior.
+{{< /warning >}}
+
+Example of the redisEnterpriseNodeResources definition:
+
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: “4000m”
+        memory: 4Gi
+      requests:
+        cpu: “4000m”
+        memory: 4Gi
+---
+Title: Manage pod stability
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how you can use quality of service,
+  priority class, eviction thresholds and resource monitoring to maintain cluster
+  node pod stability.
+linkTitle: Pod stability
+weight: 90
+url: '/operate/kubernetes/7.8.4/recommendations/pod-stability/'
+---
+
+Kubernetes clusters manage the allocation of system resources and can evict pods to release system resources.
+Here are some ways that you can configure the Redis Enterprise node pods to maintain pod stability:
+
+## Guaranteed quality of service
+
+A running pod has a quality of service measure assigned to it that is
+one of three [quality of service classes](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/):
+Guaranteed, Burstable, and Best Effort.
+You can assure the Guaranteed class is assigned to the Redis Enterprise node pods
+by following the right guidelines.
+
+To get a Guaranteed quality of service class assigned:
+
+ * Every container in the pod must have a memory limit and a memory request, and they must be the same.
+ * Every container in the pod must have a CPU limit and a CPU request, and they must be the same.
+
+If resources limits and requests are not specified in the Redis Enterprise CRD,
+these requirements are met in the default version created by the operator. of your Redis Enterprise cluster CRD,
+Otherwise, you must set the limits and requests to the same value for memory and CPU in the `redisEnterpriseNodeResources`
+section of the CRD.
+
+Sidecar containers also impact the quality of service class assignment for the pod.
+
+To check the quality of service class of any running Redis Enterprise node pod, run:
+
+```sh
+kubectl get pod rec-0 --o jsonpath="{.status.qosClass}"
+```
+
+where `rec-0` is the name of one of the pods associated with the Redis Enterprise cluster.
+
+## Using priority to protect from preemption
+
+When a Redis Enterprise node pod is scheduled, it can be assigned a
+[priority class](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/)
+with the `priorityClassName` property. This property value is the name of
+a priority class that must already exist within the cluster.
+
+A sufficiently high priority will prevent other workloads with a lower
+priority from preempting the scheduling of Redis Enterprise Nodes. Similarly,
+a high value may also prevent eviction when lower priority workloads
+are deployed on the same cluster.
+
+The successful use of this strategy involves first creating a priority class with a very large priority value:
+
+```yaml
+apiVersion: scheduling.k8s.io/v1
+kind: PriorityClass
+metadata:
+  name: redis-enterprise-priority
+value: 1000000000
+globalDefault: false
+description: "This priority class should be used for Redis Enterprise pods only."
+```
+
+Then, you refer to the priority class by name in your Redis Enterprise cluster CRD:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  size: 3
+  priorityClassName: "redis-enterprise-priority"
+```
+
+Alternatively, you can also [disable preemption entirely](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#how-to-disable-preemption).
+
+## Managing eviction thresholds
+
+Eviction thresholds are typically managed by kubelet arguments.
+You can set the thresholds:
+
+- On OpenShift - In the [config file](https://docs.openshift.com/container-platform/3.11/admin_guide/out_of_resource_handling.html#out-of-resource-create-config).
+- On GKE - In the [managed settings](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable).
+
+We recommend that you:
+
+ * Set the [soft eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#soft-eviction-thresholds)
+   to be higher than the [hard eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#hard-eviction-thresholds).
+   The high soft threshold makes the node condition change earlier, and alerts the administrator.
+ * Set `eviction-max-pod-grace-period` high enough to allow the RS pods to migrate the Redis databases before the pods are force killed.
+ * Set the `eviction-soft-grace-period` high enough that the administrator (or a k8s auto-scaling mechanism) scales k8s up or out.
+
+## Monitoring for memory and disk usage
+
+We recommend that you monitor the node for MemoryPressure and DiskPressure.
+When both of these conditions are true, then an [eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#eviction-thresholds)
+is met and the pod is evicted.
+
+To retrieve the flags, run the command:
+
+```sh
+$kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+---
+Title: Configuration recommendations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Settings and configuration recommendations for your Redis Enterprise
+  deployment.
+hideListLinks: false
+linkTitle: Recommendations
+weight: 80
+url: '/operate/kubernetes/7.8.4/recommendations/'
+---
+
+This section contains  recommended settings and configuration for your Redis Enterprise for Kubernetes deployment.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes FAQs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+hidden: true
+linkTitle: FAQs
+weight: 100
+url: '/operate/kubernetes/7.8.4/faqs/'
+---
+Here are some frequently asked questions about Redis Enterprise on integration platforms.
+
+## What is an Operator?
+
+An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources#custom-controllers) which extends the native K8s API. Refer to the article [Redis Enterprise K8s Operator-based deployments – Overview]({{< relref "/operate/kubernetes/7.8.4/architecture/" >}}).
+
+## Does Redis Enterprise operator support multiple RECs per namespace?
+
+Redis Enterprise for Kubernetes may only deploy a single Redis Enterprise cluster (REC) per [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each REC can run multiple databases while maintaining high capacity and performance.
+
+## Do I need to deploy a Redis Enterprise operator per namespace?
+
+Yes, one operator per namespace, each managing a single Redis Enterprise cluster.
+Each REC can run multiple databases while maintaining high capacity and performance.
+
+## How can I see the custom resource definitions (CRDs) created for my Redis Enterprise cluster?
+
+Run the following:
+
+```sh
+kubectl get rec
+kubectl describe rec <my-cluster-name>
+```
+
+## How can I change the Redis Enterprise cluster admin user password?
+
+The cluster admin user password is created by the operator during the deployment of the Redis Enterprise cluster (REC) and is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/).
+
+See [Manage REC credentials]({{< relref "/operate/kubernetes/7.8.4/security/manage-rec-credentials" >}}) for instructions on changing the admin password.
+
+## How is using Redis Enterprise operator superior to using Helm charts?
+
+While [Helm charts](https://helm.sh/docs/topics/charts/) help automate multi-resource deployments, they do not provide the lifecycle management and lack many of the benefits provided by the operator:
+
+- Operators are a K8s standard, while Helm is a proprietary tool
+    - Using operators means better packaging for different Kubernetes deployments and distributions, as Helm is not supported in a straightforward way everywhere
+- Operators allow full control over the Redis Enterprise cluster lifecycle
+    - We’ve experienced difficulties managing the state and lifecycle of the application through Helm, as it essentially only allows to determine the resources being deployed, which is a problem when upgrading and evolve the Redis Enterprise Cluster settings
+- Operators support advanced flows which would otherwise require using an additional third party product
+
+## How to connect to the Redis Enterprise cluster user interface
+
+Create a [port forwarding](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#port-forward) rule to expose the cluster user interface (UI) port. For example, when the default port 8443 is used, run:
+
+```sh
+kubectl port-forward –namespace <namespace> service/<name>-cluster-ui 8443:8443
+```
+
+Connect to the UI by pointing your browser to `https://localhost:8443`
+
+## How should I size Redis Enterprise cluster nodes?
+
+For nodes hosting the Redis Enterprise cluster [statefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) [pods](https://kubernetes.io/docs/concepts/workloads/pods/), follow the guidelines provided for Redis Enterprise in the [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+For additional information please also refer to [Kubernetes operator deployment – persistent volumes]({{< relref "/operate/kubernetes/7.8.4/recommendations/persistent-volumes.md" >}}).
+
+## How to retrieve the username/password for a Redis Enterprise Cluster?
+
+The Redis Enterprise cluster stores the username/password of the UI in a K8s [secret](https://kubernetes.io/docs/concepts/configuration/secret/).
+
+Find the secret by retrieving secrets and locating one of type [Opaque](https://kubernetes.io/docs/concepts/workloads/pods/) with a name identical or containing your Redis Enterprise cluster name.
+
+For example, run:
+
+```sh
+kubectl get secrets
+```
+
+A possible response may look like this:
+
+| NAME | TYPE | DATA | AGE |
+|------|------|------|-----|
+| redis-enterprise-cluster | Opaque | 2 | 5d |
+
+To retrieve the secret run:
+
+```sh
+kubectl get secret redis-enterprise-cluster -o yaml
+```
+
+A possible response may look like this:
+
+```yaml
+apiVersion: v1
+data:
+  password: Q2h5N1BBY28=
+  username: cmVkaXNsYWJzLnNi
+kind: Secret
+metadata:
+  creationTimestamp: 2018-09-03T14:06:39Z
+  labels:
+   app: redis-enterprise
+   redis.io/cluster: test
+ name: redis-enterprise-cluster
+ namespace: redis
+ ownerReferences:
+ – apiVersion: app.redislabs.com/v1alpha1
+   blockOwnerDeletion: true
+   controller: true
+   kind: RedisEnterpriseCluster
+   name: test
+   uid: 8b247469-c715-11e8-a5d5-0a778671fc2e
+ resourceVersion: “911969”
+ selfLink: /api/v1/namespaces/redis/secrets/redis-enterprise-cluster
+ uid: 8c4ff52e-c715-11e8-80f5-02cc4fca9682
+type: Opaque
+```
+
+Next, decode, for example, the password field. Run:
+
+```sh
+echo "Q2h5N1BBY28=" | base64 –-decode
+```
+
+
+## How to retrieve the username/password for a Redis Enterprise Cluster through the OpenShift Console?
+
+To retrieve your password, navigate to the OpenShift management console, select your project name, go to Resources->Secrets->your_cluster_name
+
+Retrieve your password by selecting “Reveal Secret.”
+{{< image filename="/images/rs/openshift-password-retrieval.png" >}}
+
+
+## What capabilities, privileges and permissions are defined by the Security Context Constraint (SCC) yaml?
+
+The `scc.yaml` file is defined like this:
+
+```yaml
+kind: SecurityContextConstraints
+apiVersion: security.openshift.io/v1
+metadata:
+  name: redis-enterprise-scc
+allowPrivilegedContainer: false
+allowedCapabilities:
+  - SYS_RESOURCE
+runAsUser:
+  type: MustRunAs
+  uid: 1001
+FSGroup:
+  type: MustRunAs
+  ranges: 1001,1001
+seLinuxContext:
+  type: RunAsAny
+```
+
+([latest version on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml))
+
+([latest version on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tags))
+
+The SYS_RESOURCE capability is required by the Redis Enterprise cluster (REC) container so that REC can set correct out of memory (OOM) scores to its processes inside the container.
+Also, some of the REC services must be able to increase default resource limits, especially the number of open file descriptors.
+
+{{< note >}}
+- Removing NET_RAW blocks 'ping' from being used on the solution containers.
+- These changes were made as of release 5.4.6-1183 to better align the deployment with container and Kubernetes security best practices:
+    - The NET_RAW capability requirement in PSP was removed.
+    - The allowPrivilegeEscalation is set to 'false' by default.
+{{< /note >}}
+---
+Title: Flexible deployment options
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces.
+  This article describes flexible deployment options you can use to meet your specific
+  needs.
+linkTitle: Deployment options
+aliases: [ /operate/kubernetes/architecture/deployment-options/, ]
+weight: 12
+url: '/operate/kubernetes/7.8.4/architecture/deployment-options/'
+---
+You can deploy Redis Enterprise for Kubernetes in several different ways depending on your database needs.
+
+Multiple RedisEnterpriseDatabase (REDB) resources can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces.
+
+The Redis Enterprise cluster (REC) custom resource must reside in the same namespace as the Redis Enterprise operator.
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Single REC and single namespace (one-to-one)
+
+The standard and simplest deployment deploys your Redis Enterprise databases (REDB) in the same namespace as the Redis Enterprise cluster (REC). No additional configuration is required for this, since there is no communication required to cross namespaces. See [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.8.4/deployment/quick-start.md" >}}).
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-one.png" >}}
+
+## Single REC and multiple namespaces (one-to-many)
+
+Multiple Redis Enterprise databases (REDB) spread across multiple namespaces within the same K8s cluster can be associated with the same Redis Enterprise cluster (REC). See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace.md" >}}) for more information.
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-many.png" >}}
+
+## Multiple RECs and multiple namespaces (many-to-many)
+
+A single Kubernetes cluster can contain multiple Redis Enterprise clusters (REC), as long as they reside in different namespaces. Each namespace can host only one REC and each operator can only manage one REC.
+
+You have the flexibility to create databases in separate namespaces, or in the same namespace as the REC, or combine any of the supported deployment options above. This configuration is geared towards use cases that require multiple Redis Enterprise clusters with greater isolation or different cluster configurations.
+
+See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace.md" >}}) for more information.
+
+
+{{< image filename="/images/k8s/k8s-deploy-many-to-many.png" >}}
+
+## Unsupported deployment patterns
+
+### Cross-cluster operations
+
+Redis Enterprise for Kubernetes does not support operations that cross Kubernetes clusters. Redis Enterprise clusters (REC) work inside a single K8s cluster. Crossing clusters could result in functional and security issues.
+
+{{< image filename="/images/k8s/k8s-deploy-cross-namespaces.png" >}}
+
+### Multiple RECs in one namespace
+
+Redis Enterprise for Kubernetes does not support multiple Redis Enterprise clusters (REC) in the same namespace. Creating more than one REC in the same namespace will result in errors.
+
+{{< image filename="/images/k8s/k8s-deploy-multicluster-antipattern.png" >}}
+---
+Title: Redis Enterprise for Kubernetes architecture
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Overview of the architecture and components of Redis Enterprise for Kubernetes.
+hideListLinks: true
+linkTitle: Architecture
+weight: 1
+aliases: [operate/platforms/kubernetes/kubernetes-architecture/]
+url: '/operate/kubernetes/7.8.4/architecture/'
+---
+
+Redis Enterprise for Kubernetes gives you the speed and durability of [Redis Enterprise](https://redis.io/redis-enterprise/advantages/), with the flexibility and ease of [Kubernetes (K8s)](https://kubernetes.io/). Redis Enterprise for Kubernetes uses the Kubernetes operator pattern and custom controllers to bring the best of Redis Enterprise to the Kubernetes platform.
+
+## Lifecycle
+
+Kubernetes is a rapidly evolving platform with a short release cycle (around 4 months). This frequent influx of new features, enhancements and bug fixes means Kubernetes distributions move in and out of support quickly. Redis Enterprise is also a fast-moving product, and is compatible and tested only on distributions listed as [supported distributions.]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions">}})
+
+Each version of Redis Enterprise for Kubernetes is tested to ensure the version of Redis Enterprise works with the [supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions">}}) at the time. Both the Kubernetes version and the Redis Enterprise version must be supported for the operator to function correctly. We encourage you to upgrade Redis Enterprise for Kubernetes frequently, not only to get the benefit of enhancements and bug fixes, but to keep your software supported.
+
+Supported platforms are listed in the [release notes]({{<relref "/operate/kubernetes/release-notes">}}) and in the [supported platforms reference.]({{<relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions">}})
+
+## Architecture
+
+The image below illustrates the components of a single namespace, three node deployment.
+
+{{< image filename="/images/k8s/k8s-arch-v4.png" >}}
+
+## Operator
+
+An [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is a custom extension of the Kubernetes API designed to manage complex, stateful applications and their components. This operator pattern is commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. Kubernetes.io/docs has a great explanation of the [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/).
+
+The operator is a deployment that runs within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) and uses [controllers](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) to manage [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/), ensuring these resources are continuously monitored and maintained.
+
+When the operator is installed, the following resources are created:
+
+- [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) under which the operator will run
+- set of [roles](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole) to define the privileges necessary for the operator to perform its tasks
+- set of [role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-and-clusterrolebinding) to authorize the service account
+- [CustomResourceDefinition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for each Redis Enterprise custom resource
+- the operator deployment
+
+## Namespace
+
+The Redis Enterprise [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is deployed within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each namespace can host only one operator and one [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec). Namespaces create logical boundaries between resources, allowing organization and security. Some resources are limited to a namespace, while others are cluster-wide.
+
+Redis Enterprise for Kubernetes also supports [multi-namespace deployments]({{<relref "/operate/kubernetes/7.8.4/architecture/deployment-options">}}), meaning the operator can monitor other namespaces (that host applications) for custom resources and apply any changes.
+
+## Custom resources
+
+Kubernetes [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) are commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. [Custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) extend the Kubernetes API, enabling users to manage Redis databases the Kubernetes way. Custom resources are created and managed using YAML configuration files.
+
+This [declarative configuration approach](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/) allows you to specify the desired state for your resources, and the operator makes the necessary changes to achieve that state. This simplifies [installation]({{<relref "/operate/kubernetes/7.8.4/deployment">}}), [upgrades]({{<relref "/operate/kubernetes/7.8.4/upgrade">}}), and [scaling]({{<relref "/operate/kubernetes/7.8.4/recommendations/sizing-on-kubernetes">}}) both vertically and horizontally.
+
+The operator continuously monitors CRs for changes, automatically reconciling any differences between the desired state you specified in your YAML configuration file, and the actual state of your resources. Custom resources can also reside in separate namespaces from the operator managing them, such as in [multi-namespace installations]({{<relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace">}}).
+
+## Custom resource definitions
+
+A [custom resource definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) is a cluster-wide resource that specifies which settings can be configured via custom resource files. Any setting not defined by the CRD is not managed by the operator. You can still make changes to these unmanaged settings using standard Redis Enterprise Software methods.
+
+For settings managed by the operator, any changes made outside of the CR YAML files (e.g., through the management UI) will be overwritten by the operator. Ensure that all operator-managed settings are updated using the CR YAML files to prevent conflicts.
+
+## RedisEnterpriseCluster REC
+
+A Redis Enterprise cluster is a set of Redis Enterprise nodes pooling resources. Each node is capable of running multiple Redis instances ([shards]({{<relref "/operate/rs/references/terminology">}})).
+
+{{< image filename="/images/k8s/k8s-node-arch.png">}}
+
+A Redis cluster is created and managed by the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REC configuration file prompt the operator to make changes to the cluster. The REC is required for both standard databases ([REDB](#redisenterprisedatabase-redb)) and Active-Active databases ([REAADB](#redisenterpriseactiveactivedatabase-reaadb)).
+
+See the [RedisEnterpriseCluster API Reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseDatabase REDB
+
+A Redis Enterprise database is a logical entity that manages your entire dataset across multiple Redis instances. A Redis instance is a single-threaded database process ([commonly referred to as a shard]({{<relref "/operate/rs/references/terminology">}})).
+
+Redis databases are created and managed by the [RedisEnterpriseDatabase (REDB)]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api">}}) [custom resource (CR)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REDB YAML configuration file prompt the operator to make changes to the database.
+
+An operator can manage a database in the same namespace, or a different namespace. See ["Flexible deployment"]({{<relref "/operate/kubernetes/7.8.4/architecture/deployment-options">}}) options and ["Manage databases in multiple namespaces"]({{<relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace">}}) for more information.
+
+See the [RedisEnterpriseDatabase (REDB) API Reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api">}}) for a full list of fields and settings.
+
+## Security
+
+Redis Enterprise for Kubernetes uses [secrets](https://kubernetes.io/docs/concepts/configuration/secret/) to manage your cluster credentials, cluster certificates, and client certificates. You can configure [LDAP]({{<relref "/operate/kubernetes/7.8.4/security/ldap">}}) and [internode encryption]({{<relref "/operate/kubernetes/7.8.4/security/internode-encryption">}}) using the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec) spec.
+
+### REC credentials
+
+Redis Enterprise for Kubernetes uses the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) to create a Redis Enterprise cluster. During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+See [Manage REC credentials]({{<relref "/operate/kubernetes/7.8.4/security/manage-rec-credentials">}}) for more details.
+
+### REC certificates
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes in the cluster.
+
+See [Manage REC certificates]({{<relref "/operate/kubernetes/7.8.4/security/manage-rec-certificates.md">}}) for more details.
+
+### Client certificates
+
+For each client certificate you want to use, you need to create a [Kubernetes secret](https://kubernetes.io/docs/concepts/configuration/secret/) to hold it. You can then reference that secret in your [Redis Enterprise database (REDB)](#redisenterprisedatabase-redb) custom resource.
+
+See [Add client certificates]({{<relref "/operate/kubernetes/7.8.4/security/add-client-certificates">}}) for more details.
+
+## Storage
+
+[Persistent storage is mandatory for Redis Enterprise.]({{<relref "operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage">}}) Redis Enterprise for Kubernetes [requires network-attached storage](https://en.wikipedia.org/wiki/Network-attached_storage).
+
+Redis Enterprise for Kubernetes uses [PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) to manage storage resources. The PVC is an abstract representation of the [PersistentVolume (PV)](https://kubernetes.io/docs/concepts/storage/persistent-volumes) resources used by your Redis pods. PVCs are created by the Redis Enterprise operator and used by the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec).
+
+PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims), if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+### Auto Tiering
+
+Redis Enterprise Software for Kubernetes supports [Auto Tiering]({{<relref "/operate/kubernetes/7.8.4/re-clusters/auto-tiering">}}) (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+
+## Networking
+
+By default, Kubernetes doesn't allow you to access your Redis database from outside your K8s cluster. Redis Enterprise for Kubernetes supports several ways to route external traffic to your [Redis Enterprise cluster (REC)](#redisenterprisecluster-rec):
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/7.8.4/networking/routes.md" >}}) to route external traffic.
+
+The [Active-Active databases](#active-active-databases) require one of above routing methods to be configured in the REC with the [ingressOrRouteSpec field]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#specingressorroutespec">}}).
+
+## Services Rigger
+
+The services rigger is responsible for creating and updating services related to database objects. It identifies database objects within the cluster and creates services in accordance with [`redisEnterpriseCluster.Spec.servicesRiggerSpec` setting]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api#specservicesriggerspec">}}) to allow access to those databases. By default, each database has two services, a `cluster_ip` Service with the same name as the database and a `headless` Service with the same name as the database suffixed with `-headless`. It also creates other types of Services such as Ingress Services or OpenshiftRoutes (defined in `redisEnterpriseCluster.Spec.ingressOrRouteSpec`) meant to provide access to REAADB objects.
+
+You can view a list of services with the `kubectl get services` command.
+
+Kubernetes is a dynamic environment, with nodes and pods changing as needed. The services rigger monitors the cluster for these changes and updates the database services to ensure reliable communication with the databases.
+
+## Active-Active databases
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters. Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/7.8.4/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.The admission controller is also required for Active-Active databases on Kubernetes, to validate changes to the custom resources.
+
+For more details and installation information, see [Active-Active databases]({{<relref "/operate/kubernetes/7.8.4/active-active/">}}). For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+## RedisEnterpriseRemoteCluster RERC
+
+The [RedisEnterpriseRemoteCluster (RERC)]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}) contains details allowing the REC to link to the RedisEnterpriseActiveActiveDatabase (REAADB). The RERC resource is listed in the [REAADB](#redisenterpriseactiveactivedatabase-reaadb) resource to become a participating cluster for the Active-Active database.
+
+See the [RERC API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseActiveActiveDatabase REAADB
+
+The RedisEnterpriseActiveActiveDatabase (REAADB) resource creates and manages a database that spans more than one Kubernetes cluster. An REAADB requires [external routing](#networking), at least two [RECs](#redisenterprisecluster-rec), and at least two [RERCs](#redisenterpriseremotecluster-rerc).
+
+See the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_active_active_database_api">}}) for a full list of fields and settings.
+
+## Metrics
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can [connect your Prometheus]({{<relref "/operate/kubernetes/7.8.4/re-clusters/connect-prometheus-operator">}}) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+---
+Title: Collect logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Run the log collector script to package relevant logs into a tar.gz file
+  to send to Redis Support for help troubleshooting your Kubernetes environment.
+linkTitle: Collect logs
+weight: 89
+url: '/operate/kubernetes/7.8.4/logs/collect-logs/'
+---
+
+The Redis Enterprise cluster (REC) log collector script ([`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py)) creates and fills a directory with the relevant logs for your environment. These logs will help the support team with troubleshooting.
+
+As of version 6.2.18-3, the log collector tool has two modes:
+
+- **restricted** collects only resources and logs created by the operator and Redis Enterprise deployments
+  - This is the default for versions 6.2.18-3 and later
+- **all** collects everything from your environment
+  - This is the default mode for versions 6.2.12-1 and earlier
+
+{{<note>}} This script requires Python 3.6 or later. {{</note>}}
+
+1. Download the latest [`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py) file.
+
+1. Have a K8s administrator run the script on the system that runs your `kubectl` or `oc` commands.
+    - Pass `-n` parameter to run on a different namespace than the one you are currently on
+    - Pass `-m` parameter to change the log collector mode (`all` or `restricted`)
+    - Run with `-h` to see more options
+
+    ```bash
+    python log_collector.py 
+    ```
+
+   {{< note >}} If you get an error because the yaml module is not found, install the pyYAML module with `pip install pyyaml`.
+  {{< /note >}}
+
+
+
+1. Upload the resulting `tar.gz` file containing all the logs to [Redis Support](https://support.redislabs.com/).
+---
+Title: Redis Enterprise Software logs on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how logs are stored and accessed.
+hideListLinks: true
+linkTitle: Logs
+weight: 60
+url: '/operate/kubernetes/7.8.4/logs/'
+---
+
+## Logs
+
+Each redis-enterprise container stores its logs under `/var/opt/redislabs/log`.
+When using persistent storage this path is automatically mounted to the
+`redis-enterprise-storage` volume.
+This volume can easily be accessed by a sidecar, i.e. a container residing on the same pod.
+
+For example, in the REC (Redis Enterprise Cluster) spec you can add a sidecar container, such as a busybox, and mount the logs to there:
+
+```yaml
+sideContainersSpec:
+  - name: busybox
+    image: busybox
+    args:
+      - /bin/sh
+      - -c
+      - while true; do echo "hello"; sleep 1; done
+
+    volumeMounts:
+    - name: redis-enterprise-storage
+      mountPath: /home/logs
+      subPath: logs
+```
+
+Now the logs can be accessed from in the sidecar. For example by running
+
+```kubectl exec -it <pod-name> -c busybox tail home/logs/supervisord.log```
+
+The sidecar container is user determined and can be used to format, process and share logs in a specified format and protocol.
+---
+Title: Use a private registry for container images
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section details how the Redis Enterprise Software and Kubernetes
+  operator images can be configured to be pulled from a variety of sources. This page
+  describes how to configure alternate private repositories for images, plus some
+  techniques for handling public repositories with rate limiting.
+linktitle: Use a private container registry
+weight: 92
+url: '/operate/kubernetes/7.8.4/deployment/container-images/'
+---
+
+Redis Enterprise Software, its Kubernetes operator, and the Service Rigger
+are all distributed as separate container images.
+Your Kubernetes deployment will pull these images as needed.
+ You can control where these images are
+pulled from within the operator deployment and also via the
+Redis Enterprise custom resources.
+
+In general, images for deployments that do not have a registry domain
+name (e.g., `gcr.io` or `localhost:5000`) are pulled from the default registry associated
+with the Kubernetes cluster. A plain reference to `redislabs/redis` will likely pull from DockerHub
+(except on OpenShift where it pulls from Red Hat).
+
+For security reasons (e.g., in air-gapped environments), you may want to pull the images
+from a public registry once and then push them to a private registry under
+your control.
+
+{{<warning>}}It is very important that the images you are pushing to the private registry have the same exact version tag as the original images. {{</warning>}}
+
+Furthermore, because [Docker rate limits public pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/),
+you may want to consider pulling images from a
+private registry to avoid deployment failures when you hit your DockerHub rate limit.
+
+The information below will help you track and configure where your deployments pull container images.
+
+{{< note >}}
+**IMPORTANT**
+* Each version of the Redis Enterprise operator is mapped to a specific version of Redis Enterprise Software. The semantic versions always match (for example, 7.2.4), although the specific release numbers may be different (for example, 7.2.4-7 is the operator version for Redis Enterprise Software 7.2.4-64).
+* A specific operator version only supports a specific Redis Enterprise version. Other combinations of operator and Redis Enterprise versions are **not supported**.
+{{< /note >}}
+
+
+## Find container sources
+
+Every pod in your deployed application has a source registry. Any image not prefixed by a registry domain name (e.g., "gcr.io") will pull from the default registry for the Kubernetes cluster (i.e., DockerHub). You can use the commands below to discover the pull sources for the images on your cluster.
+
+To list all the images used by your cluster:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c
+```
+
+To specifically determine the pull source for the Redis Enterprise operator itself, run the following command:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c | grep redislabs
+```
+
+You can limit this command to specific namespaces by replacing the `--all-namespaces` parameter with
+a set of `-n {namespace}` parameters, where each `{namespace}` is a specific
+namespace of interest on your cluster.
+
+## Create a private container registry
+
+You can set up a private container registry in a couple of ways:
+
+* On-premise via [Docker registry](https://docs.docker.com/registry/deploying/), [Red Hat Quay](https://www.redhat.com/en/technologies/cloud-computing/quay), or other providers
+* Cloud provider based registries (e.g., Azure Container Registry, Google Container Registry, etc.).
+
+Once you have set up a private container registry, you will identify the container registry using:
+
+* A domain name
+* A port (optional)
+* A repository path (optional)
+
+## Push images to a private container registry
+
+Important images for a Redis Enterprise Software deployment include:
+
+* Redis Enterprise Software
+* Bootstrapping a Redis Enterprise cluster node (in the operator image)
+* The Service Rigger
+* The Redis Enterprise Software operator
+
+You will need to push all these images to your private container registry. In general,
+to push the images you must:
+
+ 1. [Pull](https://docs.docker.com/engine/reference/commandline/pull/) the various images locally for the Redis Enterprise Software, the Service Rigger, and the operator.
+ 2. Tag the local images with the private container registry, repository, and version tag.
+ 3. [Push](https://docs.docker.com/engine/reference/commandline/push/) the newly tagged images.
+
+The example below shows the commands for pushing the images for Redis Enterprise Software and its operator to a private container registry:
+
+```sh
+PRIVATE_REPO=...your repo...
+RS_VERSION=7.2.4-64
+OPERATOR_VERSION=7.2.4-7
+docker pull redislabs/redis:${RS_VERSION}
+docker pull redislabs/operator:${OPERATOR_VERSION}
+docker pull redislabs/k8s-controller:${OPERATOR_VERSION}
+docker tag redislabs/redis:${RS_VERSION} ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker tag redislabs/operator:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker tag redislabs/k8s-controller:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+```
+
+## Configure deployments to use a private container registry
+
+Once you push your images to your private container registry, you need to
+configure your deployments to use that registry for Redis Enterprise Software and operator
+deployments. The operator container image is configured directly by the operator deployment
+bundle. The Redis Enterprise cluster pod (RS and bootstrapper) and Service Rigger
+images are configured in the Redis Enterprise custom resource.
+
+Depending on your Kubernetes platform, your private container registry may
+require authentication. If you do need authentication, add a [pull secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) to your namespace. Then you'll need to configure Kubernetes and the operator to use the pull secret. The two following sections have examples of adding the `imagePullSecrets` to the operator deployment and `pullSecrets` to the cluster custom resource.
+
+### Specify the operator image source
+
+The operator bundle contains the operator deployment and the reference to the operator image (`redislabs/operator`). To use a private container registry, you must
+change this image reference in your operator deployment file **before** you deploy the operator. If you apply this change to modify an existing operator deployment, the operator's pod will restart.
+
+In the operator deployment file, 'containers:image' should point to the same repository and tag you used when [pushing]({{< relref "/operate/kubernetes/7.8.4/deployment/container-images.md#push-images-to-a-private-container-registry" >}}) to the private container registry:
+
+```sh
+${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+```
+
+The example below specifies a 7.2.4-7 operator image in a Google Container Registry:
+
+```YAML
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redis-enterprise-operator
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      name: redis-enterprise-operator
+  template:
+    metadata:
+      labels:
+        name: redis-enterprise-operator
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      containers:
+        - name: redis-enterprise-operator
+          image: gcr.io/yourproject/redislabs/operator:7.2.4-7
+...
+```
+
+If your container registry requires a pull secret, configure `imagePullSecrets` on the operator deployment:
+
+```YAML
+spec:
+  template:
+    spec:
+      imagePullSecrets:
+      - name: regcred
+```
+
+### Specify the Redis Enterprise cluster images source
+
+A Redis Enterprise cluster managed by the operator consists of three
+container images:
+
+* **`redislabs/redis`**: the Redis Enterprise Software container image
+* **`redislabs/operator`**: the bootstrapper is packaged within the operator container image
+* **`redislabs/k8s-controller`**: the Service Rigger container image
+
+By default, a new Redis Enterprise cluster is created using the
+container images listed above. These container images are pulled from the K8s cluster's default
+container registry.
+
+To [pull](https://docs.docker.com/engine/reference/commandline/pull/) the Redis Enterprise container images from
+a private container registry, you must specify them in the
+Redis Enterprise cluster custom resource.
+
+Add the following sections to the `spec` section of your RedisEnterpriseCluster resource file:
+
+ * **`redisEnterpriseImageSpec`**: controls the Redis Enterprise Software container image. *The version should match the RS version associated with the operator version*.
+ * **`bootstrapperImageSpec`**": controls the bootstrapper container image. *The version must match the operator version*.
+ * **`redisEnterpriseServicesRiggerImageSpec`**: controls the Service Rigger container image. *The version must match the operator version*.
+
+The REC custom resource example below pulls all three container images from a GCR private registry:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+If your private container registry requires pull secrets, you must add `pullSecrets`
+to the `spec` section:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  pullSecrets:
+    - name: regcred
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+## Rate limiting with DockerHub
+
+Docker has [rate limits for image pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/).
+Anonymous users are allowed a certain number of pulls every 6 hours. For authenticated users, the limit is larger.
+These rate limits may affect your Kubernetes cluster in a number of ways:
+
+* The cluster nodes will likely be treated as a single anonymous user.
+* The number of pulls during a deployment might exceed the rate limit for other deployment dependencies, including the operator, Redis Enterprise Software, or other non-Redis pods.
+* Pull failures may prevent your deployment from downloading the required images in a timely manner. Delays here can affect the stability of deployments used by the Redis Enterprise operator.
+
+For these reasons, you should seriously consider where your images
+are pulled from to **avoid failures caused by rate limiting**. The easiest solution
+is to push the required images to a private container registry under your control.
+---
+Title: Deploy Redis Enterprise Software for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to install Redis Enterprise Software for Kubernetes.
+linkTitle: Kubernetes
+weight: 10
+url: '/operate/kubernetes/7.8.4/deployment/quick-start/'
+---
+
+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]({{< relref "/operate/kubernetes/7.8.4/deployment/openshift" >}}). For details on what is currently supported, see [supported distributions]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions.md" >}}).
+
+## Prerequisites
+
+To deploy Redis Enterprise for Kubernetes, you'll need:
+
+- Kubernetes cluster in a [supported distribution]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions.md" >}})
+- minimum of three worker nodes
+- Kubernetes client (kubectl)
+- access to DockerHub, RedHat Container Catalog, or a private repository that can hold the required images.
+NOTE: If you are applying version 7.8.2-6 or above, check if the [OS](https://redis.io/docs/latest/operate/kubernetes/release-notes/7-8-2-releases/7-8-2-6-nov24/#breaking-changes) installed on the node is supported.
+
+### Create a new namespace
+
+**Important:** Each namespace can only contain one Redis Enterprise cluster. Multiple RECs with different operator versions can coexist on the same Kubernetes cluster, as long as they are in separate namespaces.
+
+Throughout this guide, each command is applied to the namespace in which the Redis Enterprise cluster operates.
+
+1. Create a new namespace
+
+    ```sh
+   kubectl create namespace <rec-namespace>
+   ```
+
+1. Change the namespace context to make the newly created namespace default for future commands.
+
+    ```sh
+    kubectl config set-context --current --namespace=<rec-namespace>
+   ```
+
+You can use an existing namespace as long as it does not contain any existing Redis Enterprise cluster resources. It's best practice to create a new namespace to make sure there are no Redis Enterprise resources that could interfere with the deployment.
+
+## Install the operator
+
+Redis Enterprise for Kubernetes bundle is published as a container image. A list of required images is available in the [release notes]({{< relref "/operate/kubernetes/release-notes/_index.md" >}}) for each version.
+
+The operator [definition and reference materials](https://github.com/RedisLabs/redis-enterprise-k8s-docs) are available on GitHub. The operator definitions are [packaged as a single generic YAML file](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/bundle.yaml).
+
+{{<note>}}
+If you do not pull images from DockerHub or another public registry, you need to use a [private container registry]({{< relref "/operate/kubernetes/7.8.4/deployment/container-images#manage-image-sources" >}}).
+{{</note>}}
+
+### Download the operator bundle
+
+Pull the latest version of the operator bundle:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+```
+
+  If you need a different release, replace `VERSION` with a specific release tag.
+
+  Check version tags listed with the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases) to ensure the version of the bundle is correct.
+
+### Deploy the operator bundle
+
+Apply the operator bundle in your REC namespace:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+  You should see a result similar to this:
+
+  ```sh
+  role.rbac.authorization.k8s.io/redis-enterprise-operator created
+  serviceaccount/redis-enterprise-operator created
+  rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+  customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+  customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+  deployment.apps/redis-enterprise-operator created
+  ```
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+#### Verify the operator is running
+
+Check the operator deployment to verify it's running in your namespace:
+
+```sh
+kubectl get deployment redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+## Create a Redis Enterprise cluster (REC)
+
+A Redis Enterprise cluster (REC) is created from a `RedisEnterpriseCluster` custom resource
+that contains cluster specifications.
+
+The following example creates a minimal Redis Enterprise cluster. See the [RedisEnterpriseCluster API reference]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}}) for more information on the various options available.
+
+1. Create a file that defines a Redis Enterprise cluster with three nodes.
+
+    {{<note>}}
+The REC name (`my-rec` in this example) cannot be changed after cluster creation.
+    {{</note>}}
+
+    ```sh
+    cat <<EOF > my-rec.yaml
+    apiVersion: "app.redislabs.com/v1"
+    kind: "RedisEnterpriseCluster"
+    metadata:
+      name: my-rec
+    spec:
+      nodes: 3
+    EOF
+    ```
+
+   This will request a cluster with three Redis Enterprise nodes using the default requests (i.e., 2 CPUs and 4GB of memory per node).
+
+   To test with a larger configuration, use the example below to add node resources to the `spec` section of your test cluster (`my-rec.yaml`).
+
+    ```sh
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: 2000m
+        memory: 16Gi
+      requests:
+        cpu: 2000m
+        memory: 16Gi
+    ```
+
+    {{<note>}}
+Each cluster must have at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+    See the [Redis Enterprise hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) for more information on sizing Redis Enterprise node resource requests.
+  
+1. Apply your custom resource file in the same namespace as `my-rec.yaml`.
+
+    ```sh
+    kubectl apply -f my-rec.yaml
+    ```
+
+   You should see a result similar to this:
+
+   ```sh
+   redisenterprisecluster.app.redislabs.com/my-rec created
+   ```
+
+1. You can verify the creation of the cluster with:
+
+    ```sh
+    kubectl get rec
+    ```
+
+    You should see a result similar to this:
+
+    ```sh
+    NAME           AGE
+    my-rec   1m
+    ```
+
+    At this point, the operator will go through the process of creating various services and pod deployments.
+
+    You can track the progress by examining the StatefulSet associated with the cluster:
+
+    ```sh
+    kubectl rollout status sts/my-rec
+    ```
+
+    or by looking at the status of all of the resources in your namespace:
+
+    ```sh
+    kubectl get all
+    ```
+
+## Enable the admission controller
+
+The admission controller dynamically validates REDB resources configured by the operator. It is strongly recommended that you use the admission controller on your Redis Enterprise Cluster (REC). The admission controller only needs to be configured once per operator deployment.
+
+As part of the REC creation process, the operator stores the admission controller certificate in a Kubernetes secret called `admission-tls`. You may have to wait a few minutes after creating your REC to see the secret has been created.
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to the relevant namespaces {#webhook}
+
+The operator bundle includes a webhook file. The webhook will intercept requests from all namespaces unless you edit it to target a specific namespace. You can do this by adding the `namespaceSelector` section to the webhook spec to target a label on the namespace.
+
+1. Make sure the namespace has a unique `namespace-name` label.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+       labels:
+        namespace-name: example-ns
+    name: example-ns
+    ```
+
+1. Patch the webhook to add the `namespaceSelector` section.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+        matchLabels:
+          namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    kubectl patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+## Verify the admission controller is working
+
+1. Verify the admission controller is installed correctly by applying an invalid resource. This should force the admission controller to correct it.
+
+    ```sh
+    kubectl apply -f - << EOF
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      evictionPolicy: illegal
+    EOF
+    ```
+
+    You should see your request was denied by the `admission webhook "redisenterprise.admission.redislabs"`.
+
+    ```sh
+    Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+    ```
+
+## Create a Redis Enterprise Database (REDB)
+
+You can create multiple databases within the same namespace as your REC or in other namespaces.
+
+See [manage Redis Enterprise databases for Kubernetes]({{< relref "/operate/kubernetes/7.8.4/re-databases/db-controller.md" >}}) to create a new REDB.
+---
+Title: Redis Enterprise Software deployment for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise is supported on OpenShift Kubernetes cluster deployments
+  via an operator.
+draft: true
+hidden: true
+hideListLinks: false
+weight: 60
+url: '/operate/kubernetes/7.8.4/deployment/openshift/old-index/'
+---
+
+Redis Enterprise is supported on OpenShift Kubernetes cluster deployments via
+an operator. The operator is a software component that runs in your
+deployment namespace and facilitates deploying and managing
+Redis Enterprise clusters.
+
+
+
+{{% comment %}}
+These are the steps required to set up a Redis Enterprise Software
+Cluster with OpenShift.
+
+Prerequisites:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.8/installing/index.html) at version 4.6 or higher, with at least three nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/hardware-requirements.md" >}})
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.8/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Step 1: Login
+
+- Log in to your OpenShift account as a super admin (so you have access to all the default projects).
+- Create a new project, fill in the name and other details for the project, and click **Create**.
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image1.png" >}}
+
+- Click on “admin” (upper right corner) and then “Copy Login.”
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image4.png" >}}
+
+- Paste the *login* command into your shell; it should look something like this:
+
+    ```sh
+    oc login https://your-cluster.acme.com –token=your$login$token
+    ```
+
+- Next, verify that you are using the newly created project. Type:
+
+    ```sh
+    oc project <your project name>
+    ```
+
+This will shift to your project rather than the default project (you can verify the project you’re currently using with the *oc project* command).
+
+## Step 2: Get deployment files
+
+Clone this repository, which contains the deployment files:
+
+```sh
+git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+```
+
+<!--
+{{< note >}}
+For RHEL images, please use the redis-enterprise-cluter_rhel.yaml and operator_rhel.yaml files.
+{{< /note >}}
+-->
+
+Specifically for the custom resource (cr) yaml file, you may also download and edit one of the files in the [example folder.](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/examples)  
+
+## Step 3: Prepare your yaml files
+
+Let’s look at each yaml file to see what requires editing:
+
+- [scc.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/scc.yaml)
+
+    The scc ([Security Context Constraint](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html)) yaml defines the cluster’s security context constraints, which we will apply to our project later on. We strongly recommend **not** changing anything in this yaml file.
+
+    Apply the file:
+
+    ```sh
+    oc apply -f scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io “redis-enterprise-scc” configured
+    ```
+
+    Now you need to bind the scc to your project by typing:
+
+    ```sh
+    oc adm policy add-scc-to-group redis-enterprise-scc  system:serviceaccounts:your_project_name
+    ```
+
+    (If you do not remember your project name, run “oc project”)
+
+- [openshift.bundle.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift.bundle.yaml) -
+
+    The bundle file includes several declarations:
+
+    1. rbac (Role-Based Access Control) defines who can access which resources. The Operator application requires these definitions to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). These include declaration of rules, role and rolebinding.
+    1. crd declaration, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next
+    1. operator deployment declaration, creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes, as pods. The yaml  contains the latest image tag representing the latest Operator version available.
+
+    This yaml should be applied as-is, without changes. To apply it:
+
+    ```sh
+    kubectl apply -f openshift.bundle.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    role.rbac.authorization.k8s.io/redis-enterprise-operator created
+    serviceaccount/redis-enterprise-operator created
+    rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+    customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+    deployment.apps/redis-enterprise-operator created
+    ```
+
+1. Now, verify that your redis-enterprise-operator deployment is running:
+
+    ```sh
+    kubectl get deployment -l name=redis-enterprise-operator
+    ```
+
+    A typical response will look like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+<!--
+[rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rbac.yaml)
+
+The rbac (Role-Based Access Control) yaml defines who can access which resources. We need this to allow our Operator application to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). Therefore, we strongly recommend **not** changing anything in this yaml file. To apply it, type:
+
+```sh
+kubectl apply -f rbac.yaml
+```
+
+You should receive the following response:
+
+`role.rbac.authorization.k8s.io/redis-enterprise-operator created
+serviceaccount/redis-enterprise-operator created
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created`
+-->
+
+ <!--> [sb_rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/sb_rbac.yaml)
+
+    If you’re deploying a service broker, also apply the sb_rbac.yaml file. The sb_rbac (Service Broker Role-Based Access Control) yaml defines the access permissions of the Redis Enterprise Service Broker.
+
+    We strongly recommend **not** changing anything in this yaml file.
+
+    To apply it, run:
+
+    ```sh
+    kubectl apply -f sb_rbac.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    clusterrole.rbac.authorization.k8s.io/redis-enterprise-operator-sb configured
+    clusterrolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+    ``` -->
+
+<!--
+- [crd.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/crd.yaml)
+
+The next step applies crd.yaml, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next. We strongly recommend **not** changing anything in this yaml file.
+
+To apply it, run:
+
+```sh
+kubectl apply -f crd.yaml
+```
+
+You should receive the following response:
+
+`customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com     configured`
+
+- [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml)
+
+Applying this yaml creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes (as pods).
+
+Always make sure you have the latest [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml). Alternatively, you can edit the following tag:
+image:redislabs/operator:tag
+
+To apply the operator.yaml, run:
+
+```sh
+kubectl apply -f operator.yaml
+```
+
+You should receive the following response:
+
+`deployment.apps/redis-enterprise-operator created`
+
+Now, run `kubectl get deployment` and verify that your redis-enterprise-operator deployment is running. A Typical response will look like this:
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image2.png" >}}
+
+- [redis-enterprise-cluster.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/redis-enterprise-cluster.yaml)
+-->
+
+- The [rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml) defines the configuration of the newly created resource: Redis Enterprise Cluster. This yaml could be renamed your_cluster_name.yaml to keep things tidy, but this isn’t a mandatory step.
+
+    This yaml can be edited to the required use case, however, the sample provided can be used for test/dev and quick start purposes. Here are the main fields you may review and edit:
+
+    - name: “your_cluster_name” (e.g. “demo-cluster”)
+    - nodes: number_of_nodes_in_the_cluster (Must be an uneven number of at least 3 or greater—[here’s why](https://redislabs.com/redis-enterprise/technology/highly-available-redis/))
+    - uiServiceType: service_type
+
+        Service type value can be either ClusterIP or LoadBalancer. This is an optional configuration based on [k8s service types](https://kubernetes.io/docs/tutorials/kubernetes-basics/expose/expose-intro/). The default is ClusterIP.
+
+    - storageClassName: “<span style="color: #ff0000;">gp2</span>“
+
+        This specifies the [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/) used for your nodes’ persistent disks. For example, AWS uses “gp2” as a default, GKE uses “standard” and Azure uses "default").
+
+    - redisEnterpriseNodeResources: The [compute resources](https://docs.openshift.com/enterprise/3.2/dev_guide/compute_resources.html#dev-compute-resources) required for each node.
+    - limits – specifies the max resources for a Redis node
+    - requests – specifies the minimum resources for a Redis node
+
+        For example:
+
+        ```sh
+        limits
+        cpu: “4000m”
+        memory: 4Gi
+        requests
+
+        cpu: “4000m”
+        memory: 4Gi
+        ```
+
+        The default (if unspecified) is 4 cores (4000m) and 4GB (4Gi).
+
+        {{< note >}}
+Resource limits should equal requests ([Learn why](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/topics.md#guaranteed-quality-of-service)).
+        {{< /note >}}
+
+    - serviceBrokerSpec –
+    - enabled: \<false/true\>
+
+        This specifies [persistence](https://redislabs.com/redis-features/persistence) for the Service Broker with an “enabled/disabled” flag. The default is “false.”
+
+        persistentSpec:
+        storageClassName: “gp2“
+
+    - redisEnterpriseImageSpec: This configuration controls the Redis Enterprise version used, and where it is fetched from. This is an optional field. The Operator will automatically use the matching RHEL image version for the release.
+
+        [imagePullPolicy](https://docs.openshift.com/enterprise/3.0/architecture/core_concepts/builds_and_image_streams.html#image-pull-policy):
+        IfNotPresent
+        Repository: redislabs/redis
+        versionTag: 5.2.10-22
+
+        The version tag, as it appears on your repository (e.g. on [DockerHub](https://hub.docker.com/r/redislabs/redis/)).
+
+## Step 4: Create your cluster
+
+Once you have your_cluster_name yaml set, you need to apply it to create your Redis Enterprise Cluster:
+
+```sh
+kubectl apply -f your_cluster_name.yaml
+```
+
+Run kubectl get rec and verify that creation was successful (rec is a shortcut for “RedisEnterpriseClusters”).
+
+You should receive a response similar to the following:
+
+```sh
+NAME AGE
+
+Your_cluster_name 17s
+```
+
+Your Cluster will be ready shortly, typically within a few minutes.
+
+To check the cluster status, type the following:
+
+```sh
+kubectl get pod
+```
+
+You should receive a response similar to the following:
+
+|                                    |       |         |          |     |
+| ---------------------------------- | ----- | ------- | -------- | --- |
+| NAME                               | READY | STATUS  | RESTARTS | AGE |
+| your_cluster_name-0              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-1              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-2              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-controller-x-x | 1/1   | Running | 0        | 1m  |
+| Redis-enterprise-operator-x-x      | 1/1   | Running | 0        | 5m  |
+
+Next, create your databases.
+
+## Step 5: Create a database
+
+In order to create your database, we will log in to the Redis Enterprise UI.
+
+- First, apply port forwarding to your Cluster:
+
+    ```sh
+    kubectl port-forward your_cluster_name-0 8443:8443
+    ```
+
+    {{< note >}}
+- your_cluster_name-0 is one of your cluster pods. You may consider running the port-forward command in the background.
+- The Openshift UI provides tools for creating additional routing options, including external routes. These are covered in [RedHat Openshift documentation](https://docs.openshift.com/container-platform/3.11/dev_guide/routes.html).
+    {{< /note >}}
+
+    Next, create your database.
+
+- Open a browser window and navigate to localhost:8443
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image5.png" >}}
+
+- In order to retrieve your password, navigate to the OpenShift management console, select your project name, go to    Resources-\>Secrets-\>your_cluster_name
+- Retrieve your password by selecting “Reveal Secret.”
+
+    {{< warning >}}
+Do not change the default admin user password in the Redis Enterprise admin console.
+Changing the admin password impacts the proper operation of the K8s deployment.
+    {{< /warning >}}
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image3.png" >}}
+
+- Follow the interface’s [instructions to create your database]({{< relref "/operate/rs/administering/creating-databases/_index.md" >}}).
+
+{{< note >}}
+In order to conduct the Ping test through Telnet, you can create a new route to the newly created database port in the same way as described above for the UI port. After you create your database, go to the Openshift management console, select your project name and go to Applications-\>Services. You will see two newly created services representing the database along with their IP and port information, similar to the screenshot below.
+{{< /note >}}
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image6.png" >}}
+
+{{% /comment %}}
+---
+Title: Deploy Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: OpenShift provides the OperatorHub where you can install the Redis Enterprise
+  operator from the administrator user interface.
+linkTitle: OpenShift OperatorHub
+weight: 70
+url: '/operate/kubernetes/7.8.4/deployment/openshift/openshift-operatorhub/'
+---
+
+You can deploy Redis Enterprise for Kubernetes from the Red Hat OpenShift CLI. You can also use a UI, [OperatorHub](https://docs.openshift.com/container-platform/4.11/operators/index.html) (Red Hat) to install operators and create custom resources.
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}).
+
+## Install the Redis Enterprise operator
+
+{{<warning>}} If using version 6.2.18-41 or earlier, [Install the security context constraint](#install-security-context-constraint) before installing the operator. {{</warning>}}
+
+1. Select **Operators > OperatorHub**.
+
+2. Search for _Redis Enterprise_ in the search dialog and select the **Redis Enterprise Operator provided by Redis** marked as **Certified**.
+
+    By default, the image is pulled from Red Hat's registry.
+
+3. On the **Install Operator** page, specify the namespace for the operator.
+
+    Only one namespace per operator is supported.
+
+4. Update the **channel** with the version you're installing.
+
+    For more information about specific versions, see the [release notes]({{< relref "/operate/kubernetes/release-notes/" >}}).
+
+5. Choose an approval strategy.
+
+    Use **Manual** for production systems to ensure the operator is only upgraded by approval.
+
+6. Select **Install** and approve the install plan.
+
+   You can monitor the subscription status in **Operators > Installed Operators**.
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+{{<warning>}}
+ Before creating any clusters, install the security context constraint (SCC) for the operator in [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+{{</warning>}}
+
+You only need to install the SCC once, but you must not delete it.
+
+1. Select the project you'll be using or create a new project.
+
+1. Download [`scc.yaml`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+
+1. Apply the file to install the security context constraint.
+
+  ```sh
+  oc apply -f scc.yaml
+  ```
+
+After the install, the OperatorHub automatically uses the constraint for Redis Enterprise node pods.
+
+{{< note >}}
+If you are using the recommended RedisEnterpriseCluster name of `rec`, the SCC is automatically bound to the RedisEnterpriseCluster after install.
+
+If you choose a different name for the RedisEnterpriseCluster, or override the default service account name, you must manually bind the SCC to the RedisEnterpriseCluster’s service account:
+
+  ```sh
+  oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-service-account-name>
+  ```
+
+{{< /note >}}
+
+## Create Redis Enterprise custom resources
+
+The **Installed Operators**->**Operator details** page shows the provided APIs: **RedisEnterpriseCluster** and **RedisEnterpriseDatabase**. You can select **Create instance** to create custom resources using the OperatorHub interface.
+
+Use the YAML view to create a custom resource file or let OperatorHub generate the YAML file for you by specifying your configuration options in the form view.
+
+<note> The REC name cannot be changed after cluster creation.</note>
+
+{{<note>}} In versions 6.4.2-4 and 6.4.2-5, REC creation might fail when using the form view due to an error related to the cluster level LDAP. To avoid this, use the YAML view.
+{{</note>}}
+
+For more information on creating and maintaining Redis Enterprise custom resources, see [Redis Enterprise clusters (REC)]({{< relref "/operate/kubernetes/7.8.4/re-clusters/" >}}) and [Redis Enterprise databases (REDB)]({{< relref "/operate/kubernetes/7.8.4/re-databases/" >}}).
+---
+Title: Deployment with OpenShift CLI for Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes and cluster can be installed via CLI
+  tools OpenShift
+linkTitle: OpenShift CLI
+weight: 60
+url: '/operate/kubernetes/7.8.4/deployment/openshift/openshift-cli/'
+---
+Use these steps to set up a Redis Enterprise Software cluster with OpenShift.
+
+## Prerequisites
+
+- [OpenShift cluster](https://docs.openshift.com/container-platform/4.8/installing/index.html) with at least 3 nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}))
+- [OpenShift CLI](https://docs.openshift.com/container-platform/latest/cli_reference/openshift_cli/getting-started-cli.html)
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}).
+
+## Deploy the operator
+
+1. Create a new project.
+
+    ```sh
+    oc new-project <your-project-name> 
+    ```
+
+1. Verify the newly created project. 
+
+    ```sh
+    oc project <your-project-name>
+    ```
+
+1. Get the deployment files.
+
+    ```sh
+    git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+    ```
+
+1. Deploy the OpenShift operator bundle.
+
+    If you are using version 6.2.18-41 or earlier, you must [apply the security context constraint](#install-security-context-constraint) before the operator bundle.
+
+    ```sh
+    oc apply -f openshift.bundle.yaml
+    ```
+
+    {{< warning >}}
+Changes to the `openshift.bundle.yaml` file can cause unexpected results.
+    {{< /warning >}}
+
+1. Verify that your `redis-enterprise-operator` deployment is running.
+
+    ```sh
+    oc get deployment
+    ```
+
+    A typical response looks like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+    {{<warning>}}
+DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).
+    {{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+1. Apply the file `scc.yaml` file.
+
+   {{<warning>}}
+Do not edit this file.
+    {{</warning>}}
+
+    ```sh
+    oc apply -f openshift/scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io "redis-enterprise-scc-v2" configured
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Provide the operator permissions for the pods.
+
+    ```sh
+    oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+      system:serviceaccount:<my-project>:<rec>
+    ```
+
+    {{<note>}}
+If you are using version 6.2.18-41 or earlier, add additional permissions for your cluster.
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc \
+system:serviceaccount:<my-project>:redis-enterprise-operator
+```
+{{</note>}}
+
+  You can check the name of your project using the `oc project` command. To replace the project name, use `oc edit project myproject`. Replace `rec` with the name of your Redis Enterprise cluster, if different.
+
+## Create a Redis Enterprise cluster custom resource
+
+1. Apply the `RedisEnterpriseCluster` resource file ([rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml)).
+
+    You can rename the file to `<your_cluster_name>.yaml`, but it is not required. Examples below use `<rec_rhel>.yaml`. [Options for Redis Enterprise clusters]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api" >}}) has more info about the Redis Enterprise cluster (REC) custom resource, or see the [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}}) for a full list of options.
+
+    The REC name cannot be changed after cluster creation.
+
+    {{<note>}}
+Each Redis Enterprise cluster requires at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+2. Apply the custom resource file to create your Redis Enterprise cluster.
+
+    ```sh
+    oc apply -f <rec_rhel>.yaml
+    ```
+
+    The operator typically creates the REC within a few minutes.
+
+1. Check the cluster status.
+
+    ```sh
+    oc get pod
+    ```
+
+    You should receive a response similar to the following:
+
+    ```sh
+     NAME                             | READY | STATUS  | RESTARTS | AGE |
+    | -------------------------------- | ----- | ------- | -------- | --- |
+    | rec-name-0              | 2/2   | Running | 0        | 1m  |
+    | rec-name-1              | 2/2   | Running | 0        | 1m  |
+    | rec-name-2              | 2/2   | Running | 0        | 1m  |
+    | rec-name-controller-x-x | 1/1   | Running | 0        | 1m  |
+    | Redis-enterprise-operator-x-x    | 1/1   | Running | 0        | 5m  |
+    ```
+
+## Configure the admission controller
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to relevant namespaces
+
+If not limited, the webhook intercepts requests from all namespaces. If you have several REC objects in your Kubernetes cluster, limit the webhook to the relevant namespaces. If you aren't using multiple namespaces, skip this step.
+
+1. Verify your namespace is labeled and the label is unique to this namespace, as shown in the next example.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+      labels:
+       namespace-name: staging
+    name: staging
+    ```
+
+1. Patch the webhook spec with the `namespaceSelector` field.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+       matchLabels:
+         namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    oc patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+    {{<note>}}
+For releases before 6.4.2-4, use this command instead:
+
+```sh
+oc patch ValidatingWebhookConfiguration \
+  redb-admission --patch "$(cat modified-webhook.yaml)"
+```
+
+The 6.4.2-4 release introduces a new `ValidatingWebhookConfiguration` to replace `redb-admission`. See the [6.4.2-4 release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/" >}}).
+    {{</note>}}
+
+### Verify admission controller installation
+
+Apply an invalid resource as shown below to force the admission controller to reject it. If it applies successfully, the admission controller is not installed correctly.
+
+```sh
+oc apply -f - << EOF
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: redis-enterprise-database
+spec:
+  evictionPolicy: illegal
+EOF
+```
+
+You should see this error from the admission controller webhook `redisenterprise.admission.redislabs`.
+  
+```sh
+Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+```
+
+## Create a Redis Enterprise database custom resource
+
+The operator uses the instructions in the Redis Enterprise database (REDB) custom resources to manage databases on the Redis Enterprise cluster.
+
+1. Create a `RedisEnterpriseDatabase` custom resource.
+
+    This example creates a test database. For production databases, see [create a database]({{< relref "/operate/kubernetes/7.8.4/re-databases/db-controller.md#create-a-database" >}}) and [RedisEnterpriseDatabase API reference]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api" >}}).
+
+    ```sh
+    cat << EOF > /tmp/redis-enterprise-database.yml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      memorySize: 100MB
+    EOF
+    ```
+
+1. Apply the newly created REDB resource.
+
+    ```sh
+    oc apply -f /tmp/redis-enterprise-database.yml
+    ```
+
+## More info
+
+- [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api">}})
+- [Redis Enterprise database API]({{<relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api">}})
+---
+Title: Deploy Redis Enterprise for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A quick introduction to the steps necessary to get a Redis Enterprise
+  cluster installed in your OpenShift Kubernetes cluster
+hideListLinks: true
+linkTitle: OpenShift
+weight: 11
+url: '/operate/kubernetes/7.8.4/deployment/openshift/'
+---
+The deployment of Redis Enterprise clusters is managed with the Redis Enterprise operator that you deploy in the namespace for your project.
+To create a database that your application
+workloads can use:
+
+1. Install the Redis Enterprise operator.
+
+1. Create a Redis Enterprise CRD to describe your desired cluster.
+
+1. The operator reads this cluster description and deploys the various components on your K8s cluster.
+
+1. Once running, use the Redis Enterprise cluster to create a database.
+
+1. The operator automatically exposes the new database as a K8s service.
+
+## For OpenShift via the OperatorHub
+
+To [create a database on an OpenShift 4.x cluster via the OperatorHub]({{< relref "/operate/kubernetes/7.8.4/deployment/openshift/openshift-operatorhub" >}}) you only need to have the [OpenShift 4.x cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## For OpenShift via the CLI
+
+To [create a database on an OpenShift cluster via the CLI]({{< relref "/operate/kubernetes/7.8.4/deployment/openshift/openshift-cli.md" >}}), you need:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.2/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Version compatibility
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}).
+---
+Title: Getting Started with Active-Active (CRDB) on OpenShift with Route-Based Ingress
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+draft: true
+hidden: true
+weight: $weight
+url: '/operate/kubernetes/7.8.4/deployment/openshift/old-getting-started-openshift-crdb/'
+---
+In this guide, we'll set up an [Active-Active database]({{< relref "/operate/rs/databases/active-active/_index.md" >}})
+(formerly known as CRDB) deployment with Active-Active replication
+spanning across two Redis Enterprise clusters over OpenShift, using Redis Enterprise Operator
+and OpenShift Route.
+
+## Overview
+
+An Active-Active deployment requires connectivity between different Kubernetes clusters.
+A router is the most common way to allow such external access. A [router]
+(https://docs.openshift.com/container-platform/3.5/architecture/core_concepts/routes.html#architecture-core-concepts-routes)
+is configured to accept requests external to the cluster and proxy them into the
+cluster based on how the route is configured. Routes are limited to HTTP/HTTPS(SNI)/TLS(SNI),
+which covers web applications.
+
+Typically, a Kubernetes cluster administrator configures a [DNS wildcard entry]
+(https://docs.openshift.com/container-platform/3.9/install_config/install/prerequisites.html#prereq-dns)
+that resolves to an OpenShift Container Platform node that is running
+the OpenShift router.
+
+The default router in OpenShift is HAProxy, which is a free, fast, and reliable solution
+offering high availability, load balancing, and proxying for TCP and HTTP-based applications.
+
+The Redis Enterprise Operator uses the routes mechanism to expose 2 inter-cluster services:
+the Redis Enterprise Cluster API service and the DB service that exposes the Active-Active database.
+Both services are used during the creation and management of an Active-Active deployment.
+The routes are configured with TLS passthrough.
+
+{{< note >}}
+Routes should have unique hostnames across a Kubernetes cluster.
+{{< /note >}}
+
+## Steps for creating an Active-Active deployment with Service Broker
+
+Before you create an Active-Active deployment with Service Broker, you must create a cluster
+using the REC custom resource, with a Service Broker deployment as covered in
+[Getting Started with Kubernetes and Openshift]({{< relref "/operate/platforms/openshift/_index.md" >}}), while noting the following:
+
+1. Make sure you use the latest versions of the deployment files available on GitHub.
+1. Deploy nodes with at least 6GB of RAM in order to accommodate the Active-Active database plan's 5GB database size.
+1. Make sure you follow the instructions to deploy the Redis Enterprise Service Broker.
+
+The peerClusters section in the spec is used for creating an Active-Active with the Service Broker.
+
+{{< note >}}
+This is only relevant for OpenShift deployments, which support Service Brokers natively.
+{{< /note >}}
+
+Copy this section of the REC spec and modify it for your environment. To apply it
+to every cluster that will participate in the Active-Active database deployment, edit the cluster yaml file
+and apply it using `kubectl apply -f <cluster.yaml>`:
+
+```yaml
+   activeActive:
+    apiIngressUrl:  api1.cluster1.<openshift.department.organization.com>
+    dbIngressSuffix: -cluster1.<openshift.department.organization.com>
+     method: openShiftRoute
+
+     peerClusters:
+      - apiIngressUrl:  api2.cluster2.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster2.<openshift.department.organization.com>
+        fqdn: <cluster2_name>.<cluster2_namespace>.svc.cluster.local
+      - apiIngressUrl:  api3.cluster3.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster3.<openshift.department.organization.com>
+        fqdn: <cluster3_name>.<cluster3_namespace>.svc.cluster.local
+```
+
+This block is added to the Service Broker config map when the REC spec changes, and
+it triggers a restart of the Service Broker pod to pass the peer clusters configuration
+to the service broker. Once the Service Broker pod restarts, you can select the
+Active-Active database plan from the OS service catalog UI.
+
+The elements of the section are:
+
+- **apiIngressUrl** - The OpenShift hostname that is created using OpenShift route.
+
+- **dbIngressSuffix** - The suffix of the db route name. The resulting host is
+`<db-name><db ingress suffix>`. This is used by the Redis Enterprise Syncer to
+sync data between the databases.
+
+- **fqdn** - The FQDN of the Kubernetes cluster where the pattern is `<cluster_name>.
+<cluster_namespace>.svc.cluster.local`. (Remember that the RS cluster name is set in the REC spec).
+
+- **authSecret** - The Kubernetes secret name that contains the username and password
+to access this cluster.
+
+We need to create a secret to reference from authSecret based on the cluster admin credentials
+that were automatically created when the clusters were created. To do this,
+repeat the following process for each of the clusters involved:
+
+1. Login to the OpenShift cluster where your Redis Enterprise Cluster (REC) resides.
+1. To find the secret that holds the REC credentials, run: `kubectl get secrets`
+	
+	From the secrets listed, you’ll find one that is named after your REC and
+	of type Opaque, like this:
+
+	```sh
+	redis-enterprise-cluster            Opaque                  3       1d
+	```
+
+1. Copy the hashed password and username from the file and create a yaml file
+with that information in the following format:
+
+	```yaml
+	apiVersion: v1
+	kind: Secret
+	metadata:
+		name: crdb1-cred
+	type: Opaque
+	data:
+		password: NWhYRWU2OWQ=
+		username: YWRtaW5AYWNtZS5jb20=
+	```
+
+1. Deploy the newly created secret yaml file in the other clusters:
+
+	```sh
+	$ kubectl create -f crdb1-secret.yaml
+	```
+
+	A typical response looks like:
+
+	```
+	secret/crdb1-cred created
+	```
+
+1. Repeat the process for the other clusters until each cluster has a secret
+with the credentials of the other clusters.
+
+After applying the update cluster deployment file, the Service Broker is redeployed
+to apply the changes to the config map.
+
+Now, proceed to the Openshift web console.
+
+1. From the left menu, select a project that holds one of your configured clusters and
+then select **Add to Project > Browse Catalog**.
+
+	{{< image filename="/images/rs/openshift-crdb-catalog.png" >}}
+
+1. Find the **Redis Enterprise [Project Name:Cluster Name]** tile and double-click it to start the wizard.
+
+	{{< image filename="/images/rs/openshift-crdb-information.png" >}}
+
+1. Click **Next** in the Information step.
+
+	{{< image filename="/images/rs/openshift-crdb-plan.png" >}}
+
+1. Then, to deploy an Active-Active database on the clusters you’ve previously configured,
+select the **geo-distributed-redis** plan radio button and click **Next**.
+
+	{{< image filename="/images/rs/openshift-crdb-configuration.png" >}}
+
+1. Click **Next** on the Configuration step, choose a binding option in the Binding step,
+and click **Create**.
+
+	{{< image filename="/images/rs/openshift-crdb-binding.png" >}}
+
+The Active-Active database connected databases are now created with the specified binding, if you selected a binding.
+
+{{< image filename="/images/rs/openshift-crdb-results.png" >}}
+
+You can view the binding by following the link to the secret.
+
+{{< image filename="/images/rs/openshift-crdb-secret.png" >}}
+
+## Validating Active-Active database deployment
+
+To do a basic validation test of database replication:
+
+1. Connect to one of the cluster pods using the following command:
+
+	```sh
+	oc exec -it <your-cluster1-name>-0 bash
+	```
+
+1. At the prompt, launch the redis CLI:
+
+	```sh
+	$ redis-cli -h <your database1 hostname> -p <your database1 port> -a <your database1 password>
+	```
+
+1. Set some values and verify they have been set:
+
+	```sh
+	> set keymaster Vinz
+	OK
+	> set gatekeeper Zuul
+	OK
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+
+1. Now, exit the CLI and the pod execution environment and login to the synched database
+on the other cluster.
+
+	```sh
+	oc exec -it <your-cluster2-name>-0 bash
+	$redis-cli -h <your database2 hostname> -p <your database2 port> -a <your database2 password>
+	```
+
+1. Retrieve the values you previously set or continue manipulating key:value pairs
+and observe the 2-way synchronization, for example:
+
+	```sh
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+---
+Title: Deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section lists the different ways to set up and run Redis Enterprise
+  for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem
+  and in the cloud via our Redis Enterprise operator for Kubernetes.
+hideListLinks: false
+linkTitle: Deployment
+weight: 11
+url: '/operate/kubernetes/7.8.4/deployment/'
+---
+
+This section lists the different ways to set up and run Redis Enterprise for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem and in the cloud via our Redis Enterprise operator for Kubernetes.
+
+## Compatibility
+
+Before installing, check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.4/reference/supported_k8s_distributions" >}}) to see which Redis Enterprise operator version supports your Kubernetes distribution.
+
+
+---
+Title: Manage Redis Enterprise databases for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section describes how the database controller provides the ability
+  to create, manage, and use databases via a database custom resource.
+linkTitle: Manage databases
+weight: 5
+url: '/operate/kubernetes/7.8.4/re-databases/db-controller/'
+---
+## 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.
+
+The database controller in Redis Enterprise for Kubernetes:
+
+- Discovers the custom resource
+- Makes sure the REDB is created in the same namespace as the Redis Enterprise cluster (REC)
+- Maintains consistency between the custom resource and the REDB
+
+The database controller recognizes the new custom resource and validates the specification.
+If valid, the controller combines the values specified in
+the custom resource with default values to create a full specification. It then uses this full specification to create the
+database on the specified Redis Enterprise cluster (REC).
+
+Once the database is created, it is exposed with the same service mechanisms by the service rigger for the Redis Enterprise cluster.
+If the database [custom resource is deleted]({{< relref "/operate/kubernetes/7.8.4/re-clusters/delete-custom-resources" >}}), the database and its services are deleted from the cluster.
+
+### Flexible deployment options
+
+Databases in multiple namespaces can be managed by the same operator. To learn more, see [Manage databases in multiple namespaces]({{<relref "/operate/kubernetes/7.8.4/re-clusters/multi-namespace">}}).
+
+To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/7.8.4/architecture/deployment-options.md" >}}).
+
+## Create a database
+
+Your Redis Enterprise database custom resource must be of the `kind: RedisEnterpriseDatabase` and have values for `name` and `memorySize`. All other values are optional and will be defaults if not specified.
+
+1. Create a file (in this example mydb.yaml) that contains your database custom resource.
+
+    ```YAML
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: mydb
+    spec:
+      memorySize: 1GB
+    ```
+
+    To create a REDB in a different namespace from your REC, you need to specify the cluster with `redisEnterpriseCluster` in the `spec` section of your RedisEnterpriseDatabase custom resource.
+
+     ```YAML
+     redisEnterpriseCluster:
+       name: rec
+     ```
+
+1. Apply the file in the namespace you want your database to be in.
+
+    ```sh
+    kubectl apply -f mydb.yaml
+    ```
+
+1. Check the status of your database.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready to use.
+
+## Modify a database
+
+The custom resource defines the properties of the database.
+To change the database, you can edit your original specification and apply the change or use `kubectl edit`.
+
+To modify the database:
+
+1. Edit the definition:
+
+    ```sh
+    kubectl edit redb mydb
+    ```
+
+1. Change the specification (only properties in `spec` section) and save the changes.  
+    For more details, see [RedisEnterpriseDatabaseSpec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#redisenterprisedatabasespec) or [Options for Redis Enterprise databases]({{< relref "/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api" >}}). 
+
+1. Monitor the status to see when the changes take effect:
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready for use.
+
+## Delete a database
+
+The database exists as long as the custom resource exists.
+If you delete the custom resource, the database controller deletes the database.
+The database controller removes the database and its services from the cluster.
+
+To delete a database, run:
+
+```sh
+kubectl delete redb mydb
+```
+
+## Connect to a database
+
+After the database controller creates a database, the services for accessing the database are created in the same namespace. By default there are two services, one 'ClusterIP' service and one 'headless' service.  
+Connection information for the database is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/) maintained by the database controller. This secret contains:
+
+- The database port (`port`)
+- A comma separated list of service names (`service_names`)
+- The database password for authenticating (`password`)
+
+The name of that secret is stored in the database custom resource.
+
+{{<note>}}
+Use these steps to connect to your database from within your K8s cluster. To access your database from outside the K8s cluster, set up the [Ingress]({{< relref "/operate/kubernetes/7.8.4/networking/ingress.md" >}}) controller or use OpenShift routes.
+{{</note>}}
+
+1. Retrieve the secret name.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.spec.databaseSecretName}"
+    ```
+
+      The database secret name usually takes the form of `redb-<database_name>`, so in our example it will be `redb-mydb`.
+
+1. Retrieve and decode the password.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.password}" | base64 --decode
+    ```
+
+1. Retrieve and decode the port number.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.port}" | base64 --decode
+    ```
+
+1. Retrieve and decode the service_names.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.service_names}" | base64 --decode
+    ```
+
+    You'll need to pick just one service listed here to use for connecting.
+
+1. From a pod within your cluster, use `redis-cli` to connect to your database.
+
+    ```sh
+    redis-cli -h <service_name> -p <port>
+    ```
+
+1. Enter the password you retrieved from the secret.
+
+    ```sh
+    auth <password>
+    ```
+
+    You are now connected to your database!
+---
+Title: Create replica databases on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to create and automate database replicas using the database controller
+linkTitle: Create replica databases
+weight: 42
+url: '/operate/kubernetes/7.8.4/re-databases/replica-redb/'
+---
+
+You can configure a replica of a database by creating an item in
+the [`replicaSources`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#specreplicasources" >}}) 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:
+
+```yaml
+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.
+
+A replica of database CR simply uses the secret in the `replicaSources` section:
+
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+   name: name-of-replica
+spec:
+   redisEnterpriseCluster:
+      name: name-of-cluster
+   replicaSources:
+   - replicaSourceType: SECRET
+     replicaSourceName: my-replica-source
+```
+
+In the above, `name-of-replica` database will be created as a replica of the
+source database as long as the source database exists on the source cluster
+and the secret contains the correct replica source URL for that database.
+
+## Retrieving the replica source URL via kubectl
+
+You will need `kubectl`, `curl`, and `jq` installed for this procedure.
+
+1. Set your metadata:
+
+   ```js
+   CLUSTER_NAME=test
+   SOURCE_DB=db1
+   TARGET_DB=db2
+   TARGET_CLUSTER_NAME=test
+   ```
+
+1. Retrieve the cluster authentication:
+
+   ```js
+   CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+   CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+   ```
+
+1. Forward the port of the REST API service for your source cluster:
+
+   ```sh
+   kubectl port-forward pod/${CLUSTER_NAME}-0 9443
+   ```
+
+1. Request the information from the REST API:
+
+   ```js
+   JQ='.[] | select(.name=="'
+   JQ+="${SOURCE_DB}"
+   JQ+='") | ("redis://admin:" + .authentication_admin_pass + "@"+.name+":"+(.endpoints[0].port|tostring))'
+   URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://localhost:9443/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+   ```
+
+   Note: URI now contains the replica source URI.
+
+1. Construct the secret for the replica:
+
+   ```yaml
+   cat << EOF > secret.yaml
+   apiVersion: v1
+   kind: Secret
+   metadata:
+     name: ${SOURCE_DB}-url
+   stringData:
+     uri: ${URI}
+   EOF
+   kubectl apply -f secret.yaml
+   ```
+
+1. Create the replica database:
+
+   ```yaml
+   cat << EOF > target.yaml
+   apiVersion: app.redislabs.com/v1alpha1
+   kind: RedisEnterpriseDatabase
+   metadata:
+     name: ${TARGET_DB}
+   spec:
+     redisEnterpriseCluster:
+       name: ${TARGET_CLUSTER_NAME}
+     replicaSources:
+     - replicaSourceType: SECRET
+       replicaSourceName: ${SOURCE_DB}-url
+   EOF
+   kubectl apply -f target.yaml
+   ```
+
+## Automating the creation via a job
+
+The following procedure uses a ConfigMap and a Job to construct the replica
+source URL secret from the source database and configure the target database.
+
+There are four parameters:
+
+- `source` - the name of the source database
+- `cluster` - the name of the cluster for the source database
+- `target` - the name of the target database
+- `targetCluster` - the name of the cluster for the target database
+
+These parameters can be set by:
+
+```sh
+kubectl create configmap replica-of-database-parameters \
+--from-literal=source=name-of-source \
+--from-literal=cluster=name-of-cluster \
+--from-literal=target=name-of-target \
+--from-literal=targetCluster=name-of-cluster
+```
+
+where "name-of-..." is replaced with the database source, source cluster,
+database target, and target cluster names.
+
+The Job and ConfigMap below, when submitted, will create the secret and
+replica database:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: replica-of-database
+spec:
+  backoffLimit: 4
+  template:
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      restartPolicy: Never
+      volumes:
+        - name: scripts
+          configMap:
+            name: replica-of-database
+      containers:
+        - name: createdb
+          image: debian:stable-slim
+          env:
+            - name: MY_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+            - name: SCRIPT
+              value: create.sh
+            - name: SOURCE_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: source
+            - name: TARGET_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: target
+            - name: CLUSTER_SERVICE
+              value: .svc.cluster.local
+            - name: CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: cluster
+            - name: CLUSTER_PORT
+              value: "9443"
+            - name: TARGET_CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: targetCluster
+          volumeMounts:
+            - mountPath: /opt/scripts/
+              name: scripts
+          command:
+            - /bin/bash
+            - -c
+            - |
+              apt-get update; apt-get install -y curl jq apt-transport-https gnupg2
+              apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6A030B21BA07F4FB
+              curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
+              echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list
+              apt-get update
+              apt-get install -y kubectl
+              bash /opt/scripts/$SCRIPT
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: replica-of-database
+data:
+  create.sh: |
+    CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+    CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+    CLUSTER_HOST=${CLUSTER_NAME}.${MY_NAMESPACE}${CLUSTER_SERVICE}
+    JQ='.[] | select(.name=="'
+    JQ+="${SOURCE_DB}"
+    JQ+='") | ("redis://admin:" +  .authentication_admin_pass + "@"+.endpoints[0].dns_name+":"+(.endpoints[0].port|tostring))'
+    URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://${CLUSTER_HOST}:${CLUSTER_PORT}/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+    echo "URL: ${URL}"
+    echo ""
+    cat << EOF > /tmp/secret.yaml
+    apiVersion: v1
+    kind: Secret
+    metadata:
+      name: ${SOURCE_DB}-url
+    stringData:
+      uri: ${URI}
+    EOF
+    cat /tmp/secret.yaml
+    cat << EOF > /tmp/target.yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: ${TARGET_DB}
+    spec:
+      redisEnterpriseCluster:
+        name: ${TARGET_CLUSTER_NAME}
+      replicaSources:
+      - replicaSourceType: SECRET
+        replicaSourceName: ${SOURCE_DB}-url
+    EOF
+    echo "---"
+    cat /tmp/target.yaml
+    echo ""
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/secret.yaml
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/target.yaml
+```
+---
+Title: Redis Enterprise databases (REDB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise databases (REDBs).
+hideListLinks: false
+linkTitle: Redis Enterprise databases (REDB)
+weight: 31
+url: '/operate/kubernetes/7.8.4/re-databases/'
+---
+
+This section contains articles to help you manage your Redis Enterprise databases (REDBs).
+
+
+
+---
+title: RedisEnterpriseDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REDB API
+weight: 30
+aliases: [ /operate/kubernetes/reference/db-options, ]
+url: '/operate/kubernetes/7.8.4/reference/redis_enterprise_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseDatabase is the Schema for the redisenterprisedatabases API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettings">alertSettings</a></td>
+        <td>object</td>
+        <td>
+          Settings for database alerts<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with database. Note - For Active-Active databases this feature is currently in preview. For this feature to take effect for Active-Active databases, set a boolean environment variable with the name "ENABLE_ALPHA_FEATURES" to True. This variable can be set via the redis-enterprise-operator pod spec, or through the operator-environment-config Config Map. Note - if you do not want to upgrade to the latest version you must set upgradeSpec -> upgradeModulesToLatest to false. if you specify a version and do not set the upgradeModulesToLatest it can result errors in the operator. in addition, the option to specify specific version is Deprecated and will be deleted in next releases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB. It must be at least 10% of combined memory size (RAM and Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>enum</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+          <br/>
+            <i>Enum</i>: dense, sparse<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database (redis or memcached). Defaults to "redis".<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Settings for database alerts
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specalertsettingsbdb_backup_delayed">bdb_backup_delayed</a></td>
+        <td>object</td>
+        <td>
+          Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_high_syncer_lag">bdb_crdt_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_connection_error">bdb_crdt_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_general_error">bdb_crdt_src_syncer_general_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_latency">bdb_high_latency</a></td>
+        <td>object</td>
+        <td>
+          Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_throughput">bdb_high_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_long_running_action">bdb_long_running_action</a></td>
+        <td>object</td>
+        <td>
+          An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_low_throughput">bdb_low_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_dataset_overhead">bdb_ram_dataset_overhead</a></td>
+        <td>object</td>
+        <td>
+          Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_values">bdb_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_high_syncer_lag">bdb_replica_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_syncer_connection_error">bdb_replica_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_shard_num_ram_values">bdb_shard_num_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_size">bdb_size</a></td>
+        <td>object</td>
+        <td>
+          Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_backup_delayed
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_general_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_latency
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_long_running_action
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_low_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_dataset_overhead
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_shard_num_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_size
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.abs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.ftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.gcs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.mount
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.sftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.swift
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.modulesList[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Module: https://redislabs.com/redis-enterprise/modules/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The module's name e.g "ft" for redissearch<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          DEPRECATED - Module's semantic version e.g "1.6.12" - optional only in REDB, must be set in REAADB<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.replicaSources[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.rolesPermissions[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          DEPRECATED Upgrades the modules to the latest version that supports the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Notes - All modules must be without specifying the version. in addition, This field is currently not supported for Active-Active databases. The default is true<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusbackupinfo">backupInfo</a></td>
+        <td>object</td>
+        <td>
+          Information on the database's periodic backup<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createdTime</td>
+        <td>string</td>
+        <td>
+          Time when the database was created<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseUID</td>
+        <td>string</td>
+        <td>
+          Database UID provided by redis enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusinternalendpoints">internalEndpoints</a></td>
+        <td>[]object</td>
+        <td>
+          Endpoints listed internally by the Redis Enterprise Cluster. Can be used to correlate a ReplicaSourceStatus entry.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionStatus</td>
+        <td>string</td>
+        <td>
+          Status of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionUid</td>
+        <td>string</td>
+        <td>
+          UID of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdated</td>
+        <td>string</td>
+        <td>
+          Time when the database was last updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The generation (built in update counter of K8s) of the REDB resource that was fully acted upon, meaning that all changes were handled and sent as an API call to the Redis Enterprise Cluster (REC). This field value should equal the current generation when the resource changes were handled. Note: the lastActionStatus field tracks actions handled asynchronously by the Redis Enterprise Cluster.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusreplicasourcestatuses">replicaSourceStatuses</a></td>
+        <td>[]object</td>
+        <td>
+          ReplicaSource statuses<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardStatuses</td>
+        <td>map[string]integer</td>
+        <td>
+          Aggregated statuses of shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Database compatibility version<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.activeActive
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status.backupInfo
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Information on the database's periodic backup
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>backupFailureReason</td>
+        <td>string</td>
+        <td>
+          Reason of last failed backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupHistory</td>
+        <td>integer</td>
+        <td>
+          Backup history retention policy (number of days, 0 is forever)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupInterval</td>
+        <td>integer</td>
+        <td>
+          Interval in seconds in which automatic backup will be initiated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupIntervalOffset</td>
+        <td>integer</td>
+        <td>
+          Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupProgressPercentage</td>
+        <td>integer</td>
+        <td>
+          Database scheduled periodic backup progress (percentage)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupStatus</td>
+        <td>string</td>
+        <td>
+          Status of scheduled periodic backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastBackupTime</td>
+        <td>string</td>
+        <td>
+          Time of last successful backup<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.internalEndpoints[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Hostname assigned to the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Database port name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.replicaSourceStatuses[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpointHost</td>
+        <td>string</td>
+        <td>
+          The internal host name of the replica source database. Can be used as an identifier. See the internalEndpoints list on the REDB status.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lag</td>
+        <td>integer</td>
+        <td>
+          Lag in millisec between source and destination (while synced).<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastError</td>
+        <td>string</td>
+        <td>
+          Last error encountered when syncing from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdate</td>
+        <td>string</td>
+        <td>
+          Time when we last receive an update from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbSize</td>
+        <td>integer</td>
+        <td>
+          The source’s RDB size to be transferred during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbTransferred</td>
+        <td>integer</td>
+        <td>
+          Number of bytes transferred from the source’s RDB during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          Sync status of this source<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REC API
+weight: 30
+aliases: [ /operate/kubernetes/reference/cluster-options, ]
+url: '/operate/kubernetes/7.8.4/reference/redis_enterprise_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1](#appredislabscomv1)
+
+
+
+
+# app.redislabs.com/v1
+
+
+
+
+RedisEnterpriseCluster is the Schema for the redisenterpriseclusters API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>antiAffinityAdditionalTopologyKeys</td>
+        <td>[]string</td>
+        <td>
+          Additional antiAffinity terms in order to support installation on different zones/vcenters<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Cluster-wide backup configurations<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperimagespec">bootstrapperImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Bootstrapper container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperresources">bootstrapperResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for bootstrapper containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccertificates">certificates</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretName</td>
+        <td>string</td>
+        <td>
+          Secret Name/Path to use for Cluster Credentials. To be used only if ClusterCredentialSecretType is vault. If left blank, will use cluster name.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretRole</td>
+        <td>string</td>
+        <td>
+          Used only if ClusterCredentialSecretType is vault, to define vault role to be used.  If blank, defaults to "redis-enterprise-operator"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretType</td>
+        <td>enum</td>
+        <td>
+          Type of Secret to use for ClusterCredential, Vault, Kuberetes,... If left blank, will default ot kubernetes secrets<br/>
+          <br/>
+            <i>Enum</i>: vault, kubernetes<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterRecovery</td>
+        <td>boolean</td>
+        <td>
+          ClusterRecovery initiates cluster recovery when set to true. Note that this field is cleared automatically after the cluster is recovered<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccontainertimezone">containerTimezone</a></td>
+        <td>object</td>
+        <td>
+          Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createServiceAccount</td>
+        <td>boolean</td>
+        <td>
+          Whether to create service account<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) cluster wide policy. An optional boolean setting. Specifies if INE should be on/off for new created REDBs. May be overridden for specific REDB via similar setting, please view the similar setting for REDB for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>encryptPkeys</td>
+        <td>boolean</td>
+        <td>
+          Private key encryption Possible values: true/false<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enforceIPv4</td>
+        <td>boolean</td>
+        <td>
+          Sets ENFORCE_IPV4 environment variable<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          ADVANCED USAGE: use carefully. Add environment variables to RS StatefulSet's containers.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>extraLabels</td>
+        <td>map[string]string</td>
+        <td>
+          Labels that the user defines for their convenience<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#spechostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          Adds hostAliases entries to the Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specingressorroutespec">ingressOrRouteSpec</a></td>
+        <td>object</td>
+        <td>
+          Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldap">ldap</a></td>
+        <td>object</td>
+        <td>
+          Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>license</td>
+        <td>string</td>
+        <td>
+          Redis Enterprise License<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseSecretName</td>
+        <td>string</td>
+        <td>
+          K8s secret or Vault Secret Name/Path to use for Cluster License. When left blank, the license is read from the "license" field. Note that you can't specify non-empty values in both "license" and "licenseSecretName", only one of these fields can be used to pass the license string. The license needs to be stored under the key "license".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          Selector for nodes that could fit Redis Enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodes</td>
+        <td>integer</td>
+        <td>
+          Number of Redis Enterprise nodes (pods)<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specocspconfiguration">ocspConfiguration</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpersistentspec">persistentSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise Cluster persistence<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger and redis enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podSecurityPolicyName</td>
+        <td>string</td>
+        <td>
+          DEPRECATED PodSecurityPolicy support is removed in Kubernetes v1.25 and the use of this field is invalid for use when running on Kubernetes v1.25+. Future versions of the RedisEnterpriseCluster API will remove support for this field altogether. For migration instructions, see https://kubernetes.io/docs/tasks/configure-pod-container/migrate-from-psp/ 
+ Name of pod security policy to use on pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodstartingpolicy">podStartingPolicy</a></td>
+        <td>object</td>
+        <td>
+          Mitigation setting for STS pods stuck in "ContainerCreating"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodtolerations">podTolerations</a></td>
+        <td>[]object</td>
+        <td>
+          Tolerations that are added to all managed pods. More information: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          Adds the priority class to pods managed by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpullsecrets">pullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          PullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAwarenessNodeLabel</td>
+        <td>string</td>
+        <td>
+          Node label that specifies rack ID - if specified, will create rack aware cluster. Rack awareness requires node label must exist on all nodes. Additionally, operator needs a special cluster role with permission to list nodes.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributes">redisEnterpriseAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>enum</td>
+        <td>
+          Reserved, future use, only for use if instructed by Redis. IPFamily dictates what IP family to choose for pods' internal and external communication.<br/>
+          <br/>
+            <i>Enum</i>: IPv4, IPv6<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseimagespec">redisEnterpriseImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisenoderesources">redisEnterpriseNodeResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Redis Enterprise containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterprisePodAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for redis enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfiguration">redisEnterpriseServicesConfiguration</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster optional services settings<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerimagespec">redisEnterpriseServicesRiggerImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Services Rigger container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerresources">redisEnterpriseServicesRiggerResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Services Rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseTerminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          The TerminationGracePeriodSeconds value for the (STS created) REC pods<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisevolumemounts">redisEnterpriseVolumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          additional volume mounts within the redis enterprise containers. More info: https://kubernetes.io/docs/concepts/storage/volumes/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisonflashspec">redisOnFlashSpec</a></td>
+        <td>object</td>
+        <td>
+          Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisUpgradePolicy</td>
+        <td>enum</td>
+        <td>
+          Redis upgrade policy to be set on the Redis Enterprise Cluster. Possible values: major/latest This value is used by the cluster to choose the Redis version of the database when an upgrade is performed. The Redis Enterprise Cluster includes multiple versions of OSS Redis that can be used for databases.<br/>
+          <br/>
+            <i>Enum</i>: major, latest<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3Default</td>
+        <td>boolean</td>
+        <td>
+          Whether databases will turn on RESP3 compatibility upon database upgrade. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          the security configuration that will be applied to RS pods.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          Name of the service account to use<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservices">services</a></td>
+        <td>object</td>
+        <td>
+          Customization options for operator-managed service resources created for Redis Enterprise clusters and databases<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspec">servicesRiggerSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for service rigger<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspec">sideContainersSpec</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specslaveha">slaveHA</a></td>
+        <td>object</td>
+        <td>
+          Slave high availability mechanism configuration.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Annotations for Redis Enterprise UI service. This annotations will override the overlapping global annotations set under spec.services.servicesAnnotations The specified annotations will not override annotations that already exist and didn't originate from the operator, except for the 'redis.io/last-keys' annotation which is reserved.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiServiceType</td>
+        <td>enum</td>
+        <td>
+          Type of service used to expose Redis Enterprise UI (https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types)<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer, ExternalName<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for upgrades of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>username</td>
+        <td>string</td>
+        <td>
+          Username for the admin user of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>vaultCASecret</td>
+        <td>string</td>
+        <td>
+          K8s secret name containing Vault's CA cert - defaults to "vault-ca-cert"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          additional volumes<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiIngressUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbIngressSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host. ingress <db name><db ingress suffix> Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Used for ingress controllers such as ha-proxy or nginx in GKE<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-wide backup configurations
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          Configurations for backups to s3 and s3-compatible storage<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+Configurations for backups to s3 and s3-compatible storage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name that holds the S3 CA certificate, which contains the TLS certificate mapped to the key in the secret 'cert'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          Specifies the URL for S3 export and import<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Bootstrapper container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for bootstrapper containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbootstrapperresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources.claims[]
+<sup><sup>[↩ Parent](#specbootstrapperresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.certificates
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's API certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cmCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's CM (Cluster Manager) certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ldapClientCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's LDAP client certificate. If left blank, LDAP client certificate authentication will be disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>metricsExporterCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Metrics Exporter certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Proxy certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>syncerCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Syncer certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.containerTimezone
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>propagateHost</td>
+        <td>object</td>
+        <td>
+          Identifies that container timezone should be in sync with the host, this option mounts a hostPath volume onto RS pods that could be restricted in some systems.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timezoneName</td>
+        <td>string</td>
+        <td>
+          POSIX-style timezone name as a string to be passed as EnvVar to RE pods, e.g. "Europe/London".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specextraenvvars)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.hostAliases[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          Hostnames for the above IP address.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          IP address of the host file entry.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ingressOrRouteSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host ingress <db name><db fqdn suffix>. Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation.<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress, istio<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Additional annotations to set on ingress resources created by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationquery">authenticationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationquery">authorizationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>enum</td>
+        <td>
+          Specifies the LDAP protocol to use. One of: LDAP, LDAPS, STARTTLS.<br/>
+          <br/>
+            <i>Enum</i>: LDAP, LDAPS, STARTTLS<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapservers">servers</a></td>
+        <td>[]object</td>
+        <td>
+          One or more LDAP servers. If multiple servers are specified, they must all share an identical organization tree structure.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bindCredentialsSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding the credentials used to communicate with the LDAP server for authentication queries. The secret must have a key named 'dn' with the Distinguished Name of the user to execute the query, and 'password' with its password. If left blank, credentials-based authentication is disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding a PEM-encoded CA certificate for validating the TLS connection to the LDAP server. The secret must have a key named 'cert' with the certificate data. This field is applicable only when the protocol is LDAPS or STARTTLS.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cacheTTLSeconds</td>
+        <td>integer</td>
+        <td>
+          The maximum TTL of cached entries.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>directoryTimeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          The connection timeout to the LDAP server when authenticating a user, in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForControlPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for control plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForDataPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for data plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>template</td>
+        <td>string</td>
+        <td>
+          Configuration for a template query. Mutually exclusive with the 'query' field. The substring '%u' will be replaced with the username, e.g., 'cn=%u,ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery.query
+<sup><sup>[↩ Parent](#specldapauthenticationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>attribute</td>
+        <td>string</td>
+        <td>
+          Configuration for an attribute query. Mutually exclusive with the 'query' field. Holds the name of an attribute of the LDAP user entity that contains a list of the groups that the user belongs to, e.g., 'memberOf'.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery.query
+<sup><sup>[↩ Parent](#specldapauthorizationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.servers[]
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Address of an LDAP server.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Host name of the LDAP server<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Port number of the LDAP server. If unspecified, defaults to 389 for LDAP and STARTTLS protocols, and 636 for LDAPS protocol.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ocspConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ocspFunctionality</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable/disable OCSP mechanism for the cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>queryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate when the current staple is invalid. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryMaxTries</td>
+        <td>integer</td>
+        <td>
+          Determines the maximum number for the OCSP recovery attempts. After max number of tries passed, the control plane will revert back to the regular frequency. Minimum value is 1. Maximum value is 100.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responseTimeout</td>
+        <td>integer</td>
+        <td>
+          Determines the time interval (in seconds) for which the request waits for a response from the OCSP responder. Minimum value is 1. Maximum value is 60.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.persistentSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise Cluster persistence
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enablePersistentVolumeResize</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable PersistentVolumes resize. Disabled by default. Read the instruction in pvc_expansion readme carefully before using this feature.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to add persistent volume to Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          Storage class for persistent volume in Redis Enterprise pods. Leave empty to use the default. If using the default this way, make sure the Kubernetes Cluster has a default Storage Class configured. This can be done by running a `kubectl get storageclass` and see if one of the Storage Classes' names contains a `(default)` mark.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeSize</td>
+        <td>int or string</td>
+        <td>
+          To enable resizing after creating the cluster - please follow the instructions in the pvc_expansion readme<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podStartingPolicy
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Mitigation setting for STS pods stuck in "ContainerCreating"
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to detect and attempt to mitigate pod startup issues<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>startingThresholdSeconds</td>
+        <td>integer</td>
+        <td>
+          Time in seconds to wait for a pod to be stuck while starting up before action is taken. If set to 0, will be treated as if disabled.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podTolerations[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.pullSecrets[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Secret name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Redis Enterprise containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterprisenoderesourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterprisenoderesources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster optional services settings
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcmserver">cmServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbcoordinator">crdbCoordinator</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbworker">crdbWorker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationmdnsserver">mdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationpdnsserver">pdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationsaslauthd">saslauthd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationstatsarchiver">statsArchiver</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.cmServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the CM server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbCoordinator
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb coordinator process<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbWorker
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb worker processes<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.mdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the Multicast DNS server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.pdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the pdns server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.saslauthd
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the saslauthd service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.statsArchiver
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the stats archiver service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Services Rigger container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Services Rigger pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesriggerresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseservicesriggerresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseVolumeMounts[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisOnFlashSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bigStoreDriver</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb, speedb<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashDiskSize</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashStorageEngine</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+the security configuration that will be applied to RS pods.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsecuritycontextreadonlyrootfilesystempolicy">readOnlyRootFilesystemPolicy</a></td>
+        <td>object</td>
+        <td>
+          Whether RS containers has a read-only root filesystem and what is the policy. some mandatory paths are still writable so RS can work properly.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext.readOnlyRootFilesystemPolicy
+<sup><sup>[↩ Parent](#specsecuritycontext)</sup></sup>
+
+Whether RS containers has a read-only root filesystem and what is the policy. some mandatory paths are still writable so RS can work properly.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether RS containers has a read-only root filesystem. Default is false.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Customization options for operator-managed service resources created for Redis Enterprise clusters and databases
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesapiservice">apiService</a></td>
+        <td>object</td>
+        <td>
+          Customization options for the REC API service.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>servicesAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Global additional annotations to set on service resources created by the operator. The specified annotations will not override annotations that already exist and didn't originate from the operator.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services.apiService
+<sup><sup>[↩ Parent](#specservices)</sup></sup>
+
+Customization options for the REC API service.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          Type of service to create for the REC API service. Defaults to ClusterIP service, if not specified otherwise.<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for service rigger
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>databaseServiceType</td>
+        <td>string</td>
+        <td>
+          Service types for access to databases. should be a comma separated list. The possible values are cluster_ip, headless and load_balancer.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceNaming</td>
+        <td>enum</td>
+        <td>
+          Used to determine how to name the services created automatically when a database is created. When bdb_name is used, the database name will be also used for the service name. When redis-port is used, the service will be named redis-<port>.<br/>
+          <br/>
+            <i>Enum</i>: bdb_name, redis-port<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributes">servicesRiggerAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[]
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+EnvVar represents an environment variable present in a Container. More info: https://kubernetes.io/docs/tasks/inject-data-application/environment-variable-expose-pod-information/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the environment variable.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          Source for the environment variable's value. Cannot be used if value is not empty.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvars)</sup></sup>
+
+Source for the environment variable's value. Cannot be used if value is not empty.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a ConfigMap.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a field of the pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a resource of the container: only resources limits and requests are currently supported.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a secret in the pod's namespace<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a ConfigMap.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key to select.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the ConfigMap or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a field of the pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          Path of the field to select in the specified API version.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          Version of the schema the FieldPath is written in terms of, defaults to "v1".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a resource of the container: only resources limits and requests are currently supported.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          Required: resource to select<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          Container name: required for volumes, optional for env vars<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          Specifies the output format of the exposed resources, defaults to "1"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a secret in the pod's namespace
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key of the secret to select from.  Must be a valid secret key.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the Secret or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom
+<sup><sup>[↩ Parent](#specsidecontainersspecenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].ports[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources.claims[]
+<sup><sup>[↩ Parent](#specsidecontainersspecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeDevices[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeMounts[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.slaveHA
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Slave high availability mechanism configuration.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>slaveHAGracePeriod</td>
+        <td>integer</td>
+        <td>
+          Time in seconds between when a node fails, and when slave high availability mechanism starts relocating shards. If set to 0, will not affect cluster configuration.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for upgrades of Redis Enterprise
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>autoUpgradeRedisEnterprise</td>
+        <td>boolean</td>
+        <td>
+          Whether to upgrade Redis Enterprise automatically when operator is upgraded<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Volume represents a named volume in a pod that may be accessed by any container in the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureFile
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].fc
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flocker
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].hostPath
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].nfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].quobyte
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusbundleddatabaseversions">bundledDatabaseVersions</a></td>
+        <td>[]object</td>
+        <td>
+          Versions of open source databases bundled by Redis Enterprise Software - please note that in order to use a specific version it should be supported by the ‘upgradePolicy’ - ‘major’ or ‘latest’ according to the desired version (major/minor)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuscertificatesstatus">certificatesStatus</a></td>
+        <td>object</td>
+        <td>
+          Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ingressOrRouteMethodStatus</td>
+        <td>string</td>
+        <td>
+          The ingressOrRouteSpec/ActiveActive spec method that exist<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuslicensestatus">licenseStatus</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmanagedapis">managedAPIs</a></td>
+        <td>object</td>
+        <td>
+          Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmodules">modules</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusocspstatus">ocspStatus</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP status<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuspersistencestatus">persistenceStatus</a></td>
+        <td>object</td>
+        <td>
+          The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>state</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.bundledDatabaseVersions[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>dbType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>major</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.certificatesStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>generation</td>
+        <td>integer</td>
+        <td>
+          Generation stores the version of the cluster's Proxy and Syncer certificate secrets. In Active-Active databases, when a user updates the proxy or syncer certificate, a crdb-update command needs to be triggered to avoid potential sync issues. This helps the REAADB controller detect a change in a certificate and trigger a crdb-update. The version of the cluster's Proxy certificate secret.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>updateStatus</td>
+        <td>string</td>
+        <td>
+          The status of the cluster's certificates update<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.licenseStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseState</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.managedAPIs
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ldap</td>
+        <td>boolean</td>
+        <td>
+          Indicate whether cluster LDAP configuration is managed by the operator. When this is enabled, the operator will reconcile the cluster LDAP configuration according to the '.spec.ldap' field in the RedisEnterpriseCluster resource.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.modules[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>displayName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versions</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.ocspStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+An API object that represents the cluster's OCSP status
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>certStatus</td>
+        <td>string</td>
+        <td>
+          Indicates the proxy certificate status - GOOD/REVOKED/UNKNOWN.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nextUpdate</td>
+        <td>string</td>
+        <td>
+          The time at or before which newer information will be available about the status of the certificate (if available)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>producedAt</td>
+        <td>string</td>
+        <td>
+          The time at which the OCSP responder signed this response.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responderUrl</td>
+        <td>string</td>
+        <td>
+          The OCSP responder url from which this status came from.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revocationTime</td>
+        <td>string</td>
+        <td>
+          The time at which the certificate was revoked or placed on hold.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>thisUpdate</td>
+        <td>string</td>
+        <td>
+          The most recent time at which the status being indicated is known by the responder to have been correct.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.persistenceStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The current status of the PVCs<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>succeeded</td>
+        <td>string</td>
+        <td>
+          The number of PVCs that are provisioned with the expected size<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseActiveActiveDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REAADB API
+weight: 30
+url: '/operate/kubernetes/7.8.4/reference/redis_enterprise_active_active_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseActiveActiveDatabase is the Schema for the redisenterpriseactiveactivedatabase API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseActiveActiveDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters specifications and configurations.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurations">globalConfigurations</a></td>
+        <td>object</td>
+        <td>
+          The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.participatingClusters[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR to link.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?  If disabled, the DatabaseSecret will not be created or updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with database. Note - For Active-Active databases this feature is currently in preview. For this feature to take effect for Active-Active databases, set a boolean environment variable with the name "ENABLE_ALPHA_FEATURES" to True. This variable can be set via the redis-enterprise-operator pod spec, or through the operator-environment-config Config Map.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'. Note - Specifying Redis version is currently not supported for Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB It must be at least 10% of combined memory size (RAM+Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>string</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database.<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.activeActive
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+### spec.globalConfigurations.backup
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.abs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.ftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the "ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]" format<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.gcs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.mount
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.s3
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.sftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.swift
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.modulesList[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Module: https://redislabs.com/redis-enterprise/modules/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The module's name e.g "ft" for redissearch<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uid</td>
+        <td>string</td>
+        <td>
+          Module's uid - do not set, for system use only nolint:staticcheck // custom json tag unknown to the linter<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Module's semantic version e.g "1.6.12" - optional only in REDB, must be set in REAADB<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.replicaSources[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.rolesPermissions[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType (note: use exact name of the ACL from the Redis Enterprise ACL list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType (note: use exact name of the role from the Redis Enterprise role list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.upgradeSpec
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          Upgrades the modules to the latest version that supportes the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Note - This field is currently not supported for Active-Active databases.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>clusterCertificatesGeneration</td>
+        <td>integer</td>
+        <td>
+          Versions of the cluster's Proxy and Syncer certificates. In Active-Active databases, these are used to detect updates to the certificates, and trigger synchronization across the participating clusters. .<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>guid</td>
+        <td>string</td>
+        <td>
+          The active-active database corresponding GUID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastTaskUid</td>
+        <td>string</td>
+        <td>
+          The last active-active database task UID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>linkedRedbs</td>
+        <td>[]string</td>
+        <td>
+          The linked REDBs.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters statuses.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The overall replication status<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statussecretsstatus">secretsStatus</a></td>
+        <td>[]object</td>
+        <td>
+          The status of the secrets<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the active active database.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.participatingClusters[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR that is linked.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>id</td>
+        <td>integer</td>
+        <td>
+          The corresponding ID of the instance in the active-active database.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The replication status of the participating cluster<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.secretsStatus[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of secrets.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the secret.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>status</td>
+        <td>enum</td>
+        <td>
+          The status of the secret.<br/>
+          <br/>
+            <i>Enum</i>: Valid, Invalid<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseRemoteCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: RERC API
+weight: 30
+url: '/operate/kubernetes/7.8.4/reference/redis_enterprise_remote_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEntepriseRemoteCluster represents a remote participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseRemoteCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          The URL of the cluster, will be used for the active-active database URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recName</td>
+        <td>string</td>
+        <td>
+          The name of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recNamespace</td>
+        <td>string</td>
+        <td>
+          The namespace of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiPort</td>
+        <td>integer</td>
+        <td>
+          The port number of the cluster's URL used for connectivity/sync<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          The database URL suffix, will be used for the active-active database replication endpoint and replication endpoint SNI.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret containing cluster credentials. Must be of the following format: "redis-enterprise-<RERC name>"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>internalObservedSecretResourceVersion</td>
+        <td>string</td>
+        <td>
+          The observed secret resource version. Used for internal purposes only.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>local</td>
+        <td>boolean</td>
+        <td>
+          Indicates whether this object represents a local or a remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The most recent generation observed for this RERC. It corresponds to the RERC's generation, which is updated by the API Server.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Reference material for the operator, cluster, and database deployment
+  options.
+hideListLinks: false
+linkTitle: Reference
+weight: 89
+url: '/operate/kubernetes/7.8.4/reference/'
+---
+
+This section contains the API reference for Redis custom resources and supported distributions.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise operators allows you to use Redis Enterprise for
+  Kubernetes.
+hideListLinks: false
+linkTitle: 7.8.4
+weight: 50
+bannerText: This documentation applies to version 7.8.4. For documentation on the latest version, see [redis.io/docs/latest/operate/kubernetes/](https://redis.io/docs/latest/operate/kubernetes/).
+bannerChildren: true
+url: '/operate/kubernetes/7.8.4/'
+---
+
+Kubernetes provides enterprise orchestration of containers and has been widely adopted. Redis Enterprise for Kubernetes provides a simple way to get a Redis Enterprise cluster on Kubernetes and enables more complex deployment scenarios.
+
+---
+Title: Upgrade Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  OperatorHub.
+linkTitle: OpenShift OperatorHub
+weight: 40
+url: '/operate/kubernetes/7.4.6/upgrade/upgrade-olm/'
+---
+
+## Before upgrading
+
+1. Check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported.
+
+2. Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+3. Verify you are upgrading from Redis Enterprise operator version 6.2.10-45 or later. If you are not, you must upgrade to 6.2.10-45 before upgrading to versions 6.2.18 or later.
+
+## Upgrade the Redis Enterprise operator
+
+1. Select the **Redis Enterprise Operator** from the **Operators**>**Installed Operators** page.
+
+2. Select the **Subscription** tab.
+
+3. Verify your **Update approval** is set to "Manual".
+
+4. If you wish to upgrade to the most recent version, set your **Update channel** to "production". If you wish to upgrade to an older version, select it for your Update channel.
+
+5. Select **Upgrade available** shown under **Upgrade status**.
+
+6. When the "Review manual InstallPlan" section appears, select **Preview installPlan** and then **Approve** after reviewing the details. This will start the operator upgrade.
+
+You can monitor the upgrade from the **Installed Operators** page. A new Redis Enterprise Operator will appear in the list, with the status "Installing". The OpenShift will delete the old operator, showing the "Cannot update" status during deletion.
+
+## Reapply the SCC
+
+If you are using OpenShift, you will also need to manually reapply the [security context constraints](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.4.6/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+
+If you are upgrading from operator version 6.4.2-6 or before, see the [after upgrading section in the OpenShift CLI upgrade]({{<relref "/operate/kubernetes/7.4.6/upgrade/openshift-cli#after-upgrading">}}) to delete the old SCC and role binding after all clusters are running 6.4.2-6 or later.
+---
+Title: Upgrade Redis Enterprise with OpenShift CLI
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  CLI.
+linkTitle: OpenShift CLI
+weight: 20
+url: '/operate/kubernetes/7.4.6/upgrade/openshift-cli/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  2. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redisenterprisecluster-rec)
+  3. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## Before upgrading
+
+1. Check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported.
+
+2. Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+3. Verify you are upgrading from Redis Enterprise operator version 6.2.10-45 or later. If you are not, you must upgrade to 6.2.10-45 before upgrading to versions 6.2.18 or later.
+
+4. When upgrading existing clusters running on RHEL7-based images, make sure to select a RHEL7-based image for the new version. See [release notes]({{< relref "/operate/kubernetes/release-notes/" >}}) for more info.
+
+5. If you want to migrate from RHEL7-based images to RHEL8-based images, you'll need to upgrade to version 7.2.4-2 with a RHEL7-based image, then you'll be able to migrate to a RHEL8-based image when upgrading to 7.2.4-**TBD**.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+For OpenShift environments, the name of the bundle is `openshift.bundle.yaml`, and so the `curl` command to run is:
+
+```sh
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/openshift.bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+If you are using OpenShift, run this instead:
+
+```sh
+oc apply -f openshift.bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+oc get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+ We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+ {{< /warning >}}
+
+### Reapply the SCC
+
+If you are using OpenShift, you will also need to manually reapply the [security context constraints](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.4.6/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+
+If you are upgrading from operator version 6.4.2-6 or before, see the ["after upgrading"](#after-upgrading) section to delete the old SCC and role binding after all clusters are running 6.4.2-6 or later.
+
+## Upgrade the RedisEnterpriseCluster (REC)
+
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator release notes to find the Redis Enterprise image tag. For example, in Redis Enterprise K8s operator release [6.0.12-5](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.12-5), the `Images` section shows the Redis Enterprise tag is `6.0.12-57`.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec` in the REC spec
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+## After upgrading
+
+For OpenShift users, operator version 6.4.2-6 introduced a new SCC (`redis-enterprise-scc-v2`). If any of your OpenShift RedisEnterpriseClusters are running versions earlier than 6.2.4-6, you need to keep both the new and old versions of the SCC.
+
+If all of your clusters have been upgraded to operator version 6.4.2-6 or later, you can delete the old version of the SCC (`redis-enterprise-scc`) and remove the binding to your service account.
+
+1. Delete the old version of the SCC
+
+   ```sh
+   oc delete scc redis-enterprise-scc
+   ```
+
+   The output should look similar to the following:
+
+   ```sh
+   securitycontextconstraints.security.openshift.io "redis-enterprise-scc" deleted
+   ```
+
+1. Remove the binding to your service account.
+
+   ```sh
+   oc adm policy remove-scc-from-user redis-enterprise-scc system:serviceaccount:<my-project>:<rec-name>
+   ```
+
+
+## Upgrade databases
+
+{{<warning>}}In version 7.2.4, old module versions and manually uploaded modules are not persisted. If databases are not upgraded after cluster upgrade, and require cluster recovery afterwards, you'll need to contact Redis support. This issue will be fixed in the next maintenance release by moving the stored location of the modules.{{</warning>}}
+
+After the cluster is upgraded, you can upgrade your databases. The process for upgrading databases is the same for both Kubernetes and non-Kubernetes deployments. For more details on how to [upgrade a database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-database" >}}), see the [Upgrade an existing Redis Enterprise Software deployment]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) documentation.
+
+Note that if your cluster [`redisUpgradePolicy`]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+
+
+---
+Title: Upgrade Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via the
+  operator.
+linkTitle: Kubernetes
+weight: 10
+url: '/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster-rec)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## Prerequisites
+
+1. Check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported.
+
+1. Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+1. Verify you are upgrading from Redis Enterprise operator version 6.2.10-45 or later. If you are not, you must upgrade to 6.2.10-45 before upgrading to versions 6.2.18 or later.
+
+{{<warning>}}**Upgrade cluster operating system** If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+You can download the bundle for the latest release with the following `curl` command:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+Upgrade the bundle and operator with a single command, passing in the bundle YAML file:
+
+```sh
+kubectl apply -f bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+kubectl get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+{{< /warning >}}
+
+## Upgrade the Redis Enterprise cluster (REC)
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator release notes to find the Redis Enterprise image tag. For example, in Redis Enterprise K8s operator release [6.0.12-5](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.12-5), the `Images` section shows the Redis Enterprise tag is `6.0.12-57`.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Upgrade an REC with an Active-Active database
+
+We recommend upgrading all participating clusters to the same operator version.
+
+If you are upgrading from a preview version of the Active-Active controller, you can remove the following environment variables: `ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED`, `REMOTE_CLUSTER_CONTROLLER_ENABLED`, and `ENABLE_ALPHA_FEATURES`.
+
+### Edit `redisEnterpriseImageSpec` in the REC spec
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    kubectl edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `kubectl get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ kubectl get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+kubectl rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. The process for upgrading databases is the same for both Kubernetes and non-Kubernetes deployments.
+
+For more details on how to [upgrade a database]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-database" >}}), see the [Upgrade an existing Redis Enterprise Software deployment]({{< relref "/operate/rs/installing-upgrading/upgrading" >}}) documentation.
+
+For Active-Active databases, see [Upgrade an Active-Active database]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-active-active">}}).
+
+Note that if your cluster [`redisUpgradePolicy`]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+---
+Title: Upgrade Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Information about upgrading your Redis Enterprise cluster on Kubernetes.
+hideListLinks: true
+linkTitle: Upgrade
+weight: 15
+url: '/operate/kubernetes/7.4.6/upgrade/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. Upgrade the Redis Enterprise operator
+  2. Upgrade the Redis Enterprise cluster (REC)
+  3. Upgrade Redis Enterprise databases (REDB)
+
+To use OpenShift container platform CLI to upgrade your Redis Enterprise, see [Upgrade Redis Enterprise with OpenShift CLI]({{< relref "/operate/kubernetes/7.4.6/upgrade/openshift-cli.md" >}}).
+
+For all other Kubernetes distributions, see [Upgrade Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Upgrade compatibility
+
+When upgrading, both your Kubernetes version and Redis operator version need to be supported at all times. When upgrading your Kubernetes version, you need to make sure both the current and target K8s version are supported by your Redis operator version. When upgrading your Redis operator version, you need make sure both the current and target operator versions are supported by your K8s version. This means if you are planning a large jump in versions, the upgrade might need to be done in multiple steps.
+
+The flow chart below can help you decide if your upgrade requires multiple steps.
+
+{{< image filename="/images/k8s/upgrade-flowchart.jpg" alt="Upgrade flowchart" >}}
+
+## How does the REC upgrade work?
+
+The Redis Enterprise cluster (REC) uses a rolling upgrade, meaning it upgrades pods one by one. Each pod is updated after the last one completes successfully. This helps keep your cluster available for use.
+
+To upgrade, the cluster terminates each pod and deploys a new pod based on the new image.
+  Before each pod goes down, the operator checks if the pod is a primary (master) for the cluster, and if it hosts any primary (master) shards. If so, a replica on a different pod is promoted to primary. Then when the pod is terminated, the API remains available through the newly promoted primary pod.
+
+After a pod is updated, the next pod is terminated and updated.
+After all of the pods are updated, the upgrade process is complete.
+---
+Title: Recover a Redis Enterprise cluster on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to recover a Redis Enterprise cluster on Kubernetes.
+linkTitle: Recover a Redis cluster
+weight: 20
+url: '/operate/kubernetes/7.4.6/re-clusters/cluster-recovery/'
+---
+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:
+
+1. Recreates a fresh Redis Enterprise cluster
+1. Mounts the persistent storage with the recovery files from the original cluster to the nodes of the new cluster
+1. Recovers the cluster configuration on the first node in the new cluster
+1. Joins the remaining nodes to the new cluster.
+
+{{<warning>}}Redis Enterprise for Kubernetes 7.2.4-2 introduces a new limitation. You cannot recover or upgrade your cluster if there are databases with old module versions or manually uploaded modules. See the [Redis Enterprise Software 7.2.4 known limitations]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}}) for more details.{{</warning>}}
+
+## Prerequisites
+
+- For cluster recovery, the cluster must be [deployed with persistence]({{< relref "/operate/kubernetes/7.4.6/recommendations/persistent-volumes.md" >}}).
+
+## Recover a cluster
+
+1. Edit the REC resource to set the `clusterRecovery` flag to `true`.
+
+    ```sh
+    kubectl patch rec <cluster-name> --type merge --patch '{"spec":{"clusterRecovery":true}}'
+    ```
+
+
+1. Wait for the cluster to recover until it is in the "Running" state.
+
+    To see the state of the cluster, run:
+
+    ```sh
+    watch "kubectl describe rec | grep State"
+    ```
+
+1. To recover the database, see [Recover a failed database]({{< relref "/operate/rs/databases/recover.md" >}}).
+---
+Title: Connect to the admin console
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Connect to the Redis Enterprise admin console to manage your Redis Enterprise
+  cluster.
+linkTitle: Connect to the admin console
+weight: 10
+url: '/operate/kubernetes/7.4.6/re-clusters/connect-to-admin-console/'
+---
+
+The username and password for the Redis Enterprise Software [admin console]({{< relref "/operate/rs/" >}}) are stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/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. 
+{{</note>}}
+
+1. Switch to the namespace with your Redis Enterprise cluster (REC).
+
+    ```sh
+    kubectl config set-context --current --namespace=<namespace-of-rec>
+    ```
+
+1. Find your cluster name from your list of secrets.
+
+    ```sh
+    kubectl get secret
+    ```
+
+    In this example, the cluster name is `rec`.
+
+1. Extract and decode your credentials from the secret.
+
+    ```sh
+    kubectl get secret <cluster-name> -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <cluster-name> -o jsonpath='{.data.password}' | base64 --decode
+    ```
+
+1. Find the port for the REC UI service in the `spec:ports` section of the service definition file.
+
+    ```sh
+    kubectl get service/<cluster-name>-ui -o yaml
+    ```
+
+    {{<note>}}
+    The default port is 8443.
+    {{</note>}}
+
+1. Use `kubectl port-forward` to forward your local port to the service port.
+
+    ```sh
+    kubectl port-forward service/<cluster-name>-ui <local-port>:<service-port>
+   ```
+
+1. View the admin console from a web browser on your local machine at `https://localhost:8443`.
+
+---
+Title: Expand PersistentVolumeClaim (PVC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Expand your persistent volume claim by editing the REC.
+linkTitle: Expand PVC
+weight: 82
+url: '/operate/kubernetes/7.4.6/re-clusters/expand-pvc/'
+---
+
+This article outlines steps to increase the size of the persistent volume claim for your Redis Enterprise cluster (REC).
+
+[PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) are created by the Redis Enterprise operator and used by the RedisEnterpriseCluster (REC). PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) with the following steps, if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+This process involves deleting and recreating the REC StatefulSet with a larger persistent volume size. The pods owned by the StatefulSet are not restarted or affected by the deletion and recreation process, except when they are left without an owner momentarily.
+
+{{<note>}}Shrinking (reducing the size) of your PVC is not allowed. This process only allows you to expand (size up) your PVC.{{</note>}}
+
+## Prerequisites
+
+{{<warning>}}Do not change any other REC fields related to the StatefulSet while resizing is in progress.
+{{</warning>}}
+
+- PVC expansion must be supported and enabled by the StorageClass and underlying storage driver of the REC PVCs.
+  - The relevant StorageClass is the one associated with the REC PVCs. The StorageClass for existing PVCs cannot be changed.
+- The StorageClass must be configured with `allowVolumeExpansion: true`.
+- Your storage driver must support online expansion.
+- We highly recommend you backup your databases before beginning this PVC expansion process.
+
+## Expand REC PVC
+
+1. Enable the REC persistent volume resize flag.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+    ```
+
+1. Set the value of `volumeSize` to your desired size.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+          volumeSize: <new-size>Gi
+    ```
+
+1. Apply the changes to the REC, replacing `<your-rec.yaml>` with the name of your REC.
+
+  ```sh
+  kubectl apply -f <your-rec.yaml>
+  ```
+
+After applying the REC changes, the PVCs will begin to expand to the new size.
+
+Once all the PVCs finish the resizing process, the operator will delete and recreate the StatefulSet with the new volume size.
+
+### Track progress
+
+You can track the progress by monitoring the status of the REC and PersistentVolumeClaim objects.
+
+The REC status will correspond to the status of one or more PVCs, and will reflect if the resizing is successful or failed.
+
+While the resizing is in progress, the status will be:
+
+```yaml
+status:
+  persistenceStatus:
+    status: Resizing
+    succeeded: 2/3
+```
+
+When the resizing is complete, the status becomes Provisioned and the new volume size is available for use by the REC pods.
+
+```yaml
+status:
+  persistenceStatus:
+    status: Provisioned
+    succeeded: 3/3
+```
+
+### Troubleshooting
+
+If an error occurs during this process:
+
+- Examine the status and events of the REC and PVC objects.
+
+  ```sh
+  kubectl describe pvc
+  ```
+
+  ```sh
+  kubectl get events
+  ```
+
+- Examine the logs of the operator pods.
+
+  ```sh
+  kubectl logs <operator_pod_name>
+  ```
+---
+Title: Connect the Prometheus operator to Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article describes how to configure a Prometheus operator custom
+  resource to allow it to export metrics from Redis Enterprise for Kubernetes.
+linkTitle: Export metrics to Prometheus
+weight: 92
+url: '/operate/kubernetes/7.4.6/re-clusters/connect-prometheus-operator/'
+---
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can connect your [Prometheus](https://prometheus.io/) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+
+## Prerequisites
+
+Before connecting Redis Enterprise to Prometheus on your Kubernetes cluster, make sure you've done the following:
+
+- [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md" >}}) (version 6.2.10-4 or newer)
+- [Deploy the Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md) (version 0.19.0 or newer)
+- [Create a Redis Enterprise cluster]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}})
+
+## Create a `ServiceMonitor` custom resource
+
+Below is an example `ServiceMonitor` custom resource file. By specifying the service label (`app: redis.io/service=prom-metrics`) in the `selector.matchLabels` section, you can point the Prometheus operator to the correct Redis Enterprise service (`<rec_name>-prom`).
+
+You'll need to configure the following fields to connect Prometheus to Redis Enterprise:
+
+| Section | Field | Value |
+|---|---|---|
+| `spec.endpoints` | `port` | Name of exposed port (`prometheus`) |
+| `spec.namespaceSelector` | `matchNames` | Namespace for your REC |
+| `spec.selector` | `matchLabels` | REC service label (`app: redis.io/service=prom-metrics`) |
+
+Apply the file in the same namespace as your Redis Enterprise cluster (REC).
+    {{<note>}}If Redis Enterprise and Prometheus are deployed in different namespaces, you'll also need to add the [`serviceMonitorNamespaceSelector`](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api.md#namespaceselector) field to your Prometheus resource. See the [Prometheus operator documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources) for more details on cross-namespace `ServiceMonitor` configuration.{{</note>}}
+
+
+```YAML
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: redis-enterprise
+spec:
+  endpoints:
+  - interval: 15s
+    port: prometheus
+    scheme: https
+    tlsConfig:
+      insecureSkipVerify: true
+  namespaceSelector:
+    matchNames:
+    - <your_REC_namespace>
+  selector:
+    matchLabels:
+      redis.io/service: prom-metrics
+```
+
+For more info about configuring the `ServiceMonitor` resource, see the [`ServiceMonitorSpec` API documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api-reference/api.md#monitoring.coreos.com/v1.ServiceMonitorSpec).
+
+## More info
+
+- github.com/prometheus-operator
+  - [Getting started](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md)
+  - [Running exporters](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/running-exporters.md)
+  - [Related resources](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources)
+  - [Troubleshooting ServiceMonitor changes](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/troubleshooting.md)
+- redis.io/docs
+  - [Metrics in Prometheus]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}})
+  - [Monitoring and metrics]({{< relref "/operate/rs/monitoring/" >}})
+---
+Title: Manage databases in multiple namespaces
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces
+  within your Kubernetes cluster. This article shows you how to configure your Redis
+  Enterprise cluster to connect to databases in multiple namespaces
+linktitle: Manage multiple namespaces
+weight: 17
+url: '/operate/kubernetes/7.4.6/re-clusters/multi-namespace/'
+---
+
+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]({{< relref "/operate/kubernetes/7.4.6/deployment/deployment-options" >}}).
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Prerequisites
+
+Before configuring a multi-namespace deployment, you must have a running [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md" >}}). See more information in the [deployment]({{< relref "/operate/kubernetes/7.4.6/deployment/" >}}) section.
+
+## Create role and role binding for managed namespaces
+
+Both the operator and the RedisEnterpriseCluster (REC) resource need access to each namespace the REC will manage. For each **managed** namespace, create a `role.yaml` and `role_binding.yaml` file within the managed namespace, as shown in the examples below.
+
+{{<note>}}These will need to be reapplied each time you [upgrade]({{< relref "/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster.md" >}}). {{</note>}}
+
+Replace `<rec-namespace>` with the namespace the REC resides in.
+Replace `<service-account-name>` with your own value (defaults to the REC name).
+
+`role.yaml` example: 
+
+```yaml
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups:
+      - app.redislabs.com
+    resources: ["redisenterpriseclusters", "redisenterpriseclusters/status", "redisenterpriseclusters/finalizers",
+                "redisenterprisedatabases", "redisenterprisedatabases/status", "redisenterprisedatabases/finalizers",
+                "redisenterpriseremoteclusters", "redisenterpriseremoteclusters/status",
+                "redisenterpriseremoteclusters/finalizers",
+                "redisenterpriseactiveactivedatabases", "redisenterpriseactiveactivedatabases/status",
+                "redisenterpriseactiveactivedatabases/finalizers"]
+    verbs: ["delete", "deletecollection", "get", "list", "patch", "create", "update", "watch"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["update", "get", "read", "list", "listallnamespaces", "watch", "watchlist",
+            "watchlistallnamespaces", "create","patch","replace","delete","deletecollection"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create"]
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["get", "watch", "list", "update", "patch", "create", "delete"]
+```
+
+`role_binding.yaml` example:
+
+```yaml
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: <rec-namespace>
+- kind: ServiceAccount
+  name: <service-account-name>
+  namespace: <rec-namespace>
+roleRef:
+  kind: Role
+  name: redb-role
+  apiGroup: rbac.authorization.k8s.io
+```
+
+Apply the files, replacing `<managed-namespace>` with your own values:
+
+```sh
+kubectl apply -f role.yaml -n <managed-namespace>
+kubectl apply -f role_binding.yaml -n <managed-namespace>
+```
+
+{{<note>}}
+If the REC is configured to watch a namespace without setting the role and role binding permissions, or a namespace that is not yet created, the operator will fail and halt normal operations.
+{{</note>}}
+
+
+## Update Redis Enterprise operator ConfigMap
+
+There are two methods of updating the operator ConfigMap (`operator-environment-config`) to specify which namespaces to manage.
+
+- Method 1: Configure the operator to watch for a namespace label and add this label to managed namespaces (available in versions 6.4.2-4 or later).
+- Method 2: Configure the operator with an explicit list of namespaces to manage.
+
+You can create this ConfigMap manually before deployment, or it will be created automatically after the operator was deployed.
+
+
+### Method 1: Namespace label (available in versions 6.4.2-4 or later)
+
+1. Create the `cluster_role_binding.yaml` and `cluster_role.yaml` files. Replace the `<rec-namespace>` with the namespace the Redis Enterprise cluster (REC) resides in.
+
+  `operator_cluster_role.yaml` example:
+
+  ```yaml
+    apiVersion: rbac.authorization.k8s.io/v1
+    kind: ClusterRole
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    rules:
+      - apiGroups: [""]
+        resources: ["namespaces"]
+        verbs: ["list", "watch"]
+  ```
+
+  `operator_cluster_role_binding.yaml` example:
+
+  ```yaml
+    kind: ClusterRoleBinding
+    apiVersion: rbac.authorization.k8s.io/v1
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    subjects:
+    - kind: ServiceAccount
+      name: redis-enterprise-operator
+      namespace: <rec-namespace>
+    roleRef:
+      kind: ClusterRole
+      name: redis-enterprise-operator-consumer-ns
+      apiGroup: rbac.authorization.k8s.io
+  ```
+
+2. Apply the files.
+
+  ```sh
+  kubectl apply -f operator_cluster_role.yaml
+  kubectl apply -f operator_cluster_role_binding.yaml 
+  ```
+
+3. Patch the ConfigMap in the REC namespace (`<rec-namespace>`) to identify the managed namespaces with your label (`<label-name>`).
+
+  ```sh
+   kubectl patch ConfigMap/operator-environment-config \
+  -n <rec-namespace> \
+  --type merge \
+  -p '{"data": {"REDB_NAMESPACES_LABEL": "<label-name>"}}'
+  ```
+
+4. For each managed namespace, apply the same label. Replace `<managed-namespace>` with the namespace the REC will manage. Replace `<label-name>` with the value used in the previous step. If you specify a value for `<label-value>`, both the label name and value in managed namespaces must match to be detected by the operator. If the `<label-value>` is empty, only the label name needs to match on managed namespaces and the value is disregarded.
+
+
+  ```sh
+  kubectl label namespace <managed-namespace> <label-name>=<label-value>
+  ```
+
+{{<note>}}
+The operator restarts when it detects a namespace label was added or removed.
+{{</note>}}
+
+### Method 2: Explicit namespace list
+
+Patch the `operator-environment-config` in the REC namespace with a new environment variable (`REDB_NAMESPACES`).
+
+```sh
+kubectl patch ConfigMap/operator-environment-config \ 
+-n <rec-namespace> \
+--type merge \
+-p '{"data":{"REDB_NAMESPACES": "<comma,separated,list,of,namespaces,to,watch"}}'
+```
+
+{{<warning>}}
+Only configure the operator to watch a namespace after the namespace is created and configured with the role/role_binding as explained above. If configured to watch a namespace without setting those permissions or a namespace that is not created yet, the operator will fail and not perform normal operations.
+{{</warning>}}
+---
+Title: Redis Enterprise clusters (REC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise clusters (REC).
+hideListLinks: false
+linkTitle: Redis Enterprise clusters (REC)
+weight: 30
+url: '/operate/kubernetes/7.4.6/re-clusters/'
+---
+
+This section contains articles to help you manage your Redis Enterprise clusters (REC).
+
+
+
+---
+Title: Use Auto Tiering on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Deploy a cluster with Auto Tiering on Kubernetes.
+linkTitle: Auto Tiering
+weight: 16
+url: '/operate/kubernetes/7.4.6/re-clusters/auto-tiering/'
+---
+
+## Prerequisites
+
+Redis Enterprise Software for Kubernetes supports using Auto Tiering (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+{{<note>}}
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+{{</note>}}
+
+Before creating your Redis clusters or databases, these SSDs must be:
+
+- [locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+- formatted and mounted on the nodes that will run Redis Enterprise pods
+- dedicated to Auto Tiering and not shared with other parts of the database, (e.g. durability, binaries)
+- [provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+  - You can use a [local volume provisioner](https://github.com/kubernetes-sigs/sig-storage-local-static-provisioner/blob/master/README.md) to do this [dynamically](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#dynamic)
+- a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource with a unique name
+
+For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+## Create a Redis Enterprise cluster
+
+To deploy a Redis Enterprise cluster (REC) with Auto Tiering, you'll need to specify the following in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api" >}}):
+
+- enable Auto Tiering (`enabled: true`)
+- flash storage driver (`bigStoreDriver`)
+  - `rocksdb` or `speedb`(default)
+- storage class name (`storageClassName`)
+- minimal flash disk size (`flashDiskSize`)
+
+{{<note>}} Clusters upgraded to version 7.2.4-2 from an earlier version will change the `bigStoreDriver` (previously called `flashStorageEngine`) to the new default `speedb`, regardless of previous configuration. {{</note>}}
+
+{{<warning>}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+Here is an example of an REC custom resource with these attributes:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: "rec"
+spec:
+  
+  nodes: 3
+  redisOnFlashSpec:
+    enabled: true
+    bigStoreDriver: speedb
+    storageClassName: local-scsi
+    flashDiskSize: 100G
+```
+
+### Create a Redis Enterprise database
+
+By default, any new database will use RAM only. To create a Redis Enterprise database (REDB) that can use flash storage, specify the following in the `redisEnterpriseCluster` section of the REDB custom resource definition:
+
+- `isRof: true` enables Auto Tiering
+- `rofRamSize` defines the RAM capacity for the database
+
+Below is an example REDB custom resource:
+
+```YAML
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: autoteiring-redb
+spec:
+  redisEnterpriseCluster:
+    name: rec
+  isRof: true
+  memorySize: 2GB
+  rofRamSize: 0.5GB
+```
+
+{{< note >}}
+This example defines both `memorySize` and `rofRamSize`. When using Auto Tiering, `memorySize` refers to the total combined memory size (RAM + flash) allocated for the database. `rofRamSize` specifies only the RAM capacity for the database. `rofRamSize` must be at least 10% of `memorySize`.
+{{< /note >}}
+---
+Title: Create Active-Active databases with crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section shows how to set up an Active-Active Redis Enterprise database
+  on Kubernetes using the Redis Enterprise Software operator.
+linkTitle: Create Active-Active with crdb-cli
+weight: 99
+url: '/operate/kubernetes/7.4.6/active-active/create-aa-crdb-cli/'
+---
+{{<note>}} Versions 6.4.2 and later support the Active-Active database controller. This controller allows you to create Redis Enterprise Active-Active databases (REAADB) and Redis Enterprise remote clusters (RERC) with custom resources. We recommend using the [REAADB method for creating Active-Active databases]({{< relref "/operate/kubernetes/7.4.6/active-active/create-reaadb.md" >}}).{{</note>}}
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read-and-write access to the same dataset from different Kubernetes clusters. For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/7.4.6/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.
+
+This process consists of:
+
+1. Documenting values to be used in later steps. It's important these values are correct and consistent.
+1. Editing the Redis Enterprise cluster (REC) spec file to include the `ActiveActive` section. This will be slightly different depending on the K8s distribution you are using.
+1. Creating the database with the `crdb-cli` command. These values must match up with values in the REC resource spec.
+
+## Prerequisites
+
+Before creating Active-Active databases, you'll need admin access to two or more working Kubernetes clusters that each have:
+
+- Routing for external access with an [ingress resources]({{< relref "/operate/kubernetes/7.4.6/networking/ingress.md" >}}) (or [route resources]({{< relref "/operate/kubernetes/7.4.6/networking/routes.md" >}}) on OpenShift).
+- A working [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api" >}}) with a unique name.
+- Enough memory resources available for the database (see [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})).
+
+{{<note>}} The `activeActive` field and the `ingressOrRouteSpec` field cannot coexist in the same REC. If you configured your ingress via the `ingressOrRouteSpec` field in the REC, create your Active-Active database with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource.{{</note>}}
+
+## Document required parameters
+
+The most common mistake when setting up Active-Active databases is incorrect or inconsistent parameter values. The values listed in the resource file must match those used in the crdb-cli command.
+
+- **Database name** `<db-name>`:
+  - Description: Combined with ingress suffix to create the Active-Active database hostname
+  - Format: string
+  - Example value: `myaadb`
+  - How you get it: you choose
+  - The database name requirements are:
+       - Maximum of 63 characters
+       - Only letter, number, or hyphen (-) characters
+       - Starts with a letter; ends with a letter or digit.
+       - Database name is not case-sensitive
+
+You'll need the following information for each participating Redis Enterprise cluster (REC):
+
+{{<note>}}
+You'll need to create DNS aliases to resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address for the ingress controller’s LoadBalancer (or routes in Openshift) for each database. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as *.ijk.example.com).
+{{</note>}}
+
+- **REC hostname** `<rec-hostname>`:
+  - Description: Hostname used to identify your Redis Enterprise cluster in the `crdb-cli` command. This MUST be different from other participating clusters.
+  - Format: `<rec-name>.<namespace>.svc.cluster.local`
+  - Example value: `rec01.ns01.svc.cluster.local`
+  - How to get it: List all your Redis Enterprise clusters
+      ```bash
+      kubectl get rec
+      ```
+- **API hostname** `<api-hostname>`:
+  - Description: Hostname used to access the Redis Enterprise cluster API from outside the K8s cluster
+  - Format: string
+  - Example value: `api.ijk.example.com`
+- **Ingress suffix** `<ingress-suffix>`:
+  - Description: Combined with database name to create the Active-Active database hostname
+  - Format: string
+  - Example value: `-cluster.ijk.example.com`
+- [**REC admin credentials**]({{< relref "/operate/kubernetes/7.4.6/security/manage-rec-credentials.md" >}}) `<username> <password>`:
+  - Description: Admin username and password for the REC stored in a secret
+  - Format: string
+  - Example value: username: `user@example.com`, password: `something`
+  - How to get them:
+    ```sh
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.password}' | base64 --decode
+    ```
+- **Replication hostname** `<replication-hostname>`:
+  - Description: Hostname used inside the ingress for the database
+  - Format: `<db-name><ingress-suffix>`
+  - Example value: `myaadb-cluster.ijk.example.com`
+  - How to get it: Combine `<db-name>` and `<ingress-suffix`> values you documented above.
+- **Replication endpoint** `<replication-endpoint>`:
+  - Description: Endpoint used externally to contact the database
+  - Format: `<db-name><ingress-suffix>:443`
+  - Example value: `myaadb-cluster.ijk.example.com:443`
+  - How to get it:`<replication-hostname>:443`
+
+## Add `activeActive` section to the REC resource file
+
+From inside your K8s cluster, edit your Redis Enterprise cluster (REC) resource to add the following to the `spec` section. Do this for each participating cluster.
+
+ The operator uses the API hostname (`<api-hostname>`) to create an ingress to the Redis Enterprise cluster's API; this only happens once per cluster. Every time a new Active-Active database instance is created on this cluster, the operator creates a new ingress route to the database with the ingress suffix (`<ingress-suffix>`). The hostname for each new database will be in the format <nobr>`<db-name><ingress-suffix>`</nobr>.
+
+### Using ingress controller
+
+1. If your cluster uses an [ingress controller]({{< relref "/operate/kubernetes/7.4.6/networking/ingress.md" >}}), add the following to the `spec` section of your REC resource file.
+
+  Nginx:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+       kubernetes.io/ingress.class: nginx
+      nginx.ingress.kubernetes.io/backend-protocol: HTTPS
+      nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+HAproxy:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+      kubernetes.io/ingress.class: haproxy
+       ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+2. After the changes are saved and applied, you can verify a new ingress was created for the API.
+
+    ```sh
+    $ kubectl get ingress
+    NAME   HOSTS                            ADDRESS                                 PORTS   AGE
+    rec01  api.abc.cde.example.com  225161f845b278-111450635.us.cloud.com   80      24h
+    ```
+
+3. Verify you can access the API from outside the K8s cluster.
+
+    ```sh
+   curl -k -L -i -u <username>:<password> https://<api-hostname>/v1/cluster
+    ```
+
+    If the API call fails, create a DNS alias that resolves your API hostname (`<api-hostname>`) to the IP address for the ingress controller's LoadBalancer.
+
+4. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address of the ingress controller’s LoadBalancer. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+#### If using Istio Gateway and VirtualService
+
+No changes are required to the REC spec if you are using [Istio]({{< relref "/operate/kubernetes/7.4.6/networking/istio-ingress.md" >}}) in place of an ingress controller. The `activeActive` section added above creates ingress resources. The two custom resources used to configure Istio (Gateway and VirtualService) replace the need for ingress resources.
+
+{{<warning>}}
+These custom resources are not controlled by the operator and will need to be configured and maintained manually.
+{{</warning>}}
+
+For each cluster, verify the VirtualService resource has two `- match:` blocks in the `tls` section. The hostname under `sniHosts:` should match your `<replication-hostname>`.
+
+### Using OpenShift routes
+
+1. Make sure your Redis Enterprise cluster (REC) has a different name (`<rec-name.namespace>`) than any other participating clusters. If not, you'll need to manually rename the REC or move it to a different namespace.
+            You can check your new REC name with:
+    ```sh
+    oc get rec -o jsonpath='{.items[0].metadata.name}'
+    ```
+
+    If the rec name was modified, reapply [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml) to the namespace to reestablish security privileges.
+    
+    ```sh
+    oc apply -f scc.yaml
+    oc adm policy add-scc-to-group redis-enterprise-scc-v2  system:serviceaccounts:<namespace>
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the route IP address. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. If your cluster uses [OpenShift routes]({{< relref "/operate/kubernetes/7.4.6/networking/routes.md" >}}), add the following to the `spec` section of your Redis Enterprise cluster (REC) resource file.
+
+      ```sh
+      activeActive:
+        apiIngressUrl: <api-hostname>
+        dbIngressSuffix: <ingress-suffix>
+        method: openShiftRoute
+      ```
+
+1. Make sure you have DNS aliases that resolve to the routes IP for both the API hostname (`<api-hostname>`) and the replication hostname (`<replication-hostname>`) for each database. To avoid entering each database individually, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. After the changes are saved and applied, you can see that a new route was created for the API.
+
+    ```sh
+    $ oc get route
+    NAME    HOST/PORT                       PATH    SERVICES  PORT  TERMINATION   WILDCARD
+    rec01   api-openshift.apps.abc.example.com rec01   api             passthrough   None
+    ```
+
+## Create an Active-Active database with `crdb-cli`
+
+The `crdb-cli` command can be run from any Redis Enterprise pod hosted on any participating K8s cluster. You'll need the values for the [required parameters]({{< relref "/operate/kubernetes/7.4.6/active-active/create-aa-crdb-cli#document-required-parameters" >}}) for each Redis Enterprise cluster.
+
+```sh
+crdb-cli crdb create \
+  --name <db-name> \
+  --memory-size <mem-size> \
+  --encryption yes \
+  --instance fqdn=<rec-hostname-01>,url=https://<api-hostname-01>,username=<username-01>,password=<password-01>,replication_endpoint=<replication-endpoint-01>,replication_tls_sni=<replication-hostname-01> \
+  --instance fqdn=<rec-hostname-02>,url=https://<api-hostname-02>,username=<username-02>,password=<password-02>,replication_endpoint=<replication-endpoint-02>,replication_tls_sni=<replication-hostname-02>
+```
+
+To create a database that syncs between more than two instances, add additional `--instance` arguments.
+
+See the [`crdb-cli` reference]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for more options.
+
+## Test your database
+
+The easiest way to test your Active-Active database is to set a key-value pair in one database and retrieve it from the other.
+
+You can connect to your databases with the instructions in [Manage databases]({{< relref "/operate/kubernetes/7.4.6/re-databases/db-controller#connect-to-a-database" >}}). Set a test key with `SET foo bar` in the first database. If your Active-Active deployment is working properly, when connected to your second database, `GET foo` should output `bar`.
+---
+Title: Set global database secret
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' to set the
+  global database secret.
+linkTitle: Global database secret
+weight: 50
+url: '/operate/kubernetes/7.4.6/active-active/global-db-secret/'
+---
+{{<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.{{</note>}}
+
+## 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.
+
+To edit other global configruations, see [global configuration]({{< relref "/operate/kubernetes/7.4.6/active-active/global-config.md" >}})
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the database password.
+
+  This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+  ```yaml
+  apiVersion: v1
+  data:
+    password: bXktcGFzcw
+  kind: Secret
+  metadata:
+    name: my-db-secret
+  type: Opaque
+  ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    example-aadb-1   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit Redis Enterprise remote clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Edit the configuration details of an existing RERC with Redis Enterprise
+  for Kubernetes.
+linkTitle: Edit RERC
+weight: 60
+url: '/operate/kubernetes/7.4.6/active-active/edit-rerc/'
+---
+{{<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.{{</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.
+
+The RERC controller periodically connects to the local REC endpoint via its external address, to ensure it’s setup correctly. For this to work, the external load balancer must support [NAT hairpinning](https://en.wikipedia.org/wiki/Network_address_translation#NAT_loopback). In some cloud environments, this may involve disabling IP preservation for the load balancer target groups.
+
+For more details, see the [RERC API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+## Edit RERC
+
+Use the `kubectl patch rerc <rerc-name> --type merge --patch` command to patch the local RERC custom resource with your changes. For a full list of available fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+The following example edits the `dbFqdnSuffix` field for the RERC named `rerc-ohare`.
+
+```sh
+kubectl patch rerc rerc-ohare --type merge --patch \
+'{"spec":{"dbFqdnSuffix": "-example2-cluster-rec-chicago-ns-illinois.example.com"}}'
+```
+
+## Update RERC secret
+
+If the credentials are changed or updated for a REC participating cluster, you need to manually edit the RERC secret and apply it to all participating clusters.
+
+1. On the local cluster, update the secret with new credentials and name it with the following convention:  `redis-enterprise-<rerc-name>`.
+
+    A secret for a remote cluster named `rerc-ohare` would be similar to the following:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: PHNvbWUgcGFzc3dvcmQ+
+      username: PHNvbWUgdXNlcj4
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+    ```
+
+1. Apply the file.
+
+    ```sh
+    kubectl apply -f <secret-file>
+    ```
+
+1. Watch the RERC to verify the status is "Active" and the spec status is "Valid."
+
+      ```sh
+      kubectl get rerc <rerc-name>
+      ```
+
+    The output should look like this:
+  
+      ```sh
+       NAME        STATUS   SPEC STATUS   LOCAL
+        rerc-ohare   Active   Valid         true
+      ```
+      
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.4.6/logs/" >}}).
+
+1. Verify the status of each REAADB using that RERC is "Active" and the spec status is "Valid."
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up
+    ```
+
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.4.6/logs/" >}}).
+
+1. Repeat the above steps on all other participating clusters.
+---
+Title: Prepare participating clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Prepare your participating RECs to be part of an Active-Active database
+  deployment.
+linkTitle: Prepare clusters
+weight: 10
+url: '/operate/kubernetes/7.4.6/active-active/prepare-clusters/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.4.6/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.4.6/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+Next you'll [collect credentials](#collect-rec-credentials) for your participating clusters and create secrets for the RedisEnterprsieRemoteCluster (RERC) to use.
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+## Collect REC credentials
+
+To communicate with other clusters, all participating clusters will need access to the admin credentials for all other clusters.
+
+1. Create a file to hold the admin credentials for all participating RECs (such as `all-rec-secrets.yaml`).
+
+1. Within that file, create a new secret for each participating cluster named `redis-enterprise-<rerc-name>`.
+
+    The example below shows a file (`all-rec-secrets.yaml`) holding secrets for two participating clusters:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Get the REC credentials secret for each participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    The admin credentials secret for an REC named `rec-chicago` would be similar to this:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-chicago
+    type: Opaque
+    ```
+
+1. Add the username and password to the new secret for that REC and namespace.
+
+    This example shows the collected secrets file (`all-rec-secrets.yaml`) for `rerc-ohare` (representing `rec-chicago` in namespace `ns-illinois`) and `rerc-reagan` (representing `rec-arlington` in namespace `ns-virginia`).
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: KLmndo123456
+      username: PQrst789010
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <all-rec-secrets-file>
+    ```
+
+   If the admin credentials for any of the clusters changes, the file will need to be updated and reapplied to all clusters.
+
+## Next steps
+
+Now you are ready to [create your Redis Enterprise Active-Active database]({{< relref "/operate/kubernetes/7.4.6/active-active/create-reaadb.md" >}}).
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+---
+Title: Set global database configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' and through
+  this the database configurations are set.
+linkTitle: Global configuration
+weight: 50
+url: '/operate/kubernetes/7.4.6/active-active/global-config/'
+---
+{{<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.{{</note>}}
+
+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]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_active_active_database_api">}}) contains a full list of available fields.
+
+## Edit global configurations
+
+1. Edit or patch the REAADB custom resource with your global configuration changes.
+
+    The example command below patches the REAADB named `reaadb-boeing` to set the global memory size to 200MB:
+
+    ```sh
+    kubectl patch reaadb reaadb-boeing --type merge --patch \
+    '{"spec": {"globalConfigurations": {"memorySize": "200mb"}}}'
+    ```
+
+1. Verify the status is `active` and the spec status is `Valid`.
+
+    This example shows the status for the `reaadb-boeing` database.
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid    
+    ```
+
+1. View the global configurations on each participating cluster to verify they are synced.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o yaml
+    ```
+
+## Edit global configuration secrets
+
+This section edits the secrets under the REAADB `.spec.globalConfigurations` section. For more information and all available fields, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_active_active_database_api">}}).
+
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the relevant data.
+
+    This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+    ```yaml
+    apiVersion: v1
+     data:
+      password: bXktcGFzcw
+    kind: Secret
+    metadata:
+      name: my-db-secret
+    type: Opaque
+    ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit participating clusters for Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Steps to add or remove a participating cluster to an existing Active-Active
+  database with Redis Enterprise for Kubernetes.
+linkTitle: Edit participating clusters
+weight: 40
+url: '/operate/kubernetes/7.4.6/active-active/edit-clusters/'
+---
+{{<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.{{</note>}}
+
+## Add a participating cluster
+
+Use the following steps to add a participating cluster to an existing Redis Enterprise Active-Active database (REAADB) for Kubernetes.
+
+### Prerequisites
+
+To prepare the Redis Enterprise cluster (REC) to participate in an Active-Active database, perform the following tasks from [Prepare participating clusters]({{< relref "/operate/kubernetes/7.4.6/active-active/prepare-clusters.md" >}}):
+
+- Make sure the cluster meets the hardware and naming requirements.
+- Enable the Active-Active controllers.
+- Configure external routing.
+- Configure `ValidatingWebhookConfiguration`.
+
+### Collect REC credentials
+
+To communicate with other clusters, all participating clusters need access to the admin credentials for all other clusters.
+
+1. Get the REC credentials secret for the new participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    This example shows an admin credentials secret for an REC named `rec-boston`:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-boston
+    type: Opaque
+    ```
+
+1. Create a secret for the new participating cluster named `redis-enterprise-<rerc>` and add the username and password.
+
+    The example below shows a secret file for a remote cluster named `rerc-logan` .
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-logan
+    type: Opaque
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <rec-secret-file>
+    ```
+
+ If the admin credentials for any of the clusters change, update and reapply the file to all clusters.
+
+### Create RERC
+
+1. From one of the existing participating clusters, create a `RedisEnterpriseRemoteCluster` (RERC) custom resource for the new participating cluster.
+
+    This example shows an RERC custom resource for an REC named `rec-boston` in the namespace `ns-massachusetts`. 
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-logan
+    spec:
+      recName: rec-boston
+      recNamespace: ns-massachusetts
+      apiFqdnUrl: test-example-api-rec-boston-ns-massachusetts.example.com
+      dbFqdnSuffix: -example-cluster-rec-boston-ns-massachusetts.example.com
+      secretName: redis-enterprise-rerc-logan
+    ```
+
+1. Create the RERC custom resource.
+
+    ```sh
+    kubectl create -f <new-RERC-file>
+    ```
+
+1. Check the status of the newly created RERC custom resource.
+
+    ```sh
+    kubectl get rerc <RERC-name>
+    ```
+
+    The output should look like this:
+
+    ```sh
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-logan   Active   Valid         true
+    ```
+
+### Edit REAADB spec
+
+1. Patch the REAADB spec to add the new RERC name to the `participatingClusters`, replacing `<reaadb-name>` and `<rerc-name>` with your own values.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> < --type merge --patch '{"spec": {"participatingClusters": [{"name": "<rerc-name>"}]}}'
+    ```
+
+1. View the REAADB `participatingClusters` status to verify the cluster was added.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.participatingClusters}'
+    ```
+
+    The output should look like this:
+
+    ```sh
+    [{"id":1,"name":"rerc-ohare"},{"id":2,"name":"rerc-reagan"},{"id":3,"name":"rerc-logan"}]
+    ```
+
+## Remove a participating cluster
+
+1. On an existing participating cluster,remove the desired cluster from the `participatingCluster` section of the REAADB spec.
+
+    ```sh
+    kubectl edit reaadb <reaadb-name>
+    ```
+
+1. On each of the other participating clusters, verify the status is `active` and the spec status is `Valid` and the cluster was removed.
+
+   ```sh
+   kubectl get reaadb <reaadb-name -o=jasonpath=`{.status}`
+   ```
+   
+    The output should look like this:
+    
+    ```sh
+    {... ,"participatingClusters":[{"id":1,"name":"rerc1"},{"id":2,"name":"rerc2"}],"redisEnterpriseCluster":"rec1","specStatus":"Valid","status":"active"}
+    ```
+
+1. On the removed participating cluster, list all REAADB resources on the cluster to verify they were deleted.
+
+
+    ```sh
+    kubectl get reaadb -o+jasonpath=`{range.items[*]}{.metadata.name}`
+    ```
+---
+Title: Create Active-Active database (REAADB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: Create database
+weight: 30
+url: '/operate/kubernetes/7.4.6/active-active/create-reaadb/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+   {{<note>}}These are installed and enabled by default on clusters created via the OpenShift OperatorHub. {{</note>}}
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.4.6/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.4.6/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+4. [Prepare participating clusters]({{< relref "/operate/kubernetes/7.4.6/active-active/prepare-clusters.md" >}})
+   * RERC name (`<rerc-name`>)
+   * RERC secret name (`redis-enterprise-<rerc-name>`)
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+## Create `RedisEnterpriseRemoteCluster` resources {#create-rerc}
+
+1. Create a `RedisEnterpriseRemoteCluster` (RERC) custom resource file for each participating Redis Enterprise cluster (REC).
+
+   Below are examples of RERC resources for two participating clusters. Substitute your own values to create your own resource.
+
+    Example RERC (`rerc-ohare`) for the REC named `rec-chicago` in the namespace `ns-illinois`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-ohare
+    spec:
+      recName: rec-chicago
+      recNamespace: ns-illinois
+      apiFqdnUrl: api-rec-chicago-ns-illinois.example.com
+      dbFqdnSuffix: -db-rec-chicago-ns-illinois.example.com
+      secretName: redis-enterprise-rerc-ohare
+    ```
+
+    Example RERC (`rerc-raegan`) for the REC named `rec-arlington` in the namespace `ns-virginia`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-reagan
+    spec:
+      recName: rec-arlington
+      recNamespace: ns-virginia
+      apiFqdnUrl: test-example-api-rec-arlington-ns-virginia.example.com
+      dbFqdnSuffix: -example-cluster-rec-arlington-ns-virginia.example.com
+      secretName: redis-enterprise-rerc-reagan
+    ```
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise remote cluster from each RERC custom resource file.
+  
+   ```sh
+   kubectl create -f <rerc-file>
+   ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, then your configurations are correct.
+  
+    ```sh
+    kubectl get rerc <rerc-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get rerc rerc-ohare
+
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-ohare   Active   Valid         true
+    ```
+  
+    In case of errors, review the RERC custom resource events and the Redis Enterprise operator logs.
+
+## Create `RedisEnterpriseActiveActiveDatabase` resource {#create-reaadb}
+
+1. Create a `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource file meeting the naming requirements and listing the names of the RERC custom resources created in the last step.
+
+    Naming requirements:
+    * less than 63 characters
+    * contains only lowercase letters, numbers, or hyphens
+    * starts with a letter
+    * ends with a letter or digit
+
+    Example REAADB named `reaadb-boeing` linked to the REC named `rec-chicago` with two participating clusters and a global database configuration with shard count set to 3:
+
+     ```yaml
+     apiVersion: app.redislabs.com/v1alpha1
+     kind: RedisEnterpriseActiveActiveDatabase
+     metadata:
+       name: reaadb-boeing
+     spec:
+       globalConfigurations:
+         databaseSecretName: <my-secret>
+         memorySize: 200MB
+         shardCount: 3
+       participatingClusters:
+           - name: rerc-ohare
+           - name: rerc-reagan
+     ```
+
+     {{<note>}}Sharding is disabled on Active-Active databases created with a `shardCount` of 1. Sharding cannot be enabled after database creation. {{</note>}}
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise Active-Active database from the REAADB custom resource file.
+  
+    ```sh
+    kubectl create -f <reaadb-file>
+    ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, your configurations are correct.
+  
+    ```sh
+    kubectl get reaadb <reaadb-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up             
+    ```
+
+  
+    In case of errors, review the REAADB custom resource events and the Redis Enterprise operator logs.
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+
+---
+Title: Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Content related to Active-Active Redis Enterprise databases for Kubernetes.
+hideListLinks: true
+linkTitle: Active-Active databases
+weight: 40
+url: '/operate/kubernetes/7.4.6/active-active/'
+---
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters.
+
+## Active-Active setup methods
+
+There are two methods for creating an Active-Active database with Redis Enterprise for Kubernetes:
+
+- The `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource is available for versions 6.4.2 and later.
+- The `crdb-cli` method is available for versions 6.4.2 or earlier.
+
+
+We recommend creating new Active-Active databases using the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. This allows you to manage your Active-Active database with the operator and ensures you have the latest features and functionality.
+
+### Active-Active controller method
+
+Versions 6.4.2-6 or later fully support the Active-Active controller. 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.
+
+This setup method includes the following steps:
+
+1. Gather REC credentials and [prepare participating clusters]({{< relref "/operate/kubernetes/7.4.6/active-active/prepare-clusters.md" >}}).
+2. Create [`RedisEnterpriseRemoteCluster` (RERC)]({{< relref "/operate/kubernetes/7.4.6/active-active/create-reaadb#create-rerc" >}}) resources.
+3. Create [`RedisEnterpriseActiveActiveDatabase` (REAADB)]({{< relref "/operate/kubernetes/7.4.6/active-active/create-reaadb#create-reaadb" >}}) resource.
+
+### `crdb-cli` method
+
+For versions 6.4.2 or earlier, this Active-Active setup method includes the following steps:
+
+1. Install and configure an ingress.
+2. Gather configuration details.
+3. Add the `ActiveActive` field to the REC spec.
+4. Create the database with the `crdb-cli` tool.
+
+## Redis Enterprise Active-Active controller for Kubernetes
+
+{{<note>}}These features are supported for general availability in releases 6.4.2-6 and later.{{</note>}}
+
+[Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases give you read-and-write access to Redis Enterprise clusters (REC) in different Kubernetes clusters or namespaces. Active-Active deployments managed by the Redis Enterprise operator require two additional custom resources: Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC).
+
+To create an Active-Active Redis Enterprise deployment for Kubernetes with these new features, first [prepare participating clusters]({{< relref "/operate/kubernetes/7.4.6/active-active/prepare-clusters.md" >}}) then [create an Active-Active database]({{< relref "/operate/kubernetes/7.4.6/active-active/create-reaadb.md" >}}).
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+
+### REAADB custom resource
+
+Redis Enterprise Active-Active database (REAADB) contains a link to the RERC for each participating cluster, and provides configuration and status to the management plane.
+
+For a full list of fields and options, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_active_active_database_api">}}).
+
+### RERC custom resource
+
+Redis Enterprise remote cluster (RERC) custom resource contains configuration details for all the participating clusters.
+
+For a full list of fields and options, see the [RERC API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+### Limitations
+
+* Existing Redis databases cannot be migrated to a REAADB. (DOC-3594)
+* Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)
+    Workaround: Fix the problems with the REAADB and reapply.
+* The `<rec-name>/<rec-namespace>` value must be unique for each RERC resource. (RED-96302)
+* Only global database options are supported, no support for specifying configuration per location.
+* No support for migration from old (`crdb-cli`) Active-Active database method to new Active-Active controller.
+* No support for REAADB with participating clusters co-located within the same Kubernetes cluster, except for a single designated local participating cluster.
+
+## More info
+
+For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes where to view the archive of Redis Enterprise for Kubernetes
+  documentation.
+linkTitle: Archive
+weight: 99999999999
+url: '/operate/kubernetes/7.4.6/kubernetes-archive/'
+---
+
+Previous versions of Redis Enterprise for Kubernetes documentation are available on the archived web site:
+
+- [Redis Enterprise for Kubernetes v7.4 documentation archive](https://docs.redis.com/7.4/kubernetes/) 
+
+- [Redis Enterprise for Kubernetes v7.2 documentation archive](https://docs.redis.com/7.2/kubernetes/)  
+
+- [Redis Enterprise for Kubernetes v6.x documentation archive](https://docs.redis.com/6.4/kubernetes/)
+---
+Title: Manage Redis Enterprise cluster (REC) credentials
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: Manage REC credentials
+weight: 93
+url: '/operate/kubernetes/7.4.6/security/manage-rec-credentials/'
+---
+Redis Enterprise for Kubernetes uses a custom resource called [`RedisEnterpriseCluster`]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api" >}}) to create a Redis Enterprise cluster (REC). During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+{{<note>}}
+This procedure is only supported for operator versions 6.0.20-12 and above.
+{{</note>}}
+
+## Retrieve the current username and password
+
+The credentials can be used to access the Redis Enterprise admin console or the API. Connectivity must be configured to the REC [pods](https://kubernetes.io/docs/concepts/workloads/pods/) using an appropriate service (or port forwarding).
+
+1. Inspect the random username and password created by the operator during creation with the `kubectl get secret` command.
+
+    ```sh
+    kubectl get secret rec -o jsonpath='{.data}'
+    ```
+
+    The command outputs the encoded password and username, similar to the example below.
+
+      ```sh
+      map[password:MTIzNDU2NzgK username:ZGVtb0BleGFtcGxlLmNvbQo=]
+      ```
+
+1. Decode the password and username with the `echo` command and the password from the previous step.
+
+    ```bash
+    echo MTIzNDU2NzgK | base64 --decode
+    ```
+
+    This outputs the password and username in plain text. In this example, the plain text password is `12345678` and the username is `demo@example.com`.
+
+## Change the Redis Enterprise cluster (REC) credentials
+
+### Change the REC password for the current username
+
+1. Access a [pod](https://kubernetes.io/docs/concepts/workloads/pods/) running a Redis Enterprise cluster.
+
+    ```bash
+    kubectl exec -it <rec-resource-name>-0 bash
+    ```
+
+1. Add a new password for the existing user.
+
+    ```bash
+     REC_USER="`cat /opt/redislabs/credentials/username`" \
+     REC_PASSWORD="`cat /opt/redislabs/credentials/password`" \
+     curl -k --request POST \
+       --url https://localhost:9443/v1/users/password \
+       -u "$REC_USER:$REC_PASSWORD" \
+       --header 'Content-Type: application/json' \
+       --data "{\"username\":\"$REC_USER\", \
+     \"old_password\":\"$REC_PASSWORD\", \
+     \"new_password\":\"<NEW PASSWORD>\"}"
+    ```
+
+1. From outside the pod, update the REC credential secret.
+
+    1. Save the existing username to a text file .
+        ```bash
+        echo -n "<current_username>" > username 
+        ```
+
+    1. Save the new password to a text file.
+        ```bash
+        echo -n "<new_password>" > password
+        ```
+
+    1. Update the REC credential secret.
+        ```bash
+        kubectl create secret generic <cluster_secret_name> \
+          --from-file=./username \
+          --from-file=./password --dry-run \
+          -o yaml
+        kubectl apply -f 
+        ```
+
+1. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+1. Access a pod running a Redis Enterprise cluster again.
+
+    ```bash
+    kubectl exec -it <rec-resource-name>-0 bash
+    ```
+
+ 1. Remove the previous password to ensure only the new one applies.
+
+    ```sh
+    REC_USER="`cat /opt/redislabs/credentials/username`"; \
+    REC_PASSWORD="`cat /opt/redislabs/credentials/password`"; \
+    curl -k --request DELETE \ 
+      --url https://localhost:9443/v1/users/password \
+      -u "$REC_USER:$REC_PASSWORD" \
+      --header 'Content-Type: application/json' \
+      --data "{\"username\":\"$REC_USER\", \
+      \"old_password\":\"<OLD PASSWORD\"}"
+    ```
+
+    {{<note>}} The username for the K8s secret is the email displayed on the Redis Enterprise admin console. {{</note>}}
+
+### Change both the REC username and password
+
+1. [Connect to the admin console]({{< relref "/operate/kubernetes/7.4.6/re-clusters/connect-to-admin-console.md" >}})
+
+1. [Add another admin user]({{< relref "/operate/rs/security/access-control/create-users" >}}) and choose a new password.
+
+1. Specify the new username in the `username` field of your REC custom resource spec.
+
+1. Update the REC credential secret:
+
+    1. Save the existing username to a text file.
+
+        ```bash
+        echo -n "<current_username>" > username
+        ```
+
+    1. Save the new password to a text file.
+
+        ```bash
+        echo -n "<new_password>" > password
+        ```
+
+    1. Update the REC credential secret.
+
+        ```bash
+        kubectl create secret generic <cluster_secret_name> \
+          --from-file=./username \
+          --from-file=./password --dry-run \
+          -o yaml
+        kubectl apply -f 
+        ```
+
+1. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+1. Delete the previous admin user from the cluster.
+
+  {{<note>}}
+The operator may log errors in the time between updating the username in the REC spec and the secret update.
+  {{</note>}}
+
+### Update the credentials secret in Vault
+
+If you store your secrets with Hashicorp Vault, update the secret for the REC credentials with the following key-value pairs:
+
+```sh
+username:<desired_username>, password:<desired_password>
+```
+
+For more information about Vault integration with the Redis Enterprise Cluster see [Integrating Redis Enterprise for Kubernetes with Hashicorp Vault](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/vault/README.md).
+---
+Title: Enable internode encryption
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable encryption for communication between REC nodes in your K8s cluster.
+linkTitle: Internode encryption
+weight: 99
+url: '/operate/kubernetes/7.4.6/security/internode-encryption/'
+---
+
+Internode encryption provides added security by encrypting communication between nodes in your Redis Enterprise cluster (REC).
+
+Enable internode encryption in the `spec` section of your REC custom resource file.
+
+```yaml
+spec:
+    dataInternodeEncryption: true
+```
+
+This change will apply to all databases created in the REC. You can override the cluster-wide setting for individual databases.
+
+Edit your Redis Enterprise database (REDB) custom resource file to disable internode encryption for only that database.
+
+```yaml
+spec: 
+    dataInternodeEncryption: false
+```
+
+To learn more about internode encryption, see [Internode encryption for Redis Enterprise Software]({{< relref "/operate/rs/security/encryption/internode-encryption.md" >}}).
+---
+Title: Manage Redis Enterprise cluster (REC) certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install your own certificates to be used by the Redis Enterprise cluster's
+  operator.
+linkTitle: Manage REC certificates
+weight: 94
+url: '/operate/kubernetes/7.4.6/security/manage-rec-certificates/'
+---
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes added to the cluster. For the list of of certificates used by Redis Enterprise Software and the traffic they encrypt, see the [certificates table]({{< relref "/operate/rs/security/certificates" >}}).
+
+To install and use your own certificates with Kubernetes on your Redis Enterprise cluster, they need to be stored in [secrets](https://kubernetes.io/docs/concepts/configuration/secret/). The REC custom resource also needs to be configured with those secret names to read and use the certificates.
+
+## Create a secret to hold the new certificate
+
+Create the [secret](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-kubectl/) with the required fields shown below.
+
+  ```sh
+  kubectl create secret generic <secret-name> \
+    --from-file=certificate=</PATH/TO/certificate.pem> \
+    --from-file=key=</PATH/TO/key.pem> \
+    --from-literal=name=<proxy | api | cm | syncer | metrics_exporter>
+  ```
+
+## Update certificates in the REC custom resource
+
+Edit the Redis Enterprise cluster (REC) custom resource to add a `certificates` subsection under the `spec` section. You are only required to add the fields for the certificates you are installing.
+
+```yaml
+spec:
+  certificates:
+    apiCertificateSecretName: <apicert-secret-name>
+    cmCertificateSecretName: <cmcert-secret-name>
+    syncerCertificateSecretName: <syncercert-secret-name>
+    metricsExporterCertificateSecretName: <metricscert-secret-name>
+    proxyCertificateSecretName: <proxycert-secret-name>
+```
+
+### Update certificates through the API
+
+Alternatively, you can also update the REC certificates via the API:
+
+```API
+PUT /v1/cluster/update_cert
+{
+   "certificate": <certificate>, 
+   "key": <cert-key>,
+   "name": <cert-name> 
+}
+```
+
+### Verify the certificate was updated
+
+Check the operator logs and use the API to verify the certificate has been updated.
+
+  ```api
+  GET /v1/cluster/certificates
+  ```
+
+## More info
+
+- [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates" >}})
+- [Install your own certificates]({{< relref "/operate/rs/security/certificates/create-certificates" >}})
+- [Glossary/Transport Layer Security (TLS)]({{< relref "/glossary#letter-t" >}})
+---
+Title: Enable LDAP authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable LDAP authentication for Redis Enterprise for Kubernetes.
+linkTitle: Enable LDAP
+weight: 95
+url: '/operate/kubernetes/7.4.6/security/ldap/'
+---
+
+## LDAP support for Redis Enterprise Software
+
+Redis Enterprise Software supports LDAP authentication and authorization through [role-based access controls]({{< relref "/operate/rs/security/access-control/" >}}) (RBAC). You can map LDAP groups to [Redis Enterprise roles]({{< relref "/operate/rs/security/access-control" >}}) to control access to your database and the Cluster Manager UI. For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+
+Redis Enterprise for Kubernetes supports enabling and configuring LDAP authentication using the `RedisEnterpriseCluster` (REC) custom resource. Currently, the Redis Enterprise cluster (REC) only supports configuration related to the LDAP server, such as server addresses, connection details, credentials, and query configuration.
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+## Enable LDAP 
+
+To enable LDAP for your REC, use the `.spec.ldap` field in the `RedisEnterpriseCluster` custom resource.
+
+The following `RedisEnterpriseCluster` example resource enables a basic LDAP configuration:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  ldap:
+    protocol: LDAP
+    servers:
+    - host: openldap.openldap.svc
+      port: 389
+    bindCredentialsSecretName: ldap-bind-credentials
+    cacheTTLSeconds: 600
+    enabledForControlPlane: true
+    enabledForDataPlane: true
+    authenticationQuery:
+      template: cn=%u,ou=default,dc=example,dc=org
+    authorizationQuery:
+      attribute: memberOf
+```
+
+Refer to the `RedisEnterpriseCluster` [API reference](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#ldapspec) for full details on the available fields.
+
+### Bind credentials
+
+For LDAP servers that require authentication for client queries, store the bind credentials in a secret and reference them in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to store the bind credentials.
+    
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <bind-secret-name> \
+        --from-literal=dn='<disinguished-name>' \
+        --from-literal=password=<password>
+    ```
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `dn` key with the distinguished name for the user performing the query (such as `cn=admin,dc=example,dc=org`).
+    - Include a `password` key with the bind password.
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.ldap.bindCredentialsSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        bindCredentialsSecretName: <bind-secret-name>
+    ```
+
+### LDAPS or STARTTLS protocols
+
+In addition to plain LDAP protocol, Redis Enterprise Software also supports LDAPS and STARTTLS protocols for secure communication with the LDAP server.
+
+To enable one of these protocols, edit the `spec.ldap.protocol` field in the `RedisEnterpriseCluster` custom resource:
+
+#### Enable `LDAPS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: LDAPS
+  ```
+
+  Default port: 636
+
+#### Enable `STARTTLS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: STARTTLS
+  ```
+
+  Default port: 389
+
+### CA certificate
+
+To use a custom CA certificate for validating the LDAP server certificate, store the CA certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the CA certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <ca-secret-name> \
+        --from-file=cert=<ca-cert>.pem
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `cert` key with a PEM-encoded CA certificate (such as `cacert.pem`).
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `spec.ldap.caCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        caCertificateSecretName: <ca-secret-name>
+    ```
+
+### Client certificates
+
+To use an LDAP client certificate, store the certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the client certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <client-secret-name> \
+      --from-literal=name=ldap_client \
+      --from-file=certificate=<client-cert-file> \
+      --from-file=key=<private-key-file>
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `name` key explicitly set to `ldap_client`.
+    - Include a `certificate` key for the public key (such as `cert.pem`).
+    - Include a `key` key for the private key (such as `key.pem`).
+    
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.certificates.ldapClientCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource, substituting your own values for `<placeholders>`.
+
+    ```yaml
+    spec:
+      certificates:
+        ldapClientCertificateSecretName: <client-secret-name>
+    ```
+
+## Known limitations
+
+Redis Enterprise Software can't resolve DNS names with a `.local` suffix.
+  If your LDAP server is in the same Kubernetes cluster and exposed via a Service object, *avoid* addresses such as `openldap.openldap.svc.cluster.local`. Instead, *use short-form addresses* such as `openldap.openldap.svc`.
+
+## Next steps
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+---
+categories:
+- docs
+- operate
+- kubernetes
+description: Add client certificates to your REDB custom resource.
+linkTitle: Add client certificates
+title: Add client certificates
+weight: 95
+url: '/operate/kubernetes/7.4.6/security/add-client-certificates/'
+---
+
+For each client certificate you want to use with your database, you need to create a Kubernetes secret to hold it. You can then reference that secret in your Redis Enterprise database (REDB) custom resource spec.
+
+## Create a secret to hold the new certificate
+
+1. [Create the secret config file](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-config-file/) with the required fields shown below.
+
+    ```yaml
+    apiVersion: v1
+    kind: Secret
+    type: Opaque
+    metadata:
+      name: <client-cert-secret>
+      namespace: <your-rec-namespace>
+    data:
+      cert: <client-certificate>
+    ```
+  
+1. Apply the file to create the secret resource.
+
+    ```bash
+    kubectl apply -f <client-cert-secret>.yaml
+    ```
+
+## Edit the REDB resource
+
+1. Add the secret name to the REDB custom resource (`redb.yaml`) with the `clientAuthenticationCertificates` property in the `spec` section.
+
+  ```yaml
+   spec:
+      clientAuthenticationCertificates:
+      - <client-cert-secret>
+  ```
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Security settings and configuration for Redis Enterprise for Kubernetes
+hideListLinks: false
+linkTitle: Security
+weight: 50
+url: '/operate/kubernetes/7.4.6/security/'
+---
+
+This section contains security settings and configuration for Redis Enterprise for Kubernetes.
+
+
+---
+Title: Configure Istio for external routing
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure Istio as an ingress controller for access to your Redis Enterprise
+  databases from outside the Kubernetes cluster.
+linkTitle: Istio ingress routing
+weight: 20
+url: '/operate/kubernetes/7.4.6/networking/istio-ingress/'
+---
+
+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.
+
+## Install and configure Istio for Redis Enterprise
+
+1. [Download](https://istio.io/latest/docs/setup/getting-started/) and [install](https://istio.io/latest/docs/setup/getting-started/) Istio (see instructions from Istio's [Getting Started](https://istio.io/latest/docs/setup/getting-started/) guide).
+
+    Once the installation is complete, all the deployments, pods, and services will be deployed in a namespace called `istio-system`. This namespace contains a `LoadBalancer` type service called `service/istio-ingressgateway` that exposes the external IP address.
+
+1. Find the `EXTERNAL-IP` for the `istio-ingressgateway` service.
+
+    ```sh
+    kubectl get svc istio-ingressgateway -n istio-system
+
+    NAME                   TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)                                                                      AGE
+    istio-ingressgateway   LoadBalancer   10.34.67.89   10.145.78.91   15021:12345/TCP,80:67891/TCP,443:23456/TCP,31400:78901/TCP,15443:10112/TCP   3h8m
+    ```
+
+1. Create a DNS entry that resolves your chosen database hostname (or a wildcard `*` followed by your domain) to the Istio `EXTERNAL-IP`. Use this hostname to access your database from outside the cluster.
+
+    In this example, any hostname that ends with `.istio.k8s.my.example.com` will resolve to the Istio LoadBalancer's external IP of `10.145.78.91`. Substitute your own values accordingly.
+
+1. Verify the record was created successfully.
+
+    ```sh
+    dig api.istio.k8s.my.example.com
+    ```
+
+    Look in the `ANSWER SECTION` for the record you just created.
+
+    ```sh
+    ;; ANSWER SECTION:
+    api.istio.k8s.my.example.com 0 IN    A       10.145.78.91
+    ```
+
+## Create custom resources
+
+### `Gateway` custom resource
+
+1. On a different namespace from `istio-system`, create a `Gateway` custom resource file (`redis-gateway.yaml` in this example).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - Replace `<selector-label>` with the label set on your Istio ingress gateway pod (most common is `istio: ingress`).
+    - TLS passthrough mode is required to allow secure access to the database.
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: Gateway
+    metadata:
+      name: redis-gateway
+    spec:
+      selector:
+        istio: <selector-label>
+      servers:
+      - hosts:
+        - '*.istio.k8s.my.example.com'
+        port:
+          name: https
+          number: 443
+          protocol: HTTPS
+        tls:
+          mode: PASSTHROUGH
+    ```
+
+
+
+1. Apply the `Gateway` custom resource file to create the Ingress gateway.
+
+    ```sh
+    kubectl apply -f redis-gateway.yaml
+    ```
+
+1. Verify the gateway was created successfully.
+
+      ```sh
+      kubectl get gateway
+
+      NAME            AGE
+      redis-gateway   3h33m
+      ```
+
+### `VirtualService` custom resource
+
+1. On a different namespace than `istio-system`, create the `VirtualService` custom resource file (`redis-vs.yaml` in this example).
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: VirtualService
+    metadata:
+      name: redis-vs
+    spec:
+      gateways:
+      - redis-gateway
+      hosts:
+      - "*.istio.k8s.my.example.com"
+      tls:
+      - match:
+        - port: 443
+          sniHosts:
+          - api.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: rec1
+            port:
+              number: 9443
+      - match:
+        - port: 443
+          sniHosts:
+          - db1.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: db1
+    ```
+
+    This creates both a route to contact the API server on the REC (`rec1`) and a route to contact one of the databases (`db1`).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - The gateway's metadata name must be similar to the gateway's spec name (`redis-gateway` in this example).
+   
+1. Apply `VirtualService` custom resource file to create the virtual service.
+
+    ```sh
+    kubectl apply -f redis-vs.yaml
+    ```
+
+1. Verify the virtual service was created successfully.
+
+    ```sh
+    kubectl get vs
+
+    NAME       GATEWAYS            HOSTS                              AGE
+    redis-vs   ["redis-gateway"]   ["*.istio.k8s.my.example.com"]   3h33m
+    ```
+
+1. [Deploy the operator]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md" >}}), Redis Enterprise Cluster (REC), and Redis Enterprise Database (REDB) on the same namespace as the gateway and virtual service.
+
+## Test your external access to the database
+
+To [test your external access]({{< relref "/operate/kubernetes/7.4.6/networking/ingress.md" >}}) to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).
+
+See [Test your access with Openssl]({{< relref "/operate/kubernetes/7.4.6/networking/ingress#test-your-access-with-openssl" >}}) or [Test your access with Python]({{< relref "/operate/kubernetes/7.4.6/networking/ingress#test-your-access-with-python" >}}) for more info.
+---
+Title: Use OpenShift routes for external database access
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: OpenShift routes
+weight: 15
+url: '/operate/kubernetes/7.4.6/networking/routes/'
+---
+
+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](https://docs.openshift.com/container-platform/4.13/networking/routes/route-configuration.html).
+
+## 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.
+
+  By default, the DMC Proxy uses a self-signed certificate.  You can retrieve it from the Redis Enterprise admin console and save it as a file (for example, named "ca.pem") on the client machine.
+
+* Your database also needs TLS encryption enabled.
+
+## Create OpenShift route
+
+1. Select the **Networking/Routes** section of the OpenShift web console.
+
+1. Select **Create route** and fill out the following fields:
+
+   * **Name**: Choose any name you want as the first part of your generated hostname
+   * **Hostname**: Leave blank
+   * **Path**: Leave as is ("/")
+   * **Service**: Select the service for the database you want to access
+   * **TLS Termination**: Choose "passthrough"
+   * **Insecure Traffic**: Select "None"
+
+1. Select **Create**.
+
+1. Find the hostname for your new route. After route creation, it appears in the "Host" field.
+
+1. Verify you have a DNS entry to resolve the hostname for your new route to the cluster's load balancer.
+
+## Access database
+
+Access the database from outside the cluster using `redis-cli` or `openssl`.
+
+To connect with `redis-cli`:
+  
+   ```sh
+   redis-cli -h <hostname> -p 443 --tls --cacert ./ca.pem --sni <hostname>
+   ```
+
+Replace the `<hostname>` value with the hostname for your new route.
+
+To connect with `openssl`:
+
+   ```sh
+   openssl s_client -connect <hostname>:443 -crlf -CAfile ./ca.pem -servername <hostname>
+   ```
+---
+Title: Configure Ingress for external routing
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure an ingress controller to access your Redis Enterprise databases
+  from outside the Kubernetes cluster.
+linkTitle: Ingress routing
+weight: 5
+url: '/operate/kubernetes/7.4.6/networking/ingress/'
+---
+
+## Prerequisites
+
+Before creating an Ingress, you'll need:
+
+ - A RedisEnterpriseDatabase (REDB) with TLS enabled for client connections
+ - A supported Ingress controller with `ssl-passthrough` enabled
+    - [Ingress-NGINX Controller](https://kubernetes.github.io/ingress-nginx/deploy/)
+        - Be sure to use the `kubernetes/ingress-nginx` controller and NOT the `nginxinc/kubernetes-ingress` controller.
+    - [HAProxy Ingress](https://haproxy-ingress.github.io/docs/getting-started/)
+    - To use Istio for your Ingress resources, see [Configure Istio for external routing]({{< relref "/operate/kubernetes/7.4.6/networking/istio-ingress.md" >}})
+
+{{<note>}}Make sure your Ingress controller has `ssl-passthrough`enabled. This is enabled by default for HAProxy, but disabled by default for NGINX. See the [NGINX User Guide](https://kubernetes.github.io/ingress-nginx/user-guide/tls/#ssl-passthrough) for details. {{</note>}}
+
+## Create an Ingress resource
+
+1. Retrieve the hostname of your Ingress controller's `LoadBalancer` service.
+
+    ``` sh
+    $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                        -n <ingress-ctrl-namespace>
+    ```
+
+    Below is example output for an HAProxy running on a K8s cluster hosted by AWS.  
+
+    ``` sh
+    NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+    haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+    ```
+
+1. Choose the hostname you will use to access your database (this value will be represented in this article with `<my-db-hostname>`).  
+
+1. Create a DNS entry that resolves your chosen database hostname to the IP address for the Ingress controller's LoadBalancer.  
+
+1. Create the Ingress resource YAML file.  
+
+    ``` YAML
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    metadata:
+      name: rec-ingress
+      annotations:
+        <controller-specific-annotations-below>
+    spec:
+      rules:
+      - host: <my-db-hostname>
+        http:
+          paths:
+          - path: /
+            pathType: ImplementationSpecific
+            backend:
+              service:
+                name: <db-name>
+                port:
+                  name: redis
+    ```  
+
+    For HAProxy, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: haproxy
+     ingress.kubernetes.io/ssl-passthrough: "true"
+    ```
+
+    For NGINX, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: nginx
+    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    ```  
+
+    The `ssl-passthrough` annotation is required to allow access to the database. The specific format changes depending on your Ingress controller and any additional customizations. See [NGINX Configuration annotations](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) and [HAProxy Ingress Options](https://www.haproxy.com/documentation/kubernetes/latest/configuration/ingress/) for updated annotation formats.  
+
+## Test your external access  
+
+To test your external access to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).  
+
+#### Test your access with Openssl  
+
+1. Get the default CA certificate from the `redis-enterprise-node` container on any of the Redis Enterprise pods.  
+
+    ``` sh
+    $ kubectl exec -it <pod-name> -c redis-enterprise-node \
+                    -- cat /etc/opt/redislabs/proxy_cert.pem
+    ```  
+
+1. Run the following `openssl` command, substituting your own values for `<my-db-hostname>`.  
+
+    ``` sh
+    $ openssl s_client \
+      -connect <my-db-hostname>:443 \
+      -crlf -CAfile ./proxy_cert.pem \
+      -servername <my-db-hostname>
+    ```  
+
+    If you are connected to the database, you will receive `PONG` back, as shown below:  
+
+    ``` sh
+    ...
+     Verify return code: 0 (ok)
+    ---
+
+    PING
+    +PONG
+    ```  
+
+#### Test your access with Python  
+
+You can use the code below to test your access with Python, substituting your own values for `<my-db-hostname>` and `<file-path>`.  
+
+``` python
+import redis
+
+r = redis.StrictRedis(host='<my-db-hostname>',
+              port=443, db=0, ssl=True,
+              ssl_ca_certs='/<file-path>/proxy_cert.pem')
+
+
+print(r.info())
+```
+
+Your output should look something like this:  
+
+``` sh
+$ /Users/example-user/Documents/Projects/test_client/venv3.7/bin/python \
+    /Users/example-user/Documents/Projects/test_client/test_ssl.py
+{
+    'redis_version': '5.0.5',
+    'redis_git_sha1': 0,
+    'redis_git_dirty': 0,
+    'redis_build_id': 0,
+    'redis_mode': 'standalone',
+    'os': 'Linux 4.14.154-128.181.amzn2.x86_64 x86_64',
+    'arch_bits': 64,
+    'multiplexing_api': 'epoll',
+    'gcc_version': '7.4.0',
+    'process_id': 1,
+    'run_id': '3ce7721b096517057d28791aab555ed8ac02e1de',
+    'tcp_port': 10811,
+    'uptime_in_seconds': 316467,
+    'uptime_in_days': 3,
+    'hz': 10,
+    'lru_clock': 0,
+    'config_file': '',
+    'connected_clients': 1,
+    'client_longest_output_list': 0,
+    'client_biggest_input_buf': 0,
+    'blocked_clients': 0,
+    'used_memory': 12680016,
+    'used_memory_human': '12.9M',
+    'used_memory_rss': 12680016,
+    'used_memory_peak': 13452496,
+    'used_memory_peak_human': '12.82M',
+    'used_memory_lua': 151552,
+    'mem_fragmentation_ratio': 1,
+    'mem_allocator': 'jemalloc-5.1.0',
+    'loading': 0,
+    'rdb_changes_since_last_save': 0,
+    'rdb_bgsave_in_progress': 0,
+    'rdb_last_save_time': 1577753916,
+    'rdb_last_bgsave_status': 'ok',
+    'rdb_last_bgsave_time_sec': 0,
+    'rdb_current_bgsave_time_sec': -1,
+    'aof_enabled': 0,
+    'aof_rewrite_in_progress': 0,
+    'aof_rewrite_scheduled': 0,
+    'aof_last_rewrite_time_sec': -1,
+    'aof_current_rewrite_time_sec': -1,
+    'aof_last_bgrewrite_status': 'ok',
+    'aof_last_write_status': 'ok',
+    'total_connections_received': 4,
+    'total_commands_processed': 6,
+    'instantaneous_ops_per_sec': 14,
+    'total_net_input_bytes': 0,
+    'total_net_output_bytes': 0,
+    'instantaneous_input_kbps': 0.0,
+    'instantaneous_output_kbps': 0.0,
+    'rejected_connections': 0,
+    'sync_full': 1,
+    'sync_partial_ok': 0,
+    'sync_partial_err': 0,
+    'expired_keys': 0,
+    'evicted_keys': 0,
+    'keyspace_hits': 0,
+    'keyspace_misses': 0,
+    'pubsub_channels': 0,
+    'pubsub_patterns': 0,
+    'latest_fork_usec': 0,
+    'migrate_cached_sockets': 0,
+    'role': 'master',
+    'connected_slaves': 1,
+    'slave0': {
+        'ip': '0.0.0.0',
+        'port': 0,
+        'state': 'online',
+        'offset': 0,
+        'lag': 0
+    },
+    'master_repl_offset': 0,
+    'repl_backlog_active': 0,
+    'repl_backlog_size': 1048576,
+    'repl_backlog_first_byte_offset': 0,
+    'repl_backlog_histlen': 0,
+    'used_cpu_sys': 0.0,
+    'used_cpu_user': 0.0,
+    'used_cpu_sys_children': 0.0,
+    'used_cpu_user_children': 0.0,
+    'cluster_enabled': 0
+}
+
+Process finished with exit code 0
+```
+---
+Title: Networking
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+linkTitle: Networking
+weight: 40
+url: '/operate/kubernetes/7.4.6/networking/'
+---
+
+Redis Enterprise for Kubernetes supports several ways to route external traffic to your RedisEnterpriseCluster:
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/7.4.6/networking/routes.md" >}}) to route external traffic.
+- The RedisEnterpriseActiveActiveDatabase (REAADB) requires any of the above routing methods to be configured in the RedisEnterpriseCluster (REC) with the `ingressOrRouteSpec` field.
+
+## External routing using Redis Enterprise for Kubernetes
+
+Every time a RedisEnterpriseDatabase (REDB), Redis Enterprise Active-Active database (REAADB), or Redis Enterprise cluster (REC) is created, the Redis Enterprise operator automatically creates a [service](https://kubernetes.io/docs/concepts/services-networking/service/) to allow requests to be routed to that resource.
+
+Redis Enterprise supports three [types of services](https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types) for accessing databases: `ClusterIP`, `headless`, or `LoadBalancer`.
+
+By default, the operator creates a `ClusterIP` type service, which exposes a cluster-internal IP and that can only be accessed from within the K8s cluster. For requests to be routed from outside the K8s cluster, you need an [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) (or [route](https://docs.openshift.com/container-platform/4.12/networking/routes/route-configuration.html) if you are using OpenShift). See [kubernetes.io](https://kubernetes.io/docs/) for more details on [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) and [Ingress controllers](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/).
+
+* To use NGINX or HAProxy Ingress controllers, see [Ingress routing]({{< relref "/operate/kubernetes/7.4.6/networking/ingress.md" >}}).
+* To use OpenShift routes, see [OpenShift routes]({{< relref "/operate/kubernetes/7.4.6/networking/routes.md" >}}).
+* To use Istio as an Ingress controller, see [Istio Ingress routing]({{< relref "/operate/kubernetes/7.4.6/networking/istio-ingress.md" >}})
+
+## `ingressOrRouteSpec` for Active-Active databases
+
+Versions 6.4.2 or later of Redis Enterprise for Kubernetes include a feature for ingress configuration. The `ingressOrRouteSpec` field is available in the RedisEnterpriseCluster spec to automatically create an Ingress (or route) for the API service and databases (REAADB) on that REC. See [REC external routing]({{< relref "/operate/kubernetes/7.4.6/networking/ingressorroutespec.md" >}}) for more details.
+
+This feature only supports automatic Ingress creation for Active-Active databases created and managed with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. Use with the standard Redis Enterprise database (REDB) is not currently supported.
+
+## REC domain name
+
+The RedisEnterpriseCluster does not support custom domain names. Domain names for the REC are in the following format: `<rec-name>.<namespace>.svc.cluster.local`.
+---
+Title: Establish external routing on the RedisEnterpriseCluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: REC external routing
+weight: 30
+url: '/operate/kubernetes/7.4.6/networking/ingressorroutespec/'
+---
+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:
+* [HAProxy](https://haproxy-ingress.github.io/)
+* [NGINX](https://kubernetes.github.io/ingress-nginx/)
+* [Istio](https://istio.io/latest/docs/setup/getting-started/)
+
+OpenShift users can use [routes]({{< relref "/operate/kubernetes/7.4.6/networking/routes.md" >}}) instead of an Ingress.
+
+Install your chosen Ingress controller, making sure `ssl-passthrough` is enabled. `ssl-passthrough` is turned off by default for NGINX but enabled by default for HAProxy.
+
+## Configure DNS
+
+1. Choose the hostname (FQDN) you will use to access your database according to the recommended naming conventions below, replacing `<placeholders>` with your own values.
+
+     REC API hostname: `api-<rec-name>-<rec-namespace>.<subdomain>`
+     REAADB hostname: `-db-<rec-name>-<rec-namespace>.<subdomain>`
+     
+     We recommend using a wildcard (`*`) in place of the database name, followed by the hostname suffix.
+
+1. Retrieve the `EXTERNAL-IP` of your Ingress controller's `LoadBalancer` service.
+
+     ``` sh
+     $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                         -n <ingress-ctrl-namespace>
+     ```
+
+     Below is example output for an HAProxy ingress controller running on a K8s cluster hosted by AWS.  
+
+     ``` sh
+     NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+     haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+     ```
+
+1. Create DNS records to resolve your chosen REC API hostname and database hostname to the `EXTERNAL-IP` found in the previous step.
+
+## Edit the REC spec
+
+Edit the RedisEnterpriseCluster (REC) spec to add the `ingressOrRouteSpec` field, replacing `<placeholders>` below with your own values.
+
+### NGINX or HAproxy ingress controllers
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `ingress`.
+* Set `ssl-passthrough` to "true".
+* Add any additional annotations required for your ingress controller. See [NGINX docs](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) or [HAproxy docs](https://haproxy-ingress.github.io/docs/configuration/keys/) for more information.
+
+```sh
+kubectl patch rec  <rec-name> --type merge --patch "{\"spec\": \
+    {\"ingressOrRouteSpec\": \
+      {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\", \
+      \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+      \"ingressAnnotations\": \
+       {\"<kubernetes | github>.io/ingress.class\": \
+       \"<ingress-controller>\", \
+       \"<ingress-controller-annotation>/ssl-passthrough\": \ \"true\"}, \
+      \"method\": \"ingress\"}}}"
+```
+
+### OpenShift routes
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `openShiftRoute`.
+
+```sh
+kubectl patch rec <rec-name> --type merge --patch "{\"spec\": \
+     {\"ingressOrRouteSpec\": \
+     {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\" \ 
+     \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+     \"method\": \"openShiftRoute\"}}}"
+```
+
+OpenShift routes do not require any `ingressAnnotations` in the `ingressOrRouteSpec`.
+---
+Title: Delete custom resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article explains how to delete Redis Enterprise clusters and Redis
+  Enterprise databases from your Kubernetes environment.
+linkTitle: Delete custom resources
+weight: 70
+url: '/operate/kubernetes/7.4.6/delete-custom-resources/'
+---
+
+## Multi-namespace management
+
+Before you can delete a namespace, you must remove the Redis custom resources ([REDB](#delete-a-database-redb), [REC](#delete-a-redis-enterprise-cluster-rec), and [operator](#delete-operator-from-one-namespace)) residing within a namespace before you can delete that namespace. Deleting namespace containing an REDB may cause errors or data loss.
+
+## Delete a database (REDB)
+
+To delete a database managed by the Redis Enterprise Kubernetes operator, run `kubectl delete redb <your-db-name>` from your K8s cluster.
+
+When you delete a database, your data and the REDB custom resource are also deleted.
+
+## Delete a Redis Enterprise cluster (REC)
+
+To delete a Redis Enterprise cluster managed by the operator:
+
+1. Delete all the databases in your cluster.
+
+2. Run `kubectl delete rec <your-rec-name>` from your K8s cluster.
+
+When you delete your cluster, your databases and the REC custom resource are also deleted. However, persistent volume claims (PVCs) for your cluster are not deleted in the process. If you want to delete your PVCs, you'll have to delete them manually.
+
+## Delete the operator
+
+There are two ways to delete the operator. You can delete the entire operator bundle, but this will also delete any cluster-wide resources created by the operator. To only delete resources within a specific namespace and leave other cluster-wide resources intact, you need to delete each resource manually.
+
+Whether you decide to delete the entire bundle or just resources from a specific namespace, it's important to delete the operator ConfigMap (`operator-environment-config`).
+
+```sh
+kubectl delete cm operator-environment-config
+```
+
+### Delete operator bundle
+
+To delete the operator from your K8s cluster, you can delete the operator bundle with:
+
+- `kubectl delete -f bundle.yaml` for non-OpenShift K8s deployments
+- `kubectl delete -f openshift.bundle.yaml` for OpenShift deployments 
+
+This will remove the operator and its custom resource definitions (CRDs) from your K8s cluster.
+
+{{< warning >}} The Redis Enterprise CRDs are non-namespaced resources, meaning they are shared across your entire K8s cluster. Deleting CRDs in one namespace will delete custom resources in every other namespace across the K8s cluster.{{</warning>}}
+
+### Delete operator from one namespace
+
+If you have Redis Enterprise clusters running in different namespaces on the same K8s cluster, deleting the entire operator bundle might cause data loss.
+
+To safely delete the operator from one namespace without affecting the others, delete the operator files individually, excluding the CRD files:
+
+```sh
+kubectl delete -f role.yaml
+kubectl delete -f role_binding.yaml
+kubectl delete -f service_account.yaml
+kubectl delete -f admission-service.yaml
+kubectl delete -f operator.yaml
+```
+
+You will also need to remove [the `namespaceSelector` section from the validating webhook]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start#webhook" >}}).
+
+## Delete an Active-Active database (REAADB)
+
+1. On one of the existing participating clusters, delete the REEADB (substituting `<reaadb-name>` with your database name).
+
+  ```sh
+  kubectl delete reaadb <reaadb-name>
+  ```
+
+2. Verify the REAADB no longer exists. 
+
+  ```sh
+  kubectl get reaadb -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Delete a remote cluster (RERC)
+
+1. Verify the RERC you want to delete isn't listed as a participating cluster in any REAADB resources.
+
+    If an RERC is still listed as a participating cluster in any database, the deletion will be blocked.
+
+2. On one of the existing participating clusters, delete the RERC (substituting `<rerc-name>` with your database name).
+
+  ```sh
+  kubectl delete rerc <rerc-name>
+  ```
+
+3. Verify the RERC no longer exists.
+
+  ```sh
+  kubectl get rerc -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Troubleshoot REDB deletion
+
+The operator attaches a finalizer to the Redis Enterprise database (REDB) object. This makes sure the database is deleted before the REDB custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REDB resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REDB has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch redb <your-db-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"finalizer.redisenterprisedatabases.app.redislabs.com"}]'
+```
+
+## Troubleshoot REC deletion
+
+The operator attaches a finalizer to the Redis Enterprise cluster (REC) object. This makes sure the Redis cluster is deleted before the REC custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REC resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REC has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch rec <your-rec-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"redbfinalizer.redisenterpriseclusters.app.redislabs.com"}]'
+```
+---
+Title: Control node selection
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how Redis Enterprise cluster
+  pods can be scheduled to only be placed on specific nodes or node pools.
+linkTitle: Node selection
+weight: 80
+url: '/operate/kubernetes/7.4.6/recommendations/node-selection/'
+---
+
+Many Kubernetes cluster deployments have different kinds of nodes that have
+different CPU and memory resources available for scheduling cluster workloads.
+Redis Enterprise for Kubernetes has various abilities to control the scheduling
+Redis Enterprise cluster node pods through properties specified in the
+Redis Enterprise cluster custom resource definition (CRD).
+
+A Redis Enterprise cluster (REC) is deployed as a StatefulSet which manages the Redis Enterprise cluster node pods.
+The scheduler chooses a node to deploy a new Redis Enterprise cluster node pod on when:
+
+- The cluster is created
+- The cluster is resized
+- A pod fails
+
+Here are the ways that you can control the pod scheduling:
+
+## Using node selectors
+
+The [`nodeSelector`]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api#spec">}})
+property of the cluster specification uses the same values and structures as
+the [Kubernetes `nodeSelector`](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector).
+In general, node labels are a simple way to make sure that specific nodes are used for Redis Enterprise pods.
+For example, if nodes 'n1' and 'n2' are labeled as "high memory":
+
+```sh
+kubectl label nodes n1 memory=high
+kubectl label nodes n2 memory=high
+```
+
+The Redis Enterprise cluster CRD can request to be scheduled on these nodes:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     memory: high
+```
+
+Then, when the operator creates the StatefulSet associated with the pod, the nodeSelector
+section is part of the pod specification. When the scheduler attempts to
+create new pods, it needs to satisfy the node selection constraints.
+
+
+## Using node pools
+
+A node pool is a common part of the underlying infrastructure of the Kubernetes cluster deployment and provider.
+Often, node pools are similarly-configured classes of nodes such as nodes with the same allocated amount of memory and CPU.
+Implementors often label these nodes with a consistent set of labels.
+
+On Google Kubernetes Engine (GKE), all node pools have the label `cloud.google.com/gke-nodepool` with a value of the name used during configuration.
+On Microsoft Azure Kubernetes System (AKS), you can create node pools with a specific set of labels. Other managed cluster services may have similar labeling schemes.
+
+You can use the `nodeSelector` section to request a specific node pool by label values. For example, on GKE:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     cloud.google.com/gke-nodepool: 'high-memory'
+```
+
+## Using node taints
+
+You can use multiple node taints with a set of tolerations to control Redis Enterprise cluster node pod scheduling.
+The `podTolerations` property of the cluster specification specifies a list of pod tolerations to use.
+The value is a list of [Kubernetes tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/#concepts).
+
+For example, if the cluster has a single node pool, the node taints can control the allowed workloads for a node.
+You can add taints to the node, for example nodes n1, n2, and n3, reserve a set of nodes for the Redis Enterprise cluster:
+
+```sh
+kubectl taint nodes n1 db=rec:NoSchedule
+kubectl taint nodes n2 db=rec:NoSchedule
+kubectl taint nodes n3 db=rec:NoSchedule
+```
+
+This prevents any pods from being scheduled onto the nodes unless the pods can tolerate the taint `db=rec`.
+
+You can then add the toleration for this taint to the cluster specification:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podTolerations:
+  - key: db
+    operator: Equal     
+    value: rec
+    effect: NoSchedule
+```
+
+A set of taints can also handle more complex use cases.
+For example, a `role=test` or `role=dev` taint can be used to designate a node as dedicated for testing or development workloads via pod tolerations.
+
+## Using pod anti-affinity
+
+By default, the Redis Enterprise node pods are not allowed to be placed on the same node for the same cluster:
+
+```yaml
+podAntiAffinity:
+  requiredDuringSchedulingIgnoredDuringExecution:
+  - labelSelector:
+      matchLabels:
+        app: redis-enterprise
+        redis.io/cluster: rec
+        redis.io/role: node
+    topologyKey: kubernetes.io/hostname
+```
+
+Each pod has the three labels above where `redis.io/cluster` is the label for the name of your cluster.
+
+You can change this rule to restrict or include nodes that the Redis Enterprise cluster node pods can run on.
+For example, you can delete the `redis.io/cluster` label so that even Redis Enterprise node pods from different clusters cannot be scheduled on the same Kubernetes node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          app: redis-enterprise
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+or you can prevent Redis Enterprise nodes from being schedule with other workloads.
+For example, if all database workloads have the label 'local/role: database', you
+can use this label to avoid scheduling two databases on the same node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  extraLabels:
+     local/role: database
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          local/role: database
+          app: redis-enterprise
+          redis.io/cluster: rec
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+In this case, any pods that are deployed with the label `local/role: database` cannot be scheduled on the same node.
+
+
+## Using rack awareness
+
+You can configure Redis Enterprise with rack-zone awareness to increase availability
+during partitions or other rack (or region) related failures.
+
+{{%note%}}When creating your rack-zone ID, there are some constraints to consider; see [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness#rack-zone-id-rules" >}}) for more info. {{%/note%}}
+
+
+Rack-zone awareness is a single property in the Redis Enterprise cluster CRD named `rackAwarenessNodeLabel`.
+This value for this label is commonly `topology.kubernetes.io/zone` as documented in
+['Running in multiple zones'](https://kubernetes.io/docs/setup/best-practices/multiple-zones/#nodes-are-labeled).
+
+You can check the value for this label in your nodes with the command:
+
+```sh
+$kubectl get nodes -o custom-columns="name:metadata.name","rack\\zone:metadata.labels.failure-domain\.beta\.kubernetes\.io/zone"
+
+name                                            rack\zone
+ip-10-0-x-a.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-b.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-c.eu-central-1.compute.internal    eu-central-1b
+ip-10-0-x-d.eu-central-1.compute.internal    eu-central-1b
+```
+
+### Enabling the cluster role
+
+For the operator to read the cluster node information, you must create a cluster role for the operator and then bind the role to the service account.
+
+Here's a cluster role:
+
+```yaml
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+rules:
+  # needed for rack awareness
+  - apiGroups: [""]
+    resources: ["nodes"]
+    verbs: ["list", "get", "watch"]
+```
+
+And here's how to apply the role:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role.yaml
+```
+
+The binding is typically to the `redis-enterprise-operator` service account:
+
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+subjects:
+- kind: ServiceAccount
+  namespace: OPERATOR_NAMESPACE
+  name: redis-enterprise-operator
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator
+  apiGroup: rbac.authorization.k8s.io
+```
+
+and it can be applied by running:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role_binding.yaml
+```
+
+Once the cluster role and the binding have been applied, you can configure Redis Enterprise clusters to use rack awareness labels.
+
+### Configuring rack awareness
+
+You can configure the node label to read for the rack zone by setting the `rackAwarenessNodeLabel` property:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  nodes: 3
+  rackAwarenessNodeLabel: topology.kubernetes.io/zone
+```
+
+{{< note >}}
+When you use the `rackAwarenessNodeLabel` property, the operator will change the topologyKey for the anti-affinity rule to the label name used unless you have specified the `podAntiAffinity` property as well. If you use `rackAwarenessNodeLabel` and `podAntiAffinity` together, you must make sure that the `topologyKey` in your pod anti-affinity rule is set to the node label name.
+{{< /note >}}
+---
+Title: Size and scale a Redis Enterprise cluster deployment on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about sizing and scaling Redis Enterprise
+  in a Kubernetes deployment.
+linkTitle: Sizing and scaling
+weight: 50
+url: '/operate/kubernetes/7.4.6/recommendations/sizing-on-kubernetes/'
+---
+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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## Sizing and scaling cluster nodes
+
+### Setting the number of cluster nodes
+
+Define the number of cluster nodes in redis-enterprise-cluster.yaml file.
+
+    spec:
+
+        nodes: 3
+
+The number of nodes in the cluster must be an uneven number
+equal to or greater than 3. Refer to the article [Highly Available Redis](https://redislabs.com/redis-enterprise/technology/highly-available-redis/)
+for a detailed explanation on this topic.
+
+Set the number of cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling out
+
+To scale out a Redis Enterprise Cluster deployment, increase the number of nodes
+in the spec. For example, to scale the cluster out from 3 nodes to 5 nodes,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+    spec:
+
+        nodes: 5
+
+To apply the new cluster configuration run:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{<warning>}} Decreasing the number of nodes is not supported.{{</warning>}}
+
+### Sizing compute resources
+
+To set the compute resources required for each node,
+use the redisEnterpriseNodeResources spec field.
+
+Under redisEnterpriseNodeResources spec, set the following fields
+according to the provided guidelines.
+
+- limits – specifies the maximum compute resources for a Redis node
+- requests – specifies the minimum compute resources for a Redis node
+
+For example:
+
+    redisEnterpriseNodeResources:
+
+        limits:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+        requests:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+The default values, if unspecified, are 2 cores (2000m) and 4GB (4Gi).
+
+Set the compute resources for cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling up node compute resources
+
+To scale up nodes in an existing Redis Enterprise Cluster deployment,
+adjust the cpu and memory parameters in the spec. For example,
+to scale nodes up to the recommended amount of compute resources,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+redisEnterpriseNodeResources:
+
+    limits:
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+    requests
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+Then, apply the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{< warning >}}
+When adjusting compute resources, make sure the ratio of persistent volume size and the new memory size are in accordance to the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}). 
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.4.6/re-clusters/expand-pvc">}}) for details.
+{{< /warning >}}
+---
+Title: Manage node resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Recommendations on managing node resources and setting eviction thresholds
+  with Redis Enterprise for Kubernetes.
+linktitle: Manage resources
+weight: 17
+url: '/operate/kubernetes/7.4.6/recommendations/node-resources/'
+---
+ 
+
+
+## Node eviction thresholds
+
+ Kubernetes uses [node-pressure eviction](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/) to terminate pods and free up node resources. Redis Enterprise for Kubernetes works best when you use the recommendations below.
+
+Eviction thresholds are managed by [kubelet arguments](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/).
+
+Redis recommends setting a high [soft eviction threshold](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds). This changes the node condition early enough to alert the administrator.
+
+We also recommend setting the [`eviction-soft-grace-period`](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds) high enough for the administrator to scale the cluster.
+
+For more information about configuring eviction thresholds on specific platforms, see [Freeing node resources](https://docs.openshift.com/container-platform/4.9/nodes/nodes/nodes-nodes-garbage-collection.html) for OpenShift or [Cluster architecture](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable) for GKE.
+
+### Monitor node conditions
+
+Redis recommends monitoring the node conditions. If both `MemoryPressure` and `DiskPressure` are true, the eviction threshold was met.
+
+```sh
+> kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+
+For more information about monitoring node conditions, see [Node conditions](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#node-conditions) on [kubernetes.io](https://kubernetes.io/docs/home/).
+
+## Resource quotas
+
+Kubernetes uses the `ResourceQuota` object to limit resource consumption per namespace. This lets you limit the number of objects created by a namespace or the amount of compute resources consumed by a namespace. 
+
+The resource settings for Redis Enterprise for Kubernetes are defined in the `operator.yaml` and the [`RedisEnterpriseCluster`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#redisenterpriseclusterspec) custom resource.
+
+The following settings are the minimum workloads for the operator to function.
+
+```yaml
+  resources:
+    limits:
+      cpu: 0.5
+      memory: 256Mi
+    requests:
+      cpu: 0.5
+      memory: 256Mi
+```
+For more details on using resource quotas, see the [Kubernetes documentation](https://kubernetes.io/docs/concepts/policy/resource-quotas/).
+
+
+---
+Title: Use persistent volumes in Redis Enterprise clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section covers details about how persistent volumes are sized and
+  specified for Redis Enterprise cluster deployments.
+linkTitle: Persistent volumes
+weight: 40
+url: '/operate/kubernetes/7.4.6/recommendations/persistent-volumes/'
+---
+## 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.
+
+{{<warning>}}
+NFS, NFS-like, and multi-read-write/shared storage options are not supported. These types of storage are often slow and can cause locking behaviors that are incompatible with the requirements of database storage.
+{{</warning>}}
+
+## REC `persistentSpec` field 
+To deploy a Redis Enterprise cluster with Redis Enterprise operator the
+spec should include a *persistentSpec* section, in the
+*redis-enterprise-cluster.yaml* file:
+
+    spec:
+      nodes: 3
+      persistentSpec:
+       enabled: true
+       storageClassName: "standard"
+       volumeSize: "23Gi” #optional
+
+Persistence storage is a requirement for production deployments.
+
+{{< note >}}
+For **production deployments** of Redis Enterprise Cluster on Kubernetes,
+the Redis Enterprise Cluster (REC) must be deployed with persistence enabled.
+The REC deployment files in the [Kubernetes documentation](https://github.com/RedisLabs/redis-enterprise-k8s-docs) contain this declaration by default.
+{{< /note >}}
+
+## Volume size
+
+*volumeSize* is an optional definition. By default, if the definition is
+omitted, operator allocates five times (5x) the amount of memory (RAM)
+defined for nodes (see example below), which is the recommended
+persistent storage size as described in the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) article.
+
+To explicitly specify the persistent storage size, use the *volumeSize*
+property as described in the example above.
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.4.6/re-clusters/expand-pvc">}}) for details.
+
+{{< note >}}
+We recommend that you omit the volumeSize definition from the REC declaration
+so that the Redis Enterprise Cluster deployment on Kubernetes use the default volume size.
+{{< /note >}}
+
+## Storage class name
+
+*storageClassName* determines the Storage Class resource, which is
+defined by the Kubernetes cluster administrator, to be used for
+persistent storage.
+
+Different Kubernetes distributions and different deployments use
+different Storage Class resources.
+
+In order to determine the Storage Class resources available for your K8s
+deployment, use the following command:
+
+    kubectl get StorageClass
+
+Typically, AWS provides “gp2” as the Storage Class name while GKE uses “standard.”
+Azure provides two Storage Classes: "default" using HDDs, and "managed-premium" using SSDs.
+
+Below is an example of a response to the command.
+
+|                         |                                                         |
+| ----------------------- | ------------------------------------------------------- |
+| *Name:*                 | *gp2*                                                   |
+| *IsDefaultClass:*       | *Yes*                                                   |
+| *Annotations:*          | *storageclass.beta.kubernetes.io/is-default-class=true* |
+| *Provisioner:*          | *kubernetes.io/aws-ebs*                                 |
+| *Parameters:*           | *encrypted=false,kmsKeyId=,type=gp2*                    |
+| *AllowVolumeExpansion:* | *\<unset\>*                                             |
+| *MountOptions:*         | *\<none\>*                                              |
+| *ReclaimPolicy:*        | *Delete*                                                |
+| *VolumeBindingMode:*    | *Immediate*                                             |
+| *Events:*               | *\<none\>*                                              |
+
+{{< note >}}
+storageClassName must be specified for this deployment type.
+{{< /note >}}
+
+{{< warning >}}
+The storage class cannot be changed after deployment. Trying to change this value after deployment could result in unexpected and potentially damaging behavior.
+{{< /warning >}}
+
+Example of the redisEnterpriseNodeResources definition:
+
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: “4000m”
+        memory: 4Gi
+      requests:
+        cpu: “4000m”
+        memory: 4Gi
+---
+Title: Manage pod stability
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how you can use quality of service,
+  priority class, eviction thresholds and resource monitoring to maintain cluster
+  node pod stability.
+linkTitle: Pod stability
+weight: 90
+url: '/operate/kubernetes/7.4.6/recommendations/pod-stability/'
+---
+
+Kubernetes clusters manage the allocation of system resources and can evict pods to release system resources.
+Here are some ways that you can configure the Redis Enterprise node pods to maintain pod stability:
+
+## Guaranteed quality of service
+
+A running pod has a quality of service measure assigned to it that is
+one of three [quality of service classes](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/):
+Guaranteed, Burstable, and Best Effort.
+You can assure the Guaranteed class is assigned to the Redis Enterprise node pods
+by following the right guidelines.
+
+To get a Guaranteed quality of service class assigned:
+
+ * Every container in the pod must have a memory limit and a memory request, and they must be the same.
+ * Every container in the pod must have a CPU limit and a CPU request, and they must be the same.
+
+If resources limits and requests are not specified in the Redis Enterprise CRD,
+these requirements are met in the default version created by the operator. of your Redis Enterprise cluster CRD,
+Otherwise, you must set the limits and requests to the same value for memory and CPU in the `redisEnterpriseNodeResources`
+section of the CRD.
+
+Sidecar containers also impact the quality of service class assignment for the pod.
+
+To check the quality of service class of any running Redis Enterprise node pod, run:
+
+```sh
+kubectl get pod rec-0 --o jsonpath="{.status.qosClass}"
+```
+
+where `rec-0` is the name of one of the pods associated with the Redis Enterprise cluster.
+
+## Using priority to protect from preemption
+
+When a Redis Enterprise node pod is scheduled, it can be assigned a
+[priority class](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/)
+with the `priorityClassName` property. This property value is the name of
+a priority class that must already exist within the cluster.
+
+A sufficiently high priority will prevent other workloads with a lower
+priority from preempting the scheduling of Redis Enterprise Nodes. Similarly,
+a high value may also prevent eviction when lower priority workloads
+are deployed on the same cluster.
+
+The successful use of this strategy involves first creating a priority class with a very large priority value:
+
+```yaml
+apiVersion: scheduling.k8s.io/v1
+kind: PriorityClass
+metadata:
+  name: redis-enterprise-priority
+value: 1000000000
+globalDefault: false
+description: "This priority class should be used for Redis Enterprise pods only."
+```
+
+Then, you refer to the priority class by name in your Redis Enterprise cluster CRD:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  size: 3
+  priorityClassName: "redis-enterprise-priority"
+```
+
+Alternatively, you can also [disable preemption entirely](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#how-to-disable-preemption).
+
+## Managing eviction thresholds
+
+Eviction thresholds are typically managed by kubelet arguments.
+You can set the thresholds:
+
+- On OpenShift - In the [config file](https://docs.openshift.com/container-platform/3.11/admin_guide/out_of_resource_handling.html#out-of-resource-create-config).
+- On GKE - In the [managed settings](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable).
+
+We recommend that you:
+
+ * Set the [soft eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#soft-eviction-thresholds)
+   to be higher than the [hard eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#hard-eviction-thresholds).
+   The high soft threshold makes the node condition change earlier, and alerts the administrator.
+ * Set `eviction-max-pod-grace-period` high enough to allow the RS pods to migrate the Redis databases before the pods are force killed.
+ * Set the `eviction-soft-grace-period` high enough that the administrator (or a k8s auto-scaling mechanism) scales k8s up or out.
+
+## Monitoring for memory and disk usage
+
+We recommend that you monitor the node for MemoryPressure and DiskPressure.
+When both of these conditions are true, then an [eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#eviction-thresholds)
+is met and the pod is evicted.
+
+To retrieve the flags, run the command:
+
+```sh
+$kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+---
+Title: Configuration recommendations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Settings and configuration recommendations for your Redis Enterprise
+  deployment.
+hideListLinks: false
+linkTitle: Recommendations
+weight: 80
+url: '/operate/kubernetes/7.4.6/recommendations/'
+---
+
+This section contains  recommended settings and configuration for your Redis Enterprise for Kubernetes deployment.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes FAQs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+linkTitle: FAQs
+weight: 100
+url: '/operate/kubernetes/7.4.6/faqs/'
+---
+Here are some frequently asked questions about Redis Enterprise on integration platforms.
+
+## What is an Operator?
+
+An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources#custom-controllers) which extends the native K8s API. Refer to the article [Redis Enterprise K8s Operator-based deployments – Overview]({{< relref "/operate/kubernetes/7.4.6/architecture/operator" >}}).
+
+## Does Redis Enterprise operator support multiple RECs per namespace?
+
+Redis Enterprise for Kubernetes may only deploy a single Redis Enterprise cluster (REC) per [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each REC can run multiple databases while maintaining high capacity and performance.
+
+## Do I need to deploy a Redis Enterprise operator per namespace?
+
+Yes, one operator per namespace, each managing a single Redis Enterprise cluster.
+Each REC can run multiple databases while maintaining high capacity and performance.
+
+## How can I see the custom resource definitions (CRDs) created for my Redis Enterprise cluster?
+
+Run the following:
+
+```sh
+kubectl get rec
+kubectl describe rec <my-cluster-name>
+```
+
+## How can I change the Redis Enterprise cluster admin user password?
+
+The cluster admin user password is created by the operator during the deployment of the Redis Enterprise cluster (REC) and is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/).
+
+See [Manage REC credentials]({{< relref "/operate/kubernetes/7.4.6/security/manage-rec-credentials" >}}) for instructions on changing the admin password.
+
+## How is using Redis Enterprise operator superior to using Helm charts?
+
+While [Helm charts](https://helm.sh/docs/topics/charts/) help automate multi-resource deployments, they do not provide the lifecycle management and lack many of the benefits provided by the operator:
+
+- Operators are a K8s standard, while Helm is a proprietary tool
+    - Using operators means better packaging for different Kubernetes deployments and distributions, as Helm is not supported in a straightforward way everywhere
+- Operators allow full control over the Redis Enterprise cluster lifecycle
+    - We’ve experienced difficulties managing the state and lifecycle of the application through Helm, as it essentially only allows to determine the resources being deployed, which is a problem when upgrading and evolve the Redis Enterprise Cluster settings
+- Operators support advanced flows which would otherwise require using an additional third party product
+
+## How to connect to the Redis Enterprise cluster user interface
+
+Create a [port forwarding](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#port-forward) rule to expose the cluster user interface (UI) port. For example, when the default port 8443 is used, run:
+
+```sh
+kubectl port-forward –namespace <namespace> service/<name>-cluster-ui 8443:8443
+```
+
+Connect to the UI by pointing your browser to `https://localhost:8443`
+
+## How should I size Redis Enterprise cluster nodes?
+
+For nodes hosting the Redis Enterprise cluster [statefulSet](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) [pods](https://kubernetes.io/docs/concepts/workloads/pods/), follow the guidelines provided for Redis Enterprise in the [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+For additional information please also refer to [Kubernetes operator deployment – persistent volumes]({{< relref "/operate/kubernetes/7.4.6/recommendations/persistent-volumes.md" >}}).
+
+## How to retrieve the username/password for a Redis Enterprise Cluster?
+
+The Redis Enterprise cluster stores the username/password of the UI in a K8s [secret](https://kubernetes.io/docs/concepts/configuration/secret/).
+
+Find the secret by retrieving secrets and locating one of type [Opaque](https://kubernetes.io/docs/concepts/workloads/pods/) with a name identical or containing your Redis Enterprise cluster name.
+
+For example, run:
+
+```sh
+kubectl get secrets
+```
+
+A possible response may look like this:
+
+| NAME | TYPE | DATA | AGE |
+|------|------|------|-----|
+| redis-enterprise-cluster | Opaque | 2 | 5d |
+
+To retrieve the secret run:
+
+```sh
+kubectl get secret redis-enterprise-cluster -o yaml
+```
+
+A possible response may look like this:
+
+```yaml
+apiVersion: v1
+data:
+  password: Q2h5N1BBY28=
+  username: cmVkaXNsYWJzLnNi
+kind: Secret
+metadata:
+  creationTimestamp: 2018-09-03T14:06:39Z
+  labels:
+   app: redis-enterprise
+   redis.io/cluster: test
+ name: redis-enterprise-cluster
+ namespace: redis
+ ownerReferences:
+ – apiVersion: app.redislabs.com/v1alpha1
+   blockOwnerDeletion: true
+   controller: true
+   kind: RedisEnterpriseCluster
+   name: test
+   uid: 8b247469-c715-11e8-a5d5-0a778671fc2e
+ resourceVersion: “911969”
+ selfLink: /api/v1/namespaces/redis/secrets/redis-enterprise-cluster
+ uid: 8c4ff52e-c715-11e8-80f5-02cc4fca9682
+type: Opaque
+```
+
+Next, decode, for example, the password field. Run:
+
+```sh
+echo "Q2h5N1BBY28=" | base64 –-decode
+```
+
+
+## How to retrieve the username/password for a Redis Enterprise Cluster through the OpenShift Console?
+
+To retrieve your password, navigate to the OpenShift management console, select your project name, go to Resources->Secrets->your_cluster_name
+
+Retrieve your password by selecting “Reveal Secret.”
+{{< image filename="/images/rs/openshift-password-retrieval.png" >}}
+
+
+## What capabilities, privileges and permissions are defined by the Security Context Constraint (SCC) yaml?
+
+The `scc.yaml` file is defined like this:
+
+```yaml
+kind: SecurityContextConstraints
+apiVersion: security.openshift.io/v1
+metadata:
+  name: redis-enterprise-scc
+allowPrivilegedContainer: false
+allowedCapabilities:
+  - SYS_RESOURCE
+runAsUser:
+  type: MustRunAs
+  uid: 1001
+FSGroup:
+  type: MustRunAs
+  ranges: 1001,1001
+seLinuxContext:
+  type: RunAsAny
+```
+
+([latest version on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml))
+
+([latest version on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tags))
+
+The SYS_RESOURCE capability is required by the Redis Enterprise cluster (REC) container so that REC can set correct out of memory (OOM) scores to its processes inside the container.
+Also, some of the REC services must be able to increase default resource limits, especially the number of open file descriptors.
+
+{{< note >}}
+- Removing NET_RAW blocks 'ping' from being used on the solution containers.
+- These changes were made as of release 5.4.6-1183 to better align the deployment with container and Kubernetes security best practices:
+    - The NET_RAW capability requirement in PSP was removed.
+    - The allowPrivilegeEscalation is set to 'false' by default.
+{{< /note >}}
+---
+Title: Redis Enterprise for Kubernetes operator-based architecture
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides a description of the design of Redis Enterprise
+  for Kubernetes.
+linkTitle: What is an operator?
+weight: 30
+url: '/operate/kubernetes/7.4.6/architecture/operator/'
+---
+Redis Enterprise is the fastest, most efficient way to
+deploy and maintain a Redis Enterprise cluster in Kubernetes.
+
+## What is an operator?
+
+An operator is a [Kubernetes custom controller](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) which extends the native K8s API.
+
+Operators were developed to handle sophisticated, stateful applications
+that the default K8s controllers aren’t able to handle. While stock
+Kubernetes controllers—for example,
+[StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/)—are
+ideal for deploying, maintaining and scaling simple stateless
+applications, they are not equipped to handle access to stateful
+resources, upgrade, resize and backup of more elaborate, clustered
+applications such as databases.
+
+## What does an operator do?
+
+In abstract terms, Operators encode human operational knowledge into
+software that can reliably manage an application in an extensible,
+modular way and do not hinder the basic primitives that comprise the K8s
+architecture.
+
+Redis created an operator that deploys and manages the lifecycle of a Redis Enterprise Cluster.
+
+The Redis Enterprise operator acts as a custom controller for the custom
+resource RedisEnterpriseCluster, or ‘rec’, which is defined through K8s
+CRD ([custom resource definition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-resources))
+and deployed with a yaml file.
+
+The operator functions include:
+
+- Validating the deployed Cluster spec (for example, requiring the
+deployment of an odd number of nodes)
+- Implementing a reconciliation loop to monitor all the applicable
+resources
+- Logging events
+- Enabling a simple mechanism for editing the Cluster spec
+
+The Redis Enterprise operator functions as the logic “glue” between the
+K8s infrastructure and the Redis Enterprise Cluster.
+
+The operator creates the following resources:
+
+- Service account
+- Service account role
+- Service account role binding
+- Secret – holds the cluster username, password, and license
+- Statefulset – holds Redis Enterprise nodes
+- The Services Manager deployment – exposes databases and tags nodes
+- The Redis UI service
+- The service that runs the REST API + Sentinel
+- Pod Disruption Budget
+- Optionally: a deployment for the Service Broker, including services and a PVC
+
+The following diagram shows the high-level architecture of the Redis
+Enterprise operator:
+
+{{< image filename="/images/k8s/k8-high-level-architecture-diagram-of-redis-enterprise.png" >}}
+---
+Title: Redis Enterprise for Kubernetes architecture
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides an overview of the architecture and considerations
+  for Redis Enterprise for Kubernetes.
+hideListLinks: true
+linkTitle: Architecture
+weight: 11
+url: '/operate/kubernetes/7.4.6/architecture/'
+---
+Redis bases its Kubernetes architecture on several vital concepts.
+
+## Layered architecture
+
+Kubernetes is an excellent orchestration tool, but it was not designed to deal with all the nuances associated with operating Redis Enterprise. Therefore, it can fail to react accurately to internal Redis Enterprise edge cases or failure conditions. Also, Kubernetes orchestration runs outside the Redis Cluster deployment and may fail to trigger failover events, for example, in split network scenarios.
+
+To overcome these issues, Redis created a layered architecture approach that splits responsibilities between operations Kubernetes does well, procedures Redis Enterprise Cluster excels at, and the processes both can orchestrate together. The figure below illustrated this layered orchestration architecture:
+
+{{< image filename="/images/k8s/kubernetes-overview-layered-orchestration.png" >}}
+
+## Operator based deployment
+
+Operator allows Redis to maintain a unified deployment solution across various Kubernetes environments, i.e., RedHat OpenShift, VMware Tanzu (Tanzu Kubernetes Grid, and Tanzu Kubernetes Grid Integrated Edition, formerly known as PKS), Google Kubernetes Engine (GKE), Azure Kubernetes Service (AKS), and vanilla (upstream) Kubernetes. Statefulset and anti-affinity guarantee that each Redis Enterprise node resides on a Pod that is hosted on a different VM or physical server. See this setup shown in the figure below:
+
+{{< image filename="/images/k8s/kubernetes-overview-unified-deployment.png" >}}
+
+## Network-attached persistent storage {#networkattached-persistent-storage}
+
+Kubernetes and cloud-native environments require that storage volumes be network-attached to the compute instances, to guarantee data durability. Otherwise, if using local storage,  data may be lost in a Pod failure event. See the figure below:
+
+{{< image filename="/images/k8s/kubernetes-overview-network-attached-persistent-storage.png" >}}
+
+On the left-hand side (marked #1), Redis Enterprise uses local ephemeral storage for durability. When a Pod fails, Kubernetes launches another Pod as a replacement, but this Pod comes up with empty local ephemeral storage, and the data from the original Pod is now lost.
+
+On the right-hand side of the figure (marked #2), Redis Enterprise uses network-attached storage for data durability. In this case, when a Pod fails, Kubernetes launches another Pod and automatically connects it to the storage device used by the failed Pod. Redis Enterprise then instructs the Redis Enterprise database instance/s running on the newly created node to load the data from the network-attached storage, which guarantees a durable setup.
+
+Redis Enterprise is not only great as an in-memory database but also extremely efficient in the way it uses persistent storage, even when the user chooses to configure Redis Enterprise to write every change to the disk. Compared to a disk-based database that requires multiple interactions (in most cases) with a storage device for every read or write operation, Redis Enterprise uses a single IOPS, in most cases, for a write operation and zero IOPS for a read operation. As a result, significant performance improvements are seen in typical Kubernetes environments, as illustrated in the figures below:
+
+{{< image filename="/images/k8s/kubernetes-overview-performance-improvements-read.png" >}}{{< image filename="/images/k8s/kubernetes-overview-performance-improvements-write.png" >}}
+
+## Multiple services on each pod
+
+Each Pod includes multiple Redis Enterprise instances (multiple services). We found that the traditional method of deploying a Redis Enterprise database over Kubernetes, in which each Pod includes only a single Redis Enterprise instance while preserving a dedicated CPU, is notably inefficient. Redis Enterprise is exceptionally fast and in many cases can use just a fraction of the CPU resources to deliver the requested throughput. Furthermore, when running a Redis Enterprise Cluster with multiple Redis Enterprise instances across multiple Pods, the Kubernetes network, with its multiple vSwitches, can quickly become the deployment’s bottleneck. Therefore, Redis took a different approach to managing Redis Enterprise over the Kubernetes environment. Deploying multiple Redis Enterprise database instances on a single Pod allows us to better utilize the hardware resources used by the Pod such as CPU, memory, and network while keeping the same level of isolation. See the figure below:
+
+{{< image filename="/images/k8s/kubernetes-overview-multiple-services-per-pod.png" >}}
+---
+Title: Collect logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Run the log collector script to package relevant logs into a tar.gz file
+  to send to Redis Support for help troubleshooting your Kubernetes environment.
+linkTitle: Collect logs
+weight: 89
+url: '/operate/kubernetes/7.4.6/logs/collect-logs/'
+---
+
+The Redis Enterprise cluster (REC) log collector script ([`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py)) creates and fills a directory with the relevant logs for your environment. These logs will help the support team with troubleshooting.
+
+As of version 6.2.18-3, the log collector tool has two modes:
+
+- **restricted** collects only resources and logs created by the operator and Redis Enterprise deployments
+  - This is the default for versions 6.2.18-3 and later
+- **all** collects everything from your environment
+  - This is the default mode for versions 6.2.12-1 and earlier
+
+{{<note>}} This script requires Python 3.6 or later. {{</note>}}
+
+1. Download the latest [`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py) file.
+
+1. Have a K8s administrator run the script on the system that runs your `kubectl` or `oc` commands.
+    - Pass `-n` parameter to run on a different namespace than the one you are currently on
+    - Pass `-m` parameter to change the log collector mode (`all` or `restricted`)
+    - Run with `-h` to see more options
+
+    ```bash
+    python log_collector.py 
+    ```
+
+   {{< note >}} If you get an error because the yaml module is not found, install the pyYAML module with `pip install pyyaml`.
+  {{< /note >}}
+
+
+
+1. Upload the resulting `tar.gz` file containing all the logs to [Redis Support](https://support.redislabs.com/).
+---
+Title: Redis Enterprise Software logs on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how logs are stored and accessed.
+hideListLinks: true
+linkTitle: Logs
+weight: 60
+url: '/operate/kubernetes/7.4.6/logs/'
+---
+
+## Logs
+
+Each redis-enterprise container stores its logs under `/var/opt/redislabs/log`.
+When using persistent storage this path is automatically mounted to the
+`redis-enterprise-storage` volume.
+This volume can easily be accessed by a sidecar, i.e. a container residing on the same pod.
+
+For example, in the REC (Redis Enterprise Cluster) spec you can add a sidecar container, such as a busybox, and mount the logs to there:
+
+```yaml
+sideContainersSpec:
+  - name: busybox
+    image: busybox
+    args:
+      - /bin/sh
+      - -c
+      - while true; do echo "hello"; sleep 1; done
+
+    volumeMounts:
+    - name: redis-enterprise-storage
+      mountPath: /home/logs
+      subPath: logs
+```
+
+Now the logs can be accessed from in the sidecar. For example by running
+
+```kubectl exec -it <pod-name> -c busybox tail home/logs/supervisord.log```
+
+The sidecar container is user determined and can be used to format, process and share logs in a specified format and protocol.
+---
+Title: Flexible deployment options
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces.
+  This article describes flexible deployment options you can use to meet your specific
+  needs.
+linkTitle: Deployment options
+weight: 12
+url: '/operate/kubernetes/7.4.6/deployment/deployment-options/'
+---
+You can deploy Redis Enterprise for Kubernetes in several different ways depending on your database needs.
+
+Multiple Redis Enterprise database resources (REDB) can be associated with single Redis Enterprise cluster resource (REC) even if they reside in different namespaces.
+
+The Redis Enterprise cluster (REC) custom resource must reside in the same namespace as the Redis Enterprise operator.
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+
+## Single REC and single namespace (one-to-one)
+
+The standard and simplest deployment deploys your Redis Enterprise databases (REDB) in the same namespace as the Redis Enterprise cluster (REC). No additional configuration is required for this, since there is no communication required to cross namespaces. See [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.4.6/deployment/quick-start.md" >}}).
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-one.png" >}}
+
+## Single REC and multiple namespaces (one-to-many)
+
+Multiple Redis Enterprise databases (REDB) spread across multiple namespaces within the same K8s cluster can be associated with the same Redis Enterprise cluster (REC). See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace.md" >}}) for more information.
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-many.png" >}}
+
+## Multiple RECs and multiple namespaces (many-to-many)
+
+A single Kubernetes cluster can contain multiple Redis Enterprise clusters (REC), as long as they reside in different namespaces. Each namespace can host only one REC and each operator can only manage one REC.
+
+You have the flexibility to create databases in separate namespaces, or in the same namespace as the REC, or combine any of the supported deployment options above. This configuration is geared towards use cases that require multiple Redis Enterprise clusters with greater isolation or different cluster configurations.
+
+See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace.md" >}}) for more information.
+
+
+{{< image filename="/images/k8s/k8s-deploy-many-to-many.png" >}}
+
+## Unsupported deployment patterns
+
+### Cross-cluster operations
+
+Redis Enterprise for Kubernetes does not support operations that cross Kubernetes clusters. Redis Enterprise clusters (REC) work inside a single K8s cluster. Crossing clusters could result in functional and security issues.
+
+{{< image filename="/images/k8s/k8s-deploy-cross-namespaces.png" >}}
+
+### Multiple RECs in one namespace
+
+Redis Enterprise for Kubernetes does not support multiple Redis Enterprise clusters (REC) in the same namespace. Creating more than one REC in the same namespace will result in errors.
+
+{{< image filename="/images/k8s/k8s-deploy-multicluster-antipattern.png" >}}
+---
+Title: Use a private registry for container images
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section details how the Redis Enterprise Software and Kubernetes
+  operator images can be configured to be pulled from a variety of sources. This page
+  describes how to configure alternate private repositories for images, plus some
+  techniques for handling public repositories with rate limiting.
+linktitle: Use a private container registry
+weight: 92
+url: '/operate/kubernetes/7.4.6/deployment/container-images/'
+---
+
+Redis Enterprise Software, its Kubernetes operator, and the Service Rigger
+are all distributed as separate container images.
+Your Kubernetes deployment will pull these images as needed.
+ You can control where these images are
+pulled from within the operator deployment and also via the
+Redis Enterprise custom resources.
+
+In general, images for deployments that do not have a registry domain
+name (e.g., `gcr.io` or `localhost:5000`) are pulled from the default registry associated
+with the Kubernetes cluster. A plain reference to `redislabs/redis` will likely pull from DockerHub
+(except on OpenShift where it pulls from Red Hat).
+
+For security reasons (e.g., in air-gapped environments), you may want to pull the images
+from a public registry once and then push them to a private registry under
+your control.
+
+{{<warning>}}It is very important that the images you are pushing to the private registry have the same exact version tag as the original images. {{</warning>}}
+
+Furthermore, because [Docker rate limits public pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/),
+you may want to consider pulling images from a
+private registry to avoid deployment failures when you hit your DockerHub rate limit.
+
+The information below will help you track and configure where your deployments pull container images.
+
+{{< note >}}
+**IMPORTANT**
+* Each version of the Redis Enterprise operator is mapped to a specific version of Redis Enterprise Software. The semantic versions always match (for example, 7.2.4), although the specific release numbers may be different (for example, 7.2.4-7 is the operator version for Redis Enterprise Software 7.2.4-64).
+* A specific operator version only supports a specific Redis Enterprise version. Other combinations of operator and Redis Enterprise versions are **not supported**.
+{{< /note >}}
+
+
+## Find container sources
+
+Every pod in your deployed application has a source registry. Any image not prefixed by a registry domain name (e.g., "gcr.io") will pull from the default registry for the Kubernetes cluster (i.e., DockerHub). You can use the commands below to discover the pull sources for the images on your cluster.
+
+To list all the images used by your cluster:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c
+```
+
+To specifically determine the pull source for the Redis Enterprise operator itself, run the following command:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c | grep redislabs
+```
+
+You can limit this command to specific namespaces by replacing the `--all-namespaces` parameter with
+a set of `-n {namespace}` parameters, where each `{namespace}` is a specific
+namespace of interest on your cluster.
+
+## Create a private container registry
+
+You can set up a private container registry in a couple of ways:
+
+* On-premise via [Docker registry](https://docs.docker.com/registry/deploying/), [Red Hat Quay](https://www.redhat.com/en/technologies/cloud-computing/quay), or other providers
+* Cloud provider based registries (e.g., Azure Container Registry, Google Container Registry, etc.).
+
+Once you have set up a private container registry, you will identify the container registry using:
+
+* A domain name
+* A port (optional)
+* A repository path (optional)
+
+## Push images to a private container registry
+
+Important images for a Redis Enterprise Software deployment include:
+
+* Redis Enterprise Software
+* Bootstrapping a Redis Enterprise cluster node (in the operator image)
+* The Service Rigger
+* The Redis Enterprise Software operator
+
+You will need to push all these images to your private container registry. In general,
+to push the images you must:
+
+ 1. [Pull](https://docs.docker.com/engine/reference/commandline/pull/) the various images locally for the Redis Enterprise Software, the Service Rigger, and the operator.
+ 2. Tag the local images with the private container registry, repository, and version tag.
+ 3. [Push](https://docs.docker.com/engine/reference/commandline/push/) the newly tagged images.
+
+The example below shows the commands for pushing the images for Redis Enterprise Software and its operator to a private container registry:
+
+```sh
+PRIVATE_REPO=...your repo...
+RS_VERSION=7.2.4-64
+OPERATOR_VERSION=7.2.4-7
+docker pull redislabs/redis:${RS_VERSION}
+docker pull redislabs/operator:${OPERATOR_VERSION}
+docker pull redislabs/k8s-controller:${OPERATOR_VERSION}
+docker tag redislabs/redis:${RS_VERSION} ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker tag redislabs/operator:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker tag redislabs/k8s-controller:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+```
+
+## Configure deployments to use a private container registry
+
+Once you push your images to your private container registry, you need to
+configure your deployments to use that registry for Redis Enterprise Software and operator
+deployments. The operator container image is configured directly by the operator deployment
+bundle. The Redis Enterprise cluster pod (RS and bootstrapper) and Service Rigger
+images are configured in the Redis Enterprise custom resource.
+
+Depending on your Kubernetes platform, your private container registry may
+require authentication. If you do need authentication, add a [pull secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) to your namespace. Then you'll need to configure Kubernetes and the operator to use the pull secret. The two following sections have examples of adding the `imagePullSecrets` to the operator deployment and `pullSecrets` to the cluster custom resource.
+
+### Specify the operator image source
+
+The operator bundle contains the operator deployment and the reference to the operator image (`redislabs/operator`). To use a private container registry, you must
+change this image reference in your operator deployment file **before** you deploy the operator. If you apply this change to modify an existing operator deployment, the operator's pod will restart.
+
+In the operator deployment file, 'containers:image' should point to the same repository and tag you used when [pushing]({{< relref "/operate/kubernetes/7.4.6/deployment/container-images.md#push-images-to-a-private-container-registry" >}}) to the private container registry:
+
+```sh
+${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+```
+
+The example below specifies a 7.2.4-7 operator image in a Google Container Registry:
+
+```YAML
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redis-enterprise-operator
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      name: redis-enterprise-operator
+  template:
+    metadata:
+      labels:
+        name: redis-enterprise-operator
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      containers:
+        - name: redis-enterprise-operator
+          image: gcr.io/yourproject/redislabs/operator:7.2.4-7
+...
+```
+
+If your container registry requires a pull secret, configure `imagePullSecrets` on the operator deployment:
+
+```YAML
+spec:
+  template:
+    spec:
+      imagePullSecrets:
+      - name: regcred
+```
+
+### Specify the Redis Enterprise cluster images source
+
+A Redis Enterprise cluster managed by the operator consists of three
+container images:
+
+* **`redislabs/redis`**: the Redis Enterprise Software container image
+* **`redislabs/operator`**: the bootstrapper is packaged within the operator container image
+* **`redislabs/k8s-controller`**: the Service Rigger container image
+
+By default, a new Redis Enterprise cluster is created using the
+container images listed above. These container images are pulled from the K8s cluster's default
+container registry.
+
+To [pull](https://docs.docker.com/engine/reference/commandline/pull/) the Redis Enterprise container images from
+a private container registry, you must specify them in the
+Redis Enterprise cluster custom resource.
+
+Add the following sections to the `spec` section of your RedisEnterpriseCluster resource file:
+
+ * **`redisEnterpriseImageSpec`**: controls the Redis Enterprise Software container image. *The version should match the RS version associated with the operator version*.
+ * **`bootstrapperImageSpec`**": controls the bootstrapper container image. *The version must match the operator version*.
+ * **`redisEnterpriseServicesRiggerImageSpec`**: controls the Service Rigger container image. *The version must match the operator version*.
+
+The REC custom resource example below pulls all three container images from a GCR private registry:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+If your private container registry requires pull secrets, you must add `pullSecrets`
+to the `spec` section:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  pullSecrets:
+    - name: regcred
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+## Rate limiting with DockerHub
+
+Docker has [rate limits for image pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/).
+Anonymous users are allowed a certain number of pulls every 6 hours. For authenticated users, the limit is larger.
+These rate limits may affect your Kubernetes cluster in a number of ways:
+
+* The cluster nodes will likely be treated as a single anonymous user.
+* The number of pulls during a deployment might exceed the rate limit for other deployment dependencies, including the operator, Redis Enterprise Software, or other non-Redis pods.
+* Pull failures may prevent your deployment from downloading the required images in a timely manner. Delays here can affect the stability of deployments used by the Redis Enterprise operator.
+
+For these reasons, you should seriously consider where your images
+are pulled from to **avoid failures caused by rate limiting**. The easiest solution
+is to push the required images to a private container registry under your control.
+---
+Title: Deploy Redis Enterprise Software for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to install Redis Enterprise Software for Kubernetes.
+linkTitle: Kubernetes
+weight: 10
+url: '/operate/kubernetes/7.4.6/deployment/quick-start/'
+---
+
+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]({{< relref "/operate/kubernetes/7.4.6/deployment/openshift" >}}). For details on what is currently supported, see [supported distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions.md" >}}).
+
+## Prerequisites
+
+To deploy Redis Enterprise for Kubernetes, you'll need:
+
+- Kubernetes cluster in a [supported distribution]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions.md" >}})
+- minimum of three worker nodes
+- Kubernetes client (kubectl)
+- access to DockerHub, RedHat Container Catalog, or a private repository that can hold the required images.
+
+### Create a new namespace
+
+**Important:** Each namespace can only contain one Redis Enterprise cluster. Multiple RECs with different operator versions can coexist on the same Kubernetes cluster, as long as they are in separate namespaces.
+
+Throughout this guide, each command is applied to the namespace in which the Redis Enterprise cluster operates.
+
+1. Create a new namespace
+
+    ```sh
+   kubectl create namespace <rec-namespace>
+   ```
+
+1. Change the namespace context to make the newly created namespace default for future commands.
+
+    ```sh
+    kubectl config set-context --current --namespace=<rec-namespace>
+   ```
+
+You can use an existing namespace as long as it does not contain any existing Redis Enterprise cluster resources. It's best practice to create a new namespace to make sure there are no Redis Enterprise resources that could interfere with the deployment.
+
+## Install the operator
+
+Redis Enterprise for Kubernetes bundle is published as a container image. A list of required images is available in the [release notes]({{< relref "/operate/kubernetes/release-notes/_index.md" >}}) for each version.
+
+The operator [definition and reference materials](https://github.com/RedisLabs/redis-enterprise-k8s-docs) are available on GitHub. The operator definitions are [packaged as a single generic YAML file](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/bundle.yaml).
+
+{{<note>}}
+If you do not pull images from DockerHub or another public registry, you need to use a [private container registry]({{< relref "/operate/kubernetes/7.4.6/deployment/container-images#manage-image-sources" >}}).
+{{</note>}}
+
+### Download the operator bundle
+
+Pull the latest version of the operator bundle:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+```
+
+  If you need a different release, replace `VERSION` with a specific release tag.
+
+  Check version tags listed with the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases) to ensure the version of the bundle is correct.
+
+### Deploy the operator bundle
+
+Apply the operator bundle in your REC namespace:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+  You should see a result similar to this:
+
+  ```sh
+  role.rbac.authorization.k8s.io/redis-enterprise-operator created
+  serviceaccount/redis-enterprise-operator created
+  rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+  customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+  customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+  deployment.apps/redis-enterprise-operator created
+  ```
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+#### Verify the operator is running
+
+Check the operator deployment to verify it's running in your namespace:
+
+```sh
+kubectl get deployment redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+## Create a Redis Enterprise cluster (REC)
+
+A Redis Enterprise cluster (REC) is created from a `RedisEnterpriseCluster` custom resource
+that contains cluster specifications.
+
+The following example creates a minimal Redis Enterprise cluster. See the [RedisEnterpriseCluster API reference]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api">}}) for more information on the various options available.
+
+1. Create a file that defines a Redis Enterprise cluster with three nodes.
+
+    {{<note>}}
+The REC name (`my-rec` in this example) cannot be changed after cluster creation.
+    {{</note>}}
+
+    ```sh
+    cat <<EOF > my-rec.yaml
+    apiVersion: "app.redislabs.com/v1"
+    kind: "RedisEnterpriseCluster"
+    metadata:
+      name: my-rec
+    spec:
+      nodes: 3
+    EOF
+    ```
+
+   This will request a cluster with three Redis Enterprise nodes using the default requests (i.e., 2 CPUs and 4GB of memory per node).
+
+   To test with a larger configuration, use the example below to add node resources to the `spec` section of your test cluster (`my-rec.yaml`).
+
+    ```sh
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: 2000m
+        memory: 16Gi
+      requests:
+        cpu: 2000m
+        memory: 16Gi
+    ```
+
+    {{<note>}}
+Each cluster must have at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+    See the [Redis Enterprise hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) for more information on sizing Redis Enterprise node resource requests.
+  
+1. Apply your custom resource file in the same namespace as `my-rec.yaml`.
+
+    ```sh
+    kubectl apply -f my-rec.yaml
+    ```
+
+   You should see a result similar to this:
+
+   ```sh
+   redisenterprisecluster.app.redislabs.com/my-rec created
+   ```
+
+1. You can verify the creation of the cluster with:
+
+    ```sh
+    kubectl get rec
+    ```
+
+    You should see a result similar to this:
+
+    ```sh
+    NAME           AGE
+    my-rec   1m
+    ```
+
+    At this point, the operator will go through the process of creating various services and pod deployments.
+
+    You can track the progress by examining the StatefulSet associated with the cluster:
+
+    ```sh
+    kubectl rollout status sts/my-rec
+    ```
+
+    or by looking at the status of all of the resources in your namespace:
+
+    ```sh
+    kubectl get all
+    ```
+
+## Enable the admission controller
+
+The admission controller dynamically validates REDB resources configured by the operator. It is strongly recommended that you use the admission controller on your Redis Enterprise Cluster (REC). The admission controller only needs to be configured once per operator deployment.
+
+As part of the REC creation process, the operator stores the admission controller certificate in a Kubernetes secret called `admission-tls`. You may have to wait a few minutes after creating your REC to see the secret has been created.
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to the relevant namespaces {#webhook}
+
+The operator bundle includes a webhook file. The webhook will intercept requests from all namespaces unless you edit it to target a specific namespace. You can do this by adding the `namespaceSelector` section to the webhook spec to target a label on the namespace.
+
+1. Make sure the namespace has a unique `namespace-name` label.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+       labels:
+        namespace-name: example-ns
+    name: example-ns
+    ```
+
+1. Patch the webhook to add the `namespaceSelector` section.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+        matchLabels:
+          namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    kubectl patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+## Verify the admission controller is working
+
+1. Verify the admission controller is installed correctly by applying an invalid resource. This should force the admission controller to correct it.
+
+    ```sh
+    kubectl apply -f - << EOF
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      evictionPolicy: illegal
+    EOF
+    ```
+
+    You should see your request was denied by the `admission webhook "redisenterprise.admission.redislabs"`.
+
+    ```sh
+    Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+    ```
+
+## Create a Redis Enterprise Database (REDB)
+
+You can create multiple databases within the same namespace as your REC or in other namespaces.
+
+See [manage Redis Enterprise databases for Kubernetes]({{< relref "/operate/kubernetes/7.4.6/re-databases/db-controller.md" >}}) to create a new REDB.
+---
+Title: Redis Enterprise Software deployment for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise is supported on OpenShift Kubernetes cluster deployments
+  via an operator.
+draft: true
+hidden: true
+hideListLinks: false
+weight: 60
+url: '/operate/kubernetes/7.4.6/deployment/openshift/old-index/'
+---
+
+Redis Enterprise is supported on OpenShift Kubernetes cluster deployments via
+an operator. The operator is a software component that runs in your
+deployment namespace and facilitates deploying and managing
+Redis Enterprise clusters.
+
+
+
+{{% comment %}}
+These are the steps required to set up a Redis Enterprise Software
+Cluster with OpenShift.
+
+Prerequisites:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.8/installing/index.html) at version 4.6 or higher, with at least three nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/hardware-requirements.md" >}})
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.8/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Step 1: Login
+
+- Log in to your OpenShift account as a super admin (so you have access to all the default projects).
+- Create a new project, fill in the name and other details for the project, and click **Create**.
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image1.png" >}}
+
+- Click on “admin” (upper right corner) and then “Copy Login.”
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image4.png" >}}
+
+- Paste the *login* command into your shell; it should look something like this:
+
+    ```sh
+    oc login https://your-cluster.acme.com –token=your$login$token
+    ```
+
+- Next, verify that you are using the newly created project. Type:
+
+    ```sh
+    oc project <your project name>
+    ```
+
+This will shift to your project rather than the default project (you can verify the project you’re currently using with the *oc project* command).
+
+## Step 2: Get deployment files
+
+Clone this repository, which contains the deployment files:
+
+```sh
+git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+```
+
+<!--
+{{< note >}}
+For RHEL images, please use the redis-enterprise-cluter_rhel.yaml and operator_rhel.yaml files.
+{{< /note >}}
+-->
+
+Specifically for the custom resource (cr) yaml file, you may also download and edit one of the files in the [example folder.](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/examples)  
+
+## Step 3: Prepare your yaml files
+
+Let’s look at each yaml file to see what requires editing:
+
+- [scc.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/scc.yaml)
+
+    The scc ([Security Context Constraint](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html)) yaml defines the cluster’s security context constraints, which we will apply to our project later on. We strongly recommend **not** changing anything in this yaml file.
+
+    Apply the file:
+
+    ```sh
+    oc apply -f scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io “redis-enterprise-scc” configured
+    ```
+
+    Now you need to bind the scc to your project by typing:
+
+    ```sh
+    oc adm policy add-scc-to-group redis-enterprise-scc  system:serviceaccounts:your_project_name
+    ```
+
+    (If you do not remember your project name, run “oc project”)
+
+- [openshift.bundle.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift.bundle.yaml) -
+
+    The bundle file includes several declarations:
+
+    1. rbac (Role-Based Access Control) defines who can access which resources. The Operator application requires these definitions to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). These include declaration of rules, role and rolebinding.
+    1. crd declaration, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next
+    1. operator deployment declaration, creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes, as pods. The yaml  contains the latest image tag representing the latest Operator version available.
+
+    This yaml should be applied as-is, without changes. To apply it:
+
+    ```sh
+    kubectl apply -f openshift.bundle.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    role.rbac.authorization.k8s.io/redis-enterprise-operator created
+    serviceaccount/redis-enterprise-operator created
+    rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+    customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+    deployment.apps/redis-enterprise-operator created
+    ```
+
+1. Now, verify that your redis-enterprise-operator deployment is running:
+
+    ```sh
+    kubectl get deployment -l name=redis-enterprise-operator
+    ```
+
+    A typical response will look like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+<!--
+[rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rbac.yaml)
+
+The rbac (Role-Based Access Control) yaml defines who can access which resources. We need this to allow our Operator application to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). Therefore, we strongly recommend **not** changing anything in this yaml file. To apply it, type:
+
+```sh
+kubectl apply -f rbac.yaml
+```
+
+You should receive the following response:
+
+`role.rbac.authorization.k8s.io/redis-enterprise-operator created
+serviceaccount/redis-enterprise-operator created
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created`
+-->
+
+ <!--> [sb_rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/sb_rbac.yaml)
+
+    If you’re deploying a service broker, also apply the sb_rbac.yaml file. The sb_rbac (Service Broker Role-Based Access Control) yaml defines the access permissions of the Redis Enterprise Service Broker.
+
+    We strongly recommend **not** changing anything in this yaml file.
+
+    To apply it, run:
+
+    ```sh
+    kubectl apply -f sb_rbac.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    clusterrole.rbac.authorization.k8s.io/redis-enterprise-operator-sb configured
+    clusterrolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+    ``` -->
+
+<!--
+- [crd.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/crd.yaml)
+
+The next step applies crd.yaml, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next. We strongly recommend **not** changing anything in this yaml file.
+
+To apply it, run:
+
+```sh
+kubectl apply -f crd.yaml
+```
+
+You should receive the following response:
+
+`customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com     configured`
+
+- [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml)
+
+Applying this yaml creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes (as pods).
+
+Always make sure you have the latest [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml). Alternatively, you can edit the following tag:
+image:redislabs/operator:tag
+
+To apply the operator.yaml, run:
+
+```sh
+kubectl apply -f operator.yaml
+```
+
+You should receive the following response:
+
+`deployment.apps/redis-enterprise-operator created`
+
+Now, run `kubectl get deployment` and verify that your redis-enterprise-operator deployment is running. A Typical response will look like this:
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image2.png" >}}
+
+- [redis-enterprise-cluster.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/redis-enterprise-cluster.yaml)
+-->
+
+- The [rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml) defines the configuration of the newly created resource: Redis Enterprise Cluster. This yaml could be renamed your_cluster_name.yaml to keep things tidy, but this isn’t a mandatory step.
+
+    This yaml can be edited to the required use case, however, the sample provided can be used for test/dev and quick start purposes. Here are the main fields you may review and edit:
+
+    - name: “your_cluster_name” (e.g. “demo-cluster”)
+    - nodes: number_of_nodes_in_the_cluster (Must be an uneven number of at least 3 or greater—[here’s why](https://redislabs.com/redis-enterprise/technology/highly-available-redis/))
+    - uiServiceType: service_type
+
+        Service type value can be either ClusterIP or LoadBalancer. This is an optional configuration based on [k8s service types](https://kubernetes.io/docs/tutorials/kubernetes-basics/expose/expose-intro/). The default is ClusterIP.
+
+    - storageClassName: “<span style="color: #ff0000;">gp2</span>“
+
+        This specifies the [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/) used for your nodes’ persistent disks. For example, AWS uses “gp2” as a default, GKE uses “standard” and Azure uses "default").
+
+    - redisEnterpriseNodeResources: The [compute resources](https://docs.openshift.com/enterprise/3.2/dev_guide/compute_resources.html#dev-compute-resources) required for each node.
+    - limits – specifies the max resources for a Redis node
+    - requests – specifies the minimum resources for a Redis node
+
+        For example:
+
+        ```sh
+        limits
+        cpu: “4000m”
+        memory: 4Gi
+        requests
+
+        cpu: “4000m”
+        memory: 4Gi
+        ```
+
+        The default (if unspecified) is 4 cores (4000m) and 4GB (4Gi).
+
+        {{< note >}}
+Resource limits should equal requests ([Learn why](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/topics.md#guaranteed-quality-of-service)).
+        {{< /note >}}
+
+    - serviceBrokerSpec –
+    - enabled: \<false/true\>
+
+        This specifies [persistence](https://redislabs.com/redis-features/persistence) for the Service Broker with an “enabled/disabled” flag. The default is “false.”
+
+        persistentSpec:
+        storageClassName: “gp2“
+
+    - redisEnterpriseImageSpec: This configuration controls the Redis Enterprise version used, and where it is fetched from. This is an optional field. The Operator will automatically use the matching RHEL image version for the release.
+
+        [imagePullPolicy](https://docs.openshift.com/enterprise/3.0/architecture/core_concepts/builds_and_image_streams.html#image-pull-policy):
+        IfNotPresent
+        Repository: redislabs/redis
+        versionTag: 5.2.10-22
+
+        The version tag, as it appears on your repository (e.g. on [DockerHub](https://hub.docker.com/r/redislabs/redis/)).
+
+## Step 4: Create your cluster
+
+Once you have your_cluster_name yaml set, you need to apply it to create your Redis Enterprise Cluster:
+
+```sh
+kubectl apply -f your_cluster_name.yaml
+```
+
+Run kubectl get rec and verify that creation was successful (rec is a shortcut for “RedisEnterpriseClusters”).
+
+You should receive a response similar to the following:
+
+```sh
+NAME AGE
+
+Your_cluster_name 17s
+```
+
+Your Cluster will be ready shortly, typically within a few minutes.
+
+To check the cluster status, type the following:
+
+```sh
+kubectl get pod
+```
+
+You should receive a response similar to the following:
+
+|                                    |       |         |          |     |
+| ---------------------------------- | ----- | ------- | -------- | --- |
+| NAME                               | READY | STATUS  | RESTARTS | AGE |
+| your_cluster_name-0              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-1              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-2              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-controller-x-x | 1/1   | Running | 0        | 1m  |
+| Redis-enterprise-operator-x-x      | 1/1   | Running | 0        | 5m  |
+
+Next, create your databases.
+
+## Step 5: Create a database
+
+In order to create your database, we will log in to the Redis Enterprise UI.
+
+- First, apply port forwarding to your Cluster:
+
+    ```sh
+    kubectl port-forward your_cluster_name-0 8443:8443
+    ```
+
+    {{< note >}}
+- your_cluster_name-0 is one of your cluster pods. You may consider running the port-forward command in the background.
+- The Openshift UI provides tools for creating additional routing options, including external routes. These are covered in [RedHat Openshift documentation](https://docs.openshift.com/container-platform/3.11/dev_guide/routes.html).
+    {{< /note >}}
+
+    Next, create your database.
+
+- Open a browser window and navigate to localhost:8443
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image5.png" >}}
+
+- In order to retrieve your password, navigate to the OpenShift management console, select your project name, go to    Resources-\>Secrets-\>your_cluster_name
+- Retrieve your password by selecting “Reveal Secret.”
+
+    {{< warning >}}
+Do not change the default admin user password in the Redis Enterprise admin console.
+Changing the admin password impacts the proper operation of the K8s deployment.
+    {{< /warning >}}
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image3.png" >}}
+
+- Follow the interface’s [instructions to create your database]({{< relref "/operate/rs/administering/creating-databases/_index.md" >}}).
+
+{{< note >}}
+In order to conduct the Ping test through Telnet, you can create a new route to the newly created database port in the same way as described above for the UI port. After you create your database, go to the Openshift management console, select your project name and go to Applications-\>Services. You will see two newly created services representing the database along with their IP and port information, similar to the screenshot below.
+{{< /note >}}
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image6.png" >}}
+
+{{% /comment %}}
+---
+Title: Deploy Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: OpenShift provides the OperatorHub where you can install the Redis Enterprise
+  operator from the administrator user interface.
+linkTitle: OpenShift OperatorHub
+weight: 70
+url: '/operate/kubernetes/7.4.6/deployment/openshift/openshift-operatorhub/'
+---
+
+You can deploy Redis Enterprise for Kubernetes from the Red Hat OpenShift CLI. You can also use a UI, [OperatorHub](https://docs.openshift.com/container-platform/4.11/operators/index.html) (Red Hat) to install operators and create custom resources.
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}).
+
+## Install the Redis Enterprise operator
+
+{{<warning>}} If using version 6.2.18-41 or earlier, [Install the security context constraint](#install-security-context-constraint) before installing the operator. {{</warning>}}
+
+1. Select **Operators > OperatorHub**.
+
+2. Search for _Redis Enterprise_ in the search dialog and select the **Redis Enterprise Operator provided by Redis** marked as **Certified**.
+
+    By default, the image is pulled from Red Hat's registry.
+
+3. On the **Install Operator** page, specify the namespace for the operator.
+
+    Only one namespace per operator is supported.
+
+4. Update the **channel** with the version you're installing.
+
+    For more information about specific versions, see the [release notes]({{< relref "/operate/kubernetes/release-notes/" >}}).
+
+5. Choose an approval strategy.
+
+    Use **Manual** for production systems to ensure the operator is only upgraded by approval.
+
+6. Select **Install** and approve the install plan.
+
+   You can monitor the subscription status in **Operators > Installed Operators**.
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+{{<warning>}}
+ Before creating any clusters, install the security context constraint (SCC) for the operator in [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+{{</warning>}}
+
+You only need to install the SCC once, but you must not delete it.
+
+1. Select the project you'll be using or create a new project.
+
+1. Download [`scc.yaml`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+
+1. Apply the file to install the security context constraint.
+
+  ```sh
+  oc apply -f scc.yaml
+  ```
+
+After the install, the OperatorHub automatically uses the constraint for Redis Enterprise node pods.
+
+{{< note >}}
+If you are using the recommended RedisEnterpriseCluster name of `rec`, the SCC is automatically bound to the RedisEnterpriseCluster after install.
+
+If you choose a different name for the RedisEnterpriseCluster, or override the default service account name, you must manually bind the SCC to the RedisEnterpriseCluster’s service account:
+
+  ```sh
+  oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-service-account-name>
+  ```
+
+{{< /note >}}
+
+## Create Redis Enterprise custom resources
+
+The **Installed Operators**->**Operator details** page shows the provided APIs: **RedisEnterpriseCluster** and **RedisEnterpriseDatabase**. You can select **Create instance** to create custom resources using the OperatorHub interface.
+
+Use the YAML view to create a custom resource file or let OperatorHub generate the YAML file for you by specifying your configuration options in the form view.
+
+<note> The REC name cannot be changed after cluster creation.</note>
+
+{{<note>}} In versions 6.4.2-4 and 6.4.2-5, REC creation might fail when using the form view due to an error related to the cluster level LDAP. To avoid this, use the YAML view.
+{{</note>}}
+
+For more information on creating and maintaining Redis Enterprise custom resources, see [Redis Enterprise clusters (REC)]({{< relref "/operate/kubernetes/7.4.6/re-clusters/" >}}) and [Redis Enterprise databases (REDB)]({{< relref "/operate/kubernetes/7.4.6/re-databases/" >}}).
+---
+Title: Deployment with OpenShift CLI for Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes and cluster can be installed via CLI
+  tools OpenShift
+linkTitle: OpenShift CLI
+weight: 60
+url: '/operate/kubernetes/7.4.6/deployment/openshift/openshift-cli/'
+---
+Use these steps to set up a Redis Enterprise Software cluster with OpenShift.
+
+## Prerequisites
+
+- [OpenShift cluster](https://docs.openshift.com/container-platform/4.8/installing/index.html) with at least 3 nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}))
+- [OpenShift CLI](https://docs.openshift.com/container-platform/latest/cli_reference/openshift_cli/getting-started-cli.html)
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}).
+
+## Deploy the operator
+
+1. Create a new project.
+
+    ```sh
+    oc new-project <your-project-name> 
+    ```
+
+1. Verify the newly created project. 
+
+    ```sh
+    oc project <your-project-name>
+    ```
+
+1. Get the deployment files.
+
+    ```sh
+    git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+    ```
+
+1. Deploy the OpenShift operator bundle.
+
+    If you are using version 6.2.18-41 or earlier, you must [apply the security context constraint](#install-security-context-constraint) before the operator bundle.
+
+    ```sh
+    oc apply -f openshift.bundle.yaml
+    ```
+
+    {{< warning >}}
+Changes to the `openshift.bundle.yaml` file can cause unexpected results.
+    {{< /warning >}}
+
+1. Verify that your `redis-enterprise-operator` deployment is running.
+
+    ```sh
+    oc get deployment
+    ```
+
+    A typical response looks like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+    {{<warning>}}
+DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).
+    {{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+1. Apply the file `scc.yaml` file.
+
+   {{<warning>}}
+Do not edit this file.
+    {{</warning>}}
+
+    ```sh
+    oc apply -f openshift/scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io "redis-enterprise-scc-v2" configured
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Provide the operator permissions for the pods.
+
+    ```sh
+    oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+      system:serviceaccount:<my-project>:<rec>
+    ```
+
+    {{<note>}}
+If you are using version 6.2.18-41 or earlier, add additional permissions for your cluster.
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc \
+system:serviceaccount:<my-project>:redis-enterprise-operator
+```
+{{</note>}}
+
+  You can check the name of your project using the `oc project` command. To replace the project name, use `oc edit project myproject`. Replace `rec` with the name of your Redis Enterprise cluster, if different.
+
+## Create a Redis Enterprise cluster custom resource
+
+1. Apply the `RedisEnterpriseCluster` resource file ([rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml)).
+
+    You can rename the file to `<your_cluster_name>.yaml`, but it is not required. Examples below use `<rec_rhel>.yaml`. [Options for Redis Enterprise clusters]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api" >}}) has more info about the Redis Enterprise cluster (REC) custom resource, or see the [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api">}}) for a full list of options.
+
+    The REC name cannot be changed after cluster creation.
+
+    {{<note>}}
+Each Redis Enterprise cluster requires at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+2. Apply the custom resource file to create your Redis Enterprise cluster.
+
+    ```sh
+    oc apply -f <rec_rhel>.yaml
+    ```
+
+    The operator typically creates the REC within a few minutes.
+
+1. Check the cluster status.
+
+    ```sh
+    oc get pod
+    ```
+
+    You should receive a response similar to the following:
+
+    ```sh
+     NAME                             | READY | STATUS  | RESTARTS | AGE |
+    | -------------------------------- | ----- | ------- | -------- | --- |
+    | rec-name-0              | 2/2   | Running | 0        | 1m  |
+    | rec-name-1              | 2/2   | Running | 0        | 1m  |
+    | rec-name-2              | 2/2   | Running | 0        | 1m  |
+    | rec-name-controller-x-x | 1/1   | Running | 0        | 1m  |
+    | Redis-enterprise-operator-x-x    | 1/1   | Running | 0        | 5m  |
+    ```
+
+## Configure the admission controller
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to relevant namespaces
+
+If not limited, the webhook intercepts requests from all namespaces. If you have several REC objects in your Kubernetes cluster, limit the webhook to the relevant namespaces. If you aren't using multiple namespaces, skip this step.
+
+1. Verify your namespace is labeled and the label is unique to this namespace, as shown in the next example.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+      labels:
+       namespace-name: staging
+    name: staging
+    ```
+
+1. Patch the webhook spec with the `namespaceSelector` field.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+       matchLabels:
+         namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    oc patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+    {{<note>}}
+For releases before 6.4.2-4, use this command instead:
+
+```sh
+oc patch ValidatingWebhookConfiguration \
+  redb-admission --patch "$(cat modified-webhook.yaml)"
+```
+
+The 6.4.2-4 release introduces a new `ValidatingWebhookConfiguration` to replace `redb-admission`. See the [6.4.2-4 release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/" >}}).
+    {{</note>}}
+
+### Verify admission controller installation
+
+Apply an invalid resource as shown below to force the admission controller to reject it. If it applies successfully, the admission controller is not installed correctly.
+
+```sh
+oc apply -f - << EOF
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: redis-enterprise-database
+spec:
+  evictionPolicy: illegal
+EOF
+```
+
+You should see this error from the admission controller webhook `redisenterprise.admission.redislabs`.
+  
+```sh
+Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+```
+
+## Create a Redis Enterprise database custom resource
+
+The operator uses the instructions in the Redis Enterprise database (REDB) custom resources to manage databases on the Redis Enterprise cluster.
+
+1. Create a `RedisEnterpriseDatabase` custom resource.
+
+    This example creates a test database. For production databases, see [create a database]({{< relref "/operate/kubernetes/7.4.6/re-databases/db-controller.md#create-a-database" >}}) and [RedisEnterpriseDatabase API reference]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api" >}}).
+
+    ```sh
+    cat << EOF > /tmp/redis-enterprise-database.yml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+    name: redis-enterprise-database
+    spec:
+      memorySize: 100MB
+    EOF
+    ```
+
+1. Apply the newly created REDB resource.
+
+    ```sh
+    oc apply -f /tmp/redis-enterprise-database.yml
+    ```
+
+## More info
+
+- [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api">}})
+- [Redis Enterprise database API]({{<relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api">}})
+---
+Title: Deploy Redis Enterprise for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A quick introduction to the steps necessary to get a Redis Enterprise
+  cluster installed in your OpenShift Kubernetes cluster
+hideListLinks: true
+linkTitle: OpenShift
+weight: 11
+url: '/operate/kubernetes/7.4.6/deployment/openshift/'
+---
+The deployment of Redis Enterprise clusters is managed with the Redis Enterprise operator that you deploy in the namespace for your project.
+To create a database that your application
+workloads can use:
+
+1. Install the Redis Enterprise operator.
+
+1. Create a Redis Enterprise CRD to describe your desired cluster.
+
+1. The operator reads this cluster description and deploys the various components on your K8s cluster.
+
+1. Once running, use the Redis Enterprise cluster to create a database.
+
+1. The operator automatically exposes the new database as a K8s service.
+
+## For OpenShift via the OperatorHub
+
+To [create a database on an OpenShift 4.x cluster via the OperatorHub]({{< relref "/operate/kubernetes/7.4.6/deployment/openshift/openshift-operatorhub" >}}) you only need to have the [OpenShift 4.x cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## For OpenShift via the CLI
+
+To [create a database on an OpenShift cluster via the CLI]({{< relref "/operate/kubernetes/7.4.6/deployment/openshift/openshift-cli.md" >}}), you need:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.2/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Version compatibility
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}).
+---
+Title: Getting Started with Active-Active (CRDB) on OpenShift with Route-Based Ingress
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+draft: true
+hidden: true
+weight: $weight
+url: '/operate/kubernetes/7.4.6/deployment/openshift/old-getting-started-openshift-crdb/'
+---
+In this guide, we'll set up an [Active-Active database]({{< relref "/operate/rs/databases/active-active/_index.md" >}})
+(formerly known as CRDB) deployment with Active-Active replication
+spanning across two Redis Enterprise clusters over OpenShift, using Redis Enterprise Operator
+and OpenShift Route.
+
+## Overview
+
+An Active-Active deployment requires connectivity between different Kubernetes clusters.
+A router is the most common way to allow such external access. A [router]
+(https://docs.openshift.com/container-platform/3.5/architecture/core_concepts/routes.html#architecture-core-concepts-routes)
+is configured to accept requests external to the cluster and proxy them into the
+cluster based on how the route is configured. Routes are limited to HTTP/HTTPS(SNI)/TLS(SNI),
+which covers web applications.
+
+Typically, a Kubernetes cluster administrator configures a [DNS wildcard entry]
+(https://docs.openshift.com/container-platform/3.9/install_config/install/prerequisites.html#prereq-dns)
+that resolves to an OpenShift Container Platform node that is running
+the OpenShift router.
+
+The default router in OpenShift is HAProxy, which is a free, fast, and reliable solution
+offering high availability, load balancing, and proxying for TCP and HTTP-based applications.
+
+The Redis Enterprise Operator uses the routes mechanism to expose 2 inter-cluster services:
+the Redis Enterprise Cluster API service and the DB service that exposes the Active-Active database.
+Both services are used during the creation and management of an Active-Active deployment.
+The routes are configured with TLS passthrough.
+
+{{< note >}}
+Routes should have unique hostnames across a Kubernetes cluster.
+{{< /note >}}
+
+## Steps for creating an Active-Active deployment with Service Broker
+
+Before you create an Active-Active deployment with Service Broker, you must create a cluster
+using the REC custom resource, with a Service Broker deployment as covered in
+[Getting Started with Kubernetes and Openshift]({{< relref "/operate/platforms/openshift/_index.md" >}}), while noting the following:
+
+1. Make sure you use the latest versions of the deployment files available on GitHub.
+1. Deploy nodes with at least 6GB of RAM in order to accommodate the Active-Active database plan's 5GB database size.
+1. Make sure you follow the instructions to deploy the Redis Enterprise Service Broker.
+
+The peerClusters section in the spec is used for creating an Active-Active with the Service Broker.
+
+{{< note >}}
+This is only relevant for OpenShift deployments, which support Service Brokers natively.
+{{< /note >}}
+
+Copy this section of the REC spec and modify it for your environment. To apply it
+to every cluster that will participate in the Active-Active database deployment, edit the cluster yaml file
+and apply it using `kubectl apply -f <cluster.yaml>`:
+
+```yaml
+   activeActive:
+    apiIngressUrl:  api1.cluster1.<openshift.department.organization.com>
+    dbIngressSuffix: -cluster1.<openshift.department.organization.com>
+     method: openShiftRoute
+
+     peerClusters:
+      - apiIngressUrl:  api2.cluster2.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster2.<openshift.department.organization.com>
+        fqdn: <cluster2_name>.<cluster2_namespace>.svc.cluster.local
+      - apiIngressUrl:  api3.cluster3.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster3.<openshift.department.organization.com>
+        fqdn: <cluster3_name>.<cluster3_namespace>.svc.cluster.local
+```
+
+This block is added to the Service Broker config map when the REC spec changes, and
+it triggers a restart of the Service Broker pod to pass the peer clusters configuration
+to the service broker. Once the Service Broker pod restarts, you can select the
+Active-Active database plan from the OS service catalog UI.
+
+The elements of the section are:
+
+- **apiIngressUrl** - The OpenShift hostname that is created using OpenShift route.
+
+- **dbIngressSuffix** - The suffix of the db route name. The resulting host is
+`<db-name><db ingress suffix>`. This is used by the Redis Enterprise Syncer to
+sync data between the databases.
+
+- **fqdn** - The FQDN of the Kubernetes cluster where the pattern is `<cluster_name>.
+<cluster_namespace>.svc.cluster.local`. (Remember that the RS cluster name is set in the REC spec).
+
+- **authSecret** - The Kubernetes secret name that contains the username and password
+to access this cluster.
+
+We need to create a secret to reference from authSecret based on the cluster admin credentials
+that were automatically created when the clusters were created. To do this,
+repeat the following process for each of the clusters involved:
+
+1. Login to the OpenShift cluster where your Redis Enterprise Cluster (REC) resides.
+1. To find the secret that holds the REC credentials, run: `kubectl get secrets`
+	
+	From the secrets listed, you’ll find one that is named after your REC and
+	of type Opaque, like this:
+
+	```sh
+	redis-enterprise-cluster            Opaque                  3       1d
+	```
+
+1. Copy the hashed password and username from the file and create a yaml file
+with that information in the following format:
+
+	```yaml
+	apiVersion: v1
+	kind: Secret
+	metadata:
+		name: crdb1-cred
+	type: Opaque
+	data:
+		password: NWhYRWU2OWQ=
+		username: YWRtaW5AYWNtZS5jb20=
+	```
+
+1. Deploy the newly created secret yaml file in the other clusters:
+
+	```sh
+	$ kubectl create -f crdb1-secret.yaml
+	```
+
+	A typical response looks like:
+
+	```
+	secret/crdb1-cred created
+	```
+
+1. Repeat the process for the other clusters until each cluster has a secret
+with the credentials of the other clusters.
+
+After applying the update cluster deployment file, the Service Broker is redeployed
+to apply the changes to the config map.
+
+Now, proceed to the Openshift web console.
+
+1. From the left menu, select a project that holds one of your configured clusters and
+then select **Add to Project > Browse Catalog**.
+
+	{{< image filename="/images/rs/openshift-crdb-catalog.png" >}}
+
+1. Find the **Redis Enterprise [Project Name:Cluster Name]** tile and double-click it to start the wizard.
+
+	{{< image filename="/images/rs/openshift-crdb-information.png" >}}
+
+1. Click **Next** in the Information step.
+
+	{{< image filename="/images/rs/openshift-crdb-plan.png" >}}
+
+1. Then, to deploy an Active-Active database on the clusters you’ve previously configured,
+select the **geo-distributed-redis** plan radio button and click **Next**.
+
+	{{< image filename="/images/rs/openshift-crdb-configuration.png" >}}
+
+1. Click **Next** on the Configuration step, choose a binding option in the Binding step,
+and click **Create**.
+
+	{{< image filename="/images/rs/openshift-crdb-binding.png" >}}
+
+The Active-Active database connected databases are now created with the specified binding, if you selected a binding.
+
+{{< image filename="/images/rs/openshift-crdb-results.png" >}}
+
+You can view the binding by following the link to the secret.
+
+{{< image filename="/images/rs/openshift-crdb-secret.png" >}}
+
+## Validating Active-Active database deployment
+
+To do a basic validation test of database replication:
+
+1. Connect to one of the cluster pods using the following command:
+
+	```sh
+	oc exec -it <your-cluster1-name>-0 bash
+	```
+
+1. At the prompt, launch the redis CLI:
+
+	```sh
+	$ redis-cli -h <your database1 hostname> -p <your database1 port> -a <your database1 password>
+	```
+
+1. Set some values and verify they have been set:
+
+	```sh
+	> set keymaster Vinz
+	OK
+	> set gatekeeper Zuul
+	OK
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+
+1. Now, exit the CLI and the pod execution environment and login to the synched database
+on the other cluster.
+
+	```sh
+	oc exec -it <your-cluster2-name>-0 bash
+	$redis-cli -h <your database2 hostname> -p <your database2 port> -a <your database2 password>
+	```
+
+1. Retrieve the values you previously set or continue manipulating key:value pairs
+and observe the 2-way synchronization, for example:
+
+	```sh
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+---
+Title: Deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section lists the different ways to set up and run Redis Enterprise
+  for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem
+  and in the cloud via our Redis Enterprise operator for Kubernetes.
+hideListLinks: false
+linkTitle: Deployment
+weight: 11
+url: '/operate/kubernetes/7.4.6/deployment/'
+---
+
+This section lists the different ways to set up and run Redis Enterprise for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem and in the cloud via our Redis Enterprise operator for Kubernetes.
+
+## Operator overview {#overview}
+
+Redis Enterprise for Kubernetes uses [custom resource definitions](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) (CRDs) to create and manage Redis Enterprise clusters (REC) and Redis Enterprise databases (REDB).
+
+The operator is a deployment that runs within a given namespace. These operator pods must run with sufficient privileges to create the Redis Enterprise cluster resources within that namespace.
+
+When the operator is installed, the following resources are created:
+
+* a service account under which the operator will run
+* a set of roles to define the privileges necessary for the operator to perform its tasks
+* a set of role bindings to authorize the service account for the correct roles (see above)
+* the CRD for a Redis Enterprise cluster (REC)
+* the CRD for a Redis Enterprise database (REDB)
+* the operator itself (a deployment)
+
+The operator currently runs within a single namespace and is scoped to operate only on the Redis Enterprise cluster in that namespace.
+
+## Compatibility
+
+Before installing, check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.4.6/reference/supported_k8s_distributions" >}}) to see which Redis Enterprise operator version supports your Kubernetes distribution.
+
+
+---
+Title: Manage Redis Enterprise databases for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section describes how the database controller provides the ability
+  to create, manage, and use databases via a database custom resource.
+linkTitle: Manage databases
+weight: 5
+url: '/operate/kubernetes/7.4.6/re-databases/db-controller/'
+---
+## 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.
+
+The database controller in Redis Enterprise for Kubernetes:
+
+- Discovers the custom resource
+- Makes sure the REDB is created in the same namespace as the Redis Enterprise cluster (REC)
+- Maintains consistency between the custom resource and the REDB
+
+The database controller recognizes the new custom resource and validates the specification.
+If valid, the controller combines the values specified in
+the custom resource with default values to create a full specification. It then uses this full specification to create the
+database on the specified Redis Enterprise cluster (REC).
+
+Once the database is created, it is exposed with the same service mechanisms by the service rigger for the Redis Enterprise cluster.
+If the database [custom resource is deleted]({{< relref "/operate/kubernetes/7.4.6/delete-custom-resources" >}}), the database and its services are deleted from the cluster.
+
+### Flexible deployment options
+
+Databases in multiple namespaces can be managed by the same operator. To learn more, see [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.4.6/re-clusters/multi-namespace" >}}).
+
+To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/7.4.6/deployment/deployment-options" >}}).
+
+## Create a database
+
+Your Redis Enterprise database custom resource must be of the `kind: RedisEnterpriseDatabase` and have values for `name` and `memorySize`. All other values are optional and will be defaults if not specified.
+
+1. Create a file (in this example mydb.yaml) that contains your database custom resource.
+
+    ```YAML
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: mydb
+    spec:
+      memorySize: 1GB
+    ```
+
+    To create a REDB in a different namespace from your REC, you need to specify the cluster with `redisEnterpriseCluster` in the `spec` section of your RedisEnterpriseDatabase custom resource.
+
+     ```YAML
+     redisEnterpriseCluster:
+       name: rec
+     ```
+
+1. Apply the file in the namespace you want your database to be in.
+
+    ```sh
+    kubectl apply -f mydb.yaml
+    ```
+
+1. Check the status of your database.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready to use.
+
+## Modify a database
+
+The custom resource defines the properties of the database.
+To change the database, you can edit your original specification and apply the change or use `kubectl edit`.
+
+To modify the database:
+
+1. Edit the definition:
+
+    ```sh
+    kubectl edit redb mydb
+    ```
+
+1. Change the specification (only properties in `spec` section) and save the changes.  
+    For more details, see [RedisEnterpriseDatabaseSpec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#redisenterprisedatabasespec) or [Options for Redis Enterprise databases]({{< relref "/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api" >}}). 
+
+1. Monitor the status to see when the changes take effect:
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready for use.
+
+## Delete a database
+
+The database exists as long as the custom resource exists.
+If you delete the custom resource, the database controller deletes the database.
+The database controller removes the database and its services from the cluster.
+
+To delete a database, run:
+
+```sh
+kubectl delete redb mydb
+```
+
+## Connect to a database
+
+After the database controller creates a database, the services for accessing the database are created in the same namespace. By default there are two services, one 'ClusterIP' service and one 'headless' service.  
+Connection information for the database is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/) maintained by the database controller. This secret contains:
+
+- The database port (`port`)
+- A comma separated list of service names (`service_names`)
+- The database password for authenticating (`password`)
+
+The name of that secret is stored in the database custom resource.
+
+{{<note>}}
+Use these steps to connect to your database from within your K8s cluster. To access your database from outside the K8s cluster, set up the [Ingress]({{< relref "/operate/kubernetes/7.4.6/networking/ingress.md" >}}) controller or use OpenShift routes.
+{{</note>}}
+
+1. Retrieve the secret name.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.spec.databaseSecretName}"
+    ```
+
+      The database secret name usually takes the form of `redb-<database_name>`, so in our example it will be `redb-mydb`.
+
+1. Retrieve and decode the password.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.password}" | base64 --decode
+    ```
+
+1. Retrieve and decode the port number.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.port}" | base64 --decode
+    ```
+
+1. Retrieve and decode the service_names.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.service_names}" | base64 --decode
+    ```
+
+    You'll need to pick just one service listed here to use for connecting.
+
+1. From a pod within your cluster, use `redis-cli` to connect to your database.
+
+    ```sh
+    redis-cli -h <service_name> -p <port>
+    ```
+
+1. Enter the password you retrieved from the secret.
+
+    ```sh
+    auth <password>
+    ```
+
+    You are now connected to your database!
+---
+Title: Create replica databases on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to create and automate database replicas using the database controller
+linkTitle: Create replica databases
+weight: 42
+url: '/operate/kubernetes/7.4.6/re-databases/replica-redb/'
+---
+
+You can configure a replica of a database by creating an item in
+the `replicaSources` section of the [Redis Enterprise database specification](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#redisenterprisedatabasespec). The value of
+`replicaSourceType` must be 'SECRET'; `replicaSourceName`
+must be the name of a secret that contains the replica source url.
+
+A secret must be created using a `stringData` section containing the replica source URI as follows:
+
+```yaml
+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.
+
+A replica of database CR simply uses the secret in the `replicaSources` section:
+
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+   name: name-of-replica
+spec:
+   redisEnterpriseCluster:
+      name: name-of-cluster
+   replicaSources:
+   - replicaSourceType: SECRET
+     replicaSourceName: my-replica-source
+```
+
+In the above, `name-of-replica` database will be created as a replica of the
+source database as long as the source database exists on the source cluster
+and the secret contains the correct replica source URL for that database.
+
+## Retrieving the replica source URL via kubectl
+
+You will need `kubectl`, `curl`, and `jq` installed for this procedure.
+
+1. Set your metadata:
+
+   ```js
+   CLUSTER_NAME=test
+   SOURCE_DB=db1
+   TARGET_DB=db2
+   TARGET_CLUSTER_NAME=test
+   ```
+
+1. Retrieve the cluster authentication:
+
+   ```js
+   CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+   CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+   ```
+
+1. Forward the port of the REST API service for your source cluster:
+
+   ```sh
+   kubectl port-forward pod/${CLUSTER_NAME}-0 9443
+   ```
+
+1. Request the information from the REST API:
+
+   ```js
+   JQ='.[] | select(.name=="'
+   JQ+="${SOURCE_DB}"
+   JQ+='") | ("redis://admin:" +  .authentication_admin_pass + "@"+.endpoints[0].dns_name+":"+(.endpoints[0].port|tostring))'
+   URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://localhost:9443/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+   ```
+
+   Note: URI now contains the replica source URI.
+
+1. Construct the secret for the replica:
+
+   ```yaml
+   cat << EOF > secret.yaml
+   apiVersion: v1
+   kind: Secret
+   metadata:
+     name: ${SOURCE_DB}-url
+   stringData:
+     uri: ${URI}
+   EOF
+   kubectl apply -f secret.yaml
+   ```
+
+1. Create the replica database:
+
+   ```yaml
+   cat << EOF > target.yaml
+   apiVersion: app.redislabs.com/v1alpha1
+   kind: RedisEnterpriseDatabase
+   metadata:
+     name: ${TARGET_DB}
+   spec:
+     redisEnterpriseCluster:
+       name: ${TARGET_CLUSTER_NAME}
+     replicaSources:
+     - replicaSourceType: SECRET
+       replicaSourceName: ${SOURCE_DB}-url
+   EOF
+   kubectl apply -f target.yaml
+   ```
+
+## Automating the creation via a job
+
+The following procedure uses a ConfigMap and a Job to construct the replica
+source URL secret from the source database and configure the target database.
+
+There are four parameters:
+
+- `source` - the name of the source database
+- `cluster` - the name of the cluster for the source database
+- `target` - the name of the target database
+- `targetCluster` - the name of the cluster for the target database
+
+These parameters can be set by:
+
+```sh
+kubectl create configmap replica-of-database-parameters \
+--from-literal=source=name-of-source \
+--from-literal=cluster=name-of-cluster \
+--from-literal=target=name-of-target \
+--from-literal=targetCluster=name-of-cluster
+```
+
+where "name-of-..." is replaced with the database source, source cluster,
+database target, and target cluster names.
+
+The Job and ConfigMap below, when submitted, will create the secret and
+replica database:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: replica-of-database
+spec:
+  backoffLimit: 4
+  template:
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      restartPolicy: Never
+      volumes:
+        - name: scripts
+          configMap:
+            name: replica-of-database
+      containers:
+        - name: createdb
+          image: debian:stable-slim
+          env:
+            - name: MY_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+            - name: SCRIPT
+              value: create.sh
+            - name: SOURCE_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: source
+            - name: TARGET_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: target
+            - name: CLUSTER_SERVICE
+              value: .svc.cluster.local
+            - name: CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: cluster
+            - name: CLUSTER_PORT
+              value: "9443"
+            - name: TARGET_CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: targetCluster
+          volumeMounts:
+            - mountPath: /opt/scripts/
+              name: scripts
+          command:
+            - /bin/bash
+            - -c
+            - |
+              apt-get update; apt-get install -y curl jq apt-transport-https gnupg2
+              apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6A030B21BA07F4FB
+              curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
+              echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list
+              apt-get update
+              apt-get install -y kubectl
+              bash /opt/scripts/$SCRIPT
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: replica-of-database
+data:
+  create.sh: |
+    CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+    CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+    CLUSTER_HOST=${CLUSTER_NAME}.${MY_NAMESPACE}${CLUSTER_SERVICE}
+    JQ='.[] | select(.name=="'
+    JQ+="${SOURCE_DB}"
+    JQ+='") | ("redis://admin:" +  .authentication_admin_pass + "@"+.endpoints[0].dns_name+":"+(.endpoints[0].port|tostring))'
+    URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://${CLUSTER_HOST}:${CLUSTER_PORT}/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+    echo "URL: ${URL}"
+    echo ""
+    cat << EOF > /tmp/secret.yaml
+    apiVersion: v1
+    kind: Secret
+    metadata:
+      name: ${SOURCE_DB}-url
+    stringData:
+      uri: ${URI}
+    EOF
+    cat /tmp/secret.yaml
+    cat << EOF > /tmp/target.yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: ${TARGET_DB}
+    spec:
+      redisEnterpriseCluster:
+        name: ${TARGET_CLUSTER_NAME}
+      replicaSources:
+      - replicaSourceType: SECRET
+        replicaSourceName: ${SOURCE_DB}-url
+    EOF
+    echo "---"
+    cat /tmp/target.yaml
+    echo ""
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/secret.yaml
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/target.yaml
+```
+---
+Title: Redis Enterprise databases (REDB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise databases (REDBs).
+hideListLinks: false
+linkTitle: Redis Enterprise databases (REDB)
+weight: 31
+url: '/operate/kubernetes/7.4.6/re-databases/'
+---
+
+This section contains articles to help you manage your Redis Enterprise databases (REDBs).
+
+
+
+---
+title: RedisEnterpriseDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REDB API
+weight: 30
+aliases: [ /operate/kubernetes/reference/db-options, ]
+url: '/operate/kubernetes/7.4.6/reference/redis_enterprise_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseDatabase is the Schema for the redisenterprisedatabases API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettings">alertSettings</a></td>
+        <td>object</td>
+        <td>
+          Settings for database alerts<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with database. Note - For Active-Active databases this feature is currently in preview. For this feature to take effect for Active-Active databases, set a boolean environment variable with the name "ENABLE_ALPHA_FEATURES" to True. This variable can be set via the redis-enterprise-operator pod spec, or through the operator-environment-config Config Map.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB. It must be at least 10% of combined memory size (RAM and Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>enum</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+          <br/>
+            <i>Enum</i>: dense, sparse<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database (redis or memcached). Defaults to "redis".<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Settings for database alerts
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specalertsettingsbdb_backup_delayed">bdb_backup_delayed</a></td>
+        <td>object</td>
+        <td>
+          Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_high_syncer_lag">bdb_crdt_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_connection_error">bdb_crdt_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_general_error">bdb_crdt_src_syncer_general_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_latency">bdb_high_latency</a></td>
+        <td>object</td>
+        <td>
+          Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_throughput">bdb_high_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_long_running_action">bdb_long_running_action</a></td>
+        <td>object</td>
+        <td>
+          An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_low_throughput">bdb_low_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_dataset_overhead">bdb_ram_dataset_overhead</a></td>
+        <td>object</td>
+        <td>
+          Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_values">bdb_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_high_syncer_lag">bdb_replica_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_syncer_connection_error">bdb_replica_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_shard_num_ram_values">bdb_shard_num_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_size">bdb_size</a></td>
+        <td>object</td>
+        <td>
+          Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_backup_delayed
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_general_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_latency
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_long_running_action
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_low_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_dataset_overhead
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_shard_num_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_size
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.abs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.ftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.gcs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.mount
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.sftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.swift
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.modulesList[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Module: https://redislabs.com/redis-enterprise/modules/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The module's name e.g "ft" for redissearch<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Module's semantic version e.g "1.6.12" - optional only in REDB, must be set in REAADB<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.replicaSources[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.rolesPermissions[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          Upgrades the modules to the latest version that supportes the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Notes - All modules must be without specifing the version. in addition, This field is currently not supported for Active-Active databases.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusbackupinfo">backupInfo</a></td>
+        <td>object</td>
+        <td>
+          Information on the database's periodic backup<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createdTime</td>
+        <td>string</td>
+        <td>
+          Time when the database was created<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseUID</td>
+        <td>string</td>
+        <td>
+          Database UID provided by redis enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusinternalendpoints">internalEndpoints</a></td>
+        <td>[]object</td>
+        <td>
+          Endpoints listed internally by the Redis Enterprise Cluster. Can be used to correlate a ReplicaSourceStatus entry.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionStatus</td>
+        <td>string</td>
+        <td>
+          Status of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionUid</td>
+        <td>string</td>
+        <td>
+          UID of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdated</td>
+        <td>string</td>
+        <td>
+          Time when the database was last updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The generation (built in update counter of K8s) of the REDB resource that was fully acted upon, meaning that all changes were handled and sent as an API call to the Redis Enterprise Cluster (REC). This field value should equal the current generation when the resource changes were handled. Note: the lastActionStatus field tracks actions handled asynchronously by the Redis Enterprise Cluster.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusreplicasourcestatuses">replicaSourceStatuses</a></td>
+        <td>[]object</td>
+        <td>
+          ReplicaSource statuses<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardStatuses</td>
+        <td>map[string]integer</td>
+        <td>
+          Aggregated statuses of shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Database compatibility version<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.activeActive
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status.backupInfo
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Information on the database's periodic backup
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>backupFailureReason</td>
+        <td>string</td>
+        <td>
+          Reason of last failed backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupHistory</td>
+        <td>integer</td>
+        <td>
+          Backup history retention policy (number of days, 0 is forever)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupInterval</td>
+        <td>integer</td>
+        <td>
+          Interval in seconds in which automatic backup will be initiated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupIntervalOffset</td>
+        <td>integer</td>
+        <td>
+          Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupProgressPercentage</td>
+        <td>integer</td>
+        <td>
+          Database scheduled periodic backup progress (percentage)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupStatus</td>
+        <td>string</td>
+        <td>
+          Status of scheduled periodic backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastBackupTime</td>
+        <td>string</td>
+        <td>
+          Time of last successful backup<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.internalEndpoints[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Hostname assigned to the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Database port name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.replicaSourceStatuses[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpointHost</td>
+        <td>string</td>
+        <td>
+          The internal host name of the replica source database. Can be used as an identifier. See the internalEndpoints list on the REDB status.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lag</td>
+        <td>integer</td>
+        <td>
+          Lag in millisec between source and destination (while synced).<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastError</td>
+        <td>string</td>
+        <td>
+          Last error encountered when syncing from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdate</td>
+        <td>string</td>
+        <td>
+          Time when we last receive an update from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbSize</td>
+        <td>integer</td>
+        <td>
+          The source’s RDB size to be transferred during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbTransferred</td>
+        <td>integer</td>
+        <td>
+          Number of bytes transferred from the source’s RDB during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          Sync status of this source<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Supported Kubernetes distributions
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support matrix for the current Redis Enterprise K8s operator
+linkTitle: Supported distributions
+weight: 30
+url: '/operate/kubernetes/7.4.6/reference/supported_k8s_distributions/'
+---
+
+Each release of Redis Enterprise for Kubernetes is thoroughly tested against a set of Kubernetes distributions. The table below lists Redis Enterprise for Kubernetes versions and the Kubernetes distributions they support.
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+## Community Kubernetes
+
+For details on this platform, see the Kubernetes [documentation](https://kubernetes.io/docs/home/supported-doc-versions/).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Community K8s** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.16 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## OpenShift Container Platform
+
+For details on this platform, see the [OpenShift documentation](https://docs.openshift.com/container-platform/4.13/welcome/index.html).
+
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **OpenShift** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.16 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.15 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.14 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.13 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.12 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 4.11 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 4.10 |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 4.9 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 4.8 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.7 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.6 |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.5 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 3.11 |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## Amazon Elastic Kubernetes Service (EKS)
+
+For details on this platform, see the [EKS documentation](https://docs.aws.amazon.com/eks/?icmpid=docs_homepage_containers).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Amazon EKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Azure Kubernetes Service (AKS)
+
+For details on this platform, see the [AKS documentation](https://learn.microsoft.com/en-us/azure/aks/).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Azure AKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Google Kubernetes Engine (GKE)
+
+For details on this platform, see the [GKE documentation](https://cloud.google.com/kubernetes-engine/docs).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Google GKE** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Rancher
+
+For details on this platform, see the [Rancher documentation](https://ranchermanager.docs.rancher.com/).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Rancher 2.8** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.7** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.6** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **Rancher 2.5** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher 2.4** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid (TKG)
+
+For details on this platform, see the [TKG documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid/index.html).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 |
+| **VMWare TKG 2.4** |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.25 |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| **VMware TKG 2.3** |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.25 | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.24 | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| **VMware TKG 2.2** |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.24 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| **VMware TKG 2.1** |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.22 |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 1.6** |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.22 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid Integrated Edition (TKGI)
+
+For details on this platform, see the [TKGI documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid-Integrated-Edition/index.html).
+
+{{<table-scrollable>}}| Redis operator | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **VMware TKGI** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.19 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.17 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.16 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.15 |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.14 |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.13 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.12 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.11 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| 1.10 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.09 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.08 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.07 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## Supported upgrade paths
+
+   If you are using a version earlier than 6.2.10-45, [you must upgrade]({{< relref "/operate/kubernetes/7.4.6/upgrade" >}}) to 6.2.10-45 before you can upgrade to versions 6.2.18 or later.
+---
+title: RedisEnterpriseCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REC API
+weight: 30
+aliases: [ /operate/kubernetes/reference/cluster-options, ]
+url: '/operate/kubernetes/7.4.6/reference/redis_enterprise_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1](#appredislabscomv1)
+
+
+
+
+# app.redislabs.com/v1
+
+
+
+
+RedisEnterpriseCluster is the Schema for the redisenterpriseclusters API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>antiAffinityAdditionalTopologyKeys</td>
+        <td>[]string</td>
+        <td>
+          Additional antiAffinity terms in order to support installation on different zones/vcenters<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Cluster-wide backup configurations<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperimagespec">bootstrapperImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Bootstrapper container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperresources">bootstrapperResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for bootstrapper containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccertificates">certificates</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretName</td>
+        <td>string</td>
+        <td>
+          Secret Name/Path to use for Cluster Credentials. To be used only if ClusterCredentialSecretType is vault. If left blank, will use cluster name.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretRole</td>
+        <td>string</td>
+        <td>
+          Used only if ClusterCredentialSecretType is vault, to define vault role to be used.  If blank, defaults to "redis-enterprise-operator"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretType</td>
+        <td>enum</td>
+        <td>
+          Type of Secret to use for ClusterCredential, Vault, Kuberetes,... If left blank, will default ot kubernetes secrets<br/>
+          <br/>
+            <i>Enum</i>: vault, kubernetes<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterRecovery</td>
+        <td>boolean</td>
+        <td>
+          ClusterRecovery initiates cluster recovery when set to true. Note that this field is cleared automatically after the cluster is recovered<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccontainertimezone">containerTimezone</a></td>
+        <td>object</td>
+        <td>
+          Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createServiceAccount</td>
+        <td>boolean</td>
+        <td>
+          Whether to create service account<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) cluster wide policy. An optional boolean setting. Specifies if INE should be on/off for new created REDBs. May be overridden for specific REDB via similar setting, please view the similar setting for REDB for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>encryptPkeys</td>
+        <td>boolean</td>
+        <td>
+          Private key encryption Possible values: true/false<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enforceIPv4</td>
+        <td>boolean</td>
+        <td>
+          Sets ENFORCE_IPV4 environment variable<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          ADVANCED USAGE: use carefully. Add environment variables to RS StatefulSet's containers.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>extraLabels</td>
+        <td>map[string]string</td>
+        <td>
+          Labels that the user defines for their convenience<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#spechostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          Adds hostAliases entries to the Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specingressorroutespec">ingressOrRouteSpec</a></td>
+        <td>object</td>
+        <td>
+          Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldap">ldap</a></td>
+        <td>object</td>
+        <td>
+          Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>license</td>
+        <td>string</td>
+        <td>
+          Redis Enterprise License<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseSecretName</td>
+        <td>string</td>
+        <td>
+          K8s secret or Vault Secret Name/Path to use for Cluster License. When left blank, the license is read from the "license" field. Note that you can't specify non-empty values in both "license" and "licenseSecretName", only one of these fields can be used to pass the license string. The license needs to be stored under the key "license".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          Selector for nodes that could fit Redis Enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodes</td>
+        <td>integer</td>
+        <td>
+          Number of Redis Enterprise nodes (pods)<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specocspconfiguration">ocspConfiguration</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpersistentspec">persistentSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise Cluster persistence<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger and redis enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podSecurityPolicyName</td>
+        <td>string</td>
+        <td>
+          DEPRECATED PodSecurityPolicy support is removed in Kubernetes v1.25 and the use of this field is invalid for use when running on Kubernetes v1.25+. Future versions of the RedisEnterpriseCluster API will remove support for this field altogether. For migration instructions, see https://kubernetes.io/docs/tasks/configure-pod-container/migrate-from-psp/ 
+ Name of pod security policy to use on pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodstartingpolicy">podStartingPolicy</a></td>
+        <td>object</td>
+        <td>
+          Mitigation setting for STS pods stuck in "ContainerCreating"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodtolerations">podTolerations</a></td>
+        <td>[]object</td>
+        <td>
+          Tolerations that are added to all managed pods. More information: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          Adds the priority class to pods managed by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpullsecrets">pullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          PullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAwarenessNodeLabel</td>
+        <td>string</td>
+        <td>
+          Node label that specifies rack ID - if specified, will create rack aware cluster. Rack awareness requires node label must exist on all nodes. Additionally, operator needs a special cluster role with permission to list nodes.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributes">redisEnterpriseAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>enum</td>
+        <td>
+          Reserved, future use, only for use if instructed by Redis. IPFamily dictates what IP family to choose for pods' internal and external communication.<br/>
+          <br/>
+            <i>Enum</i>: IPv4, IPv6<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseimagespec">redisEnterpriseImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisenoderesources">redisEnterpriseNodeResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Redis Enterprise containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterprisePodAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for redis enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfiguration">redisEnterpriseServicesConfiguration</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster optional services settings<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerimagespec">redisEnterpriseServicesRiggerImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Services Rigger container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerresources">redisEnterpriseServicesRiggerResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Services Rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseTerminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          The TerminationGracePeriodSeconds value for the (STS created) REC pods<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisevolumemounts">redisEnterpriseVolumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          additional volume mounts within the redis enterprise containers. More info: https://kubernetes.io/docs/concepts/storage/volumes/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisonflashspec">redisOnFlashSpec</a></td>
+        <td>object</td>
+        <td>
+          Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisUpgradePolicy</td>
+        <td>enum</td>
+        <td>
+          Redis upgrade policy to be set on the Redis Enterprise Cluster. Possible values: major/latest This value is used by the cluster to choose the Redis version of the database when an upgrade is performed. The Redis Enterprise Cluster includes multiple versions of OSS Redis that can be used for databases.<br/>
+          <br/>
+            <i>Enum</i>: major, latest<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3Default</td>
+        <td>boolean</td>
+        <td>
+          Whether databases will turn on RESP3 compatibility upon database upgrade. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          Name of the service account to use<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservices">services</a></td>
+        <td>object</td>
+        <td>
+          Customization options for operator-managed service resources created for Redis Enterprise clusters and databases<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspec">servicesRiggerSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for service rigger<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspec">sideContainersSpec</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specslaveha">slaveHA</a></td>
+        <td>object</td>
+        <td>
+          Slave high availability mechanism configuration.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Annotations for Redis Enterprise UI service. This annotations will override the overlapping global annotations set under spec.services.servicesAnnotations The specified annotations will not override annotations that already exist and didn't originate from the operator, except for the 'redis.io/last-keys' annotation which is reserved.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiServiceType</td>
+        <td>enum</td>
+        <td>
+          Type of service used to expose Redis Enterprise UI (https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types)<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer, ExternalName<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for upgrades of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>username</td>
+        <td>string</td>
+        <td>
+          Username for the admin user of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>vaultCASecret</td>
+        <td>string</td>
+        <td>
+          K8s secret name containing Vault's CA cert - defaults to "vault-ca-cert"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          additional volumes<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiIngressUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbIngressSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host. ingress <db name><db ingress suffix> Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Used for ingress controllers such as ha-proxy or nginx in GKE<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-wide backup configurations
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          Configurations for backups to s3 and s3-compatible storage<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+Configurations for backups to s3 and s3-compatible storage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name that holds the S3 CA certificate, which contains the TLS certificate mapped to the key in the secret 'cert'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          Specifies the URL for S3 export and import<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Bootstrapper container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for bootstrapper containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbootstrapperresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources.claims[]
+<sup><sup>[↩ Parent](#specbootstrapperresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.certificates
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's API certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cmCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's CM (Cluster Manager) certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ldapClientCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's LDAP client certificate. If left blank, LDAP client certificate authentication will be disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>metricsExporterCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Metrics Exporter certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Proxy certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>syncerCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Syncer certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.containerTimezone
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>propagateHost</td>
+        <td>object</td>
+        <td>
+          Identifies that container timezone should be in sync with the host, this option mounts a hostPath volume onto RS pods that could be restricted in some systems.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timezoneName</td>
+        <td>string</td>
+        <td>
+          POSIX-style timezone name as a string to be passed as EnvVar to RE pods, e.g. "Europe/London".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specextraenvvars)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.hostAliases[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          Hostnames for the above IP address.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          IP address of the host file entry.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ingressOrRouteSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host ingress <db name><db fqdn suffix>. Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation.<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress, istio<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Additional annotations to set on ingress resources created by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationquery">authenticationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationquery">authorizationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>enum</td>
+        <td>
+          Specifies the LDAP protocol to use. One of: LDAP, LDAPS, STARTTLS.<br/>
+          <br/>
+            <i>Enum</i>: LDAP, LDAPS, STARTTLS<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapservers">servers</a></td>
+        <td>[]object</td>
+        <td>
+          One or more LDAP servers. If multiple servers are specified, they must all share an identical organization tree structure.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bindCredentialsSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding the credentials used to communicate with the LDAP server for authentication queries. The secret must have a key named 'dn' with the Distinguished Name of the user to execute the query, and 'password' with its password. If left blank, credentials-based authentication is disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding a PEM-encoded CA certificate for validating the TLS connection to the LDAP server. The secret must have a key named 'cert' with the certificate data. This field is applicable only when the protocol is LDAPS or STARTTLS.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cacheTTLSeconds</td>
+        <td>integer</td>
+        <td>
+          The maximum TTL of cached entries.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForControlPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for control plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForDataPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for data plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>template</td>
+        <td>string</td>
+        <td>
+          Configuration for a template query. Mutually exclusive with the 'query' field. The substring '%u' will be replaced with the username, e.g., 'cn=%u,ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery.query
+<sup><sup>[↩ Parent](#specldapauthenticationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>attribute</td>
+        <td>string</td>
+        <td>
+          Configuration for an attribute query. Mutually exclusive with the 'query' field. Holds the name of an attribute of the LDAP user entity that contains a list of the groups that the user belongs to, e.g., 'memberOf'.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery.query
+<sup><sup>[↩ Parent](#specldapauthorizationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.servers[]
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Address of an LDAP server.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Host name of the LDAP server<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Port number of the LDAP server. If unspecified, defaults to 389 for LDAP and STARTTLS protocols, and 636 for LDAPS protocol.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ocspConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ocspFunctionality</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable/disable OCSP mechanism for the cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>queryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate when the current staple is invalid. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryMaxTries</td>
+        <td>integer</td>
+        <td>
+          Determines the maximum number for the OCSP recovery attempts. After max number of tries passed, the control plane will revert back to the regular frequency. Minimum value is 1. Maximum value is 100.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responseTimeout</td>
+        <td>integer</td>
+        <td>
+          Determines the time interval (in seconds) for which the request waits for a response from the OCSP responder. Minimum value is 1. Maximum value is 60.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.persistentSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise Cluster persistence
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enablePersistentVolumeResize</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable PersistentVolumes resize. Disabled by default. Read the instruction in pvc_expansion readme carefully before using this feature.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to add persistent volume to Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          Storage class for persistent volume in Redis Enterprise pods. Leave empty to use the default. If using the default this way, make sure the Kubernetes Cluster has a default Storage Class configured. This can be done by running a `kubectl get storageclass` and see if one of the Storage Classes' names contains a `(default)` mark.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeSize</td>
+        <td>int or string</td>
+        <td>
+          To enable resizing after creating the cluster - please follow the instructions in the pvc_expansion readme<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podStartingPolicy
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Mitigation setting for STS pods stuck in "ContainerCreating"
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to detect and attempt to mitigate pod startup issues<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>startingThresholdSeconds</td>
+        <td>integer</td>
+        <td>
+          Time in seconds to wait for a pod to be stuck while starting up before action is taken. If set to 0, will be treated as if disabled.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podTolerations[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.pullSecrets[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Secret name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Redis Enterprise containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterprisenoderesourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterprisenoderesources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster optional services settings
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcmserver">cmServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbcoordinator">crdbCoordinator</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbworker">crdbWorker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationmdnsserver">mdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationpdnsserver">pdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationsaslauthd">saslauthd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationstatsarchiver">statsArchiver</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.cmServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the CM server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbCoordinator
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb coordinator process<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbWorker
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb worker processes<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.mdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the Multicast DNS server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.pdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the pdns server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.saslauthd
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the saslauthd service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.statsArchiver
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the stats archiver service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Services Rigger container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Services Rigger pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesriggerresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseservicesriggerresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseVolumeMounts[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisOnFlashSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bigStoreDriver</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb, speedb<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashDiskSize</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashStorageEngine</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Customization options for operator-managed service resources created for Redis Enterprise clusters and databases
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesapiservice">apiService</a></td>
+        <td>object</td>
+        <td>
+          Customization options for the REC API service.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>servicesAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Global additional annotations to set on service resources created by the operator. The specified annotations will not override annotations that already exist and didn't originate from the operator.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services.apiService
+<sup><sup>[↩ Parent](#specservices)</sup></sup>
+
+Customization options for the REC API service.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          Type of service to create for the REC API service. Defaults to ClusterIP service, if not specified otherwise.<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for service rigger
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>databaseServiceType</td>
+        <td>string</td>
+        <td>
+          Service types for access to databases. should be a comma separated list. The possible values are cluster_ip, headless and load_balancer.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceNaming</td>
+        <td>enum</td>
+        <td>
+          Used to determine how to name the services created automatically when a database is created. When bdb_name is used, the database name will be also used for the service name. When redis-port is used, the service will be named redis-<port>.<br/>
+          <br/>
+            <i>Enum</i>: bdb_name, redis-port<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributes">servicesRiggerAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[]
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+EnvVar represents an environment variable present in a Container. More info: https://kubernetes.io/docs/tasks/inject-data-application/environment-variable-expose-pod-information/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the environment variable.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          Source for the environment variable's value. Cannot be used if value is not empty.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvars)</sup></sup>
+
+Source for the environment variable's value. Cannot be used if value is not empty.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a ConfigMap.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a field of the pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a resource of the container: only resources limits and requests are currently supported.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a secret in the pod's namespace<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a ConfigMap.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key to select.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the ConfigMap or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a field of the pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          Path of the field to select in the specified API version.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          Version of the schema the FieldPath is written in terms of, defaults to "v1".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a resource of the container: only resources limits and requests are currently supported.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          Required: resource to select<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          Container name: required for volumes, optional for env vars<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          Specifies the output format of the exposed resources, defaults to "1"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a secret in the pod's namespace
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key of the secret to select from.  Must be a valid secret key.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the Secret or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom
+<sup><sup>[↩ Parent](#specsidecontainersspecenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].ports[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources.claims[]
+<sup><sup>[↩ Parent](#specsidecontainersspecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeDevices[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeMounts[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.slaveHA
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Slave high availability mechanism configuration.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>slaveHAGracePeriod</td>
+        <td>integer</td>
+        <td>
+          Time in seconds between when a node fails, and when slave high availability mechanism starts relocating shards. If set to 0, will not affect cluster configuration.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for upgrades of Redis Enterprise
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>autoUpgradeRedisEnterprise</td>
+        <td>boolean</td>
+        <td>
+          Whether to upgrade Redis Enterprise automatically when operator is upgraded<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Volume represents a named volume in a pod that may be accessed by any container in the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureFile
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].fc
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flocker
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].hostPath
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].nfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].quobyte
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusbundleddatabaseversions">bundledDatabaseVersions</a></td>
+        <td>[]object</td>
+        <td>
+          Versions of open source databases bundled by Redis Enterprise Software - please note that in order to use a specific version it should be supported by the ‘upgradePolicy’ - ‘major’ or ‘latest’ according to the desired version (major/minor)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ingressOrRouteMethodStatus</td>
+        <td>string</td>
+        <td>
+          The ingressOrRouteSpec/ActiveActive spec method that exist<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuslicensestatus">licenseStatus</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmanagedapis">managedAPIs</a></td>
+        <td>object</td>
+        <td>
+          Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmodules">modules</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusocspstatus">ocspStatus</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP status<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuspersistencestatus">persistenceStatus</a></td>
+        <td>object</td>
+        <td>
+          The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>state</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.bundledDatabaseVersions[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>dbType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>major</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.licenseStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseState</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.managedAPIs
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ldap</td>
+        <td>boolean</td>
+        <td>
+          Indicate whether cluster LDAP configuration is managed by the operator. When this is enabled, the operator will reconcile the cluster LDAP configuration according to the '.spec.ldap' field in the RedisEnterpriseCluster resource.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.modules[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>displayName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versions</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.ocspStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+An API object that represents the cluster's OCSP status
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>certStatus</td>
+        <td>string</td>
+        <td>
+          Indicates the proxy certificate status - GOOD/REVOKED/UNKNOWN.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nextUpdate</td>
+        <td>string</td>
+        <td>
+          The time at or before which newer information will be available about the status of the certificate (if available)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>producedAt</td>
+        <td>string</td>
+        <td>
+          The time at which the OCSP responder signed this response.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responderUrl</td>
+        <td>string</td>
+        <td>
+          The OCSP responder url from which this status came from.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revocationTime</td>
+        <td>string</td>
+        <td>
+          The time at which the certificate was revoked or placed on hold.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>thisUpdate</td>
+        <td>string</td>
+        <td>
+          The most recent time at which the status being indicated is known by the responder to have been correct.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.persistenceStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The current status of the PVCs<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>succeeded</td>
+        <td>string</td>
+        <td>
+          The number of PVCs that are provisioned with the expected size<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseActiveActiveDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REAADB API
+weight: 30
+url: '/operate/kubernetes/7.4.6/reference/redis_enterprise_active_active_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseActiveActiveDatabase is the Schema for the redisenterpriseactiveactivedatabase API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseActiveActiveDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters specifications and configurations.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurations">globalConfigurations</a></td>
+        <td>object</td>
+        <td>
+          The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.participatingClusters[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR to link.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettings">alertSettings</a></td>
+        <td>object</td>
+        <td>
+          Settings for database alerts<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?  If disabled, the DatabaseSecret will not be created or updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with database. Note - For Active-Active databases this feature is currently in preview. For this feature to take effect for Active-Active databases, set a boolean environment variable with the name "ENABLE_ALPHA_FEATURES" to True. This variable can be set via the redis-enterprise-operator pod spec, or through the operator-environment-config Config Map.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB It must be at least 10% of combined memory size (RAM+Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>string</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database.<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.activeActive
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Settings for database alerts
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_backup_delayed">bdb_backup_delayed</a></td>
+        <td>object</td>
+        <td>
+          Periodic backup has been delayed for longer than specified threshold value [minutes]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_crdt_src_high_syncer_lag">bdb_crdt_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync lag is higher than specified threshold value [seconds]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_crdt_src_syncer_connection_error">bdb_crdt_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync has connection error while trying to connect replica source<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_crdt_src_syncer_general_error">bdb_crdt_src_syncer_general_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync encountered in general error<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_high_latency">bdb_high_latency</a></td>
+        <td>object</td>
+        <td>
+          Latency is higher than specified threshold value [micro-sec]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_high_throughput">bdb_high_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is higher than specified threshold value [requests / sec.]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_long_running_action">bdb_long_running_action</a></td>
+        <td>object</td>
+        <td>
+          An alert for state-machines that are running for too long<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_low_throughput">bdb_low_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is lower than specified threshold value [requests / sec.]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_ram_dataset_overhead">bdb_ram_dataset_overhead</a></td>
+        <td>object</td>
+        <td>
+          Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_ram_values">bdb_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Percent of values kept in a shard's RAM is lower than [% of its key count]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_replica_src_high_syncer_lag">bdb_replica_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync lag is higher than specified threshold value [seconds]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_replica_src_syncer_connection_error">bdb_replica_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync has connection error while trying to connect replica source<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_shard_num_ram_values">bdb_shard_num_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Number of values kept in a shard's RAM is lower than [values]<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsalertsettingsbdb_size">bdb_size</a></td>
+        <td>object</td>
+        <td>
+          Dataset size has reached the threshold value [% of the memory limit]<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_backup_delayed
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Periodic backup has been delayed for longer than specified threshold value [minutes]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_crdt_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Active-active source - sync lag is higher than specified threshold value [seconds]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_crdt_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Active-active source - sync has connection error while trying to connect replica source
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_crdt_src_syncer_general_error
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Active-active source - sync encountered in general error
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_high_latency
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Latency is higher than specified threshold value [micro-sec]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_high_throughput
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Throughput is higher than specified threshold value [requests / sec.]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_long_running_action
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+An alert for state-machines that are running for too long
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_low_throughput
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Throughput is lower than specified threshold value [requests / sec.]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_ram_dataset_overhead
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_ram_values
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Percent of values kept in a shard's RAM is lower than [% of its key count]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_replica_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Replica-of source - sync lag is higher than specified threshold value [seconds]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_replica_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Replica-of source - sync has connection error while trying to connect replica source
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_shard_num_ram_values
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Number of values kept in a shard's RAM is lower than [values]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.alertSettings.bdb_size
+<sup><sup>[↩ Parent](#specglobalconfigurationsalertsettings)</sup></sup>
+
+Dataset size has reached the threshold value [% of the memory limit]
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>threshold</td>
+        <td>string</td>
+        <td>
+          Threshold for alert going on/off<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.abs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.ftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the "ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]" format<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.gcs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.mount
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.s3
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.sftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.swift
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.modulesList[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Module: https://redislabs.com/redis-enterprise/modules/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The module's name e.g "ft" for redissearch<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uid</td>
+        <td>string</td>
+        <td>
+          Module's uid - do not set, for system use only nolint:staticcheck // custom json tag unknown to the linter<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Module's semantic version e.g "1.6.12" - optional only in REDB, must be set in REAADB<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.replicaSources[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.rolesPermissions[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType (note: use exact name of the ACL from the Redis Enterprise ACL list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType (note: use exact name of the role from the Redis Enterprise role list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.upgradeSpec
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          Upgrades the modules to the latest version that supportes the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Note - This field is currently not supported for Active-Active databases.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>guid</td>
+        <td>string</td>
+        <td>
+          The active-active database corresponding GUID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastTaskUid</td>
+        <td>string</td>
+        <td>
+          The last active-active database task UID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>linkedRedbs</td>
+        <td>[]string</td>
+        <td>
+          The linked REDBs.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters statuses.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The overall replication status<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statussecretsstatus">secretsStatus</a></td>
+        <td>[]object</td>
+        <td>
+          The status of the secrets<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the active active database.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.participatingClusters[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR that is linked.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>id</td>
+        <td>integer</td>
+        <td>
+          The corresponding ID of the instance in the active-active database.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The replication status of the participating cluster<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.secretsStatus[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of secrets.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the secret.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>status</td>
+        <td>enum</td>
+        <td>
+          The status of the secret.<br/>
+          <br/>
+            <i>Enum</i>: Valid, Invalid<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseRemoteCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: RERC API
+weight: 30
+url: '/operate/kubernetes/7.4.6/reference/redis_enterprise_remote_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEntepriseRemoteCluster represents a remote participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseRemoteCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          The URL of the cluster, will be used for the active-active database URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recName</td>
+        <td>string</td>
+        <td>
+          The name of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recNamespace</td>
+        <td>string</td>
+        <td>
+          The namespace of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          The database URL suffix, will be used for the active-active database replication endpoint and replication endpoint SNI.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret containing cluster credentials. Must be of the following format: "redis-enterprise-<RERC name>"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>local</td>
+        <td>boolean</td>
+        <td>
+          Indicates whether this object represents a local or a remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The most recent generation observed for this RERC. It corresponds to the RERC's generation, which is updated by the API Server.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Reference material for the operator, cluster, and database deployment
+  options.
+hideListLinks: false
+linkTitle: Reference
+weight: 89
+url: '/operate/kubernetes/7.4.6/reference/'
+---
+
+This section contains the API reference for Redis custom resources and supported distributions.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise operators allows you to use Redis Enterprise for
+  Kubernetes.
+hideListLinks: false
+linkTitle: 7.4.6
+weight: 50
+url: '/operate/kubernetes/7.4.6/'
+bannerText: This documentation applies to version 7.4.6. For documentation on the latest version, see [redis.io/docs/latest/operate/kubernetes/](https://redis.io/docs/latest/operate/kubernetes/).
+bannerChildren: true
+---
+
+Kubernetes provides enterprise orchestration of containers and has been widely adopted. Redis Enterprise for Kubernetes provides a simple way to get a Redis Enterprise cluster on Kubernetes and enables more complex deployment scenarios.
+
+---
+Title: Configure Istio for external routing
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure Istio as an ingress controller for access to your Redis Enterprise
+  databases from outside the Kubernetes cluster.
+linkTitle: Istio ingress routing
+weight: 20
+---
+
+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.
+
+## Install and configure Istio for Redis Enterprise
+
+1. [Download](https://istio.io/latest/docs/setup/getting-started/) and [install](https://istio.io/latest/docs/setup/getting-started/) Istio (see instructions from Istio's [Getting Started](https://istio.io/latest/docs/setup/getting-started/) guide).
+
+    Once the installation is complete, all the deployments, pods, and services will be deployed in a namespace called `istio-system`. This namespace contains a `LoadBalancer` type service called `service/istio-ingressgateway` that exposes the external IP address.
+
+1. Find the `EXTERNAL-IP` for the `istio-ingressgateway` service.
+
+    ```sh
+    kubectl get svc istio-ingressgateway -n istio-system
+
+    NAME                   TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)                                                                      AGE
+    istio-ingressgateway   LoadBalancer   10.34.67.89   10.145.78.91   15021:12345/TCP,80:67891/TCP,443:23456/TCP,31400:78901/TCP,15443:10112/TCP   3h8m
+    ```
+
+1. Create a DNS entry that resolves your chosen database hostname (or a wildcard `*` followed by your domain) to the Istio `EXTERNAL-IP`. Use this hostname to access your database from outside the cluster.
+
+    In this example, any hostname that ends with `.istio.k8s.my.example.com` will resolve to the Istio LoadBalancer's external IP of `10.145.78.91`. Substitute your own values accordingly.
+
+1. Verify the record was created successfully.
+
+    ```sh
+    dig api.istio.k8s.my.example.com
+    ```
+
+    Look in the `ANSWER SECTION` for the record you just created.
+
+    ```sh
+    ;; ANSWER SECTION:
+    api.istio.k8s.my.example.com 0 IN    A       10.145.78.91
+    ```
+
+## Create custom resources
+
+### `Gateway` custom resource
+
+1. On a different namespace from `istio-system`, create a `Gateway` custom resource file (`redis-gateway.yaml` in this example).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - Replace `<selector-label>` with the label set on your Istio ingress gateway pod (most common is `istio: ingress`).
+    - TLS passthrough mode is required to allow secure access to the database.
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: Gateway
+    metadata:
+      name: redis-gateway
+    spec:
+      selector:
+        istio: <selector-label>
+      servers:
+      - hosts:
+        - '*.istio.k8s.my.example.com'
+        port:
+          name: https
+          number: 443
+          protocol: HTTPS
+        tls:
+          mode: PASSTHROUGH
+    ```
+
+
+
+1. Apply the `Gateway` custom resource file to create the Ingress gateway.
+
+    ```sh
+    kubectl apply -f redis-gateway.yaml
+    ```
+
+1. Verify the gateway was created successfully.
+
+      ```sh
+      kubectl get gateway
+
+      NAME            AGE
+      redis-gateway   3h33m
+      ```
+
+### `VirtualService` custom resource
+
+1. On a different namespace than `istio-system`, create the `VirtualService` custom resource file (`redis-vs.yaml` in this example).
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: VirtualService
+    metadata:
+      name: redis-vs
+    spec:
+      gateways:
+      - redis-gateway
+      hosts:
+      - "*.istio.k8s.my.example.com"
+      tls:
+      - match:
+        - port: 443
+          sniHosts:
+          - api.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: rec1
+            port:
+              number: 9443
+      - match:
+        - port: 443
+          sniHosts:
+          - db1.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: db1
+    ```
+
+    This creates both a route to contact the API server on the REC (`rec1`) and a route to contact one of the databases (`db1`).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - The gateway's metadata name must be similar to the gateway's spec name (`redis-gateway` in this example).
+   
+1. Apply `VirtualService` custom resource file to create the virtual service.
+
+    ```sh
+    kubectl apply -f redis-vs.yaml
+    ```
+
+1. Verify the virtual service was created successfully.
+
+    ```sh
+    kubectl get vs
+
+    NAME       GATEWAYS            HOSTS                              AGE
+    redis-vs   ["redis-gateway"]   ["*.istio.k8s.my.example.com"]   3h33m
+    ```
+
+1. [Deploy the operator]({{< relref "/operate/kubernetes/deployment/quick-start" >}}), Redis Enterprise Cluster (REC), and Redis Enterprise Database (REDB) on the same namespace as the gateway and virtual service.
+
+## Test your external access to the database
+
+To [test your external access]({{< relref "/operate/kubernetes/networking/ingress" >}}) to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).
+
+See [Test your access with Openssl]({{< relref "/operate/kubernetes/networking/ingress#test-your-access-with-openssl" >}}) or [Test your access with Python]({{< relref "/operate/kubernetes/networking/ingress#test-your-access-with-python" >}}) for more info.
+---
+Title: Use OpenShift routes for external database access
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: OpenShift routes
+weight: 15
+---
+
+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](https://docs.openshift.com/container-platform/4.13/networking/routes/route-configuration.html).
+
+## 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.
+
+  By default, the DMC Proxy uses a self-signed certificate.  You can retrieve it from the Redis Enterprise admin console and save it as a file (for example, named "ca.pem") on the client machine.
+
+* Your database also needs TLS encryption enabled.
+
+## Create OpenShift route
+
+1. Select the **Networking/Routes** section of the OpenShift web console.
+
+1. Select **Create route** and fill out the following fields:
+
+   * **Name**: Choose any name you want as the first part of your generated hostname
+   * **Hostname**: Leave blank
+   * **Path**: Leave as is ("/")
+   * **Service**: Select the service for the database you want to access
+   * **TLS Termination**: Choose "passthrough"
+   * **Insecure Traffic**: Select "None"
+
+1. Select **Create**.
+
+1. Find the hostname for your new route. After route creation, it appears in the "Host" field.
+
+1. Verify you have a DNS entry to resolve the hostname for your new route to the cluster's load balancer.
+
+## Access database
+
+Access the database from outside the cluster using `redis-cli` or `openssl`.
+
+To connect with `redis-cli`:
+  
+   ```sh
+   redis-cli -h <hostname> -p 443 --tls --cacert ./ca.pem --sni <hostname>
+   ```
+
+Replace the `<hostname>` value with the hostname for your new route.
+
+To connect with `openssl`:
+
+   ```sh
+   openssl s_client -connect <hostname>:443 -crlf -CAfile ./ca.pem -servername <hostname>
+   ```---
+Title: Configure Ingress for external routing
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure an ingress controller to access your Redis Enterprise databases
+  from outside the Kubernetes cluster.
+linkTitle: Ingress routing
+weight: 5
+---
+
+## Prerequisites
+
+Before creating an Ingress, you'll need:
+
+ - A RedisEnterpriseDatabase (REDB) with TLS enabled for client connections
+ - A supported Ingress controller with `ssl-passthrough` enabled
+    - [Ingress-NGINX Controller](https://kubernetes.github.io/ingress-nginx/deploy/)
+        - Be sure to use the `kubernetes/ingress-nginx` controller and NOT the `nginxinc/kubernetes-ingress` controller.
+    - [HAProxy Ingress](https://haproxy-ingress.github.io/docs/getting-started/)
+    - To use Istio for your Ingress resources, see [Configure Istio for external routing]({{< relref "/operate/kubernetes/networking/istio-ingress" >}})
+
+{{<note>}}Make sure your Ingress controller has `ssl-passthrough`enabled. This is enabled by default for HAProxy, but disabled by default for NGINX. See the [NGINX User Guide](https://kubernetes.github.io/ingress-nginx/user-guide/tls/#ssl-passthrough) for details. {{</note>}}
+
+## Create an Ingress resource
+
+1. Retrieve the hostname of your Ingress controller's `LoadBalancer` service.
+
+    ``` sh
+    $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                        -n <ingress-ctrl-namespace>
+    ```
+
+    Below is example output for an HAProxy running on a K8s cluster hosted by AWS.  
+
+    ``` sh
+    NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+    haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+    ```
+
+1. Choose the hostname you will use to access your database (this value will be represented in this article with `<my-db-hostname>`).  
+
+1. Create a DNS entry that resolves your chosen database hostname to the IP address for the Ingress controller's LoadBalancer.  
+
+1. Create the Ingress resource YAML file.  
+
+    ``` YAML
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    metadata:
+      name: rec-ingress
+      annotations:
+        <controller-specific-annotations-below>
+    spec:
+      rules:
+      - host: <my-db-hostname>
+        http:
+          paths:
+          - path: /
+            pathType: ImplementationSpecific
+            backend:
+              service:
+                name: <db-name>
+                port:
+                  name: redis
+    ```  
+
+    For HAProxy, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: haproxy
+     ingress.kubernetes.io/ssl-passthrough: "true"
+    ```
+
+    For NGINX, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: nginx
+    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    ```  
+
+    The `ssl-passthrough` annotation is required to allow access to the database. The specific format changes depending on your Ingress controller and any additional customizations. See [NGINX Configuration annotations](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) and [HAProxy Ingress Options](https://www.haproxy.com/documentation/kubernetes/latest/configuration/ingress/) for updated annotation formats.  
+
+## Test your external access  
+
+To test your external access to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).  
+
+#### Test your access with Openssl  
+
+1. Get the default CA certificate from the `redis-enterprise-node` container on any of the Redis Enterprise pods.  
+
+    ``` sh
+    $ kubectl exec -it <pod-name> -c redis-enterprise-node \
+                    -- cat /etc/opt/redislabs/proxy_cert.pem
+    ```  
+
+1. Run the following `openssl` command, substituting your own values for `<my-db-hostname>`.  
+
+    ``` sh
+    $ openssl s_client \
+      -connect <my-db-hostname>:443 \
+      -crlf -CAfile ./proxy_cert.pem \
+      -servername <my-db-hostname>
+    ```  
+
+    If you are connected to the database, you will receive `PONG` back, as shown below:  
+
+    ``` sh
+    ...
+     Verify return code: 0 (ok)
+    ---
+
+    PING
+    +PONG
+    ```  
+
+#### Test your access with Python  
+
+You can use the code below to test your access with Python, substituting your own values for `<my-db-hostname>` and `<file-path>`.  
+
+``` python
+import redis
+
+r = redis.StrictRedis(host='<my-db-hostname>',
+              port=443, db=0, ssl=True,
+              ssl_ca_certs='/<file-path>/proxy_cert.pem')
+
+
+print(r.info())
+```
+
+Your output should look something like this:  
+
+``` sh
+$ /Users/example-user/Documents/Projects/test_client/venv3.7/bin/python \
+    /Users/example-user/Documents/Projects/test_client/test_ssl.py
+{
+    'redis_version': '5.0.5',
+    'redis_git_sha1': 0,
+    'redis_git_dirty': 0,
+    'redis_build_id': 0,
+    'redis_mode': 'standalone',
+    'os': 'Linux 4.14.154-128.181.amzn2.x86_64 x86_64',
+    'arch_bits': 64,
+    'multiplexing_api': 'epoll',
+    'gcc_version': '7.4.0',
+    'process_id': 1,
+    'run_id': '3ce7721b096517057d28791aab555ed8ac02e1de',
+    'tcp_port': 10811,
+    'uptime_in_seconds': 316467,
+    'uptime_in_days': 3,
+    'hz': 10,
+    'lru_clock': 0,
+    'config_file': '',
+    'connected_clients': 1,
+    'client_longest_output_list': 0,
+    'client_biggest_input_buf': 0,
+    'blocked_clients': 0,
+    'used_memory': 12680016,
+    'used_memory_human': '12.9M',
+    'used_memory_rss': 12680016,
+    'used_memory_peak': 13452496,
+    'used_memory_peak_human': '12.82M',
+    'used_memory_lua': 151552,
+    'mem_fragmentation_ratio': 1,
+    'mem_allocator': 'jemalloc-5.1.0',
+    'loading': 0,
+    'rdb_changes_since_last_save': 0,
+    'rdb_bgsave_in_progress': 0,
+    'rdb_last_save_time': 1577753916,
+    'rdb_last_bgsave_status': 'ok',
+    'rdb_last_bgsave_time_sec': 0,
+    'rdb_current_bgsave_time_sec': -1,
+    'aof_enabled': 0,
+    'aof_rewrite_in_progress': 0,
+    'aof_rewrite_scheduled': 0,
+    'aof_last_rewrite_time_sec': -1,
+    'aof_current_rewrite_time_sec': -1,
+    'aof_last_bgrewrite_status': 'ok',
+    'aof_last_write_status': 'ok',
+    'total_connections_received': 4,
+    'total_commands_processed': 6,
+    'instantaneous_ops_per_sec': 14,
+    'total_net_input_bytes': 0,
+    'total_net_output_bytes': 0,
+    'instantaneous_input_kbps': 0.0,
+    'instantaneous_output_kbps': 0.0,
+    'rejected_connections': 0,
+    'sync_full': 1,
+    'sync_partial_ok': 0,
+    'sync_partial_err': 0,
+    'expired_keys': 0,
+    'evicted_keys': 0,
+    'keyspace_hits': 0,
+    'keyspace_misses': 0,
+    'pubsub_channels': 0,
+    'pubsub_patterns': 0,
+    'latest_fork_usec': 0,
+    'migrate_cached_sockets': 0,
+    'role': 'master',
+    'connected_slaves': 1,
+    'slave0': {
+        'ip': '0.0.0.0',
+        'port': 0,
+        'state': 'online',
+        'offset': 0,
+        'lag': 0
+    },
+    'master_repl_offset': 0,
+    'repl_backlog_active': 0,
+    'repl_backlog_size': 1048576,
+    'repl_backlog_first_byte_offset': 0,
+    'repl_backlog_histlen': 0,
+    'used_cpu_sys': 0.0,
+    'used_cpu_user': 0.0,
+    'used_cpu_sys_children': 0.0,
+    'used_cpu_user_children': 0.0,
+    'cluster_enabled': 0
+}
+
+Process finished with exit code 0
+```
+---
+Title: Networking
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+linkTitle: Networking
+weight: 40
+---
+
+Redis Enterprise for Kubernetes supports several ways to route external traffic to your RedisEnterpriseCluster:
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/networking/routes" >}}) to route external traffic.
+- The RedisEnterpriseActiveActiveDatabase (REAADB) requires any of the above routing methods to be configured in the RedisEnterpriseCluster (REC) with the `ingressOrRouteSpec` field.
+
+## External routing using Redis Enterprise for Kubernetes
+
+Every time a RedisEnterpriseDatabase (REDB), Redis Enterprise Active-Active database (REAADB), or Redis Enterprise cluster (REC) is created, the Redis Enterprise operator automatically creates a [service](https://kubernetes.io/docs/concepts/services-networking/service/) to allow requests to be routed to that resource.
+
+Redis Enterprise supports three [types of services](https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types) for accessing databases: `ClusterIP`, `headless`, or `LoadBalancer`.
+
+By default, the operator creates a `ClusterIP` type service, which exposes a cluster-internal IP and that can only be accessed from within the K8s cluster. For requests to be routed from outside the K8s cluster, you need an [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) (or [route](https://docs.openshift.com/container-platform/4.12/networking/routes/route-configuration.html) if you are using OpenShift). See [kubernetes.io](https://kubernetes.io/docs/) for more details on [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) and [Ingress controllers](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/).
+
+* To use NGINX or HAProxy Ingress controllers, see [Ingress routing]({{< relref "/operate/kubernetes/networking/ingress" >}}).
+* To use OpenShift routes, see [OpenShift routes]({{< relref "/operate/kubernetes/networking/routes" >}}).
+* To use Istio as an Ingress controller, see [Istio Ingress routing]({{< relref "/operate/kubernetes/networking/istio-ingress" >}})
+
+## `ingressOrRouteSpec` for Active-Active databases
+
+Versions 6.4.2 or later of Redis Enterprise for Kubernetes include a feature for ingress configuration. The `ingressOrRouteSpec` field is available in the RedisEnterpriseCluster spec to automatically create an Ingress (or route) for the API service and databases (REAADB) on that REC. See [REC external routing]({{< relref "/operate/kubernetes/networking/ingressorroutespec" >}}) for more details.
+
+This feature only supports automatic Ingress creation for Active-Active databases created and managed with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. Use with the standard Redis Enterprise database (REDB) is not currently supported.
+
+## REC domain name
+
+The RedisEnterpriseCluster does not support custom domain names. Domain names for the REC are in the following format: `<rec-name>.<namespace>.svc.cluster.local`.
+---
+Title: Establish external routing on the RedisEnterpriseCluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: REC external routing
+weight: 30
+---
+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:
+* [HAProxy](https://haproxy-ingress.github.io/)
+* [NGINX](https://kubernetes.github.io/ingress-nginx/)
+* [Istio](https://istio.io/latest/docs/setup/getting-started/)
+
+OpenShift users can use [routes]({{< relref "/operate/kubernetes/networking/routes" >}}) instead of an Ingress.
+
+Install your chosen Ingress controller, making sure `ssl-passthrough` is enabled. `ssl-passthrough` is turned off by default for NGINX but enabled by default for HAProxy.
+
+## Configure DNS
+
+1. Choose the hostname (FQDN) you will use to access your database according to the recommended naming conventions below, replacing `<placeholders>` with your own values.
+
+     REC API hostname: `api-<rec-name>-<rec-namespace>.<subdomain>`
+     REAADB hostname: `-db-<rec-name>-<rec-namespace>.<subdomain>`
+     
+     We recommend using a wildcard (`*`) in place of the database name, followed by the hostname suffix.
+
+1. Retrieve the `EXTERNAL-IP` of your Ingress controller's `LoadBalancer` service.
+
+     ``` sh
+     $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                         -n <ingress-ctrl-namespace>
+     ```
+
+     Below is example output for an HAProxy ingress controller running on a K8s cluster hosted by AWS.  
+
+     ``` sh
+     NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+     haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+     ```
+
+1. Create DNS records to resolve your chosen REC API hostname and database hostname to the `EXTERNAL-IP` found in the previous step.
+
+## Edit the REC spec
+
+Edit the RedisEnterpriseCluster (REC) spec to add the `ingressOrRouteSpec` field, replacing `<placeholders>` below with your own values.
+
+### NGINX or HAproxy ingress controllers
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `ingress`.
+* Set `ssl-passthrough` to "true".
+* Add any additional annotations required for your ingress controller. See [NGINX docs](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) or [HAproxy docs](https://haproxy-ingress.github.io/docs/configuration/keys/) for more information.
+
+```sh
+kubectl patch rec  <rec-name> --type merge --patch "{\"spec\": \
+    {\"ingressOrRouteSpec\": \
+      {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\", \
+      \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+      \"ingressAnnotations\": \
+       {\"<kubernetes | github>.io/ingress.class\": \
+       \"<ingress-controller>\", \
+       \"<ingress-controller-annotation>/ssl-passthrough\": \ \"true\"}, \
+      \"method\": \"ingress\"}}}"
+```
+
+### OpenShift routes
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `openShiftRoute`.
+
+```sh
+kubectl patch rec <rec-name> --type merge --patch "{\"spec\": \
+     {\"ingressOrRouteSpec\": \
+     {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\" \ 
+     \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+     \"method\": \"openShiftRoute\"}}}"
+```
+
+OpenShift routes do not require any `ingressAnnotations` in the `ingressOrRouteSpec`.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Feature release with Redis Software 7.22.0-28 support, enhancements, and platform updates.
+hideListLinks: true
+linkTitle: 7.22.0-7 (April 2025)
+title: Redis Enterprise for Kubernetes 7.22.0-7 (April 2025) release notes
+weight: 50
+---
+## 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.
+
+### Enhancements
+
+- Added support for Redis Software 7.22.0.
+- Enabled support for Active-Active databases (REAADB) in multi-namespace deployments.
+- Defaulted new installations and upgrades to unprivileged mode, which uses a more secure security context without additional Linux capabilities.
+- A new cronjob is created by the operator using the `redislabs/re-call-home-client.7.22.0-7 image.
+- Updated supported Kubernetes platforms.
+
+### API changes
+
+| **CRD** | **Field** | **Change** | **Description** |
+|--------|-----------|------------|-----------------|
+| REAADB | `spec.participatingClusters[].namespace` | Added | Specifies the namespace in which the REAADB object will be deployed in the corresponding participating cluster. Make sure that the Redis Enterprise operator is configured to watch this namespace and that the required RBAC configuration is in place. For more information, see [Multi-namespace deployments]({{<relref "/operate/kubernetes/re-clusters/multi-namespace/">}}). If no namespace is specified, the REAADB object is deployed to the REC’s namespace in the corresponding cluster. |
+| REC | `spec.usageMeter.callHomeClient` | Added | Configuration for the call home client. For details, see the [REC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}). |
+| REC | `spec.securityContext.resourceLimits` | Added | Configuration that allows Redis Enterprise to adjust system resource settings. For details, see the [REC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}). |
+
+## Breaking changes
+
+By default, the operator no longer sets additional Linux capabilities in the security context. If your deployment requires capabilities such as `SYS_RESOURCE`, see [Enable privileged mode]({{<relref "/operate/kubernetes/security/enable-privileged-mode">}}).
+
+## Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| Kubernetes version | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** | **1.31** | **1.32** |
+|---|---|---|---|---|---|---|---|
+| **Community K8s** |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Azure EKS** |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Google GKE** |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher** |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKG 2.4** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **OpenShift** | **4.13** | **4.14** | **4.15** | **4.16** | **4.17** | **4.18** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI** | **1.16** | **1.17** | **1.18** | **1.19** | **1.20** |  |  |
+|  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.22.0-28`
+- **Operator**: `redislabs/operator:7.22.0-7`
+- **Services Rigger**: `redislabs/k8s-controller:7.22.0-7`
+- **OLM operator bundle** : `7.22.0-7.0`
+
+## Known limitations
+
+See [7.22.0 releases]({{<relref "/operate/kubernetes/release-notes/7-22-0-releases/">}}) for information on known limitations.
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.22.0
+hideListLinks: true
+linkTitle: 7.22.0 releases
+title: Redis Enterprise for Kubernetes 7.22.0 release notes
+weight: 46
+---
+
+Redis Enterprise for Kubernetes 7.22.0-7 includes bug fixes, enhancements, and support for Redis Enterprise Software version 7.22.0-28.
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Known limitations
+
+- **Only upgrades from 7.4.2-2 and later are supported.** If you are using an earlier version, install 7.4.2-2 before upgrading to 7.8.2-6 or later.
+
+- **When changing the REDB field `spec.modulesList`, version might be upgraded to latest, even if a different version is specified.** To prevent the upgrade to latest, set  `spec.upgradeSpec.setModuleToLatest` to `false` before upgrading to 7.8.2-6.
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The primary purpose this release is supporting Redis Enterprise 7.2.4.
+linkTitle: 7.2.4-2 (Aug 2023)
+title: Redis Enterprise for Kubernetes release notes 7.2.4-2 (Aug 2023)
+weight: 10
+---
+
+## Highlights
+
+The primary purpose this release is supporting [Redis Enterprise 7.2.4]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}}), 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.
+
+The following are the notable changes:
+
+- Support for [Redis Enterprise 7.2.4]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}})
+
+    - New major version of Redis, 7.2
+    - [Changes to modules and cluster recovery]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}})
+
+{{<warning>}}Redis Enterprise Software 7.2.4-52 includes several issues that also effect Redis Enterprise for Kubernetes and are not listed below. Review the Redis Enterprise Software 7.2.4 [breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#breaking-changes" >}}) and [known limitations.]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#known-limitations" >}}) {{</warning>}}
+
+- New default engine, Speedb, for Auto Tiering (formerly Redis on Flash)
+
+- Changes to [supported Kubernetes distributions]({{< relref "#supported-distributions" >}})
+
+## New in this release
+
+### Enhancements
+
+- Support for [Redis Enterprise 7.2.4]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}}) (RED-73681)
+- New default engine, Speedb, for Auto Tiering (formerly Redis on Flash) (RED-90850)
+- Security context hardening (RED-98447)
+
+### Resolved issues
+
+- Fixed: Services or routes from the Active-Active setup might not be removed (RED-77752)
+- Fixed: Admission controller may not alert when patching the REAADB with missing secret or RERC (RED-104463)
+
+### API changes
+
+The following fields were added to the RedisEnterpriseCluster (REC) custom resource definition (CRD):
+
+- Added `status.BundledDatabaseRedisVersions.major` as a Boolean field indicating whether the Redis version is major.
+- Added `spec.RedisOnFlashSpec.bigStoreDriver` to indicate the storage engine used for Auto Tiering (formerly Redis on Flash).
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-52 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-2.
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Deprecations
+
+- Gesher (advanced admission control configuration support) previously deprecated, is no longer supported.
+- Deprecated `spec.RedisOnFlashSpec.flashStorageEngine` field for the RedisEnterpriseCluster. Use `bigStoreDriver` field to indicate storage engines going forward.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.22** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Amazon EKS | <span title="End of life">&#x274c;</span> | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Azure AKS |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |
+| Rancher 2.7 |  | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| VMware TKG 1.6 | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |  |
+| **OpenShift version** | **4.9** | **4.10** | **4.11** | **4.12** | **4.13** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.13** | **1.14** | **1.15** | **1.16** |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-52`
+- **Operator**: `redislabs/operator:7.2.4-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-2.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-52.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-52.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-2`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-2`
+
+{{<note>}}It is not possible to upgrade your OLM deployment to version 7.2.4 from version 6.2.4-8 (November release). Uninstall 6.2.4-8 and perform a fresh install of 7.2.4.{{</note>}}
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+
+### New limitations
+
+- **REDBs created with versions before 6.2.10-4 will automatically upgrade modules when the cluster is upgraded (RED-106834)**
+
+- **Cannot upgrade or recover clusters if there are databases with manually uploaded modules (RED-107711 RED-106872)** Contact support.
+
+{{<warning>}}In version 7.2.4, old module versions and manually uploaded modules are not persisted. If databases are not upgraded after cluster upgrade, and require cluster recovery afterwards, you'll need to contact Redis support. This issue will be fixed in the next maintenance release by moving the stored location of the modules.{{</warning>}}
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will detele and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+### Existing limitations
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Misleading error appears when a service creation has failed due to service already existing "`provided IP is already allocated`" (RED-100669)** Delete the service manually.
+
+- **Existing OpenShift route during REC creation might prevent REC from starting (RED-100668)** Delete the route manually.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.2.4-109.
+linkTitle: 7.2.4-12 (August 2024)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (August 2024) release notes
+weight: 6
+---
+
+## Highlights
+
+This is a maintenance release to support Redis Enterprise Software version 7.2.4-109.
+
+## New in this release
+
+### Enhancements
+
+- Added support for Redis Enterprise Software 7.2.4-109.
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-109 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-109">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}}) in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field has been added to replace the hard-coded timeout of 15 minutes for a node to be stopped/drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+
+### Upcoming changes
+
+- A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+| **Kubernetes version** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon EKS | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Azure AKS |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> |  |  |  |  |
+| Rancher RKE2 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| VMware TKG 2.1 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| VMware TKG 2.2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| VMware TKG 2.3 |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.10** | **4.11** | **4.12** | **4.13** | **4.14** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.14** | **1.15** |  |  |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-109`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-109.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-109.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12.11`
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+### Existing limitations
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to the latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release with a few enhancements/fixes on the Kubernetes product and a new Redis Enterprise container version.
+linkTitle: 7.2.4-12 (Dec 2023)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (Dec 2023) release notes
+weight: 8
+---
+
+## Highlights
+
+This is a maintenance release with a few enhancements/fixes on the Kubernetes product and a newer Redis Enterprise container version.
+
+## New in this release
+
+### Enhancements
+
+- Added to [supported distributions](#supported-distributions)
+- Added support for Redis Enterprise Software 7.2.4-92 (RED-113750)
+- Replaced usage of config maps for readiness check and prestop scripts of Redis Enterprise pods (RED-81443)
+
+### Resolved issues
+
+- Fixed issues around REC creation when namespace contains old resources from previous installation (RED-100669) (RED-100668)
+- Fixed constant updates to watched namespaces REDB services (RED-103264)
+- Fixed labeling of old operator configmaps (RED-105517)
+- Removed automatic upgrades of modules during upgrades (RED-106834)
+- Fixed unexpected restart of container during cluster recovery (RED-108511)
+- Fixed timeout of prestop (RED-111471)
+- Fixed deployment issues on TKG (RED-111271)
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-92 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-92#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field has been added to replace the hard-coded timeout of 15 minutes for a node to be stopped/drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Upcoming changes
+
+- A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+| **Kubernetes version** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon EKS | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Azure AKS |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> |  |  |  |  |
+| Rancher RKE2 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| VMware TKG 2.1 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| VMware TKG 2.2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| VMware TKG 2.3 |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.10** | **4.11** | **4.12** | **4.13** | **4.14** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.14** | **1.15** |  |  |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-92`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-92.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-92.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12`
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+### Existing limitations
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a minor maintenance release with a few enhancements/fixes on the Kubernetes product, and a newer Redis Enterprise container version.
+linkTitle: 7.2.4-7 (Oct 2023)
+title: Redis Enterprise for Kubernetes release notes 7.2.4-7 (Oct 2023)
+weight: 9
+---
+
+## Highlights
+
+This is a minor maintenance release with a few enhancement/fixes on the Kubernetes product, and a newer Redis Enterprise container version.
+
+The following are the notable changes: 
+- Customers who are on RHEL 7 based images and who are already using this version of 7.2 can migrate to RHEL 8 based images when they upgrade.
+    - Previously, you could not migrate a cluster to newer OS version.
+    - All customers should plan to move to RHEL 8 based images. The next major version of Redis Enterprise will not support RHEL 7.
+    - This process requires specific pre-requisites and actions. Updated guides are being developed and will be available soon.
+- Added VMware TKG 2.1 and 2.2 to the [Supported distributions](#supported-distributions) table.
+
+
+## New in this release
+
+### Enhancements
+
+- Support for migration from RHEL7 images to RHEL8 during upgrade (RED-106785)
+- Support for Redis Enterprise Software version 7.2.4-64 (RED-108832)
+
+### Resolved issues
+
+- Fixed cluster recovery flow when non default modules are used (RED-107711 RED-106872)
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-64 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-64#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-7.
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Upcoming changes
+
+- A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.22** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Amazon EKS | <span title="End of life">&#x274c;</span> | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Azure AKS |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |
+| Rancher 2.7 |  | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| VMware TKG 1.6 | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |  |
+| VMware TKG 2.1 | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+| VMware TKG 2.2 |  | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.9** | **4.10** | **4.11** | **4.12** | **4.13** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.13** | **1.14** | **1.15** | **1.16** |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-64`
+- **Operator**: `redislabs/operator:7.2.4-7`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-7.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-64.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-64.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-7`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-7`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-7`
+
+{{<note>}}It is not possible to upgrade your OLM deployment to version 7.2.4 from version 6.2.4-8 (November release). Uninstall 6.2.4-8 and perform a fresh install of 7.2.4.{{</note>}}
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+### Existing limitations
+
+- **REDBs created with versions before 6.2.10-4 will automatically upgrade modules when the cluster is upgraded (RED-106834)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will detele and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Misleading error appears when a service creation has failed due to service already existing "`provided IP is already allocated`" (RED-100669)** Delete the service manually.
+
+- **Existing OpenShift route during REC creation might prevent REC from starting (RED-100668)** Delete the route manually.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.2.4-105.
+linkTitle: 7.2.4-12 (March 2024)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (March 2024) release notes
+weight: 7
+---
+
+## Highlights
+
+This is a maintenance release to support Redis Enterprise Software version 7.2.4-105.
+
+## New in this release
+
+### Enhancements
+
+- Added support for Redis Enterprise Software 7.2.4-105 (RED-113750)
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-105 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-105#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field has been added to replace the hard-coded timeout of 15 minutes for a node to be stopped/drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Upcoming changes
+
+- A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+| **Kubernetes version** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon EKS | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Azure AKS |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> |  |  |  |  |
+| Rancher RKE2 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| VMware TKG 2.1 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| VMware TKG 2.2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| VMware TKG 2.3 |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.10** | **4.11** | **4.12** | **4.13** | **4.14** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.14** | **1.15** |  |  |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-105`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-105.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-105.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12.6`
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+### Existing limitations
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.2.4-117.
+linkTitle: 7.2.4-12 (October 2024)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (October 2024) release notes
+weight: 5
+---
+
+## Highlights
+
+This is a maintenance release to support Redis Enterprise Software version 7.2.4-117.
+
+## New in this release
+
+### Enhancements
+
+- Added support for Redis Enterprise Software 7.2.4-117.
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-117 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}}) in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field has been added to replace the hard-coded timeout of 15 minutes for a node to be stopped/drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+
+### Upcoming changes
+
+- A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+| **Kubernetes version** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon EKS | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Azure AKS |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> |  |  |  |  |
+| Rancher RKE2 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| VMware TKG 2.1 | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| VMware TKG 2.2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| VMware TKG 2.3 |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.10** | **4.11** | **4.12** | **4.13** | **4.14** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.14** | **1.15** |  |  |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-117`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-117.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-117.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12.22`
+
+The OLM version v7.2.4-12.22 replaces the earlier v7.2.4-12.21 release for the same Redis software version, providing only upgrade path fixes.
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+### Existing limitations
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to the latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.2.4-118.
+linkTitle: 7.2.4-12 (January 2025)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (January 2025) release notes
+weight: 4
+---
+
+## 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){{<relref "/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-10-24">}}.
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-118`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-118.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-118.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12.33`
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-118 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/">}}).---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.2.4-118.
+linkTitle: 7.2.4-12 (March 2025)
+title: Redis Enterprise for Kubernetes 7.2.4-12 (March 2025) release notes
+weight: 1
+---
+
+## 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]({{<relref "/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-10-24">}}).
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.2.4-122`
+- **Operator**: `redislabs/operator:7.2.4-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.2.4-12.`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.2.4-122.rhel8-openshift`
+    (or `redislabs/redis-enterprise:7.2.4-118.rhel7-openshift` if upgrading from RHEL 7)
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.2.4-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.2.4-12`
+
+### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.2.4-12.35`
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-122 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/">}}).---
+Title: 7.2.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for Redis Enterprise 7.2.4, platform support updates, and bug
+  fixes.
+hideListLinks: true
+linkTitle: 7.2.4 releases
+weight: 55
+---
+
+## Highlights
+
+The primary purpose this release is supporting [Redis Enterprise 7.2.4]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}}), 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.
+
+The following are the notable changes:
+
+- Support for [Redis Enterprise 7.2.4]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52" >}})
+
+    - New major version of Redis, 7.2
+    - [Changes to modules and cluster recovery]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}})
+
+{{<warning>}}Redis Enterprise Software 7.2.4-52 includes several issues that also effect Redis Enterprise for Kubernetes and are not listed below. Review the Redis Enterprise Software 7.2.4 [breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#breaking-changes" >}}) and [known limitations.]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#known-limitations" >}}) {{</warning>}}
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4 release notes]({{<relref "operate/rs/release-notes/rs-7-2-4-releases/">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-2.
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Deprecations
+
+- Gesher (advanced admission control configuration support) previously deprecated, is no longer supported.
+- Deprecated `spec.RedisOnFlashSpec.flashStorageEngine` field for the RedisEnterpriseCluster. Use `bigStoreDriver` field to indicate storage engines going forward. 
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Warning icon">&#x26A0;&#xFE0F;</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.22** | **1.23** | **1.24** | **1.25** | **1.26** | **1.27** |
+|---|---|---|---|---|---|---|
+| Community Kubernetes | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Amazon EKS | <span title="End of life">&#x274c;</span> | <span title="Deprecation warning">&#x26A0;&#xFE0F;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Azure AKS |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Google GKE | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| Rancher 2.6 | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |
+| Rancher 2.7 |  | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| VMware TKG 1.6 | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> |  |  |  |  |
+| **OpenShift version** | **4.9** | **4.10** | **4.11** | **4.12** | **4.13** |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.13** | **1.14** | **1.15** | **1.16** |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Warning icon">&#x26A0;&#xFE0F;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.2.4 release notes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases#known-limitations" >}}).
+
+{{<warning>}}Pay particular attention to the [cluster recovery limitation]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}}) if you use manually uploaded modules.{{</warning>}}
+
+- **Cannot upgrade or recover clusters if there are databases with manually uploaded modules (RED-107711 RED-106872)** Contact support.
+
+- **REDBs created with versions before 6.2.10-4 will automatically upgrade modules when the cluster is upgraded (RED-106834)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will detele and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Misleading error appears when a service creation has failed due to service already existing "`provided IP is already allocated`" (RED-100669)** Delete the service manually.
+
+- **Existing OpenShift route during REC creation might prevent REC from starting (RED-100668)** Delete the route manually.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Maintenance release to support Redis Enterprise Software version 7.8.2-60.
+hideListLinks: true
+linkTitle: 7.8.2-6 (Jan 2025)
+title: Redis Enterprise for Kubernetes 7.8.2-6 (Jan 2025) release notes
+weight: 2
+---
+
+## Highlights
+
+This is a maintenance release to support [Redis Enterprise Software version 7.8.2-60]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-7-8-2-60">}}). For version changes, supported distributions, and known limitations, see the [release notes for 7.8.2-6 (Nov 2024)]({{<relref "/operate/kubernetes/release-notes/7-8-2-releases/7-8-2-6-nov24">}}).
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.8.2-60`
+- **Operator**: `redislabs/operator:7.8.2-6`
+- **Services Rigger**: `redislabs/k8s-controller:7.8.2-6`
+- **OLM operator bundle** : `v7.8.2-6.8`
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Feature release including support for Redis Software 7.8.2 and RHEL9-based images.
+hideListLinks: true
+linkTitle: 7.8.2-6 (Nov 2024)
+title: Redis Enterprise for Kubernetes 7.8.2-6 (Nov 2024) release notes
+weight: 3
+---
+
+
+
+## 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]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-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:
+
+- Cluster version of 7.4.2-2 or later.
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+See [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/upgrade/upgrade-redis-cluster">}}) for detailed steps to upgrade to 7.8.2-6.
+
+### Deprecations
+
+- Ubuntu-based images are no longer supported.
+- REDB field `upgradeSpec.upgradeModulesToLatest is deprecated.
+- REDB field `spec.modulesList.version` is deprecated.
+
+## Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** | **1.31** |
+|---|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| **Amazon EKS** |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Azure AKS** |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Google GKE** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Rancher RKE2** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.3** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 2.4** |  | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |  |
+| **OpenShift** | **4.12** | **4.13** | **4.14** | **4.15** | **4.16** |  |  |
+| **** | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| **VMWare TKGI** | **1.16** | **1.17** | **1.18** | **1.19** |  |  |  |
+| **** | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+
+## Downloads
+
+**Redis Enterprise**: `redislabs/redis:7.8.2-34`
+**Operator**: `redislabs/operator:7.8.2-6`
+**Services Rigger**: `redislabs/k8s-controller:7.8.2-6`
+**OLM operator bundle**: `v7.8.2-6.3`
+
+## Known limitations
+
+### New limitations
+
+- **Only upgrades from 7.4.2-2 and later are supported.** If you are using an earlier version, install 7.4.2-2 before upgrading to 7.8.2-6.
+
+- **When changing the REDB field `spec.modulesList` version might be upgraded to latest even if a different version is specified.** To prevent the upgrade to latest, set  `spec.upgradeSpec.setModuleToLatest` to `false` before upgrading to 7.8.2-6.
+
+### Existing limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.8.2
+hideListLinks: true
+linkTitle: 7.8.2 releases
+title: Redis Enterprise for Kubernetes 7.8.2-6 release notes
+weight: 51
+---
+
+Redis Enterprise for Kubernetes 7.8.2-6 is a feature release including support for Redis Software 7.8.2-2.
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### RHEL9-based images
+
+- Redis Enterprise images are now based on RHEL9.
+- Ubuntu images are no longer supported.
+
+This means upgrades to 7.8.2-6 require:
+
+- Cluster version of 7.4.2-2 or later.
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+See [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/upgrade/upgrade-redis-cluster">}}) for detailed steps to upgrade to 7.8.2-6.
+
+## Known limitations
+
+### New limitations
+
+- **Only upgrades from 7.4.2-2 and later are supported.** If you are using an earlier version, install 7.4.2-2 before upgrading to 7.8.2-6.
+
+- **When changing the REDB field `spec.modulesList` version might be upgraded to latest even if a different version is specified.** To prevent the upgrade to latest, set `spec.upgradeSpec.setModuleToLatest` to `false` before upgrading to 7.8.2-6.
+
+### Existing limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release with a new version of Redis Enterprise Software 7.4.6.
+linkTitle: 7.4.6-2 (October 2024)
+title: Redis Enterprise for Kubernetes 7.4.6-2 (October 2024) release notes
+weight: 4 
+---
+
+## Highlights
+
+This is a maintenance release to support [Redis Enterprise Software version 7.4.6-77]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-77">}}). For version changes, supported distributions, and known limitations, see the [release notes for 7-4-6-2 (July 2024)]({{<relref "/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2">}}).
+
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.6-77`
+- **Operator**: `redislabs/operator:7.4.6-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.6-2`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-77.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-2`
+
+### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.6-2.3`
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release with a new version of Redis Enterprise Software 7.4.6.
+linkTitle: 7.4.6-2 (October 2024)
+title: Redis Enterprise for Kubernetes 7.4.6-2 (October 2024) release notes
+weight: 3 
+---
+
+## Highlights
+
+This is a maintenance release to support [Redis Enterprise Software version 7.4.6-102]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/">}}). For version changes, supported distributions, and known limitations, see the [release notes for 7-4-6-2 (July 2024)]({{<relref "/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2">}}).
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.6-102`
+- **Operator**: `redislabs/operator:7.4.6-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.6-2`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-102.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-2`
+
+### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.6-2.4`
+
+The OLM version v7.4.6-2.4 replaces the earlier v7.4.6-2.3 release for the same Redis software version, providing only upgrade path fixes.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.4.6-102 and contains a suggested fix needed to upgrade to newer versions.
+hideListLinks: true
+linkTitle: 7.4.6-6 (Dec 2024)
+title: Redis Enterprise for Kubernetes 7.4.6-6 (Dec 2024) release notes
+weight: 2
+---
+
+## Highlights
+
+This is a maintenance release to support [Redis Enterprise Software version 7.4.6-102]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/rs-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)]({{<relref "/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2">}}).
+
+## New in this release
+
+### Resolved issues
+
+- Fixed service rigger crashing after REC upgrade (RED-144785)
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.6-102`
+- **Operator**: `redislabs/operator:7.4.6-6`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.6-6`
+
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-102.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-6`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-6`
+- **OLM operator bundle** : `v7.4.6-6.1`
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a feature release with a new version of Redis Enterprise Software
+  7.4.6.
+linkTitle: 7.4.6-2 (July 2024)
+title: Redis Enterprise for Kubernetes 7.4.6-2 (July 2024) release notes
+weight: 5
+aliases: /operate/kubernetes/release-notes/7-4-6-2, 
+---
+
+## Highlights
+
+The primary purpose of this release is to support [Redis Enterprise Software version 7.4.6]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22">}}). It also includes updates to supported platform distributions.
+
+## New in this release
+
+### Enhancements
+
+- Removal of multiple unneeded permissions from RBAC roles used by the operator (RED-123478 RED-125020)
+- Support for non-AWS S3 compatible backup targets in REC (RED-73642)
+- Support for Redis Enterprise 7.4.6-22 (RED-13110)
+
+### API changes
+
+| **CRD** | **Field** | **Change** | **Description** |
+|---|---|---|---|
+| REC | backup.s3.caCertificateSecretName | Add | Secret name that holds the S3 CA certificate, which contains the TLS certificate mapped to the key in the secret 'cert' |
+| REC | backup.s3.url | Add | Specifies the URL for S3 export and import (used for custom S3 compatible servers) |
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-109 release notes]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+#### Upcoming Changes
+
+- Future Redis Enterprise images will be UBI9-based only, without support for Ubuntu-based images.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** |
+|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Azure AKS** |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Google GKE** | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher RKE2** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKG 2.2** | <span title="X icon">&#x274c;</span> |  |  |  |  |  |
+| **VMware TKG 2.3** | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| **VMware TKG 2.4** | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| **OpenShift version** | **4.12** | **4.13** | **4.14** | **4.15** | **4.16** |  |
+|  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.16** | **1.17** | **1.18** | **1.19** |  |  |
+|  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.6-22`
+- **Operator**: `redislabs/operator:7.4.6-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.6-2`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-22.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-2`
+
+### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.6-2.0`
+
+## Known limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release to support Redis Enterprise Software version 7.4.6-233 (7.4.6-232 for OpenShift).
+hideListLinks: true
+linkTitle: 7.4.6-6 (March 2025)
+title: Redis Enterprise for Kubernetes 7.4.6-6 (March 2025) release notes
+weight: 1
+---
+
+## Highlights
+
+This is a maintenance release to support [Redis Enterprise Software version 7.4.6-232]({{<relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-232">}}). For version changes, supported distributions, and known limitations, see the [release notes for 7.4.6]({{<relref "/operate/kubernetes/release-notes/7-4-6-releases">}}).
+
+{{<warning>}}If you are not using OpenShift, you must use the `7.4.6-233` Redis Enterprise image listed below. The `7.4.6-232` image only supports OpenShift, and may cause the upgrade to fail if used with other distributions.
+
+To upgrade successfully, use the correct Redis Enterprise image for your K8s distribution.
+
+- OpenShift: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-232.rhel8-openshift`
+- Non-OpenShift distributions: `redislabs/redis:7.4.6-233`
+{{</warning>}}
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.6-233`
+- **Operator**: `redislabs/operator:7.4.6-6`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.6-6`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.6-232.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-6`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-6`
+- **OLM operator bundle**: `v7.4.6-6.3`
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.4.6.
+hideListLinks: true
+linkTitle: 7.4.6 releases
+title: Redis Enterprise for Kubernetes 7.4.6 release notes
+weight: 52
+---
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. If you skip this step, OpenShift clusters running version 6.2.12 or earlier might get stuck when upgrading to version 6.2.18 or later. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Upcoming Changes
+
+- Future Redis Enterprise images will be UBI9-based only, without support for Ubuntu-based images.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-109 release notes]({{<relref "operate/rs/release-notes/rs-7-4-2-releases">}}).
+
+## Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** |
+|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Azure AKS** |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Google GKE** | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher RKE2** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKG 2.2** | <span title="X icon">&#x274c;</span> |  |  |  |  |  |
+| **VMware TKG 2.3** | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| **VMware TKG 2.4** | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| **OpenShift version** | **4.12** | **4.13** | **4.14** | **4.15** | **4.16** |  |
+|  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.16** | **1.17** | **1.18** | **1.19** |  |  |
+|  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+
+## Known limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Maintenance release to support Redis Enterprise Software version 7.8.4-95.
+hideListLinks: true
+linkTitle: 7.8.4-9 (March 2025)
+title: Redis Enterprise for Kubernetes 7.8.4-9 (March 2025) release notes
+weight: 9
+---
+
+This is a maintenance release to support [Redis Enterprise Software version 7.8.4-95]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-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)]({{<relref "/operate/kubernetes/release-notes/7-8-2-releases/7-8-2-6-nov24">}}).
+
+## Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** | **1.31** |
+|---|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| **Amazon EKS** |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Azure AKS** |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Google GKE** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Rancher RKE2** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.3** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 2.4** |  | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |  |
+| **OpenShift** | **4.12** | **4.13** | **4.14** | **4.15** | **4.16** | **4.17** | **4.18** |
+| **** | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| **VMWare TKGI** | **1.16** | **1.17** | **1.18** | **1.19** |  |  |  |
+| **** | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.8.4-95`
+- **Operator**: `redislabs/operator:7.8.4-9`
+- **Services Rigger**: `redislabs/k8s-controller:7.8.4-9`
+- **OLM operator bundle** : `v7.8.4-9.0`---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Maintenance release to support Redis Enterprise Software version 7.8.4-66.
+hideListLinks: true
+linkTitle: 7.8.4-8 (Feb 2025)
+title: Redis Enterprise for Kubernetes 7.8.4-8 (Feb 2025) release notes
+weight: 10
+---
+
+This release includes bug fixes, enhancements, and support for [Redis Enterprise Software version 7.8.4-66]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-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]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-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]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** | **1.31** |
+|---|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |
+| **Amazon EKS** |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Azure AKS** |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Google GKE** |  |  | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |
+| **Rancher RKE2** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.3** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 2.4** |  | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |  |
+| **OpenShift** | **4.12** | **4.13** | **4.14** | **4.15** | **4.16** |  |  |
+| **** | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |
+| **VMWare TKGI** | **1.16** | **1.17** | **1.18** | **1.19** |  |  |  |
+| **** | <span title="X icon">&#x274c;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> | <span title="Check mark icon">&#x2705;</span> |  |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.8.4-66`
+- **Operator**: `redislabs/operator:7.8.4-8`
+- **Services Rigger**: `redislabs/k8s-controller:7.8.4-8`
+- **OLM operator bundle** : `v7.8.4-8.0`---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.8.4
+hideListLinks: true
+linkTitle: 7.8.4 releases
+title: Redis Enterprise for Kubernetes 7.8.4 release notes
+weight: 49
+---
+
+Redis Enterprise for Kubernetes 7.8.4-8 includes bug fixes, enhancements, and support for [Redis Enterprise Software version 7.8.4]({{<relref "/operate/rs/release-notes/rs-7-8-releases">}}).
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## 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:
+
+- Cluster version of 7.4.2-2 or later.
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+See [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/upgrade/upgrade-redis-cluster">}}) for detailed steps to upgrade to 7.8.4-8.
+
+### Deprecations
+
+- Ubuntu-based images are no longer supported.
+- REDB field `upgradeSpec.upgradeModulesToLatest is deprecated.
+- REDB field `spec.modulesList.version` is deprecated.
+
+## Known limitations
+
+### New limitations
+
+- **Specifying `databasePort` causes issues with REAADB synchronization. (RED-149374)**
+
+### Existing limitations
+
+- **Only upgrades from 7.4.2-2 and later are supported.** If you are using an earlier version, install 7.4.2-2 before upgrading to 7.8.2-6 or later.
+
+- **When changing the REDB field `spec.modulesList`, version might be upgraded to latest, even if a different version is specified.** To prevent the upgrade to latest, set  `spec.upgradeSpec.setModuleToLatest` to `false` before upgrading to 7.8.2-6.
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release supporting Redis Enterprise Software 7.4.2.
+linkTitle: 7.4.2-2 (March 2024)
+title: Redis Enterprise for Kubernetes 7.4.2-2 (March 2024) release notes
+weight: 7
+---
+
+## Highlights
+
+The primary purpose of this release is to support [Redis Enterprise 7.4.2]({{< relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-104" >}}), which is a maintenance release of Redis Enterprise Software.
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-104 release notes]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-104#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field was added in version 7.2.4-12 to replace the hard-coded timeout of 15 minutes for a node to be stopped or drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Deprecations
+
+- Redis Software for Kubernetes no longer supports the RHEL7 operating system. Migrate to RHEL8 to use this version.
+
+### Supported distributions
+
+See the [7.4.2 releases]({{< relref "/operate/kubernetes/release-notes/7-4-2-releases" >}}) page for the list of supported distributions.
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.2-104`
+- **Operator**: `redislabs/operator:7.4.2-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.2-2`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.2-104.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.2-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.2-2`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.2-2.6`
+
+## Known limitations
+
+See the [7.4.2 releases]({{< relref "/operate/kubernetes/release-notes/7-4-2-releases" >}}) page for the list of known limitations.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The primary purpose of this release is to support Redis Enterprise 7.4.2
+linkTitle: 7.4.2-2 (Feb 2024)
+title: Redis Enterprise for Kubernetes 7.4.2-2 (Feb 2024) release notes
+weight: 8
+---
+
+## Highlights
+
+The primary purpose of this release is to support [Redis Enterprise 7.4.2]({{< relref "/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-54" >}}), 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.
+
+## New in this release
+
+### Enhancements
+
+- Added RESP3 support in K8s APIs (RED-94601)
+- Added to [supported distributions](#supported-distributions)
+- Added support for Redis Enterprise Software 7.4.2
+- Enhanced resilience of operators to misconfigured REDB namespaces (RED-113908)
+- Both the operator and services rigger are now based on UBI9 (RED-116083)
+
+### Resolved issues
+
+- Fixed the operator to prevent reconciliation of non-REDB custom resources in observed namespaces. This eliminates the need for unnecessary permission rules. (RED-87790)
+- Fixed excessive updates to ingresses and services. (RED-109289)
+- Fixed update issues in rigger after the upgrade in multi-namespace environments. (RED-111732)
+- Fixed Active-Active sharding configuration by adding a new field. (RED-112909)
+- Fixed operator CVE. (RED-115157)
+- Fixed a race condition that could have rarely caused the cluster upgrade to break. (RED-118940)
+
+### API changes
+
+| **CRD** | **Field** | **Change** | **Description** |
+|---|---|---|---|
+| REC | resp3Default | Add | Boolean controlling whether Resp3 should be enabled by default |
+| REDB | resp3 | Add | Controls resp3 for specific REDBs |
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-54 release notes]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-54#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field was added in version 7.2.4-12 to replace the hard-coded timeout of 15 minutes for a node to be stopped or drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Deprecations
+
+- Redis Software for Kubernetes no longer supports the RHEL7 operating system. Migrate to RHEL8 to use this version.
+
+### Supported distributions
+
+See the [7.4.2 releases]({{< relref "/operate/kubernetes/release-notes/7-4-2-releases" >}}) page for the list of supported distributions.
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.2-54`
+- **Operator**: `redislabs/operator:7.4.2-2`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.2-2`
+
+#### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.2-54.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.2-2`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.2-2`
+
+#### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.2-2`
+
+## Known limitations
+
+See the [7.4.2 releases]({{< relref "/operate/kubernetes/release-notes/7-4-2-releases" >}}) page for the list of known limitations.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a feature release with a new version of Redis Enterprise Software support for persistent volume expansion.
+linkTitle: 7.4.2-12 (May 2024)
+title: Redis Enterprise for Kubernetes 7.4.2-12 (May 2024) release notes
+weight: 6
+---
+
+## 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.
+
+## New in this release
+
+### Enhancements
+
+- Support for persistent volume expansion in the REC (RED-84018)
+- Ability to specify Redis version in REDB spec (RED-103945)
+- Updated [supported distributions]({{<relref "/operate/kubernetes/release-notes/7-4-2-releases/#supported-distributions">}}) (RED-119711)
+- Ability to enable modules via REDB without specifying a module version (RED-116082)
+- Dual Stack configuration support (RED-121897)
+
+### Resolved issues
+
+- Fixed case of client certificates being updated in a loop (RED-121633)
+- Fixed issues disabling replication on REDB (RED-122721)
+
+### API changes
+
+| **CRD** | **Field** | **Change** | **Description** |
+|---|---|---|---|
+| REC | spec.persistentSpec.enablePersistentVolumeResize | ADD | Set to "true" to allow changes in volumeSize after REC creation (for sizing up only) |
+| REC | status.persistenceStatus | ADD | Indicates the status of persistent volume expansion |
+| REC | spec.redisEnterpriseIPFamily | ADD | Configure which IP family to use when Kubernetes cluster has Dual Stack networking enabled  |
+| REDB | spec.moduleList[x].version | CHANGE | Field is no longer mandatory |
+| REDB | spec.upgradeSpec | ADD | New field allows configuration of module upgrade settings |
+| REDB | spec.redisVersion | CHANGE | Now allows setting version numbers (Major.Minor) |
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-129 release notes]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-129#security">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+#### Upcoming Changes
+
+- Future Redis Enterprise images will be UBI9-based only, without support for Ubuntu-based images.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** |
+|---|---|---|---|---|---|---|
+| **Community Kubernetes** |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Azure AKS** |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Google GKE** |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher RKE2** | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKG 2.2** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |
+| **VMware TKG 2.3** | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.4** |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.11** | **4.12** | **4.13** | **4.14** | **4.15** |  |
+|  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **VMware TKGI version** | **1.15** | **1.16** | **1.17** | **1.18** |  |  |
+|  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.4.2-129`
+- **Operator**: `redislabs/operator:7.4.2-12`
+- **Services Rigger**: `redislabs/k8s-controller:7.4.2-12`
+
+### OpenShift images
+
+- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.2-129.rhel8-openshift`
+- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.2-12`
+- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.2-12`
+
+### OLM bundle
+
+**Redis Enterprise operator bundle** : `v7.4.2-12.0`
+
+## Known limitations
+
+### New limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+### Existing limitations
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.4.2.
+hideListLinks: true
+linkTitle: 7.4.2 releases
+title: Redis Enterprise for Kubernetes 7.4.2 release notes
+weight: 54
+---
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Version changes
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.6-22 release notes]({{<relref "operate/rs/release-notes/rs-7-4-2-releases/">}}).
+
+### Breaking changes
+
+The following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+#### Upgrade operating system
+
+{{<warning>}}If your databases use modules, you need to update all nodes in the cluster to Redis Enterprise 7.2.4 or later before upgrading your operating system. See [Upgrade a cluster's operating system]({{< relref "/operate/rs/installing-upgrading/upgrading/upgrade-os" >}})in the Redis Enterprise Software documentation for more details.{{</warning>}}
+
+#### terminationGracePeriodSeconds
+
+The configurable `terminationGracePeriodSeconds` REC field was added in version 7.2.4-12 to replace the hard-coded timeout of 15 minutes for a node to be stopped or drained (RED-111471).
+
+#### ValidatingWebhookConfiguration
+
+Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+#### OpenShift SCC
+
+Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions.
+
+### Deprecations
+
+- Redis Software for Kubernetes no longer supports the RHEL7 operating system. Migrate to RHEL8 to use this version.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| **Kubernetes version** | **1.24** | **1.25** | **1.26** | **1.27** | **1.28** | **1.29** |
+|---|---|---|---|---|---|---|
+| **Community Kubernetes** | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Azure AKS** | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Google GKE** | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| **Rancher RKE2** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKG 2.2** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |
+| **VMware TKG 2.3** | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.4** |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **OpenShift version** | **4.11** | **4.12** | **4.13** | **4.14** |  |  |
+|  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKGI version** | **1.15** | **1.16** | **1.17** | **1.18** |  |  |
+|  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+## Known limitations
+
+The limitations below are specific to the Redis Enterprise for Kubernetes product. To view limitations for the supported Redis Enterprise Software version, see the [7.4.2 release notes]({{< relref "/operate/rs/release-notes/rs-7-4-2-releases#known-limitations" >}}).
+
+### New limitations
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+### Existing limitations
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services- rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-8 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+linkTitle: 6.4.2-8 (July 2023)
+title: Redis Enterprise for Kubernetes release notes 6.4.2-8 (July 2023)
+weight: 54
+---
+
+## 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.
+
+## New in this release 
+
+### Feature enhancements
+
+* New Redis Enterprise software version 6.4.2-94 (RED-105738)
+
+### Bug fixes
+
+* Fixed bad handling of certificate chains in the REC controller (RED-105578)
+
+## Upgrade considerations
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading to 6.4.2-8.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+* **OpenShift SCC**
+
+  This release includes a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for expand.
+
+## Compatibility
+
+### Deprecated features
+
+* Support for Gesher, the advanced admission control configuration, is deprecated.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) reflecting the most recent release.
+
+| **Kubernetes version**  | 1.22       | 1.23       | 1.24       | 1.25       | 1.26       | 1.27       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            | deprecated | supported  | supported  | supported  | supported  |
+| Amazon EKS              | deprecated | deprecated | supported  | supported  |            |            |
+| Azure AKS               |            | deprecated | supported  | supported  | supported  |
+| Google GKE              | deprecated | deprecated | supported  | supported  | supported  |            |
+| Rancher 2.6             | deprecated | deprecated | supported  |            |            |            |
+| Rancher 2.7             |            | deprecated | supported  |            |            |            |
+| VMware TKG 1.6          | deprecated | deprecated |            |            |            |            |
+| **OpenShift version**   | **4.9**    | **4.10**   | **4.11**   | **4.12**   |            |            |
+|                         |            | deprecated | supported  | supported  |            |            |
+| **VMware TKGI version** | **1.13**   | **1.14**   | **1.15**   |            |            |            |
+|                         | deprecated | deprecated | supported  |            |            |            |
+
+\* Support added in this release
+
+{{<note>}} Redis Enterprise for Kubernetes now uses RKE2 as the default for Rancher distributions. {{</note>}}
+
+### Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-94`
+* **Operator**: `redislabs/operator:6.4.2-8`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-8.`
+
+#### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-94.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-94.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-8`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-8`
+
+#### OLM bundle
+
+* **Redis Enterprise operator bundle** : `v6.4.2-8`
+
+## Known limitations
+
+* **Air-gapped environments using Gears will get stuck during cluster recovery(RED-112076)** This bug affects Redis Enterprise for Kubernetes versions older than 7.2.4-2.
+
+### Existing limitations
+
+* **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in teh Active-Active database.
+
+* **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+* **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+* **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+* **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+* **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+* **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+* **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+* **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+* **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+* **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+* **An unreachable cluster has status running (RED-32805)** When a cluster is in unreachable state, the state remains `running` instead of triggering an error.
+
+* **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+* **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-94 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-94">}}).---
+Title: Redis Enterprise for Kubernetes release notes 6.4.2-4 (March 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-4 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+linktitle: 6.4.2-4 (March 2023)
+weight: 57
+---
+## Overview
+
+The Redis Enterprise K8s 6.4.2-4 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+
+The key features, bug fixes, and known limitations are described below.
+
+## Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-43`
+* **Operator**: `redislabs/operator:6.4.2-4`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-4`
+
+### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-43.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-43.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-4`s
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-4`
+
+### OpenShift OLM bundles
+
+* Redis Enterprise operator bundle version: `v6.4.2-4.0`
+
+## New features
+
+* Cluster-level LDAP configuration support in REC (RED-83533)
+* Public preview support for declarative Active-Active configuration (RED-86470)(RED-86470)
+
+## Feature improvements
+
+* New labeling method for multi-namespace REDB (RED-83102)
+* Operator deployment uses built-in SCC in OpenShift (RED-90524)
+* Support for Redis Enterprise 6.4.2-43
+* Support added for K8s 1.26, EKS 1.24, AKS 1.25, Rancher 2.7/1.23-24
+* Improved log collector display and error handling
+
+## Bug fixes
+
+* Deployment manifests referenced non-existent redis-enterprise-admission ServiceAccount (RED-90469)
+* CVE-2022-1996 (RED-93026)
+* CVE-2022-28948 (RED-93027)
+* CVE-2021-44716 & CVE-2022-27664 (RED-93028)
+* CVE-2018-20225
+
+## API changes
+
+The following fields were changed in the [Redis Enterprise cluster (REC) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}):
+
+* Added `.spec.ldap` for configuring cluster-level LDAP settings
+* Added `.spec.certificates.ldapClientCertificateSecretName` for configuring LDAP client certificate
+* Added `.status.managedAPIs` to track APIs managed by the operator
+
+* The following custom resources definitions were added:
+  * `RedisEnterpriseRemoteCluster` (RERC)
+  * `RedisEnterpriseActiveActiveDatabase` (REAADB)
+
+## Compatibility notes
+
+### Deprecated features
+
+* Support for Gesher, the advanced admission control configuration, is deprecated.
+* The `app.redislabs.com/v1alpha1` API version of the RedisEnterpriseCluster (REC) custom resource is deprecated and will be removed in a subsequent release. Customers should switch to use the `app.redislabs.com/v1` API version instead.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}).
+
+| **Kubernetes version**  | 1.21       | 1.22       | 1.23       | 1.24       | 1.25       | 1.26       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            | deprecated | supported  | supported  | supported  | supported* |
+| Amazon EKS              |            | supported  | supported  | supported* |            |            |
+| Azure AKS               |            |            | deprecated | supported  | supported* |            |
+| Google GKE              |            | supported  | supported  | supported  | supported  |            |
+| Rancher 2.6             | deprecated | supported  | supported  | supported  |            |            |
+| Rancher 2.7             |            |            | supported* | supported* |            |            |
+| VMware TKG 1.6          |            | supported  | supported  |            |            |            |
+| **OpenShift version**   | **4.8**    | **4.9**    | **4.10**   | **4.11**   |  **4.12**  |            |
+|                         | deprecated | deprecated | supported  | supported  | supported* |            |
+| **VMware TKGI version** | **1.12**   | **1.13**   | **1.14**   | **1.15**   |            |            |
+|                         |            | deprecated | supported  | supported  |            |            |
+
+\* Support added in this release
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+* **Supported upgrade paths**
+
+  If you are using a version earlier than 6.2.10-45, you cannot upgrade directly to this release. You must upgrade to 6.2.10-45 before you can upgrade to versions 6.2.18 or later.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+## Active-Active preview known limitations
+
+* No support for Hashicorp Vault for storing secrets (RED-95805)
+* No module support (RED-95153)
+* No support for client certificates in secrets (RED-95724)
+* No support for backup configuration (RED-95724)
+* No support for upgrading the database Redis version
+* REAADB secret status isn't updated in source cluster (RED-96296)
+
+  The workaround is to view the secret status in one of the remote clusters.
+* Invalid REAADB is not rejected by admission might get deleted after apply. (RED-96300)
+
+  Fix the problems with the REAADB and reapply. Contact support if you aren't sure why the REAADB is invalid.
+* Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)
+
+  Fix the problems with the REAADB and reapply.
+* RERC resources must have a unique name (`<rec-name>/<rec-namespace>`). (RED-96302)
+
+* Only global database options are supported, not support for specifying configuration per location.
+* Can't automatically update the cluster secret via the operator (can be updated manually).
+* No support for migration from old (manual) Active-Active database method to new Active-Active controller.
+
+## Known limitations
+
+* REC creation might fail using form view on OpenShift. (RED-100517)
+
+  To avoid this, use the YAML view. This will be fixed in the next release.
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* Resharding fails for rack-aware databases with no replication (RED-97971)
+  
+  When a database is configured as [rack-aware]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}}) and replication is turned off, the resharding operation fails.
+
+  Workaround:
+    Before resharding your database, [turn off rack awareness]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api" >}}). Set the `spec.rackAware` field in your REDB custom resource to `false`.
+    After the resharding process is complete, you can [re-enable rack awareness]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api" >}}).
+
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+* An unreachable cluster has status running (RED-32805)
+
+  When a cluster is in unreachable state, the state remains `running` instead of triggering an error.
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+* Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)
+
+  The workaround is to use the newer (current) revision of the [quick start]({{< relref "/operate/kubernetes/deployment/quick-start.md" >}}).
+* `autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+  ## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-43 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-43">}}).---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-8 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+linkTitle: 6.4.2-8 (Dec 2023)
+title: Redis Enterprise for Kubernetes release notes 6.4.2-8 (Dec 2023)
+weight: 54
+---
+
+## Overview
+
+This is a maintenance release of Redis Enterprise for Kubernetes version 6.4.2-8 and includes an updated Redis Enterprise image.
+
+## New in this release
+
+### Feature enhancements
+
+* New Redis Enterprise software version 6.4.2-103
+
+## Upgrade considerations
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading to 6.4.2-8.
+
+* **Upgrade path to versions 7.2.4-2 or later**
+
+  Upgrading from this versions 7.2.4-2 or 7.2.4-7 is not possible using the OpenShift Operator Lifecycle Manager (OLM). OLM users will need to skip to version 7.2.4-10 to upgrade from this release version.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+* **OpenShift SCC**
+
+  This release includes a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for expand.
+
+## Compatibility
+
+See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#compatibility" >}}).
+
+### Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-103`
+* **Operator**: `redislabs/operator:6.4.2-8`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-8.`
+
+#### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-103.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-103.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-8`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-8`
+
+#### OLM bundle
+
+* **Redis Enterprise operator bundle** : `v6.4.2-8.1`
+
+## Known limitations
+
+See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#known-limitations" >}}).
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-103 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-103">}}).---
+Title: Redis Enterprise for Kubernetes release notes 6.4.2-6 (June 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-6 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+linktitle: 6.4.2-6 (June 2023)
+weight: 55
+---
+## Overview
+
+The Redis Enterprise K8s 6.4.2-6 release supports Redis Enterprise Software 6.4.2 and contains new features and feature improvements.
+
+The key features, bug fixes, and known limitations are described below.
+
+## Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-81`
+* **Operator**: `redislabs/operator:6.4.2-6`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-6`
+
+### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-81.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-81.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-6`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-6`
+
+### OpenShift OLM bundles
+
+* Redis Enterprise operator bundle version: `v6.4.2-6`
+
+## New features
+
+* General availability of the Active-Active database controller for declarative configuration support
+
+## Feature improvements
+
+* Active-Active controller improvements include adding support for the following:
+  * Configuration via OLM
+  * Certificates in `globalConfiguration`
+  * Backups in `globalConfiguration`
+  * Modules (preview)
+  * Hashicorp Vault secrets
+  * indication of sync failures to REAADB
+* Added support for separate `podAnnotations` for Redis Enterprise pods to allow setting `appArmor` exceptions
+* Timezone can be passed as environment variable into Redis Enterprise pods
+* REDB namespaces can be labelled without the operator going into `CrashLoopBackoff`
+* Added support for K8s 1.27
+* Added support for K8s 1.25 for EKS
+* Added support for K8s 1.26 for AKS and GKE
+* Improved log collector execution log, filtering out empty files, capturing volume attachments, option to disable RS capture debug info package
+* Added `extraEnvVars` field in REC to support environment variables for RS pods
+* Changed RKE2 to the default for Rancher distributions
+
+## Fixed bugs
+
+* REC in invalid state can't be deleted (RED-78124)
+* OpenShift route not deleted after REC is deleted (RED-94121)
+* REAADB secret status not being updated in source cluster (RED-96296)
+* Invalid REAADB that is not rejected by admission might be deleted after apply (RED-96300)
+* Operator logs an error about missing permissions to nodes on startup (RED-98227)
+* Operator continues to update REC certificates in a loop (RED-98586)
+* Log collector script may crash when trying to write multi-byte characters to file (RED-99869)
+* Log collector fails to include RS debuginfo when old kubectl is used (RED-101170)
+* REC creation fails due to required LDAP configuration in OLM form view (RED-100517)
+* Upgrading to 6.4.2 (or 6.2.18) on OpenShift will fail if pod 0 is not the master node when upgrade starts (RED-102100)
+* Upgrading from 6.2.8-15 (and below) to 6.2.12-1 (and above) may break the databases (RED-102241)
+
+## API changes
+
+The following fields were changed in the [RedisEnterpriseCluster (REC) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}):
+  * `containerTimezoneSpec.timezoneName` added to configure timezones on the Redis Enterprise pods
+  * `hostAliases` added for adding an entry to the Redis Enterprise pods' `/etc/hosts`
+  * `redisEnteprisePodAnnotations` added to specify annotations that should only be set on the Redis Enterprise pods
+  * `ingressOrRouteSpec` enabled to use without alpha features enabled
+  * `extraEnvVars` added for advanced users to add environment variables to the Redis Enterprise pods
+  * `ServicesRiggerConfigurationSpec.podAnnotations` added to specify annotations that should only be set on the service rigger pods
+
+* The following custom resources definitions were added:
+  * [`RedisEnterpriseRemoteCluster` (RERC) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}})
+  * [`RedisEnterpriseActiveActiveDatabase` (REAADB) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_active_active_database_api">}})
+
+## Compatibility notes
+
+### Deprecated features
+
+* Support for Gesher, the advanced admission control configuration, is deprecated.
+
+### Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}).
+
+
+| **Kubernetes version**  | 1.22       | 1.23       | 1.24       | 1.25       | 1.26       | 1.27       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            | deprecated | supported  | supported  | supported  | supported* |
+| Amazon EKS              | deprecated | deprecated | supported  | supported* |            |            |
+| Azure AKS               |            | deprecated | supported  | supported  | supported* |
+| Google GKE              | deprecated | deprecated | supported  | supported  | supported* |            |
+| Rancher 2.6             | deprecated | deprecated | supported  |            |            |            |
+| Rancher 2.7             |            | deprecated | supported  |            |            |            |
+| VMware TKG 1.6          | deprecated | deprecated |            |            |            |            |
+| **OpenShift version**   | **4.9**    | **4.10**   | **4.11**   | **4.12**   |            |            |
+|                         |            | deprecated | supported  | supported  |            |            |
+| **VMware TKGI version** | **1.13**   | **1.14**   | **1.15**   |            |            |            |
+|                         | deprecated | deprecated | supported  |            |            |            |
+
+\* Support added in this release
+
+{{<note>}} Redis Enterprise for Kubernetes now uses RKE2 as the default for Rancher distributions. {{</note>}}
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading to 6.4.2-6.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+* **OpenShift SCC**
+
+  This release includes a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for details.
+
+## Known limitations
+
+### New limitations
+
+* **Admission controller may not alert when patching the REAADB with missing secret or RERC (RED-104463)** Remove the secret from the spec and create the missing secret, and then re-patch the REAADB again.
+
+* **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+* **Misleading error appears when a service creation has failed due to service already existing "`provided IP is already allocated`" (RED-100669)** Delete the service manually.
+
+* **Existing OpenShift route during REC creation might prevent REC from starting (RED-100668)** Delete the route manually.
+
+* **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+* **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+### Existing limitations
+
+* **RERC resources must have a unique name (`<rec-name>/<rec-namespace>`) (RED-96302)**
+
+* **Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)** Fix the problems with the REAADB and reapply.
+
+* **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+* **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+* **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of the [quick start]({{< relref "/operate/kubernetes/deployment/quick-start.md" >}}).
+
+* **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+* **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+* **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+* **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+* **Clusters must be named "rec" in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+* **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* **5.4.10 negatively impacts 5.4.6 (RED-37233)** Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+* **An unreachable cluster has status running (RED-32805)** When a cluster is in unreachable state, the state remains `running` instead of triggering an error.
+
+* **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+* **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-81 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-81">}}).---
+Title: Redis Enterprise for Kubernetes release notes 6.4.2-5 (April 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-5 is a maintenance release for version 6.4.2-4.
+linktitle: 6.4.2-5 (April 2023)
+weight: 56
+---
+## 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.
+
+New images and fixes are listed below. Refer to [6.2.4-4 (March 2023)]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md" >}}) for compatibility notes and known limitations.
+
+## Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-61`
+* **Operator**: `redislabs/operator:6.4.2-5`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-5`
+
+### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-61.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-61.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-5`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-5`
+
+### OpenShift OLM bundles
+
+* Redis Enterprise operator bundle version: `v6.4.2-5.0`
+
+## Feature enhancements
+
+* Upgraded to support Redis Enterprise 6.4.2-61
+
+## Bug fixes
+
+* Fixed bug that can cause Redis cluster to become unresponsive during a Kubernetes upgrade on clusters with more than 9 REC nodes. (RED-93025)
+
+## Compatibility notes
+
+See [Redis Enterprise for Kubernetes release notes 6.4.2-4 (March 2023)]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md" >}}).
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading,
+
+* **Supported upgrade paths**
+
+  If you are using a version earlier than 6.2.10-45, you cannot upgrade directly to this release. You must upgrade to 6.2.10-45 before you can upgrade to versions 6.2.18 or later.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+## Known limitations
+
+See [Redis Enterprise for Kubernetes release notes 6.4.2-4 (March 2023)]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md" >}}).
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-61 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-61">}}).
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise K8s 6.4.2-8 release supports Redis Enterprise Software 6.4.2.
+linkTitle: 6.4.2-8 (Oct 2024)
+title: Redis Enterprise for Kubernetes release notes 6.4.2-8 (Oct 2024)
+weight: 53
+---
+
+## Overview
+
+This is a maintenance release of Redis Enterprise for Kubernetes version 6.4.2-8 and includes an updated Redis Enterprise image.
+
+## New in this release
+
+### Feature enhancements
+
+* New Redis Enterprise software version 6.4.2-115
+
+## Upgrade considerations
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading to 6.4.2-8.
+
+* **Upgrade path to versions 7.2.4-2 or later**
+
+  Upgrading from this versions 7.2.4-2 or 7.2.4-7 is not possible using the OpenShift Operator Lifecycle Manager (OLM). OLM users will need to skip to version 7.2.4-10 to upgrade from this release version.
+
+* **ValidatingWebhookConfiguration**
+
+  This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions.
+
+* **OpenShift SCC**
+
+  This release includes a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for more info.
+
+## Compatibility
+
+See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#compatibility" >}}).
+
+### Images
+
+* **Redis Enterprise**: `redislabs/redis:6.4.2-115`
+* **Operator**: `redislabs/operator:6.4.2-8`
+* **Services Rigger**: `redislabs/k8s-controller:6.4.2-8.`
+
+#### OpenShift images
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-115.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.4.2-115.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-8`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-8`
+
+#### OLM bundle
+
+* **Redis Enterprise operator bundle** : `v6.4.2-8.11`
+
+The OLM version v6.4.2-8.11 replaces the earlier v6.4.2-8.10 release for the same Redis software version, providing only upgrade path fixes.
+
+## Known limitations
+
+See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#known-limitations" >}}).---
+Title: 6.4.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Release notes for the 6.4.2 releases of Redis Enterprise Software for
+  Kubernetes.
+hideListLinks: true
+linkTitle: 6.4.2 releases
+weight: 57
+---
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### Supported upgrade paths
+
+If you are using operator version 6.2.8-15 or earlier, you cannot upgrade directly to operator versions 6.2.12 through 6.4.2-5. You must upgrade to operator version 6.2.10-45 before you can upgrade to operator versions between 6.2.12 and 6.4.2-5. However, upgrades directly to operator version 6.4.2-6 are supported.
+  
+### OpenShift versions 6.2.12 or earlier
+
+Due to a change in the SCC, on OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later, where `node:1` is <b>not</b> the master node, the upgrade might get stuck.
+
+For more info and steps to prevent this issue, see [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}).
+
+Operator version 6.4.2-6 includes a fix for this issue.
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2 release notes]({{<relref "operate/rs/release-notes/rs-6-4-2-releases/">}}).
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.6-6 (June 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.0.6, new database and admission controllers, various
+  improvements and bug fixes.
+linkTitle: 6.0.6-6 (June 2020)
+weight: 80
+---
+Redis Enterprise for Kubernetes 6.0.6-6 is now available. This release includes Redis Enterprise (RS) version [6.0]({{< relref "/operate/rs/release-notes/rs-6-0-may-2020.md" >}}) and introduces new features, improvements, and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+- Support for the Redis Enterprise Software release 6.0.6
+- Includes the new database and admission controllers
+- Various improvements and bug fixes
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+{{< note >}}
+If you are running Active-Active (CRBD) databases on a previous release, do not upgrade to 6.0.6-6 at this time. There is an issue with the upgrade process that is currently being investigated (RED43635). For more information and support please [contact Redis support](https://redislabs.com/company/support/).
+{{< /note >}}
+
+## Images
+
+- **Redis Enterprise** - redislabs/redis:6.0.6-6 or redislabs/redis:6.0.6-6.rhel7-openshift
+- **Operator** - redislabs/operator:6.0.6-6 or redislabs/operator:6.0.6-6.rhel7
+- **Services Rigger** - redislabs/k8s-controller:6.0.6-6 or redislabs/k8s-controller:6.0.6-6.rhel7
+
+## New features and improvements
+
+- Database controller - A new database controller in the operator provides the ability to create
+and manage databases on a Redis Enterprise cluster via a custom resource (RED36516).
+
+- Admission controller - A new admission controller in the operator provides validation of
+database custom resources (RED36458).
+
+- Pod tolerations - Support for specifying Redis Enterprise cluster node pod tolerations of node taints
+has been added to the cluster CR (see podTolerations) (RED33069).
+
+- Pod annotations - Support for specifying Redis Enterprise cluster node pod annotations has been
+added to the cluster CR (see podAnnotations) (RED35613).
+
+- Kubernetes versions - Support for Kubernetes 1.17 was added and versions 1.9 and 1.10 (previously deprecated) are no longer supported (RED41049).
+
+- Improved OLM Experience - The overall user experience and documentation in the OLM (OperatorHub) has been improved (RED37008).
+
+- Resource limits - Resource limits have been added to the recommended operator configuration (RED39572).
+
+- LoadBalancer service type added - The `LoadBalancer` value has been added to the `databaseServiceType` option in `servicesRiggerSpec` (RED43215):
+
+    ```yaml
+    servicesRiggerSpec:
+       databaseServiceType: LoadBalancer
+    ```
+
+## Important fixes
+
+- Service creation failure causes cluster setup failure (RED37197)
+- UI service update failure (RED37198)
+- Error shown in OLM deployment: "The field status.state is invalid" (RED40278)
+- OLM: StatefulSet not listed as an object owned by the Redis Enterprise Cluster (RED39296)
+- Setting extraLabels in the cluster CR did not label pods on OpenShift (RED39763)
+- log_collector failed to get the pods logs when a namespace wasn't given (RED39292)
+- Role and RoleBinding created or updated using an existing ServiceAccount in REC spec (RED42912)
+
+## Known limitations
+
+- CrashLoopBackOff pod status and cluster recovery - When a pod status is CrashLoopBackOff and we run the cluster recovery, the process
+will not complete. The solution is to delete the crashing pods manually and
+recovery process will continue (RED33713).
+
+- Active-Active (CRDB) - limitation on cluster name length - A cluster name longer than 20 characters will result in a rejected route
+configuration as the host part of the domain name exceeds 63 characters. Cluster
+names must be limited to 20 characters or less (RED25871).
+
+- Active-Active (CRDB) service broker cleanup - The service broker doesn't clean up database service bindings in case of failures.
+These bindings must be removed manually (RED25825).
+
+- Service broker deployment error - The service broker deployment results in an error when two types of service naming
+schemes are set. Choosing one of the methods will resolve this error (`redis-port`
+is the recommended default) (RED25547).
+
+- Cluster spec invalid errors not reported - A cluster CR specification error is not reported if two or more invalid CR resources are
+updated in sequence (RED25542).
+
+- Unreachable cluster does not produce an error - When a cluster is in an unreachable state the state is still `running` instead of
+being reported as an error (RED32805).
+
+- Readiness probe ignores rladmin failure - STS Readiness probe doesn't mark a node as not ready when rladmin status nodes fails (RED39300).
+
+- Missing permission for role - The redis-enterprise-operator role is missing permission on replicasets (RED39002).
+
+- Openshift 3.11 doesn't support DockerHub private registry - Openshift 3.11 doesn't support DockerHub private registry. This is a known OpenShift
+issue and not addressable by Redis Enterprise for Kubernetes (RED38579).
+
+- Possible DNS conflicts within cluster nodes - DNS conflicts are possible between the cluster mdns_server and the K8s DNS.
+This only impacts DNS resolution from within cluster node and while using the full fqdn *.cluster.local (RED37462).
+
+- Coexistence of 5.4.10 and 5.4.6 clusters - K8s clusters with Redis Enterprise 5.4.6 clusters are negatively affected by installing a Redis Enterprise 5.4.10 cluster due to changes in CRD (CustomeResourceDefinition) (RED37233).
+
+- Redis Enterprise CPU utilization metric reports at K8s node level rather than at pod level - In Kubernetes, the node CPU usage we report on is the usage of the K8S worker node hosting the REC pod (RED-36884). Pod resource utilization should be measured by K8s-native means rather than through the application.
+
+- Cluster name is limited on OpenShift via OLM - In OLM-deployed operators, the deployment of the cluster will fail if the name
+is not "rec". When the operator is deployed via the OLM, the security context constraints (scc)
+is bound to a specific service account name (i.e., "rec"). Naming the cluster
+"rec" resolves the issue (RED39825).
+
+## Coming Soon
+
+The following lists features, fixes and changes the Redis team is currently investing in:
+
+- Redis Enterprise and Kubernetes Container Artifacts - tarting from the next release of Redis Enterprise for K8s, new container artifacts will be published using different base images:
+
+    - **Redis Enterprise** - A UBI (RHEL 7) base image will replace the Ubuntu and the RHEL7 base images
+    - **Operator** - An Image built from scratch containing the Golang executable will replace the Ubuntu and the RHEL7 base images
+    - **Services Rigger** - A UBI (RHEL 7) base image will replace the Ubuntu and the RHEL7 base images
+
+- Deprecation notice - he service broker solution is deprecated and will not be supported starting from the next release of the Redis Enterprise Operator for Kubernetes.
+
+- Additional Redis Enterprise Database configuration options in the Database Controller - We're currently investing in the following additional capabilities of the Database Controller:
+    - Support for loading database modules
+    - Support for setting up Alerts, expressed as K8s events
+    - Support for configuring database backup options
+    - Support for Kubernetes 1.18
+    - Support for Rancher K8s distribution
+---
+Title: Redis Enterprise for Kubernetes Release Notes 5.4.10-8 (January 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for the Redis Enterprise Software 5.4.10 and multiple enhancements.
+linkTitle: 5.4.10-8 (January 2020)
+weight: 85
+---
+[Redis Enterprise for Kubernetes 5.4.10-8](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/5.4.10-8) is now available.
+This release includes Redis Enterprise (RS) version [5.4.10-22]({{< relref "/operate/rs/release-notes/legacy-release-notes/rs-5-4-10-december-2019.md" >}}) and introduces new feature and bug fixes.
+
+## Overview
+
+This is a maintenance release providing support for the Redis Enterprise Software release 5.4.10 and includes multiple enhancements.
+
+Follow these [instructions]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}) for upgrading to this Kubernetes operator release.
+
+## New features
+
+- All-in-one deployment bundle and documentation enhancements - This release is the easiest to deploy yet, with a new quick start guide and an all-in-one file bundle for deploying the Redis Enterprise Operator. GitHub documentation was enhanced to cover advanced deployment scenarios with the complete reference to the custom resource specifications, guides, and examples.
+
+    {{< note >}}
+    Pay special attention to the yaml file naming changes and new yaml files that have been created for this release. These are highlighted in the quick start guide.
+    {{< /note >}}
+
+- Rack Awareness - Support for the [Redis Software Rack Awareness][{{< relref "/operate/rs/clusters/configure/rack-zone-awareness.md" >}}] feature was introduced to the Kubernetes deployment. It enables deploying nodes to different zones, in a multi-zone Kubernetes cluster. Databases that are rack-aware will have the cluster populate their master shard and replica shards in different nodes, across different zones or failure domains. This enables maintaining data persistence in case of zone failure.
+
+- OLM Support - Redis Enterprise for Kubernetes is now RedHat OpenShift certified and can be effortlessly configured and deployed in Kubernetes clusters supporting OLM, including OpenShift 4.x clusters, with just a few clicks. OLM based deployments do not require Kubernetes cluster administrator rights to deploy the operator.
+
+- Improve cluster nodes' pod scheduling resiliency - Redis Enterprise Cluster pod scheduling is hardened by implementing Kubernetes best practices and providing configuration recommendations to cluster operators. Scheduling resiliency minimizes the chance of cluster node pods eviction or failure to schedule.
+See the top 4 articles in the new [Additonal Topics](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/92a2eff4b8c4ccafac459138f12e5f38acde825c/docs/topics.md#additional-topics) documentation section.
+
+- Update app.redislabs.com API version to stable - We've updated the Redis Enterprise Cluster custom resource API from [alpha to stable](https://kubernetes.io/docs/concepts/overview/kubernetes-api/#api-versioning) to reflect the current state of maturity of our implementation.
+
+[Both versions of the API are supported](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definition-versioning/) by Kubernetes versions that support specifying multiple API versions.
+
+For legacy Kubernetes versions, deployment files are available in the documentation repository that utilize the alpha version of the API.
+
+## Information
+
+- This new release deprecates the Redis Enterprise Operator support for legacy Kubernetes version 1.8.
+
+## Known limitations
+
+- Custom Resource Definition Changes - In order to comply with OLM best practices, a change was required to the Redis Enterprise Cluster Custom Resource Defintion (CRD) to introduce the status sub-resource.
+As a result of this change, any upgrade from an older release to this release requires a change to the CRD. Once the CRD is updated, all Redis Enterprise Clusters in the same K8s cluster must be updated to the latest release in order to continue operating properly.
+
+- Cluster Recovery - {{< embed-md "force-delete-pods.md" >}}
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.8-1 (October 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.0.8-28, OpenShift 4.5, K8s 1.18, and Gesher admission
+  controller proxy.
+linktitle: 6.0.8-1 (October 2020)
+weight: 74
+---
+
+The Redis Enterprise K8s 6.0.8-1 release is a *major release* on top of [6.0.6-24](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.6-24) providing support for the latest [Redis Enterprise Software release 6.0.8-28](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-8-september-2020/) and includes several enhancements (including OpenShift 4.5 and Kubernetes 1.18 support) and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+ * New features
+ * New support K8s distributions and platforms
+ * Various bug fixes
+
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+
+## Images
+
+ * **Redis Enterprise** - redislabs/redis:6.0.8-28 or redislabs/redis:6.0.8-28.rhel7-openshift
+ * **Operator** - redislabs/operator:6.0.8-1
+ * **Services Rigger** - redislabs/k8s-controller:6.0.8-1 or redislabs/services-manager:6.0.8-1 (Red Hat registry)
+
+## New features
+
+ * Redis [Modules](https://redislabs.com/redis-enterprise/modules/) can now be [configured](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#dbmodule) in the database custom resource.
+ * Support was added for **[OpenShift 4.5](https://docs.openshift.com/container-platform/4.5/release_notes/ocp-4-5-release-notes.html)**
+ * Support was added for **Kubernetes 1.18**
+ * Added support for the Gesher admission control proxy to provide an administrator the ability to setup delegation to avoid the need for administrator intervention on every namespaced deployed operator.
+
+## Important fixes
+
+ * Added the missing Services Rigger health check (RED47062)
+ * Fixed failures when updating the ui service type (RED45771)
+
+## Known limitations
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod status is CrashLoopBackOff and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually and recovery process will continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration as the host part of the domain name exceeds 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state the state is still running instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe doesn't mark a node as not ready when rladmin status on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The redis-enterprise-operator role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 doesn't support dockerhub private registry. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Master pod label in Rancher (RED42896)
+
+Master pod is not always labeled in Rancher.
+
+### Cluster fail to start for clusters with unsynchronized clocks (RED47254)
+
+When REC clusters are deployed on clusters with unsynchronized clocks, the cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Errors in operator log for REDB status (RED44919)
+
+Benign errors are reported in the operator log when using database controller (REDB) (e.g., “failed to update database status". These errors can be ignored.
+
+## Compatibility Notes
+
+* Support for **OpenShift 4.5** was **added**,
+* Support for **Kubernetes 1.18** was **added**,
+* Support for the previous deprecated **Kubernetes 1.11 and 1.12** has been **removed**.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.8-20 (December 2020)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.0.8, consumer namespaces, Gesher admission controller
+  proxy, and custom resource validation via schema.
+linkTitle: 6.0.8-20 (December 2020)
+weight: 72
+---
+
+The Redis Enterprise K8s 6.0.8-20 release is a *major release* on top of [6.0.8-1](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.8-1) providing support for the [Redis Enterprise Software release 6.0.8-30](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-8-september-2020/) and includes several enhancements and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+ * New features
+ * Various bug fixes
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Images
+This release includes the following container images:
+ * **Redis Enterprise**: redislabs/redis:6.0.8-30 or redislabs/redis:6.0.8-30.rhel7-openshift
+ * **Operator and Bootstrapper**: redislabs/operator:6.0.8-20
+ * **Services Rigger**: redislabs/k8s-controller:6.0.8-20 or redislabs/services-manager:6.0.8-20 (Red Hat registry)
+
+## New features
+
+ * You can now create database custom resources (REDB CRs) in consumer namespaces that are separate from the operator and cluster namespace. You configured the operator deployment to watch specific namespaces for these REDB CRs.
+ * The Gesher admission control proxy is now certified by Red Hat.
+ * REDB CRs no longer require a Redis Enterprise cluster name. The name will default to the cluster in the context of the operator.
+ * REC and REDB CRs are now validated via a schema.
+
+## Important fixes
+
+ * The database controller (REDB) no longer generates the following error message:  “failed to update database status"
+ * Issues with configuring replica-of through the database controller (REDB) and TLS have been fixed. (RED48285)
+ * A timeout issue with `rlutil upgrade` was fixed. (RED48700)
+
+## Known limitations
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod's status is `CrashLoopBackOff` and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually. The recovery process will then continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or fewer.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### Master pod label in Rancher (RED42896)
+
+The master pod is not always labeled in Rancher.
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.6-23 (August 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for Redis Enterprise Software 6.0.6-39, Rancher support, new
+  database backup and alert options.
+linkTitle: 6.0.6-23 (August 2020)
+weight: 76
+---
+The Redis Enterprise K8s 6.0.6-23 release is a *major release* on top of [6.0.6-11](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.6-11) providing support for the latest [Redis Enterprise Software release 6.0.6-39](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-may-2020/) and includes several enhancements (including Rancher support) and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+- Support for the Redis Enterprise Software release 6.0.6-39
+- Support for Rancher
+- Backup options in the database custom resource and controller
+- Alert option in the database custom resource and controller
+- UBI images
+- Various other enhancements and bug fixes
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Images
+
+- **Redis Enterprise** - redislabs/redis:6.0.6-39 or redislabs/redis:6.0.6-39.rhel7-openshift
+- **Operator** - redislabs/operator:6.0.6-23
+- **Services Rigger** - redislabs/k8s-controller:6.0.6-23 or redislabs/services-manager:6.0.6-23 (on the RedHat registry)
+
+## New features
+
+ Red Hat UBI base images (RED29651) - The services rigger and operator images are now based on Red Hat UBI base images. Also, the same images are now used in both OpenShift and non-OpenShift environments.
+
+- Rancher support (RED37918) - The operator is now supported on [Rancher](https://rancher.com/) version ([v2.4.5](https://rancher.com/support-maintenance-terms/all-supported-versions/rancher-v2.4.5/)). Note that since this release of the operator doesn't support K8s 1.18, it requires one of the other supported upstread version in this Rancher release, i.e. 1.15.12, 1.16.13 or 1.17.9.
+
+- Database Replica Of support (RED40160) - Support for [Replica Of](https://docs.redislabs.com/latest/rs/administering/active-passive/) was added to the [DB controller](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#replicasource).
+
+- Database backup configuration (RED40165) - Support for [backup configuration](https://docs.redislabs.com/latest/rs/administering/database-operations/database-backup/) was added to the [DB controller spec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#backupspec).
+
+- Alert configuration (RED40166) - Support for alert configuration was added to the [DB controller spec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#dbalertssettings).
+
+- Database TLS configuration (RED41758) - Support for TLS authentication configuration was added to the [DB controller spec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/0ec741ffb3d621d371b5eec5b0a045ee7364e50e/redis_enterprise_database_api.md#redisenterprisedatabasespec).
+
+- OpenShift 4.4 support (RED41352) - The operator is now supported on [Openshift 4.4](https://docs.openshift.com/container-platform/4.4/welcome/index.html).
+
+- DB controller resources via the OLM (RED41755) - Support for configuration of DB controller resources was added to the OLM (preview channel).
+
+## Important fixes
+
+- Openshift OLM upgrade support was fixed. Also, installing past versions was added through dedicated channels. (RED44130)
+- Fixed log_collector failures when pods were not scheduled. (RED45347)
+- Fixed wrong handling of the operator environment variables. Specifically, enabling/disabling the database controller now works correctly. (RED45351)
+
+## Known limitations
+
+- CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713) - When a pod status is CrashLoopBackOff and we run the cluster recovery, the process will not complete. The solution is to delete the crashing pods manually and recovery process will continue.
+
+- Long cluster names cause routes to be rejected  (RED25871) - A cluster name longer than 20 characters will result in a rejected route configuration as the host part of the domain name exceeds 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+- Cluster CR (REC) errors are not reported after invalid updates (RED25542) - A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+- An unreachable cluster has status running (RED32805) - When a cluster is in an unreachable state the state is still running instead of being reported as an error.
+
+- Readiness probe incorrect on failures (RED39300) - STS Readiness probe doesn't mark a node as not ready when rladmin status on the node fails
+
+- Role missing on replica sets (RED39002) - The redis-enterprise-operator role is missing permission on replica sets.
+
+- Private registries are not supported on OpenShift 3.11 (RED38579) - Openshift 3.11 doesn't support dockerhub private registry. This is a known OpenShift issue.
+
+- Internal DNS and K8s DNS may have conflicts (RED37462) - DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for K8s DNS names.
+
+- 5.4.10 negatively impacts 5.4.6 (RED37233) - K8S-based 5.4.10 clusters seem to negatively impact existing 5.4.6
+
+- Node CPU usage is reported instead of pod CPU usage (RED36884) - In Kubernetes, the node CPU usage we report on is the usage of the K8S worker node hosting the REC pod.
+
+- Clusters must be named "rec" in OLM-based deployments (RED39825) - In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+- Updating UI service in Rancher (RED45771) - Updating the UI service type may fail in Rancher. When this happens, delete the service manually and the operator will recreate it correctly.
+
+- Master pod label in Rancher (RED42896) - Master pod is not always labeled in Rancher.
+
+## Deprecation notice
+
+Support for Kubernetes version 1.11 and 1.12 is deprecated (excludes Openshift 3.11, which continues to be supported).
+
+## Compatibility updates
+
+- Added support for Rancher
+- Added support for Openshift 4.4
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.12-5 (February 2021)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.0.12-57, Amazon Kubernetes Service (AKS), and role permissions
+  on custom resources.
+linkTitle: 6.0.12-5 (February 2021)
+weight: 70
+---
+
+The Redis Enterprise [K8s 6.0.12-5](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.12-5) release is a *major release* on top of [6.0.8-20](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.8-20) providing support for the [Redis Enterprise Software release 6.0.12-57](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-12-january-2021/) and includes several enhancements and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+ * New features
+ * Various bug fixes
+
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Images
+
+This release includes the following container images:
+ * **Redis Enterprise**: redislabs/redis:6.0.12-57 or redislabs/redis:6.0.12-57.rhel7-openshift
+ * **Operator and Bootstrapper**: redislabs/operator:6.0.12-5
+ * **Services Rigger**: redislabs/k8s-controller:6.0.12-5 or redislabs/services-manager:6.0.12-5 (Red Hat registry)
+
+## New features
+
+ * [Azure Kubernetes Service](https://azure.microsoft.com/en-us/services/kubernetes-service/) (AKS) is now supported. (RED40323)
+ * Database custom resources now support roles permissions (role to Redis ACL bindings). (RED49780)
+
+## Feature Improvements
+
+ * The license information has been added to the REC status. (RED43078)
+ * `kubectl get rec` now displays more information (i.e., added "NODES", "VERSION", "STATE", "SPEC STATUS"). (RED46428)
+ * The `extraLabels` in the cluster spec now applies to the PV and PVC at creation. (RED48694)
+ * Added [Rancher 2.5](https://rancher.com/products/rancher/2.5) support. (RED50211)
+ * Added K8s (Kops) 1.19 support. (RED50211)
+ * Added [OpenShift 4.6](https://docs.openshift.com/container-platform/4.6/welcome/index.html) support. (RED50495)
+ * Database resources can now disable the default database user. (RED50215)
+ * REC credentials no longer use environment variables in pods. (RED47969)
+
+## Important fixes
+
+ * Fixed an issue where pods are stuck terminating during teardown. (RED44726)
+ * Fixed an issue where pods are stuck terminating during cluster recovery. (RED43846)
+ * Changed the operator logs to use human-readable dates and times. (RED39026)
+ * Fixed the display of resources in the OLM (OpenShift). (RED48116)
+ * Fixed backup configuration issue for GCS without a subdir. (RED49299)
+
+## Known limitations
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod's status is `CrashLoopBackOff` and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually. The recovery process will then continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or fewer.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### Master pod label in Rancher (RED42896)
+
+The master pod is not always labeled in Rancher.
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions can not support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+## Compatibility Notes
+
+ * OpenShift 4.6 and Rancher/kOps 1.19 are now supported.
+ * Rancher 2.5 is now supported.
+ * AKS (K8s 1.18) is now supported.
+
+## Deprecation notice
+
+ * OpenShift 4.1, 4.2, and 4.3 are now deprecated.
+ * GKE K8s version 1.14 is deprecated.
+ * kOps 1.13 and 1.14 are deprecated.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.6-11 (July 2020)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Maintenance release; support RS 6.0.6-39 and various bug fixes.
+linkTitle: 6.0.6-11 (July 2020)
+weight: 78
+---
+
+The Redis Enterprise K8s 6.0.6-11 release is a *maintenance release* on top of [6.0.6-6](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.6-6) providing support for the latest [Redis Enterprise Software release 6.0.6-39](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-may-2020/) and includes several bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+- Support for the Redis Enterprise Software release 6.0.6-39
+- Various bug fixes
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Images
+
+- **Redis Enterprise** - redislabs/redis:6.0.6-39 or redislabs/redis:6.0.6-39.rhel7-openshift
+- **Operator** - redislabs/operator:6.0.6-11 or redislabs/operator:6.0.6-11.rhel7
+- **Services Rigger** - redislabs/k8s-controller:6.0.6-11 or redislabs/k8s-controller:6.0.6-11.rhel7
+
+## Important fixes
+
+- The upgrade process may have failed in certain situations (i.e., with CRDB databases). We now ensure that rlutil runs at bootstrap to complete the upgrade process. (RED43635)
+- The example and default custom resource for the REC in the OLM now correctly uses 'nodes' (RED43847)
+- Fixes for security vulnerabilities in the server rigger image: upgraded to httpd 2.4.42, Kubernetes Python Client 8.0.1, and removed localhost private key. (RED42495)
+- A fix for an internal logging issue that caused errors to incorrectly show up on the operator log when databases are created even though the creation succeeded. (RED43336)
+
+## Known limitations
+
+- CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713) - When a pod status is CrashLoopBackOff and we run the cluster recovery, the process will not complete. The solution is to delete the crashing pods manually and recovery process will continue.
+
+- Long cluster names cause routes to be rejected  (RED25871) - A cluster name longer than 20 characters will result in a rejected route configuration as the host part of the domain name exceeds 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+- No cleanup of database services on failures (RED25825) - The service broker doesn't clean up database service bindings when there are failures. The workaround is to manually remove service bindings.
+
+- Server broker errors with two service naming schemes  (RED25547) - The service broker deployment results in an error when two types of service naming schemes are set. You must choose one of the methods if both are set - redis-port is the recommended default.
+
+- Cluster CR (REC) errors are not reported after invalid updates (RED25542) - A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+- An unreachable cluster has status running (RED32805) - When a cluster is in an unreachable state the state is still running instead of being reported as an error.
+
+- Readiness probe incorrect on failures (RED39300) - STS Readiness probe doesn't mark a node as not ready when rladmin status on the node fails
+
+- Role missing on replica sets (RED39002) - The redis-enterprise-operator role is missing permission on replica sets.
+
+- Private registries are not supported on OpenShift 3.11 (RED38579) - Openshift 3.11 doesn't support dockerhub private registry. This is a known OpenShift issue.
+
+- Internal DNS and K8s DNS may have conflicts (RED37462) - DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for K8s DNS names.
+
+- 5.4.10 negatively impacts 5.4.6 (RED37233) - K8S-based 5.4.10 clusters seem to negatively affect existing 5.4.6
+
+- Node CPU usage is reported instead of pod CPU usage (RED36884) - In Kubernetes, the node CPU usage we report on is the usage of the K8S worker node hosting the REC pod.
+
+- Clusters must be named "rec" in OLM-based deployments (RED39825) - In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.6-24 (August 2020)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Various bug fixes.
+linkTitle: 6.0.6-24 (August 2020)
+weight: 75
+---
+
+The Redis Enterprise K8s 6.0.6-24 release is a *maintenance release* on top of [6.0.6-23](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.6-23) providing support for the latest [Redis Enterprise Software release 6.0.6-39](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-may-2020/) and includes several bug fixes.
+
+## Overview
+
+This release of the operator provides:
+
+ * Various bug fixes
+
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+
+## Images
+
+ * **Redis Enterprise** - redislabs/redis:6.0.6-39 or redislabs/redis:6.0.6-39.rhel7-openshift
+ * **Operator** - redislabs/operator:6.0.6-24
+ * **Services Rigger** - redislabs/k8s-controller:6.0.6-24 or redislabs/services-manager:6.0.6-24 (on the RedHat registry)
+
+## Important fixes
+
+ * A fix for database observability where after 24 hours after creation or update, the controller was unable to observe the database (RED46149)
+ * A fix for a log collector crash on Windows when pods were not running (RED45477)
+
+## Known limitations
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod status is CrashLoopBackOff and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually and recovery process will continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration as the host part of the domain name exceeds 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state the state is still running instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe doesn't mark a node as not ready when rladmin status on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The redis-enterprise-operator role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 doesn't support dockerhub private registry. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed with the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### Updating UI service in Rancher (RED45771)
+
+Updating the UI service type may fail in Rancher. When this happens, delete the service manually and the operator will recreate it correctly.
+
+### Master pod label in Rancher (RED42896)
+
+Master pod is not always labeled in Rancher.
+
+## Deprecation notice
+
+Support for K8s version 1.11 and 1.12 is deprecated (excludes Openshift 3.11, which continues to be supported). Openshift 4.1 and 4.2 are deprecated (already End Of Life by Red Hat).
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.20-12 (July 2021)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.0.20-97, EKS, Hashicorp Vault, and added feature support
+  for OpenShift OLM.
+linkTitle: 6.0.20-12 (July 2021)
+weight: 68
+---
+## Overview
+
+The Redis Enterprise [K8s 6.0.20-12](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.20-12) release is a *major release* on top of [6.0.20-4](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.20-4) providing support for the [Redis Enterprise Software release 6.0.20-97](https://docs.redislabs.com/latest/rs/release-notes/rs-6-0-20-april-2021/) and includes several enhancements and bug fixes.
+
+This release of the operator provides:
+
+* New features
+* Various bug fixes
+
+## Images
+
+This release includes the following container images: 
+
+* **Redis Enterprise**: `redislabs/redis:6.0.20-97` or  redislabs/redis:6.0.20-97.rhel7-openshift`
+* **Operator and Bootstrapper**: `redislabs/operator:6.0.20-12`
+* **Services Rigger**: `redislabs/k8s-controller:6.0.20-12` or `redislabs/services-manager:6.0.20-12` (on the Red Hat registry)
+
+## New features
+
+* EKS support
+* Feature parity for Openshift OLM; added support for:
+   - REDB
+   - admission
+   - Hashicorp Vault integration
+* Hashicorp Vault integration is now GA
+* Moved Operator environment variables to configmap
+
+## Important fixes
+
+* Admission controller deployment combined with operator deployment to simplify deployment (RED-52701)
+* Additional verbosity in the `kubectl get redb` command output (RED-55042)
+* Support for Redis Enterprise license storage within secrets; Vault and K8s secrets (RED-55587)
+* Support for manual procedure to replace the REC credentials (RED-56529, RED-56530)
+* Fixed cluster recovery issue - recovery process was not starting (RED-55500)
+* When a pod status is CrashLoopBackOff and we run the cluster recovery, the process will not complete (RED-33713)
+* Master pod is not always labeled in Rancher (fixed in 6.0.8 but was not documented) (RED-42896)
+
+## Known limitations
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### Nodes down indefinitely after the redis-enterprise-node container of a REC pod is restarted (53042)
+
+In some cases where the Redis Enterprise Cluster container in the Redis Enterprise Cluster(REC) pod is restarted, the REC node remains down. Workaround: restart the pod, while ensuring the majority of REC nodes are available.
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod's status is `CrashLoopBackOff` and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually. The recovery process will then continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or fewer.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### Master pod label in Rancher (RED42896)
+
+The master pod is not always labeled in Rancher.
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions can not support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+## Compatibility Notes
+
+* EKS is now supported (K8s 1.18)
+* OpenShift 4.4 (previously deprecated) is no longer supported
+* GKE K8s versions 1.15, 1.16 (previously deprecated) is no longer supported
+* VMWare TKGI 1.10 (K8s 1.19) is now supported
+
+## Deprecation notice
+
+* GKE K8s version 1.17 (no longer supported by Google) is deprecated
+* kOps 1.15 is deprecated
+* VMWare TKGI 1.7 (K8s 1.16), VMWare TKGI 1.8 (K8s 1.17) are deprecated (no longer supported by VMWare)
+---
+Title: Redis Enterprise for Kubernetes Release Notes 5.4.14-2 (March 2020)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for Redis Enterprise Software 5.4.14, K8s 1.16, and OpenShift
+  4.3.
+linkTitle: 5.4.14-2 (March 2020)
+linktitle: 5.4.14-2 (March 2020)
+weight: 84
+---
+## Overview
+
+The Redis Enterprise K8s 5.4.14-2 release is a maintenance release providing support for the latest Redis Enterprise Software release 5.4.14 and includes bug fixes as well as the following notable changes:
+
+### Support for K8s 1.16
+
+This release now correctly handles the API deprecations, and API version changes that K8s release 1.16 introduced.
+
+### Support for OpenShift 4.3; improved OLM support
+
+The release now supports OpenShift 4.3. A new operator version is now available in OpenShift's Operator Hub and now includes a more comprehensive base template as well as references to documentation and support.
+
+### Changes to the upgrade process
+
+When the Operator is upgraded to a new release, it now prevents the Redis Enterprise Cluster nodes from being automatically upgraded, unless autoUpgrade is enabled or the RS image version is explicitly updated in the Redis Enterprise Cluster (REC) spec. The change was introduced to avoid situations where an Operator upgrade initiated a rolling update to the cluster nodes' StatefulSet.
+
+### Deprecated support for K8s versions 1.9/1.10
+
+This release deprecates support for K8s version 1.9/1.10 and OpenShift 3.9. If you are currently using these releases please contact Redis support for information about migrating to a new K8s release.
+
+### Coming soon
+
+- The Database Custom Resource(CR), which represents Redis Enterprise databases, is in development and planned to be part of an upcoming release. The Database Controller for the Database CR is part of the Redis Enterprise K8s Operator. It is disabled in this release.
+- The next release is planned to support K8s 1.17 and drop support for K8s versions 1.9/1.10.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.0.20-4 (May 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for 6.0.20-69, OpenShift 4.7, and K8s 1.20. Hashicorp Vault integration
+  with REC and REDB secrets.
+linktitle: 6.0.20-4 (May 2021)
+weight: 69
+---
+
+The Redis Enterprise K8s [6.0.20-4](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.20-4) release is a *major release* on top of [6.0.8-20](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.0.8-20) providing support for the [Redis Enterprise Software release 6.0.20-69]({{< relref "/operate/rs/release-notes/rs-6-0-20-april-2021.md" >}}) and includes several enhancements and bug fixes.
+
+## Overview
+
+This release of the operator provides:
+ * New features
+ * Various bug fixes
+
+To upgrade your deployment to this latest release, see ["Upgrade a Redis Enterprise cluster (REC) on Kubernetes"]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster.md" >}}).
+
+## Images
+This release includes the following container images:
+ * **Redis Enterprise**: redislabs/redis:6.0.20-69 or redislabs/redis:6.0.20-69.rhel7-openshift
+ * **Operator and Bootstrapper**: redislabs/operator:6.0.20-4
+ * **Services Rigger**: redislabs/k8s-controller:6.0.20-4 or redislabs/services-manager:6.0.20-4 (on the Red Hat registry)
+
+## New features
+ * Support for Openshift 4.7
+ * Support for Kubernetes 1.20
+
+ ## New preview features
+ * Hashicorp Vault integration - REC secret
+ * Hashicorp Vault integration - REDB secrets
+
+## Important fixes
+
+- Fixed upgrade issue with custom container repositories specifying port numbers (RED-53192)
+- REDB controller no longer performs reconciliation until Redis Enterprise software version complies with operator (RED-53194)
+- Removed unused node.js package from Services Rigger image (RED-53536)
+- Fixed operator crash on change of uiServiceType (RED-54621)
+- Avoid excessive logging within RS pod (envoy_access.log) (RED-55525)
+
+## Known limitations
+
+### OpenShift 4.7 - v6.0.20-4 cannot be deployed by OLM
+
+6.0.20-4 does not appear in OLM. Workaround - deploy manually. A future maintenance release will address this. 
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### Nodes down indefinitely after the redis-enterprise-node container of a REC pod is restarted (53042)
+
+In some cases where the Redis Enterprise Cluster container in the Redis Enterprise Cluster(REC) pod is restarted, the REC node remains down. Workaround: restart the pod, while ensuring the majority of REC nodes are available.
+
+### CrashLoopBackOff causes cluster recovery to be incomplete  (RED33713)
+
+When a pod's status is `CrashLoopBackOff` and we run the cluster recovery, the process will not complete. The workaround is to delete the crashing pods manually. The recovery process will then continue.
+
+### Long cluster names cause routes to be rejected  (RED25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or fewer.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on the node fails.
+
+### Role missing on replica sets (RED39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED38579)
+
+Openshift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED37462)
+
+DNS conflicts are possible between the cluster mdns_server and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) is bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### Master pod label in Rancher (RED42896)
+
+The master pod is not always labeled in Rancher.
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions can not support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+## Compatability Notes
+
+- OpenShift 4.7 and Rancher/kOps 1.20 are now supported
+- OpenShift 4.1, 4.2, 4.3 (previously deprecated) are no longer supported
+- GKE K8s version 1.14 (previously deprecated) is no longer supported
+- kOps (upstream K8s) 1.13, 1.14 (previously deprecated) are no longer supported
+
+## Deprecation notice
+
+- OpenShift 4.4 (no longer supported by Red Hat) is deprecated
+- GKE K8s versions 1.15, 1.16 (no longer supported by Google) are deprecated
+- kOps (upstream K8s) 1.15 is deprecated
+---
+Title: Previous version Redis Enterprise for Kubernetes release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Release notes for versions of Redis Enterprise for Kubernetes released
+  more than 18 months ago.
+hideListLinks: true
+linkTitle: Previous versions
+weight: 91
+---
+Below are archived release notes for Redis Enterprise for Kubernetes versions released more than 18 months ago.
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A maintenance release that includes support for Redis Software 7.8.6-60.
+hideListLinks: true
+linkTitle: 7.8.6-1 (May 2025)
+title: Redis Enterprise for Kubernetes 7.8.6-1 (May 2025) release notes
+weight: 49
+---
+
+Redis Enterprise for Kubernetes 7.8.6-1 (May 2025) is a maintenance release that includes support for [Redis Software 7.8.6-60]({{<relref "/operate/rs/release-notes/rs-7-8-releases/">}}).
+
+For supported distributions, known limitations, and API changes, see [Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes]({{<relref "/operate/kubernetes/release-notes/7-8-6-releases/7-8-6-1-march2025">}}).
+
+## 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]({{<relref "release-notes/7-8-6-releases">}}) for information on known limitations.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A maintenance release that includes support for Redis Software 7.8.6-36.
+hideListLinks: true
+linkTitle: 7.8.6-1 (April 2025)
+title: Redis Enterprise for Kubernetes 7.8.6-1 (April 2025) release notes
+weight: 49
+---
+
+## 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]({{<relref "/operate/rs/release-notes/rs-7-8-releases/">}}).
+
+For supported distributions, known limitations, and API changes, see [Redis Enterprise for Kubernetes 7.8.6-1 March 2025 release notes]({{<relref "/operate/kubernetes/release-notes/7-8-6-releases/7-8-6-1-march2025">}}).
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/redis:7.8.6-36`
+- **Operator**: `redislabs/operator:7.8.6-1`
+- **Services Rigger**: `redislabs/k8s-controller:7.8.6-1`
+- **OLM operator bundle** : `v7.8.6-1.1`
+
+## Known limitations
+
+See [7.8.6 releases]({{<relref "release-notes/7-8-6-releases">}}) for information on known limitations.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Feature release including enhancements, bug fixes, platform updates, and support for Redis Software 7.8.6-13
+hideListLinks: true
+linkTitle: 7.8.6-1 (March 2025)
+title: Redis Enterprise for Kubernetes 7.8.6-1 (March 2025) release notes
+weight: 50
+---
+
+## 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]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-7-8-6-13.md">}}).
+
+This release also includes the ability to [install the operator using Helm]({{<relref "deployment/helm.md">}}).
+
+Support for Helm is currently in public preview and is not supported on production workloads. Only new installations of the Redis operator are supported at this time.
+
+### Enhancements
+
+- Added support for [Redis Software 7.8.6-13]({{<relref "/operate/rs/release-notes/rs-7-8-releases/rs-7-8-6-13.md">}}).
+- Updated supported Kubernetes distributions
+- DatabaseServicePortPolicy allows use of the default Redis port (6379) for database services.
+- Added additional license fields to the REC status.
+- Added validation to prevent unsupported changes to podDisruptionBudget.
+
+### Resolved issues
+
+- Fixed Sonarcube findings in the log collector (RED-129297).
+- Fixed upgrade failure due to update of the nodeSelector during the upgrade (RED-138445).
+- Fixed issues with Vault plugin connections to Redis Enterprise (RED-139352 RED-144637).
+- Fixed operator crash when a namespace is labeled with a specific label (RED-140344).
+- Fixed failure in Services Rigger when a database uses port 10250 (RED-142673).
+- Reduced CPU priority of the health_check.py script to ensure availability (RED-144360).
+- Fixed broken use case for customizing the Active-Active port. (RED-149374).
+- Fixed API reference for REDB properties (RED-151195).
+- Fixed operator CVE-2024-24786 (RED-151873).
+- Fixed wrong image tag for OpenShift example YAML (RED-152022).
+
+### API changes
+
+| **CRD** | **Field** | **Change** | **Description** |
+|---|---|---|---|
+| REAADB | `spec.externalReplicationPort` | ADD | Specifies the replication endpoint port number for users who use LoadBalancers to synchronize Active-Active replicas and must provide the port that the LoadBalancer listens on. |
+| REC | `status.shardsUsage` | ADD | Total number of shards (both RAM and flash) currently in use under this license. |
+| REC | `status.flashShards` | ADD | Number of flash shards currently in use under this license. |
+| REC | `status.flashShardsLimit` | ADD | Number of flash shards allowed under this license. |
+| REC | `status.ramShards` | ADD | Number of RAM shards currently in use under this license. |
+| REC | `status.ramShardsLimit` | ADD | Number of RAM shards allowed under this license. |
+| REC | `spec.podSecurityPolicyName` | REMOVE | Not supported anymore by supported Kubernetes versions. |
+| REC | `spec.databaseServicePortPolicy` | ADD | Specifies how to determine service ports for REDB services. Defaults to DatabasePortForward if not set. DatabasePortForward - The service port will be the same as the database port. RedisDefaultPort - The service port will be the default Redis port (6379).
+
+## Breaking changes
+
+Customers who use load balancers for Active-Active replication endpoints and rely on the change introduced in RED-113626 (or the workaround described in the ticket) must set the spec.externalReplicationPort field in REAADB after upgrading. Otherwise, replication will fail (RED-149374).
+
+## Supported distributions
+
+The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+| Kubernetes version | **1.26** | **1.27** | **1.28** | **1.29** | **1.30** | **1.31** | **1.32** |
+|---|---|---|---|---|---|---|---|
+|  |  |  |  |  |  |  |  |
+| **Community K8s** |  |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Amazon EKS** |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Azure EKS** |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Google GKE** |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher** |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |
+| **VMware TKG 2.4** | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **OpenShift** | **4.13** | **4.14** | **4.15** | **4.16** | **4.17** | **4.18** |  |
+|  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| **VMware TKGI** | **1.16 | **1.17 | **1.18 | **1.19 | **1.2 |  |  |
+|  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+
+
+## Downloads
+
+- **Redis Enterprise**: `redislabs/operator:7.8.6-13`
+- **Operator**: `redislabs/redis:7.8.6-1`
+- **Services Rigger**: `redislabs/k8s-controller:7.8.6-1`
+- **OLM operator bundle** : `v7.8.6-1.0`
+
+## Known limitations
+
+See [7.8.6 releases]({{<relref "release-notes/7-8-6-releases">}}) for information on known limitations.
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Releases with support for Redis Enterprise Software 7.8.4
+hideListLinks: true
+linkTitle: 7.8.6 releases
+title: Redis Enterprise for Kubernetes 7.8.6 release notes
+weight: 47
+---
+
+Redis Enterprise for Kubernetes 7.8.6-1 includes bug fixes, enhancements, and support for Redis Enterprise Software version 7.8.6-13 .
+
+## Detailed release notes
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+## Breaking changes
+
+Customers who use load balancers for Active-Active replication endpoints and rely on the change introduced in RED-113626 (or the workaround described in the ticket) must set the spec.externalReplicationPort field in REAADB after upgrading. Otherwise, replication will fail (RED-149374).
+
+## Known limitations
+
+- **Only upgrades from 7.4.2-2 and later are supported.** If you are using an earlier version, install 7.4.2-2 before upgrading to 7.8.2-6 or later.
+
+- **When changing the REDB field `spec.modulesList`, version might be upgraded to latest, even if a different version is specified.** To prevent the upgrade to latest, set  `spec.upgradeSpec.setModuleToLatest` to `false` before upgrading to 7.8.2-6.
+
+- **Missing endpoint for admission endpoint (rare) (RED-119469)** Restart the operator pod.
+
+- **The REDB “redisVersion” field can’t be used for memcached databases(RED-119152)**
+
+- **When modifying the database suffix for an Active-Active database, while the service-rigger is in a terminating state, the services-rigger will delete and create the ingress or route resources in a loop (RED-107687)** Wait until the services rigger pod has finished to terminate it.
+
+- **REAADB changes might fail with "gateway timeout" errors, mostly on OpenShift (RED-103048)** Retry the operation.
+
+- **Creating two databases with the same name directly on Redis Enterprise software will cause the service to be deleted and the database will not be available (RED-99997)** Avoid duplicating database names. Database creation via K8s has validation in place to prevent this.
+
+- **Installing the operator bundle produces warning: `Warning: would violate PodSecurity "restricted: v1.24"` (RED-97381)** Ignore the warning. This issue is documented as benign on official Red Hat documentation.
+
+- **RERC resources must have a unique name (RED-96302)** The string "rec-name"/"rec-namespace" must be different from all other participating clusters in the Active-Active database.
+
+- **Admission is not blocking REAADB with `shardCount` which exceeds license quota (RED-96301)** Fix the problems with the REAADB and reapply.
+
+- **Active-Active controller only supports global database options. Configuration specific to location is not supported (RED-86490)**
+
+- **Active-Active setup removal might keep services or routes undeleted (RED-77752)** Delete services or routes manually if you encounter this problem.
+
+- **`autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351)** Contact support if your deployment is impacted.
+
+- **Following the previous quick start guide version causes issues with creating an REDB due to unrecognized memory field name (RED-69515)** The workaround is to use the newer (current) revision of Deploy Redis Enterprise Software for Kubernetes.
+
+- **PVC size issues when using decimal value in spec (RED-62132)** Make sure you use integer values for the PVC size.
+
+- **REC might report error states on initial startup (RED-61707)** There is no workaround at this time except to ignore the errors.
+
+- **Hashicorp Vault integration - no support for Gesher (RED-55080)** There is no workaround for this issue. Gesher support has been deprecated.
+
+- **REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)** When REC clusters are deployed on Kubernetes clusters without synchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+- **Deleting an OpenShift project with an REC deployed may hang (RED-47192)** When an REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. Therefore, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Then, you can delete the project.
+
+- **Clusters must be named 'rec' in OLM-based deployments (RED-39825)** In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (namely, "rec"). The workaround is to name the cluster "rec".
+
+- **Readiness probe incorrect on failures (RED-39300)** STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+- **Internal DNS and Kubernetes DNS may have conflicts (RED-37462)** DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+- **K8s-based 5.4.10 clusters seem to negatively affect existing 5.4.6 clusters (RED-37233)** Upgrade clusters to latest version.
+
+- **Node CPU usage is reported instead of pod CPU usage (RED-36884)** In Kubernetes, the reported node CPU usage is the usage of the Kubernetes worker node hosting the REC pod.
+
+- **An unreachable cluster has status running (RED-32805)** When a cluster is in an unreachable state, the state remains `running` instead of triggering an error.
+
+- **Long cluster names cause routes to be rejected  (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer.
+
+- **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+---
+Title: Redis Enterprise Software for Kubernetes release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise Software for Kubernetes operator release notes.
+hideListLinks: true
+linkTitle: Release notes
+weight: 90
+---
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: Redis Enterprise for Kubernetes release notes 6.2.12-1 (Sept 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support added for additional distributions, as well as feature improvements
+  and bug fixes.
+linktitle: 6.2.12-1 (Sept 2022)
+weight: 60
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-12-1/,
+]
+---
+## 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.
+
+The key bug fixes and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.12-82` or  `redislabs/redis:6.2.12-82.rhel8-openshift`
+* **Operator**: `redislabs/operator:6.2.12-1`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.12-1` or `redislabs/services-manager:6.2.12-1` (on the Red Hat registry)
+
+## Feature improvements
+
+* Redis Enterprise Software 6.2.12 support (RED-83829)
+* Added support for annotations on services created by Redis Enterprise (RED-56245)
+* Support for additional builds of same Redis Software version with same operator version. The list of supported builds will be published. (RED-78757)
+
+## Bug fixes
+
+* Fixed Golang related vulnerabilities (RED-79205)
+* Log collector creating larger packages (RED-79650)
+* Log collector crashes when Redis Enterprise cluster is not running (RED-79996)
+* Redis Enterprise Software pods termination process could lead, in some circumstances, to pod shutdown without proper failover of its master shards. This has been fixed so that the failover attempts are retried indefinitely within the grace period, which by default is 1 year. The grace period is controllable via the redisEnterpriseTerminationGracePeriodSeconds parameter in the REC (but note that shutting down a pod without the proper failovers may lead to data loss).(RED-75388)
+
+## API changes
+
+The Redis Enterprise cluster `podSecurityPolicy` is deprecated. This is still supported but will be removed when all K8s versions supporting the feature are removed.
+
+## Compatibility notes
+
+Below is a table showing supported distributions at the time of this release. See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the current list of supported distributions.
+
+| **Kubernetes version**  | 1.20       | 1.21       | 1.22       | 1.23       | 1.24       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|
+ | Community Kubernetes   |            |            | supported  | supported  | supported |
+| Amazon EKS              |            | deprecated | supported  | supported* |
+| Azure AKS               |            |            | supported  | supported  | supported* |
+| Google GKE              |            | deprecated | supported  | supported  | supported* |
+| Rancher 2.6             |            | supported  | supported  | supported* |            |
+| **OpenShift version**   | **4.7**    | **4.8**    | **4.9**    | **4.10**   | **4.11**   |
+|                         | deprecated | deprecated | supported  | supported  | supported* |
+| **VMware TKGI version** | **1.11**   | **1.12**   | **1.13**   | **1.14**   | **1.15**   |
+|                         | deprecated | deprecated | supported* | supported* |            |
+
+\* Support added in this release  
+
+### Support added
+
+* Azure AKS 1.24
+* Amazon EKS 1.23
+* Google GKE 1.24
+* OpenShift 4.11
+* Rancher 1.23
+* VMware TKGI 1.14
+
+### Deprecated
+
+* Amazon EKS 1.21
+* Google GKE 1.21
+* OpenShift 4.7
+* OpenShift 4.8
+* VMware TKGI 1.11
+* VMware TKGI 1.12
+
+### No longer supported
+
+* Community Kubernetes 1.21
+* Amazon EKS 1.19, 1.20
+* Azure AKS 1.21
+* Google GKE 1.19, 1.20
+* Rancher 2.6 1.19, 1.20
+* VMware TKGI 1.10
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### Supported upgrade paths
+
+If you are using operator version 6.2.8-15 or earlier, you cannot upgrade directly to operator versions 6.2.12 through 6.4.2-5. You must upgrade to operator version 6.2.10-45 before you can upgrade to operator versions between 6.2.12 and 6.4.2-5. However, upgrades directly to operator version 6.4.2-6 are supported.
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+  
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+* An unreachable cluster has status running (RED-32805)
+  
+  When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* Role missing on replica sets (RED-39002)
+
+  The `redis-enterprise-operator` role is missing permission on replica sets.
+
+* Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+  OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When a REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. As such, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Afterwards, you may delete the project.
+
+* REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+  In K8s 1.15 or older, the PVC labels come from the match selectors and not the PVC templates. As such, these versions cannot support PVC labels. If this feature is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+
+* Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+  The workaround is to use the newer (current) revision of the quick start document available online.
+
+* `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+* Procedure to update credentials might be problematic on OpenShift when accessing the cluster externally using routes (RS issue)(RED-73251)(RED-75329)
+  To workaround this, access the API from within the K8s cluster.
+
+* On Windows, `log_collector` doesn't recognize the namespace given with the `-n` flag (RED-83532)
+
+  To workaround this, use a different operating system.
+
+* Active-Active database creation will fail if the ingress class annotation is not exactly "nginx" when using Nginx ingress controller (RED-83070)
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.8-15 (January 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Maintenance release with bug fixes
+linktitle: 6.2.8-15 (January 2022)
+weight: 64
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-8-15-2022-01.md,
+]
+---
+## Overview
+
+The Redis Enterprise K8s 6.2.8-15 is a maintenance release for the [Redis Enterprise Software release 6.2.8]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021.md" >}}) and includes bug fixes.
+
+The key new features, bug fixes, and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.8-64` or  `redislabs/redis:6.2.8-64.rhel7-openshift`
+* **Operator**: `redislabs/operator:6.2.8-15`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.8-15` or `redislabs/services-manager:6.2.8-15` (on the Red Hat registry)
+
+## Fixed bugs
+
+* Upgrading with the bundle using `kubectl apply -f` fails giving error (RED-69570):
+
+    ```sh
+    The CustomResourceDefinition "redisenterpriseclusters.app.redislabs.com" is invalid: spec.preserveUnknownFields: Invalid value: true: must be false in order to use defaults in the schema.
+    ```
+
+* Removed unneeded certificates from the Redis Enterprise Software container (RED-69661, RED-60086)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+### Long cluster names cause routes to be rejected  (RED-25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED-32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED-39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+### Role missing on replica sets (RED-39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions cannot support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### REC might report error states on initial startup (RED-61707)
+
+There is no workaround at this time except to ignore the errors.
+
+### PVC size issues when using decimal value in spec (RED-62132)
+
+The workaround for this issue is to make sure you use integer values for the PVC size.
+
+### Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name
+
+The workaround is to use the newer (current) revision of the quick start document available online.
+
+## Compatibility Notes
+
+See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the full list of supported distributions.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.10-34 (May 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for REBD specific upgrade policies, memcached type REDBs, and
+  RHEL8 for OpenShift, as well as feature improvements and bug fixes.
+linktitle: 6.2.10-34 (May 2022)
+weight: 62
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-10-34-2022-05/,
+]
+---
+## 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.
+
+The key new features, bug fixes, and known limitations are described below.
+
+{{<warning>}}
+  **Do not** upgrade to this 6.2.10-34 release if you are an **OpenShift** customer and **also use modules**. Instead, **use the [6.2.10-45]({{< relref "/operate/kubernetes/release-notes/6-2-releases/k8s-6-2-10-45-2022-07" >}})** release.
+  
+  There was a change in 6.2.10-34 to a new RHEL 8 base image for the Redis Server image. Due to binary differences in modules between the two operating systems, you cannot directly update RHEL 7 clusters to RHEL 8 when those clusters host databases using modules.
+  
+   Please contact support if you have further questions. {{</warning>}}
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.10-107` or  `redislabs/redis:6.2.10-107.rhel8-openshift`
+* **Operator**: `redislabs/operator:6.2.10-34`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.10-34` or `redislabs/services-manager:6.2.10-34` (on the Red Hat registry)
+
+## New features
+
+* Support database upgrade policy (major/latest) for REDB resources (RED-71028)
+* Support for memcached type databases for REDB (RED-70284)(RED-75269)
+* Use RHEL8 base images for OpenShift deployments (RED-72374)
+
+## Feature improvements
+
+* OpenShift 4.10 support (RED-73966)
+* Allow setting host time zone on running containers (RED-56810)
+* AKS 1.23 support (RED-73965)
+* EKS 1.22 support (RED-73972)
+
+## Fixed bugs
+
+* Outdated SCC YAML file (RED-72026) (RED-73341)
+* Admission container startup failure (RED-72081)
+* Admission container restarts due to race condition with config map creation (RED-72268)
+* Incorrect REDB status report during cluster recovery (RED-72944)
+* Invalid REDB spec not always rejected by admission controller (RED-73145)
+
+## Compatibility notes
+
+Below is a table showing supported distributions at the time of this release. See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the current list of supported distributions.
+
+| **Kubernetes version**  | **1.19**   | **1.20**   | **1.21**   | **1.22**   | **1.23**   |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    | deprecated | deprecated | supported  | supported  | supported* |
+| Amazon EKS              | supported  | supported  | supported  |            |            |
+| Azure AKS               |            |            | supported  | supported  | supported* |
+| Google GKE              | supported  | supported  | supported  | supported  |            |
+| Rancher 2.6             | supported  | supported  | supported  | supported  |            |
+| **OpenShift version**   | **4.6**    | **4.7**    | **4.8**    | **4.9**    | **4.10**   |
+|                         | deprecated | deprecated | supported  | supported  | supported* |
+| **VMware TKGI version** | **1.10**   | **1.11**   | **1.12**   | **1.13**   |            |
+|                         | supported  | supported  | supported* |            |            |
+
+\* Support added in most recent release  
+
+### Now supported
+
+* OpenShift 4.10 is now supported
+* kOps (Community Kubernetes) 1.23 is now supported
+* AKS 1.23 is now supported
+* EKS 1.22 is now supported
+
+### Deprecated
+
+* OpenShift 4.6-4.7 is deprecated
+* kOps (Community Kubernetes) 1.18-1.20 are deprecated
+* GKE 1.19 is deprecated
+* Rancher 2.6 - K8s 1.18 is deprecated
+* AKS 1.20-1.21 are deprecated
+* EKS 1.18-1.19 are deprecated
+
+### No longer supported
+
+* Rancher version 2.5 (previously deprecated) is no longer supported (not supported by SUSE)
+* OpenShift version 3.11 (previously deprecated) is no longer supported.
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* **Warning** Openshift customers using modules cannot use 6.2.10-34 version
+  {{<warning>}}
+  **Do not** upgrade to this 6.2.10-34 release if you are an **OpenShift** customer and **also use modules**. 
+  
+  There was a change in 6.2.10-34 to a new RHEL 8 base image for the Redis Server image. Due to binary differences in modules between the two operating systems, you cannot directly update RHEL 7 clusters to RHEL 8 when those clusters host databases using modules. 
+  
+  This message will be updated as remediation plans and new steps are available to address this situation. Please contact support if you have further questions. {{</warning>}}
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+  
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+* An unreachable cluster has status running (RED-32805)
+  
+  When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* Role missing on replica sets (RED-39002)
+
+  The `redis-enterprise-operator` role is missing permission on replica sets.
+
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When a REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. As such, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Afterwards, you may delete the project.
+
+* REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+  In K8s 1.15 or older, the PVC labels come from the match selectors and not the PVC templates. As such, these versions cannot support PVC labels. If this feature is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+
+* Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+The workaround is to use the newer (current) revision of the quick start document available online.
+
+* `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+* Procedure to update credentials might be problematic on OpenShift when accessing the cluster externally using routes (RS issue)(RED-73251)(RED-75329)
+  To workaround this, access the API from within the K8s cluster.
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.8-2 (November 2021)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.2.8, certificate management, and Redis upgrade policy.
+linktitle: 6.2.8-2 (November 2021)
+weight: 66
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-8-2-2021-11/,
+]
+---
+## Overview
+
+The Redis Enterprise [K8s 6.2.8-2](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.2.8-2) release provides support for the [Redis Enterprise Software release 6.2.8]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021.md" >}}) and includes several enhancements and bug fixes.
+
+The key new features, bug fixes, and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.8-41` or  `redislabs/redis:6.2.8-41.rhel7-openshift`
+* **Operator**: `redislabs/operator:6.2.8-2`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.8-2` or `redislabs/services-manager:6.2.8-2` (on the Red Hat registry)
+
+## New features
+
+* Certificate management capabilities through the Redis Enterprise cluster API (RED-61176)
+
+## Feature improvements
+
+* Support for managing database ports through the REDB API (RED-48286)
+* Use explicit object instead of wildcard for roles (RED-38013)
+* Advanced use case support for custom attributes for REC stateful set and rigger pods (RED-56502, RED-62550, RED-63426)
+* Services rigger/K8s controller image changed to ubi-minimal lightweight base image (RED-61866)
+* Support for the Redis upgrade policy setting through the REC API (RED-63000)
+
+## Fixed bugs
+
+* Fixed issue of log rotation not working on OpenShift (RED-64726)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+### Long cluster names cause routes to be rejected  (RED-25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED-32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED-39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+### Role missing on replica sets (RED-39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions can not support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### REC might report error states on initial startup (RED-61707)
+
+There is no workaround at this time except to ignore the errors.
+
+### PVC size issues when using decimal value in spec (RED-62132)
+
+The workaround for this issue is to make sure you use integer values for the PVC size.
+
+## Compatibility Notes
+
+See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the full list of supported distributions.
+
+### No longer supported
+
+* kOps K8s versions 1.16 and 1.17 (previously deprecated) are no longer supported
+* AKS K8s version 1.18 (previously deprecated) is no longer supported
+* GKE K8s version 1.18 (previously deprecated) is no longer supported
+* VMWare TKGI version 1.7 (K8s 1.16) (previously deprecated) is no longer supported
+* VMWare TKGI version 1.8 (K8s 1.17) (previously deprecated) is no longer supported
+
+## Deprecation notice
+
+* Rancher version 2.4 support is deprecated
+---
+Title: Redis Enterprise for Kubernetes release notes 6.2.18-41 (Jan 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release for 6.2.18 and includes support for Redis Enterprise 6.2.18-72.
+linktitle: 6.2.18-41 (Jan 2023)
+weight: 58
+aliases: [
+  /operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41-jan-2023/,
+]
+---
+## 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.
+
+New images and fixes are listed below. Refer to [6.2.18-41 (Dec 2022]({{< relref "/operate/kubernetes/release-notes/6-2-releases/k8s-6-2-18-41.md" >}}) for compatibility notes and known limitations.
+
+{{<warning>}} Due to a change in the SCC, on OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later, where `node:1` is <b>not</b> the master node, the upgrade might get stuck.
+
+For more info and steps to prevent this issue, see [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}).
+{{</warning>}}
+
+## Images
+
+DockerHub images are available at `docker.io/`.
+
+* **Redis Enterprise**: `redislabs/redis:6.2.18-72`
+* **Operator**: `redislabs/operator:6.2.18-41`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.18-41`
+
+### OpenShift images
+
+**OLM operator version**: `v6.2.18-41c`
+
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.2.18-72.rhel8-openshift`
+    (or `registry.connect.redhat.com/redislabs/redis-enterprise:6.2.18-72.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.2.18-41`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.2.18-41`
+
+## Feature enhancements
+
+* Upgraded to support Redis Enterprise 6.2.18-72
+
+## Compatibility notes
+
+See [Redis Enterprise for Kubernetes release notes 6.2.18-41 (Dec 2022)]({{< relref "/operate/kubernetes/release-notes/6-2-releases/k8s-6-2-18-41.md" >}}).
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+ ### Supported upgrade paths
+
+  If you are using a version earlier than 6.2.10-45, you cannot upgrade directly to this release. You must upgrade to 6.2.10-45 before you can upgrade to versions 6.2.18 or later.
+
+## Known limitations
+
+See [Redis Enterprise for Kubernetes release notes 6.2.18-41 (Dec 2022)]({{< relref "/operate/kubernetes/release-notes/6-2-releases/k8s-6-2-18-41.md" >}}).
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-72 release notes]({{<relref "operate/rs/release-notes/rs-6-2-18-releases/rs-6-2-18-70#security">}}).
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.4-1 (September 2021)
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for RS 6.2.4 and OpenShift 4.8. Support for K8s 1.19 (EKS and
+  AKS), K8s 1.20 (Rancher, EKS, AKS), K8s 1.21 (GKE and kOps).
+linkTitle: 6.2.4-1 (September 2021)
+weight: 67
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-4-1-2021-09/,
+]
+---
+## Overview
+
+The Redis Enterprise [K8s 6.2.4-1](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases/tag/v6.2.4-1) release provides support for the [Redis Enterprise Software release 6.2.4]({{< relref "/operate/rs/release-notes/rs-6-2-4-august-2021.md" >}}) and includes several enhancements and bug fixes.
+
+The key new features, bug fixes, and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.4-55` or  `redislabs/redis:6.2.4-55.rhel7-openshift`
+* **Operator**: `redislabs/operator:6.2.4-1`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.4-1` or `redislabs/services-manager:6.2.4-1` (on the Red Hat registry)
+
+## New features
+
+* Internode encryption configuration through K8s custom resources (RED-59699, RED-60318)
+
+## Feature improvements
+
+* Support for addition attribute in REDB secret containing comma separated list of service names (RED-48469)
+* Support OpenShift 4.8 (K8s 1.21) (RED-59424)
+* Support K8s 1.21 - GKE (RED-59048)
+* Support K8s 1.21 - kOps (RED-59047)
+* Support K8s 1.19-1.21 - EKS (RED-60287)
+* Support K8s 1.19, 1.20 - AKS (RED-59050)
+* Support K8s 1.20 - Rancher (RED-59049)
+
+## Fixed bugs
+
+* Fixed issue with RS pods not recovering from container failures (RED-53042)
+* Fixed rare problem of Redis Enterprise pod restarting too early while statefulSet was rolling out, causing quorum loss (RED-53042)
+* Improved Github public documentation around using the admission controller with multiple namespaces (RED-59915)
+* Fixed integration issues with HashiCorp Vault enterprise namespaces and custom auth paths (RED-61273)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+### Applying bundle.yaml generated a warning
+
+When applying bundle.yaml on K8s clusters 1.20 and above, the following warning is generated: 
+```
+Warning: apiextensions.k8s.io/v1beta1 CustomResourceDefinition is deprecated in v1.16+, unavailable in v1.22+; use apiextensions.k8s.io/v1 CustomResourceDefinition
+```
+The warning can be safely ignored. A future release will leverage the updated API version for CustomResourceDefinition, once support for K8s 1.22 is introduced.
+
+### Enabling the Kubernetes webhook generates a warning
+
+When [installing](https://github.com/RedisLabs/redis-enterprise-k8s-docs#installation) and configuring the admission controller webhook (step 5), the following warning is generated: 
+```
+Warning: admissionregistration.k8s.io/v1beta1 ValidatingWebhookConfiguration is deprecated in v1.16+, unavailable in v1.22+; use admissionregistration.k8s.io/v1 ValidatingWebhookConfiguration
+```
+The warning can be safely ignored. A future release will leverage the updated API version for ValidatingWebhookConfiguration, once support for K8s 1.22 is introduced.
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### Long cluster names cause routes to be rejected  (RED-25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or fewer.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED-32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED-39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on the node fails.
+
+### Role missing on replica sets (RED-39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions can not support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+### REC might report error states on initial startup (RED-61707)
+
+There is no workaround at this time except to ignore the errors.
+
+### PVC size issues when using decimal value in spec (RED-62132)
+
+The workaround for this issue is to make sure you use integer values for the PVC size.
+
+### Long REC names or namespace names cause failures (RED-62222)
+
+The combined length of the REC name and namespace name must be equal to or less than 45 characters.
+
+## Compatibility Notes
+
+See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the full list of supported distributions.
+
+### Now supported
+
+* OpenShift 4.8
+* GKE K8s version 1.21
+* kOps K8s version 1.21
+* EKS K8s versions 1.19-1.21
+* AKS K8s versions 1.19-1.20
+* Rancher K8s version 1.20
+
+### No longer supported
+
+* GKE K8s version 1.17 (previously deprecated)
+* kOps K8s version 1.15 (previously deprecated)
+
+## Deprecation notice
+
+* kOps 1.16 and 1.17 are deprecated
+* VMWare TKGI 1.7 (K8s 1.16), VMWare TKGI 1.8 (K8s 1.17) are deprecated (no longer supported by VMWare)
+* Openshift 3.11 (K8s 1.11) is now deprecated. Redis will continue to support existing deployments for the lifetime of Openshift 3.11, but new deployments are strongly discouraged.
+---
+Title: Redis Enterprise for Kubernetes release notes 6.2.18-3 (Nov 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support added for additional distributions, as well as feature improvements and bug fixes.
+linktitle: 6.2.18-3 (Nov 2022)
+weight: 60
+aliases: [
+  /operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41/,
+]
+---
+## 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.
+
+The key bug fixes, new features, and known limitations are described below.
+
+{{<warning>}}
+If you use NGINX as an ingress controller for Redis Enterprise, **do not upgrade** to the 6.2.18-3 release. Skip this release and upgrade to version [6.2.18-41]({{< relref "/operate/kubernetes/release-notes/6-2-releases/" >}}) instead.
+{{</warning>}}
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.18-58` or  `redislabs/redis:6.2.18-58.rhel8-openshift` (or `redislabs/redis:6.2.18-58.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `redislabs/operator:6.2.18-3`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.18-3` or `redislabs/services-manager:6.2.18-3` (on the Red Hat registry)
+
+## New features
+
+* Support for [Auto Tiering]({{< relref "/operate/kubernetes/re-clusters/auto-tiering.md" >}}) (RED-78613)
+
+## Feature improvements
+
+* The `podSecurityPolicyName` field in `RedisEnterpriseCluster` resources is now deprecated for Kubernetes versions 1.24 or earlier, and invalid for 1.25 and later. Customers are advised to switch to using the [`PodSecurityAdmission`](https://kubernetes.io/docs/concepts/security/pod-security-admission/) or alternative methods to enforce pod security (RED-81921).
+
+* Added support for VMware [Tanzu Kubernetes Grid (TKG)](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid/index.html), in addition to [Tanzu Kubernetes Grid Integration Edition (TKGI)](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid-Integrated-Edition/index.html) that was previously and is still supported (RED-65630).
+
+* Added support for PEM encryption through the [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}})(RED-78613).
+
+* Hardened security context constraints to align with standards for OpenShift 4.11 (RED-83215).
+
+* Changed log collector default to avoid collection of non-Redis Enterprise logs and items (RED-83216).
+
+* Allowed configuration of the Redis Enterprise cluster (REC) service type (RED-84644).
+
+## Bug fixes
+
+* Allow any ingress class name annotation when using NGINX ingress controller. This is no longer required to be exactly `nginx` (RED-79205).
+* Fixed log collector handling of namespace parameter on Windows (RED-83532).
+* Fixed issue with updating credentials on Openshift when accessing the cluster externally with routes (RED-73251, RED-75329).
+
+## API changes
+
+The following fields were added to the [Redis Enterprise cluster (REC) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}):
+
+* Added `.services.apiService.type` to allow configuration of the API service type.
+* Made `.redisOnFlashSpec` available by default.
+* Made `.ocspConfiguration` available by default for configuring OCSP stapling.
+* Made `.encryptPkeys` available by default for configuring PEM encryption.
+
+The following fields were added to the [Redis Enterprise database (REDB) API]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api">}}):
+
+* `.isRoF` and `.rofRamSize` added to support the [Auto Tiering feature]({{< relref "/operate/kubernetes/re-clusters/auto-tiering.md" >}}).
+
+## Compatibility notes
+
+Below is a table showing supported distributions at the time of this release. See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the current list of supported distributions.
+
+| **Kubernetes version**  | 1.21       | 1.22       | 1.23       | 1.24       | 1.25       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            | supported  | supported  | supported  | supported  |
+| Amazon EKS              | deprecated | supported  | supported  |            |            |
+| Azure AKS               |            | supported  | supported  | supported  |            |
+| Google GKE              | deprecated | supported  | supported  | supported  | supported* |
+| Rancher 2.6             | supported  | supported  | supported  | supported* |            |
+| VMware TKG 1.6          |            | supported* | supported* |            |            |
+| **OpenShift version**   | **4.8**    | **4.9**    | **4.10**   | **4.11**   |            |
+|                         |            | deprecated | supported  | supported* |            |
+| **VMware TKGI version** | **1.12**   | **1.13**   | **1.14**   | **1.15**   |            |
+|                         |            | supported  | supported  | supported* |            |
+
+\* Support added in this release
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### Supported upgrade paths
+
+If you are using operator version 6.2.8-15 or earlier, you cannot upgrade directly to operator versions 6.2.12 through 6.4.2-5. You must upgrade to operator version 6.2.10-45 before you can upgrade to operator versions between 6.2.12 and 6.4.2-5. However, upgrades directly to operator version 6.4.2-6 are supported.
+  
+### OpenShift versions 6.2.12 or earlier
+
+Due to a change in the SCC, on OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later, where `node:1` is <b>not</b> the master node, the upgrade might get stuck.
+
+For more info and steps to prevent this issue, see [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}).
+
+Operator version 6.4.2-6 includes a fix for this issue.
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster.
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+  
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+* An unreachable cluster has status running (RED-32805)
+  
+  When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When a REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. As such, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Afterwards, you may delete the project.
+
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+
+* Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+  The workaround is to use the newer (current) revision of the quick start document available online.
+
+* `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-58 release notes]({{<relref "operate/rs/release-notes/rs-6-2-18-releases/rs-6-2-18-58#security">}}).
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.10-4 (March 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Added support for RS 6.2.10 as well as feature improvements and bug fixes.
+linktitle: 6.2.10-4 (March 2022)
+weight: 63
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-10-4-2022-03-copy/,
+  /operate/kubernetes/release-notes/k8s-6-2-10-4-2022-03/,
+]
+---
+## 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.
+
+The key new features, bug fixes, and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.10-90` or  `redislabs/redis:6.2.10-90.rhel7-openshift`
+* **Operator**: `redislabs/operator:6.2.10-4`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.10-4` or `redislabs/services-manager:6.2.10-4` (on the Red Hat registry)
+
+## Feature improvements
+
+* REDB status - bundled Redis versions for cluster shown in status (RED-44074)
+* OLM (OperatorHub) - example REC contains image references to Red Hat servers (RED-44439)
+* REDB status - added information about database backups (RED-45577)
+* Added dedicated metrics exporter service (service name ending in -prom). Using the service is recommended for gathering Prometheus data about the cluster. Using the service with the UI service is not recommended (RED-61807)
+* REDB - added support for shard_placement
+* RS 6.2.10 support (RED-69142)
+* REDB - control autoUpgrade (RED-71157)
+
+## Fixed bugs
+
+* Cluster no longer refuses wrong sized volume to create clusters (error shown instead) (RED-61284)
+
+* Resolved high CPU usage when many pods are running within the namespace (RED-69682)
+
+* TKGI - support 1.11/1.12 (RED-70579)
+
+* Fixed rack awareness label in documentation (RED-70622)
+
+* Fixed crash in admission container when admission service is missing (RED-70678)
+
+* Services rigger deployment generation no longer increases without changes (RED-70835)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+### Long cluster names cause routes to be rejected  (RED-25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED-32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED-39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+### Role missing on replica sets (RED-39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions cannot support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time.
+
+### REC might report error states on initial startup (RED-61707)
+
+There is no workaround at this time except to ignore the errors.
+
+### PVC size issues when using decimal value in spec (RED-62132)
+
+The workaround for this issue is to make sure you use integer values for the PVC size.
+
+### Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+The workaround is to use the newer (current) revision of the quick start document available online.
+
+### `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+Contact support if your deployment is impacted.
+
+## Compatibility Notes
+
+See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the full list of supported distributions.
+
+### Now supported
+
+* TKGI 1.11 (K8s 1.20) is supported
+* Rancher version 2.6 is supported
+
+### Deprecated
+
+* Rancher version 2.5 support is deprecated
+
+### No longer supported
+
+* Rancher version 2.5 / K8s 1.17 (previously deprecated) is no longer supported (not supported by SUSE)
+---
+Title: Redis Enterprise for Kubernetes release notes 6.2.18-41 (Dec 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This is a maintenance release for 6.2.18 and includes bug fixes.
+linktitle: 6.2.18-41 (Dec 2022)
+weight: 59
+aliases: [
+  /operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41/,
+]
+---
+## 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.
+
+The key bug fixes and known limitations are described below.
+
+{{<warning>}} Due to a change in the SCC, on OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later, where `node:1` is <b>not</b> the master node, the upgrade might get stuck.
+
+For more info and steps to prevent this issue, see [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}).
+{{</warning>}}
+
+## Images
+
+
+* **Redis Enterprise**: `redislabs/redis:6.2.18-65`
+* **Operator**: `redislabs/operator:6.2.18-41`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.18-41`
+
+### OpenShift images
+
+**OLM operator version**: `v6.2.18-41a`
+
+
+* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.2.18-65.rhel8-openshift`
+    (or `redislabs/redis-enterprise:6.2.18-65.rhel7-openshift` if upgrading from RHEL 7)
+* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.2.18-41`
+* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.2.18-41`
+
+## Bug fixes
+
+* Fixed issues with incorrect image digest (OLM/OpenShift) (RED-88863)
+* Fixed upgrade issue for using NGINX-based ingress with Active-Active databases. (RED-88882)
+* Upgraded to Redis Software 6.2.18-65 (RED-88985)
+* Fixed upgrade issue with OLM (RED-89170)
+* Removed non-core Python dependencies from the log collector (RED-90108)
+* Fixed issues with running log collector on OLM (RED-90129
+
+## Compatibility notes
+
+Below is a table showing supported distributions at the time of this release. See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the current list of supported distributions.
+
+| **Kubernetes version**  | 1.21       | 1.22       | 1.23       | 1.24       | 1.25       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            | supported  | supported  | supported  | supported  |
+| Amazon EKS              | deprecated | supported  | supported  |            |            |
+| Azure AKS               |            | supported  | supported  | supported  |            |
+| Google GKE              | deprecated | supported  | supported  | supported  | supported  |
+| Rancher 2.6             | supported  | supported  | supported  | supported  |            |
+| VMware TKG 1.6          |            | supported  | supported  |            |            |
+| **OpenShift version**   | **4.8**    | **4.9**    | **4.10**   | **4.11**   |            |
+|                         |            | deprecated | supported  | supported  |            |
+| **VMware TKGI version** | **1.12**   | **1.13**   | **1.14**   | **1.15**   |            |
+|                         |            | supported  | supported  | supported  |            |
+
+\* Support added in this release
+
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+ ### Supported upgrade paths
+
+  If you are using a version earlier than 6.2.10-45, you cannot upgrade directly to this release. You must upgrade to 6.2.10-45 before you can upgrade to versions 6.2.18 or later.
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+  
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+* An unreachable cluster has status running (RED-32805)
+  
+  When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When a REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. As such, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Afterwards, you may delete the project.
+
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+
+* Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+  The workaround is to use the newer (current) revision of the [quick start document]({{< relref "/operate/kubernetes/deployment/quick-start.md" >}}) available online.
+
+* `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+## Security
+
+For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-65 release notes]({{<relref "operate/rs/release-notes/rs-6-2-18-releases/rs-6-2-18-65#security">}}).
+---
+Title: Redis Enterprise for Kubernetes Release Notes 6.2.8-11 (January 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support for Istio as ingress controller, K8s 1.22 (AKS, kOps, GKE), OpenShift
+  4.9
+linktitle: 6.2.8-11 (January 2022)
+weight: 65
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-8-11-2022-01/,
+]
+---
+## Overview
+
+The Redis Enterprise K8s 6.2.8-11 release provides support for the [Redis Enterprise Software release 6.2.8]({{< relref "/operate/rs/release-notes/rs-6-2-8-october-2021.md" >}}) and includes several enhancements and bug fixes.
+
+The key new features, bug fixes, and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.8-53` or  `redislabs/redis:6.2.8-53.rhel7-openshift`
+* **Operator**: `redislabs/operator:6.2.8-11`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.8-11` or `redislabs/services-manager:6.2.8-11` (on the Red Hat registry)
+
+## Feature improvements
+
+* Istio gateway/virtual services are supported as ingress controllers. Note that for Active-Active databases, the operator doesn't create ingress rules, and those should be manually configured. The version of Istio that was tested is Istio 1.12.0  (RED-64020)
+* Support for K8s 1.22 (AKS, kOps, GKE) and OpenShift 4.9 (RED-64016)
+* Support for pod termination grace period customization in the REC (advanced use case) (RED-67217)
+* Improved security granularity of SCC configuration steps in documentation (RED-67321)
+* Changed behavior when two databases with the same name are created on the cluster. The operator avoids creating a service for them to prevent possible corruption (RED-64535)
+* Improved documentation about changing cluster credentials when using Hashicorp Vault (RED-65304)
+
+## Fixed bugs
+
+* Upgraded Go dependencies marked as vulnerable (RED-63858, RED-68651)
+* Avoided flooding operator logs with deprecation notices on K8s 1.21 (RED-67544)
+* Fixed log collector utility issues running on Microsoft Windows (RED-67682)
+* Fixed excessive updates to the RS cluster when using Windows line endings for TLS certificates (RED-67874)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+### Upgrading with the bundle using `kubectl apply -f` fails (RED-69515)
+
+Upgrading with the bundle using `kubectl apply -f` fails, giving the following error:
+
+`The CustomResourceDefinition "redisenterpriseclusters.app.redislabs.com" is invalid: spec.preserveUnknownFields: Invalid value: true: must be false in order to use defaults in the schema`
+
+Workaround: Before the upgrade, set the 'spec.preserveUnknownFields` value to false on the REC custom resource. You can use the following command: 
+
+```sh
+kubectl patch crd redisenterpriseclusters.app.redislabs.com -p $'spec:\n preserveUnknownFields: false'
+```
+
+### Long cluster names cause routes to be rejected  (RED-25871)
+
+A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+### Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+
+A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+### An unreachable cluster has status running (RED-32805)
+
+When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+### Readiness probe incorrect on failures (RED-39300)
+
+STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+### Role missing on replica sets (RED-39002)
+
+The `redis-enterprise-operator` role is missing permission on replica sets.
+
+### Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+### Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+### 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+### Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+### Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+### REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+### Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+When a REC cluster is deployed in a project (namespace) and has REDB resources, the
+REDB resources must be deleted first before the REC can be deleted. As such, until the
+REDB resources are deleted, the project deletion will hang. The fix is to delete the
+REDB resources first and the REC second. Afterwards, you may delete the project.
+
+### REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+In K8s 1.15 or older, the PVC labels come from the match selectors and not the
+PVC templates. As such, these versions cannot support PVC labels. If this feature
+is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+### Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+There is no workaround at this time
+
+### REC might report error states on initial startup (RED-61707)
+
+There is no workaround at this time except to ignore the errors.
+
+### PVC size issues when using decimal value in spec (RED-62132)
+
+The workaround for this issue is to make sure you use integer values for the PVC size.
+
+### Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name
+
+The workaround is to use the newer (current) revision of the quick start document available online.
+
+## Compatibility Notes
+
+See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the full list of supported distributions.
+
+### Now supported
+
+This release adds support for the following:
+
+* K8s 1.22 for GKE, AKS, and kOps
+* OpenShift 4.9 (uses K8s 1.22)
+
+### Deprecated
+
+* Rancher 2.5/K8s 1.17 support is deprecated
+
+### No longer supported
+
+This release removes support for the following:
+
+* Rancher 2.4 (previously deprecated)
+---
+Title: Redis Enterprise for Kubernetes release notes 6.2.10-45 (July 2022)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support added for additional distributions as well as some feature improvements.
+linktitle: 6.2.10-45 (July 2022)
+weight: 61
+aliases: [
+  /operate/kubernetes/release-notes/k8s-6-2-10-45-2022-07/,
+]
+---
+## 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.
+
+The key bug fixes and known limitations are described below.
+
+## Images
+
+This release includes the following container images:
+
+* **Redis Enterprise**: `redislabs/redis:6.2.10-129` or  `redislabs/redis:6.2.10-129.rhel8-openshift` (or `redislabs/redis:6.2.10-129.rhel7-openshift` if upgrading from a RHEL7 cluster)
+* **Operator**: `redislabs/operator:6.2.10-45`
+* **Services Rigger**: `redislabs/k8s-controller:6.2.10-45` or `redislabs/services-manager:6.2.10-45` (on the Red Hat registry)
+
+## Feature improvements
+
+* OpenShift OperatorLifecycleManager support on restricted networks (RED-72968)
+* `log_collector` script uses `oc` command with automatic detection of OpenShift (RED-73215)
+* Operator uses `policy/v1` for `PodDisruptionBudget`(RED-78564)
+* Added support for Kubernetes distributions (see Compatibility notes below)
+
+## Fixed bugs
+
+* Upgrade failures when RHEL7 was used (RED-77890)
+* Log collector failures when Python2 was used (RED-73403)
+
+## API changes
+
+The `digestHash` optional field added to `imageSpec` fields in the REC. This field should be used in disconnected environments using the OperatorLifecycleManager.
+
+## Compatibility notes
+
+Below is a table showing supported distributions at the time of this release. See [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions.md" >}}) for the current list of supported distributions.
+
+| **Kubernetes version**  | 1.19       | 1.20       | 1.21       | 1.22       | 1.23       | 1.24       |
+|:------------------------|:----------:|:----------:|:----------:|:----------:|:----------:|:----------:|
+| Community Kubernetes    |            |            | deprecated | supported  | supported  | supported* |
+| Amazon EKS              | deprecated | deprecated | supported  | supported* |            |
+| Azure AKS               |            |            | deprecated | supported  | supported  |
+| Google GKE              | deprecated | deprecated | supported  | supported  |supported*  |
+| Rancher 2.6             | deprecated | deprecated | supported  | supported  |            |
+| **OpenShift version**   | **4.6**    | **4.7**    | **4.8**    | **4.9**    | **4.10**   |
+|                         |            | deprecated | deprecated | supported  | supported  |
+| **VMware TKGI version** | **1.10**   | **1.11**   | **1.12**   | **1.13**   |            |
+|                         | deprecated | deprecated | supported* | supported* |            |
+
+\* Support added in this release  
+
+### Support added
+
+* K8s community version 1.24
+
+### Deprecated
+
+* OpenShift 4.7-4.8
+* Kubernetes 1.20
+* Rancher 2.6 for K8s 1.19-1.20
+* TKGI 1.10-11
+
+### No longer supported
+
+* OpenShift 4.6 (previously deprecated)
+* Kubernetes 1.18-1.19 (previously deprecated)
+* Rancher 2.6 for K8s 1.18 (previously deprecated)
+* AKS 1.20-1.21 (previously deprecated)
+* EKS 1.18-1.19 (previously deprecated)
+* GKE 1.19 (previously deprecated)
+
+## Known limitations
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. (RED-93025)
+
+* Long cluster names cause routes to be rejected  (RED-25871)
+
+  A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name will exceed 63 characters. The workaround is to limit cluster name to 20 characters or less.
+
+* Cluster CR (REC) errors are not reported after invalid updates (RED-25542)
+  
+  A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence.
+
+* An unreachable cluster has status running (RED-32805)
+  
+  When a cluster is in an unreachable state, the state is still `running` instead of being reported as an error.
+
+* Readiness probe incorrect on failures (RED-39300)
+
+  STS Readiness probe does not mark a node as "not ready" when running `rladmin status` on node failure.
+
+* Role missing on replica sets (RED-39002)
+
+  The `redis-enterprise-operator` role is missing permission on replica sets.
+
+* Private registries are not supported on OpenShift 3.11 (RED-38579)
+
+  OpenShift 3.11 does not support DockerHub private registries. This is a known OpenShift issue.
+
+* Internal DNS and Kubernetes DNS may have conflicts (RED-37462)
+
+  DNS conflicts are possible between the cluster `mdns_server` and the K8s DNS. This only impacts DNS resolution from within cluster nodes for Kubernetes DNS names.
+
+* 5.4.10 negatively impacts 5.4.6 (RED-37233)
+
+  Kubernetes-based 5.4.10 deployments seem to negatively impact existing 5.4.6 deployments that share a Kubernetes cluster.
+
+* Node CPU usage is reported instead of pod CPU usage (RED-36884)
+
+  In Kubernetes, the node CPU usage we report on is the usage of the Kubernetes worker node hosting the REC pod.
+
+* Clusters must be named "rec" in OLM-based deployments (RED-39825)
+
+  In OLM-deployed operators, the deployment of the cluster will fail if the name is not "rec". When the operator is deployed via the OLM, the security context constraints (scc) are bound to a specific service account name (i.e., "rec"). The workaround is to name the cluster "rec".
+
+* REC clusters fail to start on Kubernetes clusters with unsynchronized clocks (RED-47254)
+
+  When REC clusters are deployed on Kubernetes clusters with unsynchronized clocks, the REC cluster does not start correctly. The fix is to use NTP to synchronize the underlying K8s nodes.
+
+* Deleting an OpenShift project with an REC deployed may hang (RED-47192)
+
+  When a REC cluster is deployed in a project (namespace) and has REDB resources, the REDB resources must be deleted first before the REC can be deleted. As such, until the REDB resources are deleted, the project deletion will hang. The fix is to delete the REDB resources first and the REC second. Afterwards, you may delete the project.
+
+* REC extraLabels are not applied to PVCs on K8s versions 1.15 or older (RED-51921)
+
+  In K8s 1.15 or older, the PVC labels come from the match selectors and not the PVC templates. As such, these versions cannot support PVC labels. If this feature is required, the only fix is to upgrade the K8s cluster to a newer version.
+
+* Hashicorp Vault integration - no support for Gesher (RED-55080)
+
+  There is no workaround at this time.
+
+* REC might report error states on initial startup (RED-61707)
+
+  There is no workaround at this time except to ignore the errors.
+
+* PVC size issues when using decimal value in spec (RED-62132)
+
+  The workaround for this issue is to make sure you use integer values for the PVC size.
+
+* Following old revision of quick start guide causes issues creating an REDB due to unrecognized memory field name (RED-69515)
+
+The workaround is to use the newer (current) revision of the quick start document available online.
+
+* `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351)
+
+  Contact support if your deployment is impacted.
+
+* Procedure to update credentials might be problematic on OpenShift when accessing the cluster externally using routes (RS issue)(RED-73251)(RED-75329)
+  To workaround this, access the API from within the K8s cluster.
+---
+Title: 6.2.18 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Release notes for the 6.2.x releases of Redis Enterprise Software for
+  Kubernetes.
+hideListLinks: true
+linkTitle: 6.2 releases
+weight: 58
+---
+## Before upgrading
+
+Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading.
+
+### Supported upgrade paths
+
+If you are using operator version 6.2.8-15 or earlier, you cannot upgrade directly to operator versions 6.2.12 through 6.4.2-5. You must upgrade to operator version 6.2.10-45 before you can upgrade to operator versions between 6.2.12 and 6.4.2-5. However, upgrades directly to operator version 6.4.2-6 are supported.
+  
+### OpenShift versions 6.2.12 or earlier
+
+Due to a change in the SCC, on OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later, where `node:1` is <b>not</b> the master node, the upgrade might get stuck.
+
+For more info and steps to prevent this issue, see [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}).
+
+Operator version 6.4.2-6 includes a fix for this issue.
+
+### Large clusters
+
+On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. 
+
+{{<table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: Control node selection
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how Redis Enterprise cluster
+  pods can be scheduled to only be placed on specific nodes or node pools.
+linkTitle: Node selection
+weight: 80
+---
+
+Many Kubernetes cluster deployments have different kinds of nodes that have
+different CPU and memory resources available for scheduling cluster workloads.
+Redis Enterprise for Kubernetes has various abilities to control the scheduling
+Redis Enterprise cluster node pods through properties specified in the
+Redis Enterprise cluster custom resource definition (CRD).
+
+A Redis Enterprise cluster (REC) is deployed as a StatefulSet which manages the Redis Enterprise cluster node pods.
+The scheduler chooses a node to deploy a new Redis Enterprise cluster node pod on when:
+
+- The cluster is created
+- The cluster is resized
+- A pod fails
+
+Here are the ways that you can control the pod scheduling:
+
+## Using node selectors
+
+The [`nodeSelector`]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#spec">}})
+property of the cluster specification uses the same values and structures as
+the [Kubernetes `nodeSelector`](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector).
+In general, node labels are a simple way to make sure that specific nodes are used for Redis Enterprise pods.
+For example, if nodes 'n1' and 'n2' are labeled as "high memory":
+
+```sh
+kubectl label nodes n1 memory=high
+kubectl label nodes n2 memory=high
+```
+
+The Redis Enterprise cluster CRD can request to be scheduled on these nodes:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     memory: high
+```
+
+Then, when the operator creates the StatefulSet associated with the pod, the nodeSelector
+section is part of the pod specification. When the scheduler attempts to
+create new pods, it needs to satisfy the node selection constraints.
+
+
+## Using node pools
+
+A node pool is a common part of the underlying infrastructure of the Kubernetes cluster deployment and provider.
+Often, node pools are similarly-configured classes of nodes such as nodes with the same allocated amount of memory and CPU.
+Implementors often label these nodes with a consistent set of labels.
+
+On Google Kubernetes Engine (GKE), all node pools have the label `cloud.google.com/gke-nodepool` with a value of the name used during configuration.
+On Microsoft Azure Kubernetes System (AKS), you can create node pools with a specific set of labels. Other managed cluster services may have similar labeling schemes.
+
+You can use the `nodeSelector` section to request a specific node pool by label values. For example, on GKE:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     cloud.google.com/gke-nodepool: 'high-memory'
+```
+
+## Using node taints
+
+You can use multiple node taints with a set of tolerations to control Redis Enterprise cluster node pod scheduling.
+The `podTolerations` property of the cluster specification specifies a list of pod tolerations to use.
+The value is a list of [Kubernetes tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/#concepts).
+
+For example, if the cluster has a single node pool, the node taints can control the allowed workloads for a node.
+You can add taints to the node, for example nodes n1, n2, and n3, reserve a set of nodes for the Redis Enterprise cluster:
+
+```sh
+kubectl taint nodes n1 db=rec:NoSchedule
+kubectl taint nodes n2 db=rec:NoSchedule
+kubectl taint nodes n3 db=rec:NoSchedule
+```
+
+This prevents any pods from being scheduled onto the nodes unless the pods can tolerate the taint `db=rec`.
+
+You can then add the toleration for this taint to the cluster specification:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podTolerations:
+  - key: db
+    operator: Equal     
+    value: rec
+    effect: NoSchedule
+```
+
+A set of taints can also handle more complex use cases.
+For example, a `role=test` or `role=dev` taint can be used to designate a node as dedicated for testing or development workloads via pod tolerations.
+
+## Using pod anti-affinity
+
+By default, the Redis Enterprise node pods are not allowed to be placed on the same node for the same cluster:
+
+```yaml
+podAntiAffinity:
+  requiredDuringSchedulingIgnoredDuringExecution:
+  - labelSelector:
+      matchLabels:
+        app: redis-enterprise
+        redis.io/cluster: rec
+        redis.io/role: node
+    topologyKey: kubernetes.io/hostname
+```
+
+Each pod has the three labels above where `redis.io/cluster` is the label for the name of your cluster.
+
+You can change this rule to restrict or include nodes that the Redis Enterprise cluster node pods can run on.
+For example, you can delete the `redis.io/cluster` label so that even Redis Enterprise node pods from different clusters cannot be scheduled on the same Kubernetes node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          app: redis-enterprise
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+or you can prevent Redis Enterprise nodes from being schedule with other workloads.
+For example, if all database workloads have the label 'local/role: database', you
+can use this label to avoid scheduling two databases on the same node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  extraLabels:
+     local/role: database
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          local/role: database
+          app: redis-enterprise
+          redis.io/cluster: rec
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+In this case, any pods that are deployed with the label `local/role: database` cannot be scheduled on the same node.
+
+
+## Using rack awareness
+
+You can configure Redis Enterprise with rack-zone awareness to increase availability
+during partitions or other rack (or region) related failures.
+
+{{%note%}}When creating your rack-zone ID, there are some constraints to consider; see [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness#rack-zone-id-rules" >}}) for more info. {{%/note%}}
+
+
+Rack-zone awareness is a single property in the Redis Enterprise cluster CRD named `rackAwarenessNodeLabel`.
+This value for this label is commonly `topology.kubernetes.io/zone` as documented in
+['Running in multiple zones'](https://kubernetes.io/docs/setup/best-practices/multiple-zones/#nodes-are-labeled).
+
+You can check the value for this label in your nodes with the command:
+
+```sh
+$kubectl get nodes -o custom-columns="name:metadata.name","rack\\zone:metadata.labels.failure-domain\.beta\.kubernetes\.io/zone"
+
+name                                            rack\zone
+ip-10-0-x-a.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-b.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-c.eu-central-1.compute.internal    eu-central-1b
+ip-10-0-x-d.eu-central-1.compute.internal    eu-central-1b
+```
+
+### Enabling the cluster role
+
+For the operator to read the cluster node information, you must create a cluster role for the operator and then bind the role to the service account.
+
+Here's a cluster role:
+
+```yaml
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+rules:
+  # needed for rack awareness
+  - apiGroups: [""]
+    resources: ["nodes"]
+    verbs: ["list", "get", "watch"]
+```
+
+And here's how to apply the role:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role.yaml
+```
+
+The binding is typically to the `redis-enterprise-operator` service account:
+
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+subjects:
+- kind: ServiceAccount
+  namespace: OPERATOR_NAMESPACE
+  name: redis-enterprise-operator
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator
+  apiGroup: rbac.authorization.k8s.io
+```
+
+and it can be applied by running:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role_binding.yaml
+```
+
+Once the cluster role and the binding have been applied, you can configure Redis Enterprise clusters to use rack awareness labels.
+
+### Configuring rack awareness
+
+You can configure the node label to read for the rack zone by setting the `rackAwarenessNodeLabel` property:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  nodes: 3
+  rackAwarenessNodeLabel: topology.kubernetes.io/zone
+```
+
+{{< note >}}
+When you use the `rackAwarenessNodeLabel` property, the operator will change the topologyKey for the anti-affinity rule to the label name used unless you have specified the `podAntiAffinity` property as well. If you use `rackAwarenessNodeLabel` and `podAntiAffinity` together, you must make sure that the `topologyKey` in your pod anti-affinity rule is set to the node label name.
+{{< /note >}}
+---
+Title: Size and scale a Redis Enterprise cluster deployment on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about sizing and scaling Redis Enterprise
+  in a Kubernetes deployment.
+linkTitle: Sizing and scaling
+weight: 50
+---
+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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/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.
+
+    spec:
+
+        nodes: 3
+
+The number of nodes in the cluster must be an uneven number
+equal to or greater than 3. Refer to the article [Highly Available Redis](https://redislabs.com/redis-enterprise/technology/highly-available-redis/)
+for a detailed explanation on this topic.
+
+Set the number of cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling out
+
+To scale out a Redis Enterprise Cluster deployment, increase the number of nodes
+in the spec. For example, to scale the cluster out from 3 nodes to 5 nodes,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+    spec:
+
+        nodes: 5
+
+To apply the new cluster configuration run:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{<warning>}} Decreasing the number of nodes is not supported.{{</warning>}}
+
+### Sizing compute resources
+
+To set the compute resources required for each node,
+use the redisEnterpriseNodeResources spec field.
+
+Under redisEnterpriseNodeResources spec, set the following fields
+according to the provided guidelines.
+
+- limits – specifies the maximum compute resources for a Redis node
+- requests – specifies the minimum compute resources for a Redis node
+
+For example:
+
+    redisEnterpriseNodeResources:
+
+        limits:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+        requests:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+The default values, if unspecified, are 2 cores (2000m) and 4GB (4Gi).
+
+Set the compute resources for cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling up node compute resources
+
+To scale up nodes in an existing Redis Enterprise Cluster deployment,
+adjust the cpu and memory parameters in the spec. For example,
+to scale nodes up to the recommended amount of compute resources,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+redisEnterpriseNodeResources:
+
+    limits:
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+    requests
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+Then, apply the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{< warning >}}
+When adjusting compute resources, make sure the ratio of persistent volume size and the new memory size are in accordance to the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}). 
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/re-clusters/expand-pvc">}}) for details.
+{{< /warning >}}
+---
+Title: Manage node resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Recommendations on managing node resources and setting eviction thresholds
+  with Redis Enterprise for Kubernetes.
+linktitle: Manage resources
+weight: 17
+---
+ 
+
+
+## Node eviction thresholds
+
+ Kubernetes uses [node-pressure eviction](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/) to terminate pods and free up node resources. Redis Enterprise for Kubernetes works best when you use the recommendations below.
+
+Eviction thresholds are managed by [kubelet arguments](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/).
+
+Redis recommends setting a high [soft eviction threshold](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds). This changes the node condition early enough to alert the administrator.
+
+We also recommend setting the [`eviction-soft-grace-period`](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds) high enough for the administrator to scale the cluster.
+
+For more information about configuring eviction thresholds on specific platforms, see [Freeing node resources](https://docs.openshift.com/container-platform/4.9/nodes/nodes/nodes-nodes-garbage-collection.html) for OpenShift or [Cluster architecture](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable) for GKE.
+
+### Monitor node conditions
+
+Redis recommends monitoring the node conditions. If both `MemoryPressure` and `DiskPressure` are true, the eviction threshold was met.
+
+```sh
+> kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+
+For more information about monitoring node conditions, see [Node conditions](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#node-conditions) on [kubernetes.io](https://kubernetes.io/docs/home/).
+
+## Resource quotas
+
+Kubernetes uses the `ResourceQuota` object to limit resource consumption per namespace. This lets you limit the number of objects created by a namespace or the amount of compute resources consumed by a namespace. 
+
+The resource settings for Redis Enterprise for Kubernetes are defined in the `operator.yaml` and the [`RedisEnterpriseCluster`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#redisenterpriseclusterspec) custom resource.
+
+The following settings are the minimum workloads for the operator to function.
+
+```yaml
+  resources:
+    limits:
+      cpu: 0.5
+      memory: 256Mi
+    requests:
+      cpu: 0.5
+      memory: 256Mi
+```
+For more details on using resource quotas, see the [Kubernetes documentation](https://kubernetes.io/docs/concepts/policy/resource-quotas/).
+
+
+---
+Title: Use persistent volumes in Redis Enterprise clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section covers details about how persistent volumes are sized and
+  specified for Redis Enterprise cluster deployments.
+linkTitle: Persistent volumes
+weight: 40
+---
+## 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.
+
+{{<warning>}}
+NFS, NFS-like, and multi-read-write/shared storage options are not supported. These types of storage are often slow and can cause locking behaviors that are incompatible with the requirements of database storage.
+{{</warning>}}
+
+## REC `persistentSpec` field 
+To deploy a Redis Enterprise cluster with Redis Enterprise operator the
+spec should include a *persistentSpec* section, in the
+*redis-enterprise-cluster.yaml* file:
+
+    spec:
+      nodes: 3
+      persistentSpec:
+       enabled: true
+       storageClassName: "standard"
+       volumeSize: "23Gi” #optional
+
+Persistence storage is a requirement for production deployments.
+
+{{< note >}}
+For **production deployments** of Redis Enterprise Cluster on Kubernetes,
+the Redis Enterprise Cluster (REC) must be deployed with persistence enabled.
+The REC deployment files in the [Kubernetes documentation](https://github.com/RedisLabs/redis-enterprise-k8s-docs) contain this declaration by default.
+{{< /note >}}
+
+## Volume size
+
+*volumeSize* is an optional definition. By default, if the definition is
+omitted, operator allocates five times (5x) the amount of memory (RAM)
+defined for nodes (see example below), which is the recommended
+persistent storage size as described in the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}) article.
+
+To explicitly specify the persistent storage size, use the *volumeSize*
+property as described in the example above.
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/re-clusters/expand-pvc">}}) for details.
+
+{{< note >}}
+We recommend that you omit the volumeSize definition from the REC declaration
+so that the Redis Enterprise Cluster deployment on Kubernetes use the default volume size.
+{{< /note >}}
+
+## Storage class name
+
+*storageClassName* determines the Storage Class resource, which is
+defined by the Kubernetes cluster administrator, to be used for
+persistent storage.
+
+Different Kubernetes distributions and different deployments use
+different Storage Class resources.
+
+In order to determine the Storage Class resources available for your K8s
+deployment, use the following command:
+
+    kubectl get StorageClass
+
+Typically, AWS provides “gp2” as the Storage Class name while GKE uses “standard.”
+Azure provides two Storage Classes: "default" using HDDs, and "managed-premium" using SSDs.
+
+Below is an example of a response to the command.
+
+|                         |                                                         |
+| ----------------------- | ------------------------------------------------------- |
+| *Name:*                 | *gp2*                                                   |
+| *IsDefaultClass:*       | *Yes*                                                   |
+| *Annotations:*          | *storageclass.beta.kubernetes.io/is-default-class=true* |
+| *Provisioner:*          | *kubernetes.io/aws-ebs*                                 |
+| *Parameters:*           | *encrypted=false,kmsKeyId=,type=gp2*                    |
+| *AllowVolumeExpansion:* | *\<unset\>*                                             |
+| *MountOptions:*         | *\<none\>*                                              |
+| *ReclaimPolicy:*        | *Delete*                                                |
+| *VolumeBindingMode:*    | *Immediate*                                             |
+| *Events:*               | *\<none\>*                                              |
+
+{{< note >}}
+storageClassName must be specified for this deployment type.
+{{< /note >}}
+
+{{< warning >}}
+The storage class cannot be changed after deployment. Trying to change this value after deployment could result in unexpected and potentially damaging behavior.
+{{< /warning >}}
+
+Example of the redisEnterpriseNodeResources definition:
+
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: “4000m”
+        memory: 4Gi
+      requests:
+        cpu: “4000m”
+        memory: 4Gi
+---
+Title: Manage pod stability
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how you can use quality of service,
+  priority class, eviction thresholds and resource monitoring to maintain cluster
+  node pod stability.
+linkTitle: Pod stability
+weight: 90
+---
+
+Kubernetes clusters manage the allocation of system resources and can evict pods to release system resources.
+Here are some ways that you can configure the Redis Enterprise node pods to maintain pod stability:
+
+## Guaranteed quality of service
+
+A running pod has a quality of service measure assigned to it that is
+one of three [quality of service classes](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/):
+Guaranteed, Burstable, and Best Effort.
+You can assure the Guaranteed class is assigned to the Redis Enterprise node pods
+by following the right guidelines.
+
+To get a Guaranteed quality of service class assigned:
+
+ * Every container in the pod must have a memory limit and a memory request, and they must be the same.
+ * Every container in the pod must have a CPU limit and a CPU request, and they must be the same.
+
+If resources limits and requests are not specified in the Redis Enterprise CRD,
+these requirements are met in the default version created by the operator. of your Redis Enterprise cluster CRD,
+Otherwise, you must set the limits and requests to the same value for memory and CPU in the `redisEnterpriseNodeResources`
+section of the CRD.
+
+Sidecar containers also impact the quality of service class assignment for the pod.
+
+To check the quality of service class of any running Redis Enterprise node pod, run:
+
+```sh
+kubectl get pod rec-0 --o jsonpath="{.status.qosClass}"
+```
+
+where `rec-0` is the name of one of the pods associated with the Redis Enterprise cluster.
+
+## Using priority to protect from preemption
+
+When a Redis Enterprise node pod is scheduled, it can be assigned a
+[priority class](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/)
+with the `priorityClassName` property. This property value is the name of
+a priority class that must already exist within the cluster.
+
+A sufficiently high priority will prevent other workloads with a lower
+priority from preempting the scheduling of Redis Enterprise Nodes. Similarly,
+a high value may also prevent eviction when lower priority workloads
+are deployed on the same cluster.
+
+The successful use of this strategy involves first creating a priority class with a very large priority value:
+
+```yaml
+apiVersion: scheduling.k8s.io/v1
+kind: PriorityClass
+metadata:
+  name: redis-enterprise-priority
+value: 1000000000
+globalDefault: false
+description: "This priority class should be used for Redis Enterprise pods only."
+```
+
+Then, you refer to the priority class by name in your Redis Enterprise cluster CRD:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  size: 3
+  priorityClassName: "redis-enterprise-priority"
+```
+
+Alternatively, you can also [disable preemption entirely](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#how-to-disable-preemption).
+
+## Managing eviction thresholds
+
+Eviction thresholds are typically managed by kubelet arguments.
+You can set the thresholds:
+
+- On OpenShift - In the [config file](https://docs.openshift.com/container-platform/3.11/admin_guide/out_of_resource_handling.html#out-of-resource-create-config).
+- On GKE - In the [managed settings](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable).
+
+We recommend that you:
+
+ * Set the [soft eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#soft-eviction-thresholds)
+   to be higher than the [hard eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#hard-eviction-thresholds).
+   The high soft threshold makes the node condition change earlier, and alerts the administrator.
+ * Set `eviction-max-pod-grace-period` high enough to allow the RS pods to migrate the Redis databases before the pods are force killed.
+ * Set the `eviction-soft-grace-period` high enough that the administrator (or a k8s auto-scaling mechanism) scales k8s up or out.
+
+## Monitoring for memory and disk usage
+
+We recommend that you monitor the node for MemoryPressure and DiskPressure.
+When both of these conditions are true, then an [eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#eviction-thresholds)
+is met and the pod is evicted.
+
+To retrieve the flags, run the command:
+
+```sh
+$kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+---
+Title: Configuration recommendations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Settings and configuration recommendations for your Redis Enterprise
+  deployment.
+hideListLinks: false
+linkTitle: Recommendations
+weight: 80
+---
+
+This section contains  recommended settings and configuration for your Redis Enterprise for Kubernetes deployment.
+
+
+
+---
+Title: Flexible deployment options
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces.
+  This article describes flexible deployment options you can use to meet your specific
+  needs.
+linkTitle: Deployment options
+---
+You can deploy Redis Enterprise for Kubernetes in several different ways depending on your database needs.
+
+Multiple RedisEnterpriseDatabase (REDB) resources can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces.
+
+The Redis Enterprise cluster (REC) custom resource must reside in the same namespace as the Redis Enterprise operator.
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Single REC and single namespace (one-to-one)
+
+The standard and simplest deployment deploys your Redis Enterprise databases (REDB) in the same namespace as the Redis Enterprise cluster (REC). No additional configuration is required for this, since there is no communication required to cross namespaces. See [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/deployment/quick-start" >}}).
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-one.png" >}}
+
+## Single REC and multiple namespaces (one-to-many)
+
+Multiple Redis Enterprise databases (REDB) spread across multiple namespaces within the same K8s cluster can be associated with the same Redis Enterprise cluster (REC). See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/re-clusters/multi-namespace" >}}) for more information.
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-many.png" >}}
+
+## Multiple RECs and multiple namespaces (many-to-many)
+
+A single Kubernetes cluster can contain multiple Redis Enterprise clusters (REC), as long as they reside in different namespaces. Each namespace can host only one REC and each operator can only manage one REC.
+
+You have the flexibility to create databases in separate namespaces, or in the same namespace as the REC, or combine any of the supported deployment options above. This configuration is geared towards use cases that require multiple Redis Enterprise clusters with greater isolation or different cluster configurations.
+
+See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/re-clusters/multi-namespace" >}}) for more information.
+
+
+{{< image filename="/images/k8s/k8s-deploy-many-to-many.png" >}}
+
+## Unsupported deployment patterns
+
+### Cross-cluster operations
+
+Redis Enterprise for Kubernetes does not support operations that cross Kubernetes clusters. Redis Enterprise clusters (REC) work inside a single K8s cluster. Crossing clusters could result in functional and security issues.
+
+{{< image filename="/images/k8s/k8s-deploy-cross-namespaces.png" >}}
+
+### Multiple RECs in one namespace
+
+Redis Enterprise for Kubernetes does not support multiple Redis Enterprise clusters (REC) in the same namespace. Creating more than one REC in the same namespace will result in errors.
+
+{{< image filename="/images/k8s/k8s-deploy-multicluster-antipattern.png" >}}
+---
+Title: Redis Enterprise for Kubernetes architecture
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Overview of the architecture and components of Redis Enterprise for Kubernetes.
+hideListLinks: true
+linkTitle: Architecture
+weight: 1
+aliases: [operate/kubernetes/architecture/operator]
+---
+
+Redis Enterprise for Kubernetes gives you the speed and durability of [Redis Enterprise](https://redis.io/redis-enterprise/advantages/), with the flexibility and ease of [Kubernetes (K8s)](https://kubernetes.io/). Redis Enterprise for Kubernetes uses the Kubernetes operator pattern and custom controllers to bring the best of Redis Enterprise to the Kubernetes platform.
+
+## Lifecycle
+
+Kubernetes is a rapidly evolving platform with a short release cycle (around 4 months). This frequent influx of new features, enhancements and bug fixes means Kubernetes distributions move in and out of support quickly. Redis Enterprise is also a fast-moving product, and is compatible and tested only on distributions listed as [supported distributions.]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}})
+
+Each version of Redis Enterprise for Kubernetes is tested to ensure the version of Redis Enterprise works with the [supported Kubernetes distributions]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}}) at the time. Both the Kubernetes version and the Redis Enterprise version must be supported for the operator to function correctly. We encourage you to upgrade Redis Enterprise for Kubernetes frequently, not only to get the benefit of enhancements and bug fixes, but to keep your software supported.
+
+Supported platforms are listed in the [release notes]({{<relref "/operate/kubernetes/release-notes">}}) and in the [supported platforms reference.]({{<relref "/operate/kubernetes/reference/supported_k8s_distributions">}})
+
+## Architecture
+
+The image below illustrates the components of a single namespace, three node deployment.
+
+{{< image filename="/images/k8s/k8s-arch-v4.png" >}}
+
+## Operator
+
+An [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is a custom extension of the Kubernetes API designed to manage complex, stateful applications and their components. This operator pattern is commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. Kubernetes.io/docs has a great explanation of the [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/).
+
+The operator is a deployment that runs within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) and uses [controllers](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) to manage [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/), ensuring these resources are continuously monitored and maintained.
+
+When the operator is installed, the following resources are created:
+
+- [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) under which the operator will run
+- set of [roles](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole) to define the privileges necessary for the operator to perform its tasks
+- set of [role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-and-clusterrolebinding) to authorize the service account
+- [CustomResourceDefinition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for each Redis Enterprise custom resource
+- the operator deployment
+
+## Namespace
+
+The Redis Enterprise [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is deployed within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each namespace can host only one operator and one [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec). Namespaces create logical boundaries between resources, allowing organization and security. Some resources are limited to a namespace, while others are cluster-wide.
+
+Redis Enterprise for Kubernetes also supports [multi-namespace deployments]({{<relref "/operate/kubernetes/architecture/deployment-options">}}), meaning the operator can monitor other namespaces (that host applications) for custom resources and apply any changes.
+
+## Custom resources
+
+Kubernetes [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) are commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. [Custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) extend the Kubernetes API, enabling users to manage Redis databases the Kubernetes way. Custom resources are created and managed using YAML configuration files.
+
+This [declarative configuration approach](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/) allows you to specify the desired state for your resources, and the operator makes the necessary changes to achieve that state. This simplifies [installation]({{<relref "/operate/kubernetes/deployment">}}), [upgrades]({{<relref "/operate/kubernetes/upgrade">}}), and [scaling]({{<relref "/operate/kubernetes/recommendations/sizing-on-kubernetes">}}) both vertically and horizontally.
+
+The operator continuously monitors CRs for changes, automatically reconciling any differences between the desired state you specified in your YAML configuration file, and the actual state of your resources. Custom resources can also reside in separate namespaces from the operator managing them, such as in [multi-namespace installations]({{<relref "/operate/kubernetes/re-clusters/multi-namespace">}}).
+
+## Custom resource definitions
+
+A [custom resource definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) is a cluster-wide resource that specifies which settings can be configured via custom resource files. Any setting not defined by the CRD is not managed by the operator. You can still make changes to these unmanaged settings using standard Redis Enterprise Software methods.
+
+For settings managed by the operator, any changes made outside of the CR YAML files (e.g., through the management UI) will be overwritten by the operator. Ensure that all operator-managed settings are updated using the CR YAML files to prevent conflicts.
+
+## RedisEnterpriseCluster REC
+
+A Redis Enterprise cluster is a set of Redis Enterprise nodes pooling resources. Each node is capable of running multiple Redis instances ([shards]({{<relref "/operate/rs/references/terminology">}})).
+
+{{< image filename="/images/k8s/k8s-node-arch.png">}}
+
+A Redis cluster is created and managed by the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REC configuration file prompt the operator to make changes to the cluster. The REC is required for both standard databases ([REDB](#redisenterprisedatabase-redb)) and Active-Active databases ([REAADB](#redisenterpriseactiveactivedatabase-reaadb)).
+
+See the [RedisEnterpriseCluster API Reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseDatabase REDB
+
+A Redis Enterprise database is a logical entity that manages your entire dataset across multiple Redis instances. A Redis instance is a single-threaded database process ([commonly referred to as a shard]({{<relref "/operate/rs/references/terminology">}})).
+
+Redis databases are created and managed by the [RedisEnterpriseDatabase (REDB)]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api">}}) [custom resource (CR)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REDB YAML configuration file prompt the operator to make changes to the database.
+
+An operator can manage a database in the same namespace, or a different namespace. See ["Flexible deployment"]({{<relref "/operate/kubernetes/architecture/deployment-options">}}) options and ["Manage databases in multiple namespaces"]({{<relref "/operate/kubernetes/re-clusters/multi-namespace">}}) for more information.
+
+See the [RedisEnterpriseDatabase (REDB) API Reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api">}}) for a full list of fields and settings.
+
+## Security
+
+Redis Enterprise for Kubernetes uses [secrets](https://kubernetes.io/docs/concepts/configuration/secret/) to manage your cluster credentials, cluster certificates, and client certificates. You can configure [LDAP]({{<relref "/operate/kubernetes/security/ldap">}}) and [internode encryption]({{<relref "/operate/kubernetes/security/internode-encryption">}}) using the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec) spec.
+
+### REC credentials
+
+Redis Enterprise for Kubernetes uses the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) to create a Redis Enterprise cluster. During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+See [Manage REC credentials]({{<relref "/operate/kubernetes/security/manage-rec-credentials">}}) for more details.
+
+### REC certificates
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes in the cluster.
+
+See [Manage REC certificates]({{<relref "/operate/kubernetes/security/manage-rec-certificates">}}) for more details.
+
+### Client certificates
+
+For each client certificate you want to use, you need to create a [Kubernetes secret](https://kubernetes.io/docs/concepts/configuration/secret/) to hold it. You can then reference that secret in your [Redis Enterprise database (REDB)](#redisenterprisedatabase-redb) custom resource.
+
+See [Add client certificates]({{<relref "/operate/kubernetes/security/add-client-certificates">}}) for more details.
+
+## Storage
+
+[Persistent storage is mandatory for Redis Enterprise.]({{<relref "operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage">}}) Redis Enterprise for Kubernetes [requires network-attached storage](https://en.wikipedia.org/wiki/Network-attached_storage).
+
+Redis Enterprise for Kubernetes uses [PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) to manage storage resources. The PVC is an abstract representation of the [PersistentVolume (PV)](https://kubernetes.io/docs/concepts/storage/persistent-volumes) resources used by your Redis pods. PVCs are created by the Redis Enterprise operator and used by the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec).
+
+PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims), if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+### Auto Tiering
+
+Redis Enterprise Software for Kubernetes supports [Auto Tiering]({{<relref "/operate/kubernetes/re-clusters/auto-tiering">}}) (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+
+## Networking
+
+By default, Kubernetes doesn't allow you to access your Redis database from outside your K8s cluster. Redis Enterprise for Kubernetes supports several ways to route external traffic to your [Redis Enterprise cluster (REC)](#redisenterprisecluster-rec):
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/networking/routes" >}}) to route external traffic.
+
+The [Active-Active databases](#active-active-databases) require one of above routing methods to be configured in the REC with the [ingressOrRouteSpec field]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#specingressorroutespec">}}).
+
+## Services Rigger
+
+The services rigger is responsible for creating and updating services related to database objects. It identifies database objects within the cluster and creates services in accordance with [`redisEnterpriseCluster.Spec.servicesRiggerSpec` setting]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api#specservicesriggerspec">}}) to allow access to those databases. By default, each database has two services, a `cluster_ip` Service with the same name as the database and a `headless` Service with the same name as the database suffixed with `-headless`. It also creates other types of Services such as Ingress Services or OpenshiftRoutes (defined in `redisEnterpriseCluster.Spec.ingressOrRouteSpec`) meant to provide access to REAADB objects.
+
+You can view a list of services with the `kubectl get services` command.
+
+Kubernetes is a dynamic environment, with nodes and pods changing as needed. The services rigger monitors the cluster for these changes and updates the database services to ensure reliable communication with the databases.
+
+## Active-Active databases
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters. Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.The admission controller is also required for Active-Active databases on Kubernetes, to validate changes to the custom resources.
+
+For more details and installation information, see [Active-Active databases]({{<relref "/operate/kubernetes/active-active/">}}). For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+## RedisEnterpriseRemoteCluster RERC
+
+The [RedisEnterpriseRemoteCluster (RERC)]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}) contains details allowing the REC to link to the RedisEnterpriseActiveActiveDatabase (REAADB). The RERC resource is listed in the [REAADB](#redisenterpriseactiveactivedatabase-reaadb) resource to become a participating cluster for the Active-Active database.
+
+See the [RERC API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_remote_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseActiveActiveDatabase REAADB
+
+The RedisEnterpriseActiveActiveDatabase (REAADB) resource creates and manages a database that spans more than one Kubernetes cluster. An REAADB requires [external routing](#networking), at least two [RECs](#redisenterprisecluster-rec), and at least two [RERCs](#redisenterpriseremotecluster-rerc).
+
+See the [REAADB API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_active_active_database_api">}}) for a full list of fields and settings.
+
+## Metrics
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can [connect your Prometheus]({{<relref "/operate/kubernetes/re-clusters/connect-prometheus-operator">}}) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+---
+Title: Collect logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Run the log collector script to package relevant logs into a tar.gz file
+  to send to Redis Support for help troubleshooting your Kubernetes environment.
+linkTitle: Collect logs
+weight: 89
+---
+
+The Redis Enterprise cluster (REC) log collector script ([`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py)) creates and fills a directory with the relevant logs for your environment. These logs will help the support team with troubleshooting.
+
+As of version 6.2.18-3, the log collector tool has two modes:
+
+- **restricted** collects only resources and logs created by the operator and Redis Enterprise deployments
+  - This is the default for versions 6.2.18-3 and later
+- **all** collects everything from your environment
+  - This is the default mode for versions 6.2.12-1 and earlier
+
+{{<note>}} This script requires Python 3.6 or later. {{</note>}}
+
+1. Download the latest [`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py) file.
+
+1. Have a K8s administrator run the script on the system that runs your `kubectl` or `oc` commands.
+    - Pass `-n` parameter to run on a different namespace than the one you are currently on
+    - Pass `-m` parameter to change the log collector mode (`all` or `restricted`)
+    - Run with `-h` to see more options
+
+    ```bash
+    python log_collector.py 
+    ```
+
+   {{< note >}} If you get an error because the yaml module is not found, install the pyYAML module with `pip install pyyaml`.
+  {{< /note >}}
+
+
+
+1. Upload the resulting `tar.gz` file containing all the logs to [Redis Support](https://support.redislabs.com/).
+---
+Title: Redis Enterprise Software logs on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how logs are stored and accessed.
+hideListLinks: true
+linkTitle: Logs
+weight: 60
+---
+
+## Logs
+
+Each redis-enterprise container stores its logs under `/var/opt/redislabs/log`.
+When using persistent storage this path is automatically mounted to the
+`redis-enterprise-storage` volume.
+This volume can easily be accessed by a sidecar, i.e. a container residing on the same pod.
+
+For example, in the REC (Redis Enterprise Cluster) spec you can add a sidecar container, such as a busybox, and mount the logs to there:
+
+```yaml
+sideContainersSpec:
+  - name: busybox
+    image: busybox
+    args:
+      - /bin/sh
+      - -c
+      - while true; do echo "hello"; sleep 1; done
+
+    volumeMounts:
+    - name: redis-enterprise-storage
+      mountPath: /home/logs
+      subPath: logs
+```
+
+Now the logs can be accessed from in the sidecar. For example by running
+
+```kubectl exec -it <pod-name> -c busybox tail home/logs/supervisord.log```
+
+The sidecar container is user determined and can be used to format, process and share logs in a specified format and protocol.
+---
+Title: Use a private registry for container images
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section details how the Redis Enterprise Software and Kubernetes
+  operator images can be configured to be pulled from a variety of sources. This page
+  describes how to configure alternate private repositories for images, plus some
+  techniques for handling public repositories with rate limiting.
+linktitle: Use a private container registry
+weight: 92
+---
+
+Redis Enterprise Software, its Kubernetes operator, and the Service Rigger
+are all distributed as separate container images.
+Your Kubernetes deployment will pull these images as needed.
+ You can control where these images are
+pulled from within the operator deployment and also via the
+Redis Enterprise custom resources.
+
+In general, images for deployments that do not have a registry domain
+name (e.g., `gcr.io` or `localhost:5000`) are pulled from the default registry associated
+with the Kubernetes cluster. A plain reference to `redislabs/redis` will likely pull from DockerHub
+(except on OpenShift where it pulls from Red Hat).
+
+For security reasons (e.g., in air-gapped environments), you may want to pull the images
+from a public registry once and then push them to a private registry under
+your control.
+
+{{<warning>}}It is very important that the images you are pushing to the private registry have the same exact version tag as the original images. {{</warning>}}
+
+Furthermore, because [Docker rate limits public pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/),
+you may want to consider pulling images from a
+private registry to avoid deployment failures when you hit your DockerHub rate limit.
+
+The information below will help you track and configure where your deployments pull container images.
+
+{{< note >}}
+**IMPORTANT**
+* Each version of the Redis Enterprise operator is mapped to a specific version of Redis Enterprise Software. The semantic versions always match (for example, 7.2.4), although the specific release numbers may be different (for example, 7.2.4-7 is the operator version for Redis Enterprise Software 7.2.4-64).
+* A specific operator version only supports a specific Redis Enterprise version. Other combinations of operator and Redis Enterprise versions are **not supported**.
+{{< /note >}}
+
+
+## Find container sources
+
+Every pod in your deployed application has a source registry. Any image not prefixed by a registry domain name (e.g., "gcr.io") will pull from the default registry for the Kubernetes cluster (i.e., DockerHub). You can use the commands below to discover the pull sources for the images on your cluster.
+
+To list all the images used by your cluster:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c
+```
+
+To specifically determine the pull source for the Redis Enterprise operator itself, run the following command:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c | grep redislabs
+```
+
+You can limit this command to specific namespaces by replacing the `--all-namespaces` parameter with
+a set of `-n {namespace}` parameters, where each `{namespace}` is a specific
+namespace of interest on your cluster.
+
+## Create a private container registry
+
+You can set up a private container registry in a couple of ways:
+
+* On-premise via [Docker registry](https://docs.docker.com/registry/deploying/), [Red Hat Quay](https://www.redhat.com/en/technologies/cloud-computing/quay), or other providers
+* Cloud provider based registries (e.g., Azure Container Registry, Google Container Registry, etc.).
+
+Once you have set up a private container registry, you will identify the container registry using:
+
+* A domain name
+* A port (optional)
+* A repository path (optional)
+
+## Push images to a private container registry
+
+Important images for a Redis Enterprise Software deployment include:
+
+* Redis Enterprise Software
+* Bootstrapping a Redis Enterprise cluster node (in the operator image)
+* The Service Rigger
+* The Redis Enterprise Software operator
+
+You will need to push all these images to your private container registry. In general,
+to push the images you must:
+
+ 1. [Pull](https://docs.docker.com/engine/reference/commandline/pull/) the various images locally for the Redis Enterprise Software, the Service Rigger, and the operator.
+ 2. Tag the local images with the private container registry, repository, and version tag.
+ 3. [Push](https://docs.docker.com/engine/reference/commandline/push/) the newly tagged images.
+
+The example below shows the commands for pushing the images for Redis Enterprise Software and its operator to a private container registry:
+
+```sh
+PRIVATE_REPO=...your repo...
+RS_VERSION=7.2.4-64
+OPERATOR_VERSION=7.2.4-7
+docker pull redislabs/redis:${RS_VERSION}
+docker pull redislabs/operator:${OPERATOR_VERSION}
+docker pull redislabs/k8s-controller:${OPERATOR_VERSION}
+docker tag redislabs/redis:${RS_VERSION} ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker tag redislabs/operator:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker tag redislabs/k8s-controller:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+```
+
+## Configure deployments to use a private container registry
+
+Once you push your images to your private container registry, you need to
+configure your deployments to use that registry for Redis Enterprise Software and operator
+deployments. The operator container image is configured directly by the operator deployment
+bundle. The Redis Enterprise cluster pod (RS and bootstrapper) and Service Rigger
+images are configured in the Redis Enterprise custom resource.
+
+Depending on your Kubernetes platform, your private container registry may
+require authentication. If you do need authentication, add a [pull secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) to your namespace. Then you'll need to configure Kubernetes and the operator to use the pull secret. The two following sections have examples of adding the `imagePullSecrets` to the operator deployment and `pullSecrets` to the cluster custom resource.
+
+### Specify the operator image source
+
+The operator bundle contains the operator deployment and the reference to the operator image (`redislabs/operator`). To use a private container registry, you must
+change this image reference in your operator deployment file **before** you deploy the operator. If you apply this change to modify an existing operator deployment, the operator's pod will restart.
+
+In the operator deployment file, 'containers:image' should point to the same repository and tag you used when [pushing]({{< relref "/operate/kubernetes/deployment/container-images#push-images-to-a-private-container-registry" >}}) to the private container registry:
+
+```sh
+${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+```
+
+The example below specifies a 7.2.4-7 operator image in a Google Container Registry:
+
+```YAML
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redis-enterprise-operator
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      name: redis-enterprise-operator
+  template:
+    metadata:
+      labels:
+        name: redis-enterprise-operator
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      containers:
+        - name: redis-enterprise-operator
+          image: gcr.io/yourproject/redislabs/operator:7.2.4-7
+...
+```
+
+If your container registry requires a pull secret, configure `imagePullSecrets` on the operator deployment:
+
+```YAML
+spec:
+  template:
+    spec:
+      imagePullSecrets:
+      - name: regcred
+```
+
+### Specify the Redis Enterprise cluster images source
+
+A Redis Enterprise cluster managed by the operator consists of three
+container images:
+
+* **`redislabs/redis`**: the Redis Enterprise Software container image
+* **`redislabs/operator`**: the bootstrapper is packaged within the operator container image
+* **`redislabs/k8s-controller`**: the Service Rigger container image
+
+By default, a new Redis Enterprise cluster is created using the
+container images listed above. These container images are pulled from the K8s cluster's default
+container registry.
+
+To [pull](https://docs.docker.com/engine/reference/commandline/pull/) the Redis Enterprise container images from
+a private container registry, you must specify them in the
+Redis Enterprise cluster custom resource.
+
+Add the following sections to the `spec` section of your RedisEnterpriseCluster resource file:
+
+ * **`redisEnterpriseImageSpec`**: controls the Redis Enterprise Software container image. *The version should match the RS version associated with the operator version*.
+ * **`bootstrapperImageSpec`**": controls the bootstrapper container image. *The version must match the operator version*.
+ * **`redisEnterpriseServicesRiggerImageSpec`**: controls the Service Rigger container image. *The version must match the operator version*.
+
+The REC custom resource example below pulls all three container images from a GCR private registry:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+If your private container registry requires pull secrets, you must add `pullSecrets`
+to the `spec` section:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  pullSecrets:
+    - name: regcred
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+## Rate limiting with DockerHub
+
+Docker has [rate limits for image pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/).
+Anonymous users are allowed a certain number of pulls every 6 hours. For authenticated users, the limit is larger.
+These rate limits may affect your Kubernetes cluster in a number of ways:
+
+* The cluster nodes will likely be treated as a single anonymous user.
+* The number of pulls during a deployment might exceed the rate limit for other deployment dependencies, including the operator, Redis Enterprise Software, or other non-Redis pods.
+* Pull failures may prevent your deployment from downloading the required images in a timely manner. Delays here can affect the stability of deployments used by the Redis Enterprise operator.
+
+For these reasons, you should seriously consider where your images
+are pulled from to **avoid failures caused by rate limiting**. The easiest solution
+is to push the required images to a private container registry under your control.
+---
+Title: Install Redis Enterprise Helm chart
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install Redis Enterprise for Kubernetes version 7.8.6 using Helm charts.
+linkTitle: Helm
+weight: 11
+---
+
+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/](https://helm.sh/docs/).
+
+{{<note>}} This feature is currently in public preview and is not supported on production workloads. Only new installations of the Redis operator are supported at this time. The steps for [creating the RedisEnterpriseCluster (REC)]({{<relref "operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec">}}) and other custom resources remain the same.{{</note>}}
+
+## Prerequisites
+
+- A [supported distribution]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) of Kubernetes.
+- At least three worker nodes.
+- [Kubernetes client (kubectl)](https://kubernetes.io/docs/tasks/tools/).
+- [Helm 3.10 or later](https://helm.sh/docs/intro/install/).
+
+### Example values
+
+The steps below use the following placeholders to indicate command line parameters you must provide:
+
+- `<repo-name>` is the name of the repo holding your Helm chart (example: `redis`).
+- `<release-name>` is the name you give a specific installation of the Helm chart (example: `my-redis-enterprise-operator`)
+- `<chart-version>` is the version of the Helm chart you are installing (example: `7.8.2-2`)
+- `<namespace-name>` is the name of the new namespace the Redis operator will run in (example: `ns1`)
+- `<path-to-chart>` is the filepath to the Helm chart, if it is stored in a local directory (example: `/home/charts/redis-enterprise-operator`)
+
+## Install
+
+1. Add the Redis repository.
+
+```sh
+helm repo add <repo-name> https://helm.redis.io/
+```
+
+2. Install the Helm chart into a new namespace.
+
+```sh
+helm install <release-name> redis/redis-enterprise-operator \
+    --version <chart-version> \
+    --namespace <namespace-name> \
+    --create-namespace
+```
+
+To install with Openshift, add `--set openshift.mode=true`.
+
+To monitor the installation add the `--debug` flag. The installation runs several jobs synchronously and may take a few minutes to complete.
+
+### Install from local directory
+
+1. Find the latest release on the [redis-enterprise-k8s-docs](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) repo and download the `tar.gz` source code into a local directory.
+
+2. Install the Helm chart from your local directory.
+
+```sh
+helm install <release-name> <path-to-chart> \
+    --namespace <namespace-name> \
+    --create-namespace
+```
+
+To install with Openshift, add `--set openshift.mode=true`.
+
+To monitor the installation add the `--debug` flag. The installation runs several jobs synchronously and may take a few minutes to complete.
+
+### Specify values during install
+
+1. View configurable values with `helm show values <repo-name>/<chart-name>`.
+
+2. Install the Helm chart, overriding specific value defaults using `--set`.
+
+```sh
+helm install <operator-name> redis/redis-enterprise-operator \
+    --version <release-name> \
+    --namespace <namespace-name> \
+    --create-namespace
+    --set <key1>=<value1> \
+    --set <key2>=<value2>
+```
+
+### Install with values file
+
+1. View configurable values with `helm show values <repo-name>/<chart-name>`.
+
+2. Create a YAML file to specify the values you want to configure.
+
+3. Install the chart with the `--values` option.
+
+```sh
+helm install <operator-name> redis/redis-enterprise-operator \
+    --version <release-name> \
+    --namespace <namespace-name> \
+    --create-namespace \
+    --values <path-to-values-file>
+```
+
+## Uninstall
+
+1. Delete any custom resources managed by the operator. See [Delete custom resources]({{<relref "operate/kubernetes/re-clusters/delete-custom-resources">}}) for detailed steps. You must delete custom resources in the correct order to avoid errors.
+
+2. Uninstall the Helm chart.
+
+```sh
+helm uninstall <release-name>
+```
+
+This removes all Kubernetes resources associated with the chart and deletes the release.
+
+{{<note>}}Custom Resource Definitions (CRDs) installed by the chart are not removed during chart uninstallation. To remove them manually after uninstalling the chart, run `kubectl delete crds -l app=redis-enterprise`.{{</note>}}
+
+## Known limitations
+
+- Only new installations of the Redis operator are supported at this time. The steps for [creating the RedisEnterpriseCluster (REC)]({{<relref "operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec">}}) and other custom resources remain the same.
+- Upgrades and migrations are not supported.
+- The chart doesn't include configuration options for multiple namespaces, rack-awareness, and Vault integration. The steps for configuring these options remain the same.
+- The chart has had limited testing in advanced setups, including Active-Active configurations, air-gapped deployments, and IPv6/dual-stack environments.---
+Title: Deploy Redis Enterprise Software for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to install Redis Enterprise Software for Kubernetes.
+linkTitle: Kubernetes
+weight: 10
+---
+
+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]({{< relref "/operate/kubernetes/deployment/openshift" >}}). For details on what is currently supported, see [supported distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+## Prerequisites
+
+To deploy Redis Enterprise for Kubernetes, you'll need:
+
+- Kubernetes cluster in a [supported distribution]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}})
+- minimum of three worker nodes
+- Kubernetes client (kubectl)
+- access to DockerHub, RedHat Container Catalog, or a private repository that can hold the required images.
+NOTE: If you are applying version 7.8.2-6 or above, check if the [OS](https://redis.io/docs/latest/operate/kubernetes/release-notes/7-8-2-releases/7-8-2-6-nov24/#breaking-changes) installed on the node is supported.
+
+### Create a new namespace
+
+**Important:** Each namespace can only contain one Redis Enterprise cluster. Multiple RECs with different operator versions can coexist on the same Kubernetes cluster, as long as they are in separate namespaces.
+
+Throughout this guide, each command is applied to the namespace in which the Redis Enterprise cluster operates.
+
+1. Create a new namespace
+
+    ```sh
+   kubectl create namespace <rec-namespace>
+   ```
+
+1. Change the namespace context to make the newly created namespace default for future commands.
+
+    ```sh
+    kubectl config set-context --current --namespace=<rec-namespace>
+   ```
+
+You can use an existing namespace as long as it does not contain any existing Redis Enterprise cluster resources. It's best practice to create a new namespace to make sure there are no Redis Enterprise resources that could interfere with the deployment.
+
+## Install the operator
+
+Redis Enterprise for Kubernetes bundle is published as a container image. A list of required images is available in the [release notes]({{< relref "/operate/kubernetes/release-notes/_index" >}}) for each version.
+
+The operator [definition and reference materials](https://github.com/RedisLabs/redis-enterprise-k8s-docs) are available on GitHub. The operator definitions are [packaged as a single generic YAML file](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/bundle.yaml).
+
+{{<note>}}
+If you do not pull images from DockerHub or another public registry, you need to use a [private container registry]({{< relref "/operate/kubernetes/deployment/container-images#manage-image-sources" >}}).
+{{</note>}}
+
+### Download the operator bundle
+
+Pull the latest version of the operator bundle:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+```
+
+  If you need a different release, replace `VERSION` with a specific release tag.
+
+  Check version tags listed with the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases) to ensure the version of the bundle is correct.
+
+### Deploy the operator bundle
+
+Apply the operator bundle in your REC namespace:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+  You should see a result similar to this:
+
+  ```sh
+  role.rbac.authorization.k8s.io/redis-enterprise-operator created
+  serviceaccount/redis-enterprise-operator created
+  rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+  customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+  customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+  deployment.apps/redis-enterprise-operator created
+  ```
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+#### Verify the operator is running
+
+Check the operator deployment to verify it's running in your namespace:
+
+```sh
+kubectl get deployment redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+## Create a Redis Enterprise cluster (REC)
+
+A Redis Enterprise cluster (REC) is created from a `RedisEnterpriseCluster` custom resource
+that contains cluster specifications.
+
+The following example creates a minimal Redis Enterprise cluster. See the [RedisEnterpriseCluster API reference]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}) for more information on the various options available.
+
+1. Create a file that defines a Redis Enterprise cluster with three nodes.
+
+    {{<note>}}
+The REC name (`my-rec` in this example) cannot be changed after cluster creation.
+    {{</note>}}
+
+    ```sh
+    cat <<EOF > my-rec.yaml
+    apiVersion: "app.redislabs.com/v1"
+    kind: "RedisEnterpriseCluster"
+    metadata:
+      name: my-rec
+    spec:
+      nodes: 3
+    EOF
+    ```
+
+   This will request a cluster with three Redis Enterprise nodes using the default requests (i.e., 2 CPUs and 4GB of memory per node).
+
+   To test with a larger configuration, use the example below to add node resources to the `spec` section of your test cluster (`my-rec.yaml`).
+
+    ```sh
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: 2000m
+        memory: 16Gi
+      requests:
+        cpu: 2000m
+        memory: 16Gi
+    ```
+
+    {{<note>}}
+Each cluster must have at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+    See the [Redis Enterprise hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}) for more information on sizing Redis Enterprise node resource requests.
+  
+1. Apply your custom resource file in the same namespace as `my-rec.yaml`.
+
+    ```sh
+    kubectl apply -f my-rec.yaml
+    ```
+
+   You should see a result similar to this:
+
+   ```sh
+   redisenterprisecluster.app.redislabs.com/my-rec created
+   ```
+
+1. You can verify the creation of the cluster with:
+
+    ```sh
+    kubectl get rec
+    ```
+
+    You should see a result similar to this:
+
+    ```sh
+    NAME           AGE
+    my-rec   1m
+    ```
+
+    At this point, the operator will go through the process of creating various services and pod deployments.
+
+    You can track the progress by examining the StatefulSet associated with the cluster:
+
+    ```sh
+    kubectl rollout status sts/my-rec
+    ```
+
+    or by looking at the status of all of the resources in your namespace:
+
+    ```sh
+    kubectl get all
+    ```
+
+## Enable the admission controller
+
+The admission controller dynamically validates REDB resources configured by the operator. It is strongly recommended that you use the admission controller on your Redis Enterprise Cluster (REC). The admission controller only needs to be configured once per operator deployment.
+
+As part of the REC creation process, the operator stores the admission controller certificate in a Kubernetes secret called `admission-tls`. You may have to wait a few minutes after creating your REC to see the secret has been created.
+
+{{< embed-md "k8s-admission-webhook-cert"  >}}
+
+### Limit the webhook to the relevant namespaces {#webhook}
+
+The operator bundle includes a webhook file. The webhook will intercept requests from all namespaces unless you edit it to target a specific namespace. You can do this by adding the `namespaceSelector` section to the webhook spec to target a label on the namespace.
+
+1. Make sure the namespace has a unique `namespace-name` label.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+       labels:
+        namespace-name: example-ns
+    name: example-ns
+    ```
+
+1. Patch the webhook to add the `namespaceSelector` section.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+        matchLabels:
+          namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    kubectl patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+## Verify the admission controller is working
+
+1. Verify the admission controller is installed correctly by applying an invalid resource. This should force the admission controller to correct it.
+
+    ```sh
+    kubectl apply -f - << EOF
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      evictionPolicy: illegal
+    EOF
+    ```
+
+    You should see your request was denied by the `admission webhook "redisenterprise.admission.redislabs"`.
+
+    ```sh
+    Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+    ```
+
+## Create a Redis Enterprise Database (REDB)
+
+You can create multiple databases within the same namespace as your REC or in other namespaces.
+
+See [manage Redis Enterprise databases for Kubernetes]({{< relref "/operate/kubernetes/re-databases/db-controller" >}}) to create a new REDB.
+---
+Title: Deploy Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: OpenShift provides the OperatorHub where you can install the Redis Enterprise
+  operator from the administrator user interface.
+linkTitle: OpenShift OperatorHub
+weight: 70
+---
+
+You can deploy Redis Enterprise for Kubernetes from the Red Hat OpenShift CLI. You can also use a UI, [OperatorHub](https://docs.openshift.com/container-platform/4.11/operators/index.html) (Red Hat) to install operators and create custom resources.
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+## Install the Redis Enterprise operator
+
+{{<warning>}} If using version 6.2.18-41 or earlier, [Install the security context constraint](#install-security-context-constraint) before installing the operator. {{</warning>}}
+
+1. Select **Operators > OperatorHub**.
+
+2. Search for _Redis Enterprise_ in the search dialog and select the **Redis Enterprise Operator provided by Redis** marked as **Certified**.
+
+    By default, the image is pulled from Red Hat's registry.
+
+3. On the **Install Operator** page, specify the namespace for the operator.
+
+    Only one namespace per operator is supported.
+
+4. Update the **channel** with the version you're installing.
+
+    For more information about specific versions, see the [release notes]({{< relref "/operate/kubernetes/release-notes/" >}}).
+
+5. Choose an approval strategy.
+
+    Use **Manual** for production systems to ensure the operator is only upgraded by approval.
+
+6. Select **Install** and approve the install plan.
+
+   You can monitor the subscription status in **Operators > Installed Operators**.
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+## Security context constraints
+
+Upgrades to versions 7.22.0-6 and later run in **unprivileged mode** without any additional permissions or capabilities. If you don't specifally require additional capabilities, we recommend you maintain the default unprivileged mode, as its more secure. After upgrading, remove the existing `redis-enterprise-scc-v2` SCC and unbind it from the REC service account.
+
+To enable privileged mode, see [Enable privileged mode > OpenShift upgrades]({{<relref "/operate/kubernetes/security/enable-privileged-mode#new-openshift-installations">}}).
+
+## Create Redis Enterprise custom resources
+
+The **Installed Operators**->**Operator details** page shows the provided APIs: **RedisEnterpriseCluster** and **RedisEnterpriseDatabase**. You can select **Create instance** to create custom resources using the OperatorHub interface.
+
+Use the YAML view to create a custom resource file or let OperatorHub generate the YAML file for you by specifying your configuration options in the form view.
+
+<note> The REC name cannot be changed after cluster creation.</note>
+
+{{<note>}} In versions 6.4.2-4 and 6.4.2-5, REC creation might fail when using the form view due to an error related to the cluster level LDAP. To avoid this, use the YAML view.
+{{</note>}}
+
+For more information on creating and maintaining Redis Enterprise custom resources, see [Redis Enterprise clusters (REC)]({{< relref "/operate/kubernetes/re-clusters/" >}}) and [Redis Enterprise databases (REDB)]({{< relref "/operate/kubernetes/re-databases/" >}}).
+---
+Title: Deployment with OpenShift CLI for Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes and cluster can be installed via CLI
+  tools OpenShift
+linkTitle: OpenShift CLI
+weight: 60
+---
+Use these steps to set up a Redis Enterprise Software cluster with OpenShift.
+
+## Prerequisites
+
+- [OpenShift cluster](https://docs.openshift.com/container-platform/4.8/installing/index.html) with at least 3 nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}))
+- [OpenShift CLI](https://docs.openshift.com/container-platform/latest/cli_reference/openshift_cli/getting-started-cli.html)
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).
+
+## Deploy the operator
+
+1. Create a new project.
+
+    ```sh
+    oc new-project <your-project-name> 
+    ```
+
+1. Verify the newly created project. 
+
+    ```sh
+    oc project <your-project-name>
+    ```
+
+1. Get the deployment files.
+
+    ```sh
+    git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+    ```
+
+1. Deploy the OpenShift operator bundle.
+
+    If you are using version 6.2.18-41 or earlier, you must [apply the security context constraint](#install-security-context-constraint) before the operator bundle.
+
+    ```sh
+    oc apply -f openshift.bundle.yaml
+    ```
+
+    {{< warning >}}
+Changes to the `openshift.bundle.yaml` file can cause unexpected results.
+    {{< /warning >}}
+
+1. Verify that your `redis-enterprise-operator` deployment is running.
+
+    ```sh
+    oc get deployment
+    ```
+
+    A typical response looks like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+    {{<warning>}}
+DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).
+    {{</warning>}}
+
+## Security context constraints
+
+Upgrades to versions 7.22.0-6 and later run in **unprivileged mode** without any additional permissions or capabilities. If you don't specifally require additional capabilities, we recommend you maintain the default unprivileged mode, as its more secure. After upgrading, remove the existing `redis-enterprise-scc-v2` SCC and unbind it from the REC service account.
+
+To enable privileged mode, see [Enable privileged mode > OpenShift upgrades]({{<relref "/operate/kubernetes/security/enable-privileged-mode#new-openshift-installations">}}).
+
+## Create a Redis Enterprise cluster custom resource
+
+1. Apply the `RedisEnterpriseCluster` resource file ([rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml)).
+
+    You can rename the file to `<your_cluster_name>.yaml`, but it is not required. Examples below use `<rec_rhel>.yaml`. [Options for Redis Enterprise clusters]({{< relref "/operate/kubernetes/reference/redis_enterprise_cluster_api" >}}) has more info about the Redis Enterprise cluster (REC) custom resource, or see the [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}}) for a full list of options.
+
+    The REC name cannot be changed after cluster creation.
+
+    {{<note>}}
+Each Redis Enterprise cluster requires at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+2. Apply the custom resource file to create your Redis Enterprise cluster.
+
+    ```sh
+    oc apply -f <rec_rhel>.yaml
+    ```
+
+    The operator typically creates the REC within a few minutes.
+
+1. Check the cluster status.
+
+    ```sh
+    oc get pod
+    ```
+
+    You should receive a response similar to the following:
+
+    ```sh
+     NAME                             | READY | STATUS  | RESTARTS | AGE |
+    | -------------------------------- | ----- | ------- | -------- | --- |
+    | rec-name-0              | 2/2   | Running | 0        | 1m  |
+    | rec-name-1              | 2/2   | Running | 0        | 1m  |
+    | rec-name-2              | 2/2   | Running | 0        | 1m  |
+    | rec-name-controller-x-x | 1/1   | Running | 0        | 1m  |
+    | Redis-enterprise-operator-x-x    | 1/1   | Running | 0        | 5m  |
+    ```
+
+## Configure the admission controller
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to relevant namespaces
+
+If not limited, the webhook intercepts requests from all namespaces. If you have several REC objects in your Kubernetes cluster, limit the webhook to the relevant namespaces. If you aren't using multiple namespaces, skip this step.
+
+1. Verify your namespace is labeled and the label is unique to this namespace, as shown in the next example.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+      labels:
+       namespace-name: staging
+    name: staging
+    ```
+
+1. Patch the webhook spec with the `namespaceSelector` field.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+       matchLabels:
+         namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    oc patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+    {{<note>}}
+For releases before 6.4.2-4, use this command instead:
+
+```sh
+oc patch ValidatingWebhookConfiguration \
+  redb-admission --patch "$(cat modified-webhook.yaml)"
+```
+
+The 6.4.2-4 release introduces a new `ValidatingWebhookConfiguration` to replace `redb-admission`. See the [6.4.2-4 release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/" >}}).
+    {{</note>}}
+
+### Verify admission controller installation
+
+Apply an invalid resource as shown below to force the admission controller to reject it. If it applies successfully, the admission controller is not installed correctly.
+
+```sh
+oc apply -f - << EOF
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: redis-enterprise-database
+spec:
+  evictionPolicy: illegal
+EOF
+```
+
+You should see this error from the admission controller webhook `redisenterprise.admission.redislabs`.
+  
+```sh
+Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+```
+
+## Create a Redis Enterprise database custom resource
+
+The operator uses the instructions in the Redis Enterprise database (REDB) custom resources to manage databases on the Redis Enterprise cluster.
+
+1. Create a `RedisEnterpriseDatabase` custom resource.
+
+    This example creates a test database. For production databases, see [create a database]({{< relref "/operate/kubernetes/re-databases/db-controller.md#create-a-database" >}}) and [RedisEnterpriseDatabase API reference]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api" >}}).
+
+    ```sh
+    cat << EOF > /tmp/redis-enterprise-database.yml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      memorySize: 100MB
+    EOF
+    ```
+
+1. Apply the newly created REDB resource.
+
+    ```sh
+    oc apply -f /tmp/redis-enterprise-database.yml
+    ```
+
+## More info
+
+- [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/reference/redis_enterprise_cluster_api">}})
+- [Redis Enterprise database API]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api">}})
+---
+Title: Deploy Redis Enterprise for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A quick introduction to the steps necessary to get a Redis Enterprise
+  cluster installed in your OpenShift Kubernetes cluster
+hideListLinks: true
+linkTitle: OpenShift
+weight: 11
+---
+The deployment of Redis Enterprise clusters is managed with the Redis Enterprise operator that you deploy in the namespace for your project.
+To create a database that your application
+workloads can use:
+
+1. Install the Redis Enterprise operator.
+
+1. Create a Redis Enterprise CRD to describe your desired cluster.
+
+1. The operator reads this cluster description and deploys the various components on your K8s cluster.
+
+1. Once running, use the Redis Enterprise cluster to create a database.
+
+1. The operator automatically exposes the new database as a K8s service.
+
+## For OpenShift via the OperatorHub
+
+To [create a database on an OpenShift 4.x cluster via the OperatorHub]({{< relref "/operate/kubernetes/deployment/openshift/openshift-operatorhub" >}}) you only need to have the [OpenShift 4.x cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}).
+
+## For OpenShift via the CLI
+
+To [create a database on an OpenShift cluster via the CLI]({{< relref "/operate/kubernetes/deployment/openshift/openshift-cli" >}}), you need:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}).
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.2/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Version compatibility
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}).---
+Title: Deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section lists the different ways to set up and run Redis Enterprise
+  for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem
+  and in the cloud via our Redis Enterprise operator for Kubernetes.
+hideListLinks: false
+linkTitle: Deployment
+weight: 11
+---
+
+This section lists the different ways to set up and run Redis Enterprise for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem and in the cloud via our Redis Enterprise operator for Kubernetes.
+
+## Compatibility
+
+Before installing, check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) to see which Redis Enterprise operator version supports your Kubernetes distribution.
+
+
+---
+Title: Upgrade Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  OperatorHub.
+linkTitle: OpenShift OperatorHub
+weight: 40
+url: '/operate/kubernetes/7.8.6/upgrade/upgrade-olm/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-redis-enterprise-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-olm/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 or later involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the Redis Enterprise operator
+
+1. Select the **Redis Enterprise Operator** from the **Operators**>**Installed Operators** page.
+
+2. Select the **Subscription** tab.
+
+3. Verify your **Update approval** is set to "Manual".
+
+4. To upgrade to the latest version, set your **Update Channel** to ‘production’. To upgrade to an older version, specify the desired version for your **Update Channel**.
+
+5. Select **Upgrade available** shown under **Upgrade status**.
+
+6. When the "Review manual InstallPlan" section appears, select **Preview installPlan** and then **Approve** after reviewing the details. This will start the operator upgrade.
+
+You can monitor the upgrade from the **Installed Operators** page. A new Redis Enterprise Operator will appear in the list, with the status "Installing". OpenShift will delete the old operator, showing the "Cannot update" status during deletion.
+
+## Reapply the SCC
+
+
+If you are using OpenShift, you must manually reappply the [security context constraints (SCC)](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.8.6/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+## Upgrade the Redis Enterprise Cluster 
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+## Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions for this operator version include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconciliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+---
+Title: Upgrade Redis Enterprise with OpenShift CLI 
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via OpenShift
+  CLI.
+linkTitle: OpenShift CLI
+weight: 20
+url: '/operate/kubernetes/7.8.6/upgrade/openshift-cli/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## 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.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+#### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+#### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6 or later. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/openshift-cli/) for detailed steps.
+
+#### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}).
+
+#### RHEL9-compatible modules
+
+Upgrading to Redis operator versions 7.8.2-6 and later  involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatible with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+#### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+For OpenShift environments, the name of the bundle is `openshift.bundle.yaml`, and so the `curl` command to run is:
+
+```sh
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/openshift.bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+If you are using OpenShift, run this instead:
+
+```sh
+oc apply -f openshift.bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+oc get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+ We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+ {{< /warning >}}
+
+### Reapply the SCC
+
+If you are using OpenShift, you will also need to manually reapply the [security context constraints](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html) file ([`scc.yaml`]({{< relref "/operate/kubernetes/7.8.6/deployment/openshift/openshift-cli#deploy-the-operator" >}})) and bind it to your service account.
+
+```sh
+oc apply -f openshift/scc.yaml
+```
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-name>
+```
+
+If you are upgrading from operator version 6.4.2-6 or before, see the ["after upgrading"](#after-upgrading) section to delete the old SCC and role binding after all clusters are running 6.4.2-6 or later.
+
+## Upgrade the Redis Enterprise Cluster 
+
+{{<warning>}}
+Verify your license is valid before upgrading. Invalid licenses will cause the upgrade to fail.
+
+Use `oc get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+{{</warning>}}
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the K8s operator [release notes]({{<relref "/operate/kubernetes/release-notes">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Edit `redisEnterpriseImageSpec`
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    oc edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `oc get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ oc get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+oc rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconciliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+
+---
+Title: Upgrade Redis Enterprise for Kubernetes 7.8.2-6
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to upgrade a Redis Enterprise cluster via the
+  operator.
+linkTitle: Kubernetes
+weight: 10
+url: '/operate/kubernetes/7.8.6/upgrade/upgrade-redis-cluster/'
+---
+
+Redis implements rolling updates for software upgrades in Kubernetes deployments. The upgrade process includes updating three components:
+
+  1. [Upgrade the Redis Enterprise operator](#upgrade-the-operator)
+  1. [Upgrade the Redis Enterprise cluster (REC)](#upgrade-the-redis-enterprise-cluster-rec)
+  1. [Upgrade Redis Enterprise databases (REDB)](#upgrade-databases)
+
+## Prerequisites
+
+The following steps ensure you have the minimum versions of all components necessary to upgrade to 7.8.2-6. **Without these minimum versions, the upgrade will freeze and require manual recovery.**
+
+See the [troubleshooting](#troubleshooting) section for details on recovering a failed upgrade.
+
+### Kubernetes version
+
+Check [Supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}) to make sure your Kubernetes distribution is supported by 7.8.2-6. If not, upgrade your Kubernetes distribution before upgrading the Redis operator.
+
+### Redis operator version
+
+Your Redis Enterprise clusters must be running version 7.4.2-2 or later before upgrading to 7.8.2-6. See the [7.4 upgrade](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/upgrade-redis-cluster/) for detailed steps.
+
+### Redis database version
+
+Your Redis databases must be running version 7.2 or later before upgrading your cluster version to 7.8.2-6. See [upgrade databases](#upgrade-databases) for detailed steps. You can find your database version in the [REDB `spec.redisVersion` field]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}).
+
+### RHEL9-compatible modules
+
+Upgrading to Redis operator version 7.8.2-6 involves migrating your Redis Enterprise nodes to RHEL9 from either Ubuntu 18 or RHEL8. If your databases use modules, you need to manually install modules compatibile with RHEL9.
+
+To see which modules you have installed, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/modules | jq -r 'map([.module_name, .semantic_version, (.platforms | keys)]) | .[] | .[0] as $name | .[1] as $version | .[2][] | $name + "-" + $version + "-" + .' | sort
+```
+
+To see which modules are currently in use, run:
+
+```sh
+curl -k -u <rec_username>:<rec_password> -X GET https://localhost:9443/v1/bdbs | jq -r '.[].module_list | map(.module_name + "-" + .semantic_version) | .[]'
+```
+
+See [Upgrade modules]({{<relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module">}}) for details on how to upgrade modules with the `rladmin` tool.
+
+### Valid license
+
+Use `kubectl get rec` and verify the `LICENSE STATE` is valid on your REC before you start the upgrade process.
+
+## Upgrade the operator
+
+### Download the bundle
+
+Make sure you pull the correct version of the bundle. You can find the version tags
+by checking the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases)
+or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases).
+
+You can download the bundle for the latest release with the following `curl` command:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+curl --silent -O https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+If you need a different release, replace `VERSION` in the above with a specific release tag.
+
+### Apply the bundle
+
+Apply the bundle to deploy the new operator binary. This will also apply any changes in the new release to custom resource definitions, roles, role binding, or operator service accounts.
+
+{{< note >}}
+If you are not pulling images from Docker Hub, update the operator image spec to point to your private repository.
+If you have made changes to the role, role binding, RBAC, or custom resource definition (CRD) in the previous version, merge them with the updated declarations in the new version files.
+{{< /note >}}
+
+Upgrade the bundle and operator with a single command, passing in the bundle YAML file:
+
+```sh
+kubectl apply -f bundle.yaml
+```
+
+After running this command, you should see a result similar to this:
+
+```sh
+role.rbac.authorization.k8s.io/redis-enterprise-operator configured
+serviceaccount/redis-enterprise-operator configured
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+deployment.apps/redis-enterprise-operator configured
+```
+
+### Reapply the admission controller webhook {#reapply-webhook}
+
+If you have the admission controller enabled, you need to manually reapply the `ValidatingWebhookConfiguration`.
+
+{{<note>}}
+{{< embed-md "k8s-642-redb-admission-webhook-name-change.md" >}}
+{{</note>}}
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Verify the operator is running
+
+You can check your deployment to verify the operator is running in your namespace.
+
+```sh
+kubectl get deployment/redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+{{< warning >}}
+We recommend upgrading the REC as soon as possible after updating the operator. After the operator upgrade completes, the operator suspends the management of the REC and its associated REDBs, until the REC upgrade completes.
+{{< /warning >}}
+
+## Upgrade the Redis Enterprise cluster (REC)
+
+The Redis Enterprise cluster (REC) can be updated automatically or manually. To trigger automatic upgrade of the REC after the operator upgrade completes, specify `autoUpgradeRedisEnterprise: true` in your REC spec. If you don't have automatic upgrade enabled, follow the below steps for the manual upgrade.
+
+Before beginning the upgrade of the Redis Enterprise cluster, check the [Redis Enterprise for Kubernetes release notes]({{<relref "/operate/kubernetes/release-notes/7-8-2-releases">}}) to find the Redis Enterprise image tag.
+
+After the operator upgrade is complete, you can upgrade Redis Enterprise cluster (REC).
+
+### Upgrade an REC with an Active-Active database
+
+We recommend upgrading all participating clusters to the same operator version.
+
+If you are upgrading from a preview version of the Active-Active controller, you can remove the following environment variables: `ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED`, `REMOTE_CLUSTER_CONTROLLER_ENABLED`, and `ENABLE_ALPHA_FEATURES`.
+
+### Edit `redisEnterpriseImageSpec` in the REC spec
+
+1. Edit the REC custom resource YAML file.
+
+    ```sh
+    kubectl edit rec <your-rec.yaml>
+    ```
+
+1. Replace the `versionTag:` declaration under `redisEnterpriseImageSpec` with the new version tag.
+
+    ```YAML
+    spec:
+      redisEnterpriseImageSpec:
+        imagePullPolicy:  IfNotPresent
+        repository:       redislabs/redis
+        versionTag:       <new-version-tag>
+    ```
+
+1. Save the changes to apply.
+
+### Reapply roles and role bindings
+
+If your operator is monitoring multiple namespaces, you'll need to [reapply your role and role bindings]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace#create-role-and-role-binding-for-managed-namespaces" >}}) for each managed namespace. See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace" >}}) for more details.
+
+### Monitor the upgrade
+
+You can view the state of the REC with `kubectl get rec`.
+
+  During the upgrade, the state should be `Upgrade`.
+  When the upgrade is complete and the cluster is ready to use, the state will change to `Running`.
+  If the state is `InvalidUpgrade`, there is an error (usually relating to configuration) in the upgrade.
+
+```sh
+$ kubectl get rec
+NAME   NODES   VERSION      STATE     SPEC STATUS   LICENSE STATE   SHARDS LIMIT   LICENSE EXPIRATION DATE   AGE
+rec    3       6.2.10-107   Upgrade   Valid         Valid           4              2022-07-16T13:59:00Z      92m
+```
+
+To see the status of the current rolling upgrade, run:
+
+```sh
+kubectl rollout status sts <REC_name>
+```
+
+### Upgrade databases
+
+After the cluster is upgraded, you can upgrade your databases. Specify your new database version in the `spec.redisVersion` field for your REDB and REAADB custom resources. Supported database versions for operator version 7.8.2-6 include `"7.2"` and `"7.4"` (note this value is a string).
+
+Note that if your cluster [`redisUpgradePolicy`]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#redisupgradepolicy" >}}) or your database [`redisVersion`]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api#redisversion" >}}) are set to `major`, you won't be able to upgrade those databases to minor versions. See [Redis upgrade policy]({{< relref "/operate/rs/installing-upgrading/upgrading#redis-upgrade-policy" >}}) for more details.
+
+## Troubleshooting
+
+If you start an upgrade without meeting the [prerequisites](#prerequisites), the operator will freeze the upgrade. Check the operator logs for the source of the error. The REDB reconciliation doesn't work during an upgrade, so you need to apply a manual fix with the Redis Software API (examples below). The updates will also need to be added to the REDB custom resource.
+
+### Invalid module version
+
+If the operator logs show an event related to an unsupported module, download the updated module locally, and install it using the `v2/modules` API endpoint.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -F 'module=@<full path to your module>' https://localhost:9443/v2/modules
+```
+
+After updating the database with the Redis Software API, update the REDB custom resource to reflect the change.
+
+### Invalid database version
+
+If the operator logs show an event related to an incompatible database version, upgrade the database using the Redis Software API.
+
+```sh
+curl -sfk -u <rec_username>:<rec_password> -X POST -H "Content-Type: application/json" -d '{"redis_version": <target redis version>}' https://localhost:9443/v1/bdbs/<BDB UID>/upgrade
+```
+
+After updating the modules with the Redis Software API, update the REDB custom resource to reflect the change.
+---
+Title: Upgrade Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Information about upgrading your Redis Enterprise cluster on Kubernetes.
+hideListLinks: true
+linkTitle: Upgrade
+weight: 15
+url: '/operate/kubernetes/7.8.6/upgrade/'
+---
+
+The upgrade process includes updating three components:
+
+  1. Upgrade the Redis Enterprise operator
+  2. Upgrade the Redis Enterprise cluster (REC)
+  3. Upgrade Redis Enterprise databases (REDB)
+
+If you are using OpenShift, see [Upgrade Redis Enterprise with OpenShift CLI]({{<relref "/operate/kubernetes/7.8.6/upgrade/openshift-cli">}}) or [Upgrade Redis Enterprise with OpenShift OperatorHub]({{<relref "/operate/kubernetes/7.8.6/upgrade/upgrade-olm">}}).
+
+For all other Kubernetes distributions, see [Upgrade Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/7.8.6/upgrade/upgrade-redis-cluster" >}}).
+
+## Upgrade compatibility
+
+When upgrading, both your Kubernetes version and Redis operator version need to be supported at all times.
+
+{{<warning>}}If your current Kubernetes distribution is not [supported]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions.md">}}), upgrade to a supported distribution before upgrading. {{</warning>}}
+
+## RHEL9-based image
+
+Redis Enterprise images are now based on Red Hat Enterprise Linux 9 (RHEL9). This means upgrades require:
+
+- [Cluster version of 7.4.2-2 or later](https://redis.io/docs/latest/operate/kubernetes/7.4.6/upgrade/).
+- Database version 7.2 or later.
+- RHEL9 compatible binaries for any modules you need.
+
+For detailed steps, see the relevant upgrade page:
+
+- [OpenShift CLI]({{<relref "/operate/kubernetes/7.8.6/upgrade/openshift-cli">}})
+- [OpenShift OperatorHub]({{<relref "/operate/kubernetes/7.8.6/upgrade/upgrade-olm">}})
+- [Kubernetes]({{<relref "/operate/kubernetes/7.8.6/upgrade/upgrade-redis-cluster" >}})
+---
+Title: Recover a Redis Enterprise cluster on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This task describes how to recover a Redis Enterprise cluster on Kubernetes.
+linkTitle: Recover a Redis cluster
+weight: 20
+url: '/operate/kubernetes/7.8.6/re-clusters/cluster-recovery/'
+---
+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:
+
+1. Recreates a fresh Redis Enterprise cluster
+1. Mounts the persistent storage with the recovery files from the original cluster to the nodes of the new cluster
+1. Recovers the cluster configuration on the first node in the new cluster
+1. Joins the remaining nodes to the new cluster.
+
+{{<warning>}}Redis Enterprise for Kubernetes 7.2.4-2 introduces a new limitation. You cannot recover or upgrade your cluster if there are databases with old module versions or manually uploaded modules. See the [Redis Enterprise Software 7.2.4 known limitations]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#cluster-recovery-with-manually-uploaded-modules" >}}) for more details.{{</warning>}}
+
+## Prerequisites
+
+- For cluster recovery, the cluster must be [deployed with persistence]({{< relref "/operate/kubernetes/7.8.6/recommendations/persistent-volumes.md" >}}).
+
+## Recover a cluster
+
+1. Edit the REC resource to set the `clusterRecovery` flag to `true`.
+
+    ```sh
+    kubectl patch rec <cluster-name> --type merge --patch '{"spec":{"clusterRecovery":true}}'
+    ```
+
+
+1. Wait for the cluster to recover until it is in the "Running" state.
+
+    To see the state of the cluster, run:
+
+    ```sh
+    watch "kubectl describe rec | grep State"
+    ```
+
+1. To recover the database, see [Recover a failed database]({{< relref "/operate/rs/databases/recover.md" >}}).
+---
+Title: Delete custom resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article explains how to delete Redis Enterprise clusters and Redis
+  Enterprise databases from your Kubernetes environment.
+linkTitle: Delete custom resources
+weight: 70
+url: '/operate/kubernetes/7.8.6/re-clusters/delete-custom-resources/'
+---
+
+## Multi-namespace management
+
+Before you can delete a namespace, you must remove the Redis custom resources ([REDB](#delete-a-database-redb), [REC](#delete-a-redis-enterprise-cluster-rec), and [operator](#delete-operator-from-one-namespace)) residing within a namespace before you can delete that namespace. Deleting namespace containing an REDB may cause errors or data loss.
+
+## Delete a database (REDB)
+
+To delete a database managed by the Redis Enterprise Kubernetes operator, run `kubectl delete redb <your-db-name>` from your K8s cluster.
+
+When you delete a database, your data and the REDB custom resource are also deleted.
+
+## Delete a Redis Enterprise cluster (REC)
+
+To delete a Redis Enterprise cluster managed by the operator:
+
+1. Delete all the databases in your cluster.
+
+2. Run `kubectl delete rec <your-rec-name>` from your K8s cluster.
+
+When you delete your cluster, your databases and the REC custom resource are also deleted. However, persistent volume claims (PVCs) for your cluster are not deleted in the process. If you want to delete your PVCs, you'll have to delete them manually.
+
+## Delete the operator
+
+There are two ways to delete the operator. You can delete the entire operator bundle, but this will also delete any cluster-wide resources created by the operator. To only delete resources within a specific namespace and leave other cluster-wide resources intact, you need to delete each resource manually.
+
+Whether you decide to delete the entire bundle or just resources from a specific namespace, it's important to delete the operator ConfigMap (`operator-environment-config`).
+
+```sh
+kubectl delete cm operator-environment-config
+```
+
+### Delete operator bundle
+
+To delete the operator from your K8s cluster, you can delete the operator bundle with:
+
+- `kubectl delete -f bundle.yaml` for non-OpenShift K8s deployments
+- `kubectl delete -f openshift.bundle.yaml` for OpenShift deployments 
+
+This will remove the operator and its custom resource definitions (CRDs) from your K8s cluster.
+
+{{< warning >}} The Redis Enterprise CRDs are non-namespaced resources, meaning they are shared across your entire K8s cluster. Deleting CRDs in one namespace will delete custom resources in every other namespace across the K8s cluster.{{</warning>}}
+
+### Delete operator from one namespace
+
+If you have Redis Enterprise clusters running in different namespaces on the same K8s cluster, deleting the entire operator bundle might cause data loss.
+
+To safely delete the operator from one namespace without affecting the others, delete the operator files individually, excluding the CRD files:
+
+```sh
+kubectl delete -f role.yaml
+kubectl delete -f role_binding.yaml
+kubectl delete -f service_account.yaml
+kubectl delete -f admission-service.yaml
+kubectl delete -f operator.yaml
+```
+
+You will also need to remove [the `namespaceSelector` section from the validating webhook]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start#webhook" >}}).
+
+## Delete an Active-Active database (REAADB)
+
+1. On one of the existing participating clusters, delete the REEADB (substituting `<reaadb-name>` with your database name).
+
+  ```sh
+  kubectl delete reaadb <reaadb-name>
+  ```
+
+2. Verify the REAADB no longer exists. 
+
+  ```sh
+  kubectl get reaadb -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Delete a remote cluster (RERC)
+
+1. Verify the RERC you want to delete isn't listed as a participating cluster in any REAADB resources.
+
+    If an RERC is still listed as a participating cluster in any database, the deletion will be blocked.
+
+2. On one of the existing participating clusters, delete the RERC (substituting `<rerc-name>` with your database name).
+
+  ```sh
+  kubectl delete rerc <rerc-name>
+  ```
+
+3. Verify the RERC no longer exists.
+
+  ```sh
+  kubectl get rerc -o=jsonpath='{range .items[*]}{.metadata.name}'
+  ```
+
+## Troubleshoot REDB deletion
+
+The operator attaches a finalizer to the Redis Enterprise database (REDB) object. This makes sure the database is deleted before the REDB custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REDB resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REDB has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch redb <your-db-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"finalizer.redisenterprisedatabases.app.redislabs.com"}]'
+```
+
+## Troubleshoot REC deletion
+
+The operator attaches a finalizer to the Redis Enterprise cluster (REC) object. This makes sure the Redis cluster is deleted before the REC custom resource is removed from the K8s cluster.
+
+If the operator isn't running, or some other fatal error occurs, the finalizer isn't removed automatically by the operator. In this case, you won't be able to delete your REC resource.
+
+If this happens, you can remove the finalizer manually.
+
+{{<warning>}} If you remove the finalizer manually, there is no guarantee that the underlying REC has been deleted. This may cause resource issues and require manual intervention. {{</warning>}}
+
+```sh
+kubectl patch rec <your-rec-name> --type=json -p \
+    '[{"op":"remove","path":"/metadata/finalizers","value":"redbfinalizer.redisenterpriseclusters.app.redislabs.com"}]'
+```
+---
+Title: Connect to the admin console
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Connect to the Redis Enterprise admin console to manage your Redis Enterprise
+  cluster.
+linkTitle: Connect to the admin console
+weight: 10
+url: '/operate/kubernetes/7.8.6/re-clusters/connect-to-admin-console/'
+---
+
+The username and password for the Redis Enterprise Software [admin console]({{< relref "/operate/rs/" >}}) are stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/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. 
+{{</note>}}
+
+1. Switch to the namespace with your Redis Enterprise cluster (REC).
+
+    ```sh
+    kubectl config set-context --current --namespace=<namespace-of-rec>
+    ```
+
+1. Find your cluster name from your list of secrets.
+
+    ```sh
+    kubectl get secret
+    ```
+
+    In this example, the cluster name is `rec`.
+
+1. Extract and decode your credentials from the secret.
+
+    ```sh
+    kubectl get secret <cluster-name> -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <cluster-name> -o jsonpath='{.data.password}' | base64 --decode
+    ```
+
+1. Find the port for the REC UI service in the `spec:ports` section of the service definition file.
+
+    ```sh
+    kubectl get service/<cluster-name>-ui -o yaml
+    ```
+
+    {{<note>}}
+    The default port is 8443.
+    {{</note>}}
+
+1. Use `kubectl port-forward` to forward your local port to the service port.
+
+    ```sh
+    kubectl port-forward service/<cluster-name>-ui <local-port>:<service-port>
+   ```
+
+1. View the admin console from a web browser on your local machine at `https://localhost:8443`.
+
+---
+Title: Expand PersistentVolumeClaim (PVC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Expand your persistent volume claim by editing the REC.
+linkTitle: Expand PVC
+weight: 82
+url: '/operate/kubernetes/7.8.6/re-clusters/expand-pvc/'
+---
+
+This article outlines steps to increase the size of the persistent volume claim for your Redis Enterprise cluster (REC).
+
+{{<note>}} This feature is only supported in versions 7.4.2-12 and above. {{</note>}}
+
+[PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) are created by the Redis Enterprise operator and used by the RedisEnterpriseCluster (REC). PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) with the following steps, if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+This process involves deleting and recreating the REC StatefulSet with a larger persistent volume size. The pods owned by the StatefulSet are not restarted or affected by the deletion and recreation process, except when they are left without an owner momentarily.
+
+{{<note>}}Shrinking (reducing the size) of your PVC is not allowed. This process only allows you to expand (size up) your PVC.{{</note>}}
+
+## Prerequisites
+
+{{<warning>}}Do not change any other REC fields related to the StatefulSet while resizing is in progress.
+{{</warning>}}
+
+- PVC expansion must be supported and enabled by the StorageClass and underlying storage driver of the REC PVCs.
+  - The relevant StorageClass is the one associated with the REC PVCs. The StorageClass for existing PVCs cannot be changed.
+- The StorageClass must be configured with `allowVolumeExpansion: true`.
+- Your storage driver must support online expansion.
+- We highly recommend you backup your databases before beginning this PVC expansion process.
+
+{{<warning>}} OpenShift users should be aware that (`ClusterResourceQuota`) can limit the PVC expansion. Check your quota before resizing using `oc describe clusterresourcequota <quota-name>`.{{</warning>}}
+
+## Expand REC PVC
+
+1. Enable the REC persistent volume resize flag.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+    ```
+
+1. Set the value of `volumeSize` to your desired size.
+
+    ```YAML
+      spec:
+        persistentSpec:
+          enablePersistentVolumeResize: true
+          volumeSize: <new-size>Gi
+    ```
+
+1. Apply the changes to the REC, replacing `<your-rec.yaml>` with the name of your REC.
+
+  ```sh
+  kubectl apply -f <your-rec.yaml>
+  ```
+
+After applying the REC changes, the PVCs will begin to expand to the new size.
+
+Once all the PVCs finish the resizing process, the operator will delete and recreate the StatefulSet with the new volume size.
+
+### Track progress
+
+You can track the progress by monitoring the status of the REC and PersistentVolumeClaim objects.
+
+The REC status will correspond to the status of one or more PVCs, and will reflect if the resizing is successful or failed.
+
+While the resizing is in progress, the status will be:
+
+```yaml
+status:
+  persistenceStatus:
+    status: Resizing
+    succeeded: 2/3
+```
+
+When the resizing is complete, the status becomes Provisioned and the new volume size is available for use by the REC pods.
+
+```yaml
+status:
+  persistenceStatus:
+    status: Provisioned
+    succeeded: 3/3
+```
+
+### Troubleshooting
+
+If an error occurs during this process:
+
+- Examine the status and events of the REC and PVC objects.
+
+  ```sh
+  kubectl describe pvc
+  ```
+
+  ```sh
+  kubectl get events
+  ```
+
+- Examine the logs of the operator pods.
+
+  ```sh
+  kubectl logs <operator_pod_name>
+  ```
+---
+Title: Connect the Prometheus operator to Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This article describes how to configure a Prometheus operator custom
+  resource to allow it to export metrics from Redis Enterprise for Kubernetes.
+linkTitle: Export metrics to Prometheus
+weight: 92
+url: '/operate/kubernetes/7.8.6/re-clusters/connect-prometheus-operator/'
+---
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can connect your [Prometheus](https://prometheus.io/) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+
+## Prerequisites
+
+Before connecting Redis Enterprise to Prometheus on your Kubernetes cluster, make sure you've done the following:
+
+- [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md" >}}) (version 6.2.10-4 or newer)
+- [Deploy the Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md) (version 0.19.0 or newer)
+- [Create a Redis Enterprise cluster]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}})
+
+## Create a `ServiceMonitor` custom resource
+
+Below is an example `ServiceMonitor` custom resource file. By specifying the service label (`app: redis.io/service=prom-metrics`) in the `selector.matchLabels` section, you can point the Prometheus operator to the correct Redis Enterprise service (`<rec_name>-prom`).
+
+You'll need to configure the following fields to connect Prometheus to Redis Enterprise:
+
+| Section | Field | Value |
+|---|---|---|
+| `spec.endpoints` | `port` | Name of exposed port (`prometheus`) |
+| `spec.namespaceSelector` | `matchNames` | Namespace for your REC |
+| `spec.selector` | `matchLabels` | REC service label (`app: redis.io/service=prom-metrics`) |
+
+Apply the file in the same namespace as your Redis Enterprise cluster (REC).
+    {{<note>}}If Redis Enterprise and Prometheus are deployed in different namespaces, you'll also need to add the [`serviceMonitorNamespaceSelector`](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api.md#namespaceselector) field to your Prometheus resource. See the [Prometheus operator documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources) for more details on cross-namespace `ServiceMonitor` configuration.{{</note>}}
+
+
+```YAML
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: redis-enterprise
+spec:
+  endpoints:
+  - interval: 15s
+    port: prometheus
+    scheme: https
+    tlsConfig:
+      insecureSkipVerify: true
+  namespaceSelector:
+    matchNames:
+    - <your_REC_namespace>
+  selector:
+    matchLabels:
+      redis.io/service: prom-metrics
+```
+
+For more info about configuring the `ServiceMonitor` resource, see the [`ServiceMonitorSpec` API documentation](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api-reference/api.md#monitoring.coreos.com/v1.ServiceMonitorSpec).
+
+## More info
+
+- github.com/prometheus-operator
+  - [Getting started](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md)
+  - [Running exporters](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/running-exporters.md)
+  - [Related resources](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/user-guides/getting-started.md#related-resources)
+  - [Troubleshooting ServiceMonitor changes](https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/troubleshooting.md)
+- redis.io/docs
+  - [Metrics in Prometheus]({{< relref "/integrate/prometheus-with-redis-enterprise/prometheus-metrics-definitions" >}})
+  - [Monitoring and metrics]({{< relref "/operate/rs/monitoring/" >}})
+---
+Title: Manage databases in multiple namespaces
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces
+  within your Kubernetes cluster. This article shows you how to configure your Redis
+  Enterprise cluster to connect to databases in multiple namespaces
+linktitle: Manage multiple namespaces
+weight: 17
+url: '/operate/kubernetes/7.8.6/re-clusters/multi-namespace/'
+---
+
+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]({{< relref "/operate/kubernetes/7.8.6/architecture/deployment-options.md" >}}).
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REAADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Prerequisites
+
+Before configuring a multi-namespace deployment, you must have a running [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md" >}}). See more information in the [deployment]({{< relref "/operate/kubernetes/7.8.6/deployment/" >}}) section.
+
+## Create role and role binding for managed namespaces
+
+Both the operator and the RedisEnterpriseCluster (REC) resource need access to each namespace the REC will manage. For each **managed** namespace, create a `role.yaml` and `role_binding.yaml` file within the managed namespace, as shown in the examples below.
+
+{{<note>}}These will need to be reapplied each time you [upgrade]({{< relref "/operate/kubernetes/7.8.6/upgrade/upgrade-redis-cluster.md" >}}). {{</note>}}
+
+Replace `<rec-namespace>` with the namespace the REC resides in.
+Replace `<service-account-name>` with your own value (defaults to the REC name).
+
+`role.yaml` example: 
+
+```yaml
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups:
+      - app.redislabs.com
+    resources: ["redisenterpriseclusters", "redisenterpriseclusters/status", "redisenterpriseclusters/finalizers",
+                "redisenterprisedatabases", "redisenterprisedatabases/status", "redisenterprisedatabases/finalizers",
+                "redisenterpriseremoteclusters", "redisenterpriseremoteclusters/status",
+                "redisenterpriseremoteclusters/finalizers",
+                "redisenterpriseactiveactivedatabases", "redisenterpriseactiveactivedatabases/status",
+                "redisenterpriseactiveactivedatabases/finalizers"]
+    verbs: ["delete", "deletecollection", "get", "list", "patch", "create", "update", "watch"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["update", "get", "read", "list", "listallnamespaces", "watch", "watchlist",
+            "watchlistallnamespaces", "create","patch","replace","delete","deletecollection"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create"]
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["get", "watch", "list", "update", "patch", "create", "delete"]
+```
+
+`role_binding.yaml` example:
+
+```yaml
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: <rec-namespace>
+- kind: ServiceAccount
+  name: <service-account-name>
+  namespace: <rec-namespace>
+roleRef:
+  kind: Role
+  name: redb-role
+  apiGroup: rbac.authorization.k8s.io
+```
+
+Apply the files, replacing `<managed-namespace>` with your own values:
+
+```sh
+kubectl apply -f role.yaml -n <managed-namespace>
+kubectl apply -f role_binding.yaml -n <managed-namespace>
+```
+
+{{<note>}}
+If the REC is configured to watch a namespace without setting the role and role binding permissions, or a namespace that is not yet created, the operator will fail and halt normal operations.
+{{</note>}}
+
+
+## Update Redis Enterprise operator ConfigMap
+
+There are two methods of updating the operator ConfigMap (`operator-environment-config`) to specify which namespaces to manage.
+
+- Method 1: Configure the operator to watch for a namespace label and add this label to managed namespaces (available in versions 6.4.2-4 or later).
+- Method 2: Configure the operator with an explicit list of namespaces to manage.
+
+You can create this ConfigMap manually before deployment, or it will be created automatically after the operator was deployed.
+
+
+### Method 1: Namespace label (available in versions 6.4.2-4 or later)
+
+1. Create the `cluster_role_binding.yaml` and `cluster_role.yaml` files. Replace the `<rec-namespace>` with the namespace the Redis Enterprise cluster (REC) resides in.
+
+  `operator_cluster_role.yaml` example:
+
+  ```yaml
+    apiVersion: rbac.authorization.k8s.io/v1
+    kind: ClusterRole
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    rules:
+      - apiGroups: [""]
+        resources: ["namespaces"]
+        verbs: ["list", "watch"]
+  ```
+
+  `operator_cluster_role_binding.yaml` example:
+
+  ```yaml
+    kind: ClusterRoleBinding
+    apiVersion: rbac.authorization.k8s.io/v1
+    metadata:
+      name: redis-enterprise-operator-consumer-ns
+      labels:
+        app: redis-enterprise
+    subjects:
+    - kind: ServiceAccount
+      name: redis-enterprise-operator
+      namespace: <rec-namespace>
+    roleRef:
+      kind: ClusterRole
+      name: redis-enterprise-operator-consumer-ns
+      apiGroup: rbac.authorization.k8s.io
+  ```
+
+2. Apply the files.
+
+  ```sh
+  kubectl apply -f operator_cluster_role.yaml
+  kubectl apply -f operator_cluster_role_binding.yaml 
+  ```
+
+3. Patch the ConfigMap in the REC namespace (`<rec-namespace>`) to identify the managed namespaces with your label (`<label-name>`).
+
+  ```sh
+   kubectl patch ConfigMap/operator-environment-config \
+  -n <rec-namespace> \
+  --type merge \
+  -p '{"data": {"REDB_NAMESPACES_LABEL": "<label-name>"}}'
+  ```
+
+4. For each managed namespace, apply the same label. Replace `<managed-namespace>` with the namespace the REC will manage. Replace `<label-name>` with the value used in the previous step. If you specify a value for `<label-value>`, both the label name and value in managed namespaces must match to be detected by the operator. If the `<label-value>` is empty, only the label name needs to match on managed namespaces and the value is disregarded.
+
+
+  ```sh
+  kubectl label namespace <managed-namespace> <label-name>=<label-value>
+  ```
+
+{{<note>}}
+The operator restarts when it detects a namespace label was added or removed.
+{{</note>}}
+
+### Method 2: Explicit namespace list
+
+Patch the `operator-environment-config` in the REC namespace with a new environment variable (`REDB_NAMESPACES`).
+
+```sh
+kubectl patch ConfigMap/operator-environment-config \ 
+-n <rec-namespace> \
+--type merge \
+-p '{"data":{"REDB_NAMESPACES": "<comma,separated,list,of,namespaces,to,watch"}}'
+```
+
+{{<warning>}}
+Only configure the operator to watch a namespace after the namespace is created and configured with the role/role_binding as explained above. If configured to watch a namespace without setting those permissions or a namespace that is not created yet, the operator will fail and not perform normal operations.
+{{</warning>}}
+---
+Title: Redis Enterprise clusters (REC)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise clusters (REC).
+hideListLinks: false
+linkTitle: Redis Enterprise clusters (REC)
+weight: 30
+url: '/operate/kubernetes/7.8.6/re-clusters/'
+---
+
+This section contains articles to help you manage your Redis Enterprise clusters (REC).
+
+
+
+---
+Title: Use Auto Tiering on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Deploy a cluster with Auto Tiering on Kubernetes.
+linkTitle: Auto Tiering
+weight: 16
+url: '/operate/kubernetes/7.8.6/re-clusters/auto-tiering/'
+---
+
+## Prerequisites
+
+Redis Enterprise Software for Kubernetes supports using Auto Tiering (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+{{<note>}}
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+{{</note>}}
+
+Before creating your Redis clusters or databases, these SSDs must be:
+
+- [locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+- formatted and mounted on the nodes that will run Redis Enterprise pods
+- dedicated to Auto Tiering and not shared with other parts of the database, (e.g. durability, binaries)
+- [provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
+  - You can use a [local volume provisioner](https://github.com/kubernetes-sigs/sig-storage-local-static-provisioner/blob/master/README.md) to do this [dynamically](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#dynamic)
+- a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource with a unique name
+
+For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
+
+## Create a Redis Enterprise cluster
+
+To deploy a Redis Enterprise cluster (REC) with Auto Tiering, you'll need to specify the following in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api" >}}):
+
+- enable Auto Tiering (`enabled: true`)
+- flash storage driver (`bigStoreDriver`)
+  - `rocksdb` or `speedb`(default)
+- storage class name (`storageClassName`)
+- minimal flash disk size (`flashDiskSize`)
+
+{{<note>}} Clusters upgraded to version 7.2.4-2 from an earlier version will change the `bigStoreDriver` (previously called `flashStorageEngine`) to the new default `speedb`, regardless of previous configuration. {{</note>}}
+
+{{<warning>}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{</warning>}}
+
+Here is an example of an REC custom resource with these attributes:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: "rec"
+spec:
+  
+  nodes: 3
+  redisOnFlashSpec:
+    enabled: true
+    bigStoreDriver: speedb
+    storageClassName: local-scsi
+    flashDiskSize: 100G
+```
+
+### Create a Redis Enterprise database
+
+By default, any new database will use RAM only. To create a Redis Enterprise database (REDB) that can use flash storage, specify the following in the `redisEnterpriseCluster` section of the REDB custom resource definition:
+
+- `isRof: true` enables Auto Tiering
+- `rofRamSize` defines the RAM capacity for the database
+
+Below is an example REDB custom resource:
+
+```YAML
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: autoteiring-redb
+spec:
+  redisEnterpriseCluster:
+    name: rec
+  isRof: true
+  memorySize: 2GB
+  rofRamSize: 0.5GB
+```
+
+{{< note >}}
+This example defines both `memorySize` and `rofRamSize`. When using Auto Tiering, `memorySize` refers to the total combined memory size (RAM + flash) allocated for the database. `rofRamSize` specifies only the RAM capacity for the database. `rofRamSize` must be at least 10% of `memorySize`.
+{{< /note >}}
+---
+Title: Create Active-Active databases with crdb-cli
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section shows how to set up an Active-Active Redis Enterprise database
+  on Kubernetes using the Redis Enterprise Software operator.
+linkTitle: Create Active-Active with crdb-cli
+weight: 99
+url: '/operate/kubernetes/7.8.6/active-active/create-aa-crdb-cli/'
+---
+{{<note>}} Versions 6.4.2 and later support the Active-Active database controller. This controller allows you to create Redis Enterprise Active-Active databases (REAADB) and Redis Enterprise remote clusters (RERC) with custom resources. We recommend using the [REAADB method for creating Active-Active databases]({{< relref "/operate/kubernetes/7.8.6/active-active/create-reaadb.md" >}}).{{</note>}}
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read-and-write access to the same dataset from different Kubernetes clusters. For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/7.8.6/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.
+
+This process consists of:
+
+1. Documenting values to be used in later steps. It's important these values are correct and consistent.
+1. Editing the Redis Enterprise cluster (REC) spec file to include the `ActiveActive` section. This will be slightly different depending on the K8s distribution you are using.
+1. Creating the database with the `crdb-cli` command. These values must match up with values in the REC resource spec.
+
+## Prerequisites
+
+Before creating Active-Active databases, you'll need admin access to two or more working Kubernetes clusters that each have:
+
+- Routing for external access with an [ingress resources]({{< relref "/operate/kubernetes/7.8.6/networking/ingress.md" >}}) (or [route resources]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}) on OpenShift).
+- A working [Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api" >}}) with a unique name.
+- Enough memory resources available for the database (see [hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}})).
+
+{{<note>}} The `activeActive` field and the `ingressOrRouteSpec` field cannot coexist in the same REC. If you configured your ingress via the `ingressOrRouteSpec` field in the REC, create your Active-Active database with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource.{{</note>}}
+
+## Document required parameters
+
+The most common mistake when setting up Active-Active databases is incorrect or inconsistent parameter values. The values listed in the resource file must match those used in the crdb-cli command.
+
+- **Database name** `<db-name>`:
+  - Description: Combined with ingress suffix to create the Active-Active database hostname
+  - Format: string
+  - Example value: `myaadb`
+  - How you get it: you choose
+  - The database name requirements are:
+       - Maximum of 63 characters
+       - Only letter, number, or hyphen (-) characters
+       - Starts with a letter; ends with a letter or digit.
+       - Database name is not case-sensitive
+
+You'll need the following information for each participating Redis Enterprise cluster (REC):
+
+{{<note>}}
+You'll need to create DNS aliases to resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address for the ingress controller’s LoadBalancer (or routes in Openshift) for each database. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as *.ijk.example.com).
+{{</note>}}
+
+- **REC hostname** `<rec-hostname>`:
+  - Description: Hostname used to identify your Redis Enterprise cluster in the `crdb-cli` command. This MUST be different from other participating clusters.
+  - Format: `<rec-name>.<namespace>.svc.cluster.local`
+  - Example value: `rec01.ns01.svc.cluster.local`
+  - How to get it: List all your Redis Enterprise clusters
+      ```bash
+      kubectl get rec
+      ```
+- **API hostname** `<api-hostname>`:
+  - Description: Hostname used to access the Redis Enterprise cluster API from outside the K8s cluster
+  - Format: string
+  - Example value: `api.ijk.example.com`
+- **Ingress suffix** `<ingress-suffix>`:
+  - Description: Combined with database name to create the Active-Active database hostname
+  - Format: string
+  - Example value: `-cluster.ijk.example.com`
+- [**REC admin credentials**]({{< relref "/operate/kubernetes/7.8.6/security/manage-rec-credentials.md" >}}) `<username> <password>`:
+  - Description: Admin username and password for the REC stored in a secret
+  - Format: string
+  - Example value: username: `user@example.com`, password: `something`
+  - How to get them:
+    ```sh
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.username}' | base64 --decode
+    kubectl get secret <rec-name> \
+      -o jsonpath='{.data.password}' | base64 --decode
+    ```
+- **Replication hostname** `<replication-hostname>`:
+  - Description: Hostname used inside the ingress for the database
+  - Format: `<db-name><ingress-suffix>`
+  - Example value: `myaadb-cluster.ijk.example.com`
+  - How to get it: Combine `<db-name>` and `<ingress-suffix`> values you documented above.
+- **Replication endpoint** `<replication-endpoint>`:
+  - Description: Endpoint used externally to contact the database
+  - Format: `<db-name><ingress-suffix>:443`
+  - Example value: `myaadb-cluster.ijk.example.com:443`
+  - How to get it:`<replication-hostname>:443`
+
+## Add `activeActive` section to the REC resource file
+
+From inside your K8s cluster, edit your Redis Enterprise cluster (REC) resource to add the following to the `spec` section. Do this for each participating cluster.
+
+ The operator uses the API hostname (`<api-hostname>`) to create an ingress to the Redis Enterprise cluster's API; this only happens once per cluster. Every time a new Active-Active database instance is created on this cluster, the operator creates a new ingress route to the database with the ingress suffix (`<ingress-suffix>`). The hostname for each new database will be in the format <nobr>`<db-name><ingress-suffix>`</nobr>.
+
+### Using ingress controller
+
+1. If your cluster uses an [ingress controller]({{< relref "/operate/kubernetes/7.8.6/networking/ingress.md" >}}), add the following to the `spec` section of your REC resource file.
+
+  Nginx:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+       kubernetes.io/ingress.class: nginx
+      nginx.ingress.kubernetes.io/backend-protocol: HTTPS
+      nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+HAproxy:
+
+  ```sh
+  activeActive:
+    apiIngressUrl: <api-hostname>
+    dbIngressSuffix: <ingress-suffix>
+    ingressAnnotations:
+      kubernetes.io/ingress.class: haproxy
+       ingress.kubernetes.io/ssl-passthrough: "true"
+    method: ingress
+  ```
+
+2. After the changes are saved and applied, you can verify a new ingress was created for the API.
+
+    ```sh
+    $ kubectl get ingress
+    NAME   HOSTS                            ADDRESS                                 PORTS   AGE
+    rec01  api.abc.cde.example.com  225161f845b278-111450635.us.cloud.com   80      24h
+    ```
+
+3. Verify you can access the API from outside the K8s cluster.
+
+    ```sh
+   curl -k -L -i -u <username>:<password> https://<api-hostname>/v1/cluster
+    ```
+
+    If the API call fails, create a DNS alias that resolves your API hostname (`<api-hostname>`) to the IP address for the ingress controller's LoadBalancer.
+
+4. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the IP address of the ingress controller’s LoadBalancer. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+#### If using Istio Gateway and VirtualService
+
+No changes are required to the REC spec if you are using [Istio]({{< relref "/operate/kubernetes/7.8.6/networking/istio-ingress.md" >}}) in place of an ingress controller. The `activeActive` section added above creates ingress resources. The two custom resources used to configure Istio (Gateway and VirtualService) replace the need for ingress resources.
+
+{{<warning>}}
+These custom resources are not controlled by the operator and you will need to configure and maintain them manually.
+{{</warning>}}
+
+For each cluster, verify the VirtualService resource has two `- match:` blocks in the `tls` section. The hostname under `sniHosts:` should match your `<replication-hostname>`.
+
+### Using OpenShift routes
+
+1. Make sure your Redis Enterprise cluster (REC) has a different name (`<rec-name.namespace>`) than any other participating clusters. If not, you'll need to manually rename the REC or move it to a different namespace.
+            You can check your new REC name with:
+    ```sh
+    oc get rec -o jsonpath='{.items[0].metadata.name}'
+    ```
+
+    If the rec name was modified, reapply [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml) to the namespace to reestablish security privileges.
+    
+    ```sh
+    oc apply -f scc.yaml
+    oc adm policy add-scc-to-group redis-enterprise-scc-v2  system:serviceaccounts:<namespace>
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Make sure you have DNS aliases for each database that resolve your API hostname `<api-hostname>`,`<ingress-suffix>`, `<replication-hostname>` to the route IP address. To avoid entering multiple DNS records, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. If your cluster uses [OpenShift routes]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}), add the following to the `spec` section of your Redis Enterprise cluster (REC) resource file.
+
+      ```sh
+      activeActive:
+        apiIngressUrl: <api-hostname>
+        dbIngressSuffix: <ingress-suffix>
+        method: openShiftRoute
+      ```
+
+1. Make sure you have DNS aliases that resolve to the routes IP for both the API hostname (`<api-hostname>`) and the replication hostname (`<replication-hostname>`) for each database. To avoid entering each database individually, you can use a wildcard in your alias (such as `*.ijk.example.com`).
+
+1. After the changes are saved and applied, you can see that a new route was created for the API.
+
+    ```sh
+    $ oc get route
+    NAME    HOST/PORT                       PATH    SERVICES  PORT  TERMINATION   WILDCARD
+    rec01   api-openshift.apps.abc.example.com rec01   api             passthrough   None
+    ```
+
+## Create an Active-Active database with `crdb-cli`
+
+The `crdb-cli` command can be run from any Redis Enterprise pod hosted on any participating K8s cluster. You'll need the values for the [required parameters]({{< relref "/operate/kubernetes/7.8.6/active-active/create-aa-crdb-cli#document-required-parameters" >}}) for each Redis Enterprise cluster.
+
+```sh
+crdb-cli crdb create \
+  --name <db-name> \
+  --memory-size <mem-size> \
+  --encryption yes \
+  --instance fqdn=<rec-hostname-01>,url=https://<api-hostname-01>,username=<username-01>,password=<password-01>,replication_endpoint=<replication-endpoint-01>,replication_tls_sni=<replication-hostname-01> \
+  --instance fqdn=<rec-hostname-02>,url=https://<api-hostname-02>,username=<username-02>,password=<password-02>,replication_endpoint=<replication-endpoint-02>,replication_tls_sni=<replication-hostname-02>
+```
+
+To create a database that syncs between more than two instances, add additional `--instance` arguments.
+
+See the [`crdb-cli` reference]({{< relref "/operate/rs/references/cli-utilities/crdb-cli" >}}) for more options.
+
+## Test your database
+
+The easiest way to test your Active-Active database is to set a key-value pair in one database and retrieve it from the other.
+
+You can connect to your databases with the instructions in [Manage databases]({{< relref "/operate/kubernetes/7.8.6/re-databases/db-controller#connect-to-a-database" >}}). Set a test key with `SET foo bar` in the first database. If your Active-Active deployment is working properly, when connected to your second database, `GET foo` should output `bar`.
+---
+Title: Set global database secret
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations' to set the
+  global database secret.
+linkTitle: Global database secret
+weight: 50
+url: '/operate/kubernetes/7.8.6/active-active/global-db-secret/'
+---
+{{<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.{{</note>}}
+
+## 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.
+
+To edit other global configruations, see [global configuration]({{< relref "/operate/kubernetes/7.8.6/active-active/global-config.md" >}})
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the database password.
+
+  This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+  ```yaml
+  apiVersion: v1
+  data:
+    password: bXktcGFzcw
+  kind: Secret
+  metadata:
+    name: my-db-secret
+  type: Opaque
+  ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    example-aadb-1   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit Redis Enterprise remote clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Edit the configuration details of an existing RERC with Redis Enterprise
+  for Kubernetes.
+linkTitle: Edit RERC
+weight: 60
+url: '/operate/kubernetes/7.8.6/active-active/edit-rerc/'
+---
+{{<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.{{</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.
+
+The RERC controller periodically connects to the local REC endpoint via its external address, to ensure it’s setup correctly. For this to work, the external load balancer must support [NAT hairpinning](https://en.wikipedia.org/wiki/Network_address_translation#NAT_loopback). In some cloud environments, this may involve disabling IP preservation for the load balancer target groups.
+
+For more details, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+## Edit RERC
+
+Use the `kubectl patch rerc <rerc-name> --type merge --patch` command to patch the local RERC custom resource with your changes. For a full list of available fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+The following example edits the `dbFqdnSuffix` field for the RERC named `rerc-ohare`.
+
+```sh
+kubectl patch rerc rerc-ohare --type merge --patch \
+'{"spec":{"dbFqdnSuffix": "-example2-cluster-rec-chicago-ns-illinois.example.com"}}'
+```
+
+## Update RERC secret
+
+If the credentials are changed or updated for a REC participating cluster, you need to manually edit the RERC secret and apply it to all participating clusters.
+
+1. On the local cluster, update the secret with new credentials and name it with the following convention:  `redis-enterprise-<rerc-name>`.
+
+    A secret for a remote cluster named `rerc-ohare` would be similar to the following:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: PHNvbWUgcGFzc3dvcmQ+
+      username: PHNvbWUgdXNlcj4
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+    ```
+
+1. Apply the file.
+
+    ```sh
+    kubectl apply -f <secret-file>
+    ```
+
+1. Watch the RERC to verify the status is "Active" and the spec status is "Valid."
+
+      ```sh
+      kubectl get rerc <rerc-name>
+      ```
+
+    The output should look like this:
+  
+      ```sh
+       NAME        STATUS   SPEC STATUS   LOCAL
+        rerc-ohare   Active   Valid         true
+      ```
+      
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.8.6/logs/" >}}).
+
+1. Verify the status of each REAADB using that RERC is "Active" and the spec status is "Valid."
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up
+    ```
+
+    To troubleshoot invalid configurations, view the RERC custom resource events and the [Redis Enterprise operator logs]({{< relref "/operate/kubernetes/7.8.6/logs/" >}}).
+
+1. Repeat the above steps on all other participating clusters.
+---
+Title: Prepare participating clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Prepare your participating RECs to be part of an Active-Active database
+  deployment.
+linkTitle: Prepare clusters
+weight: 10
+url: '/operate/kubernetes/7.8.6/active-active/prepare-clusters/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.8.6/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.8.6/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+Next you'll [collect credentials](#collect-rec-credentials) for your participating clusters and create secrets for the RedisEnterprsieRemoteCluster (RERC) to use.
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+## Collect REC credentials
+
+To communicate with other clusters, all participating clusters will need access to the admin credentials for all other clusters.
+
+1. Create a file to hold the admin credentials for all participating RECs (such as `all-rec-secrets.yaml`).
+
+1. Within that file, create a new secret for each participating cluster named `redis-enterprise-<rerc-name>`.
+
+    The example below shows a file (`all-rec-secrets.yaml`) holding secrets for two participating clusters:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: 
+      username: 
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Get the REC credentials secret for each participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    The admin credentials secret for an REC named `rec-chicago` would be similar to this:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-chicago
+    type: Opaque
+    ```
+
+1. Add the username and password to the new secret for that REC and namespace.
+
+    This example shows the collected secrets file (`all-rec-secrets.yaml`) for `rerc-ohare` (representing `rec-chicago` in namespace `ns-illinois`) and `rerc-reagan` (representing `rec-arlington` in namespace `ns-virginia`).
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-ohare
+    type: Opaque
+
+    ---
+
+    apiVersion: v1
+    data:
+      password: KLmndo123456
+      username: PQrst789010
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-reagan
+    type: Opaque
+
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <all-rec-secrets-file>
+    ```
+
+   If the admin credentials for any of the clusters changes, the file will need to be updated and reapplied to all clusters.
+
+## Next steps
+
+Now you are ready to [create your Redis Enterprise Active-Active database]({{< relref "/operate/kubernetes/7.8.6/active-active/create-reaadb.md" >}}).
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+---
+Title: Set global database configurations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The REAADB contains the field '.spec.globalConfigurations'. Use
+  this to set the database configurations.
+linkTitle: Global configuration
+weight: 50
+url: '/operate/kubernetes/7.8.6/active-active/global-config/'
+---
+{{<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.{{</note>}}
+
+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]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_active_active_database_api">}}) contains a full list of available fields.
+
+## Edit global configurations
+
+1. Edit or patch the REAADB custom resource with your global configuration changes.
+
+    The example command below patches the REAADB named `reaadb-boeing` to set the global memory size to 200MB:
+
+    ```sh
+    kubectl patch reaadb reaadb-boeing --type merge --patch \
+    '{"spec": {"globalConfigurations": {"memorySize": "200mb"}}}'
+    ```
+
+1. Verify the status is `active` and the spec status is `Valid`.
+
+    This example shows the status for the `reaadb-boeing` database.
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid    
+    ```
+
+1. View the global configurations on each participating cluster to verify they are synced.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o yaml
+    ```
+
+## Edit global configuration secrets
+
+This section edits the secrets under the REAADB `.spec.globalConfigurations` section. For more information and all available fields, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_active_active_database_api">}}).
+
+
+1. On an existing participating cluster, generate a YAML file containing the database secret with the relevant data.
+
+    This example shoes a secret named `my-db-secret` with the password `my-password` encoded in base 64.
+
+    ```yaml
+    apiVersion: v1
+     data:
+      password: bXktcGFzcw
+    kind: Secret
+    metadata:
+      name: my-db-secret
+    type: Opaque
+    ```
+
+1. Apply the secret file from the previous step, substituting your own value for `<db-secret-file>`.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Patch the REAADB custom resource to specify the database secret, substituting your own values for `<reaadb-name>` and `<secret-name>`.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> --type merge --patch \
+    '{"spec": {"globalConfigurations": {"databaseSecretName": "secret-name"}}}'
+    ```
+
+1. Check the REAADB status for an `active` status and `Valid` spec status.
+
+    ```sh
+    kubectl get reaadb <reaadb-name>
+
+    NAME             STATUS   SPEC STATUS   GLOBAL CONFIGURATIONS REDB   LINKED REDBS
+    reaadb-boeing   active   Valid
+    ```
+
+1. On each other participating cluster, check the secret status.
+
+    ``sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.secretsStatus}'
+    ```
+
+    The output should show the status as `Invalid`.
+
+    ```sh
+    [{"name":"my-db-secret","status":"Invalid"}]
+    ```
+
+1. Sync the secret on each participating cluster.
+
+    ```sh
+    kubectl apply -f <db-secret-file>
+    ```
+
+1. Repeat the previous two steps on every participating cluster.
+---
+Title: Edit participating clusters for Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Steps to add or remove a participating cluster to an existing Active-Active
+  database with Redis Enterprise for Kubernetes.
+linkTitle: Edit participating clusters
+weight: 40
+url: '/operate/kubernetes/7.8.6/active-active/edit-clusters/'
+---
+{{<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.{{</note>}}
+
+## Add a participating cluster
+
+Use the following steps to add a participating cluster to an existing Redis Enterprise Active-Active database (REAADB) for Kubernetes.
+
+### Prerequisites
+
+To prepare the Redis Enterprise cluster (REC) to participate in an Active-Active database, perform the following tasks from [Prepare participating clusters]({{< relref "/operate/kubernetes/7.8.6/active-active/prepare-clusters.md" >}}):
+
+- Make sure the cluster meets the hardware and naming requirements.
+- Enable the Active-Active controllers.
+- Configure external routing.
+- Configure `ValidatingWebhookConfiguration`.
+
+### Collect REC credentials
+
+To communicate with other clusters, all participating clusters need access to the admin credentials for all other clusters.
+
+1. Get the REC credentials secret for the new participating cluster.
+
+    ```sh
+    kubectl get secret -o yaml <rec-name>
+    ```
+
+    This example shows an admin credentials secret for an REC named `rec-boston`:
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: rec-boston
+    type: Opaque
+    ```
+
+1. Create a secret for the new participating cluster named `redis-enterprise-<rerc>` and add the username and password.
+
+    The example below shows a secret file for a remote cluster named `rerc-logan` .
+
+    ```yaml
+    apiVersion: v1
+    data:
+      password: ABcdef12345
+      username: GHij56789
+    kind: Secret
+    metadata:
+      name: redis-enterprise-rerc-logan
+    type: Opaque
+    ```
+
+1. Apply the file of collected secrets to every participating REC.
+
+    ```sh
+    kubectl apply -f <rec-secret-file>
+    ```
+
+ If the admin credentials for any of the clusters change, update and reapply the file to all clusters.
+
+### Create RERC
+
+1. From one of the existing participating clusters, create a `RedisEnterpriseRemoteCluster` (RERC) custom resource for the new participating cluster.
+
+    This example shows an RERC custom resource for an REC named `rec-boston` in the namespace `ns-massachusetts`. 
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-logan
+    spec:
+      recName: rec-boston
+      recNamespace: ns-massachusetts
+      apiFqdnUrl: test-example-api-rec-boston-ns-massachusetts.example.com
+      dbFqdnSuffix: -example-cluster-rec-boston-ns-massachusetts.example.com
+      secretName: redis-enterprise-rerc-logan
+    ```
+
+1. Create the RERC custom resource.
+
+    ```sh
+    kubectl create -f <new-RERC-file>
+    ```
+
+1. Check the status of the newly created RERC custom resource.
+
+    ```sh
+    kubectl get rerc <RERC-name>
+    ```
+
+    The output should look like this:
+
+    ```sh
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-logan   Active   Valid         true
+    ```
+
+### Edit REAADB spec
+
+1. Patch the REAADB spec to add the new RERC name to the `participatingClusters`, replacing `<reaadb-name>` and `<rerc-name>` with your own values.
+
+    ```sh
+    kubectl patch reaadb <reaadb-name> < --type merge --patch '{"spec": {"participatingClusters": [{"name": "<rerc-name>"}]}}'
+    ```
+
+1. View the REAADB `participatingClusters` status to verify the cluster was added.
+
+    ```sh
+    kubectl get reaadb <reaadb-name> -o=jsonpath='{.status.participatingClusters}'
+    ```
+
+    The output should look like this:
+
+    ```sh
+    [{"id":1,"name":"rerc-ohare"},{"id":2,"name":"rerc-reagan"},{"id":3,"name":"rerc-logan"}]
+    ```
+
+## Remove a participating cluster
+
+1. On an existing participating cluster,remove the desired cluster from the `participatingCluster` section of the REAADB spec.
+
+    ```sh
+    kubectl edit reaadb <reaadb-name>
+    ```
+
+1. On each of the other participating clusters, verify the status is `active` and the spec status is `Valid` and the cluster was removed.
+
+   ```sh
+   kubectl get reaadb <reaadb-name -o=jasonpath=`{.status}`
+   ```
+   
+    The output should look like this:
+    
+    ```sh
+    {... ,"participatingClusters":[{"id":1,"name":"rerc1"},{"id":2,"name":"rerc2"}],"redisEnterpriseCluster":"rec1","specStatus":"Valid","status":"active"}
+    ```
+
+1. On the removed participating cluster, list all REAADB resources on the cluster to verify they were deleted.
+
+
+    ```sh
+    kubectl get reaadb -o+jasonpath=`{range.items[*]}{.metadata.name}`
+    ```
+---
+Title: Create Active-Active database (REAADB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: Create database
+weight: 30
+url: '/operate/kubernetes/7.8.6/active-active/create-reaadb/'
+---
+
+{{<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.{{</note>}}
+
+## 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.
+
+1. Configure the [admission controller and ValidatingWebhook]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md#enable-the-admission-controller/" >}}).
+   {{<note>}}These are installed and enabled by default on clusters created via the OpenShift OperatorHub. {{</note>}}
+
+2. Create two or more [RedisEnterpriseCluster (REC) custom resources]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start#create-a-redis-enterprise-cluster-rec" >}}) with enough [memory resources]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+   * Name of each REC (`<rec-name>`)
+   * Namespace for each REC (`<rec-namespace>`)
+
+3. Configure the REC [`ingressOrRoutes` field]({{< relref "/operate/kubernetes/7.8.6/networking/ingressorroutespec.md" >}}) and [create DNS records]({{< relref "/operate/kubernetes/7.8.6/networking/ingressorroutespec#configure-dns/" >}}).
+   * REC API hostname (`api-<rec-name>-<rec-namespace>.<subdomain>`)
+   * Database hostname suffix (`-db-<rec-name>-<rec-namespace>.<subdomain>`)
+
+4. [Prepare participating clusters]({{< relref "/operate/kubernetes/7.8.6/active-active/prepare-clusters.md" >}})
+   * RERC name (`<rerc-name`>)
+   * RERC secret name (`redis-enterprise-<rerc-name>`)
+
+For a list of example values used throughout this article, see the [Example values](#example-values) section.
+
+## Create `RedisEnterpriseRemoteCluster` resources {#create-rerc}
+
+1. Create a `RedisEnterpriseRemoteCluster` (RERC) custom resource file for each participating Redis Enterprise cluster (REC).
+
+   Below are examples of RERC resources for two participating clusters. Substitute your own values to create your own resource.
+
+    Example RERC (`rerc-ohare`) for the REC named `rec-chicago` in the namespace `ns-illinois`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-ohare
+    spec:
+      recName: rec-chicago
+      recNamespace: ns-illinois
+      apiFqdnUrl: api-rec-chicago-ns-illinois.example.com
+      dbFqdnSuffix: -db-rec-chicago-ns-illinois.example.com
+      secretName: redis-enterprise-rerc-ohare
+    ```
+
+    Example RERC (`rerc-raegan`) for the REC named `rec-arlington` in the namespace `ns-virginia`:
+
+    ```yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseRemoteCluster
+    metadata:
+      name: rerc-reagan
+    spec:
+      recName: rec-arlington
+      recNamespace: ns-virginia
+      apiFqdnUrl: test-example-api-rec-arlington-ns-virginia.example.com
+      dbFqdnSuffix: -example-cluster-rec-arlington-ns-virginia.example.com
+      secretName: redis-enterprise-rerc-reagan
+    ```
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise remote cluster from each RERC custom resource file.
+  
+   ```sh
+   kubectl create -f <rerc-file>
+   ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, then your configurations are correct.
+  
+    ```sh
+    kubectl get rerc <rerc-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get rerc rerc-ohare
+
+    NAME        STATUS   SPEC STATUS   LOCAL
+    rerc-ohare   Active   Valid         true
+    ```
+  
+    In case of errors, review the RERC custom resource events and the Redis Enterprise operator logs.
+
+## Create `RedisEnterpriseActiveActiveDatabase` resource {#create-reaadb}
+
+1. Create a `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource file meeting the naming requirements and listing the names of the RERC custom resources created in the last step.
+
+    Naming requirements:
+    * less than 63 characters
+    * contains only lowercase letters, numbers, or hyphens
+    * starts with a letter
+    * ends with a letter or digit
+
+    Example REAADB named `reaadb-boeing` linked to the REC named `rec-chicago` with two participating clusters and a global database configuration with shard count set to 3:
+
+     ```yaml
+     apiVersion: app.redislabs.com/v1alpha1
+     kind: RedisEnterpriseActiveActiveDatabase
+     metadata:
+       name: reaadb-boeing
+     spec:
+       globalConfigurations:
+         databaseSecretName: <my-secret>
+         memorySize: 200MB
+         shardCount: 3
+       participatingClusters:
+           - name: rerc-ohare
+           - name: rerc-reagan
+     ```
+
+     {{<note>}}Sharding is disabled on Active-Active databases created with a `shardCount` of 1. Sharding cannot be enabled after database creation. {{</note>}}
+
+    For more details on RERC fields, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+1. Create a Redis Enterprise Active-Active database from the REAADB custom resource file.
+  
+    ```sh
+    kubectl create -f <reaadb-file>
+    ```
+
+1. Check the status of your RERC. If `STATUS` is `Active` and `SPEC STATUS` is `Valid`, your configurations are correct.
+  
+    ```sh
+    kubectl get reaadb <reaadb-name>
+    ```
+
+    The output should look similar to:
+
+    ```sh
+    kubectl get reaadb reaadb-boeing
+
+    NAME              STATUS   SPEC STATUS   LINKED REDBS   REPLICATION STATUS
+    reaadb-boeing     active   Valid                        up             
+    ```
+
+  
+    In case of errors, review the REAADB custom resource events and the Redis Enterprise operator logs.
+
+## Example values
+
+This article uses the following example values:
+
+#### Example cluster 1
+
+* REC name: `rec-chicago`
+* REC namespace: `ns-illinois`
+* RERC name: `rerc-ohare`
+* RERC secret name: `redis-enterprise-rerc-ohare`
+* API FQDN: `api-rec-chicago-ns-illinois.example.com`
+* DB FQDN suffix: `-db-rec-chicago-ns-illinois.example.com`
+
+#### Example cluster 2
+
+* REC name: `rec-arlington`
+* REC namespace: `ns-virginia`
+* RERC name: `rerc-raegan`
+* RERC secret name: `redis-enterprise-rerc-reagan`
+* API FQDN: `api-rec-arlington-ns-virginia.example.com`
+* DB FQDN suffix: `-db-rec-arlington-ns-virginia.example.com`
+
+---
+Title: Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Content related to Active-Active Redis Enterprise databases for Kubernetes.
+hideListLinks: true
+linkTitle: Active-Active databases
+weight: 40
+url: '/operate/kubernetes/7.8.6/active-active/'
+---
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters.
+
+## Active-Active setup methods
+
+There are two methods for creating an Active-Active database with Redis Enterprise for Kubernetes:
+
+- The `RedisEnterpriseActiveActiveDatabase` (REAADB) custom resource is available for versions 6.4.2 and later.
+- The `crdb-cli` method is available for versions 6.4.2 or earlier.
+
+
+We recommend creating new Active-Active databases using the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. This allows you to manage your Active-Active database with the operator and ensures you have the latest features and functionality.
+
+### Active-Active controller method
+
+Versions 6.4.2-6 or later fully support the Active-Active controller. Some of these features were available as a preview in 6.4.2-4 and 6.4.2-5. Upgrade to 6.4.2-6 for the full set of general availability features and bug fixes.
+
+This setup method includes the following steps:
+
+1. Gather REC credentials and [prepare participating clusters]({{< relref "/operate/kubernetes/7.8.6/active-active/prepare-clusters.md" >}}).
+2. Create [`RedisEnterpriseRemoteCluster` (RERC)]({{< relref "/operate/kubernetes/7.8.6/active-active/create-reaadb#create-rerc" >}}) resources.
+3. Create [`RedisEnterpriseActiveActiveDatabase` (REAADB)]({{< relref "/operate/kubernetes/7.8.6/active-active/create-reaadb#create-reaadb" >}}) resource.
+
+### `crdb-cli` method
+
+For versions 6.4.2 or earlier, this Active-Active setup method includes the following steps:
+
+1. Install and configure an ingress.
+2. Gather configuration details.
+3. Add the `ActiveActive` field to the REC spec.
+4. Create the database with the `crdb-cli` tool.
+
+## Redis Enterprise Active-Active controller for Kubernetes
+
+{{<note>}}These features are supported for general availability in releases 6.4.2-6 and later.{{</note>}}
+
+[Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases give you read-and-write access to Redis Enterprise clusters (REC) in different Kubernetes clusters or namespaces. Active-Active deployments managed by the Redis Enterprise operator require two additional custom resources: Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC).
+
+To create an Active-Active Redis Enterprise deployment for Kubernetes with these new features, first [prepare participating clusters]({{< relref "/operate/kubernetes/7.8.6/active-active/prepare-clusters.md" >}}) then [create an Active-Active database]({{< relref "/operate/kubernetes/7.8.6/active-active/create-reaadb.md" >}}).
+
+### Preview versions
+
+If you are using a preview version of these features (operator version 6.4.2-4 or 6.4.2-5), you'll need to enable the Active-Active controller with the following steps. You need to do this only once per cluster. We recommend using the fully supported 6.4.2-6 version.
+
+1. Download the custom resource definitions (CRDs) for the most recent release (6.4.2-4) from [redis-enterprise-k8s-docs Github](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/crds).
+
+1. Apply the new CRDs for the Redis Enterprise Active-Active database (REAADB) and Redis Enterprise remote cluster (RERC) to install those controllers.
+
+    ```sh
+    kubectl apply -f crds/reaadb_crd.yaml
+    kubectl apply -f crds/rerc_crd.yaml
+    ```
+
+1. Enable the Active-Active and remote cluster controllers on the operator ConfigMap.
+
+    ```sh
+    kubectl patch cm  operator-environment-config --type merge --patch "{\"data\": \
+    {\"ACTIVE_ACTIVE_DATABASE_CONTROLLER_ENABLED\":\"true\", \
+    \"REMOTE_CLUSTER_CONTROLLER_ENABLED\":\"true\"}}"
+
+
+### REAADB custom resource
+
+Redis Enterprise Active-Active database (REAADB) contains a link to the RERC for each participating cluster, and provides configuration and status to the management plane.
+
+For a full list of fields and options, see the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_active_active_database_api">}}).
+
+### RERC custom resource
+
+Redis Enterprise remote cluster (RERC) custom resource contains configuration details for all the participating clusters.
+
+For a full list of fields and options, see the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}).
+
+### Limitations
+
+* Existing Redis databases cannot be migrated to a REAADB. (DOC-3594)
+* Admission is not blocking REAADB with `shardCount` which exceeds license quota. (RED-96301)
+    Workaround: Fix the problems with the REAADB and reapply.
+* The `<rec-name>/<rec-namespace>` value must be unique for each RERC resource. (RED-96302)
+* Only global database options are supported, no support for specifying configuration per location.
+* No support for migration from old (`crdb-cli`) Active-Active database method to new Active-Active controller.
+* No support for REAADB with participating clusters co-located within the same Kubernetes cluster, except for a single designated local participating cluster.
+
+## More information
+
+For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Describes where to view the archive of Redis Enterprise for Kubernetes
+  documentation.
+linkTitle: Archive
+weight: 99999999999
+url: '/operate/kubernetes/7.8.6/kubernetes-archive/'
+---
+
+The Redis Enterprise for Kubernetes documentation is versioned. You are looking at the documentation for the latest release.
+
+View the [7.4.6 docs](https://redis.io/docs/latest/operate/kubernetes/7.4.6/) for Redis Enterprise for Kubernetes versions 7.4.6-2 and 7.4.6-6.
+View the [7.8.4 docs](https://redis.io/docs/latest/operate/kubernetes/7.8.4/) for Redis Enterprise for Kubernetes versions 7.8.2-6, 7.8.4-8, and 7.8.4-9.
+
+Older versions of Redis Enterprise for Kubernetes documentation are available on the archived web site:
+
+- [Redis Enterprise for Kubernetes v7.4 documentation archive](https://docs.redis.com/7.4/kubernetes/) 
+
+- [Redis Enterprise for Kubernetes v7.2 documentation archive](https://docs.redis.com/7.2/kubernetes/)  
+
+- [Redis Enterprise for Kubernetes v6.x documentation archive](https://docs.redis.com/6.4/kubernetes/)
+---
+Title: Manage Redis Enterprise cluster (REC) credentials
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: Manage REC credentials
+weight: 93
+url: '/operate/kubernetes/7.8.6/security/manage-rec-credentials/'
+---
+Redis Enterprise for Kubernetes uses a custom resource called [`RedisEnterpriseCluster`]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api" >}}) to create a Redis Enterprise cluster (REC). During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+{{<note>}}
+This procedure is only supported for operator versions 6.0.20-12 and above.
+{{</note>}}
+
+## Retrieve the current username and password
+
+The credentials can be used to access the Redis Enterprise admin console or the API. Connectivity must be configured to the REC [pods](https://kubernetes.io/docs/concepts/workloads/pods/) using an appropriate service (or port forwarding).
+
+1. Inspect the random username and password created by the operator during creation with the `kubectl get secret` command.
+
+    ```sh
+    kubectl get secret rec -o jsonpath='{.data}'
+    ```
+
+    The command outputs the encoded password and username, similar to the example below.
+
+      ```sh
+      map[password:MTIzNDU2NzgK username:ZGVtb0BleGFtcGxlLmNvbQo=]
+      ```
+
+1. Decode the password and username with the `echo` command and the password from the previous step.
+
+    ```bash
+    echo MTIzNDU2NzgK | base64 --decode
+    ```
+
+    This outputs the password and username in plain text. In this example, the plain text password is `12345678` and the username is `demo@example.com`.
+
+## Change the Redis Enterprise cluster (REC) credentials
+
+### Change the REC password for the current username
+
+1. Access a [pod](https://kubernetes.io/docs/concepts/workloads/pods/) running a Redis Enterprise cluster.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+2. Add a new password for the existing user.
+
+```bash
+REC_USER="`cat /opt/redislabs/credentials/username`" \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`" \
+curl -k --request POST \
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"$REC_PASSWORD\", \
+  \"new_password\":\"<NEW PASSWORD>\"}"
+```
+
+3. From outside the pod, update the REC credential secret.
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --save-config \
+  --dry-run=client \
+  --from-literal=username=<current-username> \
+  --from-literal=password=<new-password> \
+  -o yaml | \
+kubectl apply -f -
+```
+
+4. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+5. Access a pod running a Redis Enterprise cluster again.
+
+```sh
+kubectl exec -it <rec-resource-name>-0 bash
+```
+
+6. Remove the previous password to ensure only the new one applies.
+
+```sh
+REC_USER="`cat /opt/redislabs/credentials/username`"; \
+REC_PASSWORD="`cat /opt/redislabs/credentials/password`"; \
+curl -k --request DELETE \ 
+  --url https://localhost:9443/v1/users/password \
+  -u "$REC_USER:$REC_PASSWORD" \
+  --header 'Content-Type: application/json' \
+  --data "{\"username\":\"$REC_USER\", \
+  \"old_password\":\"<OLD PASSWORD\"}"
+```
+
+{{<note>}} The username for the K8s secret is the email displayed on the Redis Enterprise admin console. {{</note>}}
+
+### Change both the REC username and password
+
+1. [Connect to the admin console]({{< relref "/operate/kubernetes/7.8.6/re-clusters/connect-to-admin-console.md" >}})
+
+2. [Add another admin user]({{< relref "/operate/rs/security/access-control/create-users" >}}) and choose a new password.
+
+3. Specify the new username in the `username` field of your REC custom resource spec.
+
+4. Update the REC credential secret:
+
+```sh
+kubectl create secret generic <cluster_secret_name> \
+  --save-config \
+  --dry-run=client \
+  --from-literal=username=<new-username> \
+  --from-literal=password=<new-password> \
+  -o yaml | \
+kubectl apply -f -
+```
+
+5. Wait five minutes for all the components to read the new password from the updated secret. If you proceed to the next step too soon, the account could get locked.
+
+6. Delete the previous admin user from the cluster.
+
+{{<note>}}
+The operator may log errors in the time between updating the username in the REC spec and the secret update.
+{{</note>}}
+
+### Update the credentials secret in Vault
+
+If you store your secrets with Hashicorp Vault, update the secret for the REC credentials with the following key-value pairs:
+
+```sh
+username:<desired_username>, password:<desired_password>
+```
+
+For more information about Vault integration with the Redis Enterprise Cluster see [Integrating Redis Enterprise for Kubernetes with Hashicorp Vault](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/vault/README.md).
+---
+Title: Enable internode encryption
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable encryption for communication between REC nodes in your K8s cluster.
+linkTitle: Internode encryption
+weight: 99
+url: '/operate/kubernetes/7.8.6/security/internode-encryption/'
+---
+
+Internode encryption provides added security by encrypting communication between nodes in your Redis Enterprise cluster (REC).
+
+Enable internode encryption in the `spec` section of your REC custom resource file.
+
+```yaml
+spec:
+    dataInternodeEncryption: true
+```
+
+This change will apply to all databases created in the REC. You can override the cluster-wide setting for individual databases.
+
+Edit your Redis Enterprise database (REDB) custom resource file to disable internode encryption for only that database.
+
+```yaml
+spec: 
+    dataInternodeEncryption: false
+```
+
+To learn more about internode encryption, see [Internode encryption for Redis Enterprise Software]({{< relref "/operate/rs/security/encryption/internode-encryption.md" >}}).
+---
+Title: Manage Redis Enterprise cluster (REC) certificates
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install your own certificates to be used by the Redis Enterprise cluster's
+  operator.
+linkTitle: Manage REC certificates
+weight: 94
+url: '/operate/kubernetes/7.8.6/security/manage-rec-certificates/'
+---
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes added to the cluster. For the list of of certificates used by Redis Enterprise Software and the traffic they encrypt, see the [certificates table]({{< relref "/operate/rs/security/certificates" >}}).
+
+To install and use your own certificates with Kubernetes on your Redis Enterprise cluster, they need to be stored in [secrets](https://kubernetes.io/docs/concepts/configuration/secret/). The REC custom resource also needs to be configured with those secret names to read and use the certificates.
+
+## Create a secret to hold the new certificate
+
+Create the [secret](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-kubectl/) with the required fields shown below.
+
+  ```sh
+  kubectl create secret generic <secret-name> \
+    --from-file=certificate=</PATH/TO/certificate.pem> \
+    --from-file=key=</PATH/TO/key.pem> \
+    --from-literal=name=<proxy | api | cm | syncer | metrics_exporter>
+  ```
+
+## Update certificates in the REC custom resource
+
+Edit the Redis Enterprise cluster (REC) custom resource to add a `certificates` subsection under the `spec` section. You are only required to add the fields for the certificates you are installing.
+
+```yaml
+spec:
+  certificates:
+    apiCertificateSecretName: <apicert-secret-name>
+    cmCertificateSecretName: <cmcert-secret-name>
+    syncerCertificateSecretName: <syncercert-secret-name>
+    metricsExporterCertificateSecretName: <metricscert-secret-name>
+    proxyCertificateSecretName: <proxycert-secret-name>
+```
+
+### Update certificates through the API
+
+Alternatively, you can also update the REC certificates via the API:
+
+```API
+PUT /v1/cluster/update_cert
+{
+   "certificate": <certificate>, 
+   "key": <cert-key>,
+   "name": <cert-name> 
+}
+```
+
+### Verify the certificate was updated
+
+Check the operator logs and use the API to verify the certificate has been updated.
+
+  ```api
+  GET /v1/cluster/certificates
+  ```
+
+## More info
+
+- [Update certificates]({{< relref "/operate/rs/security/certificates/updating-certificates" >}})
+- [Install your own certificates]({{< relref "/operate/rs/security/certificates/create-certificates" >}})
+- [Glossary/Transport Layer Security (TLS)]({{< relref "/glossary#letter-t" >}})
+---
+Title: Enable LDAP authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Enable LDAP authentication for Redis Enterprise for Kubernetes.
+linkTitle: Enable LDAP
+weight: 95
+url: '/operate/kubernetes/7.8.6/security/ldap/'
+---
+
+## LDAP support for Redis Enterprise Software
+
+Redis Enterprise Software supports LDAP authentication and authorization through [role-based access controls]({{< relref "/operate/rs/security/access-control/" >}}) (RBAC). You can map LDAP groups to [Redis Enterprise roles]({{< relref "/operate/rs/security/access-control" >}}) to control access to your database and the Cluster Manager UI. For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+
+Redis Enterprise for Kubernetes supports enabling and configuring LDAP authentication using the `RedisEnterpriseCluster` (REC) custom resource. Currently, the Redis Enterprise cluster (REC) only supports configuration related to the LDAP server, such as server addresses, connection details, credentials, and query configuration.
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+## Enable LDAP 
+
+To enable LDAP for your REC, use the `.spec.ldap` field in the `RedisEnterpriseCluster` custom resource.
+
+The following `RedisEnterpriseCluster` example resource enables a basic LDAP configuration:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  ldap:
+    protocol: LDAP
+    servers:
+    - host: openldap.openldap.svc
+      port: 389
+    bindCredentialsSecretName: ldap-bind-credentials
+    cacheTTLSeconds: 600
+    enabledForControlPlane: true
+    enabledForDataPlane: true
+    authenticationQuery:
+      template: cn=%u,ou=default,dc=example,dc=org
+    authorizationQuery:
+      attribute: memberOf
+```
+
+Refer to the `RedisEnterpriseCluster` [API reference](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#ldapspec) for full details on the available fields.
+
+### Bind credentials
+
+For LDAP servers that require authentication for client queries, store the bind credentials in a secret and reference them in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to store the bind credentials.
+    
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <bind-secret-name> \
+        --from-literal=dn='<disinguished-name>' \
+        --from-literal=password=<password>
+    ```
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `dn` key with the distinguished name for the user performing the query (such as `cn=admin,dc=example,dc=org`).
+    - Include a `password` key with the bind password.
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.ldap.bindCredentialsSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        bindCredentialsSecretName: <bind-secret-name>
+    ```
+
+### LDAPS or STARTTLS protocols
+
+In addition to plain LDAP protocol, Redis Enterprise Software also supports LDAPS and STARTTLS protocols for secure communication with the LDAP server.
+
+To enable one of these protocols, edit the `spec.ldap.protocol` field in the `RedisEnterpriseCluster` custom resource:
+
+#### Enable `LDAPS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: LDAPS
+  ```
+
+  Default port: 636
+
+#### Enable `STARTTLS`
+
+  ```yaml
+      spec:
+        ldap:
+          protocol: STARTTLS
+  ```
+
+  Default port: 389
+
+### CA certificate
+
+To use a custom CA certificate for validating the LDAP server certificate, store the CA certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the CA certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <ca-secret-name> \
+        --from-file=cert=<ca-cert>.pem
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `cert` key with a PEM-encoded CA certificate (such as `cacert.pem`).
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `spec.ldap.caCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource.
+
+    ```yaml
+    spec:
+      ldap:
+        caCertificateSecretName: <ca-secret-name>
+    ```
+
+### Client certificates
+
+To use an LDAP client certificate, store the certificate in a secret and reference the secret in the `RedisEnterpriseCluster` custom resource.
+
+1. Create a secret to hold the client certificate.
+
+    ```sh
+    kubectl -n <rec-namespace> create secret generic <client-secret-name> \
+      --from-literal=name=ldap_client \
+      --from-file=certificate=<client-cert-file> \
+      --from-file=key=<private-key-file>
+    ```
+
+    The secret must:
+    - Reside within the same namespace as the `RedisEnterpriseCluster` custom resource.
+    - Include a `name` key explicitly set to `ldap_client`.
+    - Include a `certificate` key for the public key (such as `cert.pem`).
+    - Include a `key` key for the private key (such as `key.pem`).
+    
+
+    Replace the `<placeholders>` in the command above with your own values.
+
+1. Reference the secret name in the `.spec.certificates.ldapClientCertificateSecretName` field of the `RedisEnterpriseCluster` custom resource, substituting your own values for `<placeholders>`.
+
+    ```yaml
+    spec:
+      certificates:
+        ldapClientCertificateSecretName: <client-secret-name>
+    ```
+
+## Known limitations
+
+Redis Enterprise Software can't resolve DNS names with a `.local` suffix.
+  If your LDAP server is in the same Kubernetes cluster and exposed via a Service object, *avoid* addresses such as `openldap.openldap.svc.cluster.local`. Instead, *use short-form addresses* such as `openldap.openldap.svc`.
+
+## Next steps
+
+To [map LDAP groups to Redis Enterprise access control roles]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}), you'll need to use the Redis Enterprise [API]({{< relref "/operate/rs/references/rest-api/requests/ldap_mappings/" >}}) or [admin console]({{< relref "/operate/rs/security/access-control/ldap/enable-role-based-ldap.md" >}}).
+
+For more details on how LDAP works with Redis Enterprise, see [LDAP authentication]({{< relref "/operate/rs/security/access-control/ldap/" >}}).
+---
+categories:
+- docs
+- operate
+- kubernetes
+description: Add client certificates to your REDB custom resource.
+linkTitle: Add client certificates
+title: Add client certificates
+weight: 95
+url: '/operate/kubernetes/7.8.6/security/add-client-certificates/'
+---
+
+For each client certificate you want to use with your database, you need to create a Kubernetes secret to hold it. You can then reference that secret in your Redis Enterprise database (REDB) custom resource spec.
+
+## Create a secret to hold the new certificate
+
+1. [Create the secret config file](https://kubernetes.io/docs/tasks/configmap-secret/managing-secret-using-config-file/) with the required fields shown below.
+
+    ```yaml
+    apiVersion: v1
+    kind: Secret
+    type: Opaque
+    metadata:
+      name: <client-cert-secret>
+      namespace: <your-rec-namespace>
+    data:
+      cert: <client-certificate>
+    ```
+  
+1. Apply the file to create the secret resource.
+
+    ```bash
+    kubectl apply -f <client-cert-secret>.yaml
+    ```
+
+## Edit the REDB resource
+
+1. Add the secret name to the REDB custom resource (`redb.yaml`) with the `clientAuthenticationCertificates` property in the `spec` section.
+
+  ```yaml
+   spec:
+      clientAuthenticationCertificates:
+      - <client-cert-secret>
+  ```
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Security settings and configuration for Redis Enterprise for Kubernetes
+hideListLinks: false
+linkTitle: Security
+weight: 50
+url: '/operate/kubernetes/7.8.6/security/'
+---
+
+This section contains security settings and configuration for Redis Enterprise for Kubernetes.
+
+
+---
+Title: Configure Istio for external routing
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure Istio as an ingress controller for access to your Redis Enterprise
+  databases from outside the Kubernetes cluster.
+linkTitle: Istio ingress routing
+weight: 20
+url: '/operate/kubernetes/7.8.6/networking/istio-ingress/'
+---
+
+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.
+
+## Install and configure Istio for Redis Enterprise
+
+1. [Download](https://istio.io/latest/docs/setup/getting-started/) and [install](https://istio.io/latest/docs/setup/getting-started/) Istio (see instructions from Istio's [Getting Started](https://istio.io/latest/docs/setup/getting-started/) guide).
+
+    Once the installation is complete, all the deployments, pods, and services will be deployed in a namespace called `istio-system`. This namespace contains a `LoadBalancer` type service called `service/istio-ingressgateway` that exposes the external IP address.
+
+1. Find the `EXTERNAL-IP` for the `istio-ingressgateway` service.
+
+    ```sh
+    kubectl get svc istio-ingressgateway -n istio-system
+
+    NAME                   TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)                                                                      AGE
+    istio-ingressgateway   LoadBalancer   10.34.67.89   10.145.78.91   15021:12345/TCP,80:67891/TCP,443:23456/TCP,31400:78901/TCP,15443:10112/TCP   3h8m
+    ```
+
+1. Create a DNS entry that resolves your chosen database hostname (or a wildcard `*` followed by your domain) to the Istio `EXTERNAL-IP`. Use this hostname to access your database from outside the cluster.
+
+    In this example, any hostname that ends with `.istio.k8s.my.example.com` will resolve to the Istio LoadBalancer's external IP of `10.145.78.91`. Substitute your own values accordingly.
+
+1. Verify the record was created successfully.
+
+    ```sh
+    dig api.istio.k8s.my.example.com
+    ```
+
+    Look in the `ANSWER SECTION` for the record you just created.
+
+    ```sh
+    ;; ANSWER SECTION:
+    api.istio.k8s.my.example.com 0 IN    A       10.145.78.91
+    ```
+
+## Create custom resources
+
+### `Gateway` custom resource
+
+1. On a different namespace from `istio-system`, create a `Gateway` custom resource file (`redis-gateway.yaml` in this example).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - Replace `<selector-label>` with the label set on your Istio ingress gateway pod (most common is `istio: ingress`).
+    - TLS passthrough mode is required to allow secure access to the database.
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: Gateway
+    metadata:
+      name: redis-gateway
+    spec:
+      selector:
+        istio: <selector-label>
+      servers:
+      - hosts:
+        - '*.istio.k8s.my.example.com'
+        port:
+          name: https
+          number: 443
+          protocol: HTTPS
+        tls:
+          mode: PASSTHROUGH
+    ```
+
+
+
+1. Apply the `Gateway` custom resource file to create the Ingress gateway.
+
+    ```sh
+    kubectl apply -f redis-gateway.yaml
+    ```
+
+1. Verify the gateway was created successfully.
+
+      ```sh
+      kubectl get gateway
+
+      NAME            AGE
+      redis-gateway   3h33m
+      ```
+
+### `VirtualService` custom resource
+
+1. On a different namespace than `istio-system`, create the `VirtualService` custom resource file (`redis-vs.yaml` in this example).
+
+    ```yaml
+    apiVersion: networking.istio.io/v1beta1
+    kind: VirtualService
+    metadata:
+      name: redis-vs
+    spec:
+      gateways:
+      - redis-gateway
+      hosts:
+      - "*.istio.k8s.my.example.com"
+      tls:
+      - match:
+        - port: 443
+          sniHosts:
+          - api.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: rec1
+            port:
+              number: 9443
+      - match:
+        - port: 443
+          sniHosts:
+          - db1.istio.k8s.my.example.com
+        route:
+        - destination:
+            host: db1
+    ```
+
+    This creates both a route to contact the API server on the REC (`rec1`) and a route to contact one of the databases (`db1`).
+
+    - Replace `.istio.k8s.my.example.com` with the domain that matches your DNS record.
+    - The gateway's metadata name must be similar to the gateway's spec name (`redis-gateway` in this example).
+   
+1. Apply `VirtualService` custom resource file to create the virtual service.
+
+    ```sh
+    kubectl apply -f redis-vs.yaml
+    ```
+
+1. Verify the virtual service was created successfully.
+
+    ```sh
+    kubectl get vs
+
+    NAME       GATEWAYS            HOSTS                              AGE
+    redis-vs   ["redis-gateway"]   ["*.istio.k8s.my.example.com"]   3h33m
+    ```
+
+1. [Deploy the operator]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md" >}}), Redis Enterprise Cluster (REC), and Redis Enterprise Database (REDB) on the same namespace as the gateway and virtual service.
+
+## Test your external access to the database
+
+To [test your external access]({{< relref "/operate/kubernetes/7.8.6/networking/ingress.md" >}}) to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).
+
+See [Test your access with Openssl]({{< relref "/operate/kubernetes/7.8.6/networking/ingress#test-your-access-with-openssl" >}}) or [Test your access with Python]({{< relref "/operate/kubernetes/7.8.6/networking/ingress#test-your-access-with-python" >}}) for more info.
+---
+Title: Use OpenShift routes for external database access
+alwaysOpen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: OpenShift routes
+weight: 15
+url: '/operate/kubernetes/7.8.6/networking/routes/'
+---
+
+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](https://docs.openshift.com/container-platform/4.13/networking/routes/route-configuration.html).
+
+## 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.
+
+  By default, the DMC Proxy uses a self-signed certificate.  You can retrieve it from the Redis Enterprise admin console and save it as a file (for example, named "ca.pem") on the client machine.
+
+* Your database also needs TLS encryption enabled.
+
+## Create OpenShift route
+
+1. Select the **Networking/Routes** section of the OpenShift web console.
+
+1. Select **Create route** and fill out the following fields:
+
+   * **Name**: Choose any name you want as the first part of your generated hostname
+   * **Hostname**: Leave blank
+   * **Path**: Leave as is ("/")
+   * **Service**: Select the service for the database you want to access
+   * **TLS Termination**: Choose "passthrough"
+   * **Insecure Traffic**: Select "None"
+
+1. Select **Create**.
+
+1. Find the hostname for your new route. After route creation, it appears in the "Host" field.
+
+1. Verify you have a DNS entry to resolve the hostname for your new route to the cluster's load balancer.
+
+## Access database
+
+Access the database from outside the cluster using `redis-cli` or `openssl`.
+
+To connect with `redis-cli`:
+  
+   ```sh
+   redis-cli -h <hostname> -p 443 --tls --cacert ./ca.pem --sni <hostname>
+   ```
+
+Replace the `<hostname>` value with the hostname for your new route.
+
+To connect with `openssl`:
+
+   ```sh
+   openssl s_client -connect <hostname>:443 -crlf -CAfile ./ca.pem -servername <hostname>
+   ```
+---
+Title: Configure Ingress for external routing
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Configure an ingress controller to access your Redis Enterprise databases
+  from outside the Kubernetes cluster.
+linkTitle: Ingress routing
+weight: 5
+url: '/operate/kubernetes/7.8.6/networking/ingress/'
+---
+
+## Prerequisites
+
+Before creating an Ingress, you'll need:
+
+ - A RedisEnterpriseDatabase (REDB) with TLS enabled for client connections
+ - A supported Ingress controller with `ssl-passthrough` enabled
+    - [Ingress-NGINX Controller](https://kubernetes.github.io/ingress-nginx/deploy/)
+        - Be sure to use the `kubernetes/ingress-nginx` controller and NOT the `nginxinc/kubernetes-ingress` controller.
+    - [HAProxy Ingress](https://haproxy-ingress.github.io/docs/getting-started/)
+    - To use Istio for your Ingress resources, see [Configure Istio for external routing]({{< relref "/operate/kubernetes/7.8.6/networking/istio-ingress.md" >}})
+
+{{<note>}}Make sure your Ingress controller has `ssl-passthrough`enabled. This is enabled by default for HAProxy, but disabled by default for NGINX. See the [NGINX User Guide](https://kubernetes.github.io/ingress-nginx/user-guide/tls/#ssl-passthrough) for details. {{</note>}}
+
+## Create an Ingress resource
+
+1. Retrieve the hostname of your Ingress controller's `LoadBalancer` service.
+
+    ``` sh
+    $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                        -n <ingress-ctrl-namespace>
+    ```
+
+    Below is example output for an HAProxy running on a K8s cluster hosted by AWS.  
+
+    ``` sh
+    NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+    haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+    ```
+
+1. Choose the hostname you will use to access your database (this value will be represented in this article with `<my-db-hostname>`).  
+
+1. Create a DNS entry that resolves your chosen database hostname to the IP address for the Ingress controller's LoadBalancer.  
+
+1. Create the Ingress resource YAML file.  
+
+    ``` YAML
+    apiVersion: networking.k8s.io/v1
+    kind: Ingress
+    metadata:
+      name: rec-ingress
+      annotations:
+        <controller-specific-annotations-below>
+    spec:
+      rules:
+      - host: <my-db-hostname>
+        http:
+          paths:
+          - path: /
+            pathType: ImplementationSpecific
+            backend:
+              service:
+                name: <db-name>
+                port:
+                  name: redis
+    ```  
+
+    For HAProxy, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: haproxy
+     ingress.kubernetes.io/ssl-passthrough: "true"
+    ```
+
+    For NGINX, insert the following into the `annotations` section:  
+
+    ``` YAML
+    kubernetes.io/ingress.class: nginx
+    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    ```  
+
+    The `ssl-passthrough` annotation is required to allow access to the database. The specific format changes depending on your Ingress controller and any additional customizations. See [NGINX Configuration annotations](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) and [HAProxy Ingress Options](https://www.haproxy.com/documentation/kubernetes/latest/configuration/ingress/) for updated annotation formats.  
+
+## Test your external access  
+
+To test your external access to the database, you need a client that supports [TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security) and [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication).  
+
+#### Test your access with Openssl  
+
+1. Get the default CA certificate from the `redis-enterprise-node` container on any of the Redis Enterprise pods.  
+
+    ``` sh
+    $ kubectl exec -it <pod-name> -c redis-enterprise-node \
+                    -- cat /etc/opt/redislabs/proxy_cert.pem
+    ```  
+
+1. Run the following `openssl` command, substituting your own values for `<my-db-hostname>`.  
+
+    ``` sh
+    $ openssl s_client \
+      -connect <my-db-hostname>:443 \
+      -crlf -CAfile ./proxy_cert.pem \
+      -servername <my-db-hostname>
+    ```  
+
+    If you are connected to the database, you will receive `PONG` back, as shown below:  
+
+    ``` sh
+    ...
+     Verify return code: 0 (ok)
+    ---
+
+    PING
+    +PONG
+    ```  
+
+#### Test your access with Python  
+
+You can use the code below to test your access with Python, substituting your own values for `<my-db-hostname>` and `<file-path>`.  
+
+``` python
+import redis
+
+r = redis.StrictRedis(host='<my-db-hostname>',
+              port=443, db=0, ssl=True,
+              ssl_ca_certs='/<file-path>/proxy_cert.pem')
+
+
+print(r.info())
+```
+
+Your output should look something like this:  
+
+``` sh
+$ /Users/example-user/Documents/Projects/test_client/venv3.7/bin/python \
+    /Users/example-user/Documents/Projects/test_client/test_ssl.py
+{
+    'redis_version': '5.0.5',
+    'redis_git_sha1': 0,
+    'redis_git_dirty': 0,
+    'redis_build_id': 0,
+    'redis_mode': 'standalone',
+    'os': 'Linux 4.14.154-128.181.amzn2.x86_64 x86_64',
+    'arch_bits': 64,
+    'multiplexing_api': 'epoll',
+    'gcc_version': '7.4.0',
+    'process_id': 1,
+    'run_id': '3ce7721b096517057d28791aab555ed8ac02e1de',
+    'tcp_port': 10811,
+    'uptime_in_seconds': 316467,
+    'uptime_in_days': 3,
+    'hz': 10,
+    'lru_clock': 0,
+    'config_file': '',
+    'connected_clients': 1,
+    'client_longest_output_list': 0,
+    'client_biggest_input_buf': 0,
+    'blocked_clients': 0,
+    'used_memory': 12680016,
+    'used_memory_human': '12.9M',
+    'used_memory_rss': 12680016,
+    'used_memory_peak': 13452496,
+    'used_memory_peak_human': '12.82M',
+    'used_memory_lua': 151552,
+    'mem_fragmentation_ratio': 1,
+    'mem_allocator': 'jemalloc-5.1.0',
+    'loading': 0,
+    'rdb_changes_since_last_save': 0,
+    'rdb_bgsave_in_progress': 0,
+    'rdb_last_save_time': 1577753916,
+    'rdb_last_bgsave_status': 'ok',
+    'rdb_last_bgsave_time_sec': 0,
+    'rdb_current_bgsave_time_sec': -1,
+    'aof_enabled': 0,
+    'aof_rewrite_in_progress': 0,
+    'aof_rewrite_scheduled': 0,
+    'aof_last_rewrite_time_sec': -1,
+    'aof_current_rewrite_time_sec': -1,
+    'aof_last_bgrewrite_status': 'ok',
+    'aof_last_write_status': 'ok',
+    'total_connections_received': 4,
+    'total_commands_processed': 6,
+    'instantaneous_ops_per_sec': 14,
+    'total_net_input_bytes': 0,
+    'total_net_output_bytes': 0,
+    'instantaneous_input_kbps': 0.0,
+    'instantaneous_output_kbps': 0.0,
+    'rejected_connections': 0,
+    'sync_full': 1,
+    'sync_partial_ok': 0,
+    'sync_partial_err': 0,
+    'expired_keys': 0,
+    'evicted_keys': 0,
+    'keyspace_hits': 0,
+    'keyspace_misses': 0,
+    'pubsub_channels': 0,
+    'pubsub_patterns': 0,
+    'latest_fork_usec': 0,
+    'migrate_cached_sockets': 0,
+    'role': 'master',
+    'connected_slaves': 1,
+    'slave0': {
+        'ip': '0.0.0.0',
+        'port': 0,
+        'state': 'online',
+        'offset': 0,
+        'lag': 0
+    },
+    'master_repl_offset': 0,
+    'repl_backlog_active': 0,
+    'repl_backlog_size': 1048576,
+    'repl_backlog_first_byte_offset': 0,
+    'repl_backlog_histlen': 0,
+    'used_cpu_sys': 0.0,
+    'used_cpu_user': 0.0,
+    'used_cpu_sys_children': 0.0,
+    'used_cpu_user_children': 0.0,
+    'cluster_enabled': 0
+}
+
+Process finished with exit code 0
+```
+---
+Title: Networking
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+hideListLinks: true
+linkTitle: Networking
+weight: 40
+url: '/operate/kubernetes/7.8.6/networking/'
+---
+
+Redis Enterprise for Kubernetes supports several ways to route external traffic to your RedisEnterpriseCluster:
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}) to route external traffic.
+- The RedisEnterpriseActiveActiveDatabase (REAADB) requires any of the above routing methods to be configured in the RedisEnterpriseCluster (REC) with the `ingressOrRouteSpec` field.
+
+## External routing using Redis Enterprise for Kubernetes
+
+Every time a RedisEnterpriseDatabase (REDB), Redis Enterprise Active-Active database (REAADB), or Redis Enterprise cluster (REC) is created, the Redis Enterprise operator automatically creates a [service](https://kubernetes.io/docs/concepts/services-networking/service/) to allow requests to be routed to that resource.
+
+Redis Enterprise supports three [types of services](https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types) for accessing databases: `ClusterIP`, `headless`, or `LoadBalancer`.
+
+By default, the operator creates a `ClusterIP` type service, which exposes a cluster-internal IP and that can only be accessed from within the K8s cluster. For requests to be routed from outside the K8s cluster, you need an [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) (or [route](https://docs.openshift.com/container-platform/4.12/networking/routes/route-configuration.html) if you are using OpenShift). See [kubernetes.io](https://kubernetes.io/docs/) for more details on [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) and [Ingress controllers](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/).
+
+* To use NGINX or HAProxy Ingress controllers, see [Ingress routing]({{< relref "/operate/kubernetes/7.8.6/networking/ingress.md" >}}).
+* To use OpenShift routes, see [OpenShift routes]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}).
+* To use Istio as an Ingress controller, see [Istio Ingress routing]({{< relref "/operate/kubernetes/7.8.6/networking/istio-ingress.md" >}})
+
+## `ingressOrRouteSpec` for Active-Active databases
+
+Versions 6.4.2 or later of Redis Enterprise for Kubernetes include a feature for ingress configuration. The `ingressOrRouteSpec` field is available in the RedisEnterpriseCluster spec to automatically create an Ingress (or route) for the API service and databases (REAADB) on that REC. See [REC external routing]({{< relref "/operate/kubernetes/7.8.6/networking/ingressorroutespec.md" >}}) for more details.
+
+This feature only supports automatic Ingress creation for Active-Active databases created and managed with the RedisEnterpriseActiveActiveDatabase (REAADB) custom resource. Use with the standard Redis Enterprise database (REDB) is not currently supported.
+
+## REC domain name
+
+The RedisEnterpriseCluster does not support custom domain names. Domain names for the REC are in the following format: `<rec-name>.<namespace>.svc.cluster.local`.
+---
+Title: Establish external routing on the RedisEnterpriseCluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+linkTitle: REC external routing
+weight: 30
+url: '/operate/kubernetes/7.8.6/networking/ingressorroutespec/'
+---
+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:
+* [HAProxy](https://haproxy-ingress.github.io/)
+* [NGINX](https://kubernetes.github.io/ingress-nginx/)
+* [Istio](https://istio.io/latest/docs/setup/getting-started/)
+
+OpenShift users can use [routes]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}) instead of an Ingress.
+
+Install your chosen Ingress controller, making sure `ssl-passthrough` is enabled. `ssl-passthrough` is turned off by default for NGINX but enabled by default for HAProxy.
+
+## Configure DNS
+
+1. Choose the hostname (FQDN) you will use to access your database according to the recommended naming conventions below, replacing `<placeholders>` with your own values.
+
+     REC API hostname: `api-<rec-name>-<rec-namespace>.<subdomain>`
+     REAADB hostname: `-db-<rec-name>-<rec-namespace>.<subdomain>`
+     
+     We recommend using a wildcard (`*`) in place of the database name, followed by the hostname suffix.
+
+1. Retrieve the `EXTERNAL-IP` of your Ingress controller's `LoadBalancer` service.
+
+     ``` sh
+     $ kubectl get svc <haproxy-ingress | ingress-ngnix-controller> \
+                         -n <ingress-ctrl-namespace>
+     ```
+
+     Below is example output for an HAProxy ingress controller running on a K8s cluster hosted by AWS.  
+
+     ``` sh
+     NAME              TYPE           CLUSTER-IP    EXTERNAL-IP                                                              PORT(S)                      AGE   
+     haproxy-ingress   LoadBalancer   10.43.62.53   a56e24df8c6173b79a63d5da54fd9cff-676486416.us-east-1.elb.amazonaws.com   80:30610/TCP,443:31597/TCP   21m
+     ```
+
+1. Create DNS records to resolve your chosen REC API hostname and database hostname to the `EXTERNAL-IP` found in the previous step.
+
+## Edit the REC spec
+
+Edit the RedisEnterpriseCluster (REC) spec to add the `ingressOrRouteSpec` field, replacing `<placeholders>` below with your own values.
+
+### NGINX or HAproxy ingress controllers
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `ingress`.
+* Set `ssl-passthrough` to "true".
+* Add any additional annotations required for your ingress controller. See [NGINX docs](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/) or [HAproxy docs](https://haproxy-ingress.github.io/docs/configuration/keys/) for more information.
+
+```sh
+kubectl patch rec  <rec-name> --type merge --patch "{\"spec\": \
+    {\"ingressOrRouteSpec\": \
+      {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\", \
+      \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+      \"ingressAnnotations\": \
+       {\"<kubernetes | github>.io/ingress.class\": \
+       \"<ingress-controller>\", \
+       \"<ingress-controller-annotation>/ssl-passthrough\": \ \"true\"}, \
+      \"method\": \"ingress\"}}}"
+```
+
+### OpenShift routes
+
+* Define the REC API hostname (`apiFqdnUrl`) and database hostname suffix (`dbFqdnSuffix`) you chose when configuring DNS.
+* Set `method` to `openShiftRoute`.
+
+```sh
+kubectl patch rec <rec-name> --type merge --patch "{\"spec\": \
+     {\"ingressOrRouteSpec\": \
+     {\"apiFqdnUrl\": \"api-<rec-name>-<rec-namespace>.example.com\" \ 
+     \"dbFqdnSuffix\": \"-db-<rec-name>-<rec-namespace>.example.com\", \
+     \"method\": \"openShiftRoute\"}}}"
+```
+
+OpenShift routes do not require any `ingressAnnotations` in the `ingressOrRouteSpec`.
+---
+Title: Control node selection
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how Redis Enterprise cluster
+  pods can be scheduled to only be placed on specific nodes or node pools.
+linkTitle: Node selection
+weight: 80
+url: '/operate/kubernetes/7.8.6/recommendations/node-selection/'
+---
+
+Many Kubernetes cluster deployments have different kinds of nodes that have
+different CPU and memory resources available for scheduling cluster workloads.
+Redis Enterprise for Kubernetes has various abilities to control the scheduling
+Redis Enterprise cluster node pods through properties specified in the
+Redis Enterprise cluster custom resource definition (CRD).
+
+A Redis Enterprise cluster (REC) is deployed as a StatefulSet which manages the Redis Enterprise cluster node pods.
+The scheduler chooses a node to deploy a new Redis Enterprise cluster node pod on when:
+
+- The cluster is created
+- The cluster is resized
+- A pod fails
+
+Here are the ways that you can control the pod scheduling:
+
+## Using node selectors
+
+The [`nodeSelector`]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#spec">}})
+property of the cluster specification uses the same values and structures as
+the [Kubernetes `nodeSelector`](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#nodeselector).
+In general, node labels are a simple way to make sure that specific nodes are used for Redis Enterprise pods.
+For example, if nodes 'n1' and 'n2' are labeled as "high memory":
+
+```sh
+kubectl label nodes n1 memory=high
+kubectl label nodes n2 memory=high
+```
+
+The Redis Enterprise cluster CRD can request to be scheduled on these nodes:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     memory: high
+```
+
+Then, when the operator creates the StatefulSet associated with the pod, the nodeSelector
+section is part of the pod specification. When the scheduler attempts to
+create new pods, it needs to satisfy the node selection constraints.
+
+
+## Using node pools
+
+A node pool is a common part of the underlying infrastructure of the Kubernetes cluster deployment and provider.
+Often, node pools are similarly-configured classes of nodes such as nodes with the same allocated amount of memory and CPU.
+Implementors often label these nodes with a consistent set of labels.
+
+On Google Kubernetes Engine (GKE), all node pools have the label `cloud.google.com/gke-nodepool` with a value of the name used during configuration.
+On Microsoft Azure Kubernetes System (AKS), you can create node pools with a specific set of labels. Other managed cluster services may have similar labeling schemes.
+
+You can use the `nodeSelector` section to request a specific node pool by label values. For example, on GKE:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  nodeSelector:
+     cloud.google.com/gke-nodepool: 'high-memory'
+```
+
+## Using node taints
+
+You can use multiple node taints with a set of tolerations to control Redis Enterprise cluster node pod scheduling.
+The `podTolerations` property of the cluster specification specifies a list of pod tolerations to use.
+The value is a list of [Kubernetes tolerations](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/#concepts).
+
+For example, if the cluster has a single node pool, the node taints can control the allowed workloads for a node.
+You can add taints to the node, for example nodes n1, n2, and n3, reserve a set of nodes for the Redis Enterprise cluster:
+
+```sh
+kubectl taint nodes n1 db=rec:NoSchedule
+kubectl taint nodes n2 db=rec:NoSchedule
+kubectl taint nodes n3 db=rec:NoSchedule
+```
+
+This prevents any pods from being scheduled onto the nodes unless the pods can tolerate the taint `db=rec`.
+
+You can then add the toleration for this taint to the cluster specification:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podTolerations:
+  - key: db
+    operator: Equal     
+    value: rec
+    effect: NoSchedule
+```
+
+A set of taints can also handle more complex use cases.
+For example, a `role=test` or `role=dev` taint can be used to designate a node as dedicated for testing or development workloads via pod tolerations.
+
+## Using pod anti-affinity
+
+By default, the Redis Enterprise node pods are not allowed to be placed on the same node for the same cluster:
+
+```yaml
+podAntiAffinity:
+  requiredDuringSchedulingIgnoredDuringExecution:
+  - labelSelector:
+      matchLabels:
+        app: redis-enterprise
+        redis.io/cluster: rec
+        redis.io/role: node
+    topologyKey: kubernetes.io/hostname
+```
+
+Each pod has the three labels above where `redis.io/cluster` is the label for the name of your cluster.
+
+You can change this rule to restrict or include nodes that the Redis Enterprise cluster node pods can run on.
+For example, you can delete the `redis.io/cluster` label so that even Redis Enterprise node pods from different clusters cannot be scheduled on the same Kubernetes node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          app: redis-enterprise
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+or you can prevent Redis Enterprise nodes from being schedule with other workloads.
+For example, if all database workloads have the label 'local/role: database', you
+can use this label to avoid scheduling two databases on the same node:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  extraLabels:
+     local/role: database
+  podAntiAffinity:
+    requiredDuringSchedulingIgnoredDuringExecution:
+    - labelSelector:
+        matchLabels:
+          local/role: database
+          app: redis-enterprise
+          redis.io/cluster: rec
+          redis.io/role: node
+      topologyKey: kubernetes.io/hostname
+```
+
+In this case, any pods that are deployed with the label `local/role: database` cannot be scheduled on the same node.
+
+
+## Using rack awareness
+
+You can configure Redis Enterprise with rack-zone awareness to increase availability
+during partitions or other rack (or region) related failures.
+
+{{%note%}}When creating your rack-zone ID, there are some constraints to consider; see [rack-zone awareness]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness#rack-zone-id-rules" >}}) for more info. {{%/note%}}
+
+
+Rack-zone awareness is a single property in the Redis Enterprise cluster CRD named `rackAwarenessNodeLabel`.
+This value for this label is commonly `topology.kubernetes.io/zone` as documented in
+['Running in multiple zones'](https://kubernetes.io/docs/setup/best-practices/multiple-zones/#nodes-are-labeled).
+
+You can check the value for this label in your nodes with the command:
+
+```sh
+$kubectl get nodes -o custom-columns="name:metadata.name","rack\\zone:metadata.labels.failure-domain\.beta\.kubernetes\.io/zone"
+
+name                                            rack\zone
+ip-10-0-x-a.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-b.eu-central-1.compute.internal    eu-central-1a
+ip-10-0-x-c.eu-central-1.compute.internal    eu-central-1b
+ip-10-0-x-d.eu-central-1.compute.internal    eu-central-1b
+```
+
+### Enabling the cluster role
+
+For the operator to read the cluster node information, you must create a cluster role for the operator and then bind the role to the service account.
+
+Here's a cluster role:
+
+```yaml
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+rules:
+  # needed for rack awareness
+  - apiGroups: [""]
+    resources: ["nodes"]
+    verbs: ["list", "get", "watch"]
+```
+
+And here's how to apply the role:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role.yaml
+```
+
+The binding is typically to the `redis-enterprise-operator` service account:
+
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+subjects:
+- kind: ServiceAccount
+  namespace: OPERATOR_NAMESPACE
+  name: redis-enterprise-operator
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator
+  apiGroup: rbac.authorization.k8s.io
+```
+
+and it can be applied by running:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rack_awareness/rack_aware_cluster_role_binding.yaml
+```
+
+Once the cluster role and the binding have been applied, you can configure Redis Enterprise clusters to use rack awareness labels.
+
+### Configuring rack awareness
+
+You can configure the node label to read for the rack zone by setting the `rackAwarenessNodeLabel` property:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  nodes: 3
+  rackAwarenessNodeLabel: topology.kubernetes.io/zone
+```
+
+{{< note >}}
+When you use the `rackAwarenessNodeLabel` property, the operator will change the topologyKey for the anti-affinity rule to the label name used unless you have specified the `podAntiAffinity` property as well. If you use `rackAwarenessNodeLabel` and `podAntiAffinity` together, you must make sure that the `topologyKey` in your pod anti-affinity rule is set to the node label name.
+{{< /note >}}
+---
+Title: Size and scale a Redis Enterprise cluster deployment on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about sizing and scaling Redis Enterprise
+  in a Kubernetes deployment.
+linkTitle: Sizing and scaling
+weight: 50
+url: '/operate/kubernetes/7.8.6/recommendations/sizing-on-kubernetes/'
+---
+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]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## Sizing and scaling cluster nodes
+
+### Setting the number of cluster nodes
+
+Define the number of cluster nodes in redis-enterprise-cluster.yaml file.
+
+    spec:
+
+        nodes: 3
+
+The number of nodes in the cluster must be an uneven number
+equal to or greater than 3. Refer to the article [Highly Available Redis](https://redislabs.com/redis-enterprise/technology/highly-available-redis/)
+for a detailed explanation on this topic.
+
+Set the number of cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling out
+
+To scale out a Redis Enterprise Cluster deployment, increase the number of nodes
+in the spec. For example, to scale the cluster out from 3 nodes to 5 nodes,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+    spec:
+
+        nodes: 5
+
+To apply the new cluster configuration run:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{<warning>}} Decreasing the number of nodes is not supported.{{</warning>}}
+
+### Sizing compute resources
+
+To set the compute resources required for each node,
+use the redisEnterpriseNodeResources spec field.
+
+Under redisEnterpriseNodeResources spec, set the following fields
+according to the provided guidelines.
+
+- limits – specifies the maximum compute resources for a Redis node
+- requests – specifies the minimum compute resources for a Redis node
+
+For example:
+
+    redisEnterpriseNodeResources:
+
+        limits:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+        requests:
+
+        cpu: “2000m”
+
+        memory: 4Gi
+
+The default values, if unspecified, are 2 cores (2000m) and 4GB (4Gi).
+
+Set the compute resources for cluster nodes during deployment
+by editing the redis-enterprise-cluster.yaml file and
+applying the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+### Scaling up node compute resources
+
+To scale up nodes in an existing Redis Enterprise Cluster deployment,
+adjust the cpu and memory parameters in the spec. For example,
+to scale nodes up to the recommended amount of compute resources,
+edit the redis-enterprise-cluster.yaml file with the following:
+
+redisEnterpriseNodeResources:
+
+    limits:
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+    requests
+
+        cpu: “8000m”
+
+        memory: 30Gi
+
+Then, apply the file by running:
+
+    kubectl apply -f redis-enterprise-cluster.yaml
+
+{{< warning >}}
+When adjusting compute resources, make sure the ratio of persistent volume size and the new memory size are in accordance to the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}). 
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.8.6/re-clusters/expand-pvc">}}) for details.
+{{< /warning >}}
+---
+Title: Manage node resources
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Recommendations on managing node resources and setting eviction thresholds
+  with Redis Enterprise for Kubernetes.
+linktitle: Manage resources
+weight: 17
+url: '/operate/kubernetes/7.8.6/recommendations/node-resources/'
+---
+ 
+
+
+## Node eviction thresholds
+
+ Kubernetes uses [node-pressure eviction](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/) to terminate pods and free up node resources. Redis Enterprise for Kubernetes works best when you use the recommendations below.
+
+Eviction thresholds are managed by [kubelet arguments](https://kubernetes.io/docs/reference/command-line-tools-reference/kubelet/).
+
+Redis recommends setting a high [soft eviction threshold](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds). This changes the node condition early enough to alert the administrator.
+
+We also recommend setting the [`eviction-soft-grace-period`](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#soft-eviction-thresholds) high enough for the administrator to scale the cluster.
+
+For more information about configuring eviction thresholds on specific platforms, see [Freeing node resources](https://docs.openshift.com/container-platform/4.9/nodes/nodes/nodes-nodes-garbage-collection.html) for OpenShift or [Cluster architecture](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable) for GKE.
+
+### Monitor node conditions
+
+Redis recommends monitoring the node conditions. If both `MemoryPressure` and `DiskPressure` are true, the eviction threshold was met.
+
+```sh
+> kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+
+For more information about monitoring node conditions, see [Node conditions](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#node-conditions) on [kubernetes.io](https://kubernetes.io/docs/home/).
+
+## Resource quotas
+
+Kubernetes uses the `ResourceQuota` object to limit resource consumption per namespace. This lets you limit the number of objects created by a namespace or the amount of compute resources consumed by a namespace. 
+
+The resource settings for Redis Enterprise for Kubernetes are defined in the `operator.yaml` and the [`RedisEnterpriseCluster`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_cluster_api.md#redisenterpriseclusterspec) custom resource.
+
+The following settings are the minimum workloads for the operator to function.
+
+```yaml
+  resources:
+    limits:
+      cpu: 0.5
+      memory: 256Mi
+    requests:
+      cpu: 0.5
+      memory: 256Mi
+```
+For more details on using resource quotas, see the [Kubernetes documentation](https://kubernetes.io/docs/concepts/policy/resource-quotas/).
+
+
+---
+Title: Use persistent volumes in Redis Enterprise clusters
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section covers details about how persistent volumes are sized and
+  specified for Redis Enterprise cluster deployments.
+linkTitle: Persistent volumes
+weight: 40
+url: '/operate/kubernetes/7.8.6/recommendations/persistent-volumes/'
+---
+## 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.
+
+{{<warning>}}
+NFS, NFS-like, and multi-read-write/shared storage options are not supported. These types of storage are often slow and can cause locking behaviors that are incompatible with the requirements of database storage.
+{{</warning>}}
+
+## REC `persistentSpec` field 
+To deploy a Redis Enterprise cluster with Redis Enterprise operator the
+spec should include a *persistentSpec* section, in the
+*redis-enterprise-cluster.yaml* file:
+
+    spec:
+      nodes: 3
+      persistentSpec:
+       enabled: true
+       storageClassName: "standard"
+       volumeSize: "23Gi” #optional
+
+Persistence storage is a requirement for production deployments.
+
+{{< note >}}
+For **production deployments** of Redis Enterprise Cluster on Kubernetes,
+the Redis Enterprise Cluster (REC) must be deployed with persistence enabled.
+The REC deployment files in the [Kubernetes documentation](https://github.com/RedisLabs/redis-enterprise-k8s-docs) contain this declaration by default.
+{{< /note >}}
+
+## Volume size
+
+*volumeSize* is an optional definition. By default, if the definition is
+omitted, operator allocates five times (5x) the amount of memory (RAM)
+defined for nodes (see example below), which is the recommended
+persistent storage size as described in the [Hardware
+requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) article.
+
+To explicitly specify the persistent storage size, use the *volumeSize*
+property as described in the example above.
+
+Persistent volume claims can be expanded, but not reduced after creation. See [Expand PersistentVolumeClaim (PVC)]({{<relref "/operate/kubernetes/7.8.6/re-clusters/expand-pvc">}}) for details.
+
+{{< note >}}
+We recommend that you omit the volumeSize definition from the REC declaration
+so that the Redis Enterprise Cluster deployment on Kubernetes use the default volume size.
+{{< /note >}}
+
+## Storage class name
+
+*storageClassName* determines the Storage Class resource, which is
+defined by the Kubernetes cluster administrator, to be used for
+persistent storage.
+
+Different Kubernetes distributions and different deployments use
+different Storage Class resources.
+
+In order to determine the Storage Class resources available for your K8s
+deployment, use the following command:
+
+    kubectl get StorageClass
+
+Typically, AWS provides “gp2” as the Storage Class name while GKE uses “standard.”
+Azure provides two Storage Classes: "default" using HDDs, and "managed-premium" using SSDs.
+
+Below is an example of a response to the command.
+
+|                         |                                                         |
+| ----------------------- | ------------------------------------------------------- |
+| *Name:*                 | *gp2*                                                   |
+| *IsDefaultClass:*       | *Yes*                                                   |
+| *Annotations:*          | *storageclass.beta.kubernetes.io/is-default-class=true* |
+| *Provisioner:*          | *kubernetes.io/aws-ebs*                                 |
+| *Parameters:*           | *encrypted=false,kmsKeyId=,type=gp2*                    |
+| *AllowVolumeExpansion:* | *\<unset\>*                                             |
+| *MountOptions:*         | *\<none\>*                                              |
+| *ReclaimPolicy:*        | *Delete*                                                |
+| *VolumeBindingMode:*    | *Immediate*                                             |
+| *Events:*               | *\<none\>*                                              |
+
+{{< note >}}
+storageClassName must be specified for this deployment type.
+{{< /note >}}
+
+{{< warning >}}
+The storage class cannot be changed after deployment. Trying to change this value after deployment could result in unexpected and potentially damaging behavior.
+{{< /warning >}}
+
+Example of the redisEnterpriseNodeResources definition:
+
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: “4000m”
+        memory: 4Gi
+      requests:
+        cpu: “4000m”
+        memory: 4Gi
+---
+Title: Manage pod stability
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how you can use quality of service,
+  priority class, eviction thresholds and resource monitoring to maintain cluster
+  node pod stability.
+linkTitle: Pod stability
+weight: 90
+url: '/operate/kubernetes/7.8.6/recommendations/pod-stability/'
+---
+
+Kubernetes clusters manage the allocation of system resources and can evict pods to release system resources.
+Here are some ways that you can configure the Redis Enterprise node pods to maintain pod stability:
+
+## Guaranteed quality of service
+
+A running pod has a quality of service measure assigned to it that is
+one of three [quality of service classes](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/):
+Guaranteed, Burstable, and Best Effort.
+You can assure the Guaranteed class is assigned to the Redis Enterprise node pods
+by following the right guidelines.
+
+To get a Guaranteed quality of service class assigned:
+
+ * Every container in the pod must have a memory limit and a memory request, and they must be the same.
+ * Every container in the pod must have a CPU limit and a CPU request, and they must be the same.
+
+If resources limits and requests are not specified in the Redis Enterprise CRD,
+these requirements are met in the default version created by the operator. of your Redis Enterprise cluster CRD,
+Otherwise, you must set the limits and requests to the same value for memory and CPU in the `redisEnterpriseNodeResources`
+section of the CRD.
+
+Sidecar containers also impact the quality of service class assignment for the pod.
+
+To check the quality of service class of any running Redis Enterprise node pod, run:
+
+```sh
+kubectl get pod rec-0 --o jsonpath="{.status.qosClass}"
+```
+
+where `rec-0` is the name of one of the pods associated with the Redis Enterprise cluster.
+
+## Using priority to protect from preemption
+
+When a Redis Enterprise node pod is scheduled, it can be assigned a
+[priority class](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/)
+with the `priorityClassName` property. This property value is the name of
+a priority class that must already exist within the cluster.
+
+A sufficiently high priority will prevent other workloads with a lower
+priority from preempting the scheduling of Redis Enterprise Nodes. Similarly,
+a high value may also prevent eviction when lower priority workloads
+are deployed on the same cluster.
+
+The successful use of this strategy involves first creating a priority class with a very large priority value:
+
+```yaml
+apiVersion: scheduling.k8s.io/v1
+kind: PriorityClass
+metadata:
+  name: redis-enterprise-priority
+value: 1000000000
+globalDefault: false
+description: "This priority class should be used for Redis Enterprise pods only."
+```
+
+Then, you refer to the priority class by name in your Redis Enterprise cluster CRD:
+
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: example-redisenterprisecluster
+spec:
+  size: 3
+  priorityClassName: "redis-enterprise-priority"
+```
+
+Alternatively, you can also [disable preemption entirely](https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/#how-to-disable-preemption).
+
+## Managing eviction thresholds
+
+Eviction thresholds are typically managed by kubelet arguments.
+You can set the thresholds:
+
+- On OpenShift - In the [config file](https://docs.openshift.com/container-platform/3.11/admin_guide/out_of_resource_handling.html#out-of-resource-create-config).
+- On GKE - In the [managed settings](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture#node_allocatable).
+
+We recommend that you:
+
+ * Set the [soft eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#soft-eviction-thresholds)
+   to be higher than the [hard eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#hard-eviction-thresholds).
+   The high soft threshold makes the node condition change earlier, and alerts the administrator.
+ * Set `eviction-max-pod-grace-period` high enough to allow the RS pods to migrate the Redis databases before the pods are force killed.
+ * Set the `eviction-soft-grace-period` high enough that the administrator (or a k8s auto-scaling mechanism) scales k8s up or out.
+
+## Monitoring for memory and disk usage
+
+We recommend that you monitor the node for MemoryPressure and DiskPressure.
+When both of these conditions are true, then an [eviction threshold](https://kubernetes.io/docs/tasks/administer-cluster/out-of-resource/#eviction-thresholds)
+is met and the pod is evicted.
+
+To retrieve the flags, run the command:
+
+```sh
+$kubectl get nodes -o jsonpath='{range .items[*]}name:{.metadata.name}{"\t"}MemoryPressure:{.status.conditions[?(@.type == "MemoryPressure")].status}{"\t"}DiskPressure:{.status.conditions[?(@.type == "DiskPressure")].status}{"\n"}{end}'
+
+name:gke-55d1ac88-213c	MemoryPressure:False	DiskPressure:False
+name:gke-55d1ac88-vrpp	MemoryPressure:False	DiskPressure:False
+name:gke-7253cc19-42g0	MemoryPressure:False	DiskPressure:False
+```
+---
+Title: Configuration recommendations
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Settings and configuration recommendations for your Redis Enterprise
+  deployment.
+hideListLinks: false
+linkTitle: Recommendations
+weight: 80
+url: '/operate/kubernetes/7.8.6/recommendations/'
+---
+
+This section contains  recommended settings and configuration for your Redis Enterprise for Kubernetes deployment.
+
+
+
+---
+Title: Flexible deployment options
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes allows you to deploy to multiple namespaces.
+  This article describes flexible deployment options you can use to meet your specific
+  needs.
+linkTitle: Deployment options
+url: '/operate/kubernetes/7.8.6/architecture/deployment-options/'
+---
+You can deploy Redis Enterprise for Kubernetes in several different ways depending on your database needs.
+
+Multiple RedisEnterpriseDatabase (REDB) resources can be associated with a single Redis Enterprise cluster resource (REC) even if they reside in different namespaces.
+
+The Redis Enterprise cluster (REC) custom resource must reside in the same namespace as the Redis Enterprise operator.
+
+{{<warning>}} Multi-namespace installations don't support Active-Active databases (REEADB). Only databases created with the REDB resource are supported in multi-namespace deployments at this time.{{</warning>}}
+
+## Single REC and single namespace (one-to-one)
+
+The standard and simplest deployment deploys your Redis Enterprise databases (REDB) in the same namespace as the Redis Enterprise cluster (REC). No additional configuration is required for this, since there is no communication required to cross namespaces. See [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/7.8.6/deployment/quick-start.md" >}}).
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-one.png" >}}
+
+## Single REC and multiple namespaces (one-to-many)
+
+Multiple Redis Enterprise databases (REDB) spread across multiple namespaces within the same K8s cluster can be associated with the same Redis Enterprise cluster (REC). See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace.md" >}}) for more information.
+
+{{< image filename="/images/k8s/k8s-deploy-one-to-many.png" >}}
+
+## Multiple RECs and multiple namespaces (many-to-many)
+
+A single Kubernetes cluster can contain multiple Redis Enterprise clusters (REC), as long as they reside in different namespaces. Each namespace can host only one REC and each operator can only manage one REC.
+
+You have the flexibility to create databases in separate namespaces, or in the same namespace as the REC, or combine any of the supported deployment options above. This configuration is geared towards use cases that require multiple Redis Enterprise clusters with greater isolation or different cluster configurations.
+
+See [Manage databases in multiple namespaces]({{< relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace.md" >}}) for more information.
+
+
+{{< image filename="/images/k8s/k8s-deploy-many-to-many.png" >}}
+
+## Unsupported deployment patterns
+
+### Cross-cluster operations
+
+Redis Enterprise for Kubernetes does not support operations that cross Kubernetes clusters. Redis Enterprise clusters (REC) work inside a single K8s cluster. Crossing clusters could result in functional and security issues.
+
+{{< image filename="/images/k8s/k8s-deploy-cross-namespaces.png" >}}
+
+### Multiple RECs in one namespace
+
+Redis Enterprise for Kubernetes does not support multiple Redis Enterprise clusters (REC) in the same namespace. Creating more than one REC in the same namespace will result in errors.
+
+{{< image filename="/images/k8s/k8s-deploy-multicluster-antipattern.png" >}}
+---
+Title: Redis Enterprise for Kubernetes architecture
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Overview of the architecture and components of Redis Enterprise for Kubernetes.
+hideListLinks: true
+linkTitle: Architecture
+weight: 1
+url: '/operate/kubernetes/7.8.6/architecture/'
+---
+
+Redis Enterprise for Kubernetes gives you the speed and durability of [Redis Enterprise](https://redis.io/redis-enterprise/advantages/), with the flexibility and ease of [Kubernetes (K8s)](https://kubernetes.io/). Redis Enterprise for Kubernetes uses the Kubernetes operator pattern and custom controllers to bring the best of Redis Enterprise to the Kubernetes platform.
+
+## Lifecycle
+
+Kubernetes is a rapidly evolving platform with a short release cycle (around 4 months). This frequent influx of new features, enhancements and bug fixes means Kubernetes distributions move in and out of support quickly. Redis Enterprise is also a fast-moving product, and is compatible and tested only on distributions listed as [supported distributions.]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions">}})
+
+Each version of Redis Enterprise for Kubernetes is tested to ensure the version of Redis Enterprise works with the [supported Kubernetes distributions]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions">}}) at the time. Both the Kubernetes version and the Redis Enterprise version must be supported for the operator to function correctly. We encourage you to upgrade Redis Enterprise for Kubernetes frequently, not only to get the benefit of enhancements and bug fixes, but to keep your software supported.
+
+Supported platforms are listed in the [release notes]({{<relref "/operate/kubernetes/release-notes">}}) and in the [supported platforms reference.]({{<relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions">}})
+
+## Architecture
+
+The image below illustrates the components of a single namespace, three node deployment.
+
+{{< image filename="/images/k8s/k8s-arch-v4.png" >}}
+
+## Operator
+
+An [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is a custom extension of the Kubernetes API designed to manage complex, stateful applications and their components. This operator pattern is commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. Kubernetes.io/docs has a great explanation of the [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/).
+
+The operator is a deployment that runs within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/) and uses [controllers](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#custom-controllers) to manage [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/), ensuring these resources are continuously monitored and maintained.
+
+When the operator is installed, the following resources are created:
+
+- [service account](https://kubernetes.io/docs/concepts/security/service-accounts/) under which the operator will run
+- set of [roles](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole) to define the privileges necessary for the operator to perform its tasks
+- set of [role bindings](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-and-clusterrolebinding) to authorize the service account
+- [CustomResourceDefinition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for each Redis Enterprise custom resource
+- the operator deployment
+
+## Namespace
+
+The Redis Enterprise [operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) is deployed within a [namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). Each namespace can host only one operator and one [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec). Namespaces create logical boundaries between resources, allowing organization and security. Some resources are limited to a namespace, while others are cluster-wide.
+
+Redis Enterprise for Kubernetes also supports [multi-namespace deployments]({{<relref "/operate/kubernetes/7.8.6/architecture/deployment-options">}}), meaning the operator can monitor other namespaces (that host applications) for custom resources and apply any changes.
+
+## Custom resources
+
+Kubernetes [custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) are commonly used by databases and other applications to extend the cluster's behavior without changing its underlying code. [Custom resources (CRs)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) extend the Kubernetes API, enabling users to manage Redis databases the Kubernetes way. Custom resources are created and managed using YAML configuration files.
+
+This [declarative configuration approach](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/) allows you to specify the desired state for your resources, and the operator makes the necessary changes to achieve that state. This simplifies [installation]({{<relref "/operate/kubernetes/7.8.6/deployment">}}), [upgrades]({{<relref "/operate/kubernetes/7.8.6/upgrade">}}), and [scaling]({{<relref "/operate/kubernetes/7.8.6/recommendations/sizing-on-kubernetes">}}) both vertically and horizontally.
+
+The operator continuously monitors CRs for changes, automatically reconciling any differences between the desired state you specified in your YAML configuration file, and the actual state of your resources. Custom resources can also reside in separate namespaces from the operator managing them, such as in [multi-namespace installations]({{<relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace">}}).
+
+## Custom resource definitions
+
+A [custom resource definition (CRD)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) is a cluster-wide resource that specifies which settings can be configured via custom resource files. Any setting not defined by the CRD is not managed by the operator. You can still make changes to these unmanaged settings using standard Redis Enterprise Software methods.
+
+For settings managed by the operator, any changes made outside of the CR YAML files (e.g., through the management UI) will be overwritten by the operator. Ensure that all operator-managed settings are updated using the CR YAML files to prevent conflicts.
+
+## RedisEnterpriseCluster REC
+
+A Redis Enterprise cluster is a set of Redis Enterprise nodes pooling resources. Each node is capable of running multiple Redis instances ([shards]({{<relref "/operate/rs/references/terminology">}})).
+
+{{< image filename="/images/k8s/k8s-node-arch.png">}}
+
+A Redis cluster is created and managed by the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REC configuration file prompt the operator to make changes to the cluster. The REC is required for both standard databases ([REDB](#redisenterprisedatabase-redb)) and Active-Active databases ([REAADB](#redisenterpriseactiveactivedatabase-reaadb)).
+
+See the [RedisEnterpriseCluster API Reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseDatabase REDB
+
+A Redis Enterprise database is a logical entity that manages your entire dataset across multiple Redis instances. A Redis instance is a single-threaded database process ([commonly referred to as a shard]({{<relref "/operate/rs/references/terminology">}})).
+
+Redis databases are created and managed by the [RedisEnterpriseDatabase (REDB)]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api">}}) [custom resource (CR)](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/). Changes to the REDB YAML configuration file prompt the operator to make changes to the database.
+
+An operator can manage a database in the same namespace, or a different namespace. See ["Flexible deployment"]({{<relref "/operate/kubernetes/7.8.6/architecture/deployment-options">}}) options and ["Manage databases in multiple namespaces"]({{<relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace">}}) for more information.
+
+See the [RedisEnterpriseDatabase (REDB) API Reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api">}}) for a full list of fields and settings.
+
+## Security
+
+Redis Enterprise for Kubernetes uses [secrets](https://kubernetes.io/docs/concepts/configuration/secret/) to manage your cluster credentials, cluster certificates, and client certificates. You can configure [LDAP]({{<relref "/operate/kubernetes/7.8.6/security/ldap">}}) and [internode encryption]({{<relref "/operate/kubernetes/7.8.6/security/internode-encryption">}}) using the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec) spec.
+
+### REC credentials
+
+Redis Enterprise for Kubernetes uses the [RedisEnterpriseCluster (REC)]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}}) [custom resource](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/) to create a Redis Enterprise cluster. During creation it generates random credentials for the operator to use. The credentials are saved in a Kubernetes (K8s) [secret](https://kubernetes.io/docs/concepts/configuration/secret/). The secret name defaults to the name of the cluster.
+
+See [Manage REC credentials]({{<relref "/operate/kubernetes/7.8.6/security/manage-rec-credentials">}}) for more details.
+
+### REC certificates
+
+By default, Redis Enterprise Software for Kubernetes generates TLS certificates for the cluster during creation. These self-signed certificates are generated on the first node of each Redis Enterprise cluster (REC) and are copied to all other nodes in the cluster.
+
+See [Manage REC certificates]({{<relref "/operate/kubernetes/7.8.6/security/manage-rec-certificates.md">}}) for more details.
+
+### Client certificates
+
+For each client certificate you want to use, you need to create a [Kubernetes secret](https://kubernetes.io/docs/concepts/configuration/secret/) to hold it. You can then reference that secret in your [Redis Enterprise database (REDB)](#redisenterprisedatabase-redb) custom resource.
+
+See [Add client certificates]({{<relref "/operate/kubernetes/7.8.6/security/add-client-certificates">}}) for more details.
+
+## Storage
+
+[Persistent storage is mandatory for Redis Enterprise.]({{<relref "operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage">}}) Redis Enterprise for Kubernetes [requires network-attached storage](https://en.wikipedia.org/wiki/Network-attached_storage).
+
+Redis Enterprise for Kubernetes uses [PersistentVolumeClaims (PVC)](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims) to manage storage resources. The PVC is an abstract representation of the [PersistentVolume (PV)](https://kubernetes.io/docs/concepts/storage/persistent-volumes) resources used by your Redis pods. PVCs are created by the Redis Enterprise operator and used by the [RedisEnterpriseCluster (REC)](#redisenterprisecluster-rec).
+
+PVCs are created with a specific size and [can be expanded](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#expanding-persistent-volumes-claims), if the underlying [storage class](https://kubernetes.io/docs/concepts/storage/storage-classes/) supports it.
+
+### Auto Tiering
+
+Redis Enterprise Software for Kubernetes supports [Auto Tiering]({{<relref "/operate/kubernetes/7.8.6/re-clusters/auto-tiering">}}) (previously known as Redis on Flash), which extends your node memory to use both RAM and flash storage. SSDs (solid state drives) can store infrequently used (warm) values while your keys and frequently used (hot) values are still stored in RAM. This improves performance and lowers costs for large datasets.
+
+NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
+
+## Networking
+
+By default, Kubernetes doesn't allow you to access your Redis database from outside your K8s cluster. Redis Enterprise for Kubernetes supports several ways to route external traffic to your [Redis Enterprise cluster (REC)](#redisenterprisecluster-rec):
+
+- Ingress controllers [HAProxy](https://haproxy-ingress.github.io/) and [NGINX](https://kubernetes.github.io/ingress-nginx/) require an `ingress` API resource.
+- [Istio](https://istio.io/latest/docs/setup/getting-started/) requires `Gateway` and `VirtualService` API resources.
+- OpenShift uses [routes]({{< relref "/operate/kubernetes/7.8.6/networking/routes.md" >}}) to route external traffic.
+
+The [Active-Active databases](#active-active-databases) require one of above routing methods to be configured in the REC with the [ingressOrRouteSpec field]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#specingressorroutespec">}}).
+
+## Services Rigger
+
+The services rigger is responsible for creating and updating services related to database objects. It identifies database objects within the cluster and creates services in accordance with [`redisEnterpriseCluster.Spec.servicesRiggerSpec` setting]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api#specservicesriggerspec">}}) to allow access to those databases. By default, each database has two services, a `cluster_ip` Service with the same name as the database and a `headless` Service with the same name as the database suffixed with `-headless`. It also creates other types of Services such as Ingress Services or OpenshiftRoutes (defined in `redisEnterpriseCluster.Spec.ingressOrRouteSpec`) meant to provide access to REAADB objects.
+
+You can view a list of services with the `kubectl get services` command.
+
+Kubernetes is a dynamic environment, with nodes and pods changing as needed. The services rigger monitors the cluster for these changes and updates the database services to ensure reliable communication with the databases.
+
+## Active-Active databases
+
+On Kubernetes, Redis Enterprise [Active-Active]({{< relref "/operate/rs/databases/active-active/" >}}) databases provide read and write access to the same dataset from different Kubernetes clusters. Creating an Active-Active database requires routing [network access]({{< relref "/operate/kubernetes/7.8.6/networking/" >}}) between two Redis Enterprise clusters residing in different Kubernetes clusters. Without the proper access configured for each cluster, syncing between the databases instances will fail.The admission controller is also required for Active-Active databases on Kubernetes, to validate changes to the custom resources.
+
+For more details and installation information, see [Active-Active databases]({{<relref "/operate/kubernetes/7.8.6/active-active/">}}). For more general information about Active-Active, see the [Redis Enterprise Software docs]({{< relref "/operate/rs/databases/active-active/" >}}).
+
+## RedisEnterpriseRemoteCluster RERC
+
+The [RedisEnterpriseRemoteCluster (RERC)]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}) contains details allowing the REC to link to the RedisEnterpriseActiveActiveDatabase (REAADB). The RERC resource is listed in the [REAADB](#redisenterpriseactiveactivedatabase-reaadb) resource to become a participating cluster for the Active-Active database.
+
+See the [RERC API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api">}}) for a full list of fields and settings.
+
+## RedisEnterpriseActiveActiveDatabase REAADB
+
+The RedisEnterpriseActiveActiveDatabase (REAADB) resource creates and manages a database that spans more than one Kubernetes cluster. An REAADB requires [external routing](#networking), at least two [RECs](#redisenterprisecluster-rec), and at least two [RERCs](#redisenterpriseremotecluster-rerc).
+
+See the [REAADB API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_active_active_database_api">}}) for a full list of fields and settings.
+
+## Metrics
+
+To collect  metrics data from your databases and Redis Enterprise cluster (REC), you can [connect your Prometheus]({{<relref "/operate/kubernetes/7.8.6/re-clusters/connect-prometheus-operator">}}) server to an endpoint exposed on your REC. Redis Enterprise for Kubernetes creates a dedicated service to expose the `prometheus` port (8070) for data collection. A custom resource called `ServiceMonitor` allows the [Prometheus operator](https://github.com/prometheus-operator/prometheus-operator/tree/main/Documentation) to connect to this port and collect data from Redis Enterprise.
+---
+Title: Collect logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Run the log collector script to package relevant logs into a tar.gz file
+  to send to Redis Support for help troubleshooting your Kubernetes environment.
+linkTitle: Collect logs
+weight: 89
+url: '/operate/kubernetes/7.8.6/logs/collect-logs/'
+---
+
+The Redis Enterprise cluster (REC) log collector script ([`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py)) creates and fills a directory with the relevant logs for your environment. These logs will help the support team with troubleshooting.
+
+As of version 6.2.18-3, the log collector tool has two modes:
+
+- **restricted** collects only resources and logs created by the operator and Redis Enterprise deployments
+  - This is the default for versions 6.2.18-3 and later
+- **all** collects everything from your environment
+  - This is the default mode for versions 6.2.12-1 and earlier
+
+{{<note>}} This script requires Python 3.6 or later. {{</note>}}
+
+1. Download the latest [`log_collector.py`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/log_collector/log_collector.py) file.
+
+1. Have a K8s administrator run the script on the system that runs your `kubectl` or `oc` commands.
+    - Pass `-n` parameter to run on a different namespace than the one you are currently on
+    - Pass `-m` parameter to change the log collector mode (`all` or `restricted`)
+    - Run with `-h` to see more options
+
+    ```bash
+    python log_collector.py 
+    ```
+
+   {{< note >}} If you get an error because the yaml module is not found, install the pyYAML module with `pip install pyyaml`.
+  {{< /note >}}
+
+
+
+1. Upload the resulting `tar.gz` file containing all the logs to [Redis Support](https://support.redislabs.com/).
+---
+Title: Redis Enterprise Software logs on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section provides information about how logs are stored and accessed.
+hideListLinks: true
+linkTitle: Logs
+weight: 60
+url: '/operate/kubernetes/7.8.6/logs/'
+---
+
+## Logs
+
+Each redis-enterprise container stores its logs under `/var/opt/redislabs/log`.
+When using persistent storage this path is automatically mounted to the
+`redis-enterprise-storage` volume.
+This volume can easily be accessed by a sidecar, i.e. a container residing on the same pod.
+
+For example, in the REC (Redis Enterprise Cluster) spec you can add a sidecar container, such as a busybox, and mount the logs to there:
+
+```yaml
+sideContainersSpec:
+  - name: busybox
+    image: busybox
+    args:
+      - /bin/sh
+      - -c
+      - while true; do echo "hello"; sleep 1; done
+
+    volumeMounts:
+    - name: redis-enterprise-storage
+      mountPath: /home/logs
+      subPath: logs
+```
+
+Now the logs can be accessed from in the sidecar. For example by running
+
+```kubectl exec -it <pod-name> -c busybox tail home/logs/supervisord.log```
+
+The sidecar container is user determined and can be used to format, process and share logs in a specified format and protocol.
+---
+Title: Use a private registry for container images
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section details how the Redis Enterprise Software and Kubernetes
+  operator images can be configured to be pulled from a variety of sources. This page
+  describes how to configure alternate private repositories for images, plus some
+  techniques for handling public repositories with rate limiting.
+linktitle: Use a private container registry
+weight: 92
+url: '/operate/kubernetes/7.8.6/deployment/container-images/'
+---
+
+Redis Enterprise Software, its Kubernetes operator, and the Service Rigger
+are all distributed as separate container images.
+Your Kubernetes deployment will pull these images as needed.
+ You can control where these images are
+pulled from within the operator deployment and also via the
+Redis Enterprise custom resources.
+
+In general, images for deployments that do not have a registry domain
+name (e.g., `gcr.io` or `localhost:5000`) are pulled from the default registry associated
+with the Kubernetes cluster. A plain reference to `redislabs/redis` will likely pull from DockerHub
+(except on OpenShift where it pulls from Red Hat).
+
+For security reasons (e.g., in air-gapped environments), you may want to pull the images
+from a public registry once and then push them to a private registry under
+your control.
+
+{{<warning>}}It is very important that the images you are pushing to the private registry have the same exact version tag as the original images. {{</warning>}}
+
+Furthermore, because [Docker rate limits public pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/),
+you may want to consider pulling images from a
+private registry to avoid deployment failures when you hit your DockerHub rate limit.
+
+The information below will help you track and configure where your deployments pull container images.
+
+{{< note >}}
+**IMPORTANT**
+* Each version of the Redis Enterprise operator is mapped to a specific version of Redis Enterprise Software. The semantic versions always match (for example, 7.2.4), although the specific release numbers may be different (for example, 7.2.4-7 is the operator version for Redis Enterprise Software 7.2.4-64).
+* A specific operator version only supports a specific Redis Enterprise version. Other combinations of operator and Redis Enterprise versions are **not supported**.
+{{< /note >}}
+
+
+## Find container sources
+
+Every pod in your deployed application has a source registry. Any image not prefixed by a registry domain name (e.g., "gcr.io") will pull from the default registry for the Kubernetes cluster (i.e., DockerHub). You can use the commands below to discover the pull sources for the images on your cluster.
+
+To list all the images used by your cluster:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c
+```
+
+To specifically determine the pull source for the Redis Enterprise operator itself, run the following command:
+
+```sh
+kubectl get pods --all-namespaces -o jsonpath="{..image}" |tr -s '[[:space:]]' '\n' | uniq -c | grep redislabs
+```
+
+You can limit this command to specific namespaces by replacing the `--all-namespaces` parameter with
+a set of `-n {namespace}` parameters, where each `{namespace}` is a specific
+namespace of interest on your cluster.
+
+## Create a private container registry
+
+You can set up a private container registry in a couple of ways:
+
+* On-premise via [Docker registry](https://docs.docker.com/registry/deploying/), [Red Hat Quay](https://www.redhat.com/en/technologies/cloud-computing/quay), or other providers
+* Cloud provider based registries (e.g., Azure Container Registry, Google Container Registry, etc.).
+
+Once you have set up a private container registry, you will identify the container registry using:
+
+* A domain name
+* A port (optional)
+* A repository path (optional)
+
+## Push images to a private container registry
+
+Important images for a Redis Enterprise Software deployment include:
+
+* Redis Enterprise Software
+* Bootstrapping a Redis Enterprise cluster node (in the operator image)
+* The Service Rigger
+* The Redis Enterprise Software operator
+
+You will need to push all these images to your private container registry. In general,
+to push the images you must:
+
+ 1. [Pull](https://docs.docker.com/engine/reference/commandline/pull/) the various images locally for the Redis Enterprise Software, the Service Rigger, and the operator.
+ 2. Tag the local images with the private container registry, repository, and version tag.
+ 3. [Push](https://docs.docker.com/engine/reference/commandline/push/) the newly tagged images.
+
+The example below shows the commands for pushing the images for Redis Enterprise Software and its operator to a private container registry:
+
+```sh
+PRIVATE_REPO=...your repo...
+RS_VERSION=7.2.4-64
+OPERATOR_VERSION=7.2.4-7
+docker pull redislabs/redis:${RS_VERSION}
+docker pull redislabs/operator:${OPERATOR_VERSION}
+docker pull redislabs/k8s-controller:${OPERATOR_VERSION}
+docker tag redislabs/redis:${RS_VERSION} ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker tag redislabs/operator:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker tag redislabs/k8s-controller:${OPERATOR_VERSION} ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/redis:${RS_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+docker push ${PRIVATE_REPO}/redislabs/k8s-controller:${OPERATOR_VERSION}
+```
+
+## Configure deployments to use a private container registry
+
+Once you push your images to your private container registry, you need to
+configure your deployments to use that registry for Redis Enterprise Software and operator
+deployments. The operator container image is configured directly by the operator deployment
+bundle. The Redis Enterprise cluster pod (RS and bootstrapper) and Service Rigger
+images are configured in the Redis Enterprise custom resource.
+
+Depending on your Kubernetes platform, your private container registry may
+require authentication. If you do need authentication, add a [pull secret](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) to your namespace. Then you'll need to configure Kubernetes and the operator to use the pull secret. The two following sections have examples of adding the `imagePullSecrets` to the operator deployment and `pullSecrets` to the cluster custom resource.
+
+### Specify the operator image source
+
+The operator bundle contains the operator deployment and the reference to the operator image (`redislabs/operator`). To use a private container registry, you must
+change this image reference in your operator deployment file **before** you deploy the operator. If you apply this change to modify an existing operator deployment, the operator's pod will restart.
+
+In the operator deployment file, 'containers:image' should point to the same repository and tag you used when [pushing]({{< relref "/operate/kubernetes/7.8.6/deployment/container-images.md#push-images-to-a-private-container-registry" >}}) to the private container registry:
+
+```sh
+${PRIVATE_REPO}/redislabs/operator:${OPERATOR_VERSION}
+```
+
+The example below specifies a 7.2.4-7 operator image in a Google Container Registry:
+
+```YAML
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: redis-enterprise-operator
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      name: redis-enterprise-operator
+  template:
+    metadata:
+      labels:
+        name: redis-enterprise-operator
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      containers:
+        - name: redis-enterprise-operator
+          image: gcr.io/yourproject/redislabs/operator:7.2.4-7
+...
+```
+
+If your container registry requires a pull secret, configure `imagePullSecrets` on the operator deployment:
+
+```YAML
+spec:
+  template:
+    spec:
+      imagePullSecrets:
+      - name: regcred
+```
+
+### Specify the Redis Enterprise cluster images source
+
+A Redis Enterprise cluster managed by the operator consists of three
+container images:
+
+* **`redislabs/redis`**: the Redis Enterprise Software container image
+* **`redislabs/operator`**: the bootstrapper is packaged within the operator container image
+* **`redislabs/k8s-controller`**: the Service Rigger container image
+
+By default, a new Redis Enterprise cluster is created using the
+container images listed above. These container images are pulled from the K8s cluster's default
+container registry.
+
+To [pull](https://docs.docker.com/engine/reference/commandline/pull/) the Redis Enterprise container images from
+a private container registry, you must specify them in the
+Redis Enterprise cluster custom resource.
+
+Add the following sections to the `spec` section of your RedisEnterpriseCluster resource file:
+
+ * **`redisEnterpriseImageSpec`**: controls the Redis Enterprise Software container image. *The version should match the RS version associated with the operator version*.
+ * **`bootstrapperImageSpec`**": controls the bootstrapper container image. *The version must match the operator version*.
+ * **`redisEnterpriseServicesRiggerImageSpec`**: controls the Service Rigger container image. *The version must match the operator version*.
+
+The REC custom resource example below pulls all three container images from a GCR private registry:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+If your private container registry requires pull secrets, you must add `pullSecrets`
+to the `spec` section:
+
+```YAML
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+spec:
+  nodes: 3
+  pullSecrets:
+    - name: regcred
+  redisEnterpriseImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/redis
+    versionTag: 7.2.4-64
+  bootstrapperImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/operator
+    versionTag: 7.2.4-7
+  redisEnterpriseServicesRiggerImageSpec:
+    imagePullPolicy: IfNotPresent
+    repository: gcr.io/yourproject/redislabs/k8s-controller
+    versionTag: 7.2.4-7
+```
+
+## Rate limiting with DockerHub
+
+Docker has [rate limits for image pulls](https://www.docker.com/blog/scaling-docker-to-serve-millions-more-developers-network-egress/).
+Anonymous users are allowed a certain number of pulls every 6 hours. For authenticated users, the limit is larger.
+These rate limits may affect your Kubernetes cluster in a number of ways:
+
+* The cluster nodes will likely be treated as a single anonymous user.
+* The number of pulls during a deployment might exceed the rate limit for other deployment dependencies, including the operator, Redis Enterprise Software, or other non-Redis pods.
+* Pull failures may prevent your deployment from downloading the required images in a timely manner. Delays here can affect the stability of deployments used by the Redis Enterprise operator.
+
+For these reasons, you should seriously consider where your images
+are pulled from to **avoid failures caused by rate limiting**. The easiest solution
+is to push the required images to a private container registry under your control.
+---
+Title: Install Redis Enterprise Helm chart
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Install Redis Enterprise for Kubernetes version 7.8.6 using Helm charts.
+linkTitle: Helm
+weight: 11
+url: '/operate/kubernetes/7.8.6/deployment/helm/'
+---
+
+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/](https://helm.sh/docs/).
+
+{{<note>}} This feature is currently in public preview and is not supported on production workloads. Only new installations of the Redis operator are supported at this time. The steps for [creating the RedisEnterpriseCluster (REC)]({{<relref "operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec">}}) and other custom resources remain the same.{{</note>}}
+
+## Prerequisites
+
+- A [supported distribution]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions.md" >}}) of Kubernetes.
+- At least three worker nodes.
+- [Kubernetes client (kubectl)](https://kubernetes.io/docs/tasks/tools/).
+- [Helm 3.10 or later](https://helm.sh/docs/intro/install/).
+
+### Example values
+
+The steps below use the following placeholders to indicate command line parameters you must provide:
+
+- `<repo-name>` is the name of the repo holding your Helm chart (example: `redis`).
+- `<release-name>` is the name you give a specific installation of the Helm chart (example: `my-redis-enterprise-operator`)
+- `<chart-version>` is the version of the Helm chart you are installing (example: `7.8.2-2`)
+- `<namespace-name>` is the name of the new namespace the Redis operator will run in (example: `ns1`)
+- `<path-to-chart>` is the filepath to the Helm chart, if it is stored in a local directory (example: `/home/charts/redis-enterprise-operator`)
+
+## Install
+
+1. Add the Redis repository.
+
+```sh
+helm repo add <repo-name> https://helm.redis.io/
+```
+
+2. Install the Helm chart into a new namespace.
+
+```sh
+helm install <release-name> redis/redis-enterprise-operator \
+    --version <chart-version> \
+    --namespace <namespace-name> \
+    --create-namespace
+```
+
+To install with Openshift, add `--set openshift.mode=true`.
+
+To monitor the installation add the `--debug` flag. The installation runs several jobs synchronously and may take a few minutes to complete.
+
+### Install from local directory
+
+1. Find the latest release on the [redis-enterprise-k8s-docs](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) repo and download the `tar.gz` source code into a local directory.
+
+2. Install the Helm chart from your local directory.
+
+```sh
+helm install <release-name> <path-to-chart> \
+    --namespace <namespace-name> \
+    --create-namespace
+```
+
+To install with Openshift, add `--set openshift.mode=true`.
+
+To monitor the installation add the `--debug` flag. The installation runs several jobs synchronously and may take a few minutes to complete.
+
+### Specify values during install
+
+1. View configurable values with `helm show values <repo-name>/<chart-name>`.
+
+2. Install the Helm chart, overriding specific value defaults using `--set`.
+
+```sh
+helm install <operator-name> redis/redis-enterprise-operator \
+    --version <release-name> \
+    --namespace <namespace-name> \
+    --create-namespace
+    --set <key1>=<value1> \
+    --set <key2>=<value2>
+```
+
+### Install with values file
+
+1. View configurable values with `helm show values <repo-name>/<chart-name>`.
+
+2. Create a YAML file to specify the values you want to configure.
+
+3. Install the chart with the `--values` option.
+
+```sh
+helm install <operator-name> redis/redis-enterprise-operator \
+    --version <release-name> \
+    --namespace <namespace-name> \
+    --create-namespace \
+    --values <path-to-values-file>
+```
+
+## Uninstall
+
+1. Delete any custom resources managed by the operator. See [Delete custom resources]({{<relref "operate/kubernetes/re-clusters/delete-custom-resources">}}) for detailed steps. You must delete custom resources in the correct order to avoid errors.
+
+2. Uninstall the Helm chart.
+
+```sh
+helm uninstall <release-name>
+```
+
+This removes all Kubernetes resources associated with the chart and deletes the release.
+
+{{<note>}}Custom Resource Definitions (CRDs) installed by the chart are not removed during chart uninstallation. To remove them manually after uninstalling the chart, run `kubectl delete crds -l app=redis-enterprise`.{{</note>}}
+
+## Known limitations
+
+- Only new installations of the Redis operator are supported at this time. The steps for [creating the RedisEnterpriseCluster (REC)]({{<relref "operate/kubernetes/deployment/quick-start#create-a-redis-enterprise-cluster-rec">}}) and other custom resources remain the same.
+- Upgrades and migrations are not supported.
+- The chart doesn't include configuration options for multiple namespaces, rack-awareness, and Vault integration. The steps for configuring these options remain the same.
+- The chart has had limited testing in advanced setups, including Active-Active configurations, air-gapped deployments, and IPv6/dual-stack environments.
+---
+Title: Deploy Redis Enterprise Software for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to install Redis Enterprise Software for Kubernetes.
+linkTitle: Kubernetes
+weight: 10
+url: '/operate/kubernetes/7.8.6/deployment/quick-start/'
+---
+
+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]({{< relref "/operate/kubernetes/7.8.6/deployment/openshift" >}}). For details on what is currently supported, see [supported distributions]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions.md" >}}).
+
+## Prerequisites
+
+To deploy Redis Enterprise for Kubernetes, you'll need:
+
+- Kubernetes cluster in a [supported distribution]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions.md" >}})
+- minimum of three worker nodes
+- Kubernetes client (kubectl)
+- access to DockerHub, RedHat Container Catalog, or a private repository that can hold the required images.
+NOTE: If you are applying version 7.8.2-6 or above, check if the [OS](https://redis.io/docs/latest/operate/kubernetes/release-notes/7-8-2-releases/7-8-2-6-nov24/#breaking-changes) installed on the node is supported.
+
+### Create a new namespace
+
+**Important:** Each namespace can only contain one Redis Enterprise cluster. Multiple RECs with different operator versions can coexist on the same Kubernetes cluster, as long as they are in separate namespaces.
+
+Throughout this guide, each command is applied to the namespace in which the Redis Enterprise cluster operates.
+
+1. Create a new namespace
+
+    ```sh
+   kubectl create namespace <rec-namespace>
+   ```
+
+1. Change the namespace context to make the newly created namespace default for future commands.
+
+    ```sh
+    kubectl config set-context --current --namespace=<rec-namespace>
+   ```
+
+You can use an existing namespace as long as it does not contain any existing Redis Enterprise cluster resources. It's best practice to create a new namespace to make sure there are no Redis Enterprise resources that could interfere with the deployment.
+
+## Install the operator
+
+Redis Enterprise for Kubernetes bundle is published as a container image. A list of required images is available in the [release notes]({{< relref "/operate/kubernetes/release-notes/_index.md" >}}) for each version.
+
+The operator [definition and reference materials](https://github.com/RedisLabs/redis-enterprise-k8s-docs) are available on GitHub. The operator definitions are [packaged as a single generic YAML file](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/bundle.yaml).
+
+{{<note>}}
+If you do not pull images from DockerHub or another public registry, you need to use a [private container registry]({{< relref "/operate/kubernetes/7.8.6/deployment/container-images#manage-image-sources" >}}).
+{{</note>}}
+
+### Download the operator bundle
+
+Pull the latest version of the operator bundle:
+
+```sh
+VERSION=`curl --silent https://api.github.com/repos/RedisLabs/redis-enterprise-k8s-docs/releases/latest | grep tag_name | awk -F'"' '{print $4}'`
+```
+
+  If you need a different release, replace `VERSION` with a specific release tag.
+
+  Check version tags listed with the [operator releases on GitHub](https://github.com/RedisLabs/redis-enterprise-k8s-docs/releases) or by [using the GitHub API](https://docs.github.com/en/rest/reference/repos#releases) to ensure the version of the bundle is correct.
+
+### Deploy the operator bundle
+
+Apply the operator bundle in your REC namespace:
+
+```sh
+kubectl apply -f https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/$VERSION/bundle.yaml
+```
+
+  You should see a result similar to this:
+
+  ```sh
+  role.rbac.authorization.k8s.io/redis-enterprise-operator created
+  serviceaccount/redis-enterprise-operator created
+  rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+  customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+  customresourcedefinition.apiextensions.k8s.io/redisenterprisedatabases.app.redislabs.com configured
+  deployment.apps/redis-enterprise-operator created
+  ```
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+#### Verify the operator is running
+
+Check the operator deployment to verify it's running in your namespace:
+
+```sh
+kubectl get deployment redis-enterprise-operator
+```
+
+You should see a result similar to this:
+
+```sh
+NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+redis-enterprise-operator   1/1     1            1           0m36s
+```
+
+## Create a Redis Enterprise cluster (REC)
+
+A Redis Enterprise cluster (REC) is created from a `RedisEnterpriseCluster` custom resource
+that contains cluster specifications.
+
+The following example creates a minimal Redis Enterprise cluster. See the [RedisEnterpriseCluster API reference]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}}) for more information on the various options available.
+
+1. Create a file that defines a Redis Enterprise cluster with three nodes.
+
+    {{<note>}}
+The REC name (`my-rec` in this example) cannot be changed after cluster creation.
+    {{</note>}}
+
+    ```sh
+    cat <<EOF > my-rec.yaml
+    apiVersion: "app.redislabs.com/v1"
+    kind: "RedisEnterpriseCluster"
+    metadata:
+      name: my-rec
+    spec:
+      nodes: 3
+    EOF
+    ```
+
+   This will request a cluster with three Redis Enterprise nodes using the default requests (i.e., 2 CPUs and 4GB of memory per node).
+
+   To test with a larger configuration, use the example below to add node resources to the `spec` section of your test cluster (`my-rec.yaml`).
+
+    ```sh
+    redisEnterpriseNodeResources:
+      limits:
+        cpu: 2000m
+        memory: 16Gi
+      requests:
+        cpu: 2000m
+        memory: 16Gi
+    ```
+
+    {{<note>}}
+Each cluster must have at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+    See the [Redis Enterprise hardware requirements]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}) for more information on sizing Redis Enterprise node resource requests.
+  
+1. Apply your custom resource file in the same namespace as `my-rec.yaml`.
+
+    ```sh
+    kubectl apply -f my-rec.yaml
+    ```
+
+   You should see a result similar to this:
+
+   ```sh
+   redisenterprisecluster.app.redislabs.com/my-rec created
+   ```
+
+1. You can verify the creation of the cluster with:
+
+    ```sh
+    kubectl get rec
+    ```
+
+    You should see a result similar to this:
+
+    ```sh
+    NAME           AGE
+    my-rec   1m
+    ```
+
+    At this point, the operator will go through the process of creating various services and pod deployments.
+
+    You can track the progress by examining the StatefulSet associated with the cluster:
+
+    ```sh
+    kubectl rollout status sts/my-rec
+    ```
+
+    or by looking at the status of all of the resources in your namespace:
+
+    ```sh
+    kubectl get all
+    ```
+
+## Enable the admission controller
+
+The admission controller dynamically validates REDB resources configured by the operator. It is strongly recommended that you use the admission controller on your Redis Enterprise Cluster (REC). The admission controller only needs to be configured once per operator deployment.
+
+As part of the REC creation process, the operator stores the admission controller certificate in a Kubernetes secret called `admission-tls`. You may have to wait a few minutes after creating your REC to see the secret has been created.
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to the relevant namespaces {#webhook}
+
+The operator bundle includes a webhook file. The webhook will intercept requests from all namespaces unless you edit it to target a specific namespace. You can do this by adding the `namespaceSelector` section to the webhook spec to target a label on the namespace.
+
+1. Make sure the namespace has a unique `namespace-name` label.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+       labels:
+        namespace-name: example-ns
+    name: example-ns
+    ```
+
+1. Patch the webhook to add the `namespaceSelector` section.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+        matchLabels:
+          namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    kubectl patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+## Verify the admission controller is working
+
+1. Verify the admission controller is installed correctly by applying an invalid resource. This should force the admission controller to correct it.
+
+    ```sh
+    kubectl apply -f - << EOF
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      evictionPolicy: illegal
+    EOF
+    ```
+
+    You should see your request was denied by the `admission webhook "redisenterprise.admission.redislabs"`.
+
+    ```sh
+    Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+    ```
+
+## Create a Redis Enterprise Database (REDB)
+
+You can create multiple databases within the same namespace as your REC or in other namespaces.
+
+See [manage Redis Enterprise databases for Kubernetes]({{< relref "/operate/kubernetes/7.8.6/re-databases/db-controller.md" >}}) to create a new REDB.
+---
+Title: Redis Enterprise Software deployment for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise is supported on OpenShift Kubernetes cluster deployments
+  via an operator.
+draft: true
+hidden: true
+hideListLinks: false
+weight: 60
+url: '/operate/kubernetes/7.8.6/deployment/openshift/old-index/'
+---
+
+Redis Enterprise is supported on OpenShift Kubernetes cluster deployments via
+an operator. The operator is a software component that runs in your
+deployment namespace and facilitates deploying and managing
+Redis Enterprise clusters.
+
+
+
+{{% comment %}}
+These are the steps required to set up a Redis Enterprise Software
+Cluster with OpenShift.
+
+Prerequisites:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.8/installing/index.html) at version 4.6 or higher, with at least three nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/hardware-requirements.md" >}})
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.8/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Step 1: Login
+
+- Log in to your OpenShift account as a super admin (so you have access to all the default projects).
+- Create a new project, fill in the name and other details for the project, and click **Create**.
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image1.png" >}}
+
+- Click on “admin” (upper right corner) and then “Copy Login.”
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image4.png" >}}
+
+- Paste the *login* command into your shell; it should look something like this:
+
+    ```sh
+    oc login https://your-cluster.acme.com –token=your$login$token
+    ```
+
+- Next, verify that you are using the newly created project. Type:
+
+    ```sh
+    oc project <your project name>
+    ```
+
+This will shift to your project rather than the default project (you can verify the project you’re currently using with the *oc project* command).
+
+## Step 2: Get deployment files
+
+Clone this repository, which contains the deployment files:
+
+```sh
+git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+```
+
+<!--
+{{< note >}}
+For RHEL images, please use the redis-enterprise-cluter_rhel.yaml and operator_rhel.yaml files.
+{{< /note >}}
+-->
+
+Specifically for the custom resource (cr) yaml file, you may also download and edit one of the files in the [example folder.](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/examples)  
+
+## Step 3: Prepare your yaml files
+
+Let’s look at each yaml file to see what requires editing:
+
+- [scc.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/scc.yaml)
+
+    The scc ([Security Context Constraint](https://docs.openshift.com/container-platform/4.8/authentication/managing-security-context-constraints.html)) yaml defines the cluster’s security context constraints, which we will apply to our project later on. We strongly recommend **not** changing anything in this yaml file.
+
+    Apply the file:
+
+    ```sh
+    oc apply -f scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io “redis-enterprise-scc” configured
+    ```
+
+    Now you need to bind the scc to your project by typing:
+
+    ```sh
+    oc adm policy add-scc-to-group redis-enterprise-scc  system:serviceaccounts:your_project_name
+    ```
+
+    (If you do not remember your project name, run “oc project”)
+
+- [openshift.bundle.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift.bundle.yaml) -
+
+    The bundle file includes several declarations:
+
+    1. rbac (Role-Based Access Control) defines who can access which resources. The Operator application requires these definitions to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). These include declaration of rules, role and rolebinding.
+    1. crd declaration, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next
+    1. operator deployment declaration, creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes, as pods. The yaml  contains the latest image tag representing the latest Operator version available.
+
+    This yaml should be applied as-is, without changes. To apply it:
+
+    ```sh
+    kubectl apply -f openshift.bundle.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    role.rbac.authorization.k8s.io/redis-enterprise-operator created
+    serviceaccount/redis-enterprise-operator created
+    rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created
+    customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com configured
+    deployment.apps/redis-enterprise-operator created
+    ```
+
+1. Now, verify that your redis-enterprise-operator deployment is running:
+
+    ```sh
+    kubectl get deployment -l name=redis-enterprise-operator
+    ```
+
+    A typical response will look like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+<!--
+[rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/rbac.yaml)
+
+The rbac (Role-Based Access Control) yaml defines who can access which resources. We need this to allow our Operator application to deploy and manage the entire Redis Enterprise deployment (all cluster resources within a namespace). Therefore, we strongly recommend **not** changing anything in this yaml file. To apply it, type:
+
+```sh
+kubectl apply -f rbac.yaml
+```
+
+You should receive the following response:
+
+`role.rbac.authorization.k8s.io/redis-enterprise-operator created
+serviceaccount/redis-enterprise-operator created
+rolebinding.rbac.authorization.k8s.io/redis-enterprise-operator created`
+-->
+
+ <!--> [sb_rbac.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/openshift/sb_rbac.yaml)
+
+    If you’re deploying a service broker, also apply the sb_rbac.yaml file. The sb_rbac (Service Broker Role-Based Access Control) yaml defines the access permissions of the Redis Enterprise Service Broker.
+
+    We strongly recommend **not** changing anything in this yaml file.
+
+    To apply it, run:
+
+    ```sh
+    kubectl apply -f sb_rbac.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    clusterrole.rbac.authorization.k8s.io/redis-enterprise-operator-sb configured
+    clusterrolebinding.rbac.authorization.k8s.io/redis-enterprise-operator configured
+    ``` -->
+
+<!--
+- [crd.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/crd.yaml)
+
+The next step applies crd.yaml, creating a [CustomResourceDefinition](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/#customresourcedefinitions) for your Redis Enterprise Cluster resource. This provides another API resource to be handled by the k8s API server and managed by the operator we will deploy next. We strongly recommend **not** changing anything in this yaml file.
+
+To apply it, run:
+
+```sh
+kubectl apply -f crd.yaml
+```
+
+You should receive the following response:
+
+`customresourcedefinition.apiextensions.k8s.io/redisenterpriseclusters.app.redislabs.com     configured`
+
+- [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml)
+
+Applying this yaml creates the operator deployment, which is responsible for managing the k8s deployment and lifecycle of a Redis Enterprise Cluster. Among many other responsibilities, it creates a [stateful set](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) that runs the Redis Enterprise nodes (as pods).
+
+Always make sure you have the latest [operator.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/operator.yaml). Alternatively, you can edit the following tag:
+image:redislabs/operator:tag
+
+To apply the operator.yaml, run:
+
+```sh
+kubectl apply -f operator.yaml
+```
+
+You should receive the following response:
+
+`deployment.apps/redis-enterprise-operator created`
+
+Now, run `kubectl get deployment` and verify that your redis-enterprise-operator deployment is running. A Typical response will look like this:
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image2.png" >}}
+
+- [redis-enterprise-cluster.yaml](https://raw.githubusercontent.com/RedisLabs/redis-enterprise-k8s-docs/master/redis-enterprise-cluster.yaml)
+-->
+
+- The [rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml) defines the configuration of the newly created resource: Redis Enterprise Cluster. This yaml could be renamed your_cluster_name.yaml to keep things tidy, but this isn’t a mandatory step.
+
+    This yaml can be edited to the required use case, however, the sample provided can be used for test/dev and quick start purposes. Here are the main fields you may review and edit:
+
+    - name: “your_cluster_name” (e.g. “demo-cluster”)
+    - nodes: number_of_nodes_in_the_cluster (Must be an uneven number of at least 3 or greater—[here’s why](https://redislabs.com/redis-enterprise/technology/highly-available-redis/))
+    - uiServiceType: service_type
+
+        Service type value can be either ClusterIP or LoadBalancer. This is an optional configuration based on [k8s service types](https://kubernetes.io/docs/tutorials/kubernetes-basics/expose/expose-intro/). The default is ClusterIP.
+
+    - storageClassName: “<span style="color: #ff0000;">gp2</span>“
+
+        This specifies the [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/) used for your nodes’ persistent disks. For example, AWS uses “gp2” as a default, GKE uses “standard” and Azure uses "default").
+
+    - redisEnterpriseNodeResources: The [compute resources](https://docs.openshift.com/enterprise/3.2/dev_guide/compute_resources.html#dev-compute-resources) required for each node.
+    - limits – specifies the max resources for a Redis node
+    - requests – specifies the minimum resources for a Redis node
+
+        For example:
+
+        ```sh
+        limits
+        cpu: “4000m”
+        memory: 4Gi
+        requests
+
+        cpu: “4000m”
+        memory: 4Gi
+        ```
+
+        The default (if unspecified) is 4 cores (4000m) and 4GB (4Gi).
+
+        {{< note >}}
+Resource limits should equal requests ([Learn why](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/topics.md#guaranteed-quality-of-service)).
+        {{< /note >}}
+
+    - serviceBrokerSpec –
+    - enabled: \<false/true\>
+
+        This specifies [persistence](https://redislabs.com/redis-features/persistence) for the Service Broker with an “enabled/disabled” flag. The default is “false.”
+
+        persistentSpec:
+        storageClassName: “gp2“
+
+    - redisEnterpriseImageSpec: This configuration controls the Redis Enterprise version used, and where it is fetched from. This is an optional field. The Operator will automatically use the matching RHEL image version for the release.
+
+        [imagePullPolicy](https://docs.openshift.com/enterprise/3.0/architecture/core_concepts/builds_and_image_streams.html#image-pull-policy):
+        IfNotPresent
+        Repository: redislabs/redis
+        versionTag: 5.2.10-22
+
+        The version tag, as it appears on your repository (e.g. on [DockerHub](https://hub.docker.com/r/redislabs/redis/)).
+
+## Step 4: Create your cluster
+
+Once you have your_cluster_name yaml set, you need to apply it to create your Redis Enterprise Cluster:
+
+```sh
+kubectl apply -f your_cluster_name.yaml
+```
+
+Run kubectl get rec and verify that creation was successful (rec is a shortcut for “RedisEnterpriseClusters”).
+
+You should receive a response similar to the following:
+
+```sh
+NAME AGE
+
+Your_cluster_name 17s
+```
+
+Your Cluster will be ready shortly, typically within a few minutes.
+
+To check the cluster status, type the following:
+
+```sh
+kubectl get pod
+```
+
+You should receive a response similar to the following:
+
+|                                    |       |         |          |     |
+| ---------------------------------- | ----- | ------- | -------- | --- |
+| NAME                               | READY | STATUS  | RESTARTS | AGE |
+| your_cluster_name-0              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-1              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-2              | 2/2   | Running | 0        | 1m  |
+| your_cluster_name-controller-x-x | 1/1   | Running | 0        | 1m  |
+| Redis-enterprise-operator-x-x      | 1/1   | Running | 0        | 5m  |
+
+Next, create your databases.
+
+## Step 5: Create a database
+
+In order to create your database, we will log in to the Redis Enterprise UI.
+
+- First, apply port forwarding to your Cluster:
+
+    ```sh
+    kubectl port-forward your_cluster_name-0 8443:8443
+    ```
+
+    {{< note >}}
+- your_cluster_name-0 is one of your cluster pods. You may consider running the port-forward command in the background.
+- The Openshift UI provides tools for creating additional routing options, including external routes. These are covered in [RedHat Openshift documentation](https://docs.openshift.com/container-platform/3.11/dev_guide/routes.html).
+    {{< /note >}}
+
+    Next, create your database.
+
+- Open a browser window and navigate to localhost:8443
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image5.png" >}}
+
+- In order to retrieve your password, navigate to the OpenShift management console, select your project name, go to    Resources-\>Secrets-\>your_cluster_name
+- Retrieve your password by selecting “Reveal Secret.”
+
+    {{< warning >}}
+Do not change the default admin user password in the Redis Enterprise admin console.
+Changing the admin password impacts the proper operation of the K8s deployment.
+    {{< /warning >}}
+
+    {{< image filename="/images/rs/getting-started-kubernetes-openshift-image3.png" >}}
+
+- Follow the interface’s [instructions to create your database]({{< relref "/operate/rs/administering/creating-databases/_index.md" >}}).
+
+{{< note >}}
+In order to conduct the Ping test through Telnet, you can create a new route to the newly created database port in the same way as described above for the UI port. After you create your database, go to the Openshift management console, select your project name and go to Applications-\>Services. You will see two newly created services representing the database along with their IP and port information, similar to the screenshot below.
+{{< /note >}}
+
+{{< image filename="/images/rs/getting-started-kubernetes-openshift-image6.png" >}}
+
+{{% /comment %}}
+---
+Title: Deploy Redis Enterprise with OpenShift OperatorHub
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: OpenShift provides the OperatorHub where you can install the Redis Enterprise
+  operator from the administrator user interface.
+linkTitle: OpenShift OperatorHub
+weight: 70
+url: '/operate/kubernetes/7.8.6/deployment/openshift/openshift-operatorhub/'
+---
+
+You can deploy Redis Enterprise for Kubernetes from the Red Hat OpenShift CLI. You can also use a UI, [OperatorHub](https://docs.openshift.com/container-platform/4.11/operators/index.html) (Red Hat) to install operators and create custom resources.
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}).
+
+## Install the Redis Enterprise operator
+
+{{<warning>}} If using version 6.2.18-41 or earlier, [Install the security context constraint](#install-security-context-constraint) before installing the operator. {{</warning>}}
+
+1. Select **Operators > OperatorHub**.
+
+2. Search for _Redis Enterprise_ in the search dialog and select the **Redis Enterprise Operator provided by Redis** marked as **Certified**.
+
+    By default, the image is pulled from Red Hat's registry.
+
+3. On the **Install Operator** page, specify the namespace for the operator.
+
+    Only one namespace per operator is supported.
+
+4. Update the **channel** with the version you're installing.
+
+    For more information about specific versions, see the [release notes]({{< relref "/operate/kubernetes/release-notes/" >}}).
+
+5. Choose an approval strategy.
+
+    Use **Manual** for production systems to ensure the operator is only upgraded by approval.
+
+6. Select **Install** and approve the install plan.
+
+   You can monitor the subscription status in **Operators > Installed Operators**.
+
+{{<warning>}}DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).{{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+{{<warning>}}
+ Before creating any clusters, install the security context constraint (SCC) for the operator in [scc.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+{{</warning>}}
+
+You only need to install the SCC once, but you must not delete it.
+
+1. Select the project you'll be using or create a new project.
+
+1. Download [`scc.yaml`](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/scc.yaml).
+
+1. Apply the file to install the security context constraint.
+
+  ```sh
+  oc apply -f scc.yaml
+  ```
+
+After the install, the OperatorHub automatically uses the constraint for Redis Enterprise node pods.
+
+{{< note >}}
+If you are using the recommended RedisEnterpriseCluster name of `rec`, the SCC is automatically bound to the RedisEnterpriseCluster after install.
+
+If you choose a different name for the RedisEnterpriseCluster, or override the default service account name, you must manually bind the SCC to the RedisEnterpriseCluster’s service account:
+
+  ```sh
+  oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+  system:serviceaccount:<my-project>:<rec-service-account-name>
+  ```
+
+{{< /note >}}
+
+## Create Redis Enterprise custom resources
+
+The **Installed Operators**->**Operator details** page shows the provided APIs: **RedisEnterpriseCluster** and **RedisEnterpriseDatabase**. You can select **Create instance** to create custom resources using the OperatorHub interface.
+
+Use the YAML view to create a custom resource file or let OperatorHub generate the YAML file for you by specifying your configuration options in the form view.
+
+<note> The REC name cannot be changed after cluster creation.</note>
+
+{{<note>}} In versions 6.4.2-4 and 6.4.2-5, REC creation might fail when using the form view due to an error related to the cluster level LDAP. To avoid this, use the YAML view.
+{{</note>}}
+
+For more information on creating and maintaining Redis Enterprise custom resources, see [Redis Enterprise clusters (REC)]({{< relref "/operate/kubernetes/7.8.6/re-clusters/" >}}) and [Redis Enterprise databases (REDB)]({{< relref "/operate/kubernetes/7.8.6/re-databases/" >}}).
+---
+Title: Deployment with OpenShift CLI for Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Redis Enterprise for Kubernetes and cluster can be installed via CLI
+  tools OpenShift
+linkTitle: OpenShift CLI
+weight: 60
+url: '/operate/kubernetes/7.8.6/deployment/openshift/openshift-cli/'
+---
+Use these steps to set up a Redis Enterprise Software cluster with OpenShift.
+
+## Prerequisites
+
+- [OpenShift cluster](https://docs.openshift.com/container-platform/4.8/installing/index.html) with at least 3 nodes (each meeting the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements" >}}))
+- [OpenShift CLI](https://docs.openshift.com/container-platform/latest/cli_reference/openshift_cli/getting-started-cli.html)
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}).
+
+## Deploy the operator
+
+1. Create a new project.
+
+    ```sh
+    oc new-project <your-project-name> 
+    ```
+
+1. Verify the newly created project. 
+
+    ```sh
+    oc project <your-project-name>
+    ```
+
+1. Get the deployment files.
+
+    ```sh
+    git clone https://github.com/RedisLabs/redis-enterprise-k8s-docs
+    ```
+
+1. Deploy the OpenShift operator bundle.
+
+    If you are using version 6.2.18-41 or earlier, you must [apply the security context constraint](#install-security-context-constraint) before the operator bundle.
+
+    ```sh
+    oc apply -f openshift.bundle.yaml
+    ```
+
+    {{< warning >}}
+Changes to the `openshift.bundle.yaml` file can cause unexpected results.
+    {{< /warning >}}
+
+1. Verify that your `redis-enterprise-operator` deployment is running.
+
+    ```sh
+    oc get deployment
+    ```
+
+    A typical response looks like this:
+
+    ```sh
+    NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
+    redis-enterprise-operator   1/1     1            1           0m36s
+    ```
+
+    {{<warning>}}
+DO NOT modify or delete the StatefulSet created during the deployment process. Doing so could destroy your Redis Enterprise cluster (REC).
+    {{</warning>}}
+
+## Install security context constraint
+
+The Redis Enterprise pods must run in OpenShift with privileges set in a [Security Context Constraint](https://docs.openshift.com/container-platform/4.4/authentication/managing-security-context-constraints.html#security-context-constraints-about_configuring-internal-oauth). This grants the pod various rights, such as the ability to change system limits or run as a particular user.
+
+1. Apply the file `scc.yaml` file.
+
+   {{<warning>}}
+Do not edit this file.
+    {{</warning>}}
+
+    ```sh
+    oc apply -f openshift/scc.yaml
+    ```
+
+    You should receive the following response:
+
+    ```sh
+    securitycontextconstraints.security.openshift.io "redis-enterprise-scc-v2" configured
+    ```
+
+    Releases before 6.4.2-6 use the earlier version of the SCC, named `redis-enterprise-scc`.
+
+1. Provide the operator permissions for the pods.
+
+    ```sh
+    oc adm policy add-scc-to-user redis-enterprise-scc-v2 \
+      system:serviceaccount:<my-project>:<rec>
+    ```
+
+    {{<note>}}
+If you are using version 6.2.18-41 or earlier, add additional permissions for your cluster.
+
+```sh
+oc adm policy add-scc-to-user redis-enterprise-scc \
+system:serviceaccount:<my-project>:redis-enterprise-operator
+```
+{{</note>}}
+
+  You can check the name of your project using the `oc project` command. To replace the project name, use `oc edit project myproject`. Replace `rec` with the name of your Redis Enterprise cluster, if different.
+
+## Create a Redis Enterprise cluster custom resource
+
+1. Apply the `RedisEnterpriseCluster` resource file ([rec_rhel.yaml](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/openshift/rec_rhel.yaml)).
+
+    You can rename the file to `<your_cluster_name>.yaml`, but it is not required. Examples below use `<rec_rhel>.yaml`. [Options for Redis Enterprise clusters]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api" >}}) has more info about the Redis Enterprise cluster (REC) custom resource, or see the [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}}) for a full list of options.
+
+    The REC name cannot be changed after cluster creation.
+
+    {{<note>}}
+Each Redis Enterprise cluster requires at least 3 nodes. Single-node RECs are not supported.
+    {{</note>}}
+
+2. Apply the custom resource file to create your Redis Enterprise cluster.
+
+    ```sh
+    oc apply -f <rec_rhel>.yaml
+    ```
+
+    The operator typically creates the REC within a few minutes.
+
+1. Check the cluster status.
+
+    ```sh
+    oc get pod
+    ```
+
+    You should receive a response similar to the following:
+
+    ```sh
+     NAME                             | READY | STATUS  | RESTARTS | AGE |
+    | -------------------------------- | ----- | ------- | -------- | --- |
+    | rec-name-0              | 2/2   | Running | 0        | 1m  |
+    | rec-name-1              | 2/2   | Running | 0        | 1m  |
+    | rec-name-2              | 2/2   | Running | 0        | 1m  |
+    | rec-name-controller-x-x | 1/1   | Running | 0        | 1m  |
+    | Redis-enterprise-operator-x-x    | 1/1   | Running | 0        | 5m  |
+    ```
+
+## Configure the admission controller
+
+{{< embed-md "k8s-admission-webhook-cert.md"  >}}
+
+### Limit the webhook to relevant namespaces
+
+If not limited, the webhook intercepts requests from all namespaces. If you have several REC objects in your Kubernetes cluster, limit the webhook to the relevant namespaces. If you aren't using multiple namespaces, skip this step.
+
+1. Verify your namespace is labeled and the label is unique to this namespace, as shown in the next example.
+
+    ```sh
+    apiVersion: v1
+    kind: Namespace
+    metadata:
+      labels:
+       namespace-name: staging
+    name: staging
+    ```
+
+1. Patch the webhook spec with the `namespaceSelector` field.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      namespaceSelector:
+       matchLabels:
+         namespace-name: staging
+    EOF
+    ```
+
+1. Apply the patch.
+
+    ```sh
+    oc patch ValidatingWebhookConfiguration \
+      redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+    {{<note>}}
+For releases before 6.4.2-4, use this command instead:
+
+```sh
+oc patch ValidatingWebhookConfiguration \
+  redb-admission --patch "$(cat modified-webhook.yaml)"
+```
+
+The 6.4.2-4 release introduces a new `ValidatingWebhookConfiguration` to replace `redb-admission`. See the [6.4.2-4 release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/" >}}).
+    {{</note>}}
+
+### Verify admission controller installation
+
+Apply an invalid resource as shown below to force the admission controller to reject it. If it applies successfully, the admission controller is not installed correctly.
+
+```sh
+oc apply -f - << EOF
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: redis-enterprise-database
+spec:
+  evictionPolicy: illegal
+EOF
+```
+
+You should see this error from the admission controller webhook `redisenterprise.admission.redislabs`.
+  
+```sh
+Error from server: error when creating "STDIN": admission webhook "redisenterprise.admission.redislabs" denied the request: eviction_policy: u'illegal' is not one of [u'volatile-lru', u'volatile-ttl', u'volatile-random', u'allkeys-lru', u'allkeys-random', u'noeviction', u'volatile-lfu', u'allkeys-lfu']
+```
+
+## Create a Redis Enterprise database custom resource
+
+The operator uses the instructions in the Redis Enterprise database (REDB) custom resources to manage databases on the Redis Enterprise cluster.
+
+1. Create a `RedisEnterpriseDatabase` custom resource.
+
+    This example creates a test database. For production databases, see [create a database]({{< relref "/operate/kubernetes/7.8.6/re-databases/db-controller.md#create-a-database" >}}) and [RedisEnterpriseDatabase API reference]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api" >}}).
+
+    ```sh
+    cat << EOF > /tmp/redis-enterprise-database.yml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: redis-enterprise-database
+    spec:
+      memorySize: 100MB
+    EOF
+    ```
+
+1. Apply the newly created REDB resource.
+
+    ```sh
+    oc apply -f /tmp/redis-enterprise-database.yml
+    ```
+
+## More info
+
+- [Redis Enterprise cluster API]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api">}})
+- [Redis Enterprise database API]({{<relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api">}})
+---
+Title: Deploy Redis Enterprise for Kubernetes with OpenShift
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: A quick introduction to the steps necessary to get a Redis Enterprise
+  cluster installed in your OpenShift Kubernetes cluster
+hideListLinks: true
+linkTitle: OpenShift
+weight: 11
+url: '/operate/kubernetes/7.8.6/deployment/openshift/'
+---
+The deployment of Redis Enterprise clusters is managed with the Redis Enterprise operator that you deploy in the namespace for your project.
+To create a database that your application
+workloads can use:
+
+1. Install the Redis Enterprise operator.
+
+1. Create a Redis Enterprise CRD to describe your desired cluster.
+
+1. The operator reads this cluster description and deploys the various components on your K8s cluster.
+
+1. Once running, use the Redis Enterprise cluster to create a database.
+
+1. The operator automatically exposes the new database as a K8s service.
+
+## For OpenShift via the OperatorHub
+
+To [create a database on an OpenShift 4.x cluster via the OperatorHub]({{< relref "/operate/kubernetes/7.8.6/deployment/openshift/openshift-operatorhub" >}}) you only need to have the [OpenShift 4.x cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+
+## For OpenShift via the CLI
+
+To [create a database on an OpenShift cluster via the CLI]({{< relref "/operate/kubernetes/7.8.6/deployment/openshift/openshift-cli.md" >}}), you need:
+
+1. An [OpenShift cluster installed](https://docs.openshift.com/container-platform/4.3/welcome/index.html) with at least three nodes that each meet the [minimum requirements for a development installation]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements.md" >}}).
+1. The [kubectl package installed](https://kubernetes.io/docs/tasks/tools/install-kubectl/) at version 1.9 or higher
+1. The [OpenShift cli installed](https://docs.openshift.com/container-platform/4.2/cli_reference/openshift_cli/getting-started-cli.html)
+
+## Version compatibility
+
+To see which version of Redis Enterprise for Kubernetes supports your OpenShift version, see [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}).
+---
+Title: Getting Started with Active-Active (CRDB) on OpenShift with Route-Based Ingress
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: null
+draft: true
+hidden: true
+weight: $weight
+url: '/operate/kubernetes/7.8.6/deployment/openshift/old-getting-started-openshift-crdb/'
+---
+In this guide, we'll set up an [Active-Active database]({{< relref "/operate/rs/databases/active-active/_index.md" >}})
+(formerly known as CRDB) deployment with Active-Active replication
+spanning across two Redis Enterprise clusters over OpenShift, using Redis Enterprise Operator
+and OpenShift Route.
+
+## Overview
+
+An Active-Active deployment requires connectivity between different Kubernetes clusters.
+A router is the most common way to allow such external access. A [router]
+(https://docs.openshift.com/container-platform/3.5/architecture/core_concepts/routes.html#architecture-core-concepts-routes)
+is configured to accept requests external to the cluster and proxy them into the
+cluster based on how the route is configured. Routes are limited to HTTP/HTTPS(SNI)/TLS(SNI),
+which covers web applications.
+
+Typically, a Kubernetes cluster administrator configures a [DNS wildcard entry]
+(https://docs.openshift.com/container-platform/3.9/install_config/install/prerequisites.html#prereq-dns)
+that resolves to an OpenShift Container Platform node that is running
+the OpenShift router.
+
+The default router in OpenShift is HAProxy, which is a free, fast, and reliable solution
+offering high availability, load balancing, and proxying for TCP and HTTP-based applications.
+
+The Redis Enterprise Operator uses the routes mechanism to expose 2 inter-cluster services:
+the Redis Enterprise Cluster API service and the DB service that exposes the Active-Active database.
+Both services are used during the creation and management of an Active-Active deployment.
+The routes are configured with TLS passthrough.
+
+{{< note >}}
+Routes should have unique hostnames across a Kubernetes cluster.
+{{< /note >}}
+
+## Steps for creating an Active-Active deployment with Service Broker
+
+Before you create an Active-Active deployment with Service Broker, you must create a cluster
+using the REC custom resource, with a Service Broker deployment as covered in
+[Getting Started with Kubernetes and Openshift]({{< relref "/operate/platforms/openshift/_index.md" >}}), while noting the following:
+
+1. Make sure you use the latest versions of the deployment files available on GitHub.
+1. Deploy nodes with at least 6GB of RAM in order to accommodate the Active-Active database plan's 5GB database size.
+1. Make sure you follow the instructions to deploy the Redis Enterprise Service Broker.
+
+The peerClusters section in the spec is used for creating an Active-Active with the Service Broker.
+
+{{< note >}}
+This is only relevant for OpenShift deployments, which support Service Brokers natively.
+{{< /note >}}
+
+Copy this section of the REC spec and modify it for your environment. To apply it
+to every cluster that will participate in the Active-Active database deployment, edit the cluster yaml file
+and apply it using `kubectl apply -f <cluster.yaml>`:
+
+```yaml
+   activeActive:
+    apiIngressUrl:  api1.cluster1.<openshift.department.organization.com>
+    dbIngressSuffix: -cluster1.<openshift.department.organization.com>
+     method: openShiftRoute
+
+     peerClusters:
+      - apiIngressUrl:  api2.cluster2.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster2.<openshift.department.organization.com>
+        fqdn: <cluster2_name>.<cluster2_namespace>.svc.cluster.local
+      - apiIngressUrl:  api3.cluster3.<openshift.department.organization.com>
+        authSecret: cluster2_secret
+        dbIngressSuffix: -cluster3.<openshift.department.organization.com>
+        fqdn: <cluster3_name>.<cluster3_namespace>.svc.cluster.local
+```
+
+This block is added to the Service Broker config map when the REC spec changes, and
+it triggers a restart of the Service Broker pod to pass the peer clusters configuration
+to the service broker. Once the Service Broker pod restarts, you can select the
+Active-Active database plan from the OS service catalog UI.
+
+The elements of the section are:
+
+- **apiIngressUrl** - The OpenShift hostname that is created using OpenShift route.
+
+- **dbIngressSuffix** - The suffix of the db route name. The resulting host is
+`<db-name><db ingress suffix>`. This is used by the Redis Enterprise Syncer to
+sync data between the databases.
+
+- **fqdn** - The FQDN of the Kubernetes cluster where the pattern is `<cluster_name>.
+<cluster_namespace>.svc.cluster.local`. (Remember that the RS cluster name is set in the REC spec).
+
+- **authSecret** - The Kubernetes secret name that contains the username and password
+to access this cluster.
+
+We need to create a secret to reference from authSecret based on the cluster admin credentials
+that were automatically created when the clusters were created. To do this,
+repeat the following process for each of the clusters involved:
+
+1. Login to the OpenShift cluster where your Redis Enterprise Cluster (REC) resides.
+1. To find the secret that holds the REC credentials, run: `kubectl get secrets`
+	
+	From the secrets listed, you’ll find one that is named after your REC and
+	of type Opaque, like this:
+
+	```sh
+	redis-enterprise-cluster            Opaque                  3       1d
+	```
+
+1. Copy the hashed password and username from the file and create a yaml file
+with that information in the following format:
+
+	```yaml
+	apiVersion: v1
+	kind: Secret
+	metadata:
+		name: crdb1-cred
+	type: Opaque
+	data:
+		password: NWhYRWU2OWQ=
+		username: YWRtaW5AYWNtZS5jb20=
+	```
+
+1. Deploy the newly created secret yaml file in the other clusters:
+
+	```sh
+	$ kubectl create -f crdb1-secret.yaml
+	```
+
+	A typical response looks like:
+
+	```
+	secret/crdb1-cred created
+	```
+
+1. Repeat the process for the other clusters until each cluster has a secret
+with the credentials of the other clusters.
+
+After applying the update cluster deployment file, the Service Broker is redeployed
+to apply the changes to the config map.
+
+Now, proceed to the Openshift web console.
+
+1. From the left menu, select a project that holds one of your configured clusters and
+then select **Add to Project > Browse Catalog**.
+
+	{{< image filename="/images/rs/openshift-crdb-catalog.png" >}}
+
+1. Find the **Redis Enterprise [Project Name:Cluster Name]** tile and double-click it to start the wizard.
+
+	{{< image filename="/images/rs/openshift-crdb-information.png" >}}
+
+1. Click **Next** in the Information step.
+
+	{{< image filename="/images/rs/openshift-crdb-plan.png" >}}
+
+1. Then, to deploy an Active-Active database on the clusters you’ve previously configured,
+select the **geo-distributed-redis** plan radio button and click **Next**.
+
+	{{< image filename="/images/rs/openshift-crdb-configuration.png" >}}
+
+1. Click **Next** on the Configuration step, choose a binding option in the Binding step,
+and click **Create**.
+
+	{{< image filename="/images/rs/openshift-crdb-binding.png" >}}
+
+The Active-Active database connected databases are now created with the specified binding, if you selected a binding.
+
+{{< image filename="/images/rs/openshift-crdb-results.png" >}}
+
+You can view the binding by following the link to the secret.
+
+{{< image filename="/images/rs/openshift-crdb-secret.png" >}}
+
+## Validating Active-Active database deployment
+
+To do a basic validation test of database replication:
+
+1. Connect to one of the cluster pods using the following command:
+
+	```sh
+	oc exec -it <your-cluster1-name>-0 bash
+	```
+
+1. At the prompt, launch the redis CLI:
+
+	```sh
+	$ redis-cli -h <your database1 hostname> -p <your database1 port> -a <your database1 password>
+	```
+
+1. Set some values and verify they have been set:
+
+	```sh
+	> set keymaster Vinz
+	OK
+	> set gatekeeper Zuul
+	OK
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+
+1. Now, exit the CLI and the pod execution environment and login to the synched database
+on the other cluster.
+
+	```sh
+	oc exec -it <your-cluster2-name>-0 bash
+	$redis-cli -h <your database2 hostname> -p <your database2 port> -a <your database2 password>
+	```
+
+1. Retrieve the values you previously set or continue manipulating key:value pairs
+and observe the 2-way synchronization, for example:
+
+	```sh
+	> get keymaster
+	"Vinz"
+	> get gatekeeper
+	"Zuul"
+	```
+---
+Title: Deployment
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section lists the different ways to set up and run Redis Enterprise
+  for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem
+  and in the cloud via our Redis Enterprise operator for Kubernetes.
+hideListLinks: false
+linkTitle: Deployment
+weight: 11
+url: '/operate/kubernetes/7.8.6/deployment/'
+---
+
+This section lists the different ways to set up and run Redis Enterprise for Kubernetes. You can deploy on variety of Kubernetes distributions both on-prem and in the cloud via our Redis Enterprise operator for Kubernetes.
+
+## Compatibility
+
+Before installing, check [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/7.8.6/reference/supported_k8s_distributions" >}}) to see which Redis Enterprise operator version supports your Kubernetes distribution.
+
+
+---
+Title: Manage Redis Enterprise databases for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section describes how the database controller provides the ability
+  to create, manage, and use databases via a database custom resource.
+linkTitle: Manage databases
+weight: 5
+url: '/operate/kubernetes/7.8.6/re-databases/db-controller/'
+---
+## 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.
+
+The database controller in Redis Enterprise for Kubernetes:
+
+- Discovers the custom resource
+- Makes sure the REDB is created in the same namespace as the Redis Enterprise cluster (REC)
+- Maintains consistency between the custom resource and the REDB
+
+The database controller recognizes the new custom resource and validates the specification.
+If valid, the controller combines the values specified in
+the custom resource with default values to create a full specification. It then uses this full specification to create the
+database on the specified Redis Enterprise cluster (REC).
+
+Once the database is created, it is exposed with the same service mechanisms by the service rigger for the Redis Enterprise cluster.
+If the database [custom resource is deleted]({{< relref "/operate/kubernetes/7.8.6/re-clusters/delete-custom-resources" >}}), the database and its services are deleted from the cluster.
+
+### Flexible deployment options
+
+Databases in multiple namespaces can be managed by the same operator. To learn more, see [Manage databases in multiple namespaces]({{<relref "/operate/kubernetes/7.8.6/re-clusters/multi-namespace">}}).
+
+To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/7.8.6/architecture/deployment-options.md" >}}).
+
+## Create a database
+
+Your Redis Enterprise database custom resource must be of the `kind: RedisEnterpriseDatabase` and have values for `name` and `memorySize`. All other values are optional and will be defaults if not specified.
+
+1. Create a file (in this example mydb.yaml) that contains your database custom resource.
+
+    ```YAML
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: mydb
+    spec:
+      memorySize: 1GB
+    ```
+
+    To create a REDB in a different namespace from your REC, you need to specify the cluster with `redisEnterpriseCluster` in the `spec` section of your RedisEnterpriseDatabase custom resource.
+
+     ```YAML
+     redisEnterpriseCluster:
+       name: rec
+     ```
+
+1. Apply the file in the namespace you want your database to be in.
+
+    ```sh
+    kubectl apply -f mydb.yaml
+    ```
+
+1. Check the status of your database.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready to use.
+
+## Modify a database
+
+The custom resource defines the properties of the database.
+To change the database, you can edit your original specification and apply the change or use `kubectl edit`.
+
+To modify the database:
+
+1. Edit the definition:
+
+    ```sh
+    kubectl edit redb mydb
+    ```
+
+1. Change the specification (only properties in `spec` section) and save the changes.  
+    For more details, see [RedisEnterpriseDatabaseSpec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#redisenterprisedatabasespec) or [Options for Redis Enterprise databases]({{< relref "/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api" >}}). 
+
+1. Monitor the status to see when the changes take effect:
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready for use.
+
+## Delete a database
+
+The database exists as long as the custom resource exists.
+If you delete the custom resource, the database controller deletes the database.
+The database controller removes the database and its services from the cluster.
+
+To delete a database, run:
+
+```sh
+kubectl delete redb mydb
+```
+
+## Connect to a database
+
+After the database controller creates a database, the services for accessing the database are created in the same namespace. By default there are two services, one 'ClusterIP' service and one 'headless' service.  
+Connection information for the database is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/) maintained by the database controller. This secret contains:
+
+- The database port (`port`)
+- A comma separated list of service names (`service_names`)
+- The database password for authenticating (`password`)
+
+The name of that secret is stored in the database custom resource.
+
+{{<note>}}
+Use these steps to connect to your database from within your K8s cluster. To access your database from outside the K8s cluster, set up the [Ingress]({{< relref "/operate/kubernetes/7.8.6/networking/ingress.md" >}}) controller or use OpenShift routes.
+{{</note>}}
+
+1. Retrieve the secret name.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.spec.databaseSecretName}"
+    ```
+
+      The database secret name usually takes the form of `redb-<database_name>`, so in our example it will be `redb-mydb`.
+
+1. Retrieve and decode the password.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.password}" | base64 --decode
+    ```
+
+1. Retrieve and decode the port number.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.port}" | base64 --decode
+    ```
+
+1. Retrieve and decode the service_names.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.service_names}" | base64 --decode
+    ```
+
+    You'll need to pick just one service listed here to use for connecting.
+
+1. From a pod within your cluster, use `redis-cli` to connect to your database.
+
+    ```sh
+    redis-cli -h <service_name> -p <port>
+    ```
+
+1. Enter the password you retrieved from the secret.
+
+    ```sh
+    auth <password>
+    ```
+
+    You are now connected to your database!
+---
+Title: Create replica databases on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to create and automate database replicas using the database controller
+linkTitle: Create replica databases
+weight: 42
+url: '/operate/kubernetes/7.8.6/re-databases/replica-redb/'
+---
+
+You can configure a replica of a database by creating an item in
+the [`replicaSources`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#specreplicasources" >}}) 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:
+
+```yaml
+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.
+
+A replica of database CR simply uses the secret in the `replicaSources` section:
+
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+   name: name-of-replica
+spec:
+   redisEnterpriseCluster:
+      name: name-of-cluster
+   replicaSources:
+   - replicaSourceType: SECRET
+     replicaSourceName: my-replica-source
+```
+
+In the above, `name-of-replica` database will be created as a replica of the
+source database as long as the source database exists on the source cluster
+and the secret contains the correct replica source URL for that database.
+
+## Retrieving the replica source URL via kubectl
+
+You will need `kubectl`, `curl`, and `jq` installed for this procedure.
+
+1. Set your metadata:
+
+   ```js
+   CLUSTER_NAME=test
+   SOURCE_DB=db1
+   TARGET_DB=db2
+   TARGET_CLUSTER_NAME=test
+   ```
+
+1. Retrieve the cluster authentication:
+
+   ```js
+   CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+   CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+   ```
+
+1. Forward the port of the REST API service for your source cluster:
+
+   ```sh
+   kubectl port-forward pod/${CLUSTER_NAME}-0 9443
+   ```
+
+1. Request the information from the REST API:
+
+   ```js
+   JQ='.[] | select(.name=="'
+   JQ+="${SOURCE_DB}"
+   JQ+='") | ("redis://admin:" + .authentication_admin_pass + "@"+.name+":"+(.endpoints[0].port|tostring))'
+   URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://localhost:9443/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+   ```
+
+   Note: URI now contains the replica source URI.
+
+1. Construct the secret for the replica:
+
+   ```yaml
+   cat << EOF > secret.yaml
+   apiVersion: v1
+   kind: Secret
+   metadata:
+     name: ${SOURCE_DB}-url
+   stringData:
+     uri: ${URI}
+   EOF
+   kubectl apply -f secret.yaml
+   ```
+
+1. Create the replica database:
+
+   ```yaml
+   cat << EOF > target.yaml
+   apiVersion: app.redislabs.com/v1alpha1
+   kind: RedisEnterpriseDatabase
+   metadata:
+     name: ${TARGET_DB}
+   spec:
+     redisEnterpriseCluster:
+       name: ${TARGET_CLUSTER_NAME}
+     replicaSources:
+     - replicaSourceType: SECRET
+       replicaSourceName: ${SOURCE_DB}-url
+   EOF
+   kubectl apply -f target.yaml
+   ```
+
+## Automating the creation via a job
+
+The following procedure uses a ConfigMap and a Job to construct the replica
+source URL secret from the source database and configure the target database.
+
+There are four parameters:
+
+- `source` - the name of the source database
+- `cluster` - the name of the cluster for the source database
+- `target` - the name of the target database
+- `targetCluster` - the name of the cluster for the target database
+
+These parameters can be set by:
+
+```sh
+kubectl create configmap replica-of-database-parameters \
+--from-literal=source=name-of-source \
+--from-literal=cluster=name-of-cluster \
+--from-literal=target=name-of-target \
+--from-literal=targetCluster=name-of-cluster
+```
+
+where "name-of-..." is replaced with the database source, source cluster,
+database target, and target cluster names.
+
+The Job and ConfigMap below, when submitted, will create the secret and
+replica database:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: replica-of-database
+spec:
+  backoffLimit: 4
+  template:
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      restartPolicy: Never
+      volumes:
+        - name: scripts
+          configMap:
+            name: replica-of-database
+      containers:
+        - name: createdb
+          image: debian:stable-slim
+          env:
+            - name: MY_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+            - name: SCRIPT
+              value: create.sh
+            - name: SOURCE_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: source
+            - name: TARGET_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: target
+            - name: CLUSTER_SERVICE
+              value: .svc.cluster.local
+            - name: CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: cluster
+            - name: CLUSTER_PORT
+              value: "9443"
+            - name: TARGET_CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: targetCluster
+          volumeMounts:
+            - mountPath: /opt/scripts/
+              name: scripts
+          command:
+            - /bin/bash
+            - -c
+            - |
+              apt-get update; apt-get install -y curl jq apt-transport-https gnupg2
+              apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6A030B21BA07F4FB
+              curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
+              echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list
+              apt-get update
+              apt-get install -y kubectl
+              bash /opt/scripts/$SCRIPT
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: replica-of-database
+data:
+  create.sh: |
+    CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+    CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+    CLUSTER_HOST=${CLUSTER_NAME}.${MY_NAMESPACE}${CLUSTER_SERVICE}
+    JQ='.[] | select(.name=="'
+    JQ+="${SOURCE_DB}"
+    JQ+='") | ("redis://admin:" +  .authentication_admin_pass + "@"+.endpoints[0].dns_name+":"+(.endpoints[0].port|tostring))'
+    URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://${CLUSTER_HOST}:${CLUSTER_PORT}/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+    echo "URL: ${URL}"
+    echo ""
+    cat << EOF > /tmp/secret.yaml
+    apiVersion: v1
+    kind: Secret
+    metadata:
+      name: ${SOURCE_DB}-url
+    stringData:
+      uri: ${URI}
+    EOF
+    cat /tmp/secret.yaml
+    cat << EOF > /tmp/target.yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: ${TARGET_DB}
+    spec:
+      redisEnterpriseCluster:
+        name: ${TARGET_CLUSTER_NAME}
+      replicaSources:
+      - replicaSourceType: SECRET
+        replicaSourceName: ${SOURCE_DB}-url
+    EOF
+    echo "---"
+    cat /tmp/target.yaml
+    echo ""
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/secret.yaml
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/target.yaml
+```
+---
+Title: Redis Enterprise databases (REDB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise databases (REDBs).
+hideListLinks: false
+linkTitle: Redis Enterprise databases (REDB)
+weight: 31
+url: '/operate/kubernetes/7.8.6/re-databases/'
+---
+
+This section contains articles to help you manage your Redis Enterprise databases (REDBs).
+
+
+
+---
+title: RedisEnterpriseDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REDB API
+weight: 30
+url: '/operate/kubernetes/7.8.6/reference/redis_enterprise_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseDatabase is the Schema for the redisenterprisedatabases API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettings">alertSettings</a></td>
+        <td>object</td>
+        <td>
+          Settings for database alerts<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with the database. The list of valid modules for the specific cluster can be retrieved from the status of the REC object. Use the "name" and "versions" fields for the specific module configuration. If specifying an explicit version for a module, automatic modules versions upgrade must be disabled by setting the '.upgradeSpec.upgradeModulesToLatest' field in the REC to 'false'. Note that the option to specify module versions is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB. It must be at least 10% of combined memory size (RAM and Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>enum</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+          <br/>
+            <i>Enum</i>: dense, sparse<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database (redis or memcached). Defaults to "redis".<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Settings for database alerts
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specalertsettingsbdb_backup_delayed">bdb_backup_delayed</a></td>
+        <td>object</td>
+        <td>
+          Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_high_syncer_lag">bdb_crdt_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_connection_error">bdb_crdt_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_general_error">bdb_crdt_src_syncer_general_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_latency">bdb_high_latency</a></td>
+        <td>object</td>
+        <td>
+          Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_throughput">bdb_high_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_long_running_action">bdb_long_running_action</a></td>
+        <td>object</td>
+        <td>
+          An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_low_throughput">bdb_low_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_dataset_overhead">bdb_ram_dataset_overhead</a></td>
+        <td>object</td>
+        <td>
+          Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_values">bdb_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_high_syncer_lag">bdb_replica_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_syncer_connection_error">bdb_replica_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_shard_num_ram_values">bdb_shard_num_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_size">bdb_size</a></td>
+        <td>object</td>
+        <td>
+          Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_backup_delayed
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_general_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_latency
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_long_running_action
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_low_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_dataset_overhead
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_shard_num_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_size
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.abs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.ftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.gcs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.mount
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.sftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.swift
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.modulesList[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise module (see https://redis.io/docs/latest/develop/reference/modules/)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the module, e.g. "search" or "ReJSON". The complete list of modules available in the cluster can be retrieved from the '.status.modules' field in the REC.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          The semantic version of the module, e.g. '1.6.12'. Optional for REDB, must be set for REAADB. Note that this field is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.replicaSources[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.rolesPermissions[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          DEPRECATED Upgrades the modules to the latest version that supports the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Notes - All modules must be without specifying the version. in addition, This field is currently not supported for Active-Active databases. The default is true<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusbackupinfo">backupInfo</a></td>
+        <td>object</td>
+        <td>
+          Information on the database's periodic backup<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createdTime</td>
+        <td>string</td>
+        <td>
+          Time when the database was created<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseUID</td>
+        <td>string</td>
+        <td>
+          Database UID provided by redis enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusinternalendpoints">internalEndpoints</a></td>
+        <td>[]object</td>
+        <td>
+          Endpoints listed internally by the Redis Enterprise Cluster. Can be used to correlate a ReplicaSourceStatus entry.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionStatus</td>
+        <td>string</td>
+        <td>
+          Status of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionUid</td>
+        <td>string</td>
+        <td>
+          UID of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdated</td>
+        <td>string</td>
+        <td>
+          Time when the database was last updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The generation (built in update counter of K8s) of the REDB resource that was fully acted upon, meaning that all changes were handled and sent as an API call to the Redis Enterprise Cluster (REC). This field value should equal the current generation when the resource changes were handled. Note: the lastActionStatus field tracks actions handled asynchronously by the Redis Enterprise Cluster.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusreplicasourcestatuses">replicaSourceStatuses</a></td>
+        <td>[]object</td>
+        <td>
+          ReplicaSource statuses<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardStatuses</td>
+        <td>map[string]integer</td>
+        <td>
+          Aggregated statuses of shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Database compatibility version<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.activeActive
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status.backupInfo
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Information on the database's periodic backup
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>backupFailureReason</td>
+        <td>string</td>
+        <td>
+          Reason of last failed backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupHistory</td>
+        <td>integer</td>
+        <td>
+          Backup history retention policy (number of days, 0 is forever)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupInterval</td>
+        <td>integer</td>
+        <td>
+          Interval in seconds in which automatic backup will be initiated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupIntervalOffset</td>
+        <td>integer</td>
+        <td>
+          Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupProgressPercentage</td>
+        <td>integer</td>
+        <td>
+          Database scheduled periodic backup progress (percentage)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupStatus</td>
+        <td>string</td>
+        <td>
+          Status of scheduled periodic backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastBackupTime</td>
+        <td>string</td>
+        <td>
+          Time of last successful backup<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.internalEndpoints[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Hostname assigned to the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Database port name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.replicaSourceStatuses[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpointHost</td>
+        <td>string</td>
+        <td>
+          The internal host name of the replica source database. Can be used as an identifier. See the internalEndpoints list on the REDB status.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lag</td>
+        <td>integer</td>
+        <td>
+          Lag in millisec between source and destination (while synced).<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastError</td>
+        <td>string</td>
+        <td>
+          Last error encountered when syncing from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdate</td>
+        <td>string</td>
+        <td>
+          Time when we last receive an update from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbSize</td>
+        <td>integer</td>
+        <td>
+          The source’s RDB size to be transferred during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbTransferred</td>
+        <td>integer</td>
+        <td>
+          Number of bytes transferred from the source’s RDB during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          Sync status of this source<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Supported Kubernetes distributions
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support matrix for the current Redis Enterprise K8s operator
+linkTitle: Supported distributions
+weight: 30
+url: '/operate/kubernetes/7.8.6/reference/supported_k8s_distributions/'
+---
+
+Each release of Redis Enterprise for Kubernetes is thoroughly tested against a set of Kubernetes distributions. The table below lists Redis Enterprise for Kubernetes versions and the Kubernetes distributions they support.
+
+{{<note>}}Each platform is tested with its default configuration, including storage, network, security, and container runtime components.”{{</note>}}
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+## Community Kubernetes
+
+For details on this platform, see the Kubernetes [documentation](https://kubernetes.io/docs/home/supported-doc-versions/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>**<nobr>6.2.10-4</nobr>**5</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Community K8s** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.16 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## OpenShift Container Platform
+
+For details on this platform, see the [OpenShift documentation](https://docs.openshift.com/container-platform/4.13/welcome/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **OpenShift** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.18 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.17 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.16 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.15 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.14 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.13 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.12 | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 4.11 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 4.10 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 4.9 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 4.8 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.7 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.6 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.5 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 3.11 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## Amazon Elastic Kubernetes Service (EKS)
+
+For details on this platform, see the [EKS documentation](https://docs.aws.amazon.com/eks/?icmpid=docs_homepage_containers).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Amazon EKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Azure Kubernetes Service (AKS)
+
+For details on this platform, see the [AKS documentation](https://learn.microsoft.com/en-us/azure/aks/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Azure AKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Google Kubernetes Engine (GKE)
+
+For details on this platform, see the [GKE documentation](https://cloud.google.com/kubernetes-engine/docs).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Google GKE** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Rancher
+
+For details on this platform, see the [Rancher documentation](https://ranchermanager.docs.rancher.com/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Rancher 2.8** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.7** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.6** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **Rancher 2.5** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher 2.4** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid (TKG)
+
+For details on this platform, see the [TKG documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 |
+| **VMWare TKG 2.4** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| **VMware TKG 2.3** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| **VMware TKG 2.2** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.24 |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| **VMware TKG 2.1** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 1.6** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.22 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid Integrated Edition (TKGI)
+
+For details on this platform, see the [TKGI documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid-Integrated-Edition/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **VMware TKGI** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.20 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.19 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.17 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.16 |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.15 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.14 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.13 |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.12 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.11 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| 1.10 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.09 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.08 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.07 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+
+---
+title: RedisEnterpriseCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REC API
+weight: 30
+url: '/operate/kubernetes/7.8.6/reference/redis_enterprise_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1](#appredislabscomv1)
+
+
+
+
+# app.redislabs.com/v1
+
+
+
+
+RedisEnterpriseCluster is the Schema for the redisenterpriseclusters API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>antiAffinityAdditionalTopologyKeys</td>
+        <td>[]string</td>
+        <td>
+          Additional antiAffinity terms in order to support installation on different zones/vcenters<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Cluster-wide backup configurations<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperimagespec">bootstrapperImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Bootstrapper container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperresources">bootstrapperResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for bootstrapper containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccertificates">certificates</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretName</td>
+        <td>string</td>
+        <td>
+          Secret Name/Path to use for Cluster Credentials. To be used only if ClusterCredentialSecretType is vault. If left blank, will use cluster name.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretRole</td>
+        <td>string</td>
+        <td>
+          Used only if ClusterCredentialSecretType is vault, to define vault role to be used.  If blank, defaults to "redis-enterprise-operator"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretType</td>
+        <td>enum</td>
+        <td>
+          Type of Secret to use for ClusterCredential, Vault, Kuberetes,... If left blank, will default ot kubernetes secrets<br/>
+          <br/>
+            <i>Enum</i>: vault, kubernetes<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterRecovery</td>
+        <td>boolean</td>
+        <td>
+          ClusterRecovery initiates cluster recovery when set to true. Note that this field is cleared automatically after the cluster is recovered<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccontainertimezone">containerTimezone</a></td>
+        <td>object</td>
+        <td>
+          Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createServiceAccount</td>
+        <td>boolean</td>
+        <td>
+          Whether to create service account<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) cluster wide policy. An optional boolean setting. Specifies if INE should be on/off for new created REDBs. May be overridden for specific REDB via similar setting, please view the similar setting for REDB for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>encryptPkeys</td>
+        <td>boolean</td>
+        <td>
+          Private key encryption Possible values: true/false<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enforceIPv4</td>
+        <td>boolean</td>
+        <td>
+          Sets ENFORCE_IPV4 environment variable<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          ADVANCED USAGE: use carefully. Add environment variables to RS StatefulSet's containers.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>extraLabels</td>
+        <td>map[string]string</td>
+        <td>
+          Labels that the user defines for their convenience<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#spechostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          Adds hostAliases entries to the Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specingressorroutespec">ingressOrRouteSpec</a></td>
+        <td>object</td>
+        <td>
+          Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldap">ldap</a></td>
+        <td>object</td>
+        <td>
+          Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>license</td>
+        <td>string</td>
+        <td>
+          Redis Enterprise License<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseSecretName</td>
+        <td>string</td>
+        <td>
+          K8s secret or Vault Secret Name/Path to use for Cluster License. When left blank, the license is read from the "license" field. Note that you can't specify non-empty values in both "license" and "licenseSecretName", only one of these fields can be used to pass the license string. The license needs to be stored under the key "license".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          Selector for nodes that could fit Redis Enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodes</td>
+        <td>integer</td>
+        <td>
+          Number of Redis Enterprise nodes (pods)<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specocspconfiguration">ocspConfiguration</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpersistentspec">persistentSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise Cluster persistence<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger and redis enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodstartingpolicy">podStartingPolicy</a></td>
+        <td>object</td>
+        <td>
+          Mitigation setting for STS pods stuck in "ContainerCreating"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodtolerations">podTolerations</a></td>
+        <td>[]object</td>
+        <td>
+          Tolerations that are added to all managed pods. More information: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          Adds the priority class to pods managed by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpullsecrets">pullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          PullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAwarenessNodeLabel</td>
+        <td>string</td>
+        <td>
+          Node label that specifies rack ID - if specified, will create rack aware cluster. Rack awareness requires node label must exist on all nodes. Additionally, operator needs a special cluster role with permission to list nodes.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributes">redisEnterpriseAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>enum</td>
+        <td>
+          Reserved, future use, only for use if instructed by Redis. IPFamily dictates what IP family to choose for pods' internal and external communication.<br/>
+          <br/>
+            <i>Enum</i>: IPv4, IPv6<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseimagespec">redisEnterpriseImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisenoderesources">redisEnterpriseNodeResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Redis Enterprise containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterprisePodAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for redis enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfiguration">redisEnterpriseServicesConfiguration</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster optional services settings<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerimagespec">redisEnterpriseServicesRiggerImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Services Rigger container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerresources">redisEnterpriseServicesRiggerResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Services Rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseTerminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          The TerminationGracePeriodSeconds value for the (STS created) REC pods<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisevolumemounts">redisEnterpriseVolumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          additional volume mounts within the redis enterprise containers. More info: https://kubernetes.io/docs/concepts/storage/volumes/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisonflashspec">redisOnFlashSpec</a></td>
+        <td>object</td>
+        <td>
+          Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisUpgradePolicy</td>
+        <td>enum</td>
+        <td>
+          Redis upgrade policy to be set on the Redis Enterprise Cluster. Possible values: major/latest This value is used by the cluster to choose the Redis version of the database when an upgrade is performed. The Redis Enterprise Cluster includes multiple versions of OSS Redis that can be used for databases.<br/>
+          <br/>
+            <i>Enum</i>: major, latest<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3Default</td>
+        <td>boolean</td>
+        <td>
+          Whether databases will turn on RESP3 compatibility upon database upgrade. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          the security configuration that will be applied to RS pods.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          Name of the service account to use<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservices">services</a></td>
+        <td>object</td>
+        <td>
+          Customization options for operator-managed service resources created for Redis Enterprise clusters and databases<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspec">servicesRiggerSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for service rigger<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspec">sideContainersSpec</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specslaveha">slaveHA</a></td>
+        <td>object</td>
+        <td>
+          Slave high availability mechanism configuration.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Annotations for Redis Enterprise UI service. This annotations will override the overlapping global annotations set under spec.services.servicesAnnotations The specified annotations will not override annotations that already exist and didn't originate from the operator, except for the 'redis.io/last-keys' annotation which is reserved.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiServiceType</td>
+        <td>enum</td>
+        <td>
+          Type of service used to expose Redis Enterprise UI (https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types)<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer, ExternalName<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for upgrades of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>username</td>
+        <td>string</td>
+        <td>
+          Username for the admin user of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>vaultCASecret</td>
+        <td>string</td>
+        <td>
+          K8s secret name containing Vault's CA cert - defaults to "vault-ca-cert"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          additional volumes<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiIngressUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbIngressSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host. ingress <db name><db ingress suffix> Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Used for ingress controllers such as ha-proxy or nginx in GKE<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-wide backup configurations
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          Configurations for backups to s3 and s3-compatible storage<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+Configurations for backups to s3 and s3-compatible storage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name that holds the S3 CA certificate, which contains the TLS certificate mapped to the key in the secret 'cert'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          Specifies the URL for S3 export and import<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Bootstrapper container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for bootstrapper containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbootstrapperresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources.claims[]
+<sup><sup>[↩ Parent](#specbootstrapperresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.certificates
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's API certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cmCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's CM (Cluster Manager) certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ldapClientCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's LDAP client certificate. If left blank, LDAP client certificate authentication will be disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>metricsExporterCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Metrics Exporter certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Proxy certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>syncerCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Syncer certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.containerTimezone
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>propagateHost</td>
+        <td>object</td>
+        <td>
+          Identifies that container timezone should be in sync with the host, this option mounts a hostPath volume onto RS pods that could be restricted in some systems.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timezoneName</td>
+        <td>string</td>
+        <td>
+          POSIX-style timezone name as a string to be passed as EnvVar to RE pods, e.g. "Europe/London".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specextraenvvars)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.hostAliases[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          Hostnames for the above IP address.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          IP address of the host file entry.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ingressOrRouteSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host ingress <db name><db fqdn suffix>. Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation.<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress, istio<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Additional annotations to set on ingress resources created by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationquery">authenticationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationquery">authorizationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>enum</td>
+        <td>
+          Specifies the LDAP protocol to use. One of: LDAP, LDAPS, STARTTLS.<br/>
+          <br/>
+            <i>Enum</i>: LDAP, LDAPS, STARTTLS<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapservers">servers</a></td>
+        <td>[]object</td>
+        <td>
+          One or more LDAP servers. If multiple servers are specified, they must all share an identical organization tree structure.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bindCredentialsSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding the credentials used to communicate with the LDAP server for authentication queries. The secret must have a key named 'dn' with the Distinguished Name of the user to execute the query, and 'password' with its password. If left blank, credentials-based authentication is disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding a PEM-encoded CA certificate for validating the TLS connection to the LDAP server. The secret must have a key named 'cert' with the certificate data. This field is applicable only when the protocol is LDAPS or STARTTLS.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cacheTTLSeconds</td>
+        <td>integer</td>
+        <td>
+          The maximum TTL of cached entries.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>directoryTimeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          The connection timeout to the LDAP server when authenticating a user, in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForControlPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for control plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForDataPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for data plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>template</td>
+        <td>string</td>
+        <td>
+          Configuration for a template query. Mutually exclusive with the 'query' field. The substring '%u' will be replaced with the username, e.g., 'cn=%u,ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery.query
+<sup><sup>[↩ Parent](#specldapauthenticationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>attribute</td>
+        <td>string</td>
+        <td>
+          Configuration for an attribute query. Mutually exclusive with the 'query' field. Holds the name of an attribute of the LDAP user entity that contains a list of the groups that the user belongs to, e.g., 'memberOf'.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery.query
+<sup><sup>[↩ Parent](#specldapauthorizationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.servers[]
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Address of an LDAP server.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Host name of the LDAP server<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Port number of the LDAP server. If unspecified, defaults to 389 for LDAP and STARTTLS protocols, and 636 for LDAPS protocol.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ocspConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ocspFunctionality</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable/disable OCSP mechanism for the cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>queryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate when the current staple is invalid. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryMaxTries</td>
+        <td>integer</td>
+        <td>
+          Determines the maximum number for the OCSP recovery attempts. After max number of tries passed, the control plane will revert back to the regular frequency. Minimum value is 1. Maximum value is 100.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responseTimeout</td>
+        <td>integer</td>
+        <td>
+          Determines the time interval (in seconds) for which the request waits for a response from the OCSP responder. Minimum value is 1. Maximum value is 60.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.persistentSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise Cluster persistence
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enablePersistentVolumeResize</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable PersistentVolumes resize. Disabled by default. Read the instruction in pvc_expansion readme carefully before using this feature.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to add persistent volume to Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          Storage class for persistent volume in Redis Enterprise pods. Leave empty to use the default. If using the default this way, make sure the Kubernetes Cluster has a default Storage Class configured. This can be done by running a `kubectl get storageclass` and see if one of the Storage Classes' names contains a `(default)` mark.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeSize</td>
+        <td>int or string</td>
+        <td>
+          To enable resizing after creating the cluster - please follow the instructions in the pvc_expansion readme<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podStartingPolicy
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Mitigation setting for STS pods stuck in "ContainerCreating"
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to detect and attempt to mitigate pod startup issues<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>startingThresholdSeconds</td>
+        <td>integer</td>
+        <td>
+          Time in seconds to wait for a pod to be stuck while starting up before action is taken. If set to 0, will be treated as if disabled.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podTolerations[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.pullSecrets[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Secret name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Redis Enterprise containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterprisenoderesourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterprisenoderesources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster optional services settings
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcmserver">cmServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbcoordinator">crdbCoordinator</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbworker">crdbWorker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationmdnsserver">mdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationpdnsserver">pdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationsaslauthd">saslauthd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationstatsarchiver">statsArchiver</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.cmServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the CM server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbCoordinator
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb coordinator process<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbWorker
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb worker processes<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.mdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the Multicast DNS server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.pdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the pdns server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.saslauthd
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the saslauthd service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.statsArchiver
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the stats archiver service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Services Rigger container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Services Rigger pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesriggerresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseservicesriggerresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseVolumeMounts[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisOnFlashSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bigStoreDriver</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb, speedb<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashDiskSize</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashStorageEngine</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+the security configuration that will be applied to RS pods.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsecuritycontextreadonlyrootfilesystempolicy">readOnlyRootFilesystemPolicy</a></td>
+        <td>object</td>
+        <td>
+          Whether RS containers has a read-only root filesystem and what is the policy. some mandatory paths are still writable so RS can work properly.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext.readOnlyRootFilesystemPolicy
+<sup><sup>[↩ Parent](#specsecuritycontext)</sup></sup>
+
+Whether RS containers has a read-only root filesystem and what is the policy. some mandatory paths are still writable so RS can work properly.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether RS containers has a read-only root filesystem. Default is false.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Customization options for operator-managed service resources created for Redis Enterprise clusters and databases
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesapiservice">apiService</a></td>
+        <td>object</td>
+        <td>
+          Customization options for the REC API service.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>servicesAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Global additional annotations to set on service resources created by the operator. The specified annotations will not override annotations that already exist and didn't originate from the operator.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services.apiService
+<sup><sup>[↩ Parent](#specservices)</sup></sup>
+
+Customization options for the REC API service.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          Type of service to create for the REC API service. Defaults to ClusterIP service, if not specified otherwise.<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for service rigger
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>databaseServicePortPolicy</td>
+        <td>enum</td>
+        <td>
+          databaseServicePortPolicy instructs how to determine the service ports for REDB services. Defaults to DatabasePortForward, if not specified otherwise. DatabasePortForward - The service port will be the same as the database port. RedisDefaultPort - The service port will be the default Redis port (6379).<br/>
+          <br/>
+            <i>Enum</i>: DatabasePortForward, RedisDefaultPort<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseServiceType</td>
+        <td>string</td>
+        <td>
+          Service types for access to databases. should be a comma separated list. The possible values are cluster_ip, headless and load_balancer.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceNaming</td>
+        <td>enum</td>
+        <td>
+          Used to determine how to name the services created automatically when a database is created. When bdb_name is used, the database name will be also used for the service name. When redis-port is used, the service will be named redis-<port>.<br/>
+          <br/>
+            <i>Enum</i>: bdb_name, redis-port<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributes">servicesRiggerAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[]
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+EnvVar represents an environment variable present in a Container. More info: https://kubernetes.io/docs/tasks/inject-data-application/environment-variable-expose-pod-information/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the environment variable.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          Source for the environment variable's value. Cannot be used if value is not empty.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvars)</sup></sup>
+
+Source for the environment variable's value. Cannot be used if value is not empty.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a ConfigMap.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a field of the pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a resource of the container: only resources limits and requests are currently supported.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a secret in the pod's namespace<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a ConfigMap.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key to select.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the ConfigMap or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a field of the pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          Path of the field to select in the specified API version.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          Version of the schema the FieldPath is written in terms of, defaults to "v1".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a resource of the container: only resources limits and requests are currently supported.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          Required: resource to select<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          Container name: required for volumes, optional for env vars<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          Specifies the output format of the exposed resources, defaults to "1"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a secret in the pod's namespace
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key of the secret to select from.  Must be a valid secret key.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the Secret or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom
+<sup><sup>[↩ Parent](#specsidecontainersspecenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].ports[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources.claims[]
+<sup><sup>[↩ Parent](#specsidecontainersspecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeDevices[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeMounts[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.slaveHA
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Slave high availability mechanism configuration.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>slaveHAGracePeriod</td>
+        <td>integer</td>
+        <td>
+          Time in seconds between when a node fails, and when slave high availability mechanism starts relocating shards. If set to 0, will not affect cluster configuration.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for upgrades of Redis Enterprise
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>autoUpgradeRedisEnterprise</td>
+        <td>boolean</td>
+        <td>
+          Whether to upgrade Redis Enterprise automatically when operator is upgraded<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Volume represents a named volume in a pod that may be accessed by any container in the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureFile
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].fc
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flocker
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].hostPath
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].nfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].quobyte
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusbundleddatabaseversions">bundledDatabaseVersions</a></td>
+        <td>[]object</td>
+        <td>
+          Versions of open source databases bundled by Redis Enterprise Software - please note that in order to use a specific version it should be supported by the ‘upgradePolicy’ - ‘major’ or ‘latest’ according to the desired version (major/minor)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuscertificatesstatus">certificatesStatus</a></td>
+        <td>object</td>
+        <td>
+          Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ingressOrRouteMethodStatus</td>
+        <td>string</td>
+        <td>
+          The ingressOrRouteSpec/ActiveActive spec method that exist<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuslicensestatus">licenseStatus</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmanagedapis">managedAPIs</a></td>
+        <td>object</td>
+        <td>
+          Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmodules">modules</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusocspstatus">ocspStatus</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP status<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuspersistencestatus">persistenceStatus</a></td>
+        <td>object</td>
+        <td>
+          The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>state</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.bundledDatabaseVersions[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>dbType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>major</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.certificatesStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>generation</td>
+        <td>integer</td>
+        <td>
+          Generation stores the version of the cluster's Proxy and Syncer certificate secrets. In Active-Active databases, when a user updates the proxy or syncer certificate, a crdb-update command needs to be triggered to avoid potential sync issues. This helps the REAADB controller detect a change in a certificate and trigger a crdb-update. The version of the cluster's Proxy certificate secret.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>updateStatus</td>
+        <td>string</td>
+        <td>
+          The status of the cluster's certificates update<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.licenseStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>features</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashShards</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashShardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseState</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>owner</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ramShards</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ramShardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsUsage</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.managedAPIs
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ldap</td>
+        <td>boolean</td>
+        <td>
+          Indicate whether cluster LDAP configuration is managed by the operator. When this is enabled, the operator will reconcile the cluster LDAP configuration according to the '.spec.ldap' field in the RedisEnterpriseCluster resource.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.modules[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>displayName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versions</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.ocspStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+An API object that represents the cluster's OCSP status
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>certStatus</td>
+        <td>string</td>
+        <td>
+          Indicates the proxy certificate status - GOOD/REVOKED/UNKNOWN.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nextUpdate</td>
+        <td>string</td>
+        <td>
+          The time at or before which newer information will be available about the status of the certificate (if available)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>producedAt</td>
+        <td>string</td>
+        <td>
+          The time at which the OCSP responder signed this response.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responderUrl</td>
+        <td>string</td>
+        <td>
+          The OCSP responder url from which this status came from.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revocationTime</td>
+        <td>string</td>
+        <td>
+          The time at which the certificate was revoked or placed on hold.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>thisUpdate</td>
+        <td>string</td>
+        <td>
+          The most recent time at which the status being indicated is known by the responder to have been correct.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.persistenceStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The current status of the PVCs<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>succeeded</td>
+        <td>string</td>
+        <td>
+          The number of PVCs that are provisioned with the expected size<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseActiveActiveDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REAADB API
+weight: 30
+url: '/operate/kubernetes/7.8.6/reference/redis_enterprise_active_active_database_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseActiveActiveDatabase is the Schema for the redisenterpriseactiveactivedatabase API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseActiveActiveDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters specifications and configurations.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurations">globalConfigurations</a></td>
+        <td>object</td>
+        <td>
+          The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.participatingClusters[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR to link.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>externalReplicationPort</td>
+        <td>integer</td>
+        <td>
+          The desired replication endpoint's port number for users who utilize LoadBalancers for sync between AA replicas and need to provide the specific port number that the LoadBalancer listens to.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?  If disabled, the DatabaseSecret will not be created or updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with the database. The list of valid modules for the specific cluster can be retrieved from the status of the REC object. Use the "name" and "versions" fields for the specific module configuration. If specifying an explicit version for a module, automatic modules versions upgrade must be disabled by setting the '.upgradeSpec.upgradeModulesToLatest' field in the REC to 'false'. Note that the option to specify module versions is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'. Note - Specifying Redis version is currently not supported for Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB It must be at least 10% of combined memory size (RAM+Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>string</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database.<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.activeActive
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+### spec.globalConfigurations.backup
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.abs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.ftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the "ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]" format<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.gcs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.mount
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.s3
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.sftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.swift
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.modulesList[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise module (see https://redis.io/docs/latest/develop/reference/modules/)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the module, e.g. "search" or "ReJSON". The complete list of modules available in the cluster can be retrieved from the '.status.modules' field in the REC.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          The semantic version of the module, e.g. '1.6.12'. Optional for REDB, must be set for REAADB. Note that this field is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.replicaSources[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.rolesPermissions[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType (note: use exact name of the ACL from the Redis Enterprise ACL list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType (note: use exact name of the role from the Redis Enterprise role list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.upgradeSpec
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          Upgrades the modules to the latest version that supports the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Note - This field is currently not supported for Active-Active databases.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>clusterCertificatesGeneration</td>
+        <td>integer</td>
+        <td>
+          Versions of the cluster's Proxy and Syncer certificates. In Active-Active databases, these are used to detect updates to the certificates, and trigger synchronization across the participating clusters. .<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>guid</td>
+        <td>string</td>
+        <td>
+          The active-active database corresponding GUID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastTaskUid</td>
+        <td>string</td>
+        <td>
+          The last active-active database task UID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>linkedRedbs</td>
+        <td>[]string</td>
+        <td>
+          The linked REDBs.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters statuses.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The overall replication status<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statussecretsstatus">secretsStatus</a></td>
+        <td>[]object</td>
+        <td>
+          The status of the secrets<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the active active database.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.participatingClusters[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR that is linked.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>id</td>
+        <td>integer</td>
+        <td>
+          The corresponding ID of the instance in the active-active database.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The replication status of the participating cluster<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.secretsStatus[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of secrets.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the secret.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>status</td>
+        <td>enum</td>
+        <td>
+          The status of the secret.<br/>
+          <br/>
+            <i>Enum</i>: Valid, Invalid<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseRemoteCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: RERC API
+weight: 30
+url: '/operate/kubernetes/7.8.6/reference/redis_enterprise_remote_cluster_api/'
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEntepriseRemoteCluster represents a remote participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseRemoteCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          The URL of the cluster, will be used for the active-active database URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recName</td>
+        <td>string</td>
+        <td>
+          The name of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recNamespace</td>
+        <td>string</td>
+        <td>
+          The namespace of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiPort</td>
+        <td>integer</td>
+        <td>
+          The port number of the cluster's URL used for connectivity/sync<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          The database URL suffix, will be used for the active-active database replication endpoint and replication endpoint SNI.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret containing cluster credentials. Must be of the following format: "redis-enterprise-<RERC name>"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>internalObservedSecretResourceVersion</td>
+        <td>string</td>
+        <td>
+          The observed secret resource version. Used for internal purposes only.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>local</td>
+        <td>boolean</td>
+        <td>
+          Indicates whether this object represents a local or a remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The most recent generation observed for this RERC. It corresponds to the RERC's generation, which is updated by the API Server.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Reference material for the operator, cluster, and database deployment
+  options.
+hideListLinks: false
+linkTitle: Reference
+weight: 89
+url: '/operate/kubernetes/7.8.6/reference/'
+---
+
+This section contains the API reference for Redis custom resources and supported distributions.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise operator allows you to use Redis Enterprise for
+  Kubernetes.
+hideListLinks: false
+linkTitle: 7.8.6
+weight: 50
+bannerText: This documentation applies to version 7.8.6. For documentation on the latest version, see [redis.io/docs/latest/operate/kubernetes/](https://redis.io/docs/latest/operate/kubernetes/).
+bannerChildren: true
+url: '/operate/kubernetes/7.8.6/'
+---
+
+Kubernetes provides enterprise orchestration of containers and has been widely adopted. Redis Enterprise for Kubernetes provides a simple way to get a Redis Enterprise cluster on Kubernetes and enables more complex deployment scenarios.
+
+---
+Title: Manage Redis Enterprise databases for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: This section describes how the database controller provides the ability
+  to create, manage, and use databases via a database custom resource.
+linkTitle: Manage databases
+weight: 5
+---
+## 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.
+
+The database controller in Redis Enterprise for Kubernetes:
+
+- Discovers the custom resource
+- Makes sure the REDB is created in the same namespace as the Redis Enterprise cluster (REC)
+- Maintains consistency between the custom resource and the REDB
+
+The database controller recognizes the new custom resource and validates the specification.
+If valid, the controller combines the values specified in
+the custom resource with default values to create a full specification. It then uses this full specification to create the
+database on the specified Redis Enterprise cluster (REC).
+
+Once the database is created, it is exposed with the same service mechanisms by the service rigger for the Redis Enterprise cluster.
+If the database [custom resource is deleted]({{< relref "/operate/kubernetes/re-clusters/delete-custom-resources" >}}), the database and its services are deleted from the cluster.
+
+### Flexible deployment options
+
+Databases in multiple namespaces can be managed by the same operator. To learn more, see [Manage databases in multiple namespaces]({{<relref "/operate/kubernetes/re-clusters/multi-namespace">}}).
+
+To learn more about designing a multi-namespace Redis Enterprise cluster, see [flexible deployment options]({{< relref "/operate/kubernetes/architecture/deployment-options" >}}).
+
+## Create a database
+
+Your Redis Enterprise database custom resource must be of the `kind: RedisEnterpriseDatabase` and have values for `name` and `memorySize`. All other values are optional and will be defaults if not specified.
+
+1. Create a file (in this example mydb.yaml) that contains your database custom resource.
+
+    ```YAML
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: mydb
+    spec:
+      memorySize: 1GB
+    ```
+
+    To create a REDB in a different namespace from your REC, you need to specify the cluster with `redisEnterpriseCluster` in the `spec` section of your RedisEnterpriseDatabase custom resource.
+
+     ```YAML
+     redisEnterpriseCluster:
+       name: rec
+     ```
+
+1. Apply the file in the namespace you want your database to be in.
+
+    ```sh
+    kubectl apply -f mydb.yaml
+    ```
+
+1. Check the status of your database.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready to use.
+
+## Modify a database
+
+The custom resource defines the properties of the database.
+To change the database, you can edit your original specification and apply the change or use `kubectl edit`.
+
+To modify the database:
+
+1. Edit the definition:
+
+    ```sh
+    kubectl edit redb mydb
+    ```
+
+1. Change the specification (only properties in `spec` section) and save the changes.  
+    For more details, see [RedisEnterpriseDatabaseSpec](https://github.com/RedisLabs/redis-enterprise-k8s-docs/blob/master/redis_enterprise_database_api.md#redisenterprisedatabasespec) or [Options for Redis Enterprise databases]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api" >}}). 
+
+1. Monitor the status to see when the changes take effect:
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.status.status}"
+    ```
+
+    When the status is `active`, the database is ready for use.
+
+## Delete a database
+
+The database exists as long as the custom resource exists.
+If you delete the custom resource, the database controller deletes the database.
+The database controller removes the database and its services from the cluster.
+
+To delete a database, run:
+
+```sh
+kubectl delete redb mydb
+```
+
+## Connect to a database
+
+After the database controller creates a database, the services for accessing the database are created in the same namespace. By default there are two services, one 'ClusterIP' service and one 'headless' service.  
+Connection information for the database is stored in a Kubernetes [secret](https://kubernetes.io/docs/concepts/configuration/secret/) maintained by the database controller. This secret contains:
+
+- The database port (`port`)
+- A comma separated list of service names (`service_names`)
+- The database password for authenticating (`password`)
+
+The name of that secret is stored in the database custom resource.
+
+{{<note>}}
+Use these steps to connect to your database from within your K8s cluster. To access your database from outside the K8s cluster, set up the [Ingress]({{< relref "/operate/kubernetes/networking/ingress" >}}) controller or use OpenShift routes.
+{{</note>}}
+
+1. Retrieve the secret name.
+
+    ```sh
+    kubectl get redb mydb -o jsonpath="{.spec.databaseSecretName}"
+    ```
+
+      The database secret name usually takes the form of `redb-<database_name>`, so in our example it will be `redb-mydb`.
+
+1. Retrieve and decode the password.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.password}" | base64 --decode
+    ```
+
+1. Retrieve and decode the port number.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.port}" | base64 --decode
+    ```
+
+1. Retrieve and decode the service_names.
+
+    ```sh
+    kubectl get secret redb-mydb -o jsonpath="{.data.service_names}" | base64 --decode
+    ```
+
+    You'll need to pick just one service listed here to use for connecting.
+
+1. From a pod within your cluster, use `redis-cli` to connect to your database.
+
+    ```sh
+    redis-cli -h <service_name> -p <port>
+    ```
+
+1. Enter the password you retrieved from the secret.
+
+    ```sh
+    auth <password>
+    ```
+
+    You are now connected to your database!
+---
+Title: Create replica databases on Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: How to create and automate database replicas using the database controller
+linkTitle: Create replica databases
+weight: 42
+---
+
+You can configure a replica of a database by creating an item in
+the [`replicaSources`]({{< relref "/operate/kubernetes/reference/redis_enterprise_database_api#specreplicasources" >}}) 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:
+
+```yaml
+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.
+
+A replica of database CR simply uses the secret in the `replicaSources` section:
+
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+   name: name-of-replica
+spec:
+   redisEnterpriseCluster:
+      name: name-of-cluster
+   replicaSources:
+   - replicaSourceType: SECRET
+     replicaSourceName: my-replica-source
+```
+
+In the above, `name-of-replica` database will be created as a replica of the
+source database as long as the source database exists on the source cluster
+and the secret contains the correct replica source URL for that database.
+
+## Retrieving the replica source URL via kubectl
+
+You will need `kubectl`, `curl`, and `jq` installed for this procedure.
+
+1. Set your metadata:
+
+   ```js
+   CLUSTER_NAME=test
+   SOURCE_DB=db1
+   TARGET_DB=db2
+   TARGET_CLUSTER_NAME=test
+   ```
+
+1. Retrieve the cluster authentication:
+
+   ```js
+   CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+   CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+   ```
+
+1. Forward the port of the REST API service for your source cluster:
+
+   ```sh
+   kubectl port-forward pod/${CLUSTER_NAME}-0 9443
+   ```
+
+1. Request the information from the REST API:
+
+   ```js
+   JQ='.[] | select(.name=="'
+   JQ+="${SOURCE_DB}"
+   JQ+='") | ("redis://admin:" + .authentication_admin_pass + "@"+.name+":"+(.endpoints[0].port|tostring))'
+   URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://localhost:9443/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+   ```
+
+   Note: URI now contains the replica source URI.
+
+1. Construct the secret for the replica:
+
+   ```yaml
+   cat << EOF > secret.yaml
+   apiVersion: v1
+   kind: Secret
+   metadata:
+     name: ${SOURCE_DB}-url
+   stringData:
+     uri: ${URI}
+   EOF
+   kubectl apply -f secret.yaml
+   ```
+
+1. Create the replica database:
+
+   ```yaml
+   cat << EOF > target.yaml
+   apiVersion: app.redislabs.com/v1alpha1
+   kind: RedisEnterpriseDatabase
+   metadata:
+     name: ${TARGET_DB}
+   spec:
+     redisEnterpriseCluster:
+       name: ${TARGET_CLUSTER_NAME}
+     replicaSources:
+     - replicaSourceType: SECRET
+       replicaSourceName: ${SOURCE_DB}-url
+   EOF
+   kubectl apply -f target.yaml
+   ```
+
+## Automating the creation via a job
+
+The following procedure uses a ConfigMap and a Job to construct the replica
+source URL secret from the source database and configure the target database.
+
+There are four parameters:
+
+- `source` - the name of the source database
+- `cluster` - the name of the cluster for the source database
+- `target` - the name of the target database
+- `targetCluster` - the name of the cluster for the target database
+
+These parameters can be set by:
+
+```sh
+kubectl create configmap replica-of-database-parameters \
+--from-literal=source=name-of-source \
+--from-literal=cluster=name-of-cluster \
+--from-literal=target=name-of-target \
+--from-literal=targetCluster=name-of-cluster
+```
+
+where "name-of-..." is replaced with the database source, source cluster,
+database target, and target cluster names.
+
+The Job and ConfigMap below, when submitted, will create the secret and
+replica database:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: replica-of-database
+spec:
+  backoffLimit: 4
+  template:
+    spec:
+      serviceAccountName: redis-enterprise-operator
+      restartPolicy: Never
+      volumes:
+        - name: scripts
+          configMap:
+            name: replica-of-database
+      containers:
+        - name: createdb
+          image: debian:stable-slim
+          env:
+            - name: MY_NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+            - name: SCRIPT
+              value: create.sh
+            - name: SOURCE_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: source
+            - name: TARGET_DB
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: target
+            - name: CLUSTER_SERVICE
+              value: .svc.cluster.local
+            - name: CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: cluster
+            - name: CLUSTER_PORT
+              value: "9443"
+            - name: TARGET_CLUSTER_NAME
+              valueFrom:
+                configMapKeyRef:
+                  name: replica-of-database-parameters
+                  key: targetCluster
+          volumeMounts:
+            - mountPath: /opt/scripts/
+              name: scripts
+          command:
+            - /bin/bash
+            - -c
+            - |
+              apt-get update; apt-get install -y curl jq apt-transport-https gnupg2
+              apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 6A030B21BA07F4FB
+              curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
+              echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | tee -a /etc/apt/sources.list.d/kubernetes.list
+              apt-get update
+              apt-get install -y kubectl
+              bash /opt/scripts/$SCRIPT
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: replica-of-database
+data:
+  create.sh: |
+    CLUSTER_USER=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.username | base64 -d`
+    CLUSTER_PASSWORD=`kubectl get secret/${CLUSTER_NAME} -o json | jq -r .data.password | base64 -d`
+    CLUSTER_HOST=${CLUSTER_NAME}.${MY_NAMESPACE}${CLUSTER_SERVICE}
+    JQ='.[] | select(.name=="'
+    JQ+="${SOURCE_DB}"
+    JQ+='") | ("redis://admin:" +  .authentication_admin_pass + "@"+.endpoints[0].dns_name+":"+(.endpoints[0].port|tostring))'
+    URI=`curl -sf -k -u "$CLUSTER_USER:$CLUSTER_PASSWORD" "https://${CLUSTER_HOST}:${CLUSTER_PORT}/v1/bdbs?fields=uid,name,endpoints,authentication_admin_pass" | jq "$JQ" | sed 's/"//g'`
+    echo "URL: ${URL}"
+    echo ""
+    cat << EOF > /tmp/secret.yaml
+    apiVersion: v1
+    kind: Secret
+    metadata:
+      name: ${SOURCE_DB}-url
+    stringData:
+      uri: ${URI}
+    EOF
+    cat /tmp/secret.yaml
+    cat << EOF > /tmp/target.yaml
+    apiVersion: app.redislabs.com/v1alpha1
+    kind: RedisEnterpriseDatabase
+    metadata:
+      name: ${TARGET_DB}
+    spec:
+      redisEnterpriseCluster:
+        name: ${TARGET_CLUSTER_NAME}
+      replicaSources:
+      - replicaSourceType: SECRET
+        replicaSourceName: ${SOURCE_DB}-url
+    EOF
+    echo "---"
+    cat /tmp/target.yaml
+    echo ""
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/secret.yaml
+    kubectl -n ${MY_NAMESPACE} apply -f /tmp/target.yaml
+```
+---
+Title: Redis Enterprise databases (REDB)
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Articles to help you manage your Redis Enterprise databases (REDBs).
+hideListLinks: false
+linkTitle: Redis Enterprise databases (REDB)
+weight: 31
+---
+
+This section contains articles to help you manage your Redis Enterprise databases (REDBs).
+
+
+
+---
+title: RedisEnterpriseDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REDB API
+weight: 30
+aliases: [ /operate/kubernetes/reference/db-options, ]
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseDatabase is the Schema for the redisenterprisedatabases API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseSpec defines the desired state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettings">alertSettings</a></td>
+        <td>object</td>
+        <td>
+          Settings for database alerts<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with the database. The list of valid modules for the specific cluster can be retrieved from the status of the REC object. Use the "name" and "versions" fields for the specific module configuration. If specifying an explicit version for a module, automatic modules versions upgrade must be disabled by setting the '.upgradeSpec.upgradeModulesToLatest' field in the REC to 'false'. Note that the option to specify module versions is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB. It must be at least 10% of combined memory size (RAM and Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>enum</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+          <br/>
+            <i>Enum</i>: dense, sparse<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database (redis or memcached). Defaults to "redis".<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Settings for database alerts
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specalertsettingsbdb_backup_delayed">bdb_backup_delayed</a></td>
+        <td>object</td>
+        <td>
+          Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_high_syncer_lag">bdb_crdt_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_connection_error">bdb_crdt_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_crdt_src_syncer_general_error">bdb_crdt_src_syncer_general_error</a></td>
+        <td>object</td>
+        <td>
+          Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_latency">bdb_high_latency</a></td>
+        <td>object</td>
+        <td>
+          Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_high_throughput">bdb_high_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_long_running_action">bdb_long_running_action</a></td>
+        <td>object</td>
+        <td>
+          An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_low_throughput">bdb_low_throughput</a></td>
+        <td>object</td>
+        <td>
+          Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_dataset_overhead">bdb_ram_dataset_overhead</a></td>
+        <td>object</td>
+        <td>
+          Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_ram_values">bdb_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_high_syncer_lag">bdb_replica_src_high_syncer_lag</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_replica_src_syncer_connection_error">bdb_replica_src_syncer_connection_error</a></td>
+        <td>object</td>
+        <td>
+          Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_shard_num_ram_values">bdb_shard_num_ram_values</a></td>
+        <td>object</td>
+        <td>
+          Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specalertsettingsbdb_size">bdb_size</a></td>
+        <td>object</td>
+        <td>
+          Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_backup_delayed
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Periodic backup has been delayed for longer than specified threshold value [minutes]. -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_crdt_src_syncer_general_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Active-active source - sync encountered in general error -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_latency
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Latency is higher than specified threshold value [micro-sec] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_high_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is higher than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_long_running_action
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+An alert for state-machines that are running for too long -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_low_throughput
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Throughput is lower than specified threshold value [requests / sec.] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_dataset_overhead
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset RAM overhead of a shard has reached the threshold value [% of its RAM limit] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Percent of values kept in a shard's RAM is lower than [% of its key count] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_high_syncer_lag
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync lag is higher than specified threshold value [seconds] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_replica_src_syncer_connection_error
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Replica-of source - sync has connection error while trying to connect replica source -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_shard_num_ram_values
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Number of values kept in a shard's RAM is lower than [values] -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.alertSettings.bdb_size
+<sup><sup>[↩ Parent](#specalertsettings)</sup></sup>
+
+Dataset size has reached the threshold value [% of the memory limit] expected fields: -Note threshold is commented (allow string/int/float and support backwards compatibility) but is required
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Alert enabled or disabled<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.abs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.ftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.gcs
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.mount
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.sftp
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.swift
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the K8s secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.modulesList[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise module (see https://redis.io/docs/latest/develop/reference/modules/)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the module, e.g. "search" or "ReJSON". The complete list of modules available in the cluster can be retrieved from the '.status.modules' field in the REC.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          The semantic version of the module, e.g. '1.6.12'. Optional for REDB, must be set for REAADB. Note that this field is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.replicaSources[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.rolesPermissions[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          DEPRECATED Upgrades the modules to the latest version that supports the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Notes - All modules must be without specifying the version. in addition, This field is currently not supported for Active-Active databases. The default is true<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseDatabaseStatus defines the observed state of RedisEnterpriseDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusbackupinfo">backupInfo</a></td>
+        <td>object</td>
+        <td>
+          Information on the database's periodic backup<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createdTime</td>
+        <td>string</td>
+        <td>
+          Time when the database was created<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseUID</td>
+        <td>string</td>
+        <td>
+          Database UID provided by redis enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusinternalendpoints">internalEndpoints</a></td>
+        <td>[]object</td>
+        <td>
+          Endpoints listed internally by the Redis Enterprise Cluster. Can be used to correlate a ReplicaSourceStatus entry.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionStatus</td>
+        <td>string</td>
+        <td>
+          Status of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastActionUid</td>
+        <td>string</td>
+        <td>
+          UID of the last action done by operator on this database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdated</td>
+        <td>string</td>
+        <td>
+          Time when the database was last updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The generation (built in update counter of K8s) of the REDB resource that was fully acted upon, meaning that all changes were handled and sent as an API call to the Redis Enterprise Cluster (REC). This field value should equal the current generation when the resource changes were handled. Note: the lastActionStatus field tracks actions handled asynchronously by the Redis Enterprise Cluster.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusreplicasourcestatuses">replicaSourceStatuses</a></td>
+        <td>[]object</td>
+        <td>
+          ReplicaSource statuses<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardStatuses</td>
+        <td>map[string]integer</td>
+        <td>
+          Aggregated statuses of shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          Database compatibility version<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.activeActive
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status.backupInfo
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Information on the database's periodic backup
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>backupFailureReason</td>
+        <td>string</td>
+        <td>
+          Reason of last failed backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupHistory</td>
+        <td>integer</td>
+        <td>
+          Backup history retention policy (number of days, 0 is forever)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupInterval</td>
+        <td>integer</td>
+        <td>
+          Interval in seconds in which automatic backup will be initiated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupIntervalOffset</td>
+        <td>integer</td>
+        <td>
+          Offset (in seconds) from round backup interval when automatic backup will be initiated (should be less than backup_interval)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupProgressPercentage</td>
+        <td>integer</td>
+        <td>
+          Database scheduled periodic backup progress (percentage)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>backupStatus</td>
+        <td>string</td>
+        <td>
+          Status of scheduled periodic backup process<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastBackupTime</td>
+        <td>string</td>
+        <td>
+          Time of last successful backup<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.internalEndpoints[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Hostname assigned to the database<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Database port name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.replicaSourceStatuses[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpointHost</td>
+        <td>string</td>
+        <td>
+          The internal host name of the replica source database. Can be used as an identifier. See the internalEndpoints list on the REDB status.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lag</td>
+        <td>integer</td>
+        <td>
+          Lag in millisec between source and destination (while synced).<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastError</td>
+        <td>string</td>
+        <td>
+          Last error encountered when syncing from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastUpdate</td>
+        <td>string</td>
+        <td>
+          Time when we last receive an update from the source.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbSize</td>
+        <td>integer</td>
+        <td>
+          The source’s RDB size to be transferred during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rdbTransferred</td>
+        <td>integer</td>
+        <td>
+          Number of bytes transferred from the source’s RDB during the syncing phase.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          Sync status of this source<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Supported Kubernetes distributions
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Support matrix for the current Redis Enterprise K8s operator
+linkTitle: Supported distributions
+weight: 30
+---
+
+Each release of Redis Enterprise for Kubernetes is thoroughly tested 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.{{</note>}}
+
+<span title="Check mark icon">&#x2705;</span> Supported – This distribution is supported for this version of Redis Enterprise Software for Kubernetes.
+
+<span title="Deprecation warning" class="font-serif">:warning:</span> Deprecated – This distribution is still supported for this version of Redis Enterprise Software for Kubernetes, but support will be removed in a future release.
+
+<span title="X icon">&#x274c;</span> End of life – Support for this distribution ended.
+
+Any distribution not listed below is not supported for production workloads.
+
+{{<note>}}Each platform is tested with its default configuration, including storage, network, security, and container runtime components.{{</note>}}
+
+## Community Kubernetes
+
+For details on this platform, see the Kubernetes [documentation](https://kubernetes.io/docs/home/supported-doc-versions/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>**<nobr>6.2.10-4</nobr>**5</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Community K8s** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.16 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## OpenShift Container Platform
+
+For details on this platform, see the [OpenShift documentation](https://docs.openshift.com/container-platform/4.13/welcome/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **OpenShift** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.18 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.17 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.16 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.15 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.14 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.13 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 4.12 |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 4.11 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 4.10 |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 4.9 |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 4.8 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.7 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.6 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 4.5 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 3.11 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+## Amazon Elastic Kubernetes Service (EKS)
+
+For details on this platform, see the [EKS documentation](https://docs.aws.amazon.com/eks/?icmpid=docs_homepage_containers).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Amazon EKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Azure Kubernetes Service (AKS)
+
+For details on this platform, see the [AKS documentation](https://learn.microsoft.com/en-us/azure/aks/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Azure AKS** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Google Kubernetes Engine (GKE)
+
+For details on this platform, see the [GKE documentation](https://cloud.google.com/kubernetes-engine/docs).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Google GKE** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.32 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.31 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 |  |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## Rancher
+
+For details on this platform, see the [Rancher documentation](https://ranchermanager.docs.rancher.com/).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-6</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **Rancher 2.8** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.30 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.29 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.28 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.7** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |
+| **Rancher 2.6** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.21 |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **Rancher 2.5** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.20 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.19 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| **Rancher 2.4** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+| 1.17 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid (TKG)
+
+For details on this platform, see the [TKG documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 |
+| **VMWare TKG 2.4** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.27 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.26 | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  |  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| **VMware TKG 2.3** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.26 |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| **VMware TKG 2.2** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.25 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.24 |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| **VMware TKG 2.1** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.22 |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| **VMware TKG 1.6** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.24 |  |  |  |  |  |  |  |  |  | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |  |  |  |  |  |
+| 1.23 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.22 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+{{</table-scrollable>}}
+
+## VMware Tanzu Kubernetes Grid Integrated Edition (TKGI)
+
+For details on this platform, see the [TKGI documentation](https://docs.vmware.com/en/VMware-Tanzu-Kubernetes-Grid-Integrated-Edition/index.html).
+
+{{<table-scrollable>}}
+| Redis operator | **<nobr>7.22.0-7</nobr>** | **<nobr>7.8.6-1</nobr>** | **<nobr>7.8.4-9</nobr>** | **<nobr>7.8.4-8</nobr>** | **<nobr>7.8.2-6</nobr>** | **<nobr>7.4.6-2</nobr>** | **<nobr>7.4.2-12</nobr>** | **<nobr>7.4.2-2</nobr>** | **<nobr>7.2.4-12</nobr>** | **<nobr>7.2.4-7</nobr>** | **<nobr>7.2.4-2</nobr>** | **<nobr>6.4.2-8</nobr>** | **<nobr>6.4.2-6</nobr>** | **<nobr>6.4.2-5</nobr>** | **<nobr>6.4.2-4</nobr>** | **<nobr>6.2.18-41</nobr>** | **<nobr>6.2.18-3</nobr>** | **<nobr>6.2.12-1</nobr>** | **<nobr>6.2.10-45</nobr>** | **<nobr>6.2.10-34</nobr>** | **<nobr>6.2.10-4</nobr>** | **<nobr>6.2.8-15</nobr>** | **<nobr>6.2.8-11</nobr>** | **<nobr>6.2.8-2</nobr>** | **<nobr>6.2.4-1</nobr>** |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|  | April 2025 | March 2025 | March 2025 | Feb 2025 | Nov 2024 | July 2024 | May 2024 | March 2024 | Dec 2023 | Oct 2023 | Aug 2023 | July 2023 | June 2023 | April 2023 | March 2023 | Jan 2023 | Nov 2022 | Sept 2022 | July 2022 | May 2022 | March 2022 | Jan 2022 | Jan 2022 | Nov 2021 | Sept 2021 |
+| **VMware TKGI** |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.21 | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.20 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.19 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.18 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.17 | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.16 |  |  | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.15 |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |  |
+| 1.14 |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |  |
+| 1.13 |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |  |
+| 1.12 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |  |
+| 1.11 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  |  |  |  |
+| 1.10 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 1.09 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+| 1.08 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+| 1.07 |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  | <span title="X icon">&#x274c;</span> | <span title="Deprecation warning" class="font-serif">:warning:</span> |
+
+{{</table-scrollable>}}
+
+
+---
+title: RedisEnterpriseCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REC API
+weight: 30
+aliases: [ /operate/kubernetes/reference/cluster-options, ]
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1](#appredislabscomv1)
+
+
+
+
+# app.redislabs.com/v1
+
+
+
+
+RedisEnterpriseCluster is the Schema for the redisenterpriseclusters API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseClusterSpec defines the desired state of RedisEnterpriseCluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>antiAffinityAdditionalTopologyKeys</td>
+        <td>[]string</td>
+        <td>
+          Additional antiAffinity terms in order to support installation on different zones/vcenters<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Cluster-wide backup configurations<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperimagespec">bootstrapperImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Bootstrapper container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specbootstrapperresources">bootstrapperResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for bootstrapper containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccertificates">certificates</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretName</td>
+        <td>string</td>
+        <td>
+          Secret Name/Path to use for Cluster Credentials. To be used only if ClusterCredentialSecretType is vault. If left blank, will use cluster name.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretRole</td>
+        <td>string</td>
+        <td>
+          Used only if ClusterCredentialSecretType is vault, to define vault role to be used.  If blank, defaults to "redis-enterprise-operator"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterCredentialSecretType</td>
+        <td>enum</td>
+        <td>
+          Type of Secret to use for ClusterCredential, Vault, Kuberetes,... If left blank, will default ot kubernetes secrets<br/>
+          <br/>
+            <i>Enum</i>: vault, kubernetes<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clusterRecovery</td>
+        <td>boolean</td>
+        <td>
+          ClusterRecovery initiates cluster recovery when set to true. Note that this field is cleared automatically after the cluster is recovered<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#speccontainertimezone">containerTimezone</a></td>
+        <td>object</td>
+        <td>
+          Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>createServiceAccount</td>
+        <td>boolean</td>
+        <td>
+          Whether to create service account<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) cluster wide policy. An optional boolean setting. Specifies if INE should be on/off for new created REDBs. May be overridden for specific REDB via similar setting, please view the similar setting for REDB for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>encryptPkeys</td>
+        <td>boolean</td>
+        <td>
+          Private key encryption Possible values: true/false<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enforceIPv4</td>
+        <td>boolean</td>
+        <td>
+          Sets ENFORCE_IPV4 environment variable<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          ADVANCED USAGE: use carefully. Add environment variables to RS StatefulSet's containers.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>extraLabels</td>
+        <td>map[string]string</td>
+        <td>
+          Labels that the user defines for their convenience<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#spechostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          Adds hostAliases entries to the Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specingressorroutespec">ingressOrRouteSpec</a></td>
+        <td>object</td>
+        <td>
+          Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldap">ldap</a></td>
+        <td>object</td>
+        <td>
+          Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>license</td>
+        <td>string</td>
+        <td>
+          Redis Enterprise License<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseSecretName</td>
+        <td>string</td>
+        <td>
+          K8s secret or Vault Secret Name/Path to use for Cluster License. When left blank, the license is read from the "license" field. Note that you can't specify non-empty values in both "license" and "licenseSecretName", only one of these fields can be used to pass the license string. The license needs to be stored under the key "license".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          Selector for nodes that could fit Redis Enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodes</td>
+        <td>integer</td>
+        <td>
+          Number of Redis Enterprise nodes (pods)<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specocspconfiguration">ocspConfiguration</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpersistentspec">persistentSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise Cluster persistence<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger and redis enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodstartingpolicy">podStartingPolicy</a></td>
+        <td>object</td>
+        <td>
+          Mitigation setting for STS pods stuck in "ContainerCreating"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodtolerations">podTolerations</a></td>
+        <td>[]object</td>
+        <td>
+          Tolerations that are added to all managed pods. More information: https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          Adds the priority class to pods managed by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpullsecrets">pullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          PullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAwarenessNodeLabel</td>
+        <td>string</td>
+        <td>
+          Node label that specifies rack ID - if specified, will create rack aware cluster. Rack awareness requires node label must exist on all nodes. Additionally, operator needs a special cluster role with permission to list nodes.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributes">redisEnterpriseAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>enum</td>
+        <td>
+          Reserved, future use, only for use if instructed by Redis. IPFamily dictates what IP family to choose for pods' internal and external communication.<br/>
+          <br/>
+            <i>Enum</i>: IPv4, IPv6<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseimagespec">redisEnterpriseImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Redis Enterprise container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisenoderesources">redisEnterpriseNodeResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Redis Enterprise containers<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterprisePodAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for redis enterprise pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfiguration">redisEnterpriseServicesConfiguration</a></td>
+        <td>object</td>
+        <td>
+          RS Cluster optional services settings<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerimagespec">redisEnterpriseServicesRiggerImageSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for Services Rigger container image<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesriggerresources">redisEnterpriseServicesRiggerResources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Services Rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseTerminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          The TerminationGracePeriodSeconds value for the (STS created) REC pods<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisevolumemounts">redisEnterpriseVolumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          additional volume mounts within the redis enterprise containers. More info: https://kubernetes.io/docs/concepts/storage/volumes/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisonflashspec">redisOnFlashSpec</a></td>
+        <td>object</td>
+        <td>
+          Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisUpgradePolicy</td>
+        <td>enum</td>
+        <td>
+          Redis upgrade policy to be set on the Redis Enterprise Cluster. Possible values: major/latest This value is used by the cluster to choose the Redis version of the database when an upgrade is performed. The Redis Enterprise Cluster includes multiple versions of OSS Redis that can be used for databases.<br/>
+          <br/>
+            <i>Enum</i>: major, latest<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3Default</td>
+        <td>boolean</td>
+        <td>
+          Whether databases will turn on RESP3 compatibility upon database upgrade. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          The security configuration that will be applied to RS pods.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          Name of the service account to use<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservices">services</a></td>
+        <td>object</td>
+        <td>
+          Customization options for operator-managed service resources created for Redis Enterprise clusters and databases<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspec">servicesRiggerSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for service rigger<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspec">sideContainersSpec</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specslaveha">slaveHA</a></td>
+        <td>object</td>
+        <td>
+          Slave high availability mechanism configuration.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Annotations for Redis Enterprise UI service. This annotations will override the overlapping global annotations set under spec.services.servicesAnnotations The specified annotations will not override annotations that already exist and didn't originate from the operator, except for the 'redis.io/last-keys' annotation which is reserved.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>uiServiceType</td>
+        <td>enum</td>
+        <td>
+          Type of service used to expose Redis Enterprise UI (https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types)<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer, ExternalName<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specification for upgrades of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specusagemeter">usageMeter</a></td>
+        <td>object</td>
+        <td>
+          The configuration of the usage meter.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>username</td>
+        <td>string</td>
+        <td>
+          Username for the admin user of Redis Enterprise<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>vaultCASecret</td>
+        <td>string</td>
+        <td>
+          K8s secret name containing Vault's CA cert - defaults to "vault-ca-cert"<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          additional volumes<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.activeActive
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for ActiveActive setup. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiIngressUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbIngressSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host. ingress <db name><db ingress suffix> Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Used for ingress controllers such as ha-proxy or nginx in GKE<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-wide backup configurations
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          Configurations for backups to s3 and s3-compatible storage<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.backup.s3
+<sup><sup>[↩ Parent](#specbackup)</sup></sup>
+
+Configurations for backups to s3 and s3-compatible storage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name that holds the S3 CA certificate, which contains the TLS certificate mapped to the key in the secret 'cert'<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          Specifies the URL for S3 export and import<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Bootstrapper container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for bootstrapper containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specbootstrapperresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.bootstrapperResources.claims[]
+<sup><sup>[↩ Parent](#specbootstrapperresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.certificates
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster Certificates. Used to modify the certificates used by the cluster. See the "RSClusterCertificates" struct described above to see the supported certificates.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's API certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cmCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's CM (Cluster Manager) certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ldapClientCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's LDAP client certificate. If left blank, LDAP client certificate authentication will be disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>metricsExporterCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Metrics Exporter certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Proxy certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>syncerCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Secret name to use for cluster's Syncer certificate. If left blank, a cluster-provided certificate will be used.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.containerTimezone
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Container timezone configuration. While the default timezone on all containers is UTC, this setting can be used to set the timezone on services rigger/bootstrapper/RS containers. You can either propagate the hosts timezone to RS pods or set it manually via timezoneName.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>propagateHost</td>
+        <td>object</td>
+        <td>
+          Identifies that container timezone should be in sync with the host, this option mounts a hostPath volume onto RS pods that could be restricted in some systems.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timezoneName</td>
+        <td>string</td>
+        <td>
+          POSIX-style timezone name as a string to be passed as EnvVar to RE pods, e.g. "Europe/London".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specextraenvvars)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specextraenvvarsvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.hostAliases[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          Hostnames for the above IP address.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          IP address of the host file entry.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ingressOrRouteSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Access configurations for the Redis Enterprise Cluster and Databases. At most one of ingressOrRouteSpec or activeActive fields can be set at the same time.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          RS API URL<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          DB ENDPOINT SUFFIX - will be used to set the db host ingress <db name><db fqdn suffix>. Creates a host name so it should be unique if more than one db is created on the cluster with the same name<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>method</td>
+        <td>enum</td>
+        <td>
+          Used to distinguish between different platforms implementation.<br/>
+          <br/>
+            <i>Enum</i>: openShiftRoute, ingress, istio<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>ingressAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Additional annotations to set on ingress resources created by the operator<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Cluster-level LDAP configuration, such as server addresses, protocol, authentication and query settings.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationquery">authenticationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationquery">authorizationQuery</a></td>
+        <td>object</td>
+        <td>
+          Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>enum</td>
+        <td>
+          Specifies the LDAP protocol to use. One of: LDAP, LDAPS, STARTTLS.<br/>
+          <br/>
+            <i>Enum</i>: LDAP, LDAPS, STARTTLS<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specldapservers">servers</a></td>
+        <td>[]object</td>
+        <td>
+          One or more LDAP servers. If multiple servers are specified, they must all share an identical organization tree structure.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bindCredentialsSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding the credentials used to communicate with the LDAP server for authentication queries. The secret must have a key named 'dn' with the Distinguished Name of the user to execute the query, and 'password' with its password. If left blank, credentials-based authentication is disabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>caCertificateSecretName</td>
+        <td>string</td>
+        <td>
+          Name of a secret within the same namespace, holding a PEM-encoded CA certificate for validating the TLS connection to the LDAP server. The secret must have a key named 'cert' with the certificate data. This field is applicable only when the protocol is LDAPS or STARTTLS.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>cacheTTLSeconds</td>
+        <td>integer</td>
+        <td>
+          The maximum TTL of cached entries.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>directoryTimeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          The connection timeout to the LDAP server when authenticating a user, in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForControlPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for control plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabledForDataPlane</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable LDAP for data plane access. Disabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authentication queries, mapping between the username, provided to the cluster for authentication, and the LDAP Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specldapauthenticationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>template</td>
+        <td>string</td>
+        <td>
+          Configuration for a template query. Mutually exclusive with the 'query' field. The substring '%u' will be replaced with the username, e.g., 'cn=%u,ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authenticationQuery.query
+<sup><sup>[↩ Parent](#specldapauthenticationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'template' field. The substring '%u' in the query filter will be replaced with the username.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Configuration of authorization queries, mapping between a user's Distinguished Name and its group memberships.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>attribute</td>
+        <td>string</td>
+        <td>
+          Configuration for an attribute query. Mutually exclusive with the 'query' field. Holds the name of an attribute of the LDAP user entity that contains a list of the groups that the user belongs to, e.g., 'memberOf'.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specldapauthorizationqueryquery">query</a></td>
+        <td>object</td>
+        <td>
+          Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.authorizationQuery.query
+<sup><sup>[↩ Parent](#specldapauthorizationquery)</sup></sup>
+
+Configuration for a search query. Mutually exclusive with the 'attribute' field. The substring '%D' in the query filter will be replaced with the user's Distinguished Name.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>base</td>
+        <td>string</td>
+        <td>
+          The Distinguished Name of the entry at which to start the search, e.g., 'ou=dev,dc=example,dc=com'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>filter</td>
+        <td>string</td>
+        <td>
+          An RFC-4515 string representation of the filter to apply in the search. For an authentication query, the substring '%u' will be replaced with the username, e.g., '(cn=%u)'. For an authorization query, the substring '%D' will be replaced with the user's Distinguished Name, e.g., '(members=%D)'.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>scope</td>
+        <td>enum</td>
+        <td>
+          The search scope for an LDAP query. One of: BaseObject, SingleLevel, WholeSubtree<br/>
+          <br/>
+            <i>Enum</i>: BaseObject, SingleLevel, WholeSubtree<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ldap.servers[]
+<sup><sup>[↩ Parent](#specldap)</sup></sup>
+
+Address of an LDAP server.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          Host name of the LDAP server<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          Port number of the LDAP server. If unspecified, defaults to 389 for LDAP and STARTTLS protocols, and 636 for LDAPS protocol.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.ocspConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+An API object that represents the cluster's OCSP configuration. To enable OCSP, the cluster's proxy certificate should contain the OCSP responder URL.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ocspFunctionality</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable/disable OCSP mechanism for the cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>queryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryFrequency</td>
+        <td>integer</td>
+        <td>
+          Determines the interval (in seconds) in which the control plane will poll the OCSP responder for a new status for the server certificate when the current staple is invalid. Minimum value is 60. Maximum value is 86400.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>recoveryMaxTries</td>
+        <td>integer</td>
+        <td>
+          Determines the maximum number for the OCSP recovery attempts. After max number of tries passed, the control plane will revert back to the regular frequency. Minimum value is 1. Maximum value is 100.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responseTimeout</td>
+        <td>integer</td>
+        <td>
+          Determines the time interval (in seconds) for which the request waits for a response from the OCSP responder. Minimum value is 1. Maximum value is 60.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.persistentSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise Cluster persistence
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enablePersistentVolumeResize</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable PersistentVolumes resize. Disabled by default. Read the instruction in pvc_expansion readme carefully before using this feature.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to add persistent volume to Redis Enterprise pods<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          Storage class for persistent volume in Redis Enterprise pods. Leave empty to use the default. If using the default this way, make sure the Kubernetes Cluster has a default Storage Class configured. This can be done by running a `kubectl get storageclass` and see if one of the Storage Classes' names contains a `(default)` mark.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeSize</td>
+        <td>int or string</td>
+        <td>
+          To enable resizing after creating the cluster - please follow the instructions in the pvc_expansion readme<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Override for the default anti-affinity rules of the Redis Enterprise pods. More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#an-example-of-a-pod-that-uses-pod-affinity
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specpodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specpodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podStartingPolicy
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Mitigation setting for STS pods stuck in "ContainerCreating"
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to detect and attempt to mitigate pod startup issues<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>startingThresholdSeconds</td>
+        <td>integer</td>
+        <td>
+          Time in seconds to wait for a pod to be stuck while starting up before action is taken. If set to 0, will be treated as if disabled.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.podTolerations[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.pullSecrets[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Secret name<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the statefulset - Redis Enterprise pods. Pod attributes managed by the operator might override these settings. Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseadditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specredisenterpriseadditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Redis Enterprise container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Redis Enterprise containers
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterprisenoderesourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseNodeResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterprisenoderesources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+RS Cluster optional services settings
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcmserver">cmServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbcoordinator">crdbCoordinator</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationcrdbworker">crdbWorker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationmdnsserver">mdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationpdnsserver">pdnsServer</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationsaslauthd">saslauthd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterpriseservicesconfigurationstatsarchiver">statsArchiver</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.cmServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the CM server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbCoordinator
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb coordinator process<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.crdbWorker
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the crdb worker processes<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.mdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the Multicast DNS server<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.pdnsServer
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Deprecated: The PDNS Server is now disabled by the operator. This field will be ignored.<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.saslauthd
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the saslauthd service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesConfiguration.statsArchiver
+<sup><sup>[↩ Parent](#specredisenterpriseservicesconfiguration)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>operatingMode</td>
+        <td>enum</td>
+        <td>
+          Whether to enable/disable the stats archiver service<br/>
+          <br/>
+            <i>Enum</i>: enabled, disabled<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerImageSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for Services Rigger container image
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Compute resource requirements for Services Rigger pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specredisenterpriseservicesriggerresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-compute-resources-container/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseServicesRiggerResources.claims[]
+<sup><sup>[↩ Parent](#specredisenterpriseservicesriggerresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseVolumeMounts[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisOnFlashSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Stores configurations specific to redis on flash. If provided, the cluster will be capable of creating redis on flash databases.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bigStoreDriver</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb, speedb<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashDiskSize</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashStorageEngine</td>
+        <td>enum</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Enum</i>: rocksdb<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The security configuration that will be applied to RS pods.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsecuritycontextreadonlyrootfilesystempolicy">readOnlyRootFilesystemPolicy</a></td>
+        <td>object</td>
+        <td>
+          Policy controlling whether to enable read-only root filesystem for the Redis Enterprise software containers. Note that certain filesystem paths remain writable through mounted volumes to ensure proper functionality.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsecuritycontextresourcelimits">resourceLimits</a></td>
+        <td>object</td>
+        <td>
+          Settings pertaining to resource limits management by the Redis Enterprise Node container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext.readOnlyRootFilesystemPolicy
+<sup><sup>[↩ Parent](#specsecuritycontext)</sup></sup>
+
+Policy controlling whether to enable read-only root filesystem for the Redis Enterprise software containers. Note that certain filesystem paths remain writable through mounted volumes to ensure proper functionality.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>enabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to enable read-only root filesystem for the Redis Enterprise software containers. Default is false.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.securityContext.resourceLimits
+<sup><sup>[↩ Parent](#specsecuritycontext)</sup></sup>
+
+Settings pertaining to resource limits management by the Redis Enterprise Node container.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowAutoAdjustment</td>
+        <td>boolean</td>
+        <td>
+          Allow Redis Enterprise to adjust resource limits, like max open file descriptors, of its data plane processes. When this option is enabled, the SYS_RESOURCE capability is added to the Redis Enterprise pods, and their allowPrivilegeEscalation field is set. Turned off by default.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Customization options for operator-managed service resources created for Redis Enterprise clusters and databases
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesapiservice">apiService</a></td>
+        <td>object</td>
+        <td>
+          Customization options for the REC API service.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>servicesAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          Global additional annotations to set on service resources created by the operator. The specified annotations will not override annotations that already exist and didn't originate from the operator.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.services.apiService
+<sup><sup>[↩ Parent](#specservices)</sup></sup>
+
+Customization options for the REC API service.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          Type of service to create for the REC API service. Defaults to ClusterIP service, if not specified otherwise.<br/>
+          <br/>
+            <i>Enum</i>: ClusterIP, NodePort, LoadBalancer<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for service rigger
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>databaseServicePortPolicy</td>
+        <td>enum</td>
+        <td>
+          databaseServicePortPolicy instructs how to determine the service ports for REDB services. Defaults to DatabasePortForward, if not specified otherwise. DatabasePortForward - The service port will be the same as the database port. RedisDefaultPort - The service port will be the default Redis port (6379).<br/>
+          <br/>
+            <i>Enum</i>: DatabasePortForward, RedisDefaultPort<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseServiceType</td>
+        <td>string</td>
+        <td>
+          Service types for access to databases. should be a comma separated list. The possible values are cluster_ip, headless and load_balancer.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvars">extraEnvVars</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>podAnnotations</td>
+        <td>map[string]string</td>
+        <td>
+          annotations for the service rigger pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceNaming</td>
+        <td>enum</td>
+        <td>
+          Used to determine how to name the services created automatically when a database is created. When bdb_name is used, the database name will be also used for the service name. When redis-port is used, the service will be named redis-<port>.<br/>
+          <br/>
+            <i>Enum</i>: bdb_name, redis-port<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributes">servicesRiggerAdditionalPodSpecAttributes</a></td>
+        <td>object</td>
+        <td>
+          ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[]
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+EnvVar represents an environment variable present in a Container. More info: https://kubernetes.io/docs/tasks/inject-data-application/environment-variable-expose-pod-information/
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the environment variable.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          Source for the environment variable's value. Cannot be used if value is not empty.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvars)</sup></sup>
+
+Source for the environment variable's value. Cannot be used if value is not empty.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a ConfigMap.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a field of the pod<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a resource of the container: only resources limits and requests are currently supported.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecextraenvvarsvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          Selects a key of a secret in the pod's namespace<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a ConfigMap.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key to select.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the ConfigMap or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a field of the pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          Path of the field to select in the specified API version.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          Version of the schema the FieldPath is written in terms of, defaults to "v1".<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a resource of the container: only resources limits and requests are currently supported.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          Required: resource to select<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          Container name: required for volumes, optional for env vars<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          Specifies the output format of the exposed resources, defaults to "1"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.extraEnvVars[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecextraenvvarsvaluefrom)</sup></sup>
+
+Selects a key of a secret in the pod's namespace
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          The key of the secret to select from.  Must be a valid secret key.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name of the referent<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          Specify whether the Secret or its key must be defined<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes
+<sup><sup>[↩ Parent](#specservicesriggerspec)</sup></sup>
+
+ADVANCED USAGE USE AT YOUR OWN RISK - specify pod attributes that are required for the rigger deployment pod. Pod attributes managed by the operator might override these settings (Containers, serviceAccountName, podTolerations, ImagePullSecrets, nodeSelector, PriorityClassName, PodSecurityContext). Also make sure the attributes are supported by the K8s version running on the cluster - the operator does not validate that.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activeDeadlineSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity">affinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>automountServiceAccountToken</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig">dnsConfig</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dnsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>enableServiceLinks</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers">ephemeralContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributeshostaliases">hostAliases</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostIPC</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostNetwork</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPID</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostUsers</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostname</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesimagepullsecrets">imagePullSecrets</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers">initContainers</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeSelector</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesos">os</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>overhead</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>preemptionPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priority</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>priorityClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesreadinessgates">readinessGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims">resourceClaims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>restartPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runtimeClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>schedulerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesschedulinggates">schedulingGates</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serviceAccountName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>setHostnameAsFQDN</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shareProcessNamespace</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subdomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestolerations">tolerations</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints">topologySpreadConstraints</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes">volumes</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity">nodeAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity">podAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity">podAntiAffinity</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference">preference</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreferencematchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution[].preference.matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinitypreferredduringschedulingignoredduringexecutionpreference)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms">nodeSelectorTerms</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectortermsmatchfields">matchFields</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution.nodeSelectorTerms[].matchFields[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitynodeaffinityrequiredduringschedulingignoredduringexecutionnodeselectorterms)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution">preferredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution">requiredDuringSchedulingIgnoredDuringExecution</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm">podAffinityTerm</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>weight</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinityterm)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution[].podAffinityTerm.namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinitypreferredduringschedulingignoredduringexecutionpodaffinitytermnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinity)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector">namespaceSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespaces</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionlabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecution)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.affinity.podAntiAffinity.requiredDuringSchedulingIgnoredDuringExecution[].namespaceSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesaffinitypodantiaffinityrequiredduringschedulingignoredduringexecutionnamespaceselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>nameservers</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfigoptions">options</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>searches</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.dnsConfig.options[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesdnsconfig)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetContainerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.ephemeralContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesephemeralcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.hostAliases[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>hostnames</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ip</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.imagePullSecrets[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerslivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].ports[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainerssecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.exec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainersstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeDevices[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.initContainers[].volumeMounts[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesinitcontainers)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.os
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.readinessGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>conditionType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaimssource">source</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.resourceClaims[].source
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesresourceclaims)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resourceClaimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resourceClaimTemplateName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.schedulingGates[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsGroupChangePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>supplementalGroups</td>
+        <td>[]integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextsysctls">sysctls</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.sysctls[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributessecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.tolerations[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>effect</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tolerationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>maxSkew</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>topologyKey</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>whenUnsatisfiable</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector">labelSelector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabelKeys</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>minDomains</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeAffinityPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nodeTaintsPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraints)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.topologySpreadConstraints[].labelSelector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributestopologyspreadconstraintslabelselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral">ephemeral</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].azureFile
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate">volumeClaimTemplate</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeral)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>metadata</td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplate)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>accessModes</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasource">dataSource</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecdatasourceref">dataSourceRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector">selector</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageClassName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSource
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.dataSourceRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiGroup</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.resources.claims[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselectormatchexpressions">matchExpressions</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>matchLabels</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].ephemeral.volumeClaimTemplate.spec.selector.matchExpressions[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesephemeralvolumeclaimtemplatespecselector)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>operator</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>values</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].fc
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].flocker
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].hostPath
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].nfs
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].quobyte
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.servicesRiggerSpec.servicesRiggerAdditionalPodSpecAttributes.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specservicesriggerspecservicesriggeradditionalpodspecattributesvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>args</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenv">env</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfrom">envFrom</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycle">lifecycle</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobe">livenessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecports">ports</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobe">readinessProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecresources">resources</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontext">securityContext</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobe">startupProbe</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdin</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>stdinOnce</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationMessagePolicy</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tty</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumedevices">volumeDevices</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecvolumemounts">volumeMounts</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>workingDir</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefrom">valueFrom</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom
+<sup><sup>[↩ Parent](#specsidecontainersspecenv)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromconfigmapkeyref">configMapKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvvaluefromsecretkeyref">secretKeyRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.configMapKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.fieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.resourceFieldRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].env[].valueFrom.secretKeyRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvvaluefrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecenvfromconfigmapref">configMapRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecenvfromsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].configMapRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].envFrom[].secretRef
+<sup><sup>[↩ Parent](#specsidecontainersspecenvfrom)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststart">postStart</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestop">preStop</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststartexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarttcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecyclepoststarthttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststarthttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.postStart.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecyclepoststart)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycle)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestopexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestoptcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclifecycleprestophttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestophttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].lifecycle.preStop.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclifecycleprestop)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspeclivenessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspeclivenessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].livenessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspeclivenessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].ports[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>containerPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>hostIP</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostPort</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protocol</td>
+        <td>string</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Default</i>: TCP<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecreadinessprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecreadinessprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].readinessProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecreadinessprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].resources.claims[]
+<sup><sup>[↩ Parent](#specsidecontainersspecresources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>allowPrivilegeEscalation</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextcapabilities">capabilities</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>privileged</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>procMount</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnlyRootFilesystem</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsGroup</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsNonRoot</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUser</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextselinuxoptions">seLinuxOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextseccompprofile">seccompProfile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecsecuritycontextwindowsoptions">windowsOptions</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.capabilities
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>add</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>drop</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seLinuxOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>level</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.seccompProfile
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>localhostProfile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].securityContext.windowsOptions
+<sup><sup>[↩ Parent](#specsidecontainersspecsecuritycontext)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gmsaCredentialSpec</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>gmsaCredentialSpecName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>hostProcess</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>runAsUserName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specsidecontainersspecstartupprobeexec">exec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>failureThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobegrpc">grpc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpget">httpGet</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initialDelaySeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>periodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>successThreshold</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobetcpsocket">tcpSocket</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>terminationGracePeriodSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>timeoutSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.exec
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>command</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.grpc
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>service</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specsidecontainersspecstartupprobehttpgethttpheaders">httpHeaders</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>scheme</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.httpGet.httpHeaders[]
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobehttpget)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>value</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].startupProbe.tcpSocket
+<sup><sup>[↩ Parent](#specsidecontainersspecstartupprobe)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>port</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>host</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeDevices[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>devicePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.sideContainersSpec[].volumeMounts[]
+<sup><sup>[↩ Parent](#specsidecontainersspec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>mountPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mountPropagation</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>subPathExpr</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.slaveHA
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Slave high availability mechanism configuration.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>slaveHAGracePeriod</td>
+        <td>integer</td>
+        <td>
+          Time in seconds between when a node fails, and when slave high availability mechanism starts relocating shards. If set to 0, will not affect cluster configuration.<br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.upgradeSpec
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Specification for upgrades of Redis Enterprise
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>autoUpgradeRedisEnterprise</td>
+        <td>boolean</td>
+        <td>
+          Whether to upgrade Redis Enterprise automatically when operator is upgraded<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.usageMeter
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The configuration of the usage meter.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specusagemetercallhomeclient">callHomeClient</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.usageMeter.callHomeClient
+<sup><sup>[↩ Parent](#specusagemeter)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>disabled</td>
+        <td>boolean</td>
+        <td>
+          Whether to disable the call home client. Enabled by default.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specusagemetercallhomeclientimagespec">imageSpec</a></td>
+        <td>object</td>
+        <td>
+          Image specification<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specusagemetercallhomeclientresources">resources</a></td>
+        <td>object</td>
+        <td>
+          Compute resource requirements for Call Home Client pod<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.usageMeter.callHomeClient.imageSpec
+<sup><sup>[↩ Parent](#specusagemetercallhomeclient)</sup></sup>
+
+Image specification
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>digestHash</td>
+        <td>string</td>
+        <td>
+          The digest hash of the container image to pull. When specified, the container image is pulled according to the digest hash instead of the image tag. The versionTag field must also be specified with the image tag matching this digest hash. Note: This field is only supported for OLM deployments.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>imagePullPolicy</td>
+        <td>string</td>
+        <td>
+          The image pull policy to be applied to the container image. One of Always, Never, IfNotPresent.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          The repository (name) of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versionTag</td>
+        <td>string</td>
+        <td>
+          The tag of the container image to be deployed.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.usageMeter.callHomeClient.resources
+<sup><sup>[↩ Parent](#specusagemetercallhomeclient)</sup></sup>
+
+Compute resource requirements for Call Home Client pod
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specusagemetercallhomeclientresourcesclaims">claims</a></td>
+        <td>[]object</td>
+        <td>
+          Claims lists the names of resources, defined in spec.resourceClaims, that are used by this container. 
+ This is an alpha field and requires enabling the DynamicResourceAllocation feature gate. 
+ This field is immutable. It can only be set for containers.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>limits</td>
+        <td>map[string]int or string</td>
+        <td>
+          Limits describes the maximum amount of compute resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>requests</td>
+        <td>map[string]int or string</td>
+        <td>
+          Requests describes the minimum amount of compute resources required. If Requests is omitted for a container, it defaults to Limits if that is explicitly specified, otherwise to an implementation-defined value. Requests cannot exceed Limits. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.usageMeter.callHomeClient.resources.claims[]
+<sup><sup>[↩ Parent](#specusagemetercallhomeclientresources)</sup></sup>
+
+ResourceClaim references one entry in PodSpec.ResourceClaims.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          Name must match the name of one entry in pod.spec.resourceClaims of the Pod where this field is used. It makes that resource available inside a container.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Volume represents a named volume in a pod that may be accessed by any container in the pod. More info: https://kubernetes.io/docs/concepts/storage/volumes
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesawselasticblockstore">awsElasticBlockStore</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazuredisk">azureDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesazurefile">azureFile</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfs">cephfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescinder">cinder</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsi">csi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesemptydir">emptyDir</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesfc">fc</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolume">flexVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflocker">flocker</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgcepersistentdisk">gcePersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesgitrepo">gitRepo</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesglusterfs">glusterfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumeshostpath">hostPath</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsi">iscsi</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesnfs">nfs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumespersistentvolumeclaim">persistentVolumeClaim</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesphotonpersistentdisk">photonPersistentDisk</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesportworxvolume">portworxVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojected">projected</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesquobyte">quobyte</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbd">rbd</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleio">scaleIO</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageos">storageos</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesvspherevolume">vsphereVolume</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].awsElasticBlockStore
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>diskName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>diskURI</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>cachingMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>kind</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].azureFile
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>shareName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretFile</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescephfssecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cephfs.secretRef
+<sup><sup>[↩ Parent](#specvolumescephfs)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescindersecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].cinder.secretRef
+<sup><sup>[↩ Parent](#specvolumescinder)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumescsinodepublishsecretref">nodePublishSecretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeAttributes</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].csi.nodePublishSecretRef
+<sup><sup>[↩ Parent](#specvolumescsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].emptyDir
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>medium</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sizeLimit</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].fc
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>targetWWNs</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>wwids</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>driver</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>options</td>
+        <td>map[string]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesflexvolumesecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flexVolume.secretRef
+<sup><sup>[↩ Parent](#specvolumesflexvolume)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].flocker
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>datasetName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>datasetUUID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gcePersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>partition</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].gitRepo
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>repository</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>directory</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revision</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].glusterfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>endpoints</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].hostPath
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>iqn</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>lun</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>targetPortal</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>chapAuthDiscovery</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>chapAuthSession</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>initiatorName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>iscsiInterface</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>portals</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesiscsisecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].iscsi.secretRef
+<sup><sup>[↩ Parent](#specvolumesiscsi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].nfs
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>server</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].persistentVolumeClaim
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>claimName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].photonPersistentDisk
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>pdID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].portworxVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumeID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsources">sources</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[]
+<sup><sup>[↩ Parent](#specvolumesprojected)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmap">configMap</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapi">downwardAPI</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcessecret">secret</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesserviceaccounttoken">serviceAccountToken</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesconfigmapitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].configMap.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesconfigmap)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapi)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsfieldref">fieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesprojectedsourcesdownwardapiitemsresourcefieldref">resourceFieldRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].fieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fieldPath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiVersion</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].downwardAPI.items[].resourceFieldRef
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcesdownwardapiitems)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>resource</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>containerName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>divisor</td>
+        <td>int or string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specvolumesprojectedsourcessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumesprojectedsourcessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].projected.sources[].serviceAccountToken
+<sup><sup>[↩ Parent](#specvolumesprojectedsources)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>audience</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationSeconds</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].quobyte
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>registry</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>volume</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>group</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tenant</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>image</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>monitors</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>keyring</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>pool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesrbdsecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>user</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].rbd.secretRef
+<sup><sup>[↩ Parent](#specvolumesrbd)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>gateway</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specvolumesscaleiosecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>system</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>protectionDomain</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>sslEnabled</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storageMode</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePool</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].scaleIO.secretRef
+<sup><sup>[↩ Parent](#specvolumesscaleio)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>defaultMode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumessecretitems">items</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>optional</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].secret.items[]
+<sup><sup>[↩ Parent](#specvolumessecret)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>key</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>mode</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>readOnly</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specvolumesstorageossecretref">secretRef</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>volumeNamespace</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].storageos.secretRef
+<sup><sup>[↩ Parent](#specvolumesstorageos)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.volumes[].vsphereVolume
+<sup><sup>[↩ Parent](#specvolumes)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>volumePath</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>fsType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyID</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>storagePolicyName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#statusbundleddatabaseversions">bundledDatabaseVersions</a></td>
+        <td>[]object</td>
+        <td>
+          Versions of open source databases bundled by Redis Enterprise Software - please note that in order to use a specific version it should be supported by the ‘upgradePolicy’ - ‘major’ or ‘latest’ according to the desired version (major/minor)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuscertificatesstatus">certificatesStatus</a></td>
+        <td>object</td>
+        <td>
+          Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ingressOrRouteMethodStatus</td>
+        <td>string</td>
+        <td>
+          The ingressOrRouteSpec/ActiveActive spec method that exist<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuslicensestatus">licenseStatus</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmanagedapis">managedAPIs</a></td>
+        <td>object</td>
+        <td>
+          Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusmodules">modules</a></td>
+        <td>[]object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusocspstatus">ocspStatus</a></td>
+        <td>object</td>
+        <td>
+          An API object that represents the cluster's OCSP status<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statuspersistencestatus">persistenceStatus</a></td>
+        <td>object</td>
+        <td>
+          The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseIPFamily</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>state</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.bundledDatabaseVersions[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>dbType</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>major</td>
+        <td>boolean</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.certificatesStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Stores information about cluster certificates and their update process. In Active-Active databases, this is used to detect updates to the certificates, and trigger synchronization across the participating clusters.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>generation</td>
+        <td>integer</td>
+        <td>
+          Generation stores the version of the cluster's Proxy and Syncer certificate secrets. In Active-Active databases, when a user updates the proxy or syncer certificate, a crdb-update command needs to be triggered to avoid potential sync issues. This helps the REAADB controller detect a change in a certificate and trigger a crdb-update. The version of the cluster's Proxy certificate secret.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>updateStatus</td>
+        <td>string</td>
+        <td>
+          The status of the cluster's certificates update<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.licenseStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>activationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>expirationDate</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>features</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashShards</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>flashShardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>licenseState</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>owner</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ramShards</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ramShardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+          <br/>
+            <i>Format</i>: int32<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsLimit</td>
+        <td>integer</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsUsage</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.managedAPIs
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Indicates cluster APIs that are being managed by the operator. This only applies to cluster APIs which are optionally-managed by the operator, such as cluster LDAP configuration. Most other APIs are automatically managed by the operator, and are not listed here.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>ldap</td>
+        <td>boolean</td>
+        <td>
+          Indicate whether cluster LDAP configuration is managed by the operator. When this is enabled, the operator will reconcile the cluster LDAP configuration according to the '.spec.ldap' field in the RedisEnterpriseCluster resource.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.modules[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>displayName</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>versions</td>
+        <td>[]string</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.ocspStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+An API object that represents the cluster's OCSP status
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>certStatus</td>
+        <td>string</td>
+        <td>
+          Indicates the proxy certificate status - GOOD/REVOKED/UNKNOWN.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>nextUpdate</td>
+        <td>string</td>
+        <td>
+          The time at or before which newer information will be available about the status of the certificate (if available)<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>producedAt</td>
+        <td>string</td>
+        <td>
+          The time at which the OCSP responder signed this response.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>responderUrl</td>
+        <td>string</td>
+        <td>
+          The OCSP responder url from which this status came from.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>revocationTime</td>
+        <td>string</td>
+        <td>
+          The time at which the certificate was revoked or placed on hold.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>thisUpdate</td>
+        <td>string</td>
+        <td>
+          The most recent time at which the status being indicated is known by the responder to have been correct.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.persistenceStatus
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+The status of the Persistent Volume Claims that are used for Redis Enterprise Cluster persistence. The status will correspond to the status of one or more of the PVCs (failed/resizing if one of them is in resize or failed to resize)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The current status of the PVCs<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>succeeded</td>
+        <td>string</td>
+        <td>
+          The number of PVCs that are provisioned with the expected size<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseActiveActiveDatabase API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: REAADB API
+weight: 30
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEnterpriseActiveActiveDatabase is the Schema for the redisenterpriseactiveactivedatabase API
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseActiveActiveDatabase</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseSpec defines the desired state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters specifications and configurations.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurations">globalConfigurations</a></td>
+        <td>object</td>
+        <td>
+          The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.participatingClusters[]
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR to link.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>externalReplicationPort</td>
+        <td>integer</td>
+        <td>
+          The desired replication endpoint's port number for users who utilize LoadBalancers for sync between AA replicas and need to provide the specific port number that the LoadBalancer listens to.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>namespace</td>
+        <td>string</td>
+        <td>
+          Namespace in which the REAADB object will be deployed to within the corresponding participating cluster. The user must ensure that the Redis Enterprise operator is configured to watch this namespace in the corresponding cluster, and the required RBAC configuration is properly set up. See https://redis.io/docs/latest/operate/kubernetes/re-clusters/multi-namespace/ for more information how to set up multiple namespaces. If no namespace is specified, then the REAADB is deployed to the REC's namespace in the corresponding cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+The Active-Active database global configurations, contains the global properties for each of the participating clusters/ instances databases within the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsactiveactive">activeActive</a></td>
+        <td>object</td>
+        <td>
+          Connection/ association to the Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackup">backup</a></td>
+        <td>object</td>
+        <td>
+          Target for automatic database backups.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>clientAuthenticationCertificates</td>
+        <td>[]string</td>
+        <td>
+          The Secrets containing TLS Client Certificate to use for Authentication<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dataInternodeEncryption</td>
+        <td>boolean</td>
+        <td>
+          Internode encryption (INE) setting. An optional boolean setting, overriding a similar cluster-wide policy. If set to False, INE is guaranteed to be turned off for this DB (regardless of cluster-wide policy). If set to True, INE will be turned on, unless the capability is not supported by the DB ( in such a case we will get an error and database creation will fail). If left unspecified, will be disabled if internode encryption is not supported by the DB (regardless of cluster default). Deleting this property after explicitly setting its value shall have no effect.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databasePort</td>
+        <td>integer</td>
+        <td>
+          Database port number. TCP port on which the database is available. Will be generated automatically if omitted. can not be changed after creation<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>databaseSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the password to the database (redis databases only). If secret does not exist, it will be created. To define the password, create an opaque secret and set the name in the spec. The password will be taken from the value of the 'password' key. Use an empty string as value within the secret to disable authentication for the database. Notes - For Active-Active databases this secret will not be automatically created, and also, memcached databases must not be set with a value, and a secret/password will not be automatically created for them. Use the memcachedSaslSecretName field to set authentication parameters for memcached databases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>defaultUser</td>
+        <td>boolean</td>
+        <td>
+          Is connecting with a default user allowed?  If disabled, the DatabaseSecret will not be created or updated<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>evictionPolicy</td>
+        <td>string</td>
+        <td>
+          Database eviction policy. see more https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>isRof</td>
+        <td>boolean</td>
+        <td>
+          Whether it is an RoF database or not. Applicable only for databases of type "REDIS". Assumed to be false if left blank.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memcachedSaslSecretName</td>
+        <td>string</td>
+        <td>
+          Credentials used for binary authentication in memcached databases. The credentials should be saved as an opaque secret and the name of that secret should be configured using this field. For username, use 'username' as the key and the actual username as the value. For password, use 'password' as the key and the actual password as the value. Note that connections are not encrypted.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>memorySize</td>
+        <td>string</td>
+        <td>
+          memory size of database. use formats like 100MB, 0.1GB. minimum value in 100MB. When redis on flash (RoF) is enabled, this value refers to RAM+Flash memory, and it must not be below 1GB.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsmoduleslist">modulesList</a></td>
+        <td>[]object</td>
+        <td>
+          List of modules associated with the database. The list of valid modules for the specific cluster can be retrieved from the status of the REC object. Use the "name" and "versions" fields for the specific module configuration. If specifying an explicit version for a module, automatic modules versions upgrade must be disabled by setting the '.upgradeSpec.upgradeModulesToLatest' field in the REC to 'false'. Note that the option to specify module versions is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>ossCluster</td>
+        <td>boolean</td>
+        <td>
+          OSS Cluster mode option. Note that not all client libraries support OSS cluster mode.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>persistence</td>
+        <td>enum</td>
+        <td>
+          Database on-disk persistence policy<br/>
+          <br/>
+            <i>Enum</i>: disabled, aofEverySecond, aofAlways, snapshotEvery1Hour, snapshotEvery6Hour, snapshotEvery12Hour<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>proxyPolicy</td>
+        <td>string</td>
+        <td>
+          The policy used for proxy binding to the endpoint. Supported proxy policies are: single/all-master-shards/all-nodes When left blank, the default value will be chosen according to the value of ossCluster - single if disabled, all-master-shards when enabled<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rackAware</td>
+        <td>boolean</td>
+        <td>
+          Whether database should be rack aware. This improves availability - more information: https://docs.redislabs.com/latest/rs/concepts/high-availability/rack-zone-awareness/<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsredisenterprisecluster">redisEnterpriseCluster</a></td>
+        <td>object</td>
+        <td>
+          Connection to Redis Enterprise Cluster<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisVersion</td>
+        <td>string</td>
+        <td>
+          Redis OSS version. Version can be specified via <major.minor> prefix, or via channels - for existing databases - Upgrade Redis OSS version. For new databases - the version which the database will be created with. If set to 'major' - will always upgrade to the most recent major Redis version. If set to 'latest' - will always upgrade to the most recent Redis version. Depends on 'redisUpgradePolicy' - if you want to set the value to 'latest' for some databases, you must set redisUpgradePolicy on the cluster before. Possible values are 'major' or 'latest' When using upgrade - make sure to backup the database before. This value is used only for database type 'redis'. Note - Specifying Redis version is currently not supported for Active-Active database.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsreplicasources">replicaSources</a></td>
+        <td>[]object</td>
+        <td>
+          What databases to replicate from<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replication</td>
+        <td>boolean</td>
+        <td>
+          In-memory database replication. When enabled, database will have replica shard for every master - leading to higher availability. Defaults to false.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>resp3</td>
+        <td>boolean</td>
+        <td>
+          Whether this database supports RESP3 protocol. Note - Deleting this property after explicitly setting its value shall have no effect. Please view the corresponding field in RS doc for more info.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>rofRamSize</td>
+        <td>string</td>
+        <td>
+          The size of the RAM portion of an RoF database. Similarly to "memorySize" use formats like 100MB, 0.1GB It must be at least 10% of combined memory size (RAM+Flash), as specified by "memorySize".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsrolespermissions">rolesPermissions</a></td>
+        <td>[]object</td>
+        <td>
+          List of Redis Enteprise ACL and Role bindings to apply<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardCount</td>
+        <td>integer</td>
+        <td>
+          Number of database server-side shards<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardingEnabled</td>
+        <td>boolean</td>
+        <td>
+          Toggles database sharding for REAADBs (Active Active databases) and enabled by default. This field is blocked for REDB (non-Active Active databases) and sharding is toggled via the shardCount field - when shardCount is 1 this is disabled otherwise enabled.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>shardsPlacement</td>
+        <td>string</td>
+        <td>
+          Control the density of shards - should they reside on as few or as many nodes as possible. Available options are "dense" or "sparse". If left unset, defaults to "dense".<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsMode</td>
+        <td>enum</td>
+        <td>
+          Require SSL authenticated and encrypted connections to the database. enabled - all incoming connections to the Database must use SSL. disabled - no incoming connection to the Database should use SSL. replica_ssl - databases that replicate from this one need to use SSL.<br/>
+          <br/>
+            <i>Enum</i>: disabled, enabled, replica_ssl<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>type</td>
+        <td>enum</td>
+        <td>
+          The type of the database.<br/>
+          <br/>
+            <i>Enum</i>: redis, memcached<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsupgradespec">upgradeSpec</a></td>
+        <td>object</td>
+        <td>
+          Specifications for DB upgrade.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.activeActive
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection/ association to the Active-Active database.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The the corresponding Active-Active database name, Redis Enterprise Active Active Database custom resource name, this Resource is associated with. In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>participatingClusterName</td>
+        <td>string</td>
+        <td>
+          The corresponding participating cluster name, Redis Enterprise Remote Cluster custom resource name, in the Active-Active database, In case this resource is created manually at the active active database creation this field must be filled via the user, otherwise, the operator will assign this field automatically. Note: this feature is currently unsupported.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+### spec.globalConfigurations.backup
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Target for automatic database backups.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td><a href="#specglobalconfigurationsbackupabs">abs</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupftp">ftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupgcs">gcs</a></td>
+        <td>object</td>
+        <td>
+          GoogleStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>interval</td>
+        <td>integer</td>
+        <td>
+          Backup Interval in seconds<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupmount">mount</a></td>
+        <td>object</td>
+        <td>
+          MountPointStorage<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackups3">s3</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupsftp">sftp</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#specglobalconfigurationsbackupswift">swift</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.abs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>absSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds ABS credentials. The secret must contain the keys "AccountName" and "AccountKey", and these must hold the corresponding credentials<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Azure Blob Storage container name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Azure Blob Storage subdir under container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.ftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>url</td>
+        <td>string</td>
+        <td>
+          a URI of the "ftps://[USER[:PASSWORD]@]HOST[:PORT]/PATH[/]" format<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.gcs
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+GoogleStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Google Storage bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>gcsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the Google Cloud Storage credentials. The secret must contain the keys "CLIENT_ID", "PRIVATE_KEY", "PRIVATE_KEY_ID", "CLIENT_EMAIL" and these must hold the corresponding credentials. The keys should correspond to the values in the key JSON.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Google Storage subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.mount
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+MountPointStorage
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>path</td>
+        <td>string</td>
+        <td>
+          Path to the local mount point. You must create the mount point on all nodes, and the redislabs:redislabs user must have read and write permissions on the local mount point.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.s3
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>awsSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds the AWS credentials. The secret must contain the keys "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY", and these must hold the corresponding credentials.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>bucketName</td>
+        <td>string</td>
+        <td>
+          Amazon S3 bucket name.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>subdir</td>
+        <td>string</td>
+        <td>
+          Optional. Amazon S3 subdir under bucket.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.sftp
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>sftpSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds SFTP credentials. The secret must contain the "Key" key, which is the SSH private key for connecting to the sftp server.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>sftp_url</td>
+        <td>string</td>
+        <td>
+          SFTP url<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.backup.swift
+<sup><sup>[↩ Parent](#specglobalconfigurationsbackup)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>auth_url</td>
+        <td>string</td>
+        <td>
+          Swift service authentication URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>container</td>
+        <td>string</td>
+        <td>
+          Swift object store container for storing the backup files.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>swiftSecretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret that holds Swift credentials. The secret must contain the keys "Key" and "User", and these must hold the corresponding credentials: service access key and service user name (pattern for the latter does not allow special characters &,<,>,")<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>prefix</td>
+        <td>string</td>
+        <td>
+          Optional. Prefix (path) of backup files in the swift container.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.modulesList[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise module (see https://redis.io/docs/latest/develop/reference/modules/)
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the module, e.g. "search" or "ReJSON". The complete list of modules available in the cluster can be retrieved from the '.status.modules' field in the REC.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>config</td>
+        <td>string</td>
+        <td>
+          Module command line arguments e.g. VKEY_MAX_ENTITY_COUNT 30 30<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>version</td>
+        <td>string</td>
+        <td>
+          The semantic version of the module, e.g. '1.6.12'. Optional for REDB, must be set for REAADB. Note that this field is deprecated, and will be removed in future releases.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.replicaSources[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>replicaSourceName</td>
+        <td>string</td>
+        <td>
+          The name of the resource from which the source database URI is derived. The type of resource must match the type specified in the ReplicaSourceType field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>replicaSourceType</td>
+        <td>string</td>
+        <td>
+          The type of resource from which the source database URI is derived. If set to 'SECRET', the source database URI is derived from the secret named in the ReplicaSourceName field. The secret must have a key named 'uri' that defines the URI of the source database in the form of 'redis://...'. The type of secret (kubernetes, vault, ...) is determined by the secret mechanism used by the underlying REC object. If set to 'REDB', the source database URI is derived from the RedisEnterpriseDatabase resource named in the ReplicaSourceName field.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>clientKeySecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the client certificate and key used by the syncer in the target database cluster. The secret must have 2 keys in its map: "cert" which is the PEM encoded certificate, and "key" which is the PEM encoded private key.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>compression</td>
+        <td>integer</td>
+        <td>
+          GZIP compression level (0-6) to use for replication.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>serverCertSecret</td>
+        <td>string</td>
+        <td>
+          Secret that defines the server certificate used by the proxy in the source database cluster. The secret must have 1 key in its map: "cert" which is the PEM encoded certificate.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>tlsSniName</td>
+        <td>string</td>
+        <td>
+          TLS SNI name to use for the replication link.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.rolesPermissions[]
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Redis Enterprise Role and ACL Binding
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>acl</td>
+        <td>string</td>
+        <td>
+          Acl Name of RolePermissionType (note: use exact name of the ACL from the Redis Enterprise ACL list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>role</td>
+        <td>string</td>
+        <td>
+          Role Name of RolePermissionType (note: use exact name of the role from the Redis Enterprise role list, case sensitive)<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>type</td>
+        <td>string</td>
+        <td>
+          Type of Redis Enterprise Database Role Permission<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.globalConfigurations.upgradeSpec
+<sup><sup>[↩ Parent](#specglobalconfigurations)</sup></sup>
+
+Specifications for DB upgrade.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>upgradeModulesToLatest</td>
+        <td>boolean</td>
+        <td>
+          Upgrades the modules to the latest version that supports the DB version during a DB upgrade action, to upgrade the DB version view the 'redisVersion' field. Note - This field is currently not supported for Active-Active databases.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### spec.redisEnterpriseCluster
+<sup><sup>[↩ Parent](#spec)</sup></sup>
+
+Connection to Redis Enterprise Cluster
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the Redis Enterprise Cluster where the database should be stored.<br/>
+        </td>
+        <td>true</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+RedisEnterpriseActiveActiveDatabaseStatus defines the observed state of RedisEnterpriseActiveActiveDatabase
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>clusterCertificatesGeneration</td>
+        <td>integer</td>
+        <td>
+          Versions of the cluster's Proxy and Syncer certificates. In Active-Active databases, these are used to detect updates to the certificates, and trigger synchronization across the participating clusters. .<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>guid</td>
+        <td>string</td>
+        <td>
+          The active-active database corresponding GUID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>lastTaskUid</td>
+        <td>string</td>
+        <td>
+          The last active-active database task UID.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>linkedRedbs</td>
+        <td>[]string</td>
+        <td>
+          The linked REDBs.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statusparticipatingclusters">participatingClusters</a></td>
+        <td>[]object</td>
+        <td>
+          The list of instances/ clusters statuses.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>redisEnterpriseCluster</td>
+        <td>string</td>
+        <td>
+          The Redis Enterprise Cluster Object this Resource is associated with<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The overall replication status<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#statussecretsstatus">secretsStatus</a></td>
+        <td>[]object</td>
+        <td>
+          The status of the secrets<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the active active database.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.participatingClusters[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the remote cluster CR that is linked.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>id</td>
+        <td>integer</td>
+        <td>
+          The corresponding ID of the instance in the active-active database.<br/>
+          <br/>
+            <i>Format</i>: int64<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>replicationStatus</td>
+        <td>enum</td>
+        <td>
+          The replication status of the participating cluster<br/>
+          <br/>
+            <i>Enum</i>: up, down<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status.secretsStatus[]
+<sup><sup>[↩ Parent](#status)</sup></sup>
+
+Status of secrets.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>name</td>
+        <td>string</td>
+        <td>
+          The name of the secret.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>status</td>
+        <td>enum</td>
+        <td>
+          The status of the secret.<br/>
+          <br/>
+            <i>Enum</i>: Valid, Invalid<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+title: RedisEnterpriseRemoteCluster API Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+linkTitle: RERC API
+weight: 30
+---
+
+apiVersion:
+
+
+- [app.redislabs.com/v1alpha1](#appredislabscomv1alpha1)
+
+
+
+
+# app.redislabs.com/v1alpha1
+
+
+
+
+RedisEntepriseRemoteCluster represents a remote participating cluster.
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+      <td>apiVersion</td>
+      <td>string</td>
+      <td>app.redislabs.com/v1alpha1</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td>kind</td>
+      <td>string</td>
+      <td>RedisEnterpriseRemoteCluster</td>
+      <td>true</td>
+      </tr>
+      <tr>
+      <td><a href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.27/#objectmeta-v1-meta">metadata</a></td>
+      <td>object</td>
+      <td>Refer to the Kubernetes API documentation for the fields of the `metadata` field.</td>
+      <td>true</td>
+      </tr><tr>
+        <td><a href="#spec">spec</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td><a href="#status">status</a></td>
+        <td>object</td>
+        <td>
+          <br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### spec
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>apiFqdnUrl</td>
+        <td>string</td>
+        <td>
+          The URL of the cluster, will be used for the active-active database URL.<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recName</td>
+        <td>string</td>
+        <td>
+          The name of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>recNamespace</td>
+        <td>string</td>
+        <td>
+          The namespace of the REC that the RERC is pointing at<br/>
+        </td>
+        <td>true</td>
+      </tr><tr>
+        <td>apiPort</td>
+        <td>integer</td>
+        <td>
+          The port number of the cluster's URL used for connectivity/sync<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>dbFqdnSuffix</td>
+        <td>string</td>
+        <td>
+          The database URL suffix, will be used for the active-active database replication endpoint and replication endpoint SNI.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>secretName</td>
+        <td>string</td>
+        <td>
+          The name of the secret containing cluster credentials. Must be of the following format: "redis-enterprise-<RERC name>"<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+
+
+### status
+<sup><sup>[↩ Parent](#)</sup></sup>
+
+
+
+<table>
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Type</th>
+            <th>Description</th>
+            <th>Required</th>
+        </tr>
+    </thead>
+    <tbody><tr>
+        <td>internalObservedSecretResourceVersion</td>
+        <td>string</td>
+        <td>
+          The observed secret resource version. Used for internal purposes only.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>local</td>
+        <td>boolean</td>
+        <td>
+          Indicates whether this object represents a local or a remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>observedGeneration</td>
+        <td>integer</td>
+        <td>
+          The most recent generation observed for this RERC. It corresponds to the RERC's generation, which is updated by the API Server.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>specStatus</td>
+        <td>string</td>
+        <td>
+          Whether the desired specification is valid.<br/>
+        </td>
+        <td>false</td>
+      </tr><tr>
+        <td>status</td>
+        <td>string</td>
+        <td>
+          The status of the remote cluster.<br/>
+        </td>
+        <td>false</td>
+      </tr></tbody>
+</table>
+---
+Title: Reference
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: Reference material for the operator, cluster, and database deployment
+  options.
+hideListLinks: false
+linkTitle: Reference
+weight: 89
+---
+
+This section contains the API reference for Redis custom resources and supported distributions.
+
+
+
+---
+Title: Redis Enterprise for Kubernetes
+alwaysopen: false
+categories:
+- docs
+- operate
+- kubernetes
+description: The Redis Enterprise operators allows you to use Redis Enterprise for
+  Kubernetes.
+hideListLinks: false
+linkTitle: Redis for Kubernetes
+weight: 30
+---
+
+Kubernetes provides enterprise orchestration of containers and has been widely adopted. Redis Enterprise for Kubernetes provides a simple way to get a Redis Enterprise cluster on Kubernetes and enables more complex deployment scenarios.
+
+---
+Title: Supported Cloud providers and regions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Supported regions
+weight: 90
+---
+
+Your choice of cloud provider and region may affect latency between your application and your database, and may affect what connectivity options are available for your database.
+
+Redis Cloud supports databases on the following cloud providers:
+- [Amazon Web Services (AWS)](#amazon-web-services)
+- [Google Cloud](#google-cloud)
+- [Microsoft Azure](#microsoft-azure)
+
+## Amazon Web Services
+
+Redis Cloud supports databases in the following Amazon Web Services (AWS) regions. 
+
+Redis Cloud Pro databases on AWS support [VPC Peering]({{< relref "/operate/rc/security/vpc-peering#aws-vpc-peering" >}}) and [Transit Gateway]({{< relref "/operate/rc/security/aws-transit-gateway" >}}).
+
+#### Americas
+
+| Region ID      | Location                 | Redis Cloud Pro | Redis Cloud Essentials |
+|:---------------|:-------------------------|:----------------|:-----------------------|
+| `ca-central-1` | Montreal, Canada         | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `mx-central-1` | Central Mexico | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `sa-east-1`    | Sao Paulo, Brazil        | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-east-1`    | Northern Virginia, USA   | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-east-2`    | Ohio, USA                | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-west-1`    | Northern California, USA | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-west-2`    | Oregon, USA              | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+
+#### Europe
+
+| Region ID | Location | Redis Cloud Pro | Redis Cloud Essentials |
+|---|---|---|---|
+| `eu-central-1` | Frankfurt, Germany | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `eu-central-2` | Zurich, Switzerland | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `eu-north-1` | Stockholm, Sweden | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `eu-south-1` | Milan, Italy | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `eu-south-2` | Spain | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `eu-west-1` | Ireland | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `eu-west-2` | London, UK | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `eu-west-3` | Paris, France | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+#### Asia Pacific
+
+| Region ID        | Location             | Redis Cloud Pro | Redis Cloud Essentials |
+|:-----------------|:---------------------|:----------------|:-----------------------|
+| `ap-east-1`      | Hong Kong, China     | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-northeast-1` | Tokyo, Japan         | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-northeast-2` | Seoul, South Korea   | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-northeast-3` | Osaka, Japan         | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `ap-south-1`     | Mumbai, India        | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-south-2`     | Hyderabad, India     | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `ap-southeast-1` | Singapore            | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-southeast-2` | Sydney, Australia    | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `ap-southeast-3` | Jakarta, Indonesia   | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `ap-southeast-4` | Melbourne, Australia | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `ap-southeast-5` | Malaysia | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `ap-southeast-7` | Thailand | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+
+#### Middle East and Africa
+
+| Region ID      | Location                | Redis Cloud Pro | Redis Cloud Essentials |
+|:---------------|:------------------------|:----------------|:-----------------------|
+| `af-south-1`   | Cape Town, South Africa | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `il-central-1` | Tel Aviv, Israel        | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `me-central-1` | UAE                     | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `me-south-1`   | Bahrain                 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+## Google Cloud
+
+Redis Cloud supports databases in the following Google Cloud regions. 
+
+Redis Cloud Pro databases on Google Cloud support [VPC Peering]({{< relref "/operate/rc/security/vpc-peering#gcp-vpc-peering" >}}) and [Private Service Connect]({{< relref "/operate/rc/security/private-service-connect" >}}).
+
+#### Americas
+
+| Region ID                 | Location            | Redis Cloud Pro | Redis Cloud Essentials |
+|:--------------------------|:--------------------|:----------------|:-----------------------|
+| `northamerica-northeast1` | Montreal, Canada    | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `northamerica-northeast2` | Toronto, Canada     | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `southamerica-east1`      | Sao Paulo, Brazil   | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `southamerica-west1`      | Santiago, Chile     | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `us-central1`             | Iowa, USA           | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-east1`                | South Carolina, USA | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-east4`                | Virginia, USA       | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-east5`                | Columbus, USA       | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `us-south1`               | Dallas, USA         | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `us-west1`                | Oregon, USA         | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `us-west2`                | Los Angeles, USA    | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `us-west3`                | Salt Lake City, USA | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `us-west4`                | Las Vegas, USA      | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+
+#### Europe
+
+| Region ID           | Location            | Redis Cloud Pro | Redis Cloud Essentials |
+|:--------------------|:--------------------|:----------------|:-----------------------|
+| `europe-central2`   | Warsaw, Poland      | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-north1`     | Finland             | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-southwest1` | Madrid, Spain       | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west1`      | Belgium             | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `europe-west2`      | London, UK          | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `europe-west3`      | Frankfurt, Germany  | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `europe-west4`      | Netherlands         | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west6`      | Zurich, Switzerland | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west8`      | Milan, Italy        | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west9`      | Paris, France       | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west10`     | Berlin, Germany     | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `europe-west12`     | Turin, Italy        | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+
+#### Asia Pacific
+
+| Region ID              | Location             | Redis Cloud Pro | Redis Cloud Essentials |
+|:-----------------------|:---------------------|:----------------|:-----------------------|
+| `asia-east1`           | Taiwan               | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-east2`           | Hong Kong, China     | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-northeast1`      | Tokyo, Japan         | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `asia-northeast2`      | Osaka, Japan         | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-northeast3`      | Seoul, South Korea   | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-south1`          | Mumbai, India        | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `asia-south2`          | Delhi, India         | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-southeast1`      | Singapore            | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `asia-southeast2`      | Jakarta, Indonesia   | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `australia-southeast1` | Sydney, Australia    | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| `australia-southeast2` | Melbourne, Australia | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+
+#### Middle East and Africa
+
+| Region ID       | Location                   | Redis Cloud Pro | Redis Cloud Essentials |
+|:----------------|:---------------------------|:----------------|:-----------------------|
+| `africa-south1` | Johannesburg, South Africa | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `me-central1`   | Doha, Qatar                | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `me-central2`   | Dammam, Saudi Arabia       | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+| `me-west1`      | Tel Aviv, Israel           | <span title="Supported">&#x2705;</span> | <span title="Not supported">&#x274c;</span> |
+
+## Microsoft Azure
+
+Redis Cloud Essentials is available on the following Microsoft Azure regions:
+
+| Region ID | Location        |
+|:----------|:----------------|
+| `east-us` | Virginia, USA   |
+| `west-us` | California, USA |
+
+{{< note >}}
+Redis Cloud Pro is available on Azure through Azure Cache for Redis Enterprise. See [Azure Cache for Redis pricing](https://azure.microsoft.com/en-us/pricing/details/cache/) to view the list of Azure regions that support Azure Cache for Redis Enterprise.
+{{< /note >}}
+
+
+---
+Title: Data eviction
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Data eviction policies control what happens when new data exceeds the
+  memory limits of a database.  Here, you'll learn the available policies and how
+  to change which one is used for a database.
+linkTitle: Data eviction
+weight: $weight
+aliases: 
+  - /operate/rc/concepts/data-eviction-policies
+---
+
+The data eviction policy of a database controls what happens when new data exceeds the memory size of a database.  Typically, such situations require _evicting_ (or deleting) data previously added to the database.  
+
+You can [edit database details]({{< relref "/operate/rc/databases/view-edit-database.md" >}}) to change the **Data eviction policy** setting at the database level.
+
+## Available policies
+
+For each database, you can choose from these data eviction policies:
+
+| **Available&nbsp;policies** | **Description** |
+|:------------|:-----------------|
+| 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 (*Default*) |
+| 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 keys with expire field set to true and the shortest remaining time-to-live (TTL) value |
+| no eviction | New values aren't saved when memory limit is reached<br/><br/>When a database uses replication, this applies to the primary database |
+
+## Prevent data eviction
+
+Redis Cloud supports [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) 
+to prevent data eviction but maintain high performance.
+
+Auto Tiering can extend your database across RAM and Flash Memory and intelligently manage "hot" (active) data in RAM and "cold" (less active) data in Flash memory (SSD).
+---
+Title: Data persistence
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Data persistence enables recovery in the event of memory loss or other
+  catastrophic failure.  Here, you learn data persistence options, when they're available,
+  and how to apply specific settings to individual databases.
+linkTitle: Data persistence
+weight: $weight
+aliases: 
+  - /operate/rc/concepts/data-persistence
+---
+Redis Cloud can persist data to enable recovery in the event of memory loss or other catastrophic failure.  When you enable data persistence, in-memory data is copied to persistent storage attached to the underlying cloud instance.
+
+## Persistence options
+
+Data can be persisted in one of two ways:
+
+- An _Append-Only File_ (AOF) maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure.
+
+    The AOF file records write operations made to the database; it can be updated every second or on every write (_Redis Cloud Pro plans only_).
+
+- Snapshots are copies of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time.
+
+
+AOF files provide greater protection (durability) than snapshots at the cost of resources and recovery time. 
+Although snapshot recovery is faster, the risk of data loss is higher, depending on the time between failure and the most recent snapshot.
+
+{{<warning>}}
+If you turn off data persistence, data is lost when the database goes down.
+{{</warning>}}
+
+## Configure data persistence 
+
+In Redis Cloud, data persistence is a database configuration setting that can be changed by [editing your database]({{< relref "/operate/rc/databases/view-edit-database.md" >}}) settings.
+
+The availability of the setting depends on your plan:
+
+- Free Redis Cloud Essentials plans do not support data persistence; the setting is disabled entirely.
+
+- Paid Redis Cloud Essentials plans support AOF every second and all snapshot options.
+
+- Redis Cloud Pro enables data persistence settings for every database.
+
+When enabled, you can change the **Data persistence** setting to one of the following values:
+
+| **Options** | **Description** |
+|------------|-----------------|
+|  None | Data is not persisted to disk at all. |
+|  Append Only File (AoF) every write | _(Redis Cloud Pro only)_ Every write is recorded (synchronized to disk using `fsync`) |
+|  Append Only File (AoF) every 1 second | Record is updated every second (synchronized to disk using `fsync`)|
+|  Snapshot every 1 hour | A snapshot of the database is created every hour |
+|  Snapshot every 6 hours | A snapshot of the database is created every 6 hours |
+|  Snapshot every 12 hours | A snapshot of the database is created every 12 hours |
+
+When you save changes to data persistence settings, the updates are applied in the background.  This means there is a brief delay while the new settings are applied.
+
+When replication is enabled for a database, persistence is performed against replicas (copies) to reduce performance impact on the primary (_master_) database. 
+
+---
+Title: Size a Redis Cloud database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes sizing considerations for your Redis Cloud database, including throughput and dataset size.
+linkTitle: Sizing
+weight: $weight
+---
+
+## Dataset size {#dataset-size}
+
+The dataset size of a database is a part of the full memory limit for the database. The memory limit represents the maximum amount of memory for the database, which includes data values, keys, module data, and overhead for specific features.  High availability features, such as replication and Active-Active,  increase memory consumption, so your dataset size and memory limit will be different.
+
+For Redis Cloud Essentials, the plan size refers to the full memory limit, not the dataset size. Both the total memory limit and dataset size are listed under **Database details** when you create an Essentials database.
+
+For Redis Cloud Pro, you define your dataset size when you create the database, and we calculate your total memory limit based on the features you choose. 
+
+Here are some general guidelines:
+
+- Memory limit represents an upper limit.  You cannot store more data than the memory limit.  Depending on your other selections, available memory for data may be less than expected.
+
+- [Replication]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) doubles memory consumption; that is, 512 MB of data requires at least 1 GB of memory limit when replication is enabled. This affects both Redis Cloud Pro and Redis Cloud Essentials. For example, if you subscribe to a 1 GB Essentials plan, Redis will allocate 512 MB for your dataset and the other 512 MB for replication.
+
+- [Active-Active]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}) also doubles memory consumption and the effect is cumulative with replication's impact. Since Active-Active requires replication to be turned on, the memory limit impact can be as large as four times (4x) the original data size.
+
+- [Advanced capabilities]({{< relref "/operate/rc/databases/configuration/advanced-capabilities" >}}) also consume memory. For search databases, consider index size when you size your database. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more info.
+
+Memory limits in Redis Cloud are subject to the same considerations as Redis Enterprise Software; to learn more, see [Database memory limits]({{< relref "/operate/rs/databases/memory-performance/memory-limit" >}}).
+
+## Throughput
+
+Throughput is the number of operations a database can handle over a certain period of time. For Redis Cloud databases, throughput is defined in operations per second (ops/sec).
+
+For a Redis Cloud Pro subscription, you define throughput for a database when you create it. For a Redis Cloud Essentials subscription, your maximum throughput depends on your plan. 
+
+We use this setting to guide the allocation of compute power and network bandwidth, ensuring your database can handle the expected workload. However, the throughput specified is not guaranteed - actual throughput may be higher or lower depending on your workload and database configuration.
+
+### Throughput factors and variability
+
+Some factors that can affect throughput include:
+- **Request size**: Smaller requests (under 3KB) consume less network bandwidth and may result in more operations per second than requested, while larger requests may result in fewer operations per second.
+- **Command complexity**: Simple commands, like `GET` and `SET`, are faster and require fewer resources, whereas more complex commands involve more processing time and can reduce throughput. See the [Command list]({{< relref "/commands" >}}) to see which commands are more complex than others.
+- **Replication**: Using [multi-zone replication]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) affects throughput as each write operation is executed asynchronously in each zone.
+- **Security**: Some security options, such as [transport layer security]({{< relref "/operate/rc/security/database-security/tls-ssl" >}}), may affect throughput.
+- **Number of client connections**: The number of client connections affects throughput. Increasing or decreasing the number of client connections can result in higher or lower throughput.
+
+### Optimize throughput
+
+Here are some things to keep in mind for optimizing throughput:
+- Optimize capacity planning and sizing of your Redis Cloud databases to meet your app performance requirements.
+- Benchmark your app to understand what latency expectations are required, and adjust throughput accordingly.
+- Test and monitor your app's performance and adjust the set ops/sec based on how if performs in real-world conditions.
+- If your average request size is larger than 3KB, consider setting your throughput higher than expected. 
+- Track the slow logs using the [`SLOWLOG` command]({{< relref "/commands/slowlog" >}}) or the **Slowlog** tab on the [database screen]({{< relref "/operate/rc/databases/view-edit-database" >}}).
+- Use [pipelining]({{< relref "/develop/use/pipelining" >}}) and [concurrent connections]({{< relref "/develop/reference/clients" >}}) effectively to optimize throughput and latency.
+- Search databases have their own throughput requirements. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more info.
+
+### Frequently asked questions
+
+**Can my workload exceed the configured throughput?**
+
+Yes, many workloads perform better than expected, especially with optimized configurations and ideal conditions.
+
+**Why is my application getting less throughput than what I set?**
+
+Factors like high connection counts, complex commands, large payloads, and network limitations can affect throughput. Test and adjust based on your application’s needs. 
+
+**How do I know the optimal throughput for my application?**
+
+Start with the expected ops/sec. Most of the time, it’s more than enough. For an average request size of less than 3KB, we suggest specifying lower ops/sec than expected to reduce costs. For request sizes higher than 3 KB, we suggest specifying higher ops/sec than your target. Benchmarking your application under production-like conditions will help you find the best configuration.
+
+**How does network bandwidth impact throughput?**
+
+Insufficient bandwidth can bottleneck performance, especially with large request sizes.
+
+**What is the expected latency for my application?**
+
+Latency expectations vary by use case. Some applications tolerate milliseconds, while others require sub-millisecond performance. Benchmark your application to understand its latency profile.---
+Title: Active-Active Redis
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Overview of the Active-Active feature for Redis Cloud.
+weight: 5
+---
+
+Active-Active databases store data across multiple regions and availability zones.  This improves scalability, performance, and availability, especially when compared to standalone databases.
+
+To create Active-Active databases, you need a Redis Cloud Pro subscription that enables Active-Active Redis and defines the regions for each copy of your databases. See [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}}) for instructions.
+
+Active-Active databases are distributed across multiple regions (geo-distribution).  This improves performance by reducing latency for nearby users and improves availability by protecting against data loss in case of network or resource failure.
+
+Active-Active databases allow read and write operations in each copy.  Each copy eventually reflects changes made in other copies ([eventual consistency]({{< relref "/glossary#eventual-consistency" >}})).  Conflict-free data types (CRDTs) synchronize read and write operations between copies.  CRDTs ensure consistency and resolve conflicts.
+
+When developing for Active-Active databases, you need to consider some important differences. See [Develop applications with Active-Active databases]({{< relref "/operate/rs/databases/active-active/develop/_index.md" >}}) for related information.
+
+    {{< note >}}
+Active-Active subscriptions on Redis Cloud are limited to a maximum of 10 regions and 10 databases.
+    {{< /note >}}
+
+## Active-Active geo-distributed replication highlights
+
+### Multi-zone
+
+Geo-distributed replication maintains copies of both primary and replica shards in multiple clusters. These clusters can be spread across multiple availability zones. Active-Active Redis uses zone awareness to spread your primary and replica shards across zones, which helps protect against data loss from regional outages.
+
+### Local latency with unique endpoints
+
+Applications can connect to a specific copy of an Active-Active database using its unique endpoint. For local latency, configure your application to use a database endpoint in the closest region.
+
+### Conflict resolution
+
+Active-Active databases use special data types called conflict-free data types (CRDT). These automatically resolve conflicts that occur when writes are made to different clusters at the same time.
+
+### Failover handling
+
+After a failure at the process, node, or zone level, Active-Active databases automatically promote replica shards to replace failed primaries, copy data to new replica shards, and migrate shards to new nodes as needed. This reduces downtime and makes the most of your computing resources, even in the event of a failure.  
+
+Active-Active also provides a failover opportunity in case an entire cluster fails. Applications should redirect traffic to another cluster in the Active-Active deployment if a connected cluster fails. After the original cluster recovers, applications can direct traffic back to the original cluster. Redirecting traffic to alternate clusters is not handled automatically by Active-Active, so you must add redirection logic to the application. However, data automatically syncs to a recovered cluster when it returns to a healthy state.---
+Title: Clustering Redis Databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Redis Cloud uses clustering to manage very large databases (25 GB and
+  larger).  Here, you'll learn how to manage clustering and how to use hashing policies
+  to control how data is managed.
+linkTitle: Clustering
+weight: $weight
+aliases:
+    - /operate/rc/concepts/clustering
+---
+For very large databases, Redis Cloud distributes database data to different cloud instances.  For example:
+
+- When data grows beyond the RAM resources of a single server.
+
+    Multiple shards should be used when data grows to 25 GB (50 GB for Auto Tiering) to create multiple shards.
+
+- The operations performed against the database are CPU intensive enough to degrade performance.
+
+    Clustering distributes operational load, whether to instances on the same server or across multiple servers.
+
+This distribution is called _clustering_ because it manages the way data is distributed throughout the cluster of nodes that support the database.
+
+## How data is distributed
+
+A Redis Cloud cluster is a set of managed Redis processes and cloud instances,
+with each process managing a subset of the database keyspace.
+Clustering uses multiple cores and resources of multiple instances to overcome scaling challenges.
+
+In a Redis Cloud cluster, the keyspace is partitioned into hash
+slots. At any given time a hash slot resides on and is managed by a single
+Redis server. 
+
+An instance that belongs to a cluster can manage multiple hash
+slots. This division of the key space, known as _sharding_, is achieved by
+hashing the key names, or parts of these (key hash tags), in order to
+obtain the hash slot in which a key should reside. Redis Cloud supports several [hashing policies](#manage-the-hashing-policy).
+
+Even when using multiple Redis processes, the use of a Redis
+Enterprise Cloud cluster is nearly transparent to the application that
+uses it. The cluster is accessible via a single endpoint that
+automatically routes all operations to the relevant shards, without the
+complexity of a cluster-aware Redis client. This allows applications to
+benefit from using the cluster without performing any code changes, even
+if they were not designed to use it beforehand.
+
+When creating or editing a Redis database on Redis Cloud, the
+system automatically calculates the number of shards needed based on
+the database memory limit and required throughput.
+
+<!--  DOC-439: Stubbing out for initial pass
+{{< note >}}
+For Redis Cloud Essentials, clustering is only available in the
+"Pay-As-You-Go" subscription.
+{{< image filename="/images/rc/clustering-subscription.png" >}}
+{{< /note >}}
+-->
+
+## Multi-key operations {#multikey-operations}
+
+Operations on multiple keys in a sharded Redis Cloud cluster
+are supported, with the following limitations:
+
+1. **Multi-key commands:** Redis offers several commands that accept
+    multiple keys as arguments. In a sharded setup, you can run multi-key commands
+    only if all the affected keys reside in the same slot (thus on the same shard).
+    This restriction applies to all mulit-key commands, including BITOP, BLPOP, BRPOP, BRPOPLPUSH, MSETNX,
+    RPOPLPUSH, SDIFF, SDIFFSTORE, SINTER, SINTERSTORE, SMOVE, SORT,
+    SUNION, XREAD, XREADGROUP, ZINTER, ZINTERSTORE, ZUNION, ZUNIONSTORE, ZDIFF, ZDIFFSTORE
+1. **Geo commands:** In GEORADIUS/GEORADIUSBYMEMBER/GEOSEARCHSTORE commands, the
+    STORE and STOREDIST options can only be used when all affected keys
+    reside in the same slot.
+1. **Transactions:** All operations within a WATCH/MULTI/EXEC block
+    should be performed on keys that are in the same slot.
+1. **Lua scripts:** All keys that are used by the script must reside in
+    the same slot and need to be provided as arguments to the
+    EVAL/EVALSHA commands (as per the Redis specification).
+1. **Renaming/Copy keys:** The use of the RENAME/RENAMENX/COPY commands is
+    allowed only when both the key's original name and its new name are
+    mapped to the same hash slot.
+1. **Variadic commands**: The use of (MGET, MSET, HMGET, HMSET, etc..)
+    and pipelining are supported with Redis Cloud cluster
+    like if it were a non-cluster DB.
+
+## Hashing policies and hash tags {#manage-the-hashing-policy}
+
+The hashing policy determines how data is distributed across multiple Redis processes of a database. It uses a hashing function to map keys to hash slots in these processes, ensuring an even distribution of data for optimal performance and scalability.
+
+The hashing function uses the entire key name to calculate the hash slot, unless the key name contains a **hash tag**, represented by a `{...}` pattern.
+
+If the key contains a `{...}` pattern, only the substring between `{` and `}` is hashed in order to obtain the hash slot.
+
+You can use the `{...}` pattern to direct related keys to the same hash slot, so that multi-key operations are supported on them. On the other hand, not using a hashtag in the key's name results in a (statistically) even distribution of keys across the keyspace's shards, which improves resource utilization. If your application does not perform multi-key operations, you don't need to construct key names with hashtags.
+
+Redis Cloud offers 3 hashing policies, which differ in how hash tags are processed. These hashing policies are not always available.
+
+For accounts created after March 31, 2025, Redis defaults to the [Redis hashing policy](#redis-hashing-policy) **when creating a new database**. For all other accounts, Redis defaults to the [standard hashing policy](#standard-hashing-policy). 
+
+### Redis hashing policy
+
+{{< note >}}
+This policy is available for selected accounts and will be rolled out gradually to other accounts in the future.
+{{< /note >}}
+
+The Redis hashing policy is identical to the [hashing policy used by Redis Open Source]({{< relref "/operate/oss_and_stack/reference/cluster-spec#hash-tags" >}}). This policy is recommended for most users and you should select it if any of the following conditions apply:
+- This is your first Redis Cloud account, and you are starting fresh.
+- You are migrating data from Redis Open Source or other Redis-managed platforms.
+- Your application does not use hashtags in database key names.
+- Your application uses binary data as key names.
+
+### Standard hashing policy
+
+The Standard hashing policy is mostly consistent with the Redis hashing policy, and will generate the same hash-slot calculation in the following cases:
+1. Keys with a single hashtag: a key's hashtag is any substring between '{' and '}' in the key's name. That means that when a key's name includes the pattern '{...}', the hashtag is used as input for the hashing function. For example, the following key names have the same hashtag and are mapped to the same slot: foo{bar}, {bar}baz & foo{bar}baz.
+1. Keys without a hashtag: when a key doesn't contain the '{...}' pattern, the entire key's name is used for hashing
+
+However, this policy is less recommended and you should select it only if any of the following conditions apply:
+- Your application uses empty hashtags to hash different keys to the same hashslot
+- Your application uses multiple curly brackets within a key’s name
+
+In some cases, the Standard hashing policy behaves differently from the Redis hashing policy:
+1. Using empty hashtags (“{}”): the Standard hashing policy does not ignore empty hashtags, so two keys that start with empty hashtags will be hashed to the same hashslot (while the Redis hashing policy would ignore them). 
+    For example: given 2 keys {}foo and {}bar, hashing would be:
+    - Standard hashing policy: to the same hash slot
+    - Redis hashing policy: to different hash slots
+2. Using multiple curly brackets: when a key’s name contains multiple curly brackets, the Standard hashing calculation might be different than the Redis hashing policy. 
+    For example: given 2 keys {foo}bar} and {foo}qux}:
+    - Standard hashing policy: substrings “foo}bar” and “foo}qux” will be used for the 1st and 2nd key respectively, hashed each key to a different hash-slot.
+    - Redis hashing policy: the substring “foo” will be used for both keys, hashing them to the same slot.
+
+### Custom hashing policy
+
+{{< note >}}
+The custom hashing policy is not available for accounts created after March 31, 2025.
+
+For all other accounts, this policy is not recommended and will be deprecated in the future. Select this option only if you are already using a custom hashing policy with your existing Redis Cloud databases.
+{{< /note >}}
+
+A Redis Cloud  cluster can be configured to use a custom hashing
+policy. A custom hashing policy is required when different keys need to
+be kept together on the same shard to allow multi-key operations. Redis
+Cloud's custom hashing policy is provided via a set of Perl
+Compatible Regular Expressions (PCRE) rules that describe the dataset's
+key name patterns.
+
+To configure a custom hashing policy, enter regular expression (RegEx)
+rules that identify the substring in the key's name - hashtag - on
+which hashing will be done. The hashing tag is denoted in the RegEx by
+the use of the \`tag\` named subpattern. Different keys that have the
+same hashtag will be stored and managed in the same slot.
+
+Once you enable the custom hashing policy, the Redis Cloud's
+default RegEx rules that implement the standard hashing policy are:
+
+| RegEx Rule | Description |
+|-----------|-----------------|
+| .\*{(?\<tag\>.\*)}.\* | Hashing is done on the substring between the curly braces. |
+| (?\<tag\>.\*) | The entire key's name is used for hashing. |
+
+You can modify existing rules, add new ones, delete rules, or change
+their order to suit your application's requirements.
+
+{{< warning >}}
+If the Custom hashing policy is available, you can change the hashing policy between Standard and Custom after you create your database. However, hashing policy changes delete existing data 
+(using [`FLUSHDB`]({{< relref "/commands/flushdb" >}})) before they're applied. 
+
+These changes include:
+
+1. Changing the hashing policy, either from standard to custom or vice versa.
+1. Changing the order of custom hashing policy rules.
+1. Adding rules before existing ones in the custom hashing policy.
+1. Deleting rules from the custom hashing policy.
+1. Disabling clustering for the database.
+{{< /warning >}}
+
+### Custom hashing policy notes and limitations
+
+1. You can define up to 32 RegEx rules, each up to 256 characters.
+1. RegEx rules are evaluated by their order.
+1. The first rule matched is used; strive to place common key name
+    patterns at the beginning of the rule list.
+1. Key names that do not match any of the RegEx rules trigger an
+    error.
+1. The '.\*(?\<tag\>)' RegEx rule forces keys into a single slot as the
+    hash key is always empty. When used, this should be the last
+    catch-all rule.
+1. The following flag is enabled in our regular expression parser:
+   - **PCRE_ANCHORED:** the pattern is constrained to match only at
+        the start of the string which is being searched.
+
+## Cluster API {#oss-cluster-api}
+
+{{< embed-md "oss-cluster-api-intro.md"  >}}
+
+The Cluster API is only supported on Redis Cloud Pro databases. You can enable it in the Performance section of the configuration screen.
+
+After you select OSS Cluster API, you can select **Use external endpoint** if you want to use the external endpoint for the database. Selecting **Use external endpoint** will block the private endpoint for this database.
+
+The Redis Cluster API is supported only when a database uses the [standard hashing policy](#standard-hashing-policy) and does not use Search and Query or Time Series advanced capabilities.
+
+Review [Redis Cluster API architecture]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api" >}}) to determine if you should enable this feature for your database.---
+Title: Advanced capabilities
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes Redis Cloud Advanced capability options.
+headerRange: '[1-3]'
+toc: 'true'
+weight: $weight
+---
+
+Advanced capabilities extend Redis database functionality by adding new features and data types.  
+
+Available options depend on your database plan and **Type**.
+
+## Redis Cloud Essentials {#essentials}
+
+All Redis Cloud Essentials databases support [Redis Stack]({{< relref "/operate/oss_and_stack/" >}}), which enables the most frequently used capabilities.
+
+{{<image filename="images/rc/new-database-general-type-free-stack.png" alt="For Essentials, the Type setting in the General section includes an option for Redis Stack." width="300px">}}
+
+When the database **Type** is set to _Redis Stack_, the Advanced capabilities section of the database details page displays the advanced capabilities included with the database and their versions.
+
+{{<image filename="images/rc/database-details-modules-stack-free.png" alt="For Essentials, the Database details page lists the capabilities and versions added by Redis Stack." width="75%">}}
+
+Redis Cloud is updated on a regular basis, which includes the advanced capabilities supported by the service. Versions displayed by the Redis Cloud console may vary from those shown above.  For the latest details of any capability, see [Redis Stack and Redis Enterprise]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}). 
+
+## Redis Cloud Pro {#pro}
+
+By default, Redis Cloud Pro databases load all supported advanced capabilities. You can choose to load specific capabilities when you create your database. To choose which capabilities to load for your Pro database, [create it with custom settings]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) and select **More options** in the **Sizing tab** to view advanced capability settings.
+
+{{<image filename="images/rc/database-details-redis-module-select-flexible.png" alt="For Pro databases, you can select the capabilities included in your database." width="75%">}}
+
+You can select more than one advanced capability for a database, though there are limits:
+
+- The following advanced capabilities can be combined in Pro databases:
+
+    - Search and query
+    - JSON
+    - Time series
+    - Probabilistic
+
+- [Active-Active databases]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}}) only support JSON and Search and query.
+
+To remove a selected capability, clear its checkbox.
+
+To learn more, see [Redis Stack]({{< relref "/develop/get-started/" >}}) and [Redis Stack and Redis Enterprise]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}).
+
+### Search and query sizing
+
+When you create a Pro database with [Search and Query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}), you must consider the sizing and throughput requirements for search and query when you define the dataset size and throughput for your database. 
+
+Use the [Search and query sizing calculator](https://redis.io/redisearch-sizing-calculator/) to estimate your index size and throughput requirements.
+
+- **Dataset Size**: Add the estimated index size from the Sizing calculator to your expected dataset size.
+- **Throughput**: Enter the total estimated throughput from the Sizing calculator when you enter your throughput.
+- **Query performance factor**: The query performance factor adds extra power specifically for search and query. Select a factor to increase your queries per second by that amount.
+
+#### Query performance factor
+
+The query performance factor adds extra compute power specifically for search and query. When you create a Pro database with search and query, you can increase your search queries per second by the selected factor.
+
+{{<image filename="images/rc/database-details-query-performance-factor-pro.png" alt="For Pro databases, you can select the query performance factor for your database." width="75%">}}
+
+We recommend testing your application with a test database to see your baseline queries per second and determine how much you want to boost your query performance. After you have determined your queries per second and your desired performance factor, [create a new database]({{< relref "/operate/rc/databases/create-database" >}}) with the desired performance factor and [migrate data]({{< relref "/operate/rc/databases/migrate-databases" >}}) from the test database to your new database.
+
+For more info on how to use scalable search, see [Best practices for scalable Redis Query Engine]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/scalable-query-best-practices" >}}).
+
+The query performance factor is available for Redis Cloud Pro databases on Redis 7.2 and later.---
+Title: Configure databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Provides background information to help you configure Redis Cloud databases
+  to best fit your needs.
+hideListLinks: false
+linkTitle: Configure
+weight: 50
+---
+
+Here, you'll find background info and conceptual details to help you customize your Redis Cloud databases to meet your needs.
+
+
+---
+Title: High availability and replication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes database replication and high availability as it affects Redis
+  Cloud.
+linkTitle: High availability
+weight: $weight
+aliases: 
+  - /operate/rc/databases/high-availability
+---
+
+Database replication helps ensure high availability. 
+
+When replication is enabled, your dataset is duplicated to create a replica that is synchronized with the primary dataset.  
+
+Replication allows for automatic failover and greater fault tolerance.  It can prevent data loss in the event of a hardware or zone failure. 
+
+## Options and plan support
+
+Redis Cloud supports three levels of replication:
+
+- _No replication_ means that you will have a single copy of your database.
+
+- _Single-zone replication_ means that your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.
+
+- _Multi-zone replication_ means that the primary and its replicas are stored in different zones. This means that your database can remain online even if an entire zone becomes unavailable.
+
+Your replication options depend on your [subscription plan]({{< relref "/operate/rc/subscriptions/_index.md" >}}):
+
+- Free Redis Cloud Essentials plans do not support replication.
+- Paid Redis Cloud Essentials plans and Redis Cloud Pro plans let you choose between multi-zone or single-zone replication when creating a subscription. You can also turn off replication.
+
+Whether or not you can change your replication settings after database creation depends on your plan type and what type of replication you originally selected.
+
+- For Redis Cloud Essentials, you select the kind of replication when you create your database. If you selected Multi-zone replication when you created your database, you can't change it to Single-zone or turn it off after database creation. However, if you selected No Replication or Single-zone replication, you can switch between the two at any time by [editing your Essentials subscription]({{< relref "/operate/rc/subscriptions/view-essentials-subscription#change-high-availability-and-persistence" >}}). 
+- For Redis Cloud Pro, you select whether you want a multi-zone deployment during subscription creation. You can't change this setting or any [Zone settings]({{< relref "/operate/rc/databases/configuration/high-availability#zone-setting-maintenance" >}}) after subscription creation. However, you can activate or deactivate replication for each database within the subscription at any time by [editing your database]({{< relref "/operate/rc/databases/view-edit-database" >}}).
+
+## Performance impact 
+
+Replication can affect performance as traffic increases to synchronize all copies. 
+
+## Dataset size
+
+For both Redis Cloud Essentials and Redis Cloud Pro, replication requires a memory limit that is double the dataset size of your database.
+
+For Redis Cloud Essentials, the size of the plan you choose includes replication. Therefore, if you choose replication, the dataset size you can use is half of the stated plan size. For example, if you choose a 1 GB plan, Redis allocates 512 MB for the dataset size, and the other 512 MB for replication.
+
+For Redis Cloud Pro, you select your dataset size when you create your database, and we calculate your memory limit based on the replication settings you choose.
+
+## Zone setting maintenance
+
+Zone settings can only be defined when a subscription is created.  You cannot change these settings once the subscription becomes active.
+
+This means you can't convert a multi-zone subscription to a single zone (or vice-versa).  
+
+To use different zone settings, create a new subscription with the preferred settings and then [migrate data]({{< relref "/operate/rc/databases/migrate-databases.md" >}}) from the original subscription.
+
+## Availability zones
+
+You can reduce network transfer costs and network latency by ensuring your Redis Cloud Pro cluster and your application are located in the same availability zone. 
+
+To specify the availability zone(s) for your cluster, [create your Pro database with custom settings]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}), and select *Manual Selection* under **Allowed Availability Zones** in **Advanced options**.
+
+For Google Cloud clusters and [Redis Cloud BYOC]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/" >}}), select an availability zone from the **Zone name** list.
+
+{{<image filename="images/rc/availability-zones-no-multi-az.png" width="95%" alt="Select one availability zone when Multi-AZ is turned off." >}}
+
+For all other AWS clusters, select an availability zone ID from the **Zone IDs** list. For more information on how to find an availability zone ID, see the [AWS docs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones).
+
+{{<image filename="images/rc/availability-zones-aws-hosted-no-multi-az.png" width="80%" alt="For hosted AWS clusters, select availability zone IDs from the Zone IDs list." >}}
+
+If **Multi-AZ** is enabled, you must select three availability zones from the list.
+
+{{<image filename="images/rc/availability-zones-multi-az.png" width="80%" alt="Select Manual selection to select three availability zones when Multi-AZ is enabled." >}}
+
+For more information on availability zones, see the [Google Cloud docs](https://cloud.google.com/compute/docs/regions-zones/#available) or the [AWS docs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones).
+
+## More info
+
+To learn more about high availability and replication, see:
+- [Highly Available Redis](https://redislabs.com/redis-enterprise/technology/highly-available-redis/)
+- [Database replication]({{< relref "/operate/rs/databases/durability-ha/replication.md" >}})
+---
+Title: Monitor database performance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Monitor performance
+weight: 35
+---
+
+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.
+
+{{<image filename="images/rc/database-metrics-tab.png" width="75%" alt="The Metrics tab of the View Database screen." >}}
+
+Performance data provides insight into how your database is being used and how well it is performing.
+
+The interval scrollbar controls the time period displayed in the graphs.  
+
+{{<image filename="images/rc/database-metrics-interval-scrollbar.png" width="75%" alt="The Metrics tab of the View Database screen." >}}
+
+## Promote metric graphs
+
+The **Metrics** screen shows two primary graphs and a collection of smaller ones.  You can promote any smaller graph to a primary position.
+
+When you use the mouse to point to a smaller graph, three things appear:
+
+- A promotion icon pointing left
+- A promotion icon pointing right
+- A summary panel showing the minimum, average, maximum, and most recent values displayed in the graph.
+
+{{<image filename="images/rc/metrics-promote-graphs.png" width="300px" alt="Promoting graphs to primary positions" >}}
+
+Use the promotion icons to promote the smaller graph to one of the primary positions. The left icon promotes the smaller graph to the left position and the right icon promotes the smaller graph to the right position.
+
+## Metric definitions
+
+Several metric graphs are available:
+
+| **Metric** | **Description** |
+|------------|-----------------|
+| [Ops/sec]({{< relref "/operate/rs/references/metrics/database-operations#opssec" >}}) | The number of overall operations per sec for all Redis commands |
+| [Reads/sec]({{< relref "/operate/rs/references/metrics/database-operations#readssec" >}}) | The number of read operations per second |
+| [Writes/sec]({{< relref "/operate/rs/references/metrics/database-operations#writessec" >}}) | The number of write operations per second |
+| [Other cmds/sec]({{< relref "/operate/rs/references/metrics/database-operations#other-commandssec" >}}) | The number of other Redis commands per second |
+| [Latency]({{< relref "/operate/rs/references/metrics/database-operations#latency" >}}) | Latency per operation, in milliseconds |
+| [Reads latency]({{< relref "/operate/rs/references/metrics/database-operations#reads-latency" >}}) | Latency per read operation, in milliseconds |
+| [Writes latency]({{< relref "/operate/rs/references/metrics/database-operations#writes-latency" >}}) | Latency per write operation, in milliseconds |
+| [Other latency]({{< relref "/operate/rs/references/metrics/database-operations#other-commands-latency" >}}) | Latency of other commands, in milliseconds |
+| [Used memory]({{< relref "/operate/rs/references/metrics/resource-usage#used-memory" >}}) | Amount of memory used by the database |
+| [Total keys]({{< relref "/operate/rs/references/metrics/database-operations#total-keys" >}}) | Total number of keys in the database |
+| [Connections]({{< relref "/operate/rs/references/metrics/resource-usage#connections" >}}) | Total number of connections to the endpoint |
+| [Evicted objects/sec]({{< relref "/operate/rs/references/metrics/database-operations#evicted-objectssec" >}}) | Number of objects evicted from the database per second. |
+| [Expired objects/sec]({{< relref "/operate/rs/references/metrics/database-operations#expired-objectssec" >}}) | Number of expired objects per second. An expired object is an object with expired TTL that was deleted from the database. |
+| [Hit ratio]({{< relref "/operate/rs/references/metrics/database-operations#hit-ratio" >}}) | Percent of operations on existing keys out of the total number database operations |
+| Network Ingress bytes/sec | Amount of traffic in bytes per second entering the database network |
+| Network Egress bytes/sec | Amount of traffic in bytes per second exiting the database network |
+
+For more detailed analysis, consider using [Redis Insight]({{< relref "/develop/tools/insight" >}}) or [Prometheus and Grafana]({{< relref "/integrate/prometheus-with-redis-cloud/" >}}).
+
+## Configure alerts {#configure-metric-alerts}
+
+Depending on your subscription plan, you can enable alerts for several metrics for a given database.
+
+To do so, go to the **Configuration** tab of the database and then locate the **Alerts** section. 
+
+| Setting name | Description | Default Value | Accepted Range |
+|---|---|---|---|
+| **Dataset size has reached** | Sends an alert when the dataset size reaches or exceeds the defined percentage of the memory limit. (_Pro only_) | 80% | 1-100% |
+| **Total size of datasets under this plan reached** | Sends an alert when the total size of all datasets in the plan reaches or exceeds the defined percentage of the plan limit. (_Essentials only_) | 80% | 1-100% |
+| **Throughput is higher than** | Sends an alert when throughput is over the defined limit in operations per second (ops/sec). (_Paid Essentials or Pro only_) | 1000 ops/sec | 1-10000000 ops/sec |
+| **Throughput is lower than** | Sends an alert when throughput is under the defined limit in operations per second (ops/sec). (_Paid Essentials or Pro only_) | 10 ops/sec | 1-10000000 ops/sec |
+| **Latency is higher than** | Sends an alert when the latency is over the defined limit in milliseconds (msec). (_Paid Essentials or Pro only_) | 10 msec | 1-10000 msec |
+| **Number of connections** | Sends an alert when the number of connections exceeds the defined percentage of the plan limit.  (_Essentials only_) | 80% | 1-100% |
+| **Replica Of - database unable to sync with source** | Sends an alert when the target database cannot sync with the source database after the defined number of seconds. (_Pro only_) | 1 second | 0-1 seconds |
+| **Replica Of - sync lag is higher than** | Sends an alert if lag between the source and target databases exceeds the defined number of seconds. (_Pro only_) | 600 seconds | 1-86400 seconds |
+
+Alert settings are specific to each database. Make sure you've configured alerts for all desired databases.
+
+## Change alert recipients
+
+Any member of the account team can receive alert emails.
+
+To update alert settings for one or more team members, select **Access Management** from the Redis Cloud console menu and then select the **Team** tab. For details, see [Access management]({{< relref "/operate/rc/security/access-control/access-management" >}}).
+
+If you subscribe to Redis Cloud through a Platform-as-a-Service (PaaS) provider (such as Heroku), you will need to review your provider's documentation for help managing your team.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Upgrade Redis database version
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes when you can upgrade your database to the latest available version for each plan type.
+linkTitle: Upgrade database version
+weight: 37
+---
+
+Database version upgrade options depend on your plan type.
+
+## Redis Cloud Essentials
+
+All new Redis Cloud Essentials databases are on the latest available version of Redis. Redis will notify Redis Cloud Essentials users when a new database version is available. 
+
+## Redis Cloud Pro
+
+You can upgrade Redis Cloud Pro 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]({{< relref "/operate/rc/databases/back-up-data" >}}) before upgrading to make it easier to [manually revert the upgrade](#manually-revert-upgrade) if needed.
+
+- We recommend that you upgrade your database during off-peak hours or during application maintenance to minimize reconnections.
+
+- Review the breaking changes for the new database version before upgrading: 
+    - [Redis 7.2]({{< relref "/operate/rc/changelog/2023/june-2023#redis-72-breaking-changes" >}}) 
+    - [Redis 7.4]({{< relref "/operate/rc/changelog/july-2024#redis-74-breaking-changes" >}}) 
+
+- You must upgrade the target database in an [Active-Passive]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}) setup before you upgrade the source database to prevent compatibility issues.
+{{< /note >}}
+
+### Upgrade Redis Cloud Pro database
+
+To upgrade a Redis Cloud Pro database: 
+
+1. Choose your database from the **Databases** list to open your database page. Select **More actions > Version upgrade**.
+
+    {{<image filename="images/rc/databases-more-actions-menu.png" alt="The More Actions menu on the Database page." width=40% >}}
+    
+    You can also select **More actions > Version upgrade** from the database list.
+
+1. Select the target version from the **Select version** list.
+
+    {{<image filename="images/rc/database-version-upgrade.png" alt="The Redis version upgrade screen." width=80% >}}
+
+    If your database has not been backed up before, we recommend that you back up your database. Select **Go to backup** to go to the [backup settings]({{< relref "/operate/rc/databases/back-up-data" >}}).
+
+1. Select **Upgrade** to start the upgrade.
+
+    {{<image filename="images/rc/button-upgrade.png" alt="The upgrade button." width=100px >}}
+
+The database will start upgrading to the selected version immediately. The upgrade may take a few minutes. 
+
+You can continue to use the Redis Cloud console for other tasks during the upgrade.
+
+### Manually revert upgrade
+
+Automatically reverting to a previous Redis version is not supported on Redis Cloud.
+
+If you [backed up your database]({{< relref "/operate/rc/databases/back-up-data" >}}) before you upgraded your version, you can:
+
+1. [Delete your database]({{< relref "/operate/rc/databases/delete-database" >}}) without deleting your subscription.
+1. [Create a new database]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}) in your subscription with the following settings:
+    - **Port number**: Use the same port number as the old database.
+    - **Version**: Select the original version of Redis.
+1. [Import the backup files]({{< relref "/operate/rc/databases/import-data" >}}) into the new database.
+
+This allows you to connect to the database on the previous version without changing your connection details in your application.
+
+If you did not back up your database before upgrading:
+
+1. [Back up your database]({{< relref "/operate/rc/databases/back-up-data" >}}).
+1. [Create a new database]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}) in your subscription and select the original version of Redis.
+1. [Import the backup files]({{< relref "/operate/rc/databases/import-data" >}}) into the new database.
+1. Change connection details in your application from the old database to the new database.---
+Title: Delete database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linkTitle: Delete database
+weight: 45
+---
+
+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]({{< relref "/operate/rc/databases/back-up-data.md" >}}), just in case.
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io/).
+
+1.  Select the database from the list.  The **Configuration** tab is selected by default.
+
+    {{<image filename="images/rc/database-details-configuration-tab-general-flexible.png" alt="The Configuration tab of the Database details screen." >}}
+
+1.  Scroll to the **Danger zone**.
+
+    {{<image filename="images/rc/database-details-configuration-tab-danger-flexible.png" width="75%" alt="The Danger Zone of the Database details screen." >}}
+
+1.  Select the **Delete** button.
+
+    {{<image filename="images/rc/button-danger-zone-delete.png" alt="The Delete button is located in the Danger zone section of the database Configuration tab." >}}
+
+1. The **Delete database** confirmation dialog appears. If this database is the only one in the subscription, you can also delete the subscription at this time.
+    
+    - Select **Delete my subscription and stop my payment** to delete both the database and the subscription.
+    
+    - Clear **Delete my subscription and stop my payment** to delete the database but keep the subscription.
+
+    {{< note >}}
+You will continue to be charged for your subscription until you delete it, even if there are no databases in your subscription.
+    {{< /note >}}
+
+    {{<image filename="images/rc/database-delete-last-dialog.png" alt="A delete database confirmation dialog asks you to consider deleting the subscription as well.">}}
+
+1. Select **Delete database** to confirm your choice.
+
+    {{<image filename="images/rc/button-database-delete.png" alt="The Delete database button is located in the Danger zone section of the database Configuration tab." >}}
+
+
+When the operation completes, the database and its data are deleted.
+---
+Title: View and edit databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linkTitle: Edit and view
+weight: 15
+---
+
+Use the **Databases** menu of the Redis Cloud console to manage your databases.
+
+To view the details of a database:
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io/).  (Create an account if you don't already have one.)
+
+2. Select the **Databases** menu to display a [searchable list of all databases](#manage-the-database-list).
+ 
+3. Locate the database in the list.
+
+4. Select the database name to open the **Database** page.
+
+    {{<image filename="images/rc/database-details-configuration-tab-general-flexible.png" alt="The Configuration tab of the Database details screen." >}}
+
+The **Database** screen lets you review:
+- Configuration details of a database
+- Graphs showing performance metrics
+- Recent activity via a "[slowlog]({{< relref "/commands/slowlog" >}})," which lists queries that exceed a certain execution time.
+
+For help changing database settings, see [Edit database details](#edit-database-details).
+
+## Configuration tab
+
+The **Configuration** screen is divided into sections, each dedicated to a specific category.  Note that not every section or setting is available to every [subscription plan]({{< relref "/operate/rc/subscriptions/" >}}).
+
+### General settings
+
+The **General** section defines basic properties about your database.
+
+The available settings vary according to your plan, cloud provider, and design choices.  For example, if you do not select an Advanced Capability when creating a database, the **Advanced Capabilities** setting is not displayed when you view its configuration details.
+
+| Setting name              | Description                                                                                                                                                 |
+|:--------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Database Name**         | The name given to your database                                                                                                                             |
+| **Subscription Name**     | The name for the subscription your database is a part of                                                                                                    |
+| **Public endpoint**       | Public URI used by any application or client to access the database.                                                                                        |
+| **Private endpoint**      | Private endpoint URI available to approved clients; use CIDR allow list, VPC peering, or other connectivity options to enable access. (_Redis Cloud Pro only_) |
+| **Tags**                  | A list of the [tags]({{< relref "/operate/rc/databases/tag-database" >}}) associated with the database. Select [Manage tags]({{< relref "/operate/rc/databases/tag-database#configuration-tab" >}}) to manage the database tags. |
+| **Vendor**                | The Cloud vendor hosting your database: AWS, Google Cloud, or Azure.                                                   |
+| **Region**                | The Cloud vendor region hosting your database                                                  |
+| **Type**                  | Displays 'Redis', 'Redis Stack' or 'memcached' based on the value selected when the database was created                                                    |
+| **Redis version**         | Redis version of the database                                                                                                                  |
+| **Auto Tiering**          | Checked when the subscription supports Auto Tiering (_Redis Cloud Pro only_)                                                               |
+| **Active-Active Redis**   | Checked when the database is part of an [Active-Active]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}) relationship (_Redis Cloud Pro only_)                                                                                         |
+| **Creation time**         | Date and time the database was created                                                                                                                      |
+| **Last changed**          | Date and time of last update                                                                                                                                |
+| **Supported Protocol(s)** | Shows which version of RESP the database uses. See [Redis serialization protocol]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions) for details |
+| **Advanced Capabilites**  | This setting appears when an [advanced capability]({{< relref "/operate/rc/databases/configuration/advanced-capabilities" >}}) is enabled for a database                                                  |
+
+### Performance section
+
+The **Performance** section describes the memory size, throughput, and hashing policy for a database.
+
+{{<image filename="images/rc/database-details-configuration-tab-scalability-flexible.png" alt="Use the Performance section to control the size, throughput, and hashing policy for a database." >}}
+
+| Setting name          |Description|
+|:----------------------|:----------|
+| **Dataset size** | Maximum size (in GB) for your dataset. See [Dataset size]({{< relref "/operate/rc/databases/configuration/sizing#dataset-size" >}}).  |
+| **Throughput**        | Defines [throughput]({{< relref "/operate/rc/databases/configuration/sizing#throughput" >}}) in terms of maximum operations per second for the database (_Redis Cloud Pro only_). |
+| **Memory used**       | Memory currently used for your database.  |
+| **High availability**    | Replicates your data across multiple nodes; [available options]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) depend on your plan type  |
+| **Hashing policy**    | Defines the [hashing policy]({{< relref "/operate/rc/databases/configuration/clustering#manage-the-hashing-policy" >}}) (_Redis Cloud Pro only_).  |
+| **OSS Cluster API**       | Enables the [Cluster API]({{< relref "/operate/rc/databases/configuration/clustering#oss-cluster-api" >}}) for a database (_Redis Cloud Pro only_).<br/><br/>When this option is enabled, you cannot define a custom hashing policy.|
+
+To learn more about these settings and when to use them, see [Sizing]({{< relref "/operate/rc/databases/configuration/sizing" >}}) and [Database clustering]({{< relref "/operate/rc/databases/configuration/clustering" >}}).
+
+### Durability section
+
+The Durability section helps protect your data when problems occur.  These settings define replication, persistence, backup, and eviction policies.
+
+{{<image filename="images/rc/database-details-configuration-tab-durability-flexible.png" alt="Use the Durability  section to protect your data from unexpected problems." >}}
+
+| Setting name             | Description                                                                                                                                                     |
+|:-------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Data persistence**     | Defines whether (and how) data is saved to disk; [available options]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) depend on your plan type |
+| **Data eviction policy** | Configures which [policy]({{< relref "/operate/rc/databases/configuration/data-eviction-policies" >}}) is applied when your database reaches its memory limit        |
+| **Remote backup**        | When enabled, identifies a location and interval for [data backups]({{< relref "/operate/rc/databases/back-up-data" >}}). (_Paid plans only_)                |
+| **Active-Passive Redis** | When enabled, identifies a path to the [linked database]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}). (_Redis Cloud Pro only_)                                                               |
+
+### Security section
+
+The **Security** section helps you control access to your database.
+
+{{<image filename="images/rc/database-details-configuration-tab-security-flexible.png" alt="Use the Security settings to control access to your database." >}}
+
+
+|Setting name| Description                                                                                                                                                                    |
+|:-----------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Default user** | When enabled, permits access using a simple password                                                                                                                           |
+| **Default user password** | Password for default user. A default password is assigned to the database on creation and may be updated.                                                                      |
+| **CIDR allow list** | [Allow list]({{< relref "/operate/rc/security/cidr-whitelist.md" >}}) of IP addresses/security groups permitted to access the database. (_Paid plans only_)                    |
+| **Transport layer security (TLS)** | Enables [transport layer security]({{< relref "/operate/rc/security/database-security/tls-ssl.md" >}}) (TLS) encryption for database access. (_Pro plans only_)  |
+
+### Alerts section
+
+
+The **Alerts** section defines notification emails sent to your account and the conditions that trigger them.
+
+{{<image filename="images/rc/database-details-configuration-tab-alerts-flexible.png" alt="The Alerts section defines the notification emails and their triggering conditions." >}}
+
+The available alerts vary according to the plan type. See [Configure alerts]({{< relref "/operate/rc/databases/monitor-performance#configure-metric-alerts" >}}) for more information.
+
+### Danger zone
+
+Actions in the **Danger Zone** are permanent and should not be taken lightly.
+
+{{<image filename="images/rc/database-details-configuration-tab-danger-flexible.png" alt="The Danger Zone includes activities that impact data, such as deleting a database.  Use with care." >}}
+
+Here, you can:
+
+- Delete the database. Databases must be active before they can be deleted.  To learn more, see [Delete a database]({{< relref "/operate/rc/databases/delete-database.md" >}}).
+- Flush the database (_Active-Active databases only_).
+
+For best results, we recommend [backing up data]({{< relref "/operate/rc/databases/back-up-data" >}}) before any danger zone actions.
+
+## Manage the database list
+
+The **Databases** list summarizes the status of all databases associated with your account.  
+
+You can:
+
+- Search by typing into the search box located above the database list.
+
+    {{<image filename="images/rc/database-list-search.png" alt="Use the search bar to filter the list." >}}
+
+- Filter by selecting a filter type and then selecting the checkbox next to the options you want to include from the dropdown.  Select the Filter toggle, located on the right of the search bar, if the filter types are hidden.
+
+    {{<image filename="images/rc/database-list-filter.png" alt="Use the filter toggle to display filter options." >}}
+
+    You can filter the list on **Status**, **Subscription**, **Subscription Type**, **Capabilities**, **Options**, and **Tags**.  String matches are _not_ case-sensitive.  You can specify more than one filter expression at a time.  
+
+    A list of selected filters appears below the filter types.
+
+    To remove a filter click the **x** to the right of the name of that filter.  To remove all filters, select **Clear all**.
+
+    {{<image filename="images/rc/database-list-filter-selected.png" alt="Use the filter toggle to display filter options." >}}
+
+- Select **Columns** to change what information is displayed on the list.
+
+    {{<image filename="images/rc/database-list-columns.png" alt="Use the columns toggle to display column options." >}}
+
+- Select the **Export** button to export the current view as a CSV file.
+
+    {{<image filename="images/rc/icon-export-to-csv.png" alt="The Export button exports the current list view to CSV." >}}
+
+- Sort the list in descending or ascending order using the arrow displayed to right of the field name in the header.  Supported fields include **Subscription**, **Database name**, **Memory usage**, and **Version**.
+
+    {{<image filename="images/rc/icon-list-sort-asc.png#no-click" alt="Use the arrows in the list header to sort the list." class="inline">}} {{<image filename="images/rc/icon-list-sort-desc.png#no-click" alt="The direction of the arrow corresponds to the direction of the sort." class="inline">}}
+
+    Select the arrow icon to change the sort order.  One sort order can be active at any given time.
+
+- Use the controls in the list footer to change the number of items displayed in the list or to navigate.
+
+Sort orders and filter expressions are not saved between console sessions.
+
+## Other actions and info
+
+The **View Database** screen also has tabs that let you view:
+
+- **Metrics**: a series of graphs showing database performance over time.  See [Monitor performance]({{< relref "/operate/rc/databases/monitor-performance" >}}) for more information.
+
+- **Slowlog**: a log showing recent [slow queries]({{< relref "/commands/slowlog" >}}) run against your database.  The log displays when the action started, the duration, the complexity of the operation, and any parameters passed to the operation.
+
+
+## Edit database details
+
+Use the **Edit** button to edit database details.
+
+{{<image filename="images/rc/button-database-edit.png" alt="The Edit button lets you change selected database properties." width=100px >}}
+
+Because databases exist within the context of a deployment, certain fields cannot be updated, especially those that might lead to data loss.
+
+Here's what you can change:
+
+| Section | Setting                        | Comments |
+|:-----------|:-------------------------------|:---------|
+| General | Database name                  ||
+| | Supported protocol(s)                  ||
+| | Tags                                   ||
+| Performance | Dataset size                   | |
+| | High-availability                     | _Paid plans only_ |
+| | Throughput                     | _Pro plans only_ |
+| | Hashing policy                 | _Pro plans only_ |
+| | OSS Cluster API                | _Pro plans only_ |
+| Durability | Data persistence                | _Paid plans only_ |
+| | Data eviction policy           | |
+| | Remote backup                  | _Paid plans only_ |
+| | Active-Passive Redis           | _Pro plans only_ |
+| Security | Default user                   | |
+| | Default user password          |
+| | CIDR allow list                | _Paid plans only_ |
+| | Transport layer security (TLS) | _Pro plans only_ |
+| Alerts | all available for plan type |
+
+Choose **Save database** to save your changes.
+
+{{<image filename="images/rc/button-database-save.png" alt="Use the Save database button to save database changes." >}}
+
+If you need to change other details, create a new database and then migrate existing data.
+---
+Title: Back up and export a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Back up database and export 
+weight: 25
+aliases:
+    - /operate/rc/administration/configuration/backups
+---
+
+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.
+{{</note>}}
+
+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](#set-up-backup-storage-locations).
+
+Backups are saved in RDB format. If the database is comprised of multiple shards, an RDB file will be created for each shard of the database. For more information on restoring data from a backup, see [Restore from an RDB file]({{< relref "/operate/rc/databases/import-data#restore-from-an-rdb-file" >}}).
+
+Here, you'll learn how to store backups using different cloud providers.
+
+## Turn on backups
+
+To turn on database backups:
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io/). 
+
+1.  Select the database to open the **Database** page and then select **Edit**.
+
+    {{<image filename="images/rc/database-details-configuration-tab-general-flexible.png" alt="The Configuration tab of the Database details screen." >}}
+
+1.  In the **Durability** section of the **Configuration** tab, locate the **Remote backup** setting:
+
+    {{<image filename="images/rc/database-details-configuration-tab-durability-flexible.png" alt="The Remote backup setting is located in the Durability section of the Configuration tab of the database details screen." >}}
+
+When you enable **Remote backup**, additional options appear.  The options vary according to your subscription.
+
+{{<image filename="images/rc/database-details-configuration-durability-backup.png" alt="Backup settings appear when you enable the Remote backup settings." >}}
+
+|Setting name|Description|
+|:-----------|:----------|
+| **Interval** | Defines the frequency of automatic backups.  Paid Redis Cloud Essentials databases are backed up every 24 hours.  Redis Cloud Pro databases can be set to 24, 12, 6, 4, 2, or 1 hour backup intervals. |
+| **Set backup time** | When checked, this lets you set the hour of the **Backup time**. (_Redis Cloud Pro only_) |
+| **Backup time** | Defines the hour automatic backups are made.  Note that actual backup times will vary up in order to minimize customer access disruptions.  (_Redis Cloud Pro only_)<br/> Times are expressed in [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC).|
+| **Storage type** | Defines the provider of the storage location, which can be: `AWS S3`, `Google Cloud Storage`, `Azure Blob Storage`, or `FTP` (FTPS). |
+| **Backup destination** | Defines a URI representing the backup storage location. |
+
+## Back up and export data on demand
+
+After backups are turned on, you can back up your data at any time.  Use the **Backup now** button in the **Durability** section.
+
+{{<image filename="images/rc/button-database-backup-now.png" alt="Use the Backup Now button to make backups on demand." >}}
+
+You can only use the **Backup now** button after you turn on backups.
+
+## Set up backup storage locations
+
+Database backups can be stored to a cloud provider service or saved to a URI using FTP/FTPS.
+
+Your subscription needs the ability to view permissions and update objects in the storage location.  Specific details vary according to the provider.  To learn more, consult the provider's documentation.
+
+The following sections describe specific backup options. Be aware that provider features change frequently.  For best results, use your provider's documentation for the latest info.
+
+### AWS S3
+
+To store backups in an Amazon Web Services (AWS) Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html):
+
+1. In the [AWS Management Console](https://console.aws.amazon.com/), use the **Services** menu to locate and select **Storage** > **S3**.  This takes you to the Amazon S3 admin panel.
+
+1.  Use the **Buckets** list to locate and select your bucket.  When the settings appear, select the **Permissions** tab, locate the **Bucket policy** section, and then click **Edit**.
+
+    -  If there is no existing bucket policy, add the following JSON bucket policy. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.
+
+        ```json
+        {
+            "Version": "2012-10-17",
+            "Id": "MyBucketPolicy",
+            "Statement": [
+                {
+                    "Sid": "RedisCloudBackupsAccess",
+                    "Effect": "Allow",
+                    "Principal": {
+                        "AWS": "arn:aws:iam::168085023892:root"
+                    },
+                    "Action": [
+                        "s3:PutObject",
+                        "s3:getObject",
+                        "s3:DeleteObject"
+                    ],
+                    "Resource": "arn:aws:s3:::UNIQUE-BUCKET-NAME/*"
+                }
+            ]
+        }
+        ```
+
+    - If a bucket policy already exists, add the following JSON policy statement to the list of statements. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.
+
+        ```json
+        {
+            "Sid": "RedisCloudBackupsAccess",
+            "Effect": "Allow",
+            "Principal": {
+                "AWS": "arn:aws:iam::168085023892:root"
+            },
+            "Action": [
+                "s3:PutObject",
+                "s3:getObject",
+                "s3:DeleteObject"
+            ],
+            "Resource": "arn:aws:s3:::UNIQUE-BUCKET-NAME/*"
+        }
+        ```
+
+
+1. Save your changes.
+
+1. If the bucket is encrypted using [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html), add the following statement to your [key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html). If you do not have a key policy, see [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html). Replace `UNIQUE-BUCKET-NAME` with the name of your bucket and `CUSTOM-KEY-ARN` with your key's [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html).
+
+    ```json
+    {
+        "Sid": "Allow use of the key",
+        "Effect": "Allow",
+        "Principal": {
+            "AWS": "arn:aws:iam::168085023892:root"
+        },
+        "Action": [
+            "kms:Encrypt",
+            "kms:Decrypt",
+            "kms:ReEncrypt*",
+            "kms:GenerateDataKey*",
+            "kms:DescribeKey"
+        ],
+        "Resource": [
+            "arn:aws:s3:::UNIQUE-BUCKET-NAME/*",
+            "CUSTOM-KEY-ARN"
+        ]
+    }
+    ```
+
+Once the bucket is available and the permissions are set, use the name of your bucket as the **Backup destination** for your database's Remote backup settings. For example, suppose your bucket is named *backups-bucket*.  In that case, set **Backup destination** to `s3://backups-bucket`.
+
+To learn more, see [Using bucket policies](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) on the AWS docs.
+
+{{< note >}}
+An AWS S3 bucket can be used by only one Redis Cloud account. If you have more than one Redis Cloud account, repeat the setup steps for multiple buckets. 
+{{< /note >}}
+
+### Google Cloud Storage
+
+To store backups in a Google Cloud Storage [bucket](https://cloud.google.com/storage/docs/creating-buckets):
+
+1. Sign in to the Google Cloud console.
+
+1. In the console menu, locate the _Storage_ section, then select **Cloud Storage&nbsp;>&nbsp;Buckets**.
+
+1. Create or select a bucket.
+
+1. Select the **Permissions** tab.
+
+1. Select the **Grant Access** button and then add:
+
+    `service@redislabs-prod-clusters.iam.gserviceaccount.com`
+
+1. Set **Role** to **Storage Legacy Bucket Writer**.
+
+1. Save your changes.
+
+1. Verify that your bucket does _not_ have a set retention policy.  
+
+    To do so:
+
+    1. View the details of your bucket.
+
+    1. Select the **Configuration** tab.
+
+    1. Verify **Protection** -> **Bucket retention policy** is set to **none**.  
+
+    If a policy is defined and you cannot delete it, you need to use a different bucket.
+
+Use the bucket details **Configuration** tab to locate the **gsutil URI**.  This is the value you'll assign to your resource's backup path.
+
+To learn more, see [Use IAM permissions](https://cloud.google.com/storage/docs/access-control/using-iam-permissions#bucket-iam).
+
+### Azure Blob Storage
+
+To store your backup in Microsoft Azure Blob Storage, sign in to the Azure portal and then:
+
+1. [Create an Azure Storage account](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-create) if you do not already have one.
+
+1. [Create a container](https://docs.microsoft.com/en-us/azure/storage/blobs/storage-quickstart-blobs-portal#create-a-container) if you do not already have one.
+
+1. Find your storage account's primary access key. See [Manage storage account access keys](https://docs.microsoft.com/en-us/azure/storage/common/storage-account-keys-manage) for instructions.
+
+Set your resource's **Backup Path** to the path of your storage account.
+
+The syntax for creating the backup varies according to your authorization mechanism.  For example:
+
+`abs://:storage_account_access_key@storage_account_name/container_name/[path/]`
+
+Where:
+
+- *storage_account_access_key:* the primary access key to the
+    storage account
+- *storage_account_name:* the storage account name
+- *container_name:* the name of the container, if needed.
+- *path*: the backups path, if needed.
+
+To learn more, see [Authorizing access to data in Azure Storage](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth).
+
+### FTP Server
+
+To store your backups on an FTP server, set its **Backup Path** using the following syntax:
+
+`<protocol>://[username]:[password]@[hostname]:[port]/[path]/`
+
+Where:
+
+- *protocol*: the server's protocol, can be either `ftp` or `ftps`.
+- *username*: your username, if needed.
+- *password*: your password, if needed.
+- *hostname*: the hostname or IP address of the server.
+- *port*: the port number of the server, if needed.
+- *path*: the backup path, if needed.
+
+    {{< note >}}
+If your FTP username or password contains special characters such as `@`, `\`, or `:`, you must URL encode (also known as Percent encode) these special characters. If you don't, your database may become stuck.
+    {{< /note >}}
+
+The user account needs permission to write files to the server.
+---
+Title: Flush data
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+weight: 40
+---
+
+The [FLUSHALL]({{< relref "/commands/flushall" >}}) command provides a fast way to remove all data from a database.
+
+{{< note >}}
+When you _flush_ a database, you remove all data.<br/><br/>
+
+This _permanently_ removes all data from the database.  The data cannot be recovered, except by restoring from earlier backups.<br/><br/>
+
+We _strongly_ recommend backing up databases before flushing them.
+{{</note>}}
+
+## How to use FLUSHALL
+
+To use it, connect your database and then issue the command.  
+
+There are several ways to do this, depending on your circumstances and environment.
+
+The following sections provide some options:
+
+- [`redis-cli`](#redis-cli)
+- [Redis Insight CLI](#redisinsight)
+- [SASL connection](#sasl-connection)
+
+### redis-cli
+
+To use the `redis-cli` utility:
+
+```sh
+redis-cli -h <hostname> -p <portnumber> -a <password> flushall
+```
+
+Example:
+
+```sh
+redis-cli -h redis-12345.server.cloud.redislabs.example.com -p 12345 -a xyz flushall
+```
+
+### Redis Insight
+
+If you install [Redis Insight]({{< relref "/develop/tools/insight" >}}) and [add your database]({{< relref "/operate/rc/rc-quickstart#using-redisinsight" >}}), you can use the Redis Insight workbench to run commands:
+
+1.  Start Redis Insight and connect to your database.
+
+2.  From the Redis Insight menu, select **Workbench** and wait for the client to connect to your database.
+
+3.  In the command area, enter `flushall` and then select the green **run** arrow.
+
+    {{<image filename="images/rc/redisinsight-cli-flushall-example.png" alt="You can use Redis Insight to issue commands to a database." >}}
+
+    The 'OK' response indicates that the command executed properly.
+<!--
+### netcat 
+
+If you have shell access to your database's host server, you can use [netcat](https://en.wikipedia.org/wiki/Netcat) (`nc`) to send the `flush_all` command to your database:
+
+```sh
+echo "flush_all" | nc redis-12345.server.cloud.redislabs.example.com 12345
+```
+-->
+
+### SASL connection
+
+If you do not have permission to access the command shell of the server hosting your database or are unable to use Redis Insight, but you have connection credentials and your database supports [Simple Authentication and Security Layer](https://en.wikipedia.org/wiki/Simple_Authentication_and_Security_Layer) connections, you can use an SASL-enabled command-line client.
+
+For example, suppose you're using Memcached Enterprise Cloud and that your database has SASL enabled. In this case, you can can use the [bmemcached-CLI](https://github.com/RedisLabs/bmemcached-cli) client to connect and issue commands to your database.
+
+Setup instructions vary according to the environment.  Many Linux systems, such as Ubuntu, follow this process:
+
+```sh
+$ wget https://github.com/RedisLabs/bmemcached-cli/archive/master.zip
+$ sudo apt-get install unzip python-pip
+$ unzip master.zip -d bmemcached-cli
+$ cd bmemcached-cli/bmemcached-cli-master/
+$ sudo pip install --upgrade pip
+$ sudo pip install . -r requirements.pip
+```
+
+Adjust as needed for your operating system and configuration.
+
+When the client is properly installed, you can use it to run the `flush_all` command:
+
+```sh
+bmemcached-cli [user]:[password]@[host]:[port]
+```
+
+Here's an example:
+
+```sh
+$ bmemcached-cli username:password@redis-12345.server.cloud.redislabs.example.com:12345
+([B]memcached) flush_all
+True
+exit
+```---
+LinkTitle: Tag database
+Title: Manage database tags
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+weight: 33
+---
+
+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]({{< relref "/operate/rc/databases/view-edit-database#manage-the-database-list" >}}) by tag key or value.
+
+## Manage tags
+
+You can manage tags from the [Redis Cloud console](https://cloud.redis.io/#/) in the [tag manager](#tag-manager). You can find the tag manager in the following places: 
+
+- [From your database in the **Configuration** tab](#configuration-tab)
+- [From the database list](#database-list)
+
+After you open the [tag manager](#tag-manager), you can use it to add, edit, or delete tags.
+
+### Open tag manager from the Configuration tab {#configuration-tab}
+
+To learn how to navigate to your database, see [View and edit databases]({{< relref "/operate/rc/databases/view-edit-database" >}}). Select the **Configuration** tab and go to the **General** section to view the tags that are set for your database.
+
+{{<image filename="images/rc/database-details-configuration-tab-general-flexible.png" alt="The Configuration tab of the Database details screen." >}}
+
+Select **Manage Tags** to open the [tag manager](#tag-manager).
+
+{{<image filename="images/rc/tags-button-manage-tags.png" width=120px alt="The Manage tags button." >}}
+
+### Open tag manager from the database list {#database-list}
+
+Using the database list allows you to manage tags for multiple databases without having to go into each database's **Tags** tab.
+
+To get to the database list, select **Databases** from the main menu. 
+
+{{<image filename="images/rc/tags-database-list.png" alt="The database list with databases that are tagged." >}}
+
+Hover over the database and select **Manage tags**, or select **More actions** > **Manage tags** to open the [tag manager](#tag-manager).
+
+{{<image filename="images/rc/tags-icon-manage-tags.png#no-click" width=30px alt="Manage tags button." class="inline">}}
+{{<image filename="images/rc/tags-icon-more-actions.png#no-click" width=30px alt="More actions button." class="inline">}}
+
+### Use the tag manager {#tag-manager}
+
+The tag manager shows any tags that are associated with the database and allows you to create, edit, or delete tags.
+
+{{<image filename="images/rc/tags-tag-manager.png" alt="The tag manager." >}}
+
+{{< embed-md "rc-tags-tag-module.md" >}}
+
+Select **Save tags** to save your changes.
+
+{{<image filename="images/rc/tags-button-save-tags.png" width=100px alt="The Save tags button." >}}
+---
+Title: Use Redis Insight on Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+- redisinsight
+description: Shows how to open your database in a browser-based version of Redis Insight and lists the features that are available.
+hideListLinks: true
+linkTitle: Redis Insight on Redis Cloud
+weight: 1
+---
+
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.
+
+You can either [install Redis Insight]({{< relref "/develop/tools/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 currently available for some Essentials databases, and will be available to more Essentials databases over time. For all other databases, [install Redis Insight]({{< relref "/develop/tools/insight" >}}) on your computer and [open Redis Insight]({{< relref "/operate/rc/databases/connect#ri-app" >}}) from the database page.
+{{< /note >}}
+
+To open your database with Redis Insight on Redis Cloud, select **Open with Redis Insight** on the [database screen]({{< relref "/operate/rc/databases/view-edit-database" >}}).
+
+{{<image filename="images/rc/rc-ri-open.png" alt="Open with Redis Insight" width=400px >}}
+
+Redis Insight will open in a new tab. 
+
+This browser-based version of Redis Insight has a subset of the features of Redis Insight. For other Redis Insight features, [install Redis Insight]({{< relref "/develop/tools/insight" >}}) on your computer and [open Redis Insight]({{< relref "/operate/rc/databases/connect#ri-app" >}}) from the database page.
+
+## Browser
+
+The **Browser** lets you browse, filter, and visualize your Redis data structures.
+
+- Create, read, update, and delete lists, hashes, strings, sets, sorted sets, streams, and [JSON]({{< relref "/develop/data-types/json/" >}})
+- Group keys according to their namespaces
+    {{<image filename="images/rc/rc-ri-browser-group.png" alt="Keys in a database grouped by namespace." width=50% >}}
+- View, validate, and manage your key values in a human-readable format using formatters that prettify and highlight data in different formats (for example, Unicode, JSON, MessagePack, HEX, and ASCII)
+    {{<image filename="images/rc/rc-ri-browser-view.png" alt="Human-readable view of a hash key." width=50% >}}
+
+If you don't have any Redis data yet, you can select **Load sample data** to add sample data into your database.
+
+{{<image filename="images/rc/rc-ri-load-data.png" alt="Load Sample Data button" width=300px >}}
+
+## CLI and Command Helper
+
+The **CLI** lets you run Redis commands directly. 
+
+{{<image filename="images/rc/rc-ri-cli.png" alt="The CLI and command helper" width=75% >}}
+
+The CLI integrates with a **Command Helper** that lets you search and read information about Redis commands.
+
+## Workbench
+
+The **Workbench** is an advanced command line interface with intelligent command auto-complete and complex data visualization support.
+
+{{<image filename="images/rc/rc-ri-workbench.png" alt="The Workbench" width=75% >}}
+
+Select **Explore** to view interactive tutorials to learn more about Redis and tips to improve your database usage.
+
+{{<image filename="images/rc/rc-ri-explore-button.png" alt="The Explore button" width=200px >}}
+
+
+---
+Title: Connect to a Redis Cloud database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+linkTitle: Connect
+weight: 12
+---
+
+After you [create your database]({{< relref "/operate/rc/databases/create-database" >}}), you can connect to it.
+
+To connect to the database, you need your username and password. By default, your database is protected by a [**Default user**]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) called `default` and a masked **Default user password**. You can see the default user password in the **Security** section of the **Configuration** details for your database. Select the eye icon to show or hide the password.    
+
+{{<image filename="images/rc/database-fixed-configuration-security.png" width="75%" alt="The Security section of the Configuration tab of the database details page." >}}
+
+If you've turned on [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}) for your database and [turned off the default User]({{< relref "/operate/rc/security/access-control/data-access-control/default-user#turn-off-default-user" >}}), use the username and password for your data access role.
+
+Once you have the username and password, select **Connect** to open the connection wizard.
+
+{{< image filename="/images/rc/button-connect.png#no-click" alt="Connect button." >}}
+
+The connection wizard provides the following database connection methods:
+
+- [Redis Insight](#using-redisinsight)
+
+- [`redis-cli`](#using-rediscli) utility
+
+- [Redis client](#using-redis-client) for your preferred programming language
+
+{{<image filename="images/rc/connection-wizard.png" alt="The connection wizard." width=500px >}}
+
+## Redis Insight {#using-redisinsight}
+
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.
+
+You can connect to your database with Redis Insight in two ways:
+
+1. [Open your database in Redis Insight in your browser](#ri-browser).
+
+1. [Download and Install Redis Insight](#ri-app) on Windows, macOS, and Linux.
+
+### Open in your browser {#ri-browser}
+
+{{< note >}}
+Opening your database with Redis Insight in your browser is currently available for some Essentials databases, and will be available to more Essentials databases over time. 
+{{< /note >}}
+
+If Redis Insight on Redis Cloud is available for your database, select **Launch Redis Insight web** from the connection wizard to open it.
+
+{{<image filename="images/rc/rc-ri-wizard-launch.png" alt="Launch Redis Insight web from the Connection Wizard." width=500px >}}
+
+You can also select **Launch** from the database page under **View and manage data with Redis Insight** to open Redis Insight in your browser.
+
+{{<image filename="images/rc/rc-ri-open.png" alt="Launch Redis Insight web from the database page." width=500px >}}
+
+Redis Insight will open in a new tab. 
+
+This browser-based version of Redis Insight has a subset of the features of Redis Insight. For more information, see [Open with Redis Insight on Redis Cloud]({{< relref "/operate/rc/databases/connect/insight-cloud" >}}).
+
+### Install and open on your computer {#ri-app}
+
+1. If you haven't downloaded Redis Insight, select **Download** under **Redis Insight** in the Connection wizard to download it. 
+
+1. [Install Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+1. Once installed, select **Open with Redis Insight**.
+
+1. A pop-up asks if you wish to open the link with Redis Insight. Select **Open Redis Insight** to connect to your database with Redis Insight.
+
+If you get an error when connecting with Redis Insight, [manually connect to your database]({{< relref "/develop/tools/insight" >}}) from Redis Insight.
+
+You can use Redis Insight to view your data, run Redis commands, and analyze database performance. See the [Redis Insight docs]({{< relref "/develop/tools/insight" >}}) for more info.
+
+## Redis client {#using-redis-client}
+
+A Redis client is a software library or tool that enables applications to interact with a Redis server. Each client has its own syntax and installation process. For help with a specific client, see the client's documentation.
+
+The connection wizard provides code snippets to connect to your database with the following programming languages:
+
+- .NET using [NRedisStack]({{< relref "/develop/clients/dotnet" >}})
+- node.js using [node-redis]({{< relref "/develop/clients/nodejs" >}})
+- Python using [redis-py]({{< relref "/develop/clients/redis-py" >}})
+- Java using [Jedis]({{< relref "/develop/clients/jedis" >}}) and [Lettuce]({{< relref "/develop/clients/lettuce" >}})
+- Go using [go-redis]({{< relref "/develop/clients/go" >}})
+- PHP using [Predis]({{< relref "/develop/clients/php" >}})
+
+{{<image filename="images/rc/connection-wizard-clients.png" alt="The connection wizard clients." width=500px >}}
+
+If the username and password are not already filled in, replace `<username>` and `<password>` with your username and password.
+
+See [Clients]({{< relref "/develop/clients" >}}) to learn how to connect with the official Redis clients.
+
+### redis-cli {#using-rediscli}
+
+The [`redis-cli`]({{< relref "/develop/tools/cli" >}}) utility is installed when you install Redis.  It provides a command-line interface that lets you work with your database using core [Redis commands]({{< relref "/commands" >}}).
+
+To run `redis-cli`, [install Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) on your machine. After it's installed, copy the `redis-cli` command under **Redis CLI** in the connection wizard and enter it into your terminal. If the username and password are not already filled in, replace `<username>` and `<password>` with your username and password.
+
+See [Redis CLI]({{< relref "/develop/tools/cli" >}}) to learn how to use `redis-cli`.
+
+## More info
+
+- [Connect your application]({{< relref "/develop/clients" >}})
+- [Connect with TLS]({{< relref "/operate/rc/security/database-security/tls-ssl#connect-over-tls" >}})
+- [Default user]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}})
+- [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}})---
+Title: Import data into a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Import data
+weight: 20
+---
+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]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}), 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]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}), the dataset will also be replicated across regions.
+{{< /warning >}}
+<br/>
+{{< 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.
+{{< /note >}}
+
+## Prerequisites
+
+Make sure the Redis version of the source database is compatible with the database where the data will be imported.
+
+## Import from a Redis server {#redis-server}
+
+To import a dataset from any publicly available Redis Open Source server:
+
+1. Select **Databases** from the Redis Cloud console menu and then select the target database from the database list.
+1. Select **Import**.
+    {{<image filename="images/rc/database-configuration-import.png" alt="The Import dataset section and Import button." >}}
+1. Enter the source database details:
+    - Source type - Select **Redis**.
+    - Redis Hostname/IP Address - Enter the hostname or the public IP address of the source Redis server.
+    - Redis port - Enter the port of the source Redis server if it is not the default value of `6379`.
+    - Password - Enter the password, if required by the source Redis database.
+1. Select **Import**.
+
+## Restore from an RDB file
+
+If you have an RDB or a compressed RDB file from a previous backup, you can restore data from that file into your Redis Cloud database.
+
+### Via FTP or HTTP
+
+To import an RDB file stored on an FTP or HTTP server:
+
+1. Select **Databases** from the Redis Cloud console menu and then select your database from the list.
+1. Select **Import**.
+    {{<image filename="images/rc/database-configuration-import.png" alt="The Import dataset section and Import button." >}}
+1. Enter the details for the RDB file:
+    - Source type - Select **FTP** or **HTTP**.
+    - Source path - Enter the URL for the RDB file: `<protocol>://[username][:password]@hostname[:port]/[path/]filename.rdb[.gz]`
+
+    Where:
+
+    - `protocol` - Server protocol: ftp, ftps, http, https
+    - `username` - Your username, if necessary
+    - `password` - Your password, if necessary
+    - `hostname` - Hostname or IP address of the server
+    - `port` - Port number of the server, if not `6379`
+    - `path` - Path to the file, if necessary
+    - `filename` - Filename of the RDB file, including the `.gz` suffix if the file is compressed
+
+    {{< note >}}
+If your FTP username or password contains special characters such as `@`, `\`, or `:`, you must URL encode (also known as Percent encode) these special characters. If you don't, your database may become stuck.
+    {{< /note >}}
+
+1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.
+    {{< warning >}}
+For sharded databases with multiple RDB files, make sure to add every file before proceeding.
+    {{< /warning >}}
+
+1. Select **Import**.
+
+### Via AWS S3
+
+To use the Redis Cloud console to import your data, you must first share the file from the Amazon Web Services (AWS) management console.
+
+To share and import an RDB file that is stored in an AWS Simple Storage Service (S3) bucket:
+
+1. In the [AWS Management Console](https://console.aws.amazon.com/), configure the bucket's [bucket policy](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-policies.html) to give access to Redis Cloud:
+    1. Use the **Services** menu to locate and select **Storage** > **S3**.  This takes you to the Amazon S3 admin panel.
+
+    1.  Use the **Buckets** list to locate and select your bucket.  When the settings appear, select the **Permissions** tab, locate the **Bucket policy** section, and then click **Edit**.
+
+        -  If there is no existing bucket policy, add the following JSON bucket policy. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.
+
+            ```json
+            {
+                "Version": "2012-10-17",
+                "Id": "MyBucketPolicy",
+                "Statement": [
+                    {
+                        "Sid": "RedisCloudBackupsAccess",
+                        "Effect": "Allow",
+                        "Principal": {
+                            "AWS": "arn:aws:iam::168085023892:root"
+                        },
+                        "Action": [
+                            "s3:PutObject",
+                            "s3:getObject",
+                            "s3:DeleteObject"
+                        ],
+                        "Resource": "arn:aws:s3:::UNIQUE-BUCKET-NAME/*"
+                    }
+                ]
+            }
+            ```
+
+        - If a bucket policy already exists, add the following JSON policy statement to the list of statements. Replace `UNIQUE-BUCKET-NAME` with the name of your bucket.
+
+            ```json
+            {
+                "Sid": "RedisCloudBackupsAccess",
+                "Effect": "Allow",
+                "Principal": {
+                    "AWS": "arn:aws:iam::168085023892:root"
+                },
+                "Action": [
+                    "s3:PutObject",
+                    "s3:getObject",
+                    "s3:DeleteObject"
+                ],
+                "Resource": "arn:aws:s3:::UNIQUE-BUCKET-NAME/*"
+            }
+            ```
+
+    1. Save your changes.
+
+    1. If the bucket is encrypted using [SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html), add the following statement to your [key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html). If you do not have a key policy, see [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html). Replace `UNIQUE-BUCKET-NAME` with the name of your bucket and `CUSTOM-KEY-ARN` with your key's [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html).
+
+        ```json
+        {
+            "Sid": "Allow use of the key",
+            "Effect": "Allow",
+            "Principal": {
+                "AWS": "arn:aws:iam::168085023892:root"
+            },
+            "Action": [
+                "kms:Encrypt",
+                "kms:Decrypt",
+                "kms:ReEncrypt*",
+                "kms:GenerateDataKey*",
+                "kms:DescribeKey"
+            ],
+            "Resource": [
+                "arn:aws:s3:::UNIQUE-BUCKET-NAME/*",
+                "CUSTOM-KEY-ARN"
+            ]
+        }
+        ```
+
+
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select the target database from the database list.
+1. Select **Import**.
+    {{<image filename="images/rc/database-configuration-import.png" alt="The Import dataset section and Import button." >}}
+1. Enter the details for the RDB file:
+    - Source type - Select **AWS S3**.
+    - Source path - Enter the URL for the RDB file: `s3://bucketname/[path/]filename.rdb[.gz]`
+
+        Where:
+
+        - `bucketname` - Name of the S3 bucket
+        - `path` - Path to the file, if necessary
+        - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed
+
+1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.
+
+1. Select **Import**.
+
+### Via Google Cloud Storage
+
+To use the Redis Cloud console to import your data, you must first share the file from the Google Cloud console.
+
+To share and import an RDB file that is stored in a Google Cloud Storage bucket:
+
+1. In the Google Cloud Storage bucket, edit the file's Access Control List to give read access to Redis Cloud:
+    1. Select **Edit access** in the RDB file menu.
+    1. Select **Add item**.
+    1. Enter the user details and access:
+       - In the Entity field of the new item, select **User**.
+       - In the Name field of the new item, enter: `service@redislabs-prod-clusters.iam.gserviceaccount.com`
+       - In the Access field of the new item, select **Reader**.
+    1. Select **Save**.
+
+    For more info, see [Set ACLs](https://cloud.google.com/storage/docs/access-control/create-manage-lists#set-an-acl).
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select the target database from the database list.
+1. Select **Import**.
+    {{<image filename="images/rc/database-configuration-import.png" alt="The Import dataset section and Import button." >}}
+1. Enter the details for the RDB file:
+    - Source type - Select **Google Cloud Storage**.
+    - Source path - Enter the URL for the RDB file: `gs://bucketname/[path/]filename.rdb[.gz]`
+
+        Where:
+        - `bucketname` - Name of the GCS bucket
+        - `path` - Path to the file
+        - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed
+
+1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.
+
+1. Select **Import**.
+
+### Via Azure Blob Storage container
+
+To import an RDB file stored in a Microsoft Azure Blog storage container:
+
+1. In the Redis Cloud console, select the target database from the database list.
+1. Select **Import**.
+    {{<image filename="images/rc/database-configuration-import.png" alt="The Import dataset section and Import button." >}}
+1. Enter the details for the RDB file:
+    - Source type - Select **Azure Blob Storage**.
+    - Source path - Enter the URL for the RDB file:
+        ```text
+        abs://:storage_account_access_key@storage_account_name/[container/]filename.rdb[.gz]     
+        ```
+
+        Where:
+        - `storage_account_access_key` - Primary access key to the storage account
+        - `storage_account_name` - Name of the storage account
+        - `url` - URL of the storage account
+        - `container` - Name of the container, if necessary
+        - `filename` - Filename of the RDB file, including the .gz suffix if the file is compressed
+
+1. For sharded databases with multiple RDB files, select **Add source** to add another RDB file.
+
+1. Select **Import**.
+---
+Title: Migrate data to new subscription
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows two ways to migrate data to a database in a new subscription.
+linkTitle: Migrate databases
+weight: 30
+---
+There are times when you need to migrate data from one 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.
+
+Here's how it works:
+
+1.  [Select an export storage destination]({{< relref "/operate/rc/databases/back-up-data#set-up-backup-storage-locations" >}}) and verify that it's ready for use and has sufficient space.
+
+1.  [Export]({{< relref "/operate/rc/databases/back-up-data.md" >}}) the data from the original database to the storage location.
+
+1.  [Import]({{< relref "/operate/rc/databases/import-data.md" >}}) the exported data into the target database, the one hosted by the new subscription.
+
+The migrated data reflects the state of the data at the time it was originally exported.  
+
+If you have apps or other connections actively using the source database, consider scheduling downtime for the migration to avoid loss.
+
+This approach also lets you transfer data between databases hosted by different services. 
+
+## Sync using Active-Passive
+
+If your target database is hosted on Redis Cloud Pro, you can use Active-Passive to sync the source database to the target database.  The source database can be hosted on Redis Cloud Pro or Redis Cloud Essentials.
+
+The source database remains active while the data migrates.
+
+The following sections describe Active-Passive syncing processes.
+
+### General Active-Passive syncing process
+
+To migrate data using Active-Passive syncing, specify the target database as an Active-Passive replica of the source database:
+
+1.  Get the source database's public endpoint from the **General** section of the database's **Configuration** tab.
+2.  Activate the target database as an Active-Passive replica for the source.
+3.  Stop all writes to the source database and wait for the data to sync.
+4.  Turn off Active-Passive for the target database.
+5.  Switch apps and other connections to the target database.
+
+{{< note >}}
+Before you use Active-Passive, be aware of the following limitations:
+
+- An error will appear when syncing the two databases if the source and target databases are hosted on different Redis Cloud accounts. [Contact support](https://redis.io/support/) if you want to migrate a database between accounts using Active-Passive.
+
+- As long as Active-Passive is enabled, data in the target database will not expire and will not be evicted regardless of the set [data eviction policy]({{< relref "/operate/rc/databases/configuration/data-eviction-policies.md" >}}). We recommend that you turn off Active-Passive after the databases are synced. 
+
+- Turning on Active-Passive will flush the target database. Make sure that your target database has no important data before you turn on Active-Passive.
+{{< /note >}}
+
+### Detailed Active-Passive syncing process
+
+Follow these detailed steps to migrate data using Active-Passive syncing:
+
+1.  Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and select the target database in the list.
+
+    {{<image filename="images/rc/migrate-database-select-source.png" alt="Select the target database from the database list." >}}
+
+1.  From the **Configuration** tab of the target database, select **Edit**.
+
+    {{<image filename="images/rc/migrate-data-target-edit.png" alt="Use the **Edit Database** button to change the configuration of the target database." >}}
+
+1.  In the **Durability** section, enable **Active-Passive Redis** and then select **Add Source**.
+
+    {{<image filename="images/rc/migrate-data-active-passive-enable.png" alt="Active-Passive settings are located in the **Durability** section of the database **Configuration** tab." >}}
+
+    {{<image filename="images/rc/button-database-uri-add.png" alt="Use the **Add Source** button to specify the source of the Active-Passive replica." width="150px">}}
+
+1. This will open the **Add Active-Passive Redis** screen. Select where the source database is located.
+
+    {{<image filename="images/rc/migrate-data-add-active-passive.png" alt="The Add Active-Passive Redis screen." width=70% >}}
+
+    - Select **Current account** if the source database is located in this Redis Cloud account. 
+    
+        Select the source database from the **Source database** list. You can type in the database's name to find it.
+
+        {{<image filename="images/rc/database-add-account-path-list.png" alt="Select the Source database from the database list." width=70% >}}
+
+    - If the source database is hosted externally, select **External**.
+
+        1.  In the **Enter the source URI** field, type `redis://` and then paste in the public endpoint details. 
+
+            {{<image filename="images/rc/migrate-data-specify-source-uri.png" alt="The source URI must be specified using the 'redis://' protocol." width=70% >}}
+
+        1. Select if the source database requires Transport Layer Security (TLS).
+        
+            - If the source database requires TLS, select **TLS** and enter the public server certificate in the **Server Certificate** field.
+
+            {{<image filename="images/rc/migrate-data-tls-server-cert.png" alt="The Server Certificate field." width=70% >}}
+
+            - If the source database requires client authentication, select **Mutual TLS**.
+
+                1. Enter the public server certificate in the **Server Certificate** field.
+
+                    {{<image filename="images/rc/migrate-data-tls-server-cert.png" alt="The Server Certificate field." width=70% >}}
+
+                1. Select **Download** to download the client certificate. 
+
+                    {{<image filename="images/rc/migrate-data-tls-client-cert.png" alt="The Client Certificate field. Select Download to download the client certificate." width=70% >}}
+
+                1. Configure the source database to accept the client certificate.
+
+1. Select **Save Active-Passive** to save your Active-Passive settings.
+
+    {{<image filename="images/rc/icon-database-save-active-passive.png" alt="The **Save** button verifies the Source URI and you can't save until it validates." width="150px">}}
+
+    For an external database, we'll verify the endpoint at this step. If the endpoint can't be verified, make sure that you've copied the details directly from the source database and that the value you entered starts with `redis://`.
+
+1.  Select **Save Database** to begin updating the database.
+
+    {{<image filename="images/rc/button-database-save.png" alt="Use the **Save Database** button to save your changes, deploy the database, and to start data migration." >}}
+
+    Initially, the database status is __Pending__, which means the update task is still running.  
+
+    {{<image filename="images/rc/icon-database-update-status-pending.png" alt="When the status is 'Pending', your changes are still being deployed.">}}
+
+    The sync process doesn't begin until the database becomes `Active`.  
+
+    {{<image filename="images/rc/icon-database-status-active.png" alt="When the status becomes 'Active', data begins to sync." >}}
+
+    When data has fully migrated to the target database, database status reports `Synced`.  
+
+    {{<image filename="images/rc/migrate-data-status-synced.png" alt="When the data is migrated, the target database status displays `Synced`." width=100px >}}
+
+Active-Passive sync lets you migrate data while apps and other connections are using the source database.  Once the data is migrated, you should migrate active connections to the target database.  
+
+## Active-Passive memory requirements
+
+Active-Passive sync requires more memory than data import.  On average, you need an extra 25% memory on top of other requirements, though specific requirements depend on the data types and other factors.  
+
+To illustrate, suppose you want to migrate a 1&nbsp;GB source database without replication to a target database with replication enabled.  Here, the target database memory limit should be at least 2.5&nbsp;GB to avoid data loss.
+
+Once the databases are synced, you can disable Active-Passive for the target database.  Before doing so, however, verify that apps and other connections have switched to the target database; otherwise, you may lose data.
+
+---
+Title: Manage databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+linktitle: Databases
+weight: 20
+---
+
+Databases are the heart of any Redis Cloud deployment.  
+
+Here's how to perform a variety of tasks:
+
+## Common database tasks
+
+- [Create a database]({{< relref "/operate/rc/databases/create-database" >}})
+
+    - [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}})
+    - [Create a Pro database with a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}})
+    - [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}})
+    - [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}})
+
+- [View and edit databases]({{< relref "/operate/rc/databases/view-edit-database" >}})
+
+- [Delete database]({{< relref "/operate/rc/databases/delete-database" >}})
+
+If you're new to Redis Cloud, see the [Quick Start]({{< relref "/operate/rc/rc-quickstart" >}}).
+
+## Additional tasks
+
+- [Monitor database performance]({{< relref "/operate/rc/databases/monitor-performance" >}}) 
+
+- [Import data into databases]({{< relref "/operate/rc/databases/import-data" >}}) 
+
+- [Back up databases]({{< relref "/operate/rc/databases/back-up-data" >}})
+
+- [Secure database access]({{< relref "/operate/rc/security/database-security/" >}})
+
+- [Flush database data]({{< relref "/operate/rc/databases/flush-data" >}})
+
+## Configuration details
+
+These topics provide background details that can help you tailor your databases to better fit your needs.
+
+- [Clustering Redis databases]({{< relref "/operate/rc/databases/configuration/clustering" >}}): Redis Cloud uses clustering to manage very large databases (25 GB and larger). Learn how to manage clustering and how to use hashing policies to manage the process.
+
+- [Data eviction policies]({{< relref "/operate/rc/databases/configuration/data-eviction-policies" >}}): Data eviction policies control what happens when new data exceeds the memory limits of a database. Learn the available policies and how to control them.
+
+- [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}): Data persistence enables recovery in the event of memory loss or other catastrophic failure. Learn which options are available and how to apply specific settings to individual databases.
+
+- [High availability and replication]({{< relref "/operate/rc/databases/configuration/high-availability" >}}): Replication allows for automatic failover and greater fault tolerance. It can prevent data loss in the event of a hardware or zone failure.  Learn which options are available for Redis Cloud subscriptions.
+
+- [Advanced Capabilities]({{< relref "/operate/rc/databases/configuration/advanced-capabilities" >}}): Advanced capabilities extend Redis database functionality by adding new data types and options. Learn about the advanced capability options that are available for your database.
+
+## Compatibility
+
+Redis Cloud does not support certain commands. Instead of using these commands, Redis Cloud automatically handles features like replication and lets you [manage your database]({{< relref "/operate/rc/databases" >}}) from the [Redis Cloud console](https://cloud.redis.io/) or [Redis Cloud REST API]({{< relref "/operate/rc/api" >}}).
+
+For more details, see:
+
+- [Redis Cloud compatibility]({{< relref "/operate/rc/compatibility" >}})
+
+- [Command compatibility]({{< relref "/operate/rs/references/compatibility/commands" >}})
+
+- [Configuration compatibility]({{< relref "/operate/rs/references/compatibility/config-settings" >}})
+---
+Title: Create a Pro database in an existing subscription
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create a Pro database in an existing subscription
+linkTitle: Create Pro database (existing subscription)
+weight: 15
+tocEmbedHeaders: true
+---
+
+{{< 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]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}).
+- If you'd rather create an Essentials database, see [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}).
+{{< /note >}}
+
+To create a database in an already existing Pro subscription: 
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io).
+
+2. Select the **New database** button.
+
+    {{<image filename="images/rc/button-database-new.png" alt="The New Database button creates a new database." width="120px">}}
+
+    This displays the **Create database** screen.
+
+1. Select the type of [subscription]({{< relref "/operate/rc/subscriptions" >}}) you need. For this guide, select **Existing subscription**, and then select your existing Pro subscription from the list.
+
+    {{<image filename="images/rc/create-database-subscription-pro-existing.png" alt="The Subscription selection panel with Pro selected and an existing subscription selected.">}}
+
+After you select your existing subscription from the list, select **Continue** to go to the **New database** page.
+
+You can also select your subscription from the [subscription list]({{< relref "/operate/rc/subscriptions/view-pro-subscription" >}}) and select **Create database in this subscription**.
+
+{{<image filename="images/rc/button-add-new-to-pro.png" alt="The Create database in this subscription button." width=400px >}}
+
+The **New database** page is divided into sections, each dedicated to a specific category of settings. The following sections provide more details.
+
+When you've configured your new database, click the **Activate database** button to create and activate it.
+
+{{<image filename="images/rc/button-database-activate.png" alt="Use the Activate database button to create and activate your database." width="150px">}}
+
+## General section
+
+The **General** section defines basic properties about your database.
+
+{{<image filename="images/rc/database-new-flexible.png" alt="The general section of the New Database screen.">}}
+
+The available settings vary according to your subscription plan:
+
+| Setting name              | Description                                                                                                                                                                                                                                                                                                       |
+|:--------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Subscription**          | Read-only description of your Pro subscription, including cloud provider and region                                                                                                                                                                                                                              |
+| **Active-Active Redis**   | Checked when the subscription supports Active-Active databases                                                                                                                                                                                         |
+| **Auto Tiering**          | Checked when the subscription supports Auto Tiering                                                                                                                                                                                     |
+| **Database name**         | A name for your database (_required_)                                                                                                                                                                                                                                                                             |
+| **Database port**         | Automatically or manually assigns a database port (range: 10000-19999).  You cannot assign a port that is reserved or already in use.                                                                                                                                                                                      |
+| **Database version**         | The Redis version of your database. We recommend you choose the latest available version.                                                                                                                                                                                      |
+| **Type**                  | Controls advanced database capabilities and protocol.  Supported values include _Redis_ and _Memcached_                                                                       |
+| **Advanced capabilities** | Advanced data types used by the database. Choose from [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}), [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}), [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}), or [Probabilistic]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}). <br/> Databases with Search and query have specific sizing requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **Query performance factor** | *(Search and query databases on Redis 7.2 or later only)* Adds additional compute power to process your query and vector search workloads and boost your queries per second. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **Supported Protocol(s)** | Choose between RESP2 and RESP3 _(Redis 7.2 only)_. See [Redis serialization protocol]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions) for details                                                                                                                                                   |
+
+## Performance section
+
+The **Performance** section lets you manage the maximum size, throughput, and hashing policy for a database.
+
+{{<image filename="images/rc/database-new-flexible-scalability.png" alt="Use the Performance section to control the size, throughput, and hashing policy for a database." >}}
+
+| Setting name        | Description                                                                                                                                                                                                                                                                                                                                   |
+|:--------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Dataset size**    | Maximum size (in GB) for your dataset. See [Dataset size]({{< relref "/operate/rc/databases/configuration/sizing#dataset-size" >}}) for sizing considerations. <br/> Databases with Search and query have specific size requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **Throughput**      | Defines throughput in terms of maximum operations per second for the database. See [Throughput]({{< relref "/operate/rc/databases/configuration/sizing#throughput" >}}) for more info. <br/> Databases with Search and query have specific throughput requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **High availability**    | Replicates your data across multiple nodes, as allowed by your subscription plan. See [High availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) for more info|
+| **Hashing policy**  | Defines the [hashing policy]({{< relref "/operate/rc/databases/configuration/clustering#manage-the-hashing-policy" >}}).  |
+| **OSS Cluster API** | Activates the [Cluster API]({{< relref "/operate/rc/databases/configuration/clustering#oss-cluster-api" >}}) for a database. When this option is selected, you cannot define a custom hashing policy.<br/> After you select OSS Cluster API, you can select **Use external endpoint** if you want to use the external endpoint for the database. Selecting **Use external endpoint** will block the private endpoint for this database. |
+
+## Durability section
+
+The **Durability** section helps you keep your database (and your data) available when problems occur.
+
+{{<image filename="images/rc/database-new-flexible-durability.png" alt="Use the Durability settings to keep your database (and data) available when problems occur." >}}
+
+
+| Setting name             | Description                                                                                                                                                                |
+|:-------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Data persistence**     | Defines whether (and how) data is saved to disk; [available options]({{< relref "/operate/rc/databases/configuration/data-persistence.md" >}}) depending on your plan type            |
+| **Data eviction policy** | Configures which [policy]({{< relref "/operate/rc/databases/configuration/data-eviction-policies.md" >}}) is applied when your database reaches its memory limit              |
+| **Remote backup**        | When enabled, identifies a location and interval for [data backups]({{< relref "/operate/rc/databases/back-up-data" >}}) |
+| **Active-Passive Redis** | When enabled, identifies a path to the linked database. See [Migrate data]({{< relref "/operate/rc/databases/migrate-databases" >}}) for more information.           |
+
+## Tags section
+
+The **Tags** section lets you add [tags]({{< relref "/operate/rc/databases/tag-database" >}}) to the database.
+
+{{<image filename="images/rc/database-new-tags.png" alt="Use the Tag settings to add tags to the database." >}}
+
+Select **Add tag** to add a tag.
+
+{{<image filename="images/rc/tags-button-add-tag.png" alt="The Add tag button." width=100px >}}
+
+{{< embed-md "rc-tags-tag-module.md" >}}
+
+## Security section
+
+The **Security** section helps you control access to your database.
+
+{{<image filename="images/rc/database-new-flexible-security.png" alt="Use the Security settings to control access to your database." >}}
+
+
+| Setting name                       | Description                                                                                                                                                                           |
+|:-----------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Default user**                   | When enabled, permits access using the `default` username and a simple password (see [Default User]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}})). Turn on [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}) to turn off this setting.              |
+| **Default user password**                 | Password assigned to the database when created                                                                                                                                        |  
+| **CIDR allow list**                | [Allow list]({{< relref "/operate/rc/security/cidr-whitelist.md" >}}) of IP addresses/security groups permitted to access the database |
+| **Transport layer security (TLS)** | Enables [transport layer security]({{< relref "/operate/rc/security/database-security/tls-ssl.md" >}}) (TLS) encryption for database access          |
+
+
+## Alerts section
+
+The **Alerts** section defines notification emails sent to your account and the conditions that trigger them.
+
+{{<image filename="images/rc/database-new-flexible-alerts.png" alt="The Alerts section defines the notification emails and their triggering conditions." >}}
+
+The available alerts vary according to the plan type. See [Configure alerts]({{< relref "/operate/rc/databases/monitor-performance#configure-metric-alerts" >}}) for more information.
+
+{{< embed-md "rc-pro-billing-units.md" >}}---
+Title: Create an Essentials database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create an Essentials database.
+linkTitle: Create Essentials database
+weight: 5
+aliases:
+    - /operate/rc/subscriptions/create-fixed-subscription
+tocEmbedHeaders: true
+---
+
+{{< embed-md "rc-create-db-first-steps.md" >}} 
+
+3. Select the type of [subscription]({{< relref "/operate/rc/subscriptions" >}}) you need. For this guide, select **Essentials**.
+
+    {{<image filename="images/rc/create-database-subscription-essentials.png" alt="The Subscription selection panel with Essentials selected.">}}
+
+    {{< note >}}
+This guide shows how to create an Essentials database.
+- If you'd rather create a Redis Flex database on Redis Cloud Essentials, see [Create a Redis Flex database]({{< relref "/operate/rc/databases/create-database/create-flex-database" >}})
+- If you'd rather create a Pro database, see [Create a Pro database with a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}).
+- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}).
+    {{< /note >}}
+    
+    After you select **Essentials**, the rest of the database details will appear.
+
+    {{<image filename="images/rc/create-database-essentials-cloud-vendor.png" alt="The database name, cloud vendor, region, and type settings.">}}
+
+1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.  
+
+1. Choose a **Cloud Provider** and a **Region**.
+
+1. The **Type** of database controls the protocol and advanced capabilities. Leave this as **Redis Stack** unless you have a legacy application that uses **Memcached**.
+
+    A Redis Stack database gives access to a set of advanced capabilities. For more information, see [Advanced capabilities]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#essentials" >}}).
+
+1. In the **Durability settings** panel, choose your **High availability settings** and **Data persistence** settings from the list. 
+
+    {{<image filename="images/rc/create-database-essentials-durability.png" alt="The durability settings allow you to choose High availability and Data persistence." width=75% >}}
+
+    Redis Cloud supports the following high availability settings:
+
+    - **None**: You will have a single copy of your database without replication.
+    - **Single-Zone**: Your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.
+    - **Multi-Zone**: The primary and its replicas are stored in different zones. This means that your database can remain online even if an entire zone becomes unavailable.
+
+    See [High availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) for more information about these settings.
+
+    Redis Cloud supports the following Data persistence options:
+
+    - An **Append-Only File** maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure. For Essentials databases, Redis updates the Append-Only file every second.
+
+    - A **Snapshot** is a copy of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time. 
+    
+    See [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) for more information about these settings.
+    
+1. Select the desired memory limit. To create a free database, select the 30 MB memory limit. You can only have one free database at a time.
+
+    {{<image filename="images/rc/subscription-new-fixed-tiers.png" alt="Available Essentials plans." >}}
+
+    For a comparison of available plans, see [Redis Cloud Essentials plans]({{< relref "/operate/rc/subscriptions/view-essentials-subscription/essentials-plan-details" >}}).
+
+1.  Enter your payment details if you chose a paid plan.
+
+    If you chose a paid plan and haven't previously entered a payment method, use the **Add Credit Card** button to add one.
+
+    {{<image filename="images/rc/icon-add.png" width="30px" alt="The Add credit card icon." >}}
+
+    {{< embed-md "rc-credit-card-add.md" >}}
+
+1. Select **Create database** or **Confirm & pay** to create your database.
+
+{{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & Pay to create your new database." >}}
+
+When you create your database, there's a brief pause while your request is processed and then the **Database details** page appears.
+
+
+---
+Title: Create a Pro database with a new subscription
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create a Pro database with a new subscription
+linkTitle: Create Pro database (new subscription)
+weight: 10
+tocEmbedHeaders: true
+---
+
+{{< embed-md "rc-create-db-first-steps.md" >}}
+
+3. Select the type of [subscription]({{< relref "/operate/rc/subscriptions" >}}) you need. For this guide, select **Pro**. 
+
+    {{<image filename="images/rc/create-database-subscription-pro-new.png" alt="The Subscription selection panel with Pro selected.">}}
+
+    {{< note >}}
+This guide shows how to create a Pro database with a new subscription.
+- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}).
+- If you'd rather create an Essentials database, see [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}).
+    {{< /note >}}
+    
+
+After you select **Pro**, the **Database settings** section will appear.
+
+{{<image filename="images/rc/create-pro-db-settings.png" alt="The database settings section.">}}
+
+You can choose to create your database in one of two ways:
+
+- [**Easy create**](#easy-create) selects the optimal settings for you to get started faster.
+- [**Custom settings**](#custom-settings) lets you select all of the configuration options for your new database.
+
+## Create database with Easy create {#easy-create}
+
+If you choose to create your database with Easy create:
+
+{{<image filename="images/rc/pro-easy-create-vendor.png" alt="The database name, cloud vendor and region settings.">}}
+
+1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.  
+
+1. Choose a **Cloud Provider** and a **Region**.
+
+1. Enter the following settings for your database:
+
+    {{<image filename="images/rc/pro-easy-create-size-throughput.png" alt="The Dataset size, throughput, and High availability settings.">}}
+
+    | Database&nbsp;setting | Description |
+    |:---------|:-----------|
+    | **Dataset size (GB)** | The amount of data for your dataset. Specify small sizes as decimals of 1.0&nbsp;GB; example: `0.1` GB (minimum). We calculate the total memory limit for you based on the other settings you choose for your database. <br/> Databases with Search and query have specific sizing requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+    | **Throughput** | Identifies maximum throughput for the database, which is specified in terms of operations per second (**Ops/sec**). See [Throughput]({{< relref "/operate/rc/databases/configuration/sizing#throughput" >}}) for more information. <br/> Databases with Search and query have specific throughput requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+    | **High Availability** | Indicates whether a replica copy of the database is maintained in case the primary database becomes unavailable.  (Warning: doubles memory consumption). See [High Availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}).  |
+
+1. Select **View all settings** to review the database settings that we selected for you.
+
+    {{<image filename="images/rc/pro-easy-create-optimal-settings.png" alt="The optimal database settings.">}}
+
+    If you want to change these settings, select [**Switch to custom settings**](#custom-settings).
+
+1. Enter your payment details.
+
+    If you haven't previously entered a payment method, use the **Add Credit Card** button to add one.
+
+    {{<image filename="images/rc/icon-add.png" width="30px" alt="The Add credit card icon." >}}
+
+ Select **Confirm & pay** to create your database.
+
+{{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & Pay to create your new database." >}}
+
+Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes. This process generally takes 10-15 minutes.
+
+Use the **Database list** to check the status of your databases.
+
+## Create database with Custom settings {#custom-settings}
+
+{{<image filename="images/rc/create-pro-db-settings-custom.png" alt="The database settings section, with custom settings selected.">}}
+
+If you choose to create your database with custom settings, you need to:
+
+1. Set up the deployment options, including cloud vendor details, high availability settings, and advanced options.
+
+2. Define the database size requirements.
+
+3. Review your choices, provide payment details, and then create your databases.
+
+The following sections provide more information.
+
+### Set up deployment details
+
+The **Setup** tab specifies general settings for your Redis deployment.
+
+{{<image filename="images/rc/subscription-new-flexible-tabs-setup.png" width="75%" alt="The Setup tab of the new Pro Database process." >}}
+
+There are two sections on this tab:
+
+- [General settings](#general-settings) include the cloud provider details and specific configuration options.
+- [Advanced options](#advanced-options) define settings for high availability and security. Configurable settings vary according to cloud provider.
+
+#### General settings {#general-settings}
+
+{{<image filename="images/rc/subscription-new-flexible-setup-general.png" width="75%" alt="The General settings of the Setup tab." >}}
+
+In the **General settings** of the **Setup** tab, you need to:
+
+1. Select the public **Cloud vendor** to deploy your databases.
+
+1. Select the **Region** where you want to deploy your database. 
+
+    {{< note >}}
+This guide is for single region database deployment. If you want to create a multi-region Active-Active database, see [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}}) for specific steps and configuration options exclusive to Active-Active.
+    {{< /note >}}
+
+#### Advanced options {#advanced-options}
+
+{{<image filename="images/rc/subscription-new-flexible-setup-advanced.png" width="75%" alt="The Advanced settings of the Setup tab." >}}
+
+The following settings are defined in the **Advanced options** of the **Setup** tab:
+
+| Advanced option | Description |
+|---|---|
+| **Multi-AZ** | Determines if replication spans multiple Availability Zones, which provides automatic failover when problems occur. See [High Availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}). |
+| **Allowed Availability Zones** | The availability zones for your selected region.<br/><br/>If you choose **Manual selection**, you must select at least one zone ID from the **Zone IDs** list.  For more information, see [Availability zones]({{< relref "/operate/rc/databases/configuration/high-availability#availability-zones" >}}). |
+| **Cloud account** | To deploy these databases to an existing cloud account, select it here.  Use the **Add** button to add a new cloud account.<br/><br/>(Available only if [Redis Cloud Bring your own Cloud]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud" >}}) is enabled) |
+| **VPC configuration** | Select **In a new VPC** to deploy to a new [virtual private cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC).<br/><br/>To deploy these databases to an existing virtual private cloud, select **In existing VPC** and then set VPC ID to the appropriate ID value.<br/><br/>(Available only if [Redis Cloud Bring your own Cloud]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud" >}}) is enabled) |
+| **Deployment CIDR** | The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) range of IP addresses for your deployment. Redis creates a new [subnet](https://en.wikipedia.org/wiki/Subnetwork) for the **Deployment CIDR** in your [virtual private cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC). It cannot overlap with the CIDR ranges of other subnets used by your account.<br/><br/>For deployments in an existing VPC, the **Deployment CIDR** must be within your VPC's **primary** CIDR range (secondary CIDRs are not supported). |
+| **Auto Tiering**| Determines if your databases are stored only in memory (RAM) or are split between memory and Flash storage (RAM+Flash).  See [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}})|
+| **Maintenance windows** | Determines when Redis can perform [maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) on your databases. Select **Manual** if you want to set [manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}). |
+
+When finished, choose **Continue** to determine your size requirements.
+
+{{<image filename="images/rc/button-subscription-continue.png" width="100px" alt="Select the Continue button to continue to the next step." >}}
+
+### Sizing tab
+
+The **Sizing** tab helps you specify the database, memory, and throughput requirements for your subscription.
+
+{{<image filename="images/rc/subscription-new-flexible-sizing-tab.png" width="75%" alt="The Sizing tab when creating a new Pro subscription." >}}
+
+When you first visit the **Sizing** tab, there are no databases defined.  Select the **Add** button to create one.
+
+{{<image filename="images/rc/icon-add.png" width="30px" alt="Use the Add button to define a new database for your subscription." >}}
+
+This opens the **New Database** dialog, which lets you define the requirements for your new database.
+
+{{<image filename="images/rc/flexible-add-database-basic.png" width="75%" alt="The New Database dialog with basic settings." >}}
+
+By default, you're shown basic settings, which include:
+
+| Database&nbsp;setting | Description |
+|:---------|:-----------|
+| **Name** | A custom name for your database (_required_) |
+| **Version** | The Redis version for your database. We recommend you choose the latest available version. |
+| **Dataset size (GB)** | The amount of data for your dataset. Specify small sizes as decimals of 1.0&nbsp;GB; example: `0.1` GB (minimum). We calculate the total memory limit for you based on the other settings you choose for your database. <br/> Databases with Search and query have specific sizing requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **High Availability** | Indicates whether a replica copy of the database is maintained in case the primary database becomes unavailable.  (Warning: Doubles memory consumption). See [High Availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}).  |
+| **Throughput** | Identifies maximum throughput for the database, which is specified in terms of operations per second (**Ops/sec**). See [Throughput]({{< relref "/operate/rc/databases/configuration/sizing#throughput" >}}) for more information. <br/> Databases with Search and query have specific throughput requirements. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **Hashing policy** | Determines how data is distributed across multiple Redis processes of a database. Available options depend on your account creation date. See [Clustering]({{< relref "/operate/rc/databases/configuration/clustering#manage-the-hashing-policy" >}}) for more information.  |
+| **Query performance factor** | *(Search and query databases on Redis 7.2 or later only)* Adds additional compute power to process your query and vector search workloads and boost your queries per second. See [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **Data Persistence** | Defines the data persistence policy, if any. See [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence.md" >}}). |
+
+Select **More options** to specify values for the following settings.
+
+{{<image filename="images/rc/flexible-add-database-advanced.png" width="75%" alt="The New Database dialog with advanced settings." >}}
+
+| Database&nbsp;option | Description                                                                                                                                                     |
+|:---------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Advanced Capabilities** | [Advanced features and data types]({{< relref "/operate/rc/databases/configuration/advanced-capabilities" >}}) used by the database. Choose from [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}), [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}), [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}), or [Probabilistic]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}). <br/> Databases with Search and query have specific sizing requirements, see [Search and query sizing]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}) for more information. |
+| **OSS Cluster API** | Enable to use the [Redis Cluster API]({{< relref "/operate/rc/databases/configuration/clustering#oss-cluster-api" >}}).                                                                                                                |
+| **Type** | Set to **Redis**, otherwise **Memcached** database for legacy database support.                                                                                     |
+| **Supported Protocol(s)** | Choose between RESP2 and RESP3 _(Redis 7.2 only)_. See [Redis serialization protocol]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions) for details |
+| **Quantity** | Number of databases to create with these settings.                                                                                                              |
+
+When finished, select **Save configuration** to save your database configuration.
+
+{{<image filename="images/rc/button-configuration-save.png" width="140px" alt="Select the Save configuration button to define your new database." >}}
+
+Use the **Add database** button to define additional databases or select the **Continue button** to display the **Review and create** tab.
+
+Hover over a database to see the **Edit** and **Delete** icons. You can use the **Edit** icon to change a database or the **Delete** icon to remove a database from the list.
+
+{{<image filename="images/rc/icon-edit.png#no-click" width="30px" alt="Use the Edit button to change database settings." class="inline" >}}&nbsp;{{<image filename="images/rc/icon-delete-teal.png#no-click" width="30px" alt="Use the Delete button to remove a database." class="inline">}}
+
+
+### Review and Create tab
+
+The **Review & Create** tab provides a cost estimate for your Redis Cloud Pro plan:
+
+{{<image filename="images/rc/subscription-new-flexible-review.png" width="75%" alt="The Review & Create tab of the New Flexible subscription screen." >}}
+
+Redis breaks down your databases to Redis Billing Units (RBUs), each with their own size and throughput requirements. For more info, see [Billing unit types](#billing-unit-types).
+
+The **Payment methods** section of this tab shows which payment method you're using for this database. Select the arrow on the top right of this section to view all available payment methods.
+
+{{<image filename="images/rc/subscription-new-flexible-cardlist.png" width="250px" alt="The payment method list." >}}
+
+If you have not added a payment method or want to add a new payment method, select **Add credit card** to add a new credit card.
+
+{{< embed-md "rc-credit-card-add.md" >}}
+
+Select **Back to Sizing** to make changes or **Confirm & Pay** to create your databases.
+
+{{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & pay to create your database." >}}
+
+Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes. This process generally takes 10-15 minutes.
+
+Use the **Database list** to check the status of your databases.
+
+
+
+{{< embed-md "rc-pro-billing-units.md" >}}
+
+
+---
+Title: Create an Active-Active database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create an Active-Active database
+linkTitle: Create Active-Active database
+weight: 20
+aliases: 
+    - /operate/rc/subscriptions/create-active-active-subscription
+---
+
+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]({{< relref "/operate/rc/databases/configuration/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.
+
+This reduces latency for local users and improves availability should a region fail.
+
+Redis Cloud maintains consistency among instances in the background; that is, each copy eventually includes updates from every region.  As a result, memory limit and throughput increase.
+
+## Create an Active-Active database
+
+{{< embed-md "rc-create-db-first-steps.md" >}}
+
+3. Select the type of [subscription]({{< relref "/operate/rc/subscriptions" >}}) you need. For this guide, select **Pro**. 
+
+    {{<image filename="images/rc/create-database-subscription-pro-new.png" alt="The Subscription selection panel with Pro selected.">}}
+
+    {{< note >}}
+This guide shows how to create an Active-Active database with a new Pro subscription. If you already have an Active-Active subscription and want to add a database to it, see [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}). Active-Active subscriptions can host a maximum of 10 databases.
+    {{< /note >}}
+    
+
+After you select **Pro**, the **Database settings** section will appear.
+
+{{<image filename="images/rc/create-pro-db-settings-custom.png" alt="The database settings section, with custom settings selected.">}}
+
+For this guide, select **Custom settings**. For an Active-Active database, you will need to: 
+
+1. Set up the deployment options, including cloud vendor and region details for each instance.
+
+2. Define the database size requirements.
+
+3. Review your choices, provide payment details, and then create your databases.
+
+The following sections provide more information.
+
+### Set up deployment details
+
+The **Setup** tab specifies general settings for your Redis deployment.
+
+{{<image filename="images/rc/subscription-new-flexible-tabs-setup.png" width="75%" alt="The Setup tab of the new Pro Database process." >}}
+
+There are two sections on this tab:
+
+- [General settings](#general-settings) include the cloud provider details and specific configuration options.
+- [Advanced options](#advanced-options) define settings for high availability and security. Configurable settings vary according to cloud provider.
+
+#### General settings {#general-settings}
+
+Select **Active-Active (Multi-region)** to turn on Active-Active. 
+
+{{<image filename="images/rc/create-flexible-sub-active-active-on.png" width="75%" alt="The general settings of the setup tab with Active-Active selected." >}}
+
+When you enable Active-Active Redis, two regions are selected by default. Select the drop-down arrow to display a list of provider regions that support Active-Active databases.
+
+{{<image filename="images/rc/create-sub-active-active-regions.png" width="50%" alt="Use the Region drop-down to select the regions for your Active-Active database." >}}
+
+    {{< note >}}
+Active-Active subscriptions on Redis Cloud are limited to a maximum of 10 regions.
+    {{< /note >}}
+
+Use the checkboxes in the list to select or remove regions.  The Search box lets you locate specific regions.
+
+You can use a region's Remove button to remove it from the list.
+
+{{<image filename="images/rc/icon-region-delete.png" width="30px" alt="Select the Delete button to remove a region from the list." >}}
+
+#### Advanced options {#advanced-options}
+
+{{<image filename="images/rc/create-sub-active-active-cidr.png" width="75%" alt="Each region needs a unique CIDR address block to communicate securely with other instances." >}}
+
+In the **Advanced options** section, you can:
+    
+- Define CIDR addresses for each region in the **VPC configuration** section.
+
+    Every CIDR should be unique to properly route network traffic between each Active-Active database instance and your consumer VPCs. The CIDR block regions should _not_ overlap between the Redis server and your app consumer VPCs. In addition, CIDR blocks should not overlap between cluster instances. 
+
+    When all **Deployment CIDR** regions display a green checkmark, you're ready to continue.  
+
+    {{<image filename="images/rc/icon-cidr-address-ok.png" width="30px" alt="Green checkmarks indicate valid CIDR address values." >}}
+
+    Red exclamation marks indicate error conditions; the tooltip provides additional details.
+
+    {{<image filename="images/rc/icon-cidr-address-error.png" width="30px" alt="Red exclamation points indicate CIDR address problems." >}} 
+
+- Set your [maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) settings in the **Maintenance windows** section. Select **Manual** if you want to set [manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}).
+
+When finished, choose **Continue** to determine your size requirements.
+
+{{<image filename="images/rc/button-subscription-continue.png" width="100px" alt="Select the Continue button to continue to the next step." >}}
+
+### Sizing tab
+
+The **Sizing** tab helps you specify the database, memory, and throughput requirements for your subscription.
+
+{{<image filename="images/rc/subscription-new-flexible-sizing-tab.png" width="75%" alt="The Sizing tab when creating a new Pro subscription." >}}
+
+When you first visit the **Sizing** tab, there are no databases defined.  Select the **Add** button to create one.
+
+{{<image filename="images/rc/icon-add.png" width="30px" alt="Use the Add button to define a new database for your subscription." >}}
+
+This opens the **New Active-Active Redis Database** dialog, which lets you define the requirements for your new database.
+
+{{<image filename="images/rc/create-database-active-active.png" width="75%" alt="New database dialog for Active-Active database." >}}
+
+By default, you're shown basic settings, which include:
+
+- **Name**: A custom name for your database.
+- **Version**: The Redis version for your database. We recommend you choose the latest available version. 
+- **Advanced Capabilities**: Advanced data types or features used by the database. Active-Active databases support the [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}) data type and [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) features.
+
+    {{<image filename="images/rc/active-active-json-detail.png" width="75%" alt="When you create an Active-Active database, you can select the JSON and Search and query advanced capabilities." >}}  
+
+    We select both capabilities for you automatically. You can remove a capability by selecting it. Selected capabilities will be available in all regions, including those added in the future.
+
+    See [Search and query Active-Active databases]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/search-active-active" >}}) to learn how to use Search and query on Active-Active databases.
+
+- **Dataset size**: The amount of data needed for your dataset in GB. 
+
+    For Search and query databases, use the [Sizing calculator](https://redis.io/redisearch-sizing-calculator/) to estimate your index size and throughput requirements. When you're entering the dataset size for your database, add the estimated index size from the Sizing calculator to your expected dataset size.
+
+- **Hashing policy**: Determines how data is distributed across multiple Redis processes of a database. Available options depend on your account creation date. See [Clustering]({{< relref "/operate/rc/databases/configuration/clustering#manage-the-hashing-policy" >}}) for more information.
+
+- **Throughput**: When you create an Active-Active database, you define the throughput for each instance. The total operations per second combines the total read ops/sec and applies the write ops/sec for each region across every region. 
+
+    {{<image filename="images/rc/active-active-throughput-detail.png" width="75%" alt="When you create an Active-Active database, you define throughput for each region." >}}
+    
+    Because each instance needs the ability to write to every other instance, write operations significantly affect the total, as shown in the following table:
+
+    | Number of regions | Read operations | Write operations | Total operations |
+    |:-----------------:|:---------------:|:----------------:|:----------------:|
+    | Two | 1,000 each | 1,000 each | 6,000<br/>(2,000 reads; 4,000 writes) |
+    | Two | 1,500 each | 1,000 each | 7,000<br/>(3,000 reads; 4,000 writes) |
+    | Two | 1,000 each | 1,500 each | 8,000<br/>(2,000 reads; 6,000 writes) |
+    | Three | 1,000 each | 1,000 each | 12,000<br/>(3,000 reads; 9,000 writes) |
+
+    For Search and query databases, the estimated throughput from the [Sizing calculator](https://redis.io/redisearch-sizing-calculator/) is the total amount of throughput you need. When setting throughput for your Active-Active database, use the total amount for each region and divide it depending on your read (query) and write (update) needs for each region. For example, if the total amount of throughput needed is 50000 ops/sec, you could set each region to have 20000 ops/sec for reads (queries) and 30000 ops/sec for writes (updates).
+
+- **Data Persistence**: Defines the data persistence policy, if any. See [Database persistence]({{< relref "/operate/rs/databases/configure/database-persistence.md" >}}).
+- **Supported Protocol(s)**: Choose between RESP2 and RESP3 _(Redis 7.2 only)_. See [Redis serialization protocol]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions) for details.
+- **Quantity**: Number of databases to create with these settings. 
+
+When finished, select **Save configuration** to save your database configuration.
+
+{{<image filename="images/rc/button-configuration-save.png" width="140px" alt="Select the Save configuration button to define your new database." >}}
+
+Use the **Add database** button to define additional databases or select the **Continue button** to display the **Review and create** tab.
+
+Hover over a database to see the **Edit** and **Delete** icons. You can use the **Edit** icon to change a database or the **Delete** icon to remove a database from the list.
+
+{{<image filename="images/rc/icon-edit.png#no-click" width="30px" alt="Use the Edit button to change database settings." class="inline" >}}&nbsp;{{<image filename="images/rc/icon-delete-teal.png#no-click" width="30px" alt="Use the Delete button to remove a database." class="inline">}}
+
+
+### Review and Create tab
+
+The **Review and Create** tab provides a cost estimate for your Redis Cloud Pro plan:
+
+{{<image filename="images/rc/create-pro-aa-review.png" width="75%" alt="The Review & Create tab of the New Active-Active subscription screen." >}}
+
+Redis breaks down your databases to Redis Billing Units (RBUs), each with their own size and throughput requirements. For more info, see [Billing unit types]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}#billing-unit-types).
+
+The **Payment methods** section of this tab shows which payment method you're using for this database. Select the arrow on the top right of this section to view all available payment methods.
+
+{{<image filename="images/rc/subscription-new-flexible-cardlist.png" width="250px" alt="The payment method list." >}}
+
+If you have not added a payment method or want to add a new payment method, select **Add credit card** to add a new credit card.
+
+{{< embed-md "rc-credit-card-add.md" >}}
+
+Select **Back to Sizing** to make changes or **Confirm & Pay** to create your databases.
+
+{{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & pay to create your database." >}}
+
+Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes. This process generally takes 10-15 minutes.
+
+Use the **Database list** to check the status of your databases.
+
+## More info
+
+- [Create a Pro database with a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}})
+- [Active-Active Redis]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}})
+- [Develop applications with Active-Active databases]({{< relref "/operate/rs/databases/active-active/develop/_index.md" >}})
+- Database [memory limit]({{< relref "/operate/rc/databases/configuration/sizing#dataset-size" >}})
+- Redis Cloud [subscription plans]({{< relref "/operate/rc/subscriptions/" >}})
+- [Redis Cloud pricing](https://redis.io/pricing/#monthly)
+
+---
+Title: Create a Redis Flex database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create an Redis Flex database on Redis Cloud and describes the best use cases for Redis Flex. 
+linkTitle: Create Redis Flex database
+weight: 8
+tocEmbedHeaders: true
+---
+
+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 currently available in preview on Redis Cloud Essentials. 
+
+## Redis Flex use cases
+
+The benefits associated with Redis Flex are dependent on the use case.
+
+Redis Flex is ideal when your:
+
+- working set is significantly smaller than your dataset (high RAM hit rate)
+- average key size is smaller than average value size (all key names are stored in RAM)
+- most recent data is the most frequently used (high RAM hit rate)
+
+Redis Flex is not recommended for:
+
+- Long key names (all key names are stored in RAM)
+- Broad access patterns (any value could be pulled into RAM)
+- Large working sets (working set is stored in RAM)
+- Frequently moved data (moving to and from RAM too often can impact performance)
+
+Redis Flex is not intended to be used for persistent storage.
+
+## Where is my data?
+
+When using Redis Flex, RAM storage holds:
+- All keys (names)
+- Key indexes
+- Dictionaries
+- Hot data (working set)
+
+All data is accessed through RAM. If a value in flash memory is accessed, it becomes part of the working set and is moved to RAM. These values are referred to as “hot data”.
+
+Inactive or infrequently accessed data is referred to as “warm data” and stored in flash memory. When more space is needed in RAM, warm data is moved from RAM to flash storage.
+
+## Create a Redis Flex database on Redis Cloud Essentials
+
+{{< embed-md "rc-create-db-first-steps.md" >}} 
+
+3. Select the type of [subscription]({{< relref "/operate/rc/subscriptions" >}}) you need. For this guide, select **Redis Flex**.
+
+    {{<image filename="images/rc/create-database-subscription-flex.png" alt="The Subscription selection panel with Redis Flex selected.">}}
+
+    {{< note >}}
+This guide shows how to create a Redis Flex database on Redis Cloud Essentials.
+- If you'd rather create a Redis on RAM Essentials database, see [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}).
+- If you'd rather create a Pro database, see [Create a Pro database with a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}).
+- If you already have a Pro subscription and want to add a database to it, see [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}).
+    {{< /note >}}
+    
+    After you select **Redis Flex**, the rest of the database details will appear.
+
+    {{<image filename="images/rc/create-database-essentials-cloud-vendor.png" alt="The database name, cloud vendor, region, and type settings.">}}
+
+1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.  
+
+1. Choose a **Region** on Amazon Web Services for your database.
+
+1. In the **Durability settings** panel, choose your **High availability settings** and **Data persistence** settings from the list. 
+
+    {{<image filename="images/rc/create-database-essentials-durability.png" alt="The durability settings allow you to choose High availability and Data persistence." width=75% >}}
+
+
+    Redis Cloud supports the following high availability settings:
+
+    - **None**: You will have a single copy of your database without replication.
+    - **Single-Zone**: Your database will have a primary and a replica located in the same cloud zone. If anything happens to the primary, the replica takes over and becomes the new primary.
+    - **Multi-Zone**: The primary and its replicas are stored in different zones. This means that your database can remain online even if an entire zone becomes unavailable.
+
+    See [High availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) for more information about these settings.
+
+    Redis Cloud supports the following Data persistence options:
+
+    - An **Append-Only File** maintains a record (sometimes called a _redo log_ or _journal_) of write operations.  This allows the data to be restored by using the record to reconstruct the database up to the point of failure. For Essentials databases, Redis updates the Append-Only file every second.
+
+    - A **Snapshot** is a copy of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time. 
+    
+    See [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) for more information about these settings.
+    
+1. Select the desired memory limit. 
+
+    {{<image filename="images/rc/subscription-new-flex-tiers.png" alt="Available Redis Flex plans." >}}
+
+    For a comparison of available plans, see [Redis Cloud Essentials plans]({{< relref "/operate/rc/subscriptions/view-essentials-subscription/essentials-plan-details" >}}).
+
+1.  Enter your payment details.
+
+    If you haven't previously entered a payment method, use the **Add Credit Card** button to add one.
+
+    {{<image filename="images/rc/icon-add.png" width="30px" alt="The Add credit card icon." >}}
+
+    {{< embed-md "rc-credit-card-add.md" >}}
+
+1. Select **Confirm & pay** to create your database.
+
+{{<image filename="images/rc/button-create-db-confirm-pay.png" width="140px" alt="Select Confirm & Pay to create your new database." >}}
+
+When you create your database, there's a brief pause while your request is processed and then the **Database details** page appears.
+---
+Title: Create a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+linkTitle: Create database
+weight: 10
+---
+
+A database is the heart of any Redis Cloud deployment. 
+
+The process for Creating a database depends on the type of [subscription plan]({{< relref "/operate/rc/subscriptions" >}}) you need.
+
+An **Essentials** plan is a fixed monthly price for a single database. It is cost-efficient and designed for low-throughput scenarios. It supports a range of availability, persistence, and backup options. Pricing supports low throughput workloads.
+- [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}})
+- [Create a Redis Flex database]({{< relref "/operate/rc/databases/create-database/create-flex-database" >}})
+
+A **Pro** plan is an hourly price based on capacity. It supports more databases, larger databases, greater throughput, and unlimited connections. 
+- [Create a Pro database with a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}})
+- [Create a Pro database in an existing subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}})
+- [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}})
+
+
+---
+LinkTitle: AWS Marketplace
+Title: Sign up for Redis Cloud with AWS Marketplace
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to subscribe to Redis Cloud using AWS Marketplace
+hideListLinks: true
+weight: 20
+---
+
+You can use AWS Marketplace to subscribe to Redis Cloud through AWS Marketplace.  This lets you provision according to your needs and pay using your AWS account.
+
+## Subscribe to Redis Cloud with AWS Marketplace
+
+Here's how to subscribe to Redis Cloud with AWS Marketplace:
+
+1.  Sign in to the [AWS console](https://console.aws.amazon.com/).
+
+1.  Search AWS Marketplace for [Redis Cloud (Pay-As-You-Go with 14-day FREE TRIAL)](https://aws.amazon.com/marketplace/pp/prodview-mwscixe4ujhkq) and subscribe to the listing.
+
+    {{<image filename="images/rc/aws-marketplace-rc-flexible-plan.png" alt="The Redis Cloud listing on AWS Marketplace" >}}
+
+    Or, click on the URL provided by your Redis seller for a private offer for [Redis Cloud - Annual Commits](https://aws.amazon.com/marketplace/pp/prodview-e6y7ork67pjwg?sr=0-3&ref_=beagle&applicationId=AWSMPContessa) and accept the private offer.
+
+1.  Locate the **Set Up Your Account button**, and then select it to begin mapping your Redis Cloud account with your AWS Marketplace account.
+
+    {{<image filename="images/rc/aws-marketplace-account-setup-button.png" alt="Use the Set Up Your Account button after subscribing to Redis Cloud with your AWS Marketplace account." width="50%">}}
+
+1.  Sign in to the [Redis Cloud console](https://cloud.redis.io). If you do not yet have an account, you will need to create one. You must have the **Account Owner** role.
+
+1.  Select the Redis account(s) to be mapped to your AWS Marketplace account and confirm that your Marketplace account will pay for your Redis Cloud resources going forward.
+
+    {{<image filename="images/rc/aws-marketplace-map-account-dialog.png" alt="Use the AWS Marketplace dialog to map your Redis Cloud account to your AWS Marketplace account." width="80%">}}
+
+1.  Use the **Connect account** button to confirm your choice.
+
+    {{< note >}}
+You must complete this step to bill your Redis Cloud resources to your AWS Marketplace account.
+    {{< /note >}}
+
+1.  Once your Redis account is mapped to your AWS Marketplace account, a message appears in the upper, left corner of the account panel.
+
+    {{<image filename="images/rc/aws-marketplace-billing-badge.png" alt="The AWS Marketplace badge appears when your Redis Cloud account is mapped to an AWS Marketplace account." width="150px">}}
+
+    In addition, AWS Marketplace is reported as the selected payment method.
+
+At this point, you can create a new database using the [standard workflow]({{< relref "/operate/rc/databases/create-database" >}}), with one important change. You don't need to enter a payment method, as it's automatically assigned to your AWS Marketplace account.
+
+To confirm this, review the payment method associated with your subscription.
+
+If your AWS Marketplace account is deactivated or otherwise unavailable, you won't be able to use your databases until the billing method is updated.  For help, [contact support](https://redis.io/support/).
+
+## Add additional Redis accounts to AWS Marketplace
+
+If you are the owner of more than one Redis Cloud account and have already associated your AWS marketplace account with one or more of your Redis accounts, you can add your AWS marketplace account to your other Redis Cloud accounts.
+
+{{< embed-md "rc-marketplace-account-add.md" >}}---
+LinkTitle: Vercel Marketplace
+Title: Create a Redis Cloud database with the Vercel integration
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to create a Redis Cloud database with Vercel integration.
+hideListLinks: true
+weight: 66
+---
+
+The [Redis Cloud Vercel integration](https://vercel.com/marketplace/redis-cloud) lets you create a new Redis database from your Vercel account and connect it to your Vercel project(s).
+
+## Create database
+
+1. Log in to your Vercel account (or create a new one).
+
+1. Navigate to the **Storage** tab and select **Create database**.
+    {{<image filename="/images/rc/vercel-storage-create-database-button.png" alt="Storage - Create Database">}}
+
+1. Under **Storage partners**, select **View all partners**.
+    {{<image filename="/images/rc/vercel-redis-cloud-partners.png" alt="Browse storage" width=400px >}}
+
+1. Find **Redis Cloud** and select **Continue**.
+
+1. In the **Create Database** dialog, select your plan and **Continue**.
+
+    {{<image filename="/images/rc/vercel-create-db-select-plan.png" alt="Create database">}}
+
+    More configuration options are coming soon, such as region selection and multi-zone high availability.
+
+1. Enter your database name or use the automatically generated name.
+
+1. Select **Create**.
+
+## Connect to your database
+
+After creation, you will see your database details. After provisioning is complete, the status will change from `Initializing` to `Available` (you may need to refresh your browser).
+
+{{<image filename="/images/rc/vercel-status-available.png" alt="Vercel database details">}}
+
+You can use the connection string shown under **Quickstart** to [connect to your database]({{<relref "operate/rc/databases/connect">}}).
+
+## Link database to your project
+
+1. Navigate to the **Storage** tab.
+1. Find your new database in the list of your team's databases.
+1. Select **Connect Project**.
+    {{<image filename="/images/rc/vercel-connect-project-button.png" alt="Connect Project button">}}
+1. Choose your project and environments and select **Connect**.
+    {{<image filename="/images/rc/vercel-connect-project.png" alt="Connect project">}}
+
+## Manage your database
+
+From the database details page, you can make edits to your database under **Settings**.
+
+More configuration options are coming soon, including plan changes, multi-zone high availability, and region selection.
+
+### Configure from Redis Cloud
+
+You can also edit some configuration options in Redis Cloud.
+
+From the database detail page, select **Open in Redis Cloud**.
+
+{{<image filename="/images/rc/vercel-open-in-redis-cloud.png" alt="Open in Redis">}}
+
+Your Redis Cloud account is linked to your Vercel account. All your team's Redis databases will be listed under **Databases** in Redis Cloud.
+
+Select your new database to make configuration changes such as passwords or the eviction policy.
+
+{{<note>}} The [eviction policy]({{<relref "/operate/rc/databases/configuration/data-eviction-policies">}}) defaults to `no eviction` for new databases.  You can change this by [editing the database details]({{<relref "/operate/rc/databases/view-edit-database">}}).{{</note>}}
+---
+LinkTitle: Team management
+Title: Google Cloud Marketplace team management
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to add users in a legacy version of the Google Cloud Marketplace
+  subscription.
+weight: $weight
+---
+
+{{<banner-article bannerColor="#fff8dc">}}
+This article applies to an earlier Google Cloud marketplace listing. For the current [Redis Cloud - Pay as You Go](https://console.cloud.google.com/marketplace/product/redis-marketplace-isaas/redis-enterprise-cloud-flexible-plan) listing, manage your team through the [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) screen. See [Sign up for Redis Cloud with Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) for more information.
+{{</banner-article>}}
+
+If you subscribed to Redis Cloud through Google Cloud Marketplace using the **Redis Cloud** listing, use the IAM section of the Google Cloud console to manage your team.
+
+To grant Redis Cloud access to a Google Cloud user, select **Add** to add a member, insert the email address, and then assign the following roles to the user:
+- To designate a viewer, assign `editor`, `serviceusage.serviceUsageViewer`, and `redisenterprisecloud.viewer`
+- To designate an owner, assign `editor`, `serviceusage.serviceUsageViewer`, and `redisenterprisecloud.admin`
+
+
+If these roles are not available, you can add them to your project.
+
+1. Select **Manage Roles**.
+2. Use the filter table field to locate the role. (Search for “service usage viewer” or “Redis Cloud admin”.)
+3. Select the role.
+4. Select **Create role from selection** and then select **Create**.
+5. Use IAM to add a member and assign the desired role.
+
+Users must sign in to Redis Cloud using their single sign-on credentials before they appear in the team member list.
+---
+LinkTitle: Google Cloud Marketplace
+Title: Sign up for Redis Cloud with Google Cloud Marketplace
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to subscribe to Redis Cloud using Google Cloud marketplace
+hideListLinks: true
+weight: 30
+---
+
+You can use Google Cloud marketplace to subscribe to Redis Cloud. This lets you provision according to your needs and pay using your Google Cloud account.
+
+## Subscribe to Redis Cloud using Google Cloud marketplace
+
+Here's how to subscribe to Redis Cloud with Google Cloud marketplace:
+
+1.  Sign in to the [Google Cloud console](https://console.cloud.google.com/).
+
+1. Identify the Google Cloud Billing account that will subscribe to Redis Cloud. This account must have one of the following sets of Identity and Access Management (IAM) Roles:
+
+    - [Billing Administrator](https://cloud.google.com/billing/docs/how-to/billing-access#overview-of-cloud-billing-roles-in-cloud-iam) (`roles/billing.admin`), OR
+    - [Billing User](https://cloud.google.com/billing/docs/how-to/billing-access#overview-of-cloud-billing-roles-in-cloud-iam) (`roles/billing.user`) AND [Consumer Procurement Order Administrator](https://cloud.google.com/marketplace/docs/access-control#roles-permissions)
+
+    If you don't have the correct roles, request access from your Google Cloud Billing Administrator or Organization Administrator. For more information about granting roles, see [Access control for Google Cloud Marketplace](https://cloud.google.com/marketplace/docs/access-control).
+
+1.  Search Google Cloud Marketplace for [Redis® Cloud Cache and Vector Database](https://console.cloud.google.com/marketplace/product/redis-marketplace-isaas/redis-enterprise-cloud-flexible-plan).
+
+    {{<image filename="images/rc/gcp-marketplace-rc-payg-plan.png" alt="The Redis Cloud - Pay as You Go plan listing on Google Cloud Marketplace" >}}
+
+    Alternatively, in the navigation panel, select **View all products** and select **Redis Cloud** under **Databases**. You can pin Redis Cloud for easy access.
+
+    Or, click on the URL provided by your Redis seller for a private offer for [Redis® Cloud Cache and Vector Database](https://console.cloud.google.com/marketplace/product/redis-marketplace-isaas/redis-enterprise-cloud-flexible-plan) and accept the private offer.
+
+1.  Select the **Subscribe** button. This redirects you to the subscription details page.
+
+1. Under **Purchase Details**, select the Google Cloud Billing account that will subscribe to Redis Cloud. Review the subscription details, accept the terms, and select **Subscribe**.
+
+1. When you subscribe for the first time, select **Sign Up with Redis**. This will redirect you to the [Redis Cloud console](https://cloud.redis.io).
+
+1. Create a Redis Cloud account or sign in to an existing account. You must have the **Account Owner** role.
+
+1.  Select the Redis account to be mapped to your GCP Marketplace account and confirm that your Marketplace account will pay for your Redis Cloud resources going forward.
+
+    {{<image filename="images/rc/gcp-marketplace-map-account-dialog.png" alt="Use the GCP Marketplace dialog to map your Redis Cloud account to your Google Cloud Marketplace account." width="75%">}}
+
+1.  Select **Connect account** to confirm your choice.
+
+    {{< note >}}
+You must complete this step to bill your Redis Cloud resources to your Google Cloud Marketplace account.
+    {{< /note >}}
+
+1.  After you connect your Redis account to your Google Cloud Marketplace account, a message appears in the upper left corner of the account panel.
+
+    {{<image filename="images/rc/gcp-marketplace-billing-badge.png" alt="The Google Cloud Marketplace badge appears when your Redis Cloud account is mapped to a Google Cloud Marketplace account.">}}
+
+1. On the Google Cloud Marketplace listing, select **Manage on provider** to go to the [Redis Cloud console](https://cloud.redis.io).
+
+    {{<image filename="images/rc/gcp-marketplace-manage-on-provider.png" alt="The Manage on Provider button" >}}
+
+At this point, you can create a new database using the [standard workflow]({{< relref "/operate/rc/databases/create-database" >}}), with one important change. You don't need to enter a payment method, as it automatically uses your Google Cloud Marketplace account.
+
+To confirm this, review the payment method associated with your subscription.
+
+Additional users can be added on the Redis Cloud console using the [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) page.
+
+If your Google Cloud Marketplace account is deactivated or otherwise unavailable, you can't use your subscription until you update the billing method.  For help, [contact support](https://redis.io/support/).
+
+## Add additional Redis accounts to Google Cloud marketplace
+
+If you are the owner of more than one Redis Cloud account and have already associated your Google Cloud marketplace account with one or more of your Redis accounts, you can add your Google Cloud marketplace account to your other Redis Cloud accounts.
+
+{{< embed-md "rc-marketplace-account-add.md" >}}---
+LinkTitle: Marketplace integrations
+Title: Manage marketplace integrations
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes how to integrate Redis Cloud subscriptions into existing cloud
+  provider services, whether existing subscriptions or through vendor marketplaces.
+hideListLinks: true
+weight: 40
+---
+
+By default, Redis Cloud subscriptions are hosted in cloud vendor accounts owned and managed by Redis.
+
+To integrate Redis Cloud into an existing cloud vendor account, you can:
+
+- Subscribe to Redis Cloud through [AWS Marketplace]({{< relref "/operate/rc/cloud-integrations/aws-marketplace/" >}}).
+
+- Subscribe to Redis Cloud through [Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}).
+
+When you subscribe to Redis Cloud through a cloud vendor marketplace, billing is handled through the marketplace.
+
+Redis also offers monthly and annual commitments through cloud vendor marketplaces. [Contact sales](https://redis.io/meeting/) if you're interested in a monthly or annual offer.
+
+## Marketplace billing considerations
+
+Cloud vendor marketplaces provide a convenient way to handle multiple subscription fees.  However, this also means that billing issues impact multiple subscriptions, including Redis Cloud.
+
+When billing details change, you should verify that each service is operating normally and reflects the updated billing details.  Otherwise, you might experience unexpected consequences, such as data loss or subscription removal.
+
+For best results, we recommend:
+
+- [Backing up all data]({{< relref "/operate/rc/databases/back-up-data" >}}) _before_ updating billing details.
+
+- Contacting [support](https://redis.io/support/) or your account team for assistance.---
+Title: Redis Cloud quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Quick start
+weight: 10
+---
+
+If you're new to Redis Cloud, this quick start helps you get up and running.  
+
+You'll learn how to:
+
+1.  Create an account and a free database
+
+1.  Connect to your database
+
+If you already have an account, see [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-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]({{< relref "/operate/rc/databases/" >}}).
+
+## Create an account
+
+To create a new account with a free database:
+
+1. Go to the [Sign up](https://redis.io/try-free/) page.
+
+1. There are two options available to get started with Redis Cloud:
+   * Enter your information in the form and select **Get Started**.
+   * Sign up with **Google** or **Github**.
+
+1. After you enter your information, you should receive an activation email from Redis. Select **Activate account** to go to the **Create your database** page in the [Redis Cloud console](https://cloud.redis.io).
+
+1. Select whether you want an **Essentials** or a **Pro** plan.
+
+    - A Redis Cloud Essentials plan contains a single database designed for low-throughput scenarios. Your free database will have 30 MB of space for you to learn Redis concepts and develop application prototypes.
+
+        If you select **Essentials**, you can choose your cloud provider and region, and then select **Get started** to create your database.
+
+        {{<image filename="images/rc/quickstart-essentials.png" width="75%" alt="Create your database with Essentials selected." >}}
+
+        {{< note >}}
+If you would rather customize your database, select **See more plans** to go to the **New database** page. From there, you can [Create a database]({{< relref "/operate/rc/databases/create-database" >}}).
+        {{< /note >}}
+
+        You'll go directly to your new database's **Configuration** tab.
+
+        {{<image filename="images/rc/quickstart-database-overview.png" width="75%" alt="Configuration tab showing details of your new database." >}}
+
+    - A Redis Cloud Pro plan supports more databases, larger databases, greater throughput, and unlimited connections compared to Redis Cloud Essentials; as well as more security and connectivity options. You'll get started with a $400 credit to set up your database. 
+
+        If you select **Pro**, you can choose your cloud provider and region, and then select **Start with $400 credit** to go to the **New database** page.
+
+        {{<image filename="images/rc/quickstart-pro.png" width="75%" alt="Create your database with Pro selected." >}}
+
+        From there, see [Create a Redis Cloud Pro database]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) to learn how to finish setting up your Pro database.
+
+    See [Subscriptions]({{< relref "/operate/rc/subscriptions" >}}) for more information about the available plans.
+
+1.  In the upper corner, an icon shows the current status of the database.  If the icon shows an orange clock, this means your database is still being created and its status is _pending_.
+
+       {{< image filename="/images/rc/icon-database-update-status-pending.png#no-click" alt="Pending database status" class="inline" >}} {{< image filename="/images/rc/icon-database-status-active.png#no-click" alt="Active database status" class="inline">}}</nobr>
+
+       Once the database has been created, it becomes _active_ and the status indicator switches to a green circle containing a checkmark.  
+
+    Redis Cloud console operations are asynchronous; they operate [in the background]({{< relref "/operate/rc/api/get-started/process-lifecycle.md" >}}).  You can continue to use the Redis Cloud console for other tasks, but pending resources aren't available until they're active.
+
+    When your new database becomes active, you're ready to connect to it.
+
+## Connect to a database
+
+At this point, you're viewing the **Configuration** details for your new database. Go to the **Security** section of the page.
+
+To connect to your database, you need your username and password. Each database is protected by a **Default user** called `default` and a masked **Default user password**. Select the eye icon to show or hide the password.    
+
+{{<image filename="images/rc/database-fixed-configuration-security.png" width="75%" alt="The Security section of the Configuration tab of the database details page." >}}
+
+Once you have the username and password, select **Connect** to open the connection wizard.
+
+{{< image filename="/images/rc/button-connect.png#no-click" alt="Connect button." >}}
+
+The connection wizard provides the following database connection methods:
+
+- [Redis Insight](#using-redisinsight)
+
+- [`redis-cli`](#using-rediscli) utility
+
+- [Redis client](#using-redis-client) for your preferred programming language
+
+
+{{<image filename="images/rc/connection-wizard.png" alt="The connection wizard." width=500px >}}
+
+### Redis Insight{#using-redisinsight}
+
+[Redis Insight]({{< relref "/develop/tools/insight" >}}) is a free Redis GUI that lets you visualize your Redis data and learn more about Redis.
+
+You can connect to your database with Redis Insight in two ways:
+
+1. [Open your database in Redis Insight in your browser](#ri-browser).
+
+1. [Download and Install Redis Insight](#ri-app) on Windows, macOS, and Linux.
+
+#### Open in your browser {#ri-browser}
+
+{{< note >}}
+Opening your database with Redis Insight in your browser is currently available for some Essentials databases, and will be available to more Essentials databases over time. 
+{{< /note >}}
+
+If Redis Insight on Redis Cloud is available for your database, select **Launch Redis Insight web** from the connection wizard to open it.
+
+{{<image filename="images/rc/rc-ri-wizard-launch.png" alt="Launch Redis Insight web from the Connection Wizard." width=500px >}}
+
+You can also select **Launch** from the database page under **View and manage data with Redis Insight** to open Redis Insight in your browser.
+
+{{<image filename="images/rc/rc-ri-open.png" alt="Launch Redis Insight web from the database page." width=500px >}}
+
+Redis Insight will open in a new tab. 
+
+From there, you can:
+
+- Select **Load sample data** to add sample data into your database.
+    {{<image filename="images/rc/rc-ri-load-data.png" alt="Load Sample Data button" width=300px >}}
+- Select **Explore** to learn how to use Redis.
+    {{<image filename="images/rc/rc-ri-explore-icon.png" alt="The Explore icon" >}}
+
+For more information on how to use Redis Insight in your browser, see [Open with Redis Insight on Redis Cloud]({{< relref "/operate/rc/databases/connect/insight-cloud" >}}).
+
+#### Install and open on your computer {#ri-app}
+
+1. In the connection wizard, under **Redis Insight**, select **Download** to download Redis Insight.
+
+1. [Install Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+1. Once installed, select **Open in desktop**.
+
+1. A pop-up asks if you wish to open the link with Redis Insight. Select **Open Redis Insight** to connect to your database with Redis Insight.
+
+
+See the [Redis Insight docs]({{< relref "/develop/tools/insight" >}}) for more info.
+
+### Redis client{#using-redis-client}
+
+A Redis client is a software library or tool that enables applications to interact with a Redis server. Each client has its own syntax and installation process. For help with a specific client, see the client's documentation.
+
+The connection wizard provides code snippets to connect to your database with the following programming languages:
+
+- .NET using [NRedisStack]({{< relref "/develop/clients/dotnet" >}})
+- node.js using [node-redis]({{< relref "/develop/clients/nodejs" >}})
+- Python using [redis-py]({{< relref "/develop/clients/redis-py" >}})
+- Java using [Jedis]({{< relref "/develop/clients/jedis" >}}) and [Lettuce]({{< relref "/develop/clients/lettuce" >}})
+- Go using [go-redis]({{< relref "/develop/clients/go" >}})
+- PHP using [Predis]({{< relref "/develop/clients/php" >}})
+
+{{<image filename="images/rc/connection-wizard-clients.png" alt="The connection wizard clients." width=500px >}}
+
+See [Clients]({{< relref "/develop/clients" >}}) to learn how to connect with the official Redis clients.
+
+See the following guides to get started with different Redis use cases:
+- [Data structure store]({{< relref "/develop/get-started/data-store" >}})
+- [Document database]({{< relref "/develop/get-started/document-database" >}})
+- [Vector database]({{< relref "/develop/get-started/vector-database" >}})
+- [RAG with Redis]({{< relref "/develop/get-started/rag" >}})
+- [Redis for AI]({{< relref "/develop/ai" >}})
+
+### redis-cli {#using-rediscli}
+
+The [`redis-cli`]({{< relref "/develop/tools/cli" >}}) utility is installed when you install Redis.  It provides a command-line interface that lets you work with your database using core [Redis commands]({{< relref "/commands" >}}).
+
+To run `redis-cli`, [install Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) on your machine.
+
+See [Redis CLI]({{< relref "/develop/tools/cli" >}}) to learn how to use `redis-cli`.
+
+## More info
+
+- [Connect your application]({{< relref "/develop/clients" >}})
+- [Import data]({{< relref "/operate/rc/databases/import-data.md" >}})
+- [Manage databases]({{< relref "/operate/rc/databases" >}})
+- [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence.md" >}})
+- [Secure your Redis Cloud database]({{< relref "/operate/rc/security/" >}})
+- [Back-up databases]({{< relref "/operate/rc/databases/back-up-data.md" >}})
+- [Monitor Redis Cloud performance]({{< relref "/operate/rc/databases/monitor-performance.md" >}})
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Redis Cloud changelog (January 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  January 2023.
+highlights: Pub/sub ACLs, multiple availability zones, add users with first and last
+  names
+linktitle: January 2023
+weight: 90
+aliases:
+  - /operate/rc/changelog/january-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during January 2023.
+
+## New features and enhancements
+
+- [Pub/sub ACLs]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls#pubsub-acl-rules" >}})
+
+- Add users with first name and last name
+
+- Select multiple [availability zones]({{< relref "/operate/rc/databases/configuration/high-availability#availability-zones" >}})
+
+- Additional enhancements---
+Title: Redis Cloud changelog (May 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  May 2023.
+highlights: Cloud API Fixed plans support, Active-Active ACL roles
+linktitle: May 2023
+weight: 86
+aliases:
+  - /operate/rc/changelog/may-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during May 2023.
+
+## New features and enhancements
+
+### Cloud API - Fixed plans support
+
+The [Redis Cloud API]({{< relref "/operate/rc/api" >}}) supports new endpoints to manage fixed subscriptions and databases. 
+
+The new fixed endpoints can be viewed in the [Redis Cloud Swagger UI](https://api.redislabs.com/v1/swagger-ui/index.html#/Subscriptions%20-%20Fixed). For more information about using the Redis Cloud API, see [Use the REST API]({{< relref "/operate/rc/api/get-started/use-rest-api" >}}).
+
+### Active-Active access roles
+
+For [Active-Active databases]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}), you can now define roles with different levels of access for different regions.
+
+For more information, see [Active-Active roles]({{< relref "/operate/rc/security/access-control/data-access-control/active-active-roles" >}}).---
+Title: Redis Cloud changelog (March 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  March 2023.
+highlights: Redis 7.0 preview
+linktitle: March 2023
+weight: 88
+aliases:
+  - /operate/rc/changelog/march-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during March 2023.
+
+## New features and enhancements
+
+### Redis 7.0 preview
+
+A preview of Redis 7.0 is available for [Fixed subscriptions]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) in selected regions in AWS and GCP. However, some Redis 7.0 functionality might not be fully available during preview. Redis 7.0 also introduces several changes to existing Redis commands; see the [list of breaking changes](#redis-70-breaking-changes) for more details.
+
+The following tables show which new open source Redis 7.0 commands are supported in Redis 7.0 subscriptions.
+
+#### [Cluster management commands]({{< relref "/commands" >}}?group=cluster)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [CLUSTER ADDSLOTSRANGE]({{< relref "/commands/cluster-addslotsrange" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [CLUSTER DELSLOTSRANGE]({{< relref "/commands/cluster-delslotsrange" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [CLUSTER LINKS]({{< relref "/commands/cluster-links" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [CLUSTER SHARDS]({{< relref "/commands/cluster-shards" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+
+#### [Connection management commands]({{< relref "/commands" >}}?group=connection)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [CLIENT NO-EVICT]({{< relref "/commands/client-no-evict" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+
+#### Data type commands
+
+| Data type | Command | Supported |
+|:----------|:--------|:----------|
+| [List]({{< relref "/commands" >}}?group=list) | [BLMPOP]({{< relref "/commands/blmpop" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [List]({{< relref "/commands" >}}?group=list) | [LMPOP]({{< relref "/commands/lmpop" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [Set]({{< relref "/commands" >}}?group=set) | [SINTERCARD]({{< relref "/commands/sintercard" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [Sorted set]({{< relref "/commands" >}}?group=sorted-set) | [BZMPOP]({{< relref "/commands/bzmpop" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [Sorted set]({{< relref "/commands" >}}?group=sorted-set) | [ZINTERCARD]({{< relref "/commands/zintercard" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [Sorted set]({{< relref "/commands" >}}?group=sorted-set) | [BZMPOP]({{< relref "/commands/bzmpop" >}}) | <span title="Supported">&#x2705; Supported</span>|
+
+#### [Keys (generic) commands]({{< relref "/commands" >}}?group=generic)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [EXPIRETIME]({{< relref "/commands/expiretime" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [PEXPIRETIME]({{< relref "/commands/pexpiretime" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [SORT_RO]({{< relref "/commands/sort_ro" >}}) | <span title="Supported">&#x2705; Supported</span>|
+
+#### [Pub/sub commands]({{< relref "/commands" >}}?group=pubsub)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [PUBSUB SHARDCHANNELS]({{< relref "/commands/pubsub-shardchannels" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [PUBSUB SHARDNUMSUB]({{< relref "/commands/pubsub-shardnumsub" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [SPUBLISH]({{< relref "/commands/spublish" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [SSUBSCRIBE]({{< relref "/commands/ssubscribe" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [SUNSUBSCRIBE]({{< relref "/commands/sunsubscribe" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+
+#### [Scripting and function commands]({{< relref "/commands" >}}?group=scripting)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [EVAL_RO]({{< relref "/commands/eval_ro" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [EVALSHA_RO]({{< relref "/commands/evalsha_ro" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [FUNCTION DELETE]({{< relref "/commands/function-delete" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION DUMP]({{< relref "/commands/function-dump" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION FLUSH]({{< relref "/commands/function-flush" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION HELP]({{< relref "/commands/function-help" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION KILL]({{< relref "/commands/function-kill" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION LIST]({{< relref "/commands/function-list" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION LOAD]({{< relref "/commands/function-load" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION RESTORE]({{< relref "/commands/function-restore" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [FUNCTION STATS]({{< relref "/commands/function-stats" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+
+#### [Server management commands]({{< relref "/commands" >}}?group=server)
+
+| <span style="min-width: 10em; display: table-cell">Command</span> | Supported |
+|:--------|:----------|
+| [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [COMMAND DOCS]({{< relref "/commands/command-docs" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [COMMAND GETKEYSANDFLAGS]({{< relref "/commands/command-getkeysandflags" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [COMMAND LIST]({{< relref "/commands/command-list" >}}) | <span title="Supported">&#x2705; Supported</span>|
+| [MODULE LOADEX]({{< relref "/commands/module-loadex" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+| [LATENCY HISTOGRAM]({{< relref "/commands/latency-histogram" >}}) | <span title="Not supported">&#x274c; Not supported</span> |
+
+## Breaking changes
+
+{{<embed-md "r7-breaking-changes.md">}}
+
+## Deprecations
+
+- [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) is deprecated as of Redis 7.0
+---
+Title: Redis Cloud changelog (November 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  November 2023.
+highlights: New Fixed plans, Redis 7.2 Fixed region support
+linktitle: November 2023
+weight: 74
+---
+
+## New features
+
+### New Fixed plans
+
+Redis is updating our [Fixed subscriptions]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) on Redis Cloud. These plans offer increased capacity at lower prices compared to legacy plans.
+
+See [Fixed plan subscription tiers]({{< relref "/operate/rc/databases/create-database/create-essentials-database#fixed-plans" >}}) for an updated list of all Fixed plans.
+
+### Redis 7.2 Fixed region support
+
+You can now use Redis 7.2 on [Fixed subscriptions]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) in `us-east-1` on Amazon Web Services. New Fixed subscriptions created in `us-east-1` will use Redis 7.2, and existing subscriptions will continue to use Redis 6.2.
+
+Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes]({{< relref "/operate/rc/changelog/2023/june-2023#redis-72-breaking-changes" >}}) published in June's changelog for more details.
+
+## Deprecations
+
+### Heroku add-on free database limit
+
+Heroku add-ons for [Redis Cloud](https://elements.heroku.com/addons/rediscloud) and [Memcached Cloud](https://elements.heroku.com/addons/memcachedcloud) are limited to one free database per Heroku account. As of November 1st, users will not be able to add a new free database if they already have one or more free databases. There will be no impact to existing free and paid databases.
+
+Additionally, Heroku Review and CI Apps will provision a 100 MB database for the [Redis Cloud](https://elements.heroku.com/addons/rediscloud) and [Memcached Cloud](https://elements.heroku.com/addons/memcachedcloud) add-on selections.
+
+---
+Title: Redis Cloud changelog (February 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  February 2023.
+highlights: Private Service Connect
+linktitle: February 2023
+weight: 89
+aliases:
+  - /operate/rc/changelog/february-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during February 2023.
+
+## New features and enhancements
+
+- [Private Service Connect]({{< relref "/operate/rc/security/private-service-connect" >}})
+
+- Additional enhancements
+---
+Title: Redis Cloud changelog (August 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  August 2023.
+highlights: Redis 7.2 Opt-in for Flexible subscriptions, Triggers and functions preview
+linktitle: August 2023
+weight: 80
+aliases:
+  - /operate/rc/changelog/august-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during August 2023.
+
+## New features
+
+### Redis 7.2 flexible opt-in
+
+You can opt in to Redis 7.2 on [Flexible subscriptions]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}). Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes]({{< relref "/operate/rc/changelog/2023/june-2023#redis-72-breaking-changes" >}}) published in June's changelog for more details.
+
+### Triggers and functions preview
+
+A preview of [triggers and functions]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions" >}}) (previously known as RedisGears) is now available in the following regions:
+
+- AWS Asia Pacific - Singapore (`ap-southeast-1`)
+- GCP Asia Pacific - Tokyo (`asia-northeast1`)
+
+To use it, [create a fixed subscription]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) in one of these regions. Then, [create your database]({{< relref "/operate/rc/databases/create-database" >}}) and set the database Type to Redis and select Triggers and Functions in the drop-down. Or, set the database Type to Redis Stack to get all of our advanced capabilities.
+
+If you'd like to use triggers and functions with a [Flexible subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}), contact [support](https://redis.com/company/support/).
+
+For more information about triggers and functions, see the [triggers and functions documentation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/" >}}).
+
+{{< note >}}
+Triggers and functions is discontinued as of [May 2024]({{< relref "/operate/rc/changelog/may-2024" >}}).
+{{< /note >}}
+
+### Maintenance windows
+
+You can now [set manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}) if you want to control when Redis can perform [maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) for a Flexible subscription.
+
+## Known issues
+
+#### Invalid ACL rule causes failed state machine
+
+Applying an invalid ACL rule to a database may cause a failed state machine. If this happens, use the [`PUT /v1/acl/redisRules/{aclRedisRuleId}`](https://api.redislabs.com/v1/swagger-ui/index.html#/Access%20Control%20List/updateRedisRule) API call to update the rule, and then delete it if necessary.
+
+---
+Title: Redis Cloud changelog (December 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  December 2023.
+highlights: Active-Active JSON support, mTLS enhancements
+linktitle: December 2023
+weight: 72
+aliases:
+  - /operate/rc/changelog/december-2023
+---
+
+## New features
+
+### Active-Active JSON support
+
+[Active-Active databases]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}) on Redis Cloud now support the [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}) data type. 
+
+See [Create an Active-Active subscription]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}}) to learn how to create an Active-Active subscription.
+
+### Mutual TLS enhancements
+
+Databases that support [Transport layer security (TLS)]({{< relref "/operate/rc/security/database-security/tls-ssl" >}}) now support multiple client certificates for use with mutual TLS. This makes it easier to rotate client certificates outside of a maintenance window. In addition, you can now provide a client Certificate Authority chain to trust any leaf certificate it signed for more flexibility.
+
+See [Transport layer security (TLS)]({{< relref "/operate/rc/security/database-security/tls-ssl" >}}) to learn how to enable TLS. 
+
+---
+Title: Redis Cloud changelog (June 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  June 2023.
+highlights: Redis 7.2 opt-in for Fixed subscriptions
+linktitle: June 2023
+weight: 84
+aliases:
+  - /operate/rc/changelog/june-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during June 2023.
+
+## New features
+
+### Redis 7.2 fixed opt-in
+
+You can opt in to Redis 7.2 on [Fixed subscriptions]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) in selected regions in AWS and GCP. Redis 7.2 introduces several changes to existing Redis commands; see the [list of breaking changes](#redis-72-breaking-changes) for more details.
+
+### Export database list to CSV includes Active-Active
+
+Your Active-Active databases will now appear in the database list when you export it to a CSV file. To support this, we added a "Region" column to differentiate between  Active-Active databases with the same name.
+
+To export your database list to a CSV file, select **Export all** on the **Databases** screen.
+
+## Breaking changes
+
+{{<embed-md "r7.2-breaking-changes.md">}}
+
+### Known limitations
+
+{{<embed-md "r7.2-known-limitations.md">}}
+
+{{<embed-md "r7.2-migration-guides.md">}}
+
+## Deprecations
+
+- [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) is deprecated as of Redis 7.0
+- [`QUIT`]({{< relref "/commands/quit" >}}) is deprecated as of Redis 7.2
+
+---
+Title: Redis Cloud changelog (October 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  October 2023.
+highlights: Cost report CSV download, SAML Account linking tokens
+linktitle: October 2023
+weight: 76
+aliases:
+  - /operate/rc/changelog/october-2023
+---
+
+## New features
+
+### Cost report CSV download
+
+You can now download shard cost reports in CSV format from the [**Billing and Payments**]({{< relref "/operate/rc/billing-and-payments" >}}) and [**Usage Reports**]({{< relref "/operate/rc/logs-reports/usage-reports" >}}) pages.
+
+{{< embed-md "rc-cost-report-csv.md" >}}
+### SAML account linking tokens
+
+The process for [linking new Redis accounts]({{< relref "/operate/rc/security/access-control/saml-sso#link-other-accounts" >}}) to your [SAML single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) configuration has changed to enhance security. Now, both accounts must use a token to ensure that the connection is legitimate.
+---
+Title: Redis Cloud changelog (April 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  April 2023.
+highlights: Exposed advanced capabilities when creating a new database
+linktitle: April 2023
+weight: 87
+aliases:
+  - /operate/rc/changelog/april-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during April 2023.
+
+## New features and enhancements
+
+- Exposed advanced capabilities when creating a new database
+
+- Bug fixes and enhancements---
+Title: Redis Cloud changelog (September 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  September 2023.
+highlights: RESP protocol selection
+linktitle: September 2023
+weight: 78
+aliases:
+  - /operate/rc/changelog/september-2023
+---
+
+## New features
+
+### RESP protocol selection
+
+For all databases using Redis 7.2, you can now choose between the RESP2 and RESP3 protocols when you [create a database]({{< relref "/operate/rc/databases/create-database" >}}). For more information about the different RESP versions, see the [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions).
+
+### Opt-in to Redis 7.2
+
+{{< embed-md "rc-opt-in-to-72.md" >}}
+
+---
+Title: Redis Cloud changelog (July 2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  July 2023.
+highlights: New ACL capabilities
+linktitle: July 2023
+weight: 82
+aliases:
+  - /operate/rc/changelog/july-2023
+---
+
+This changelog lists new features, enhancements, and other changes added to Redis Cloud during July 2023.
+
+## New features
+
+### New ACL capabilities
+
+You can now use [Selectors]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors) and [Key Permissions]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors) in your [ACL rules]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls" >}}) for all Redis 7.2 databases. 
+
+In addition, the admin console now returns an error if you try to enter an invalid ACL. It will also associate the ACL rule with the supported database version when you [add it to a role]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}).
+
+## Deprecations
+
+- RedisGraph is no longer available when you select Redis Stack on Fixed. For more information, see the [RedisGraph end of life announcement](https://redis.com/blog/redisgraph-eol/).
+- You are no longer able to [create an ACL rule]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls" >}}) using the rule builder. Instead, use [ACL syntax](https://redis.io/docs/management/security/acl/) to define your ACL rules.---
+Title: Redis Cloud changelog (2023)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: All Redis Cloud changelogs from 2023.
+hideListLinks: true
+linktitle: 2023
+highlights: All Redis Cloud changelogs from 2023.
+weight: 95
+---
+
+Select a month from the following table to see a more detailed changelog for that month:
+
+{{<table-children columnNames="Month,Major changes" columnSources="LinkTitle,highlights" enableLinks="LinkTitle">}}---
+Title: Redis Cloud changelog (July 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  July 2024.
+highlights: Redis 7.4 Preview
+linktitle: July 2024
+weight: 46
+---
+
+## New Features
+
+
+### Query performance factor preview
+
+When you create a Pro database with [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) 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]({{< relref "/operate/rc/databases/configuration/advanced-capabilities#search-and-query-sizing" >}}).
+
+You can take advantage of extra query speed for free during the preview period.
+
+The query performance factor is available for Redis Cloud Pro databases on Redis 7.2 and later.
+
+### Redis 7.4 Preview
+
+A preview of Redis 7.4 is now available on [Redis Cloud Essentials databases]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) in select regions on Amazon Web Services and Google Cloud.
+
+Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74).
+
+#### Redis database version 7.4 breaking changes {#redis-74-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 Software and update any applications that connect to your database to handle these changes.
+
+Confirm your Redis database version (`redis_version`) using the Cluster Manager UI or run the following [`INFO`]({{< relref "/commands/info" >}}) command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+##### Security behavior changes
+
+- [#13108](https://github.com/redis/redis/pull/13108) Lua: LRU eviction for scripts generated with `EVAL`. 
+
+##### Other general behavior changes
+
+- [#13133](https://github.com/redis/redis/pull/13133) Lua: allocate VM code with jemalloc instead of libc and count it as used memory.
+
+- [#12171](https://github.com/redis/redis/pull/12171) `ACL LOAD`: do not disconnect all clients.
+
+---
+Title: Redis Cloud changelog (April 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  April 2024.
+highlights: Nano billing unit, Essentials subscriptions through AWS Marketplace
+linktitle: April 2024
+weight: 55
+---
+
+## 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.
+
+### Essentials subscriptions through AWS Marketplace
+
+You can now use your [AWS Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) account to pay for your Essentials subscriptions as well as your Pro subscriptions.
+
+## Enhancements
+
+### Search and query throughput in ops/sec
+
+You can now set the throughput for databases with Search and query in operations per second (ops/sec), like all other Redis databases. This will let you seamlessly scale your query workload in and out as needed. 
+
+## Deprecations
+
+- Setting throughput by `number-of-shards` is now deprecated for the `POST /v1/subscriptions/{subscriptionId}/databases` REST API endpoint and will be removed soon. We recommend changing the throughput measurement to `operations-per-second` when you create databases using the Redis Cloud API.---
+Title: Redis Cloud changelog (October 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  October 2024.
+highlights: Redis 7.4 Preview on Redis Cloud Pro, Security fixes
+linktitle: October 2024
+weight: 42
+---
+
+## New Features
+
+### Redis 7.4 Preview on Redis Cloud Pro
+
+A preview of Redis 7.4 is now available on [Redis Cloud Pro databases]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}).
+
+Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74).
+
+## Security fixes
+
+Redis Cloud has already been updated with patches for CVE-2024-31449, CVE-2024-31227, and CVE-2024-31228. No further action is required at this time. For more information, see the [Redis blog post](https://redis.io/blog/security-advisory-cve-2024-31449-cve-2024-31227-cve-2024-31228/) about these vulnerabilities.---
+Title: Redis Cloud changelog (April 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  April 2025.
+highlights: New UI and dark mode, Map multiple Redis Cloud accounts to marketplace account
+linktitle: April 2025
+weight: 32
+---
+
+## New features
+
+### New UI and dark mode
+
+The Redis Cloud console has a refreshed user interface! You can now choose between light mode and dark mode when using the Redis Cloud console.
+
+{{<image filename="images/rc/mode-select-light.png#no-click" alt="Mode selection toggle with light mode selected." class="inline" >}}&nbsp;
+{{<image filename="images/rc/mode-select-dark.png#no-click" alt="Mode selection toggle with dark mode selected." class="inline" >}}
+
+The new user interface and dark mode are currently available for selected accounts and will be gradually rolled out to new accounts over time.
+
+### Map multiple Redis Cloud accounts to marketplace account
+
+You can now map multiple Redis Cloud accounts to a single [Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) or [AWS Marketplace]({{< relref "/operate/rc/cloud-integrations/aws-marketplace/" >}}) account. 
+---
+Title: Redis Cloud changelog (February 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  February 2025.
+highlights: Pico billing unit, Redis hashing policy
+linktitle: February 2025
+weight: 36
+---
+
+## New features
+
+### Pico billing unit
+
+We added a Pico billing unit for Pro databases with a maximum size of 100 MB and a maximum throughput of 100 ops/sec. Use it to create smaller databases for a lower cost.---
+Title: Redis Cloud changelog (June 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  June 2024.
+highlights: Redis Cloud Essentials support for Terraform
+linktitle: June 2024
+weight: 48
+---
+
+## Enhancements
+
+### Redis Cloud Essentials support for Terraform
+
+The [Redis Cloud Terraform provider]({{< relref "/integrate/terraform-provider-for-redis-cloud/" >}}) now supports provisioning Redis Cloud Essentials databases. It also supports Active-Active databases with advanced capabilities. 
+
+See the [Redis Cloud Terraform provider changelog](https://github.com/RedisLabs/terraform-provider-rediscloud/blob/main/CHANGELOG.md) for full version content.
+
+See [Get started with Terraform]({{< relref "/integrate/terraform-provider-for-redis-cloud/get-started" >}}) to learn how to install the Redis Cloud provider and create a subscription and database.---
+Title: Redis Cloud changelog (February 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  February 2024.
+highlights: CIDR overlap detection
+linktitle: February 2024
+weight: 65
+---
+
+## Enhancements
+
+### Dataset size alert set by default
+
+The **Dataset size has reached** [alert]({{< relref "/operate/rc/databases/create-database#alerts-section" >}}) is now set by default when you create your first database in a Flexible subscription.
+
+### Separated capability selection
+
+When you select [advanced capabilities]({{< relref "/operate/rc/databases/create-database#modules" >}}) during database creation, selecting **Search and query** will no longer automatically select **JSON**. You can still combine the **Search and query** and **JSON** advanced capabilities.
+
+### New backup location errors
+
+The Redis Cloud console will now notify you through email and on the application if the backup location you specify does not exist or has the wrong permissions. See [Back up databases]({{< relref "/operate/rc/databases/back-up-data" >}}) to learn how to set the correct permissions for your backup locations.
+
+### CIDR overlap detection
+
+When you [create a new Flexible subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}), the Redis Cloud console will now detect if the Classless Inter-Domain Routing (CIDR) subnet range you specify is in use by another Flexible subscription on the same account. This will allow you to address and resolve CIDR conflicts in your Redis deployment.
+
+---
+Title: Redis Cloud changelog (December 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  December 2024.
+highlights: Logs Viewer API role
+linktitle: December 2024
+weight: 38
+---
+
+## New features
+
+### Logs Viewer role
+
+You can now add a user with the **Logs Viewer** role in the [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) screen. Logs Viewers can only use the [Redis Cloud API]({{< relref "/operate/rc/api" >}}) [`GET logs/`](https://api.redislabs.com/v1/swagger-ui/index.html#/Account/getAccountSystemLogs) endpoint. 
+
+See [Team Management roles]({{< relref "/operate/rc/security/access-control/access-management#team-management-roles" >}}) to see an overview of user roles and their permissions.
+
+### Redis Flex preview on Redis Cloud Essentials
+
+Redis Flex is now available in Preview on Redis Cloud Essentials.
+
+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.
+
+See [Create a Redis Flex database]({{< relref "/operate/rc/databases/create-database/create-flex-database" >}}) for more info.---
+Title: Redis Cloud changelog (November 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  November 2024.
+highlights: Pro subscription version upgrade
+linktitle: November 2024
+weight: 40
+---
+
+## New Features
+
+### Pro subscription version upgrade
+
+You can now upgrade all databases in your Pro subscription from your [subscription page]({{< relref "/operate/rc/subscriptions/view-pro-subscription" >}}). 
+
+{{< embed-md "rc-version-upgrade.md" >}}---
+Title: Redis Cloud changelog (March 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  March 2025.
+highlights: Redis Insight on Redis Cloud, Redis Hashing policy
+linktitle: March 2025
+weight: 34
+---
+
+## New features
+
+### Redis Insight on Redis Cloud
+
+Users with select Redis Cloud Essentials databases can now open a browser-based version of [Redis Insight]({{< relref "/operate/rc/databases/connect/insight-cloud" >}}) directly from Redis Cloud. See [Connect to your database]({{< relref "/operate/rc/databases/connect#ri-browser" >}}) to learn how to open Redis Insight from Redis Cloud.
+
+This browser-based version of Redis Insight has a subset of the features of Redis Insight on desktop. For more information, see [Open with Redis Insight on Redis Cloud]({{< relref "/operate/rc/databases/connect/insight-cloud" >}}).
+
+### Redis hashing policy
+
+Accounts created after March 31, 2025, can select the new [Redis hashing policy]({{< relref "/operate/rc/databases/configuration/clustering#redis-hashing-policy" >}}) for their databases when creating a new database. 
+
+The Redis hashing policy is identical to the [hashing policy used by Redis Community Edition]({{< relref "/operate/oss_and_stack/reference/cluster-spec#hash-tags" >}}). This policy is recommended for most users. Select it if any of the following conditions apply:
+- This is your first Redis Cloud account, and you are starting fresh.
+- You are migrating data from Redis Community Edition or other Redis-managed platforms.
+- Your application does not use hashtags in database key names.
+- Your application uses binary data as key names.
+
+See [Clustering]({{< relref "/operate/rc/databases/configuration/clustering#manage-the-hashing-policy" >}}) for more information.
+
+## Deprecations
+
+- The [Custom hashing policy]({{< relref "/operate/rc/databases/configuration/clustering#custom-hashing-policy" >}}) is no longer available for accounts created after March 31, 2025. For all other accounts, this policy is not recommended and will be deprecated in the future. Only select a custom hashing policy if you are already using a custom hashing policy with your existing Redis Cloud databases.---
+Title: Redis Cloud changelog (May 2025)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  May 2025.
+highlights: Upgrade database version for a single Pro database, Business address and billing address separation, Redis Cloud Bring your own Cloud
+linktitle: May 2025
+weight: 30
+---
+
+## New features
+
+### Upgrade database version for a single Pro database
+
+Selected accounts can now upgrade a single Pro database to a later version. From the database page or database list, select **More actions > Version upgrade** to upgrade your database.
+
+{{<image filename="images/rc/databases-more-actions-menu.png" alt="The More Actions menu on the Database page." width=40% >}}
+
+See [Upgrade database version]({{< relref "/operate/rc/databases/upgrade-version" >}}) for more information.
+
+### Business address and billing address separation
+
+You can now have multiple credit cards with different billing addresses. See [Billing and payments]({{< relref "/operate/rc/billing-and-payments" >}}) to learn how to add a new credit card.
+
+Your account now also has a **Business address**, which you can find in [Account settings]({{< relref "/operate/rc/accounts/account-settings" >}}).
+
+## Enhancements
+
+### Redis Cloud Bring your own Cloud
+
+AWS Cloud Accounts are now known as Redis Cloud Bring your own Cloud (BYOC). See [Redis Cloud Bring your own Cloud]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud" >}}) to learn how to use your own AWS cloud infrastructure to deploy Redis Cloud.
+---
+Title: Redis Cloud changelog (January 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  January 2024.
+highlights: Transit Gateway, Database tags
+linktitle: January 2024
+weight: 70
+---
+
+## New features
+
+### Transit Gateway 
+
+You can now connect your Flexible subscriptions hosted on Amazon Web Services (AWS) to [AWS Transit Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/how-transit-gateways-work.html). See [Connect to Transit Gateway]({{< relref "/operate/rc/security/aws-transit-gateway" >}}) to learn how to connect your Flexible subscription to Transit Gateway.
+
+### Billing Admin role
+
+You can now add a user with the Billing Admin role in the [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) screen. Billing Admins can view and edit settings related to billing and payments. They can add and remove payment methods and change the payment method for a subscription, but they cannot change any other subscription or database settings.
+
+See [Team Management roles]({{< relref "/operate/rc/security/access-control/access-management#team-management-roles" >}}) to see an overview of user roles and their permissions.
+
+### Database tags
+
+You can now add [tags]({{< relref "/operate/rc/databases/tag-database" >}}) to your database.
+
+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]({{< relref "/operate/rc/databases/view-edit-database#manage-the-database-list" >}}) by tag key or value. 
+
+See [Manage tags]({{< relref "/operate/rc/databases/tag-database" >}}) to learn how to add tags to your database.
+
+### Network data cost breakdowns
+
+Invoices for customers with Flexible and Annual subscriptions now include a breakdown of network data costs for the subscription. To download an invoice, go to the [Billing and Payments]({{< relref "/operate/rc/billing-and-payments#download-invoice" >}}) page on the [Redis Cloud console](https://cloud.redis.io/).
+
+Customers with Annual subscriptions can also find a breakdown of network data costs in the consumption report.
+
+## Deprecations
+
+- {{< embed-md "rc-fixed-upgrade-limitation.md" >}}
+---
+Title: Redis Cloud changelog (March 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  March 2024.
+highlights: Fixed plans through Google Cloud Marketplace
+linktitle: March 2024
+weight: 60
+---
+
+## New Features
+
+### Fixed subscriptions through Google Cloud Marketplace
+
+You can now use your [Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) account to pay for your Fixed subscriptions as well as your Flexible subscriptions. 
+
+### Active-Passive with TLS
+
+[Active-Passive]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}) now supports source databases that require connections over TLS. See [Migrate data]({{< relref "/operate/rc/databases/migrate-databases" >}}) for more information.---
+Title: Redis Cloud changelog (May 2024)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: New features, enhancements, and other changes added to Redis Cloud during
+  May 2024.
+highlights: Multi-domain SAML setup, SAML domain verification, Active-Active search support
+linktitle: May 2024
+weight: 50
+---
+
+## New features
+
+### Multi-domain SAML setup
+
+[SAML single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) now supports multiple username domains. Select **Manage domains** on the **Single sign-on** screen to associate additional domains to your SAML setup.
+
+### SAML domain verification
+
+We added domain verification to [SAML single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) to enhance security. Before you set up SAML in Redis Cloud, you must first [verify domain ownership]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) for any domains associated with your SAML setup.
+
+If you have an active SAML configuration, you can still sign in with SAML SSO, but your domains will be set to **Unverified**. You should [verify domain ownership]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) as soon as possible.
+
+### Active-Active Search and query support
+
+[Active-Active databases]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}) on Redis Cloud now support [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}). 
+
+See [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database" >}}) to learn how to create an Active-Active database.
+
+See [Search and query Active-Active databases]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/search-active-active" >}}) to learn how to use Search and query on Active-Active databases.
+
+## Enhancements
+
+### Dataset size
+
+We now distinguish between dataset size and memory limit to reduce confusion.
+
+For Redis Cloud Essentials, the plan size refers to the full memory limit, not the dataset size. If you select high availability for an Essentials database, your dataset size will be half of the plan size. Both the total memory limit and dataset size are listed under **Database details** when you create an Essentials database.
+
+For Redis Cloud Pro, you define your dataset size when you create the database, and we calculate your total memory limit automatically based on the features you choose.
+
+See [Dataset size]({{< relref "/operate/rc/databases/configuration/sizing#dataset-size" >}}) for more information.
+
+## Deprecations
+
+### End of Triggers and Functions preview
+
+Redis has discontinued the "Triggers and Functions" preview feature. You are no longer able to create a database with Triggers and Functions.  
+
+- Commands such as TFCALL, TFCALLASYNC, and TFUNCTION are now deprecated and will return error messages upon execution.
+- Any JavaScript functions stored in Redis will be automatically removed, and JavaScript-based triggers will be disabled.
+- Lua functions and scripts will remain unaffected by this change.---
+Title: Redis Cloud changelog
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Lists new features, enhancements, and other changes in Redis Cloud.
+hideListLinks: true
+linktitle: Changelog
+weight: 95
+---
+
+Changelogs list new features, enhancements, and other changes in Redis Cloud.
+
+Select a month from the following table to see a more detailed changelog for that month:
+
+{{<table-children columnNames="Month,Major changes" columnSources="LinkTitle,highlights" enableLinks="LinkTitle">}}
+---
+Title: Enable Private Service Connect
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Private Service Connect creates a private endpoint that allows secure
+  connections to Redis Cloud databases without exposing your application VPC.
+linkTitle: Private Service Connect
+toc: 'true'
+weight: 50
+---
+
+[Private Service Connect](https://cloud.google.com/vpc/docs/private-service-connect) (PSC) creates a private endpoint that allows secure connections to Redis Cloud databases without exposing your application's [virtual private cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC). 
+
+This feature is only available for Redis Cloud Pro subscriptions hosted on Google Cloud.
+
+## Considerations
+
+You can use Private Service Connect as an alternative to [VPC peering]({{< relref "/operate/rc/security/vpc-peering" >}}), or you can enable both for your subscription.
+
+Compared to VPC peering, Private Service Connect:
+
+- Only exposes the private endpoint instead of the entire application VPC network.
+
+- Allows producer (Redis Cloud VPC) and consumer (application VPC) CIDR ranges to overlap.
+ 
+- Has slightly higher network latency than VPC peering due to load balancing requirements.
+
+    {{<note>}}
+Larger clusters are more likely to experience increased latency with Private Service Connect versus VPC peering.
+    {{</note>}}
+
+Consider using VPC peering and Private Service Connect in parallel for the following situations:
+
+- When migrating from one connectivity solution to the other.
+
+- If different applications need to connect to the same database but have different latency or security requirements.
+
+## Set up Private Service Connect {#setup-psc}
+
+To set up Private Service Connect, you need to:
+
+1. [Configure Private Service Connect](#configure-psc) in the Redis Cloud console.
+
+1. [Create Private Service Connect endpoints](#create-endpoints) in the application VPC.
+
+1. From the Redis Cloud console, review and [accept the Private Service Connect endpoint connection](#accept-psc).
+
+### Configure PSC {#configure-psc}
+
+First, configure Private Service Connect in Redis Cloud:
+
+1. Select **Subscriptions** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your subscription from the list.
+
+2. Select the **Connectivity** tab and then **Private Service Connect**.
+
+3. Select the **Create connection** button:
+
+    {{<image filename="images/rc/button-subscription-connectivity-psc-create-connection.png" width="140px" alt="Use the Create connection button to configure a new PSC endpoint." >}}
+
+4. Read the **Latency and cost impact** message and select **Accept and continue**:
+
+    {{<image filename="images/rc/button-subscription-connectivity-psc-accept-continue.png" width="140px" alt="Use the Accept and continue button to acknowledge PSC's impact on latency and cost." >}}
+
+5. For **Create connection**, enter the following **Endpoint details**:
+
+    | Setting&nbsp;name | Description |
+    |-------------------|-------------|
+    | _Google Cloud project ID_ | Google Cloud project ID |
+    | _VPC name_ | Name of the VPC that hosts your application |
+    | _Subnet name_ | Name of your VPC's subnet of IP address ranges |
+    | _Endpoint name_ | Prefix used to create PSC endpoints in the consumer application VPC, so endpoint names appear in Google Cloud as _endpoint name prefix + endpoint number_ |
+
+6. Continue to the **Add connections** step:
+    
+    {{<image filename="images/rc/button-subscription-continue.png" width="100px" alt="Use the Continue button to proceed to the Add connections step." >}}
+
+7. Select either **Bash Shell** or **PowerShell** and then download or copy the provided `gcloud` script for later:
+
+    {{<image filename="images/rc/subscription-connectivity-psc-gcloud-script.png" width="350px" alt="Use the Download or Copy buttons to save the gcloud script for later use." >}}
+
+8. Select **Continue** to save this endpoint configuration:
+
+    {{<image filename="images/rc/button-subscription-continue.png" width="100px" alt="Use the Continue button to save the PSC endpoint configuration." >}}
+
+### Create endpoints {#create-endpoints}
+
+Now that you have a pending Private Service Connect entry, you need to create the endpoints in your application's VPC:
+
+1. If you have not already done so, [enable Cloud DNS](https://cloud.google.com/dns/docs/set-up-dns-records-domain-name) for your Google Cloud project.
+
+    {{<note>}}
+Since it can take some time for the DNS changes to become active, we recommend you wait 10 minutes before running the `gcloud` script in the next steps.
+    {{</note>}}
+
+1. If you already have a copy of the `gcloud` script shown earlier during the **Add connections** step, you can continue to the next step. 
+
+    1. Otherwise, return to your Redis Cloud subscription's **Connectivity > Private Service Connect** screen and select **Complete setup** for the pending endpoint:
+
+        {{<image filename="images/rc/button-subscription-connectivity-psc-complete-setup.png" width="140px" alt="Use the Complete setup button if you need access to the gcloud script again." >}}
+
+    1. Download or copy the script.
+
+1. Use the [`gcloud` CLI](https://cloud.google.com/sdk/gcloud) to run the script.
+
+    {{<warning>}}
+To ensure the `gcloud` script configures the endpoints correctly, do not make any changes to it.
+    {{</warning>}}
+
+The `gcloud` script creates a PSC endpoint and a DNS response policy in the consumer application VPC.
+
+
+### Accept PSC connection {#accept-psc}
+
+After the `gcloud` script finishes creating the Private Service Connect endpoint, you need to accept the connection in Redis Cloud:
+
+1. In the Redis Cloud console, return to your subscription's **Connectivity > Private Service Connect** screen.
+
+1. Find your pending endpoint connection in the list and select **Accept**:
+
+    {{<image filename="images/rc/button-subscription-connectivity-psc-accept.png" width="100px" alt="Use the Accept button to finish PSC endpoint setup." >}}
+
+### Connect to database {#connect-db}
+
+Once your Private Service Connect endpoint is active, you can connect your application to a database:
+
+1. From your subscription's **Connectivity > Private Service Connect** tab, select the **Connect** button for the active endpoint:
+
+    {{<image filename="images/rc/button-connect.png" width="100px" alt="Use the Connect button to retrieve PSC connection details." >}}
+
+1. Select a database from the list.
+
+1. Copy the endpoint and use it in your application to connect to your database.
+
+{{< note >}}
+Once your Private Service Connect endpoint is active, you must connect to the database from the Private Service Connect endpoint if you want to connect with Private Service connect. If you previously used the public or private endpoint to connect to your database, you must migrate any connections to the Private Service Connect endpoint.
+{{< /note >}}
+
+
+## Deactivate Private Service Connect {#deactivate-psc}
+
+To deactivate Private Service Connect for your subscription:
+
+1. Select **Subscriptions** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your subscription from the list.
+
+1. Select the **Connectivity** tab and then **Private Service Connect**.
+
+1. For each endpoint:
+
+    1. Select the **Delete PSC endpoint** button:
+
+        {{<image filename="images/rc/icon-delete-teal.png" width="40px" alt="Use the Delete PSC endpoint button to remove an endpoint." >}}
+
+    1. Copy the provided `gcloud` script from the **Remove endpoint** dialog.
+
+    1. Run the `gcloud` script with [`gcloud` CLI](https://cloud.google.com/sdk/gcloud) to delete the endpoint and DNS response policy.
+
+1. After you remove all endpoints, select the **Actions** button to see a list of available actions:
+
+    {{<image filename="images/rc/icon-psc-actions.png" width="40px" alt="Use the Toggle actions button to see a list of actions." >}}
+
+1. Select **Remove service** and then **Confirm**:
+
+    {{<image filename="images/rc/button-subscription-connectivity-psc-remove-service-confirm.png" width="100px" alt="Use the Confirm button to deactivate Private Service Connect." >}}
+
+Once you remove all of your Private Service Connect endpoints and deactivate it, you must migrate any connections from a Private Service Connect endpoint to the public or private endpoint of your database.
+
+## Limitations
+
+Private Service Connect has the following limitations in Redis Cloud:
+
+- Although Redis Cloud supports using Private Service Connect with Enterprise clustering, you cannot use the [Cluster API]({{< relref "/operate/rc/databases/create-database#oss-cluster-api" >}}) with Private Service Connect enabled.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Encryption at rest
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes when data is encrypted at rest.
+weight: 40
+---
+Redis Cloud databases write their data to disk whenever [persistence]({{< relref "/operate/rc/databases/configuration/data-persistence.md" >}}) is enabled. 
+
+Redis Cloud deployments are always encrypted at rest. 
+
+## Encryption at rest on AWS {#aws}
+
+Persistent data is written to encrypted EBS volumes. For more information, see [Amazon EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html). 
+
+When Auto Tiering is enabled, the flash memory data is written to encrypted NVMe SSD volumes. For more information, see [SSD instance store volumes](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ssd-instance-store.html).
+
+## Disk encryption on Google Cloud {#gcp}
+
+All data written to disk on Google Cloud-based Redis Cloud deployments is encrypted by default. When deploying
+a Redis Cloud database on Google Cloud, you don't need to take any actions to enable this encryption.
+
+To learn more, see the [Google Cloud Default encryption at rest](https://cloud.google.com/security/encryption-at-rest).
+
+## Disk encryption on Azure {#azure}
+
+All data written to disk on Azure-based Redis Cloud deployments is encrypted by default. When deploying
+a Redis Cloud database on Azure, you don't need to take any actions to enable this encryption.
+
+To learn more, see the [Azure Data Encryption at rest](https://docs.microsoft.com/en-us/azure/security/fundamentals/encryption-atrest).
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+
+---
+Title: Redis Cloud shared responsibility model
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linkTitle: Shared responsibility model
+weight: 10
+---
+
+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.
+
+Redis is responsible for the software that runs Redis Cloud. This includes the patching and maintenance of
+the operating systems that Redis is deployed on as well as the patching and maintenance of Redis Cloud.
+
+## Cloud provider responsibility
+
+The public cloud provider hosting your Redis Cloud databases is responsible for the physical security of their data centers and
+the security of the network, storage, servers, and virtualization that form the core infrastructure of your deployment.
+
+Amazon, Microsoft, and Google public clouds embrace a wide range of security best practices and compliance standards. Compliance information—including audits, attestations, and certifications about resources hosted—can be found on these compliance pages:
+
+* [AWS Compliance](https://aws.amazon.com/compliance/)
+* [Google Cloud Compliance](https://cloud.google.com/security/compliance)
+* [Azure Compliance](https://azure.microsoft.com/en-us/overview/trusted-cloud/compliance/)
+
+## Customer responsibility
+
+Customers are responsible for the security configurations in their Redis databases and the Redis Cloud console. Customers must understand and implement the Redis Cloud security features and best practices.
+
+Customers are also responsible for the applications built on Redis and the data they store in Redis. Customers determine the cloud provider, region, and availability zone of their deployments.
+
+Customers understand that Redis Cloud Essentials plans are deployed to a multi-tenant infrastructure. Redis Cloud Pro plans are deployed to a single-tenant infrastructure dedicated to one specific customer.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+
+---
+Title: Transport Layer Security (TLS)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Enable TLS to encrypt data communications between applications and Redis
+  databases.
+weight: 20
+---
+
+Transport Layer Security (TLS) uses encryption to secure [network communications](https://en.wikipedia.org/wiki/Transport_Layer_Security).  
+
+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.
+{{</note>}}
+
+## TLS recommendations
+
+TLS is not enabled by default.
+
+Because TLS has an impact on performance, you need to determine whether the security benefits of TLS are worth the performance impact. TLS recommendations depend on the subscription plan and whether clients connect to your database using public or private endpoints.
+
+This table shows TLS recommendations:
+
+| Subscription | Public&nbsp;endpoint | Private endpoint |
+|--------------|----------------------|------------|
+| Redis Cloud Essentials        | Enable TLS           | N/A |
+| Redis Cloud Pro     | Enable TLS           | Enable TLS if security outweighs performance impact |
+
+## Client authentication
+
+When you enable TLS, you can optionally require client authentication (also known as "mutual authentication"). If enabled, all clients must present a valid client certificate when they connect to the database.
+
+Client authentication is not required by Redis Cloud; however, it is strongly recommended.
+
+## Enable TLS
+
+To enable TLS for a Redis Cloud database:
+
+1. Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your database from the list.
+
+1. From the database's **Configuration** screen, select **Edit**:
+
+    {{<image filename="images/rc/button-database-edit.png" width="100px" alt="The Edit database button lets you change selected database properties." >}}
+
+1. In the **Security** section, use the **Transport layer security (TLS)** toggle to enable TLS:
+
+    {{<image filename="images/rc/database-details-configuration-tab-security-tls-toggle.png" width="200px" alt="Use the Transport Layer Security toggle to enable TLS." >}}
+
+1. Select the **Download server certificate** button to download the Redis Cloud certificate bundle `redis_ca.pem`:
+
+    {{<image filename="images/rc/button-database-config-security-server-ca-download.png" width="250px" alt="Use the Download server certificate button to download the Redis Cloud CA certificates." >}}
+
+1. Decide whether you want to require client authentication:
+
+    - If you only want clients that present a valid certificate to be able to connect, continue to the next step.
+    
+    - If you do not want to require client authentication, skip to the final step to apply your changes.
+
+1. To require client authentication, select the **Mutual TLS (require client authentication)** checkbox. 
+
+1. Select **Add client certificate** to add a certificate.
+
+    {{<image filename="images/rc/mtls-add-client-certificate.png" width="200px" alt="The Add client certificate button." >}}
+
+1. Either provide an [X.509 client certificate](https://en.wikipedia.org/wiki/X.509) or chain in PEM format for your client or select **Generate** to create one:
+
+    {{<image filename="images/rc/database-details-configuration-tab-security-tls-client-auth-certificate.png" alt="Provide or generate a certificate for Mutual TLS." >}}
+
+    - If you generate your certificate from the Redis Cloud console, a **Download certificate** button will appear after it is generated. Select it to download the certificate. 
+
+        {{<image filename="images/rc/mtls-download-certificate.png" alt="The Download certificate button." >}}
+        
+        The download contains:
+
+        - `redis-db-<database_id>.crt` – the certificate's public key.
+
+        - `redis-db-<database_id>.key` – the certificate's private key.
+
+        {{<note>}}
+You must download the certificate using the button at this point.  After your changes have been applied, the full bundle of public and private keys will no longer be available for download.
+        {{</note>}}
+    
+    - If you provide a client certificate or a certificate chain, you will see the certificate details before you save your changes.
+
+        {{<image filename="images/rc/mtls-certificate-details.png" alt="The Download certificate button." >}}
+    
+    Select **Save** to save the client certificate.
+
+1. You can select **Add client certificate** again to add another certificate.
+
+    {{<image filename="images/rc/mtls-add-client-certificate.png" width="200px" alt="The Add client certificate button." >}}
+
+1. To apply your changes and enable TLS, select the **Save database** button:
+
+    {{<image filename="images/rc/button-database-save.png" width="140px" alt="Use the Save database button to save database changes." >}}
+
+{{<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.
+
+- Once you've enabled TLS, all client connections to your database must use TLS. Unencrypted connections will no longer be permitted.
+{{</note>}}
+
+## Connect over TLS
+
+To connect to a Redis Cloud database over TLS, you need:
+
+* A Redis client that supports TLS
+* Redis Cloud CA certificates
+
+### Download CA certificates {#download-certificates}
+
+If you don't have the Redis Cloud CA certificates, you can download them from the Redis Cloud console:
+
+1. Either select **Account Settings** from the Redis Cloud console menu or go to the database's **Configuration** screen.
+
+1. Go to the **Security** section.
+
+1. For **Redis Cloud certificate authority**, either:
+
+    - Select the **Download** button to download the certificates from **Redis Cloud certificate authority** in **Account Settings**:
+
+        {{<image filename="images/rc/button-account-settings-security-ca-download.png" width="140px" alt="Use the Download button to download the Redis Cloud CA certificates." >}}
+
+    - Select the **Download server certificate** button to download the certificates from the database's **Configuration** screen:
+
+        {{<image filename="images/rc/button-database-config-security-server-ca-download.png" width="250px" alt="Use the Download server certificate button to download the Redis Cloud CA certificates." >}}
+
+The download contains a file called `redis_ca.pem`, which includes the following certificates:
+   
+- Self-signed Redis Cloud Essentials plan Root CA (deprecated but still in use)
+
+- Self-signed Redis Cloud Pro plan Root CA and intermediate CA (deprecated but still in use)
+
+- Publicly trusted GlobalSign Root CA
+
+{{<note>}}
+The downloaded PEM file contains multiple certificates. Make sure to import **all** certificates to your client trust store. If your client code is not implemented properly, it may only import the first certificate. 
+{{</note>}}
+
+To inspect the certificates in `redis_ca.pem`, run the `keytool` command:
+
+```sh
+keytool -printcert -file ./redis_ca.pem | grep "Owner:"
+```
+
+You can add `redis_ca.pem` to the trust store or pass it directly to a Redis client.
+
+If your database requires client authentication, you also need the public (`redis_user.crt`) and private (`redis_user_private.key`) client keys. See
+[Enable TLS](#enable-tls) for details.
+
+### Connect with the Redis CLI
+
+Here's how to use the [Redis CLI]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) to connect to a TLS-enabled Redis Cloud database.
+
+Endpoint and port details are available from the **Databases** list or the database's **Configuration** screen.
+
+#### Without client authentication
+
+If your database doesn't require client authentication, then provide the Redis Cloud CA certificate bundle (`redis_ca.pem`) when you connect:
+
+```sh
+redis-cli -h <endpoint> -p <port> --tls --cacert redis_ca.pem
+```
+
+#### With client authentication
+
+If your database requires client authentication, then you also need to provide your client's private and public keys:
+
+```sh
+redis-cli -h <endpoint> -p <port> --tls --cacert redis_ca.pem \
+    --cert redis_user.crt --key redis_user_private.key
+```
+---
+Title: Network security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linkTitle: Network security
+weight: 30
+---
+
+Redis Cloud supports two types of network security: database-level CIDR allow lists and [VPC](#virtual-private-clouds)-wide CIDR allow lists.
+
+These features are available in most Redis Cloud configurations, as shown here:
+
+| Cloud&nbsp;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 {#ip}
+
+You can restrict database access to a configurable
+set of source IP addresses and subnets. This is roughly equivalent
+to using [iptables](https://en.wikipedia.org/wiki/Iptables) to limit access to a host.
+
+To restrict a database to a specific set of source IP addresses or subnets, see [Configure CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist" >}}).
+
+## Virtual private clouds
+
+A [Virtual Private Cloud](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPC) is an isolated set of resources within a [public cloud](https://en.wikipedia.org/wiki/Cloud_computing#Public_cloud), usually having its own subnets and VLAN.
+
+Redis Cloud Pro databases are almost always deployed in a Redis VPC. In most cases, you'll need to create a [VPC peering connection]({{< relref "/operate/rc/security/vpc-peering" >}}) to access these databases. A VPC peering connection allows unrestricted network access between two VPCs.
+
+Connection creation and supported features vary by public cloud provider. Learn more about VPC usage for [AWS](#vpcs-with-aws), [Google Cloud](#vpcs-with-google-cloud), and [Azure](#vpcs-with-azure).
+
+### VPCs with AWS
+
+Subscriptions that run on AWS support two VPC options. To ensure that that you can securely connect to your database, you need to [create a VPC peering connection]({{< relref "/operate/rc/security/vpc-peering#aws-vpc-peering" >}}).
+
+If you create a VPC peering connection, you can also [configure a CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist" >}}) to allow connections only from specific IP address blocks or security groups.
+
+### VPCs with Google Cloud
+
+Subscriptions that run on Google Cloud *require* a VPC peering connection. See [Google Cloud VPC peering]({{< relref "/operate/rc/security/vpc-peering#gcp-vpc-peering" >}}) to learn how to set up VPC peering for Google Cloud.
+
+### VPCs with Azure
+
+When you request a Redis Cloud Annual subscription, all databases will be deployed in your own Azure VPC.
+---
+Title: Cloud database security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+weight: 20
+---
+
+Redis Cloud provides several features to help you secure your databases. These include
+[password-based authentication]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) and [role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control.md" >}}),
+[network security]({{< relref "/operate/rc/security/database-security/network-security.md" >}}), [TLS]({{< relref "/operate/rc/security/database-security/tls-ssl.md" >}}), and [encryption-at-rest]({{< relref "/operate/rc/security/encryption-at-rest.md" >}}).
+
+## Passwords, users, and roles
+
+All Redis Cloud databases [require a password]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}) to connect. However, we recommend enabling [role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control.md" >}}) (RBAC) for additional security. With RBAC, you can define
+all the roles you need, with the appropriate permissions, and assign those roles
+to your users.
+
+## Network security
+
+Redis Cloud supports two types of network security: [IP Restrictions]({{< relref "/operate/rc/security/database-security/network-security.md" >}}#ip) and [VPCs]({{< relref "/operate/rc/security/database-security/network-security.md" >}}#virtual-private-clouds). We recommend that you employ at least one of these network security options to constrain access to your databases.
+
+## Transport Layer Security (TLS)
+
+Redis Cloud supports [Transport Layer Security]({{< relref "/operate/rc/security/database-security/tls-ssl.md" >}}) (TLS) for database connections. TLS, often called "SSL", ensures the privacy of the TCP connection between your application and database. When client
+authentication is enabled, TLS also ensures that those clients with an authorized key can connect to your Redis databases.
+
+We strongly recommend enabling TLS for any application transmitting sensitive data across the wire.
+
+## Disk encryption
+
+Redis Cloud provides encryption for all data stored on disk in Redis databases. See our [encryption at rest documentation]({{< relref "/operate/rc/security/encryption-at-rest.md" >}}) for specific details.
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Enable VPC peering
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: VPC peering uses private IP addresses to route traffic between a Redis
+  Cloud VPC and an application VPC.
+linkTitle: VPC peering
+weight: 80
+---
+
+VPC peering uses private IP addresses to allow network connections between two [virtual private clouds](https://en.wikipedia.org/wiki/Virtual_private_cloud) (VPCs).
+
+You can connect your VPC in the Redis Cloud subscription to the VPC of your application. This lets your application connect securely to your Redis Cloud database using VPC peering to optimize the performance of your application.
+
+{{< note >}}
+VPC peering is available only with Redis Cloud Pro.  It is not supported for Redis Cloud Essentials.
+{{< /note >}}
+
+VPC peering configuration requires you to initiate VPC peering on your Redis Cloud subscription and then accept the VPC peering request for the AWS VPC that you want to peer with.
+
+## AWS VPC peering
+
+If you want to peer a Redis Cloud VPC with an AWS VPC, you need to:
+
+1. [Configure and initiate VPC peering](#config-aws-vpc-peering) for your Redis Cloud subscription.
+
+1. [Approve the VPC peering request](#approve-aws-vpc-peering).
+
+1. [Update the routes tables](#update-route-tables).
+
+### Configure VPC peering {#config-aws-vpc-peering}
+
+To set up VPC peering:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select the **Subscriptions** menu and then select your subscription from the list.
+
+1. Select **Connectivity > VPC Peering**.
+
+1. Select **Add peering**.
+
+1. Enter **VPC peering** details:
+
+    | Setting | Description |
+    |-------------------|-------------|
+    | _Consumer AWS Account_ | Your AWS account ID (see [Finding your AWS account ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId)) |
+    | _Consumer region_ | AWS VPC region |
+    | _Consumer VPC ID_ | The VPC ID for the application that needs to access your Redis Cloud VPC (see [Finding a VPC ID](https://docs.aws.amazon.com/managedservices/latest/userguide/find-vpc.html)) |
+    | _Consumer VPC CIDRs_ | [CIDR-formatted](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) IP addresses for the AWS VPC that needs to access your Redis Cloud VPC; must not overlap with the _Redis producer VPC CIDR_ (see [View your VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#view-vpc)) |
+
+1. You can provide up to five VPC CIDRs.
+    
+    To add multiple VPC CIDRs:
+
+    1. Select **Add CIDR**.
+    1. Enter additional CIDR-formatted IP address in the box:
+
+        {{<image filename="images/rc/subscription-connectivity-vpc-peering-add-multiple-cidrs.png" width="300px" alt="Select the Add CIDR button to add another VPC CIDR." >}}
+
+1. Select **Initiate peering**.
+1. Note the **Peering ID** of the VPC peering request.
+
+    {{<image filename="images/rc/subscription-connectivity-vpc-peering-aws.png" width="350px" alt="View VPC peering list." >}} 
+
+### Approve VPC peering request {#approve-aws-vpc-peering}
+
+After you set up and intitiate VPC peering, you need to approve the VPC peering request:
+
+1. Follow the AWS guide to [accept the VPC peering connection](https://docs.aws.amazon.com/vpc/latest/peering/accept-vpc-peering-connection.html).
+
+1. After you accept the peering request, select **Modify my route tables now**. This button can be found in the green header once the peering connection is **active**.
+
+{{<image filename="images/rc/modify_route_tables_aws.png" width="800px" alt="Modify Route Table." >}}
+
+### Update route tables {#update-route-tables}
+
+To finish VPC peering setup, [update your route tables for the peering connection](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html). There may be many different route tables assigned to different VPCs. It is important to choose the route table assigned to the VPC you specified in the [Configure VPC Peering](#config-aws-vpc-peering) section with the following details:
+
+1. In the **Destination** field, enter the Redis Cloud VPC CIDR shown when you accepted the peering request.
+
+    This is the Redis Cloud VPC CIDR address, to which your application's VPC connects.
+
+1. In the **Target** field, select **Peering Connection** and select the relevant **Peering ID**.
+
+Once VPC peering is established, we recommend switching your application connection string to the private endpoint.
+
+{{< note >}}
+{{< embed-md "rc-vpc-peering-cidr-list.md"  >}}
+{{< /note >}}
+
+## Google Cloud VPC peering {#gcp-vpc-peering}
+
+If you want to peer a Redis Cloud VPC with a Google Cloud VPC, you need to:
+
+1. [Configure and initiate VPC peering](#config-gcp-vpc-peering) for your Redis Cloud subscription.
+
+1. [Approve the VPC peering request](#approve-gcp-vpc-peering).
+
+### Configure VPC peering {#config-gcp-vpc-peering}
+
+To set up VPC peering:
+
+1. Select **Subscriptions** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your subscription from the list.
+
+1. Select **Connectivity > VPC Peering**.
+
+1. Select **Add peering**.
+
+1. Enter the VPC peering details:
+
+    | Setting&nbsp;name | Description |
+    |-------------------|-------------|
+    | **Project ID** | Google Cloud project ID (see [Identifying projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects)) |
+    | **Network name** | Google Cloud VPC network you want to peer with (see [View networks](https://cloud.google.com/vpc/docs/create-modify-vpc-networks#viewing-networks)) |
+
+1. Copy the **Google cloud command** after you enter the other VPC peering settings. You need this command to accept the peering request later:
+
+    {{<image filename="images/rc/subscription-connectivity-vpc-peering-gcloud-command.png" width="350px" alt="The Initiate peering button creates a VPC peering request." >}}
+
+1. Select **Initiate peering**.
+1. Note the **Cloud peering ID** of the VPC peering request.
+
+    {{<image filename="images/rc/subscription-connectivity-vpc-peering-gcp.png" width="350px" alt="View VPC peering list." >}}
+
+### Approve VPC peering request {#approve-gcp-vpc-peering}
+
+To approve the VPC peering request between Redis Cloud and Google Cloud, use the [`gcloud` CLI](https://cloud.google.com/sdk/gcloud) to run the **Google cloud command** that you copied before you initiated VPC peering.
+
+Once VPC peering is established, we recommend switching your application connection string to the private endpoint.
+
+{{< note >}}
+{{< embed-md "rc-vpc-peering-cidr-list.md"  >}}
+{{< /note >}}
+
+## Continue learning with Redis University
+
+{{< university-links >}}---
+Title: Social login
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Social login with Redis Cloud.
+linkTitle: Social login
+weight: 10
+---
+
+Redis Cloud supports the following social logins:
+- [GitHub](https://github.com/)
+- [Google](https://accounts.google.com/)
+
+{{<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.
+{{</note>}}
+
+## Create a new account with social login
+
+To set up Google login:
+
+1. Select **Google** from the [sign-in](https://cloud.redis.io/) screen.
+1. Sign in with the Google account you would like to use.
+1. Select **Confirm** on the **Sign in with Google** prompt.
+
+To set up GitHub login:
+
+1. Select **Github** from the [sign-in](https://cloud.redis.io/) screen.
+2. Sign in with the Github account you would like to use.
+3. Select **Authorize** on the **Authorize Redis Okta Auth Github** prompt.
+
+{{<note>}}
+If the email address associated with your GitHub account is not public, you will see an error message that your sign in attempt failed. You need to [make your email address public](https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-personal-account-on-github/managing-email-preferences) on GitHub before you try again.
+{{</note>}}
+
+## Migrate an existing account to social login
+
+If you already have a Redis Cloud account that requires an email address and password to sign in, you can migrate your existing account to use a social login associated with that same email address instead.
+
+{{<warning>}}
+Once you migrate your account to use social login, you cannot revert to your old email/password sign in method.
+{{</warning>}}
+
+To migrate your account to Google social login:
+
+1. Select **Google** on the [sign-in](https://cloud.redis.io/) screen.
+1. Choose your preferred account from the list.
+1. A confirmation prompt will display and warn that you cannot revert to your old sign in method if you proceed with the migration to social login.
+1. Select **Confirm** to continue migration.
+
+To migrate your account to GitHub social login:
+
+1. Select **Github** on the [sign-in](https://cloud.redis.io/) screen.
+1. Select **Authorize** on the **Authorize Redis Okta Auth Github** prompt.
+1. Enter your GitHub password to **Confirm access**. A confirmation prompt warns that you cannot revert to your old sign-in method if you proceed with the migration to social login.
+1. Select **Confirm** to continue migration.
+---
+LinkTitle: Role-based access control
+Title: Enable Role-based access control
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Lets you define multiple users with fine-grained data authorization features.
+headerRange: '[1-3]'
+toc: 'true'
+weight: 10
+---
+
+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](https://en.wikipedia.org/wiki/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.
+
+There are three tabs on this screen: **Users**, **Roles**, and **Redis ACLs**.
+
+In the **Redis ACLs** tab, you [define named *permissions*]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls" >}}) for specific Redis commands, keys, and pub/sub channels.
+
+{{<image filename="images/rc/data-access-control-acls.png" alt="Data access control screen." >}}
+
+In the **Roles** tab, you [create roles]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}). Each role consists of a set of permissions for one or more Redis Cloud databases.
+
+{{<image filename="images/rc/data-access-control-roles.png" alt="Data access control screen." >}}
+
+Finally, in the **Users** tab, you [create users]({{< relref "/operate/rc/security/access-control/data-access-control/create-assign-users" >}}) and [assign each user a role]({{< relref "/operate/rc/security/access-control/data-access-control/create-assign-users#assign-roles-to-existing-users" >}}).
+
+{{<image filename="images/rc/data-access-control-users.png" alt="Data access control screen." >}}
+
+{{<note>}}Database access users are different from account access users. To learn more, see [Access management]({{< relref "/operate/rc/security/access-control/" >}}).{{</note>}}
+
+
+## Redis ACLs vs. Redis Cloud RBAC
+
+In Redis, you can create users and assign ACLs to them using the `ACL` command. However, 
+Redis does not support generic roles.
+
+In Redis Cloud, you configure RBAC using the Redis Cloud console. As a result, certain Redis ACL
+subcommands are not available in Redis Cloud. The following table shows which ACL commands are supported.
+
+{{<embed-md "acl-command-compatibility.md">}}
+
+In Redis, you must explicitly provide access to the `MULTI`, `EXEC`, and `DISCARD` commands.
+In Redis Cloud, these commands, which are used in transactions, are always permitted. However, the commands
+run within the transaction block are subject to RBAC permissions.
+
+When you run multi-key commands on multi-slot keys, the return value is `failure` but the command runs on the keys that are allowed.
+
+
+
+---
+LinkTitle: Configure ACLs
+Title: Configure permissions with Redis ACLs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+headerRange: '[1-3]'
+toc: 'true'
+weight: 15
+---
+
+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:
+
+1. Go to **Data Access Control** from the [Redis Cloud console](https://cloud.redis.io/#/) menu.
+
+    {{<image filename="images/rc/data-access-control-menu.png" width="200px" alt="Menu for database access control." >}}
+
+1. Select the **Redis ACLs** tab.
+
+    {{<image filename="images/rc/data-access-control-redis-acls.png" alt="Redis ACLs area." >}}
+
+1. Either select `+` to create a new Redis ACL or point to an existing ACL and select the pencil icon to edit it.
+
+    {{<image filename="images/rc/data-access-control-redis-acls-add-or-update.png" width="400px" alt="Add or Update Redis ACL." >}}
+
+    {{< note >}}The built-in Redis ACLs can't be edited.{{< /note >}}
+
+1. Provide a descriptive name and create the ACL rule [using ACL syntax](#define-permissions-with-acl-syntax).
+
+    {{<image filename="images/rc/data-access-control-redis-acls-add.png" alt="Add Redis ACL." >}}
+
+1. Select the check mark to save your changes.  Your new Redis ACL should appear in the list.
+
+    {{<image filename="images/rc/data-access-control-redis-acls-saved.png" alt="Saved Redis ACL." >}}
+
+After you create a Redis ACL, you can assign it to a role. Redis ACLs are not fully verified until they are assigned to a role. For more information, see [Create roles]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}) or [Active-Active access roles]({{< relref "/operate/rc/security/access-control/data-access-control/active-active-roles" >}}) for an [Active-Active database]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}).
+
+## Define permissions with ACL syntax
+
+You can define these permissions using the [Redis ACL syntax]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#acl-rules). This syntax lets you concisely specify which commands, command categories, keys, and pub/sub channels to allow.
+
+- `+` *includes* commands or command categories
+- `-` *excludes* commands or command categories
+- `@` indicates a command category
+- `~` defines a permitted key pattern
+- `&` allows access to a [pub/sub channel]({{< relref "/develop/interact/pubsub" >}})
+
+The Redis Cloud console will validate your ACL syntax while you are typing.
+
+### Command ACL rules
+
+A **command** can be any [Redis command]({{< relref "/commands" >}}).
+
+For example, this Redis ACL rule indicates that the `SET` command is permitted:
+
+```sh
++set
+```
+
+### Command category ACL rules
+
+A [**command category**]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories) is a predefined, named set of commands.
+
+For example, the Redis commands that
+read data are available in the `read` command category. This Redis ACL rule permits access to all read commands:
+
+```sh
++@read
+```
+
+To find out which commands are included in the
+`read` command category, run the following command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+ACL CAT read
+```
+
+### Key ACL rules
+
+To specify which **keys** are accessible, use the [key permissions syntax]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#key-permissions).
+
+The following ACL rule allows access to all keys:
+
+```sh
+~*
+```
+
+Whereas, this ACL rule only allows access to keys prefixed with `cache:`
+
+```
+~cache:*
+```
+
+Starting with Redis 7.0, key patterns can also be used to define how a command is able to read or write a key.
+
+The following ACL rule allows you to copy information from keys prefixed with `cache:` into keys prefixed with `app:`:
+
+```text
++@all ~app:* %R~cache:*
+```
+
+For more information on how this works, see the [key permissions syntax]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#key-permissions).
+
+### Pub/sub ACL rules
+
+Pub/sub ACL rules determine which pub/sub channels a user can access. For more information see, [Redis pub/sub]({{< relref "/develop/interact/pubsub" >}})
+
+For versions older than Redis 7.0, pub/sub is permissive and allows access to all channels by default.
+
+Redis 7.0 makes pub/sub restrictive and blocks access to all channels in Redis Software. However, Redis Cloud still defaults to permissive pub/sub even for Redis 7.0 subscriptions.
+
+| Redis<br />version | Redis Open Source<br />pub/sub ACLs | Redis Cloud<br />pub/sub ACLs |
+|:-------------:|-----------|-------------|
+| 6.0 | Not supported | Not supported |
+| 6.2 | Permissive | Permissive |
+| 7.0 | Restrictive | Permissive |
+
+#### Restrict channel access
+
+To block access to all channels, use the following ACL rule:
+
+```sh
+resetchannels
+```
+
+If you want to limit access to specific channels, first include `resetchannels`. Then use `&` syntax to allow access to particular channels:
+
+```sh
+resetchannels &channel1 &channel2
+```
+
+#### Allow all channels
+
+To make pub/sub explicitly permissive and allow users to access all channels, set the following rule:
+
+```sh
+allchannels
+```
+
+### Selectors
+
+Starting with Redis 7.0, Redis supports adding multiple sets of rules that are evaluated independently of each other, called [selectors]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#selectors). 
+
+The following ACL rule allows a user to execute `GET` on keys prefixed with `cache` and `SET` on keys prefixed with `app`:
+
+```text
++GET ~cache:* (+SET ~app:*)
+```
+
+### Predefined permissions
+
+Redis Cloud includes three predefined permissions:
+
+- Full-Access (`+@all ~*`) - All commands are allowed for all keys.
+
+- Read-Write (`+@all -@dangerous ~*`) - All commands except for the `dangerous` command category are allowed for all keys.
+
+- Read-Only (`+@read ~*`) - Only the `read` command category is allowed for all keys.
+
+### Advanced capability command permissions
+
+Note that you can define permissions for the Redis commands of any advanced capabilities that are part of your subscription;
+however, these permissions can only be used for databases that support those capabilities.---
+LinkTitle: Create roles
+Title: Assign permissions to roles
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+headerRange: '[1-3]'
+toc: 'true'
+weight: 20
+---
+
+To assign [Redis ACLs]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls" >}}) to a data access role:
+
+1. Go to **Data Access Control** from the [Redis Cloud console](https://cloud.redis.io/#/) menu.
+
+    {{<image filename="images/rc/data-access-control-menu.png" width="200px" alt="Menu for database access control." >}}
+
+1. Select the **Roles** tab.
+
+    {{<image filename="images/rc/data-access-control-roles.png" alt="Role configuration area." >}}
+
+1. Select `+` to create a new role or point to an existing role and select the pencil icon to edit it.
+
+    {{<image filename="images/rc/data-access-control-roles-add-or-edit.png" width="300px" alt="Add or edit a role." >}}
+
+1. Enter a name for the role.
+
+    {{<image filename="images/rc/data-access-control-roles-add.png" width="400px" alt="Role add screen." >}}
+
+1. Select an **ACL rule** to assign to the role.
+
+    {{<image filename="images/rc/data-access-control-roles-select-acl.png" width="300px" alt="Select an ACL Rule." >}}
+
+1. Select one or more databases from the **Databases** list and click the check mark to confirm the association.
+
+    {{<image filename="images/rc/data-access-control-roles-select-databases.png" width="400px" alt="Select databases." >}}
+
+1. Select **Save role**.
+
+When you assign a user-defined ACL rule to a role and associate it with one or more databases, we'll verify that the ACL rule will work with the selected databases. 
+
+After you create a role, you can assign it to a user. Users with this role can access the databases according to the role's associated Redis ACLs. For more information, see [Assign roles to users]({{< relref "/operate/rc/security/access-control/data-access-control/create-assign-users#assign-roles-to-existing-users" >}}).
+
+To assign Redis ACLs to a role for an [Active-Active database]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}), see [Active-Active access roles]({{< relref "/operate/rc/security/access-control/data-access-control/active-active-roles" >}}).
+
+{{< note >}}
+{{< embed-md "rc-acls-note.md" >}}
+{{< /note >}}---
+LinkTitle: Create users
+Title: Create and edit database users
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Create a database user and assign it a role.
+headerRange: '[1-3]'
+toc: 'true'
+weight: 25
+---
+
+Before you create a database user, you must [create a data access role]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}) to assign to that user.
+
+## Create a user
+
+To create a user:
+
+1. Go to **Data Access Control** from the [Redis Cloud console](https://cloud.redis.io/#/) menu.
+
+    {{<image filename="images/rc/data-access-control-menu.png" width="200px" alt="Menu for database access control." >}}
+
+1. Select the **Users** tab.
+
+    {{<image filename="images/rc/data-access-control-users-no-users.png" alt="User configuration area." >}}
+
+2. Select `+` to create a new user.
+
+    {{<image filename="images/rc/data-access-control-users-add-or-edit.png" width="300px" alt="User add or edit." >}}
+
+3. Enter a username in the **Username** field.
+
+    {{<image filename="images/rc/data-access-control-users-add.png" alt="User add username." >}}
+
+    {{<note>}}
+An error occurs if a user tries to connect to a memcached database with the username `admin`. Do not use `admin` for a username if the user will be connecting to a memcached database.
+    {{</note>}}
+
+1. Select a [**Role**]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}) from the list.
+
+    {{<image filename="images/rc/data-access-control-users-add-role.png" width="300px" alt="User select role." >}}
+
+1. Enter and confirm the user's password. ACL user passwords must be between 8 and 128 characters long.
+
+    Then, select the check mark to save the user. 
+
+    {{<image filename="images/rc/data-access-control-users-password-and-finish.png" width="300px" alt="User add password and finish." >}}
+
+
+## Assign roles to existing users
+
+To assign a data access role to an existing user:
+
+1. Go to **Data Access Control** from the [Redis Cloud console](https://cloud.redis.io/#/) menu.
+
+    {{<image filename="images/rc/data-access-control-menu.png" width="200px" alt="Menu for database access control." >}}
+
+1. Select the **Users** tab.
+
+    {{<image filename="images/rc/data-access-control-users.png" alt="User configuration area." >}}
+
+1. Point to the user and select the **Edit*** icon when it appears.
+
+    {{<image filename="images/rc/data-access-control-users-add-or-edit.png" width="300px" alt="User add or edit." >}}
+
+1. Select a [**Role**]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}}) from the list.
+
+    {{<image filename="images/rc/data-access-control-users-add-role.png" width="300px" alt="User select role." >}}
+
+1. Select the check mark to save the user. 
+
+    {{<image filename="images/rc/data-access-control-users-password-and-finish.png" width="300px" alt="User add password and finish." >}}---
+LinkTitle: Active-Active roles
+Title: Create roles for Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+headerRange: '[1-3]'
+toc: 'true'
+weight: $weight
+---
+
+For [Active-Active databases]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}), you can define roles with different levels of access for different regions. For example, you can define a user role with full database access in one region and read-only access in another. Or, you can prevent a user from running any commands in a specified region.
+
+1. Go to **Data Access Control > Roles** and either select `+` to create a new role or point to an existing role and select the pencil icon to edit it.
+
+    {{<image filename="images/rc/data-access-control-roles-add-or-edit.png" width="300px" alt="Add or edit a role." >}}
+
+1. In the **Associations** section of the **Edit role** or **Create new role** screen, you can select `+` to create a new association or point to an existing association and select the pencil icon to edit it.
+
+1. Select one or more Active-Active databases from the **Databases** list. Active-Active databases are marked with a globe icon.
+
+    {{<image filename="images/rc/roles-select-aa-database.png" alt="List of databases. Active-Active databases are marked with a globe icon." >}}
+
+1. To set the role's default level of access to the selected databases, choose a **Redis ACL** from the list and select the check mark to confirm the association.
+
+    {{< note >}}
+The default level of access to the selected database only applies to regions that exist when the role is created. If you add a new region to your Active-Active subscription, the new region will default to **No Access** for the role.
+    {{< /note >}}
+
+1. Select the ACL name next to a region to change which ACL applies to that region.
+
+    {{<image filename="images/rc/roles-assign-rules-active-active.png" alt="Assign different ACL rules for different regions." >}}
+
+    In addition to the ACL rules that are already configured, you can set a role to have **No-Access** in a region. This is a special rule that prevents a user with this role from running any commands when connecting to the database in that region.
+
+1. Select **Save role**.
+
+When you assign a user-defined ACL rule to a role and associate it with one or more databases, Redis will verify that the ACL rule will work with the selected databases. Verify that the [syntax]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls#define-permissions-with-acl-syntax" >}}) of the ACL rule is correct if you receive an error.
+
+After you create a role, you can assign it to a user. Users with this role can access the databases according to the role's associated Redis ACLs. For more information, see [Assign roles to users]({{< relref "/operate/rc/security/access-control/data-access-control/create-assign-users#assign-roles-to-existing-users" >}}).
+
+{{< note >}}
+{{< embed-md "rc-acls-note.md" >}}
+{{< /note >}}---
+LinkTitle: Data access control
+Title: Data access control
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Control who can access your databases using the default user database
+  password and role-based access control.
+headerRange: '[1-3]'
+hideListLinks: true
+toc: 'true'
+weight: 25
+---
+
+## Default user
+
+When you create a Redis Cloud database, your database is given a randomly generated password called the [**Default user password**]({{< relref "/operate/rc/security/access-control/data-access-control/default-user" >}}). Learn how to [change the default user password]({{< relref "/operate/rc/security/access-control/data-access-control/default-user#change-password" >}}) or [turn off default user access]({{< relref "/operate/rc/security/access-control/data-access-control/default-user#turn-off-default-user" >}}).
+
+## Role-based access control
+
+With [role-based access control (RBAC)]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control.md" >}}), you create roles and assign users to those roles to grant different levels of access to the database.
+
+- [Enable RBAC]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}})
+- [Configure ACLs]({{< relref "/operate/rc/security/access-control/data-access-control/configure-acls" >}})
+- [Create roles]({{< relref "/operate/rc/security/access-control/data-access-control/create-roles" >}})
+- [Create and edit database users]({{< relref "/operate/rc/security/access-control/data-access-control/create-assign-users" >}})
+- [Active-Active roles]({{< relref "/operate/rc/security/access-control/data-access-control/active-active-roles" >}})---
+Title: Default user
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Learn how to change your default user password or turn off access using
+  the default user password.
+linkTitle: Default user
+weight: 5
+---
+
+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.
+
+{{<image filename="images/rc/database-fixed-configuration-security.png" alt="The Default user password appears in the Security section of the Configuration tab on the database details screen." >}}
+
+Use the copy button to copy the password to the clipboard:
+
+{{<image filename="images/rc/button-copy.png"  alt="Use the Copy button to copy the default user password." >}}
+
+You'll need to use this password whenever you connect to your database using a Redis client. See [Connect to a database]({{< relref "/operate/rc/databases/connect" >}}) for more info.
+
+See your [Redis client's documentation]({{< relref "/develop/clients" >}}) to learn how to provide your password when connecting.
+
+## Change password
+
+To change the default user password for your database:
+
+1. From the database **Configuration** tab, select **Edit**.
+
+    {{<image filename="images/rc/button-database-edit.png" width="100px" alt="The Edit button lets you change the database's default user password." >}}
+
+1. Under the **Security** section, enter the new password in the **Default user password** field. Database passwords must be less than 50 characters long.
+
+1. Select **Save database** to update the password.
+
+    {{<image filename="images/rc/button-database-save.png" width="150px" alt="Use the Save database button to save the new password." >}}
+
+## Turn off default user
+
+After you set up [role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}}) to limit who can access your database, we recommend that you turn off default user access.
+
+To turn off the default user for a database:
+
+1. From the database **Configuration** tab, select **Edit**.
+
+    {{<image filename="images/rc/button-database-edit.png" width="100px" alt="The Edit database button lets you change the database's default user password." >}}
+
+1. Under the **Security** section, select the **Default User** switch to turn it off.
+
+1. Select **Save database**.
+
+    {{<image filename="images/rc/button-database-save.png" width="150px" alt="Use the Save database button to save the new password." >}}---
+Title: Multi-factor authentication
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Redis Cloud supports multi-factor authentication to reduce the risk of
+  unauthorized Redis Cloud console access.
+linkTitle: Multi-factor authentication
+weight: 15
+---
+
+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](#app) such as [Google Authenticator](https://en.wikipedia.org/wiki/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](#enforcing).
+
+{{< note >}}
+Once you enable MFA, it will be required to access every account that belongs to you. Deactivating MFA enforcement on an account does not deactivate MFA enforcement for other users of that account that have defined a phone number. To deactivate MFA enforcement for other users, those users will each need to deactivate MFA enforcement for their own user accounts.
+{{< /note >}}
+
+### Enable MFA
+
+Each user can enable and configure MFA for their account.
+The default MFA configuration sends an authentication code by text message that users must enter when they sign in.
+
+To configure MFA for your user account:
+
+1. Sign in to your account.
+2. From the Redis Cloud console menu, select your name and then **User Profile** from the drop down menu.
+
+    {{<image filename="images/rc/multi-factor-authentication-user-dropdown.png"  width="300px" alt="Use the user drop down menu to get to the User Profile section." >}}
+
+3. Under your user profile, locate **Multi-factor authentication**.
+
+    {{<image filename="images/rc/multi-factor-authentication-user-profile.png" alt="Multi-factor authentication is located on the user profile page." >}}
+
+4. Enter your mobile phone number in the **Text message** box and then select **Send code**.
+5. You will receive a confirmation code sent by text message. Enter the code when prompted by the Redis Cloud console and select **Verify**.
+
+Your account is now configured for MFA.
+
+{{< note >}}
+We recommend that you also [configure MFA for an authenticator app](#app) as an additional factor.
+{{< /note >}}
+
+If you cannot sign in to your account because of MFA, please [contact support](https://redis.io/support/).
+
+If your mobile phone is lost or stolen, make sure that you update the MFA configuration to prevent unauthorized sign-ins.
+
+
+### Change your MFA phone number
+
+To change the mobile phone number used for MFA:
+
+1. Navigate to the Multi-Factor authentication section in the **User Profile**.
+2. Select **Change number**.
+3. Enter the new mobile phone number, and complete the verification process as described above.
+
+
+### Configure MFA for an authenticator app {#app}
+
+After you configure MFA for text messages, you can also configure MFA to work with a time-based one-time password (TOTP) app such as [Google Authenticator](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2&hl=en_US&gl=US&pli=1).
+
+When you sign in to the Redis Cloud console, you can select  either an authentication code sent by text message or an authentication code shown in your authenticator app.
+
+To configure MFA for an authenticator app:
+
+1. Install an authenticator app on your mobile phone.
+1. Add Redis Cloud to the app:
+    1. From the **User Profile** view in your Redis Cloud account, locate **Multi-Factor Authentication**.
+    1. Select **Connect** for the authenticator app. A QR code appears, requesting verification.
+    1. Scan the QR code using your phone's authenticator app.
+    1. Enter the code generated by your authenticator app to verify the setup.
+
+You can now use either a text message code or an authenticator app code as your second factor when signing in.
+
+#### Deactivate MFA
+
+You can deactivate MFA for your user account. To deactivate MFA, go to your profile, locate **Multi-Factor Authentication**, and select **Deactivate**.
+
+### Enforce MFA for all user accounts {#enforcing}
+
+Account owner users can enable MFA enforcement for all users in their account.
+After MFA is enforced for the account, all users who do not have MFA enabled will be required to configure MFA the next time they sign in to the Redis Cloud console.
+
+{{< note >}}
+Redis Cloud does not enforce MFA for [SAML SSO]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) users since the identity provider handles MFA management and enforcement.
+{{< /note >}}
+
+To enable MFA enforcement for all user accounts:
+
+1. Sign in as an account owner.
+2. Go to **Account Settings**.
+3. Under **Security**, switch the **MFA environment** toggle to *On*.
+
+    {{<image filename="images/rc/multi-factor-authentication-force-all-users-on.png" alt="Multi-factor authentication toggle for all users on." >}}
+
+- When you enable MFA enforcement, users cannot disable MFA for their account.
+- When you disable MFA enforcement, users can disable MFA for their account.
+
+4. Select **Save changes** to save your changes.
+
+{{< tip >}}
+Notify all of your Redis Cloud console users before enabling MFA enforcement.
+{{< /tip >}}
+---
+Title: Access management
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Control who can make changes to your databases using the Redis Cloud
+  console.
+weight: 5
+---
+
+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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+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]({{< relref "/operate/rc/api/get-started/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.
+
+{{<image filename="images/rc/access-management-team-tab.png" alt="The Access management tab helps you manage the people allowed to access your subscription." >}}
+
+The list contains one entry summarizing the team settings for each user in your team. By default, the list includes the account owner.
+
+The list includes several buttons and icons to help you manage the list:
+
+| Icon | Description |
+|------|-------------|
+| {{<image filename="images/rc/icon-add.png#no-click" width="30px" alt="Use the Add button to add members to your team." class="inline" >}} | The **Add** button lets you add members to your team |
+| {{<image filename="images/rc/icon-edit.png#no-click" width="30px" alt="Use the Edit button change details for a team member." class="inline">}} | The **Edit** button lets you edit the settings for the selected team member |
+| {{<image filename="images/rc/icon-delete-teal.png#no-click" width="30px" alt="Use the Delete button to remove a member from your team." class="inline">}} | The **Delete** button lets you remove members from your team
+| <nobr>{{<image filename="images/rc/icon-list-sort-asc.png#no-click" width="10px" alt="The Sort ascending button displays members in ascending order according to the values of the selected field." class="inline">}}{{<image filename="images/rc/icon-list-sort-desc.png#no-click" width="10px" alt="The Sort descending button displays members in descending order according to the values of the selected field." class="inline">}}</nobr> | The **Sort ascending** and **Sort descending** icons display the list according to the selected order |
+
+You can also use the list search to find a specific user or filter by **Role**, **User Type**, or **Options**.
+
+### Add user
+
+When you add a member to your team, the **Add user** dialog appears.  
+
+{{<image filename="images/rc/access-mgmt-add-user-dialog.png" width="50%" alt="Use the Add User dialog to specify the details for your new user." >}}
+
+Use the dialog to specify these values.
+
+| Setting | Description |
+|---------|-------------|
+| **First name** | First name of the user displayed in the Redis Cloud console and in email messages |
+| **Last name** | Last name of the user displayed in the Redis Cloud console and in email messages |
+| **Role** | The role identifies their subscription and account privileges.  For details, see [Team management roles](#team-management-roles). |
+| **Email** | The address used for alerts and other email messages regarding the account | 
+| **Alert emails** | Enable to be notified when subscription databases cross certain thresholds, such as exceeding memory limits or latency requirements |
+| **Operational emails** | Notifications about subscription and database changes, such as creating or deleting a database, and [subscription and database maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) |
+| **Billing emails** | Notifications about billing, such as when bills are issued and paid |
+| **Multi-factor authentication** | Whether MFA is enabled for the member.  This is deactivated when members have not enabled or confirmed MFA in their user profile settings. |
+
+Use the **Add user** button to save your new team member details. 
+
+Redis will send an activation email to the user once their details are saved. After following the activation link, they can sign in.
+
+### Edit user
+
+To edit user team details, select the user from the list and then select the **Edit** button.
+The **Edit user** dialog displays the details you can change.  
+
+{{<image filename="images/rc/access-mgmt-edit-user-dialog.png" width="50%" alt="Use the Edit User dialog to change the details for a user" >}}
+
+You can change any detail except the team member's email address.
+
+Select **Save user** to save your changes.
+
+### Delete user
+
+To remove a member from your team, select them from the list and then select the **Delete** button. A confirmation dialog appears.  
+
+{{<image filename="images/rc/access-management-delete-user-dialog.png" width="50%" alt="Confirm that you want to remove a user from your team" >}}
+
+Select **Delete user** to confirm removal. This is a permanent action that cannot be undone.
+
+## Team management roles
+
+Each team member is assigned a role that identifies their privileges and limits their activities in the Redis Cloud console.
+
+Roles and responsibilities are:
+
+- **Owner** can view, create, and edit any settings in the account.
+
+    Each subscription must have at least one account owner. Accounts can have multiple owners.
+
+    Owners can also manage subscriptions, databases, and API keys.
+
+- **Billing Admin** can view and edit settings related to billing and payments.
+
+    Billing Admins can add and remove payment methods and change the payment method for a subscription, but they cannot change any other subscription or database settings.
+
+- **Manager** can view, create, and edit any setting in the subscription. 
+
+    Managers can change subscription costs and change payment methods associated with a subscription, but they cannot add or remove available payment methods.
+
+- **Member** can view, create, and edit databases in ways that do not impact costs.
+
+    Members cannot create databases or edit databases in ways that impact costs.
+
+- **Viewer** can view all databases and their configurations, including database secrets.
+
+- **Logs viewer** can not access the Redis Cloud console. They are only allowed access to the [Redis Cloud API]({{< relref "/operate/rc/api" >}}) [`GET logs/`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountSystemLogs" >}}) endpoint. 
+
+This table shows each role's ability to perform common tasks.
+
+| **Task** | **Owner** | **Billing Admin** | **Manager** | **Member** | **Viewer** | **Logs Viewer** |
+|---|---|---|---|---|---|---|
+| Access management | <span title="Owners can manage account access">&#x2705; Yes</span> | <span title="Billing Admins may not manage account access">&#x274c; No</span> | <span title="Managers may not manage account access">&#x274c; No</span> | <span title="Members may not manage account access">&#x274c; No</span> | <span title="Viewers may not manage account access">&#x274c; No</span> | <span title="Logs Viewers may not manage account access">&#x274c; No</span> |
+| Account settings | <span title="Owners can change account settings">&#x2705; Yes</span> | <span title="Billing Admins can change the billing address in account settings">&#x2705; Yes<sup>[1](#table-note-1)</sup></span> | <span title="Managers may not manage account settings">&#x274c; No</span> | <span title="Members may not manage account settings">&#x274c; No</span> | <span title="Viewers may not manage account settings">&#x274c; No</span> | <span title="Logs Viewers may not manage account settings">&#x274c; No</span> |
+| Billing & payments | <span title="Owners can add/remove payment methods and view history">&#x2705; Yes</span> | <span title="Billing Admins can add/remove payment methods and view history">&#x2705; Yes</span> | <span title="Managers may not add/remove payment methods or view billing history (Managers may change subscription payment methods between those available to the account)">&#x274c; No</span> | <span title="Members may not add/remove payment methods or view billing history">&#x274c; No</span> | <span title="Viewers may not add/remove payment methods or view billing history">&#x274c; No</span> | <span title="Logs viewers may not add/remove payment methods or view billing history">&#x274c; No</span> |
+| Create subscription | <span title="Owners can create new subscriptions">&#x2705; Yes</span> | <span title="Billing Admins may not create subscriptions">&#x274c; No</span> | <span title="Managers can create new subscriptions">&#x2705; Yes</span> | <span title="Members may not create subscriptions">&#x274c; No</span> | <span title="Viewers may not create subscriptions">&#x274c; No</span> | <span title="Logs viewers may not create subscriptions">&#x274c; No</span> |
+| Edit subscription | <span title="Owners can edit subscriptions">&#x2705; Yes</span> | <span title="Billing Admins can edit subscriptions to change the payment method">&#x2705; Yes<sup>[2](#table-note-2)</sup></span> | <span title="Managers can edit subscriptions">&#x2705; Yes</span> | <span title="Members may not edit subscriptions">&#x274c; No</span> | <span title="Viewers may not edit subscriptions">&#x274c; No</span> | <span title="Logs viewers may not edit subscriptions">&#x274c; No</span> |
+| Create database (affects cost) | <span title="Owners can create databases when doing so will impact costs">&#x2705; Yes</span> | <span title="Billing Admins may not create databases when doing so will impact costs">&#x274c; No</span> | <span title="Managers can create databases when doing so will impact costs">&#x2705; Yes</span> | <span title="Members may not create databases when doing so will impact costs">&#x274c; No</span> | <span title="Viewers may not create databases when doing so will impact costs">&#x274c; No</span> | <span title="Logs viewers may not create databases when doing so will impact costs">&#x274c; No</span> |
+| Edit database (affects cost) | <span title="Owners can edit databases in ways that will impact costs">&#x2705; Yes</span> | <span title="Billing Admins may not edit databases in ways that impact costs">&#x274c; No</span> | <span title="Managers can edit databases in ways that impact costs">&#x2705; Yes</span> | <span title="Members may not edit databases in ways that impact costs">&#x274c; No</span> | <span title="Viewers may not edit databases in ways that impact costs">&#x274c; No</span> | <span title="Logs viewers may not edit databases in ways that impact costs">&#x274c; No</span> |
+| Create database (no cost impact) | <span title="Owners can create databases when doing so will not impact costs">&#x2705; Yes</span> | <span title="Billing Admins may not create databases when doing so will not impact costs">&#x274c; No</span> | <span title="Managers can create databases when doing so will not impact costs">&#x2705; Yes</span> | <span title="Members can not create databases when doing so will not impact costs">&#x274c; No</span> | <span title="Viewers may not create databases when doing so will not impact costs">&#x274c; No</span> | <span title="Logs viewers may not create databases when doing so will not impact costs">&#x274c; No</span> |
+| Edit database (no cost impact) | <span title="Owners can edit databases in ways that do not impact costs">&#x2705; Yes</span> | <span title="Billing Admins may not change databases in ways that do not affect costs">&#x274c; No</span> | <span title="Managers can change databases in ways that do not affect costs">&#x2705; Yes</span> | <span title="Members can change databases in ways that do not affect costs">&#x2705; Yes</span> | <span title="Viewers may not change databases in ways that do not affect costs">&#x274c; No</span> | <span title="Logs viewers may not change databases in ways that do not affect costs">&#x274c; No</span> |
+| View subscription | <span title="Owners can view subscription details">&#x2705; Yes</span> | <span title="Billing Admins can view subscription details">&#x2705; Yes</span> | <span title="Managers can view subscription details">&#x2705; Yes</span> | <span title="Members can view subscription details">&#x2705; Yes</span> | <span title="Viewers can view subscription details">&#x2705; Yes</span> | <span title="Logs viewers may not view subscriptions">&#x274c; No</span> |
+| View database | <span title="Owners can view database details">&#x2705; Yes</span> | <span title="Billing Admins can view the list of databases but not database details">&#x2705; Yes<sup>[3](#table-note-3)</sup></span> | <span title="Managers can view database details">&#x2705; Yes</span> | <span title="Members can view database details">&#x2705; Yes</span> | <span title="Viewers can view database details">&#x2705; Yes</span> | <span title="Logs viewers may not view databases">&#x274c; No</span> |
+| Use the [REST API]({{< relref "/operate/rc/api" >}}) | <span title="Owners can use the Redis Cloud API">&#x2705; Yes</span> | <span title="Billing Admins may not use the Redis Cloud API">&#x274c; No</span> | <span title="Managers may not use the REST API">&#x274c; No</span> | <span title="Members may not use the REST API">&#x274c; No</span> | <span title="Viewers can use the REST API for GET requests only">&#x2705; Yes<sup>[4](#table-note-4)</sup></span> | <span title="Logs viewers can use the REST API for GET /logs only">&#x2705; Yes<sup>[5](#table-note-5)</sup></span> |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>Billing Admins can only edit the account billing address in Account Settings.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>Billing Admins can only change the payment method when editing a subscription.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a>Billing Admins can see the list of databases, but can not see database details, including connection details.
+
+4. <a name="table-note-4" style="display: block; height: 80px; margin-top: -80px;"></a>Viewers can use the REST API for GET requests, but can not modify subscription or database details.
+
+5. <a name="table-note-5" style="display: block; height: 80px; margin-top: -80px;"></a>Logs viewers can only use the [`GET logs/`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountSystemLogs" >}}) endpoint of the REST API.
+---
+Title: Auth0 SAML integration guide
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to configure Auth0 as a SAML single
+  sign on provider for your Redis Cloud account.
+linkTitle: Auth0 integration
+weight: 10
+---
+
+This guide shows how to configure [Auth0](https://auth0.com/docs) 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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) you want to associate with your SAML setup.
+
+## Step 1: Set up your identity provider (IdP)
+
+### Specify the SAML owner
+
+1. Sign in to your Auth0 account and navigate to **User Management > Users**.
+   * Select the SAML owner.
+   * Verify the details.
+
+    SAML assertion requires first and last name, which are not available in the default user profile. 
+
+    > **Note**: Depending how they are created, users can have different profiles. 
+
+    {{<image filename="images/rc/saml/auth0_saml_1.png" >}}
+
+1. Add `user_metadata` to fulfill the SAML assertion, then select **Save**. 
+   
+   {{<image filename="images/rc/saml/auth0_saml_2.png" >}}
+
+   The key-value pair of `redisAccountMapping` consists of a lowercase role name (owner, member, manager, billing_admin, or viewer) and your Redis Cloud Account ID found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}).
+
+    ```
+    {
+       "FirstName": "Test",
+       "LastName": "User",
+       "redisAccountMapping": "YOUR_REDIS_CLOUD_ID=owner"
+    }
+    ```
+
+1. Open **Auth Pipeline > Rules** and select **Create**.
+
+    {{<image filename="images/rc/saml/auth0_saml_3.png" >}}
+
+1. Pick a rule template then select **Empty rule**.
+
+1. Provide a **name** for the rule and add the following script.
+
+    ```
+    function mapSamlAttributes(user, context, callback) {
+      user.user_metadata = user.user_metadata || {};
+      context.samlConfiguration.mappings = {
+         "Email": "email",
+         "LastName":  "user_metadata.LastName",
+         "FirstName": "user_metadata.FirstName",
+         "redisAccountMapping": "user_metadata.redisAccountMapping"
+      };
+      callback(null, user, context);
+    }
+    ```
+
+ 1. Select **Save Changes**.
+
+    {{<image filename="images/rc/saml/auth0_saml_4.png" >}}
+
+### Create and configure the SAML application
+
+1. Open **Applications > Applications** and select **Create Application**.
+
+    {{<image filename="images/rc/saml/auth0_saml_5.png" >}}
+
+1. Provide a **name** for the Application and select **Single Page Web Applications**. Select **Create**.
+
+    {{<image filename="images/rc/saml/auth0_saml_6.png" >}}
+
+1. From the newly created application, go to **Settings > Advanced Settings > Certificates**.
+
+    * Copy and save the **Signing Certificate**. You will need this information to configure SAML in admin console.
+
+    {{<image filename="images/rc/saml/auth0_saml_7.png" >}}
+
+    * We suggest that you update the default logo of the application to the Redis icon for better visibility. 
+
+1. From the newly created application, go to **Addons** and enable **SAML 2 WEB APP**.
+
+    {{<image filename="images/rc/saml/auth0_saml_8.png" >}}
+
+1. From the **Usage** tab:
+
+    * Copy and save the **Issuer** value.
+    * Copy and save the **Identity Provider Login URL**.
+    
+    You will need both of these values, along with the certificate value you copied in the previous step, to configure SAML in admin console.
+
+    {{<image filename="images/rc/saml/auth0_saml_9.png" >}}
+
+## Step 2: Configure SAML support in Redis Cloud
+
+Now that you have you Auth0 IdP server ready, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in Access Management
+
+To activate SAML, you need to have a local user (or social sign-on user) with the **owner** role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Fill in the information you saved previously in the **setup** form. This includes:
+
+    * **Issuer (IdP Entity ID)**: Issuer value from Auth0
+    * **IdP server URL**: Identity Provider Login URL from Auth0
+    * **Assertion signing certificate**: Certificate value from Auth0
+
+    {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+    Once you click **Enable**, wait a few seconds for the status to change.
+
+1. Download the service provider (SP) metadata. Save the file to your local hard disk.
+
+    {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+    * **EntityID**: The unique name of the service provider (SP)
+
+    {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+    * **Location** : The location of the assertion consumer service
+
+    {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+## Step 3: Finish SAML configuration in Auth0
+
+1. Return to the Auth0 SAML application and select **Addons > Settings**:
+
+    {{<image filename="images/rc/saml/auth0_saml_10.png" >}}
+
+    * Paste the **Location** link in **Application Callback URL** field.
+
+    * To update the **Settings** code area, add this code. Modify the `audience` variable with the `EntityID` value from the metadata file you downloaded. Also, modify the `recipient` variable with the `Location` value from the metadata file you downloaded.
+
+    ```
+    {
+      "audience": "ENTITYID VALUE FROM FILE",
+      "recipient": "LOCATION VALUE FROM FILE",
+      "passthroughClaimsWithNoMapping": false,
+      "nameIdentifierProbes": [
+        "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress"
+      ]
+    }
+    ```
+    Scroll down and select **Save** to apply the configuration.
+
+### IdP initiated SSO
+
+To use IdP-initiated SSO with certain identity providers, you also need to set the `RelayState` parameter to this URL: 
+
+`https://cloud.redis.io/#/login/?idpId=<ID>`
+
+{{< note >}}
+Replace `ID` so it matches the `AssertionConsumerService` Location URL ID (the content after the last forward slash "/"). To learn more about how to configure service provider apps, see your identity provider’s documentation.
+{{</ note >}}
+
+## Step 4: Return to the Redis Cloud console
+
+1. Return to the Redis Cloud console and select **Activate**.
+
+    {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+   A popup appears, explaining that, in order to test the SAML connection, we need to login with credentials of a user defined in Auth0. Select **Continue** to go to the Auth0 login screen.
+
+1. The Auth0 login screen appears. Enter the credentials and select **Sign In**.
+
+    {{<image filename="images/rc/saml/auth0_saml_12.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}
+---
+Title: PingIdentity SAML integration guide
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to set up PingIndentity as a SAML single
+  sign-on provider for your Redis Cloud account.
+linkTitle: PingIdentity integration
+weight: 10
+---
+
+This guide shows how to configure [PingIdentity](https://docs.pingidentity.com/p/en-us/makeitwork#top) 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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) you want to associate with your SAML setup.
+
+## Step 1: Set up your identity provider (IdP)
+
+### Add the `redisAccountMapping` attribute
+
+1. Log in into your Ping Identity account. Open **Administrators > Identities > User Attributes** and select **Add Attribute**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_1.png" >}}
+
+2. Select the **DECLARED** attribute type.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_2.png" >}}
+
+3. Fill in the fields with the following values:
+
+    * **Name**: `redisAccountMapping`
+    * **Display name**: `redisAccountMapping`
+    * **Description**: `redisAccountMapping`
+
+    {{<image filename="images/rc/saml/ping_identity_saml_3.png" >}}
+
+    Select **Save and Close**. Then, verify that the attribute was created successfully.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_4.png" >}}
+
+### Add the user who will activate SAML in Service Manager (Redis Cloud)
+
+1. Go to **Administrators > Identities > Users** and select **Add User**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_5.png" >}}
+
+1. Fill in the following information:
+
+    * **redisAccountMapping**: `{accountID}={role}`
+     
+    **accountID** is the account ID from [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}) and **role** represents the role that the user will be assigned in Redis Cloud console (owner, member, manager, billing_admin, or viewer):
+
+    {{<image filename="images/rc/saml/ping_identity_saml_6.png" >}}
+
+    Save and check that the user was added successfully.
+
+### Create the Ping Identity SAML application
+
+1. Go to **Administrators > Connections > Applications** and select **+** to add a new application.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_7.png" >}}
+
+1. Choose a name for the application, select **SAML Application Type** and select **Configure**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_8.png" >}}
+
+1. In the ACS URLs and Entity ID field add for now some dummy data, like https://example.com
+   
+    * This data will be updated with the correct data in a subsequent step.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_9.png" >}}
+
+    Select **Save**.
+
+1. Go to the **Configuration** tab and save the following information:
+   
+    * Issuer ID
+    * Single Logout Service
+    * Single Signon Service
+
+    This information will be needed once we configure SAML in the Redis Cloud console.
+
+    * Select **Download Metadata**. An XML file will be downloaded. Open it and copy the certificate, which is required for the configuration in Redis Cloud console.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_10.png" >}}
+
+5. Go to the **Attribute Mappings** tab. Add the following attributes:
+
+    * saml_subject
+    * Email
+    * FirstName
+    * LastName
+    * redisAccountMapping
+
+    {{<image filename="images/rc/saml/ping_identity_saml_11.png" >}}
+
+## Step 2: Configure SAML support in Redis Cloud
+
+Now that we have our Ping Identity IdP server ready, we need to configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in access management
+
+To activate SAML, you must have a local user (or social sign-on user) with the **owner** role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Fill in the information you copied previously, including:
+
+    * **Issuer (IdP Entity ID)**: `Issuer ID`
+    * **IdP server URL**: `Single Signon Service`
+    * **Single logout URL**: `Single Logout Service`
+    * **Assertion signing certificate**: Certificate info you copied from the Ping Identity XML file
+
+    Also add:
+
+    * **Email domain binding**: The domain used in your company's email addresses
+
+    {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+    Select **Enable** and wait a few seconds for the status to change.
+
+1. You will then be able to **Download** the service provider (SP) metadata. Save the file to your local hard disk.
+
+    {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+    * **EntityID**: The unique name of the service provider (SP)
+
+    {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+    * **Location**: The location of the assertion consumer service
+
+    {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+## Step 3: Finish SAML configuration in Ping Identity
+
+1. In Ping Identity, go to **Administrators > Connections > Applications** and select your application name. Select the **Configuration** tab and select **Edit**.
+
+    This is where we had entered mock data. We will now enter the correct data for this step:
+
+    * Paste **EntityID** information in the **Entity ID** field.
+
+    * Paste **Location** link in the ACS URLS field.
+
+    * For the **Sign on URL** field, add URL `https://cloud.redis.io/#/login/?idpId=`, where you need to add the ID from the Reply URL ID, for example, `https://cloud.redis.io/#/login/?idpId=0oa5pwatz2JfpfCb91d7`.
+
+    Select **Save**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_13.png" >}}
+
+1. Select the slider to enable the app.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_14.png" >}}
+
+## Step 4: Return to Redis Cloud console
+
+1. Return to the Redis Cloud console and select **Activate**.
+
+    {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+1. A popup appears, explaining that to test the SAML connection, you need to log in with credentials of a user defined in Ping Federate. Select **Continue** to go to the Ping Federate login screen.
+
+1. The Ping Federate login screen will appear. Enter the credentials and select **Sign In**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_20.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}
+
+## IdP-initiated SSO
+
+`https://cloud.redis.io/#/login/?idpId=`
+
+1. In Ping Identity, go to **Administrators > Connections > Applications** and select your application name. Select the **Configuration** tab and select **Edit**.
+
+1. Go to **Target Application URL** and enter: **https://{enviroment}/#/login/?idpId={idpId}**, where idpId is the ID found in the Location field, after the last '/'
+
+1. Select **Save**.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_16.png" >}}
+
+1. Go to **https://apps.pingone.com/{environment}/myapps/#**, where environment is the environment ID, found in **Administrators -> Environment** for your app.
+
+    {{<image filename="images/rc/saml/ping_identity_saml_17.png" >}}
+
+   You are redirected to the Redis Cloud console.
+
+---
+Title: Okta SAML integration guide (Generic)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to set up Okta as a SAML single sign-on
+  provider for your Redis Cloud account.
+linkTitle: Okta integration (Generic)
+weight: 10
+---
+
+This guide shows how to configure [Okta](https://help.okta.com/en-us/Content/Topics/Security/Identity_Providers.htm) 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]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-okta-org2org" >}}) application template.
+
+To learn more about Redis Cloud support for SAML, see [SAML single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) you want to associate with your SAML setup.
+
+## Step 1: Set up your demo identity provider (IdP)
+
+To create the Okta SAML integration application:
+
+1. Log in to the Okta admin console. Select **Applications > Create App Integration**.
+
+   {{<image filename="images/rc/saml/okta_saml_app_int_1.png" >}}
+
+1. Select **SAML 2.0**, then select **Next**.
+
+   {{<image filename="images/rc/saml/okta_saml_app_int_2.png" >}}
+
+1. Complete these fields for the SAML application **General Settings** section:
+
+    * **App name**: Redis Cloud
+
+    * **App logo**: Upload a Redis icon.
+
+    Select **Next**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_3.png" >}}
+
+1. In the **Configure SAML** tab, enter this data in the **General** section:
+
+    * **Single sign-on URL**: `http://www.fake.com`. This is a temporary mock URL that you will modify later.
+    * **Audience URI (SP Entity ID)**: `http://www.fake.com`. This is a temporary mock URL that you will modify later.
+    * **Default RelayState**: `https://cloud.redis.io/#/login/?idpId=XXXXXX`. You will need to complete this URL with the `idpId` later. _Complete this field only if you need your SAML flow to be IdP initiated._
+    * **Name ID forma**: `Unspecified`
+    * **Application username**: `Okta username`
+    * **Update application username on**: `Create and update`
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_4.png" >}}
+
+    Next, add __attribute statements__, which are required for the configuration:
+
+    * **Attribute 1**:
+      * **Name**: `redisAccountMapping`
+      * **Name Format**: `Basic`
+      * **Value**: `appuser.redisAccountMapping`
+
+    * **Attribute 2**:
+      * **Name**: `FirstName`
+      * **Name Format**: `Basic`
+      * **Value**: `user.firstName`
+
+    * **Attribute 3**:
+      * **Name**: `LastName`
+      * **Name Format**: `Basic`
+      * **Value**: `user.lastName`
+
+    * **Attribute 4**:
+      * **Name**: `Email`
+      * **Name Format**: `Basic`
+      * **Value**: `user.login`
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_5.png" >}}
+
+    Select **Next**.
+
+1. The last step is an optional feedback step for Okta. Select **I'm an Okta customer adding an internal app** and then select **Finish**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_6.png" >}}
+
+1. Next, scroll down the page of your newly created app integration and select **View Setup Instructions**. A new browser window opens, providing the information you need to configure the IdP in Redis Cloud.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_7.png" >}}
+
+   Scroll down to **Applications > Applications**, and note down the following information:
+   
+    * **Identity Provider Single Sign-On URL**
+    * **Identity Provider Issuer**
+    * **X.509 Certificate**
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_8.png" >}}
+
+   Once you save the information, close the window.
+
+To modify the application user profile:
+
+1. Go to **Directory > Profile Editor** in the left menu, and select **Redis Cloud User**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_9.png" >}}
+
+1. Add the custom attribute to your user profile to specify which Redis Cloud role the user has and on which account. Select **Add Attribute**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_10.png" >}}
+
+1. Add this information for the new custom attribute.
+
+    * **Data type**: `string array`
+    * **Display name**: `redisAccountMapping`
+    * **Variable name**: `redisAccountMapping`
+    * **Description**: `redisAccountMapping`
+    * **Attribute required**: `Yes`
+    * **Group priority**: `Combine values across groups`
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_11.png" >}}
+
+1. Once you add the attribute, it appears in the list of attributes for the profile.
+
+    {{<image filename="images/rc/saml/okta_saml_9.png" >}}
+
+## Step 2: Create a group and assign the application
+
+Now that your SAML IdP is configured, create an Okta group and assign users to the Redis Cloud application.
+
+### Create the group
+
+1. In the left menu, select **Directory > Groups**, then select **Add group**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_1.png" >}}
+
+1. Complete **Name** and  **Description**, then click **Save**.
+ 
+    {{<image filename="images/rc/saml/okta_saml_group_2.png" >}}
+
+    {{<image filename="images/rc/saml/okta_saml_group_3.png" >}}
+
+### Assign users to the group
+
+1. Select the group, then select **Assign people**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_4.png" >}}
+
+1. For each user you want to add to the group, highlight the user in the table and select **+**. You can also select **Add all** to add all users. Once you add all the users to your group, select **Save**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_5.png" >}}
+
+### Assign the application to the group
+
+Now that your group is populated with its users, you can assign the SAML integration application to your group. From **Applications > Applications > Redis Cloud**:
+
+1. Select **Assign to groups** menu item.
+
+    {{<image filename="images/rc/saml/okta_saml_group_6.png" >}}
+
+1. In the **Redis Cloud User Group**, select **Assign**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_7.png" >}}
+
+1. Define the Redis account mapping string default for this group and select **Save and Go Back**. The key-value pair consists of the lowercase role name (owner, member, manager, billing_admin, or viewer) and your **Redis Cloud Account ID** found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}). Select **"Done"**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_8.png" >}}
+
+    The mapping field has now been defined as a default for each member of the group.
+
+    {{<image filename="images/rc/saml/okta_saml_group_9.png" >}}
+
+### Edit the mapping field for the group
+
+To modify the Redis mapping field, select the pencil icon of the Redis Cloud group in the **Redis Cloud** application screen.
+
+{{<image filename="images/rc/saml/okta_saml_group_10.png" >}}
+
+You can modify the mapping field for the whole group on the edit screen that appears.
+
+{{<image filename="images/rc/saml/okta_saml_group_11.png" >}}
+
+### Edit the mapping field for a specific user
+
+To override the Redis mapping field at an individual user level, select the **People** menu, and then the pencil icon of the person whose field you want to modify.
+
+{{<image filename="images/rc/saml/okta_saml_group_15.png" >}}
+
+Set the user's **Assignment master** to **Administrator**, enabling the group's policy override. Select **Save**.
+
+{{<image filename="images/rc/saml/okta_saml_group_13.png" >}}
+
+The user's **Type** is set to `Individual`.
+
+{{<image filename="images/rc/saml/okta_saml_group_14.png" >}}
+
+On the screen that appears, select the pencil icon of the user to modify the Redis mapping field.
+
+{{<image filename="images/rc/saml/okta_saml_group_15.png" >}}
+
+Then, edit the user assignment.
+
+{{<image filename="images/rc/saml/okta_saml_group_16.png" >}}
+
+## Step 3: Configure SAML support in Redis Cloud
+
+Now that you have a test IdP server ready as well as your user group, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in Access Management
+
+To activate SAML, you must have a local user (or social sign-on user) with the **owner** role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Fill in the information you saved in step 6 in the **setup** form, including:
+
+    * **IdP Server URL**: Identity Provider Single Sign-On URL
+    * **Issuer**: Identity Provider Issuer
+    * **Assertion signing certificate**: X.509 Certificate
+
+    {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+1. Select **Enable** and wait a few seconds for the status to change. You are then able to download the service provider (SP) metadata. Save the file to your local hard disk.
+
+    {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+    * **EntityID**: The unique name of the service provider (SP)
+
+    {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+    * **Location**: The location of the assertion consumer service
+
+    {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+1. Return to Okta, select **Applications > Redis Cloud > General** and select **Edit**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_12.png" >}}
+
+1. Then, navigate to **Configure SAML** (step 2) and update the following information in **SAML Settings General**:
+
+   * **Single sign-on URL**: Use the information that you copied for **Location**.
+   * **Audience URI (SP Entity ID)**: Use the information that you copied for **EntityID**.
+   * **Default RelayState**: Only needed if you want to have an IdP initiated flow. Take the ID from the location URL in step 3 (the content after the last forward slash "/") and append to the url (for example, `https://cloud.redis.io/#/login/?idpId=YOUR_LOCATION_ID`).
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_13.png" >}}
+
+   Select **Next**, then select **Finish**.
+
+### Return to Redis Cloud console
+
+1. Return to Redis Cloud console and select **Activate**.
+
+    {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+    A popup appears, stating that to test the SAML connection, you need to log in with Okta credentials of the user defined in the Redis Cloud group. This user is part of the group to which you assigned the Redis Cloud application. Select **Continue** to go to the Okta login screen.
+
+1. The Okta login screen appears. Enter the credentials and select **Sign In**.
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_14.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}---
+Title: Microsoft Entra (formerly Azure Active Directory) SAML integration guide
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to set up Microsoft Entra as a SAML single sign on provider for your Redis Cloud account.
+linkTitle: Microsoft Entra integration
+weight: 10
+---
+
+This guide shows how to configure [Microsoft Entra](https://learn.microsoft.com/en-us/azure/active-directory/fundamentals/active-directory-architecture) (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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) 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:
+
+1. Sign in to your Microsoft Azure account.
+
+1. From the main menu, select **Microsoft Entra ID > Enterprise Applications**. Select **New application** to add a new application.
+
+    {{<image filename="images/rc/saml/ad_saml_1.png" >}}
+
+1. Select **Microsoft Entra SAML Toolkit** from the list of apps.
+
+    {{<image filename="images/rc/saml/ad_saml_2.png" >}}
+
+1. Name the application **Redis Cloud** and then select **Create**. 
+
+    {{<image filename="images/rc/saml/ad_saml_3.png" >}}
+
+1. Select **Properties** and upload the Redis logo. 
+
+    {{<image filename="images/rc/saml/ad_saml_17.png" >}}
+
+    Select **Save**.
+
+1. Once you've created the application, go to the **Application Overview** and select **Set up single sign on**.
+
+    {{<image filename="images/rc/saml/ad_saml_4.png" >}}
+
+1. Select **SAML** as the single sign-on method.
+
+    {{<image filename="images/rc/saml/ad_saml_5.png" >}}
+
+1. Go to **Step 1** in the configuration screen and select **Edit**.
+
+    Enter some mock data in the required fields.
+
+    {{<image filename="images/rc/saml/ad_saml_8.png" >}}
+
+    Select **Save** to save your changes.
+
+1. Go to **Step 3** in the configuration screen.
+
+   * Certificate (Base 64) is required to complete SAML configuration in the Redis Cloud console. Select **Download** to download it.
+
+     {{<image filename="images/rc/saml/ad_saml_7.png" >}}
+
+1. Go to **Step 4** in the configuration screen, and note down or copy the following information:
+
+   * **Login URL** is used as the "IdP server URL" in the SAML configuration in admin console.
+   * **Microsoft Entra Identifier** is used as the "Issuer (IdP Entity ID)" in the SAML configuration in admin console.
+  
+    {{<image filename="images/rc/saml/ad_saml_6.png" >}}
+
+## Step 2: Configure SAML support in Redis Cloud
+
+Now that you have your Entra IdP server ready, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in access management
+
+To activate SAML, you must have a local user (or social sign-on user) with the **owner** role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Fill in the information you saved previously in the **setup** form. This includes :
+
+   * **Issuer (IdP Entity ID)**: Microsoft Entra Identifier
+   * **IdP server URL**: Login URL
+   * **Assertion signing certificate**: Drag-and-drop the certificate file you downloaded to disk in the form text area
+
+     {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+   Once you click the **Enable** button, wait a few seconds for the status to change.
+
+1. You will then be able to **download** the service provider (SP) metadata. Save the file to your local hard disk.
+
+    {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+   * **EntityID**: The unique name of the service provider (SP)
+
+    {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+   * **Location**: The location of the assertion consumer service
+
+    {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+## Step 3: Finish SAML configuration in Microsoft Entra ID
+
+1. Go back to Microsoft Entra ID setup and **Edit** the Basic SAML Configuration in **Step 1**. 
+   
+   This is where you entered mock data. Let's now enter the correct data for this step.
+
+   {{< note >}}
+   For the `EntityID` and `Location` fields below you can directly upload the metadata file using the option at the top of the page. However, you will still need to manually    add the **Sign on URL**.
+   {{< /note >}}
+
+    * Paste `EntityID` information in the `Identifier (Entity ID)` field.
+  
+    * Paste `Location` link in `Reply URL (Assertion Consumer Service URL)` field.
+
+    * For the `Sign on URL` field, add URL `https://cloud.redis.io/#/login/?idpId=` where you need to add the ID from the Reply URL ID, for example,    `https://cloud.redis.io/#/login/?idpId=0oa5pwatz2JfpfCb91d7`.
+
+    Select **Save**.
+
+      {{<image filename="images/rc/saml/ad_saml_23.png" >}}
+
+1. Go to step 2, **Attributes & Claims** and select **Edit**.
+
+    {{<image filename="images/rc/saml/ad_saml_24.png" >}}
+
+1. Configure these attributes and claims:
+
+    * Modify Unique User Identifier (Name ID) to **user.mail**
+  
+    * Modify additional claims to match SAML assertion as follows:
+  
+        * **Email**: user.mail
+        * **FirstName**: user.givenname
+        * **LastName**: user.surname
+        * **redisAccountMapping**: "<sm_account_id>=owner"
+            * The `redisAccountMapping` contains Redis Cloud account IDs and user roles pairs. The key-value pair consists of the lowercase role name (owner, member, manager, billing_admin, or viewer) and your **Redis Cloud Account ID** found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}). 
+
+          {{<image filename="images/rc/saml/ad_saml_14.png" >}}
+        
+        {{<note>}}
+Make sure the **Namespace** field is empty when modifying these claims.
+
+{{<image filename="images/rc/saml/ad_saml_namespace_field.png" >}}
+        {{</note>}}
+
+1. To add a user to the application, select **User and Groups > Add user/group**.
+
+    {{<image filename="images/rc/saml/ad_saml_15.png" >}}
+
+1. Add the user and select **Assign**.
+
+    {{<image filename="images/rc/saml/ad_saml_16.png" >}}
+
+## Step 4: Return to Redis Cloud console
+
+1. Return to Redis Cloud console and select **Activate**.
+
+    {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+1. A popup appears, explaining that you must log in with the credentials of a Microsoft Entra user to test the SAML connection. Select **Continue** to go to the Microsoft login screen.
+
+1. The Microsoft login screen will appear. Enter the credentials and click **Sign In**.
+
+    {{<image filename="images/rc/saml/ad_saml_19.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}
+
+## Claim conditions and user groups
+
+If your users are going to be part of different Groups, you can create a Claim Condition for the `redisAccountMapping` attribute.
+
+{{<image filename="images/rc/saml/ad_saml_20.png" >}}
+
+## IdP initiated SSO
+
+If you correctly set the up the **Sign on URL**, the SAML application appears by default on the user's **My Apps** panel.
+
+{{<image filename="images/rc/saml/ad_saml_25.png" >}}
+
+While assigning the user to the app, a notification will appear:
+
+{{<image filename="images/rc/saml/ad_saml_26.png" >}}
+
+Therefore, if you sign into `https://myapplications.microsoft.com/`, the application will be available.
+
+If the app is not available, make sure that the App is registered. It should be done automatically.
+
+{{<image filename="images/rc/saml/ad_saml_27.png" >}}
+
+{{<image filename="images/rc/saml/ad_saml_28.png" >}}
+
+You can also access the app directly by using the **User access Url** from App Properties.
+---
+Title: AWS IAM Identity Center SAML integration guide
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to configure AWS IAM Identity Center
+  as a SAML single sign on provider for your Redis Cloud account.
+linkTitle: AWS IAM Identity Center integration
+weight: 10
+---
+
+This guide shows how to configure [AWS IAM Identity Center](https://aws.amazon.com/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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) you want to associate with your SAML setup.
+
+## Step 1: Setup your identity provider (IdP)
+
+### Create the AWS IAM Identity Center SAML application
+
+1. Sign in to your AWS account.
+
+1. From the main menu, search for **IAM Identity Center (successor to AWS Single Sign-On)**.
+
+    {{<image filename="images/rc/saml/aws_iam_identity_center_saml_1.png" >}}
+
+1. Once in IAM Identity Center, select **Applications**.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_2.png" >}}
+
+1. Next, select **Add application**.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_3.png" >}}
+
+1. In the next screen, select **Add custom SAML 2.0 application** then **Next**.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_4.png" >}}
+
+1. The **Configure Application** screen is where you initially get the information needed to configure SAML in Redis Cloud. To begin, change the **Display name** and **Description** to **Redis Cloud**.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_5.png" >}}
+
+1. Next, scroll to the **IAM Identity Center metadata** section. Here, you will find all of the information needed to configure SAML in Redis Cloud:
+
+* IAM Identity Center sign-in URL
+* IAM Identity Center SAML issuer URL
+* IAM Identity Center Certificate
+
+Note down or copy the URLs and select **Download** to download the certification information.
+
+{{< note >}}
+Both the IAM Identity Center sign-in URL and the IAM Identity Center SAML issuer URL are the same value. This is expected.
+{{< /note >}}
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_6.png" >}}
+
+
+## Step 2: Configure SAML support in Redis Cloud
+
+Now that you have your IAM Identity Center IdP server information, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in Access Management
+
+To activate SAML, you must have a local user (or social sign-on user) with the `owner` role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Add the information you saved previously in the **Configuration setup** screen. This includes:
+
+   * **Issuer (IdP Entity ID)**: IAM Identity Center SAML issuer URL.
+   * **IdP server URL**: IAM Identity Center sign-in URL.
+   * **Assertion signing certificate**: Drag and drop the certificate file you downloaded to disk in the form text area.
+
+     {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+   Select **Enable** and wait a few seconds for the status to change.
+
+1. Select **Download** to get the service provider (SP) metadata. Save the file to your local hard disk.
+
+   {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+   * **EntityID** - The unique name of the service provider (SP).
+
+     {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+   * **Location** : The location of the assertion consumer service.
+
+      {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+## Step 3: Finish SAML configuration in AWS IAM Identity Center's Redis Cloud Application
+
+1. Return to the **Configuration setup** screen in IAM identity Center. Scroll down to the bottom of the page and select **Upload application SAML metadata file**. Select **upload** and choose the file that you downloaded in the SAML configuration screen in Redis Cloud. 
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_10.png" >}}
+
+1. If you would like to also configure an IdP initiated workflow, fill in the **relay state** field in the **Application properties** section. Use this URL: `https://cloud.redis.io/#/login/?idpId=XXXXXX`. Take the ID from the location URL in step 3 (the content after the last forward slash "/") and append to the URL.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_11.png" >}}
+
+1. Select **Submit** to finish creating the application.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_12.png" >}}
+
+1. Configure the **Redis Cloud** application's attribute mappings. Select **Actions > Edit Attribute Mappings**. 
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_13.png" >}}   
+
+   In the next screen, add these attributes:
+
+   * **Subject**: `${user:email}`, `unspecified`
+   * **Email**: `${user:email}`, `unspecified`
+   * **FirstName**: `${user:givenName}`, `unspecified`
+   * **LastName**: `${user:familyName}`, `unspecified`
+   * **redisAccountMapping**: `XXXXXXX=owner`, `unspecified`
+
+The `redisAccountMapping` key-value pair consists of the lowercase role name (owner, member, manager, billing_admin, or viewer) and your Redis Cloud Account ID found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}).
+
+{{<image filename="images/rc/saml/aws_iam_identity_center_saml_14.png" >}}
+
+## Step 4: Ensure that the Cloud account user has an IAM Identity Center user account
+
+To complete SAML setup, ensure that the user who began SAML configuration in Redis Cloud console has a user defined in the AWS IAM identity center. This user account is required to complete the SAML setup.
+
+Also, make sure that the user has been assigned to the **Redis Cloud** Application.
+
+## Step 5: Activate SAML integration
+
+The final step in our SAML integration with AWS IAM identity Center is to activate the SAML integration. 
+
+1. In the Single Sign-On screen, select **Activate**.
+
+   {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+  A logout notification screen displays, letting you know that you will be redirected to your identity provider. Select **Continue** to go to the AWS IAM Identity Center's login screen.
+
+1. Enter your AWS IAM Identity Center credentials.
+
+   {{<image filename="images/rc/saml/aws_iam_identity_center_saml_18.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}---
+Title: Okta SAML integration guide (Org2Org)
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to set up Okta as a SAML single sign
+  on provider for your Redis Cloud account.
+linkTitle: Okta integration (Org2Org)
+weight: 10
+---
+
+This guide shows how to configure [Okta](https://help.okta.com/en-us/Content/Topics/Security/Identity_Providers.htm) 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]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-okta-generic" >}}) application template.
+
+To learn more about Redis Cloud support for SAML, see [SAML single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) 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. 
+
+1. Sign in to the Okta admin console.
+
+1. From the left menu, select **Applications**.
+
+1. Select **Browse App Catalog**.
+
+1. Locate and select **Okta Org2Org**.
+
+    {{<image filename="images/rc/saml/okta_saml_1.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Once you have found the application, click "Add".
+
+    {{<image filename="images/rc/saml/okta_saml_2.png" alt="Data transformaiton Pipeline" >}}
+
+1. Enter this field for the **Org2Org** application **General Settings** section and select **Next**:
+
+   * **Application label**: `Redis Cloud`
+
+    {{<image filename="images/rc/saml/okta_saml_3.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Enter the following fields in the **Sign-On Options > Attributes** section:
+
+    * **Name**: `redisAccountMapping`
+    * **Name Format**: `Basic`
+    * **Value**: `appuser.redisAccountMapping`
+
+    {{< warning >}}
+To ensure the role mapping will not take effect, don't skip entering `appuser.redisAccountMapping` in the **Value** field.
+    {{< /warning >}}
+
+    {{<image filename="images/rc/saml/okta_saml_4.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Next, select **View Setup Instructions**. A new browser window opens, providing the information needed to configure the IdP in Redis Cloud.
+
+    {{<image filename="images/rc/saml/okta_saml_5.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Scroll down to section 6 in the page, and note the following information:
+
+   * **IdP Issuer URI**
+   * **IdP Single Sign-On Url**
+   * **IdP Signature Certificate**: Click the link and download the certificate to your hard drive
+
+    {{<image filename="images/rc/saml/okta_saml_6.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+    Once you capture the information, close the window, return to the Okta admin console, and select **Done**.
+
+### Modify the application user profile
+
+1. In the left menu, select **Directory > Profile Editor**, then select **Redis Cloud User**.
+
+    {{<image filename="images/rc/saml/okta_saml_7_customer.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Select **Add Attribute** to add a custom attribute to the user profile and specify the Redis Cloud role.
+
+    {{<image filename="images/rc/saml/okta_saml_7_5_customer.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Add this information for the new custom attribute:
+
+   * **Data type**: `string array`
+   * **Display name**: `redisAccountMapping`
+   * **Variable nam**: `redisAccountMapping`
+   * **Description**: `redisAccountMapping`
+   * **Attribute required**: `Yes`
+   * **Group priority**: `Combine values across groups`
+
+    {{<image filename="images/rc/saml/okta_saml_app_int_11.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Once you add the attribute, it appears in the list of profile attributes.
+
+    {{<image filename="images/rc/saml/okta_saml_9.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Add a Redis Cloud icon to the application because it's easier for users to identify the application. Select the pencil icon on the application logo and upload a Redis image using these steps:
+
+    {{<image filename="images/rc/saml/okta_saml_10_customer.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+    {{<image filename="images/rc/saml/okta_saml_11_customer.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+## Step 2: Create a group and assign the application {#createtestuser}
+
+Now that our SAML IdP is configured, create an Okta group and assign the Redis Cloud application.
+
+### Create the group
+
+1. In the left menu, select **Directory > Groups**, then select **Add group**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_1.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Enter **Name** and **Description**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_2.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+    {{<image filename="images/rc/saml/okta_saml_group_3.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+### Assign users to the group
+
+1. Select the group, then select **Assign people**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_4.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. For each user you want to add to the group, highlight the user in the table and select **+**. You can also add all users by selecting **Add all**. After you add all the users to your group, select **Save**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_5.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+### Assign application to the group
+
+Now that your group is populated with its users, assign the SAML integration application to your group. 
+
+1. From the menu, select **Applications > Applications > Redis Cloud**. Then, select **Assign to groups**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_6.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. In the **Redis Cloud User Group**, select **Assign**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_7.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Now, define the Redis account mapping string default for this group and select **Save and go back**. The key-value pair consists of the lowercase role name (owner, member, manager, billing_admin, or viewer) and your **Redis Cloud Account ID** found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}). Select **"Done"**.
+
+    {{<image filename="images/rc/saml/okta_saml_group_8.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+    The mapping field is now defined as a default for each member of the group. 
+
+    {{<image filename="images/rc/saml/okta_saml_group_9.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+### Editing the mapping field for the group
+
+To modify the Redis mapping field, select the pencil icon of the Redis Cloud group in the "Redis Cloud" application screen.
+
+{{<image filename="images/rc/saml/okta_saml_group_10.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+You can modify the mapping field for the whole group on the edit screen that appears.
+
+{{<image filename="images/rc/saml/okta_saml_group_11.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+### Editing the mapping field for a specific user
+
+To override the Redis mapping field at an individual user level, select the **People** menu, then select the pencil icon of the person whos field you want to modify.
+
+{{<image filename="images/rc/saml/okta_saml_group_12.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+Set the user's **Assignment master** to `Administrator` to enable group policy overrides. Select **Save**.
+
+{{<image filename="images/rc/saml/okta_saml_group_13.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+The user's **Type** is set to `Individual`.
+
+{{<image filename="images/rc/saml/okta_saml_group_14.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+On the screen that appears, select the pencil icon of the user to modify the Redis mapping field.
+
+{{<image filename="images/rc/saml/okta_saml_group_15.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+{{<image filename="images/rc/saml/okta_saml_group_16.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+## Step 3: Configure SAML support in Redis Cloud
+
+Now that you have a test IdP server and your user group ready, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in access management
+
+To activate SAML, you must have a local user (or social sign-on user) with the **owner** role. If you have the correct permissions, the **Single Sign-On** tab is enabled.
+
+1. Add the information you saved previously in the **setup** form (step 1), including:
+
+   * **Issuer (IdP Entity ID)**: IdP Issuer URI
+   * **IdP server URL**: IdP Single Sign-On Url
+   * **Assertion signing certificate**: Drag and drop the file you downloaded to disk in the form text area.
+
+    {{<image filename="images/rc/saml/sm_saml_1.png" alt="Use the Okta admin console to locate the Org2Org application template." >}}
+
+1. Select **Enable** and wait a few seconds for the status to change. Then, download the service provider (SP) metadata. Save the file to your local hard disk.
+
+    {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+   * **EntityID**: Unique name of the service provider (SP)
+
+    {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+   * **Location**: Location of the assertion consumer service
+
+    {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+
+1. Return to Okta, select **Applications > Redis Cloud > General**, then select **Edit**.
+
+    {{<image filename="images/rc/saml/sm_saml_6.png" >}}
+
+1. Update this information in **Advanced Sign-on Settings**.
+
+   * **Hub ACS URL**: Use the information that you copied for **Location**.
+   * **Audience URI**: Use the information that you copied for **EntityID**.
+
+    {{<image filename="images/rc/saml/sm_saml_7.png" >}}
+
+
+Select **Save**.
+
+### IdP-initiated SSO
+
+To use IdP-initiated SSO with identity providers, set the RelayState parameter to URL `https://cloud.redis.io/#/login/?idpId=<ID>`.
+
+{{< note >}}
+Replace `<ID>` so it matches the AssertionConsumerService Location URL ID (the content after the last forward slash "/"). To learn more about configuring service provider applications, see your identity provider's documentation.
+{{< /note >}}
+
+### Return to Redis Cloud console
+
+1. Return to Redis Cloud console and select **Activate**.
+
+    {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+   A popup appears, explaining that, to test the SAML connection, you need to log in with Okta credentials of the user defined in the Redis Cloud group. This user is part of the group to which you assigned the Redis Cloud application. Select **Continue** to go to the Okta login screen.
+
+1. The Okta login screen appears. Enter the credentials and select **Sign In**.
+
+    {{<image filename="images/rc/saml/sm_saml_10.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}---
+Title: Google Workspace SAML integration guide
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This integration guide shows how to configure Google Workspace as a SAML
+  single sign on provider for your Redis Cloud account.
+linkTitle: Google workspace integration
+weight: 10
+---
+
+This guide shows how to configure [Google Workspace](https://workspace.google.com/) 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]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+Before completing this guide, you must [verify ownership of any domains]({{< relref "/operate/rc/security/access-control/saml-sso#verify-domain" >}}) you want to associate with your SAML setup.
+
+## Step 1: Set up your identity provider (IdP)
+
+### Create the Google Workspace SAML application
+
+1. Sign in to your [Google Workspace admin account](https://admin.google.com/).
+
+1. From the main menu, select **Apps** then **Web and mobile apps**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_0.png" >}}
+
+1. Once in Web and mobile apps, select **Add custom SAML app** from the dropdown list.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_1.png" >}}
+
+1. To begin, change the **App name** and **Description** to **Redis Cloud**. You can also choose an **App icon** for the application. We suggest you upload a Redis icon. Once complete, select **Continue**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_2.png" >}}
+
+1. In the next screen, you will find all of the information needed to configure SAML in Redis Cloud. Select the **copy** button for the following information sections:
+
+   * SSO URL
+   * Entity ID
+   * Certificate
+
+   {{<image filename="images/rc/saml/google_workspace_saml_3.png" >}}
+
+Once complete, select **Continue**.
+
+## Step 2: Configure SAML support in Redis Cloud
+
+Now that you have your Google Workspace IdP server information, configure support for SAML in Redis Cloud.
+
+### Sign in to Redis Cloud
+
+Sign in to your account on the [Redis Cloud console](https://cloud.redis.io/#/login).
+
+### Activate SAML in Access Management
+
+To activate SAML, you must have a local user (or social sign-on user) with the `owner` role. If you have the correct permissions, you will see the **Single Sign-On** tab.
+
+1. Add the information you saved previously in the **Google identity provider details** screen. This includes:
+
+    * **Issuer (IdP Entity ID)**: `Entity ID`.
+    * **IdP server URL**: `SSO URL`.
+    * **Assertion signing certificate**: `Certificate`.
+
+   {{<image filename="images/rc/saml/sm_saml_1.png" >}}
+
+   Select **Enable** and wait a few seconds for the status to change.
+
+1. Select **Download** to get the service provider (SP) metadata. Save the file to your local hard disk.
+
+   {{<image filename="images/rc/saml/sm_saml_3.png" >}}
+
+1. Open the file in any text editor. Save the following text from the metadata:
+
+    * **EntityID**: The unique name of the service provider (SP).
+
+      {{<image filename="images/rc/saml/sm_saml_4.png" >}}
+
+   * **Location**: The location of the assertion consumer service.
+
+  {{<image filename="images/rc/saml/sm_saml_5.png" >}}
+
+## Step 3: Add a custom attribute to Google Workspace's user profile
+
+1. From the main menu in Google Workspace, select **Directory** then **Users**, and from the **more options** dropdown select **Manage custom attributes**.
+   
+   {{<image filename="images/rc/saml/google_workspace_saml_7.png" >}}
+
+1. From the **Manage user attributes** screen, select **Add Custom Attribute**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_8.png" >}}
+
+1. Add the following information for the new custom attribute:
+
+   * **Category**: `Redis Cloud`
+   * **Name**: `redisAccountMapping`
+   * **Info type**: `Text`
+   * **Visibility**: `Visible to user and admin`
+   * **No. of values**: `Single`
+
+   {{<image filename="images/rc/saml/google_workspace_saml_9.png" >}}
+
+   Once complete, select **Add**. The summary page now displays the new **redisAccountMapping** custom field.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_10.png" >}}
+
+1. From the main menu in Google Workspace, select **Directory** then **Users**, then select the user you wish to configure. 
+
+   {{<image filename="images/rc/saml/google_workspace_saml_11.png" >}}
+
+1. Each user who needs to access Redis Cloud through SAML needs to define the **redisAccountMapping** attribute. The `redisAccountMapping` key-value pair consists of the lowercase role name (owner, member, manager, billing_admin, or viewer) and your Redis Cloud Account ID found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}).
+
+   {{<image filename="images/rc/saml/google_workspace_saml_12.png" >}}
+
+   Once complete, select **Save**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_13.png" >}}
+
+   Repeat this step for each user who needs to define the `redisAccountMapping` attribute.
+
+## Step 4: Finish SAML configuration in Google Workspace's Redis Cloud Application
+
+1. Return to the **Service provider details** screen in Google Workspace, and add the following information:
+
+   * **ACS URL**: The Location from the downloaded service provider (SP) metadata
+   * **Entity Id**: The EntityID from the downloaded service provider (SP) metadata
+
+   {{<image filename="images/rc/saml/google_workspace_saml_6.png" >}}
+
+   Leave the **Name ID** default information as it is. Once complete, select **Continue**.
+
+1. Configure the **Redis Cloud** application's attribute mappings. Select **Add Mapping**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_14.png" >}}
+
+   In the next screen, map these attributes:
+
+   * **Primary Email**: `Email`
+   * **First name**: `FirstName`
+   * **Last name**: `LastName`
+   * **redisAccountMapping**: `redisAccountMapping`
+
+   {{<image filename="images/rc/saml/google_workspace_saml_15.png" >}}
+
+   Once complete, select **Finish**.
+
+1. Next, we need to turn on the Redis Cloud service for all users, select **Web and mobile apps** -> **Redis Cloud** and then **service status**. Select **ON for everyone**. Once complete, select **Save**.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_16.png" >}}
+
+## Step 5: Activate SAML integration
+
+The final step in our SAML integration with AWS IAM identity Center is to activate the SAML integration.
+
+1. In the Single Sign-On screen, select **Activate**.
+
+   {{<image filename="images/rc/saml/sm_saml_8.png" >}}
+
+A logout notification screen displays, letting you know that you are redirected to Google's login screen.
+
+1. Select the Google account you wish to login with.
+
+   {{<image filename="images/rc/saml/google_workspace_saml_18.png" >}}
+
+If everything is configured correctly, you will see the the Redis Cloud console screen. Your local account is now considered a SAML account. 
+
+To log in to the Redis Cloud console from now on, click on **Sign in with SSO**.
+
+{{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}
+---
+Title: SAML single sign-on
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Redis Cloud supports both IdP-initiated and SP-initiated single sign-on
+  (SSO) with SAML (Security Assertion Markup Language). You can use any identity provider
+  to integrate with Redis Cloud as long as it supports the SAML protocol, or you can
+  refer to integration guides for a few specific providers.
+hideListLinks: true
+linkTitle: SAML SSO
+weight: 20
+---
+
+Redis Cloud supports both [IdP-initiated](#idp-initiated-sso) and [SP-initiated](#sp-initiated-sso) [single sign-on (SSO)](https://en.wikipedia.org/wiki/Single_sign-on) with [SAML (Security Assertion Markup Language)](https://en.wikipedia.org/wiki/Security_Assertion_Markup_Language).
+
+You cannot use [SCIM (System for Cross-domain Identity Management)](https://en.wikipedia.org/wiki/System_for_Cross-domain_Identity_Management) to provision Redis Cloud users. However, Redis Cloud supports just-in-time (JIT) user provisioning, which means Redis Cloud automatically creates a user account the first time a new user signs in with SAML SSO.
+
+## SAML SSO overview
+
+When SAML SSO is enabled, the [identity provider (IdP)](https://en.wikipedia.org/wiki/Identity_provider) admin handles SAML user management instead of the Redis Cloud account owner.
+
+You can use any identity provider to integrate with Redis Cloud as long as it supports the SAML protocol. You can also refer to these integration guides for several popular identity providers:
+
+  - [Auth0 SAML integration]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-auth0" >}})
+  - [AWS IAM Identity Center SAML integration]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-aws-identity-center" >}})
+  - [Azure Active Directory SAML integration]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-azure-ad" >}})
+  - [Google Workspace integration]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-google" >}})
+  - [Okta SAML integration (Generic)]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-okta-generic" >}})
+  - [Okta SAML integration (Org2Org)]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-okta-org2org" >}})
+  - [PingIdentity SAML integration]({{< relref "/operate/rc/security/access-control/saml-sso/saml-integration-ping-identity" >}})
+
+After you activate SAML SSO for a Redis Cloud account, all existing local users for the account, except for the user that set up SAML SSO, are converted to SAML users and are required to use SAML SSO to sign in. Before they can sign in to Redis Cloud, the identity provider admin needs to set up these users on the IdP side and configure the `redisAccountMapping` attribute to map them to the appropriate Redis Cloud accounts and [roles]({{< relref "/operate/rc/security/access-control/access-management#team-management-roles" >}}).
+
+### IdP-initiated SSO
+
+With IdP-initiated single sign-on, you can select the Redis Cloud application after you sign in to your [identity provider (IdP)](https://en.wikipedia.org/wiki/Identity_provider). This redirects you to the [Redis Cloud console](https://cloud.redis.io/#/login) and signs you in to your SAML user account.
+
+### SP-initiated SSO
+
+You can also initiate single sign-on from the [Redis Cloud console](https://cloud.redis.io/#/login). This process is known as [service provider (SP)](https://en.wikipedia.org/wiki/Service_provider)-initiated single sign-on.
+
+1. From the Redis Cloud console's [sign-in screen](https://cloud.redis.io/#/login), select **SSO**.
+
+    {{<image filename="images/rc/button-sign-in-sso.png" width="50px" alt="Sign in with SSO button">}}
+
+1. Enter the email address associated with your SAML user account.
+
+1. Select the **Login** button.
+
+    - If you already have an active SSO session with your identity provider, this signs you in to your SAML user account.
+
+    - Otherwise, the SSO flow redirects you to your identity provider's sign in screen. Enter your IdP user credentials to sign in. This redirects you back to the Redis Cloud console and automatically signs in to your SAML user account.
+
+### Multi-factor authentication
+
+The account owner remains a local user and should set up [multi-factor authentication (MFA)]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}}) to help secure their account. After SAML activation, the account owner can set up additional local bypass users with MFA enabled.
+
+If MFA enforcement is enabled, note that Redis Cloud does not enforce MFA for SAML users since the identity provider handles MFA management and enforcement.
+
+## Set up SAML SSO
+
+To set up SAML single sign-on for a Redis Cloud account:
+
+1. [Verify domain ownership in Redis Cloud](#verify-domain).
+
+1. [Set up a SAML app](#set-up-app) to integrate Redis Cloud with your identity provider.
+
+1. [Configure SAML identity provider in Redis Cloud](#configure-idp).
+
+1. [Download service provider metadata](#download-sp) and upload it to your identity provider.
+
+1. [Activate SAML SSO](#activate-saml-sso).
+
+### Verify domain ownership in Redis Cloud {#verify-domain}
+
+Before you set up SAML SSO in Redis Cloud, you must verify that you own the domain(s) associated with your SAML setup.
+
+1. Sign in to [Redis Cloud](https://cloud.redis.io/#/login) with the email address associated with the SAML user you set up with your identity provider.
+
+1. Select **Access Management** from the [Redis Cloud console](https://cloud.redis.io) menu.
+
+1. Select **Single Sign-On**.
+
+1. Select the **Setup SAML SSO** button:
+
+    {{<image filename="images/rc/button-access-management-sso-setup.png" width="120px" alt="Setup SSO button">}}
+
+1. From the **SAML** screen of the [Redis Cloud console](https://cloud.redis.io), you must verify you own the domains associated with your SAML configuration. Select **Add domain** to open the **Manage domain bindings** panel.
+
+    {{<image filename="images/rc/saml-button-add-domain.png" width="120px" alt="Add domain button">}}
+
+    {{<image filename="images/rc/saml-manage-domain-bindings.png" width="80%" alt="The Manage domain bindings panel">}}
+
+1. Select **Copy** to copy the provided TXT DNS record. For each domain you want to associate with your SAML setup, add the copied TXT record to its DNS records. 
+
+1. Select **Add domain** to add a domain. 
+
+    {{<image filename="images/rc/saml-button-add-domain.png" width="120px" alt="Add domain button">}}
+
+1. Enter the domain name and select {{<image filename="images/rc/saml-button-confirm.png#no-click" width="20px" alt="Confirm domain" class="inline">}} to save it, or select {{<image filename="images/rc/saml-button-cancel.png#no-click" width="20px" alt="Cancel" class="inline">}} to cancel.
+
+    {{<image filename="images/rc/saml-enter-domain.png" width="80%" alt="Enter domain name in the Domain field.">}}
+
+1. After you save the domain name, its status is **Pending**. Select **Verify** to verify it. 
+
+    {{<image filename="images/rc/saml-domain-pending.png" width="80%" alt="The Manage domain bindings panel, with a pending domain">}}
+
+    We'll check the domain's DNS records for the provided TXT record. If the TXT record does not exist or we can't resolve your domain, we won't be able to verify the domain and users with that domain won't be able to sign in using SAML SSO. 
+    
+    Select {{<image filename="images/rc/icon-delete-teal.png#no-click" width="25px" alt="delete domain" class="inline">}} to delete a domain if it was added by mistake.
+
+    If we find the TXT record, the domain's status will change to **Verified**.
+
+    You can select **Add domain** to add another domain.
+
+1. Select **Close** to close the domain binding panel.
+
+    {{<image filename="images/rc/saml-button-close.png" width="100px" alt="Close button">}}
+
+After you verify at least one domain, you can select **Manage domains** to open the **Manage domain bindings** panel again and add or verify more domains.
+
+### Set up SAML app {#set-up-app}
+
+Set up a SAML app to integrate Redis Cloud with your identity provider:
+
+1. Sign in to your identity provider's admin console.
+
+1. Create or add a SAML integration app for the service provider Redis Cloud.
+
+1. Set up your SAML service provider app so the SAML assertion contains the following attributes:
+
+    | Attribute&nbsp;name<br />(case-sensitive) | Description |
+    |-------------------------------------------|-------------|
+    | FirstName | User's first name |
+    | LastName | User's last name |
+    | Email | User's email address (used as the username in the Redis Cloud console) |
+    | redisAccountMapping | Key-value pair of a lowercase [role name]({{< relref "/operate/rc/security/access-control/access-management#team-management-roles" >}}) (owner, member, manager, billing_admin, or viewer) and the user's Redis Cloud **Account number** found in the [account settings]({{< relref "/operate/rc/accounts/account-settings" >}}) |
+
+    For `redisAccountMapping`, you can add the same user to multiple SAML-enabled accounts using one of these options:
+
+    - A single string that contains a comma-separated list of account/role pairs
+
+        ```xml
+        <saml2:Attribute Name="redisAccountMapping" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
+            <saml2:AttributeValue xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+                12345=owner,54321=manager
+            </saml2:AttributeValue>
+        </saml2:Attribute>
+        ```
+
+    - Multiple strings, where each represents a single account/role pair
+
+        ```xml
+        <saml2:Attribute Name="redisAccountMapping" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified">
+            <saml2:AttributeValue xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+                12345=owner
+            </saml2:AttributeValue>
+            <saml2:AttributeValue xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+                54321=manager
+            </saml2:AttributeValue>
+        </saml2:Attribute>
+        ```
+
+    {{<note>}}
+To confirm the identity provider's SAML assertions contain the required attributes, you can use a SAML-tracer web developer tool to inspect them.
+    {{</note>}}
+
+1. Set up any additional configuration required by your identity provider to ensure you can configure the `redisAccountMapping` attribute for SAML users.
+
+    If your identity provider lets you configure custom attributes with workflows or group rules, you can set up automation to configure the `redisAccountMapping` field automatically instead of manually.
+
+### Configure SAML in Redis Cloud {#configure-idp}
+
+After you set up the SAML integration app and create a SAML user in your identity provider, you need to configure your Redis Cloud account to set up SAML SSO.
+
+1. Sign in to [Redis Cloud](https://cloud.redis.io/#/login) with the email address associated with the SAML user you set up with your identity provider.
+
+1. Select **Access Management** from the [Redis Cloud console](https://cloud.redis.io) menu.
+
+1. Select **Single Sign-On**.
+
+1. [Verify at least one domain](#verify-domain) if you haven't.
+
+1. Configure the **Identity Provider metadata** settings. 
+
+    {{<image filename="images/rc/access-management-saml-config.png"  alt="SAML Single Sign-On configuration screen.">}}
+
+    To do so, you need the following metadata values from your identity provider:
+
+    | Setting | Description |
+    |---------|-------------|
+    | **Issuer (IdP entity ID)** | The unique entity ID for the identity provider |
+    | **IdP server URL** | The identity provider's HTTPS URL for SAML SSO |
+    | **Single logout URL** | The URL used to sign out of the identity provider and connected apps (optional) |
+    | **Assertion signing certificate** | Public SHA-256 certificate used to validate SAML assertions from the identity provider |
+
+    To find these metadata values, see your identity provider's documentation.
+
+1. Select **Enable**.
+
+    {{<image filename="images/rc/saml-enable-button.png" width="100px" alt="Enable button">}}
+
+1. From the **SAML activation** dialog box, select **Continue**.
+
+### Download service provider metadata {#download-sp}
+
+Next, you need to download the service provider metadata for Redis Cloud and use it to finish configuring the SAML integration app for your identity provider:
+
+1. Select the **Download** button to download the service provider [metadata](https://docs.oasis-open.org/security/saml/v2.0/saml-metadata-2.0-os.pdf) in XML format.
+
+1. Sign in to your identity provider's admin console.
+
+1. Configure the Redis Cloud service provider app with the downloaded XML.
+
+    - Some identity providers let you upload the XML file directly. 
+    
+    - Others require you to manually configure the service provider app with specific metadata fields, such as:
+    
+        | XML attribute | Value | Description |
+        |---------------|-------|-------------|
+        | EntityDescriptor's **entityID** | https://<nobr>auth.redis.com</nobr>/saml2/<nobr>service-provider</nobr>/\<ID\> | Unique URL that identifies the Redis Cloud service provider |
+        | AssertionConsumerService's **Location** | <nobr> https://<nobr>auth.redis.com</nobr>/sso/saml2/\<ID\> | The service provider endpoint where the identity provider sends a SAML assertion that authenticates a user  |
+
+    - To use [IdP-initiated SSO](#idp-initiated-sso) with certain identity providers, you also need to set the RelayState parameter to the following URL:
+    
+        ```sh
+        https://cloud.redis.io/#/login/?idpId=<ID>
+        ```
+
+       > Replace `<ID>` so it matches the `AssertionConsumerService Location` URL's ID.
+        
+    To learn more about how to configure service provider apps, see your identity provider's documentation.
+
+### Activate SAML SSO {#activate-saml-sso}
+
+After you finish the required SAML SSO configuration between your identity provider and Redis Cloud account, you can test and activate SAML SSO.
+
+All users associated with the account, excluding the local user you used to set up SAML SSO, are converted to SAML users on successful activation. They can no longer sign in with their previous sign-in method and must use SAML SSO instead. However, you can add local bypass users after SAML SSO activation to allow access to the account in case of identity provider downtime or other issues with SAML SSO.
+
+To activate SAML SSO:
+
+1. Sign out of any active SSO sessions with your identity provider.
+
+1. For **Activate SAML integration**, select the **Activate** button.
+
+1. From the **Logout notification** dialog, select **Continue**. This redirects you to your configured identity provider's sign-in screen.
+
+1. Sign in with your identity provider.
+
+1. When redirected to the Redis Cloud sign-in screen, you can either:
+
+    - Sign in with your local credentials as usual.
+
+    - Select **SSO** and enter the email address associated with the SAML user configured in your identity provider. Your user converts to a SAML user in Redis Cloud. Don't use this method if you want your user account to remain a local bypass user.
+
+    {{<note>}}
+If you see a **SAML activation failed** notification when redirected to the Redis Cloud sign-in screen, sign in with your local user credentials and review the SAML configuration for issues.
+    {{</note>}}
+
+After you activate SAML SSO, [add a few local bypass users]({{< relref "/operate/rc/security/access-control/access-management#manage-team-access" >}}) from the **Team** tab. Local bypass users should [set up MFA]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}}) for additional security.
+
+## Update configuration {#update-config}
+
+If you change certain metadata or configuration settings after you set up SAML SSO, such as the assertion signing certificate, remember to do the following:
+
+1. [Update the SAML SSO configuration](#configure-idp) with the new values.
+
+1. [Download the updated service provider metadata](#download-sp) and use it to update the Redis Cloud service provider app.
+
+## Link other accounts
+
+After you set up SAML SSO for one account, you can link other accounts you own to the existing SAML configuration. This lets you use the same SAML configuration for SSO across multiple accounts.
+
+To link other accounts to an existing SAML SSO configuration:
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io/) with the account that has an existing SAML configuration.
+
+1. Go to **Access Management > Single Sign-On**. 
+
+1. Select **Get token**.
+
+    {{<image filename="images/rc/saml/popup-saml-get-token.png" alt="Get Token popup">}}
+
+    Select **Copy** to copy the linking token.
+
+1. Sign in to the account that you want to link to the SAML configuration. Go to **Access Management > Single Sign-On** and then enter the copied token into the **Join an existing SAML configuration** text box. Select the arrow to confirm.
+
+    After you do this, the owner of the original account will receive a request to link the new account to the SAML configuration.
+
+1. Sign in with the original account and select **Access Management > Single Sign-On**. You should see the new account in the **Unlinked accounts** list.
+
+    {{<note>}}
+To see and interact with the Redis Cloud account in the **Unlinked accounts** list, you must be an owner of the account. If you are not an owner, the account will not be displayed in the section.
+    {{</note>}}
+
+1. Select **Link account**.
+
+    {{<image filename="images/rc/saml/button-saml-link-account.png" alt="The Link Account button" width=150px >}}
+
+1. In the **Convert existing users** dialog, select **Confirm conversion** to finish linking the accounts.
+
+## Deactivate SAML SSO
+
+Before you can deactivate SAML SSO for an account, you must sign in to the account as a local (non-SAML) user with the owner role assigned.
+
+Deactivating SAML SSO for an account also removes any existing SAML-type users associated with the account.
+
+To deactivate SAML SSO for a specific account:
+
+1. In the [Redis Cloud console](https://cloud.redis.io), select your name to display your available accounts.
+
+1. If the relevant account is not already selected, select it from the **Switch account** list.
+
+1. Go to **Access Management > Single Sign-On**.
+
+1. Select **Deactivate SAML**. This only deactivates SAML SSO for the current account. Other linked accounts continue to use this SAML SSO configuration.
+
+1. Select **Deactivate** to confirm deactivation.
+
+## Deprovision SAML users
+
+When a user is removed from your identity provider, their access to Redis Cloud should also be removed.  
+
+When you have revoked a user’s access to Redis Cloud, they cannot access the Redis Cloud console, but their API keys remain active. You can [delete an API key]({{< relref "/operate/rc/api/get-started/manage-api-keys#delete-a-user-key" >}}) to remove access.
+
+To deprovision SAML users upon deletion, the identity provider admin can set up a webhook to automatically make the appropriate Cloud API requests. For more information about managing users with API requests, see [Users]({{< relref "/operate/rc/api/api-reference#tag/Users" >}}) in the Redis Cloud API documentation.
+---
+LinkTitle: Access control
+Title: Access control
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Control who can access the Redis Cloud console and databases.
+hideListLinks: false
+toc: 'true'
+weight: 5
+---
+
+Redis Cloud offers you a few different ways to control who can access and make changes to your databases.
+
+
+
+---
+Title: Configure CIDR allow list
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: The CIDR allow list permits traffic between a range of IP addresses and
+  the Redis Cloud VPC.
+linkTitle: CIDR allow list
+weight: 30
+---
+
+The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) [allow list](https://en.wikipedia.org/wiki/Whitelist) lets you restrict traffic to your Redis Cloud database. When you configure an allow list, only the [IP addresses](https://en.wikipedia.org/wiki/IP_address) 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.
+{{< /note >}}
+
+## Define CIDR allow list
+
+To define the CIDR allow list for a database:
+
+1. Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your database from the list.
+
+1. From the database's **Configuration** screen, select the **Edit database** button.
+
+1. In the **Security** section, turn on the **CIDR allow list** toggle.
+
+1. Enter the first IP address (in CIDR format) you want to allow in the text box and then select the check mark to add it to the allow list:
+
+    {{<image filename="images/rc/database-details-configuration-tab-security-cidr-allowlist-add-first-ip.png" width="80%" alt="Add the first IP address to the CIDR allow list." >}}
+   
+1. To allow additional IP addresses:
+
+    1. Select **Add CIDR**.
+
+    1. Enter the new IP address in the text box and then select check to add it to the allow list.
+
+        {{<image filename="images/rc/database-details-configuration-tab-security-cidr-allowlist-add-more-ips.png" width="80%" alt="Add a new IP address to the CIDR allow list." >}}
+
+1. Select **Save database** to apply your changes.
+
+{{< note >}}
+The database CIDR allow list applies to both the public endpoint and the private endpoint. If you use connectivity options such as [VPC Peering]({{< relref "/operate/rc/security/vpc-peering" >}}) and [Transit Gateway]({{< relref "/operate/rc/security/aws-transit-gateway" >}}) to connect to your database via the private endpoint, you must also add those IPs to your database's CIDR allow list.
+{{< /note >}}
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Security
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+weight: 51
+---
+
+Redis Cloud provides a number of ways to secure subscriptions and databases.
+
+As a Redis Cloud user, consider these security domains:
+
+- The [Redis Cloud console](#admin-console-security)
+- [Your databases]({{< relref "/operate/rc/security/database-security/" >}})
+- The [Redis Cloud API]({{< relref "/operate/rc/api/get-started/enable-the-api" >}})
+
+First, you might want to review our [shared responsibility model]({{< relref "/operate/rc/security/shared-responsibility-model" >}}) for security.
+
+## Redis Cloud console security {#admin-console-security}
+
+The Redis Cloud console is the web application you use to manage your Redis Cloud deployments. 
+
+Secure access to the Redis Cloud console by:
+
+- Assigning appropriate roles to [team members with access]({{< relref "/operate/rc/security/access-control/access-management#team-management-roles" >}}).
+
+- Enabling [multi-factor authentication]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}}).
+
+- Enabling [SAML SSO]({{< relref "/operate/rc/security/access-control/saml-sso" >}}).
+
+{{< note >}}
+A user session on Redis Cloud expires after 30 minutes. You'll be signed out of Redis Cloud after 30 minutes of inactivity.
+{{< /note >}}
+
+## Database security
+
+You have several options when it comes to securing your Redis Cloud databases. For more information, see [Cloud database security]({{< relref "/operate/rc/security/database-security/" >}}). Options include:
+
+- [Encryption at rest]({{< relref "/operate/rc/security/encryption-at-rest" >}})
+- [Role-based access control]({{< relref "/operate/rc/security/access-control/data-access-control/role-based-access-control" >}})
+- [TLS]({{< relref "/operate/rc/security/database-security/tls-ssl" >}})
+- [Network security]({{< relref "/operate/rc/security/database-security/network-security" >}}) using
+[VPC peering]({{< relref "/operate/rc/security/vpc-peering" >}}) and [CIDR whitelist]({{< relref "/operate/rc/security/cidr-whitelist" >}})
+
+## API security
+
+The Redis Cloud API allows you to programmatically administer your subscriptions and database deployments. This API is disabled by default. When you [enable the API]({{< relref "/operate/rc/api/get-started/enable-the-api" >}}), you can then [manage the API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}}) for all owners of your Redis Cloud account. For an overview of the security features of the API, see the [API authentication documentation]({{< relref "/operate/rc/api/get-started/" >}}).
+
+## Continue learning with Redis University
+
+{{< university-links >}}---
+Title: Connect to Amazon Web Services Transit Gateway
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linkTitle: Transit Gateway
+weight: 80
+---
+
+[Amazon Web Services (AWS) Transit Gateway](https://docs.aws.amazon.com/vpc/latest/tgw/how-transit-gateways-work.html) acts as a Regional virtual router for traffic flowing between your virtual private cloud(s) (VPCs) and on-premises networks. You can attach different resources to your Transit Gateway which include:
+
+- One or more VPCs
+- One or more virtual private network (VPN) connections
+- One or more AWS Direct Connect gateways
+- One or more Transit Gateway Connect attachments
+- One or more transit gateway peering connections
+
+You can connect your Redis Cloud Pro subscription to a Transit Gateway which is attached to the VPC of your application. This lets your application connect securely to your Redis Cloud database while optimizing performance.
+
+{{< note >}}
+Transit Gateway is available only with Redis Cloud Pro.  It is not supported for Redis Cloud Essentials.
+{{< /note >}}
+
+## Considerations
+
+You can use Transit Gateway as an alternative to [VPC peering]({{< relref "/operate/rc/security/vpc-peering" >}}), or you can enable both for your subscription.
+
+Compared to VPC peering, Transit Gateway:
+
+- Supports complex network topologies, such as multiple VPCs or site-to-site VPNs.
+
+- Uses security groups and network ACLs to control traffic between VPCs.
+
+- Has a higher network latency and cost than VPC peering due to Transit Gateway infrastructure costs.
+
+Consider using VPC peering and Transit Gateway in parallel for the following situations:
+
+- When migrating from one connectivity solution to the other.
+
+- If different applications need to connect to the same database but have different latency or security requirements.
+
+## Prerequisites
+
+Before you can set up Transit Gateway, you need to:
+
+1. [Create a database with Redis Cloud Pro]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) from the [Redis Cloud console](https://cloud.redis.io/#/).
+
+1. [Create a transit gateway](https://docs.aws.amazon.com/vpc/latest/tgw/create-tgw.html) from the [AWS VPC console](https://console.aws.amazon.com/vpc/) in the same region as your database.
+
+{{< note >}}
+If you use Redis Cloud Bring your own Cloud, you will need to set its IAM Instance Policy to include Transit Gateway. See [Create IAM resources using the AWS console]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources/aws-console.md" >}}) for more information.
+{{< /note >}}
+
+## AWS Transit Gateway
+
+To set up Transit Gateway:
+
+1. [Associate your resource share with the Redis AWS account](#associate-resource-share).
+
+1. [Accept the resource share and create an attachment](#accept-resource-share).
+
+1. [Add consumer CIDRs](#add-consumer-cidrs) to the attachment.
+
+1. [Update AWS route tables](#update-route-tables) with the Redis Cloud producer CIDRs.
+
+### Associate resource share with Redis Cloud {#associate-resource-share}
+
+In this step, you will associate your resource share with your subscription's AWS account. You can do this either in the [AWS console](#aws-console) or with the [AWS CLI](#aws-cli).
+
+#### AWS Console
+
+To use the AWS console to set up the resource share:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select the **Subscriptions** menu and then select your subscription from the list.
+
+1. Select **Connectivity > Transit Gateway** to view the transit gateway settings.
+
+1. In the **Share Transit Gateway** section, select **Copy** under **AWS console** to copy the Redis AWS Account number.
+
+    {{<image filename="images/rc/tgw-share-transit-gateway.png" width="80%" alt="The Share Transit Gateway section." >}}
+
+1. If you don't have a resource share for your transit gateway, follow the guide to [create a resource share](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-create.html) in the [AWS resource access manager](https://console.aws.amazon.com/ram/home). If you do, follow the guide to [update](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing-update.html) the resource share to include the provided AWS account as an Allowed Principal.
+
+    During the **Grant access to principals** step, select **AWS Account** in the **Select principal type** field. Enter the copied AWS account number in the **Enter an AWS Account ID** field. 
+
+    {{<image filename="images/rc/aws-tgw-add-principal.png" width="80%" alt="The AWS Add principal field." >}}
+
+    After the principal is added, it may take some time before it is associated. You can see the status of the principals under **Shared Principals** in the resource share page.
+
+#### AWS CLI
+
+To use the AWS CLI to set up the resource share:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select the **Subscriptions** menu and then select your subscription from the list.
+
+1. Select **Connectivity > Transit Gateway** to view the transit gateway settings.
+
+1. In the **Share Transit Gateway** section, select **Copy** under **AWS CLI Command** to copy the Redis AWS Account number.
+
+    {{<image filename="images/rc/tgw-share-transit-gateway.png" width="80%" alt="The Share Transit Gateway section." >}}
+
+1. Enter the copied CLI command into a terminal shell. Replace `<TGW ARN>` with the Amazon resource name of your transit gateway.
+
+### Accept resource share and create attachment {#accept-resource-share}
+
+After you've associated the Redis AWS account with your resource share, you must accept the resource share in the Redis Cloud console.
+
+1. In your Redis Cloud subscription's Transit Gateway settings, you should now see that a **Resource Share** is available. Select **Resource Shares** to view the resource share you initiated.
+
+    {{<image filename="images/rc/tgw-resource-shares-button.png" width="250px" alt="The Share Transit Gateway section." >}}
+
+1. Select **Accept** to associate the **Resource Share** with your Redis Cloud console account.
+
+    {{<image filename="images/rc/tgw-accept-resource-shares.png" width="80%" alt="The Accept resource shares section." >}}
+
+1. Select **Close** to close the **Accept resource shares** section.
+
+1. You will now see your transit gateway in the **Transit Gateways** section. After the **TGW status** is **Available**, select **Create Attachment** under **Attachment status**. 
+
+    {{<image filename="images/rc/tgw-create-attachment-button.png" width="250px" alt="The Create attachment button." >}}
+
+    This will request a peering attachment representing Redis's AWS account to the Transit Gateway. 
+
+1. If your transit gateway does not automatically accept peering attachment requests, the attachment will be in **Pending acceptance** status. Follow the guide to [Accept a peering attachment request](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html#tgw-peering-accept-reject) from the [AWS VPC console](https://console.aws.amazon.com/vpc/). 
+
+### Add consumer CIDRs 
+
+1. In your Redis Cloud subscription's Transit Gateway settings, in the **Transit Gateways** section, select **Add CIDRs** under **Consumer CIDRs**.
+
+    {{<image filename="images/rc/tgw-add-cidrs-button.png" width="150px" alt="The Add CIDRs button." >}}
+
+1. Enter the IPv4 CIDR of the VPC you want to connect to that is also connected to your transit gateway. To find this, go to the [AWS VPC console](https://console.aws.amazon.com/vpc/) and select **Your VPCs**.
+
+    Select **Add** to add another CIDR if needed.
+
+    {{<image filename="images/rc/tgw-add-additional-cidrs-button.png" width="100px" alt="The Add button for adding additional CIDRs." >}}
+
+    Select **Save** to save your changes.
+
+### Update AWS route tables {#update-route-tables}
+
+To finish Transit gateway setup, [update your route tables for the peering connection](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-routing.html) with the following details:
+
+1. In the **Destination** field, enter the producer deployment CIDRs. 
+
+    You can find the producer deployment CIDRs on the Redis Cloud console in the Transit Gateway settings by selecting **More actions > View Attachment** in the **Transit Gateway** section.
+
+    {{<image filename="images/rc/tgw-attachment-more-actions-menu.png" width="300px" alt="The More actions menu." >}}
+
+    {{<image filename="images/rc/tgw-producer-cidr-copy.png" width="100%" alt="The Producer deployment CIDRs in the Attachment settings. " >}}
+
+1. In the **Target** field, select **Transit Gateway** and select the relevant **Transit gateway ID**.
+
+After Transit gateway is established, we recommend switching your application connection string to the private endpoint.
+
+{{< note >}}
+If you've enabled the database's [CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist" >}}), you must also [add the Transit Gateway's IP address to the CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist#define-cidr-allow-list" >}}) to connect to the database via the private endpoint.
+{{< /note >}}
+
+## Continue learning with Redis University
+
+{{< university-links >}}
+---
+Title: Develop highly available and resilient apps with Redis Cloud 
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Set up your Redis Cloud databases to enable stable and highly available apps.
+hideListLinks: true
+linkTitle: Develop highly available apps
+weight: 85
+---
+
+You can set up your Redis Cloud databases and Redis Client libraries to ensure your app re-connects to your database after unexpected failover events or network outages and minimize data losses. 
+
+## Set up databases
+
+These settings can be turned on when you create or edit your database. 
+
+### Enable data persistence
+
+Enabling [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) allows Redis to save your data to a durable storage medium, such as a disk, to ensure data availability in case of memory loss or system failure.
+
+Redis Cloud supports the following data persistence options:
+
+- An **Append-Only File** maintains a record of write operations. This lets you restore data by using the record to reconstruct the database up to the point of failure. The Append-only file updates on every write or every second.
+
+- A **Snapshot** is a copy of the in-memory database, taken at periodic intervals (one, six, or twelve hours). You can restore data to the snapshot's point in time. 
+
+Append-only files provide greater protection than snapshots at the cost of resources and recovery time. 
+Although snapshot recovery is faster, the risk of data loss is higher, depending on the time between failure and the most recent snapshot.
+
+If you do not enable data persistence, your data may be lost if the database goes down. It is best practice to  enable data persistence for all production databases. You can turn on data persistence when you create or edit your database. 
+
+### Enable replication
+
+[Database replication]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) allows for automatic failover and greater fault tolerance. Replication can prevent data loss in the event of a hardware or zone failure. 
+
+Redis Cloud supports these replication settings:
+
+- **No replication**: You will have a single copy of your database in one zone. If anything happens to your database, your app will not be able to connect to it. 
+- **Single-Zone**: Your database will have a primary dataset and a replica dataset located in the same cloud zone. If anything happens to the primary database, the replica takes over and becomes the new primary. Your app will connect to the new primary database automatically with the same endpoint.
+- **Multi-Zone** _(or Multi-AZ)_: The primary and its replicas are stored in different availability zones. This means that your app will connect to the new primary database zone automatically if an entire availability zone becomes unavailable.
+
+You can enable replication when you create your database. You can switch between no replication and single-zone replication after your create your database. However, you can't switch from no replication or single-zone replication to multi-zone replication.
+
+It is best practice to enable replication for any databases that need to be highly available.
+
+### Set manual maintenance windows
+
+Redis maintains your Redis Cloud subscriptions and databases as needed to ensure your databases are running the most stable and up-to-date version of Redis. By default, Redis will perform [maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) automatically while limiting service disruption as much as possible.
+
+For stable apps, you may want to control when Redis can perform maintenance on your databases. For Redis Cloud Pro subscriptions, you can [set manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}) to ensure non-urgent maintenance will occur at set times. Configuring or altering the maintenance window will not have any impact on your subscription or databases.
+
+A Redis Cloud Essentials database has a set maintenance window based on the region where it is located. See [Essentials maintenance]({{< relref "/operate/rc/subscriptions/maintenance#redis-cloud-essentials" >}}) for more information.
+
+## Set up Redis clients
+
+When you're developing your apps, it is best to use specific Redis Client features to connect to Redis Cloud if they are available for your preferred client.
+
+See [Clients]({{< relref "/develop/clients" >}}) to learn how to connect with the official Redis clients.
+
+### Re-attempt connections
+
+Some clients allow you to re-try connecting to your database if the connection fails. For these clients, we recommend that you implement connection re-attempts to ensure high availability and connection stability. 
+
+View your [client's docs]({{< relref "/develop/clients" >}}) to learn more.
+
+### Refresh DNS
+
+Your application may disconnect from your database either during planned maintenance or for other, unplanned reasons. Most Redis clients are set to refresh their DNS address when they reconnect to the database, and you will not be required to perform any further action. If you encounter connectivity problems for more than a minute during maintenance then you should refresh your DNS entries. 
+
+Depending on the client, you may be recommended to turn off the DNS cache entirely. Refer to your [client's docs]({{< relref "/develop/clients" >}}) to learn more.
+
+### Use the WAIT and WAITAOF commands
+
+The [WAIT]({{< relref "/commands/wait" >}}) and [WAITAOF]({{< relref "/commands/waitaof" >}}) commands block the current client until all previous write commands are persisted between replicas. With these commands, your application guarantees that acknowledged writes are recorded between replicas. 
+
+For more info, see [Use the WAIT command for strong consistency]({{< relref "/operate/rs/clusters/optimize/wait" >}}).
+
+## More info
+
+- [Redis Clients]({{< relref "/develop/clients" >}})
+- [Active-Active Redis]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}})
+- [Active-Active Redis applications]({{< relref "/operate/rs/databases/active-active/develop" >}})---
+Title: Redis Cloud Essentials plans
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Provides detailed information on Redis Cloud Essentials plans
+weight: $weight
+---
+
+Redis Cloud Essentials is cost-efficient and designed for low-throughput scenarios. It supports a range of availability, persistence, and backup options.  
+
+[Essentials plan pricing](https://redis.io/pricing/#monthly) scales according to the memory size of the database defined in the subscription.  Additional limits also apply, as shown in the tables below.
+
+The 30 MB Essentials plan is free; it's designed for learning and building test projects. It gives you enough space to learn Redis concepts and develop application prototypes.
+
+Our paid plans start at 250 MB and offer extra features, like high availability and backups (both daily and instant). They are great for bigger projects or production environments that require increased storage, reliability, and other features to support your operational needs.
+
+Essentials plans have bandwidth and throughput limits described in the tables below. We will notify you before limiting your database usage if you exceed these limits.
+
+If you need additional resources, you can [upgrade your subscription]({{< relref "/operate/rc/subscriptions/view-essentials-subscription#upgrade-plan" >}}) at any time.
+
+## Current plans
+
+These plans are currently offered for all new and upgraded Essentials subscriptions (updated December 2024).
+
+### Redis Cloud Essentials plans
+
+{{<table-scrollable>}}
+| **DB&nbsp;size**<sup>[1](#table-note-1)</sup> | **30&nbsp;MB&nbsp;(Free)** | **250 MB** | **1 GB** | **2.5 GB** | **5 GB** | **12 GB** |
+|---|---|---|---|---|---|---|
+| **Concurrent<br/>connections<br/>per database** | 30 | 256 | 1024 | 2500 | 5000 | 10000 |
+| **CIDR<br/> allow rules** | 1 | 4 | 4-8 | 4-8 | 4-16 | 4-32 |
+| **Monthly<br/> total network<br/> bandwidth<sup>[2](#table-note-2)</sup>** | 5&nbsp;GB | 100&nbsp;GB | 200&nbsp;GB | 400&nbsp;GB | 800&nbsp;GB | 2000&nbsp;GB |
+| **Maximum<br/> throughput<sup>[3](#table-note-3)</sup>** | 100&nbsp;ops/sec | 1000&nbsp;ops/sec | 2000&nbsp;ops/sec | 4000&nbsp;ops/sec | 8000&nbsp;ops/sec | 16000&nbsp;ops/sec |
+{{</table-scrollable>}}
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a> Database size includes replication where applicable. See [High availability cost impact]({{< relref "/operate/rc/databases/configuration/high-availability#dataset-size" >}}) for more information.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a> The monthly total network bandwidth limit applies to the entire plan. All databases in the plan share the allocated bandwidth limit.
+
+3. <a name="table-note-3" style="display: block; height: 80px; margin-top: -80px;"></a> Assumes request size of 1 KiB. Maximums are capped by actual MB/s reached. To find the MB/s limit, divide the Maximum throughput by 1024.
+
+### Redis Flex plans
+
+{{<table-scrollable>}}
+| **DB&nbsp;size**<sup>[1](#table-note-1-flex)</sup> | **1 GB** | **2.5 GB** | **5 GB** | **12 GB** | **25 GB** | **50 GB** | **100 GB** |
+|---|---|---|---|---|---|---|---|
+| **Concurrent<br/>connections<br/>per database** | 1024 | 2500 | 5000 | 10000 | 10000 | 10000 | 10000 |
+| **CIDR<br/> allow rules** | 4-8 | 4-8 | 4-16 | 4-32 | 4-32 | 4-32 | 4-32 |
+| **Monthly<br/> total network<br/> bandwidth** | 50&nbsp;GB | 100&nbsp;GB | 200&nbsp;GB | 500&nbsp;GB | 1000&nbsp;GB | 2000&nbsp;GB | 4000&nbsp;GB |
+| **Maximum<br/> throughput<sup>[2](#table-note-2-flex)</sup>** | 200&nbsp;ops/sec | 500&nbsp;ops/sec | 1000&nbsp;ops/sec | 2400&nbsp;ops/sec | 5000&nbsp;ops/sec | 10000&nbsp;ops/sec | 20000&nbsp;ops/sec |
+{{</table-scrollable>}}
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a> Database size includes replication where applicable. See [High availability cost impact]({{< relref "/operate/rc/databases/configuration/high-availability#dataset-size" >}}) for more information.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a> Assumes request size of 1 KiB. Maximums are capped by actual MB/s reached. To find the MB/s limit, divide the Maximum throughput by 1024.
+
+## Previous plans {#legacy}
+
+These plans were available before November 2023.
+
+{{<table-scrollable>}}
+| **Max&nbsp;DB&nbsp;size&nbsp;**<sup>[1](#table-note-1-legacy)</sup>               | **30 MB**        | **100 MB**       | **250 MB**        | **500 MB**        | **1 GB**          | **2.5 GB**        | **5 GB**          | **10 GB**          |
+|-----------------------------------------------------------------------------------|------------------|------------------|-------------------|-------------------|-------------------|-------------------|-------------------|--------------------|
+| **Concurrent<br/>connections<br/>per database**                                   | 30               | 256              | 256               | 512               | 1024              | 2500              | 5000              | 10000              |
+| **Monthly<br/> total network<br/> bandwidth**<sup>[2](#table-note-2-legacy)</sup> | 5&nbsp;GB        | 50&nbsp;GB       | 100&nbsp;GB       | 150&nbsp;GB       | 200&nbsp;GB       | 400&nbsp;GB       | 800&nbsp;GB       | 2000&nbsp;GB       |
+| **Maximum<br/> throughput<sup>[3](#table-note-3-legacy)</sup>**                                                       | 100&nbsp;ops/sec | 500&nbsp;ops/sec | 1000&nbsp;ops/sec | 1500&nbsp;ops/sec | 2000&nbsp;ops/sec | 4000&nbsp;ops/sec | 8000&nbsp;ops/sec | 16000&nbsp;ops/sec |
+{{</table-scrollable>}}
+
+1. <a name="table-note-1-legacy" style="display: block; height: 80px; margin-top: -80px;"></a> Database size includes replication. See [High availability cost impact]({{< relref "/operate/rc/databases/configuration/high-availability#dataset-size" >}}) for more information.
+
+2. <a name="table-note-2-legacy" style="display: block; height: 80px; margin-top: -80px;"></a> The monthly total network bandwidth limit applies to the entire plan. All databases in the plan share the allocated bandwidth limit.
+
+2. <a name="table-note-2-legacy" style="display: block; height: 80px; margin-top: -80px;"></a> Assumes request size of 1 KiB. Maximums are capped by actual MB/s reached. To find the MB/s limit, divide the Maximum throughput by 1024.---
+LinkTitle: View and Upgrade Essentials plan
+Title: View and Upgrade Redis Cloud Essentials plan
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+weight: 30
+---
+To view the details of a Redis Cloud Essentials subscription:
+
+1.  Sign in to the [Redis Cloud console](https://cloud.redis.io/) and select the **Subscriptions** list.
+
+1.  Select the target subscription from the subscription list.
+
+    {{<image filename="images/rc/subscription-list-select.png" alt="The Subscription list shows your current subscriptions." width=50% >}}
+
+1.  Your subscription details appear, along with a summary of your database details.
+
+    {{<image filename="images/rc/subscription-details-fixed-databases-tab.png" alt="The Databases tab of the subscription details page is the default view." >}}
+
+From here, you can:
+
+- Select the **Upgrade** button to update your subscription plan, high availability settings, or payment method.
+
+    {{<image filename="images/rc/button-subscription-upgrade-plan.png" alt="Select the Upgrade plan button to update your subscription settings." width=100px >}}
+
+- Select the **Overview** tab to view and edit subscription details.
+
+The following sections provide more details.
+
+## Upgrade plan
+
+Use the **Upgrade** button to update your Redis Cloud Essentials plan, your high availability settings, or your payment method. Upgrading your database between Redis Cloud Essentials plans does not impact database availability during the update.
+
+{{<image filename="images/rc/button-subscription-upgrade-plan.png" alt="Use the Upgrade plan button to change selected Redis Cloud Essentials subscription detils." width=100px >}}
+
+For information on how to upgrade to Redis Cloud Pro, see [upgrade subscription plan from Essentials to Pro]({{< relref "/operate/rc/subscriptions/upgrade-essentials-pro" >}}).
+
+### Change subscription plan
+
+To change your subscription plan, select the desired plan from the list and select the **Upgrade plan** button:
+
+{{<image filename="images/rc/subscription-change-fixed-tiers.png" width="100%" alt="Select the desired subscription plan from the ones shown." >}}
+
+Each Redis Cloud Essentials plan provides a variety of benefits, including increased memory and number of connections.
+For a comparison of available plans, see [Redis Cloud Essentials plans]({{< relref "/operate/rc/subscriptions/view-essentials-subscription/essentials-plan-details" >}}).
+
+When you change your plan, your data and endpoints are not disrupted.  
+
+If you upgrade a free plan to a paid plan, you need to add a payment method.
+
+If you change your subscription to a lower plan, make sure your data fits within the limits of the new plan; otherwise, the change attempt will fail.
+
+{{< note >}}
+{{< embed-md "rc-fixed-upgrade-limitation.md" >}}
+{{< /note >}}
+
+### Change high availability and persistence
+
+To change your plan's [high availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) and [data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) settings, change them in the **Durability settings** panel.
+
+{{<image filename="images/rc/subscription-fixed-high-availability-panel.png" alt="Use the Durability settings panel to set Essentials subscription settings." >}}
+
+You can switch between **No replication** and **Single-zone replication** at any time, but you cannot choose **Multi-zone replication** after your subscription is created. You also cannot switch from **Multi-zone replication** to another high availability option.
+
+### Change payment method
+
+To change your subscription payment method, update the **Credit card** settings.  You can select a known payment method from the drop-down list or use the **Add** button to add a new one.
+
+{{<image filename="images/rc/subscription-change-credit-card.png" alt="Use the Credit card drop-down to set your subscription payment method." >}}
+
+Payment method changes require the Owner or Billing Admin roles. To verify your role, select **Access Management** from the admin menu and then locate your credentials in the **Team** tab.
+
+### Save changes
+
+Use the **Update Database** button to save changes.
+
+{{<image filename="images/rc/button-subscription-upgrade-plan-blue.png" alt="Use the Upgrade plan button to save your subscription plan changes." >}}
+
+## Subscription overview
+
+The **Overview** tab summarizes your Redis Cloud Essentials subscription details using a series of panels:
+
+{{<image filename="images/rc/subscription-details-fixed-overview-tab.png" width="75%" alt="The Overview tab displays the details of your Fixed subscription." >}}
+
+The following details are displayed:
+
+| Detail | Description |
+|:---------|:--------------|
+| **Subscription description** | Brief summary of subscription, including the plan type, cloud provider, region, and data size limit |
+| **Cloud vendor** | Your database's cloud vendor |
+| **Availability** | Describes high availability settings |
+| **Region** | The region your subscription is deployed to |
+| **Plan** | The maximum database size of your Essentials plan. Also displays the cost for paid plans. |
+| **Databases** | Maximum number of databases for your plan |
+| **Connections** | Maximum number of concurrent connections |
+| **CIDR allow rules** | Maximum number of authorization rules |
+| **Data persistence** | Indicates whether persistence is supported for your subscription |
+| **Daily & instant backups** | Indicates whether backups are supported for your subscription |
+| **Replication** | Indicates whether replication is supported for your subscription |
+| **Clustering** | Indicates whether clustering is supported for your subscription |
+
+The **Delete Database** button lets you [delete your database]({{< relref "/operate/rc/databases/delete-database" >}}).
+
+{{<image filename="images/rc/button-delete-database-essentials-overview.png" alt="Use the Delete subscription button to delete your subscription plan." >}}
+---
+Title: View and edit Redis Cloud Pro plan
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: View and edit Pro plan
+weight: 40
+---
+To view the details of a Redis Cloud Pro subscription:
+
+1.  Sign in to the [Redis Cloud console](https://cloud.redis.io/#) and select **Subscriptions**.
+
+1.  If you have more than one subscription, select the target subscription from the subscription list.
+
+    {{<image filename="images/rc/subscription-list-select.png" alt="The Subscription list shows your current subscriptions." width=50% >}}
+
+1.  Your subscription details appear, along with a summary of your database details.
+
+    {{<image filename="images/rc/subscription-flexible-databases-tab-pending.png" alt="The Databases tab of the subscription details page is the default view." >}}
+
+From here, you can:
+
+- Select **Create database in this subscription** to [add a database to your subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-existing" >}}).
+
+    {{<image filename="images/rc/button-add-new-to-pro.png" alt="The Create database in this subscription button." width=400px >}}
+
+- View the Status icon to learn the status of your subscription.  Active subscriptions display a green circle with a check mark. Pending subscriptions display an animated yellow circle.
+
+    {{<image filename="images/rc/icon-database-status-active.png#no-click" alt="When a subscription is active, the status icon displays a green circle with a checkmark." class="inline" >}} &nbsp; {{<image filename="images/rc/icon-subscription-status-pending.png#no-click" alt="When a subscription is pending, the status icon displays a gre, animated circle." class="inline">}}
+
+Because subscriptions represent active deployments, there aren't many details you can change.  If your needs change, [create a new subscription]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) and then [migrate the existing data]({{< relref "/operate/rc/databases/migrate-databases" >}}) to the new databases.
+
+In addition, three tabs are available:
+
+1.  The **Databases** tab lists the databases in your subscription and summarizes their settings.
+
+2.  The **Overview** tab displays subscription settings for your Redis Cloud Pro subscription.
+
+3.  The **Connectivity** tab lets you limit access to the subscription by defining a VPC peering or other connectivity options.
+
+The following sections provide more info.
+
+## **Databases** tab
+
+The **Databases** tab summarizes the databases in your subscription.  
+
+{{<image filename="images/rc/subscription-flexible-databases-tab-pending.png" alt="The Databases tab of the subscription details page is the default view." >}}
+
+The following details are provided:
+
+| Detail | Description |
+|:---------|:--------------|
+| **Status** | An icon indicating whether the database is active (a green circle) or pending (yellow circle)<br/>{{<image filename="images/rc/icon-database-detail-status-active.png#no-click" alt="Active status is indicated by a teal circle." class="inline" >}}&nbsp;{{<image filename="images/rc/icon-database-detail-status-pending.png#no-click" alt="Pending status is indicated by a yellow circle." class="inline">}} |
+| **Name** | The database name |
+| **Endpoint** | Use the **Copy** button to copy the endpoint URI to the Clipboard |
+| **Memory** | Memory size of the database, showing the current size and the maximum size |
+| **Throughput** | Maximum operations per second supported for the database |
+| **Capabilities** | Identifies advanced capabilities attached to the database |
+| **Options** | Icons showing options associated with the database |
+
+To view full details of a database, click its name in the list.
+
+## **Overview** tab
+
+The **Overview** summarizes the options used to create the subscription.
+
+{{<image filename="images/rc/subscription-details-overview-flexible.png" alt="The Overview tab displays the settings used to create your Redis Cloud Pro subscription." >}}
+
+- The general settings panel describes the cloud vendor, region, and high-availability settings for your subscription.
+
+    Select **Edit** to change the name of the subscription.
+
+    {{<image filename="images/rc/icon-edit-subscription-name.png" alt="Use the **Edit** button to change the subscription name." >}}
+
+
+    | Setting | Description |
+    |:---------|:--------------|
+    | **Cloud vendor** | Your subscription cloud vendor |
+    | **Plan description** | Brief summary of subscription, including the plan type, cloud provider, and region |
+    | **Auto Tiering** | Checked when Auto Tiering is enabled |
+    | **Multi-AZ** | Checked when multiple availability zones are enabled |
+    | **Active-Active Redis** | Checked when Active-Active Redis is enabled for your subscription |
+    | **Region** | Describes the region your subscription is deployed to |
+    | **Availability Zones** | The availability zones your subscription is deployed in (Visible if you selected availability zones on creation) |
+
+
+- The **Price** panel shows the monthly cost of your Redis Cloud Pro subscription.
+
+- The **Payment Method** panel shows the current payment details.
+
+    Select the **Edit payment method** button to change the credit card associated with this subscription.
+
+    {{< image filename="/images/rc/icon-subscription-detail-change-payment-flexible.png" alt="The edit payment method button, selected and showing a credit card." width=400px >}}
+
+    Select **Add credit card** to add a new credit card.
+
+- The **Maintenance Window** panel shows your current [maintenance window settings]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}).
+
+    See [Maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}) for more information about subscription maintenance on Redis Cloud.
+
+- The **Provisioned cloud resources** panel shows the storage resources used by your subscription.
+
+  If your subscription is attached to a cloud account, the details appear in the panel header.
+
+- The **Redis price** panel breaks down your subscription price.
+
+## **Connectivity** tab
+
+The **Connectivity** tabs helps secure your subscription.  
+
+{{<image filename="images/rc/subscription-details-connectivity-tab-flexible.png" alt="The Connectivity tab helps you secure your subscription." >}}
+
+Here, you can:
+
+- Set up a [VPC peering]({{< relref "/operate/rc/security/vpc-peering.md" >}}) relationship between the virtual PC (VPC) hosting your subscription and another virtual PC.
+
+- Set up a [CIDR allow list]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/subscription-whitelist" >}}) containing IP addresses or security groups permitted to access your subscription (_AWS Cloud accounts only_).
+
+- Set up [Private Service Connect]({{< relref "/operate/rc/security/private-service-connect" >}}) (*Google Cloud only*) or [Transit Gateway]({{< relref "/operate/rc/security/aws-transit-gateway" >}}) (*AWS only*).
+
+See the individual links to learn more.
+---
+Title: Configure subscription CIDR allow list 
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: The CIDR allow list permits traffic between a range of IP addresses and
+  the Redis Cloud VPC.
+linkTitle: Subscription CIDR allow list
+weight: $weight
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/subscription-whitelist
+  - /operate/rc/cloud-accounts/subscription-whitelist
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/subscription-whitelist
+---
+
+The [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) [allow list](https://en.wikipedia.org/wiki/Whitelist) lets you restrict traffic to your Redis Cloud database. When you configure an allow list, only the [IP addresses](https://en.wikipedia.org/wiki/IP_address) defined in the list can connect to the database. Traffic from all other IP addresses is blocked.
+
+If you use [Redis Cloud Bring your Own Cloud]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud" >}}) to host your Redis Cloud deployment, you can configure a subscription-wide allow list
+to restrict traffic to all databases associated with the subscription.
+
+The subscription CIDR allow list defines a range of IP addresses and [AWS security groups](https://docs.aws.amazon.com/managedservices/latest/userguide/about-security-groups.html) that control inbound and outbound traffic to the Redis Cloud [VPC](https://en.wikipedia.org/wiki/Virtual_private_cloud). When you add security groups to the allow list, you can also use the same security groups to manage access to your application.
+
+{{< note >}}
+The subscription-level allow list is available for Redis Cloud Bring your Own Cloud. If you don't have Redis Cloud Bring your Own Cloud, you can configure a [CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist" >}}) for each database.
+{{< /note >}}
+
+## Allow IP address or security group
+
+To add IP addresses or [AWS security groups](https://docs.aws.amazon.com/managedservices/latest/userguide/about-security-groups.html) to a subscription's allow list:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/) menu, select **Subscriptions** and then select your subscription from the list.
+
+1. Select **Connectivity > Allow List**.
+
+1. If the allow list is empty, select **Add allow list**.
+
+    {{<image filename="images/rc/button-subscription-allow-list-add.png" alt="Use the Add allow list button to create an allow list." width="140px">}}
+
+1. Select an entry **Type** from the list:
+
+    {{<image filename="images/rc/subscription-connectivity-allow-list-type-dropdown.png" alt="Select the type of entry to add to the allow list from the Type list." >}}
+
+1. In the **Value** box, enter one of these options:
+
+    - An IP address in CIDR format
+
+    - The AWS security group ID
+
+1. Select the check to add the entry to the allow list.
+
+1. To allow additional IP addresses or security groups:
+
+    1. Select **Add** to add a new entry.
+
+    {{<image filename="images/rc/icon-add.png" alt="The Add button adds new entries to the allow list." width="36px">}}
+
+    1. Select the new entry's **Type**, enter the **Value**, and select the check to add it to the allow list.
+
+        {{<image filename="images/rc/subscription-connectivity-allow-list-add-entry.png" alt="Define the new entry and select the Submit entry button to add it to the allow list." >}}
+    
+    You can also select the **Edit** button to change an entry or the **Delete** button to remove it.
+
+    {{<image filename="images/rc/icon-edit.png#no-click" alt="The Edit button updates an entry in the allow list." width="36px" class="inline" >}}&nbsp;{{<image filename="images/rc/icon-delete-teal.png#no-click" alt="The Delete button removes an entry from the allow list." width="36px" class="inline" >}}
+    
+1. Select **Apply all changes** to apply the allow list updates.
+
+    {{<image filename="images/rc/button-subscription-allow-list-apply-all.png" alt="The Apply all changes button saves your allow list changes." width="140px">}}---
+Title: Create IAM resources using Terraform
+Weight: $weight
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+linkTitle: Terraform
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/iam-resources/terraform
+  - /operate/rc/cloud-accounts/iam-resources/terraform
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/iam-resources/terraform
+---
+You can use [HashiCorp Terraform](https://www.terraform.io/intro/index.html) to create identity and access management (IAM) resources to support AWS cloud account access to Redis Cloud subscriptions.
+
+{{< warning >}}
+We use the provided credentials to configure your AWS environment and provision required resources.
+
+You **must not** change the configurations of provisioned resources or stop or terminate provisioned instances. If you do, your databases will be inaccessible and Redis will not be able to ensure database stability. See [Avoid service disruption]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings#avoid-service-disruption" >}}) for more details.
+{{< /warning >}}
+
+The following example uses the `terraform-aws-Redislabs-Cloud-Account-IAM-Resources` module, located in Amazon&nbsp;S3:
+
+
+1. Copy the following code into a file called `main.tf`.
+
+    {{< expand "View main.tf" >}}
+{{% code-include file="rv/terraformIAMTemplate.json" language="js" %}}
+    {{< /expand >}}
+
+    Replace the following values in the `main.tf` file:
+
+    - `<profile>`: The AWS CLI profile to use.
+    - `<region>`: The AWS region to use.
+    - `<pgp_key>`: The PGP key to use. For details, see the [Terraform docs](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/iam_user_login_profile#pgp_key).
+
+2. Initialize Terraform with the module:
+
+    Note: Terraform requires [AWS credentials be supplied](https://www.terraform.io/docs/language/modules/sources.html#s3-bucket), but the source of the module is a public S3 bucket, so any valid credentials should work. 
+
+    ```
+    AWS_ACCESS_KEY_ID=<access_key_id> AWS_SECRET_KEY=<secret_key> terraform init
+    ```
+
+    Replace `<access_key_id>` and `<secret_key>` with valid AWS keys.
+
+3. Build the resources and display the outputs:
+
+    ```
+    terraform apply
+    ```
+
+    You need the following information to [create a Cloud Account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) in the Redis Cloud console:
+
+    - **Access Key ID**: The `accessKeyId` output.
+    - **Secret Access Key**: Run the following command to extract the secret key from the `accessSecretKey` output:
+        ``` shell
+        echo $(terraform output -raw accessSecretKey)
+        ```
+    - **IAM Role Name**: The `IAMRoleName` output.
+
+---
+LinkTitle: AWS console
+Title: Create IAM resources using AWS console
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+weight: $weight
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/iam-resources/aws-console
+  - /operate/rc/cloud-accounts/iam-resources/aws-console
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/iam-resources/aws-console
+---
+Follow these steps to manually create IAM resources using the [AWS console](https://console.aws.amazon.com/).
+
+{{< warning >}}
+We use the provided credentials to configure your AWS environment and provision required resources.
+
+You **must not** change the configurations of provisioned resources or stop or terminate provisioned instances. If you do, your databases will be inaccessible and Redis will not be able to ensure database stability. See [Avoid service disruption]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings#avoid-service-disruption" >}}) for more details.
+{{< /warning >}}
+
+## Step 1: Create the IAM instance policy
+
+The IAM instance policy controls the permissions for the instances that Redis Cloud creates in your AWS account.
+
+Follow the steps to [create an IAM policy using the JSON editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor) with the following settings:
+
+- In **Specify permissions**, select **JSON**, and then enter the contents of the RedisLabsInstanceRolePolicy.json policy file:
+
+    {{< expand "View RedisLabsInstanceRolePolicy.json" >}}
+```js
+ {
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "DescribeReadOnlyEc2Resources",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:DescribeAvailabilityZones",
+                "ec2:DescribeRegions",
+                "ec2:DescribeSecurityGroups",
+                "ec2:DescribeTags",
+                "ec2:DescribeVolumes"
+            ],
+            "Resource": [
+                "*"
+            ]
+        },
+        {
+            "Sid": "EC2EBSActions",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:AttachVolume",
+                "ec2:CreateVolume"
+            ],
+            "Resource": [
+                "*"
+            ],
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "SecurityGroupAccessActions",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:AuthorizeSecurityGroupIngress",
+                "ec2:DeleteSecurityGroup"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "TagResourcesCreation",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:CreateTags"
+            ],
+            "Resource": [
+                "*"
+            ]
+        },
+        {
+          "Sid": "TagResourcesDelete",
+          "Effect": "Allow",
+          "Action": [
+                "ec2:DeleteTags"
+          ],
+          "Resource": [
+                "*"
+          ],
+          "Condition": {
+              "StringEquals": {
+                  "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+              }
+          }
+        }
+    ]
+}
+```
+    {{< /expand >}}
+
+- In **Review and Create**, enter `RedisLabsInstanceRolePolicy` in the **Policy name** field.
+
+Select **Create policy** to finish policy creation.
+
+## Step 2: Create the service role
+
+After creating the instance role policy, you must create a role to assign the policy.
+
+Follow the steps to [create a role for an AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console) with the following settings:
+
+- In **Select trusted entity**:
+    - **Trusted entity**: Select **AWS service**.
+    - **Service or use case**: Select **EC2**.
+    - **Use case**: Select **EC2**.
+- In **Add permissions**, select the **RedisLabsInstanceRolePolicy** you created.
+- In **Name, review, and create**, enter `redislabs-cluster-node-role` in the **Role name** field.
+
+Select **Create role** to finish role creation.
+
+## Step 3: Create the user policy
+
+The user policy controls the permissions for the user that Redis Cloud uses to manage your AWS account.
+
+Follow the steps to [create an IAM policy using the JSON editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor) with the following settings:
+
+- In **Specify permissions**, select **JSON**, and then enter the contents of the RedisLabsIAMUserRestrictedPolicy.json policy file:
+
+    {{< expand "View RedislabsIAMUserRestrictedPolicy.json" >}}
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "DescribeReadOnlyEc2Resources",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:DescribeAvailabilityZones",
+                "ec2:DescribeInstanceTypeOfferings",
+                "ec2:DescribeRegions",
+                "ec2:DescribeInstances",
+                "ec2:DescribeVolumes",
+                "ec2:DescribeSnapshots",
+                "ec2:DescribeVpcs",
+                "ec2:DescribeSubnets",
+                "ec2:DescribeSecurityGroups",
+                "ec2:DescribeRouteTables",
+                "ec2:DescribeInternetGateways",
+                "ec2:DescribeImages",
+                "ec2:DescribeTransitGatewayVpcAttachments",
+                "ec2:DescribeVpcPeeringConnections",
+                "ec2:DescribeKeyPairs",
+                "ec2:DescribeTransitGateways",
+                "ec2:DescribeInstanceStatus",
+                "ec2:DescribeNetworkAcls"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "CloudWatchReadOnly",
+            "Effect": "Allow",
+            "Action": [
+                "cloudwatch:Describe*",
+                "cloudwatch:Get*",
+                "cloudwatch:List*"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "IamUserOperations",
+            "Effect": "Allow",
+            "Action": [
+                "iam:GetUser",
+                "iam:GetUserPolicy",
+                "iam:ChangePassword"
+            ],
+            "Resource": "arn:aws:iam::*:user/${aws:username}"
+        },
+        {
+            "Sid": "RolePolicyUserReadActions",
+            "Action": [
+                "iam:GetRole",
+                "iam:GetPolicy",
+                "iam:ListUsers",
+                "iam:ListPolicies",
+                "iam:ListRolePolicies",
+                "iam:ListAttachedRolePolicies",
+                "iam:ListInstanceProfiles",
+                "iam:ListInstanceProfilesForRole",
+                "iam:SimulatePrincipalPolicy"
+            ],
+            "Effect": "Allow",
+            "Resource": "*"
+        },
+        {
+            "Sid": "PassRlClusterNodeRole",
+            "Effect": "Allow",
+            "Action": "iam:PassRole",
+            "Resource": "arn:aws:iam::*:role/redislabs-cluster-node-role"
+        },
+        {
+            "Sid": "CreateEc2ResourcesWithoutTag",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:CreateTags",
+                "ec2:RunInstances",
+                "ec2:ImportKeyPair",
+                "ec2:CreateKeyPair",
+                "ec2:CreateVpc",
+                "ec2:CreateSecurityGroup",
+                "ec2:CreateInternetGateway",
+                "ec2:CreateRouteTable",
+                "ec2:CreateSubnet",
+                "ec2:CreateSnapshot",
+                "ec2:CreateTransitGateway",
+                "ec2:AssociateVpcCidrBlock",
+                "ec2:CreateTransitGatewayVpcAttachment",
+                "ec2:AttachInternetGateway",
+                "ec2:ReplaceRoute"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "ForceUnderlyingResourcesToHaveIdentifierTags",
+            "Effect": "Deny",
+            "Action": [
+                "ec2:RunInstances",
+                "ec2:CreateKeyPair"
+            ],
+            "Resource": [
+                "arn:aws:ec2:*:*:instance/*",
+                "arn:aws:ec2:*:*:volume/*",
+                "arn:aws:ec2:*:*:keypair/*"
+            ],
+            "Condition": {
+                "Null": {
+                    "aws:RequestTag/RedisLabsIdentifier": "true"
+                }
+            }
+        },
+        {
+            "Sid": "AllowVpcPeeringManagement",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:CreateVpcPeeringConnection",
+                "ec2:AcceptVpcPeeringConnection"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "AllowVpcPeeringDeletion",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:DeleteVpcPeeringConnection"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "CreateEc2Resources",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:CreateVolume",
+                "ec2:CreateRoute",
+                "ec2:AuthorizeSecurityGroupIngress",
+                "ec2:AuthorizeSecurityGroupEgress"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "ModifyEc2Resources",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:AttachVolume",
+                "ec2:ModifyInstanceAttribute",
+                "ec2:ModifySubnetAttribute",
+                "ec2:AssociateRouteTable",
+                "ec2:StartInstances",
+                "ec2:StopInstances",
+                "ec2:RebootInstances"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "DeleteEc2Resources",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:TerminateInstances",
+                "ec2:DeleteVolume",
+                "ec2:DeleteSnapshot",
+                "ec2:DetachVolume",
+                "ec2:DeleteKeyPair",
+                "ec2:DeleteTags",
+                "ec2:DeleteSubnet",
+                "ec2:DeleteSecurityGroup",
+                "ec2:DeleteRouteTable",
+                "ec2:DeleteRoute",
+                "ec2:DeleteInternetGateway",
+                "ec2:DeleteVpc"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "StringEquals": {
+                    "ec2:ResourceTag/RedisLabsIdentifier": "Redislabs-VPC"
+                }
+            }
+        },
+        {
+            "Sid": "DeleteEc2ResourcesWithoutTag",
+            "Effect": "Allow",
+            "Action": [
+                "ec2:RevokeSecurityGroupIngress",
+                "ec2:RejectVpcPeeringConnection",
+                "ec2:DeleteTransitGatewayVpcAttachment",
+                "ec2:DeleteTransitGateway",
+                "ec2:DetachInternetGateway"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "CreateAndChangeServiceLinkedRoleForTransitGateway",
+            "Effect": "Allow",
+            "Action": "iam:CreateServiceLinkedRole",
+            "Resource": "arn:aws:iam::*:role/aws-service-role/transitgateway.amazonaws.com/AWSServiceRoleForVPCTransitGateway*",
+            "Condition": {
+                "StringLike": {
+                    "iam:AWSServiceName": "transitgateway.amazonaws.com"
+                }
+            }
+        },
+        {
+            "Sid": "RolePolicyForTransitGateway",
+            "Effect": "Allow",
+            "Action": [
+                "iam:AttachRolePolicy",
+                "iam:PutRolePolicy"
+            ],
+            "Resource": "arn:aws:iam::*:role/aws-service-role/transitgateway.amazonaws.com/AWSServiceRoleForVPCTransitGateway*"
+        },
+        {
+            "Sid": "AllowEncryptedVolumeCreation",
+            "Effect": "Allow",
+            "Action": [
+                "kms:GenerateDataKeyWithoutPlaintext",
+                "kms:DescribeKey"
+            ],
+            "Resource": "*"
+        },
+        {
+            "Sid": "AllowAttachDetachOfEncryptedVolumes",
+            "Effect": "Allow",
+            "Action": [
+                "kms:CreateGrant",
+                "kms:ListGrants",
+                "kms:RevokeGrant"
+            ],
+            "Resource": "*",
+            "Condition": {
+                "Bool": {
+                    "kms:GrantIsForAWSResource": "true"
+                }
+            }
+        }
+    ]
+}
+```
+    {{< /expand >}}
+
+- In **Review and Create**, enter `RedislabsIAMUserRestrictedPolicy` in the **Policy name** field.
+
+Select **Create policy** to finish policy creation.
+
+## Step 4: Create the programmatic access user
+
+After you create the user policy, you must create a programmatic access user and attach the policy to it.
+
+Follow the steps to [create a user on the AWS console](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html), with the following settings:
+
+- In **Specify user details**, For **User name**, enter `redislabs-user`.
+- In **Set permissions**:
+    - **Permissions options**: Select **Attach existing policies directly**.
+    - **Permissions policies**: Select the **RedislabsIAMUserRestrictedPolicy** you created from the list.
+
+Select **Create user** to create the user.
+
+After you create the user, you need to add an access key for the user.
+
+Follow the steps to [create an access key](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-keys-admin-managed.html#admin-create-access-key) for the user you just created. Save the access key ID and secret access key in a secure location.
+
+## Step 5: Create the console access role
+
+The console access role controls the permissions for the user that Redis Cloud uses to access the AWS console.
+
+Follow the steps to [Create a role for an IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) with the following settings:
+
+- In **Select trusted entity**:
+    - **Trusted entity**: Select **AWS account**.
+    - **An AWS account**: Select **Another AWS account**.
+    - **Account ID**: Enter account number `168085023892` (Redis Cloud's AWS account).
+    - **Options**: Select **Require MFA**.
+    {{< warning >}}
+Do not check the **Require external ID** checkbox.
+    {{< /warning >}}
+- In **Add permissions**, select the **RedisLabsInstanceRolePolicy** you created.
+- In **Name, review, and create**, enter `redislabs-role` in the **Role name** field.
+
+Select **Create role** to finish role creation. Save the Role name for later.
+
+## Next steps
+
+When you've finished creating all of the resources, you can [create a Cloud Account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) in the Redis Cloud console. To do this, you'll need the following information:
+
+- **Access Key ID**: The Access Key ID for the [programmatic user you created](#step-4-create-the-programmatic-access-user).
+- **Secret Access Key**: The Secret Access Key for the [programmatic user you created](#step-4-create-the-programmatic-access-user).
+- **IAM Role Name**: The name of the [console access role you created](#step-5-create-the-console-access-role).
+---
+Title: Create IAM resources using CloudFormation
+Weight: $weight
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+linkTitle: CloudFormation
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/iam-resources/cloudformation
+  - /operate/rc/cloud-accounts/iam-resources/cloudformation
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/iam-resources/cloudformation
+---
+You can use [AWS CloudFormation](https://aws.amazon.com/cloudformation/) to create the IAM resources for Redis Cloud Bring your Own Cloud (BYOC).
+
+{{< warning >}}
+We use the provided credentials to configure your AWS environment and provision required resources.
+
+You **must not** change the configurations of provisioned resources or stop or terminate provisioned instances. If you do, your databases will be inaccessible and Redis will not be able to ensure database stability. See [Avoid service disruption]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings#avoid-service-disruption" >}}) for more details.
+{{< /warning >}}
+
+## Create resources using CloudFormation on the AWS Console
+
+The following link uses CloudFormation to create a stack using the AWS console:
+
+<a href="https://console.aws.amazon.com/cloudformation/home?#/stacks/new?stackName=RedisCloud&templateURL=https://s3.amazonaws.com/iam-resource-automation-do-not-delete/RedisCloud.yaml">
+<img alt="Launch RedisCloud template" src="https://s3.amazonaws.com/cloudformation-examples/cloudformation-launch-stack.png"/>
+</a>
+
+When the stack finishes, select the stack and then the **Outputs** tab. You need the following information to [create a Cloud Account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) in the Redis Cloud console:
+
+- **Access Key ID**: The `accessKeyId` output.
+- **Secret Access Key**: Follow the link to AWS Secrets Manager in the `accessSecretKey` output and select **Retrieve secret value**. 
+- **IAM Role Name**: The `IAMRoleName` output.
+
+## Create resources using CloudFormation through AWS CLI
+
+You can also use the AWS command-line interface (CLI) to create the stack:
+
+``` shell
+aws cloudformation create-stack --stack-name RedisCloud --template-url \
+https://s3.amazonaws.com/iam-resource-automation-do-not-delete/RedisCloud.yaml \
+--capabilities CAPABILITY_AUTO_EXPAND CAPABILITY_NAMED_IAM CAPABILITY_IAM
+```
+
+You can track the status of the cloud formation with the following command:
+
+```shell
+aws cloudformation describe-stacks --stack-name RedisCloud
+```
+
+After the stack finishes, you can retrieve the outputs from the `Outputs` section of the response.
+
+You need the following information to [create a Cloud Account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) in the Redis Cloud console:
+
+- **Access Key ID**: The `accessKeyId` output.
+- **Secret Access Key**: Extract the secret ID from the `accessSecretKey` output. The secret ID is the `name` query parameter in the `accessSecretKey` output. 
+
+    For example, if the `accessSecretKey` output is `https://console.aws.amazon.com/secretsmanager/home?region=<region>/secret?name=/redislabsuser/secret_access_key`, then the secret ID is `/redislabsuser/secret_access_key`.
+
+    Use the secret ID to retrieve the secret value using the AWS secretsmanager CLI:
+
+    ``` shell
+    aws secretsmanager get-secret-value --secret-id=<accessSecretKey-ID>
+    ```
+    Replace `<accessSecretKey-ID>` with the secret ID you extracted from the `accessSecretKey` output.
+- **IAM Role Name**: The `IAMRoleName` output.
+---
+Title: Create IAM resources for AWS cloud accounts
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+linkTitle: Create IAM resources
+weight: 1
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/iam-resources
+  - /operate/rc/cloud-accounts/iam-resources
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/iam-resources
+---
+For Redis Cloud Bring your Own Cloud (BYOC) on Amazon Web Services (AWS), we manage the supporting infrastructure for you in dedicated AWS accounts.
+
+You can manage this infrastructure with your own AWS accounts.  
+
+You'll want these accounts to be separate from any AWS application accounts 
+and you'll need to create dedicated [identity and access management](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) (IAM) resources to allow us to manage the infrastructure.
+
+In the new AWS account, you need to create:
+
+- An **instance role**
+- A user with an **access key**
+- A role that grants **AWS console access**
+
+Save the access key in a secure location so that you can enter it when you [register the cloud account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) with your Redis Cloud subscription.
+
+{{< warning >}}
+We use the provided credentials to configure your AWS environment and provision required resources.
+
+You **must not** change the configurations of provisioned resources or stop or terminate provisioned instances. If you do, your databases will be inaccessible and Redis will not be able to ensure database stability. See [Avoid service disruption]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings#avoid-service-disruption" >}}) for more details.
+{{< /warning >}}
+
+For help creating an AWS user, see the [AWS IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
+
+You can use one of the following tools to create IAM resources:
+
+- [CloudFormation]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources/cloudformation" >}})
+- [Terraform]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources/terraform" >}})
+- The [AWS Console]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources/aws-console" >}})
+---
+LinkTitle: Bring your own Cloud
+Title: Redis Cloud Bring your own Cloud
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes how to provision your Redis Cloud subscription to use an existing
+  cloud provider account.
+bannerText: This article covers Redis Cloud Bring your Own Cloud (BYOC) deployments. To learn more or get started with Redis Cloud BYOC, [contact sales](https://redis.io/meeting/).
+bannerChildren: true
+hideListLinks: true
+weight: 80
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account
+  - /operate/rc/cloud-accounts
+  - /operate/rc/cloud-integrations/aws-cloud-accounts
+---
+
+Redis Cloud Bring your own Cloud (BYOC) allows organizations to use their own cloud infrastructure to deploy Redis Cloud.
+
+By default, Redis hosts the infrastructure that runs Redis Cloud. However, if your organization has specific requirements, you may need to have more control over your data residency or security options. Redis Cloud BYOC lets you fulfill these requirements while still having a fully managed service experience of Redis Cloud. Like standard Redis Cloud, Redis manages deployment, scaling, monitoring, and support, so you can focus on building applications while Redis manages the backend.
+
+Redis Cloud BYOC availability requires approval from Redis. If you're interested, [contact sales](https://redis.io/meeting/).
+
+## Benefits of Redis Cloud BYOC
+
+Redis Cloud BYOC has some benefits over standard Redis Cloud:
+
+- **Full Data Control**: All data stays within your environment, giving you complete control over data security and reducing risks associated with data sovereignty.
+- **Simplified Compliance**: BYOC simplifies adherence to regulatory standards like GDPR, HIPAA, and compliance frameworks like SOC 2 and PCI DSS since data remains within your own cloud account.
+- **Maximize Cloud Commitments**: Infrastructure costs are billed directly through your cloud provider account, enabling you to fully utilize existing commitments.
+- **Separation of Costs**: Customers pay Redis only for licensing and management, while infrastructure costs go directly to the cloud provider, offering clear visibility into each cost stream.
+- **Instant Access Control**: You can revoke Redis’ access to your environment at any time, offering complete control over data and infrastructure.
+
+## Redis Cloud BYOC Use cases
+
+Consider using Redis Cloud BYOC if you have specific organizational needs or requirements, such as:
+
+- **Data Residency and Compliance**: Organizations operating in heavily regulated industries (such as finance, healthcare, and government) can use Redis Cloud BYOC to meet strict data residency and sovereignty requirements, ensuring sensitive data remains within their controlled environments.
+- **Cloud spend optimization**: Companies with significant cloud provider commitments can use Redis Cloud BYOC to optimize their cloud spend. Since infrastructure costs are billed directly through the cloud provider, customers can fully utilize existing cloud provider discounts, improving cost efficiency.
+- **Enhanced Security and Control**: Redis Cloud BYOC is ideal for organizations that require a higher degree of security and control over their data. By keeping data within your own cloud account, you can use existing security policies, tools, and procedures in your cloud’s security infrastructure. In this way, you can minimize external access to your data, and adhere to more strict organizational security guidelines.
+
+## Set up Redis Cloud BYOC
+
+To set up Redis Cloud BYOC on Amazon Web Services (AWS):
+
+1. [Create the Identity and Access Management (IAM) resources]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources" >}}) needed to let Redis create, monitor, and maintain deployment infrastructure.
+
+1. [Set your AWS Account as a BYOC Cloud account]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings" >}}) on Redis Cloud.
+
+## Avoid Redis Cloud BYOC service disruption {#avoid-service-disruption}
+
+{{< warning >}}
+Failing to follow the instructions in this section will cause your databases to become inaccessible, and Redis will not be able to ensure cluster and database stability. Please read them carefully.
+{{< /warning >}}
+
+To keep your Redis Cloud BYOC service and all databases running without issues:
+- Do not stop, delete, or modify Redis-managed resources through the cloud provider - including VPCs, subnets, virtual machines, and other infrastructure.
+- Do not change roles or access policies.
+
+If you make any infrastructure changes, whether or not they are listed above, it may violate our SLA commitments. See [Appendix 1 in our Terms of Service](https://redis.io/legal/cloud-tos/#Appendix-1) for more details.
+
+---
+Title: Create and edit Cloud accounts
+LinkTitle: Create and edit Cloud accounts
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+weight: 2
+aliases:
+  - /operate/rc/how-to/view-edit-cloud-account/cloud-account-settings
+  - /operate/rc/cloud-accounts/cloud-account-settings
+  - /operate/rc/cloud-integrations/aws-cloud-accounts/cloud-account-settings
+---
+
+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:
+
+1. A programmatic user with an access key and a secret access key for that user.
+1. 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]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources" >}}).
+
+{{<warning>}}
+After an AWS account has been configured as a cloud account, you **must not** change the configurations of provisioned resources or stop or terminate provisioned instances. If you do, your databases will be inaccessible and Redis will not be able to ensure database stability. See [Avoid service disruption]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/cloud-account-settings#avoid-service-disruption" >}}) for more details.
+{{</warning>}}
+
+## View cloud account settings
+
+To create or edit a cloud account in Redis Cloud:
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io/) and then select the target subscription.
+
+1. From the console menu, select **Account Settings** and then select the **Cloud Account** tab.
+
+    This displays a list of cloud accounts associated with your Redis Cloud subscription.
+
+    {{<image filename="images/rc/account-settings-cloud-account-tab.png" alt="Use the Cloud Account tab of the Account Settings screen to define cloud accounts for your Redis Cloud subscription." width="80%">}}
+
+The **Cloud account** tab lets you manage cloud accounts associated with your Redis Cloud subscription.
+
+The **Cloud Account** tab is only available for accounts with Redis Cloud Bring your own Cloud (BYOC) subscriptions.
+
+## Add a new cloud account
+
+To add a new cloud account to your Redis Cloud subscription, select the **Add** button from the Cloud Account tab of the Account Settings screen.
+
+{{<image filename="images/rc/icon-add.png" width="30px" alt="Use the Add button to add new cloud accounts to your Redis Cloud subscription." width="36px">}}
+
+This displays the **Add cloud account** dialog.
+
+{{<image filename="images/rc/account-settings-prompt-add-cloud-account.png" alt="Use the Add cloud account prompt to enter the details of the cloud account." width="75%">}}
+
+Each of the following fields are required.
+
+|Setting|Description|
+|-------|-----------|
+| _Account name_ | A descriptive name for your cloud account settings |
+| _AWS&nbsp;access&nbsp;key_ | The AWS access key for the programmatic user created to support your cloud account settings |
+| _AWS&nbsp;secret&nbsp;key_ | The AWS secret key for the programmatic user created to support your cloud account settings |
+| _IAM role name_ | The name of the AWS console role with access to the AWS console |
+
+Use the **Add account** button to save your cloud account details.
+
+{{<image filename="images/rc/button-cloud-account-add.png" alt="Use the Add account button to save the details of your new cloud account." width="140px">}}
+
+Be sure to create the resources before adding the cloud account to your subscription, as they're used to verify access to the cloud account.  The details can be saved only after access is verified.
+
+When problems occur, an information icon appears and the field is highlighted in red.  When this happens, the icon includes a tooltip that explains the issue.
+
+If the **Add account** button is inactive, verify that:
+
+- You've specified all field values correctly
+- The resources exist in your AWS account
+- Each resource provides the required level of access
+
+For help, see [Create IAM resources]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources" >}}).
+
+## Edit cloud account details
+
+To update the details of a cloud account associated with your Redis Cloud subscription, select the cloud account from the **Cloud account** tab and then select the **Edit** button.
+
+{{<image filename="images/rc/icon-edit.png" alt="Use the Edit button to update cloud account details." width="36px">}}
+
+This displays the **Edit cloud account** dialog:
+
+{{<image filename="images/rc/account-settings-prompt-edit-cloud-account.png" alt="Use the Edit cloud account prompt to update the details of the cloud account." width="75%">}}
+
+|Setting|Description|
+|-------|-----------|
+| _Account name_ | A descriptive name for your cloud account settings |
+| _AWS access key_ | The AWS access key for the programmatic user created to support your cloud account settings |
+| _AWS secret key_ | The AWS secret key for the programmatic user created to support your cloud account settings |
+| _IAM role name_ | The name of the AWS console role with access to the AWS console |
+
+Use the **Update account** button to save your changes.
+
+{{<image filename="images/rc/button-cloud-account-update.png" alt="Use the Update account button to save the updated cloud account details." width="140px">}}
+
+## Delete cloud account
+
+To remove a cloud account from your Redis cloud subscription, select the cloud account from the **Cloud account** tab and then select the **Delete** button.
+
+{{<image filename="images/rc/icon-delete-teal.png" alt="Use the Delete button to remove cloud account details." width="36px">}}
+
+## Dedicated IAM resources
+
+We strongly recommend using dedicated identity and access management (IAM) resources to manage your AWS cloud accounts.  These resources should not be shared with any other task, account, or process.
+
+To learn more, see [Create IAM resources for AWS cloud accounts]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/iam-resources" >}}).---
+Title: Delete a subscription
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+linktitle: Delete subscription
+weight: 50
+---
+
+{{<note>}}
+Once a subscription is deleted, it cannot be recovered. We recommend [backing up your data]({{< relref "/operate/rc/databases/back-up-data.md" >}}) before removing databases or subscriptions.
+{{</note>}}
+
+To delete a subscription:
+
+1.  [Delete all databases]({{< relref "/operate/rc/databases/delete-database.md" >}}) 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.
+
+    {{<image filename="images/rc/subscription-list-pro-no-databases.png" width="50%" alt="The number of databases is shown in the bottom, left of the subscription in the subscription list." >}}
+
+2.  View the subscription details.  
+
+    If you have more than one subscription, select the target subscription from the subscription list.
+
+3.  Select the **Overview** tab.
+
+    {{<image filename="images/rc/subscription-details-overview-flexible.png" width="75%" alt="The Overview tab displays the details of your subscription." >}}
+
+4.  Select the **Delete subscription** button.
+
+    {{<image filename="images/rc/button-subscription-delete.png" alt="Use the Delete subscription button to delete your subscription plan." >}}
+
+    {{<image filename="images/rc/subscription-delete-confirm-dialog.png" alt="Select the Yes, cancel button to confirm the subscription cancellation." >}}
+
+
+5.  Select the **Delete subscription** button to confirm your choice.
+---
+LinkTitle: Set maintenance windows
+Title: Set maintenance windows
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Shows how to set manual maintenance windows and skip maintenance.
+headerRange: '[1-3]'
+toc: 'true'
+weight: $weight
+---
+
+By default, Redis will maintain your Redis Cloud subscriptions and databases as needed. During maintenance, you may notice some latency when connecting to your databases. For more information about the types of maintenance and how Redis maintains your subscriptions, see [Maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}}).
+
+For Redis Cloud Pro plans, Redis will perform maintenance automatically while limiting service disruption as much as possible. If you want to control when Redis performs maintenance for a Redis Cloud Pro subscription, you can [set manual maintenance windows](#set-manual-maintenance-windows) to ensure non-urgent maintenance will occur at set times. Configuring or altering the maintenance window will not have any impact on your subscription or databases.
+
+{{<note>}}
+You can only set manual maintenance windows for Redis Cloud Pro plans. A Redis Cloud Essentials database has a set maintenance window based on the region where it is located. See [Essentials maintenance]({{< relref "/operate/rc/subscriptions/maintenance#redis-cloud-essentials" >}}) for more information.
+{{</note>}}
+
+## Set manual maintenance windows
+
+To set manual maintenance windows for a single Redis Cloud Pro subscription:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select the **Subscriptions** menu and then select your subscription from the list.
+
+1. Select the **Overview** tab.
+
+1. In the **Maintenance Windows** panel, select **Manual**.
+
+1. Click **Activate** to confirm your selection.
+
+1. Enter the maintenance window time frame details.
+
+    {{<image filename="images/rc/subscriptions-set-maintenance-window.png" alt="The set maintenance windows panel" >}}
+
+    - Select the days that Redis can perform maintenance in the **Days** drop-down.
+    - Select the time that Redis can start performing maintenance on those days in the **From** drop-down.
+    - Select the amount of time that Redis can perform maintenance in the **Duration** drop-down.
+    - Select **+ Time Frame** to add another time frame for maintenance.
+    - Select **Advance notification** if you want to be notified of maintenance in advance.
+
+    Redis recommends allowing maintenance on at least two different days for 8 hours on each day.
+
+1. Click **Save**.
+
+## Skip maintenance temporarily
+
+To skip maintenance temporarily for a subscription:
+
+1. From the [Redis Cloud console](https://cloud.redis.io/), select the **Subscriptions** menu and then select your subscription from the list.
+
+1. Select the **Overview** tab.
+
+1. In the **Maintenance Windows** panel, select **Skip the next 14 days**.
+
+1. Click **Continue** to confirm your selection.
+
+You will only be allowed to skip maintenance once per month. 
+
+During the skipped maintenance period, Redis will not perform any minor or major upgrades. Redis may perform [urgent maintenance]({{< relref "/operate/rc/subscriptions/maintenance#urgent-maintenance" >}}) on your subscription, but only if it is absolutely necessary.
+
+
+---
+LinkTitle: Maintenance
+Title: Subscription and database maintenance
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes maintenance that Redis performs on a Redis Cloud subscription.
+headerRange: '[1-3]'
+hideListLinks: true
+toc: 'true'
+weight: $weight
+---
+
+Redis will maintain your Redis Cloud subscriptions and databases as needed to ensure your databases are running the most stable and up-to-date version of Redis.
+
+## Maintenance windows
+
+Maintenance windows define when Redis can perform maintenance on your subscriptions and databases. Maintenance window options depend on your subscription type.
+
+### Redis Cloud Pro
+
+For Redis Cloud Pro plans, Redis will perform maintenance automatically while limiting service disruption as much as possible. If you want to control when we can perform maintenance for a Redis Cloud Pro subscription, you can [set manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows#set-manual-maintenance-windows" >}}).
+
+### Redis Cloud Essentials
+
+Redis Cloud Essentials databases have a set maintenance window based on the cloud provider region. The maintenance window for Redis Cloud Essentials databases is **daily from 12 AM to 6 AM** in the region's local time zone. We won't use more than one maintenance window per week unless we need to do [urgent maintenance]({{< relref "/operate/rc/subscriptions/maintenance#urgent-maintenance" >}}), and we won't perform any maintenance that introduces breaking changes during these maintenance windows.
+
+## Maintenance activities
+
+During maintenance, Redis ensures the stability of your subscriptions and databases. 
+
+This includes, but is not limited to:
+
+- Upgrading Redis or an advanced capability to the latest version
+- Cluster optimization
+- Replacing a cluster node
+- Adding more memory to a node
+- Applying security patches
+
+Redis will notify users by email when maintenance starts and ends. For more details, see [Notifications](#notifications).
+
+During maintenance, your database will be operational, but you may notice some latency when connecting to your databases.
+
+Your application may also disconnect from your database for a few seconds. Most Redis clients are set to refresh their DNS address when they reconnect to the database, and you will not be required to perform any further action. If you encounter connectivity problems for more than a minute during maintenance, please refresh your DNS entries.
+
+{{<tip>}}
+To make sure your applications are set to reconnect after maintenance activity, see [Develop highly available and resilient apps with Redis Cloud]({{< relref "/operate/rc/resilient-apps" >}}).
+{{</tip>}}
+
+### Urgent maintenance
+
+Urgent maintenance refers to any activity that could affect service and cannot wait for scheduling. This includes applying urgent security patches.
+
+Redis can perform urgent maintenance at any time, even if you have set a manual maintenance window or have temporarily [skipped maintenance]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows#skip-maintenance-temporarily" >}}). Redis will notify you by email when urgent maintenance starts and ends.
+
+### Major upgrades
+
+We won't schedule major upgrades or upgrades that might include breaking changes until you opt-in to those changes. You can control your Redis major version on the [subscription page]({{< relref "/operate/rc/subscriptions/view-pro-subscription" >}}).
+
+## Notifications
+
+Redis will notify you by email when maintenance starts and ends. If Redis needs an action from you to start maintenance, we will notify you with a reasonable amount of time before planned maintenance.
+
+If you want to receive advance notifications, you must [set manual maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows#set-manual-maintenance-windows" >}}).
+
+To receive maintenance notifications by email:
+ 
+ 1. Go to [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) and select your account in the list.
+
+1. Go to [Access Management]({{< relref "/operate/rc/security/access-control/access-management" >}}) and select your account in the list.
+
+1. Select the Edit button.
+
+    {{<image filename="images/rc/icon-edit.png" width="30px" alt="Use the Edit button change details for a team member." >}}
+
+1. Select **Operational emails** if it is not already turned on.
+
+    {{<image filename="images/rc/access-mgmt-edit-user-dialog.png" width="50%" alt="Use the Edit User dialog to change the details for a user" >}}
+
+1. Select **Save user** to save your changes.---
+LinkTitle: Upgrade from Essentials to Pro
+Title: Upgrade database from Redis Cloud Essentials to Redis Cloud Pro
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Upgrade your Redis Cloud Essentials subscription to a Redis Cloud Pro
+  subscription.
+weight: 45
+---
+
+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]({{< relref "/operate/rc/subscriptions#subscription-plans" >}}).
+
+To upgrade your Essentials plan, see [Upgrade subscription plan]({{< relref "/operate/rc/subscriptions/view-essentials-subscription#upgrade-plan" >}}).
+
+## Upgrade Essentials subscription to Pro
+
+To follow the steps in this guide, you must have a database with [Redis Cloud Essentials]({{< relref "/operate/rc/subscriptions/view-essentials-subscription" >}}) that you want to upgrade to Redis Cloud Pro.
+
+To upgrade your Essentials database to Redis Cloud Pro:
+
+1. [Create a new database in Redis Cloud Pro](#create-rcp) with the right specifications to be able to migrate your database.
+
+1. [Migrate your Essentials database](#migrate-database) to your new Redis Cloud Pro database.
+
+### Create Redis Cloud Pro database {#create-rcp}
+
+[Create a new database]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) with the following specifications:
+
+- Select **Redis Cloud Pro** for your subscription type.
+- Select the **Version** that matches the Redis version your Essentials subscriptions use.
+- In the [**Sizing tab**]({{< relref "/operate/rc/databases/create-database/create-pro-database-new#sizing-tab" >}}), create your databases with the following specifications:
+    - Set the memory limit to comply with [Active-Passive memory requirements]({{< relref "/operate/rc/databases/migrate-databases#active-passive-memory-requirements" >}}) if you want to migrate your database using [Active-Passive]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}).
+    - Select any advanced capabilities that your Essentials database offers. You can find a list of enabled advanced capabilities in the [Configuration tab]({{< relref "/operate/rc/databases/view-edit-database#configuration-details-tab" >}}) of your database.
+
+### Migrate database
+
+You can migrate your Redis Cloud Essentials database to your new Redis Cloud Pro subscription using any method in the [Migrate databases]({{< relref "/operate/rc/databases/migrate-databases" >}}) guide. This guide uses [Active-Passive]({{< relref "/operate/rc/databases/migrate-databases#sync-using-active-passive" >}}) to migrate databases between subscriptions in the same account.
+
+{{< note >}}
+Before you follow this guide, be aware of the following limitations:
+
+- This guide is for migrating databases between subscriptions in the same Redis Cloud console account. [Contact support](https://redis.io/support/) if you want to migrate a database between accounts using Active-Passive.
+
+- As long as Active-Passive is enabled, data in the target database will not expire and will not be evicted regardless of the set [data eviction policy]({{< relref "/operate/rc/databases/configuration/data-eviction-policies.md" >}}). We recommend that you turn off Active-Passive after the databases are synced. 
+{{< /note >}}
+
+1. Select the database you want to migrate your data to. This will be your target database.
+
+1. From the **Configuration** tab of the target database, select **Edit**.
+
+    {{<image filename="images/rc/button-database-edit.png" alt="The Edit database button lets you change selected database properties." width=100px >}}
+
+1. In the **Durability** section, enable **Active-Passive Redis** and then select **Add Source**.
+
+    {{<image filename="images/rc/migrate-data-active-passive-enable.png" alt="Active-Passive settings are located in the **Durability** section of the database **Configuration** tab." >}}
+
+    {{<image filename="images/rc/button-database-uri-add.png" alt="Use the **Add Source** button to specify the source of the Active-Passive replica." width="150px">}}
+
+1. This will open the **Add Active-Passive Redis** screen. Select **Current account** to connect a database in your current account.
+
+    {{<image filename="images/rc/migrate-data-add-active-passive.png" alt="The Add Active-Passive Redis screen." width=70% >}}
+
+1. Select your Redis Cloud Essentials database from the **Source database** list. This will be your source database. You can type in the database's name to find it.
+
+    {{<image filename="images/rc/database-add-account-path-list.png" alt="Select the Source database from the database list." width=70% >}}
+
+1. Select **Save Database** to begin updating the database.
+
+    {{<image filename="images/rc/button-database-save.png" alt="Use the **Save Database** button to save your changes, deploy the database, and to start data migration." >}}
+
+    Initially, the database status is __Pending__, which means the update task is still running.  
+
+    {{<image filename="images/rc/icon-database-update-status-pending.png" alt="When the status is 'Pending', your changes are still being deployed.">}}
+
+    The sync process doesn't begin until the database becomes `Active`.  
+
+    {{<image filename="images/rc/icon-database-status-active.png" alt="When the status becomes 'Active', data begins to sync." >}}
+
+    When data has fully migrated to the target database, database status reports `Synced`.  
+
+    {{<image filename="images/rc/migrate-data-status-synced.png" alt="When the data is migrated, the target database status displays `Synced`." >}}
+
+    Active-Passive sync lets you migrate data while apps and other connections are using the source database. Once the data is migrated, you should migrate active connections to the target database before you move on.
+
+1. After your data and connections are migrated, turn off **Active-Passive Redis** from the target database.
+
+1. [Delete the source database]({{< relref "/operate/rc/databases/delete-database" >}}).
+
+
+
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: true
+linktitle: Subscriptions
+title: Manage subscriptions
+weight: 35
+---
+
+This page helps you manage your Redis Cloud subscriptions; it briefly compares available plans and shows where to find help with common tasks.
+
+## Subscription plans
+
+As of April 2024, Redis Cloud supports the following subscription plans:
+
+- [Free Redis Cloud Essentials](#free-rce)
+- [Paid Redis Cloud Essentials](#paid-rce)
+- [Redis Cloud Pro](#redis-cloud-pro)
+
+Here's a quick comparison of each plan:
+
+| Feature | Redis Cloud Essentials (free) | Redis Cloud Essentials (paid) | Redis Cloud Pro |
+|:-----|:-------:|:----:|:-----:|
+| Memory size | 30 MB | 250 MB-12 GB | 50 TB |
+| Concurrent connections | 30 | 256-10000 | Unlimited |
+| Security | Role-based auth<br/>Password protection<br/>Encryption in transit | Role-based auth<br/>Password protection<br/>TLS auth<br/>Encryption in transit | Role-based auth<br/>Password protection<br/>TLS auth<br/>Encryption in transit<br/>Encryption at rest |
+| REST API | No | Yes | Yes | 
+| Selected additional features<br/> <br/> <br/>|| Replication<br/>Auto-failover<br /> | Dedicated accounts<br>Auto Tiering<br/>Active/Active<br/> |   
+
+To learn more, see [Redis Cloud Pricing](https://redis.io/pricing/).
+
+### Free Redis Cloud Essentials {#free-rce}
+
+Free plans are a type of Redis Cloud Essentials plans designed for training purposes and prototyping. They can be seamlessly upgraded to other Redis Cloud Essentials plans with no data loss.
+
+### Paid Redis Cloud Essentials {#paid-rce}
+Redis Cloud Essentials is cost-efficient and designed for low-throughput scenarios. It support a range of availability, persistence, and backup options.  Pricing supports low throughput workloads. See [Redis Cloud Essentials plans]({{< relref "/operate/rc/subscriptions/view-essentials-subscription/essentials-plan-details" >}}) for a list of available plans.
+
+- [View and upgrade Essentials plan]({{< relref "/operate/rc/subscriptions/view-essentials-subscription" >}})
+
+### Redis Cloud Pro
+Redis Cloud Pro supports more databases, larger databases, greater throughput, and unlimited connections compared to Redis Cloud Essentials. Hosted in dedicated VPCs, they feature high-availability in a single or multi-AZ, Active-Active, Auto-Tiering, clustering, data persistence, and configurable backups.  Pricing is "pay as you go" to support any dataset size or throughput.
+
+Redis Cloud Pro annual plans support the same features as Redis Cloud Pro but at significant savings. Annual plans also provide Premium support. The underlying commitment applies to all workloads across multiple providers and regions.
+
+- [View and edit Pro subscription]({{< relref "/operate/rc/subscriptions/view-pro-subscription" >}})
+- [Upgrade from Essentials to Pro]({{< relref "/operate/rc/subscriptions/upgrade-essentials-pro" >}})
+- [Subscription maintenance]({{< relref "/operate/rc/subscriptions/maintenance" >}})
+
+
+---
+LinkTitle: Account settings
+Title: Manage account settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes the settings for a Redis Cloud account.
+weight: $weight
+---
+
+To review or manage the settings associated with your Redis Cloud account, sign in to the [Redis Cloud console](https://cloud.redis.io/) and then select **Account Settings** from the menu.
+
+This displays the **Account Settings** screen:
+
+{{<image filename="images/rc/account-settings-account-tab.png" alt="Use the Account tab of the Account Settings screen to review and update settings associated with your Redis Cloud account." width="75%">}}
+
+The available tabs depend on your account, and may include:
+
+- The **Account** tab displays basic information associated with your account, including general info, address details, time zone setting, security settings, and provider integration details.
+
+- The **Cloud Account** tab is displayed for Redis Cloud Pro subscriptions hosted on Amazon Web Services (AWS).  To learn more, see [Bring your own Cloud]({{< relref "/operate/rc/subscriptions/bring-your-own-cloud/" >}}).
+
+- The **Integrations** tab lets you manage certain integrations.
+
+You can change some settings by selecting **Edit**. For help changing other settings, [contact Support](https://redis.io/support/).
+
+{{<image filename="images/rc/button-database-edit.png" alt="The Edit button changes account settings." width="100px">}}
+    
+## Redis account info settings
+
+The **Redis Account Info** section provides basic details about your account, including:
+
+| Setting          | Description |
+|------------------|-------------|
+| _Redis account name_   | Name associated with the Redis Cloud account | 
+| _Redis account number_ | Internal ID of the Redis account |
+| _Date created_   | Date the user's Redis Cloud account was created, which may differ from the organization account creation date |
+| _Last updated_   | Date of the last administrative change to the owner's account, typically reflects access changes or other administrative updates | 
+
+Select **Edit** to change the Redis Account name.
+
+{{<image filename="images/rc/button-database-edit.png" alt="The Edit button changes account settings." width="100px">}}
+
+After changing the account name, use the **Save changes** button to save changes or **Discard changes** to revert them.
+
+{{<image filename="images/rc/account-settings-buttons-save-discard.png" alt="Use the Discard Changes and the Save Changes buttons to manage changes to account settings." width="300px">}} 
+
+You cannot change the email address associated with a Redis Cloud account.  Instead, create a new account with the updated email address, assign it as an administrator to the organization account, and then use the new account to delete the account with the invalid email address.
+
+## Contacts & Business information 
+
+The **Contacts & Business information** section shows the company name and business address associated with the current Redis Cloud account. Redis uses the company name and business address for invoice and tax purposes.
+
+In addition, this section may include fields unique to your location.  For example, certain regions require tax IDs or other regulatory details.
+
+Select **Edit** to change the account's company name and business address.
+
+   {{<image filename="images/rc/button-database-edit.png" alt="The Edit button changes account settings." width="100px">}}
+
+   {{<image filename="images/rc/account-settings-change-business-info.png" alt="The Contacts & Business information section, with details changed." width="75%">}}
+
+When you change your business address, you must approve the use of the information in this section for communication and billing purposes before you can save. After approving, select **Save changes** to save your changes or **Discard changes** to revert them. 
+
+{{<image filename="images/rc/account-settings-buttons-save-discard.png" alt="Use the Discard Changes and the Save Changes buttons to manage changes to account settings." width="300px">}}
+
+## Security settings
+
+The **Security** section lets you:
+
+- Manage [multi-factor authentication]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}}) (MFA) for your Redis Cloud account.
+
+- Download the [Redis Cloud certificate authority (CA) bundle]({{< relref "/operate/rc/security/database-security/tls-ssl#download-certificates" >}}) as a [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) file, which contains the certificates associated with your Redis Cloud account.
+
+## Time zone settings
+
+To change the time zone settings, select **Edit** and then select the desired time zone from the **Time zone** drop-down.
+
+Select **Save changes** to save your changes or **Discard changes** to revert them. 
+
+{{<image filename="images/rc/account-settings-buttons-save-discard.png" alt="Use the Discard Changes and the Save Changes buttons to manage changes to account settings." width="300px">}}
+
+## Integration settings
+
+The **Integrations** tab includes settings that help you manage integrations of your Redis Cloud account with other services.
+
+For more details, see:
+- [Use the Redis Sink Confluent Connector]({{< relref "/integrate/confluent-with-redis-cloud/" >}})
+- [Prometheus and Grafana with Redis Cloud]({{< relref "/integrate/prometheus-with-redis-cloud/" >}})
+
+---
+LinkTitle: User account and profile
+Title: Manage user account and profile
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes the how to manage your user account profile and how to switch
+  between Redis Cloud accounts.
+weight: $weight
+---
+When you sign in to the [Redis Cloud console](https://cloud.redis.io/), you use a profile associated with one or more Redis Cloud accounts.  
+
+This account has a profile with settings that you can manage using the Profile control located near the top, right corner of the Redis Cloud console:
+
+{{<image filename="images/rc/account-selector-single-account.png" alt="Use the Profile control to manage your user account profile and to switch between Redis Cloud accounts." width="300px">}}
+
+When you open the Profile control, you can:
+
+- Review and manage your user account profile.
+
+- Sign out from the Redis Cloud console.
+
+- Switch between Redis Cloud subscriptions administered by your user account.
+
+## Manage user profile
+
+To review your user profile settings, select **User profile** from the Profile control.  This displays the **User Profile** screen:
+
+{{<image filename="images/rc/user-profile-settings.png" alt="The User Profile screen lets you manage selected settings associated with your user account." width="75%">}}
+
+This screen contains up to three sections, including:
+
+- The *User details* section includes basic information about your account, including _First name_, _Last name_, _Job title_, _Email_, and the date the account was created.  The names and job title can be edited; other settings are read-only.
+
+- The *Password* section lets you change the password for accounts created and managed by Redis Cloud. 
+
+    If you're using single sign-on authentication, you cannot change the password using the *User Profile* screen.  Such accounts are managed by an identity provider (IdP).  For help changing (or recovering) the passwords for these accounts, consult your identity provider docs.
+
+- The **Multi-factor authentication (MFA)** section lets you [manage MFA settings]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}}) for the current user account.  
+
+    When you activate a mobile device, you can use SMS MFA as a second authentication factor.
+
+    To use an authentication app as the factor, you need to activate a mobile device and then use that device to enable the app.
+
+## Sign out 
+
+To sign out from the Redis Cloud console, select **Logout** from the profile control.
+
+## Switch Redis cloud accounts
+
+When your user account is authorized to manage multiple Redis Cloud accounts, each account is displayed in the Profile control.
+
+{{<image filename="images/rc/account-selector-switch-account.png" alt="To switch between Redis Cloud accounts, select the desired account from the list shown on the Profile control." width="300px">}}
+
+To switch accounts, select the desired account from the list shown in the Profile control.
+
+{{< note >}}
+To create another Redis Cloud account associated with the same email address, you need to [sign up for Redis Cloud]({{< relref "/operate/rc/rc-quickstart" >}}) again with a plus address of the email address. For many email providers, you can do this by adding `+` and any string to the end of your username. For example, if your address is `example@example.com`, enter `example+account2@example.com`.
+{{< /note >}}
+
+## Save or discard changes
+
+Use the **Discard changes** button to cancel user profile setting changes or the **Save changes** button to save changes.---
+Title: Manage accounts and settings
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes how to work with Redis Cloud accounts and manage their settings.
+hideListLinks: true
+linkTitle: Accounts & settings
+weight: 39
+---
+
+Here, you learn how to manage Redis Cloud accounts and their settings:
+
+- [Manage account settings]({{< relref "/operate/rc/accounts/account-settings" >}})
+
+- [Manage user account and profile]({{< relref "/operate/rc/accounts/user-profile" >}})
+
+- [Switch between Redis Cloud accounts]({{< relref "/operate/rc/accounts/user-profile#switch-redis-cloud-accounts" >}})
+---
+Title: Usage reports
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: You can view usage reports to track the memory usage and shard usage
+  of all your databases.
+weight: 70
+---
+
+The **Usage Report** shows the daily memory usage and shard usage of all databases from the subscriptions associated with your account.
+
+{{< image filename="/images/rc/usage-report-memory-usage.png" >}}
+
+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.
+
+## Download cost report
+
+{{< embed-md "rc-cost-report-csv.md" >}}---
+Title: System logs
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: You can view and export system logs to track any activity associated
+  with your subscriptions and databases.
+weight: 35
+---
+The **Logs** page contains events, alerts, and logs from the activities, databases, and subscriptions associated with your account.
+
+{{<image filename="images/rc/system-logs.png" alt="Choose the Logs page from the Redis Cloud console menu to view your subscription system log." width="100%">}} 
+
+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*.
+
+    {{<image filename="images/rc/icon-list-sort-asc.png#no-click" alt="Use the arrows in the list header to sort the list." class="inline">}}&nbsp;{{<image filename="images/rc/icon-list-sort-desc.png#no-click" alt="The direction of the arrow corresponds to the direction of the sort." class="inline">}}    
+    
+    Select the arrow icon to change the sort order.  You can only sort by one field at a time.
+
+* Use the **Export all** button to export all logs as a comma-separated values (CSV) file for use in other systems and programs.
+
+    {{<image filename="images/rc/system-logs-export.png" alt="Use the export all button in the top right to export all logs to a CSV file" width="130px">}} 
+
+* Use the refresh button to refresh the system logs.
+
+    {{<image filename="images/rc/system-logs-refresh.png" alt="Use the refresh button in the top right to refresh the system logs" width="30px">}}
+
+* Use the search bar to search for specific entries. Supported fields include *Originator*, *Database name*, *API key name*, *Activity*, and *Description*.---
+LinkTitle: Logs & reports
+Title: View logs and reports
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+hideListLinks: false
+weight: 37
+---
+
+Here, you learn how to use Redis Cloud logs and reports to track activity and usage statistics. 
+---
+Title: Redis Cloud compatibility with Redis Open Source
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Redis Cloud compatibility with Redis Open Source.
+linkTitle: Redis Open Source compatibility
+weight: 90
+tocEmbedHeaders: true
+---
+
+Both [Redis Enterprise Software]({{< relref "/operate/rs" >}}) and Redis Cloud are compatible with Redis Open Source.
+
+{{< embed-md "rc-rs-oss-compatibility.md"  >}}
+
+## RESP compatibility
+
+Redis Enterprise Software and Redis Cloud support RESP2 and RESP3. In Redis Cloud, you can choose between RESP2 and RESP3 when you [create a database]({{< relref "/operate/rc/databases/create-database" >}}) and you can change it when you [edit a database]({{< relref "/operate/rc/databases/view-edit-database" >}}). For more information about the different RESP versions, see the [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}#resp-versions).
+
+## Client-side caching compatibility
+
+Redis Software and Redis Cloud support [client-side caching]({{<relref "/develop/clients/client-side-caching">}}) for databases with Redis versions 7.4 or later. See [Client-side caching compatibility with Redis Software and Redis Cloud]({{<relref "/operate/rs/references/compatibility/client-side-caching">}}) for more information about compatibility.
+
+## Compatibility with Redis Cluster API
+
+Redis Cloud supports [Redis Cluster API]({{< relref "/operate/rc/databases/configuration/clustering#oss-cluster-api" >}}) on Redis Cloud Pro if it is enabled for a database. Review [Redis Cluster API architecture]({{< relref "/operate/rs/clusters/optimize/oss-cluster-api" >}}) to determine if you should enable this feature for your database.---
+Title: Frequently Asked Questions
+description:
+weight: 40
+alwaysopen: false
+categories: ["RC"]
+draft: true
+------
+Title: Metrics and Usage Statistics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Using the metrics API operation to query database usage and statistics
+  information
+draft: true
+weight: 80
+---
+You can get metrics and usage statistics for a database from the API operation:
+
+`GET /subscriptions/{subscription-id}/databases/{database-id}/metrics?metricSpan={metric-span}`.
+
+The metrics API is supported for Redis Cloud Pro subscriptions.
+
+The query accepts 3 parameters:
+
+- `subscription-id` (Required) - The relevant subscription ID for the database
+- `database-id` (Required) - The ID of the database
+- `metric-span` (Optional) - The [time span]({{< relref "/operate/rc/api/concepts/metrics#metric-spans-and-intervals" >}}) for the query. The default time span is `1hour`.
+
+## Metrics query example
+
+```shell
+{{% embed-code "rv/api/70-query-metrics.sh" %}}
+```
+---
+Title: Manage API Keys
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Managing API Keys using the Redis Cloud admin console
+draft: true
+hidden: true
+weight: 30
+---
+After you create a Redis Cloud API access key, you can manage your API access key in the following ways:
+
+- Deleting the access key
+- Limiting usage of the access key by network subnets
+<!-->
+## Delete an access key
+
+To delete an access key:
+
+1. [Log in to admin console](https://app.redislabs.com) as an account owner.
+1. Go to: **Settings** > **Cloud API Keys**
+
+    If **Cloud API Keys** is not shown, make sure you have [enabled the API for your account]({{< relref "/operate/rc/api/how-to/enable-your-account-to-use-api.md" >}})).
+1. Click **Delete**.
+1. Confirm that you want to delete the access key.
+
+## Limit access by subnet
+
+By default, API access is allowed from all IP addresses.
+
+To limit API access to a specified range of source IP addresses:
+
+1. [Log in to admin console](https://app.redislabs.com) as an account owner.
+1. Go to: **Settings** > **Cloud API Keys**
+1. Click **Manage IPs** for the access key that you want to limit.
+1. Click {{< image filename="/images/rs/icon_add.png#no-click" alt="Add" >}} to add a new whitelist subnet.
+1. Enter the subnet in [CIDR format](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation), for example: `10.2.5.0/24`
+1. Save the subnet.
+
+After you add the subnet, you can add more subnets or click **OK**.
+
+## Delete an allowed subnet
+
+1. [Log in to admin console](https://app.redislabs.com) as an account owner.
+1. Go to: **Settings** > **Cloud API Keys**
+1. Click **Manage IPs** for the access key that you want to change.
+1. Delete the subnet that you want to disallow.
+
+After you delete the subnet, you can delete more subnets or click **OK**.
+-->---
+Title: Audit using System Log
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Use the system log to track and audit actions performed in the account.
+weight: 60
+---
+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](https://cloud.redis.io/) and then select **Logs** from the main menu.
+
+{{<image filename="images/rc/system-logs.png" alt="Choose the Logs command from the Redis Cloud console menu to view your subscription system log." width="100%">}} 
+
+To learn more, see [System logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}).
+
+## Get system logs via REST API
+
+The REST API operation for querying the system log is [`GET /logs`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountSystemLogs" >}}).
+
+The `/logs` API operation accepts the following parameters:
+
+- `offset` - The starting point for the results.  The default value of `0` starts with the latest log entry. A value of `11` skips the first 10 entries and retrieves entries starting with the 11 and older.
+- `limit` - The maximum number of entries to return per request. The default value is `100`.
+
+The system log reports activity for the entire account. It reports log entries for all types of entities, including subscriptions, databases, and so on.
+
+### Request results
+
+An API system log request results in data that includes an `entries` array. The entries are sorted by system log entry ID in descending order and include the following properties:
+
+- `id` - A unique identifier for each system log entry.
+
+- `time` - The system log entry timestamp, defined in ISO-8601 date format and in the UTC timezone (for example: `2019-03-15T14:26:02Z`).
+
+- `originator` - The name of the user who performed the action described by the system log entry.
+
+- `apiKeyName` - The name of the API key used to perform the action described by the system log entry.
+    This field only appears if the action was performed through the API.
+    If the operation was performed through the Redis Cloud console, this property is omitted.
+
+- `resource` - The name of the entity associated with the logged action (for example, database name).
+    This property is omitted if it is not applicable to the specific log entry.
+
+- `type` - The category associated with the action log entry.
+
+- `description` - The detailed description of the action in the log entry.
+---
+Title: API usage quota and throttling
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+draft: true
+weight: 50
+---
+{{/* This appears to be a stub article that starte but not completed.  
+
+     It's been moved from /concepts to /examples so that, if/when completed, 
+     it shows up in the right place.
+     
+*//}}---
+Title: Create and manage subscriptions
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes how to create and manage a subscription using the Redis Cloud API.
+weight: 10
+---
+
+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`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/createSubscription_1" >}}) to create an Essentials subscription.
+
+```sh
+POST "https://[host]/v1/fixed/subscriptions"
+{
+    "name": "My new subscription",
+    "planId": <plan_id>,
+    "paymentMethodId": <payment_id>
+}
+```
+
+Modify the following parameters in the sample JSON document to create a subscription on your own account:
+
+- **`paymentMethodId`** - Specify a payment method connected to your account.
+
+    Use [`GET /v1/payment-methods`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountPaymentMethods" >}}) to find a payment method ID.
+
+    You don't need to pass this field in your API request if you subscribed to Redis Cloud through a marketplace integration.
+
+- **`planId`** - Specify an essentials plan to create.
+
+    Use [`GET /v1/fixed/plans`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/getAllFixedSubscriptionsPlans" >}}) to get a list of plan IDs.
+
+After you create an Essentials subscription, you must use the [`POST /v1/fixed/subscriptions/{subscriptionId}/databases`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/createFixedDatabase" >}}) endpoint to [create the database]({{< relref "/operate/rc/api/examples/create-database#redis-cloud-essentials" >}}).
+
+You can include the contents of the JSON document in the `POST /v1/fixed/subscriptions` operation in the [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html). See [Swagger user interface]({{< relref "/operate/rc/api/get-started/use-rest-api#swagger-user-interface" >}}) for more details.
+
+{{< note >}}
+The Swagger UI generates default JSON examples for `POST` and `PUT` operations. You can reference these examples and modify them to fit your specific needs and account settings. The examples will fail if used as-is.
+{{< /note >}}
+
+The response body contains the `taskId` for the task that creates the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Update an Essentials subscription
+
+Use [`PUT /v1/fixed/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/updateSubscription_1" >}}) to update an Essentials subscription.
+
+```sh
+PUT "https://[host]/v1/fixed/subscriptions/{subscriptionId}"
+{
+    "name": "new-subscription-name",
+    "planId": <plan_id>,
+    "paymentMethodId": <payment_id>
+}
+```
+
+You can only change the following settings with this endpoint:
+- **`name`** - Specify a new name for your subscription.
+
+- **`planId`** - Specify a new Essentials plan to change to.
+
+    You can only change to a plan that:
+        
+    - Is in the same cloud provider and region of your current plan.
+        
+    - Has a compatible [High-availability option]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) to your current plan. For example, if your current plan has single-zone replication, you cannot switch to a plan with multi-zone replication, but you can switch to a plan with no replication. If your current plan has multi-zone replication, you must switch to a plan with multi-zone replication.
+
+    Use [`GET /v1/fixed/plans/subscriptions/{subscriptionID}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/getFixedSubscriptionsPlanById" >}}) to get a list of plan IDs that are compatible with your subscription.
+
+- **`paymentMethodId`** - Specify a different payment method connected to your account.
+
+    Use [`GET /v1/payment-methods`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountPaymentMethods" >}}) to find a payment method ID.
+
+The response body contains the `taskId` for the task that updates the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Delete an Essentials subscription
+
+Use [`DELETE /v1/fixed/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/deleteSubscriptionById_1" >}}) to delete a subscription.
+
+```sh
+DELETE "https://[host]/v1/fixed/subscriptions/{subscriptionId}"
+```
+The response body contains the `taskId` for the task that deletes the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+## Redis Cloud Pro
+
+### Create a Pro subscription
+
+Use [`POST /v1/subscriptions`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/createSubscription" >}}) to create a Pro subscription.
+
+```sh
+POST "https://[host]/v1/subscriptions"
+{
+    "name": "Basic Subscription Example",
+    "paymentMethodId": <payment_id>,
+    "cloudProviders": [
+        {
+            "provider": "AWS",
+            "regions": [
+                {
+                    "region": "us-east-1",
+                    "networking": {
+                        "deploymentCIDR": "10.0.1.0/24"
+                    }
+                }
+            ]
+        }
+    ],
+    "databases": [
+        {
+            "name": "Redis-database-example",
+            "protocol": "redis",
+            "datasetSizeInGb": 1
+        }
+    ]
+}
+```
+
+Modify the following parameters in the sample JSON document to create a subscription on your own account:
+
+- **`paymentMethodId`** - Specify a payment method connected to your account.
+
+    Use [`GET /v1/payment-methods`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountPaymentMethods" >}}) to find a payment method ID.
+
+    You don't need to pass this field in your API request if you subscribed to Redis Cloud through a marketplace integration.
+
+The request JSON body contains two primary segments: subscription specification and databases specification. When you create a subscription, you must specify one or more databases in the "`databases`" array. 
+
+There are many additional parameters and settings that can be defined on subscription and database creation. Review the subscription parameters and options in the [Full API documentation]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/createSubscription" >}}).
+
+The response body contains the `taskId` for the task that creates the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Update a Pro subscription
+
+Use [`PUT /v1/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/updateSubscription" >}}) to update a Pro subscription.
+
+```sh
+PUT "https://[host]/v1/subscriptions/{subscriptionId}"
+{
+    "name": "new-subscription-name",
+    "paymentMethodId": <payment_id>
+}
+```
+
+You can only change the following settings with this endpoint:
+- **`name`** - Specify a new name for your subscription.
+
+- **`paymentMethodId`** - Specify a different payment method connected to your account.
+
+    Use [`GET /v1/payment-methods`]({{< relref "/operate/rc/api/api-reference#tag/Account/operation/getAccountPaymentMethods" >}}) to find a payment method ID.
+
+The response body contains the `taskId` for the task that updates the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Delete a Pro subscription
+
+Use [`DELETE /v1/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/deleteSubscriptionById" >}}) to delete a subscription.
+
+```sh
+DELETE "https://[host]/v1/subscriptions/{subscriptionId}"
+```
+The response body contains the `taskId` for the task that deletes the subscription. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+---
+Title: Create and manage databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: This article describes how to create and manage a database using the Redis Cloud API.
+linkTitle: Create and manage databases
+weight: 20
+---
+
+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`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/createFixedDatabase" >}}).
+
+This call creates a database in the specified subscription. Use [`GET /fixed/subscriptions`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/getAllSubscriptions_1" >}}) to get a list of Essentials subscriptions and their IDs. 
+
+```shell
+POST "https://[host]/v1/fixed/subscriptions/{subscriptionId}/databases"
+{
+  "name": "Basic-essentials-database-example"
+}
+```
+
+This example JSON body contains only the most basic, required parameters to create a database:
+
+- `name`: The database name. A unique name per subscription that can contain only alphanumeric characters and hyphens
+
+There are other additional parameters and settings that can be defined on database creation. Review the database parameters and options in the [full API reference]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/createFixedDatabase" >}}). 
+
+Some options may not be compatible with your selected plan. Use [`GET /fixed/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/getFixedSubscriptionsPlansBySubscriptionId" >}}) to view the plan you have selected and what options it supports.
+
+The response body contains the `taskId` for the task that creates the database. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Update an Essentials database
+
+To update a Redis Cloud Essentials database, use [`PUT /fixed/subscriptions/{subscriptionId}/databases/{databaseId}`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/deleteFixedDatabaseByID" >}}). 
+
+The primary component of a database update request is the JSON request body that contains the details of the requested database changes. You can see the full set of changes you can make in the [full API reference]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/deleteFixedDatabaseByID" >}}).
+
+Some options may not be compatible with your selected plan. Use [`GET /fixed/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Essentials/operation/getFixedSubscriptionsPlansBySubscriptionId" >}}) to view the plan you have selected and what options it supports.
+
+The response body contains the `taskId` for the task that updates the database. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+## Redis Cloud Pro
+
+### Create a Pro database
+
+If you want to create a Pro database in a new subscription, see [Create a Pro subscription]({{< relref "/operate/rc/api/examples/manage-subscriptions#create-a-pro-subscription" >}}).
+
+To create a Redis Cloud Pro database in an existing subscription, use [`POST /subscriptions/{subscriptionId}/databases`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/createDatabase" >}}).
+
+This call creates a database in the specified subscription. Use [`GET /subscriptions`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/getAllSubscriptions" >}}) to get a list of subscriptions and their IDs. 
+
+```shell
+POST "https://[host]/v1/subscriptions/{subscriptionId}/databases"
+{
+  "name": "Basic-database-example",
+  "datasetSizeInGb": 1
+}
+```
+
+This example JSON body contains only the most basic, required parameters to create a database:
+
+- `name`: The database name. A unique name per subscription that can contain only alphanumeric characters and hyphens
+- `datasetSizeInGb`: Maximum dataset size in GB
+
+There are many additional parameters and settings that can be defined on database creation. Review the database parameters and options in the [full API reference]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/createDatabase" >}}).
+
+The response body contains the `taskId` for the task that creates the database. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.
+
+### Update a Redis Cloud Pro database
+
+To update a Redis Cloud Pro database, use [`PUT /subscriptions/{subscriptionId}/databases/{databaseId}`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/updateDatabase" >}}). 
+
+The primary component of a database update request is the JSON request body that contains the details of the requested database changes. You can see the full set of changes you can make in the [full API reference]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/updateDatabase" >}}).
+
+The response body contains the `taskId` for the task that updates the database. You can use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to track the task's status.---
+Title: Security and privacy
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: null
+draft: true
+weight: 70
+---
+---
+Title: View account information
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Get initial information on account parameters
+weight: 70
+draft: true
+---
+<!-- This article is removed since it was duplicated with the REST API reference. I decided to keep it as a draft just in case. -->
+
+The root API operation returns information about the current account, user, and API Key (as identified by the set of API Keys provided in the API request).
+
+```shell
+GET "https://[host]/v1/subscriptions/<subscription_id>/databases/<database_id>/metrics?metricSpan=1hour"
+```
+
+Here is an example of the API operation response:
+
+```json
+{
+  "account": {
+    "id": 654321,
+    "name": "Redis",
+    "createdTimestamp": "2018-12-23T15:15:31Z",
+    "updatedTimestamp": "2019-07-04T12:22:04Z",
+    "key": {
+      "name": "jay-doe-api-key-6",
+      "accountId": 654321,
+      "accountName": "Redis account for Jay Doe",
+      "allowedSourceIps": [
+        "192.0.2.0/24"
+      ],
+      "createdTimestamp": "2019-06-06T07:41:14Z",
+      "owner": {
+        "name": "Jay Doe",
+        "email": "jay.doe@redislabs.com"
+      },
+      "httpSourceIp": "192.0.2.0"
+    }
+  }
+}
+```
+
+The above example contains:
+
+- **httpSourceIp**: The public source IP of the current user
+- **allowedSourceIps**: Restricts the current API Key access to requests originating from IP addresses that reside within the specified IP range
+---
+Title: Request performance metrics
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: The metrics API provides programmatic access to database usage and performance
+  data
+draft: true
+weight: 40
+---
+The REST API briefly provided programmatic access to database usage and performance metrics as a test.
+
+However, these APIs do not provide accurate results and are not supported.  Do _not_ use them.
+---
+Title: Create and manage cloud accounts
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Cloud accounts specify which account to use when creating and modifying
+  infrastructure resources.
+linkTitle: Manage cloud accounts
+weight: 80
+draft: true
+---
+<!-- This article is removed since it was duplicated with the REST API reference. I decided to keep it as a draft just in case. -->
+
+You can use the Redis Cloud REST API to create and manage cloud accounts.
+
+These examples use the [`cURL` utility]({{< relref "/operate/rc/api/get-started/use-rest-api#use-the-curl-http-client" >}}); you can use any REST client to work with the Redis Cloud REST API.
+
+## Create a cloud account
+
+To create a cloud account, use the `POST /v1/cloud-accounts` endpoint.
+
+The created cloud account is defined by a JSON document that is sent as the body of the request.
+
+```sh
+POST https://[host]/v1/cloud-accounts
+{
+  "accessKeyId": "$ACCESS_KEY_ID",
+  "accessSecretKey": "$ACCESS_SECRET_KEY",
+  "consolePassword": "$CONSOLE_PASSWORD",
+  "consoleUsername": "$CONSOLE_USERNAME",
+  "name": "My new Cloud Account",
+  "provider": "AWS",
+  "signInLoginUrl": "https://$AWS_ACCOUNT_IDENTIFIER.signin.aws.amazon.com/console"
+}
+```
+
+The POST response is a JSON document that contains the `taskId`. You can use `GET /v1/tasks/<taskId>` to track the status of the cloud account creation.
+---
+Title: Database backup and import
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: When you create or update a database, you can specify the backup path.
+  The import API operation lets you import data from various source types and specified
+  locations.
+weight: 40
+---
+
+## Back up a database
+
+When you create or update a database, you can specify the (optional) `periodicBackupPath` parameter
+with a [backup path]({{< relref "/operate/rc/databases/back-up-data" >}}).
+This parameter enables periodic and on-demand backup operations for the specified database.
+
+{{<note>}}
+The number of database backups that can run simultaneously on a cluster is limited to 4 by default.
+{{</note>}}
+
+For Redis Cloud Pro databases, back up a database with [`POST /subscriptions/{subscriptionId}/databases/{databaseId}/backup`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/backupDatabase" >}}). For Redis Cloud Essentials databases, use [`POST /fixed/subscriptions/{subscriptionId}/databases/{databaseId}/backup`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/backupDatabase_1" >}}).
+On-demand database backup is an [asynchronous operation]({{< relref "/operate/rc/api/get-started/process-lifecycle" >}}).
+
+The backup database API does not require a body. Instead, the `periodicBackupPath` must be set to a valid path with available storage capacity to store the backup files for the specific database. You can set an `adhocBackupPath` in the body to specify a different backup location for this backup.
+
+See [Set up backup storage locations]({{< relref "/operate/rc/databases/back-up-data#set-up-backup-storage-locations" >}}) to learn how to configure your backup storage locations.
+
+## Import data to a database
+
+You can import data into an existing database from multiple storage sources, including AWS S3, Redis, and FTP.
+Database import is an [asynchronous operation]({{< relref "/operate/rc/api/get-started/process-lifecycle" >}}).
+
+Use [`POST /v1/subscriptions/{subscriptionId}/databases/{databaseId}/import`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Pro/operation/importDatabase" >}}) to import data to an existing Redis Cloud Pro database. For Redis Cloud Essentials databases, use [`POST /fixed/subscriptions/{subscriptionId}/databases/{databaseId}/backup`]({{< relref "/operate/rc/api/api-reference#tag/Databases-Essentials/operation/importDatabase_1" >}})
+
+The requirements for data import are:
+
+- The URI of the data
+    - The source URI must be accessible to the importing database
+    - The data format must be a Redis backup file or a Redis database
+- The subscription ID and database ID of the destination database
+
+The duration of the import process depends on the amount of data imported and the network bandwidth between the data source and the importing database.
+
+{{< warning >}}
+Data imported into an existing database overwrites any existing data.
+{{< /warning >}}
+
+You can specify the backup location with the `sourceType` and `importFromUri` values for these sources:
+
+|Data location|`sourceType`|`importFromUri`|
+|---|---|---|
+|Amazon AWS S3|aws-s3|s3://bucketname/[path/]filename.rdb[.gz]|
+|FTP|ftp|ftp://[username][:password]@[:port]/[path/]filename.rdb[.gz]|
+|Google Blob Storage|google-blob-storage|gs://bucketname/[path/]filename.rdb[.gz]|
+|Microsoft Azure Blob Storage|azure-blob-storage|abs://:storage_account_access_key@storage_account_name/[container/]filename.rdb[.gz]|
+|Redis server|redis|redis://[db_password]@[host]:[port]|
+|Web server|HTTP|HTTP://[username][:password]@[:port]/[path/]filename.rdb[.gz]|
+
+See [Import data]({{< relref "/operate/rc/databases/import-data" >}}) to learn how to set up your storage locations for data import.
+---
+Title: Estimate cost
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: How to evaluate the cost of a specific subscription or database without
+  changing existing resources.
+weight: 50
+---
+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.
+
+For example, the JSON body of a create subscription request body can include `"dryRun": true`:
+
+
+```json
+{
+  "name": "DryRun Cost evaluation subscription",
+  "dryRun": true,
+  "paymentMethodId": 8240,
+  "cloudProviders": [
+    {
+      "cloudAccountId": 16424,
+      "regions": [
+        {
+          "region": "us-east-1",
+          "networking": {
+            "deploymentCIDR": "10.0.0.0/24"
+          }
+        }
+      ]
+    }
+  ],
+  "databases": [
+    {
+      "name": "database-a",
+      "memoryLimitInGb": 0.1
+    }
+  ]
+}
+```
+
+## Executing a dry-run request
+
+Dry-run requests behave like regular requests except that no changes are made to existing resources.
+A dry-run request produces a cost evaluation report for the subscription.
+
+| API Operation | `"dryRun": false` (default) | `"dryRun": true` |
+|---|---|---|
+| **Create subscription** | Create a subscription | Returns a cost evaluation report of the planned subscription |
+| **Create database** | Creates a new database in the subscription | Returns a cost evaluation report for the relevant subscription |
+| **Update database** | Changes the specified database | Returns a cost evaluation report and evaluates whether the relevant subscription requires additional resources based on the database modification |
+
+
+### Example of a dry-run request & response
+
+This section demonstrates a complete example of a create subscription dry-run request and response.
+
+#### Dry-run request body
+
+Here is an example of the pricing request body:
+
+```json
+{
+  "name": "DryRun Cost evaluation subscription",
+  "dryRun": true,
+  "paymentMethodId": 8240,
+  "cloudProviders": [
+    {
+      "cloudAccountId": 16424,
+      "regions": [
+        {
+          "region": "us-east-1",
+          "networking": {
+            "deploymentCIDR": "10.0.0.0/24"
+          }
+        }
+      ]
+    }
+  ],
+  "databases": [
+    {
+      "name": "database-a",
+      "throughputMeasurement": {
+        "by": "operations-per-second",
+        "value": 1000
+      },
+      "memoryLimitInGb": 0.1
+      , "quantity": 3
+    },
+    {
+      "name": "database-b",
+      "throughputMeasurement": {
+        "by": "operations-per-second",
+        "value": 1000
+      },
+      "replication": false
+      ,"memoryLimitInGb": 0.1
+    },
+    {
+      "name": "database-c",
+      "throughputMeasurement": {
+        "by": "operations-per-second",
+        "value": 1000
+      },
+      "replication": true
+      ,"memoryLimitInGb": 5
+    },
+    {
+      "name": "database-d",
+      "throughputMeasurement": {
+        "by": "operations-per-second",
+        "value": 10000
+      },
+      "replication": false
+      ,"memoryLimitInGb": 12
+    },
+    {
+      "name": "database-e",
+      "throughputMeasurement": {
+        "by": "operations-per-second",
+        "value": 25000
+      },
+      "replication": true
+      ,"memoryLimitInGb": 25
+    }   ]
+}
+```
+
+1. The create subscription request contains the `"dryRun": true` parameter
+2. The databases array contains the definitions of multiple database templates, named `database-a`,  `database-b`, `database-c`, etc.
+3. Note that the databases differ in structure (size, throughput measurement, replication, quantity, etc.)
+
+#### Dry-run response
+
+Here is an example of the pricing response section for the above create subscription dry-run request:
+
+```shell
+{
+  "response": {
+    "resource": {
+      "pricing": [
+        {
+          "databaseName": "database-a",
+          "type": "Shards",
+          "typeDetails": "micro",
+          "quantity": 6,
+          "quantityMeasurement": "shards",
+          "pricePerUnit": 0.027,
+          "priceCurrency": "USD",
+          "pricePeriod": "hour"
+        },
+        {
+          "databaseName": "database-b",
+          "type": "Shards",
+          "typeDetails": "micro",
+          "quantity": 1,
+          "quantityMeasurement": "shards",
+          "pricePerUnit": 0.027,
+          "priceCurrency": "USD",
+          "pricePeriod": "hour"
+        },
+        {
+          "databaseName": "database-c",
+          "type": "Shards",
+          "typeDetails": "high-throughput",
+          "quantity": 2,
+          "quantityMeasurement": "shards",
+          "pricePerUnit": 0.124,
+          "priceCurrency": "USD",
+          "pricePeriod": "hour"
+        },
+        {
+          "databaseName": "database-d",
+          "type": "Shards",
+          "typeDetails": "small",
+          "quantity": 1,
+          "quantityMeasurement": "shards",
+          "pricePerUnit": 0.156,
+          "priceCurrency": "USD",
+          "pricePeriod": "hour"
+        },
+        {
+          "databaseName": "database-e",
+          "type": "Shards",
+          "typeDetails": "large",
+          "quantity": 2,
+          "quantityMeasurement": "shards",
+          "pricePerUnit": 0.293,
+          "priceCurrency": "USD",
+          "pricePeriod": "hour"
+        },
+        {
+          "type": "EBS Volume",
+          "quantity": 345,
+          "quantityMeasurement": "GB"
+        },
+        {
+          "type": "r5.xlarge",
+          "quantity": 3,
+          "quantityMeasurement": "instances"
+        }
+      ]
+    }
+  }  
+}
+```
+
+{{<note>}}Some of the response content was omitted for brevity.{{</note>}}
+
+1. The `pricing` array contains an element for each database, containing the database name and cost evaluation related to that database
+2. The database cost is measured in type and number of shards required for the specific database, as defined by the database template in the request. See [Cloud Pricing](https://redislabs.com/redis-enterprise-cloud/pricing)
+3. The cost evaluation for each database is measured in quantity of the specific shard type required by the requested database. The cost per shard is defined by the fields `pricePerUnit` (where `unit` is a shard of the specific type), `priceCurrency`, and `pricePeriod`
+4. For example, to calculate the total hourly cost of a database, use the following formula:  `pricePerUnit` * `quantity`
+5. The structure of the pricing response depends on the cloud account used by the request. There are two types of cloud accounts: a cloud account owned, named, and managed by the customer (AWS only) and one maintained by "Redis resources" cloud account (All cloud providers)
+6. For a customer-provided cloud account - The cost evaluation response lists the AWS resources required (storage and compute instances) without pricing data (which depends on the specific details of the customer's AWS account)
+7. For a Redis internal cloud account (defined a `cloudAccountId = 1` in the create subscription request) - The cost evaluation response includes a `MinimumPrice` element. This indicates the minimal hourly cost of the entire subscription. This minimum price will be charged if the sum of all shards for all the subscription's databases is less than the specified minimum price
+
+
+### Viewing actual subscription cost
+
+The `Get subscriptions` and `Get subscription by id` JSON response contains an element named `subscriptionPricing` that details the latest calculated cost of a subscription, grouped by shard type for all the databases in the subscription.
+---
+Title: REST API Examples
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: These examples show how to use the API and the results to expect.
+hideListLinks: false
+linkTitle: Examples
+weight: 30
+---
+
+---
+Title: Enable the API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Use the Redis Cloud dashboard to enable the REST API.
+weight: 10
+---
+
+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:
+
+1. Sign in to your [Redis Cloud account](https://cloud.redis.io) as an account owner.
+1. From the menu, choose **Access Management**.
+1. When the **Access Management** screen appears, select the **API Keys** tab.
+
+    {{<image filename="images/rc/access-management-api-keys-tab.png" width="75%" alt="Use the **API Keys** tab of the **Access Management** screen to manage your REST API keys." >}}
+
+1. 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.
+
+    {{<image filename="images/rc/button-copy.png" alt="Use the **Copy** button to copy the access key to the Clipboard." >}}
+
+    If you see an **Enable API** button, select it to enable the API and generate your API account key.
+
+    {{<image filename="images/rc/button-access-management-enable-api.png" alt="Use the **Enable API** button to enable the REST API for your account." >}}
+
+To authenticate REST API calls, you need to use both the API account key and an [API user key]({{< relref "/operate/rc/api/get-started/manage-api-keys#api-user-keys" >}}) to make API calls.
+
+Only account owners can see the access key in the account settings and give API access to other users.
+
+{{< warning >}}
+Make sure that you keep your access keys secret. Anyone who sends an API request with a valid access key can make changes to your account.
+{{< /warning >}}
+
+To manage your API keys or to limit IP addresses for user keys, see [Manage API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys.md" >}}).
+---
+Title: The API request lifecycle
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: API requests follow specific lifecycle phases and states, based on the
+  complexity and length of execution of the operation.
+linkTitle: API request lifecycle
+weight: 60
+---
+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]({{< relref "/operate/rc/api/get-started/enable-the-api.md" >}}), 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 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 performs its work.
+
+For operations that do not create or modify resources (such as most GET operations), the API is synchronous; that is, the response object reports the results of the request.
+
+Asynchronous operations have two main phases: processing and provisioning.  A resource is not available until both phases are complete.
+
+{{< image filename="/images/rv/api/processing-and-provisioning.png" >}}
+
+## Task processing
+
+During this phase, the request is received, evaluated, planned, and executed.
+
+### Use tasks to track requests
+
+The response objects for all asynchronous operations provide a `taskId` identifier that lets you track the progress of the underlying operation.
+
+You can query the `taskId` to track the state of a specific task using [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}).
+
+You can also query the state of all active tasks or recently completed tasks in your account using [`GET /tasks`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getAllTasks" >}}).
+
+### Task process states
+
+During the processing of a request, the task moves through these states:
+
+- `received` - Request is received and awaits processing.
+- `processing-in-progress` - A dedicated worker is processing the request.
+- `processing-completed` - Request processing succeeded and the request is being provisioned (or de-provisioned, depending on the specific request).
+    A `response` segment is included with the task status JSON response.
+    The response includes a `resourceId` for each resource that the request creates, such as Subscription or Database ID.
+- `processing-error` - Request processing failed.
+    A detailed cause or reason is included in the task status JSON response.
+
+{{< note >}}
+A task that reaches the `received` state cannot be cancelled and it will await completion (i.e. processing and provisioning). If you wish to undo an operation that was performed by a task, perform a compensating action (for example: delete a subscription that was created unintentionally)
+{{< /note >}}
+
+## Task provisioning phase
+
+When the processing phase succeeds and the task is in the `processing-completed` state, the provisioning phase starts.
+During the provisioning phase, the API orchestrates all of the infrastructure, resources, and dependencies required by the request.
+
+{{< note >}}
+The term "provisioning" refers to all infrastructure changes required in order to apply the request. This includes provisioning new or additional infrastructure.
+{{< /note >}}
+
+The provisioning phase may require several minutes to complete. You can query the resource identifier to track the progress of the provisioning phase.
+
+For example, when you provision a new subscription, use [`GET /v1/subscriptions/{subscriptionId}`]({{< relref "/operate/rc/api/api-reference#tag/Subscriptions-Pro/operation/getSubscriptionById" >}}), where the `{subscriptionId}` is the resource ID that you receive when the task is in the `processing-completed` state.
+
+### Provisioning state values
+
+During the provisioning of a resource (such as a subscription, database, or cloud account) the resource transitions through these states:
+
+- `pending` - Provisioning is in progress.
+- `active` - Provisioning completed successfully.
+- `deleting` - De-provisioning and deletion is in progress.
+- `error` - An error occurred during the provisioning phase, including the details of the error.
+
+## Process limitations
+
+The following limitations apply to asynchronous operations:
+
+- For each account, only one operation is **processed** concurrently. When multiple tasks are sent for the same account, they will be received and processed one after the other.
+- The provisioning phase can be performed in parallel except:
+    - Subscription creation, update, and deletion: You cannot change (make non-active) more than three subscriptions at the same time.
+    - Database creation in an existing subscription: This can cause the subscription state to change from `active` to `pending`
+    during  database provisioning in cases such as database sizing that requires cluster resizing or updating cluster metadata.
+
+- For example:
+    - Concurrently sending multiple "create database" tasks will cause each task to be in the `received` state, awaiting processing.
+    - When the first task starts processing it will be moved to the `processing-in-progress` state.
+    - When that first task is completed (either `processing-completed` or `processing-error`), the second task will start processing, and so on.
+    - Typically, the processing phase is much faster than the provisioning phase, and multiple tasks will be in provisioned concurrently.
+    - If the creation of the database requires an update to the subscription, the subscription state is set to `pending`.
+    When you create multiple databases one after the other, we recommend that you check the subscription state after the processing phase of each database create request.
+    If the subscription is in `pending` state you must wait for the subscription changes to complete and the subscription state to return to `active`.
+---
+Title: Manage API keys
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: How to use the Redis Cloud console to create and manage API user
+  keys for your account's team owners
+weight: 20
+---
+Every REST API request must include the following API keys:
+
+1. The **Account key** identifies the account associated with the Redis Cloud subscription.
+
+2. 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:
+
+1. Sign in to your [Redis Cloud account](https://cloud.redis.io) as an account owner.
+
+1. From the menu, choose **Access Management** and then select the **API Keys** tab.
+
+    {{<image filename="images/rc/access-management-api-keys-tab.png" width="75%" alt="Use the **API Keys** tab of the **Access Management** screen to manage your REST API keys." >}}
+
+If an **Enable API** button appears, select it to [enable the REST API]({{< relref "/operate/rc/api/get-started/enable-the-api.md" >}}) for your account.
+
+{{<image filename="images/rc/button-access-management-enable-api.png" alt="Use the **Enable API** button to enable the REST API for your account." >}}
+
+## API account key
+
+The **API account key** is used as the value of the `x-api-key` HTTP header in order to authenticate a REST API request.
+
+By default, the **API account key** is masked; that is, it is obscured for security reasons.  You can use the **Show** button to display the key and the **Hide** button to mask it.
+
+{{<image filename="images/rc/button-access-management-show-key.png#no-click" alt="The **Show** button displays the account key." class="inline" >}} &nbsp; {{<image filename="images/rc/button-access-management-hide-key.png#no-click" alt="The **Hide** button masks the account key." class="inline">}}
+
+The **Copy** button copies the account key to the Clipboard.
+
+{{<image filename="images/rc/button-copy.png" alt="The **Copy** button copies the account key to the Clipboard." >}}
+
+## API user keys
+
+**API user keys** (also known as _secret keys_) are used as the value of the `x-api-secret-key` HTTP header used to authenticate a REST API request.
+
+In this context, _user_ refers to the account used to sign in to the Redis Cloud console.  Users must have an owner (read-write) or viewer (read-only) role.
+
+Users can have more than one user key; however, users should not share user keys.
+
+### Create a new user key {#secret}
+
+Use the **Add** button to create a new user key.
+
+{{<image filename="images/rc/icon-add.png" width="30px" alt="Use the **Add** button to begin creating a new user key." >}}
+
+When you do this, you're prompted for the **Key name** and the associated **User name**.
+
+{{<image filename="images/rc/access-management-user-key-add.png" alt="When you add a user key, you're prompted to specify the name of the key and the asscoiated user." >}}
+
+The key name:
+
+- Must be between 10 and 50 characters long
+- Can contain alphanumeric characters, hyphens, and underscores. Spaces are not allowed.
+
+The selected user must have an owner, viewer, or logs viewer role.
+
+Select **Create** to create the new key.  
+
+{{<image filename="images/rc/button-access-management-user-key-create.png" alt="Use the **Create** button to create the new user key." >}}
+
+When you do this, the **API user key** dialog appears.
+
+{{<image filename="images/rc/access-management-create-user-key.png" width="75%" alt="The **API user key** dialog lets you copy the value of the new key to the Clipboard." >}}<br/>
+
+{{<warning>}}
+This is the only time the value of the user key is available.  Save it to a secure location before closing the dialog box.  <br/><br/>
+If you lose the user key value, it cannot be retrieved.  If this happens, create a new key to replace the lost one.
+{{</warning>}}
+
+The **Finish** button is inactive until you copy the key to the clipboard. After you save the user key, you can also select **Copy account key** to save the account key.
+
+### Delete a user key
+
+To delete a user key:
+
+1.  Use the **API Keys** tab of the **Access Management** screen to locate the target key. Hover over the key to display the **Delete** button.
+
+    {{<image filename="images/rc/access-management-api-user-key-delete.png" alt="The **Delete** button appears to the right of the selected user key." >}}<br/>
+
+2.  Select the **Delete** button.
+
+    {{<image filename="images/rc/icon-delete-teal.png" width="36px" alt="Select the **Delete** button to begin deleting the selected user key." >}}
+
+3.  This displays the **Delete API secret key** dialog box.  
+
+    {{<image filename="images/rc/access-management-delete-api-secret-key.png" width="50%" alt="The **Delete** button appears to the right of the selected user key." >}}<br/>
+
+    Select the **Delete** button to confirm.
+
+### Manage CIDR allow list
+
+By default, REST API requests are allowed from all IP addresses.  To limit access to specific addresses, define a CIDR allow list for the user key.
+
+To manage the CIDR allow list:
+
+1.  Use the **API Keys** tab of the **Access Management** screen to locate the target key. Hover over the key to display the **Manage** link.
+
+    {{<image filename="images/rc/access-management-api-user-key-delete.png" alt="The **Manage** link appears to the right of the user name for the selected user key." >}}
+
+2.  Select the **Manage** link in the **CIDR allow list** column; this displays the **Manage CIDR allow list** dialog box.
+
+    {{<image filename="images/rc/access-management-user-key-manage-cidr.png" width="50%" alt="Select the **Manage** link to define the **CIDR allow list** dialog." >}}
+
+3.  Enter each allowed IP address in [CIDR format](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation) (example: `127.1.0.0/24`) and then select the **Save** button.
+
+    {{<image filename="images/rc/button-access-management-cidr-rule-save.png" width="36px" alt="Use the **Save** button to save a CIDR allow list rule." >}}
+
+    Use the **Add CIDR rule** button to add additional addresses to the list.
+
+    {{<image filename="images/rc/button-access-management-cidr-rule-add.png" alt="Use the **Add Rule** button to add a new address to the CIDR allow list." >}}
+
+    Use the **Edit** button to change the address for a rule or the **Delete button** to remove a rule.
+
+    {{<image filename="images/rc/icon-edit.png#no-click" width="36px" alt="Use the **Edit** button to change the address for a CIDR allow list rule." class="inline">}} &nbsp; {{<image filename="images/rc/icon-delete-teal.png#no-click" width="36px" alt="Use the **Delete** button to remove an address from the CIDR allow list." class="inline" >}} 
+---
+Title: Manage API tasks
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: A task is an API operation that is performed asynchronously because it
+  exceeds the time allowed for the synchronous request/response model.
+linkTitle: Manage tasks
+weight: 50
+---
+
+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]({{< relref "/operate/rc/api/get-started/process-lifecycle" >}}).
+
+## Task information
+
+When you request an asynchronous operation, the response to the request includes the task status and additional information about the task:
+
+```json
+{
+  "taskId": "f3ec0e7b-0548-46e3-82f3-1977012ec738",
+  "commandType": "subscriptionCreateRequest",
+  "status": "received",
+  "description": "Task request received and is being queued for processing.",
+  "timestamp": "2019-08-08T09:07:39.826Z",
+  "_links": {
+    "task": {
+      "href": "https://api.redislabs.com/v1/tasks/f3ec0e7b-0548-46e3-82f3-1977012ec738",
+      "title": "getTaskStatusUpdates",
+      "type": "GET"
+    }
+  }
+}
+```
+
+Where:
+
+- `taskId` - The unique identifier (UUID) of the specific task
+- `commandType` - The request (command) type
+- `status` - The [status]({{< relref "/operate/rc/api/get-started/process-lifecycle#task-process-states" >}}) of the task
+- `description` - A description of the status
+- `timestamp` - The time of the response in ISO-8601 date format and in the UTC timezone
+- `_links` - URI links to resources related to the task including:
+    - A link to itself
+    - Additional links based on the context of the response
+
+## Task status updates
+
+With the task ID, you can query the task status for updates and progress information.
+The response in the above example shows a URL with the title `getTaskStatusUpdates`.
+The URL in the `href` property returns updates for the specified task.
+
+Use [`GET /v1/tasks/{taskId}`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getTaskById" >}}) to check the task status.
+
+This endpoint returns information about the queried task.
+
+```json
+{
+  "taskId": "36d4b04d-72d4-4404-8600-a223120a553e",
+  "commandType": "subscriptionCreateRequest",
+  "status": "processing-completed",
+  "description": "Request processing completed successfully and its resources are now being provisioned / de-provisioned.",
+  "timestamp": "2019-08-08T06:49:15.929Z",
+  "response": {
+    "resourceId": 77899
+  },
+  "_links": {
+    "resource": {
+      "href": "https://api.redislabs.com/v1/subscriptions/77899",
+      "title": "getSubscriptionInformation",
+      "type": "GET"
+    },
+    "self": {
+      "href": "https://api.redislabs.com/v1/tasks/36d4b04d-72d4-4404-8600-a223120a553e",
+      "type": "GET"
+    }
+  }
+}
+```
+
+This response example shows:
+
+- The `status` value is `"processing-completed"`.
+- The `response` field contains the resource identifier of the subscription resource changed by this task.
+- The `links` array contains another `getSubscriptionInformation` URL that links to the newly created subscription.
+    This link queries the subscription status during [provisioning]({{< relref "/operate/rc/api/get-started/process-lifecycle.md" >}}))
+
+### Tasks list
+
+You can use the API operation [`GET /tasks`]({{< relref "/operate/rc/api/api-reference#tag/Tasks/operation/getAllTasks" >}}) to list the recently submitted and completed tasks for the current account.
+
+This API operation returns a list of tasks for the current account, sorted by most recent status update.
+
+The result returns all the tasks submitted during the past 10 days.
+---
+Title: Use the REST API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: How to use the API with various tools (especially `cURL`)
+linkTitle: Use the API
+weight: 40
+---
+You can access and use the API endpoint URI ([`https://api.redislabs.com/v1`](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.
+{{< /note >}}
+
+## Swagger user interface
+
+The [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html) is useful for initial introduction and for learning about API operations, models, and simulated usage.
+
+### Authenticate to Swagger
+
+To authenticate to the Swagger UI:
+
+1. Open the [Swagger UI](https://api.redislabs.com/v1/swagger-ui.html) page in a browser.
+
+    {{< image filename="/images/rv/api/swagger-authorize-and-try-now.png" >}}
+
+1. Select `Authorize`.
+
+    The **Available Authorizations** box is shown with the headers and values that are used for authentication in all API interactions with Swagger.
+
+    {{< image filename="/images/rv/api/swagger-authorizations.png" >}}
+
+1. Insert the API Key values:
+
+    1. Enter the [Account Key]({{< relref "/operate/rc/api/get-started/enable-the-api.md" >}}) as the `x-api-key` value and then choose **Authorize**.
+    1. Enter the [Secret Key]({{< relref "/operate/rc/api/get-started/manage-api-keys.md" >}}) as the `x-api-secret-key` value and then choose **Authorize**.
+    1. Select **Close**.
+
+{{< note >}}
+The key values are not saved when you refresh the page.
+{{< /note >}}
+
+When authorization is successful, the lock icon displays a closed lock.
+
+{{< image filename="/images/rv/api/swagger-closed-lock.png" >}}
+
+### Make API requests
+
+After you complete the authorization in the Swagger UI, you can make an API request:
+
+1. Open an action category and select an API operation.
+
+    For example, in the `Account` category select the `GET /payment-methods` operation.
+
+    {{< image filename="/images/rv/api/swagger-payment-methods-try-it-now.png" >}}
+
+1. Select **Try it out** and then select **Execute**.
+
+    The API response is shown in the **Responses** section of the API operation.
+    The results include an example of how to execute the same operation in a standard command-line utility using `cURL`.
+
+    {{< image filename="/images/rv/api/swagger-query-results.png" >}}
+
+#### Inputs for operations in Swagger
+
+Some API operations require input, such as:
+
+- **Parameters** - When an API operation requires URI parameters, such as "get subscription by subscription id", you can enter the values for the parameters.
+
+    {{< image filename="/images/rv/api/swagger-parameters.png" >}}
+
+- **JSON Request Body** - For API operations that require a JSON request body, you can either:
+
+    - Use the **model display** to write the request based on the expected JSON structure and parameters.
+
+        {{< image filename="/images/rv/api/swagger-post-body-model.png" >}}
+
+    - Use the **Try it now** sample JSON created by Swagger as a base template that you can edit and execute.
+
+        {{< image filename="/images/rv/api/swagger-post-edit-body.png" >}}
+
+{{< warning >}}
+The Swagger UI generates default JSON examples for `POST` and `PUT` operations. You should modify these examples to suit your specific needs and account settings. The examples will fail if used as-is. <br/><br/>For more examples showing how to use specific endpoints, see [REST API examples]({{< relref "/operate/rc/api/examples" >}}).
+{{< /warning >}}
+
+## Use the `cURL` HTTP client
+
+`cURL` is a popular command line tool used to perform HTTP requests,
+either as individual commands or within shell scripts (such as bash and zsh).
+For an introduction, see [How to start using cURL and why: a hands-on introduction](https://www.freecodecamp.org/news/how-to-start-using-curl-and-why-a-hands-on-introduction-ea1c913caaaa/).
+
+{{% info %}}
+Our examples use `cURL` and Linux shell scripts to demonstrate the API; you can use any standard REST client or library.<br/><br/>
+Our examples also use `jq`, [a JSON parser](https://stedolan.github.io/jq/).  Use your package manager to install it  (Example: `sudo apt install jq`)
+{{% /info %}}
+
+For example, a standard API call to get System Log information looks like this in `cURL`:
+
+```bash
+curl -s -X GET "https://$HOST/logs" \
+    -H "accept: application/json" \
+    -H "x-api-key: $ACCOUNT_KEY" \
+    -H "x-api-secret-key: $SECRET_KEY" \
+    | jq -r .
+```
+
+- The example expects several variables to be set in the Linux shell:
+
+    - **$HOST** - The URI of the REST API host (`api.redislabs.com/v1`)
+    - **$ACCOUNT_KEY** - The [account key value]({{< relref "/operate/rc/api/get-started/enable-the-api.md" >}})
+    - **$SECRET_KEY** - The personal [secret key value]({{< relref "/operate/rc/api/get-started/manage-api-keys.md" >}})
+
+- The line "`| jq -r .`" means that the HTTP response will be piped (forwarded) to the `jq` JSON parser, and it will display only the raw output ("`-r`") of the root element ("`.`")
+- You can set the variables using shell commands like the following:
+
+```shell
+{{% embed-code "rv/api/05-set-variables.sh" %}}
+```
+---
+Title: Get started with the REST API
+alwaysopen: true
+categories:
+- docs
+- operate
+- rc
+description: Describes how Redis Cloud REST API uses keys to authenticate and authorize
+  access.
+hideListLinks: true
+linkTitle: Get started
+weight: 10
+---
+
+To use the Redis Cloud REST API, you need to:
+
+- Enable the API
+- Create an account key
+- Create a user key
+- Collect endpoint details
+
+To use the keys to authenticate and authorize your request, include the keys with the request headers:
+
+| Key name         | HTTP&nbsp;header&nbsp;name   |Description                                            |
+| -----------      | -------------------| ----------------------------------------------------- |
+| Account&nbsp;key | `x-api-key`        | Account-level key assigned to all users of an account |
+| User key       | <nobr>`x-api-secret-key`</nobr> | Personal key associated with a specific user and possibly limited to certain IP ranges                      |
+
+## Enable the API
+
+The API is disabled on all accounts by default. You must [enable the API]({{< relref "/operate/rc/api/get-started/enable-the-api" >}}) before you can use it.
+
+## Account key
+
+The account key identifies your specific account when you perform an API request.  This is the account responsible for your subscription.
+
+{{< note >}}
+An account key is an account-level secret. Do not share this key with anyone not authorized to use the account.
+{{< /note >}}
+
+You create the account key once when enabling API access.
+
+If you need to change or delete your account key, please [contact support](https://redislabs.com/company/support/).
+
+## User key
+
+The user key is a personal key that belongs to a specific user having the **Owner**, **Viewer**, or **Logs viewer** role.  User keys are assigned to users when they're created.  Keys can belong to only one user; however, a user may have multiple keys.
+
+You can view keys or copy their values _only_ during the [creation process]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}}).
+
+{{< note >}}
+User keys are personal secrets. Do not share them.
+{{< /note >}}
+
+Individual owners can [generate multiple user keys]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}})
+for themselves, for separate apps, or for other owners, viewers, or log viewers within the same account.
+
+Use key names to uniquely associate specific API requests to individual users or apps.
+
+Doing so lets you [audit API requests]({{< relref "/operate/rc/api/examples/audit-system-logs" >}}) using the system log, which tracks the key used to authenticate each request.
+
+## Authentication using API keys
+
+Every API request must use the **account key** and a **user key** to authenticate.
+
+The keys are provided as [HTTP request headers]({{< relref "/operate/rc/api/get-started/use-rest-api#use-the-curl-http-client" >}}), shown earlier.
+
+## Authenticate a request
+
+An API request successfully authenticates when:
+
+1. The account and user keys are valid and properly defined in the HTTP request headers.
+1. The user key is associated with the same account as the account key.
+1. The request originates from a valid source IP address, as defined in a [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) allow list associated with the user key.
+
+    This requirement applies when you've [defined a CIDR allow list]({{< relref "/operate/rc/api/get-started/manage-api-keys#manage-cidr-allow-list" >}}) for the secret key.
+
+## More info
+
+To learn more, see:
+
+- [Manage API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys" >}})
+- [Use the API]({{< relref "/operate/rc/api/get-started/use-rest-api" >}})
+- [Full API reference]({{< relref "/operate/rc/api/api-reference" >}})
+---
+Title: Redis Cloud REST API
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes the Redis Cloud REST API and links to additional info
+hideListLinks: true
+linkTitle: REST API
+weight: 80
+---
+
+The [Redis Cloud REST API]({{< relref "/operate/rc/api/api-reference" >}}) helps you manage your Redis Cloud databases programmatically.
+
+You can use the API to:
+ 
+- Create or manage databases  
+- Define or change hosting credentials    
+- Audit access via logs  
+- Backup or import databases  
+
+## Get started
+
+1. [Enable the API]({{< relref "/operate/rc/api/get-started/enable-the-api.md" >}})
+1. [Authenticate and authorize]({{< relref "/operate/rc/api/get-started" >}})
+1. [Create API keys]({{< relref "/operate/rc/api/get-started/manage-api-keys.md" >}})
+1. [Use the API]({{< relref "/operate/rc/api/get-started/use-rest-api.md" >}})
+1. [Learn the API lifecycle]({{< relref "/operate/rc/api/get-started/process-lifecycle.md" >}})
+1. [Create and manage subscriptions]({{< relref "/operate/rc/api/examples/manage-subscriptions.md" >}})
+
+## Examples
+
+1. [Manage subscriptions]({{< relref "/operate/rc/api/examples/manage-subscriptions.md" >}})
+1. Database examples
+    - [Create and manage databases]({{< relref "/operate/rc/api/examples/create-database" >}})
+    - [Back up and import data]({{< relref "/operate/rc/api/examples/back-up-and-import-data.md" >}})
+1. [Estimate costs]({{< relref "/operate/rc/api/examples/dryrun-cost-estimates.md" >}})
+    
+## More info
+
+- Use the [Redis Cloud API]({{< relref "/operate/rc/api/get-started/use-rest-api.md" >}})
+- [Full API Reference]({{< relref "/operate/rc/api/api-reference" >}})
+- Secure [authentication and authorization]({{< relref "/operate/rc/api/get-started" >}})
+---
+Title: API Reference
+layout: apireference
+type: page
+---
+---
+Title: Archive
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes where to view the archive of Redis Cloud documentation.
+linkTitle: Archive
+weight: 99
+draft: true
+---
+
+Previous versions of Redis Cloud documentation are available on the [Redis Cloud documentation archive](https://docs.redis.com/2024-04-07/rc/).  
+
+---
+Title: Billing & payments
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: Describes how to view billing transactions and manage payment methods
+  for Redis Cloud subscriptions.
+linkTitle: Billing & payments
+weight: 39
+---
+
+The **Billing & Payments** screen:
+
+- Shows recent transactions for your account
+- Helps you manage your payment methods
+- Applies coupon credits to your account
+
+{{<image filename="images/rc/billing-billing-history-tab.png" alt="The Billing & Payments screen shows billing transactions and manage payment methods." >}}
+
+The following tabs are available:
+
+- The **Billing History** tab displays recent charges and payments.  Each transaction includes the following details:
+
+    | Detail | Description |
+    |:-------|:------------|
+    | Date   | Date the transaction was recorded |
+    | Description | Description of the transaction |
+    | Reference | Reference number |
+    | Amount    | Transaction amount |
+
+    Billing details may vary between regions.
+
+    You can [download invoices](#download-invoice) on this tab.
+
+    A **Pay Now** button appears in selected regions.
+
+    {{<image filename="images/rc/billing-payments-pay-now.png" width="100px" alt="Use the Pay Now button to Pay your invoice in selected regions." >}} 
+    
+    Select this button to pay your invoice.
+
+- The **Payment Methods** tab lists your current payment methods.  You can add a new payment method, associate different payment methods with specific subscriptions, and remove payment methods.
+
+    {{<image filename="images/rc/billing-payment-method-tab.png" alt="The Payments Methods tab helps you manage payments for your subscriptions." >}}
+
+    Select **Add credit card** to enter new credit card details, or **Add marketplace account** to add a [Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) or [AWS Marketplace]({{< relref "/operate/rc/cloud-integrations/aws-marketplace/" >}}) account.
+
+- The **Credits** tab shows coupon credits that have been applied to your account, if any.
+
+    {{<image filename="images/rc/billing-payments-credits-tab.png" alt="The Credits tab lets you apply coupons to your account and shows credits that have already been applied." >}}
+
+    | Detail | Description |
+    |:-------|:------------|
+    | Code   | Coupon code |
+    | Coupon Amount | Amount credited to your account |
+    | Current Balance | Amount left |
+    | Date added | Date applied to your account |
+    | Expiration Date | Date the amount expires |
+
+    You can [apply a coupon](#apply-coupon) on this tab.
+
+## Download invoice
+
+To download an invoice:
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments**.
+
+2.  From the **Billing History** tab, locate and select the invoice.
+
+3.  Select the **Download invoice** icon displayed to the right of the invoice amount.
+
+    {{<image filename="images/rc/icon-billing-download.png" width="50px" alt="Use the download icon to download a PDF for the selected invoice." >}}
+
+The invoice is downloaded as an Acrobat PDF file.  Use your browser's download features to manage the file.
+
+## Add credit card
+
+To add a new credit card:
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments > Payment Methods**.
+
+2.  Select **Add credit card** and add the credit card details.
+
+    {{< embed-md "rc-credit-card-add.md" >}} 
+
+3.  Select the **Add Credit Card** button to save your changes.
+
+    {{<image filename="images/rc/button-billing-save-card.png" width="150px" alt="Use the Save Card button to save new payment details." >}}
+
+## Add marketplace account
+
+If you have a [Google Cloud Marketplace]({{< relref "/operate/rc/cloud-integrations/gcp-marketplace/" >}}) or [AWS Marketplace]({{< relref "/operate/rc/cloud-integrations/aws-marketplace/" >}}) account already associated with another Redis Account that you own, you can add it to your current account. 
+
+{{< embed-md "rc-marketplace-account-add.md" >}}
+
+## Apply coupon
+
+Coupons apply credits to your Redis Cloud account.  To redeem a coupon:
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), select **Billing & Payments** and then select the **Credits** tab.
+
+2.  Enter the coupon code and then select the **Apply** button.
+
+    {{<image filename="images/rc/button-billing-payments-apply.png" width="80px" alt="Use the Apply button to redeem a coupon." >}}
+
+    The value of the coupon is applied to your account when accepted.  
+
+For help, contact [Support](https://redis.io/support/).
+
+{{< note >}}
+Generally, charges are non-refundable.
+
+For any special circumstances that may warrant a refund, please contact [Support](https://redis.io/support/) and be sure to provide detail about the reasons for the refund request.
+{{< /note >}}
+
+## Download cost report
+
+{{< embed-md "rc-cost-report-csv.md" >}}---
+Title: Redis Cloud
+alwaysopen: false
+categories:
+- docs
+- operate
+- rc
+description: The fastest way to set up Redis - a fully managed Redis database on major public cloud services.
+hideListLinks: true
+weight: 20
+---
+[Redis Cloud](https://redis.io/cloud/) is a fully managed database-as-a-service that brings the speed and reliability of Redis to the cloud, offering seamless scalability and high availability for modern applications.
+
+With Redis Cloud, you get all of the features of Redis Software, including:
+- [Redis]({{< relref "/develop/" >}}) and [Redis Stack]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}}) support
+- Linear scalability
+- Instant failover, backups, and recovery
+- Predictable performance
+- 24/7 monitoring and support
+
+[Try Redis Cloud](https://redis.io/try-free/) to set up your free 30MB database.
+
+## Get started
+Use the [Quick start]({{< relref "/operate/rc/rc-quickstart" >}}) to learn how to create your free database.
+- [Connect with redis-cli]({{< relref "/operate/rc/rc-quickstart#using-rediscli" >}})
+- [Connect with Redis client]({{< relref "/operate/rc/rc-quickstart#using-redis-client" >}})
+- [Connect with Redis Insight]({{< relref "/operate/rc/rc-quickstart#using-redisinsight" >}})
+
+## Databases
+Create and manage [Redis databases]({{< relref "/operate/rc/databases" >}}) in the cloud.
+- [Create database]({{< relref "/operate/rc/databases/create-database" >}})
+- [View and edit databases]({{< relref "/operate/rc/databases/view-edit-database" >}})
+- [Monitor performance]({{< relref "/operate/rc/databases/monitor-performance" >}})
+- [Manage databases]({{< relref "/operate/rc/databases/configuration" >}})
+- [Redis commands]({{< relref "/commands" >}}) & [compatibility]({{< relref "/operate/rc/compatibility" >}})
+
+## Subscriptions
+Learn about the [types of subscriptions]({{< relref "/operate/rc/subscriptions" >}}).
+- [View and upgrade Essentials plan]({{< relref "/operate/rc/subscriptions/view-essentials-subscription" >}})
+- [Essentials plans]({{< relref "/operate/rc/subscriptions/view-essentials-subscription/essentials-plan-details" >}})
+- [View and edit Pro plan]({{< relref "/operate/rc/subscriptions/view-pro-subscription" >}})
+
+## Accounts & settings
+Manage Redis Cloud [accounts and settings]({{< relref "/operate/rc/accounts" >}}).
+- [Billing and payments]({{< relref "/operate/rc/billing-and-payments" >}})
+- [Manage marketplace integrations]({{< relref "/operate/rc/cloud-integrations" >}})
+
+## Security
+Manage [secure connections]({{< relref "/operate/rc/security" >}}) to cloud databases.
+- [Access management]({{< relref "/operate/rc/security/access-control/access-management" >}}) for Redis Cloud console security and account management
+- [Cloud database security]({{< relref "/operate/rc/security/database-security" >}})
+- [Multi-factor authentication]({{< relref "/operate/rc/security/access-control/multi-factor-authentication" >}})
+- [Single sign-on]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) and [social login]({{< relref "/operate/rc/security/access-control/social-login" >}})
+- [Data access control]({{< relref "/operate/rc/security/access-control/data-access-control" >}})
+
+## REST API
+Use the [REST API]({{< relref "/operate/rc/api" >}}) to manage the database.
+- [Get started with the REST API]({{< relref "/operate/rc/api/get-started" >}})
+- REST API [reference]({{< relref "/operate/rc/api/api-reference" >}}) & [examples]({{< relref "/operate/rc/api/examples" >}})
+
+
+## Related info
+- [Redis Enterprise Software]({{< relref "/operate/rs" >}})
+- [Develop with Redis]({{< relref "/develop/" >}})
+- [Redis Stack]({{< relref "/operate/oss_and_stack/stack-with-enterprise" >}})
+- [Glossary]({{< relref "/glossary" >}})
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Upgrade a Redis Open Source cluster to Redis 8
+linkTitle: Redis cluster
+title: Upgrade a Redis cluster to Redis 8
+weight: 30
+---
+
+{{< 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 >}}
+</br>
+{{< 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.
+{{< /note >}}
+
+Follow these instructions to upgrade a Redis cluster. This guide assumes you have installed Redis using one of the supported methods listed [here]({{< relref "/operate/oss_and_stack/install/archive" >}}).
+
+### Save your current data
+
+Before upgrading, create a snapshot of your current dataset on each node (identified by its port) using the following command:
+
+```bash
+redis-cli -p <port> SAVE
+```
+
+Repeat for every node in your cluster, both masters and replicas.
+
+This creates or updates an `RDB` file, for example `dump.rdb`, in the node's Redis data directory. If you use AOF persistence, the files will be named `appendonly.aof.*` and they will be written in the `appendonlydir` directory inside the data directory. The AOF-related directory and file names are the defaults. Use the names defined in your `redis.conf` file if different from the defaults.
+
+Use the following command on each node to identify where your data directories are located:
+
+```bash
+redis-cli -p <port> CONFIG GET dir
+```
+
+Make a copy of the files contained in each of those directories before proceeding.
+
+### Upgrade Redis nodes
+
+Upgrade each node one at a time, starting with the replicas, using these steps:
+
+1. Stop the current version of Redis Open Source or Redis Stack server.
+1. Follow the installation steps that correspond to your [Redis distribution]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) to install Redis 8.
+1. Start Redis 8 if it didn't start automatically.
+
+### Restore from saved files (if necessary)
+
+If necessary, restore the saved files to their original locations on each node. Then restart Redis on each node.
+
+{{< warning >}}
+Redis Query Engine won't be fully operational until all master shards have completed their upgrades.
+Any queries sent during the upgrade process will either return errors or a message such as "Waiting for all nodes to connect".
+{{< /warning >}}
+
+### Verify the upgrade
+
+```bash
+redis-cli -p <port> INFO server | grep redis_version
+redis-cli -p <port> cluster info
+redis-cli --cluster check <IP address>:<port>
+```
+
+You should also verify that your data is accessible and that your clients can connect successfully.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Upgrade a standalone instance of Redis Open Source or Redis Stack to Redis 8
+linkTitle: Standalone (single node)
+title: Upgrade a standalone Redis instance to Redis 8
+weight: 20
+---
+{{< 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 >}}
+
+{{< 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.
+{{< /note >}}
+
+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]({{< relref "/operate/oss_and_stack/install/archive" >}}).
+
+### Save your current data
+
+Before upgrading, create a snapshot of your current dataset using the following command:
+
+```bash
+redis-cli SAVE
+```
+
+This creates or updates an `RDB` file, for example `dump.rdb`, in your Redis data directory. If you use AOF persistence, the files will be named `appendonly.aof.*` and they will be written in the `appendonlydir` directory inside the data directory. The AOF-related directory and file names are the defaults. Use the names defined in your `redis.conf` file if different from the defaults.
+
+Use the following command to identify where your data directory is located:
+
+```bash
+redis-cli CONFIG GET dir
+```
+
+Make a copy of these files before proceeding:
+
+```bash
+cp -r /path/to/redis-data-dir/ /path/to/backup/
+```
+
+### Upgrade Redis
+
+Follow these steps to upgrade Redis.
+
+1. Stop the current version of Redis Open Source or Redis Stack server.
+1. Follow the installation steps that correspond to your [Redis distribution]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) to install Redis 8.
+1. Start Redis 8 if it didn't start automatically.
+
+### Restore from saved files (if necessary)
+
+If Redis fails to start properly or if data is missing after the upgrade, restore from your backup.
+
+1. Stop the Redis server.
+2. Copy the backup file back into the the Redis data directory:
+   ```bash
+   cp -r /path/to/backup/ /path/to/redis-data-dir/
+   ```
+3. Start Redis again and verify data is restored:
+   ```bash
+   redis-cli INFO persistence
+   ```
+
+### Verify the upgrade
+
+Use the following command to confirm you're running Redis 8:
+
+```bash
+redis-cli INFO server | grep redis_version
+```
+
+You should also verify that your data is accessible and that your clients can connect successfully.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Upgrade Redis Open Source
+linkTitle: Upgrade Redis Open Source
+stack: true
+title: Upgrade Redis Open Source
+weight: 10
+---
+
+Upgrade Redis Open Source to version 8 from version 7.x with or without modules or from Redis Stack 7.2 and 7.4.
+
+<hr/>---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: AlmaLinux/Rocky 8.10
+title: Build and run Redis Open Source on AlmaLinux/Rocky Linux 8.10
+weight: 5
+---
+
+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
+{{< /note >}}
+
+## 1. Prepare the system
+
+{{< note >}}
+For 8.10-minimal, you'll need to install `sudo` and `dnf` as follows:
+
+```bash
+microdnf install dnf sudo -y
+```
+
+For 8.10 (regular), you'll need to install `sudo` as follows:
+
+```bash
+dnf install sudo -y
+```
+{{< /note >}}
+
+Clean the package metadata, enable required repositories, and install development tools:
+
+```bash
+sudo dnf clean all
+
+# Add GoReleaser repo
+sudo tee /etc/yum.repos.d/goreleaser.repo > /dev/null <<EOF
+[goreleaser]
+name=GoReleaser
+baseurl=https://repo.goreleaser.com/yum/
+enabled=1
+gpgcheck=0
+EOF
+
+sudo dnf update -y
+sudo dnf groupinstall "Development Tools" -y
+sudo dnf config-manager --set-enabled powertools
+sudo dnf install -y epel-release
+```
+
+## 2. Install required packages
+
+Install the build dependencies, Python 3.11, and supporting tools:
+
+```bash
+sudo dnf install -y --nobest --skip-broken \
+    pkg-config \
+    wget \
+    gcc-toolset-13-gcc \
+    gcc-toolset-13-gcc-c++ \
+    git \
+    make \
+    openssl \
+    openssl-devel \
+    python3.11 \
+    python3.11-pip \
+    python3.11-devel \
+    unzip \
+    rsync \
+    clang \
+    curl \
+    libtool \
+    automake \
+    autoconf \
+    jq \
+    systemd-devel
+```
+
+Create a Python virtual environment:
+
+```bash
+python3.11 -m venv /opt/venv
+```
+
+Enable the GCC toolset:
+
+```bash
+sudo cp /opt/rh/gcc-toolset-13/enable /etc/profile.d/gcc-toolset-13.sh
+echo "source /etc/profile.d/gcc-toolset-13.sh" | sudo tee -a /etc/bashrc
+```
+
+## 3. Install CMake
+
+Install CMake 3.25.1 manually:
+
+```bash
+CMAKE_VERSION=3.25.1
+ARCH=$(uname -m)
+
+if [ "$ARCH" = "x86_64" ]; then
+  CMAKE_FILE=cmake-${CMAKE_VERSION}-linux-x86_64.sh
+else
+  CMAKE_FILE=cmake-${CMAKE_VERSION}-linux-aarch64.sh
+fi
+
+wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/${CMAKE_FILE}
+chmod +x ${CMAKE_FILE}
+./${CMAKE_FILE} --skip-license --prefix=/usr/local --exclude-subdir
+rm ${CMAKE_FILE}
+
+cmake --version
+```
+
+## 4. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 5. Build Redis
+
+Enable the GCC toolset and build Redis with support for TLS and modules:
+
+```bash
+source /etc/profile.d/gcc-toolset-13.sh
+cd /usr/src/redis-<version>
+
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+## 6. (Optional) Verify the installation
+
+Check the installed Redis server and CLI versions:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 7. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 8. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: Ubuntu 24.04 (Noble)
+title: Build and run Redis Open Source on Ubuntu 24.04 (Noble)
+weight: 35
+---
+
+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
+{{< /note >}}
+
+## 1. Install required dependencies
+
+First, update your package lists and install the development tools and libraries needed to build Redis:
+
+```bash
+apt-get update
+apt-get install -y sudo
+sudo apt-get install -y --no-install-recommends \
+    ca-certificates \
+    wget \
+    dpkg-dev \
+    gcc \
+    g++ \
+    libc6-dev \
+    libssl-dev \
+    make \
+    git \
+    cmake \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    unzip \
+    rsync \
+    clang \
+    automake \
+    autoconf \
+    libtool
+```
+
+## 2. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 3. Build Redis
+
+Set the appropriate environment variables to enable TLS, modules, and other build options, then compile and install Redis:
+
+```bash
+cd /usr/src/redis-<version>
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+This builds the Redis server, CLI, and any included modules.
+
+## 4. (Optional) Verify the installation
+
+You can confirm that Redis has been built and installed successfully by checking the version:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 5. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 6. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: Ubuntu 20.04 (Focal)
+title: Build and run Redis Open Source on Ubuntu 20.04 (Focal)
+weight: 25
+---
+
+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
+{{< /note >}}
+
+## 1. Install required dependencies
+
+Update your package lists and install the necessary development tools and libraries:
+
+```bash
+apt-get update
+apt-get install -y sudo
+sudo apt-get install -y --no-install-recommends \
+    ca-certificates \
+    wget \
+    dpkg-dev \
+    gcc \
+    g++ \
+    libc6-dev \
+    libssl-dev \
+    make \
+    git \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    unzip \
+    rsync \
+    clang \
+    automake \
+    autoconf \
+    gcc-10 \
+    g++-10 \
+    libtool
+```
+
+## 2. Use GCC 10 as the default compiler
+
+Update the system's default compiler to GCC 10:
+
+```bash
+sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100 --slave /usr/bin/g++ g++ /usr/bin/g++-10
+```
+
+## 3. Install CMake
+
+Install CMake using `pip3` and link it for system-wide access.
+
+{{< warning >}}
+CMake version 3.31.6 is the latest supported version. Newer versions cannot be used.
+{{< /warning>}}
+
+```bash
+pip3 install cmake==3.31.6
+sudo ln -sf /usr/local/bin/cmake /usr/bin/cmake
+cmake --version
+```
+
+## 4. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 5. Build Redis
+
+Set the necessary environment variables and compile Redis:
+
+```bash
+cd /usr/src/redis-<version>
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+## 6. (Optional) Verify the installation
+
+Confirm the Redis installation:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 7. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 8. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: AlmaLinux/Rocky 9.5
+title: Build and run Redis Open Source on AlmaLinux/Rocky Linux 9.5
+weight: 10
+---
+
+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
+{{< /note >}}
+
+## 1. Prepare the system
+
+{{< note >}}
+For 9.5-minimal, you'll need to install `sudo` and `dnf` as follows:
+
+```bash
+microdnf install dnf sudo -y
+```
+
+For 9.5 (regular), you'll need to install `sudo` as follows:
+
+```bash
+dnf install sudo -y
+```
+{{< /note >}}
+
+Enable the GoReleaser repository and install required packages:
+
+```bash
+sudo tee /etc/yum.repos.d/goreleaser.repo > /dev/null <<EOF
+[goreleaser]
+name=GoReleaser
+baseurl=https://repo.goreleaser.com/yum/
+enabled=1
+gpgcheck=0
+EOF
+
+sudo dnf clean all
+sudo dnf makecache
+sudo dnf update -y
+```
+
+## 2. Install required packages
+
+Install build dependencies, GCC toolset, Python, and utilities:
+
+```bash
+sudo dnf install -y --nobest --skip-broken \
+    pkg-config \
+    xz \
+    wget \
+    which \
+    gcc-toolset-13-gcc \
+    gcc-toolset-13-gcc-c++ \
+    git \
+    make \
+    openssl \
+    openssl-devel \
+    python3 \
+    python3-pip \
+    python3-devel \
+    unzip \
+    rsync \
+    clang \
+    curl \
+    libtool \
+    automake \
+    autoconf \
+    jq \
+    systemd-devel
+```
+
+Create a Python virtual environment:
+
+```bash
+python3 -m venv /opt/venv
+```
+
+Enable the GCC toolset:
+
+```bash
+sudo cp /opt/rh/gcc-toolset-13/enable /etc/profile.d/gcc-toolset-13.sh
+echo "source /etc/profile.d/gcc-toolset-13.sh" | sudo tee -a /etc/bashrc
+```
+
+## 3. Install CMake
+
+Install CMake version 3.25.1 manually:
+
+```bash
+CMAKE_VERSION=3.25.1
+ARCH=$(uname -m)
+
+if [ "$ARCH" = "x86_64" ]; then
+  CMAKE_FILE=cmake-${CMAKE_VERSION}-linux-x86_64.sh
+else
+  CMAKE_FILE=cmake-${CMAKE_VERSION}-linux-aarch64.sh
+fi
+
+wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/${CMAKE_FILE}
+chmod +x ${CMAKE_FILE}
+./${CMAKE_FILE} --skip-license --prefix=/usr/local --exclude-subdir
+rm ${CMAKE_FILE}
+
+cmake --version
+```
+
+## 4. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 5. Build Redis
+
+Enable the GCC toolset and compile Redis with TLS and module support:
+
+```bash
+source /etc/profile.d/gcc-toolset-13.sh
+cd /usr/src/redis-<version>
+
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+## 6. (Optional) Verify the installation
+
+Check that Redis was installed successfully:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 7. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 8. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: Ubuntu 22.04 (Jammy)
+title: Build and run Redis Open Source on Ubuntu 22.04 (Jammy)
+weight: 30
+---
+
+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
+{{< /note >}}
+
+## 1. Install required dependencies
+
+First, update your package lists and install the development tools and libraries needed to build Redis:
+
+```bash
+apt-get update
+apt-get install -y sudo
+sudo apt-get install -y --no-install-recommends \
+    ca-certificates \
+    wget \
+    dpkg-dev \
+    gcc \
+    g++ \
+    libc6-dev \
+    libssl-dev \
+    make \
+    git \
+    cmake \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    unzip \
+    rsync \
+    clang \
+    automake \
+    autoconf \
+    libtool
+```
+
+## 2. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 3. Build Redis
+
+Set the appropriate environment variables to enable TLS, modules, and other build options, then compile and install Redis:
+
+```bash
+cd /usr/src/redis-<version>
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+This builds the Redis server, CLI, and any included modules.
+
+## 4. (Optional) Verify the installation
+
+You can confirm that Redis has been built and installed successfully by checking the version:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 5. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 6. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: macOS 13 / macOS 14
+title: Build and run Redis Open Source on macOS 13 (Ventura) and macOS 14 (Sonoma)
+weight: 50
+---
+
+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](https://brew.sh).
+
+## 2. Install required packages
+
+```
+export HOMEBREW_NO_AUTO_UPDATE=1
+brew update
+brew install coreutils
+brew install make
+brew install openssl
+brew install llvm@18
+brew install cmake
+brew install gnu-sed
+brew install automake
+brew install libtool
+brew install wget
+```
+
+## 3. Install Rust
+
+Rust is required to build the JSON package.
+
+```
+RUST_INSTALLER=rust-1.80.1-$(if [ "$(uname -m)" = "arm64" ]; then echo "aarch64"; else echo "x86_64"; fi)-apple-darwin
+wget --quiet -O ${RUST_INSTALLER}.tar.xz https://static.rust-lang.org/dist/${RUST_INSTALLER}.tar.xz
+tar -xf ${RUST_INSTALLER}.tar.xz
+(cd ${RUST_INSTALLER} && sudo ./install.sh)
+```
+
+## 4. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Create a directory for the src, for example `~/src`.
+
+```
+mkdir ~/src
+```
+
+Copy the tar(1) file to `~/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd ~/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 5. Build Redis
+
+```
+cd ~/src/redis-<version>
+export HOMEBREW_PREFIX="$(brew --prefix)"
+export BUILD_WITH_MODULES=yes
+export BUILD_TLS=yes
+export DISABLE_WERRORS=yes
+PATH="$HOMEBREW_PREFIX/opt/libtool/libexec/gnubin:$HOMEBREW_PREFIX/opt/llvm@18/bin:$HOMEBREW_PREFIX/opt/make/libexec/gnubin:$HOMEBREW_PREFIX/opt/gnu-sed/libexec/gnubin:$HOMEBREW_PREFIX/opt/coreutils/libexec/gnubin:$PATH"
+export LDFLAGS="-L$HOMEBREW_PREFIX/opt/llvm@18/lib"
+export CPPFLAGS="-I$HOMEBREW_PREFIX/opt/llvm@18/include"
+          
+mkdir -p build_dir/etc
+make -C redis-8.0 -j "$(nproc)" all OS=macos
+make -C redis-8.0 install PREFIX=$(pwd)/build_dir OS=macos
+```
+
+## 6. (Optional) Verify the installation
+
+Check the installed Redis server and CLI versions:
+
+```bash
+build_dir/bin/redis-server --version
+build_dir/bin/redis-cli --version
+```
+
+## 7. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+export LC_ALL=en_US.UTF-8
+export LANG=en_US.UTF-8
+build_dir/bin/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+build_dir/bin/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: Debian 11 (Bullseye)
+title: Build and run Redis Open Source on Debian 11 (Bullseye)
+weight: 20
+---
+
+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
+{{< /note >}}
+
+## 1. Install required dependencies
+
+First, update your package lists and install the development tools and libraries needed to build Redis:
+
+```bash
+apt-get update
+apt-get install -y sudo
+sudo apt-get install -y --no-install-recommends \
+    ca-certificates \
+    wget \
+    dpkg-dev \
+    gcc \
+    g++ \
+    libc6-dev \
+    libssl-dev \
+    make \
+    git \
+    cmake \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    unzip \
+    rsync \
+    clang \
+    automake \
+    autoconf \
+    libtool
+```
+
+## 2. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+## 3. Build Redis
+
+Set the appropriate environment variables to enable TLS, modules, and other build options, then compile and install Redis:
+
+```bash
+cd /usr/src/redis-<version>
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+This builds the Redis server, CLI, and any included modules.
+
+## 4. (Optional) Verify the installation
+
+You can confirm that Redis has been built and installed successfully by checking the version:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 5. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 6. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-<version>
+sudo make install
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Build and run Redis 8 in Redis Open Source on Linux and macOS
+linkTitle: Build and run Redis Open Source
+stack: true
+title: Build and run Redis Open Source
+weight: 20
+---
+
+Build instructions are provided for the following platforms:
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+linkTitle: Debian 12 (Bookworm)
+title: Build and run Redis Open Source on Debian 12 (Bookworm)
+weight: 15
+---
+
+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
+{{< /note >}}
+
+## 1. Install required dependencies
+
+First, update your package lists and install the development tools and libraries needed to build Redis:
+
+```bash
+apt-get update
+apt-get install -y sudo
+sudo apt-get install -y --no-install-recommends \
+    ca-certificates \
+    wget \
+    dpkg-dev \
+    gcc \
+    g++ \
+    libc6-dev \
+    libssl-dev \
+    make \
+    git \
+    cmake \
+    python3 \
+    python3-pip \
+    python3-venv \
+    python3-dev \
+    unzip \
+    rsync \
+    clang \
+    automake \
+    autoconf \
+    libtool
+```
+
+## 2. Download and extract the Redis source
+
+The Redis source code is available from [the Redis GitHub site](https://github.com/redis/redis/releases). Select the release you want to build and then select the .tar.gz file from the **Assets** drop down menu. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes GitHub repository](https://github.com/redis/redis-hashes).
+
+Copy the tar(1) file to `/usr/src`.
+
+Alternatively, you can download the file directly using the `wget` command, as shown below.
+
+```
+cd /usr/src
+wget -O redis-<version>.tar.gz https://github.com/redis/redis/archive/refs/tags/<version>.tar.gz
+```
+
+Replace `<version>` with the three-digit Redis release number, for example `8.0.0`.
+
+Extract the source:
+
+```bash
+cd /usr/src
+tar xvf redis-<version>.tar.gz
+rm redis-<version>.tar.gz
+```
+
+
+## 3. Build Redis
+
+Set the appropriate environment variables to enable TLS, modules, and other build options, then compile and install Redis:
+
+```bash
+cd /usr/src/redis-<version>
+export BUILD_TLS=yes
+export BUILD_WITH_MODULES=yes
+export INSTALL_RUST_TOOLCHAIN=yes
+export DISABLE_WERRORS=yes
+
+make -j "$(nproc)" all
+```
+
+This builds the Redis server, CLI, and any included modules.
+
+## 4. (Optional) Verify the installation
+
+You can confirm that Redis has been built and installed successfully by checking the version:
+
+```bash
+./src/redis-server --version
+./src/redis-cli --version
+```
+
+## 5. Start Redis
+
+To start Redis, use the following command:
+
+```bash
+./src/redis-server redis-full.conf
+```
+
+To validate that the available modules have been installed, run the [`INFO`]{{< relref "/commands/info" >}} command and look for lines similar to the following:
+
+```
+./src/redis-cli INFO
+...
+# Modules
+module:name=ReJSON,ver=20803,api=1,filters=0,usedby=[search],using=[],options=[handle-io-errors]
+module:name=search,ver=21005,api=1,filters=0,usedby=[],using=[ReJSON],options=[handle-io-errors]
+module:name=bf,ver=20802,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=timeseries,ver=11202,api=1,filters=0,usedby=[],using=[],options=[handle-io-errors]
+module:name=RedisCompat,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+module:name=vectorset,ver=1,api=1,filters=0,usedby=[],using=[],options=[]
+...
+```
+
+## 6. (Optional) Install Redis to its default location
+
+```
+cd /usr/src/redis-version
+sudo make install
+```
+---
+aliases:
+- /operate/oss_and_stack/install/install-redis/install-redis-on-mac-os
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Use Homebrew to install and start Redis on macOS
+linkTitle: MacOS
+title: Install Redis on macOS
+weight: 1
+---
+
+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]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-from-source" >}}).
+
+{{< note >}}
+The Homebrew distribution of Redis Open Source is only supported on macOS.
+{{< /note >}}
+
+## Prerequisites
+
+First, make sure you have Homebrew installed. From the terminal, run:
+
+{{< highlight bash  >}}
+brew --version
+{{< / highlight >}}
+
+If this command fails, you'll need to [follow the Homebrew installation instructions](https://brew.sh/).
+
+## Installation
+
+From the terminal, run:
+
+{{< highlight bash  >}}
+brew install redis
+{{< / highlight >}}
+
+This will install Redis on your system.
+
+## Starting and stopping Redis in the foreground
+
+To test your Redis installation, you can run the `redis-server` executable from the command line:
+
+{{< highlight bash  >}}
+redis-server
+{{< / highlight >}}
+
+If successful, you'll see the startup logs for Redis, and Redis will be running in the foreground.
+
+To stop Redis, enter `Ctrl-C`.
+
+### Starting and stopping Redis using launchd
+
+As an alternative to running Redis in the foreground, you can also use `launchd` to start the process in the background:
+
+{{< highlight bash  >}}
+brew services start redis
+{{< / highlight >}}
+
+This launches Redis and restarts it at login. You can check the status of a `launchd` managed Redis by running the following:
+
+{{< highlight bash  >}}
+brew services info redis
+{{< / highlight >}}
+
+If the service is running, you'll see output like the following:
+
+{{< highlight bash  >}}
+redis (homebrew.mxcl.redis)
+Running: ✔
+Loaded: ✔
+User: miranda
+PID: 67975
+{{< / highlight >}}
+
+To stop the service, run:
+
+{{< highlight bash  >}}
+brew services stop redis
+{{< / highlight >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> ping
+PONG
+{{< / highlight >}}
+
+You can also test that your Redis server is running using
+[Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* [Install Redis "properly"]({{< relref "/operate/oss_and_stack/install/archive/install-redis#install-redis-properly" >}})
+  for production use.
+  
+---
+aliases:
+- /operate/oss_and_stack/install/install-redis/install-redis-on-linux
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis on Linux
+linkTitle: Linux
+title: Install Redis on Linux
+weight: 1
+---
+
+Most major Linux distributions provide packages for Redis.
+
+## Install on Ubuntu/Debian
+
+Add the repository to the APT index, update it, and install Redis:
+
+{{< highlight bash  >}}
+sudo apt-get install lsb-release curl gpg
+curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
+sudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpg
+echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
+sudo apt-get update
+sudo apt-get install redis
+{{< /highlight  >}}
+
+Redis will start automatically, and it should restart at boot time. If Redis doesn't start across reboots, you may need to manually enable it:
+
+{{< highlight bash >}}
+sudo systemctl enable redis-server
+sudo systemctl start redis-server
+{{< /highlight >}}
+
+## Install on Red Hat/Rocky
+
+{{< highlight bash  >}}
+sudo yum install redis
+sudo systemctl enable redis
+sudo systemctl start redis
+{{< /highlight  >}}
+
+Redis will restart at boot time.
+
+## Install on Ubuntu using Snap
+
+To install via Snap, run:
+
+{{< highlight bash  >}}
+sudo apt update
+sudo apt install redis-tools # for redis-cli
+sudo snap install redis
+{{< /highlight  >}}
+
+Redis will start automatically, but it won't restart at boot time. To do this, run:
+
+{{< highlight bash >}}
+sudo snap set redis service.start=true
+{{< /highlight  >}}
+
+You can use these additional snap-related commands to start, stop, restart, and check the status of Redis:
+
+* `sudo snap start redis`
+* `sudo snap stop redis`
+* `sudo snap restart redis`
+* `sudo snap services redis`
+
+If your Linux distribution does not currently have Snap installed, you can install it using the instructions described  [here](https://snapcraft.io/docs/installing-snapd). Then, consult the [Snapcraft store](https://snapcraft.io/redis) for instructions on installing Redis using Snap for your distribution.
+
+## Starting and stopping Redis in the background
+
+You can start the Redis server as a background process using the `systemctl` command. This only applies to Ubuntu/Debian when installed using `apt`, and Red Hat/Rocky when installed using `yum`.
+
+{{< highlight bash  >}}
+sudo systemctl start <redis-service-name> # redis or redis-server depending on platform
+{{< / highlight  >}}
+
+To stop the server, use:
+
+{{< highlight bash  >}}
+sudo systemctl stop <redis-service-name> # redis or redis-server depending on platform
+{{< / highlight  >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> ping
+PONG
+{{< / highlight >}}
+
+You can also test that your Redis server is running using
+[Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* [Install Redis "properly"]({{< relref "/operate/oss_and_stack/install/archive/install-redis#install-redis-properly" >}})
+  for production use.
+  
+---
+aliases:
+- /operate/oss_and_stack/install/install-redis/install-redis-on-windows
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Use Redis on Windows for development
+linkTitle: Windows
+title: Install Redis on Windows
+weight: 1
+---
+
+Redis is not officially supported on Windows. However, you can install Redis on Windows for development by following the instructions below.
+
+To install Redis on Windows, you'll first need to enable [WSL2](https://docs.microsoft.com/en-us/windows/wsl/install) (Windows Subsystem for Linux). WSL2 lets you run Linux binaries natively on Windows. For this method to work, you'll need to be running Windows 10 version 2004 and higher or Windows 11.
+
+## Install or enable WSL2
+
+Microsoft provides [detailed instructions for installing WSL](https://docs.microsoft.com/en-us/windows/wsl/install). Follow these instructions, and take note of the default Linux distribution it installs. This guide assumes Ubuntu.
+
+## Install Redis
+
+Once you're running Ubuntu on Windows, you can follow the steps detailed at [Install on Ubuntu/Debian]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-on-linux#install-on-ubuntu-debian" >}}) to install recent stable versions of Redis from the official `packages.redis.io` APT repository.
+Add the repository to the <code>apt</code> index, update it, and then install:
+
+{{< highlight bash  >}}
+curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
+
+echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
+
+sudo apt-get update
+sudo apt-get install redis
+{{< / highlight  >}}
+
+Lastly, start the Redis server like so:
+
+{{< highlight bash  >}}
+sudo service redis-server start
+{{< / highlight  >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> ping
+PONG
+{{< / highlight >}}
+
+You can also test that your Redis server is running using
+[Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* [Install Redis "properly"]({{< relref "/operate/oss_and_stack/install/archive/install-redis#install-redis-properly" >}})
+  for production use.
+---
+aliases:
+- /operate/oss_and_stack/install/install-redis/install-redis-from-source
+categories:
+- docs
+- operate
+- stack
+- oss
+description: 'Compile and install Redis from source
+
+  '
+linkTitle: Source code
+title: Install Redis from Source
+weight: 5
+---
+
+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](https://redis.io/downloads) page. You can verify the integrity of these downloads by checking them against the digests in the [redis-hashes git repository](https://github.com/redis/redis-hashes).
+
+To obtain the source files for the latest stable version of Redis from the Redis downloads site, run:
+
+{{< highlight bash >}}
+wget https://download.redis.io/redis-stable.tar.gz
+{{< / highlight >}}
+
+## Compiling Redis
+
+To compile Redis, first extract the tarball, change to the root directory, and then run `make`:
+
+{{< highlight bash >}}
+tar -xzvf redis-stable.tar.gz
+cd redis-stable
+make
+{{< / highlight >}}
+
+To build with TLS support, you'll need to install OpenSSL development libraries (e.g., libssl-dev on Debian/Ubuntu) and then run:
+
+{{< highlight bash >}}
+make BUILD_TLS=yes
+{{< / highlight >}}
+
+If the compile succeeds, you'll find several Redis binaries in the `src` directory, including:
+
+* **redis-server**: the Redis Server itself
+* **redis-cli** is the command line interface utility to talk with Redis.
+
+To install these binaries in `/usr/local/bin`, run:
+
+{{< highlight bash  >}}
+sudo make install
+{{< / highlight >}}
+
+### Starting and stopping Redis in the foreground
+
+Once installed, you can start Redis by running
+
+{{< highlight bash  >}}
+redis-server
+{{< / highlight >}}
+
+If successful, you'll see the startup logs for Redis, and Redis will be running in the foreground.
+
+To stop Redis, enter `Ctrl-C`.
+
+For a more complete installation, continue with [these instructions]({{< relref "/operate/oss_and_stack/install/archive/install-redis/#install-redis-properly" >}}).
+---
+aliases:
+- /operate/oss_and_stack/install/install-redis/
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Install Redis on Linux, macOS, and Windows
+linkTitle: Install Redis
+title: Install Redis
+weight: 1
+---
+
+This is a an installation guide. You'll learn how to install, run, and experiment with the Redis server process.
+
+While you can install Redis on any of the platforms listed below, you might also consider using Redis Cloud by creating a [free account](https://redis.com/try-free?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users). You can also download [Redis Insight]({{< relref "/operate/redisinsight/install/" >}}), a free developer tool that works with Redis.
+
+## Install Redis Open Source
+
+How you install Redis depends on your operating system. See the guide below that best fits your needs:
+
+* [Install Redis on Linux]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-on-linux" >}})
+* [Install Redis on macOS]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-on-mac-os" >}})
+* [Install Redis on Windows]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-on-windows" >}})
+
+Refer to [Redis Administration]({{< relref "/operate/oss_and_stack/management/admin" >}}) for detailed setup tips.
+
+## Test if you can connect using the CLI
+
+After you have Redis up and running, you can connect using `redis-cli`.
+
+External programs talk to Redis using a TCP socket and a Redis specific protocol. This protocol is implemented in the Redis client libraries for the different programming languages. However, to make hacking with Redis simpler, Redis provides a command line utility that can be used to send commands to Redis. This program is called **redis-cli**.
+
+The first thing to do to check if Redis is working properly is sending a **PING** command using redis-cli:
+
+```
+$ redis-cli ping
+PONG
+```
+
+Running **redis-cli** followed by a command name and its arguments will send this command to the Redis instance running on localhost at port 6379. You can change the host and port used by `redis-cli` - just try the `--help` option to check the usage information.
+
+Another interesting way to run `redis-cli` is without arguments: the program will start in interactive mode. You can type different commands and see their replies.
+
+```
+$ redis-cli
+redis 127.0.0.1:6379> ping
+PONG
+```
+
+## Securing Redis
+
+By default Redis binds to **all the interfaces** and has no authentication at all. If you use Redis in a very controlled environment, separated from the external internet and in general from attackers, that's fine. However, if an unhardened Redis is exposed to the internet, it is a big security concern. If you are not 100% sure your environment is secured properly, please check the following steps in order to make Redis more secure:
+
+1. Make sure the port Redis uses to listen for connections (by default 6379 and additionally 16379 if you run Redis in cluster mode, plus 26379 for Sentinel) is firewalled, so that it is not possible to contact Redis from the outside world.
+2. Use a configuration file where the `bind` directive is set in order to guarantee that Redis listens on only the network interfaces you are using. For example, only the loopback interface (127.0.0.1) if you are accessing Redis locally from the same computer.
+3. Use the `requirepass` option to add an additional layer of security so that clients will be required to authenticate using the [`AUTH`](/commands/auth) command.
+4. Use [spiped](http://www.tarsnap.com/spiped.html) or another SSL tunneling software to encrypt traffic between Redis servers and Redis clients if your environment requires encryption.
+
+Note that a Redis instance exposed to the internet without any security [is very simple to exploit](http://antirez.com/news/96), so make sure you understand the above and apply **at least** a firewall layer. After the firewall is in place, try to connect with `redis-cli` from an external host to confirm that the instance is not reachable.
+
+## Use Redis from your application
+
+Of course using Redis just from the command line interface is not enough as the goal is to use it from your application. To do so, you need to download and install a Redis client library for your programming language.
+
+You'll find a [full list of supported clients for different languages in this page]({{< relref "develop/clients/" >}}).
+
+
+## Redis persistence
+
+You can learn [how Redis persistence works on this page]({{< relref "/operate/oss_and_stack/management/persistence" >}}). It is important to understand that, if you start Redis with the default configuration, Redis will spontaneously save the dataset only from time to time. For example, after at least five minutes if you have at least 100 changes in your data. If you want your database to persist and be reloaded after a restart make sure to call the **SAVE** command manually every time you want to force a data set snapshot. Alternatively, you can save the data on disk before quitting by using the **SHUTDOWN** command:
+
+```
+$ redis-cli shutdown
+```
+
+This way, Redis will save the data on disk before quitting. Reading the [persistence page]({{< relref "/operate/oss_and_stack/management/persistence" >}}) is strongly suggested to better understand how Redis persistence works.
+
+## Install Redis properly
+
+Running Redis from the command line is fine just to hack a bit or for development. However, at some point you'll have some actual application to run on a real server. For this kind of usage you have two different choices:
+
+* Run Redis using screen.
+* Install Redis in your Linux box in a proper way using an init script, so that after a restart everything will start again properly.
+
+A proper install using an init script is strongly recommended. 
+
+{{% alert title="Note" color="warning" %}}
+The available packages for supported Linux distributions already include the capability of starting the Redis server from `/etc/init`.
+{{% /alert  %}}
+
+{{% alert title="Note" color="warning" %}}
+The remainder of this section assumes you've [installed Redis from its source code]({{< relref "/operate/oss_and_stack/install/archive/install-redis/install-redis-from-source" >}}).
+{{% /alert  %}}
+
+The following instructions can be used to perform a proper installation using the init script shipped with the Redis source code, `/path/to/redis-stable/utils/redis_init_script`.
+
+If you have not yet run `make install` after building the Redis source, you will need to do so before continuing. By default, `make install` will copy the `redis-server` and `redis-cli` binaries to `/usr/local/bin`.
+
+* Create a directory in which to store your Redis config files and your data:
+
+    ```
+    sudo mkdir /etc/redis
+    sudo mkdir /var/redis
+    ```
+
+* Copy the init script that you'll find in the Redis distribution under the **utils** directory into `/etc/init.d`. We suggest calling it with the name of the port where you are running this instance of Redis. Make sure the resulting file has `0755` permissions.
+    
+    ```
+    sudo cp utils/redis_init_script /etc/init.d/redis_6379
+    ```
+
+* Edit the init script.
+
+    ```
+    sudo vi /etc/init.d/redis_6379
+    ```
+
+Make sure to set the **REDISPORT** variable to the port you are using.
+Both the pid file path and the configuration file name depend on the port number.
+
+* Copy the template configuration file you'll find in the root directory of the Redis distribution into `/etc/redis/` using the port number as the name, for instance:
+
+    ```
+    sudo cp redis.conf /etc/redis/6379.conf
+    ```
+
+* Create a directory inside `/var/redis` that will work as both data and working directory for this Redis instance:
+
+    ```
+    sudo mkdir /var/redis/6379
+    ```
+
+* Edit the configuration file, making sure to perform the following changes:
+    * Set **daemonize** to yes (by default it is set to no).
+    * Set the **pidfile** to `/var/run/redis_6379.pid`, modifying the port as necessary.
+    * Change the **port** accordingly. In our example it is not needed as the default port is already `6379`.
+    * Set your preferred **loglevel**.
+    * Set the **logfile** to `/var/log/redis_6379.log`.
+    * Set the **dir** to `/var/redis/6379` (very important step!).
+* Finally, add the new Redis init script to all the default runlevels using the following command:
+
+    ```
+    sudo update-rc.d redis_6379 defaults
+    ```
+
+You are done! Now you can try running your instance with:
+
+```
+sudo /etc/init.d/redis_6379 start
+```
+
+Make sure that everything is working as expected:
+
+1. Try pinging your instance within a `redis-cli` session using the [`PING`](/commands/ping) command.
+2. Do a test save with `redis-cli save` and check that a dump file is correctly saved to `/var/redis/6379/dump.rdb`.
+3. Check that your Redis instance is logging to the `/var/log/redis_6379.log` file.
+4. If it's a new machine where you can try it without problems, make sure that after a reboot everything is still working.
+
+{{% alert title="Note" color="warning" %}}
+The above instructions don't include all of the Redis configuration parameters that you could change. For example, to use AOF persistence instead of RDB persistence, or to set up replication, and so forth.
+{{% /alert  %}}
+
+You should also read the example [redis.conf]({{< relref "/operate/oss_and_stack/management/config-file" >}}) file, which is heavily annotated to help guide you on making changes. Further details can also be found in the [configuration article on this site]({{< relref "/operate/oss_and_stack/management/config" >}}).
+
+<hr>
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Stack on Windows
+linkTitle: Windows
+title: Install Redis Stack on Windows
+weight: 3
+---
+
+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]({{< relref "/operate/oss_and_stack/install/install-stack/docker" >}}). Then, use Docker to connect with `redis-cli` as explained in that topic.
+
+{{% alert title="About using WSL and Ubuntu for Windows " color="warning" %}}
+If you attempt to use Windows Subsystem for Linux (WSL) or Ubuntu for Windows to follow [Linux instructions]({{< relref "/operate/oss_and_stack/install/install-stack/apt" >}}), 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. 
+
+_`systemd` is a suite of basic building blocks for a Linux system._ For more information about its function, see [System and Service Manager](https://systemd.io/). This becomes an issue due to the lack of support for Linux workflows on WSL. But, you can test the instructions listed in [Systemd support is now available in WSL!](https://devblogs.microsoft.com/commandline/systemd-support-is-now-available-in-wsl/). Let us know how that worked for you. 
+{{% /alert %}}
+
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Stack on Linux
+linkTitle: Linux
+title: Install Redis Stack on Linux
+weight: 1
+---
+
+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](https://redis.io/downloads/#redis-stack-downloads) for a complete list of supported Ubuntu/Debian platforms.
+Add the repository to the APT index, update it, and install Redis Stack:
+
+{{< highlight bash >}}
+sudo apt-get install lsb-release curl gpg
+curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
+sudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpg
+echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
+sudo apt-get update
+sudo apt-get install redis-stack-server
+{{< /highlight >}}
+
+Redis will not start automatically, nor will it start at boot time. To do this, run the following commands.
+
+{{< highlight bash >}}
+sudo systemctl enable redis-stack-server
+sudo systemctl start redis-stack-server
+{{< /highlight >}}
+
+## From the official Red Hat/Rocky RPM Feeds
+
+See [this page](https://redis.io/downloads/#redis-stack-downloads) for a complete list of supported Red Hat/Rocky platforms.
+Follow these steps to install Redis Stack.
+
+1. Create the file `/etc/yum.repos.d/redis.repo` with the following contents.
+
+    {{< highlight bash >}}
+    [Redis]
+    name=Redis
+    baseurl=http://packages.redis.io/rpm/rhel9 # replace rhel9 with the appropriate value for your platform
+    enabled=1
+    gpgcheck=1
+    {{< /highlight >}}
+
+1. Run the following commands:
+
+    {{< highlight bash >}}
+    curl -fsSL https://packages.redis.io/gpg > /tmp/redis.key
+    sudo rpm --import /tmp/redis.key
+    sudo yum install epel-release
+    sudo yum install redis-stack-server
+    {{< / highlight >}}
+
+Redis will not start automatically, nor will it start at boot time. To do this, run the following commands.
+
+{{< highlight bash >}}
+sudo systemctl enable redis-stack-server
+sudo systemctl start redis-stack-server
+{{< /highlight >}}
+
+## On Ubuntu with Snap
+
+First, download the latest Redis Stack snap package from [this page](https://redis.io/downloads/).
+
+To install, run:
+
+{{< highlight bash >}}
+sudo apt update
+sudo apt install redis-tools
+sudo snap install --dangerous --classic <snapname.snap>
+{{< / highlight >}}
+
+Redis will not start automatically, nor will it start at boot time. To start `redis-stack-server` in the foreground, run the command:
+
+{{< highlight bash >}}
+sudo snap run redis-stack-server
+{{< /highlight >}}
+
+To stop Redis, enter `Ctrl-C`.
+
+Follow these steps to integrate Redis Stack with `systemd` so you can start/stop in/from the background:
+
+1. Edit the `/etc/systemd/system/redis-stack-server.service` file and enter the following information:
+
+    {{< highlight text >}}
+    [Unit]
+    Description=Redis Stack Server
+    After=network.target
+
+    [Service]
+    ExecStart=/usr/bin/snap run redis-stack-server
+    Restart=always
+    User=root
+    Group=root
+
+    [Install]
+    WantedBy=multi-user.target
+    {{< /highlight >}}
+
+1. Run the following commands.
+
+    {{< highlight bash >}}
+    sudo systemctl daemon-reload
+    sudo systemctl start redis-stack-server
+    sudo systemctl enable redis-stack-server
+    {{< /highlight >}}
+
+If your Linux distribution does not currently have Snap installed, you can install it using the instructions described  [here](https://snapcraft.io/docs/installing-snapd). Then, download the appropriate from the [downloads page](https://redis.io/downloads/).
+
+## On Ubuntu with AppImage
+
+Fuse needs to be installed before proceeding. Install it as follows.
+
+{{< highlight bash >}}
+sudo apt update
+sudo apt install fuse
+{{< / highlight >}}
+
+Next, download the latest Redis Stack AppImage package from [this page](https://redis.io/downloads/).
+
+To run the image, execute these commands:
+
+{{< highlight bash >}}
+sudo apt update
+sudo apt install redis-tools
+chmod a+x <AppImageFile> # replace AppImageFile with the name of your downloaded file
+./<AppImageFile>
+{{< / highlight >}}
+
+This will start Redis in the foreground. To stop Redis, enter `Ctrl-C`.
+
+Follow these steps to integrate Redis Stack with `systemd` so you can start/stop in/from the background:
+
+1. Edit the `/etc/systemd/system/redis-appimage.service` file and enter the following information:
+
+    {{< highlight text >}}
+    [Unit]
+    Description=Redis Server (AppImage)
+    After=network.target
+
+    [Service]
+    ExecStart=/path/to/your/<AppImageFile> --daemonize no
+    Restart=always
+    User=redis-user   # replace with an existing user or create a new one
+    Group=redis-group # replace with an existing group or create a new one
+
+    [Install]
+    WantedBy=multi-user.target
+    {{< /highlight >}}
+1. Run the following commands.
+
+    {{< highlight bash >}}
+    sudo systemctl daemon-reload
+    sudo systemctl start redis-appimage
+    sudo systemctl enable redis-appimage
+    {{< /highlight >}}
+
+## Starting and stopping Redis Stack in the background
+
+You can start the Redis server as a background process using the `systemctl` command. This only applies to Ubuntu/Debian when installed using `apt`, and Red Hat/Rocky when installed using `yum`.
+
+{{< highlight bash  >}}
+sudo systemctl start redis-stack-server
+{{< / highlight  >}}
+
+To stop the service, use:
+
+{{< highlight bash  >}}
+sudo systemctl stop redis-stack-server
+{{< / highlight  >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> ping
+PONG
+{{< / highlight >}}
+
+You can also test that your Redis server is running using
+[Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* [Install Redis properly]({{< relref "/operate/oss_and_stack/install/archive/install-redis#install-redis-properly" >}})
+  for production use.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Stack on macOS
+linkTitle: MacOS
+title: Install Redis Stack on macOS
+weight: 2
+---
+
+To install Redis Stack on macOS, use [Homebrew](https://brew.sh/). Make sure that you have [Homebrew installed](https://docs.brew.sh/Installation) 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:
+
+{{< highlight bash >}}
+brew tap redis-stack/redis-stack
+{{< / highlight >}}
+
+Next, run `brew install`:
+
+{{< highlight bash >}}
+brew install redis-stack
+{{< / highlight >}}
+
+The `redis-stack-server` cask will install all Redis and Redis Stack binaries. How you run these binaries depends on whether you already have Redis installed on your system.
+
+### First-time Redis installation
+
+If this is the first time you've installed Redis on your system, you need to be sure that your `PATH` variable includes the Redis Stack installation location. This location is either `/opt/homebrew/bin` for Apple silicon Macs or `/usr/local/bin` for Intel-based Macs.
+
+To check this, run:
+
+{{< highlight bash >}}
+echo $PATH
+{{< / highlight >}}
+
+Then, confirm that the output contains `/opt/homebrew/bin` (Apple silicon Macs) or `/usr/local/bin` (Intel Mac). If these directories are not in the output, see the "Existing Redis installation" instructions below.
+
+{{< note >}}
+Because Redis Stack is installed using a brew cask via the `brew tap` command, it will not be integrated with the `brew services` command.
+{{< /note >}}
+
+### Existing Redis installation
+
+If you have an existing Redis installation on your system, then might want to modify your `$PATH` to ensure that you're using the latest Redis Stack binaries.
+
+Open the file `~/.bashrc` or `~/zshrc` (depending on your shell), and add the following lines.
+
+For Intel-based Macs:
+
+{{< highlight bash >}}
+export PATH=/usr/local/Caskroom/redis-stack-server/<VERSION>/bin:$PATH
+{{< / highlight >}}
+
+For Apple silicon Macs:
+
+{{< highlight bash >}}
+export PATH=/opt/homebrew/Caskroom/redis-stack-server/<VERSION>/bin:$PATH
+{{< / highlight >}}
+
+In both cases, replace `<VERSION>` with your version of Redis Stack. For example, with version 6.2.0, path is as follows:
+
+{{< highlight bash >}}
+export PATH=/opt/homebrew/Caskroom/redis-stack-server/6.2.0/bin:$PATH
+{{< / highlight >}}
+
+### Start Redis Stack Server
+
+You can now start Redis Stack Server as follows:
+
+{{< highlight bash >}}
+redis-stack-server
+{{< / highlight >}}
+
+## Installing Redis after installing Redis Stack
+
+If you've already installed Redis Stack with Homebrew and then try to install Redis with `brew install redis`, you may encounter errors like the following:
+
+{{< highlight bash >}}
+Error: The brew link step did not complete successfully
+The formula built, but is not symlinked into /usr/local
+Could not symlink bin/redis-benchmark
+Target /usr/local/bin/redis-benchmark
+already exists. You may want to remove it:
+rm '/usr/local/bin/redis-benchmark'
+
+To force the link and overwrite all conflicting files:
+brew link --overwrite redis
+
+To list all files that would be deleted:
+brew link --overwrite --dry-run redis
+{{< / highlight >}}
+
+In this case, you can overwrite the Redis binaries installed by Redis Stack by running:
+
+{{< highlight bash >}}
+brew link --overwrite redis
+{{< / highlight >}}
+
+However, Redis Stack Server will still be installed. To uninstall Redis Stack Server, see below.
+
+## Uninstall Redis Stack
+
+To uninstall Redis Stack, run:
+
+{{< highlight bash >}}
+brew uninstall redis-stack-redisinsight redis-stack-server redis-stack
+brew untap redis-stack/redis-stack
+{{< / highlight >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> ping
+PONG
+{{< / highlight >}}
+
+You can also test that your Redis server is running using
+[Redis Insight]({{< relref "/develop/tools/insight" >}}).
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* [Install Redis "properly"]({{< relref "/operate/oss_and_stack/install/archive/install-redis#install-redis-properly" >}})
+  for production use.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Stack using tarballs
+linkTitle: Binaries
+title: Install Redis Stack from binaries
+weight: 5
+---
+
+## Start Redis Stack Server
+
+Install the openssl libraries for your platform. For example, on a Debian or Ubuntu instance run:
+
+{{< highlight bash >}}
+sudo apt install libssl-dev
+{{< / highlight >}}
+
+After untarring or unzipping your redis-stack-server download, you can start Redis Stack Server as follows:
+
+{{< highlight bash >}}
+/path/to/redis-stack-server/bin/redis-stack-server
+{{< / highlight >}}
+
+### Add the binaries to your PATH
+
+You can add the redis-stack-server binaries to your `$PATH` as follows:
+
+Open the file `~/.bashrc` or `~/zshrc` (depending on your shell), and add the following lines.
+
+{{< highlight bash >}}
+export PATH=/path/to/redis-stack-server/bin:$PATH
+{{< / highlight >}}
+
+If you have an existing Redis installation on your system, then you can choose override those override those PATH variables as before, or you can choose to only add redis-stack-server binary as follows:
+
+{{< highlight bash >}}
+export PATH=/path/to/redis-stack-server/bin/redis-stack-server:$PATH
+{{< / highlight >}}
+
+If you're running redis-stack-server on a mac, please ensure you have openssl installed, via [homebrew](https://brew.sh/).
+
+Now you can start Redis Stack Server as follows:
+
+{{< highlight bash >}}
+redis-stack-server
+{{< / highlight >}}
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Stack using Docker
+linkTitle: Docker
+title: Run Redis Stack on Docker
+weight: 4
+---
+
+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:
+
+{{< highlight bash >}}
+docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest
+{{< / highlight >}}
+
+### redis/redis-stack
+
+To start a Redis Stack container using the `redis-stack` image, run the following command in your terminal:
+
+{{< highlight bash >}}
+docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+{{< / highlight >}}
+
+The `docker run` command above also exposes Redis Insight on port 8001. You can use Redis Insight by pointing your browser to `localhost:8001`.
+
+## Connect with redis-cli
+
+You can then connect to the server using `redis-cli`, just as you connect to any Redis instance.
+
+If you don’t have `redis-cli` installed locally, you can run it from the Docker container:
+
+{{< highlight bash >}}
+$ docker exec -it redis-stack redis-cli
+{{< / highlight >}}
+
+## Configuration
+
+### Persistence in Docker
+
+To mount directories or files to your Docker container, specify `-v` to configure a local volume. This command stores all data in the local directory `local-data`:
+{{< highlight bash >}}
+$ docker run -v /local-data/:/data redis/redis-stack:latest
+{{< / highlight >}}
+
+### Ports
+
+If you want to expose Redis Stack server or Redis Insight on a different port, update the left hand of portion of the `-p` argument. This command exposes Redis Stack server on port `10001` and Redis Insight on port `13333`:
+{{< highlight bash >}}
+$ docker run -p 10001:6379 -p 13333:8001 redis/redis-stack:latest
+{{< / highlight >}}
+
+### Config files
+
+By default, the Redis Stack Docker containers use internal configuration files for Redis. To start Redis with local configuration file, you can use the `-v` volume options:
+
+{{< highlight bash >}}
+$ docker run -v `pwd`/local-redis-stack.conf:/redis-stack.conf -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
+{{< / highlight >}}
+
+### Environment variables
+
+To pass in arbitrary configuration changes, you can set any of these environment variables:
+
+* `REDIS_ARGS`: extra arguments for Redis
+
+* `REDISEARCH_ARGS`: arguments for the search and query features (RediSearch)
+
+* `REDISJSON_ARGS`: arguments for JSON (RedisJSON)
+
+* `REDISTIMESERIES_ARGS`: arguments for time series (RedisTimeSeries)
+
+* `REDISBLOOM_ARGS`: arguments for  the probabilistic data structures (RedisBloom)
+
+
+For example, here's how to use the `REDIS_ARGS` environment variable to pass the `requirepass` directive to Redis:
+
+{{< highlight bash >}}
+docker run -e REDIS_ARGS="--requirepass redis-stack" redis/redis-stack:latest
+{{< / highlight >}}
+
+An example of setting [Redis persistence]({{< relref "/operate/oss_and_stack/management/persistence" >}}):
+{{< highlight bash >}}
+docker run -e REDIS_ARGS="--save 60 1000 --appendonly yes" redis/redis-stack:latest
+{{< / highlight >}}
+
+Here's how to set a retention policy for time series:
+{{< highlight bash >}}
+docker run -e REDISTIMESERIES_ARGS="RETENTION_POLICY=20" redis/redis-stack:latest
+{{< / highlight >}}
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Install Redis Stack on Linux, macOS, and Windows
+linkTitle: Install Redis Stack
+stack: true
+title: Install Redis Stack
+weight: 2
+---
+
+While you can install Redis Stack on any of the platforms listed below, you might also consider using Redis Cloud by creating a [free account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+
+<hr/>---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install your preferred Redis flavor on your target platform
+hideListLinks: true
+linkTitle: Archived instructions
+title: Install Redis Community Edition or Redis Stack
+weight: 30
+bannerText: These docs apply to Redis Community Edition and Redis Stack version 7.x.
+bannerChildren: true
+---
+
+You can install [Redis](https://redis.io/about/) or [Redis Stack](https://redis.io/about/about-stack/) locally on your machine. Redis and Redis Stack are available on Linux, macOS, and Windows.
+
+Here are the installation instructions:
+
+* [Install Redis]({{< relref "/operate/oss_and_stack/install/archive/install-redis" >}})
+* [Install Redis Stack]({{< relref "/operate/oss_and_stack/install/archive/install-stack" >}})
+
+While you can install Redis or Redis Stack locally, you might also consider using Redis Cloud by creating a [free account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Open Source using APT
+linkTitle: APT
+title: Install Redis Open Source on Linux
+weight: 2
+---
+
+## Install Redis Open Source on Ubuntu or Debian Linux using APT
+
+See [this page](https://redis.io/downloads/#redis-stack-downloads) for a complete list of supported Ubuntu and Debian platforms.
+Add the repository to the APT index, update it, and install Redis Open Source:
+
+{{< highlight bash >}}
+sudo apt-get install lsb-release curl gpg
+curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
+sudo chmod 644 /usr/share/keyrings/redis-archive-keyring.gpg
+echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
+sudo apt-get update
+sudo apt-get install redis
+{{< /highlight >}}
+
+The most recent version of Redis Open Source will be installed, along with the redis-tools package (redis-cli, etc.).
+If you need to install an earlier version, run the following command to list the available versions:
+
+{{< highlight bash >}}
+apt policy redis
+
+redis:
+  Installed: (none)
+  Candidate: 6:8.0.0-1rl1~bookworm1
+  Version table:
+     6:8.0.0-1rl1~bookworm1 500
+        500 https://packages.redis.io/deb bookworm/main arm64 Packages
+        500 https://packages.redis.io/deb bookworm/main all Packages
+     6:7.4.3-1rl1~bookworm1 500
+        500 https://packages.redis.io/deb bookworm/main arm64 Packages
+        500 https://packages.redis.io/deb bookworm/main all Packages
+     6:7.4.2-1rl1~bookworm1 500
+        500 https://packages.redis.io/deb bookworm/main arm64 Packages
+        500 https://packages.redis.io/deb bookworm/main all Packages
+{{< /highlight >}}
+
+To install an earlier version, say 7.4.2, run the following command:
+
+{{< highlight bash >}}
+sudo apt-get install redis=6:7.4.2-1rl1~jammy1
+{{< /highlight >}}
+
+Redis should start automatically after the initial installation and also at boot time.
+Should that not be the case on your system, run the following commands:
+
+{{< highlight bash >}}
+sudo systemctl enable redis-server
+sudo systemctl start redis-server
+{{< /highlight >}}
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Open Source using RPM
+linkTitle: RPM
+title: Install Redis Open Source on Linux
+weight: 3
+---
+
+## Install Redis Open Source on Red Hat, CentOS, or Rocky Linux using RPM
+
+See [this page](https://redis.io/downloads/#redis-downloads) for a complete list of supported Red Hat/Rocky platforms.
+Follow these steps to install Redis Open Source.
+
+1. Create the file `/etc/yum.repos.d/redis.repo` with the following contents.
+
+    - For Rocky Linux 9 and AlmaLinux 9
+    {{< highlight ini >}}
+    [Redis]
+    name=Redis
+    baseurl=http://packages.redis.io/rpm/rockylinux9
+    enabled=1
+    gpgcheck=1
+    {{< /highlight >}}
+
+    - For Rocky Linux 8 and AlmaLinux 8
+    {{< highlight ini >}}
+    [Redis]
+    name=Redis
+    baseurl=http://packages.redis.io/rpm/rockylinux8
+    enabled=1
+    gpgcheck=1
+    {{< /highlight >}}
+
+2. Run the following commands:
+
+    {{< highlight bash >}}
+    curl -fsSL https://packages.redis.io/gpg > /tmp/redis.key
+    sudo rpm --import /tmp/redis.key
+    sudo yum install redis
+    {{< / highlight >}}
+
+Redis will not start automatically, nor will it start at boot time. To do this, run the following commands.
+
+{{< highlight bash >}}
+sudo systemctl enable redis
+sudo systemctl start redis
+{{< /highlight >}}
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to run Redis Open Source on Windows
+linkTitle: Windows
+title: Run Redis Open Source on Windows using Docker
+weight: 7
+---
+
+## 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]({{< relref "/operate/oss_and_stack/install/install-stack/docker" >}}). Then, use Docker to connect with `redis-cli` as explained in that topic.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to run Redis Open Source using Docker
+linkTitle: Docker
+title: Run Redis Open Source on Docker
+weight: 1
+---
+
+## 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:
+
+{{< highlight bash >}}
+docker run -d --name redis -p 6379:6379 redis:<version>
+{{< / highlight >}}
+
+## Connect with redis-cli
+
+You can then connect to the server using `redis-cli`, just as you connect to any Redis instance.
+
+If you don’t have `redis-cli` installed locally, you can run it from the Docker container:
+
+{{< highlight bash >}}
+$ docker exec -it redis redis-cli
+{{< / highlight >}}
+
+If you do have `redis-cli` installed locally, you can run it from your terminal:
+
+{{< highlight bash >}}
+$ redis-cli -h 127.0.0.1 -p 6379
+{{< / highlight >}}
+
+## Use a local configuration file
+
+By default, the Redis Docker containers use internal configuration files for Redis. To start Redis with local configuration file, you can do one of the following:
+
+You can create your own Dockerfile that adds a `redis.conf` from the context into `/data/`, like so.
+
+```
+FROM redis
+COPY redis.conf /usr/local/etc/redis/redis.conf
+CMD [ "redis-server", "/usr/local/etc/redis/redis.conf" ]
+```
+Alternatively, you can specify something along the same lines with docker run options.
+
+{{< highlight bash >}}
+$ docker run -v /myredis/conf:/usr/local/etc/redis --name myredis redis redis-server /usr/local/etc/redis/redis.conf
+{{< / highlight >}}
+
+where `/myredis/conf/` is a local directory containing your `redis.conf` file. Using this method means that there is no need for you to have a Dockerfile for your redis container.
+
+The mapped directory should be writable, as depending on the configuration and mode of operation, Redis may need to create additional configuration files or rewrite existing ones.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Open Source on macOS using Homebrew
+linkTitle: Homebrew
+title: Install Redis Open Source on macOS
+weight: 6
+---
+
+## Install Redis Open Source on macOS using Homebrew
+
+{{< note >}}Installation using Homebrew is only supported on macOS.{{< /note >}}
+
+To install Redis Open Source on macOS, use [Homebrew](https://brew.sh/).
+Make sure that you have [Homebrew installed](https://docs.brew.sh/Installation) before starting on the installation instructions below.
+
+## Install using Homebrew
+
+First, tap the Redis Homebrew cask:
+
+{{< highlight bash >}}
+brew tap redis/redis
+{{< /highlight >}}
+
+Next, run `brew install`:
+
+{{< highlight bash >}}
+brew install --cask redis
+{{< /highlight >}}
+
+## Run Redis
+
+If this is the first time you've installed Redis on your system, you need to be sure that your `PATH` variable includes the Redis installation location. This location is either `/opt/homebrew/bin` for Apple silicon Macs or `/usr/local/bin` for Intel-based Macs.
+
+To check this, run:
+
+{{< highlight bash >}}
+echo $PATH
+{{< /highlight >}}
+
+Next, confirm that the output contains `/opt/homebrew/bin` (Apple silicon Macs) or `/usr/local/bin` (Intel Mac). If neither `/opt/homebrew/bin` nor `/usr/local/bin` are in the output, add them.
+
+Open the file `~/.bashrc` or `~/.zshrc` (depending on your shell), and add the following line.
+
+{{< highlight bash >}}
+export PATH=$(brew --prefix)/bin:$PATH
+{{< /highlight >}}
+
+You can now start the Redis server as follows:
+
+{{< highlight bash >}}
+redis-server /opt/homebrew/etc/redis.conf
+{{< /highlight >}}
+
+The server will run in the background.
+
+{{< note >}}
+Because Redis is installed using a Homebrew cask with the `brew tap` command, it will not be integrated with the `brew services` command.
+{{< /note >}}
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< /highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> PING
+PONG
+{{< /highlight >}}
+
+## Stop Redis
+
+Run the following command:
+
+{{< highlight bash  >}}
+redis-cli SHUTDOWN
+{{< /highlight >}}
+
+## Uninstall Redis Open Source
+
+To uninstall Redis, run:
+
+{{< highlight bash >}}
+brew uninstall redis
+brew untap redis/redis
+{{< /highlight >}}
+
+## Next steps
+
+Once you have a running Redis instance, you may want to:
+
+* Try the [Redis CLI tutorial]({{< relref "/develop/tools/cli" >}})
+* Connect using one of the [Redis clients]({{< relref "/develop/clients" >}})
+* Connect using [Redis Insight]({{< relref "/develop/tools/insight" >}})
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Install Redis Open Source on Docker, Linux, macOS, and Windows (using Docker only)
+linkTitle: Install Redis Open Source
+stack: true
+title: Install Redis Open Source
+weight: 2
+---
+
+Redis Open Source has been tested on the following platforms:
+
+- Ubuntu 20.04 (Focal Fossa), 22.04 (Jammy Jellyfish), and 24.04 (Noble Numbat).
+- Rocky Linux 8.10 and 9.5.
+- AlmaLinux 8.10 and 9.5.
+- Debian 11 (Bullseye) and 12 (Bookworm).
+- macOS 13 (Ventura), 14 (Sonoma), and 15 (Sequoia).
+
+Follow the links below for installation instructions for your OS and distribution.
+
+While you can install Redis Open Source on any of the platforms listed below, you might also consider using Redis Cloud by creating a [free account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+Redis 8 is not yet available on Redis Cloud.
+
+<hr/>---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Open Source using Snap
+linkTitle: Snap
+title: Install Redis Open Source on Linux
+weight: 4
+---
+
+## Install Redis Open Source on Ubuntu Linux using Snap
+
+To install Redis via snap, run the following commands:
+
+{{< highlight bash >}}
+sudo apt update
+sudo apt install redis-tools # this will install `redis-cli`
+sudo snap install redis
+{{< / highlight >}}
+
+Redis will start automatically after installation and also at boot time.
+
+## Connect to Redis
+
+Once Redis is running, you can test it by running `redis-cli`:
+
+{{< highlight bash  >}}
+redis-cli
+{{< / highlight >}}
+
+Test the connection with the `ping` command:
+
+{{< highlight bash  >}}
+127.0.0.1:6379> PING
+PONG
+{{< / highlight >}}
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How to install Redis Open Source on your target platform
+hideListLinks: true
+linkTitle: Install and upgrade
+title: Install Redis Open Source
+weight: 30
+---
+
+You can install [Redis Open Source]({{< relref "/operate/oss_and_stack/" >}}) locally on your machine. Redis Open Source is available on Docker, Linux, macOS, and Windows (using Docker only).
+
+Here are the installation and upgrade instructions:
+
+* [Install Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}})
+* [Upgrade Redis Open Source]({{< relref "/operate/oss_and_stack/install/upgrade" >}})
+
+While you can install Redis Open Source locally, you might also consider using Redis Cloud by creating a [free account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users). Redis 8 is not yet available on Redis Cloud.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How Redis supports high availability and failover with replication
+linkTitle: Replication
+title: Redis replication
+weight: 5
+---
+
+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.
+
+This system works using three main mechanisms:
+
+1. When a master and a replica instance are well-connected, the master keeps the replica updated by sending a stream of commands to the replica to replicate the effects on the dataset happening on the master side due to: client writes, keys expired or evicted, any other action changing the master dataset.
+2. When the link between the master and the replica breaks, for network issues or because a timeout is sensed in the master or the replica, the replica reconnects and attempts to proceed with a partial resynchronization: it means that it will try to just obtain the part of the stream of commands it missed during the disconnection.
+3. When a partial resynchronization is not possible, the replica will ask for a full resynchronization. This will involve a more complex process in which the master needs to create a snapshot of all its data, send it to the replica, and then continue sending the stream of commands as the dataset changes.
+
+Redis uses by default asynchronous replication, which being low latency and
+high performance, is the natural replication mode for the vast majority of Redis
+use cases. However, Redis replicas asynchronously acknowledge the amount of data
+they receive periodically with the master. So the master does not wait every time
+for a command to be processed by the replicas, however it knows, if needed, what
+replica already processed what command. This allows having optional synchronous replication.
+
+Synchronous replication of certain data can be requested by the clients using
+the [`WAIT`](/commands/wait) command. However [`WAIT`](/commands/wait) is only able to ensure there are the
+specified number of acknowledged copies in the other Redis instances, it does not
+turn a set of Redis instances into a CP system with strong consistency: acknowledged
+writes can still be lost during a failover, depending on the exact configuration
+of the Redis persistence. However, [WAIT]({{< relref "commands/wait" >}}) dramatically reduces the probability of losing a write after a failure event to specific hard-to-trigger failure modes.
+
+You can check the Redis Sentinel or Redis Cluster documentation for more information
+about high availability and failover. The rest of this document mainly describes the basic characteristics of Redis basic replication.
+
+### Important facts about Redis replication
+
+* Redis uses asynchronous replication, with asynchronous replica-to-master acknowledges of the amount of data processed.
+* A master can have multiple replicas.
+* Replicas are able to accept connections from other replicas. Aside from connecting a number of replicas to the same master, replicas can also be connected to other replicas in a cascading-like structure. Since Redis 4.0, all the sub-replicas will receive exactly the same replication stream from the master.
+* Redis replication is non-blocking on the master side. This means that the master will continue to handle queries when one or more replicas perform the initial synchronization or a partial resynchronization.
+* Replication is also largely non-blocking on the replica side. While the replica is performing the initial synchronization, it can handle queries using the old version of the dataset, assuming you configured Redis to do so in redis.conf.  Otherwise, you can configure Redis replicas to return an error to clients if the replication stream is down. However, after the initial sync, the old dataset must be deleted and the new one must be loaded. The replica will block incoming connections during this brief window (that can be as long as many seconds for very large datasets). Since Redis 4.0 you can configure Redis so that the deletion of the old data set happens in a different thread, however loading the new initial dataset will still happen in the main thread and block the replica.
+* Replication can be used both for scalability, to have multiple replicas for read-only queries (for example, slow O(N) operations can be offloaded to replicas), or simply for improving data safety and high availability.
+* You can use replication to avoid the cost of having the master writing the full dataset to disk: a typical technique involves configuring your master `redis.conf` to avoid persisting to disk at all, then connect a replica configured to save from time to time, or with AOF enabled. However, this setup must be handled with care, since a restarting master will start with an empty dataset: if the replica tries to sync with it, the replica will be emptied as well.
+
+## Safety of replication when master has persistence turned off
+
+In setups where Redis replication is used, it is strongly advised to have
+persistence turned on in the master and in the replicas. When this is not possible,
+for example because of latency concerns due to very slow disks, instances should
+be configured to **avoid restarting automatically** after a reboot.
+
+To better understand why masters with persistence turned off configured to
+auto restart are dangerous, check the following failure mode where data
+is wiped from the master and all its replicas:
+
+1. We have a setup with node A acting as master, with persistence turned down, and nodes B and C replicating from node A.
+2. Node A crashes, however it has some auto-restart system, that restarts the process. However since persistence is turned off, the node restarts with an empty data set.
+3. Nodes B and C will replicate from node A, which is empty, so they'll effectively destroy their copy of the data.
+
+When Redis Sentinel is used for high availability, also turning off persistence
+on the master, together with auto restart of the process, is dangerous. For example the master can restart fast enough for Sentinel to not detect a failure, so that the failure mode described above happens.
+
+Every time data safety is important, and replication is used with master configured without persistence, auto restart of instances should be disabled.
+
+## How Redis replication works
+
+Every Redis master has a replication ID: it is a large pseudo random string
+that marks a given history of the dataset. Each master also takes an offset that
+increments for every byte of replication stream that it is produced to be
+sent to replicas, to update the state of the replicas with the new changes
+modifying the dataset. The replication offset is incremented even if no replica
+is actually connected, so basically every given pair of:
+
+    Replication ID, offset
+
+Identifies an exact version of the dataset of a master.
+
+When replicas connect to masters, they use the [`PSYNC`](/commands/psync) command to send
+their old master replication ID and the offsets they processed so far. This way
+the master can send just the incremental part needed. However if there is not
+enough *backlog* in the master buffers, or if the replica is referring to an
+history (replication ID) which is no longer known, then a full resynchronization
+happens: in this case the replica will get a full copy of the dataset, from scratch.
+
+This is how a full synchronization works in more details:
+
+The master starts a background saving process to produce an RDB file. At the same time it starts to buffer all new write commands received from the clients. When the background saving is complete, the master transfers the database file to the replica, which saves it on disk, and then loads it into memory. The master will then send all buffered commands to the replica. This is done as a stream of commands and is in the same format of the Redis protocol itself.
+
+You can try it yourself via telnet. Connect to the Redis port while the
+server is doing some work and issue the [`SYNC`](/commands/sync) command. You'll see a bulk
+transfer and then every command received by the master will be re-issued
+in the telnet session. Actually [`SYNC`](/commands/sync) is an old protocol no longer used by
+newer Redis instances, but is still there for backward compatibility: it does
+not allow partial resynchronizations, so now [`PSYNC`](/commands/psync) is used instead.
+
+As already said, replicas are able to automatically reconnect when the master-replica link goes down for some reason. If the master receives multiple concurrent replica synchronization requests, it performs a single background save in to serve all of them.
+
+## Replication ID explained
+
+In the previous section we said that if two instances have the same replication
+ID and replication offset, they have exactly the same data. However it is useful
+to understand what exactly is the replication ID, and why instances have actually
+two replication IDs: the main ID and the secondary ID.
+
+A replication ID basically marks a given *history* of the data set. Every time
+an instance restarts from scratch as a master, or a replica is promoted to master,
+a new replication ID is generated for this instance. The replicas connected to
+a master will inherit its replication ID after the handshake. So two instances
+with the same ID are related by the fact that they hold the same data, but
+potentially at a different time. It is the offset that works as a logical time
+to understand, for a given history (replication ID), who holds the most updated
+data set.
+
+For instance, if two instances A and B have the same replication ID, but one
+with offset 1000 and one with offset 1023, it means that the first lacks certain
+commands applied to the data set. It also means that A, by applying just a few
+commands, may reach exactly the same state of B.
+
+The reason why Redis instances have two replication IDs is because of replicas
+that are promoted to masters. After a failover, the promoted replica requires
+to still remember what was its past replication ID, because such replication ID
+was the one of the former master. In this way, when other replicas will sync
+with the new master, they will try to perform a partial resynchronization using the
+old master replication ID. This will work as expected, because when the replica
+is promoted to master it sets its secondary ID to its main ID, remembering what
+was the offset when this ID switch happened. Later it will select a new random
+replication ID, because a new history begins. When handling the new replicas
+connecting, the master will match their IDs and offsets both with the current
+ID and the secondary ID (up to a given offset, for safety). In short this means
+that after a failover, replicas connecting to the newly promoted master don't have
+to perform a full sync.
+
+In case you wonder why a replica promoted to master needs to change its
+replication ID after a failover: it is possible that the old master is still
+working as a master because of some network partition: retaining the same
+replication ID would violate the fact that the same ID and same offset of any
+two random instances mean they have the same data set.
+
+## Diskless replication
+
+Normally a full resynchronization requires creating an RDB file on disk,
+then reloading the same RDB from disk to feed the replicas with the data.
+
+With slow disks this can be a very stressing operation for the master.
+Redis version 2.8.18 is the first version to have support for diskless
+replication. In this setup the child process directly sends the
+RDB over the wire to replicas, without using the disk as intermediate storage.
+
+## Configuration
+
+To configure basic Redis replication is trivial: just add the following line to the replica configuration file:
+
+    replicaof 192.168.1.1 6379
+
+Of course you need to replace 192.168.1.1 6379 with your master IP address (or
+hostname) and port. Alternatively, you can call the [`REPLICAOF`](/commands/replicaof) command and the
+master host will start a sync with the replica.
+
+There are also a few parameters for tuning the replication backlog taken
+in memory by the master to perform the partial resynchronization. See the example
+`redis.conf` shipped with the Redis distribution for more information.
+
+Diskless replication can be enabled using the `repl-diskless-sync` configuration
+parameter. The delay to start the transfer to wait for more replicas to
+arrive after the first one is controlled by the `repl-diskless-sync-delay`
+parameter. Please refer to the example `redis.conf` file in the Redis distribution
+for more details.
+
+## Read-only replica
+
+Since Redis 2.6, replicas support a read-only mode that is enabled by default.
+This behavior is controlled by the `replica-read-only` option in the redis.conf file, and can be enabled and disabled at runtime using [`CONFIG SET`](/commands/config-set).
+
+Read-only replicas will reject all write commands, so that it is not possible to write to a replica because of a mistake. This does not mean that the feature is intended to expose a replica instance to the internet or more generally to a network where untrusted clients exist, because administrative commands like [`DEBUG`](/commands/debug) or [`CONFIG`](/commands/config) are still enabled. The [Security]({{< relref "/operate/oss_and_stack/management/security/" >}}) page describes how to secure a Redis instance.
+
+You may wonder why it is possible to revert the read-only setting
+and have replica instances that can be targeted by write operations.
+The answer is that writable replicas exist only for historical reasons.
+Using writable replicas can result in inconsistency between the master and the replica, so it is not recommended to use writable replicas.
+To understand in which situations this can be a problem, we need to understand how replication works.
+Changes on the master is replicated by propagating regular Redis commands to the replica.
+When a key expires on the master, this is propagated as a DEL command.
+If a key which exists on the master but is deleted, expired or has a different type on the replica compared to the master will react differently to commands like DEL, INCR or RPOP propagated from the master than intended.
+The propagated command may fail on the replica or result in a different outcome.
+To minimize the risks (if you insist on using writable replicas) we suggest you follow these recommendations:
+
+* Don't write to keys in a writable replica that are also used on the master.
+  (This can be hard to guarantee if you don't have control over all the clients that write to the master.)
+
+* Don't configure an instance as a writable replica as an intermediary step when upgrading a set of instances in a running system.
+  In general, don't configure an instance as a writable replica if it can ever be promoted to a master if you want to guarantee data consistency.
+
+Historically, there were some use cases that were considered legitimate for writable replicas.
+As of version 7.0, these use cases are now all obsolete and the same can be achieved by other means.
+For example:
+
+* Computing slow Set or Sorted set operations and storing the result in temporary local keys using commands like [`SUNIONSTORE`](/commands/sunionstore) and [`ZINTERSTORE`](/commands/zinterstore).
+  Instead, use commands that return the result without storing it, such as [`SUNION`](/commands/sunion) and [`ZINTER`](/commands/zinter).
+
+* Using the [`SORT`](/commands/sort) command (which is not considered a read-only command because of the optional STORE option and therefore cannot be used on a read-only replica).
+  Instead, use [`SORT_RO`](/commands/sort_ro), which is a read-only command.
+
+* Using [`EVAL`](/commands/eval) and [`EVALSHA`](/commands/evalsha) are also not considered read-only commands, because the Lua script may call write commands.
+  Instead, use [`EVAL_RO`](/commands/eval_ro) and [`EVALSHA_RO`](/commands/evalsha_ro) where the Lua script can only call read-only commands.
+
+While writes to a replica will be discarded if the replica and the master resync or if the replica is restarted, there is no guarantee that they will sync automatically.
+
+Before version 4.0, writable replicas were incapable of expiring keys with a time to live set.
+This means that if you use [`EXPIRE`](/commands/expire) or other commands that set a maximum TTL for a key, the key will leak, and while you may no longer see it while accessing it with read commands, you will see it in the count of keys and it will still use memory.
+Redis 4.0 RC3 and greater versions are able to evict keys with TTL as masters do, with the exceptions of keys written in DB numbers greater than 63 (but by default Redis instances only have 16 databases).
+Note though that even in versions greater than 4.0, using [`EXPIRE`](/commands/expire) on a key that could ever exists on the master can cause inconsistency between the replica and the master.
+
+Also note that since Redis 4.0 replica writes are only local, and are not propagated to sub-replicas attached to the instance. Sub-replicas instead will always receive the replication stream identical to the one sent by the top-level master to the intermediate replicas. So for example in the following setup:
+
+    A ---> B ---> C
+
+Even if `B` is writable, C will not see `B` writes and will instead have identical dataset as the master instance `A`.
+
+## Setting a replica to authenticate to a master
+
+If your master has a password via `requirepass`, it's trivial to configure the
+replica to use that password in all sync operations.
+
+To do it on a running instance, use `redis-cli` and type:
+
+    config set masterauth <password>
+
+To set it permanently, add this to your config file:
+
+    masterauth <password>
+
+## Allow writes only with N attached replicas
+
+Starting with Redis 2.8, you can configure a Redis master to
+accept write queries only if at least N replicas are currently connected to the
+master.
+
+However, because Redis uses asynchronous replication it is not possible to ensure
+the replica actually received a given write, so there is always a window for data
+loss.
+
+This is how the feature works:
+
+* Redis replicas ping the master every second, acknowledging the amount of replication stream processed.
+* Redis masters will remember the last time it received a ping from every replica.
+* The user can configure a minimum number of replicas that have a lag not greater than a maximum number of seconds.
+
+If there are at least N replicas, with a lag less than M seconds, then the write will be accepted.
+
+You may think of it as a best effort data safety mechanism, where consistency is not ensured for a given write, but at least the time window for data loss is restricted to a given number of seconds. In general bound data loss is better than unbound one.
+
+If the conditions are not met, the master will instead reply with an error and the write will not be accepted.
+
+There are two configuration parameters for this feature:
+
+* min-replicas-to-write `<number of replicas>`
+* min-replicas-max-lag `<number of seconds>`
+
+For more information, please check the example `redis.conf` file shipped with the
+Redis source distribution.
+
+## How Redis replication deals with expires on keys
+
+Redis expires allow keys to have a limited time to live (TTL). Such a feature depends
+on the ability of an instance to count the time, however Redis replicas correctly
+replicate keys with expires, even when such keys are altered using Lua
+scripts.
+
+To implement such a feature Redis cannot rely on the ability of the master and
+replica to have synced clocks, since this is a problem that cannot be solved
+and would result in race conditions and diverging data sets, so Redis
+uses three main techniques to make the replication of expired keys
+able to work:
+
+1. Replicas don't expire keys, instead they wait for masters to expire the keys. When a master expires a key (or evict it because of LRU), it synthesizes a [`DEL`](/commands/del) command which is transmitted to all the replicas.
+2. However because of master-driven expire, sometimes replicas may still have in memory keys that are already logically expired, since the master was not able to provide the [`DEL`](/commands/del) command in time. To deal with that the replica uses its logical clock to report that a key does not exist **only for read operations** that don't violate the consistency of the data set (as new commands from the master will arrive). In this way replicas avoid reporting logically expired keys that are still existing. In practical terms, an HTML fragments cache that uses replicas to scale will avoid returning items that are already older than the desired time to live.
+3. During Lua scripts executions no key expiries are performed. As a Lua script runs, conceptually the time in the master is frozen, so that a given key will either exist or not for all the time the script runs. This prevents keys expiring in the middle of a script, and is needed to send the same script to the replica in a way that is guaranteed to have the same effects in the data set.
+
+Once a replica is promoted to a master it will start to expire keys independently, and will not require any help from its old master.
+
+## Configuring replication in Docker and NAT
+
+When Docker, or other types of containers using port forwarding, or Network Address Translation is used, Redis replication needs some extra care, especially when using Redis Sentinel or other systems where the master [`INFO`](/commands/info) or [`ROLE`](/commands/role) commands output is scanned to discover replicas' addresses.
+
+The problem is that the [`ROLE`](/commands/role) command, and the replication section of
+the [`INFO`](/commands/info) output, when issued into a master instance, will show replicas
+as having the IP address they use to connect to the master, which, in
+environments using NAT may be different compared to the logical address of the
+replica instance (the one that clients should use to connect to replicas).
+
+Similarly the replicas will be listed with the listening port configured
+into `redis.conf`, that may be different from the forwarded port in case
+the port is remapped.
+
+To fix both issues, it is possible, since Redis 3.2.2, to force
+a replica to announce an arbitrary pair of IP and port to the master.
+The two configurations directives to use are:
+
+    replica-announce-ip 5.5.5.5
+    replica-announce-port 1234
+
+And are documented in the example `redis.conf` of recent Redis distributions.
+
+## The INFO and ROLE command
+
+There are two Redis commands that provide a lot of information on the current
+replication parameters of master and replica instances. One is [`INFO`](/commands/info). If the
+command is called with the `replication` argument as `INFO replication` only
+information relevant to the replication are displayed. Another more
+computer-friendly command is [`ROLE`](/commands/role), that provides the replication status of
+masters and replicas together with their replication offsets, list of connected
+replicas and so forth.
+
+## Partial sync after restarts and failovers
+
+Since Redis 4.0, when an instance is promoted to master after a failover,
+it will still be able to perform a partial resynchronization with the replicas
+of the old master. To do so, the replica remembers the old replication ID and
+offset of its former master, so can provide part of the backlog to the connecting
+replicas even if they ask for the old replication ID.
+
+However the new replication ID of the promoted replica will be different, since it
+constitutes a different history of the data set. For example, the master can
+return available and can continue accepting writes for some time, so using the
+same replication ID in the promoted replica would violate the rule that a
+replication ID and offset pair identifies only a single data set.
+
+Moreover, replicas - when powered off gently and restarted - are able to store
+in the `RDB` file the information needed to resync with their
+master. This is useful in case of upgrades. When this is needed, it is better to
+use the [`SHUTDOWN`](/commands/shutdown) command in order to perform a `save & quit` operation on the
+replica.
+
+It is not possible to partially sync a replica that restarted via the
+AOF file. However the instance may be turned to RDB persistence before shutting
+down it, than can be restarted, and finally AOF can be enabled again.
+
+## `Maxmemory` on replicas
+
+By default, a replica will ignore `maxmemory` (unless it is promoted to master after a failover or manually).
+It means that the eviction of keys will be handled by the master, sending the DEL commands to the replica as keys evict in the master side.
+
+This behavior ensures that masters and replicas stay consistent, which is usually what you want.
+However, if your replica is writable, or you want the replica to have a different memory setting, and you are sure all the writes performed to the replica are idempotent, then you may change this default (but be sure to understand what you are doing).
+
+Note that since the replica by default does not evict, it may end up using more memory than what is set via `maxmemory` (since there are certain buffers that may be larger on the replica, or data structures may sometimes take more memory and so forth).
+Make sure you monitor your replicas, and make sure they have enough memory to never hit a real out-of-memory condition before the master hits the configured `maxmemory` setting.
+
+To change this behavior, you can allow a replica to not ignore the `maxmemory`. The configuration directives to use is:
+
+    replica-ignore-maxmemory no
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Advice for configuring and managing Redis in production
+linkTitle: Administration
+title: Redis administration
+weight: 1
+---
+
+## 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.
+
+* Set the Linux kernel overcommit memory setting to 1. Add `vm.overcommit_memory = 1` to `/etc/sysctl.conf`. Then, reboot or run the command `sysctl vm.overcommit_memory=1` to activate the setting. See [FAQ: Background saving fails with a fork() error on Linux?]({{< relref "develop/get-started/faq/#background-saving-fails-with-a-fork-error-on-linux" >}}) for details. 
+
+* To ensure the Linux kernel feature Transparent Huge Pages does not impact Redis memory usage and latency, run the command: `echo never > /sys/kernel/mm/transparent_hugepage/enabled` to disable it. See [Latency Diagnosis - Latency induced by transparent huge pages]({{< relref "operate/oss_and_stack/management/optimization/latency#latency-induced-by-transparent-huge-pages" >}}) for additional context. 
+
+### Memory
+
+* Ensured that swap is enabled and that your swap file size is equal to amount of memory on your system. If Linux does not have swap set up, and your Redis instance accidentally consumes too much memory, Redis can crash when it is out of memory, or the Linux kernel OOM killer can kill the Redis process. When swapping is enabled, you can detect latency spikes and act on them.
+
+* Set an explicit `maxmemory` option limit in your instance to make sure that it will report errors instead of failing when the system memory limit is near to be reached. Note that `maxmemory` should be set by calculating the overhead for Redis, other than data, and the fragmentation overhead. So if you think you have 10 GB of free memory, set it to 8 or 9.
+
+* If you are using Redis in a write-heavy application, while saving an RDB file on disk or rewriting the AOF log, Redis can use up to 2 times the memory normally used. The additional memory used is proportional to the number of memory pages modified by writes during the saving process, so it is often proportional to the number of keys (or aggregate types items) touched during this time. Make sure to size your memory accordingly.
+
+* See the [`LATENCY DOCTOR`](/commands/latency-doctor) and [`MEMORY DOCTOR`](/commands/memory-doctor) commands to assist in troubleshooting.
+
+### Imaging
+
+* When running under daemontools, use `daemonize no`.
+
+### Replication
+
+* Set up a non-trivial replication backlog in proportion to the amount of memory Redis is using. The backlog allows replicas to sync with the primary (master) instance much more easily.
+
+* If you use replication, Redis performs RDB saves even if persistence is disabled. (This does not apply to diskless replication.) If you don't have disk usage on the master, enable diskless replication.
+
+* If you are using replication, ensure that either your master has persistence enabled, or that it does not automatically restart on crashes. Replicas will try to maintain an exact copy of the master, so if a master restarts with an empty data set, replicas will be wiped as well.
+
+### Security
+
+* By default, Redis does not require any authentication and listens to all the network interfaces. This is a big security issue if you leave Redis exposed on the internet or other places where attackers can reach it. See for example [this attack](http://antirez.com/news/96) to see how dangerous it can be. Please check our [security page]({{< relref "/operate/oss_and_stack/management/security/" >}}) for information about how to secure Redis.
+
+## Running Redis on EC2
+
+* Use HVM based instances, not PV based instances.
+* Do not use old instance families. For example, use m3.medium with HVM instead of m1.medium with PV.
+* The use of Redis persistence with EC2 EBS volumes needs to be handled with care because sometimes EBS volumes have high latency characteristics.
+* You may want to try the new diskless replication if you have issues when replicas are synchronizing with the master.
+
+## Upgrading or restarting a Redis instance without downtime
+
+Redis is designed to be a long-running process in your server. You can modify many configuration options without a restart using the [`CONFIG SET`](/commands/config-set) command. You can also switch from AOF to RDB snapshots persistence, or the other way around, without restarting Redis. Check the output of the `CONFIG GET *` command for more information.
+
+From time to time, a restart is required, for example, to upgrade the Redis process to a newer version, or when you need to modify a configuration parameter that is currently not supported by the [`CONFIG`](/commands/config) command.
+
+Follow these steps to avoid downtime.
+
+* Set up your new Redis instance as a replica for your current Redis instance. In order to do so, you need a different server, or a server that has enough RAM to keep two instances of Redis running at the same time.
+
+* If you use a single server, ensure that the replica is started on a different port than the master instance, otherwise the replica cannot start.
+
+* Wait for the replication initial synchronization to complete. Check the replica's log file.
+
+* Using [`INFO`](/commands/info), ensure the master and replica have the same number of keys. Use `redis-cli` to check that the replica is working as expected and is replying to your commands.
+
+* Allow writes to the replica using `CONFIG SET slave-read-only no`.
+
+* Configure all your clients to use the new instance (the replica). Note that you may want to use the [`CLIENT PAUSE`](/commands/client-pause) command to ensure that no client can write to the old master during the switch.
+
+* Once you confirm that the master is no longer receiving any queries (you can check this using the [`MONITOR`](/commands/monitor) command), elect the replica to master using the `REPLICAOF NO ONE` command, and then shut down your master.
+
+If you are using [Redis Sentinel]({{< relref "/operate/oss_and_stack/management/sentinel" >}}) or [Redis Cluster]({{< relref "/operate/oss_and_stack/management/scaling" >}}), the simplest way to upgrade to newer versions is to upgrade one replica after the other. Then you can perform a manual failover to promote one of the upgraded replicas to master, and finally promote the last replica.
+
+---
+**NOTE** 
+
+Redis Cluster 4.0 is not compatible with Redis Cluster 3.2 at cluster bus protocol level, so a mass restart is needed in this case. However, Redis 5 cluster bus is backward compatible with Redis 4.
+
+---
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Problems with Redis? Start here.
+linkTitle: Troubleshooting
+title: Troubleshooting Redis
+weight: 9
+---
+
+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]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}}).
+* 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]({{< relref "/operate/oss_and_stack/management/debugging" >}}).
+* 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](http://memtest86.com).
+
+For every other problem please drop a message to the [Redis Google Group](http://groups.google.com/group/redis-db). We will be glad to help.
+
+You can also find assistance on the [Redis Discord server](https://discord.gg/redis).
+
+### List of known critical bugs in Redis 3.0.x, 2.8.x and 2.6.x
+
+To find a list of critical bugs please refer to the changelogs:
+
+* [Redis 3.0 Changelog](https://raw.githubusercontent.com/redis/redis/3.0/00-RELEASENOTES).
+* [Redis 2.8 Changelog](https://raw.githubusercontent.com/redis/redis/2.8/00-RELEASENOTES).
+* [Redis 2.6 Changelog](https://raw.githubusercontent.com/redis/redis/2.6/00-RELEASENOTES).
+
+Check the *upgrade urgency* level in each patch release to more easily spot
+releases that included important fixes.
+
+### List of known Linux related bugs affecting Redis.
+
+* Ubuntu 10.04 and 10.10 contain [bugs](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/666211) that can cause performance issues. The default kernels shipped with these distributions are not recommended. Bugs were reported as having affected EC2 instances, but some users also cited server impact.
+* Certain versions of the Xen hypervisor report poor fork() performance. See [the latency page]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}}) for more information.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Redis Access Control List
+linkTitle: ACL
+title: ACL
+weight: 1
+---
+
+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.
+
+In the default configuration, Redis 6 (the first version to have ACLs) works
+exactly like older versions of Redis. Every new connection is
+capable of calling every possible command and accessing every key, so the
+ACL feature is backward compatible with old clients and applications. Also
+the old way to configure a password, using the **requirepass** configuration
+directive, still works as expected. However, it now
+sets a password for the default user.
+
+The Redis [`AUTH`](/commands/auth) command was extended in Redis 6, so now it is possible to
+use it in the two-arguments form:
+
+    AUTH <username> <password>
+
+Here's an example of the old form:
+
+    AUTH <password>
+
+What happens is that the username used to authenticate is "default", so
+just specifying the password implies that we want to authenticate against
+the default user. This provides backward compatibility.
+
+## When ACLs are useful
+
+Before using ACLs, you may want to ask yourself what's the goal you want to
+accomplish by implementing this layer of protection. Normally there are
+two main goals that are well served by ACLs:
+
+1. You want to improve security by restricting the access to commands and keys, so that untrusted clients have no access and trusted clients have just the minimum access level to the database in order to perform the work needed. For instance, certain clients may just be able to execute read only commands.
+2. You want to improve operational safety, so that processes or humans accessing Redis are not allowed to damage the data or the configuration due to software errors or manual mistakes. For instance, there is no reason for a worker that fetches delayed jobs from Redis to be able to call the [`FLUSHALL`](/commands/flushall) command.
+
+Another typical usage of ACLs is related to managed Redis instances. Redis is
+often provided as a managed service both by internal company teams that handle
+the Redis infrastructure for the other internal customers they have, or is
+provided in a software-as-a-service setup by cloud providers. In both 
+setups, we want to be sure that configuration commands are excluded for the
+customers.
+
+## Configure ACLs with the ACL command
+
+ACLs are defined using a DSL (domain specific language) that describes what
+a given user is allowed to do. Such rules are always implemented from the
+first to the last, left-to-right, because sometimes the order of the rules is
+important to understand what the user is really able to do.
+
+By default there is a single user defined, called *default*. We
+can use the [`ACL LIST`](/commands/acl-list) command in order to check the currently active ACLs
+and verify what the configuration of a freshly started, defaults-configured
+Redis instance is:
+
+    > ACL LIST
+    1) "user default on nopass ~* &* +@all"
+
+The command above reports the list of users in the same format that is
+used in the Redis configuration files, by translating the current ACLs set
+for the users back into their description.
+
+The first two words in each line are "user" followed by the username. The
+next words are ACL rules that describe different things. We'll show how the rules work in detail, but for now it is enough to say that the default
+user is configured to be active (on), to require no password (nopass), to
+access every possible key (`~*`) and Pub/Sub channel (`&*`), and be able to
+call every possible command (`+@all`).
+
+Also, in the special case of the default user, having the *nopass* rule means
+that new connections are automatically authenticated with the default user
+without any explicit [`AUTH`](/commands/auth) call needed.
+
+## ACL rules
+
+The following is the list of valid ACL rules. Certain rules are just
+single words that are used in order to activate or remove a flag, or to
+perform a given change to the user ACL. Other rules are char prefixes that
+are concatenated with command or category names, key patterns, and
+so forth.
+
+Enable and disallow users:
+
+* `on`: Enable the user: it is possible to authenticate as this user.
+* `off`: Disallow the user: it's no longer possible to authenticate with this user; however, previously authenticated connections will still work. Note that if the default user is flagged as *off*, new connections will start as not authenticated and will require the user to send [`AUTH`](/commands/auth) or [`HELLO`](/commands/hello) with the AUTH option in order to authenticate in some way, regardless of the default user configuration.
+
+Allow and disallow commands:
+
+* `+<command>`: Add the command to the list of commands the user can call. Can be used with `|` for allowing subcommands (e.g "+config|get").
+* `-<command>`: Remove the command to the list of commands the user can call. Starting Redis 7.0, it can be used with `|` for blocking subcommands (e.g "-config|set").
+* `+@<category>`: Add all the commands in such category to be called by the user, with valid categories being like @admin, @set, @sortedset, ... and so forth, see the full list by calling the [`ACL CAT`](/commands/acl-cat) command. The special category @all means all the commands, both the ones currently present in the server, and the ones that will be loaded in the future via modules.
+* `-@<category>`: Like `+@<category>` but removes the commands from the list of commands the client can call.
+* `+<command>|first-arg`: Allow a specific first argument of an otherwise disabled command. It is only supported on commands with no sub-commands, and is not allowed as negative form like -SELECT|1, only additive starting with "+". This feature is deprecated and may be removed in the future.
+* `allcommands`: Alias for +@all. Note that it implies the ability to execute all the future commands loaded via the modules system.
+* `nocommands`: Alias for -@all.
+
+Allow and disallow certain keys and key permissions:
+
+* `~<pattern>`: Add a pattern of keys that can be mentioned as part of commands. For instance `~*` allows all the keys. The pattern is a glob-style pattern like the one of [`KEYS`](/commands/keys). It is possible to specify multiple patterns.
+* `%R~<pattern>`: (Available in Redis 7.0 and later) Add the specified read key pattern. This behaves similar to the regular key pattern but only grants permission to read from keys that match the given pattern. See [key permissions](#key-permissions) for more information.
+* `%W~<pattern>`: (Available in Redis 7.0 and later) Add the specified write key pattern. This behaves similar to the regular key pattern but only grants permission to write to keys that match the given pattern. See [key permissions](#key-permissions) for more information.
+* `%RW~<pattern>`: (Available in Redis 7.0 and later) Alias for `~<pattern>`. 
+* `allkeys`: Alias for `~*`.
+* `resetkeys`: Flush the list of allowed keys patterns. For instance the ACL `~foo:* ~bar:* resetkeys ~objects:*`, will only allow the client to access keys that match the pattern `objects:*`.
+
+Allow and disallow Pub/Sub channels:
+
+* `&<pattern>`: (Available in Redis 6.2 and later) Add a glob style pattern of Pub/Sub channels that can be accessed by the user. It is possible to specify multiple channel patterns. Note that pattern matching is done only for channels mentioned by [`PUBLISH`](/commands/publish) and [`SUBSCRIBE`](/commands/subscribe), whereas [`PSUBSCRIBE`](/commands/psubscribe) requires a literal match between its channel patterns and those allowed for user.
+* `allchannels`: Alias for `&*` that allows the user to access all Pub/Sub channels.
+* `resetchannels`: Flush the list of allowed channel patterns and disconnect the user's Pub/Sub clients if these are no longer able to access their respective channels and/or channel patterns.
+
+Configure valid passwords for the user:
+
+* `><password>`: Add this password to the list of valid passwords for the user. For example `>mypass` will add "mypass" to the list of valid passwords.  This directive clears the *nopass* flag (see later). Every user can have any number of passwords.
+* `<<password>`: Remove this password from the list of valid passwords. Emits an error in case the password you are trying to remove is actually not set.
+* `#<hash>`: Add this SHA-256 hash value to the list of valid passwords for the user. This hash value will be compared to the hash of a password entered for an ACL user. This allows users to store hashes in the `acl.conf` file rather than storing cleartext passwords. Only SHA-256 hash values are accepted as the password hash must be 64 characters and only contain lowercase hexadecimal characters.
+* `!<hash>`: Remove this hash value from the list of valid passwords. This is useful when you do not know the password specified by the hash value but would like to remove the password from the user.
+* `nopass`: All the set passwords of the user are removed, and the user is flagged as requiring no password: it means that every password will work against this user. If this directive is used for the default user, every new connection will be immediately authenticated with the default user without any explicit AUTH command required. Note that the *resetpass* directive will clear this condition.
+* `resetpass`: Flushes the list of allowed passwords and removes the *nopass* status. After *resetpass*, the user has no associated passwords and there is no way to authenticate without adding some password (or setting it as *nopass* later).
+
+*Note: if a user is not flagged with nopass and has no list of valid passwords, that user is effectively impossible to use because there will be no way to log in as that user.*
+
+Configure selectors for the user:
+
+* `(<rule list>)`: (Available in Redis 7.0 and later) Create a new selector to match rules against. Selectors are evaluated after the user permissions, and are evaluated according to the order they are defined. If a command matches either the user permissions or any selector, it is allowed. See [selectors](#selectors) for more information.
+* `clearselectors`: (Available in Redis 7.0 and later) Delete all of the selectors attached to the user.
+
+Reset the user:
+
+* `reset` Performs the following actions: resetpass, resetkeys, resetchannels, allchannels (if acl-pubsub-default is set), off, clearselectors, -@all. The user returns to the same state it had immediately after its creation.
+
+## Create and edit user ACLs with the ACL SETUSER command
+
+Users can be created and modified in two main ways:
+
+1. Using the ACL command and its [`ACL SETUSER`](/commands/acl-setuser) subcommand.
+2. Modifying the server configuration, where users can be defined, and restarting the server. With an *external ACL file*, just call [`ACL LOAD`](/commands/acl-load).
+
+In this section we'll learn how to define users using the [`ACL`](/commands/acl) command.
+With such knowledge, it will be trivial to do the same things via the
+configuration files. Defining users in the configuration deserves its own
+section and will be discussed later separately.
+
+To start, try the simplest [`ACL SETUSER`](/commands/acl-setuser) command call:
+
+    > ACL SETUSER alice
+    OK
+
+The [`ACL SETUSER`](/commands/acl-setuser) command takes the username and a list of ACL rules to apply
+to the user. However the above example did not specify any rule at all.
+This will just create the user if it did not exist, using the defaults for new
+users. If the user already exists, the command above will do nothing at all.
+
+Check the default user status:
+
+    > ACL LIST
+    1) "user alice off resetchannels -@all"
+    2) "user default on nopass ~* &* +@all"
+
+The new user "alice" is:
+
+* In the off status, so [`AUTH`](/commands/auth) will not work for the user "alice".
+* The user also has no passwords set.
+* Cannot access any command. Note that the user is created by default without the ability to access any command, so the `-@all` in the output above could be omitted; however, [`ACL LIST`](/commands/acl-list) attempts to be explicit rather than implicit.
+* There are no key patterns that the user can access.
+* There are no Pub/Sub channels that the user can access.
+
+New users are created with restrictive permissions by default. Starting with Redis 6.2, ACL provides Pub/Sub channels access management as well. To ensure backward compatibility with version 6.0 when upgrading to Redis 6.2, new users are granted the 'allchannels' permission by default. The default can be set to `resetchannels` via the `acl-pubsub-default` configuration directive.
+
+From 7.0, The `acl-pubsub-default` value is set to `resetchannels` to restrict the channels access by default to provide better security.
+The default can be set to `allchannels` via the `acl-pubsub-default` configuration directive to be compatible with previous versions.
+
+Such user is completely useless. Let's try to define the user so that
+it is active, has a password, and can access with only the [`GET`](/commands/get) command
+to key names starting with the string "cached:".
+
+    > ACL SETUSER alice on >p1pp0 ~cached:* +get
+    OK
+
+Now the user can do something, but will refuse to do other things:
+
+    > AUTH alice p1pp0
+    OK
+    > GET foo
+    (error) NOPERM this user has no permissions to access one of the keys used as arguments
+    > GET cached:1234
+    (nil)
+    > SET cached:1234 zap
+    (error) NOPERM this user has no permissions to run the 'set' command
+
+Things are working as expected. In order to inspect the configuration of the
+user alice (remember that user names are case sensitive), it is possible to
+use an alternative to [`ACL LIST`](/commands/acl-list) which is designed to be more suitable for
+computers to read, while [`ACL GETUSER`](/commands/acl-getuser) is more human readable.
+
+    > ACL GETUSER alice
+    1) "flags"
+    2) 1) "on"
+    3) "passwords"
+    4) 1) "2d9c75..."
+    5) "commands"
+    6) "-@all +get"
+    7) "keys"
+    8) "~cached:*"
+    9) "channels"
+    10) ""
+    11) "selectors"
+    12) (empty array)
+
+The [`ACL GETUSER`](/commands/acl-getuser) returns a field-value array that describes the user in more parsable terms. The output includes the set of flags, a list of key patterns, passwords, and so forth. The output is probably more readable if we use RESP3, so that it is returned as a map reply:
+
+    > ACL GETUSER alice
+    1# "flags" => 1~ "on"
+    2# "passwords" => 1) "2d9c75273d72b32df726fb545c8a4edc719f0a95a6fd993950b10c474ad9c927"
+    3# "commands" => "-@all +get"
+    4# "keys" => "~cached:*"
+    5# "channels" => ""
+    6# "selectors" => (empty array)
+
+*Note: from now on, we'll continue using the Redis default protocol, version 2*
+
+Using another [`ACL SETUSER`](/commands/acl-setuser) command (from a different user, because alice cannot run the [`ACL`](/commands/acl) command), we can add multiple patterns to the user:
+
+    > ACL SETUSER alice ~objects:* ~items:* ~public:*
+    OK
+    > ACL LIST
+    1) "user alice on #2d9c75... ~cached:* ~objects:* ~items:* ~public:* resetchannels -@all +get"
+    2) "user default on nopass ~* &* +@all"
+
+The user representation in memory is now as we expect it to be.
+
+## Multiple calls to ACL SETUSER
+
+It is very important to understand what happens when [`ACL SETUSER`](/commands/acl-setuser) is called
+multiple times. What is critical to know is that every [`ACL SETUSER`](/commands/acl-setuser) call will
+NOT reset the user, but will just apply the ACL rules to the existing user.
+The user is reset only if it was not known before. In that case, a brand new
+user is created with zeroed-ACLs. The user cannot do anything, is
+disallowed, has no passwords, and so forth. This is the best default for safety.
+
+However later calls will just modify the user incrementally. For instance,
+the following sequence:
+
+    > ACL SETUSER myuser +set
+    OK
+    > ACL SETUSER myuser +get
+    OK
+
+Will result in myuser being able to call both [`GET`](/commands/get) and [`SET`](/commands/set):
+
+    > ACL LIST
+    1) "user default on nopass ~* &* +@all"
+    2) "user myuser off resetchannels -@all +get +set"
+
+## Command categories
+
+Setting user ACLs by specifying all the commands one after the other is
+really annoying, so instead we do things like this:
+
+    > ACL SETUSER antirez on +@all -@dangerous >42a979... ~*
+
+The above command includes all commands (`+@all`) and then removes all commands tagged as dangerous (`-@dangerous`) inside the Redis command table.
+Note that command categories, with the exception of `+@all`, never include module commands.
+
+If you use `+@all` for a particular user, all commands are available to that user, including commands loaded via the modules system. However, if you use `+@read` or any other, module commands are excluded. This concept is fundamental because you should only trust the Redis
+internal command table. Modules may expose dangerous things, and in
+the case of an ACL that is just additive, that is, in the form of `+@all -...`,
+you should be absolutely sure that you won't include what you did not mean to.
+
+The following is a list of command categories and their meanings:
+
+* **admin** - Administrative commands. Normal applications will never need to use
+  these. Includes [`REPLICAOF`](/commands/replicaof), [`CONFIG`](/commands/config), [`DEBUG`](/commands/debug), [`SAVE`](/commands/save), [`MONITOR`](/commands/monitor), [`ACL`](/commands/acl), [`SHUTDOWN`](/commands/shutdown), etc.
+* **bitmap** - Data type: all bitmap related commands.
+* **blocking** - Potentially blocking the connection until released by another
+  command.
+* **bloom** - Data type: all Bloom filter related commands.
+* **cms** - Data type: count-min sketch related commands.
+* **connection** - Commands affecting the connection or other connections.
+  This includes [`AUTH`](/commands/auth), [`SELECT`](/commands/select), [`COMMAND`](/commands/command), [`CLIENT`](/commands/client), [`ECHO`](/commands/echo), [`PING`](/commands/ping), etc.
+* **cuckoo** - Data type: all Cuckoo filter related commands.
+* **dangerous** - Potentially dangerous commands (each should be considered with care for
+  various reasons). This includes [`FLUSHALL`](/commands/flushall), [`MIGRATE`](/commands/migrate), [`RESTORE`](/commands/restore), [`SORT`](/commands/sort), [`KEYS`](/commands/keys),
+  [`CLIENT`](/commands/client), [`DEBUG`](/commands/debug), [`INFO`](/commands/info), [`CONFIG`](/commands/config), [`SAVE`](/commands/save), [`REPLICAOF`](/commands/replicaof), etc.
+* **fast** - Fast O(1) commands. May loop on the number of arguments, but not the number of elements in the key.
+* **geo** - Data type: all geospatial index related commands.
+* **hash** - Data type: all hash related commands.
+* **hyperloglog** - Data type: all hyperloglog related commands.
+* **json** - Data type: all JSON related commands.
+* **keyspace** - Writing or reading from keys, databases, or their metadata 
+  in a type agnostic way. Includes [`DEL`](/commands/del), [`RESTORE`](/commands/restore), [`DUMP`](/commands/dump), [`RENAME`](/commands/rename), [`EXISTS`](/commands/exists), [`DBSIZE`](/commands/dbsize),
+  [`KEYS`](/commands/keys), [`EXPIRE`](/commands/expire), [`TTL`](/commands/ttl), [`FLUSHALL`](/commands/flushall), etc. Commands that may modify the keyspace,
+  key, or metadata will also have the `write` category. Commands that only read
+  the keyspace, key, or metadata will have the `read` category.
+* **list** - Data type: all list related commands.
+* **pubsub** - all pubsub related commands.
+* **read** - Reading from keys (values or metadata). Note that commands that don't interact with keys, will not have either `read` or `write`.
+* **scripting** - Scripting related.
+* **search** - All search related commands. Note that indexes can only be created/modified if their key prefixes are a superset of the keys to which a user has access. For example, a user with the key ACL pattern `h:*` can create an index with keys prefixed by `h:*` or `h:p*`, but not keys prefixed by `h*`, `k:*`, or `k*`, because these prefixes may involve keys to which the user has access.
+* **set** - Data type: all set related commands.
+* **sortedset** - Data type: all sorted set related commands.
+* **slow** - All commands that are not `fast`.
+* **stream** - Data type: all stream related commands.
+* **string** - Data type: all string related commands.
+* **tdigest** - Data type: all t-digest related commands.
+* **timeseries** - Data type: all time series related commands.
+* **topk** - Data type: all top-k related commands.
+* **transaction** - [`WATCH`](/commands/watch) / [`MULTI`](/commands/multi) / [`EXEC`](/commands/exec) related commands.
+* **write** - Writing to keys (values or metadata). Note that commands that don't interact with keys, will not have either `read` or `write`.
+
+Redis can also show you a list of all categories and the exact commands each category includes using the Redis [`ACL CAT`](/commands/acl-cat) command. It can be used in two forms:
+
+    ACL CAT -- Will just list all the categories available
+    ACL CAT <category-name> -- Will list all the commands inside the category
+
+Examples:
+
+```
+> ACL CAT
+ 1) "keyspace"
+ 2) "read"
+ 3) "write"
+ 4) "set"
+ 5) "sortedset"
+ 6) "list"
+ 7) "hash"
+ 8) "string"
+ 9) "bitmap"
+10) "hyperloglog"
+11) "geo"
+12) "stream"
+13) "pubsub"
+14) "admin"
+15) "fast"
+16) "slow"
+17) "blocking"
+18) "dangerous"
+19) "connection"
+20) "transaction"
+21) "scripting"
+22) "json"
+23) "search"
+24) "tdigest"
+25) "cms"
+26) "bloom"
+27) "cuckoo"
+28) "topk"
+29) "timeseries"
+```
+
+As you can see, so far there are 29 distinct categories. Now let's check what
+command is part of the *geo* category:
+
+```
+> ACL CAT geo
+1) "geohash"
+2) "georadius_ro"
+3) "georadiusbymember"
+4) "geopos"
+5) "geoadd"
+6) "georadiusbymember_ro"
+7) "geodist"
+8) "georadius"
+9) "geosearch"
+10) "geosearchstore"
+```
+
+Note that commands may be part of multiple categories. For example, an
+ACL rule like `+@geo -@read` will result in certain geo commands to be
+excluded because they are read-only commands.
+
+## Allow/block subcommands
+
+Starting from Redis 7.0, subcommands can be allowed/blocked just like other
+commands (by using the separator `|` between the command and subcommand, for
+example: `+config|get` or `-config|set`)
+
+That is true for all commands except DEBUG. In order to allow/block specific
+DEBUG subcommands, see the next section.
+
+## Allow the first-arg of a blocked command
+
+**Note: This feature is deprecated since Redis 7.0 and may be removed in the future.**
+
+Sometimes the ability to exclude or include a command or a subcommand as a whole is not enough.
+Many deployments may not be happy providing the ability to execute a [`SELECT`](/commands/select) for any DB, but may
+still want to be able to run `SELECT 0`.
+
+In such case we could alter the ACL of a user in the following way:
+
+    ACL SETUSER myuser -select +select|0
+
+First, remove the [`SELECT`](/commands/select) command and then add the allowed
+first-arg. Note that **it is not possible to do the reverse** since first-args
+can be only added, not excluded. It is safer to specify all the first-args
+that are valid for some user since it is possible that
+new first-args may be added in the future.
+
+Another example:
+
+    ACL SETUSER myuser -debug +debug|digest
+
+Note that first-arg matching may add some performance penalty; however, it is hard to measure even with synthetic benchmarks. The
+additional CPU cost is only paid when such commands are called, and not when
+other commands are called.
+
+It is possible to use this mechanism in order to allow subcommands in Redis
+versions prior to 7.0 (see above section).
+
+## +@all VS -@all
+
+In the previous section, it was observed how it is possible to define command
+ACLs based on adding/removing single commands.
+
+## Selectors
+
+Starting with Redis 7.0, Redis supports adding multiple sets of rules that are evaluated independently of each other.
+These secondary sets of permissions are called selectors and added by wrapping a set of rules within parentheses.
+In order to execute a command, either the root permissions (rules defined outside of parenthesis) or any of the selectors (rules defined inside parenthesis) must match the given command.
+Internally, the root permissions are checked first followed by selectors in the order they were added.
+
+For example, consider a user with the ACL rules `+GET ~key1 (+SET ~key2)`.
+This user is able to execute `GET key1` and `SET key2 hello`, but not `GET key2` or `SET key1 world`.
+
+Unlike the user's root permissions, selectors cannot be modified after they are added.
+Instead, selectors can be removed with the `clearselectors` keyword, which removes all of the added selectors.
+Note that `clearselectors` does not remove the root permissions.
+
+## Key permissions
+
+Starting with Redis 7.0, key patterns can also be used to define how a command is able to touch a key.
+This is achieved through rules that define key permissions.
+The key permission rules take the form of `%(<permission>)~<pattern>`.
+Permissions are defined as individual characters that map to the following key permissions:
+
+* W (Write): The data stored within the key may be updated or deleted. 
+* R (Read): User supplied data from the key is processed, copied or returned. Note that this does not include metadata such as size information (example [`STRLEN`](/commands/strlen)), type information (example [`TYPE`](/commands/type)) or information about whether a value exists within a collection (example [`SISMEMBER`](/commands/sismember)). 
+
+Permissions can be composed together by specifying multiple characters. 
+Specifying the permission as 'RW' is considered full access and is analogous to just passing in `~<pattern>`.
+
+For a concrete example, consider a user with ACL rules `+@all ~app1:* (+@read ~app2:*)`.
+This user has full access on `app1:*` and readonly access on `app2:*`.
+However, some commands support reading data from one key, doing some transformation, and storing it into another key.
+One such command is the [`COPY`](/commands/copy) command, which copies the data from the source key into the destination key.
+The example set of ACL rules is unable to handle a request copying data from `app2:user` into `app1:user`, since neither the root permission nor the selector fully matches the command.
+However, using key selectors you can define a set of ACL rules that can handle this request `+@all ~app1:* %R~app2:*`.
+The first pattern is able to match `app1:user` and the second pattern is able to match `app2:user`.
+
+Which type of permission is required for a command is documented through [key specifications]({{< relref "develop/reference/key-specs#logical-operation-flags" >}}).
+The type of permission is based off the keys logical operation flags. 
+The insert, update, and delete flags map to the write key permission. 
+The access flag maps to the read key permission.
+If the key has no logical operation flags, such as [`EXISTS`](/commands/exists), the user still needs either key read or key write permissions to execute the command. 
+
+Note: Side channels to accessing user data are ignored when it comes to evaluating whether read permissions are required to execute a command.
+This means that some write commands that return metadata about the modified key only require write permission on the key to execute.
+For example, consider the following two commands:
+
+* `LPUSH key1 data`: modifies "key1" but only returns metadata about it, the size of the list after the push, so the command only requires write permission on "key1" to execute.
+* `LPOP key2`: modifies "key2" but also returns data from it, the left most item in the list, so the command requires both read and write permission on "key2" to execute.
+
+If an application needs to make sure no data is accessed from a key, including side channels, it's recommended to not provide any access to the key.
+
+## How passwords are stored internally
+
+Redis internally stores passwords hashed with SHA256. If you set a password
+and check the output of [`ACL LIST`](/commands/acl-list) or [`ACL GETUSER`](/commands/acl-getuser), you'll see a long hex
+string that looks pseudo random. Here is an example, because in the previous
+examples, for the sake of brevity, the long hex string was trimmed:
+
+```
+> ACL GETUSER default
+1) "flags"
+2) 1) "on"
+3) "passwords"
+4) 1) "2d9c75273d72b32df726fb545c8a4edc719f0a95a6fd993950b10c474ad9c927"
+5) "commands"
+6) "+@all"
+7) "keys"
+8) "~*"
+9) "channels"
+10) "&*"
+11) "selectors"
+12) (empty array)
+```
+
+Using SHA256 provides the ability to avoid storing the password in clear text
+while still allowing for a very fast [`AUTH`](/commands/auth) command, which is a very important
+feature of Redis and is coherent with what clients expect from Redis.
+
+However ACL *passwords* are not really passwords. They are shared secrets
+between the server and the client, because the password is
+not an authentication token used by a human being. For instance:
+
+* There are no length limits, the password will just be memorized in some client software. There is no human that needs to recall a password in this context.
+* The ACL password does not protect any other thing. For example, it will never be the password for some email account.
+* Often when you are able to access the hashed password itself, by having full access to the Redis commands of a given server, or corrupting the system itself, you already have access to what the password is protecting: the Redis instance stability and the data it contains.
+
+For this reason, slowing down the password authentication, in order to use an
+algorithm that uses time and space to make password cracking hard,
+is a very poor choice. What we suggest instead is to generate strong
+passwords, so that nobody will be able to crack it using a
+dictionary or a brute force attack even if they have the hash. To do so, there is a special ACL
+command [`ACL GENPASS`](/commands/acl-genpass) that generates passwords using the system cryptographic pseudorandom
+generator:
+
+    > ACL GENPASS
+    "dd721260bfe1b3d9601e7fbab36de6d04e2e67b0ef1c53de59d45950db0dd3cc"
+
+The command outputs a 32-byte (256-bit) pseudorandom string converted to a
+64-byte alphanumerical string. This is long enough to avoid attacks and short
+enough to be easy to manage, cut & paste, store, and so forth. This is what
+you should use in order to generate Redis passwords.
+
+## Use an external ACL file
+
+There are two ways to store users inside the Redis configuration:
+
+1. Users can be specified directly inside the `redis.conf` file.
+2. It is possible to specify an external ACL file.
+
+The two methods are *mutually incompatible*, so Redis will ask you to use one
+or the other. Specifying users inside `redis.conf` is
+good for simple use cases. When there are multiple users to define, in a
+complex environment, we recommend you use the ACL file instead.
+
+The format used inside `redis.conf` and in the external ACL file is exactly
+the same, so it is trivial to switch from one to the other, and is
+the following:
+
+    user <username> ... acl rules ...
+
+For instance:
+
+    user worker +@list +@connection ~jobs:* on >ffa9203c493aa99
+
+When you want to use an external ACL file, you are required to specify
+the configuration directive called `aclfile`, like this:
+
+    aclfile /etc/redis/users.acl
+
+When you are just specifying a few users directly inside the `redis.conf`
+file, you can use [`CONFIG REWRITE`](/commands/config-rewrite) in order to store the new user configuration
+inside the file by rewriting it.
+
+The external ACL file however is more powerful. You can do the following:
+
+* Use [`ACL LOAD`](/commands/acl-load) if you modified the ACL file manually and you want Redis to reload the new configuration. Note that this command is able to load the file *only if all the users are correctly specified*. Otherwise, an error is reported to the user, and the old configuration will remain valid.
+* Use [`ACL SAVE`](/commands/acl-save) to save the current ACL configuration to the ACL file.
+
+Note that [`CONFIG REWRITE`](/commands/config-rewrite) does not also trigger [`ACL SAVE`](/commands/acl-save). When you use
+an ACL file, the configuration and the ACLs are handled separately.
+
+## ACL rules for Sentinel and Replicas
+
+In case you don't want to provide Redis replicas and Redis Sentinel instances
+full access to your Redis instances, the following is the set of commands
+that must be allowed in order for everything to work correctly.
+
+For Sentinel, allow the user to access the following commands both in the master and replica instances:
+
+* AUTH, CLIENT, SUBSCRIBE, SCRIPT, PUBLISH, PING, INFO, MULTI, SLAVEOF, CONFIG, CLIENT, EXEC.
+
+Sentinel does not need to access any key in the database but does use Pub/Sub, so the ACL rule would be the following (note: [`AUTH`](/commands/auth) is not needed since it is always allowed):
+
+    ACL SETUSER sentinel-user on >somepassword allchannels +multi +slaveof +ping +exec +subscribe +config|rewrite +role +publish +info +client|setname +client|kill +script|kill
+
+Redis replicas require the following commands to be allowed on the master instance:
+
+* PSYNC, REPLCONF, PING
+
+No keys need to be accessed, so this translates to the following rules:
+
+    ACL setuser replica-user on >somepassword +psync +replconf +ping
+
+Note that you don't need to configure the replicas to allow the master to be able to execute any set of commands. The master is always authenticated as the root user from the point of view of replicas.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Redis TLS support
+linkTitle: TLS
+title: TLS
+weight: 1
+---
+
+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).
+
+Build Redis with the following command:
+
+```sh
+make BUILD_TLS=yes
+```
+
+### Tests
+
+To run Redis test suite with TLS, you'll need TLS support for TCL (i.e.
+`tcl-tls` package on Debian/Ubuntu).
+
+1. Run `./utils/gen-test-certs.sh` to generate a root CA and a server
+   certificate.
+
+2. Run `./runtest --tls` or `./runtest-cluster --tls` to run Redis and Redis
+   Cluster tests in TLS mode.
+
+### Running manually
+
+To manually run a Redis server with TLS mode (assuming `gen-test-certs.sh` was
+invoked so sample certificates/keys are available):
+
+    ./src/redis-server --tls-port 6379 --port 0 \
+        --tls-cert-file ./tests/tls/redis.crt \
+        --tls-key-file ./tests/tls/redis.key \
+        --tls-ca-cert-file ./tests/tls/ca.crt
+
+To connect to this Redis server with `redis-cli`:
+
+    ./src/redis-cli --tls \
+        --cert ./tests/tls/redis.crt \
+        --key ./tests/tls/redis.key \
+        --cacert ./tests/tls/ca.crt
+
+### Certificate configuration
+
+In order to support TLS, Redis must be configured with a X.509 certificate and a
+private key. In addition, it is necessary to specify a CA certificate bundle
+file or path to be used as a trusted root when validating certificates. To
+support DH based ciphers, a DH params file can also be configured. For example:
+
+```
+tls-cert-file /path/to/redis.crt
+tls-key-file /path/to/redis.key
+tls-ca-cert-file /path/to/ca.crt
+tls-dh-params-file /path/to/redis.dh
+```
+
+### TLS listening port
+
+The `tls-port` configuration directive enables accepting SSL/TLS connections on
+the specified port. This is **in addition** to listening on `port` for TCP
+connections, so it is possible to access Redis on different ports using TLS and
+non-TLS connections simultaneously.
+
+You may specify `port 0` to disable the non-TLS port completely. To enable only
+TLS on the default Redis port, use:
+
+```
+port 0
+tls-port 6379
+```
+
+### Client certificate authentication
+
+By default, Redis uses mutual TLS and requires clients to authenticate with a
+valid certificate (authenticated against trusted root CAs specified by
+`ca-cert-file` or `ca-cert-dir`).
+
+You may use `tls-auth-clients no` to disable client authentication.
+
+### Replication
+
+A Redis master server handles connecting clients and replica servers in the same
+way, so the above `tls-port` and `tls-auth-clients` directives apply to
+replication links as well.
+
+On the replica server side, it is necessary to specify `tls-replication yes` to
+use TLS for outgoing connections to the master.
+
+### Cluster
+
+When Redis Cluster is used, use `tls-cluster yes` in order to enable TLS for the
+cluster bus and cross-node connections.
+
+### Sentinel
+
+Sentinel inherits its networking configuration from the common Redis
+configuration, so all of the above applies to Sentinel as well.
+
+When connecting to master servers, Sentinel will use the `tls-replication`
+directive to determine if a TLS or non-TLS connection is required.
+
+In addition, the very same `tls-replication` directive will determine whether Sentinel's
+port, that accepts connections from other Sentinels, will support TLS as well. That is,
+Sentinel will be configured with `tls-port` if and only if `tls-replication` is enabled. 
+
+### Additional configuration
+
+Additional TLS configuration is available to control the choice of TLS protocol
+versions, ciphers and cipher suites, etc. Please consult the self documented
+`redis.conf` for more information.
+
+### Performance considerations
+
+TLS adds a layer to the communication stack with overheads due to writing/reading to/from an SSL connection, encryption/decryption and integrity checks. Consequently, using TLS results in a decrease of the achievable throughput per Redis instance (for more information refer to this [discussion](https://github.com/redis/redis/issues/7595)). 
+
+### Limitations
+
+Starting with version 8.0, Redis supports I/O threading with TLS.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Security model and features in Redis
+linkTitle: Security
+title: Redis security
+weight: 1
+---
+
+This document provides an introduction to the topic of security from the point of
+view of Redis. It covers the access control provided by Redis, code security concerns,
+attacks that can be triggered from the outside by selecting malicious inputs, and
+other similar topics. 
+You can learn more about access control, data protection and encryption, secure Redis architectures, and secure deployment techniques by taking the [Redis University security course](https://university.redis.com/courses/ru330/).
+
+For security-related contacts, open an issue on GitHub, or when you feel it
+is really important to preserve the security of the communication, use the
+GPG key at the end of this document.
+
+## Security model
+
+Redis is designed to be accessed by trusted clients inside trusted environments.
+This means that usually it is not a good idea to expose the Redis instance
+directly to the internet or, in general, to an environment where untrusted
+clients can directly access the Redis TCP port or UNIX socket.
+
+For instance, in the common context of a web application implemented using Redis
+as a database, cache, or messaging system, the clients inside the front-end
+(web side) of the application will query Redis to generate pages or
+to perform operations requested or triggered by the web application user.
+
+In this case, the web application mediates access between Redis and
+untrusted clients (the user browsers accessing the web application).
+
+In general, untrusted access to Redis should
+always be mediated by a layer implementing ACLs, validating user input,
+and deciding what operations to perform against the Redis instance.
+
+## Network security
+
+Access to the Redis port should be denied to everybody but trusted clients
+in the network, so the servers running Redis should be directly accessible
+only by the computers implementing the application using Redis.
+
+In the common case of a single computer directly exposed to the internet, such
+as a virtualized Linux instance (Linode, EC2, ...), the Redis port should be
+firewalled to prevent access from the outside. Clients will still be able to
+access Redis using the loopback interface.
+
+Note that it is possible to bind Redis to a single interface by adding a line
+like the following to the **redis.conf** file:
+
+    bind 127.0.0.1
+
+Failing to protect the Redis port from the outside can have a big security
+impact because of the nature of Redis. For instance, a single [`FLUSHALL`](/commands/flushall) command can be used by an external attacker to delete the whole data set.
+
+## Protected mode
+
+Unfortunately, many users fail to protect Redis instances from being accessed
+from external networks. Many instances are simply left exposed on the
+internet with public IPs. Since version 3.2.0, Redis enters a special mode called **protected mode** when it is
+executed with the default configuration (binding all the interfaces) and
+without any password in order to access it. In this mode, Redis only replies to queries from the
+loopback interfaces, and replies to clients connecting from other
+addresses with an error that explains the problem and how to configure
+Redis properly.
+
+We expect protected mode to seriously decrease the security issues caused
+by unprotected Redis instances executed without proper administration. However,
+the system administrator can still ignore the error given by Redis and
+disable protected mode or manually bind all the interfaces.
+
+## Authentication
+
+Redis provides two ways to authenticate clients.
+The recommended authentication method, introduced in Redis 6, is via Access Control Lists, allowing named users to be created and assigned fine-grained permissions.
+Read more about Access Control Lists [here]({{< relref "/operate/oss_and_stack/management/security/acl" >}}).
+
+The legacy authentication method is enabled by editing the **redis.conf** file, and providing a database password using the `requirepass` setting.
+This password is then used by all clients.
+
+When the `requirepass` setting is enabled, Redis will refuse any query by
+unauthenticated clients. A client can authenticate itself by sending the
+**AUTH** command followed by the password.
+
+The password is set by the system administrator in clear text inside the
+redis.conf file. It should be long enough to prevent brute force attacks
+for two reasons:
+
+* Redis is very fast at serving queries. Many passwords per second can be tested by an external client.
+* The Redis password is stored in the **redis.conf** file and inside the client configuration. Since the system administrator does not need to remember it, the password can be very long.
+
+The goal of the authentication layer is to optionally provide a layer of
+redundancy. If firewalling or any other system implemented to protect Redis
+from external attackers fail, an external client will still not be able to
+access the Redis instance without knowledge of the authentication password.
+
+Since the [`AUTH`](/commands/auth) command, like every other Redis command, is sent unencrypted, it
+does not protect against an attacker that has enough access to the network to
+perform eavesdropping.
+
+## TLS support
+
+Redis has optional support for TLS on all communication channels, including
+client connections, replication links, and the Redis Cluster bus protocol.
+
+## Disallowing specific commands
+
+It is possible to disallow commands in Redis or to rename them as an unguessable
+name, so that normal clients are limited to a specified set of commands.
+
+For instance, a virtualized server provider may offer a managed Redis instance
+service. In this context, normal users should probably not be able to
+call the Redis **CONFIG** command to alter the configuration of the instance,
+but the systems that provide and remove instances should be able to do so.
+
+In this case, it is possible to either rename or completely shadow commands from
+the command table. This feature is available as a statement that can be used
+inside the redis.conf configuration file. For example:
+
+    rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
+
+In the above example, the **CONFIG** command was renamed into an unguessable name.  It is also possible to completely disallow it (or any other command) by renaming it to the empty string, like in the following example:
+
+    rename-command CONFIG ""
+
+## Attacks triggered by malicious inputs from external clients
+
+There is a class of attacks that an attacker can trigger from the outside even
+without external access to the instance. For example, an attacker might insert data into Redis that triggers pathological (worst case)
+algorithm complexity on data structures implemented inside Redis internals.
+
+An attacker could supply, via a web form, a set of strings that
+are known to hash to the same bucket in a hash table in order to turn the
+O(1) expected time (the average time) to the O(N) worst case. This can consume more
+CPU than expected and ultimately cause a Denial of Service.
+
+To prevent this specific attack, Redis uses a per-execution, pseudo-random
+seed to the hash function.
+
+Redis implements the SORT command using the qsort algorithm. Currently,
+the algorithm is not randomized, so it is possible to trigger a quadratic
+worst-case behavior by carefully selecting the right set of inputs.
+
+## String escaping and NoSQL injection
+
+The Redis protocol has no concept of string escaping, so injection
+is impossible under normal circumstances using a normal client library.
+The protocol uses prefixed-length strings and is completely binary safe.
+
+Since Lua scripts executed by the [`EVAL`](/commands/eval) and [`EVALSHA`](/commands/evalsha) commands follow the
+same rules, those commands are also safe.
+
+While it would be a strange use case, the application should avoid composing the body of the Lua script from strings obtained from untrusted sources.
+
+## Code security
+
+In a classical Redis setup, clients are allowed full access to the command set,
+but accessing the instance should never result in the ability to control the
+system where Redis is running.
+
+Internally, Redis uses all the well-known practices for writing secure code to
+prevent buffer overflows, format bugs, and other memory corruption issues.
+However, the ability to control the server configuration using the **CONFIG**
+command allows the client to change the working directory of the program and
+the name of the dump file. This allows clients to write RDB Redis files
+to random paths. This is [a security issue](http://antirez.com/news/96) that may lead to the ability to compromise the system and/or run untrusted code as the same user as Redis is running.
+
+Redis does not require root privileges to run. It is recommended to
+run it as an unprivileged *redis* user that is only used for this purpose.
+
+## GPG key
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=J9BD
+-----END PGP PUBLIC KEY BLOCK-----
+```
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: High availability for non-clustered Redis
+linkTitle: High availability with Sentinel
+title: High availability with Redis Sentinel
+weight: 4
+---
+
+Redis Sentinel provides high availability for Redis when not using [Redis Cluster]({{< relref "/operate/oss_and_stack/management/scaling" >}}). 
+
+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:
+
+Sentinel itself is designed to run in a configuration where there are multiple Sentinel processes cooperating together. The advantage of having multiple Sentinel processes cooperating are the following:
+
+1. Failure detection is performed when multiple Sentinels agree about the fact a given master is no longer available. This lowers the probability of false positives.
+2. Sentinel works even if not all the Sentinel processes are working, making the system robust against failures. There is no fun in having a failover system which is itself a single point of failure, after all.
+
+The sum of Sentinels, Redis instances (masters and replicas) and clients
+connecting to Sentinel and Redis, are also a larger distributed system with
+specific properties. In this document concepts will be introduced gradually
+starting from basic information needed in order to understand the basic
+properties of Sentinel, to more complex information (that are optional) in
+order to understand how exactly Sentinel works.
+
+## Sentinel quick start
+
+### Obtaining Sentinel
+
+The current version of Sentinel is called **Sentinel 2**. It is a rewrite of
+the initial Sentinel implementation using stronger and simpler-to-predict
+algorithms (that are explained in this documentation).
+
+A stable release of Redis Sentinel is shipped since Redis 2.8.
+
+New developments are performed in the *unstable* branch, and new features
+sometimes are back ported into the latest stable branch as soon as they are
+considered to be stable.
+
+Redis Sentinel version 1, shipped with Redis 2.6, is deprecated and should not be used.
+
+### Running Sentinel
+
+If you are using the `redis-sentinel` executable (or if you have a symbolic
+link with that name to the `redis-server` executable) you can run Sentinel
+with the following command line:
+
+    redis-sentinel /path/to/sentinel.conf
+
+Otherwise you can use directly the `redis-server` executable starting it in
+Sentinel mode:
+
+    redis-server /path/to/sentinel.conf --sentinel
+
+Both ways work the same.
+
+However **it is mandatory** to use a configuration file when running Sentinel, as this file will be used by the system in order to save the current state that will be reloaded in case of restarts. Sentinel will simply refuse to start if no configuration file is given or if the configuration file path is not writable.
+
+Sentinels by default run **listening for connections to TCP port 26379**, so
+for Sentinels to work, port 26379 of your servers **must be open** to receive
+connections from the IP addresses of the other Sentinel instances.
+Otherwise Sentinels can't talk and can't agree about what to do, so failover
+will never be performed.
+
+### Fundamental things to know about Sentinel before deploying
+
+1. You need at least three Sentinel instances for a robust deployment.
+2. The three Sentinel instances should be placed into computers or virtual machines that are believed to fail in an independent way. So for example different physical servers or Virtual Machines executed on different availability zones.
+3. Sentinel + Redis distributed system does not guarantee that acknowledged writes are retained during failures, since Redis uses asynchronous replication. However there are ways to deploy Sentinel that make the window to lose writes limited to certain moments, while there are other less secure ways to deploy it.
+4. You need Sentinel support in your clients. Popular client libraries have Sentinel support, but not all.
+5. There is no HA setup which is safe if you don't test from time to time in development environments, or even better if you can, in production environments, if they work. You may have a misconfiguration that will become apparent only when it's too late (at 3am when your master stops working).
+6. **Sentinel, Docker, or other forms of Network Address Translation or Port Mapping should be mixed with care**: Docker performs port remapping, breaking Sentinel auto discovery of other Sentinel processes and the list of replicas for a master. Check the [section about _Sentinel and Docker_](#sentinel-docker-nat-and-possible-issues) later in this document for more information.
+
+### Configuring Sentinel
+
+The Redis source distribution contains a file called `sentinel.conf`
+that is a self-documented example configuration file you can use to
+configure Sentinel, however a typical minimal configuration file looks like the
+following:
+
+    sentinel monitor mymaster 127.0.0.1 6379 2
+    sentinel down-after-milliseconds mymaster 60000
+    sentinel failover-timeout mymaster 180000
+    sentinel parallel-syncs mymaster 1
+
+    sentinel monitor resque 192.168.1.3 6380 4
+    sentinel down-after-milliseconds resque 10000
+    sentinel failover-timeout resque 180000
+    sentinel parallel-syncs resque 5
+
+You only need to specify the masters to monitor, giving to each separated
+master (that may have any number of replicas) a different name. There is no
+need to specify replicas, which are auto-discovered. Sentinel will update the
+configuration automatically with additional information about replicas (in
+order to retain the information in case of restart). The configuration is
+also rewritten every time a replica is promoted to master during a failover
+and every time a new Sentinel is discovered.
+
+The example configuration above basically monitors two sets of Redis
+instances, each composed of a master and an undefined number of replicas.
+One set of instances is called `mymaster`, and the other `resque`.
+
+The meaning of the arguments of `sentinel monitor` statements is the following:
+
+    sentinel monitor <master-name> <ip> <port> <quorum>
+
+For the sake of clarity, let's check line by line what the configuration
+options mean:
+
+The first line is used to tell Redis to monitor a master called *mymaster*,
+that is at address 127.0.0.1 and port 6379, with a quorum of 2. Everything
+is pretty obvious but the **quorum** argument:
+
+* The **quorum** is the number of Sentinels that need to agree about the fact the master is not reachable, in order to really mark the master as failing, and eventually start a failover procedure if possible.
+* However **the quorum is only used to detect the failure**. In order to actually perform a failover, one of the Sentinels need to be elected leader for the failover and be authorized to proceed. This only happens with the vote of the **majority of the Sentinel processes**.
+
+So for example if you have 5 Sentinel processes, and the quorum for a given
+master set to the value of 2, this is what happens:
+
+* If two Sentinels agree at the same time about the master being unreachable, one of the two will try to start a failover.
+* If there are at least a total of three Sentinels reachable, the failover will be authorized and will actually start.
+
+In practical terms this means during failures **Sentinel never starts a failover if the majority of Sentinel processes are unable to talk** (aka no failover in the minority partition).
+
+### Other Sentinel options
+
+The other options are almost always in the form:
+
+    sentinel <option_name> <master_name> <option_value>
+
+And are used for the following purposes:
+
+* `down-after-milliseconds` is the time in milliseconds an instance should not
+be reachable (either does not reply to our PINGs or it is replying with an
+error) for a Sentinel starting to think it is down.
+* `parallel-syncs` sets the number of replicas that can be reconfigured to use
+the new master after a failover at the same time. The lower the number, the
+more time it will take for the failover process to complete, however if the
+replicas are configured to serve old data, you may not want all the replicas to
+re-synchronize with the master at the same time. While the replication
+process is mostly non blocking for a replica, there is a moment when it stops to
+load the bulk data from the master. You may want to make sure only one replica
+at a time is not reachable by setting this option to the value of 1.
+
+Additional options are described in the rest of this document and
+documented in the example `sentinel.conf` file shipped with the Redis
+distribution.
+
+Configuration parameters can be modified at runtime:
+
+* Master-specific configuration parameters are modified using `SENTINEL SET`.
+* Global configuration parameters are modified using `SENTINEL CONFIG SET`.
+
+See the [_Reconfiguring Sentinel at runtime_ section](#reconfiguring-sentinel-at-runtime) for more information.
+
+### Example Sentinel deployments
+
+Now that you know the basic information about Sentinel, you may wonder where
+you should place your Sentinel processes, how many Sentinel processes you need
+and so forth. This section shows a few example deployments.
+
+We use ASCII art in order to show you configuration examples in a *graphical*
+format, this is what the different symbols means:
+
+    +--------------------+
+    | This is a computer |
+    | or VM that fails   |
+    | independently. We  |
+    | call it a "box"    |
+    +--------------------+
+
+We write inside the boxes what they are running:
+
+    +-------------------+
+    | Redis master M1   |
+    | Redis Sentinel S1 |
+    +-------------------+
+
+Different boxes are connected by lines, to show that they are able to talk:
+
+    +-------------+               +-------------+
+    | Sentinel S1 |---------------| Sentinel S2 |
+    +-------------+               +-------------+
+
+Network partitions are shown as interrupted lines using slashes:
+
+    +-------------+                +-------------+
+    | Sentinel S1 |------ // ------| Sentinel S2 |
+    +-------------+                +-------------+
+
+Also note that:
+
+* Masters are called M1, M2, M3, ..., Mn.
+* Replicas are called R1, R2, R3, ..., Rn (R stands for *replica*).
+* Sentinels are called S1, S2, S3, ..., Sn.
+* Clients are called C1, C2, C3, ..., Cn.
+* When an instance changes role because of Sentinel actions, we put it inside square brackets, so [M1] means an instance that is now a master because of Sentinel intervention.
+
+Note that we will never show **setups where just two Sentinels are used**, since
+Sentinels always need **to talk with the majority** in order to start a
+failover.
+
+#### Example 1: just two Sentinels, DON'T DO THIS
+
+    +----+         +----+
+    | M1 |---------| R1 |
+    | S1 |         | S2 |
+    +----+         +----+
+
+    Configuration: quorum = 1
+
+* In this setup, if the master M1 fails, R1 will be promoted since the two Sentinels can reach agreement about the failure (obviously with quorum set to 1) and can also authorize a failover because the majority is two. So apparently it could superficially work, however check the next points to see why this setup is broken.
+* If the box where M1 is running stops working, also S1 stops working. The Sentinel running in the other box S2 will not be able to authorize a failover, so the system will become not available.
+
+Note that a majority is needed in order to order different failovers, and later propagate the latest configuration to all the Sentinels. Also note that the ability to failover in a single side of the above setup, without any agreement, would be very dangerous:
+
+    +----+           +------+
+    | M1 |----//-----| [M1] |
+    | S1 |           | S2   |
+    +----+           +------+
+
+In the above configuration we created two masters (assuming S2 could failover
+without authorization) in a perfectly symmetrical way. Clients may write
+indefinitely to both sides, and there is no way to understand when the
+partition heals what configuration is the right one, in order to prevent
+a *permanent split brain condition*.
+
+So please **deploy at least three Sentinels in three different boxes** always.
+
+#### Example 2: basic setup with three boxes
+
+This is a very simple setup, that has the advantage to be simple to tune
+for additional safety. It is based on three boxes, each box running both
+a Redis process and a Sentinel process.
+
+
+           +----+
+           | M1 |
+           | S1 |
+           +----+
+              |
+    +----+    |    +----+
+    | R2 |----+----| R3 |
+    | S2 |         | S3 |
+    +----+         +----+
+
+    Configuration: quorum = 2
+
+If the master M1 fails, S2 and S3 will agree about the failure and will
+be able to authorize a failover, making clients able to continue.
+
+In every Sentinel setup, as Redis uses asynchronous replication, there is
+always the risk of losing some writes because a given acknowledged write
+may not be able to reach the replica which is promoted to master. However in
+the above setup there is a higher risk due to clients being partitioned away
+with an old master, like in the following picture:
+
+             +----+
+             | M1 |
+             | S1 | <- C1 (writes will be lost)
+             +----+
+                |
+                /
+                /
+    +------+    |    +----+
+    | [M2] |----+----| R3 |
+    | S2   |         | S3 |
+    +------+         +----+
+
+In this case a network partition isolated the old master M1, so the
+replica R2 is promoted to master. However clients, like C1, that are
+in the same partition as the old master, may continue to write data
+to the old master. This data will be lost forever since when the partition
+will heal, the master will be reconfigured as a replica of the new master,
+discarding its data set.
+
+This problem can be mitigated using the following Redis replication
+feature, that allows to stop accepting writes if a master detects that
+it is no longer able to transfer its writes to the specified number of replicas.
+
+    min-replicas-to-write 1
+    min-replicas-max-lag 10
+
+With the above configuration (please see the self-commented `redis.conf` example in the Redis distribution for more information) a Redis instance, when acting as a master, will stop accepting writes if it can't write to at least 1 replica. Since replication is asynchronous *not being able to write* actually means that the replica is either disconnected, or is not sending us asynchronous acknowledges for more than the specified `max-lag` number of seconds.
+
+Using this configuration, the old Redis master M1 in the above example, will become unavailable after 10 seconds. When the partition heals, the Sentinel configuration will converge to the new one, the client C1 will be able to fetch a valid configuration and will continue with the new master.
+
+However there is no free lunch. With this refinement, if the two replicas are
+down, the master will stop accepting writes. It's a trade off.
+
+#### Example 3: Sentinel in the client boxes
+
+Sometimes we have only two Redis boxes available, one for the master and
+one for the replica. The configuration in the example 2 is not viable in
+that case, so we can resort to the following, where Sentinels are placed
+where clients are:
+
+                +----+         +----+
+                | M1 |----+----| R1 |
+                |    |    |    |    |
+                +----+    |    +----+
+                          |
+             +------------+------------+
+             |            |            |
+             |            |            |
+          +----+        +----+      +----+
+          | C1 |        | C2 |      | C3 |
+          | S1 |        | S2 |      | S3 |
+          +----+        +----+      +----+
+
+          Configuration: quorum = 2
+
+In this setup, the point of view Sentinels is the same as the clients: if
+a master is reachable by the majority of the clients, it is fine.
+C1, C2, C3 here are generic clients, it does not mean that C1 identifies
+a single client connected to Redis. It is more likely something like
+an application server, a Rails app, or something like that.
+
+If the box where M1 and S1 are running fails, the failover will happen
+without issues, however it is easy to see that different network partitions
+will result in different behaviors. For example Sentinel will not be able
+to setup if the network between the clients and the Redis servers is
+disconnected, since the Redis master and replica will both be unavailable.
+
+Note that if C3 gets partitioned with M1 (hardly possible with
+the network described above, but more likely possible with different
+layouts, or because of failures at the software layer), we have a similar
+issue as described in Example 2, with the difference that here we have
+no way to break the symmetry, since there is just a replica and master, so
+the master can't stop accepting queries when it is disconnected from its replica,
+otherwise the master would never be available during replica failures.
+
+So this is a valid setup but the setup in the Example 2 has advantages
+such as the HA system of Redis running in the same boxes as Redis itself
+which may be simpler to manage, and the ability to put a bound on the amount
+of time a master in the minority partition can receive writes.
+
+#### Example 4: Sentinel client side with less than three clients
+
+The setup described in the Example 3 cannot be used if there are less than
+three boxes in the client side (for example three web servers). In this
+case we need to resort to a mixed setup like the following:
+
+                +----+         +----+
+                | M1 |----+----| R1 |
+                | S1 |    |    | S2 |
+                +----+    |    +----+
+                          |
+                   +------+-----+
+                   |            |
+                   |            |
+                +----+        +----+
+                | C1 |        | C2 |
+                | S3 |        | S4 |
+                +----+        +----+
+
+          Configuration: quorum = 3
+
+This is similar to the setup in Example 3, but here we run four Sentinels
+in the four boxes we have available. If the master M1 becomes unavailable
+the other three Sentinels will perform the failover.
+
+In theory this setup works removing the box where C2 and S4 are running, and
+setting the quorum to 2. However it is unlikely that we want HA in the
+Redis side without having high availability in our application layer.
+
+### Sentinel, Docker, NAT, and possible issues
+
+Docker uses a technique called port mapping: programs running inside Docker
+containers may be exposed with a different port compared to the one the
+program believes to be using. This is useful in order to run multiple
+containers using the same ports, at the same time, in the same server.
+
+Docker is not the only software system where this happens, there are other
+Network Address Translation setups where ports may be remapped, and sometimes
+not ports but also IP addresses.
+
+Remapping ports and addresses creates issues with Sentinel in two ways:
+
+1. Sentinel auto-discovery of other Sentinels no longer works, since it is based on *hello* messages where each Sentinel announce at which port and IP address they are listening for connection. However Sentinels have no way to understand that an address or port is remapped, so it is announcing an information that is not correct for other Sentinels to connect.
+2. Replicas are listed in the [`INFO`](/commands/info) output of a Redis master in a similar way: the address is detected by the master checking the remote peer of the TCP connection, while the port is advertised by the replica itself during the handshake, however the port may be wrong for the same reason as exposed in point 1.
+
+Since Sentinels auto detect replicas using masters [`INFO`](/commands/info) output information,
+the detected replicas will not be reachable, and Sentinel will never be able to
+failover the master, since there are no good replicas from the point of view of
+the system, so there is currently no way to monitor with Sentinel a set of
+master and replica instances deployed with Docker, **unless you instruct Docker
+to map the port 1:1**.
+
+For the first problem, in case you want to run a set of Sentinel
+instances using Docker with forwarded ports (or any other NAT setup where ports
+are remapped), you can use the following two Sentinel configuration directives
+in order to force Sentinel to announce a specific set of IP and port:
+
+    sentinel announce-ip <ip>
+    sentinel announce-port <port>
+
+Note that Docker has the ability to run in *host networking mode* (check the `--net=host` option for more information). This should create no issues since ports are not remapped in this setup.
+
+### IP Addresses and DNS names
+
+Older versions of Sentinel did not support host names and required IP addresses to be specified everywhere.
+Starting with version 6.2, Sentinel has *optional* support for host names.
+
+**This capability is disabled by default. If you're going to enable DNS/hostnames support, please note:**
+
+1. The name resolution configuration on your Redis and Sentinel nodes must be reliable and be able to resolve addresses quickly. Unexpected delays in address resolution may have a negative impact on Sentinel.
+2. You should use hostnames everywhere and avoid mixing hostnames and IP addresses. To do that, use `replica-announce-ip <hostname>` and `sentinel announce-ip <hostname>` for all Redis and Sentinel instances, respectively.
+
+Enabling the `resolve-hostnames` global configuration allows Sentinel to accept host names:
+
+* As part of a `sentinel monitor` command
+* As a replica address, if the replica uses a host name value for `replica-announce-ip`
+
+Sentinel will accept host names as valid inputs and resolve them, but will still refer to IP addresses when announcing an instance, updating configuration files, etc.
+
+Enabling the `announce-hostnames` global configuration makes Sentinel use host names instead. This affects replies to clients, values written in configuration files, the [`REPLICAOF`](/commands/replicaof) command issued to replicas, etc.
+
+This behavior may not be compatible with all Sentinel clients, that may explicitly expect an IP address.
+
+Using host names may be useful when clients use TLS to connect to instances and require a name rather than an IP address in order to perform certificate ASN matching.
+
+## A quick tutorial
+
+In the next sections of this document, all the details about [_Sentinel API_](#sentinel-api),
+configuration and semantics will be covered incrementally. However for people
+that want to play with the system ASAP, this section is a tutorial that shows
+how to configure and interact with 3 Sentinel instances.
+
+Here we assume that the instances are executed at port 5000, 5001, 5002.
+We also assume that you have a running Redis master at port 6379 with a
+replica running at port 6380. We will use the IPv4 loopback address 127.0.0.1
+everywhere during the tutorial, assuming you are running the simulation
+on your personal computer.
+
+The three Sentinel configuration files should look like the following:
+
+    port 5000
+    sentinel monitor mymaster 127.0.0.1 6379 2
+    sentinel down-after-milliseconds mymaster 5000
+    sentinel failover-timeout mymaster 60000
+    sentinel parallel-syncs mymaster 1
+
+The other two configuration files will be identical but using 5001 and 5002
+as port numbers.
+
+A few things to note about the above configuration:
+
+* The master set is called `mymaster`. It identifies the master and its replicas. Since each *master set* has a different name, Sentinel can monitor different sets of masters and replicas at the same time.
+* The quorum was set to the value of 2 (last argument of `sentinel monitor` configuration directive).
+* The `down-after-milliseconds` value is 5000 milliseconds, that is 5 seconds, so masters will be detected as failing as soon as we don't receive any reply from our pings within this amount of time.
+
+Once you start the three Sentinels, you'll see a few messages they log, like:
+
+    +monitor master mymaster 127.0.0.1 6379 quorum 2
+
+This is a Sentinel event, and you can receive this kind of events via Pub/Sub
+if you [`SUBSCRIBE`](/commands/subscribe) to the event name as specified later in [_Pub/Sub Messages_ section](#pubsub-messages).
+
+Sentinel generates and logs different events during failure detection and
+failover.
+
+Asking Sentinel about the state of a master
+---
+
+The most obvious thing to do with Sentinel to get started, is check if the
+master it is monitoring is doing well:
+
+    $ redis-cli -p 5000
+    127.0.0.1:5000> sentinel master mymaster
+     1) "name"
+     2) "mymaster"
+     3) "ip"
+     4) "127.0.0.1"
+     5) "port"
+     6) "6379"
+     7) "runid"
+     8) "953ae6a589449c13ddefaee3538d356d287f509b"
+     9) "flags"
+    10) "master"
+    11) "link-pending-commands"
+    12) "0"
+    13) "link-refcount"
+    14) "1"
+    15) "last-ping-sent"
+    16) "0"
+    17) "last-ok-ping-reply"
+    18) "735"
+    19) "last-ping-reply"
+    20) "735"
+    21) "down-after-milliseconds"
+    22) "5000"
+    23) "info-refresh"
+    24) "126"
+    25) "role-reported"
+    26) "master"
+    27) "role-reported-time"
+    28) "532439"
+    29) "config-epoch"
+    30) "1"
+    31) "num-slaves"
+    32) "1"
+    33) "num-other-sentinels"
+    34) "2"
+    35) "quorum"
+    36) "2"
+    37) "failover-timeout"
+    38) "60000"
+    39) "parallel-syncs"
+    40) "1"
+
+As you can see, it prints a number of information about the master. There are
+a few that are of particular interest for us:
+
+1. `num-other-sentinels` is 2, so we know the Sentinel already detected two more Sentinels for this master. If you check the logs you'll see the `+sentinel` events generated.
+2. `flags` is just `master`. If the master was down we could expect to see `s_down` or `o_down` flag as well here.
+3. `num-slaves` is correctly set to 1, so Sentinel also detected that there is an attached replica to our master.
+
+In order to explore more about this instance, you may want to try the following
+two commands:
+
+    SENTINEL replicas mymaster
+    SENTINEL sentinels mymaster
+
+The first will provide similar information about the replicas connected to the
+master, and the second about the other Sentinels.
+
+Obtaining the address of the current master
+---
+
+As we already specified, Sentinel also acts as a configuration provider for
+clients that want to connect to a set of master and replicas. Because of
+possible failovers or reconfigurations, clients have no idea about who is
+the currently active master for a given set of instances, so Sentinel exports
+an API to ask this question:
+
+    127.0.0.1:5000> SENTINEL get-master-addr-by-name mymaster
+    1) "127.0.0.1"
+    2) "6379"
+
+### Testing the failover
+
+At this point our toy Sentinel deployment is ready to be tested. We can
+just kill our master and check if the configuration changes. To do so
+we can just do:
+
+    redis-cli -p 6379 DEBUG sleep 30
+
+This command will make our master no longer reachable, sleeping for 30 seconds.
+It basically simulates a master hanging for some reason.
+
+If you check the Sentinel logs, you should be able to see a lot of action:
+
+1. Each Sentinel detects the master is down with an `+sdown` event.
+2. This event is later escalated to `+odown`, which means that multiple Sentinels agree about the fact the master is not reachable.
+3. Sentinels vote a Sentinel that will start the first failover attempt.
+4. The failover happens.
+
+If you ask again what is the current master address for `mymaster`, eventually
+we should get a different reply this time:
+
+    127.0.0.1:5000> SENTINEL get-master-addr-by-name mymaster
+    1) "127.0.0.1"
+    2) "6380"
+
+So far so good... At this point you may jump to create your Sentinel deployment
+or can read more to understand all the Sentinel commands and internals.
+
+## Sentinel API
+
+Sentinel provides an API in order to inspect its state, check the health
+of monitored masters and replicas, subscribe in order to receive specific
+notifications, and change the Sentinel configuration at run time.
+
+By default Sentinel runs using TCP port 26379 (note that 6379 is the normal
+Redis port). Sentinels accept commands using the Redis protocol, so you can
+use `redis-cli` or any other unmodified Redis client in order to talk with
+Sentinel.
+
+It is possible to directly query a Sentinel to check what is the state of
+the monitored Redis instances from its point of view, to see what other
+Sentinels it knows, and so forth. Alternatively, using Pub/Sub, it is possible
+to receive *push style* notifications from Sentinels, every time some event
+happens, like a failover, or an instance entering an error condition, and
+so forth.
+
+### Sentinel commands
+
+The `SENTINEL` command is the main API for Sentinel. The following is the list of its subcommands (minimal version is noted for where applicable):
+
+* **SENTINEL CONFIG GET `<name>`** (`>= 6.2`) Get the current value of a global Sentinel configuration parameter. The specified name may be a wildcard, similar to the Redis [`CONFIG GET`](/commands/config-get) command.
+* **SENTINEL CONFIG SET `<name>` `<value>`** (`>= 6.2`) Set the value of a global Sentinel configuration parameter.
+* **SENTINEL CKQUORUM `<master name>`** Check if the current Sentinel configuration is able to reach the quorum needed to failover a master, and the majority needed to authorize the failover. This command should be used in monitoring systems to check if a Sentinel deployment is ok.
+* **SENTINEL FLUSHCONFIG** Force Sentinel to rewrite its configuration on disk, including the current Sentinel state. Normally Sentinel rewrites the configuration every time something changes in its state (in the context of the subset of the state which is persisted on disk across restart). However sometimes it is possible that the configuration file is lost because of operation errors, disk failures, package upgrade scripts or configuration managers. In those cases a way to force Sentinel to rewrite the configuration file is handy. This command works even if the previous configuration file is completely missing.
+* **SENTINEL FAILOVER `<master name>`** Force a failover as if the master was not reachable, and without asking for agreement to other Sentinels (however a new version of the configuration will be published so that the other Sentinels will update their configurations).
+* **SENTINEL GET-MASTER-ADDR-BY-NAME `<master name>`** Return the ip and port number of the master with that name. If a failover is in progress or terminated successfully for this master it returns the address and port of the promoted replica.
+* **SENTINEL INFO-CACHE** (`>= 3.2`) Return cached [`INFO`](/commands/info) output from masters and replicas.
+* **SENTINEL IS-MASTER-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>** Check if the master specified by ip:port is down from current Sentinel's point of view. This command is mostly for internal use.
+* **SENTINEL MASTER `<master name>`** Show the state and info of the specified master.
+* **SENTINEL MASTERS** Show a list of monitored masters and their state.
+* **SENTINEL MONITOR** Start Sentinel's monitoring. Refer to the [_Reconfiguring Sentinel at Runtime_ section](#reconfiguring-sentinel-at-runtime) for more information.
+* **SENTINEL MYID** (`>= 6.2`) Return the ID of the Sentinel instance.
+* **SENTINEL PENDING-SCRIPTS** This command returns information about pending scripts.
+* **SENTINEL REMOVE** Stop Sentinel's monitoring. Refer to the [_Reconfiguring Sentinel at Runtime_ section](#reconfiguring-sentinel-at-runtime) for more information.
+* **SENTINEL REPLICAS `<master name>`** (`>= 5.0`) Show a list of replicas for this master, and their state.
+* **SENTINEL SENTINELS `<master name>`** Show a list of sentinel instances for this master, and their state.
+* **SENTINEL SET** Set Sentinel's monitoring configuration. Refer to the [_Reconfiguring Sentinel at Runtime_ section](#reconfiguring-sentinel-at-runtime) for more information.
+* **SENTINEL SIMULATE-FAILURE (crash-after-election|crash-after-promotion|help)** (`>= 3.2`) This command simulates different Sentinel crash scenarios.
+* **SENTINEL RESET `<pattern>`** This command will reset all the masters with matching name. The pattern argument is a glob-style pattern. The reset process clears any previous state in a master (including a failover in progress), and removes every replica and sentinel already discovered and associated with the master.
+
+For connection management and administration purposes, Sentinel supports the following subset of Redis' commands:
+
+* **ACL** (`>= 6.2`) This command manages the Sentinel Access Control List. For more information refer to the [ACL]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) documentation page and the [_Sentinel Access Control List authentication_](#sentinel-access-control-list-authentication).
+* **AUTH** (`>= 5.0.1`) Authenticate a client connection. For more information refer to the [`AUTH`](/commands/auth) command and the [_Configuring Sentinel instances with authentication_ section](#configuring-sentinel-instances-with-authentication).
+* **CLIENT** This command manages client connections. For more information refer to its subcommands' pages.
+* **COMMAND** (`>= 6.2`) This command returns information about commands. For more information refer to the [`COMMAND`](/commands/command) command and its various subcommands.
+* **HELLO** (`>= 6.0`) Switch the connection's protocol. For more information refer to the [`HELLO`](/commands/hello) command.
+* **INFO** Return information and statistics about the Sentinel server. For more information see the [`INFO`](/commands/info) command.
+* **PING** This command simply returns PONG.
+* **ROLE** This command returns the string "sentinel" and a list of monitored masters. For more information refer to the [`ROLE`](/commands/role) command.
+* **SHUTDOWN** Shut down the Sentinel instance.
+
+Lastly, Sentinel also supports the [`SUBSCRIBE`](/commands/subscribe), [`UNSUBSCRIBE`](/commands/unsubscribe), [`PSUBSCRIBE`](/commands/psubscribe) and [`PUNSUBSCRIBE`](/commands/punsubscribe) commands. Refer to the [_Pub/Sub Messages_ section](#pubsub-messages) for more details.
+
+### Reconfiguring Sentinel at Runtime
+
+Starting with Redis version 2.8.4, Sentinel provides an API in order to add, remove, or change the configuration of a given master. Note that if you have multiple sentinels you should apply the changes to all to your instances for Redis Sentinel to work properly. This means that changing the configuration of a single Sentinel does not automatically propagate the changes to the other Sentinels in the network.
+
+The following is a list of `SENTINEL` subcommands used in order to update the configuration of a Sentinel instance.
+
+* **SENTINEL MONITOR `<name>` `<ip>` `<port>` `<quorum>`** This command tells the Sentinel to start monitoring a new master with the specified name, ip, port, and quorum. It is identical to the `sentinel monitor` configuration directive in `sentinel.conf` configuration file, with the difference that you can't use a hostname in as `ip`, but you need to provide an IPv4 or IPv6 address.
+* **SENTINEL REMOVE `<name>`** is used in order to remove the specified master: the master will no longer be monitored, and will totally be removed from the internal state of the Sentinel, so it will no longer listed by `SENTINEL masters` and so forth.
+* **SENTINEL SET `<name>` [`<option>` `<value>` ...]** The SET command is very similar to the [`CONFIG SET`](/commands/config-set) command of Redis, and is used in order to change configuration parameters of a specific master. Multiple option / value pairs can be specified (or none at all). All the configuration parameters that can be configured via `sentinel.conf` are also configurable using the SET command.
+
+The following is an example of `SENTINEL SET` command in order to modify the `down-after-milliseconds` configuration of a master called `objects-cache`:
+
+    SENTINEL SET objects-cache-master down-after-milliseconds 1000
+
+As already stated, `SENTINEL SET` can be used to set all the configuration parameters that are settable in the startup configuration file. Moreover it is possible to change just the master quorum configuration without removing and re-adding the master with `SENTINEL REMOVE` followed by `SENTINEL MONITOR`, but simply using:
+
+    SENTINEL SET objects-cache-master quorum 5
+
+Note that there is no equivalent GET command since `SENTINEL MASTER` provides all the configuration parameters in a simple to parse format (as a field/value pairs array).
+
+Starting with Redis version 6.2, Sentinel also allows getting and setting global configuration parameters which were only supported in the configuration file prior to that.
+
+* **SENTINEL CONFIG GET `<name>`** Get the current value of a global Sentinel configuration parameter. The specified name may be a wildcard, similar to the Redis [`CONFIG GET`](/commands/config-get) command.
+* **SENTINEL CONFIG SET `<name>` `<value>`** Set the value of a global Sentinel configuration parameter.
+
+Global parameters that can be manipulated include:
+
+* `resolve-hostnames`, `announce-hostnames`. See [_IP addresses and DNS names_](#ip-addresses-and-dns-names).
+* `announce-ip`, `announce-port`. See [_Sentinel, Docker, NAT, and possible issues_](#sentinel-docker-nat-and-possible-issues).
+* `sentinel-user`, `sentinel-pass`. See [_Configuring Sentinel instances with authentication_](#configuring-sentinel-instances-with-authentication).
+
+### Adding or removing Sentinels
+
+Adding a new Sentinel to your deployment is a simple process because of the
+auto-discover mechanism implemented by Sentinel. All you need to do is to
+start the new Sentinel configured to monitor the currently active master.
+Within 10 seconds the Sentinel will acquire the list of other Sentinels and
+the set of replicas attached to the master.
+
+If you need to add multiple Sentinels at once, it is suggested to add it
+one after the other, waiting for all the other Sentinels to already know
+about the first one before adding the next. This is useful in order to still
+guarantee that majority can be achieved only in one side of a partition,
+in the chance failures should happen in the process of adding new Sentinels.
+
+This can be easily achieved by adding every new Sentinel with a 30 seconds delay, and during absence of network partitions.
+
+At the end of the process it is possible to use the command
+`SENTINEL MASTER mastername` in order to check if all the Sentinels agree about
+the total number of Sentinels monitoring the master.
+
+Removing a Sentinel is a bit more complex: **Sentinels never forget already seen
+Sentinels**, even if they are not reachable for a long time, since we don't
+want to dynamically change the majority needed to authorize a failover and
+the creation of a new configuration number. So in order to remove a Sentinel
+the following steps should be performed in absence of network partitions:
+
+1. Stop the Sentinel process of the Sentinel you want to remove.
+2. Send a `SENTINEL RESET *` command to all the other Sentinel instances (instead of `*` you can use the exact master name if you want to reset just a single master). One after the other, waiting at least 30 seconds between instances.
+3. Check that all the Sentinels agree about the number of Sentinels currently active, by inspecting the output of `SENTINEL MASTER mastername` of every Sentinel.
+
+### Removing the old master or unreachable replicas
+
+Sentinels never forget about replicas of a given master, even when they are
+unreachable for a long time. This is useful, because Sentinels should be able
+to correctly reconfigure a returning replica after a network partition or a
+failure event.
+
+Moreover, after a failover, the failed over master is virtually added as a
+replica of the new master, this way it will be reconfigured to replicate with
+the new master as soon as it will be available again.
+
+However sometimes you want to remove a replica (that may be the old master)
+forever from the list of replicas monitored by Sentinels.
+
+In order to do this, you need to send a `SENTINEL RESET mastername` command
+to all the Sentinels: they'll refresh the list of replicas within the next
+10 seconds, only adding the ones listed as correctly replicating from the
+current master [`INFO`](/commands/info) output.
+
+### Pub/Sub messages
+
+A client can use a Sentinel as a Redis-compatible Pub/Sub server
+(but you can't use [`PUBLISH`](/commands/publish)) in order to [`SUBSCRIBE`](/commands/subscribe) or [`PSUBSCRIBE`](/commands/psubscribe) to
+channels and get notified about specific events.
+
+The channel name is the same as the name of the event. For instance the
+channel named `+sdown` will receive all the notifications related to instances
+entering an `SDOWN` (SDOWN means the instance is no longer reachable from
+the point of view of the Sentinel you are querying) condition.
+
+To get all the messages simply subscribe using `PSUBSCRIBE *`.
+
+The following is a list of channels and message formats you can receive using
+this API. The first word is the channel / event name, the rest is the format of the data.
+
+Note: where *instance details* is specified it means that the following arguments are provided to identify the target instance:
+
+    <instance-type> <name> <ip> <port> @ <master-name> <master-ip> <master-port>
+
+The part identifying the master (from the @ argument to the end) is optional
+and is only specified if the instance is not a master itself.
+
+* **+reset-master** `<instance details>` -- The master was reset.
+* **+slave** `<instance details>` -- A new replica was detected and attached.
+* **+failover-state-reconf-slaves** `<instance details>` -- Failover state changed to `reconf-slaves` state.
+* **+failover-detected** `<instance details>` -- A failover started by another Sentinel or any other external entity was detected (An attached replica turned into a master).
+* **+slave-reconf-sent** `<instance details>` -- The leader sentinel sent the [`REPLICAOF`](/commands/replicaof) command to this instance in order to reconfigure it for the new replica.
+* **+slave-reconf-inprog** `<instance details>` -- The replica being reconfigured showed to be a replica of the new master ip:port pair, but the synchronization process is not yet complete.
+* **+slave-reconf-done** `<instance details>` -- The replica is now synchronized with the new master.
+* **-dup-sentinel** `<instance details>` -- One or more sentinels for the specified master were removed as duplicated (this happens for instance when a Sentinel instance is restarted).
+* **+sentinel** `<instance details>` -- A new sentinel for this master was detected and attached.
+* **+sdown** `<instance details>` -- The specified instance is now in Subjectively Down state.
+* **-sdown** `<instance details>` -- The specified instance is no longer in Subjectively Down state.
+* **+odown** `<instance details>` -- The specified instance is now in Objectively Down state.
+* **-odown** `<instance details>` -- The specified instance is no longer in Objectively Down state.
+* **+new-epoch** `<instance details>` -- The current epoch was updated.
+* **+try-failover** `<instance details>` -- New failover in progress, waiting to be elected by the majority.
+* **+elected-leader** `<instance details>` -- Won the election for the specified epoch, can do the failover.
+* **+failover-state-select-slave** `<instance details>` -- New failover state is `select-slave`: we are trying to find a suitable replica for promotion.
+* **no-good-slave** `<instance details>` -- There is no good replica to promote. Currently we'll try after some time, but probably this will change and the state machine will abort the failover at all in this case.
+* **selected-slave** `<instance details>` -- We found the specified good replica to promote.
+* **failover-state-send-slaveof-noone** `<instance details>` -- We are trying to reconfigure the promoted replica as master, waiting for it to switch.
+* **failover-end-for-timeout** `<instance details>` -- The failover terminated for timeout, replicas will eventually be configured to replicate with the new master anyway.
+* **failover-end** `<instance details>` -- The failover terminated with success. All the replicas appears to be reconfigured to replicate with the new master.
+* **switch-master** `<master name> <oldip> <oldport> <newip> <newport>` -- The master new IP and address is the specified one after a configuration change. This is **the message most external users are interested in**.
+* **+tilt** -- Tilt mode entered.
+* **-tilt** -- Tilt mode exited.
+
+### Handling of -BUSY state
+
+The -BUSY error is returned by a Redis instance when a Lua script is running for
+more time than the configured Lua script time limit. When this happens before
+triggering a fail over Redis Sentinel will try to send a [`SCRIPT KILL`](/commands/script-kill)
+command, that will only succeed if the script was read-only.
+
+If the instance is still in an error condition after this try, it will
+eventually be failed over.
+
+Replicas priority
+---
+
+Redis instances have a configuration parameter called `replica-priority`.
+This information is exposed by Redis replica instances in their [`INFO`](/commands/info) output,
+and Sentinel uses it in order to pick a replica among the ones that can be
+used in order to failover a master:
+
+1. If the replica priority is set to 0, the replica is never promoted to master.
+2. Replicas with a *lower* priority number are preferred by Sentinel.
+
+For example if there is a replica S1 in the same data center of the current
+master, and another replica S2 in another data center, it is possible to set
+S1 with a priority of 10 and S2 with a priority of 100, so that if the master
+fails and both S1 and S2 are available, S1 will be preferred.
+
+For more information about the way replicas are selected, please check the [_Replica selection and priority_ section](#replica-selection-and-priority) of this documentation.
+
+### Sentinel and Redis authentication
+
+When the master is configured to require authentication from clients,
+as a security measure, replicas need to also be aware of the credentials in
+order to authenticate with the master and create the master-replica connection
+used for the asynchronous replication protocol.
+
+## Redis Access Control List authentication
+
+Starting with Redis 6, user authentication and permission is managed with the [Access Control List (ACL)]({{< relref "/operate/oss_and_stack/management/security/acl" >}}).
+
+In order for Sentinels to connect to Redis server instances when they are
+configured with ACL, the Sentinel configuration must include the
+following directives:
+
+    sentinel auth-user <master-name> <username>
+    sentinel auth-pass <master-name> <password>
+
+Where `<username>` and `<password>` are the username and password for accessing the group's instances. These credentials should be provisioned on all of the group's Redis instances with the minimal control permissions. For example:
+
+    127.0.0.1:6379> ACL SETUSER sentinel-user ON >somepassword allchannels +multi +slaveof +ping +exec +subscribe +config|rewrite +role +publish +info +client|setname +client|kill +script|kill
+
+### Redis password-only authentication
+
+Until Redis 6, authentication is achieved using the following configuration directives:
+
+* `requirepass` in the master, in order to set the authentication password, and to make sure the instance will not process requests for non authenticated clients.
+* `masterauth` in the replicas in order for the replicas to authenticate with the master in order to correctly replicate data from it.
+
+When Sentinel is used, there is not a single master, since after a failover
+replicas may play the role of masters, and old masters can be reconfigured in
+order to act as replicas, so what you want to do is to set the above directives
+in all your instances, both masters and replicas.
+
+This is also usually a sane setup since you don't want to protect
+data only in the master, having the same data accessible in the replicas.
+
+However, in the uncommon case where you need a replica that is accessible
+without authentication, you can still do it by setting up **a replica priority
+of zero**, to prevent this replica from being promoted to master, and
+configuring in this replica only the `masterauth` directive, without
+using the `requirepass` directive, so that data will be readable by
+unauthenticated clients.
+
+In order for Sentinels to connect to Redis server instances when they are
+configured with `requirepass`, the Sentinel configuration must include the
+`sentinel auth-pass` directive, in the format:
+
+    sentinel auth-pass <master-name> <password>
+
+Configuring Sentinel instances with authentication
+---
+
+Sentinel instances themselves can be secured by requiring clients to authenticate via the [`AUTH`](/commands/auth) command. Starting with Redis 6.2, the [Access Control List (ACL)]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) is available, whereas previous versions (starting with Redis 5.0.1) support password-only authentication. 
+
+Note that Sentinel's authentication configuration should be **applied to each of the instances** in your deployment, and **all instances should use the same configuration**. Furthermore, ACL and password-only authentication should not be used together.
+
+### Sentinel Access Control List authentication
+
+The first step in securing a Sentinel instance with ACL is preventing any unauthorized access to it. To do that, you'll need to disable the default superuser (or at the very least set it up with a strong password) and create a new one and allow it access to Pub/Sub channels:
+
+    127.0.0.1:5000> ACL SETUSER admin ON >admin-password allchannels +@all
+    OK
+    127.0.0.1:5000> ACL SETUSER default off
+    OK
+
+The default user is used by Sentinel to connect to other instances. You can provide the credentials of another superuser with the following configuration directives:
+
+    sentinel sentinel-user <username>
+    sentinel sentinel-pass <password>
+
+Where `<username>` and `<password>` are the Sentinel's superuser and password, respectively (e.g. `admin` and `admin-password` in the example above).
+
+Lastly, for authenticating incoming client connections, you can create a Sentinel restricted user profile such as the following:
+
+    127.0.0.1:5000> ACL SETUSER sentinel-user ON >user-password -@all +auth +client|getname +client|id +client|setname +command +hello +ping +role +sentinel|get-master-addr-by-name +sentinel|master +sentinel|myid +sentinel|replicas +sentinel|sentinels +sentinel|masters
+
+Refer to the documentation of your Sentinel client of choice for further information.
+
+### Sentinel password-only authentication
+
+To use Sentinel with password-only authentication, add the `requirepass` configuration directive to **all** your Sentinel instances as follows:
+
+    requirepass "your_password_here"
+
+When configured this way, Sentinels will do two things:
+
+1. A password will be required from clients in order to send commands to Sentinels. This is obvious since this is how such configuration directive works in Redis in general.
+2. Moreover the same password configured to access the local Sentinel, will be used by this Sentinel instance in order to authenticate to all the other Sentinel instances it connects to.
+
+This means that **you will have to configure the same `requirepass` password in all the Sentinel instances**. This way every Sentinel can talk with every other Sentinel without any need to configure for each Sentinel the password to access all the other Sentinels, that would be very impractical.
+
+Before using this configuration, make sure your client library can send the [`AUTH`](/commands/auth) command to Sentinel instances.
+
+### Sentinel clients implementation
+---
+
+Sentinel requires explicit client support, unless the system is configured to execute a script that performs a transparent redirection of all the requests to the new master instance (virtual IP or other similar systems). The topic of client libraries implementation is covered in the document [Sentinel clients guidelines]({{< relref "/develop/reference/sentinel-clients" >}}).
+
+## More advanced concepts
+
+In the following sections we'll cover a few details about how Sentinel works,
+without resorting to implementation details and algorithms that will be
+covered in the final part of this document.
+
+### SDOWN and ODOWN failure state
+
+Redis Sentinel has two different concepts of *being down*, one is called
+a *Subjectively Down* condition (SDOWN) and is a down condition that is
+local to a given Sentinel instance. Another is called *Objectively Down*
+condition (ODOWN) and is reached when enough Sentinels (at least the
+number configured as the `quorum` parameter of the monitored master) have
+an SDOWN condition, and get feedback from other Sentinels using
+the `SENTINEL is-master-down-by-addr` command.
+
+From the point of view of a Sentinel an SDOWN condition is reached when it
+does not receive a valid reply to PING requests for the number of seconds
+specified in the configuration as `is-master-down-after-milliseconds`
+parameter.
+
+An acceptable reply to PING is one of the following:
+
+* PING replied with +PONG.
+* PING replied with -LOADING error.
+* PING replied with -MASTERDOWN error.
+
+Any other reply (or no reply at all) is considered non valid.
+However note that **a logical master that advertises itself as a replica in
+the INFO output is considered to be down**.
+
+Note that SDOWN requires that no acceptable reply is received for the whole
+interval configured, so for instance if the interval is 30000 milliseconds
+(30 seconds) and we receive an acceptable ping reply every 29 seconds, the
+instance is considered to be working.
+
+SDOWN is not enough to trigger a failover: it only means a single Sentinel
+believes a Redis instance is not available. To trigger a failover, the
+ODOWN state must be reached.
+
+To switch from SDOWN to ODOWN no strong consensus algorithm is used, but
+just a form of gossip: if a given Sentinel gets reports that a master
+is not working from enough Sentinels **in a given time range**, the SDOWN is
+promoted to ODOWN. If this acknowledge is later missing, the flag is cleared.
+
+A more strict authorization that uses an actual majority is required in
+order to really start the failover, but no failover can be triggered without
+reaching the ODOWN state.
+
+The ODOWN condition **only applies to masters**. For other kind of instances
+Sentinel doesn't require to act, so the ODOWN state is never reached for replicas
+and other sentinels, but only SDOWN is.
+
+However SDOWN has also semantic implications. For example a replica in SDOWN
+state is not selected to be promoted by a Sentinel performing a failover.
+
+Sentinels and replicas auto discovery
+---
+
+Sentinels stay connected with other Sentinels in order to reciprocally
+check the availability of each other, and to exchange messages. However you
+don't need to configure a list of other Sentinel addresses in every Sentinel
+instance you run, as Sentinel uses the Redis instances Pub/Sub capabilities
+in order to discover the other Sentinels that are monitoring the same masters
+and replicas.
+
+This feature is implemented by sending *hello messages* into the channel named
+`__sentinel__:hello`.
+
+Similarly you don't need to configure what is the list of the replicas attached
+to a master, as Sentinel will auto discover this list querying Redis.
+
+* Every Sentinel publishes a message to every monitored master and replica Pub/Sub channel `__sentinel__:hello`, every two seconds, announcing its presence with ip, port, runid.
+* Every Sentinel is subscribed to the Pub/Sub channel `__sentinel__:hello` of every master and replica, looking for unknown sentinels. When new sentinels are detected, they are added as sentinels of this master.
+* Hello messages also include the full current configuration of the master. If the receiving Sentinel has a configuration for a given master which is older than the one received, it updates to the new configuration immediately.
+* Before adding a new sentinel to a master a Sentinel always checks if there is already a sentinel with the same runid or the same address (ip and port pair). In that case all the matching sentinels are removed, and the new added.
+
+Sentinel reconfiguration of instances outside the failover procedure
+---
+
+Even when no failover is in progress, Sentinels will always try to set the
+current configuration on monitored instances. Specifically:
+
+* Replicas (according to the current configuration) that claim to be masters, will be configured as replicas to replicate with the current master.
+* Replicas connected to a wrong master, will be reconfigured to replicate with the right master.
+
+For Sentinels to reconfigure replicas, the wrong configuration must be observed for some time, that is greater than the period used to broadcast new configurations.
+
+This prevents Sentinels with a stale configuration (for example because they just rejoined from a partition) will try to change the replicas configuration before receiving an update.
+
+Also note how the semantics of always trying to impose the current configuration makes the failover more resistant to partitions:
+
+* Masters failed over are reconfigured as replicas when they return available.
+* Replicas partitioned away during a partition are reconfigured once reachable.
+
+The important lesson to remember about this section is: **Sentinel is a system where each process will always try to impose the last logical configuration to the set of monitored instances**.
+
+### Replica selection and priority
+
+When a Sentinel instance is ready to perform a failover, since the master
+is in `ODOWN` state and the Sentinel received the authorization to failover
+from the majority of the Sentinel instances known, a suitable replica needs
+to be selected.
+
+The replica selection process evaluates the following information about replicas:
+
+1. Disconnection time from the master.
+2. Replica priority.
+3. Replication offset processed.
+4. Run ID.
+
+A replica that is found to be disconnected from the master for more than ten
+times the configured master timeout (down-after-milliseconds option), plus
+the time the master is also not available from the point of view of the
+Sentinel doing the failover, is considered to be not suitable for the failover
+and is skipped.
+
+In more rigorous terms, a replica whose the [`INFO`](/commands/info) output suggests it has been
+disconnected from the master for more than:
+
+    (down-after-milliseconds * 10) + milliseconds_since_master_is_in_SDOWN_state
+
+Is considered to be unreliable and is disregarded entirely.
+
+The replica selection only considers the replicas that passed the above test,
+and sorts it based on the above criteria, in the following order.
+
+1. The replicas are sorted by `replica-priority` as configured in the `redis.conf` file of the Redis instance. A lower priority will be preferred.
+2. If the priority is the same, the replication offset processed by the replica is checked, and the replica that received more data from the master is selected.
+3. If multiple replicas have the same priority and processed the same data from the master, a further check is performed, selecting the replica with the lexicographically smaller run ID. Having a lower run ID is not a real advantage for a replica, but is useful in order to make the process of replica selection more deterministic, instead of resorting to select a random replica.
+
+In most cases, `replica-priority` does not need to be set explicitly so all
+instances will use the same default value. If there is a particular fail-over
+preference, `replica-priority` must be set on all instances, including masters,
+as a master may become a replica at some future point in time - and it will then
+need the proper `replica-priority` settings.
+
+A Redis instance can be configured with a special `replica-priority` of zero
+in order to be **never selected** by Sentinels as the new master.
+However a replica configured in this way will still be reconfigured by
+Sentinels in order to replicate with the new master after a failover, the
+only difference is that it will never become a master itself.
+
+## Algorithms and internals
+
+In the following sections we will explore the details of Sentinel behavior.
+It is not strictly needed for users to be aware of all the details, but a
+deep understanding of Sentinel may help to deploy and operate Sentinel in
+a more effective way.
+
+### Quorum
+
+The previous sections showed that every master monitored by Sentinel is associated to a configured **quorum**. It specifies the number of Sentinel processes
+that need to agree about the unreachability or error condition of the master in
+order to trigger a failover.
+
+However, after the failover is triggered, in order for the failover to actually be performed, **at least a majority of Sentinels must authorize the Sentinel to
+failover**. Sentinel never performs a failover in the partition where a
+minority of Sentinels exist.
+
+Let's try to make things a bit more clear:
+
+* Quorum: the number of Sentinel processes that need to detect an error condition in order for a master to be flagged as **ODOWN**.
+* The failover is triggered by the **ODOWN** state.
+* Once the failover is triggered, the Sentinel trying to failover is required to ask for authorization to a majority of Sentinels (or more than the majority if the quorum is set to a number greater than the majority).
+
+The difference may seem subtle but is actually quite simple to understand and use.  For example if you have 5 Sentinel instances, and the quorum is set to 2, a failover will be triggered as soon as 2 Sentinels believe that the master is not reachable, however one of the two Sentinels will be able to failover only if it gets authorization at least from 3 Sentinels.
+
+If instead the quorum is configured to 5, all the Sentinels must agree about the master error condition, and the authorization from all Sentinels is required in order to failover.
+
+This means that the quorum can be used to tune Sentinel in two ways:
+
+1. If a quorum is set to a value smaller than the majority of Sentinels we deploy, we are basically making Sentinel more sensitive to master failures, triggering a failover as soon as even just a minority of Sentinels is no longer able to talk with the master.
+2. If a quorum is set to a value greater than the majority of Sentinels, we are making Sentinel able to failover only when there are a very large number (larger than majority) of well connected Sentinels which agree about the master being down.
+
+### Configuration epochs
+
+Sentinels require to get authorizations from a majority in order to start a
+failover for a few important reasons:
+
+When a Sentinel is authorized, it gets a unique **configuration epoch** for the master it is failing over. This is a number that will be used to version the new configuration after the failover is completed. Because a majority agreed that a given version was assigned to a given Sentinel, no other Sentinel will be able to use it. This means that every configuration of every failover is versioned with a unique version. We'll see why this is so important.
+
+Moreover Sentinels have a rule: if a Sentinel voted another Sentinel for the failover of a given master, it will wait some time to try to failover the same master again. This delay is the `2 * failover-timeout` you can configure in `sentinel.conf`. This means that Sentinels will not try to failover the same master at the same time, the first to ask to be authorized will try, if it fails another will try after some time, and so forth.
+
+Redis Sentinel guarantees the *liveness* property that if a majority of Sentinels are able to talk, eventually one will be authorized to failover if the master is down.
+
+Redis Sentinel also guarantees the *safety* property that every Sentinel will failover the same master using a different *configuration epoch*.
+
+### Configuration propagation
+
+Once a Sentinel is able to failover a master successfully, it will start to broadcast the new configuration so that the other Sentinels will update their information about a given master.
+
+For a failover to be considered successful, it requires that the Sentinel was able to send the `REPLICAOF NO ONE` command to the selected replica, and that the switch to master was later observed in the [`INFO`](/commands/info) output of the master.
+
+At this point, even if the reconfiguration of the replicas is in progress, the failover is considered to be successful, and all the Sentinels are required to start reporting the new configuration.
+
+The way a new configuration is propagated is the reason why we need that every
+Sentinel failover is authorized with a different version number (configuration epoch).
+
+Every Sentinel continuously broadcast its version of the configuration of a master using Redis Pub/Sub messages, both in the master and all the replicas.  At the same time all the Sentinels wait for messages to see what is the configuration
+advertised by the other Sentinels.
+
+Configurations are broadcast in the `__sentinel__:hello` Pub/Sub channel.
+
+Because every configuration has a different version number, the greater version
+always wins over smaller versions.
+
+So for example the configuration for the master `mymaster` start with all the
+Sentinels believing the master is at 192.168.1.50:6379. This configuration
+has version 1. After some time a Sentinel is authorized to failover with version 2. If the failover is successful, it will start to broadcast a new configuration, let's say 192.168.1.50:9000, with version 2. All the other instances will see this configuration and will update their configuration accordingly, since the new configuration has a greater version.
+
+This means that Sentinel guarantees a second liveness property: a set of
+Sentinels that are able to communicate will all converge to the same configuration with the higher version number.
+
+Basically if the net is partitioned, every partition will converge to the higher
+local configuration. In the special case of no partitions, there is a single
+partition and every Sentinel will agree about the configuration.
+
+### Consistency under partitions
+
+Redis Sentinel configurations are eventually consistent, so every partition will
+converge to the higher configuration available.
+However in a real-world system using Sentinel there are three different players:
+
+* Redis instances.
+* Sentinel instances.
+* Clients.
+
+In order to define the behavior of the system we have to consider all three.
+
+The following is a simple network where there are 3 nodes, each running
+a Redis instance, and a Sentinel instance:
+
+                +-------------+
+                | Sentinel 1  |----- Client A
+                | Redis 1 (M) |
+                +-------------+
+                        |
+                        |
+    +-------------+     |          +------------+
+    | Sentinel 2  |-----+-- // ----| Sentinel 3 |----- Client B
+    | Redis 2 (S) |                | Redis 3 (M)|
+    +-------------+                +------------+
+
+In this system the original state was that Redis 3 was the master, while
+Redis 1 and 2 were replicas. A partition occurred isolating the old master.
+Sentinels 1 and 2 started a failover promoting Sentinel 1 as the new master.
+
+The Sentinel properties guarantee that Sentinel 1 and 2 now have the new
+configuration for the master. However Sentinel 3 has still the old configuration
+since it lives in a different partition.
+
+We know that Sentinel 3 will get its configuration updated when the network
+partition will heal, however what happens during the partition if there
+are clients partitioned with the old master?
+
+Clients will be still able to write to Redis 3, the old master. When the
+partition will rejoin, Redis 3 will be turned into a replica of Redis 1, and
+all the data written during the partition will be lost.
+
+Depending on your configuration you may want or not that this scenario happens:
+
+* If you are using Redis as a cache, it could be handy that Client B is still able to write to the old master, even if its data will be lost.
+* If you are using Redis as a store, this is not good and you need to configure the system in order to partially prevent this problem.
+
+Since Redis is asynchronously replicated, there is no way to totally prevent data loss in this scenario, however you can bound the divergence between Redis 3 and Redis 1
+using the following Redis configuration option:
+
+    min-replicas-to-write 1
+    min-replicas-max-lag 10
+
+With the above configuration (please see the self-commented `redis.conf` example in the Redis distribution for more information) a Redis instance, when acting as a master, will stop accepting writes if it can't write to at least 1 replica. Since replication is asynchronous *not being able to write* actually means that the replica is either disconnected, or is not sending us asynchronous acknowledges for more than the specified `max-lag` number of seconds.
+
+Using this configuration the Redis 3 in the above example will become unavailable after 10 seconds. When the partition heals, the Sentinel 3 configuration will converge to
+the new one, and Client B will be able to fetch a valid configuration and continue.
+
+In general Redis + Sentinel as a whole are an **eventually consistent system** where the merge function is **last failover wins**, and the data from old masters are discarded to replicate the data of the current master, so there is always a window for losing acknowledged writes. This is due to Redis asynchronous
+replication and the discarding nature of the "virtual" merge function of the system. Note that this is not a limitation of Sentinel itself, and if you orchestrate the failover with a strongly consistent replicated state machine, the same properties will still apply. There are only two ways to avoid losing acknowledged writes:
+
+1. Use synchronous replication (and a proper consensus algorithm to run a replicated state machine).
+2. Use an eventually consistent system where different versions of the same object can be merged.
+
+Redis currently is not able to use any of the above systems, and is currently outside the development goals. However there are proxies implementing solution "2" on top of Redis stores such as SoundCloud [Roshi](https://github.com/soundcloud/roshi), or Netflix [Dynomite](https://github.com/Netflix/dynomite).
+
+Sentinel persistent state
+---
+
+Sentinel state is persisted in the sentinel configuration file. For example
+every time a new configuration is received, or created (leader Sentinels), for
+a master, the configuration is persisted on disk together with the configuration
+epoch. This means that it is safe to stop and restart Sentinel processes.
+
+### TILT mode
+
+Redis Sentinel is heavily dependent on the computer time: for instance in
+order to understand if an instance is available it remembers the time of the
+latest successful reply to the PING command, and compares it with the current
+time to understand how old it is.
+
+However if the computer time changes in an unexpected way, or if the computer
+is very busy, or the process blocked for some reason, Sentinel may start to
+behave in an unexpected way.
+
+The TILT mode is a special "protection" mode that a Sentinel can enter when
+something odd is detected that can lower the reliability of the system.
+The Sentinel timer interrupt is normally called 10 times per second, so we
+expect that more or less 100 milliseconds will elapse between two calls
+to the timer interrupt.
+
+What a Sentinel does is to register the previous time the timer interrupt
+was called, and compare it with the current call: if the time difference
+is negative or unexpectedly big (2 seconds or more) the TILT mode is entered
+(or if it was already entered the exit from the TILT mode postponed).
+
+When in TILT mode the Sentinel will continue to monitor everything, but:
+
+* It stops acting at all.
+* It starts to reply negatively to `SENTINEL is-master-down-by-addr` requests as the ability to detect a failure is no longer trusted.
+
+If everything appears to be normal for 30 second, the TILT mode is exited.
+ 
+In the Sentinel TILT mode, if we send the INFO command, we could get the following response:
+
+    $ redis-cli -p 26379
+    127.0.0.1:26379> info
+    (Other information from Sentinel server skipped.)
+
+    # Sentinel
+    sentinel_masters:1
+    sentinel_tilt:0
+    sentinel_tilt_since_seconds:-1
+    sentinel_running_scripts:0
+    sentinel_scripts_queue_length:0
+    sentinel_simulate_failure_flags:0
+    master0:name=mymaster,status=ok,address=127.0.0.1:6379,slaves=0,sentinels=1
+
+The field "sentinel_tilt_since_seconds" indicates how many seconds the Sentinel already is in the TILT mode.
+If it is not in TILT mode, the value will be -1.
+
+Note that in some ways TILT mode could be replaced using the monotonic clock
+API that many kernels offer. However it is not still clear if this is a good
+solution since the current system avoids issues in case the process is just
+suspended or not executed by the scheduler for a long time.
+
+**A note about the word slave used in this man page**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: 'Performance engineering guide for on-CPU profiling and tracing
+
+  '
+linkTitle: CPU profiling
+title: Redis CPU profiling
+weight: 1
+---
+
+## 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. 
+
+Nevertheless, if you're finding room to improve the efficiency of Redis or
+are pursuing a performance regression investigation you will need a concise
+methodical way of monitoring and analyzing Redis performance. 
+
+To do so you can rely on different methodologies (some more suited than other 
+depending on the class of issues/analysis we intend to make). A curated list
+of methodologies and their steps are enumerated by Brendan Greg at the
+[following link](http://www.brendangregg.com/methodology.html). 
+
+We recommend the Utilization Saturation and Errors (USE) Method for answering
+the question of what is your bottleneck. Check the following mapping between
+system resource, metric, and tools for a practical deep dive:
+[USE method](http://www.brendangregg.com/USEmethod/use-rosetta.html). 
+
+### Ensuring the CPU is your bottleneck
+
+This guide assumes you've followed one of the above methodologies to perform a 
+complete check of system health, and identified the bottleneck being the CPU. 
+**If you have identified that most of the time is spent blocked on I/O, locks,
+timers, paging/swapping, etc., this guide is not for you**. 
+
+### Build Prerequisites
+
+For a proper On-CPU analysis, Redis (and any dynamically loaded library like
+Redis Modules) requires stack traces to be available to tracers, which you may
+need to fix first. 
+
+By default, Redis is compiled with the `-O2` switch (which we intent to keep
+during profiling). This means that compiler optimizations are enabled. Many
+compilers omit the frame pointer as a runtime optimization (saving a register),
+thus breaking frame pointer-based stack walking. This makes the Redis
+executable faster, but at the same time it makes Redis (like any other program)
+harder to trace, potentially wrongfully pinpointing on-CPU time to the last
+available frame pointer of a call stack that can get a lot deeper (but
+impossible to trace).
+
+It's important that you ensure that:
+- debug information is present: compile option `-g`
+- frame pointer register is present: `-fno-omit-frame-pointer`
+- we still run with optimizations to get an accurate representation of production run times, meaning we will keep: `-O2`
+
+You can do it as follows within redis main repo:
+
+    $ make REDIS_CFLAGS="-g -fno-omit-frame-pointer"
+
+## A set of instruments to identify performance regressions and/or potential **on-CPU performance** improvements 
+
+This document focuses specifically on **on-CPU** resource bottlenecks analysis,
+meaning we're interested in understanding where threads are spending CPU cycles
+while running on-CPU and, as importantly, whether those cycles are effectively
+being used for computation or stalled waiting (not blocked!) for memory I/O,
+and cache misses, etc.
+
+For that we will rely on toolkits (perf, bcc tools), and hardware specific PMCs
+(Performance Monitoring Counters), to proceed with:
+
+- Hotspot analysis (perf or bcc tools): to profile code execution and determine which functions are consuming the most time and thus are targets for optimization. We'll present two options to collect, report, and visualize hotspots either with perf or bcc/BPF tracing tools.
+
+- Call counts analysis: to count events including function calls, enabling us to correlate several calls/components at once, relying on bcc/BPF tracing tools.
+
+- Hardware event sampling: crucial for understanding CPU behavior, including memory I/O, stall cycles, and cache misses.
+
+### Tool prerequisites
+
+The following steps rely on Linux perf_events (aka ["perf"](https://man7.org/linux/man-pages/man1/perf.1.html)), [bcc/BPF tracing tools](https://github.com/iovisor/bcc), and Brendan Greg’s [FlameGraph repo](https://github.com/brendangregg/FlameGraph).
+
+We assume beforehand you have:
+
+- Installed the perf tool on your system. Most Linux distributions will likely package this as a package related to the kernel. More information about the perf tool can be found at perf [wiki](https://perf.wiki.kernel.org/).
+- Followed the install [bcc/BPF](https://github.com/iovisor/bcc/blob/master/INSTALL.md#installing-bcc) instructions to install bcc toolkit on your machine.
+- Cloned Brendan Greg’s [FlameGraph repo](https://github.com/brendangregg/FlameGraph) and made accessible the `difffolded.pl` and `flamegraph.pl` files, to generated the collapsed stack traces and Flame Graphs.
+
+## Hotspot analysis with perf or eBPF (stack traces sampling)
+
+Profiling CPU usage by sampling stack traces at a timed interval is a fast and
+easy way to identify performance-critical code sections (hotspots).
+
+### Sampling stack traces using perf
+
+To profile both user- and kernel-level stacks of redis-server for a specific
+length of time, for example 60 seconds, at a sampling frequency of 999 samples
+per second:
+
+    $ perf record -g --pid $(pgrep redis-server) -F 999 -- sleep 60
+
+#### Displaying the recorded profile information using perf report
+
+By default perf record will generate a perf.data file in the current working
+directory. 
+
+You can then report with a call-graph output (call chain, stack backtrace),
+with a minimum call graph inclusion threshold of 0.5%, with:
+
+    $ perf report -g "graph,0.5,caller"
+
+See the [perf report](https://man7.org/linux/man-pages/man1/perf-report.1.html)
+documentation for advanced filtering, sorting and aggregation capabilities.
+
+#### Visualizing the recorded profile information using Flame Graphs
+
+[Flame graphs](http://www.brendangregg.com/flamegraphs.html) allow for a quick
+and accurate visualization of frequent code-paths. They can be generated using
+Brendan Greg's open source programs on [github](https://github.com/brendangregg/FlameGraph),
+which create interactive SVGs from folded stack files.
+
+Specifically, for perf we need to convert the generated perf.data into the
+captured stacks, and fold each of them into single lines. You can then render
+the on-CPU flame graph with:
+
+    $ perf script > redis.perf.stacks
+    $ stackcollapse-perf.pl redis.perf.stacks > redis.folded.stacks
+    $ flamegraph.pl redis.folded.stacks > redis.svg
+
+By default, perf script will generate a perf.data file in the current working
+directory. See the [perf script](https://linux.die.net/man/1/perf-script)
+documentation for advanced usage.
+
+See [FlameGraph usage options](https://github.com/brendangregg/FlameGraph#options)
+for more advanced stack trace visualizations (like the differential one).
+
+#### Archiving and sharing recorded profile information
+
+So that analysis of the perf.data contents can be possible on a machine other
+than the one on which collection happened, you need to export along with the
+perf.data file all object files with build-ids found in the record data file.
+This can be easily done with the help of 
+[perf-archive.sh](https://github.com/torvalds/linux/blob/master/tools/perf/perf-archive.sh)
+script:
+
+    $ perf-archive.sh perf.data
+
+Now please run:
+
+    $ tar xvf perf.data.tar.bz2 -C ~/.debug
+
+on the machine where you need to run `perf report`.
+
+### Sampling stack traces using bcc/BPF's profile
+    
+Similarly to perf, as of Linux kernel 4.9, BPF-optimized profiling is now fully
+available with the promise of lower overhead on CPU (as stack traces are
+frequency counted in kernel context) and disk I/O resources during profiling. 
+
+Apart from that, and relying solely on bcc/BPF's profile tool, we have also
+removed the perf.data and intermediate steps if stack traces analysis is our
+main goal. You can use bcc's profile tool to output folded format directly, for
+flame graph generation:
+
+    $ /usr/share/bcc/tools/profile -F 999 -f --pid $(pgrep redis-server) --duration 60 > redis.folded.stacks
+
+In that manner, we've remove any preprocessing and can render the on-CPU flame
+graph with a single command:
+
+    $ flamegraph.pl redis.folded.stacks > redis.svg
+
+### Visualizing the recorded profile information using Flame Graphs
+
+## Call counts analysis with bcc/BPF
+
+A function may consume significant CPU cycles either because its code is slow
+or because it's frequently called. To answer at what rate functions are being
+called, you can rely upon call counts analysis using BCC's `funccount` tool:
+
+    $ /usr/share/bcc/tools/funccount 'redis-server:(call*|*Read*|*Write*)' --pid $(pgrep redis-server) --duration 60
+    Tracing 64 functions for "redis-server:(call*|*Read*|*Write*)"... Hit Ctrl-C to end.
+
+    FUNC                                    COUNT
+    call                                      334
+    handleClientsWithPendingWrites            388
+    clientInstallWriteHandler                 388
+    postponeClientRead                        514
+    handleClientsWithPendingReadsUsingThreads      735
+    handleClientsWithPendingWritesUsingThreads      735
+    prepareClientToWrite                     1442
+    Detaching...
+
+
+The above output shows that, while tracing, the Redis's call() function was
+called 334 times, handleClientsWithPendingWrites() 388 times, etc.
+
+## Hardware event counting with Performance Monitoring Counters (PMCs)
+
+Many modern processors contain a performance monitoring unit (PMU) exposing
+Performance Monitoring Counters (PMCs). PMCs are crucial for understanding CPU
+behavior, including memory I/O, stall cycles, and cache misses, and provide
+low-level CPU performance statistics that aren't available anywhere else.
+
+The design and functionality of a PMU is CPU-specific and you should assess
+your CPU supported counters and features by using `perf list`. 
+
+To calculate the number of instructions per cycle, the number of micro ops
+executed, the number of cycles during which no micro ops were dispatched, the
+number stalled cycles on memory, including a per memory type stalls, for the
+duration of 60s, specifically for redis process: 
+
+    $ perf stat -e "cpu-clock,cpu-cycles,instructions,uops_executed.core,uops_executed.stall_cycles,cache-references,cache-misses,cycle_activity.stalls_total,cycle_activity.stalls_mem_any,cycle_activity.stalls_l3_miss,cycle_activity.stalls_l2_miss,cycle_activity.stalls_l1d_miss" --pid $(pgrep redis-server) -- sleep 60
+
+    Performance counter stats for process id '3038':
+
+      60046.411437      cpu-clock (msec)          #    1.001 CPUs utilized          
+      168991975443      cpu-cycles                #    2.814 GHz                      (36.40%)
+      388248178431      instructions              #    2.30  insn per cycle           (45.50%)
+      443134227322      uops_executed.core        # 7379.862 M/sec                    (45.51%)
+       30317116399      uops_executed.stall_cycles #  504.895 M/sec                    (45.51%)
+         670821512      cache-references          #   11.172 M/sec                    (45.52%)
+          23727619      cache-misses              #    3.537 % of all cache refs      (45.43%)
+       30278479141      cycle_activity.stalls_total #  504.251 M/sec                    (36.33%)
+       19981138777      cycle_activity.stalls_mem_any #  332.762 M/sec                    (36.33%)
+         725708324      cycle_activity.stalls_l3_miss #   12.086 M/sec                    (36.33%)
+        8487905659      cycle_activity.stalls_l2_miss #  141.356 M/sec                    (36.32%)
+       10011909368      cycle_activity.stalls_l1d_miss #  166.736 M/sec                    (36.31%)
+
+      60.002765665 seconds time elapsed
+
+It's important to know that there are two very different ways in which PMCs can
+be used (counting and sampling), and we've focused solely on PMCs counting for
+the sake of this analysis. Brendan Greg clearly explains it on the following
+[link](http://www.brendangregg.com/blog/2017-05-04/the-pmcs-of-ec2.html).
+
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Discovering slow server events in Redis
+linkTitle: Latency monitoring
+title: Redis latency monitoring
+weight: 1
+---
+
+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.
+
+Finally, Redis is single threaded. This is usually an advantage
+from the point of view of the amount of work it can perform per core, and in
+the latency figures it is able to provide. However, it poses
+a challenge for latency, since the single
+thread must be able to perform certain tasks incrementally, for
+example key expiration, in a way that does not impact the other clients
+that are served.
+
+For all these reasons, Redis 2.8.13 introduced a new feature called
+**Latency Monitoring**, that helps the user to check and troubleshoot possible
+latency problems. Latency monitoring is composed of the following conceptual
+parts:
+
+* Latency hooks that sample different latency-sensitive code paths.
+* Time series recording of latency spikes, split by different events.
+* Reporting engine to fetch raw data from the time series.
+* Analysis engine to provide human-readable reports and hints according to the measurements.
+
+The rest of this document covers the latency monitoring subsystem
+details. For more information about the general topic of Redis
+and latency, see [Redis latency problems troubleshooting]({{< relref "/operate/oss_and_stack/management/optimization/latency" >}}).
+
+## Events and time series
+
+Different monitored code paths have different names and are called *events*.
+For example, `command` is an event that measures latency spikes of possibly slow
+command executions, while `fast-command` is the event name for the monitoring
+of the O(1) and O(log N) commands. Other events are less generic and monitor
+specific operations performed by Redis. For example, the `fork` event
+only monitors the time taken by Redis to execute the `fork(2)` system call.
+
+A latency spike is an event that takes more time to run than the configured latency
+threshold. There is a separate time series associated with every monitored
+event. This is how the time series work:
+
+* Every time a latency spike happens, it is logged in the appropriate time series.
+* Every time series is composed of 160 elements.
+* Each element is a pair made of a Unix timestamp of the time the latency spike was measured and the number of milliseconds the event took to execute.
+* Latency spikes for the same event that occur in the same second are merged by taking the maximum latency. Even if continuous latency spikes are measured for a given event, which could happen with a low threshold, at least 160 seconds of history are available.
+* Records the all-time maximum latency for every element.
+
+The framework monitors and logs latency spikes in the execution time of these events:
+
+* `command`: regular commands.
+* `fast-command`: O(1) and O(log N) commands.
+* `fork`: the `fork(2)` system call.
+* `rdb-unlink-temp-file`: the `unlink(2)` system call.
+* `aof-fsync-always`: the `fsync(2)` system call when invoked by the `appendfsync allways` policy.
+* `aof-write`: writing to the AOF - a catchall event for `write(2)` system calls.
+* `aof-write-pending-fsync`: the `write(2)` system call when there is a pending fsync.
+* `aof-write-active-child`: the `write(2)` system call when there are active child processes.
+* `aof-write-alone`: the `write(2)` system call when no pending fsync and no active child process.
+* `aof-fstat`: the `fstat(2)` system call.
+* `aof-rename`: the `rename(2)` system call for renaming the temporary file after completing [`BGREWRITEAOF`](/commands/bgrewriteaof).
+* `aof-rewrite-diff-write`: writing the differences accumulated while performing [`BGREWRITEAOF`](/commands/bgrewriteaof).
+* `active-defrag-cycle`: the active defragmentation cycle.
+* `expire-cycle`: the expiration cycle.
+* `eviction-cycle`: the eviction cycle.
+* `eviction-del`: deletes during the eviction cycle.
+
+## How to enable latency monitoring
+
+What is high latency for one use case may not be considered high latency for another. Some applications may require that all queries be served in less than 1 millisecond. For other applications, it may be acceptable for a small amount of clients to experience a 2 second latency on occasion.
+
+The first step to enable the latency monitor is to set a **latency threshold** in milliseconds. Only events that take longer than the specified threshold will be logged as latency spikes. The user should set the threshold according to their needs. For example, if the application requires a maximum acceptable latency of 100 milliseconds, the threshold should be set to log all the events blocking the server for a time equal or greater to 100 milliseconds.
+
+Enable the latency monitor at runtime in a production server
+with the following command:
+
+    CONFIG SET latency-monitor-threshold 100
+
+Monitoring is turned off by default (threshold set to 0), even if the actual cost of latency monitoring is near zero. While the memory requirements of latency monitoring are very small, there is no good reason to raise the baseline memory usage of a Redis instance that is working well.
+
+## Report information with the LATENCY command
+
+The user interface to the latency monitoring subsystem is the [`LATENCY`](/commands/latency) command.
+Like many other Redis commands, [`LATENCY`](/commands/latency) accepts subcommands that modify its behavior. These subcommands are:
+
+* [`LATENCY LATEST`](/commands/latency-latest) - returns the latest latency samples for all events.
+* [`LATENCY HISTORY`](/commands/latency-history) - returns latency time series for a given event.
+* [`LATENCY RESET`](/commands/latency-reset) - resets latency time series data for one or more events.
+* [`LATENCY GRAPH`](/commands/latency-graph) - renders an ASCII-art graph of an event's latency samples.
+* [`LATENCY DOCTOR`](/commands/latency-doctor) - replies with a human-readable latency analysis report.
+
+Refer to each subcommand's documentation page for further information.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Finding the causes of slow responses
+linkTitle: Latency diagnosis
+title: Diagnosing latency issues
+weight: 1
+---
+
+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.
+
+I've little time, give me the checklist
+---
+
+The following documentation is very important in order to run Redis in
+a low latency fashion. However I understand that we are busy people, so
+let's start with a quick checklist. If you fail following these steps, please
+return here to read the full documentation.
+
+1. Make sure you are not running slow commands that are blocking the server. Use the Redis [Slow Log feature](/commands/slowlog) to check this.
+2. For EC2 users, make sure you use HVM based modern EC2 instances, like m3.medium. Otherwise fork() is too slow.
+3. Transparent huge pages must be disabled from your kernel. Use `echo never > /sys/kernel/mm/transparent_hugepage/enabled` to disable them, and restart your Redis process.
+4. If you are using a virtual machine, it is possible that you have an intrinsic latency that has nothing to do with Redis. Check the minimum latency you can expect from your runtime environment using `./redis-cli --intrinsic-latency 100`. Note: you need to run this command in *the server* not in the client.
+5. Enable and use the [Latency monitor]({{< relref "operate/oss_and_stack/management/optimization/latency-monitor" >}}) feature of Redis in order to get a human readable description of the latency events and causes in your Redis instance.
+
+In general, use the following table for durability VS latency/performance tradeoffs, ordered from stronger safety to better latency.
+
+1. AOF + fsync always: this is very slow, you should use it only if you know what you are doing.
+2. AOF + fsync every second: this is a good compromise.
+3. AOF + fsync every second + no-appendfsync-on-rewrite option set to yes: this is as the above, but avoids to fsync during rewrites to lower the disk pressure.
+4. AOF + fsync never. Fsyncing is up to the kernel in this setup, even less disk pressure and risk of latency spikes.
+5. RDB. Here you have a vast spectrum of tradeoffs depending on the save triggers you configure.
+
+And now for people with 15 minutes to spend, the details...
+
+Measuring latency
+-----------------
+
+If you are experiencing latency problems, you probably know how to measure
+it in the context of your application, or maybe your latency problem is very
+evident even macroscopically. However redis-cli can be used to measure the
+latency of a Redis server in milliseconds, just try:
+
+    redis-cli --latency -h `host` -p `port`
+
+Using the internal Redis latency monitoring subsystem
+---
+
+Since Redis 2.8.13, Redis provides latency monitoring capabilities that
+are able to sample different execution paths to understand where the
+server is blocking. This makes debugging of the problems illustrated in
+this documentation much simpler, so we suggest enabling latency monitoring
+ASAP. Please refer to the [Latency monitor documentation]({{< relref "operate/oss_and_stack/management/optimization/latency-monitor" >}}).
+
+While the latency monitoring sampling and reporting capabilities will make
+it simpler to understand the source of latency in your Redis system, it is still
+advised that you read this documentation extensively to better understand
+the topic of Redis and latency spikes.
+
+Latency baseline
+----------------
+
+There is a kind of latency that is inherently part of the environment where
+you run Redis, that is the latency provided by your operating system kernel
+and, if you are using virtualization, by the hypervisor you are using.
+
+While this latency can't be removed it is important to study it because
+it is the baseline, or in other words, you won't be able to achieve a Redis
+latency that is better than the latency that every process running in your
+environment will experience because of the kernel or hypervisor implementation
+or setup.
+
+We call this kind of latency **intrinsic latency**, and `redis-cli` starting
+from Redis version 2.8.7 is able to measure it. This is an example run
+under Linux 3.11.0 running on an entry level server.
+
+Note: the argument `100` is the number of seconds the test will be executed.
+The more time we run the test, the more likely we'll be able to spot
+latency spikes. 100 seconds is usually appropriate, however you may want
+to perform a few runs at different times. Please note that the test is CPU
+intensive and will likely saturate a single core in your system.
+
+    $ ./redis-cli --intrinsic-latency 100
+    Max latency so far: 1 microseconds.
+    Max latency so far: 16 microseconds.
+    Max latency so far: 50 microseconds.
+    Max latency so far: 53 microseconds.
+    Max latency so far: 83 microseconds.
+    Max latency so far: 115 microseconds.
+
+Note: redis-cli in this special case needs to **run in the server** where you run or plan to run Redis, not in the client. In this special mode redis-cli does not connect to a Redis server at all: it will just try to measure the largest time the kernel does not provide CPU time to run to the redis-cli process itself.
+
+In the above example, the intrinsic latency of the system is just 0.115
+milliseconds (or 115 microseconds), which is a good news, however keep in mind
+that the intrinsic latency may change over time depending on the load of the
+system.
+
+Virtualized environments will not show so good numbers, especially with high
+load or if there are noisy neighbors. The following is a run on a Linode 4096
+instance running Redis and Apache:
+
+    $ ./redis-cli --intrinsic-latency 100
+    Max latency so far: 573 microseconds.
+    Max latency so far: 695 microseconds.
+    Max latency so far: 919 microseconds.
+    Max latency so far: 1606 microseconds.
+    Max latency so far: 3191 microseconds.
+    Max latency so far: 9243 microseconds.
+    Max latency so far: 9671 microseconds.
+
+Here we have an intrinsic latency of 9.7 milliseconds: this means that we can't ask better than that to Redis. However other runs at different times in different virtualization environments with higher load or with noisy neighbors can easily show even worse values. We were able to measure up to 40 milliseconds in
+systems otherwise apparently running normally.
+
+Latency induced by network and communication
+--------------------------------------------
+
+Clients connect to Redis using a TCP/IP connection or a Unix domain connection.
+The typical latency of a 1 Gbit/s network is about 200 us, while the latency
+with a Unix domain socket can be as low as 30 us. It actually depends on your
+network and system hardware. On top of the communication itself, the system
+adds some more latency (due to thread scheduling, CPU caches, NUMA placement,
+etc ...). System induced latencies are significantly higher on a virtualized
+environment than on a physical machine.
+
+The consequence is even if Redis processes most commands in sub microsecond
+range, a client performing many roundtrips to the server will have to pay
+for these network and system related latencies.
+
+An efficient client will therefore try to limit the number of roundtrips by
+pipelining several commands together. This is fully supported by the servers
+and most clients. Aggregated commands like MSET/MGET can be also used for
+that purpose. Starting with Redis 2.4, a number of commands also support
+variadic parameters for all data types.
+
+Here are some guidelines:
+
++ If you can afford it, prefer a physical machine over a VM to host the server.
++ Do not systematically connect/disconnect to the server (especially true
+  for web based applications). Keep your connections as long lived as possible.
++ If your client is on the same host than the server, use Unix domain sockets.
++ Prefer to use aggregated commands (MSET/MGET), or commands with variadic
+  parameters (if possible) over pipelining.
++ Prefer to use pipelining (if possible) over sequence of roundtrips.
++ Redis supports Lua server-side scripting to cover cases that are not suitable
+  for raw pipelining (for instance when the result of a command is an input for
+  the following commands).
+
+On Linux, some people can achieve better latencies by playing with process
+placement (taskset), cgroups, real-time priorities (chrt), NUMA
+configuration (numactl), or by using a low-latency kernel. Please note
+vanilla Redis is not really suitable to be bound on a **single** CPU core.
+Redis can fork background tasks that can be extremely CPU consuming
+like [`BGSAVE`](/commands/bgsave) or [`BGREWRITEAOF`](/commands/bgrewriteaof). These tasks must **never** run on the same core
+as the main event loop.
+
+In most situations, these kind of system level optimizations are not needed.
+Only do them if you require them, and if you are familiar with them.
+
+Single threaded nature of Redis
+-------------------------------
+
+Redis uses a *mostly* single threaded design. This means that a single process
+serves all the client requests, using a technique called **multiplexing**.
+This means that Redis can serve a single request in every given moment, so
+all the requests are served sequentially. This is very similar to how Node.js
+works as well. However, both products are not often perceived as being slow.
+This is caused in part by the small amount of time to complete a single request,
+but primarily because these products are designed to not block on system calls,
+such as reading data from or writing data to a socket.
+
+I said that Redis is *mostly* single threaded since actually from Redis 2.4
+we use threads in Redis in order to perform some slow I/O operations in the
+background, mainly related to disk I/O, but this does not change the fact
+that Redis serves all the requests using a single thread.
+
+Latency generated by slow commands
+----------------------------------
+
+A consequence of being single thread is that when a request is slow to serve
+all the other clients will wait for this request to be served. When executing
+normal commands, like [`GET`](/commands/get) or [`SET`](/commands/set) or [`LPUSH`](/commands/lpush) this is not a problem
+at all since these commands are executed in constant (and very small) time.
+However there are commands operating on many elements, like [`SORT`](/commands/sort), [`LREM`](/commands/lrem),
+[`SUNION`](/commands/sunion) and others. For instance taking the intersection of two big sets
+can take a considerable amount of time.
+
+The algorithmic complexity of all commands is documented. A good practice
+is to systematically check it when using commands you are not familiar with.
+
+If you have latency concerns you should either not use slow commands against
+values composed of many elements, or you should run a replica using Redis
+replication where you run all your slow queries.
+
+It is possible to monitor slow commands using the Redis
+[Slow Log feature](/commands/slowlog).
+
+Additionally, you can use your favorite per-process monitoring program
+(top, htop, prstat, etc ...) to quickly check the CPU consumption of the
+main Redis process. If it is high while the traffic is not, it is usually
+a sign that slow commands are used.
+
+**IMPORTANT NOTE**: a VERY common source of latency generated by the execution
+of slow commands is the use of the [`KEYS`](/commands/keys) command in production environments.
+[`KEYS`](/commands/keys), as documented in the Redis documentation, should only be used for
+debugging purposes. Since Redis 2.8 a new commands were introduced in order to
+iterate the key space and other large collections incrementally, please check
+the [`SCAN`](/commands/scan), [`SSCAN`](/commands/sscan), [`HSCAN`](/commands/hscan) and [`ZSCAN`](/commands/zscan) commands for more information.
+
+Latency generated by fork
+-------------------------
+
+In order to generate the RDB file in background, or to rewrite the Append Only File if AOF persistence is enabled, Redis has to fork background processes.
+The fork operation (running in the main thread) can induce latency by itself.
+
+Forking is an expensive operation on most Unix-like systems, since it involves
+copying a good number of objects linked to the process. This is especially
+true for the page table associated to the virtual memory mechanism.
+
+For instance on a Linux/AMD64 system, the memory is divided in 4 kB pages.
+To convert virtual addresses to physical addresses, each process stores
+a page table (actually represented as a tree) containing at least a pointer
+per page of the address space of the process. So a large 24 GB Redis instance
+requires a page table of 24 GB / 4 kB * 8 = 48 MB.
+
+When a background save is performed, this instance will have to be forked,
+which will involve allocating and copying 48 MB of memory. It takes time
+and CPU, especially on virtual machines where allocation and initialization
+of a large memory chunk can be expensive.
+
+Fork time in different systems
+------------------------------
+
+Modern hardware is pretty fast at copying the page table, but Xen is not.
+The problem with Xen is not virtualization-specific, but Xen-specific. For instance using VMware or Virtual Box does not result into slow fork time.
+The following is a table that compares fork time for different Redis instance
+size. Data is obtained performing a BGSAVE and looking at the `latest_fork_usec` filed in the [`INFO`](/commands/info) command output.
+
+However the good news is that **new types of EC2 HVM based instances are much
+better with fork times**, almost on par with physical servers, so for example
+using m3.medium (or better) instances will provide good results.
+
+* **Linux beefy VM on VMware** 6.0GB RSS forked in 77 milliseconds (12.8 milliseconds per GB).
+* **Linux running on physical machine (Unknown HW)** 6.1GB RSS forked in 80 milliseconds (13.1 milliseconds per GB)
+* **Linux running on physical machine (Xeon @ 2.27Ghz)** 6.9GB RSS forked into 62 milliseconds (9 milliseconds per GB).
+* **Linux VM on 6sync (KVM)** 360 MB RSS forked in 8.2 milliseconds (23.3 milliseconds per GB).
+* **Linux VM on EC2, old instance types (Xen)** 6.1GB RSS forked in 1460 milliseconds (239.3 milliseconds per GB).
+* **Linux VM on EC2, new instance types (Xen)** 1GB RSS forked in 10 milliseconds (10 milliseconds per GB).
+* **Linux VM on Linode (Xen)** 0.9GBRSS forked into 382 milliseconds (424 milliseconds per GB).
+
+As you can see certain VMs running on Xen have a performance hit that is between one order to two orders of magnitude. For EC2 users the suggestion is simple: use modern HVM based instances.
+
+Latency induced by transparent huge pages
+-----------------------------------------
+
+Unfortunately when a Linux kernel has transparent huge pages enabled, Redis
+incurs to a big latency penalty after the `fork` call is used in order to
+persist on disk. Huge pages are the cause of the following issue:
+
+1. Fork is called, two processes with shared huge pages are created.
+2. In a busy instance, a few event loops runs will cause commands to target a few thousand of pages, causing the copy on write of almost the whole process memory.
+3. This will result in big latency and big memory usage.
+
+Make sure to **disable transparent huge pages** using the following command:
+
+    echo never > /sys/kernel/mm/transparent_hugepage/enabled
+
+Latency induced by swapping (operating system paging)
+-----------------------------------------------------
+
+Linux (and many other modern operating systems) is able to relocate memory
+pages from the memory to the disk, and vice versa, in order to use the
+system memory efficiently.
+
+If a Redis page is moved by the kernel from the memory to the swap file, when
+the data stored in this memory page is used by Redis (for example accessing
+a key stored into this memory page) the kernel will stop the Redis process
+in order to move the page back into the main memory. This is a slow operation
+involving random I/Os (compared to accessing a page that is already in memory)
+and will result into anomalous latency experienced by Redis clients.
+
+The kernel relocates Redis memory pages on disk mainly because of three reasons:
+
+* The system is under memory pressure since the running processes are demanding
+more physical memory than the amount that is available. The simplest instance of
+this problem is simply Redis using more memory than is available.
+* The Redis instance data set, or part of the data set, is mostly completely idle
+(never accessed by clients), so the kernel could swap idle memory pages on disk.
+This problem is very rare since even a moderately slow instance will touch all
+the memory pages often, forcing the kernel to retain all the pages in memory.
+* Some processes are generating massive read or write I/Os on the system. Because
+files are generally cached, it tends to put pressure on the kernel to increase
+the filesystem cache, and therefore generate swapping activity. Please note it
+includes Redis RDB and/or AOF background threads which can produce large files.
+
+Fortunately Linux offers good tools to investigate the problem, so the simplest
+thing to do is when latency due to swapping is suspected is just to check if
+this is the case.
+
+The first thing to do is to checking the amount of Redis memory that is swapped
+on disk. In order to do so you need to obtain the Redis instance pid:
+
+    $ redis-cli info | grep process_id
+    process_id:5454
+
+Now enter the /proc file system directory for this process:
+
+    $ cd /proc/5454
+
+Here you'll find a file called **smaps** that describes the memory layout of
+the Redis process (assuming you are using Linux 2.6.16 or newer).
+This file contains very detailed information about our process memory maps,
+and one field called **Swap** is exactly what we are looking for. However
+there is not just a single swap field since the smaps file contains the
+different memory maps of our Redis process (The memory layout of a process
+is more complex than a simple linear array of pages).
+
+Since we are interested in all the memory swapped by our process the first thing
+to do is to grep for the Swap field across all the file:
+
+    $ cat smaps | grep 'Swap:'
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                 12 kB
+    Swap:                156 kB
+    Swap:                  8 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  4 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  4 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  4 kB
+    Swap:                  4 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+    Swap:                  0 kB
+
+If everything is 0 kB, or if there are sporadic 4k entries, everything is
+perfectly normal. Actually in our example instance (the one of a real web
+site running Redis and serving hundreds of users every second) there are a
+few entries that show more swapped pages. To investigate if this is a serious
+problem or not we change our command in order to also print the size of the
+memory map:
+
+    $ cat smaps | egrep '^(Swap|Size)'
+    Size:                316 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  8 kB
+    Swap:                  0 kB
+    Size:                 40 kB
+    Swap:                  0 kB
+    Size:                132 kB
+    Swap:                  0 kB
+    Size:             720896 kB
+    Swap:                 12 kB
+    Size:               4096 kB
+    Swap:                156 kB
+    Size:               4096 kB
+    Swap:                  8 kB
+    Size:               4096 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:               1272 kB
+    Swap:                  0 kB
+    Size:                  8 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                 16 kB
+    Swap:                  0 kB
+    Size:                 84 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  8 kB
+    Swap:                  4 kB
+    Size:                  8 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  4 kB
+    Size:                144 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  4 kB
+    Size:                 12 kB
+    Swap:                  4 kB
+    Size:                108 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+    Size:                272 kB
+    Swap:                  0 kB
+    Size:                  4 kB
+    Swap:                  0 kB
+
+As you can see from the output, there is a map of 720896 kB
+(with just 12 kB swapped) and 156 kB more swapped in another map:
+basically a very small amount of our memory is swapped so this is not
+going to create any problem at all.
+
+If instead a non trivial amount of the process memory is swapped on disk your
+latency problems are likely related to swapping. If this is the case with your
+Redis instance you can further verify it using the **vmstat** command:
+
+    $ vmstat 1
+    procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
+     r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
+     0  0   3980 697932 147180 1406456    0    0     2     2    2    0  4  4 91  0
+     0  0   3980 697428 147180 1406580    0    0     0     0 19088 16104  9  6 84  0
+     0  0   3980 697296 147180 1406616    0    0     0    28 18936 16193  7  6 87  0
+     0  0   3980 697048 147180 1406640    0    0     0     0 18613 15987  6  6 88  0
+     2  0   3980 696924 147180 1406656    0    0     0     0 18744 16299  6  5 88  0
+     0  0   3980 697048 147180 1406688    0    0     0     4 18520 15974  6  6 88  0
+    ^C
+
+The interesting part of the output for our needs are the two columns **si**
+and **so**, that counts the amount of memory swapped from/to the swap file. If
+you see non zero counts in those two columns then there is swapping activity
+in your system.
+
+Finally, the **iostat** command can be used to check the global I/O activity of
+the system.
+
+    $ iostat -xk 1
+    avg-cpu:  %user   %nice %system %iowait  %steal   %idle
+              13.55    0.04    2.92    0.53    0.00   82.95
+
+    Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await  svctm  %util
+    sda               0.77     0.00    0.01    0.00     0.40     0.00    73.65     0.00    3.62   2.58   0.00
+    sdb               1.27     4.75    0.82    3.54    38.00    32.32    32.19     0.11   24.80   4.24   1.85
+
+If your latency problem is due to Redis memory being swapped on disk you need
+to lower the memory pressure in your system, either adding more RAM if Redis
+is using more memory than the available, or avoiding running other memory
+hungry processes in the same system.
+
+Latency due to AOF and disk I/O
+-------------------------------
+
+Another source of latency is due to the Append Only File support on Redis.
+The AOF basically uses two system calls to accomplish its work. One is
+write(2) that is used in order to write data to the append only file, and
+the other one is fdatasync(2) that is used in order to flush the kernel
+file buffer on disk in order to ensure the durability level specified by
+the user.
+
+Both the write(2) and fdatasync(2) calls can be source of latency.
+For instance write(2) can block both when there is a system wide sync
+in progress, or when the output buffers are full and the kernel requires
+to flush on disk in order to accept new writes.
+
+The fdatasync(2) call is a worse source of latency as with many combinations
+of kernels and file systems used it can take from a few milliseconds to
+a few seconds to complete, especially in the case of some other process
+doing I/O. For this reason when possible Redis does the fdatasync(2) call
+in a different thread since Redis 2.4.
+
+We'll see how configuration can affect the amount and source of latency
+when using the AOF file.
+
+The AOF can be configured to perform a fsync on disk in three different
+ways using the **appendfsync** configuration option (this setting can be
+modified at runtime using the **CONFIG SET** command).
+
+* When appendfsync is set to the value of **no** Redis performs no fsync.
+In this configuration the only source of latency can be write(2).
+When this happens usually there is no solution since simply the disk can't
+cope with the speed at which Redis is receiving data, however this is
+uncommon if the disk is not seriously slowed down by other processes doing
+I/O.
+
+* When appendfsync is set to the value of **everysec** Redis performs a
+fsync every second. It uses a different thread, and if the fsync is still
+in progress Redis uses a buffer to delay the write(2) call up to two seconds
+(since write would block on Linux if a fsync is in progress against the
+same file). However if the fsync is taking too long Redis will eventually
+perform the write(2) call even if the fsync is still in progress, and this
+can be a source of latency.
+
+* When appendfsync is set to the value of **always** a fsync is performed
+at every write operation before replying back to the client with an OK code
+(actually Redis will try to cluster many commands executed at the same time
+into a single fsync). In this mode performances are very low in general and
+it is strongly recommended to use a fast disk and a file system implementation
+that can perform the fsync in short time.
+
+Most Redis users will use either the **no** or **everysec** setting for the
+appendfsync configuration directive. The suggestion for minimum latency is
+to avoid other processes doing I/O in the same system.
+Using an SSD disk can help as well, but usually even non SSD disks perform
+well with the append only file if the disk is spare as Redis writes
+to the append only file without performing any seek.
+
+If you want to investigate your latency issues related to the append only
+file you can use the strace command under Linux:
+
+    sudo strace -p $(pidof redis-server) -T -e trace=fdatasync
+
+The above command will show all the fdatasync(2) system calls performed by
+Redis in the main thread. With the above command you'll not see the
+fdatasync system calls performed by the background thread when the
+appendfsync config option is set to **everysec**. In order to do so
+just add the -f switch to strace.
+
+If you wish you can also see both fdatasync and write system calls with the
+following command:
+
+    sudo strace -p $(pidof redis-server) -T -e trace=fdatasync,write
+
+However since write(2) is also used in order to write data to the client
+sockets this will likely show too many things unrelated to disk I/O.
+Apparently there is no way to tell strace to just show slow system calls so
+I use the following command:
+
+    sudo strace -f -p $(pidof redis-server) -T -e trace=fdatasync,write 2>&1 | grep -v '0.0' | grep -v unfinished
+
+Latency generated by expires
+----------------------------
+
+Redis evict expired keys in two ways:
+
++ One *lazy* way expires a key when it is requested by a command, but it is found to be already expired.
++ One *active* way expires a few keys every 100 milliseconds.
+
+The active expiring is designed to be adaptive. An expire cycle is started every 100 milliseconds (10 times per second), and will do the following:
+
++ Sample `ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP` keys, evicting all the keys already expired.
++ If the more than 25% of the keys were found expired, repeat.
+
+Given that `ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP` is set to 20 by default, and the process is performed ten times per second, usually just 200 keys per second are actively expired. This is enough to clean the DB fast enough even when already expired keys are not accessed for a long time, so that the *lazy* algorithm does not help. At the same time expiring just 200 keys per second has no effects in the latency a Redis instance.
+
+However the algorithm is adaptive and will loop if it finds more than 25% of keys already expired in the set of sampled keys. But given that we run the algorithm ten times per second, this means that the unlucky event of more than 25% of the keys in our random sample are expiring at least *in the same second*.
+
+Basically this means that **if the database has many, many keys expiring in the same second, and these make up at least 25% of the current population of keys with an expire set**, Redis can block in order to get the percentage of keys already expired below 25%.
+
+This approach is needed in order to avoid using too much memory for keys that are already expired, and usually is absolutely harmless since it's strange that a big number of keys are going to expire in the same exact second, but it is not impossible that the user used [`EXPIREAT`](/commands/expireat) extensively with the same Unix time.
+
+In short: be aware that many keys expiring at the same moment can be a source of latency.
+
+Redis software watchdog
+---
+
+Redis 2.6 introduces the *Redis Software Watchdog* that is a debugging tool
+designed to track those latency problems that for one reason or the other
+escaped an analysis using normal tools.
+
+The software watchdog is an experimental feature. While it is designed to
+be used in production environments care should be taken to backup the database
+before proceeding as it could possibly have unexpected interactions with the
+normal execution of the Redis server.
+
+It is important to use it only as *last resort* when there is no way to track the issue by other means.
+
+This is how this feature works:
+
+* The user enables the software watchdog using the [`CONFIG SET`](/commands/config-set) command.
+* Redis starts monitoring itself constantly.
+* If Redis detects that the server is blocked into some operation that is not returning fast enough, and that may be the source of the latency issue, a low level report about where the server is blocked is dumped on the log file.
+* The user contacts the developers writing a message in the Redis Google Group, including the watchdog report in the message.
+
+Note that this feature cannot be enabled using the redis.conf file, because it is designed to be enabled only in already running instances and only for debugging purposes.
+
+To enable the feature just use the following:
+
+    CONFIG SET watchdog-period 500
+
+The period is specified in milliseconds. In the above example I specified to log latency issues only if the server detects a delay of 500 milliseconds or greater. The minimum configurable period is 200 milliseconds.
+
+When you are done with the software watchdog you can turn it off setting the `watchdog-period` parameter to 0. **Important:** remember to do this because keeping the instance with the watchdog turned on for a longer time than needed is generally not a good idea.
+
+The following is an example of what you'll see printed in the log file once the software watchdog detects a delay longer than the configured one:
+
+    [8547 | signal handler] (1333114359)
+    --- WATCHDOG TIMER EXPIRED ---
+    /lib/libc.so.6(nanosleep+0x2d) [0x7f16b5c2d39d]
+    /lib/libpthread.so.0(+0xf8f0) [0x7f16b5f158f0]
+    /lib/libc.so.6(nanosleep+0x2d) [0x7f16b5c2d39d]
+    /lib/libc.so.6(usleep+0x34) [0x7f16b5c62844]
+    ./redis-server(debugCommand+0x3e1) [0x43ab41]
+    ./redis-server(call+0x5d) [0x415a9d]
+    ./redis-server(processCommand+0x375) [0x415fc5]
+    ./redis-server(processInputBuffer+0x4f) [0x4203cf]
+    ./redis-server(readQueryFromClient+0xa0) [0x4204e0]
+    ./redis-server(aeProcessEvents+0x128) [0x411b48]
+    ./redis-server(aeMain+0x2b) [0x411dbb]
+    ./redis-server(main+0x2b6) [0x418556]
+    /lib/libc.so.6(__libc_start_main+0xfd) [0x7f16b5ba1c4d]
+    ./redis-server() [0x411099]
+    ------
+
+Note: in the example the **DEBUG SLEEP** command was used in order to block the server. The stack trace is different if the server blocks in a different context.
+
+If you happen to collect multiple watchdog stack traces you are encouraged to send everything to the Redis Google Group: the more traces we obtain, the simpler it will be to understand what the problem with your instance is.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Strategies for optimizing memory usage in Redis
+linkTitle: Memory optimization
+title: Memory optimization
+weight: 1
+---
+
+## 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).
+
+This is completely transparent from the point of view of the user and API.
+Since this is a CPU / memory tradeoff it is possible to tune the maximum 
+number of elements and maximum element size for special encoded types 
+using the following redis.conf directives (defaults are shown):
+
+### Redis <= 6.2
+
+```
+hash-max-ziplist-entries 512
+hash-max-ziplist-value 64
+zset-max-ziplist-entries 128 
+zset-max-ziplist-value 64
+set-max-intset-entries 512
+```
+
+### Redis >= 7.0
+
+```
+hash-max-listpack-entries 512
+hash-max-listpack-value 64
+zset-max-listpack-entries 128
+zset-max-listpack-value 64
+set-max-intset-entries 512
+```
+
+### Redis >= 7.2
+
+The following directives are also available:
+
+```
+set-max-listpack-entries 128
+set-max-listpack-value 64
+```
+
+If a specially encoded value overflows the configured max size,
+Redis will automatically convert it into normal encoding.
+This operation is very fast for small values,
+but if you change the setting in order to use specially encoded values
+for much larger aggregate types the suggestion is to run some 
+benchmarks and tests to check the conversion time.
+
+## Using 32-bit instances
+
+
+When Redis is compiled as a 32-bit target, it uses a lot less memory per key, since pointers are small,
+but such an instance will be limited to 4 GB of maximum memory usage.
+To compile Redis as 32-bit binary use *make 32bit*.
+RDB and AOF files are compatible between 32-bit and 64-bit instances
+(and between little and big endian of course) so you can switch from 32 to 64-bit, or the contrary, without problems.
+
+## Bit and byte level operations
+
+Redis 2.2 introduced new bit and byte level operations: [`GETRANGE`](/commands/getrange), [`SETRANGE`](/commands/setrange), [`GETBIT`](/commands/getbit) and [`SETBIT`](/commands/setbit).
+Using these commands you can treat the Redis string type as a random access array.
+For instance, if you have an application where users are identified by a unique progressive integer number,
+you can use a bitmap to save information about the subscription of users in a mailing list,
+setting the bit for subscribed and clearing it for unsubscribed, or the other way around.
+With 100 million users this data will take just 12 megabytes of RAM in a Redis instance.
+You can do the same using [`GETRANGE`](/commands/getrange) and [`SETRANGE`](/commands/setrange) to store one byte of information for each user.
+This is just an example but it is possible to model several problems in very little space with these new primitives.
+
+## Use hashes when possible
+
+
+Small hashes are encoded in a very small space, so you should try representing your data using hashes whenever possible.
+For instance, if you have objects representing users in a web application, 
+instead of using different keys for name, surname, email, password, use a single hash with all the required fields.
+
+If you want to know more about this, read the next section.
+
+## Using hashes to abstract a very memory-efficient plain key-value store on top of Redis
+
+I understand the title of this section is a bit scary, but I'm going to explain in detail what this is about.
+
+Basically it is possible to model a plain key-value store using Redis
+where values can just be just strings, which is not just more memory efficient
+than Redis plain keys but also much more memory efficient than memcached.
+
+Let's start with some facts: a few keys use a lot more memory than a single key
+containing a hash with a few fields. How is this possible? We use a trick.
+In theory to guarantee that we perform lookups in constant time
+(also known as O(1) in big O notation) there is the need to use a data structure
+with a constant time complexity in the average case, like a hash table.
+
+But many times hashes contain just a few fields. When hashes are small we can
+instead just encode them in an O(N) data structure, like a linear
+array with length-prefixed key-value pairs. Since we do this only when N
+is small, the amortized time for [`HGET`](/commands/hget) and [`HSET`](/commands/hset) commands is still O(1): the
+hash will be converted into a real hash table as soon as the number of elements
+it contains grows too large (you can configure the limit in redis.conf).
+
+This does not only work well from the point of view of time complexity, but
+also from the point of view of constant times since a linear array of key-value pairs happens to play very well with the CPU cache (it has a better
+cache locality than a hash table).
+
+However since hash fields and values are not (always) represented as full-featured Redis objects, hash fields can't have an associated time to live
+(expire) like a real key, and can only contain a string. But we are okay with
+this, this was the intention anyway when the hash data type API was
+designed (we trust simplicity more than features, so nested data structures
+are not allowed, as expires of single fields are not allowed).
+
+So hashes are memory efficient. This is useful when using hashes
+to represent objects or to model other problems when there are group of
+related fields. But what about if we have a plain key value business?
+
+Imagine we want to use Redis as a cache for many small objects, which can be JSON encoded objects, small HTML fragments, simple key -> boolean values
+and so forth. Basically, anything is a string -> string map with small keys
+and values.
+
+Now let's assume the objects we want to cache are numbered, like:
+
+ * object:102393
+ * object:1234
+ * object:5
+
+This is what we can do. Every time we perform a
+SET operation to set a new value, we actually split the key into two parts,
+one part used as a key, and the other part used as the field name for the hash. For instance, the
+object named "object:1234" is actually split into:
+
+* a Key named object:12
+* a Field named 34
+
+So we use all the characters but the last two for the key, and the final
+two characters for the hash field name. To set our key we use the following
+command:
+
+```
+HSET object:12 34 somevalue
+```
+
+As you can see every hash will end up containing 100 fields, which is an optimal compromise between CPU and memory saved.
+
+There is another important thing to note, with this schema
+every hash will have more or
+less 100 fields regardless of the number of objects we cached. This is because our objects will always end with a number and not a random string. In some way, the final number can be considered as a form of implicit pre-sharding.
+
+What about small numbers? Like object:2? We handle this case using just
+"object:" as a key name, and the whole number as the hash field name.
+So object:2 and object:10 will both end inside the key "object:", but one
+as field name "2" and one as "10".
+
+How much memory do we save this way?
+
+I used the following Ruby program to test how this works:
+
+```ruby
+require 'rubygems'
+require 'redis'
+
+USE_OPTIMIZATION = true
+
+def hash_get_key_field(key)
+  s = key.split(':')
+  if s[1].length > 2
+    { key: s[0] + ':' + s[1][0..-3], field: s[1][-2..-1] }
+  else
+    { key: s[0] + ':', field: s[1] }
+  end
+end
+
+def hash_set(r, key, value)
+  kf = hash_get_key_field(key)
+  r.hset(kf[:key], kf[:field], value)
+end
+
+def hash_get(r, key, value)
+  kf = hash_get_key_field(key)
+  r.hget(kf[:key], kf[:field], value)
+end
+
+r = Redis.new
+(0..100_000).each do |id|
+  key = "object:#{id}"
+  if USE_OPTIMIZATION
+    hash_set(r, key, 'val')
+  else
+    r.set(key, 'val')
+  end
+end
+```
+
+This is the result against a 64 bit instance of Redis 2.2:
+
+ * USE_OPTIMIZATION set to true: 1.7 MB of used memory
+ * USE_OPTIMIZATION set to false; 11 MB of used memory
+
+This is an order of magnitude, I think this makes Redis more or less the most
+memory efficient plain key value store out there.
+
+*WARNING*: for this to work, make sure that in your redis.conf you have
+something like this:
+
+```
+hash-max-zipmap-entries 256
+```
+
+Also remember to set the following field accordingly to the maximum size
+of your keys and values:
+
+```
+hash-max-zipmap-value 1024
+```
+
+Every time a hash exceeds the number of elements or element size specified
+it will be converted into a real hash table, and the memory saving will be lost.
+
+You may ask, why don't you do this implicitly in the normal key space so that
+I don't have to care? There are two reasons: one is that we tend to make
+tradeoffs explicit, and this is a clear tradeoff between many things: CPU,
+memory, and max element size. The second is that the top-level key space must
+support a lot of interesting things like expires, LRU data, and so
+forth so it is not practical to do this in a general way.
+
+But the Redis Way is that the user must understand how things work so that he can pick the best compromise and to understand how the system will
+behave exactly.
+
+## Memory allocation
+
+To store user keys, Redis allocates at most as much memory as the `maxmemory`
+setting enables (however there are small extra allocations possible).
+
+The exact value can be set in the configuration file or set later via
+[`CONFIG SET`](/commands/config-set) (for more info, see [Using memory as an LRU cache]({{< relref "/develop/reference/eviction" >}})).
+There are a few things that should be noted about how Redis manages memory:
+
+* Redis will not always free up (return) memory to the OS when keys are removed.
+This is not something special about Redis, but it is how most malloc() implementations work.
+For example, if you fill an instance with 5GB worth of data, and then
+remove the equivalent of 2GB of data, the Resident Set Size (also known as
+the RSS, which is the number of memory pages consumed by the process)
+will probably still be around 5GB, even if Redis will claim that the user
+memory is around 3GB.  This happens because the underlying allocator can't easily release the memory.
+For example, often most of the removed keys were allocated on the same pages as the other keys that still exist.
+* The previous point means that you need to provision memory based on your
+**peak memory usage**. If your workload from time to time requires 10GB, even if
+most of the time 5GB could do, you need to provision for 10GB.
+* However allocators are smart and are able to reuse free chunks of memory,
+so after you free 2GB of your 5GB data set, when you start adding more keys
+again, you'll see the RSS (Resident Set Size) stay steady and not grow
+more, as you add up to 2GB of additional keys. The allocator is basically
+trying to reuse the 2GB of memory previously (logically) freed.
+* Because of all this, the fragmentation ratio is not reliable when you
+had a memory usage that at the peak is much larger than the currently used memory.
+The fragmentation is calculated as the physical memory actually used (the RSS
+value) divided by the amount of memory currently in use (as the sum of all
+the allocations performed by Redis). Because the RSS reflects the peak memory,
+when the (virtually) used memory is low since a lot of keys/values were freed, but the RSS is high, the ratio `RSS / mem_used` will be very high.
+
+If `maxmemory` is not set Redis will keep allocating memory as it sees
+fit and thus it can (gradually) eat up all your free memory.
+Therefore it is generally advisable to configure some limits. You may also
+want to set `maxmemory-policy` to `noeviction` (which is *not* the default
+value in some older versions of Redis).
+
+It makes Redis return an out-of-memory error for write commands if and when it reaches the 
+limit - which in turn may result in errors in the application but will not render the 
+whole machine dead because of memory starvation.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Use the redis-benchmark utility on a Redis server
+linkTitle: Benchmarking
+title: Redis benchmark
+weight: 1
+---
+## 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.
+
+The following options are supported:
+
+    Usage: redis-benchmark [-h <host>] [-p <port>] [-c <clients>] [-n <requests]> [-k <boolean>]
+
+     -h <hostname>      Server hostname (default 127.0.0.1)
+     -p <port>          Server port (default 6379)
+     -s <socket>        Server socket (overrides host and port)
+     -a <password>      Password for Redis Auth
+     --user <username>  Used to send ACL style 'AUTH username pass'. Needs -a.
+     -c <clients>       Number of parallel connections (default 50)
+     -n <requests>      Total number of requests (default 100000)
+     -d <size>          Data size of SET/GET value in bytes (default 3)
+     --dbnum <db>       SELECT the specified db number (default 0)
+     --threads <num>    Enable multi-thread mode.
+     --cluster          Enable cluster mode.
+     --enable-tracking  Send CLIENT TRACKING on before starting benchmark.
+     -k <boolean>       1=keep alive 0=reconnect (default 1)
+     -r <keyspacelen>   Use random keys for SET/GET/INCR, random values for
+                        SADD, random members and scores for ZADD.
+                        Using this option the benchmark will expand the string
+                        __rand_int__ inside an argument with a 12 digits number
+                        in the specified range from 0 to keyspacelen-1. The
+                        substitution changes every time a command is executed.
+                        Default tests use this to hit random keys in the
+                        specified range.
+     -P <numreq>        Pipeline <numreq> requests. Default 1 (no pipeline).
+     -e                 If server replies with errors, show them on stdout.
+                        (No more than 1 error per second is displayed.)
+     -q                 Quiet. Just show query/sec values
+     --precision        Number of decimal places to display in latency output (default 0)
+     --csv              Output in CSV format
+     -l                 Loop. Run the tests forever
+     -t <tests>         Only run the comma separated list of tests. The test
+                        names are the same as the ones produced as output.
+     -I                 Idle mode. Just open N idle connections and wait.
+     --help             Output this help and exit.
+     --version          Output version and exit.
+
+You need to have a running Redis instance before launching the benchmark.
+A typical example would be:
+
+    redis-benchmark -q -n 100000
+
+Using this tool is quite easy, and you can also write your own benchmark,
+but as with any benchmarking activity, there are some pitfalls to avoid.
+
+Running only a subset of the tests
+---
+
+You don't need to run all the default tests every time you execute redis-benchmark.
+The simplest thing to select only a subset of tests is to use the `-t` option
+like in the following example:
+
+    $ redis-benchmark -t set,lpush -n 100000 -q
+    SET: 180180.17 requests per second, p50=0.143 msec                    
+    LPUSH: 188323.91 requests per second, p50=0.135 msec
+
+In the above example we asked to just run test the SET and LPUSH commands,
+in quiet mode (see the `-q` switch).
+
+It is also possible to specify the command to benchmark directly like in the
+following example:
+
+    $ redis-benchmark -n 100000 -q script load "redis.call('set','foo','bar')"
+    script load redis.call('set','foo','bar'): 69881.20 requests per second
+
+Selecting the size of the key space
+---
+
+By default the benchmark runs against a single key. In Redis the difference
+between such a synthetic benchmark and a real one is not huge since it is an
+in-memory system, however it is possible to stress cache misses and in general
+to simulate a more real-world work load by using a large key space.
+
+This is obtained by using the `-r` switch. For instance if I want to run
+one million SET operations, using a random key for every operation out of
+100k possible keys, I'll use the following command line:
+
+    $ redis-cli flushall
+    OK
+
+    $ redis-benchmark -t set -r 100000 -n 1000000
+    ====== SET ======
+      1000000 requests completed in 13.86 seconds
+      50 parallel clients
+      3 bytes payload
+      keep alive: 1
+
+    99.76% `<=` 1 milliseconds
+    99.98% `<=` 2 milliseconds
+    100.00% `<=` 3 milliseconds
+    100.00% `<=` 3 milliseconds
+    72144.87 requests per second
+
+    $ redis-cli dbsize
+    (integer) 99993
+
+Using pipelining
+---
+
+By default every client (the benchmark simulates 50 clients if not otherwise
+specified with `-c`) sends the next command only when the reply of the previous
+command is received, this means that the server will likely need a read call
+in order to read each command from every client. Also RTT is paid as well.
+
+Redis supports [pipelining](/topics/pipelining), so it is possible to send
+multiple commands at once, a feature often exploited by real world applications.
+Redis pipelining is able to dramatically improve the number of operations per
+second a server is able to deliver.
+
+This is an example of running the benchmark in a MacBook Air 11" using a
+pipelining of 16 commands:
+
+    $ redis-benchmark -n 1000000 -t set,get -P 16 -q
+    SET: 1536098.25 requests per second, p50=0.479 msec                     
+    GET: 1811594.25 requests per second, p50=0.391 msec
+
+Using pipelining results in a significant increase in performance.
+
+Pitfalls and misconceptions
+---------------------------
+
+The first point is obvious: the golden rule of a useful benchmark is to
+only compare apples and apples. Different versions of Redis can be compared
+on the same workload for instance. Or the same version of Redis, but with
+different options. If you plan to compare Redis to something else, then it is
+important to evaluate the functional and technical differences, and take them
+in account.
+
++ Redis is a server, hence, all commands involve network round trips. Embedded data stores do not involve network and protocol management. When comparing such products to Redis, command execution times should be used instead of end-to-end times.
++ Redis commands return an acknowledgment for all usual commands. Some other data stores do not. Comparing Redis to stores involving one-way queries is only mildly useful.
++ Naively iterating on synchronous Redis commands does not benchmark Redis itself, but rather measure your network (or IPC) latency and the client library intrinsic latency. To really test Redis, you need multiple connections (like redis-benchmark) and/or to use pipelining to aggregate several commands and/or multiple threads or processes.
++ Redis is an in-memory data store with some optional persistence options. If you plan to compare it to transactional servers (MySQL, PostgreSQL, etc ...), then you should consider activating AOF and decide on a suitable fsync policy.
++ Redis is, mostly, a single-threaded server from the POV of commands execution (actually modern versions of Redis use threads for different things). It is not designed to benefit from multiple CPU cores. People are supposed to launch several Redis instances to scale out on several cores if needed. It is not really fair to compare one single Redis instance to a multi-threaded data store.
+
+A common misconception is that redis-benchmark is designed to make Redis
+performances look stellar, the throughput achieved by redis-benchmark being
+somewhat artificial, and not achievable by a real application. This is
+actually not true.
+
+The `redis-benchmark` program is a quick and useful way to get some figures and
+evaluate the performance of a Redis instance on a given hardware. However,
+by default, it does not represent the maximum throughput a Redis instance can
+sustain. Actually, by using pipelining and a fast client (hiredis), it is fairly
+easy to write a program generating more throughput than redis-benchmark. The
+default behavior of redis-benchmark is to achieve throughput by exploiting
+concurrency only (i.e. it creates several connections to the server).
+It does not use pipelining or any parallelism at all (one pending query per
+connection at most, and no multi-threading), if not explicitly enabled via
+the `-P` parameter. So in some way using `redis-benchmark` and, triggering, for
+example, a `BGSAVE` operation in the background at the same time, will provide
+the user with numbers more near to the *worst case* than to the best case.
+
+To run a benchmark using pipelining mode (and achieve higher throughput),
+you need to explicitly use the -P option. Please note that it is still a
+realistic behavior since a lot of Redis based applications actively use
+pipelining to improve performance. However you should use a pipeline size that
+is more or less the average pipeline length you'll be able to use in your
+application in order to get realistic numbers.
+
+Finally, the benchmark should apply the same operations, and work in the same way
+with the multiple data stores you want to compare. It is absolutely pointless to
+compare the result of redis-benchmark to the result of another benchmark
+program and extrapolate.
+
+For instance, Redis and memcached in single-threaded mode can be compared on
+GET/SET operations. Both are in-memory data stores, working mostly in the same
+way at the protocol level. Provided their respective benchmark application is
+aggregating queries in the same way (pipelining) and use a similar number of
+connections, the comparison is actually meaningful.
+
+This perfect example is illustrated by the dialog between Redis (antirez) and
+memcached (dormando) developers.
+
+[antirez 1 - On Redis, Memcached, Speed, Benchmarks and The Toilet](http://antirez.com/post/redis-memcached-benchmark.html)
+
+[dormando - Redis VS Memcached (slightly better bench)](http://dormando.livejournal.com/525147.html)
+
+[antirez 2 - An update on the Memcached/Redis benchmark](http://antirez.com/post/update-on-memcached-redis-benchmark.html)
+
+You can see that in the end, the difference between the two solutions is not
+so staggering, once all technical aspects are considered. Please note both
+Redis and memcached have been optimized further after these benchmarks.
+
+Finally, when very efficient servers are benchmarked (and stores like Redis
+or memcached definitely fall in this category), it may be difficult to saturate
+the server. Sometimes, the performance bottleneck is on client side,
+and not server-side. In that case, the client (i.e. the benchmark program itself)
+must be fixed, or perhaps scaled out, in order to reach the maximum throughput.
+
+Factors impacting Redis performance
+-----------------------------------
+
+There are multiple factors having direct consequences on Redis performance.
+We mention them here, since they can alter the result of any benchmarks.
+Please note however, that a typical Redis instance running on a low end,
+untuned box usually provides good enough performance for most applications.
+
++ Network bandwidth and latency usually have a direct impact on the performance.
+It is a good practice to use the ping program to quickly check the latency
+between the client and server hosts is normal before launching the benchmark.
+Regarding the bandwidth, it is generally useful to estimate
+the throughput in Gbit/s and compare it to the theoretical bandwidth
+of the network. For instance a benchmark setting 4 KB strings
+in Redis at 100000 q/s, would actually consume 3.2 Gbit/s of bandwidth
+and probably fit within a 10 Gbit/s link, but not a 1 Gbit/s one. In many real
+world scenarios, Redis throughput is limited by the network well before being
+limited by the CPU. To consolidate several high-throughput Redis instances
+on a single server, it worth considering putting a 10 Gbit/s NIC
+or multiple 1 Gbit/s NICs with TCP/IP bonding.
++ CPU is another very important factor. Being single-threaded, Redis favors
+fast CPUs with large caches and not many cores. At this game, Intel CPUs are
+currently the winners. It is not uncommon to get only half the performance on
+an AMD Opteron CPU compared to similar Nehalem EP/Westmere EP/Sandy Bridge
+Intel CPUs with Redis. When client and server run on the same box, the CPU is
+the limiting factor with redis-benchmark.
++ Speed of RAM and memory bandwidth seem less critical for global performance
+especially for small objects. For large objects (>10 KB), it may become
+noticeable though. Usually, it is not really cost-effective to buy expensive
+fast memory modules to optimize Redis.
++ Redis runs slower on a VM compared to running without virtualization using
+the same hardware. If you have the chance to run Redis on a physical machine
+this is preferred. However this does not mean that Redis is slow in
+virtualized environments, the delivered performances are still very good
+and most of the serious performance issues you may incur in virtualized
+environments are due to over-provisioning, non-local disks with high latency,
+or old hypervisor software that have slow `fork` syscall implementation.
++ When the server and client benchmark programs run on the same box, both
+the TCP/IP loopback and unix domain sockets can be used. Depending on the
+platform, unix domain sockets can achieve around 50% more throughput than
+the TCP/IP loopback (on Linux for instance). The default behavior of
+redis-benchmark is to use the TCP/IP loopback.
++ The performance benefit of unix domain sockets compared to TCP/IP loopback
+tends to decrease when pipelining is heavily used (i.e. long pipelines).
++ When an ethernet network is used to access Redis, aggregating commands using
+pipelining is especially efficient when the size of the data is kept under
+the ethernet packet size (about 1500 bytes). Actually, processing 10 bytes,
+100 bytes, or 1000 bytes queries almost result in the same throughput.
+See the graph below.
+
+![Data size impact](https://github.com/dspezia/redis-doc/raw/client_command/topics/Data_size.png)
+
++ On multi CPU sockets servers, Redis performance becomes dependent on the
+NUMA configuration and process location. The most visible effect is that
+redis-benchmark results seem non-deterministic because client and server
+processes are distributed randomly on the cores. To get deterministic results,
+it is required to use process placement tools (on Linux: taskset or numactl).
+The most efficient combination is always to put the client and server on two
+different cores of the same CPU to benefit from the L3 cache.
+Here are some results of 4 KB SET benchmark for 3 server CPUs (AMD Istanbul,
+Intel Nehalem EX, and Intel Westmere) with different relative placements.
+Please note this benchmark is not meant to compare CPU models between themselves
+(CPUs exact model and frequency are therefore not disclosed).
+
+![NUMA chart](https://github.com/dspezia/redis-doc/raw/6374a07f93e867353e5e946c1e39a573dfc83f6c/topics/NUMA_chart.gif)
+
++ With high-end configurations, the number of client connections is also an
+important factor. Being based on epoll/kqueue, the Redis event loop is quite
+scalable. Redis has already been benchmarked at more than 60000 connections,
+and was still able to sustain 50000 q/s in these conditions. As a rule of thumb,
+an instance with 30000 connections can only process half the throughput
+achievable with 100 connections. Here is an example showing the throughput of
+a Redis instance per number of connections:
+
+![connections chart](https://github.com/dspezia/redis-doc/raw/system_info/topics/Connections_chart.png)
+
++ With high-end configurations, it is possible to achieve higher throughput by
+tuning the NIC(s) configuration and associated interruptions. Best throughput
+is achieved by setting an affinity between Rx/Tx NIC queues and CPU cores,
+and activating RPS (Receive Packet Steering) support. More information in this
+[thread](https://groups.google.com/forum/#!msg/redis-db/gUhc19gnYgc/BruTPCOroiMJ).
+Jumbo frames may also provide a performance boost when large objects are used.
++ Depending on the platform, Redis can be compiled against different memory
+allocators (libc malloc, jemalloc, tcmalloc), which may have different behaviors
+in term of raw speed, internal and external fragmentation.
+If you did not compile Redis yourself, you can use the INFO command to check
+the `mem_allocator` field. Please note most benchmarks do not run long enough to
+generate significant external fragmentation (contrary to production Redis
+instances).
+
+Other things to consider
+------------------------
+
+One important goal of any benchmark is to get reproducible results, so they
+can be compared to the results of other tests.
+
++ A good practice is to try to run tests on isolated hardware as much as possible.
+If it is not possible, then the system must be monitored to check the benchmark
+is not impacted by some external activity.
++ Some configurations (desktops and laptops for sure, some servers as well)
+have a variable CPU core frequency mechanism. The policy controlling this
+mechanism can be set at the OS level. Some CPU models are more aggressive than
+others at adapting the frequency of the CPU cores to the workload. To get
+reproducible results, it is better to set the highest possible fixed frequency
+for all the CPU cores involved in the benchmark.
++ An important point is to size the system accordingly to the benchmark.
+The system must have enough RAM and must not swap. On Linux, do not forget
+to set the `overcommit_memory` parameter correctly. Please note 32 and 64 bit
+Redis instances do not have the same memory footprint.
++ If you plan to use RDB or AOF for your benchmark, please check there is no other
+I/O activity in the system. Avoid putting RDB or AOF files on NAS or NFS shares,
+or on any other devices impacting your network bandwidth and/or latency
+(for instance, EBS on Amazon EC2).
++ Set Redis logging level (loglevel parameter) to warning or notice. Avoid putting
+the generated log file on a remote filesystem.
++ Avoid using monitoring tools which can alter the result of the benchmark. For
+instance using INFO at regular interval to gather statistics is probably fine,
+but MONITOR will impact the measured performance significantly.
+
+## Benchmark results on bare-metal servers across different Redis versions
+
+It is critically important that Redis performance is retained or improved seamlessly on every released version. 
+
+To assess it, we've conducted benchmarks on the released versions of Redis (starting on v2.6.0) using `redis-benchmark` on a series of command types over a standalone redis-server, repeating the same benchmark multiple times, ensuring its statistical significance, and measuring the run-to-run variance.
+
+The used hardware platform was a stable bare-metal HPE ProLiant DL380 Gen10 Server, with one Intel(R) Xeon(R) Gold 6230 CPU @ 2.10GHz, disabling Intel HT Technology, disabling CPU Frequency scaling, with all configurable BIOS and CPU system settings set to performance. 
+
+The box was running Ubuntu 18.04 Linux release 4.15.0-123, and Redis was compiled with gcc 7.5.0.
+The used benchmark client (`redis-benchmark`) was kept stable across all tests, with version `redis-benchmark 6.2.0 (git:445aa844)`.
+Both the redis-server and redis-benchmark processes were pinned to specific physical cores.
+
+The following benchmark options were used across tests:
+
+
+* The tests were done with 50 simultaneous clients performing 5 million requests.
+* Tests were executed using the loopback interface.
+* Tests were executed without pipelining.
+* The used payload size was 256 Bytes.
+* For each redis-benchmark process, 2 threads were used to ensure that the benchmark client was not the bottleneck.
+* Strings, Hashes, Sets, and Sorted Sets data types were benchmarked.
+
+Below we present the obtained results, broken by data type.
+
+
+![Strings performance over versions](./performance-strings.png)
+
+![Hashes performance over versions](./performance-hashes.png)
+
+![Sets performance over versions](./performance-sets.png)
+
+![Sorted sets performance over versions](./performance-sorted-sets.png)
+## Other Redis benchmarking tools
+
+There are several third-party tools that can be used for benchmarking Redis. Refer to each tool's
+documentation for more information about its goals and capabilities.
+
+* [memtier_benchmark](https://github.com/redislabs/memtier_benchmark) from [Redis Labs](https://twitter.com/RedisLabs) is a NoSQL Redis and Memcache traffic generation and benchmarking tool.
+* [rpc-perf](https://github.com/twitter/rpc-perf) from [Twitter](https://twitter.com/twitter) is a tool for benchmarking RPC services that supports Redis and Memcache.
+* [YCSB](https://github.com/brianfrankcooper/YCSB) from [Yahoo @Yahoo](https://twitter.com/Yahoo) is a benchmarking framework with clients to many databases, including Redis.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Benchmarking, profiling, and optimizations for memory and latency
+linkTitle: Optimization
+title: Optimizing Redis
+weight: 8
+---
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Overview of redis.conf, the Redis configuration file
+linkTitle: Configuration
+title: Redis configuration
+weight: 2
+---
+
+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`.
+
+{{< note >}}
+For Redis 8 in Redis Open Source, the configuration file is called `redis-full.conf`.
+{{< /note >}}
+
+The configuration file contains a number of directives that have a very simple
+format:
+
+    keyword argument1 argument2 ... argumentN
+
+This is an example of a configuration directive:
+
+    replicaof 127.0.0.1 6380
+
+It is possible to provide strings containing spaces as arguments using
+(double or single) quotes, as in the following example:
+
+    requirepass "hello world"
+
+Single-quoted string can contain characters escaped by backslashes, and
+double-quoted strings can additionally include any ASCII symbols encoded using
+backslashed hexadecimal notation "\\xff".
+
+The list of configuration directives, and their meaning and intended usage
+is available in the self-documented example `redis.conf` or `redis-full.conf` shipped into the
+Redis distribution.
+
+* The self-documented [redis-full.conf for Redis 8.0](https://raw.githubusercontent.com/redis/redis/8.0/redis-full.conf).
+* The self-documented [redis.conf for Redis 7.4](https://raw.githubusercontent.com/redis/redis/7.4/redis.conf).
+* The self-documented [redis.conf for Redis 7.2](https://raw.githubusercontent.com/redis/redis/7.2/redis.conf).
+* The self-documented [redis.conf for Redis 7.0](https://raw.githubusercontent.com/redis/redis/7.0/redis.conf).
+* The self-documented [redis.conf for Redis 6.2](https://raw.githubusercontent.com/redis/redis/6.2/redis.conf).
+* The self-documented [redis.conf for Redis 6.0](https://raw.githubusercontent.com/redis/redis/6.0/redis.conf).
+* The self-documented [redis.conf for Redis 5.0](https://raw.githubusercontent.com/redis/redis/5.0/redis.conf).
+* The self-documented [redis.conf for Redis 4.0](https://raw.githubusercontent.com/redis/redis/4.0/redis.conf).
+* The self-documented [redis.conf for Redis 3.2](https://raw.githubusercontent.com/redis/redis/3.2/redis.conf).
+* The self-documented [redis.conf for Redis 3.0](https://raw.githubusercontent.com/redis/redis/3.0/redis.conf).
+* The self-documented [redis.conf for Redis 2.8](https://raw.githubusercontent.com/redis/redis/2.8/redis.conf).
+* The self-documented [redis.conf for Redis 2.6](https://raw.githubusercontent.com/redis/redis/2.6/redis.conf).
+* The self-documented [redis.conf for Redis 2.4](https://raw.githubusercontent.com/redis/redis/2.4/redis.conf).
+
+Passing arguments using the command line
+---
+
+You can also pass Redis configuration parameters
+using the command line directly. This is very useful for testing purposes.
+The following is an example that starts a new Redis instance using port 6380
+as a replica of the instance running at 127.0.0.1 port 6379.
+
+    ./redis-server --port 6380 --replicaof 127.0.0.1 6379
+
+The format of the arguments passed using the command line is exactly the same
+as the one used in the redis.conf file, with the exception that the keyword
+is prefixed with `--`.
+
+Note that internally this generates an in-memory temporary config file
+(possibly concatenating the config file passed by the user, if any) where
+arguments are translated into the format of redis.conf.
+
+Changing Redis configuration while the server is running
+---
+
+It is possible to reconfigure Redis on the fly without stopping and restarting
+the service, or querying the current configuration programmatically using the
+special commands [`CONFIG SET`](/commands/config-set) and [`CONFIG GET`](/commands/config-get).
+
+Not all of the configuration directives are supported in this way, but most
+are supported as expected.
+Please refer to the [`CONFIG SET`](/commands/config-set) and [`CONFIG GET`](/commands/config-get) pages for more information.
+
+Note that modifying the configuration on the fly **has no effects on the
+redis.conf file** so at the next restart of Redis the old configuration will
+be used instead.
+
+Make sure to also modify the `redis.conf` file accordingly to the configuration
+you set using [`CONFIG SET`](/commands/config-set).
+You can do it manually, or you can use [`CONFIG REWRITE`](/commands/config-rewrite), which will automatically scan your `redis.conf` file and update the fields which don't match the current configuration value.
+Fields non existing but set to the default value are not added.
+Comments inside your configuration file are retained.
+
+Configuring Redis as a cache
+---
+
+If you plan to use Redis as a cache where every key will have an
+expire set, you may consider using the following configuration instead
+(assuming a max memory limit of 2 megabytes as an example):
+
+    maxmemory 2mb
+    maxmemory-policy allkeys-lru
+
+In this configuration there is no need for the application to set a
+time to live for keys using the [`EXPIRE`](/commands/expire) command (or equivalent) since
+all the keys will be evicted using an approximated LRU algorithm as long
+as we hit the 2 megabyte memory limit.
+
+Basically, in this configuration Redis acts in a similar way to memcached.
+We have more extensive documentation about using Redis as an LRU cache [here]({{< relref "/develop/reference/eviction" >}}).
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How Redis writes data to disk
+linkTitle: Persistence
+title: Redis persistence
+weight: 7
+---
+
+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]({{< relref "/operate/rs/databases/configure/database-persistence" >}}), which can be pre-configured using a UI.
+
+To learn more about how to evaluate your Redis persistence strategy, read on.
+
+## RDB advantages
+
+* RDB is a very compact single-file point-in-time representation of your Redis data. RDB files are perfect for backups. For instance you may want to archive your RDB files every hour for the latest 24 hours, and to save an RDB snapshot every day for 30 days. This allows you to easily restore different versions of the data set in case of disasters.
+* RDB is very good for disaster recovery, being a single compact file that can be transferred to far data centers, or onto Amazon S3 (possibly encrypted).
+* RDB maximizes Redis performances since the only work the Redis parent process needs to do in order to persist is forking a child that will do all the rest. The parent process will never perform disk I/O or alike.
+* RDB allows faster restarts with big datasets compared to AOF.
+* On replicas, RDB supports [partial resynchronizations after restarts and failovers]({{< relref "/operate/oss_and_stack/management/replication#partial-resynchronizations-after-restarts-and-failovers" >}}).
+
+## RDB disadvantages
+
+* RDB is NOT good if you need to minimize the chance of data loss in case Redis stops working (for example after a power outage). You can configure different *save points* where an RDB is produced (for instance after at least five minutes and 100 writes against the data set, you can have multiple save points). However you'll usually create an RDB snapshot every five minutes or more, so in case of Redis stopping working without a correct shutdown for any reason you should be prepared to lose the latest minutes of data.
+* RDB needs to fork() often in order to persist on disk using a child process. fork() can be time consuming if the dataset is big, and may result in Redis stopping serving clients for some milliseconds or even for one second if the dataset is very big and the CPU performance is not great. AOF also needs to fork() but less frequently and you can tune how often you want to rewrite your logs without any trade-off on durability.
+
+## AOF advantages
+
+* Using AOF Redis is much more durable: you can have different fsync policies: no fsync at all, fsync every second, fsync at every query. With the default policy of fsync every second, write performance is still great. fsync is performed using a background thread and the main thread will try hard to perform writes when no fsync is in progress, so you can only lose one second worth of writes.
+* The AOF log is an append-only log, so there are no seeks, nor corruption problems if there is a power outage. Even if the log ends with a half-written command for some reason (disk full or other reasons) the redis-check-aof tool is able to fix it easily.
+* Redis is able to automatically rewrite the AOF in background when it gets too big. The rewrite is completely safe as while Redis continues appending to the old file, a completely new one is produced with the minimal set of operations needed to create the current data set, and once this second file is ready Redis switches the two and starts appending to the new one.
+* AOF contains a log of all the operations one after the other in an easy to understand and parse format. You can even easily export an AOF file. For instance even if you've accidentally flushed everything using the [`FLUSHALL`](/commands/flushall) command, as long as no rewrite of the log was performed in the meantime, you can still save your data set just by stopping the server, removing the latest command, and restarting Redis again.
+
+## AOF disadvantages
+
+* AOF files are usually bigger than the equivalent RDB files for the same dataset.
+* AOF can be slower than RDB depending on the exact fsync policy. In general with fsync set to *every second* performance is still very high, and with fsync disabled it should be exactly as fast as RDB even under high load. Still RDB is able to provide more guarantees about the maximum latency even in the case of a huge write load.
+
+**Redis < 7.0**
+
+* AOF can use a lot of memory if there are writes to the database during a rewrite (these are buffered in memory and written to the new AOF at the end).
+* All write commands that arrive during rewrite are written to disk twice.
+* Redis could freeze writing and fsyncing these write commands to the new AOF file at the end of the rewrite.
+  
+Ok, so what should I use?
+---
+
+The general indication you should use both persistence methods is if
+you want a degree of data safety comparable to what PostgreSQL can provide you.
+
+If you care a lot about your data, but still can live with a few minutes of
+data loss in case of disasters, you can simply use RDB alone.
+
+There are many users using AOF alone, but we discourage it since to have an
+RDB snapshot from time to time is a great idea for doing database backups,
+for faster restarts, and in the event of bugs in the AOF engine.
+
+The following sections will illustrate a few more details about the two persistence models.
+
+## Snapshotting
+
+By default Redis saves snapshots of the dataset on disk, in a binary
+file called `dump.rdb`. You can configure Redis to have it save the
+dataset every N seconds if there are at least M changes in the dataset,
+or you can manually call the [`SAVE`](/commands/save) or [`BGSAVE`](/commands/bgsave) commands.
+
+For example, this configuration will make Redis automatically dump the
+dataset to disk every 60 seconds if at least 1000 keys changed:
+
+    save 60 1000
+
+This strategy is known as _snapshotting_.
+
+### How it works
+
+Whenever Redis needs to dump the dataset to disk, this is what happens:
+
+* Redis [forks](http://linux.die.net/man/2/fork). We now have a child
+and a parent process.
+
+* The child starts to write the dataset to a temporary RDB file.
+
+* When the child is done writing the new RDB file, it replaces the old
+one.
+
+This method allows Redis to benefit from copy-on-write semantics.
+
+## Append-only file
+
+Snapshotting is not very durable. If your computer running Redis stops,
+your power line fails, or you accidentally `kill -9` your instance, the
+latest data written to Redis will be lost.  While this may not be a big
+deal for some applications, there are use cases for full durability, and
+in these cases Redis snapshotting alone is not a viable option.
+
+The _append-only file_ is an alternative, fully-durable strategy for
+Redis.  It became available in version 1.1.
+
+You can turn on the AOF in your configuration file:
+
+    appendonly yes
+
+From now on, every time Redis receives a command that changes the
+dataset (e.g. [`SET`](/commands/set)) it will append it to the AOF.  When you restart
+Redis it will re-play the AOF to rebuild the state.
+
+Since Redis 7.0.0, Redis uses a multi part AOF mechanism.
+That is, the original single AOF file is split into base file (at most one) and incremental files (there may be more than one).
+The base file represents an initial (RDB or AOF format) snapshot of the data present when the AOF is [rewritten](#log-rewriting).
+The incremental files contains incremental changes since the last base AOF file was created. All these files are put in a separate directory and are tracked by a manifest file.
+
+### Log rewriting
+
+The AOF gets bigger and bigger as write operations are
+performed.  For example, if you are incrementing a counter 100 times,
+you'll end up with a single key in your dataset containing the final
+value, but 100 entries in your AOF. 99 of those entries are not needed
+to rebuild the current state.
+
+The rewrite is completely safe.
+While Redis continues appending to the old file,
+a completely new one is produced with the minimal set of operations needed to create the current data set,
+and once this second file is ready Redis switches the two and starts appending to the new one.
+
+So Redis supports an interesting feature: it is able to rebuild the AOF
+in the background without interrupting service to clients. Whenever
+you issue a [`BGREWRITEAOF`](/commands/bgrewriteaof), Redis will write the shortest sequence of
+commands needed to rebuild the current dataset in memory.  If you're
+using the AOF with Redis 2.2 you'll need to run [`BGREWRITEAOF`](/commands/bgrewriteaof) from time to
+time. Since Redis 2.4 is able to trigger log rewriting automatically (see the
+example configuration file for more information).
+
+Since Redis 7.0.0, when an AOF rewrite is scheduled, the Redis parent process opens a new incremental AOF file to continue writing.
+The child process executes the rewrite logic and generates a new base AOF.
+Redis will use a temporary manifest file to track the newly generated base file and incremental file.
+When they are ready, Redis will perform an atomic replacement operation to make this temporary manifest file take effect.
+In order to avoid the problem of creating many incremental files in case of repeated failures and retries of an AOF rewrite,
+Redis introduces an AOF rewrite limiting mechanism to ensure that failed AOF rewrites are retried at a slower and slower rate.
+
+### How durable is the append only file?
+
+You can configure how many times Redis will
+[`fsync`](http://linux.die.net/man/2/fsync) data on disk. There are
+three options:
+
+* `appendfsync always`: `fsync` every time new commands are appended to the AOF. Very very slow, very safe. Note that the commands are appended to the AOF after a batch of commands from multiple clients or a pipeline are executed, so it means a single write and a single fsync (before sending the replies).
+* `appendfsync everysec`: `fsync` every second. Fast enough (since version 2.4 likely to be as fast as snapshotting), and you may lose 1 second of data if there is a disaster.
+* `appendfsync no`: Never `fsync`, just put your data in the hands of the Operating System. The faster and less safe method. Normally Linux will flush data every 30 seconds with this configuration, but it's up to the kernel's exact tuning.
+
+The suggested (and default) policy is to `fsync` every second. It is
+both fast and relatively safe. The `always` policy is very slow in
+practice, but it supports group commit, so if there are multiple parallel
+writes Redis will try to perform a single `fsync` operation.
+
+### What should I do if my AOF gets truncated?
+
+It is possible the server crashed while writing the AOF file, or the
+volume where the AOF file is stored was full at the time of writing. When this happens the
+AOF still contains consistent data representing a given point-in-time version
+of the dataset (that may be old up to one second with the default AOF fsync
+policy), but the last command in the AOF could be truncated.
+The latest major versions of Redis will be able to load the AOF anyway, just
+discarding the last non well formed command in the file. In this case the
+server will emit a log like the following:
+
+```
+* Reading RDB preamble from AOF file...
+* Reading the remaining AOF tail...
+# !!! Warning: short read while loading the AOF file !!!
+# !!! Truncating the AOF at offset 439 !!!
+# AOF loaded anyway because aof-load-truncated is enabled
+```
+
+You can change the default configuration to force Redis to stop in such
+cases if you want, but the default configuration is to continue regardless of
+the fact the last command in the file is not well-formed, in order to guarantee
+availability after a restart.
+
+Older versions of Redis may not recover, and may require the following steps:
+
+* Make a backup copy of your AOF file.
+* Fix the original file using the `redis-check-aof` tool that ships with Redis:
+
+      $ redis-check-aof --fix <filename>
+
+* Optionally use `diff -u` to check what is the difference between two files.
+* Restart the server with the fixed file.
+
+### What should I do if my AOF gets corrupted?
+
+If the AOF file is not just truncated, but corrupted with invalid byte
+sequences in the middle, things are more complex. Redis will complain
+at startup and will abort:
+
+```
+* Reading the remaining AOF tail...
+# Bad file format reading the append only file: make a backup of your AOF file, then use ./redis-check-aof --fix <filename>
+```
+
+The best thing to do is to run the `redis-check-aof` utility, initially without
+the `--fix` option, then understand the problem, jump to the given
+offset in the file, and see if it is possible to manually repair the file:
+The AOF uses the same format of the Redis protocol and is quite simple to fix
+manually. Otherwise it is possible to let the utility fix the file for us, but
+in that case all the AOF portion from the invalid part to the end of the
+file may be discarded, leading to a massive amount of data loss if the
+corruption happened to be in the initial part of the file.
+
+### How it works
+
+Log rewriting uses the same copy-on-write trick already in use for
+snapshotting.  This is how it works:
+
+**Redis >= 7.0**
+
+* Redis [forks](http://linux.die.net/man/2/fork), so now we have a child
+and a parent process.
+
+* The child starts writing the new base AOF in a temporary file.
+
+* The parent opens a new increments AOF file to continue writing updates.
+  If the rewriting fails, the old base and increment files (if there are any) plus this newly opened increment file represent the complete updated dataset,
+  so we are safe.
+  
+* When the child is done rewriting the base file, the parent gets a signal,
+and uses the newly opened increment file and child generated base file to build a temp manifest,
+and persist it.
+
+* Profit! Now Redis does an atomic exchange of the manifest files so that the result of this AOF rewrite takes effect. Redis also cleans up the old base file and any unused increment files.
+
+**Redis < 7.0**
+
+* Redis [forks](http://linux.die.net/man/2/fork), so now we have a child
+and a parent process.
+
+* The child starts writing the new AOF in a temporary file.
+
+* The parent accumulates all the new changes in an in-memory buffer (but
+at the same time it writes the new changes in the old append-only file,
+so if the rewriting fails, we are safe).
+
+* When the child is done rewriting the file, the parent gets a signal,
+and appends the in-memory buffer at the end of the file generated by the
+child.
+
+* Now Redis atomically renames the new file into the old one,
+and starts appending new data into the new file.
+
+### How I can switch to AOF, if I'm currently using dump.rdb snapshots?
+
+If you want to enable AOF in a server that is currently using RDB snapshots, you need to convert the data by enabling AOF via CONFIG command on the live server first.
+
+**IMPORTANT:** not following this procedure (e.g. just changing the config and restarting the server) can result in data loss!
+
+**Redis >= 2.2**
+
+Preparations:
+
+* Make a backup of your latest dump.rdb file.
+* Transfer this backup to a safe place.
+
+Switch to AOF on live database:
+
+* Enable AOF: `redis-cli config set appendonly yes`
+* Optionally disable RDB: `redis-cli config set save ""`
+* Make sure writes are appended to the append only file correctly.
+* **IMPORTANT:** Update your `redis.conf` (potentially through [`CONFIG REWRITE`](/commands/config-rewrite)) and ensure that it matches the configuration above.
+  If you forget this step, when you restart the server, the configuration changes will be lost and the server will start again with the old configuration, resulting in a loss of your data.
+
+Next time you restart the server:
+
+* Before restarting the server, wait for AOF rewrite to finish persisting the data.
+  You can do that by watching `INFO persistence`, waiting for `aof_rewrite_in_progress` and `aof_rewrite_scheduled` to be `0`, and validating that `aof_last_bgrewrite_status` is `ok`.
+* After restarting the server, check that your database contains the same number of keys it contained previously.
+
+**Redis 2.0**
+
+* Make a backup of your latest dump.rdb file.
+* Transfer this backup into a safe place.
+* Stop all the writes against the database!
+* Issue a `redis-cli BGREWRITEAOF`. This will create the append only file.
+* Stop the server when Redis finished generating the AOF dump.
+* Edit redis.conf end enable append only file persistence.
+* Restart the server.
+* Make sure that your database contains the same number of keys it contained before the switch.
+* Make sure that writes are appended to the append only file correctly.
+
+## Interactions between AOF and RDB persistence
+
+Redis >= 2.4 makes sure to avoid triggering an AOF rewrite when an RDB
+snapshotting operation is already in progress, or allowing a [`BGSAVE`](/commands/bgsave) while the
+AOF rewrite is in progress. This prevents two Redis background processes
+from doing heavy disk I/O at the same time.
+
+When snapshotting is in progress and the user explicitly requests a log
+rewrite operation using [`BGREWRITEAOF`](/commands/bgrewriteaof) the server will reply with an OK
+status code telling the user the operation is scheduled, and the rewrite
+will start once the snapshotting is completed.
+
+In the case both AOF and RDB persistence are enabled and Redis restarts the
+AOF file will be used to reconstruct the original dataset since it is
+guaranteed to be the most complete.
+
+## Backing up Redis data
+
+Before starting this section, make sure to read the following sentence: **Make Sure to Backup Your Database**. Disks break, instances in the cloud disappear, and so forth: no backups means huge risk of data disappearing into /dev/null.
+
+Redis is very data backup friendly since you can copy RDB files while the
+database is running: the RDB is never modified once produced, and while it
+gets produced it uses a temporary name and is renamed into its final destination
+atomically using rename(2) only when the new snapshot is complete.
+
+This means that copying the RDB file is completely safe while the server is
+running. This is what we suggest:
+
+* Create a cron job in your server creating hourly snapshots of the RDB file in one directory, and daily snapshots in a different directory.
+* Every time the cron script runs, make sure to call the `find` command to make sure too old snapshots are deleted: for instance you can take hourly snapshots for the latest 48 hours, and daily snapshots for one or two months. Make sure to name the snapshots with date and time information.
+* At least one time every day make sure to transfer an RDB snapshot *outside your data center* or at least *outside the physical machine* running your Redis instance.
+
+### Backing up AOF persistence
+
+If you run a Redis instance with only AOF persistence enabled, you can still perform backups.
+Since Redis 7.0.0, AOF files are split into multiple files which reside in a single directory determined by the `appenddirname` configuration.
+During normal operation all you need to do is copy/tar the files in this directory to achieve a backup. However, if this is done during a [rewrite](#log-rewriting), you might end up with an invalid backup.
+To work around this you must disable AOF rewrites during the backup:
+
+1. Turn off automatic rewrites with<br/>
+   [`CONFIG SET`](/commands/config-set) `auto-aof-rewrite-percentage 0`<br/>
+   Make sure you don't manually start a rewrite (using [`BGREWRITEAOF`](/commands/bgrewriteaof)) during this time.
+2. Check there's no current rewrite in progress using<br/>
+   [`INFO`](/commands/info) `persistence`<br/>
+   and verifying `aof_rewrite_in_progress` is 0. If it's 1, then you'll need to wait for the rewrite to complete.
+3. Now you can safely copy the files in the `appenddirname` directory.
+4. Re-enable rewrites when done:<br/>
+   [`CONFIG SET`](/commands/config-set) `auto-aof-rewrite-percentage <prev-value>`
+
+**Note:** If you want to minimize the time AOF rewrites are disabled you may create hard links to the files in `appenddirname` (in step 3 above) and then re-enable rewrites (step 4) after the hard links are created.
+Now you can copy/tar the hardlinks and delete them when done. This works because Redis guarantees that it
+only appends to files in this directory, or completely replaces them if necessary, so the content should be
+consistent at any given point in time.
+
+
+**Note:** If you want to handle the case of the server being restarted during the backup and make sure no rewrite will automatically start after the restart you can change step 1 above to also persist the updated configuration via [`CONFIG REWRITE`](/commands/config-rewrite).
+Just make sure to re-enable automatic rewrites when done (step 4) and persist it with another [`CONFIG REWRITE`](/commands/config-rewrite).
+
+Prior to version 7.0.0 backing up the AOF file can be done simply by copying the aof file (like backing up the RDB snapshot). The file may lack the final part
+but Redis will still be able to load it (see the previous sections about [truncated AOF files](#what-should-i-do-if-my-aof-gets-truncated)).
+
+
+## Disaster recovery
+
+Disaster recovery in the context of Redis is basically the same story as
+backups, plus the ability to transfer those backups in many different external
+data centers. This way data is secured even in the case of some catastrophic
+event affecting the main data center where Redis is running and producing its
+snapshots.
+
+We'll review the most interesting disaster recovery techniques
+that don't have too high costs.
+
+* Amazon S3 and other similar services are a good way for implementing your disaster recovery system. Simply transfer your daily or hourly RDB snapshot to S3 in an encrypted form. You can encrypt your data using `gpg -c` (in symmetric encryption mode). Make sure to store your password in many different safe places (for instance give a copy to the most important people of your organization). It is recommended to use multiple storage services for improved data safety.
+* Transfer your snapshots using SCP (part of SSH) to far servers. This is a fairly simple and safe route: get a small VPS in a place that is very far from you, install ssh there, and generate a ssh client key without passphrase, then add it in the `authorized_keys` file of your small VPS. You are ready to transfer backups in an automated fashion. Get at least two VPS in two different providers
+for best results.
+
+It is important to understand that this system can easily fail if not
+implemented in the right way. At least, make absolutely sure that after the
+transfer is completed you are able to verify the file size (that should match
+the one of the file you copied) and possibly the SHA1 digest, if you are using
+a VPS.
+
+You also need some kind of independent alert system if the transfer of fresh
+backups is not working for some reason.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Horizontal scaling with Redis Cluster
+linkTitle: Scale with Redis Cluster
+title: Scale with Redis Cluster
+weight: 6
+---
+
+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]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}). To learn how Redis Enterprise handles scaling, see [Linear Scaling with Redis Enterprise](https://redis.com/redis-enterprise/technology/linear-scaling-redis-enterprise/).
+
+## Redis Cluster 101
+
+Redis Cluster provides a way to run a Redis installation where data is automatically sharded across multiple Redis nodes. 
+Redis Cluster also provides some degree of availability during partitions&mdash;in practical terms, the ability to continue operations when some nodes fail or are unable to communicate. 
+However, the cluster will become unavailable in the event of larger failures (for example, when the majority of masters are unavailable).
+
+So, with Redis Cluster, you get the ability to:
+
+* Automatically split your dataset among multiple nodes.
+* Continue operations when a subset of the nodes are experiencing failures or are unable to communicate with the rest of the cluster.
+
+#### Redis Cluster TCP ports
+
+Every Redis Cluster node requires two open TCP connections: a Redis TCP port used to serve clients, e.g., 6379, and second port known as the _cluster bus port_. 
+By default, the cluster bus port is set by adding 10000 to the data port (e.g., 16379); however, you can override this in the `cluster-port` configuration.
+
+Cluster bus is a node-to-node communication channel that uses a binary protocol, which is more suited to exchanging information between nodes due to
+little bandwidth and processing time. 
+Nodes use the cluster bus for failure detection, configuration updates, failover authorization, and so forth. 
+Clients should never try to communicate with the cluster bus port, but rather use the Redis command port. 
+However, make sure you open both ports in your firewall, otherwise Redis cluster nodes won't be able to communicate.
+
+For a Redis Cluster to work properly you need, for each node:
+
+1. The client communication port (usually 6379) used to communicate with clients and be open to all the clients that need to reach the cluster, plus all the other cluster nodes that use the client port for key migrations.
+2. The cluster bus port must be reachable from all the other cluster nodes.
+
+If you don't open both TCP ports, your cluster will not work as expected.
+
+#### Redis Cluster and Docker
+
+Currently, Redis Cluster does not support NATted environments and in general
+environments where IP addresses or TCP ports are remapped.
+
+Docker uses a technique called _port mapping_: programs running inside Docker containers may be exposed with a different port compared to the one the program believes to be using. 
+This is useful for running multiple containers using the same ports, at the same time, in the same server.
+
+To make Docker compatible with Redis Cluster, you need to use Docker's _host networking mode_. 
+Please see the `--net=host` option in the [Docker documentation](https://docs.docker.com/engine/userguide/networking/dockernetworks/) for more information.
+
+#### Redis Cluster data sharding
+
+Redis Cluster does not use consistent hashing, but a different form of sharding
+where every key is conceptually part of what we call a **hash slot**.
+
+There are 16384 hash slots in Redis Cluster, and to compute the hash
+slot for a given key, we simply take the CRC16 of the key modulo
+16384.
+
+Every node in a Redis Cluster is responsible for a subset of the hash slots,
+so, for example, you may have a cluster with 3 nodes, where:
+
+* Node A contains hash slots from 0 to 5500.
+* Node B contains hash slots from 5501 to 11000.
+* Node C contains hash slots from 11001 to 16383.
+
+This makes it easy to add and remove cluster nodes. For example, if
+I want to add a new node D, I need to move some hash slots from nodes A, B, C
+to D. Similarly, if I want to remove node A from the cluster, I can just
+move the hash slots served by A to B and C. Once node A is empty,
+I can remove it from the cluster completely.
+
+Moving hash slots from a node to another does not require stopping
+any operations; therefore, adding and removing nodes, or changing the percentage of hash slots held by a node, requires no downtime.
+
+Redis Cluster supports multiple key operations as long as all of the keys involved in a single command execution (or whole transaction, or Lua script
+execution) belong to the same hash slot. The user can force multiple keys
+to be part of the same hash slot by using a feature called *hash tags*.
+
+Hash tags are documented in the Redis Cluster specification, but the gist is
+that if there is a substring between {} brackets in a key, only what is
+inside the string is hashed. For example, the keys `user:{123}:profile` and `user:{123}:account` are guaranteed to be in the same hash slot because they share the same hash tag. As a result, you can operate on these two keys in the same multi-key operation.
+
+#### Redis Cluster master-replica model
+
+To remain available when a subset of master nodes are failing or are
+not able to communicate with the majority of nodes, Redis Cluster uses a
+master-replica model where every hash slot has from 1 (the master itself) to N
+replicas (N-1 additional replica nodes).
+
+In our example cluster with nodes A, B, C, if node B fails the cluster is not
+able to continue, since we no longer have a way to serve hash slots in the
+range 5501-11000.
+
+However, when the cluster is created (or at a later time), we add a replica
+node to every master, so that the final cluster is composed of A, B, C
+that are master nodes, and A1, B1, C1 that are replica nodes.
+This way, the system can continue if node B fails.
+
+Node B1 replicates B, and B fails, the cluster will promote node B1 as the new
+master and will continue to operate correctly.
+
+However, note that if nodes B and B1 fail at the same time, Redis Cluster will not be able to continue to operate.
+
+#### Redis Cluster consistency guarantees
+
+Redis Cluster does not guarantee **strong consistency**. In practical
+terms this means that under certain conditions it is possible that Redis
+Cluster will lose writes that were acknowledged by the system to the client.
+
+The first reason why Redis Cluster can lose writes is because it uses
+asynchronous replication. This means that during writes the following
+happens:
+
+* Your client writes to the master B.
+* The master B replies OK to your client.
+* The master B propagates the write to its replicas B1, B2 and B3.
+
+As you can see, B does not wait for an acknowledgement from B1, B2, B3 before
+replying to the client, since this would be a prohibitive latency penalty
+for Redis, so if your client writes something, B acknowledges the write,
+but crashes before being able to send the write to its replicas, one of the
+replicas (that did not receive the write) can be promoted to master, losing
+the write forever.
+
+This is very similar to what happens with most databases that are
+configured to flush data to disk every second, so it is a scenario you
+are already able to reason about because of past experiences with traditional
+database systems not involving distributed systems. Similarly you can
+improve consistency by forcing the database to flush data to disk before
+replying to the client, but this usually results in prohibitively low
+performance. That would be the equivalent of synchronous replication in
+the case of Redis Cluster.
+
+Basically, there is a trade-off to be made between performance and consistency.
+
+Redis Cluster has support for synchronous writes when absolutely needed,
+implemented via the [`WAIT`](/commands/wait) command. This makes losing writes a lot less
+likely. However, note that Redis Cluster does not implement strong consistency
+even when synchronous replication is used: it is always possible, under more
+complex failure scenarios, that a replica that was not able to receive the write
+will be elected as master.
+
+There is another notable scenario where Redis Cluster will lose writes, that
+happens during a network partition where a client is isolated with a minority
+of instances including at least a master.
+
+Take as an example our 6 nodes cluster composed of A, B, C, A1, B1, C1,
+with 3 masters and 3 replicas. There is also a client, that we will call Z1.
+
+After a partition occurs, it is possible that in one side of the
+partition we have A, C, A1, B1, C1, and in the other side we have B and Z1.
+
+Z1 is still able to write to B, which will accept its writes. If the
+partition heals in a very short time, the cluster will continue normally.
+However, if the partition lasts enough time for B1 to be promoted to master
+on the majority side of the partition, the writes that Z1 has sent to B
+in the meantime will be lost.
+
+{{% alert title="Note" color="info" %}}
+There is a **maximum window** to the amount of writes Z1 will be able
+to send to B: if enough time has elapsed for the majority side of the
+partition to elect a replica as master, every master node in the minority
+side will have stopped accepting writes.
+{{% /alert %}}
+
+This amount of time is a very important configuration directive of Redis
+Cluster, and is called the **node timeout**.
+
+After node timeout has elapsed, a master node is considered to be failing,
+and can be replaced by one of its replicas.
+Similarly, after node timeout has elapsed without a master node to be able
+to sense the majority of the other master nodes, it enters an error state
+and stops accepting writes.
+
+## Redis Cluster configuration parameters
+
+We are about to create an example cluster deployment. 
+Before we continue, let's introduce the configuration parameters that Redis Cluster introduces
+in the `redis.conf` file.
+
+* **cluster-enabled `<yes/no>`**: If yes, enables Redis Cluster support in a specific Redis instance. Otherwise the instance starts as a standalone instance as usual.
+* **cluster-config-file `<filename>`**: Note that despite the name of this option, this is not a user editable configuration file, but the file where a Redis Cluster node automatically persists the cluster configuration (the state, basically) every time there is a change, in order to be able to re-read it at startup. The file lists things like the other nodes in the cluster, their state, persistent variables, and so forth. Often this file is rewritten and flushed on disk as a result of some message reception.
+* **cluster-node-timeout `<milliseconds>`**: The maximum amount of time a Redis Cluster node can be unavailable, without it being considered as failing. If a master node is not reachable for more than the specified amount of time, it will be failed over by its replicas. This parameter controls other important things in Redis Cluster. Notably, every node that can't reach the majority of master nodes for the specified amount of time, will stop accepting queries.
+* **cluster-slave-validity-factor `<factor>`**: If set to zero, a replica will always consider itself valid, and will therefore always try to failover a master, regardless of the amount of time the link between the master and the replica remained disconnected. If the value is positive, a maximum disconnection time is calculated as the *node timeout* value multiplied by the factor provided with this option, and if the node is a replica, it will not try to start a failover if the master link was disconnected for more than the specified amount of time. For example, if the node timeout is set to 5 seconds and the validity factor is set to 10, a replica disconnected from the master for more than 50 seconds will not try to failover its master. Note that any value different than zero may result in Redis Cluster being unavailable after a master failure if there is no replica that is able to failover it. In that case the cluster will return to being available only when the original master rejoins the cluster.
+* **cluster-migration-barrier `<count>`**: Minimum number of replicas a master will remain connected with, for another replica to migrate to a master which is no longer covered by any replica. See the appropriate section about replica migration in this tutorial for more information.
+* **cluster-require-full-coverage `<yes/no>`**: If this is set to yes, as it is by default, the cluster stops accepting writes if some percentage of the key space is not covered by any node. If the option is set to no, the cluster will still serve queries even if only requests about a subset of keys can be processed.
+* **cluster-allow-reads-when-down `<yes/no>`**: If this is set to no, as it is by default, a node in a Redis Cluster will stop serving all traffic when the cluster is marked as failed, either when a node can't reach a quorum of masters or when full coverage is not met. This prevents reading potentially inconsistent data from a node that is unaware of changes in the cluster. This option can be set to yes to allow reads from a node during the fail state, which is useful for applications that want to prioritize read availability but still want to prevent inconsistent writes. It can also be used for when using Redis Cluster with only one or two shards, as it allows the nodes to continue serving writes when a master fails but automatic failover is impossible.
+
+## Create and use a Redis Cluster
+
+To create and use a Redis Cluster, follow these steps:
+
+* [Create a Redis Cluster](#create-a-redis-cluster)
+* [Interact with the cluster](#interact-with-the-cluster)
+* [Write an example app with redis-rb-cluster](#write-an-example-app-with-redis-rb-cluster)
+* [Reshard the cluster](#reshard-the-cluster)
+* [A more interesting example application](#a-more-interesting-example-application)
+* [Test the failover](#test-the-failover)
+* [Manual failover](#manual-failover)
+* [Add a new node](#add-a-new-node)
+* [Remove a node](#remove-a-node)
+* [Replica migration](#replica-migration)
+* [Upgrade nodes in a Redis Cluster](#upgrade-nodes-in-a-redis-cluster)
+* [Migrate to Redis Cluster](#migrate-to-redis-cluster)
+
+But, first, familiarize yourself with the requirements for creating a cluster.
+
+#### Requirements to create a Redis Cluster
+
+To create a cluster, the first thing you need is to have a few empty Redis instances running in _cluster mode_. 
+
+At minimum, set the following directives in the `redis.conf` file:
+
+```
+port 7000
+cluster-enabled yes
+cluster-config-file nodes.conf
+cluster-node-timeout 5000
+appendonly yes
+```
+
+To enable cluster mode, set the `cluster-enabled` directive to `yes`.
+Every instance also contains the path of a file where the
+configuration for this node is stored, which by default is `nodes.conf`.
+This file is never touched by humans; it is simply generated at startup
+by the Redis Cluster instances, and updated every time it is needed.
+
+Note that the **minimal cluster** that works as expected must contain
+at least three master nodes. For deployment, we strongly recommend
+a six-node cluster, with three masters and three replicas.
+
+You can test this locally by creating the following directories named
+after the port number of the instance you'll run inside any given directory.
+
+For example:
+
+```
+mkdir cluster-test
+cd cluster-test
+mkdir 7000 7001 7002 7003 7004 7005
+```
+
+Create a `redis.conf` file inside each of the directories, from 7000 to 7005.
+As a template for your configuration file just use the small example above,
+but make sure to replace the port number `7000` with the right port number
+according to the directory name.
+
+
+You can start each instance as follows, each running in a separate terminal tab:
+
+```
+cd 7000
+redis-server ./redis.conf
+```
+You'll see from the logs that every node assigns itself a new ID:
+
+    [82462] 26 Nov 11:56:55.329 * No cluster configuration found, I'm 97a3a64667477371c4479320d683e4c8db5858b1
+
+This ID will be used forever by this specific instance in order for the instance
+to have a unique name in the context of the cluster. Every node
+remembers every other node using this IDs, and not by IP or port.
+IP addresses and ports may change, but the unique node identifier will never
+change for all the life of the node. We call this identifier simply **Node ID**.
+
+#### Create a Redis Cluster
+
+Now that we have a number of instances running, you need to create your cluster by writing some meaningful configuration to the nodes.
+
+You can configure and execute individual instances manually or use the create-cluster script.
+Let's go over how you do it manually.
+
+To create the cluster, run:
+
+    redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 \
+    127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 \
+    --cluster-replicas 1
+
+The command used here is **create**, since we want to create a new cluster.
+The option `--cluster-replicas 1` means that we want a replica for every master created.
+
+The other arguments are the list of addresses of the instances I want to use
+to create the new cluster.
+
+`redis-cli` will propose a configuration. Accept the proposed configuration by typing **yes**.
+The cluster will be configured and *joined*, which means that instances will be
+bootstrapped into talking with each other. Finally, if everything has gone well, you'll see a message like this:
+
+    [OK] All 16384 slots covered
+
+This means that there is at least one master instance serving each of the
+16384 available slots.
+
+If you don't want to create a Redis Cluster by configuring and executing
+individual instances manually as explained above, there is a much simpler
+system (but you'll not learn the same amount of operational details).
+
+Find the `utils/create-cluster` directory in the Redis distribution.
+There is a script called `create-cluster` inside (same name as the directory
+it is contained into), it's a simple bash script. In order to start
+a 6 nodes cluster with 3 masters and 3 replicas just type the following
+commands:
+
+1. `create-cluster start`
+2. `create-cluster create`
+
+Reply to `yes` in step 2 when the `redis-cli` utility wants you to accept
+the cluster layout.
+
+You can now interact with the cluster, the first node will start at port 30001
+by default. When you are done, stop the cluster with:
+
+3. `create-cluster stop`
+
+Please read the `README` inside this directory for more information on how
+to run the script.
+
+#### Interact with the cluster
+
+To connect to Redis Cluster, you'll need a cluster-aware Redis client. 
+See the [documentation]({{< relref "/develop/clients" >}}) for your client of choice to determine its cluster support.
+
+You can also test your Redis Cluster using the `redis-cli` command line utility:
+
+```
+$ redis-cli -c -p 7000
+redis 127.0.0.1:7000> set foo bar
+-> Redirected to slot [12182] located at 127.0.0.1:7002
+OK
+redis 127.0.0.1:7002> set hello world
+-> Redirected to slot [866] located at 127.0.0.1:7000
+OK
+redis 127.0.0.1:7000> get foo
+-> Redirected to slot [12182] located at 127.0.0.1:7002
+"bar"
+redis 127.0.0.1:7002> get hello
+-> Redirected to slot [866] located at 127.0.0.1:7000
+"world"
+```
+
+{{% alert title="Note" color="info" %}} 
+If you created the cluster using the script, your nodes may listen
+on different ports, starting from 30001 by default.
+{{% /alert %}}
+
+The `redis-cli` cluster support is very basic, so it always uses the fact that
+Redis Cluster nodes are able to redirect a client to the right node.
+A serious client is able to do better than that, and cache the map between
+hash slots and nodes addresses, to directly use the right connection to the
+right node. The map is refreshed only when something changed in the cluster
+configuration, for example after a failover or after the system administrator
+changed the cluster layout by adding or removing nodes.
+
+#### Write an example app with redis-rb-cluster
+
+Before going forward showing how to operate the Redis Cluster, doing things
+like a failover, or a resharding, we need to create some example application
+or at least to be able to understand the semantics of a simple Redis Cluster
+client interaction.
+
+In this way we can run an example and at the same time try to make nodes
+failing, or start a resharding, to see how Redis Cluster behaves under real
+world conditions. It is not very helpful to see what happens while nobody
+is writing to the cluster.
+
+This section explains some basic usage of
+[redis-rb-cluster](https://github.com/antirez/redis-rb-cluster) showing two
+examples. 
+The first is the following, and is the
+[`example.rb`](https://github.com/antirez/redis-rb-cluster/blob/master/example.rb)
+file inside the redis-rb-cluster distribution:
+
+```
+   1  require './cluster'
+   2
+   3  if ARGV.length != 2
+   4      startup_nodes = [
+   5          {:host => "127.0.0.1", :port => 7000},
+   6          {:host => "127.0.0.1", :port => 7001}
+   7      ]
+   8  else
+   9      startup_nodes = [
+  10          {:host => ARGV[0], :port => ARGV[1].to_i}
+  11      ]
+  12  end
+  13
+  14  rc = RedisCluster.new(startup_nodes,32,:timeout => 0.1)
+  15
+  16  last = false
+  17
+  18  while not last
+  19      begin
+  20          last = rc.get("__last__")
+  21          last = 0 if !last
+  22      rescue => e
+  23          puts "error #{e.to_s}"
+  24          sleep 1
+  25      end
+  26  end
+  27
+  28  ((last.to_i+1)..1000000000).each{|x|
+  29      begin
+  30          rc.set("foo#{x}",x)
+  31          puts rc.get("foo#{x}")
+  32          rc.set("__last__",x)
+  33      rescue => e
+  34          puts "error #{e.to_s}"
+  35      end
+  36      sleep 0.1
+  37  }
+```
+
+The application does a very simple thing, it sets keys in the form `foo<number>` to `number`, one after the other. So if you run the program the result is the
+following stream of commands:
+
+* SET foo0 0
+* SET foo1 1
+* SET foo2 2
+* And so forth...
+
+The program looks more complex than it should usually as it is designed to
+show errors on the screen instead of exiting with an exception, so every
+operation performed with the cluster is wrapped by `begin` `rescue` blocks.
+
+The **line 14** is the first interesting line in the program. It creates the
+Redis Cluster object, using as argument a list of *startup nodes*, the maximum
+number of connections this object is allowed to take against different nodes,
+and finally the timeout after a given operation is considered to be failed.
+
+The startup nodes don't need to be all the nodes of the cluster. The important
+thing is that at least one node is reachable. Also note that redis-rb-cluster
+updates this list of startup nodes as soon as it is able to connect with the
+first node. You should expect such a behavior with any other serious client.
+
+Now that we have the Redis Cluster object instance stored in the **rc** variable,
+we are ready to use the object like if it was a normal Redis object instance.
+
+This is exactly what happens in **line 18 to 26**: when we restart the example
+we don't want to start again with `foo0`, so we store the counter inside
+Redis itself. The code above is designed to read this counter, or if the
+counter does not exist, to assign it the value of zero.
+
+However note how it is a while loop, as we want to try again and again even
+if the cluster is down and is returning errors. Normal applications don't need
+to be so careful.
+
+**Lines between 28 and 37** start the main loop where the keys are set or
+an error is displayed.
+
+Note the `sleep` call at the end of the loop. In your tests you can remove
+the sleep if you want to write to the cluster as fast as possible (relatively
+to the fact that this is a busy loop without real parallelism of course, so
+you'll get the usually 10k ops/second in the best of the conditions).
+
+Normally writes are slowed down in order for the example application to be
+easier to follow by humans.
+
+Starting the application produces the following output:
+
+```
+ruby ./example.rb
+1
+2
+3
+4
+5
+6
+7
+8
+9
+^C (I stopped the program here)
+```
+
+This is not a very interesting program and we'll use a better one in a moment
+but we can already see what happens during a resharding when the program
+is running.
+
+#### Reshard the cluster
+
+Now we are ready to try a cluster resharding. To do this, please
+keep the example.rb program running, so that you can see if there is some
+impact on the program running. Also, you may want to comment the `sleep`
+call to have some more serious write load during resharding.
+
+Resharding basically means to move hash slots from a set of nodes to another
+set of nodes. 
+Like cluster creation, it is accomplished using the redis-cli utility.
+
+To start a resharding, just type:
+
+    redis-cli --cluster reshard 127.0.0.1:7000
+
+You only need to specify a single node, redis-cli will find the other nodes
+automatically.
+
+Currently redis-cli is only able to reshard with the administrator support,
+you can't just say move 5% of slots from this node to the other one (but
+this is pretty trivial to implement). So it starts with questions. The first
+is how much of a resharding do you want to do:
+
+    How many slots do you want to move (from 1 to 16384)?
+
+We can try to reshard 1000 hash slots, that should already contain a non
+trivial amount of keys if the example is still running without the sleep
+call.
+
+Then redis-cli needs to know what is the target of the resharding, that is,
+the node that will receive the hash slots.
+I'll use the first master node, that is, 127.0.0.1:7000, but I need
+to specify the Node ID of the instance. This was already printed in a
+list by redis-cli, but I can always find the ID of a node with the following
+command if I need:
+
+```
+$ redis-cli -p 7000 cluster nodes | grep myself
+97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5460
+```
+
+Ok so my target node is 97a3a64667477371c4479320d683e4c8db5858b1.
+
+Now you'll get asked from what nodes you want to take those keys.
+I'll just type `all` in order to take a bit of hash slots from all the
+other master nodes.
+
+After the final confirmation you'll see a message for every slot that
+redis-cli is going to move from a node to another, and a dot will be printed
+for every actual key moved from one side to the other.
+
+While the resharding is in progress you should be able to see your
+example program running unaffected. You can stop and restart it multiple times
+during the resharding if you want.
+
+At the end of the resharding, you can test the health of the cluster with
+the following command:
+
+    redis-cli --cluster check 127.0.0.1:7000
+
+All the slots will be covered as usual, but this time the master at
+127.0.0.1:7000 will have more hash slots, something around 6461.
+
+Resharding can be performed automatically without the need to manually
+enter the parameters in an interactive way. This is possible using a command
+line like the following:
+
+    redis-cli --cluster reshard <host>:<port> --cluster-from <node-id> --cluster-to <node-id> --cluster-slots <number of slots> --cluster-yes
+
+This allows to build some automatism if you are likely to reshard often,
+however currently there is no way for `redis-cli` to automatically
+rebalance the cluster checking the distribution of keys across the cluster
+nodes and intelligently moving slots as needed. This feature will be added
+in the future.
+
+The `--cluster-yes` option instructs the cluster manager to automatically answer
+"yes" to the command's prompts, allowing it to run in a non-interactive mode.
+Note that this option can also be activated by setting the
+`REDISCLI_CLUSTER_YES` environment variable.
+
+#### A more interesting example application
+
+The example application we wrote early is not very good.
+It writes to the cluster in a simple way without even checking if what was
+written is the right thing.
+
+From our point of view the cluster receiving the writes could just always
+write the key `foo` to `42` to every operation, and we would not notice at
+all.
+
+So in the `redis-rb-cluster` repository, there is a more interesting application
+that is called `consistency-test.rb`. It uses a set of counters, by default 1000, and sends [`INCR`](/commands/incr) commands in order to increment the counters.
+
+However instead of just writing, the application does two additional things:
+
+* When a counter is updated using [`INCR`](/commands/incr), the application remembers the write.
+* It also reads a random counter before every write, and check if the value is what we expected it to be, comparing it with the value it has in memory.
+
+What this means is that this application is a simple **consistency checker**,
+and is able to tell you if the cluster lost some write, or if it accepted
+a write that we did not receive acknowledgment for. In the first case we'll
+see a counter having a value that is smaller than the one we remember, while
+in the second case the value will be greater.
+
+Running the consistency-test application produces a line of output every
+second:
+
+```
+$ ruby consistency-test.rb
+925 R (0 err) | 925 W (0 err) |
+5030 R (0 err) | 5030 W (0 err) |
+9261 R (0 err) | 9261 W (0 err) |
+13517 R (0 err) | 13517 W (0 err) |
+17780 R (0 err) | 17780 W (0 err) |
+22025 R (0 err) | 22025 W (0 err) |
+25818 R (0 err) | 25818 W (0 err) |
+```
+
+The line shows the number of **R**eads and **W**rites performed, and the
+number of errors (query not accepted because of errors since the system was
+not available).
+
+If some inconsistency is found, new lines are added to the output.
+This is what happens, for example, if I reset a counter manually while
+the program is running:
+
+```
+$ redis-cli -h 127.0.0.1 -p 7000 set key_217 0
+OK
+
+(in the other tab I see...)
+
+94774 R (0 err) | 94774 W (0 err) |
+98821 R (0 err) | 98821 W (0 err) |
+102886 R (0 err) | 102886 W (0 err) | 114 lost |
+107046 R (0 err) | 107046 W (0 err) | 114 lost |
+```
+
+When I set the counter to 0 the real value was 114, so the program reports
+114 lost writes ([`INCR`](/commands/incr) commands that are not remembered by the cluster).
+
+This program is much more interesting as a test case, so we'll use it
+to test the Redis Cluster failover.
+
+#### Test the failover
+
+To trigger the failover, the simplest thing we can do (that is also
+the semantically simplest failure that can occur in a distributed system)
+is to crash a single process, in our case a single master.
+
+{{% alert title="Note" color="info" %}} 
+During this test, you should take a tab open with the consistency test
+application running.
+{{% /alert %}} 
+
+We can identify a master and crash it with the following command:
+
+```
+$ redis-cli -p 7000 cluster nodes | grep master
+3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 127.0.0.1:7001 master - 0 1385482984082 0 connected 5960-10921
+2938205e12de373867bf38f1ca29d31d0ddb3e46 127.0.0.1:7002 master - 0 1385482983582 0 connected 11423-16383
+97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5959 10922-11422
+```
+
+Ok, so 7000, 7001, and 7002 are masters. Let's crash node 7002 with the
+**DEBUG SEGFAULT** command:
+
+```
+$ redis-cli -p 7002 debug segfault
+Error: Server closed the connection
+```
+
+Now we can look at the output of the consistency test to see what it reported.
+
+```
+18849 R (0 err) | 18849 W (0 err) |
+23151 R (0 err) | 23151 W (0 err) |
+27302 R (0 err) | 27302 W (0 err) |
+
+... many error warnings here ...
+
+29659 R (578 err) | 29660 W (577 err) |
+33749 R (578 err) | 33750 W (577 err) |
+37918 R (578 err) | 37919 W (577 err) |
+42077 R (578 err) | 42078 W (577 err) |
+```
+
+As you can see during the failover the system was not able to accept 578 reads and 577 writes, however no inconsistency was created in the database. This may
+sound unexpected as in the first part of this tutorial we stated that Redis
+Cluster can lose writes during the failover because it uses asynchronous
+replication. What we did not say is that this is not very likely to happen
+because Redis sends the reply to the client, and the commands to replicate
+to the replicas, about at the same time, so there is a very small window to
+lose data. However the fact that it is hard to trigger does not mean that it
+is impossible, so this does not change the consistency guarantees provided
+by Redis cluster.
+
+We can now check what is the cluster setup after the failover (note that
+in the meantime I restarted the crashed instance so that it rejoins the
+cluster as a replica):
+
+```
+$ redis-cli -p 7000 cluster nodes
+3fc783611028b1707fd65345e763befb36454d73 127.0.0.1:7004 slave 3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 0 1385503418521 0 connected
+a211e242fc6b22a9427fed61285e85892fa04e08 127.0.0.1:7003 slave 97a3a64667477371c4479320d683e4c8db5858b1 0 1385503419023 0 connected
+97a3a64667477371c4479320d683e4c8db5858b1 :0 myself,master - 0 0 0 connected 0-5959 10922-11422
+3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 127.0.0.1:7005 master - 0 1385503419023 3 connected 11423-16383
+3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 127.0.0.1:7001 master - 0 1385503417005 0 connected 5960-10921
+2938205e12de373867bf38f1ca29d31d0ddb3e46 127.0.0.1:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0 1385503418016 3 connected
+```
+
+Now the masters are running on ports 7000, 7001 and 7005. What was previously
+a master, that is the Redis instance running on port 7002, is now a replica of
+7005.
+
+The output of the [`CLUSTER NODES`](/commands/cluster-nodes) command may look intimidating, but it is actually pretty simple, and is composed of the following tokens:
+
+* Node ID
+* ip:port
+* flags: master, replica, myself, fail, ...
+* if it is a replica, the Node ID of the master
+* Time of the last pending PING still waiting for a reply.
+* Time of the last PONG received.
+* Configuration epoch for this node (see the Cluster specification).
+* Status of the link to this node.
+* Slots served...
+
+#### Manual failover
+
+Sometimes it is useful to force a failover without actually causing any problem
+on a master. For example, to upgrade the Redis process of one of the
+master nodes it is a good idea to failover it to turn it into a replica
+with minimal impact on availability.
+
+Manual failovers are supported by Redis Cluster using the [`CLUSTER FAILOVER`](/commands/cluster-failover)
+command, that must be executed in one of the replicas of the master you want
+to failover.
+
+Manual failovers are special and are safer compared to failovers resulting from
+actual master failures. They occur in a way that avoids data loss in the
+process, by switching clients from the original master to the new master only
+when the system is sure that the new master processed all the replication stream
+from the old one.
+
+This is what you see in the replica log when you perform a manual failover:
+
+    # Manual failover user request accepted.
+    # Received replication offset for paused master manual failover: 347540
+    # All master replication stream processed, manual failover can start.
+    # Start of election delayed for 0 milliseconds (rank #0, offset 347540).
+    # Starting a failover election for epoch 7545.
+    # Failover election won: I'm the new master.
+
+Basically clients connected to the master we are failing over are stopped.
+At the same time the master sends its replication offset to the replica, that
+waits to reach the offset on its side. When the replication offset is reached,
+the failover starts, and the old master is informed about the configuration
+switch. When the clients are unblocked on the old master, they are redirected
+to the new master.
+
+{{% alert title="Note" color="info" %}} 
+To promote a replica to master, it must first be known as a replica by a majority of the masters in the cluster.
+  Otherwise, it cannot win the failover election.
+  If the replica has just been added to the cluster (see [Add a new node as a replica](#add-a-new-node-as-a-replica)), you may need to wait a while before sending the [`CLUSTER FAILOVER`](/commands/cluster-failover) command, to make sure the masters in cluster are aware of the new replica.
+{{% /alert %}} 
+
+#### Add a new node
+
+Adding a new node is basically the process of adding an empty node and then
+moving some data into it, in case it is a new master, or telling it to
+setup as a replica of a known node, in case it is a replica.
+
+We'll show both, starting with the addition of a new master instance.
+
+In both cases the first step to perform is **adding an empty node**.
+
+This is as simple as to start a new node in port 7006 (we already used
+from 7000 to 7005 for our existing 6 nodes) with the same configuration
+used for the other nodes, except for the port number, so what you should
+do in order to conform with the setup we used for the previous nodes:
+
+* Create a new tab in your terminal application.
+* Enter the `cluster-test` directory.
+* Create a directory named `7006`.
+* Create a redis.conf file inside, similar to the one used for the other nodes but using 7006 as port number.
+* Finally start the server with `../redis-server ./redis.conf`
+
+At this point the server should be running.
+
+Now we can use **redis-cli** as usual in order to add the node to
+the existing cluster.
+
+    redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000
+
+As you can see I used the **add-node** command specifying the address of the
+new node as first argument, and the address of a random existing node in the
+cluster as second argument.
+
+In practical terms redis-cli here did very little to help us, it just
+sent a [`CLUSTER MEET`](/commands/cluster-meet) message to the node, something that is also possible
+to accomplish manually. However redis-cli also checks the state of the
+cluster before to operate, so it is a good idea to perform cluster operations
+always via redis-cli even when you know how the internals work.
+
+Now we can connect to the new node to see if it really joined the cluster:
+
+```
+redis 127.0.0.1:7006> cluster nodes
+3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 127.0.0.1:7001 master - 0 1385543178575 0 connected 5960-10921
+3fc783611028b1707fd65345e763befb36454d73 127.0.0.1:7004 slave 3e3a6cb0d9a9a87168e266b0a0b24026c0aae3f0 0 1385543179583 0 connected
+f093c80dde814da99c5cf72a7dd01590792b783b :0 myself,master - 0 0 0 connected
+2938205e12de373867bf38f1ca29d31d0ddb3e46 127.0.0.1:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0 1385543178072 3 connected
+a211e242fc6b22a9427fed61285e85892fa04e08 127.0.0.1:7003 slave 97a3a64667477371c4479320d683e4c8db5858b1 0 1385543178575 0 connected
+97a3a64667477371c4479320d683e4c8db5858b1 127.0.0.1:7000 master - 0 1385543179080 0 connected 0-5959 10922-11422
+3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 127.0.0.1:7005 master - 0 1385543177568 3 connected 11423-16383
+```
+
+Note that since this node is already connected to the cluster it is already
+able to redirect client queries correctly and is generally speaking part of
+the cluster. However it has two peculiarities compared to the other masters:
+
+* It holds no data as it has no assigned hash slots.
+* Because it is a master without assigned slots, it does not participate in the election process when a replica wants to become a master.
+
+Now it is possible to assign hash slots to this node using the resharding
+feature of `redis-cli`. 
+It is basically useless to show this as we already
+did in a previous section, there is no difference, it is just a resharding
+having as a target the empty node.
+
+##### Add a new node as a replica
+
+Adding a new replica can be performed in two ways. The obvious one is to
+use redis-cli again, but with the --cluster-slave option, like this:
+
+    redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000 --cluster-slave
+
+Note that the command line here is exactly like the one we used to add
+a new master, so we are not specifying to which master we want to add
+the replica. In this case, what happens is that redis-cli will add the new
+node as replica of a random master among the masters with fewer replicas.
+
+However you can specify exactly what master you want to target with your
+new replica with the following command line:
+
+    redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000 --cluster-slave --cluster-master-id 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e
+
+This way we assign the new replica to a specific master.
+
+A more manual way to add a replica to a specific master is to add the new
+node as an empty master, and then turn it into a replica using the
+[`CLUSTER REPLICATE`](/commands/cluster-replicate) command. This also works if the node was added as a replica
+but you want to move it as a replica of a different master.
+
+For example in order to add a replica for the node 127.0.0.1:7005 that is
+currently serving hash slots in the range 11423-16383, that has a Node ID
+3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e, all I need to do is to connect
+with the new node (already added as empty master) and send the command:
+
+    redis 127.0.0.1:7006> cluster replicate 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e
+
+That's it. Now we have a new replica for this set of hash slots, and all
+the other nodes in the cluster already know (after a few seconds needed to
+update their config). We can verify with the following command:
+
+```
+$ redis-cli -p 7000 cluster nodes | grep slave | grep 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e
+f093c80dde814da99c5cf72a7dd01590792b783b 127.0.0.1:7006 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0 1385543617702 3 connected
+2938205e12de373867bf38f1ca29d31d0ddb3e46 127.0.0.1:7002 slave 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 0 1385543617198 3 connected
+```
+
+The node 3c3a0c... now has two replicas, running on ports 7002 (the existing one) and 7006 (the new one).
+
+#### Remove a node
+
+To remove a replica node just use the `del-node` command of redis-cli:
+
+    redis-cli --cluster del-node 127.0.0.1:7000 `<node-id>`
+
+The first argument is just a random node in the cluster, the second argument
+is the ID of the node you want to remove.
+
+You can remove a master node in the same way as well, **however in order to
+remove a master node it must be empty**. If the master is not empty you need
+to reshard data away from it to all the other master nodes before.
+
+An alternative to remove a master node is to perform a manual failover of it
+over one of its replicas and remove the node after it turned into a replica of the
+new master. Obviously this does not help when you want to reduce the actual
+number of masters in your cluster, in that case, a resharding is needed.
+
+There is a special scenario where you want to remove a failed node.
+You should not use the `del-node` command because it tries to connect to all nodes and you will encounter a "connection refused" error.
+Instead, you can use the `call` command:
+
+    redis-cli --cluster call 127.0.0.1:7000 cluster forget `<node-id>`
+
+This command will execute [`CLUSTER FORGET`](/commands/cluster-forget) command on every node. 
+
+#### Replica migration
+
+In Redis Cluster, you can reconfigure a replica to replicate with a
+different master at any time just using this command:
+
+    CLUSTER REPLICATE <master-node-id>
+
+However there is a special scenario where you want replicas to move from one
+master to another one automatically, without the help of the system administrator.
+The automatic reconfiguration of replicas is called *replicas migration* and is
+able to improve the reliability of a Redis Cluster.
+
+{{% alert title="Note" color="info" %}} 
+You can read the details of replicas migration in the [Redis Cluster Specification]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}), here we'll only provide some information about the
+general idea and what you should do in order to benefit from it.
+{{% /alert %}} 
+
+The reason why you may want to let your cluster replicas to move from one master
+to another under certain condition, is that usually the Redis Cluster is as
+resistant to failures as the number of replicas attached to a given master.
+
+For example a cluster where every master has a single replica can't continue
+operations if the master and its replica fail at the same time, simply because
+there is no other instance to have a copy of the hash slots the master was
+serving. However while net-splits are likely to isolate a number of nodes
+at the same time, many other kind of failures, like hardware or software failures
+local to a single node, are a very notable class of failures that are unlikely
+to happen at the same time, so it is possible that in your cluster where
+every master has a replica, the replica is killed at 4am, and the master is killed
+at 6am. This still will result in a cluster that can no longer operate.
+
+To improve reliability of the system we have the option to add additional
+replicas to every master, but this is expensive. Replica migration allows to
+add more replicas to just a few masters. So you have 10 masters with 1 replica
+each, for a total of 20 instances. However you add, for example, 3 instances
+more as replicas of some of your masters, so certain masters will have more
+than a single replica.
+
+With replicas migration what happens is that if a master is left without
+replicas, a replica from a master that has multiple replicas will migrate to
+the *orphaned* master. So after your replica goes down at 4am as in the example
+we made above, another replica will take its place, and when the master
+will fail as well at 5am, there is still a replica that can be elected so that
+the cluster can continue to operate.
+
+So what you should know about replicas migration in short?
+
+* The cluster will try to migrate a replica from the master that has the greatest number of replicas in a given moment.
+* To benefit from replica migration you have just to add a few more replicas to a single master in your cluster, it does not matter what master.
+* There is a configuration parameter that controls the replica migration feature that is called `cluster-migration-barrier`: you can read more about it in the example `redis.conf` file provided with Redis Cluster.
+
+#### Upgrade nodes in a Redis Cluster
+
+Upgrading replica nodes is easy since you just need to stop the node and restart
+it with an updated version of Redis. If there are clients scaling reads using
+replica nodes, they should be able to reconnect to a different replica if a given
+one is not available.
+
+Upgrading masters is a bit more complex, and the suggested procedure is:
+
+1. Use [`CLUSTER FAILOVER`](/commands/cluster-failover) to trigger a manual failover of the master to one of its replicas.
+   (See the [Manual failover](#manual-failover) in this topic.)
+2. Wait for the master to turn into a replica.
+3. Finally upgrade the node as you do for replicas.
+4. If you want the master to be the node you just upgraded, trigger a new manual failover in order to turn back the upgraded node into a master.
+
+Following this procedure you should upgrade one node after the other until
+all the nodes are upgraded.
+
+#### Migrate to Redis Cluster
+
+Users willing to migrate to Redis Cluster may have just a single master, or
+may already using a preexisting sharding setup, where keys
+are split among N nodes, using some in-house algorithm or a sharding algorithm
+implemented by their client library or Redis proxy.
+
+In both cases it is possible to migrate to Redis Cluster easily, however
+what is the most important detail is if multiple-keys operations are used
+by the application, and how. There are three different cases:
+
+1. Multiple keys operations, or transactions, or Lua scripts involving multiple keys, are not used. Keys are accessed independently (even if accessed via transactions or Lua scripts grouping multiple commands, about the same key, together).
+2. Multiple keys operations, or transactions, or Lua scripts involving multiple keys are used but only with keys having the same **hash tag**, which means that the keys used together all have a `{...}` sub-string that happens to be identical. For example the following multiple keys operation is defined in the context of the same hash tag: `SUNION {user:1000}.foo {user:1000}.bar`.
+3. Multiple keys operations, or transactions, or Lua scripts involving multiple keys are used with key names not having an explicit, or the same, hash tag.
+
+The third case is not handled by Redis Cluster: the application requires to
+be modified in order to not use multi keys operations or only use them in
+the context of the same hash tag.
+
+Case 1 and 2 are covered, so we'll focus on those two cases, that are handled
+in the same way, so no distinction will be made in the documentation.
+
+Assuming you have your preexisting data set split into N masters, where
+N=1 if you have no preexisting sharding, the following steps are needed
+in order to migrate your data set to Redis Cluster:
+
+1. Stop your clients. No automatic live-migration to Redis Cluster is currently possible. You may be able to do it orchestrating a live migration in the context of your application / environment.
+2. Generate an append only file for all of your N masters using the [`BGREWRITEAOF`](/commands/bgrewriteaof) command, and waiting for the AOF file to be completely generated.
+3. Save your AOF files from aof-1 to aof-N somewhere. At this point you can stop your old instances if you wish (this is useful since in non-virtualized deployments you often need to reuse the same computers).
+4. Create a Redis Cluster composed of N masters and zero replicas. You'll add replicas later. Make sure all your nodes are using the append only file for persistence.
+5. Stop all the cluster nodes, substitute their append only file with your pre-existing append only files, aof-1 for the first node, aof-2 for the second node, up to aof-N.
+6. Restart your Redis Cluster nodes with the new AOF files. They'll complain that there are keys that should not be there according to their configuration.
+7. Use `redis-cli --cluster fix` command in order to fix the cluster so that keys will be migrated according to the hash slots each node is authoritative or not.
+8. Use `redis-cli --cluster check` at the end to make sure your cluster is ok.
+9. Restart your clients modified to use a Redis Cluster aware client library.
+
+There is an alternative way to import data from external instances to a Redis
+Cluster, which is to use the `redis-cli --cluster import` command.
+
+The command moves all the keys of a running instance (deleting the keys from
+the source instance) to the specified pre-existing Redis Cluster. However
+note that if you use a Redis 2.8 instance as source instance the operation
+may be slow since 2.8 does not implement migrate connection caching, so you
+may want to restart your source instance with a Redis 3.x version before
+to perform such operation.
+
+{{% alert title="Note" color="info" %}} 
+Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+{{% /alert %}} 
+
+## Learn more
+
+* [Redis Cluster specification]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}})
+* [Linear Scaling with Redis Enterprise](https://redis.com/redis-enterprise/technology/linear-scaling-redis-enterprise/)
+* [Docker documentation](https://docs.docker.com/engine/userguide/networking/dockernetworks/)
+
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: The self-documented `redis-full.conf` file that is shipped with every version.
+linkTitle: Configuration example
+title: Redis Open Source configuration file example
+weight: 3
+---
+
+```
+include redis.conf
+
+loadmodule ./modules/redisbloom/redisbloom.so
+loadmodule ./modules/redisearch/redisearch.so
+loadmodule ./modules/redisjson/rejson.so
+loadmodule ./modules/redistimeseries/redistimeseries.so
+
+############################## QUERY ENGINE CONFIG ############################
+
+# Keep numeric ranges in numeric tree parent nodes of leafs for `x` generations.
+# numeric, valid range: [0, 2], default: 0
+#
+# search-_numeric-ranges-parents 0
+
+# The number of iterations to run while performing background indexing
+# before we call usleep(1) (sleep for 1 micro-second) and make sure that we
+# allow redis to process other commands.
+# numeric, valid range: [1, UINT32_MAX], default: 100
+#
+# search-bg-index-sleep-gap 100
+
+# The default dialect used in search queries.
+# numeric, valid range: [1, 4], default: 1
+#
+# search-default-dialect 1
+
+# the fork gc will only start to clean when the number of not cleaned document
+# will exceed this threshold.
+# numeric, valid range: [1, LLONG_MAX], default: 100
+#
+# search-fork-gc-clean-threshold 100
+
+# interval (in seconds) in which to retry running the forkgc after failure.
+# numeric, valid range: [1, LLONG_MAX], default: 5
+#
+# search-fork-gc-retry-interval 5
+
+# interval (in seconds) in which to run the fork gc (relevant only when fork
+# gc is used).
+# numeric, valid range: [1, LLONG_MAX], default: 30
+#
+# search-fork-gc-run-interval 30
+
+# the amount of seconds for the fork GC to sleep before exiting.
+# numeric, valid range: [0, LLONG_MAX], default: 0
+#
+# search-fork-gc-sleep-before-exit 0
+
+# Scan this many documents at a time during every GC iteration.
+# numeric, valid range: [1, LLONG_MAX], default: 100
+#
+# search-gc-scan-size 100
+
+# Max number of cursors for a given index that can be opened inside of a shard.
+# numeric, valid range: [0, LLONG_MAX], default: 128
+#
+# search-index-cursor-limit 128
+
+# Maximum number of results from ft.aggregate command.
+# numeric, valid range: [0, (1ULL << 31)], default: 1ULL << 31
+#
+# search-max-aggregate-results 2147483648
+
+# Maximum prefix expansions to be used in a query.
+# numeric, valid range: [1, LLONG_MAX], default: 200
+#
+# search-max-prefix-expansions 200
+
+# Maximum runtime document table size (for this process).
+# numeric, valid range: [1, 100000000], default: 1000000
+#
+# search-max-doctablesize 1000000
+
+# max idle time allowed to be set for cursor, setting it high might cause
+# high memory consumption.
+# numeric, valid range: [1, LLONG_MAX], default: 300000
+#
+# search-cursor-max-idle 300000
+
+# Maximum number of results from ft.search command.
+# numeric, valid range: [0, 1ULL << 31], default: 1000000
+#
+# search-max-search-results 1000000
+
+# Number of worker threads to use for background tasks when the server is
+# in an operation event.
+# numeric, valid range: [1, 16], default: 4
+#
+# search-min-operation-workers 4
+
+# Minimum length of term to be considered for phonetic matching.
+# numeric, valid range: [1, LLONG_MAX], default: 3
+#
+# search-min-phonetic-term-len 3
+
+# the minimum prefix for expansions (`*`).
+# numeric, valid range: [1, LLONG_MAX], default: 2
+#
+# search-min-prefix 2
+
+# the minimum word length to stem.
+# numeric, valid range: [2, UINT32_MAX], default: 4
+#
+# search-min-stem-len 4
+
+# Delta used to increase positional offsets between array
+# slots for multi text values.
+# Can control the level of separation between phrases in different
+# array slots (related to the SLOP parameter of ft.search command)"
+# numeric, valid range: [1, UINT32_MAX], default: 100
+#
+# search-multi-text-slop 100
+
+# Used for setting the buffer limit threshold for vector similarity tiered
+# HNSW index, so that if we are using WORKERS for indexing, and the
+# number of vectors waiting in the buffer to be indexed exceeds this limit,
+# we insert new vectors directly into HNSW.
+# numeric, valid range: [0, LLONG_MAX], default: 1024
+#
+# search-tiered-hnsw-buffer-limit 1024
+
+# Query timeout.
+# numeric, valid range: [1, LLONG_MAX], default: 500
+#
+# search-timeout 500
+
+# minimum number of iterators in a union from which the iterator will
+# will switch to heap-based implementation.
+# numeric, valid range: [1, LLONG_MAX], default: 20
+# switch to heap based implementation.
+#
+# search-union-iterator-heap 20
+
+# The maximum memory resize for vector similarity indexes (in bytes).
+# numeric, valid range: [0, UINT32_MAX], default: 0
+#
+# search-vss-max-resize 0
+
+# Number of worker threads to use for query processing and background tasks.
+# numeric, valid range: [0, 16], default: 0
+# This configuration also affects the number of connections per shard.
+#
+# search-workers 0
+
+# The number of high priority tasks to be executed at any given time by the
+# worker thread pool, before executing low priority tasks. After this number
+# of high priority tasks are being executed, the worker thread pool will
+# execute high and low priority tasks alternately.
+# numeric, valid range: [0, LLONG_MAX], default: 1
+#
+# search-workers-priority-bias-threshold 1
+
+# Load extension scoring/expansion module. Immutable.
+# string, default: ""
+#
+# search-ext-load ""
+
+# Path to Chinese dictionary configuration file (for Chinese tokenization). Immutable.
+# string, default: ""
+#
+# search-friso-ini ""
+
+# Action to perform when search timeout is exceeded (choose RETURN or FAIL).
+# enum, valid values: ["return", "fail"], default: "fail"
+#
+# search-on-timeout fail
+
+# Determine whether some index resources are free on a second thread.
+# bool, default: yes
+#
+# search-_free-resource-on-thread yes
+
+# Enable legacy compression of double to float.
+# bool, default: no
+#
+# search-_numeric-compress no
+
+# Disable print of time for ft.profile. For testing only.
+# bool, default: yes
+#
+# search-_print-profile-clock yes
+
+# Intersection iterator orders the children iterators by their relative estimated
+# number of results in ascending order, so that if we see first iterators with
+# a lower count of results we will skip a larger number of results, which
+# translates into faster iteration. If this flag is set, we use this
+# optimization in a way where union iterators are being factorize by the number
+# of their own children, so that we sort by the number of children times the
+# overall estimated number of results instead.
+# bool, default: no
+#
+# search-_prioritize-intersect-union-children no
+
+# Set to run without memory pools.
+# bool, default: no
+#
+# search-no-mem-pools no
+
+# Disable garbage collection (for this process).
+# bool, default: no
+#
+# search-no-gc no
+
+# Enable commands filter which optimize indexing on partial hash updates.
+# bool, default: no
+#
+# search-partial-indexed-docs no
+
+# Disable compression for DocID inverted index. Boost CPU performance.
+# bool, default: no
+#
+# search-raw-docid-encoding no
+
+# Number of search threads in the coordinator thread pool.
+# numeric, valid range: [1, LLONG_MAX], default: 20
+#
+# search-threads 20
+
+# Timeout for topology validation (in milliseconds). After this timeout,
+# any pending requests will be processed, even if the topology is not fully connected.
+# numeric, valid range: [0, LLONG_MAX], default: 30000
+#
+# search-topology-validation-timeout 30000
+
+
+############################## TIME SERIES CONFIG #############################
+
+# The maximal number of per-shard threads for cross-key queries when using cluster mode
+# (TS.MRANGE, TS.MREVRANGE, TS.MGET, and TS.QUERYINDEX).
+# Note: increasing this value may either increase or decrease the performance.
+# integer, valid range: [1..16], default: 3
+# This is a load-time configuration parameter.
+#
+# ts-num-threads 3
+
+
+# Default compaction rules for newly created key with TS.ADD, TS.INCRBY, and TS.DECRBY.
+# Has no effect on keys created with TS.CREATE.
+# This default value is applied to each new time series upon its creation.
+# string, see documentation for rules format, default: no compaction rules
+#
+# ts-compaction-policy ""
+
+# Default chunk encoding for automatically-created compacted time series.
+# This default value is applied to each new compacted time series automatically
+# created when ts-compaction-policy is specified.
+# valid values: COMPRESSED, UNCOMPRESSED, default: COMPRESSED
+#
+# ts-encoding COMPRESSED
+
+
+# Default retention period, in milliseconds. 0 means no expiration.
+# This default value is applied to each new time series upon its creation.
+# If ts-compaction-policy is specified - it is overridden for created
+# compactions as specified in ts-compaction-policy.
+# integer, valid range: [0 .. LLONG_MAX], default: 0
+#
+# ts-retention-policy 0
+
+# Default policy for handling insertion (TS.ADD and TS.MADD) of multiple
+# samples with identical timestamps.
+# This default value is applied to each new time series upon its creation.
+# string, valid values: BLOCK, FIRST, LAST, MIN, MAX, SUM, default: BLOCK
+#
+# ts-duplicate-policy BLOCK
+
+# Default initial allocation size, in bytes, for the data part of each new chunk
+# This default value is applied to each new time series upon its creation.
+# integer, valid range: [48 .. 1048576]; must be a multiple of 8, default: 4096
+#
+# ts-chunk-size-bytes 4096
+
+# Default values for newly created time series.
+# Many sensors report data periodically. Often, the difference between the measured
+# value and the previous measured value is negligible and related to random noise
+# or to measurement accuracy limitations. In such situations it may be preferable
+# not to add the new measurement to the time series.
+# A new sample is considered a duplicate and is ignored if the following conditions are met:
+# - The time series is not a compaction;
+# - The time series' DUPLICATE_POLICY IS LAST;
+# - The sample is added in-order (timestamp >= max_timestamp);
+# - The difference of the current timestamp from the previous timestamp
+#   (timestamp - max_timestamp) is less than or equal to ts-ignore-max-time-diff
+# - The absolute value difference of the current value from the value at the previous maximum timestamp
+#   (abs(value - value_at_max_timestamp) is less than or equal to ts-ignore-max-val-diff.
+# where max_timestamp is the timestamp of the sample with the largest timestamp in the time series,
+# and value_at_max_timestamp is the value at max_timestamp.
+# ts-ignore-max-time-diff: integer, valid range: [0 .. LLONG_MAX], default: 0
+# ts-ignore-max-val-diff: double, Valid range: [0 .. DBL_MAX], default: 0
+#
+# ts-ignore-max-time-diff 0
+# ts-ignore-max-val-diff 0
+
+
+########################### BLOOM FILTERS CONFIG ##############################
+
+# Defaults values for new Bloom filters created with BF.ADD, BF.MADD, BF.INSERT, and BF.RESERVE
+# These defaults are applied to each new Bloom filter upon its creation.
+
+# Error ratio
+# The desired probability for false positives.
+# For a false positive rate of 0.1% (1 in 1000) - the value should be 0.001.
+# double, Valid range: (0 .. 1), value greater than 0.25 is treated as 0.25, default: 0.01
+#
+# bf-error-rate 0.01
+
+# Initial capacity
+# The number of entries intended to be added to the filter.
+# integer, valid range: [1 .. 1GB], default: 100
+#
+# bf-initial-size 100
+
+# Expansion factor
+# When capacity is reached, an additional sub-filter is created.
+# The size of the new sub-filter is the size of the last sub-filter multiplied
+# by expansion.
+# integer, [0 .. 32768]. 0 is equivalent to NONSCALING. default: 2
+#
+# bf-expansion-factor 2
+
+
+########################### CUCKOO FILTERS CONFIG #############################
+
+# Defaults values for new Cuckoo filters created with
+# CF.ADD, CF.ADDNX, CF.INSERT, CF.INSERTNX, and CF.RESERVE
+# These defaults are applied to each new Cuckoo filter upon its creation.
+
+# Initial capacity
+# A filter will likely not fill up to 100% of its capacity.
+# Make sure to reserve extra capacity if you want to avoid expansions.
+# value is rounded to the next 2^n integer.
+# integer, valid range: [2*cf-bucket-size .. 1GB], default: 1024
+#
+# cf-initial-size 1024
+
+# Number of items in each bucket
+# The minimal false positive rate is 2/255 ~ 0.78% when bucket size of 1 is used.
+# Larger buckets increase the error rate linearly, but improve the fill rate.
+# integer, valid range: [1 .. 255], default: 2
+#
+# cf-bucket-size 2
+
+# Maximum iterations
+# Number of attempts to swap items between buckets before declaring filter
+# as full and creating an additional filter.
+# A lower value improves performance. A higher value improves fill rate.
+# integer, Valid range: [1 .. 65535], default: 20
+#
+# cf-max-iterations 20
+
+# Expansion factor
+# When a new filter is created, its size is the size of the current filter
+# multiplied by this factor.
+# integer, Valid range: [0 .. 32768], 0 is equivalent to NONSCALING, default: 1
+#
+# cf-expansion-factor 1
+
+# Maximum expansions
+# integer, Valid range: [1 .. 65536], default: 32
+#
+# cf-max-expansions 32
+
+
+################################## SECURITY ###################################
+#
+# The following is a list of command categories and their meanings:
+#
+# * search - Query engine related.
+# * json - Data type: JSON related.
+# * timeseries -  Data type: time series related.
+# * bloom - Data type:  Bloom filter related.
+# * cuckoo - Data type: cuckoo filter related.
+# * topk -  Data type: top-k related.
+# * cms - Data type: count-min sketch related.
+# * tdigest -  Data type: t-digest related.
+```---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: 'A guide to debugging Redis server processes
+
+  '
+linkTitle: Debugging
+title: Debugging
+weight: 10
+---
+
+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.
+
+This guide shows how to use GDB to provide the information the
+Redis developers will need to track the bug more easily.
+
+## What is GDB?
+
+GDB is the Gnu Debugger: a program that is able to inspect the internal state
+of another program. Usually tracking and fixing a bug is an exercise in
+gathering more information about the state of the program at the moment the
+bug happens, so GDB is an extremely useful tool.
+
+GDB can be used in two ways:
+
+* It can attach to a running program and inspect the state of it at runtime.
+* It can inspect the state of a program that already terminated using what is called a *core file*, that is, the image of the memory at the time the program was running.
+
+From the point of view of investigating Redis bugs we need to use both of these
+GDB modes. The user able to reproduce the bug attaches GDB to their running Redis
+instance, and when the crash happens, they create the `core` file that in turn
+the developer will use to inspect the Redis internals at the time of the crash.
+
+This way the developer can perform all the inspections in his or her computer
+without the help of the user, and the user is free to restart Redis in their
+production environment.
+
+## Compiling Redis without optimizations
+
+By default Redis is compiled with the `-O2` switch, this means that compiler
+optimizations are enabled. This makes the Redis executable faster, but at the
+same time it makes Redis (like any other program) harder to inspect using GDB.
+
+It is better to attach GDB to Redis compiled without optimizations using the
+`make noopt` command (instead of just using the plain `make` command). However,
+if you have an already running Redis in production there is no need to recompile
+and restart it if this is going to create problems on your side. GDB still works
+against executables compiled with optimizations.
+
+You should not be overly concerned at the loss of performance from compiling Redis
+without optimizations. It is unlikely that this will cause problems in your
+environment as Redis is not very CPU-bound.
+
+## Attaching GDB to a running process
+
+If you have an already running Redis server, you can attach GDB to it, so that
+if Redis crashes it will be possible to both inspect the internals and generate
+a `core dump` file.
+
+After you attach GDB to the Redis process it will continue running as usual without
+any loss of performance, so this is not a dangerous procedure.
+
+In order to attach GDB the first thing you need is the *process ID* of the running
+Redis instance (the *pid* of the process). You can easily obtain it using
+`redis-cli`:
+
+    $ redis-cli info | grep process_id
+    process_id:58414
+
+In the above example the process ID is **58414**.
+
+Login into your Redis server.
+
+(Optional but recommended) Start **screen** or **tmux** or any other program that will make sure that your GDB session will not be closed if your ssh connection times out. You can learn more about screen in [this article](http://www.linuxjournal.com/article/6340).
+
+Attach GDB to the running Redis server by typing:
+
+    $ gdb <path-to-redis-executable> <pid>
+
+For example:
+
+    $ gdb /usr/local/bin/redis-server 58414
+
+GDB will start and will attach to the running server printing something like the following:
+
+    Reading symbols for shared libraries + done
+    0x00007fff8d4797e6 in epoll_wait ()
+    (gdb)
+
+At this point GDB is attached but **your Redis instance is blocked by GDB**. In
+order to let the Redis instance continue the execution just type **continue** at
+the GDB prompt, and press enter.
+
+    (gdb) continue
+    Continuing.
+
+Done! Now your Redis instance has GDB attached. Now you can wait for the next crash. :)
+
+Now it's time to detach your screen/tmux session, if you are running GDB using it, by
+pressing **Ctrl-a a** key combination.
+
+## After the crash
+
+Redis has a command to simulate a segmentation fault (in other words a bad crash) using
+the `DEBUG SEGFAULT` command (don't use it against a real production instance of course!
+So I'll use this command to crash my instance to show what happens in the GDB side:
+
+    (gdb) continue
+    Continuing.
+
+    Program received signal EXC_BAD_ACCESS, Could not access memory.
+    Reason: KERN_INVALID_ADDRESS at address: 0xffffffffffffffff
+    debugCommand (c=0x7ffc32005000) at debug.c:220
+    220         *((char*)-1) = 'x';
+
+As you can see GDB detected that Redis crashed, and was even able to show me
+the file name and line number causing the crash. This is already much better
+than the Redis crash report back trace (containing just function names and
+binary offsets).
+
+## Obtaining the stack trace
+
+The first thing to do is to obtain a full stack trace with GDB. This is as
+simple as using the **bt** command:
+
+    (gdb) bt
+    #0  debugCommand (c=0x7ffc32005000) at debug.c:220
+    #1  0x000000010d246d63 in call (c=0x7ffc32005000) at redis.c:1163
+    #2  0x000000010d247290 in processCommand (c=0x7ffc32005000) at redis.c:1305
+    #3  0x000000010d251660 in processInputBuffer (c=0x7ffc32005000) at networking.c:959
+    #4  0x000000010d251872 in readQueryFromClient (el=0x0, fd=5, privdata=0x7fff76f1c0b0, mask=220924512) at networking.c:1021
+    #5  0x000000010d243523 in aeProcessEvents (eventLoop=0x7fff6ce408d0, flags=220829559) at ae.c:352
+    #6  0x000000010d24373b in aeMain (eventLoop=0x10d429ef0) at ae.c:397
+    #7  0x000000010d2494ff in main (argc=1, argv=0x10d2b2900) at redis.c:2046
+
+This shows the backtrace, but we also want to dump the processor registers using the **info registers** command:
+
+    (gdb) info registers
+    rax            0x0  0
+    rbx            0x7ffc32005000   140721147367424
+    rcx            0x10d2b0a60  4515891808
+    rdx            0x7fff76f1c0b0   140735188943024
+    rsi            0x10d299777  4515796855
+    rdi            0x0  0
+    rbp            0x7fff6ce40730   0x7fff6ce40730
+    rsp            0x7fff6ce40650   0x7fff6ce40650
+    r8             0x4f26b3f7   1327936503
+    r9             0x7fff6ce40718   140735020271384
+    r10            0x81 129
+    r11            0x10d430398  4517462936
+    r12            0x4b7c04f8babc0  1327936503000000
+    r13            0x10d3350a0  4516434080
+    r14            0x10d42d9f0  4517452272
+    r15            0x10d430398  4517462936
+    rip            0x10d26cfd4  0x10d26cfd4 <debugCommand+68>
+    eflags         0x10246  66118
+    cs             0x2b 43
+    ss             0x0  0
+    ds             0x0  0
+    es             0x0  0
+    fs             0x0  0
+    gs             0x0  0
+
+Please **make sure to include** both of these outputs in your bug report.
+
+## Obtaining the core file
+
+The next step is to generate the core dump, that is the image of the memory of the running Redis process. This is done using the `gcore` command:
+
+    (gdb) gcore
+    Saved corefile core.58414
+
+Now you have the core dump to send to the Redis developer, but **it is important
+to understand** that this happens to contain all the data that was inside the
+Redis instance at the time of the crash; Redis developers will make sure not to
+share the content with anyone else, and will delete the file as soon as it is no
+longer used for debugging purposes, but you are warned that by sending the core
+file you are sending your data.
+
+## What to send to developers
+
+Finally you can send everything to the Redis core team:
+
+* The Redis executable you are using.
+* The stack trace produced by the **bt** command, and the registers dump.
+* The core file you generated with gdb.
+* Information about the operating system and GCC version, and Redis version you are using.
+
+## Thank you
+
+Your help is extremely important! Many issues can only be tracked this way. So
+thanks!
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: An administrator's guide to Redis
+linkTitle: Manage Redis
+title: Manage Redis
+weight: 60
+---
+---
+Title: RedisGears Python quick start
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: A quick start to learn how to use RedisGears with Python.
+linkTitle: Quick start
+weight: 10
+---
+For this tutorial, you need:
+
+- Either:
+    - A Redis Enterprise cluster with the [RedisGears module and Python plugin installed]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}}) and [enabled on a database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/install" >}})
+    - 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.
+
+With RedisGears, **batch processing** means processing the data already stored in a Redis database. **Event processing** means processing changes to the Redis key space.
+
+The examples below assume an empty Redis database.
+
+## Batch processing
+
+Let's start with the simplest example. From the `redis-cli`, run the following command:
+
+```sh
+redis.cloud:6379> RG.PYEXECUTE "GearsBuilder().run()"
+1) (empty array)
+2) (empty array)
+```
+
+This command doesn't do much; it simply iterates over the keyspace. Let's add a key and run it again:
+
+```sh
+redis.cloud:6379> SET message "hello world"
+OK
+redis.cloud:6379> RG.PYEXECUTE "GearsBuilder().run()"
+1) 1) "{'event': None, 'key': 'message', 'type': 'string', 'value': 'hello world'}"
+2) (empty array)
+```
+
+We've added a single string, and you can see that this gears function processes it, even though it does nothing with the data. Let's actually do something with the data. So first, we'll add a few more strings:
+
+```sh
+redis.cloud::6379> SET message:2 "hello galaxy"
+OK
+redis.cloud:6379> SET message:3 "hello universe"
+OK
+```
+
+We now have three strings in our database. Suppose we want to perform a unique word count on these strings. We can write a RedisGears function to do this just that. So open a file called `wordcount.py`, and add the following code:
+
+```py
+gb = GearsBuilder()
+gb.map(lambda x: x['value'])     # map each key object to its string value
+gb.flatmap(lambda x: x.split())  # split each string into a list of words
+gb.countby()                     # run a count-unique on these words
+gb.run()
+```
+
+There are two ways to load files into RedisGears. For production deployments, we recommend using the special [`gears-cli`](https://github.com/gears-project/gears-cli). However, for the purpose of this demonstration, the easiest way is to pass the filename through the `redis-cli` command, like so:
+
+```sh
+$ redis-cli rg.pyexecute "`cat wordcount.py`"
+1) 1) "{'key': 'world', 'value': 1}"
+   2) "{'key': 'galaxy', 'value': 1}"
+   3) "{'key': 'hello', 'value': 3}"
+   4) "{'key': 'universe', 'value': 1}"
+2) (empty array)
+```
+
+The results here show the number of occurences of each word in all of our strings. So, we've effectively processed the data in our Redis database all at once, in a batch.
+
+## Event processing
+
+You may have noticed that all of the RedisGears functions above end with a call to `run()`. This indicates that the function should be run immediately on the data in the Redis database. But what if you want to process data as it arrives in Redis? In that case, your functions will end with a call to `register()`, which will store the function and apply it as events occur in Redis.
+
+Let's see how to register a function. First, suppose we're writing hashes to our database that represent users. They take the following form:
+
+```sh
+redis.cloud:6379> HSET person:3 name "Summer Smith" age 17
+(integer) 2
+redis.cloud:6379> HSET person:4 name "James Jameson" age 21
+(integer) 2
+```
+
+Each hash has two fields, one containing a name and the other an age. Now, suppose we want to keep a record of the maximum age of all users. We can register a RedisGears function to do this. Open up a file called `maxage.py`, and add the following code:
+
+```py
+def age(x):
+  ''' Extracts the age from a person's record '''
+  return int(x['value']['age'])
+
+def compare_and_swap(x):
+  ''' Checks and sets the current maximum '''
+  k = 'age:maximum'
+  v = execute('GET', k)   # read key's current value
+  v = int(v) if v else 0  # initialize to 0 if None
+  if x > v:               # if a new maximum found
+    execute('SET', k, x)  # set key to new value
+
+# Event handling function registration
+gb = GearsBuilder()
+gb.map(age) # Extract the 'age' field from each hash
+gb.foreach(compare_and_swap) # Compare the max age to the value stored at age:maximum
+gb.register(prefix='person:*') # Only process keys matching the pattern 'person:*'
+```
+
+You can see here that we define two methods: `age()` and `compare_and_swap()`. Even if you're not familiar with Python, you should be able to see what the methods do.
+
+Below the method definitions is the RedisGears data flow that we're defining. Notice that at the end we call `register()` to register the function to listen for events.
+
+To load this function into RedisGears, run the following:
+
+```sh
+$ redis-cli RG.PYEXECUTE "`cat maxage.py`"
+```
+
+Now start the `redis-cli`, and create a couple of hashes:
+
+```sh
+redis.cloud:6379> HSET person:5 name "Marek Michalski" age 17
+(integer) 2
+redis.cloud:6379> HSET person:6 name "Noya Beit" age 21
+(integer) 2
+```
+
+To see if the RedisGears function is working, check the value of `age:maximum`:
+
+```sh
+redis.cloud:6379> GET age:maximum
+"21"
+```
+
+## Next steps
+
+You should now have a basic idea of how to run RedisGears functions for batch and event processing. If you're interested in write-behind caching, see our [write-behind caching]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/recipes/write-behind" >}}) overview.
+---
+Title: Install RedisGears and the Python plugin
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Install
+toc: 'true'
+weight: 20
+---
+
+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
+
+1. Redis Enterprise v6.0.12 or later
+
+1. [Created a Redis Enterprise cluster]({{< relref "/operate/rs/clusters/new-cluster-setup" >}})
+
+1. [Added nodes to the cluster]({{< relref "/operate/rs/clusters/add-node" >}})
+
+1. [Installed RedisGears and the Python plugin]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}})
+
+## Enable RedisGears for a database
+
+1. From the Redis Enterprise admin console's **databases** page, select the **Add** button to create a new database:
+
+    {{<image filename="images/rs/icon_add.png" width="30px" alt="The Add icon">}}
+
+1. Confirm that you want to create a new Redis database with the **Next** button.
+
+1. On the **create database** page, give your database a name.
+
+1. For **Redis Modules**, select the **Add** button and choose RedisGears from the **Module** dropdown list.
+
+1. Select **Add Configuration**, enter <nobr>`Plugin gears_python CreateVenv 1`</nobr> in the box, then select the **OK** button:
+
+    {{<image filename="images/rs/icon_save.png" width="30px" alt="The Save icon">}}
+
+    {{<note>}}
+Only RedisGears v1.2 and later require this configuration.
+    {{</note>}}
+
+1. Select the **Activate** button.
+
+## Verify the install
+
+Run the `RG.PYSTATS` command to view statistics and verify that you set up RedisGears and the Python plugin correctly:
+
+```sh
+redis> RG.PYSTATS
+```
+---
+Title: Write-behind caching
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Write-behind and write-through caching between Redis and other databases
+  (SQL or NoSQL).
+linkTitle: Write-behind caching
+weight: 70
+---
+
+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]({{< relref "/operate/rs" >}}).
+
+Here's how these caching patterns work:
+
+1. Your application uses the cache for reads and writes.
+1. The cache syncs any changed data to the backing database asynchronously.
+
+<!-- ### Read-through caching
+
+1. Your application reads from the cache. If there's a cache hit, the data is returned.
+1. If there's cache miss, the cache retrieves the data from your backing database (think Oracle, PostgreSQL, etc.). The data is then stored in the cache and returned. -->
+
+## Install the write-behind recipe
+
+The write-behind recipe comes with two types of dependencies:
+
+- Drivers to connect to the backend database
+- Python libraries for the RedisGears functions
+
+In most cases all of these can be provisioned to RedisGears before the functions are uploaded.
+However, root access for the driver on the host is required in some cases, for example with Oracle drivers.
+
+### Install Oracle driver (optional)
+
+If you want to do write-behind with an Oracle database:
+
+1. [Download the Oracle driver](https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html).
+1. On each RS node in the cluster, follow the installation instructions on the download page for the Oracle driver.
+
+### Import requirements
+
+1. Install [Python 3](https://www.python.org/downloads/).
+1. To install the [gears-cli](https://pypi.org/project/gears-cli/), run: 
+    ```sh
+    pip install gears-cli
+    ```
+
+1. Download [rgsync offline package](https://redislabs.com/download-center/modules/).
+1. Import the requirements:
+
+    ```sh
+    # gears-cli import-requirements \
+        --host HOST [ --port PORT ] --password PASSWORD \
+        --requirements-path rgsync-99.99.99.linux-bionic-x64.zip
+    ```
+
+    {{< note >}}
+You can be more efficient and import only the requirements you need, but rgsync is always required and can be combined with one or more of these packages according to your backend database:
+
+- redisgears-requirement-v1-snowflake-sqlalchemy-linux-\<os>-x64.zip
+- redisgears-requirement-v1-PyMySQL-linux-\<os>-x64.zip
+- redisgears-requirement-v1-cx-Oracle-linux-\<os>-x64.zip
+- redisgears-requirement-v1-cassandra-driver-linux-\<os>-x64.zip
+
+This list can be different or more extensive in newer versions.
+The `module.json` file in the module package lists the dependencies for the module.
+
+    {{< /note >}}
+
+1. From the CLI of a node or of a client that is connected to the database, check that the requirements were imported successfully with: 
+
+    ```sh
+    redis-cli RG.PYDUMPREQS
+    ```
+
+    To connect to the database from a client, run:
+
+    ```sh
+    redis-cli -h <FQDN_of_node> -p <host> [-a <password>]
+    ```
+
+    This command returns a list of all available requirements.
+
+### Register the functions
+
+The following is a RedisGears recipe that shows how to use the write-behind pattern to map data from Redis hashes to MySQL tables.
+
+The recipe maps all Redis hashes with the prefix <nobr>`person:<id>`</nobr> to the MySQL table `persons`, with `<id>` being the primary key and mapped to the `person_id` column.
+Similarly, it maps all hashes with the prefix <nobr>`car:<id>`</nobr> to the `cars` table.
+
+```sh
+from rgsync import RGWriteBehind
+from rgsync.Connectors import MySqlConnector, MySqlConnection
+
+'''
+Create MySQL connection object
+'''
+connection = MySqlConnection('demouser', 'Password123!', 'localhost:3306/test')
+
+'''
+Create MySQL persons connector
+persons - MySQL table to put the data
+person_id - primary key
+'''
+personConnector = MySqlConnector(connection, 'persons', 'person_id')
+
+personsMappings = {
+	'first_name':'first',
+	'last_name':'last',
+	'age':'age'
+}
+
+RGWriteBehind(GB, keysPrefix='person', mappings=personsMappings, connector=personConnector, name='PersonsWriteBehind', version='99.99.99')
+
+'''
+Create MySQL car connector
+cars - MySQL table to put the data
+car_id - primary key
+'''
+carConnector = MySqlConnector(connection, 'cars', 'car_id')
+
+carsMappings = {
+	'id':'id',
+	'color':'color'
+}
+
+RGWriteBehind(GB, keysPrefix='cars', mappings=carsMappings, connector=carConnector, name='CarsWriteBehind', version='99.99.99')
+```
+
+Go to the [rgsync website](https://pypi.org/project/rgsync/) to get the replication options and the configuration options for the database and mapping.
+
+1. Create a Python file with the configuration mapping according to your specific needs.
+1. Run `gears-cli` with your custom file:
+
+    ```sh
+    gears-cli run --host <host> --port <post> --password <password> <yourfile>.py
+    ```
+
+## Write-behind caching with RedisGears
+
+[RGSync](https://github.com/RedisGears/rgsync) is a RedisGears recipe that uses the write-behind pattern to synchronize Redis data structures to a backing data store (Oracle, MySQL, Cassandra, and Snowflake are currently supported).
+
+Here's how you can create a write-behind function using the `RGSync` recipe against MySQL. This function will synchronize a set of fields in a Redis hash to the columns in a MySQL row. The key name for the Redis hash must have the form `{name}:{id}`, where `id` is the primary key for the row we want to keep in sync with. So, for example, suppose our hashes look like this:
+
+```sh
+redis.cloud:6379> HSET person:5 first_name Marek last_name Michalski age 27
+(integer) 2
+```
+
+The data in this hash would correspond to a row with ID of 5. But we need to define the mapping from our hash field to our columns. In our function, we do this using a Python dictionary:
+
+```py
+personsMappings = {
+	'first_name':'first',
+	'last_name':'last',
+	'age':'age'
+}
+```
+
+This is saying that the `last_name` field in our hash should be synchronized with the 'last' field in our row. So, now we're ready to write our RedisGears function.
+
+First, load the necessary libraries and connect to MySQL:
+
+```py
+from rgsync import RGWriteBehind
+from rgsync.Connectors import MySqlConnector, MySqlConnection
+
+connection = MySqlConnection('myapplication', 'Password123!', 'localhost:3306/test')
+```
+
+Next, create a connector object, specifying the table name and the name of the column storing the primary key:
+
+```py
+personConnector = MySqlConnector(mySqlConnection, 'persons', 'id')
+```
+
+After that, define your field-column mappings:
+
+```py
+personsMappings = {
+	'first_name':'first',
+	'last_name':'last',
+	'age':'age'
+}
+```
+
+Finally, use these initialized objects to create an `RGWRiteBehind` object:
+
+```py
+RGWriteBehind(GB,
+              name='PersonsWriteBehind',
+              version='1',
+              connector=personsConnector,
+              keysPrefix='person',
+              mappings=personsMappings)
+```
+
+Notice here that you can version this function registration with the `version` argument, as newer versions with the same `name` will replace the old one.
+
+If you've placed all of this code into a file (`example.py`), then you can load it into your Redis deployment using the [`gears-cli`](https://github.com/RedisGears/gears-cli) tool:
+
+```sh
+gears-cli --host <host>
+          --port <post>
+          --password <password>
+          example.py
+          REQUIREMENTS rgsync
+```
+
+### Secret management
+
+You may not want to store database credentials in your RedisGears functions. To avoid this, you can pass these credentials as module parameters and then reference them from your functions.
+
+The code below shows how to reference these credentials when creating a backing database connection.
+
+```py
+def User():
+	return configGet('MySqlUser')
+def Password():
+	return configGet('MySqlPassword')
+def DB():
+	return configGet('MySqlDB')
+
+connection = MySqlConnection(User, Password, DB)
+```
+
+Notice that for each credential, we define a Python function that returns the specified module parameter. We then provide each function reference when we instantiate `MySqlConnection`.
+
+This code references three parameters: `MySqlUser`, `MySqlPassword`, and `MySqlDB`. In Redis Enterprise, you can set these parameters using the `rladmin` tool. The command to set these parameters takes the following form:
+
+```sh
+rladmin tune db [DB-NAME] module_name rg module_config_params "[PARAM-NAME] [PARAM-VALUE]"
+```
+
+To set the `MySqlPassword` parameter to "Password123!" on a database named "user-api", you would run the this `rladmin` command:
+
+```sh
+rladmin tune db user-api module_name rg module_config_params "MySqlPassword Password123!"
+```
+
+Once a connection is successfully established, RedisGears will not attempt to reconnect until a disconnect occurs.
+This means that updates to the parameters that store the secrets will not take effect immediately,
+but they will be used for all subsequent connection attempts.
+---
+Title: Python-based RedisGears recipes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Recipes
+toc: 'false'
+weight: 70
+---
+
+A RedisGears recipe is a collection of RedisGears functions, often designed to perform a specific, complex task.
+
+{{<table-children columnNames="Recipe,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: RedisGears Python plugin
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: The RedisGears Python plugin allows you to run RedisGears functions with
+  Python.
+hideListLinks: true
+linkTitle: Run with Python
+weight: 71
+---
+
+With the RedisGears Python plugin, you can write RedisGears functions in [Python](https://www.python.org/) and run them on a [Redis Enterprise]({{< relref "/operate/rs/" >}}) cluster.
+
+The Python plugin allows both batch processing and event-driven processing.
+
+Before you can run RedisGears with Python, you will need to [install the RedisGears module and the Python plugin]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}}) on your Redis Enterprise cluster and [enable them for your database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/install" >}}).
+
+Once you have written your code, upload it to a node on your Redis Enterprise cluster. Use the `RG.PYEXECUTE` command with the `redis-cli` command-line tool to run your code.
+
+## More info
+
+- [RedisGears Python quick start]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/quickstart" >}})
+- [RedisGears recipes]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/recipes" >}})---
+Title: CallNextArray
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Calls the next execution that overrides the command or the original command
+  itself.
+linkTitle: callNextArray
+weight: 50
+---
+
+```java
+public static native java.lang.Object callNextArray(
+    java.lang.String[] command)
+```
+
+When you override a Redis command with the [`CommandOverrider`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/readers/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.
+
+## Example
+
+```java
+GearsBuilder.callNextArray(new String[]{"restaurant:1", "reviews", "50"});
+```---
+Title: ExecuteArray
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Runs a Redis command.
+linkTitle: executeArray
+weight: 50
+---
+
+```java
+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.
+
+## Example
+
+```java
+GearsBuilder.executeArray(new String[]{"SET", "age:maximum", "100"});
+```---
+Title: Filter
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Filters out records in the pipe based on a given condition.
+linkTitle: filter
+weight: 50
+---
+
+```java
+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<T> | 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.
+
+## Example
+
+Get all records that contain the substring "person:":
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+    filter(r->{
+        return r.getKey().contains("person:");
+});
+```---
+Title: AsyncForeach
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: For each record in the pipe, asynchronously runs some operations.
+linkTitle: asyncForeach
+weight: 50
+---
+
+```java
+public GearsBuilder<T> asyncForeach​(
+    gears.operations.AsyncForeachOperation<T> foreach)
+```
+
+The `asyncForeach` function allows you to use a [`GearsFuture`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsfuture" >}}) object to define a set of operations and run them asynchronously for each record in the pipe.
+
+## Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| foreach | AsyncForeachOperation<T> | The set of operations to run for each record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).map(r->r.getKey()).
+	asyncForeach(r->{
+		GearsFuture<Serializable> f = new GearsFuture<Serializable>();
+		new Thread(new Runnable() {
+				
+			@Override
+			public void run() {
+				try {
+					Thread.sleep(1);
+						
+					f.setResult(r);
+				} catch (Exception e) {
+					e.printStackTrace();
+				}					
+			}
+		}).start();
+		return f;
+});
+```---
+Title: Hashtag
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Returns a string that maps to the current shard.
+linkTitle: hashtag
+weight: 50
+---
+
+```java
+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. 
+{{</note>}}
+
+## Parameters
+
+None
+
+## Returns
+
+Returns a string that maps to the current shard.
+
+## Example
+
+The following example uses the `hashtag` function to calculate the hslot. The string maps to the current shard.
+
+```java
+GearsBuilder.execute(
+    "SET", 
+    String.format("key{%s}", GearsBuilder.hashtag()), 
+    "1"
+);
+```
+---
+Title: Map
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Maps records one-to-one.
+linkTitle: map
+weight: 50
+---
+
+```java
+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:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| mapper | <nobr>MapOperation<T,​I></nobr> | For each input record, returns a new output record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+Map each record to its string value:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+ 		map(r->{
+    		return r.getStringVal();
+});
+```
+---
+Title: Foreach
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: For each record in the pipe, runs some operations.
+linkTitle: foreach
+weight: 50
+---
+
+```java
+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<T> | The set of operations to run for each record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+For each person hash, add a new full_name field that combines their first and last names:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).foreach(r->{
+    String firstName = r.getHashVal().get("first_name");
+    String lastName = r.getHashVal().get("last_name");
+   	r.getHashVal().put("full_name", firstName + lastName);
+}); 
+```---
+Title: AccumulateBy
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Groups records and reduces each group to a single record per group.
+linkTitle: accumulateBy
+weight: 50
+---
+
+```java
+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.
+
+## Parameters
+ 
+Type parameters:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| accumulator | <nobr>AccumulateByOperation<T,​I></nobr> | A function with logic to update the accumulator value with each record |
+| extractor | ExtractorOperation<T> | Extracts a specific value from each record |
+| valueInitializer | ValueInitializerOperation<I> | Whenever the accumulated value is null, use this function to initialize it |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Examples
+
+Both of the following examples count the number of unique values.
+
+Without the `valueInitializer` parameter:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+   	accumulateBy(r->{
+   		return r.getStringVal();
+   	},(k, a, r)->{
+   		Integer ret = null;
+   		if(a == null) {
+   			ret = 0;
+   		}else {
+   			ret = (Integer)a;
+   		}
+   		return ret + 1;
+});
+```
+
+With the `valueInitializer` parameter:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+    	accumulateBy(()->{
+   		return 0;
+   	},r->{
+   		return r.getStringVal();
+   	},(k, a, r)->{
+   		return a + 1;
+   	});
+```
+---
+Title: LocalAccumulateBy
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Groups records and reduces each group to a single record per group locally
+  on each shard.
+linkTitle: localAccumulateBy
+weight: 50
+---
+
+```java
+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`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/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.
+
+## Parameters
+ 
+Type parameters:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| accumulator | <nobr>AccumulateByOperation<T,​I></nobr> | A function with logic to update the accumulator value with each record |
+| extractor | ExtractorOperation<T> | Extracts a specific value from each record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+   	localAccumulateBy(r->{
+   		return r.getStringVal();
+   	},(k, a, r)->{
+   		Integer ret = null;
+   		if(a == null) {
+   			ret = 0;
+   		}else {
+   			ret = (Integer)a;
+   		}
+   		return ret + 1;
+});
+```
+---
+Title: Count
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Counts the number of records in the pipe.
+linkTitle: count
+weight: 50
+---
+
+```java
+public GearsBuilder<java.lang.Integer> count()
+```
+
+Counts the number of records in the pipe and returns the total as a single record.
+
+## Parameters
+ 
+None
+
+## Returns
+
+Returns a GearsBuilder object with a new template type of `Integer`.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).count();
+```---
+Title: CreateGearsBuilder
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Creates a new GearsBuilder object.
+linkTitle: CreateGearsBuilder
+weight: 50
+---
+
+```java
+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:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder. The reader determines the type. |
+
+Parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| desc | string | The description |
+| reader | BaseReader<I> | The pipe reader |
+
+## Returns
+
+Returns a new GearsBuilder object.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader);
+```---
+Title: FlatMap
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Maps a single input record to one or more output records.
+linkTitle: flatMap
+weight: 50
+---
+
+```java
+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`](https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html). RedisGears 
+splits the elements from the `Iterable` object and processes them as individual records.
+
+## Parameters
+ 
+Type parameters:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder object |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| flatmapper | <nobr>FlatMapOperation<T,​I></nobr> | For each input record, returns one or more output records |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).flatMap(r->{
+   	return r.getListVal();
+}); 
+```---
+Title: Log
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Writes a log message to the Redis log file.
+linkTitle: log
+weight: 50
+---
+
+```java
+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
+
+## Example
+
+```java
+GearsBuilder.log(
+    "Setting keys to expire after 1 month", 
+    LogLevel.WARNING
+);
+```---
+Title: Register
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Registers the pipeline of functions to run when certain events occur.
+linkTitle: register
+weight: 50
+---
+
+```java
+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]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-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`. 
+{{</note>}}
+
+## 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.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).register();
+```---
+Title: Run
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Runs the pipeline of functions immediately.
+linkTitle: run
+weight: 50
+---
+
+```java
+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
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).run();
+```---
+Title: Collect
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Collects all records to the origin shard.
+linkTitle: collect
+weight: 50
+---
+
+```java
+public GearsBuilder<T> collect()
+```
+
+Collects all of the records to the shard where the RedisGears job started.
+
+## Parameters
+ 
+None
+
+## Returns
+
+Returns a GearsBuilder object with the same template type as the input builder.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).collect();
+```---
+Title: CallNext
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Calls the next execution that overrides the command or the original command
+  itself. A more flexible version of callNextArray.
+linkTitle: callNext
+weight: 50
+---
+
+```java
+public static java.lang.Object callNext(java.lang.String... args)
+```
+
+When you override a Redis command with the [`CommandOverrider`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/readers/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`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/callNextArray" >}}) since the list of string arguments does not have to be an explicit `String[]` object. This allows function calls like: <nobr>`callNext("key", "value")`.</nobr>
+
+## 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.
+
+## Examples
+
+Without `String[]`:
+
+```java
+GearsBuilder.callNext("restaurant:1", "reviews", "50");
+```
+
+With `String[]`:
+
+```java
+GearsBuilder.callNext(new String[]{"restaurant:1", "reviews", "50"});
+```
+---
+Title: AsyncFilter
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Asynchronously filters out records in the pipe based on a given condition.
+linkTitle: asyncFilter
+weight: 50
+---
+
+```java
+public GearsBuilder<T> asyncFilter​(
+    gears.operations.AsyncFilterOperation<T> filter)
+```
+
+The `asyncFilter` function allows you to use a [`GearsFuture`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/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<T> | 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.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).map(r->r.getKey()).
+	asyncFilter(r->{
+		GearsFuture<Boolean> f = new GearsFuture<Boolean>();
+		new Thread(new Runnable() {
+				
+			@Override
+			public void run() {
+				try {
+					Thread.sleep(1);
+						
+					f.setResult(r.equals("x"));
+				} catch (Exception e) {
+					e.printStackTrace();
+				}					
+			}
+		}).start();
+		return f;
+});
+```---
+Title: AsyncMap
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Asynchronously maps records one-to-one.
+linkTitle: asyncMap
+weight: 50
+---
+
+```java
+public <I extends java.io.Serializable> GearsBuilder<I> asyncMap​(
+	gears.operations.AsyncMapOperation<T,​I> mapper)
+```
+
+The `asyncMap` function allows you to use a [`GearsFuture`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsfuture" >}}) object to asynchronously map each input record in the pipe to an output record, one-to-one.
+
+## Parameters
+ 
+Type parameters:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| mapper | <nobr>AsyncMapOperation<T,​I></nobr> | For each input record, returns a new output record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+	asyncMap(r->{
+		GearsFuture<String> f = new GearsFuture<String>();
+		new Thread(new Runnable() {
+				
+			@Override
+			public void run() {
+				try {
+					Thread.sleep(1);
+					
+					f.setResult("done");
+				} catch (Exception e) {
+					e.printStackTrace();
+				}					
+			}
+		}).start();
+		return f;
+});
+```
+---
+Title: GearsBuilder
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Creates a RedisGears pipeline of operations to transform data.
+hideListLinks: true
+linkTitle: GearsBuilder
+toc: 'false'
+weight: 60
+---
+
+The `GearsBuilder` class allows you to create a pipeline of RedisGears functions that transform data.
+
+It requires a reader to supply data to the pipe.
+
+To create a `GearsBuilder` object, follow this example code:
+
+```java
+BaseReader reader = ...; // Initialize the reader
+builder = GearsBuilder.CreateGearsBuilder(reader);
+```
+
+## Functions
+
+{{<table-children columnNames="Function,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: Accumulate
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Reduces many records in the pipe to a single record.
+linkTitle: accumulate
+weight: 50
+---
+
+```java
+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:
+
+| Name | Description |
+|------|-------------|
+| I | The template type of the returned builder |
+
+Function parameters:
+
+| Name | Type | Description |
+|------|------|-------------|
+| accumulator | <nobr>AccumulateOperation<T,​I></nobr> | A function with logic to update the accumulator value with each record |
+| initialValue | template type I | The initial value of the accumulated object |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Examples
+
+Both of the following examples count the number of records in the pipeline.
+
+Without the `initialValue` parameter:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).accumulate((a, r)->{
+    Integer ret = null;
+    if (a == null) {
+	    ret = 1;
+    } else {
+	    ret = (Integer)a;
+    }
+    return ret + 1;
+});
+```
+
+With the `initialValue` parameter set to 0:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).accumulate(0, (a, r)->{
+   	return a + 1;
+});
+```
+---
+Title: ConfigGet
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Gets the value of a RedisGears configuration setting.
+linkTitle: configGet
+weight: 50
+---
+
+```java
+public static java.lang.String configGet​(java.lang.String key)
+```
+
+Gets the value of a RedisGears [configuration setting]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Configuration" >}}).
+
+{{<note>}}
+You can set configuration values when you load the module or use the `RG.CONFIGSET` command.
+{{</note>}}
+
+## Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| key | string | The configuration setting to get |
+
+## Returns
+
+Returns the configuration value of a RedisGears configuration setting.
+
+## Example
+
+```java
+GearsBuilder.configGet("ExecutionMaxIdleTime");
+```---
+Title: Execute
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Runs a Redis command. A more flexible version of executeArray.
+linkTitle: execute
+weight: 50
+---
+
+```java
+public static java.lang.Object execute​(java.lang.String... command)
+```
+
+Runs a Redis command, similar to [`executeArray`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/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: <nobr>`execute("SET", "key", "value")`.</nobr>
+
+## 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.
+
+## Examples
+
+Without `String[]`:
+
+```java
+GearsBuilder.execute("SET", "age:maximum", "100");
+```
+
+With `String[]`:
+
+```java
+GearsBuilder.execute(new String[]{"SET", "age:maximum", "100"});
+```
+---
+Title: Repartition
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Moves records between shards according to the extracted data.
+linkTitle: repartition
+weight: 50
+---
+
+```java
+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 | <nobr>ExtractorOperation<T></nobr> | Extracts a specific value from each record |
+
+## Returns
+
+Returns a GearsBuilder object with a new template type.
+
+## Example
+
+Repartition by value:
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).
+   	repartition(r->{
+   		return r.getStringVal();
+});
+```---
+Title: SetResult
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Sets a computation to run asynchronously.
+linkTitle: setResult
+weight: 50
+---
+
+```java
+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
+
+## Example
+
+```java
+GearsBuilder.CreateGearsBuilder(reader).map(r->r.getKey()).
+	asyncFilter(r->{
+		GearsFuture<Boolean> f = new GearsFuture<Boolean>();
+		try {
+			f.setResult(r.equals("x"));	
+		} catch (Exception e) {
+			e.printStackTrace();
+		}			
+		return f;
+});
+```
+---
+Title: SetError
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Sets an error message.
+linkTitle: setError
+weight: 50
+---
+
+```java
+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
+
+## Example
+
+```java
+GearsFuture<Boolean> f = new GearsFuture<Boolean>();
+try {
+	f.setError("An error has occurred during asyncForeach");
+} catch (Exception e) {
+	e.printStackTrace();
+}
+```
+---
+Title: GearsFuture
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Allows asynchronous processing of records.
+hideListLinks: true
+linkTitle: GearsFuture
+weight: 60
+---
+
+The `GearsFuture` class allows asynchronous processing of records in another thread.
+
+You can use a `GearsFuture` object with the following [`GearsBuilder`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder" >}}) functions:
+
+- [`asyncFilter`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/asyncfilter" >}})
+- [`asyncForeach`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/asyncforeach" >}})
+- [`asyncMap`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/asyncmap" >}})
+
+## Functions
+
+{{<table-children columnNames="Function,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: JavaReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: A template for creating custom readers.
+linkTitle: JavaReader
+weight: 60
+---
+
+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:
+
+- Extend the `JavaReader` class
+- Override the `iterator()` function
+
+## Custom reader example
+
+The implementation of the [`KeysOnlyReader`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/readers/keysonlyreader" >}}) class shows how to create a custom reader with `JavaReader`:
+
+```java
+import java.util.Iterator;
+
+import gears.GearsBuilder;
+
+/**
+ * A reader that only reads key names from the key space
+ *
+ */
+public class KeysOnlyReader extends JavaReader<String> {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+	
+	private String scanSize;
+	private String pattern;
+	
+	/**
+	 * Create a new KeysOnlyReader reader
+	 * @param scanSize - the size to use with the scan command
+	 * @param pattern - the pattern of the keys to read
+	 */
+	public KeysOnlyReader(int scanSize, String pattern) {
+		this.scanSize = Integer.toString(scanSize);
+		this.pattern = pattern;
+	}
+	
+	/**
+	 * Create a new KeysOnlyReader reader with default pattern (*) and default
+	 * scan size (10000)
+	 */
+	public KeysOnlyReader() {
+		this(10000, "*");
+	}
+
+	@Override
+	public Iterator<String> iterator() {
+		return new Iterator<String>() {
+
+			String cursor = "0";
+			int currIndex = 0;
+			Object[] keys = null;
+			boolean isDone = false;
+			String nextKey = null;
+			
+			private String innerNext() {
+				while(!isDone) {
+					if(keys == null) {
+						Object[] res = (Object[]) GearsBuilder.execute("scan", 
+										cursor == null ? "0" : cursor,
+										"MATCH", pattern, "COUNT", scanSize);
+						keys = (Object[])res[1];
+						cursor = (String)res[0];
+						currIndex = 0;
+					}
+					if(currIndex < keys.length) {
+						return (String) keys[currIndex++];
+					}
+					
+					keys = null;
+					if(cursor.charAt(0) == '0') {
+						isDone = true;
+					}
+				}
+				return null;
+			}
+			
+			@Override
+			public boolean hasNext() {
+				if(nextKey == null) {
+					nextKey = innerNext();
+				}
+				return !isDone;
+			}
+
+			@Override
+			public String next() {
+				String temp = nextKey != null ? nextKey : innerNext();
+				nextKey = innerNext();
+				return temp;
+			}
+			
+		};
+	}
+
+}
+```---
+Title: StreamReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Reads Redis stream data.
+linkTitle: StreamReader
+weight: 60
+---
+
+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.
+
+Each record is a `HashMap<String, Object>` with the following fields:
+
+| Name | Type | Description |
+|------|------|-------------|
+| id | string | The message's ID |
+| key | string | The stream key name |
+| value | HashMap<String, byte[]> | The message's data |
+
+## Examples
+
+The following example creates a `StreamReader` with default values:
+
+```java
+StreamReader reader = new StreamReader();
+```
+
+To change the parameter values for a `StreamReader`, use their setter methods:
+
+```java
+StreamReader reader = new StreamReader();
+// Get streams for keys that match "weather"
+reader.setPattern("weather");
+// Run RedisGears functions after every 10 messages
+reader.setBatchSize(10);
+```
+---
+Title: CommandOverrider
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Override a Redis command.
+linkTitle: CommandOverrider
+weight: 60
+---
+
+The `CommandOverrider` allows you to override and customize Redis commands.
+
+1. Pass the `CommandOverrider` to the [`GearsBuilder.CreateGearsBuilder()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/creategearsbuilder" >}}) function in your Java code.
+1. Call the [`register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}}) function.
+1. 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"`.
+{{</note>}}
+
+## 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.
+
+## Example
+
+The following example shows how to override the `HSET` command so that it also adds a `last_modified` timestamp for "user:" hashes.
+
+Add some user data as a hash:
+
+```sh
+redis> HSET user:1 name "morgan" posts 201
+(integer) 2
+```
+
+Example code:
+
+```java
+// Create the reader that will pass data to the pipe
+CommandOverrider overrider = new CommandOverrider();
+// Override the HSET command
+overrider.setCommand("HSET");
+// Only override HSET for keys that start with "user:"
+overrider.setPrefix("user:");
+
+// Create the data pipe builder
+GearsBuilder.CreateGearsBuilder(overrider).map(r-> {
+    // Get the operation arguments
+    ArrayList<String> operationArguments = new ArrayList<String>();
+    for (int i = 1; i < r.length; i++) {
+        operationArguments.add(new String((byte[]) r[i], StandardCharsets.UTF_8));
+    }
+
+    // Add a last-modified field and a corresponding timestamp to the operation arguments
+    operationArguments.add("last-modified");
+    operationArguments.add(Long.toString(System.currentTimeMillis()));
+
+    // Run the enriched HSET operation
+    Object reply = GearsBuilder.callNext(operationArguments.toArray(new String[0]));
+    
+    return reply.toString();
+}).register(ExecutionMode.SYNC);
+```
+
+After you register the previous code with the `RG.JEXECUTE` command, try to update the user's data with `HSET` to test it:
+
+```sh
+redis> HSET user:1 posts 234
+"OK"
+```
+
+Now the user's profile should have the updated value for `posts` and a `last_modified` timestamp:
+
+```sh
+redis> HGETALL user:1
+1) "name"
+2) "morgan"
+3) "posts"
+4) "234"
+5) "last_modified"
+6) "1643237927663"
+```---
+Title: ShardsIDReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Gets the shard ID for each shard in a database.
+linkTitle: ShardsIDReader
+weight: 60
+---
+
+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
+
+## Output records
+
+Creates a record for each shard with the shard's cluster identifier.
+
+## Example
+
+```java
+ShardsIDReader reader = new ShardsIDReader();
+```---
+Title: CommandReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Run RedisGears functions on command.
+linkTitle: CommandReader
+weight: 60
+---
+
+The `CommandReader` allows you to run RedisGears functions on command when you:
+
+1. Pass the `CommandReader` to the [`GearsBuilder.CreateGearsBuilder()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/creategearsbuilder" >}}) function in your Java code.
+1. Call the [`register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}}) function.
+1. Run `RG.JEXECUTE` to register your code.
+1. Use `RG.TRIGGER` to run your code on command:
+
+    ```sh
+    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.
+
+## Example
+
+The following example shows how to create a custom command to update an item's stock. It also adds a timestamp to track when the last restock occurred.
+
+Add a hash to the database that represents an inventory item:
+
+```sh
+redis> HSET inventory:headphones:1 color "blue" stock 5 price 30.00
+(integer) 3
+```
+
+Example code:
+
+```java
+// Create the reader that will pass data to the pipe
+CommandReader reader = new CommandReader();
+// Set the name of the custom command
+reader.setTrigger("Restock");
+        
+// Create the data pipe builder
+GearsBuilder.CreateGearsBuilder(reader).map(r-> {
+    // Parse the command arguments to get the key name and new stock value
+    String itemKey = new String((byte[]) r[1], StandardCharsets.UTF_8);
+    String newStock = new String((byte[]) r[2], StandardCharsets.UTF_8);
+        	
+    // Update the item's stock and add a timestamp
+    GearsBuilder.execute("HSET", itemKey , "stock", newStock,
+        			"last_restocked", Long.toString(System.currentTimeMillis()));
+        	
+    return "OK restocked " + itemKey;
+}).register();
+```
+
+After you register the previous code with the `RG.JEXECUTE` command, run `RG.TRIGGER` to test it:
+
+```sh
+redis> RG.TRIGGER Restock inventory:headphones:1 20
+1) "OK restocked inventory:headphones:1"
+```
+
+The item now has the updated value for `stock` and a `last_restocked` timestamp:
+
+```sh
+redis> HGETALL inventory:headphones:1
+1) "color"
+2) "blue"
+3) "stock"
+4) "20"
+5) "price"
+6) "30.00"
+7) "last_restocked"
+8) "1643232394078"
+```
+---
+Title: KeysReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Gets keys and their values from a database.
+linkTitle: KeysReader
+weight: 60
+---
+
+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.
+{{</note>}}
+
+## Constructors
+
+You can use one of these constructors to create a new `KeysReader` object:
+
+```java
+public KeysReader()
+
+public KeysReader(String pattern)
+
+public KeysReader(String prefix, boolean readValues)
+
+public KeysReader(String pattern, boolean noScan, boolean readValues)
+
+public KeysReader(String prefix, 
+                  boolean readValues, 
+                  String[] eventTypes, 
+                  String[] keyTypes)
+
+public KeysReader(String pattern, 
+                  boolean noScan, 
+                  boolean readValues, 
+                  String[] eventTypes, 
+                  String[] keyTypes)
+```
+
+## Parameters
+
+| Name | Type | Default value | Description |
+|------|------|---------------|-------------|
+| commands | array of strings | null | The commands that this reader is registered on |
+| eventTypes | array of strings | null | The [event types]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/register-events#event-types" >}}) to register on (usually the command name) |
+| keyTypes | array of strings | null | The key types to register on |
+| noScan | boolean | false | Whether or not to scan the key space or just read the pattern as is |
+| pattern/prefix | string | "\*" (match all keys) | The reader will get all keys that match this pattern |
+| readValues | boolean | true | Whether or not to read the keys' values |
+
+
+## Output records
+
+Creates a `KeysReaderRecord` for each matching key in the database.
+
+| Name | Type | Description |
+|------|------|-------------|
+| key | string | The name of the key |
+| type | long | The core Redis type: 'string', 'hash', 'list', 'set', 'zset', or 'stream' |
+| event | string | The event that triggered the execution (null if using the run function) |
+| stringVal | string | The key's value for string data types |
+| hashVal | Map<String,String> | The key's value for hash data types |
+| listVal | List<String> | The key's value for list data types |
+| setVal | Set<String> | The key's value for set data types |
+
+## Examples
+
+Here's a basic example of a `KeysReader` that creates records for all keys in the database:
+
+```java
+KeysReader reader = new KeysReader();
+```
+
+In the following example, the `KeysReader` creates records for all keys in the database that start with "person:". When registered, it only runs for hashes after `HSET` and `DEL` events occur.
+
+```java
+String[] eventTypes = {"HSET", "DEL"};
+String[] keyTypes = {"HASH"};
+KeysReader reader = new KeysReader("person:*", false, true, eventTypes, keyTypes);
+```
+---
+Title: KeysOnlyReader
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Gets key names from a database.
+linkTitle: KeysOnlyReader
+weight: 60
+---
+
+The `KeysOnlyReader` only extracts the key names from a database.
+
+## Constructors
+
+You can use one of these constructors to create a new `KeysOnlyReader` object:
+
+```java
+public KeysOnlyReader()
+
+public KeysOnlyReader(int scanSize, String pattern)
+```
+
+## Parameters
+
+| Name | Type | Default value | Description |
+|------|------|---------------|-------------|
+| pattern | string | "\*" (match all keys) | Get all keys that match this pattern |
+| scanSize | integer | 10000 | The scan command's size limit |
+
+## Output records
+
+Each output record is a string that represents the key's name.
+
+## Examples
+
+Get all keys in the database:
+
+```java
+KeysOnlyReader reader = new KeysOnlyReader();
+```
+
+Only get keys that start with "user:":
+
+```java
+KeysOnlyReader reader = new KeysOnlyReader(1000, "user:*");
+```
+
+---
+Title: RedisGears readers
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Extracts data from the database and creates records to pass through a
+  RedisGears pipeline.
+hideListLinks: true
+linkTitle: Readers
+weight: 60
+---
+
+A reader extracts data from the database and creates records.
+
+The [`GearsBuilder.CreateGearsBuilder(reader)`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/creategearsbuilder" >}}) function takes a reader as a parameter and passes the generated records through a pipeline of RedisGears functions.
+
+## Classes
+
+{{<table-children columnNames="Class,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: RedisGears Java classes and functions
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Classes and functions
+weight: 60
+---
+
+The RedisGears JVM plugin provides a set of classes and functions for you to use in your Java code.
+
+## Classes
+
+{{<table-children columnNames="Class,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: "RedisGears JVM\_quick start"
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: A quick start to learn how to use RedisGears with Java.
+linkTitle: Quick start
+weight: 10
+---
+
+## Prerequisites
+
+For this quick start, you need:
+
+- A Redis Enterprise cluster with the [RedisGears module and JVM plugin installed]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}}) and [enabled on a database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/install" >}})
+- `redis-cli` with connectivity to a Redis database
+
+## Tutorial
+
+### Create a Maven project
+
+1. Create a new [Maven project](https://maven.apache.org/guides/getting-started/index.html#).
+
+1. Add the following sections to the [pom.xml](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html) file:
+
+    ```xml
+    <repositories>
+        <repository>
+            <id>snapshots-repo</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.redislabs</groupId>
+            <artifactId>gear_runtime</artifactId>
+            <version>0.0.3-SNAPSHOT</version>
+        </dependency>
+    </dependencies>
+    ```
+
+1. Add example code for either [batch processing](#batch-processing) or [event processing](#event-processing) to your project's `main` function.
+
+
+
+### Build a JAR
+
+Use the Maven command-line tool or an IDE plugin to compile and package your code into a JAR file:
+
+```sh
+$ mvn package
+```
+
+### Upload the JAR
+
+Upload your JAR file to a node in the Redis Enterprise cluster. You will need to use the destination filepath when you run your code.
+
+### Run RedisGears Java code
+
+Use the `RG.JEXECUTE` command to run your code:
+
+```sh
+$ redis-cli -x -h {host} -p {port} RG.JEXECUTE {package.MainClass} < {filepath}/{JAR name}.jar
+```
+
+{{<note>}}
+When you use [`GearsBuilder.run()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/run" >}}), `RG.JEXECUTE` runs your code immediately.
+<br></br>
+However, if you use [`GearsBuilder.register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}}), `RG.JEXECUTE` only outputs an `OK` message if it registers successfully. Your registered code will run whenever certain database events occur.
+{{</note>}}
+
+## Example code
+
+You can use these code examples with your own Maven project to try out batch processing or event processing with the RedisGears JVM plugin.
+
+### Batch processing
+
+If you use the [`GearsBuilder.run()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/run" >}}) function within your code, then the functions you add to the pipeline will run exactly once when you use `RG.JEXECUTE` with your JAR file.
+
+The following example calculates the average rating of all restaurant reviews stored in your database.
+
+#### Add data to the database
+
+1. Connect to your database with `redis-cli`:
+
+    ```sh
+    $ redis-cli -h <host> -p <port>
+    ```
+
+1. Add a few review hashes to the database with the `HSET` command:
+
+    ```sh
+    127.0.0.1:12000> HSET review:1 user "Alex L" message "My new favorite restaurant!" rating 5
+    (integer) 3
+    127.0.0.1:12000> HSET review:2 user "Anonymous user" message "Kind of overpriced" rating 2
+    (integer) 3
+    127.0.0.1:12000> HSET review:3 user "Francis J" message "They have a really unique menu." rating 4
+    (integer) 3
+    127.0.0.1:12000> exit
+    ```
+
+#### Example code
+
+```java
+import java.io.Serializable;
+import gears.GearsBuilder;
+import gears.readers.KeysReader;
+import gears.records.KeysReaderRecord;
+
+public class Reviews implements Serializable
+{
+
+	private static final long serialVersionUID = 1L;
+	int count; // Total number of reviews
+	int ratingsSum; // Sum of all review ratings
+	
+    // Reviews constructor
+	public Reviews(int count, int ratingsSum) {
+		this.count = count;
+		this.ratingsSum = ratingsSum;
+	}
+
+    public static void main(String args[]) 
+    {  
+        // Create the reader that will pass data to the pipe
+        KeysReader reader = new KeysReader();
+        
+        // Create the data pipe builder
+        GearsBuilder<KeysReaderRecord> gb = GearsBuilder.CreateGearsBuilder(reader);
+        
+		gb.filter(r->{
+			// Filter out any keys that are not reviews
+			return r.getKey().startsWith("review:");
+		}).map(r->{
+			// Extract the rating field
+			return r.getHashVal().get("rating");
+		})
+		.accumulate(new Reviews(0, 0), (accumulator, record)-> {
+			// Count the reviews and add up all of their ratings
+			accumulator.count++;
+			accumulator.ratingsSum += Integer.parseInt(record);
+			return accumulator;
+		}).map(r->{
+			// Calculate the average rating
+			return Double.valueOf(((double) r.ratingsSum) / r.count);
+		});
+             
+        // Run the data through the pipeline immediately
+        gb.run();
+    }
+}
+```
+
+#### Example output
+
+```sh
+$ redis-cli -x -h {host} -p {port} \
+    RG.JEXECUTE com.domain.packagename.Reviews < /tmp/rgjvmtest-0.0.1-SNAPSHOT.jar
+1) 1) "3.6666666666666665"
+2) (empty array)
+```
+
+### Event processing
+
+If you use the [`GearsBuilder.register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}}) function in your code, then the functions you add to the pipeline will run every time a certain database event occurs.
+
+The following example registers a pipeline of functions to automatically update the maximum age every time you add a new person hash to your database.
+
+#### Example code
+
+```java
+import gears.GearsBuilder;
+import gears.readers.KeysReader;
+import gears.records.KeysReaderRecord;
+
+public class App 
+{
+    public static void main(String args[]) 
+    {  
+        // Create the reader that will pass data to the pipe
+        KeysReader reader = new KeysReader();
+        
+        // Create the data pipe builder
+        GearsBuilder<KeysReaderRecord> gb = GearsBuilder.CreateGearsBuilder(reader);
+
+        // Only process keys that start with "person:"
+        gb.filter(r->{
+        	return r.getKey().startsWith("person:");
+       	});
+
+        // Compare each person's age to the current maximum age
+        gb.foreach(r->{
+        	String newAgeStr = r.getHashVal().get("age");
+        	int newAge = Integer.parseInt(newAgeStr);
+        	
+        	// Get the current maximum age
+        	String maxAgeKey = "age:maximum";
+        	String maxAgeStr = (String) GearsBuilder.execute("GET", maxAgeKey);
+        	
+        	int maxAge = 0; // Initialize to 0
+        	if (maxAgeStr != null) {
+                // Convert the maximum age to an integer
+        		maxAge = Integer.parseInt(maxAgeStr);
+        	}
+
+        	// Update the maximum age if a new age is higher
+        	if (newAge > maxAge) {               
+        		GearsBuilder.execute("SET", maxAgeKey, newAgeStr); 
+        	}
+        });
+        
+        // Store this pipeline of functions and 
+        // run them when a new person key is added
+        gb.register(ExecutionMode.SYNC);
+        // Note: ExecutionMode defaults to ASYNC 
+        // if you call register() without any arguments
+    }
+}
+```
+
+#### Example event processing
+
+After you register your code with the `RG.JEXECUTE` command, add some data to the database and check the value of `age:maximum` to verify that it runs correctly.
+
+1. Connect to your database with `redis-cli`:
+
+    ```sh
+    $ redis-cli -h <host> -p <port>
+    ```
+
+1. Add a hash that represents a person with `HSET`:
+
+    ```sh
+    127.0.0.1:12000> HSET person:1 name "Alex" age 24
+    (integer) 2
+    ```
+
+1. The current value of `age:maximum` should match Alex's age:
+
+    ```sh
+    127.0.0.1:12000> GET age:maximum
+    "24"
+    ```
+
+1. Add another person with a higher age and then check that `age:maximum` updated automatically:
+
+    ```sh
+    127.0.0.1:12000> HSET person:2 name "Morgan" age 45
+    (integer) 2
+    127.0.0.1:12000> GET age:maximum
+    "45"
+    ```
+
+1. Add a person with a lower age and verify that `age:maximum` did not change:
+
+    ```sh
+    127.0.0.1:12000> HSET person:3 name "Lee" age 31
+    (integer) 2
+    127.0.0.1:12000> GET age:maximum
+    "45"
+    ```---
+Title: Install RedisGears and the JVM plugin
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Install
+toc: 'true'
+weight: 20
+---
+
+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
+
+1. Redis Enterprise v6.0.12 or later
+
+1. [Created a Redis Enterprise cluster]({{< relref "/operate/rs/clusters/new-cluster-setup" >}})
+
+1. [Added nodes to the cluster]({{< relref "/operate/rs/clusters/add-node" >}})
+
+1. [Installed RedisGears and the JVM plugin]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}})
+
+## Enable RedisGears for a database
+
+1. From the Redis Enterprise admin console's **databases** page, select the **Add** button to create a new database:
+
+    {{<image filename="images/rs/icon_add.png" width="30px" alt="The Add icon">}}
+
+1. Confirm that you want to create a new Redis database with the **Next** button.
+
+1. On the **create database** page, give your database a name.
+
+1. For **Redis Modules**, select the **Add** button and choose RedisGears from the **Module** dropdown list.
+
+1. Select **Add Configuration**, enter `Plugin gears_jvm` in the box, then select the **OK** button:
+
+    {{<image filename="images/rs/icon_save.png" width="30px" alt="The Save icon">}}
+
+    {{<note>}}
+You can configure additional JVM options in this box. For example:<br></br>
+`Plugin gears_jvm JvmOptions `<nobr>`'-Dproperty1=value1`</nobr> <nobr>`-Dproperty2=value2'`</nobr>
+    {{</note>}}
+
+1. Select the **Activate** button.
+
+## Verify the install
+
+Run the `RG.JSTATS` command from a database shard to view statistics and verify that you set up RedisGears and the JVM plugin correctly:
+
+```sh
+$ shard-cli 3
+172.16.0.1:12345> RG.JSTATS
+```
+---
+Title: Write-behind, write-through, and read-through caching
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Write-behind, write-through, and read-through caching between Redis and
+  other databases (SQL or NoSQL).
+linkTitle: Caching strategies
+toc: 'true'
+weight: 70
+---
+
+The [rghibernate](https://github.com/RedisGears/rghibernate) recipe uses RedisGears functions and the [Hibernate](https://hibernate.org/) 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.
+
+## Differences from RGSync
+
+[RGSync](https://github.com/RedisGears/rgsync):
+- Python-based recipe
+- Programmable
+
+[rghibernate](https://github.com/RedisGears/rghibernate):
+- Java-based recipe
+- Uses the Hibernate framework
+- Configurable rather than programmable
+
+## Set up write-behind and read-through
+
+To set up write-behind caching, first build an rghibernate JAR and register it with RedisGears.
+
+Then, register the following configuration files:
+
+- Connector XML: Tells Redis how to connect to the underlying database.
+
+- Mapping XML: Shows how to map data between the two databases, such as mapping Redis hashes to MySQL tables.
+
+### Register rghibernate JAR
+
+1. Download the rghibernate JAR from the [download center](https://redis.com/redis-enterprise-software/download-center/modules/).
+
+1. Upload the JAR to a Redis node.
+
+1. Register rghibernate with RedisGears:
+
+    ```sh
+    $ redis-cli -x RG.JEXECUTE com.redislabs.WriteBehind < {filepath}/rghibernate-0.1.1-jar-with-dependencies.jar
+    ```
+
+### Configure database connection
+
+1. Create a [connector XML file](#connector-xml) with the configuration to connect Redis to an underlying database.
+
+1. Upload the file to a Redis node.
+
+1. Register the connector configuration:
+
+    ```sh
+    > redis-cli -x RG.TRIGGER SYNC.REGISTERCONNECTOR mysql 1000 10 5 < src/test/resources/mysql_hibernate.cfg.xml 
+    1) "OK"
+    ```
+
+### Configure data mapping
+
+1. Create a [mapping XML file](#mapping-xml) that defines how Redis maps data to an underlying database.
+
+1. Upload the file to a Redis node.
+
+1. Register the mapping configuration for write-behind:
+
+    ```sh
+    > redis-cli -x RG.TRIGGER SYNC.REGISTERSOURCE StudentWrite mysql WriteBehind < src/test/resources/Student.hbm.xml 
+    1) "OK"
+    ````
+
+1. Register the same mapping configuration for read-through:
+
+    ```sh
+    > redis-cli -x RG.TRIGGER SYNC.REGISTERSOURCE StudentRead mysql ReadThrough 0 < src/test/resources/Student.hbm.xml 
+    1) "OK"
+    ````
+## Example configuration
+
+Here are some example configuration files for connecting to databases and mapping data.
+
+### Connector XML
+
+This configuration file contains connection details for an underlying MySQL database:
+
+```xml
+<!DOCTYPE hibernate-configuration PUBLIC
+        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+  "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
+        
+<hibernate-configuration>
+  <session-factory>
+    <!-- JDBC Database connection settings -->
+    <property name="connection.driver_class">org.mariadb.jdbc.Driver</property>
+    <property name="connection.url">jdbc:mysql://localhost:3306/test?allowPublicKeyRetrieval=true&amp;useSSL=false</property>
+    <property name="connection.username">user</property>
+    <property name="connection.password">pass</property>
+    <!-- JDBC connection pool settings ... using built-in test pool -->
+    <property name="connection.pool_size">1</property>
+    <!-- Echo the SQL to stdout -->
+    <property name="show_sql">false</property>
+    <!-- Set the current session context -->
+    <property name="current_session_context_class">thread</property>
+    <!-- Drop and re-create the database schema on startup -->
+    <property name="hbm2ddl.auto">update</property>
+    <!-- dbcp connection pool configuration -->
+    <property name="hibernate.dbcp.initialSize">5</property>
+    <property name="hibernate.dbcp.maxTotal">20</property>
+    <property name="hibernate.dbcp.maxIdle">10</property>
+    <property name="hibernate.dbcp.minIdle">5</property>
+    <property name="hibernate.dbcp.maxWaitMillis">-1</property>
+  </session-factory>
+</hibernate-configuration>
+```
+
+### Mapping XML
+
+The following XML maps Redis hashes, which represent students, to a MySQL table:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<hibernate-mapping xmlns="http://www.hibernate.org/xsd/hibernate-mapping"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.hibernate.org/xsd/hibernate-mapping
+    http://www.hibernate.org/xsd/hibernate-mapping/hibernate-mapping-4.0.xsd">
+
+  <class entity-name="Student" table="student">
+          <tuplizer entity-mode="dynamic-map" class="org.hibernate.tuple.entity.DynamicMapEntityTuplizer"/>
+          <id name="id" type="integer" length="50" column="id"/>
+          <property name="firstName" column="first_name" type="string"/>
+          <property name="lastName" column="last_name" type="string"/>
+          <property name="email" column="email" type="string" not-null="true"/>
+          <property name="age" column="age" type="integer"/>
+  </class>
+
+</hibernate-mapping>
+```
+## Commands
+
+Run rghibernate commands with `RG.TRIGGER`:
+
+```sh
+redis-cli RG.TRIGGER SYNC.<COMMAND>
+```
+
+To pass a file to a command like `SYNC.REGISTERCONNECTOR` or `SYNC.REGISTERSOURCE`, use the <nobr>`redis-cli -x`</nobr> option:
+
+```sh
+redis-cli -x RG.TRIGGER SYNC.{COMMAND} {arg1 arg2 ...} < {file}
+```
+
+### Command list
+
+| Command | Description |
+|---------|-------------|
+| [SYNC.REGISTERCONNECTOR](#syncregisterconnector) | Register a new connector |
+| SYNC.UNREGISTERCONNECTOR | Unregister a connector (cannot have sources attached) |
+| [SYNC.REGISTERSOURCE](#syncregistersource) | Extra configuration based on policy |
+| SYNC.UNREGISTERSOURCE | Unregister a source |
+| SYNC.INFO SOURCES | Dump all sources |
+| SYNC.INFO CONNECTORS | Dump all connectors |
+
+### SYNC.REGISTERCONNECTOR
+
+```sh
+$ redis-cli -x RG.TRIGGER SYNC.REGISTERCONNECTOR \
+    {connector name} {batch size} {timeout} {retry interval} \
+    < {connector xml}
+```
+
+| Name | Description |
+|------|-------------|
+| connector name | Name to give to your connector |
+| batch size | The size of the data sent to the backend in batches |
+| timeout | After this timeout, sends data to the backend even if the batch size was not reached |
+| retry interval | Retry interval on error |
+| connector xml | Hibernate XML definition of the connector |
+
+### SYNC.REGISTERSOURCE
+
+```sh
+redis-cli -x RG.TRIGGER SYNC.REGISTERSOURCE \
+    {source name} {connector name} {policy} \
+    < {mapping xml}
+```
+
+| Name | Description |
+|------|-------------|
+| source name | Name to give to your source |
+| connector name | Connector to send the data to |
+| policy | WriteBehind/WriteThrough/ReadThrough: <br></br>• On WriteThrough, an extra argument is WriteTimeout <br></br>• On ReadThrough, an extra argument is expire (0 for no expire) |
+| mapping xml | Hibernate XML definition of the mapping |
+
+---
+Title: Java-based RedisGears recipes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Recipes
+toc: 'false'
+weight: 70
+---
+
+A RedisGears recipe is a collection of RedisGears functions, often designed to perform a specific, complex task.
+
+{{<table-children columnNames="Recipe,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}---
+Title: RG.JDUMPSESSIONS
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Outputs information about existing Java sessions.
+linkTitle: RG.JDUMPSESSIONS
+weight: 40
+---
+
+```sh
+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.
+{{</note>}}
+
+## 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.
+
+## Examples
+
+Get information for all sessions:
+
+```sh
+> redis-cli RG.JDUMPSESSIONS
+1)  1) "mainClass"
+    2) "gears_experiments.test"
+    3) "version"
+    4) (integer) 1
+    5) "description"
+    6) "foo"
+    7) "upgradeData"
+    8) (nil)
+    9) "jar"
+   10) "/home/user/work/RedisGears/plugins/jvmplugin/-jars/6876b8b78ccfc2ad764edc7ede590f573bd7260b.jar"
+   11) "refCount"
+   12) (integer) 2
+   13) "linked"
+   14) "true"
+   15) "ts"
+   16) "false"
+   17) "registrations"
+   18) 1) "0000000000000000000000000000000000000000-1"
+```
+
+Get more detailed information about a specific session:
+
+```sh
+> redis-cli RG.JDUMPSESSIONS VERBOSE SESSIONS gears_experiments.test
+1)  1) "mainClass"
+    2) "gears_experiments.test"
+    3) "version"
+    4) (integer) 1
+    5) "description"
+    6) "foo"
+    7) "upgradeData"
+    8) (nil)
+    9) "jar"
+   10) "/home/user/work/RedisGears/plugins/jvmplugin/-jars/6876b8b78ccfc2ad764edc7ede590f573bd7260b.jar"
+   11) "refCount"
+   12) (integer) 2
+   13) "linked"
+   14) "true"
+   15) "ts"
+   16) "false"
+   17) "registrations"
+   18) 1)  1) "id"
+           2) "0000000000000000000000000000000000000000-1"
+           3) "reader"
+           4) "CommandReader"
+           5) "desc"
+           6) (nil)
+           7) "RegistrationData"
+           8)  1) "mode"
+               2) "async"
+               3) "numTriggered"
+               4) (integer) 0
+               5) "numSuccess"
+               6) (integer) 0
+               7) "numFailures"
+               8) (integer) 0
+               9) "numAborted"
+              10) (integer) 0
+              11) "lastRunDurationMS"
+              12) (integer) 0
+              13) "totalRunDurationMS"
+              14) (integer) 0
+              15) "avgRunDurationMS"
+              16) "-nan"
+              17) "lastError"
+              18) (nil)
+              19) "args"
+              20) 1) "trigger"
+                  2) "test"
+                  3) "inorder"
+                  4) (integer) 0
+           9) "ExecutionThreadPool"
+          10) "JVMPool"
+```
+
+---
+Title: RG.JEXECUTE
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Executes a Java function.
+linkTitle: RG.JEXECUTE
+weight: 40
+---
+
+```sh
+RG.JEXECUTE <path.to.main.class> [UPGRADE] <JAR file>
+```
+
+Executes a Java function.
+
+The code runs immediately if it uses [`GearsBuilder.run()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/run" >}}). Code that uses [`GearsBuilder.register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/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()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/run" >}}), it returns the output of the executed code.
+
+For registered code, it returns the string "`OK`" instead.
+
+## Examples
+
+The executed code in this example [runs]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/run" >}}) immediately:
+
+```sh
+$ redis-cli -x RG.JEXECUTE com.domain.packagename.Reviews < /tmp/rgjvmtest-0.0.1-SNAPSHOT.jar
+1) 1) "3.6666666666666665"
+2) (empty array)
+```
+
+This example [registers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}}) the RedisGears code to run every time certain database events occur:
+
+```sh
+$ redis-cli -x RG.JEXECUTE com.domain.packagename.App < /tmp/rgjvmtest-0.0.1-SNAPSHOT.jar
+OK
+```
+
+Here's an example of how to upgrade registered code to a new version:
+
+```sh
+$ redis-cli -x RG.JEXECUTE com.domain.packagename.App UPGRADE < /tmp/rgjvmtest-0.0.2-SNAPSHOT.jar
+OK
+```---
+Title: RedisGears JVM commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Commands
+toc: 'false'
+weight: 40
+---
+
+Use a Redis client like `redis-cli` to send commands to the RedisGears JVM plugin.
+
+## JVM plugin commands
+
+{{<table-children columnNames="Command,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+
+{{<note>}}
+Ignore any commands that start with `RG.PY` while using the JVM plugin. The `RG.PY` commands are for the Python plugin.
+{{</note>}}---
+Title: RedisGears JVM plugin
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: The RedisGears JVM plugin allows you to run RedisGears functions in the
+  Java virtual machine.
+hideListLinks: true
+linkTitle: Run with JVM
+weight: 75
+---
+
+With the [RedisGears JVM plugin](https://github.com/RedisGears/JVMPlugin), you can write RedisGears functions in [Java](https://en.wikipedia.org/wiki/Java_(programming_language)) and run them on a [Redis Enterprise]({{< relref "/operate/rs/" >}}) cluster. It currently supports [JVM](https://en.wikipedia.org/wiki/Java_virtual_machine) version 11.
+
+Similar to the Python plugin, the JVM plugin allows both batch processing and event-driven processing.
+
+Before you can run RedisGears with Java, you will need to [install the RedisGears module and the JVM plugin]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears#install-redisgears" >}}) on your Redis Enterprise cluster and [enable them for your database]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/install" >}}).
+
+Once you have written your code, compile and package it into a [JAR](https://en.wikipedia.org/wiki/JAR_(file_format)) file and upload it to a node on your Redis Enterprise cluster. Use the `RG.JEXECUTE` command with the `redis-cli` command-line tool to run your code.
+
+## More info
+
+- [RedisGears JVM quick start]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/quickstart" >}})
+- [RedisGears Java classes and functions]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes" >}})
+- [RedisGears recipes]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/recipes" >}})---
+Title: Install RedisGears
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Install
+weight: 60
+---
+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]({{< relref "/operate/rs/clusters/new-cluster-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.
+
+Offline installation requires you to manually upload dependencies to the primary node.
+
+### Install RedisGears and dependencies
+
+1. Download the **RedisGears** package from the Redis Enterprise [download center](https://cloud.redis.io/#/rlec-downloads).
+
+    {{<note>}}
+For offline installation of RedisGears v1.2 and later, you also need to download the **RedisGears Dependencies** packages for both Python and Java.
+<br/>
+For RedisGears v1.0, you only need the Python dependency package.
+    {{</note>}}
+
+1. Upload the RedisGears package to a node in the cluster.
+
+1. For offline installation only, copy the dependencies to the primary node.
+
+    {{<note>}}
+Skip this step unless your cluster does not have internet access.
+    {{</note>}}
+
+    1. For versions 7.2.4 and later, copy the dependencies to `$modulesdatadir/rg/<version-integer>/<OS_name>/<architecture>/deps/`:
+
+        ```sh
+        cp redisgears-jvm.<OS>.<version>.tgz $modulesdatadir/rg/<version-integer>/<OS_name>/<architecture>/deps/
+        ```
+
+    1. For versions 6.4.2 and earlier, copy the dependencies to `$modulesdatadir/rg/<version-integer>/deps/`:
+    
+        ```sh
+        cp redisgears-jvm.<OS>.<version>.tgz $modulesdatadir/rg/<version-integer>/deps/
+        ```
+
+    Replace these fields with your own values:
+
+    - `<OS>`: the operating system running Redis Enterprise
+    - `<version>`: the RedisGears version `(x.y.z)`
+    - `<version-integer>`: the RedisGears version as an integer, calculated as <nobr>`(x*10000 + y*100 + z)`</nobr>
+
+        For example, the `<version-integer>` for RedisGears version 1.2.5 is 10205.
+
+    - `<OS_name>`: the operating system's name
+    - `<architecture>`: the node's architecture
+
+1. Add RedisGears to the cluster with a `POST` request to the primary node's [`/v2/modules`]({{< relref "/operate/rs/references/rest-api/requests/modules#post-module-v2" >}}) REST API endpoint:
+
+    ```sh
+    POST https://[host][:port]/v2/modules
+    {"module=@/tmp/redisgears.<OS>.<version>.zip"}
+    ```
+
+Here, the *module* parameter specifies the full path of the module package and must be submitted as form-data. In addition, the package must be available and accessible to the server processing the request.
+
+After the install is complete, RedisGears will appear in the list of available modules on the **settings** and **create database** pages of the Redis Enterprise admin console.
+
+### Enable RedisGears for a database
+
+After installation, create a new database and enable RedisGears:
+
+- [With Python]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/install" >}})
+
+- [With the JVM]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/install" >}})
+
+## Uninstall RedisGears
+
+To uninstall RedisGears, make a [`DELETE` request to the `/v2/modules` REST API endpoint]({{< relref "/operate/rs/references/rest-api/requests/modules#delete-module-v2" >}}).
+---
+Title: Gears
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisGears supports batch and event-driven processing for Redis data.
+hideListLinks: true
+linkTitle: Gears
+weight: 70
+---
+## What is RedisGears?
+
+RedisGears is an engine for data processing in Redis. RedisGears supports batch and event-driven processing for Redis data. To use RedisGears, you write functions that describe how your data should be processed. You then submit this code to your Redis deployment for remote execution.
+
+## Supported languages
+
+As of RedisGears v1.2, you can enable a plugin to select which programming language to use. It currently supports code written in either [Python]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python" >}}) or [Java]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm" >}}).
+
+Prior to v1.2, RedisGears only supported Python. However, an internal C API exists and can be used by other Redis modules. Support for other languages is being planned.
+
+## Getting started with RedisGears
+
+RedisGears is implemented by a Redis module. To use RedisGears, you'll need to make sure that your Redis deployment has the module installed. [Redis Enterprise Software](https://docs.redislabs.com/latest/rs/) supports the module natively.
+
+If you're running Redis Open Source, you'll also need to [install the RedisGears module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears" >}}) before using it.
+
+To get started with RedisGears, see the quick start tutorial for [Python]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/quickstart" >}}) or [Java]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/quickstart" >}}).
+
+## Write-behind caching patterns
+
+Redis users typically implement caching by using the look-aside pattern. However, with RedisGears, you can implement write-behind caching strategies as well.
+
+Redis publishes RedisGears recipes to support write-behind. You can learn how to use these recipes in our write-behind caching guides for [Python]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/python/recipes/write-behind" >}}) and [Java]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/recipes/write-behind" >}}).
+
+## More info
+
+- [RedisGears source](https://github.com/RedisGears/RedisGears)
+---
+Title: Register events
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Register RedisGears functions to run when certain events occur in a Redis
+  database.
+linkTitle: Register events
+toc: 'true'
+weight: 80
+---
+
+You can register RedisGears functions to run when certain events occur in a Redis database.
+
+## Register on events
+
+To register RedisGears functions to run on an event, your code needs to:
+
+1. Pass `KeysReader` to a `GearsBuilder` object.
+
+1. Call the `GearsBuilder.register()` function.
+
+1. Pass the `eventTypes` parameter to either:
+
+    - The `register` function for Python.
+    
+    - The `KeysReader` object for Java.
+
+For more information and examples of event registration, see:
+
+- Java references:
+
+    - [`KeysReader`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/readers/keysreader" >}})
+
+    - [`GearsBuilder.register()`]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm/classes/gearsbuilder/register" >}})
+
+## Event types
+
+For the list of event types you can register on, see the [Redis keyspace notification documentation]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands).
+
+## Active-Active event types
+
+In addition to standard Redis [events]({{< relref "/develop/use/keyspace-notifications" >}}#events-generated-by-different-commands), [Redis Enterprise Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) also support the registration of RedisGears functions for the following event types:
+
+- `change`: This event occurs when a key changes on another replica of the Active-Active database.
+---
+Title: Module lifecycle
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Module lifecycle
+weight: 7
+---
+Redis Enterprise Software follows the [Redis Enterprise lifecycle]({{< relref "/operate/rs/installing-upgrading/product-lifecycle" >}}).  (For complete details, see the Redis Enterprise Software [subscription agreement](https://redis.com/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.
+
+The format is “Major1.Major2.Minor”.
+
+- Major sections of the version number represent fundamental changes to functionality and feature capabilities. The _Major1_ and _Major2_ part of the version number are incremented according to the size and scale of the changes in each release.
+
+- The _Minor_ section of the version number represents quality improvements and fixes to existing capabilities.  The minor release number is increased when release quality improves.
+
+## Module end-of-life schedule {#modules-endoflife-schedule}
+
+End-of-Life for a given Major version is 18 months after the formal release of
+that version or 12 months after the release of the next subsequent (following) version, whichever comes last.
+
+### RediSearch
+
+{{< table-csv "redisearch-lifecycle.csv" 2 >}}
+
+### RedisJSON
+
+{{< table-csv "redisjson-lifecycle.csv" 2 >}}
+
+### RedisGraph
+
+{{< table-csv "redisgraph-lifecycle.csv" 2 >}}
+
+### RedisTimeSeries
+
+{{< table-csv "redistimeseries-lifecycle.csv" 2 >}}
+
+### RedisBloom
+
+{{< table-csv "redisbloom-lifecycle.csv" 2 >}}
+
+### RedisGears
+
+{{< table-csv "redisgears-lifecycle.csv" 2 >}}
+---
+Title: Install a module on a cluster
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Install on a cluster
+weight: 10
+---
+
+[Redis Enterprise Software]({{< relref "/operate/rs" >}}) comes packaged with several modules. As of version 7.8.2, Redis Enterprise Software includes three 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.
+
+{{<warning>}}
+- Some module versions are not supported or recommended for use with Redis Enterprise.
+
+- We recommend consulting [Redis support](https://redis.io/support/) before you upgrade a module on the cluster, especially if the cluster is used in production.
+{{</warning>}}
+
+## Get packaged modules
+
+To install or upgrade a module on a [Redis Enterprise Software]({{< relref "/operate/rs" >}}) cluster, you need a module package.
+
+- For versions of official Redis modules that are not available from the [Redis download center](https://redis.io/downloads/), [contact support](https://redis.io/support/).
+
+- For custom-packaged modules, download a [custom-packaged module](https://redislabs.com/community/redis-modules-hub/) from the developer.
+
+## Add a module to a cluster
+
+Use one of the following methods to add a module to a Redis Enterprise cluster:
+
+- REST API [`POST` request to the `/v2/modules`]({{< relref "/operate/rs/references/rest-api/requests/modules#post-module-v2" >}}) endpoint
+
+- Redis Enterprise Cluster Manager UI
+
+- For RedisGears, follow these [installation instructions]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/installing-redisgears" >}})
+
+### REST API method
+
+To add a module to the cluster using the REST API:
+
+1. Copy the module package to a node in the cluster.
+
+1. Add the module to the cluster with a [`POST` request to the `/v2/modules`]({{< relref "/operate/rs/references/rest-api/requests/modules#post-module-v2" >}}) endpoint:
+
+    ```sh
+    POST https://[host][:port]/v2/modules
+    "module=@/tmp/redisearch.Linux-ubuntu16.04-x86_64.2.2.6.zip"
+    ```
+
+    Here, the *module* parameter specifies the full path of the module package and must be submitted as form-data. In addition, the package must be available and accessible to the server processing the request.
+
+1. If the module installation succeeds, the `POST` request returns a [JSON object]({{< relref "/operate/rs/references/rest-api/objects/module" >}}) that represents the new module. If it fails, it may return a JSON object with an `error_code` and `description` with more details.
+
+### Cluster Manager UI method
+
+To add a module to the cluster using the Cluster Manager UI:
+
+1. Go to **Cluster > Modules**.
+
+1. Select **Upload module**.
+
+1. Use the file browser to add the packaged module.
+
+## Next steps
+
+- Create a database and [enable the new module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database" >}}).
+- [Upgrade a module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to the new version.
+---
+Title: Upgrade modules
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Upgrade modules
+weight: 50
+---
+
+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.
+{{</note>}}
+
+## Prerequisites
+
+Before you upgrade a module enabled in a database, [install the new version of the module on the cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}).
+
+## Upgrade a module for a database
+
+After you install an updated module on the cluster, you can upgrade databases to use the new module version.
+
+{{<warning>}}
+After you upgrade the module for a database, the database shards restart. This causes a short interruption in the availability of this database across the cluster.
+{{</warning>}}
+
+To upgrade a module enabled for a database:
+
+1. Connect to the terminal of a node in the cluster.
+1. Run `rladmin status` to list the databases on the node.
+1. Copy the name of the database that uses the module that you want to upgrade.
+
+    {{< image filename="/images/rs/rladmin_status.png" >}}
+
+1. Find the exact module name and version:
+
+    1. Extract the module archive (zip) file.
+    1. Open the JSON file.
+    1. Find the module name and version number in the file.
+
+    Here's an example of the JSON file for the RediSearch module:
+
+    {{< image filename="/images/rs/module_info.png" >}}
+
+1. To see the versions of the modules on the cluster, run either:
+
+    - `rladmin status modules` - Shows the latest modules available on the cluster and the modules used by databases.
+    - `rladmin status modules all` - Shows all of the modules available on the cluster and the modules used by databases.
+
+1. To upgrade a database to the latest version of Redis and its modules to the latest version without changing the module arguments:
+
+    - For clusters with Redis Enterprise Software versions 7.8.2 or later, run:
+
+        ```sh
+        rladmin upgrade db < database-name | database-ID >
+        ```
+
+    - For clusters with versions earlier than 7.8.2, include the `latest_with_modules` option:
+
+        ```sh
+        rladmin upgrade db < database-name | database-ID > latest_with_modules
+        ```
+
+    {{<warning>}}
+The upgrade process does not validate the module upgrade arguments, and incorrect arguments can cause unexpected downtime. Test module upgrade commands in a test environment before you upgrade modules in production. 
+    {{</warning>}}
+
+    - Use `keep_redis_version` to upgrade the modules without upgrading the database to the latest Redis version.
+    
+        `keep_redis_version` is deprecated as of Redis Enterprise Software version 7.8.2. To upgrade modules without upgrading the Redis database version, set `redis_version` to the current Redis database version instead.
+
+    - To specify the modules to upgrade, add the following for each module:
+
+        ```sh
+        and module module_name <module_name> version <new_module_version_number> module_args "<module arguments>"
+        ```
+
+        For the module arguments, use one of the following:
+
+        - `module_args "<module_arguments>"` to replace the existing module arguments.
+
+        - `module_args ""` without arguments to remove the existing module arguments.
+
+        - `module_args keep_args` to use the existing module arguments.
+
+## Examples for Redis Software v7.8.2 and later
+
+The following module upgrade examples are supported for Redis Enterprise Software versions 7.8.2 and later:
+
+- Keep the current Redis database version, which is 7.2 in this example, and upgrade to the latest version of the enabled modules:
+
+    ```sh
+    rladmin upgrade db shopping-cart redis_version 7.2
+    ```
+
+- Upgrade the database to use the latest version of Redis and the latest versions of the enabled modules:
+
+    ```sh
+    rladmin upgrade db shopping-cart
+    ```
+
+## Deprecated examples
+
+As of Redis Enterprise Software version 7.8.2, the following module upgrade examples are deprecated but still supported.
+
+- Keep the current version of Redis and upgrade to the latest version of the enabled modules:
+
+    ```sh
+    rladmin upgrade db shopping-cart keep_redis_version latest_with_modules
+    ```
+
+- Upgrade the database to the latest Redis version and upgrade RediSearch to 1.6.7 with the specified arguments:
+
+    ```sh
+    rladmin upgrade db shopping-cart and module db_name shopping-cart module_name ft version 10607 module_args "PARTITIONS AUTO"
+    ```
+
+- Upgrade the database to the latest Redis version and upgrade RedisBloom to version 2.2.1 without arguments:
+
+    ```sh
+    rladmin upgrade db db:3 and module db_name shopping-cart module_name bf version 20201 module_args ""
+    ```
+
+- Upgrade RedisJSON to 1.0.4 with the existing arguments and RedisBloom to version 2.2.1 without arguments:
+
+    ```sh
+    rladmin upgrade module db_name MyDB module_name ReJSON version 10004 module_args keep_args and module db_name MyDB module_name bf version 20201 module_args ""
+    ```
+
+- Upgrade the database to use the latest version of Redis and use the latest version of the enabled modules:
+
+    ```sh
+    rladmin upgrade db shopping-cart latest_with_modules
+    ```
+---
+Title: Enable a module for a database
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Enable for a database
+toc: 'true'
+weight: 30
+---
+
+Modules add additional functionality to Redis databases for specific use cases. You can enable modules when you create a database.
+
+## Prerequisites
+
+- [Installed the module on the cluster]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}})
+- [Upgraded the module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) to the latest version
+
+## Create a database with a module
+
+{{<note>}}
+You can only add modules to a database when you first create it. You cannot add modules to an existing database.
+{{</note>}}
+
+In the Redis Enterprise Cluster Manager UI, follow these steps to add modules to a database:
+
+1. From the **Databases** screen, select **Quick database** or **Create database**.
+
+1. In the **Capabilities** section, select one or more capabilities:
+
+    {{<image filename="images/rs/screenshots/databases/quick-db-capabilities-7-8-2.png" alt="Select which capabilities to add to your database.">}}
+
+    {{<note>}}
+You cannot use RediSearch 1.x and RediSearch 2.x in the same database.
+    {{</note>}}
+
+1. To use custom configuration for capabilities:
+
+    1. Select **Parameters**.
+    
+    1. Enter the [configuration options](#module-configuration-options).
+    
+    1. Select **Done**.
+
+1. Configure additional database settings.
+
+    {{<note>}}
+Depending on the [features supported by an enabled module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities#module-feature-support" >}}), certain database configuration fields may not be available.
+    {{</note>}}
+
+1. Select **Create**.
+
+## Module configuration options
+
+- [RediSearch configuration options]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/config" >}})
+
+- [RedisTimeSeries configuration options]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries/config" >}})
+
+- [RedisBloom configuration options]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom/config" >}})---
+Title: Install and upgrade modules
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Install and upgrade modules
+weight: 4
+---
+
+Several modules, which provide Redis Stack features, come packaged with [Redis Enterprise Software]({{< relref "/operate/rs" >}}). As of version 7.8.2, Redis Enterprise Software includes three feature sets, compatible with different Redis database versions. However, if you want to use additional modules or upgrade a module to a more recent version, you need to:
+
+1. [Install a module package]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-cluster" >}}) on the cluster.
+1. [Enable a module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database" >}}) for a new database or [upgrade a module]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/upgrade-module" >}}) in an existing database.
+---
+Title: Time series commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Lists time series commands and provides links to the command reference
+  pages.
+linkTitle: Commands
+toc: 'false'
+weight: 25
+---
+
+The following table lists time series commands. See the command links for more information about each command's syntax, arguments, and examples.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [TS.ADD]({{< relref "commands/ts.add" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Appends a sample to a time series. |
+| [TS.ALTER]({{< relref "commands/ts.alter" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Updates the retention, chunk size, duplicate policy, or labels for an existing time series. |
+| [TS.CREATE]({{< relref "commands/ts.create" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Creates a new time series. |
+| [TS.CREATERULE]({{< relref "commands/ts.createrule" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Creates a compaction rule for [downsampling]({{< relref "develop/data-types/timeseries/quickstart#aggregation" >}}). |
+| [TS.DECRBY]({{< relref "commands/ts.decrby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | 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]({{< relref "commands/ts.del" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes all samples between two timestamps for a given time series. |
+| [TS.DELETERULE]({{< relref "commands/ts.deleterule" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes a compaction rule. |
+| [TS.GET]({{< relref "commands/ts.get" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the last sample in a time series. |
+| [TS.INCRBY]({{< relref "commands/ts.incrby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | 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]({{< relref "commands/ts.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns time series information and statistics. |
+| [TS.MADD]({{< relref "commands/ts.madd" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Appends multiple samples to one or more time series. |
+| [TS.MGET]({{< relref "commands/ts.mget" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns multiple samples with [labels]({{< relref "develop/data-types/timeseries/quickstart#labels" >}}) that match the filter. |
+| [TS.MRANGE]({{< relref "commands/ts.mrange" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | For multiple time series, runs a query against samples within a range of timestamps, from earliest to latest. Supports [filtering]({{< relref "/develop/data-types/timeseries/quickstart" >}}#filtering) and [aggregation]({{< relref "/develop/data-types/timeseries/quickstart" >}}#aggregation). |
+| [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | For multiple time series, runs a query against samples within a range of timestamps in reverse order, from latest to earliest. Supports [filtering]({{< relref "/develop/data-types/timeseries/quickstart" >}}#filtering) and [aggregation]({{< relref "/develop/data-types/timeseries/quickstart" >}}#aggregation). |
+| [TS.QUERYINDEX]({{< relref "commands/ts.queryindex" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the keys of all time series with [labels]({{< relref "/develop/data-types/timeseries/quickstart" >}}#labels) that match the given filters. |
+| [TS.RANGE]({{< relref "commands/ts.range" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | From the start of a single time series, runs a query against samples within a range of timestamps. Supports [filtering]({{< relref "/develop/data-types/timeseries/quickstart" >}}#filtering) and [aggregation]({{< relref "/develop/data-types/timeseries/quickstart" >}}#aggregation). |
+| [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | From the end of a single time series, runs a query against samples within a range of timestamps in reverse order. Supports [filtering]({{< relref "/develop/data-types/timeseries/quickstart" >}}#filtering) and [aggregation]({{< relref "/develop/data-types/timeseries/quickstart" >}}#aggregation). |
+---
+Title: Time series configuration compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Time series configuration settings supported by Redis Enterprise Software and Redis Cloud.
+linkTitle: Configuration
+toc: 'false'
+weight: 30
+---
+
+## Configure time series in Redis Software
+
+[Redis Enterprise Software]({{< relref "/operate/rs" >}}) lets you manually change any [RedisTimeSeries configuration setting]({{< relref "/develop/data-types/timeseries/" >}}configuration/#redistimeseries-configuration-parameters).
+
+To change RedisTimeSeries configuration using the Redis Software Cluster Manager UI:
+
+  1. From the **Databases** list, select the database, then click **Configuration**.
+
+  1. Select the **Edit** button.
+
+  1. In the **Capabilities** section, click **Parameters**.
+
+  1. After you finish editing the module's configuration parameters, click **Done** to close the parameter editor.
+
+  1. Click **Save**.
+
+## Configure time series in Redis Cloud
+
+[Redis Cloud]({{< relref "/operate/rc" >}}) does not let you configure RedisTimeSeries manually. However, if you have a Flexible or Annual [subscription]({{< relref "/operate/rc/subscriptions" >}}), you can contact [support](https://redis.com/company/support/) to request a configuration change. You cannot change RedisTimeSeries configuration for Free or Fixed subscriptions.
+
+## Configuration settings
+
+See [configuration parameters]({{< relref "/develop/data-types/timeseries/configuration" >}}) in the Develop section for parameter details and compatibility with Redis Software and Redis Cloud.
+---
+Title: Time series
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Time series
+weight: 50
+---
+You can manage time series data in Redis Enterprise with Redis Open Source.
+
+## Features
+
+- Query by start time and end-time
+- Query by labels sets
+- Aggregated queries (Min, Max, Avg, Sum, Range, Count, First, Last) for any time bucket
+- Configurable max retention period
+- Compaction/Roll-ups - automatically updated aggregated time series
+- labels index - each key has labels which allows query by labels
+
+## Memory model
+
+A time series is a linked list of memory chunks.
+Each chunk has a predefined size of samples.
+Each sample is a tuple of the time and the value of 128 bits,
+64 bits for the timestamp and 64 bits for the value.
+
+## Time series capabilities
+
+Redis Open Source provides a new data type that uses chunks of memory of fixed size for time series samples, indexed by the same Radix Tree implementation as Redis streams. With streams, you can create [a capped stream]({{< relref "/develop/data-types/streams/#capped-streams" >}}), effectively limiting the number of messages by count. For time series, you can apply a retention policy in milliseconds. This is better for time series use cases, because they are typically interested in the data during a given time window, rather than a fixed number of samples.
+
+### Downsampling/compaction
+
+| Before Downsampling | After Downsampling |
+| --- | --- |
+| {{< image filename="/images/rs/TimeSeries-downsampling1.png" >}} | {{< image filename="/images/rs/TimeSeries-downsampling2.png" >}} |
+
+If you want to keep all of your raw data points indefinitely, your data set grows linearly over time. However, if your use case allows you to have less fine-grained data further back in time, downsampling can be applied. This allows you to keep fewer historical data points by aggregating raw data for a given time window using a given aggregation function. Time series support [downsampling]({{< relref "develop/data-types/timeseries/quickstart#aggregation" >}}) with the following aggregations: avg, sum, min, max, range, count, first, and last.  
+
+### Secondary indexing
+
+When using Redis’ core data structures, you can only retrieve a time series by knowing the exact key holding the time series. Unfortunately, for many time series use cases (such as root cause analysis or monitoring), your application won’t know the exact key it’s looking for. These use cases typically want to query a set of time series that relate to each other in a couple of dimensions to extract the insight you need. You could create your own secondary index with core Redis data structures to help with this, but it would come with a high development cost and require you to manage edge cases to make sure the index is correct.
+
+Redis does this indexing for you based on `field value` pairs called [labels]({{< relref "develop/data-types/timeseries/quickstart#labels" >}}). You can add labels to each time series and use them to [filter]({{< relref "develop/data-types/timeseries/quickstart#filtering" >}}) at query time.
+
+Here’s an example of creating a time series with two labels (sensor_id and area_id are the fields with values 2 and 32 respectively) and a retention window of 60,000 milliseconds:
+
+```sh
+    TS.CREATE temperature RETENTION 60000 LABELS sensor_id 2 area_id 32
+```
+
+### Aggregation at read time
+
+When you need to query a time series, it’s cumbersome to stream all raw data points if you’re only interested in, say, an average over a given time interval. Time series only transfer the minimum required data to ensure lowest latency.
+
+Here's an example of [aggregation]({{< relref "develop/data-types/timeseries/quickstart#aggregation" >}}) over time buckets of 5,000 milliseconds:  
+
+```sh
+    127.0.0.1:12543> TS.RANGE temperature:3:32 1548149180000 1548149210000 AGGREGATION avg 5000
+    1) 1) (integer) 1548149180000
+       2) "26.199999999999999"
+    2) 1) (integer) 1548149185000
+       2) "27.399999999999999"
+    3) 1) (integer) 1548149190000
+       2) "24.800000000000001"
+    4) 1) (integer) 1548149195000
+       2) "23.199999999999999"
+    5) 1) (integer) 1548149200000
+       2) "25.199999999999999"
+    6) 1) (integer) 1548149205000
+       2) "28"
+    7) 1) (integer) 1548149210000
+       2) "20"
+```
+
+### Integrations
+
+Redis Open Source comes with several integrations into existing time series tools. One such integration is our [RedisTimeSeries adapter](https://github.com/RedisTimeSeries/prometheus-redistimeseries-adapter) for [Prometheus](https://prometheus.io/), which keeps all your monitoring metrics inside time series while leveraging the entire [Prometheus ecosystem](https://prometheus.io/docs/prometheus/latest/storage/#remote-storage-integrations).
+
+{{< image filename="/images/rs/TimeSeries-integrations.png" >}}
+
+Furthermore, we also created direct integrations for [Grafana](https://github.com/RedisTimeSeries/grafana-redistimeseries). [This repository](https://github.com/RedisTimeSeries/prometheus-demos) contains a docker-compose setup of RedisTimeSeries, its remote write adaptor, Prometheus and [Grafana](https://grafana.com/). It also comes with a set of data generators and pre-built Grafana dashboards.
+
+## Time series modeling approaches with Redis
+
+### Data modeling approaches
+
+Redis streams allow you to add several field value pairs in a message for a given timestamp. For each device, we collected 10 metrics that were modeled as 10 separate fields in a single stream message.
+
+{{< image filename="/images/rs/TimeSeries-modeling1.png" >}}
+
+For sorted sets, we modeled the data in two different ways. For “Sorted set per device”, we concatenated the metrics and separated them out by colons, e.g. `“<timestamp>:<metric1>:<metric2>: … :<metric10>”`.
+
+{{< image filename="/images/rs/TimeSeries-modeling2.png" >}}
+
+Of course, this consumes less memory but needs more CPU cycles to get the correct metric at read time. It also implies that changing the number of metrics per device isn’t straightforward, which is why we also benchmarked a second sorted set approach. In “Sorted set per metric,” we kept each metric in its own sorted set and had 10 sorted sets per device. We logged values in the format `“<timestamp>:<metric>”`.
+
+{{< image filename="/images/rs/TimeSeries-modeling3.png" >}}
+
+Another alternative approach would be to normalize the data by creating a hash with a unique key to track all measurements for a given device for a given timestamp. This key would then be the value in the sorted set. However, having to access many hashes to read a time series would come at a huge cost during read time, so we abandoned this path.
+
+Each time series holds a single metric. We chose this design to maintain the Redis principle that a larger number of small keys is better than a fewer number of large keys.
+
+{{< image filename="/images/rs/TimeSeries-modeling4.png" >}}
+
+Our benchmark did not utilize the out-of-the-box secondary indexing capabilities of time series. Redis keeps a partial secondary index in each shard, and since the index inherits the same hash-slot of the key it indexes, it is always hosted on the same shard. This approach would make the setup for native data structures even more complex to model, so for the sake of simplicity, we decided not to include it in our benchmarks. Additionally, while Redis Enterprise can use the [proxy](https://redis.com/redis-enterprise/technology/redis-enterprise-cluster-architecture/) to fan out requests for commands like [TS.MGET]({{< relref "commands/ts.mget" >}}) and [TS.MRANGE]({{< relref "commands/ts.mrange" >}}) to all the shards and aggregate the results, we chose not to exploit this advantage in the benchmark either.
+
+### Data ingestion
+
+For the data ingestion part of our benchmark, we compared the four approaches by measuring how many devices’ data we could ingest per second. Our client side had 8 worker threads with 50 connections each, and a pipeline of 50 commands per request.
+
+Ingestion details of each approach:
+
+|                         | **Redis streams** | **Time series** | **Sorted set<br/>per device** | **Sorted set<br/>per metric** |
+| ----------------------- | ----------------- | ------------------- | ----------------------------- | ----------------------------- |
+| **Command**             | XADD              | TS.MADD             | ZADD                          | ZADD                          |
+| **Pipeline**            | 50                | 50                  | 50                            | 50                            |
+| **Metrics per request** | 5000              | 5000                | 5000                          | 500                           |
+| **# keys**              | 4000              | 40000               | 4000                          | 40000                         |
+
+{{< image filename="/images/rs/TimeSeries-DataIngestion.png" >}}
+
+All our ingestion operations were executed at sub-millisecond latency. Although both used the same Rax data structure, the time series approach has slightly higher throughput than Redis streams.
+
+Each approach yields different results, which shows the value of prototyping against specific use cases. As we see on query performance, the sorted set per device comes with improved write throughput but at the expense of query performance. It’s a trade off between ingestion, query performance, and flexibility (remember the earlier data modeling remark).
+
+### Read performance
+
+The read query we used in this benchmark queried a single time series and aggregated it in one-hour time buckets by keeping the maximum observed CPU percentage in each bucket. The time range we considered in the query was exactly one hour, so a single maximum value was returned. For time series, this is out of the box functionality.  
+
+```sh
+    127.0.0.1:12543> TS.RANGE cpu_usage_user{1340993056} 1451606390000 1451609990000 AGGREGATION max 3600000
+```
+
+For the Redis streams and sorted sets approaches, we created [the following LUA scripts](https://gist.github.com/itamarhaber/0107020b91c71cb52e57e9a9c890c24e). The client once again had 8 threads and 50 connections each. Since we executed the same query, only a single shard was hit, and in all four cases this shard maxed out at 100% CPU.
+
+{{< image filename="/images/rs/TimeSeries-ReadQueries.png" >}}
+
+This is where you can see the real power of having dedicated data structure for a given use case with a toolbox that runs alongside it. Using time series exceeds all other approaches and is the only one to achieve sub-millisecond response times.
+
+### Memory utilization
+
+For both the Redis streams and sorted set approaches, the samples were stored as strings, while time series stored them as doubles. In this specific data set, we chose a CPU measurement with rounded integer values between 0-100, which thus consumes two bytes of memory as a string. With time series, each metric had 64-bit precision.
+
+Time series can dramatically reduce the memory consumption when compared against both sorted set approaches. Given the unbounded nature of time series data, this is typically a critical criteria to evaluate - the overall data set size that needs to be retained in memory. Redis streams reduces the memory consumption further but would be equal or higher than time series when more digits for a higher precision would be required.
+
+{{< image filename="/images/rs/TimeSeries-UsedMemory.png" >}}
+
+## More info
+
+- [Time series quick start]({{< relref "/develop/data-types/timeseries/quickstart" >}})
+- [Time series commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries/commands" >}})
+- [Time series configuration]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries/config" >}})
+- [RedisTimeSeries source](https://github.com/RedisTimeSeries/RedisTimeSeries)
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How triggers and functions can be used
+linkTitle: Examples
+title: Triggers and functions examples
+weight: 7
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/examples/
+---
+
+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. 
+
+Using keyspace and Stream triggers to capture events and execute the desired JavaScript functions requires few lines of code to enrich applications with new behaviors. The following examples show how typical problems are solved with JavaScript.
+
+
+## Auditing and logging
+
+Redis Triggers can be used to detect changes to specific data structures, and log an auditing trail in the Redis log. The timestamp of the latest change can be updated in the same function.
+
+```javascript
+function alertUserChanged(client, data) {
+    // detect the event and log an audit trail
+    if (data.event == 'hset'){
+        redis.log('User data changed: ' + data.key);
+    }
+    else if (data.event == 'del'){
+        redis.log('User deleted: ' + data.key);
+    }
+
+    var curr_time = client.call("time")[0];
+
+    // add the current timestamp to the Hash
+    client.call('hset', data.key, 'last', curr_time);
+}
+
+redis.registerKeySpaceTrigger('alert_user_changed', 'user:', 
+    alertUserChanged, {description: 'Report user data change.'});
+```
+
+
+## Enrich and transform data
+
+Data can be extracted, enriched or transformed, and loaded again. As an example, upon insertion of a document in a Hash data structure, a Trigger can launch the execution of a Function that computes the number of words in the text (in the example, a simple tokenization is presented but the logic can be as complex as required). The counter is finally stored in the same Hash together with the original document. 
+
+```javascript
+function wordsCounter(client, data){
+    text = client.call('hget', data.key, 'content');
+    words = text.split(' ').length;
+    client.call('hset', data.key, 'cnt', words.toString());
+    redis.log('Number of words: ' + words.toString()); //This log is for demo purposes, be aware of spamming the log file in production
+}
+
+redis.registerKeySpaceTrigger('words_counter', 'doc:', 
+    wordsCounter, {description: 'Count words in a document.'});
+```
+
+
+## Batch operations
+
+JavaScript functions can be executed when required, for example as part of scheduled or periodic maintenance routines. An example could be deleting data identified by the desired pattern. 
+
+
+```javascript
+#!js api_version=1.0 name=utils
+
+
+redis.registerAsyncFunction('del_keys', async function(async_client, pattern){
+    var count = 0;
+    var cursor = '0';
+    do {
+        async_client.block((client)=>{
+            var res = client.call('scan', cursor, 'match', pattern);
+            cursor = res[0];
+            var keys = res[1];
+            keys.forEach((key) => {
+                client.call('del', key);
+            });
+        });
+    } while(cursor != '0');
+    return count;
+});
+```
+
+The function `del_keys` performs an asynchronous batch scan of all the keys in the database matching the desired pattern, and enters a blocking section where it gets partial results. The asynchronous design of this function permits non-blocking execution, so other clients will not starve while the iteration is performed on a keyspace of arbitrary size. The function can be invoked as follows.
+
+```text
+TFCALLASYNC utils.del_keys 0 "user:*"
+```
+
+## Automatic expiration
+
+Sometimes it is useful to enforce expiration time for data that by nature is short-lived. An example could be session data, or authentication tokens. A trigger fits the use case and can execute a function that sets the desired TTL.
+
+
+```javascript
+function automaticSessionExpiry(client, data){
+    client.call('expire', data.key, '3600');
+    redis.log('Session ' + data.key + ' has been automatically expired'); //This log is for demo purposes, be aware of spamming the log file in production
+}
+
+redis.registerKeySpaceTrigger('automaticSessionExpiry', 'session:', 
+    automaticSessionExpiry, {description: 'Set the session TTL to one hour.'});
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get started with triggers and functions using Redis Insight
+linkTitle: Quick start (Redis Insight)
+title: Quick start using Redis Insight
+weight: 1
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/quick_start_cli/
+---
+
+Make sure that you have [Redis Stack installed]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) and running. Alternatively, you can create a [free Redis Cloud account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users).
+
+If you haven't already installed Redis Insight, you can download the latest version [here](https://redis.com/redis-enterprise/redis-insight/?_ga=2.232184223.127667221.1704724457-86137583.1685485233&_gl=1*1gygred*_ga*ODYxMzc1ODMuMTY4NTQ4NTIzMw..*_ga_8BKGRQKRPV*MTcwNDkyMzExMC40MDEuMS4xNzA0OTI3MjQ2LjUyLjAuMA..*_gcl_au*MTQzODY1OTU4OS4xNzAxMTg0MzY0). If this is your first time using Redis Insight, you may wish to read through the [Redis Insight guide]({{< relref "/develop/tools/insight" >}}) 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.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-0.png" >}}
+
+## Load a library
+
+Click on the triggers and functions icon and then on **+ Library** as shown below.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-1.png" >}}
+
+Add your code to the **Library Code** section of the right-hand panel and then click **Add Library**.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-2.png" >}}
+
+You'll see the following when the library was added:
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-3.png" >}}
+
+The `TFCALL` command is used to execute the JavaScript Function. If the command fails, an error will be returned. Click on the **>_ CLI**  button in the lower left-hand corner to open a console window and then run the command shown below.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-3a.png" >}}
+
+To update a library you can edit the library code directly in the interface by clicking on the edit (pencil) icon. When you save your changes, the libary will be reloaded.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-4.png" >}}
+
+## Uploading an external file
+
+Click on the **+ Add Library** button as before and, instead of adding the code directly into the editor, click on the **Upload** button, select the file from your file browser, and then click on **Add Library**. The file needs to contain the header, which contains the engine identifier, the API version, and the library name: `#!js api_version=1.0 name=myFirstLibrary`.
+
+{{< image filename="/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/images/tf-rdi-5.png" >}}
+
+## Creating triggers
+
+Functions within Redis can respond to events using keyspace triggers. While the majority of these events are initiated by command invocations, they also include events that occur when a key expires or is removed from the database.
+
+For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}).
+
+The following code creates a new keyspace trigger that adds a new field to a new or updated hash with the latest update time.
+
+```javascript
+#!js name=myFirstLibrary api_version=1.0
+
+function addLastUpdatedField(client, data) {
+    if(data.event == 'hset') {
+        var currentDateTime = Date.now();
+        client.call('hset', data.key, 'last_updated', currentDateTime.toString());
+    }
+} 
+
+// Register the KeySpaceTrigger 'AddLastUpdated' for keys with the prefix 'fellowship'
+// with the callback function 'addLastUpdatedField'.
+redis.registerKeySpaceTrigger('addLastUpdated', 'fellowship:', addLastUpdatedField);"
+```
+
+Update the existing library as before and then, using the Redis Insight console, add a new hash with the required prefix to trigger the function.
+
+```Shell
+> HSET fellowship:1 name "Frodo Baggins" title "The One Ring Bearer"
+```
+
+Run the [`HGETALL`]({{< relref "/commands/hgetall" >}}) command to check if the last updated time is added to the example.
+
+```Shell
+> HGETALL fellowship:1
+1) "name"
+2) "Frodo Baggins"
+3) "title"
+4) "The One Ring Bearer"
+5) "last_updated"
+6) "1693238681822"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Configure the operation parameters
+linkTitle: Configuration
+title: Configuration
+weight: 3
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/configuration/
+---
+
+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`]({{< relref "/commands/module-loadex" >}}) command. Each configuration must be prefixed with the module name, `redisgears_2.<configuration name>`.
+
+## Runtime configuration
+
+You may set certain configuration options at runtime. Setting a configuration at runtime is done using [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command. Here each configuration must be prefixed with the module name, `redisgears_2.<configuration name>`.
+
+Example:
+
+```bash
+> config set redisgears_2.lock-redis-timeout 1000
+OK
+```
+
+## Configurations
+
+### execution-threads
+
+The `execution-threads` configuration option controls the number of background threads that run JS code. **Note that libraries are considered single threaded**. This configuration allows Redis to parallelize the invocation of multiple libraries.
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+1
+
+_Minimum Value_
+
+1
+
+_Maximum Value_
+
+32
+
+_Runtime Configurability_
+
+No
+
+### library-fatal-failure-policy
+
+The `library-fatal-failure-policy` configuration option controls how to handle a fatal error. A fatal error is consider one of the following:
+
+* Block timeout - The function blocks the Redis processes for too long (configurable using the [lock-redis-timeout](#lock-redis-timeout) configuration value)
+* OOM - The function consumes too much memory (configurable using the [v8-maxmemory](#v8-maxmemory) configuration value).
+
+This configuration basically allows choosing between two options:
+
+* Do not break atomicity property, even at the cost of killing the Redis processes.
+* Keep my Redis processes alive, even at the cost of losing atomicity.
+
+_Expected Value_
+
+* kill - Save the atomicity property. Risk of killing the Redis processes.
+* abort - Abort the invocation of the function and keep the Redis processes alive. Risk of losing the atomicity property.
+
+_Default_
+
+abort
+
+_Runtime Configurability_
+
+Yes
+
+### v8-maxmemory
+
+The `v8-maxmemory` configuration option controls the maximum amount of memory used by all V8 libraries. Exceeding this limit is considered a fatal error and will be handled base on the [library-fatal-failure-policy](#library-fatal-failure-policy) configuration value.
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+200M
+
+_Minimum Value_
+
+50M
+
+_Maximum Value_
+
+1G
+
+_Runtime Configurability_
+
+No
+
+### v8-library-initial-memory-usage
+
+The `v8-library-initial-memory-usage` configuration option controls the initial memory given to a single V8 library. This value can not be greater then [`v8-library-initial-memory-limit`](#v8-library-initial-memory-limit) or [v8-maxmemory](#v8-maxmemory).
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+2M
+
+_Minimum Value_
+
+1M
+
+_Maximum Value_
+
+10M
+
+_Runtime Configurability_
+
+No
+
+### v8-library-initial-memory-limit
+
+The `v8-library-initial-memory-limit` configuration option controls the initial memory limit on a single V8 library. This value can not be greater then [v8-maxmemory](#v8-maxmemory).
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+3M
+
+_Minimum Value_
+
+2M
+
+_Maximum Value_
+
+20M
+
+_Runtime Configurability_
+
+No
+
+### v8-library-memory-usage-delta
+
+The `v8-library-memory-usage-delta` configuration option controls the delta by which we will increase the V8 library memory limit once the limit reached. This value can not be greater then [v8-maxmemory](#v8-maxmemory).
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+1M
+
+_Minimum Value_
+
+1M
+
+_Maximum Value_
+
+10M
+
+_Runtime Configurability_
+
+No
+
+### lock-redis-timeout
+
+The `lock-redis-timeout` configuration option controls the maximum amount of time (in MS) a library can lock Redis. Exceeding this limit is considered a fatal error and will be handled based on the [library-fatal-failure-policy](#library-fatal-failure-policy) configuration value. This
+configuration only affects library loading at runtime with `TFUNCTION LOAD`.
+The timeout for loading a library from RDB is set separately via
+[db-loading-lock-redis-timeout](#db-loading-lock-redis-timeout).
+
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+500 MS
+
+_Minimum Value_
+
+100 MS
+
+_Maximum Value_
+
+Unlimited
+
+_Runtime Configurability_
+
+Yes
+
+#### Side effects
+
+When setting `lock-redis-timeout`, if the new value is higher than the
+`db-loading-lock-redis-timeout`, the `db-loading-lock-redis-timeout` is also updated to
+this value.
+
+
+### db-loading-lock-redis-timeout
+
+This timeout configuration is used for setting the upper time limit
+(in milliseconds) for the library loading from RDB.
+
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+30000 MS
+
+_Minimum Value_
+
+100 MS
+
+_Maximum Value_
+
+Unlimited
+
+_Runtime Configurability_
+
+Yes
+
+#### Notes
+
+The value cannot be lower than the value of `lock-redis-timeout`.
+
+
+### remote-task-default-timeout
+
+The `remote-task-default-timeout` configuration option controls the timeout when waiting for a remote task to finish. If the timeout is reached an error will result.
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+500 MS
+
+_Minimum Value_
+
+1 MS
+
+_Maximum Value_
+
+Unlimited
+
+_Runtime Configurability_
+
+Yes
+
+### error-verbosity
+
+The `error-verbosity` configuration option controls the verbosity of error messages that will be provided by triggers and functions. The higher the value the more verbose the error messages will be (for example, including stack traces and extra information for better analysis and debugging).
+
+_Expected Value_
+
+Integer
+
+_Default_
+
+1
+
+_Minimum Value_
+
+1
+
+_Maximum Value_
+
+2
+
+_Runtime Configurability_
+
+Yes
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Overview of the known limitations
+linkTitle: Known limitations
+title: Known limitations
+weight: 8
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/known_limitations/
+---
+
+## 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.
+
+- `async_client.runOnShards` runs the remote function on all the shards
+- `async_client.runOnKey` runs the remote function on the shard responsible for a given key
+
+In addition, keyspace modification performed by JavaScript functions that are registered using any of the methods available should perform write operations locally:
+
+- If the function is registered with `registerFunction` or `registerAsyncFunction`, it can insert, modify or delete keys that are in the same shard where the function is executed.
+- If the function is registered with `registerKeySpaceTrigger` or `registerStreamTrigger`, keyspace modification must be local to the shard that originated the events.
+
+It is also recommended to co-locate the keys to be modified in the same hash slot as the key or Stream that originated the event. As an example, if the user profile stored in the Hash `myserv:user:1234` is subject to changes and we'd like to count them in an external counter, we would name the counter using hash tags: `{myserv:user:1234}:cnt`.
+
+## Exclusive access to the keyspace
+
+By design, asynchronous functions guarantee exclusive single-threaded access to the keyspace, the distinctive feature of Redis. In asynchronous programming with JavaScript functions, access to the keyspace in read or write mode must be blocking, while if not accessing the keyspace, the execution may be non-blocking. This implementation maintains the same level of data consistency as Redis standard commands or Lua scripts and functions but takes advantage of asynchronous execution, a feature of the JavaScript engine.
+
+## JavaScript variables
+
+Not all the JavaScript global variables are made available by the JavaScript engine loaded by Redis (e.g. `console`, `document`). The `redis` global variable can be used to manage functions registration, logging etc. 
+
+## Sandboxed
+
+This feature is sandboxed, meaning, from within a function, it’s not possible to make calls to external services, including other Redis databases, or APIs.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Overview of the JavaScript API
+linkTitle: JavaScript API
+title: JavaScript API
+weight: 2
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/javascript_api/
+---
+
+
+## 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.
+
+### `redis.registerFunction`
+
+* Since version: 2.0.0
+
+Register a new function that can later be invoke using `TFCALL` command.
+
+```JavaScript
+//name and callback mandatory
+//object with optional arguments
+redis.registerFunction(
+  'foo', //name
+  function(client, args) {}, //callback
+  {
+    description: 'The description',
+    flags: [redis.functionFlags.NO_WRITES, redis.functionFlags.ALLOW_OOM]
+  } // optional arguments
+);
+```
+
+### `redis.registerAsyncFunction`
+
+* Since version: 2.0.0
+
+Register a new async function that can later be invoke using `TFCALLASYNC` command.
+
+```JavaScript
+redis.registerAsyncFunction(
+  'foo', //Function name
+  function(client, args){}, //callback
+  {
+    description: 'description',
+    flags: [redis.functionFlags.NO_WRITES, redis.functionFlags.ALLOW_OOM]
+  } //optional arguments
+);
+```
+
+### `redis.registerKeySpaceTrigger`
+
+* Since version: 2.0.0
+
+Register a key space notification trigger that will run whenever a key space notification fired.
+
+```JavaScript
+redis.registerKeySpaceTrigger(
+  'foo', // trigger name
+  'keys:*', //key prefix
+  function(client, data) {}, //callback
+  {
+    description: 'description'
+    onTriggerFired: function(client, data){}
+  } //optional arguments
+)
+```
+
+### `redis.registerStreamTrigger`
+
+* Since version: 2.0.0
+
+Register a stream trigger that will be invoke whenever a data is added to a stream.
+
+```JavaScript
+redis.registerStreamTrigger(
+  'foo', //trigger name
+  'stream:*', //prefix
+  function(client, data){},//callback
+  {
+    description: 'Description'
+    window: 1,
+    isStreamTrimmed: false 
+  } //optional arguments
+)
+```
+
+### `redis.registerClusterFunction`
+
+* Since version: 2.0.0
+
+Register a cluster function that can later be called using `async_client.runOnKey()` or `async_client.runOnShards()`
+
+```JavaScript
+redis.registerClusterFunction(
+  'foo', //name
+  async function(client, ...args){} //callback
+)
+```
+
+### `redis.config`
+
+* Since version: 2.0.0
+
+```Shell
+redis-cli -x RG.FUNCTION LOAD UPGRADE CONFIG '{"example_config": "example_config_value"}' < main.js
+```
+
+```JavaScript
+var configExample = redis.config.example_config;
+```
+
+## Client object
+
+Client object that is used to perform operations on Redis.
+
+### `client.call`
+
+* Since version: 2.0.0
+
+Run a command on Redis. The command is executed on the current Redis instrance.
+
+```JavaScript
+client.call(
+  '',
+  ...args
+)
+```
+
+### `client.callRaw`
+
+* Since version: 2.0.0
+
+Run a command on Redis but does not perform UTF8 decoding on the result. The command is executed on the current Redis instrance.
+
+```JavaScript
+client.callRaw(
+  '',
+  ...args
+)
+```
+
+### `client.callAsync`
+
+* Since version: 2.0.0
+
+Call a command on Redis. Allow Redis to block the execution if needed (like `blpop` command) and return the result asynchronously. Returns a promise object that will be resolved when the command invocation finished.
+
+```JavaScript
+client.callAsync(
+  '',
+  ...args
+)
+```
+
+
+### `client.callAsyncRaw`
+
+* Since version: 2.0.0
+
+Call a command on Redis. Allow Redis to block the execution if needed (like `blpop` command) and return the result asynchronously. Returns a promise object that will be resolved when the command invocation finished. The command is executed on the current Redis instrance.
+
+```JavaScript
+client.callRaw(
+  '',
+  ...args
+)
+```
+
+
+### `client.isBlockAllowed`
+
+* Since version: 2.0.0
+
+Return true if it is allow to return promise from the function callback. In case it is allowed and a promise is return, Redis will wait for the promise to be fulfilled and only then will return the function result.
+
+```JavaScript
+client.isBlockAllowed(); // True / False
+```
+
+### `client.executeAsync`
+
+* Since version: 2.0.0
+
+Execute the given function asynchroniusly. Return a promise that will be fulfilled when the promise will be resolved/rejected.
+
+
+```JavaScript
+client.executeAsync(
+  async function(client){}
+)
+```
+
+
+
+## Async client object
+
+Background client object that is used to perform background operation on Redis.
+This client is given to any background task that runs as a JS coroutine.
+
+
+### `async_client.block`
+
+* Since version: 2.0.0
+
+Blocks Redis for command invocation. All the command that are executed inside the given function is considered atomic and will be wrapped with `Multi/Exec` and send to the replica/AOF.
+
+```JavaScript
+async_client.block(
+  function(client){}
+)
+```
+
+### `async_client.runOnKey`
+
+* Since version: 2.0.0
+
+Runs a remote function on a given key. If the key located on the current shard on which we currently runs on, the remote function will run write away. Otherwise the remote function will run on the remote shard. Returns a promise which will be fulfilled when the invocation finishes. Notice that the remote function must return a json serializable result so we can serialize the result back to the original shard. 
+
+Notice that remote function can only perform read operations, not writes are allowed.
+
+
+```JavaScript
+async_client.runOnKey(
+  'key1', // key
+  'foo', // function name
+  ...args
+)
+```
+
+### `async_client.runOnShards`
+
+* Since version: 2.0.0
+
+Runs a remote function on all the shards. Returns a promise which will be fulfilled when the invocation finishes on all the shards.
+ 
+The result is array of 2 elements, the first is another array of all the results. The second is an array of all the errors happened durring the invocation. Notice that the remote function must return a json serializable result so we can serialize the result back to the original shard.
+
+Notice that remote function can only perform read operations, not writes are allowed.
+
+```JavaScript
+async_client.runOnShards(
+  'foo', //name
+  ...args //arguments
+)
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Sync and async functions
+linkTitle: Sync and async
+title: Sync and async
+weight: 3
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/sync_async/
+---
+
+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 Stack's triggers and functions feature aims to provide greater flexibility to function writers by enabling the invocation of functions in the background. When a function is invoked in the background, it cannot directly access the Redis key space. To interact with the Redis key space from the background, the function must block Redis and enter an atomic section where the atomicity property is once again guaranteed.
+
+To run triggers and functions in the background, functions can be implemented as JS coroutines using the `registerAsyncFunction` API. The coroutine is invoked on a background thread and does not block the Redis processes. Here's an example:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerAsyncFunction('test', async function(){
+    return 'test';
+});
+```
+
+The simple function shown above will return the value 'test' and will execute on a background thread without blocking Redis. This allows Redis to continue accepting commands from other clients while the function is running.
+
+The coroutine also accepts an optional client argument, which differs from the client used in synchronous functions. This client argument does not allow direct invocation of Redis commands. Instead, it provides the capability to block Redis and enter an atomic section where the atomicity property is once again guaranteed. Here's an example that demonstrates invoking a ping command from within an async coroutine:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('test', async function(client){
+    return client.block(function(redis_client){
+        return redis_client.call('ping');
+    });
+});
+```
+
+Running this function will return a `pong` reply:
+
+```bash
+127.0.0.1:6379> TFCALLASYNC lib.test 0
+"PONG"
+```
+
+Notice that this time, in order to invoke the function, we used `TFCALLASYNC`. **We can only invoke async functions using `TFCALLASYNC`**.
+
+Now let's look at a more complex example. Assume we want to write a function that counts the number of hashes in Redis that have a `name` property with some value. As a first attempt, we'll write a synchronous function that uses the [`SCAN`]({{< relref "/commands/scan" >}}) command to scan the key space:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('test', function(client, expected_name){
+    var count = 0;
+    var cursor = '0';
+    do{
+        var res = client.call('scan', cursor);
+        cursor = res[0];
+        var keys = res[1];
+        keys.forEach((key) => {
+            if (client.call('hget', key, 'name') == expected_name) {
+                count += 1;
+            }
+        });
+    } while(cursor != '0');
+    return count;
+});
+```
+
+While this function works, it has the potential to block Redis for a long time. So let's modify this function to run in the background as a coroutine:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerAsyncFunction('test', async function(async_client, expected_name){
+    var count = 0;
+    var cursor = '0';
+    do{
+        async_client.block((client)=>{
+            var res = client.call('scan', cursor);
+            cursor = res[0];
+            var keys = res[1];
+            keys.forEach((key) => {
+                if (client.call('hget', key, 'name') == expected_name) {
+                    count += 1;
+                }
+            });
+        });
+    } while(cursor != '0');
+    return count;
+});
+```
+
+Both implementations return the same result, but the second function runs in the background and blocks Redis just to analyze the next batch of keys that are returned from the [`SCAN`]({{< relref "/commands/scan" >}}) command. Other commands will be processed in between [`SCAN`]({{< relref "/commands/scan" >}}) batches. Notice that the coroutine approach allows the key space to be changed while the scanning it. The function writer will need to decide if this is acceptable.
+
+# Start sync and move to async
+
+The previous example, although functional, has a drawback in terms of performance. Even though Redis is not blocked, it still takes time to return the reply to the user. However, if we modify the requirement slightly and agree to obtain an approximate value, we can achieve much better performance in most cases. This can be done by implementing result caching using a key named `<name>_count` and setting an expiration time on that key, which triggers recalculation of the value periodically. Here's the updated code:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerAsyncFunction('test', async function(async_client, expected_name){
+    // check the cache first
+    var cached_value = async_client.block((client)=>{
+        return client.call('get', expected_name + '_count');
+    });
+
+    if (cached_value != null) {
+        return cached_value;
+    }
+
+
+    var count = 0;
+    var cursor = '0';
+    do{
+        async_client.block((client)=>{
+            var res = client.call('scan', cursor);
+            cursor = res[0];
+            var keys = res[1];
+            keys.forEach((key) => {
+                if (client.call('hget', key, 'name') == expected_name) {
+                    count += 1;
+                }
+            });
+        });
+    } while(cursor != '0');
+
+    // set count to the cache wil 5 seconds expiration
+    async_client.block((client)=>{
+        client.call('set', expected_name + '_count', count);
+        client.call('expire', expected_name + '_count', 5);
+    });
+
+    return count;
+});
+```
+
+The above code works as expected. It first checks the cache and if the cache exists it's returned. Otherwise it will perform the calculation and update the cache. But the above example is not optimal. The callback is a coroutine, which means that it will always be calculated on a background thread. Intrinsically, moving to a background thread is costly. The best approach would be to check the cache synchronously and, only if its not there, move to the background. Triggers and functions provides for starting synchronously and then moving asynchronous execution using `executeAsync` function as required. The new code:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerAsyncFunction('test', function(client, expected_name){
+    // check the cache first
+    var cached_value = client.call('get', expected_name + '_count');
+    if (cached_value != null) {
+        return cached_value;
+    }
+
+    // cache is not set, move to background
+    return client.executeAsync(async function(async_client) {
+        var count = 0;
+        var cursor = '0';
+        do{
+            async_client.block((client)=>{
+                var res = client.call('scan', cursor);
+                cursor = res[0];
+                var keys = res[1];
+                keys.forEach((key) => {
+                    if (client.call('hget', key, 'name') == expected_name) {
+                        count += 1;
+                    }
+                });
+            });
+        } while(cursor != '0');
+
+        // set count to the cache wil 5 seconds expiration
+        async_client.block((client)=>{
+            client.call('set', expected_name + '_count', count);
+            client.call('expire', expected_name + '_count', 5);
+        });
+
+        return count;
+    });
+});
+```
+
+`executeAsync` will return a `Promise` object. When triggers and functions sees that the function returns a Promise, it waits for the promise to be resolved and returns its result to the client. The above implementation will be much faster in the case of cache hit.
+
+**Notice** that even though we registered a synchronous function (not a coroutine) we still used `registerAsyncFunction`. This is because our function has the potential of blocking the client, taking the execution to the background. If we had used `registerFunction`, Triggers and functions would not have allowed the function to block the client and it would have ignored the returned promise object.
+
+**Also notice** it is not always possible to wait for a promise to be resolved. If the command is called inside a `multi/exec` it is not possible to block it and wait for the promise. In such cases the client will get an error. It is possible to check if blocking the client is allowed using the `client.isBlockAllowed()` function, which will return `true` if it is OK to wait for a promise to be resolved and `false` if it is not possible.
+
+# Call blocking commands
+
+Redis has a few commands that blocks the client and executed asynchronously when some condition holds (commands like [blpop]({{< relref "/commands/blpop" >}})). In general, such commands are not suppose to be called inside a script and calling them will result in running their none blocking logic. For example, [blpop]({{< relref "/commands/blpop" >}}) will basically runs lpop and return empty result if the list it empty.
+
+RedisGears allows running blocking commands using `client.callAsync` API. `client.callAsync` will execute the blocking command and return a promise object which will be resolved when the command invocation finished (notice that `client.callAsync` allow calling any command and not just blocking but it will always return a promise object that will be resolve later, so **using it for regular commands is less efficient**). 
+
+Example:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerAsyncFunction('my_blpop', async function(client, key, expected_val) {
+    var res = null
+    do {
+        res = await client.block((c) => {
+            return c.callAsync('blpop', key, '0');
+        })
+    } while (res[1] != expected_val);
+    return res;
+});
+```
+
+The following function will continue popping elements from the requested list up until it will encounter the requested value. In case the list is empty it will wait until elements will be added to the list.
+
+RedisGears also provided `client.callAsyncRaw` API, which is the same as `client.callAsync` but will not decode the replies as utf8.
+
+**Notice**: There is no guarantee when the promise returned from `client.callAsyn` will be resolved. So the **function writer should not make any assumption about atomicity guarantees.**
+
+# Block Redis failure
+
+Blocking Redis might fail for a few reasons:
+
+* Redis reached OOM state and the `redis.functionFlags.NO_WRITES` or `redis.functionFlags.ALLOW_OOM` flags are not set (see [functions flags]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Function_Flags" >}}) for more information)
+* `redis.functionFlags.NO_WRITES` flag is not set and the Redis instance changed roles and is now a replica.
+* The ACL user that invoked the function was deleted.
+
+The failure will result in an exception that the function writer can choose to handle or throw it to be caught by triggers and functions.
+
+# Block Redis timeout
+
+Blocking Redis for a long time is discouraged and is considered an unsafe operation. The triggers and functions feature attempts to protect the function writer and will time out the blocking function if it continues for too long. The timeout can be set as a [module configuration]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Configuration" >}}) along side the fatal failure policy that indicates how to handle the timeout. Policies can be one of the following:
+
+* Abort - Stop the function invocation even at the cost of losing the atomicity property.
+* Kill - Keep the atomicity property and do not stop the function invocation. In this case there is a risk of an external process killing the Redis server, thinking that the shard is not responding.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Execute a JavaScript function based on a keyspace notification
+linkTitle: Keyspace triggers
+title: Keyspace triggers
+weight: 2
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/triggers/keyspace_triggers/
+---
+
+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:
+
+1. Expired: This event is fired when a key expires from the database.
+2. 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]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands" >}}).
+
+To register a keyspace trigger, you need to use the `redis.registerKeySpaceTrigger` API when loading your library. The following example demonstrates how to register a database trigger that adds a "last updated" field whenever a hash key is modified:
+
+```js
+#!js api_version=1.0 name=myFirstLibrary
+
+redis.registerKeySpaceTrigger("consumer", "", function(client, data){
+    if (client.call("type", data.key) != "hash") {
+        // key is not a has, do not touch it.
+        return;
+    }
+    // get the current time in ms
+    var curr_time = client.call("time")[0];
+    // set '__last_updated__' with the current time value
+    client.call('hset', data.key, '__last_updated__', curr_time);
+});
+```
+
+Argument Description:
+
+* `consumer`: The consumer name.
+* `prefix `: The key prefix on which the trigger should be fired.
+* `callback`: The callback function to invoke, following the same rules of [Sync and Async invocation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Sync_Async" >}}). The callback will only be invoked on the primary shard.
+
+Run the example:
+
+```bash
+127.0.0.1:6379> hset h x 1
+(integer) 1
+127.0.0.1:6379> hgetall h
+1) "x"
+2) "1"
+3) "__last_updated__"
+4) "1658390831"
+127.0.0.1:6379> hincrby h x 1
+(integer) 2
+127.0.0.1:6379> hgetall h
+1) "x"
+2) "2"
+3) "__last_updated__"
+4) "1658390910"
+```
+
+The `data` argument, which is passed to the consumer callback, are in the following format:
+
+```json
+{
+    "event": "<the event name that fired the trigger>",
+    "key": "<key name that the event was fired on as String>",
+    "key_raw": "<key name that the event was fired on as ArrayBuffer>"
+}
+```
+
+Notice that the `key` field is given only if the key can be decoded as a `JS` `String`, otherwise the value will be `null`.
+
+We can display trigger information using `TFUNCTION LIST` command:
+
+```bash
+127.0.0.1:6379> TFUNCTION list vvv
+1)  1) "engine"
+    2) "js"
+    3) "api_version"
+    4) "1.0"
+    5) "name"
+    6) "foo"
+    7) "pending_jobs"
+    8) (integer) 0
+    9) "user"
+    10) "default"
+    11) "functions"
+   12) (empty array)
+   13) "keyspace_triggers"
+   14) (empty array)
+   15) "stream_triggers"
+   16) 1)  1) "name"
+           2) "consumer"
+           3) "num_triggered"
+           4) (integer) 2
+           5) "num_finished"
+           6) (integer) 2
+           7) "num_success"
+           8) (integer) 1
+           9) "num_failed"
+          10) (integer) 1
+          11) "last_error"
+          12) "TypeError: redis.call is not a function"
+          13) "last_exection_time"
+          14) (integer) 0
+          15) "total_exection_time"
+          16) (integer) 0
+          17) "avg_exection_time"
+          18) "0"
+```
+
+## Trigger guarantees
+
+If the callback function passed to the trigger is a `JS` function (not a Coroutine), it is guaranteed that the callback will be invoked atomically along side the operation that caused the trigger; meaning all clients will see the data only after the callback has completed. In addition, it is guaranteed that the effect of the callback will be replicated to the replica and the AOF in a `multi/exec` block together with the command that fired the trigger.
+
+If the callback is a Coroutine, it will be executed in the background and there is no guarantee on where or if it will be executed. The guarantees are the same as described on [sync and async invocation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Sync_Async" >}}).
+
+## Upgrades
+
+When upgrading existing trigger code using the `REPLACE` option of `TFUNCTION LOAD` command, all trigger parameters can be modified.
+
+## Advanced usage
+
+For most use cases, the `registerKeySpaceTrigger` API is sufficient. But there are some use cases where you might need a better guarantee on when a trigger will be fired. Let's look at the following example:
+
+```js
+#!js api_version=1.0 name=myFirstLibrary
+
+redis.registerKeySpaceTrigger("consumer", "", function(client, data){
+    if (client.call("type", data.key) != "hash") {
+        // key is not a has, do not touch it.
+        return;
+    }
+    var name = client.call('hget', data.key, 'name');
+    client.call('incr', `name_${name}`);
+});
+```
+
+Whenever a hash key is changed, the example above will read the field `name` from the hash, for example `tom`, and increase the value of the key `name_tom`. (**Notice: This function will not work properly on cluster. We need to use `{}` on the key's name to make sure we are writing to a key located on the current shard. For the sake of simplicity we will ignore the cluster issues for the time being**). Running the function will give the following results:
+
+```bash
+127.0.0.1:6379> hset x name tom
+(integer) 1
+127.0.0.1:6379> hset x name jerry
+(integer) 0
+127.0.0.1:6379> get name_tom
+"1"
+127.0.0.1:6379> get name_jerry
+"1"
+```
+
+We can see that the key `name_tom` was incremented once, and the key `name_jerry` was incremented once. Will we get the same results if we wrap the `hset` call with a `multi`/`exec`?
+
+```bash
+127.0.0.1:6379> multi
+OK
+127.0.0.1:6379(TX)> hset x name tom
+QUEUED
+127.0.0.1:6379(TX)> hset x name jerry
+QUEUED
+127.0.0.1:6379(TX)> exec
+1) (integer) 1
+2) (integer) 0
+127.0.0.1:6379> get name_tom
+(nil)
+127.0.0.1:6379> get name_jerry
+"2"
+```
+
+What just happened? `name_jerry` was incremented twice while `name_tom` was not incremented at all. This happened because, in case of a `multi`/`exec` or Lua function, the notifications are fired at the end of the transaction, so all the clients will receive notifications of the last value written, which is `jerry`.
+
+To fix the code and still get the expected results even on `multi`/`exec`. Triggers and functions allows you to specify an optional callback that will run exactly when the notification happened (and not at the end of the transaction). The constraint on this callback is that it can only **read** data without performing any writes. The new code will be as follow:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerKeySpaceTrigger("consumer", "", function(client, data){
+    if (data.name !== undefined) {
+        client.call('incr', `name_${data.name}`);
+    }
+},{
+    onTriggerFired: (client, data) => {
+        if (client.call("type", data.key) != "hash") {
+            // key is not a has, do not touch it.
+            return;
+        }
+        data.name = client.call('hget', data.key, 'name');
+    }
+});
+```
+
+The above code gives an optional function argument, `onTriggerFired`, to our trigger. The function will be fired right after a key change and will allow us to read the content of the key. We are adding the content into the `data` argument, which will be given to the actual trigger function that can write the data. The above code works as expected:
+
+```bash
+127.0.0.1:6379> multi
+OK
+127.0.0.1:6379(TX)> hset x name tom
+QUEUED
+127.0.0.1:6379(TX)> hset x name jerry
+QUEUED
+127.0.0.1:6379(TX)> exec
+1) (integer) 1
+2) (integer) 0
+127.0.0.1:6379> get name_tom
+"1"
+127.0.0.1:6379> get name_jerry
+"1"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Execute a JavaScript function when an item is added to a stream
+linkTitle: Stream triggers
+title: Stream triggers
+weight: 2
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/triggers/stream_triggers/
+---
+
+Redis Stack's triggers and functions feature comes with a full stream API to process data from [Redis streams]({{< relref "/develop/data-types/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]({{< relref "develop/data-types/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:
+
+```js
+#!js api_version=1.0 name=myFirstLibrary
+
+redis.registerStreamTrigger(
+    "consumer", // consumer name
+    "stream", // streams prefix
+    function(c, data) {
+        // callback to run on each element added to the stream
+        redis.log(JSON.stringify(data, (key, value) =>
+            typeof value === 'bigint'
+                ? value.toString()
+                : value // return everything else unchanged
+        ));
+    }
+);
+```
+
+Argument Description:
+
+* consumer - the consumer name.
+* stream - streams name prefix on which to trigger the callback.
+* callback - the callback to invoke on each element in the stream. Following the same rules of [sync and async invocation]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Sync_Async" >}}). The callback will be invoke only on primary shard.
+
+If we register this library (see the [quick start]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Quick_Start_CLI" >}}) section to learn how to Register a RedisGears function) and run the following command on our Redis:
+
+```
+XADD stream:1 * foo1 bar1
+XADD stream:1 * foo2 bar2
+XADD stream:2 * foo1 bar1
+XADD stream:2 * foo2 bar2
+```
+
+We will see the following line on the Redis log file:
+
+```
+2630021:M 05 Jul 2022 17:13:22.506 * <redisgears_2> {"id":["1657030402506","0"],"stream_name":"stream:1","record":[["foo1","bar1"]]}
+2630021:M 05 Jul 2022 17:13:25.323 * <redisgears_2> {"id":["1657030405323","0"],"stream_name":"stream:1","record":[["foo2","bar2"]]}
+2630021:M 05 Jul 2022 17:13:29.475 * <redisgears_2> {"id":["1657030409475","0"],"stream_name":"stream:2","record":[["foo1","bar1"]]}
+2630021:M 05 Jul 2022 17:13:32.715 * <redisgears_2> {"id":["1657030412715","0"],"stream_name":"stream:2","record":[["foo2","bar2"]]}
+```
+
+The `data` argument which pass to the stream consumer callback are in the following format:
+
+```json
+{
+    "id": ["<ms>", "<seq>"],
+    "stream_name": "<stream name>",
+    "stream_name_raw": "<stream name as ArrayBuffer>",
+    "record":[
+        ["<key>", "<value>"],
+        .
+        .
+        ["<key>", "<value>"]
+    ],
+    "record_raw":[
+        ["<key_raw>", "<value_raw>"],
+        .
+        .
+        ["<key_raw>", "<value_raw>"]
+    ],
+}
+```
+
+The reason why the record is a list of touples and not an object is because the Redis Stream specifications allows duplicate keys.
+
+Notice that `stream_name` and `record` fields might contains `null`'s if the data can not be decoded as string. the `*_raw` fields will always be provided and will contains the data as `JS` `ArrayBuffer`.
+
+We can observe the streams which are tracked by our registered consumer using `TFUNCTION LIST` command:
+
+```
+127.0.0.1:6379> TFUNCTION LIST LIBRARY lib vvv
+1)  1) "engine"
+    1) "js"
+    2) "api_version"
+    3) "1.0"
+    4) "name"
+    5) "lib"
+    6) "pending_jobs"
+    7) (integer) 0
+    8) "user"
+    9)  "default"
+    10) "functions"
+   1)  (empty array)
+   2)  "stream_triggers"
+   3)  1)  1) "name"
+           1) "consumer"
+           2) "prefix"
+           3) "stream"
+           4) "window"
+           5) (integer) 1
+           6) "trim"
+           7) "disabled"
+           8) "num_streams"
+          1)  (integer) 2
+          2)  "streams"
+          3)  1)  1) "name"
+                  1) "stream:2"
+                  2) "last_processed_time"
+                  3) (integer) 0
+                  4) "avg_processed_time"
+                  5) "0"
+                  6) "last_lag"
+                  7) (integer) 0
+                  8) "avg_lag"
+                 1)  "0"
+                 2)  "total_record_processed"
+                 3)  (integer) 2
+                 4)  "id_to_read_from"
+                 5)  "1657030412715-0"
+                 6)  "last_error"
+                 7)  "None"
+                 17) "pending_ids"
+                 18) (empty array)
+              1)  1) "name"
+                  1) "stream:1"
+                  2) "last_processed_time"
+                  3) (integer) 1
+                  4) "avg_processed_time"
+                  5) "0.5"
+                  6) "last_lag"
+                  7) (integer) 1
+                  8) "avg_lag"
+                 1)  "0.5"
+                 2)  "total_record_processed"
+                 3)  (integer) 2
+                 4)  "id_to_read_from"
+                 5)  "1657030405323-0"
+                 6)  "last_error"
+                 7)  "None"
+                 8)  "pending_ids"
+                 9)  (empty array)
+   4)  "keyspace_triggers"
+   5)  (empty array)
+```
+
+## Enable trimming and set window
+
+We can enable stream trimming by adding `isStreamTrimmed` optional argument after the trigger callback, we can also set the `window` argument that controls how many elements can be processed simultaneously. example:
+
+```js
+#!js api_version=1.0 name=myFirstLibrary
+
+redis.registerStreamTrigger(
+    "consumer", // consumer name
+    "stream", // streams prefix
+    function(c, data) {
+        // callback to run on each element added to the stream
+        redis.log(JSON.stringify(data, (key, value) =>
+            typeof value === 'bigint'
+                ? value.toString()
+                : value // return everything else unchanged
+        ));
+    }, 
+    {
+        isStreamTrimmed: true,
+        window: 3   
+    }
+);
+
+```
+
+The default values are:
+* `isStreamTrimmed` - `false`
+* `window` - 1
+
+It is enough that a single consumer will enable trimming so that the stream will be trimmed. The stream will be trim according to the slowest consumer that consume the stream at a given time (even if this is not the consumer that enabled the trimming). Raising exception during the callback invocation will **not prevent the trimming**. The callback should decide how to handle failures by invoke a retry or write some error log. The error will be added to the `last_error` field on `TFUNCTION LIST` command.
+
+## Data processing guarantees
+
+As long as the primary shard is up and running we guarantee exactly once property (the callback will be triggered exactly one time on each element in the stream). In case of failure such as shard crashing, we guarantee at least once property (the callback will be triggered at least one time on each element in the stream)
+
+## Upgrades
+
+When upgrading the consumer code (using the `REPLACE` option of `TFUNCTION LOAD` command) the following consumer parameters can be updated:
+
+* Window
+* Trimming
+
+Any attempt to update any other parameter will result in an error when loading the library.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Different ways of executing JavaScript functions
+linkTitle: Triggers
+title: Triggers
+weight: 1
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/triggers/
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Execute JavaScript functions via `TFCALL` or `TFCALLASYNC`
+linkTitle: User functions
+title: User functions
+weight: 1
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/triggers/user_functions/
+---
+
+
+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
+#!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:
+
+```bash
+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:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('my_get', function(client, ...keys){
+    var results = [];
+    keys.forEach((key_name)=> {
+            if (client.call('type', key_name) == 'string') {
+                results.push(client.call('get', key_name));
+                return;
+            }
+            if (client.call('type', key_name) == 'hash') {
+                results.push(client.call('hgetall', key_name));
+                return;
+            }
+            results.push("Unsupported type");
+        }
+    );
+    return results;
+
+});
+```
+
+Run example:
+
+```bash
+127.0.0.1:6379> TFCALL foo.my_get 2 x h
+1) "1"
+2) 1) "a"
+   2) "b"
+   3) "x"
+   4) "y"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Working with binary data
+linkTitle: Binary data
+title: Binary data
+weight: 8
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/binary_data/
+---
+
+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:
+
+1. Binary function arguments
+2. Binary command results
+3. Binary key names on [keyspace triggers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/Keyspace_Triggers" >}})
+4. Binary data on [stream triggers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/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]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Function_Flags" >}}) function flag. In this case, the function arguments will be given as `JS` `ArrayBuffer`. Example:
+
+```js
+#!js api_version=1.0 name=lib
+redis.registerFunction("my_set",
+    (c, key, val) => {
+        return c.call("set", key, val);
+    },
+    {
+        flags: [redis.functionFlags.RAW_ARGUMENTS]
+    }
+);
+```
+
+The above example will allow us to set `key` and `val` even if those are binary data. Run example:
+
+```bash
+127.0.0.1:6379> TFCALL lib.my_set 1 "\xaa" "\xaa"
+"OK"
+127.0.0.1:6379> get "\xaa"
+"\xaa"
+```
+
+Notice that the `call` function also accepts `JS` `ArrayBuffer` arguments.
+
+### Binary command results
+
+Getting function arguments as binary data is not enough. We might want to read binary data from a Redis key. In order to do this we can use the `callRaw` function, which will not decode the result as a `JS` `String` and instead will return the result as a `JS` `ArrayBuffer`. Example:
+
+```js
+#!js api_version=1.0 name=lib
+redis.registerFunction("my_get", 
+    (c, key) => {
+        return c.callRaw("get", key);
+    },
+    {
+        flags: [redis.functionFalgs.RAW_ARGUMENTS]
+    }
+);
+```
+
+The above example will be able to fetch binary data and return it to the user. For example:
+
+```bash
+27.0.0.1:6379> set "\xaa" "\xaa"
+OK
+127.0.0.1:6379> TFCALL lib.my_get 1 "\xaa"
+"\xaa"
+```
+
+Notice that a `JS` `ArrayBuffer` can be returned by a function, it will be returned to the client as `bulk string`.
+
+### Binary keys names on database triggers
+
+On [keyspace triggers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/Keyspace_Triggers" >}}), if the key name that triggered the event is binary, the `data.key` field will be NULL. The `data.key_raw` field is always provided as a `JS` `ArrayBuffer` and can be used as in the following example:
+
+```js
+#!js api_version=1.0 name=lib
+/* The following is just an example, in general it is discourage to use globals. */
+var n_notifications = 0;
+var last_key = null;
+var last_key_raw = null;
+redis.registerKeySpaceTrigger("consumer", "", function(client, data) {
+    if (data.event == "set") {
+        n_notifications += 1;
+        last_data = data.key;
+        last_key_raw = data.key_raw;
+    }
+});
+
+redis.registerFunction("notifications_stats", async function(){
+    return [
+        n_notifications,
+        last_key,
+        last_key_raw
+    ];
+});
+```
+
+Run example:
+
+```bash
+127.0.0.1:6379> set "\xaa" "\xaa"
+OK
+127.0.0.1:6379> TFCALL lib.notifications_stats 0
+1) (integer) 1
+2) (nil)
+3) "\xaa"
+```
+
+For more information see [keyspace triggers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/Keyspace_Triggers" >}}).
+
+### Binary data on stream consumers
+
+On [stream triggers]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/Stream_Triggers" >}}), if the key name is binary. The `data.stream_name` field will be NULL. The `data.stream_name_raw` field is always provided as a `JS` `ArrayBuffer` and can be used in this case. In addition, if the content of the steam is binary, it will also appear as `null` under `data.record`. In this case, it is possible to use `data.record` (which always exists) and contains the data as a `JS` `ArrayBuffer`. Example:
+
+```js
+#!js api_version=1.0 name=lib
+/* The following is just an example, in general it is discourage to use globals. */
+var last_key = null;
+var last_key_raw = null;
+var last_data = null;
+var last_data_raw = null;
+redis.registerFunction("stats", function(){
+    return [
+        last_key,
+        last_key_raw,
+        last_data,
+        last_data_raw
+    ];
+})
+redis.registerStreamTrigger("consumer", new Uint8Array([255]).buffer, function(c, data){
+    last_key = data.stream_name;
+    last_key_raw = data.stream_name_raw;
+    last_data = data.record;
+    last_data_raw = data.record_raw;
+})
+```
+
+Run Example:
+
+```bash
+127.0.0.1:6379> xadd "\xff\xff" * "\xaa" "\xaa"
+"1659515146671-0"
+127.0.0.1:6379> TFCALL foo.stats 0
+1) (nil)
+2) "\xff\xff"
+3) 1) 1) (nil)
+      2) (nil)
+4) 1) 1) "\xaa"
+      2) "\xaa"
+
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to use configuration in JavaScript functions
+linkTitle: Library configuration
+title: Library configuration
+weight: 6
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/library_configuration/
+---
+
+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]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/triggers/Keyspace_Triggers" >}})), the code will look like this:
+
+```js
+#!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:
+
+```bash
+127.0.0.1:6379> TFCALL lib.hset k a b 0
+(integer) 2
+127.0.0.1:6379> hgetall k
+1) "foo"
+2) "bar"
+3) "__last_update__"
+4) "1658653125"
+```
+
+The problem with the above code is that the `__last_update__` field is hard coded. What if we want to allow the user to configure it at runtime? Triggers and functions provide for specifying a library configuration at load time using a [`CONFIG`]({{< relref "/commands/config" >}}) argument that is passed to the `TFUNCTION LOAD` command. The configuration argument accepts a string representation of a JSON object. The JSON will be provided to the library as a JS object under the `redis.config` variable. We can change the above example to accept the `__last_update__` field name as a library configuration. The code will look like this:
+
+```js
+#!js api_version=1.0 name=lib
+
+var last_update_field_name = "__last_update__"
+
+if (redis.config.last_update_field_name !== undefined) {
+    if (typeof redis.config.last_update_field_name != 'string') {
+        throw "last_update_field_name must be a string";
+    }
+    last_update_field_name = redis.config.last_update_field_name
+}
+
+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_field_name, curr_time);
+});
+```
+
+Notice that in the above example we first set `last_update_field_name` to `__last_update__`, the default value in cases where a value is not provided by the configuration. Then we check if we have `last_update_field_name` in our configuration and if we do we use it. We can now load our function with a [`CONFIG`]({{< relref "/commands/config" >}}) argument:
+
+```bash
+> redis-cli -x TFUNCTION LOAD REPLACE CONFIG '{"last_update_field_name":"last_update"}' < <path to code file>
+OK
+```
+
+We can see that the last update field name is `last_update`:
+
+```bash
+127.0.0.1:6379> TFCALL lib.hset h a b 0
+(integer) 2
+127.0.0.1:6379> hgetall h
+1) "a"
+2) "b"
+3) "last_update"
+4) "1658654047"
+```
+
+Notice, triggers and functions only provides the library with the JSON configuration. **It's the library's responsibility to verify the correctness of the given configuration**.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Cluster support for triggers and functions
+linkTitle: Cluster support
+title: Cluster support
+weight: 4
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/cluster_support/
+---
+
+**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.
+
+Just like local functions, remote function must be declared on library load time using `redis.registerClusterFunction` API. The following example declares a remote function that returns the number of keys on the shard:
+
+```js
+redis.registerClusterFunction("dbsize", async(async_client) => {
+    return client.block((async_client) => {
+        return client.call("dbsize").toString();
+    });
+});
+```
+
+`redis.registerClusterFunction` is passed the remote function name, which will be used later to call the remote function, and the remote function code. The remote function must be a Coroutine (async function) and it is executed in the background on the remote shard. For more information about async function, please refer to [sync and async]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Sync_Async" >}}) page.
+
+We have couple of options for calling a remote function. These options are exposed through the async client that is given to a Coroutine:
+
+* `async_client.runOnShards` - run the remote function on all the shards (including the current shard). Returns a promise that, once resolved, will give two nested arrays, the first contains another array with the results from all the shards and the other contains an array of errors (`[[res1, res2, ...],[err1, err2, ..]]`).
+* `async_client.runOnKey` - run the remote function on the shard responsible for a given key. Returns a promise that, once resolved, will give the result from the remote function execution or raise an exception in the case of an error.
+
+The following example registers a function that will return the total number of keys on the cluster. The function will use the remote function defined above:
+
+```js
+redis.registerAsyncFunction("my_dbsize", async(async_client) => {
+    let res = await async_client.runOnShards("dbsize");
+    let results = res[0];
+    let errors = res[1];
+    if (errors.length > 0) {
+        return errors;
+    }
+    let sum = BigInt(0);
+    results.forEach((element) => sum+=BigInt(element));
+    return sum;
+});
+```
+
+First, the function executes a remote function on all shards that returns the number of keys on each shard, then the function adds all the results and returns total number of keys for all shards.
+
+Here's the complete example:
+
+```js
+#!js name=lib api_version=1.0
+
+redis.registerClusterFunction("dbsize", async(client) => {
+    return client.block((client) => {
+        return client.call("dbsize").toString();
+    });
+});
+
+redis.registerAsyncFunction("test", async(async_client) => {
+    let res = await async_client.runOnShards("dbsize");
+    let results = res[0];
+    let errors = res[1];
+    if (errors.length > 0) {
+        return errors;
+    }
+    let sum = BigInt(0);
+    results.forEach((element) => sum+=BigInt(element));
+    return sum;
+});
+```
+
+## Arguments and results serialization
+
+It is possible to pass arguments to the remote function. The arguments will be given to the remote function after the `async_client`. The following example shows how to get a value of a key from any shard in the cluster:
+
+```js
+#!js name=lib api_version=1.0
+const remote_get = "remote_get";
+
+redis.registerClusterFunction(remote_get, async(client, key) => {
+    let res = client.block((client) => {
+        return client.call("get", key);
+    });
+    return res;
+});
+
+redis.registerAsyncFunction("test", async (async_client) => {
+    return await async_client.runOnKey("x", remote_get, "x");
+});
+```
+
+The function `test` will return the value of `x` regardless of which shard the function was executed on.
+
+The remote function arguments and results are serialized in the following way:
+
+1. If the argument is of type `ArrayBuffer`, the data will be sent as is.
+2. Otherwise, RedisGears will try to serialize the give arguments (or the return value) as JSON using `JSON.stringify`. A serialization failure will cause an error to be raised.
+
+## Execution timeout
+
+Remote functions will not be permitted to run forever and will timeout. The timeout period can be configured using [remote-task-default-timeout]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/Configuration#remote-task-default-timeout" >}}).
+When using `async_client.runOnShards` API, the timeout will be added as error to the error array. When using `async_client.runOnKey`, a timeout will cause an exception to be raised.
+
+## Remote function limitations
+
+All the limitations listed on [coroutines]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/Sync_Async" >}}) also apply to remote functions. Remote function also come with some extra limitations:
+
+* Remote functions can only perform read operations. An attempt to perform a write operation will result in an error.
+* Remote function are not guaranteed to succeed (if the shard crashed for example). In such cases a timeout error will be given.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Converting RESP to and from JavaScript
+linkTitle: RESP & JavaScript
+title: RESP & JavaScript
+weight: 7
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/resp_js_conversion/
+---
+
+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:
+
+| resp 3            | JS object type                                                                                                                                 |
+|-------------------|------------------------------------------------------------------------------------------------------------------------------------------------|
+| `status`          | JS `ArrayBuffer` with a field called `__reply_type` and value `status`                                                                        |
+| `bulk string`     | JS `ArrayBuffer`                                                                                                                              |
+| `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` | JS `ArrayBuffer` with 2 additional fields: 1. `__reply_type` and value `verbatim` 2. `__format` with the value of the ext in the verbatim string |
+| `null`            | JS null                                                                                                                                        |
+|                   |                                                                                                                                                |
+
+## JavaScript to RESP conversion
+
+| JS type                                                          | RESP2         | RESP3                                  |
+|------------------------------------------------------------------|---------------|----------------------------------------|
+| `string`                                                         | `bulk string` | `bulk string`                          |
+| `string` object with field `__reply_type=status`                 | `status`      | `status`                               |
+| Exception                                                        | `error`       | `error`                                |
+| `big integer`                                                    | `long`        | `long`                                 |
+| `number`                                                         | `bulk string` | `double`                               |
+| `array`                                                          | `array`       | `array`                                |
+| `map`                                                            | `array`       | `map`                                  |
+| `set`                                                            | `array`       | `set`                                  |
+| `bool`                                                           | `long`        | `bool`                                 |
+| `string` object with field`__reply_type=varbatim` and `__format=txt` | `bulk string` | `verbatim string` with format as `txt` |
+| `null`                                                           | resp2 `null`  | resp3 `null`                           |
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Function flags for JavaScript functions
+linkTitle: Function flags
+title: Function flags
+weight: 5
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/function_flags/
+---
+
+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:
+1. `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.
+2. `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.
+3. `redis.functionFlags.RAW_ARGUMENTS`: By default, Redis attempts to decode all function arguments as `JS` `String`s. 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:
+
+```js
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('my_ping',
+    function(client){
+        return client.call('ping');
+    },
+    {
+        flags: [redis.functionFlags.NO_WRITES]
+    }
+);
+```
+
+Run example:
+
+```bash
+127.0.0.1:6379> TFCALL lib.my_ping 0
+"PONG"
+127.0.0.1:6379> config set maxmemory 1
+OK
+127.0.0.1:6379> TFCALL lib.my_ping 0
+"PONG"
+
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Details about triggers, the JavaScript API, and advanced concepts
+linkTitle: Concepts
+title: Concepts
+weight: 6
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/concepts/
+---
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Get started with triggers and functions using redis-cli
+linkTitle: Quick start (redis-cli)
+title: Quick start using redis-cli
+weight: 2
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/quick_start_ri/
+---
+
+Make sure that you have [Redis Stack installed]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) and running. Alternatively, you can create a [free Redis Cloud account](https://redis.com/try-free/?utm_source=redisio&utm_medium=referral&utm_campaign=2023-09-try_free&utm_content=cu-redis_cloud_users). 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
+
+```Shell
+> 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.
+
+```Shell
+127.0.0.1:6379> TFUNCTION LOAD "#!js api_version=1.0 name=myFirstLibrary\n redis.registerFunction('hello', ()=>{ return 'Hello World'})"
+OK
+```
+
+When the library is created successfully, an `OK` response is returned. Run the `TFUNCTION LIST` command to confirm your library was added to Redis.
+
+```shell
+> TFUNCTION LIST
+1) 1) "api_version"
+   2) "1.0"
+   3) "cluster_functions"
+   4) (empty list or set)
+   5) "configuration"
+   6) "null"
+   7) "engine"
+   8) "js"
+   9) "functions"
+   10) 1) "hello"
+   11) "keyspace_triggers"
+   12) (empty list or set)
+   13) "name"
+   14) "myFirstLibrary"
+   15) "pending_async_calls"
+   16) (empty list or set)
+   17) "pending_jobs"
+   18) "0"
+   19) "stream_triggers"
+   20) (empty list or set)
+   21) "user"
+   22) "default"
+```
+
+The `TFCALL` command is used to execute the JavaScript Function. If the command fails, an error will be returned.
+
+```Shell
+127.0.0.1:6379> TFCALL myFirstLibrary.hello 0
+"Hello World"
+```
+
+To update the library run the `TFUNCTION LOAD` command with the additional parameter `REPLACE`.
+
+```Shell
+127.0.0.1:6379> TFUNCTION LOAD REPLACE "#!js api_version=1.0 name=myFirstLibrary\n redis.registerFunction('hello', ()=>{ return 'Hello World updated'})"
+OK
+```
+
+## Uploading an external file
+
+Use the `redis-cli` command to upload JavaScript from an external file. The file needs to contain the header, which contains the engine identifier, the API version, and the library name: `#!js api_version=1.0 name=myFirstLibrary`.
+
+```JavaScript
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('hello', ()=> {
+  return 'Hello from an external file'
+})
+```
+
+Use the `redis-cli -x` option to send the file with the command and use the `TFUNCTION LOAD REPLACE` to replace the inline library with the one from the `main.js` file.
+
+```Shell
+redis-cli -x TFUNCTION LOAD REPLACE < ./main.js
+```
+
+## Creating triggers
+
+Functions within Redis can respond to events using keyspace triggers. While the majority of these events are initiated by command invocations, they also include events that occur when a key expires or is removed from the database.
+
+For the full list of supported events, please refer to the [Redis keyspace notifications page]({{< relref "develop/use/keyspace-notifications#events-generated-by-different-commands/?utm_source=redis\&utm_medium=app\&utm_campaign=redisinsight_triggers_and_functions_guide" >}}).
+
+The following code creates a new keyspace trigger that adds a new field to a new or updated hash with the latest update time. 
+
+Load the code in your database:
+
+```redis Load keyspace example
+TFUNCTION LOAD REPLACE "#!js name=myFirstLibrary api_version=1.0\n 
+    function addLastUpdatedField(client, data) {
+        if(data.event == 'hset') {
+            var currentDateTime = Date.now();
+            client.call('hset', data.key, 'last_updated', currentDateTime.toString());
+        }
+    } 
+    redis.registerKeySpaceTrigger('addLastUpdated', 'fellowship:', addLastUpdatedField);" // Register the KeySpaceTrigger 'AddLastUpdated' for keys with the prefix 'fellowship' with a callback to the function 'addLastUpdatedField'
+```
+
+Add a new hash with the required prefix to trigger our function.
+
+```Shell
+127.0.0.1:6379> HSET fellowship:1 name "Frodo Baggins" title "The One Ring Bearer"
+```
+
+Check if the last updated time is added to the example.
+
+```Shell
+127.0.0.1:6379> HGETALL fellowship:1
+1) "name"
+2) "Frodo Baggins"
+3) "title"
+4) "The One Ring Bearer"
+5) "last_updated"
+6) "1693238681822"
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Methods for debugging your Redis Stack functions
+linkTitle: Debugging
+title: Debugging
+weight: 5
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/debugging/
+---
+## Overview
+
+There are two methods you can use to debug your Redis Stack functions:
+
+1. Make judicious use of the `redis.log` function, which writes to the Redis log file.
+1. Use Redis [pub/sub]({{< relref "/develop/interact/pubsub" >}}).
+
+### Use `redis.log`
+
+If you have access to the Redis log files, `redis.log` is a good method to use when debugging. However, there is a drawback. Redis Cloud users do not have access to the Redis log files, and it's pretty common that only system administrators have access to them on self-hosted installations. Fortunately, you can also use Redis pub/sub, which will be discussed in the next section.
+
+You don't have to do anything special to use `redis.log`, as it's always available. Here is an example:
+
+```javascript
+#!js api_version=1.0 name=lib
+
+redis.registerFunction('hello', ()=> {
+  redis.log('Hello log')
+  return 'Hello from an external file'
+})
+```
+
+After loading the library and executing the function with `TFCALL`, you'll see something like the following in your Redis log file:
+
+```
+45718:M 01 Nov 2023 07:02:40.593 * <redisgears_2> Hello log
+```
+
+### Use Redis pub/sub
+
+If you don't have access to your Redis database log files, you can use pub/sub. The following example demonstrates how to use the [client.call]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/JavaScript_API#clientcall" >}}) API to publish to a pub/sub channel.
+
+```javascript
+#!js api_version=1.0 name=lib
+
+const logChannel = 'tfLogChannel'
+
+function publog(client, message) {
+  client.call('publish', logChannel, message)
+}
+
+redis.registerFunction('tflog', (client) => {
+  publog(client, 'sample pub/sub log message')
+  return 'sample'
+})
+```
+In a CLI session, subscribe to the `tfLogChannel` channel and watch for messages.
+
+```redis
+$ redis-cli
+127.0.0.1:6379> subscribe tfLogChannel
+1) "subscribe"
+2) "tfLogChannel"
+3) (integer) 1
+Reading messages... (press Ctrl-C to quit or any key to type command)
+```
+
+In another CLI session, load the library, replacing what was already there, and then call the new function:
+
+```redis
+127.0.0.1:6379> TFCALL lib.tflog 0
+"sample"
+```
+
+You'll see the following in the previous CLI session:
+
+```redis
+1) "message"
+2) "tfLogChannel"
+3) "sample pub/sub log message"
+```
+
+There is a downside to using pub/sub. Redis pub/sub provides at-most-once message delivery semantics, which means that once a message is sent, it won't be sent again. So, if a message isn't consumed, it's gone forever. This is likely okay for debugging, but for the longer term, `redis.log` is the better solution for log persistence.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: How to develop for triggers and functions
+title: Development
+weight: 4
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/development/
+---
+
+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]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/concepts/JavaScript_API" >}}), which allows your preferred development environment to provide autocompletion and type checking. You can install this information using the following command:
+
+```bash
+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:
+
+```json
+"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:
+
+```bash
+$ npm init -y -f
+npm WARN using --force Recommended protections disabled.
+Wrote to /home/work/my_first_project/package.json:
+
+{
+  "name": "my_first_project",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}
+```
+
+Update the `package.json` to add the gears API to the `devDependencies` object.
+
+```js
+{
+  "name": "my_first_project",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "devDependencies": {
+    "@redis/gears-api": "https://gitpkg.now.sh/RedisGears/RedisGears/js_api"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}
+```
+
+Install the dependencies using `npm install`.
+
+Create a new file, `index.js` and import the gears-api module. While this step is not strictly necessary, doing so will enable code intelligent code completion when adding the `registerFunction`:
+
+```JavaScript
+#!js name=lib api_version=1.0
+
+import { redis } from '@redis/gears-api';
+
+redis.registerFunction("test", ()=>{
+    return "test";
+});
+```
+
+To automate the deployment, update the `scripts` section in `package.json`:
+
+```json
+"scripts": {
+  "deploy": "gears-api index.js"
+}
+```
+
+Now you can deploy your code to Redis Stack using the following command:
+
+```bash
+> npm run deploy -- -r redis://localhost:6379
+
+> deploy
+> gears-api index.js
+
+Deployed! :)
+```
+
+The provided URL should follow the following format:
+
+`<redis[s]://[[username][:password]@][host][:port][/db-number]>`
+
+You can now run your Redis Stack function:
+
+```bash
+127.0.0.1:6379> TFCALL lib.test 0
+"test"
+```
+
+## Example function using a third-party `npm` package
+
+If you want to use a third-party `npm` package in your Redis Stack function, the overall process is nearly the same as already discussed, with just a couple of differences.
+
+First, you'll need to install your package using `npm install`. For this example, the `pi` symbol from the `math.js` library will be used in a simple function that calculates the area of a circle.
+
+```bash
+npm install mathjs
+```
+
+Note: your `package.json` file will also be updated with the new dependency. For example:
+
+```json
+"dependencies": {
+    "mathjs": "^12.0.0"
+}
+```
+
+Next, you'll import the required symbol(s) into your function.
+
+```javascript
+#!js api_version=1.0 name=lib
+
+import { redis } from '@redis/gears-api';
+import { pi } from 'mathjs';
+
+function calculateCircleArea(client, radius) {
+  return pi * radius * radius;
+}
+
+redis.registerFunction('calculateArea', calculateCircleArea);
+```
+
+Load and run your new function as described in the previous section.---
+bannerChildren: true
+bannerText: 'The Redis Stack triggers and functions feature preview has ended and it will not be promoted to GA.'
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+description: Trigger and execute JavaScript functions in the Redis process
+linktitle: Triggers and functions
+stack: true
+title: Triggers and functions
+weight: 16
+aliases:
+  - /develop/interact/programmability/triggers-and-functions/
+  - /commands/tfcall/
+  - /commands/tfcallasync/
+  - /commands/tfunction-delete/
+  - /commands/tfunction-list/
+  - /commands/tfunction-load/
+---
+
+[![discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/xTbqgTB)
+[![Github](https://img.shields.io/static/v1?label=&message=repository&color=5961FF&logo=github)](https://github.com/RedisGears/RedisGears/)
+
+The triggers and functions feature of Redis Stack allows running JavaScript functions inside Redis. These functions can be executed on-demand, by an event-driven trigger, or by a stream processing trigger.
+
+## Quick links
+* [Command documentation](https://github.com/RedisGears/RedisGears/tree/master/docs/commands)
+* [Source code](https://github.com/RedisGears/RedisGears)
+* [Latest release](https://github.com/RedisGears/RedisGears/releases)
+* [Docker image](https://hub.docker.com/r/redis/redis-stack-server/)
+
+## Primary features
+
+* JavaScript engine for functions
+* On-demand functions
+* Keyspace triggers
+* Stream triggers
+* Async handling of functions
+* Read data from across the cluster
+
+## Cluster support
+
+Triggers and functions support deployment and execution of functions across a cluster. Functions are executed on the correct shard based on the key that is changed or read functions can be executed on all to return a correct view of the data.
+
+## References
+
+### Blog posts
+
+- [Expanding the Database Trigger Features in Redis](https://redis.com/blog/database-trigger-features/)
+
+## Overview
+---
+Title: "Graph\_quick start"
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: "Graph\_quick start"
+linkTitle: Quick start
+weight: 20
+---
+
+## Prerequisites
+
+For this quick start tutorial, you need:
+
+- A Redis database with the RedisGraph module enabled. You can use either:
+
+    - A [Redis Cloud]({{< relref "/operate/oss_and_stack/stack-with-enterprise/stack-quickstart" >}}) database
+
+    - A [Redis Enterprise Software]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database" >}}) database
+
+- [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) command-line tool
+
+- [`redis-py`](https://github.com/redis/redis-py) client library v4.1.0 or later
+
+## Graph with `redis-cli`
+
+To begin, [connect to your database]({{< relref "/operate/rs/references/cli-utilities/redis-cli#connect-to-a-database" >}}) with `redis-cli`.
+
+### Create a graph
+
+When you create a graph, you can define nodes and the relationships between them with this format:
+
+`(:<node 1>)-[:<relationship>]->(:<node 2>)`
+
+To define multiple nodes and relationships in a single creation query, separate the entries with commas.
+
+For example, use the [`CREATE`](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#create) query to create a new graph of motorcycle riders and teams participating in the MotoGP league:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'}), (:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'}), (:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})"
+1) 1) "Labels added: 2"
+   2) "Nodes created: 6"
+   3) "Properties set: 6"
+   4) "Relationships created: 3"
+   5) "Cached execution: 0"
+   6) "Query internal execution time: 0.385472 milliseconds"
+```
+
+### Add nodes
+
+You can add new nodes to a previously created graph:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "CREATE (:Rider {name:'Jorge Lorenzo'})"
+1) 1) "Nodes created: 1"
+   2) "Properties set: 1"
+   3) "Cached execution: 0"
+   4) "Query internal execution time: 0.185841 milliseconds"
+```
+
+### Add relationships
+
+To create new relationships between nodes of a graph:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider), (t:Team) WHERE r.name = 'Jorge Lorenzo' and t.name = 'Honda' CREATE (r)-[:rides]->(t)"
+1) 1) "Relationships created: 1"
+   2) "Cached execution: 0"
+   3) "Query internal execution time: 0.356578 milliseconds"
+```
+
+### Query the graph
+
+After you create a graph, you can use the [`GRAPH.QUERY`](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md) command to query the graph's data.
+
+The following example returns which motorcycle riders compete for team Yamaha:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team) WHERE t.name = 'Yamaha' RETURN r,t"
+1) 1) "r"
+   2) "t"
+2) 1) 1) 1) 1) "id"
+            2) "0"
+         2) 1) "labels"
+            2) 1) "Rider"
+         3) 1) "properties"
+            2) 1) 1) "name"
+                  2) "Valentino Rossi"
+      2) 1) 1) "id"
+            2) "1"
+         2) 1) "labels"
+            2) 1) "Team"
+         3) 1) "properties"
+            2) 1) 1) "name"
+                  2) "Yamaha"
+3) 1) "Cached execution: 0"
+   2) "Query internal execution time: 0.500535 milliseconds"
+```
+
+You can also use [functions](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#functions) to create more complex queries.
+
+For example, you can use the `count` function to check how many riders represent team Honda:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team {name:'Honda'}) RETURN count(r)"
+1) 1) "count(r)"
+2) 1) 1) "2"
+3) 1) "Cached execution: 0"
+   2) "Query internal execution time: 0.445760 milliseconds"
+```
+
+### Delete nodes
+
+You can use the [`DELETE`](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#delete) query to remove a specific node and its relationships from the graph:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider {name: 'Dani Pedrosa'}) DELETE r"
+1) 1) "Nodes deleted: 1"
+   2) "Relationships deleted: 1"
+   3) "Cached execution: 0"
+   4) "Query internal execution time: 0.276815 milliseconds"
+```
+
+### Delete relationships
+
+You can also use the [`DELETE`](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#delete) query to delete a node's relationships without removing any nodes:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (:Rider {name: 'Valentino Rossi'})-[r:rides]->() DELETE r"
+1) 1) "Relationships deleted: 1"
+   2) "Cached execution: 0"
+   3) "Query internal execution time: 0.348346 milliseconds"
+```
+
+### Delete a graph
+
+To delete an entire graph, including all nodes and relationships, run the [`GRAPH.DELETE`](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.delete.md) command:
+
+```sh
+127.0.0.1:12543> GRAPH.DELETE MotoGP
+"Graph removed, internal execution time: 0.013138 milliseconds"
+```
+
+## Graph with Python
+
+If you want to use graphs within an application, you can use one of these [client libraries](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/clients.md).
+
+The following example uses the Redis Python client library [redis-py](https://github.com/redis/redis-py), which supports graph commands as of v4.1.0.
+
+This Python code creates a graph that represents friendships between users on a social media website. It also shows how to run queries and change relationships between users.
+
+```python
+import redis
+from redis.commands.graph.edge import Edge
+from redis.commands.graph.node import Node
+
+# Connect to a database
+r = redis.Redis(host="<endpoint>", port="<port>", 
+                password="<password>")
+
+# Create nodes that represent users
+users = { "Alex": Node(label="Person", properties={"name": "Alex", "age": 35}),
+          "Jun": Node(label="Person", properties={"name": "Jun", "age": 33}),
+          "Taylor": Node(label="Person", properties={"name": "Taylor", "age": 28}),
+          "Noor": Node(label="Person", properties={"name": "Noor", "age": 41}) }
+
+# Define a graph called SocialMedia
+social_graph = r.graph("SocialMedia")
+
+# Add users to the graph as nodes
+for key in users.keys():
+    social_graph.add_node(users[key])
+
+# Add relationships between user nodes
+social_graph.add_edge( Edge(users["Alex"], "friends", users["Jun"]) )
+# Make the relationship bidirectional
+social_graph.add_edge( Edge(users["Jun"], "friends", users["Alex"]) )
+
+social_graph.add_edge( Edge(users["Jun"], "friends", users["Taylor"]) )
+social_graph.add_edge( Edge(users["Taylor"], "friends", users["Jun"]) )
+
+social_graph.add_edge( Edge(users["Jun"], "friends", users["Noor"]) )
+social_graph.add_edge( Edge(users["Noor"], "friends", users["Jun"]) )
+
+social_graph.add_edge( Edge(users["Alex"], "friends", users["Noor"]) )
+social_graph.add_edge( Edge(users["Noor"], "friends", users["Alex"]) )
+
+# Create the graph in the database
+social_graph.commit()
+
+# Query the graph to find out how many friends Alex has
+result1 = social_graph.query("MATCH (p1:Person {name: 'Alex'})-[:friends]->(p2:Person) RETURN count(p2)")
+print("Alex's original friend count:", result1.result_set)
+
+# Delete a relationship without deleting any user nodes
+social_graph.query("MATCH (:Person {name: 'Alex'})<-[f:friends]->(:Person {name: 'Jun'}) DELETE f")
+
+# Query the graph again to see Alex's updated friend count
+result2 = social_graph.query("MATCH (p1:Person {name: 'Alex'})-[:friends]->(p2:Person) RETURN count(p2)")
+print("Alex's updated friend count:", result2.result_set)
+
+# Delete the entire graph
+social_graph.delete()
+```
+
+Example output:
+
+```text
+$ ./quick_start.py
+Alex's original friend count: [[2]]
+Alex's updated friend count: [[1]]
+```
+
+## Visualize graphs with Redis Insight
+
+You can use the [Redis Insight]({{< relref "/develop/tools/insight" >}}) workbench to visualize the relationships between the nodes of your graph.
+
+1. Connect to your database with Redis Insight. You can [connect manually]({{< relref "develop/tools/insight#add-a-standalone-redis-database" >}}) or use the [auto-discovery]({{< relref "develop/tools/insight#auto-discovery-for-redis-cloud-databases" >}}) feature.
+
+1. Select the **Workbench** button:
+
+   {{<image filename="images/ri/icon-workbench.png" width="30px" alt="The Workbench icon">}}
+
+1. Enter a graph query in the text editor.
+
+   For example, this query returns all nodes and relationships in the graph:
+
+   ```sh
+   GRAPH.QUERY MotoGP "MATCH (n) RETURN n"
+   ```
+
+1. Select **Run**:
+
+   {{<image filename="images/ri/icon-run-command.png" width="30px" alt="The Run command icon">}}
+
+After you run a query, the output log displays a visual representation of your graph's nodes and relationships:
+
+{{<image filename="images/modules/visualize-graph.png" alt="Visualize a graph with Redis Insight workbench.">}}
+
+## More info
+
+- [Graph commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph/commands" >}})
+- [RedisGraph client libraries](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/clients.md)
+- [RedisGraph documentation on GitHub](https://github.com/RedisGraph/RedisGraph/tree/master/docs/docs)
+---
+Title: Graph commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Lists graph commands and provides links to the command reference pages.
+linkTitle: Commands
+toc: 'false'
+weight: 25
+---
+
+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<br />Flexible & Annual | Redis Cloud<br />Free & Fixed | Description |
+|:--------|:----------------------|:-----------------|:-----------------|:------|
+| [GRAPH.CONFIG GET](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.config-get.md) | <span title="Not supported"><nobr>&#x274c; Not supported</span> | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[2](#table-note-2)</sup> | <span title="Not supported"><nobr>&#x274c; Not supported</nobr></span> | Returns the current value of a [RedisGraph configuration parameter](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#redisgraph-configuration-parameters). |
+| [GRAPH.CONFIG SET](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.config-set.md) | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[1](#table-note-1)</sup> | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[2](#table-note-2)</sup> | <span title="Not supported"><nobr>&#x274c; Not supported</nobr></span> | Changes the value of a [RedisGraph configuration parameter](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#redisgraph-configuration-parameters). |
+| [GRAPH.DELETE](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.delete.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Removes the graph and its entities. |
+| [GRAPH.EXPLAIN](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.explain.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Displays the query execution plan but does not run the query. |
+| [GRAPH.LIST](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.list.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Lists all graph keys. |
+| [GRAPH.PROFILE](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.profile.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Runs a query and displays the execution plan with metrics for each operation. |
+| [GRAPH.QUERY](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Runs a query against a graph. Supports a variety of [clauses](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#query-structure) and [functions](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.query.md#functions). |
+| [GRAPH.RO_QUERY](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.ro_query.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Runs a read-only query against a graph. |
+| [GRAPH.SLOWLOG](https://github.com/RedisGraph/RedisGraph/blob/master/docs/commands/graph.slowlog.md) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns the slowest 10 queries run against a specific graph. |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>Use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) to change RedisGraph configuration for Redis Enterprise Software. See [RedisGraph configuration compatibility with Redis Enterprise]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph/config" >}}) for more information and examples.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>[Contact support](https://redis.com/company/support/) to view the current RedisGraph configuration values or request configuration changes for Flexible or Annual Redis Cloud subscriptions.---
+Title: Graph configuration compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Graph configuration settings supported by Redis Enterprise.
+linkTitle: Configuration
+toc: 'false'
+weight: 30
+---
+
+You cannot use `GRAPH.CONFIG SET` to configure RedisGraph in [Redis Enterprise Software]({{< relref "/operate/rs" >}}) or [Redis Cloud]({{< relref "/operate/rc" >}}). Instead, use one of the following methods.
+
+For Redis Cloud:
+
+- _Flexible or Annual [subscriptions]({{< relref "/operate/rc/subscriptions" >}})_: contact [support](https://redis.com/company/support/) to request a configuration change.
+    
+- _Free or Fixed subscriptions_: you cannot change RedisGraph configuration.
+
+For Redis Enterprise Software, use either:
+
+- [`rladmin tune db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+    ```sh
+    $ rladmin tune db db:<ID|name> module_name graph \
+        module_config_params "setting-name setting-value"
+    ```
+
+- [Configure module]({{< relref "/operate/rs/references/rest-api/requests/modules/config" >}}) REST API request:
+
+    ```sh
+    POST /v1/modules/config/bdb/<ID>
+    {
+      "modules": [
+        {
+          "module_name": "graph",
+          "module_args": "setting-name setting-value"
+        }
+      ]
+    }
+    ```
+
+| Setting | Redis<br />Enterprise | Redis<br />Cloud | Notes |
+|:--------|:----------------------|:-----------------|:------|
+| [CACHE_SIZE](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#cache_size) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 25 |
+| [MAX_QUEUED_QUERIES](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#max_queued_queries) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 25 |
+| [NODE_CREATION_BUFFER](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#node_creation_buffer) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 16384 |
+| [OMP_THREAD_COUNT](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#omp_thread_count) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual\*</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | \* Updates automatically when you change your plan.<br /><br />Redis Enterprise default: Set by plan<br /><br />Redis Cloud defaults:<br />• Flexible & Annual: Set by plan<br />• Free & Fixed: 1<br /> |
+| [QUERY_MEM_CAPACITY](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#query_mem_capacity) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 100000000 |
+| [RESULTSET_SIZE](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#resultset_size) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 10000 |
+| [THREAD_COUNT](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#thread_count) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual\*</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | \* Updates automatically when you change your plan.<br /><br />Redis Enterprise default: Set by plan<br /><br />Redis Cloud defaults:<br />• Flexible & Annual: Set by plan<br />• Free & Fixed: 1<br /> |
+| [TIMEOUT](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#timeout) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 100 |
+| [VKEY_MAX_ENTITY_COUNT](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#vkey_max_entity_count) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Not supported"><nobr>&#x274c; Free & Fixed</nobr></span> | Default: 100000 |
+---
+Title: Graph
+alwaysopen: false
+bannerChildren: true
+bannerText: Redis, Inc. has announced the end of life of RedisGraph. We will carry
+  out the process gradually and in accordance with our commitment to our customers.
+  See [details](https://redis.io/blog/redisgraph-eol/).
+categories:
+- docs
+- operate
+- stack
+description: RedisGraph is a queryable graph database built on Redis.
+hideListLinks: true
+linkTitle: Graph
+toc: 'true'
+weight: 40
+---
+RedisGraph is the first queryable [Property Graph](https://github.com/opencypher/openCypher/blob/master/docs/property-graph-model.adoc) database to use [sparse matrices](https://en.wikipedia.org/wiki/Sparse_matrix) to represent the [adjacency matrix](https://en.wikipedia.org/wiki/Adjacency_matrix) in graphs and [linear algebra](http://faculty.cse.tamu.edu/davis/GraphBLAS.html) to query the graph.
+
+## Primary features
+
+- Based on the [Property Graph Model](https://github.com/opencypher/openCypher/blob/master/docs/property-graph-model.adoc)
+    - Nodes (vertices) and Relationships (edges) that may have attributes
+    - Nodes that can be labeled
+    - Relationships have a relationship type
+- Graphs represented as sparse adjacency matrices
+- [Cypher](http://www.opencypher.org/) as query language
+    - Cypher queries translated into linear algebra expressions
+
+## Commands
+
+See [Graph commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph/commands" >}}) for a list of graph commands that are supported in Redis Enterprise.
+
+## Clients
+
+For a list of available RedisGraph clients, see [RedisGraph client libraries](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/clients.md).
+
+## Configuration
+
+See [Configuration parameters](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md) for the complete list of RedisGraph configuration parameters.
+
+To learn which configuration parameters are supported in Redis Enterprise, see [Graph configuration compatibility with Redis Enterprise]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph/config" >}}).
+
+## Design
+
+For an overview of RedisGraph's design, see [RedisGraph: A High Performance In-Memory Graph Database](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/design/_index.md).
+
+### Client specification
+
+RedisGraph client libraries should follow the [Technical specification for writing RedisGraph client libraries](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/design/client_spec.md).
+
+### Result set structure
+
+[RedisGraph result set structure](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/design/result_structure.md) describes the format RedisGraph uses to print data when using `redis-cli`.
+
+### GRAPH.BULK endpoint
+
+You can import new graphs from CSV files using `redisgraph-bulk-loader`.
+
+See the [`GRAPH.BULK` implementation details](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/design/bulk_spec.md) for more information.
+
+## Data types
+
+RedisGraph supports a number of distinct data types, including:
+
+- Graph types:
+    - Nodes
+    - Relationships
+    - Paths
+
+- Scalar types:
+    - Strings
+    - Booleans
+    - Integers
+    - Floating-point values
+    - Geospatial points
+    - Null
+  
+- Collection types:
+    - Arrays
+    - Maps
+
+See [RedisGraph data types](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/datatypes.md) for details.
+
+## Cypher coverage
+
+RedisGraph implements a subset of the Cypher language. See [Cypher coverage](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/cypher_support.md) for more information.
+
+## Path algorithms
+
+To learn how to find single-pair and single-source paths using `algo.SPpaths` and `algo.SSpaths`, see [Path algorithms](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/path_algorithm.md).
+
+## Known limitations
+
+RedisGraph has several [known limitations](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/known_limitations.md).
+
+## More info
+
+- [Graph quick start]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph/graph-quickstart" >}})
+
+- [RedisGraph documentation on GitHub](https://github.com/RedisGraph/RedisGraph/tree/master/docs/docs)
+
+- [References](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/References.md)
+
+- [RedisGraph source](https://github.com/RedisGraph/RedisGraph/)
+---
+Title: Deprecated Redis Open Source features and modules
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Features (modules) that have been deprecated or replaced with a new version.
+hideListLinks: true
+linkTitle: Deprecated features
+weight: 90
+---
+
+The following features (modules) have been deprecated or replaced with a new version:
+
+{{<table-children columnNames="Feature,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle">}}
+---
+Title: Redis Enterprise and Redis Open Source feature compatibility
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Describes the Redis Enterprise features supported by each Redis Open Source
+  feature.
+linkTitle: Enterprise feature compatibility
+weight: 8
+---
+
+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.
+
+| Feature | Redis Enterprise<br/>Software | Redis Enterprise<br/>Cloud |
+|:-------|:-------------------------|:-----------------------|
+| [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) | &#x2705; Supported | &#x2705; Supported |
+| [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})   | &#x2705; Supported | &#x2705; Supported |
+| [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}) | &#x2705; Supported | &#x2705; Supported |
+| [Probabilistic]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}) | &#x2705; Supported | &#x2705; Supported |
+| [Gears]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1" >}}) | &#x2705; Supported | &#x274c; Not supported |
+| [Triggers and functions]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/" >}}) | &#x26A0;&#xFE0F; Deprecated | &#x26A0;&#xFE0F; Deprecated |
+| [Graph]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph" >}}) | &#x26A0;&#xFE0F; Deprecated | &#x26A0;&#xFE0F; Deprecated |
+
+
+## Feature compatibility
+
+The following tables show Redis Enterprise feature support for each Redis Open Source feature. 
+
+Version numbers indicate when the feature was first supported.  If you're using an earlier version than what's shown in the table, the feature is not supported.
+
+For details about individual features, see the corresponding documentation.
+
+| Feature name/capability   | [Search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search" >}}) | [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}})    | 
+|---------------------------|:--------------:|:------------:|
+| Active-Active (CRDB)[^5]  | Yes (v2.0)     | Yes (v2.2)   |
+| Backup/Restore            | Yes (v1.4)     | Yes (v1.0)   |
+| Clustering                | Yes (v1.6)[^3] | Yes (v1.0)   |
+| Custom hashing policy     | Yes (v2.0)     | Yes (v1.0)   |
+| Eviction expiration       | Yes (v2.0)     | Yes (v1.0)   |
+| Failover/migration        | Yes (v1.4)     | Yes (v1.0)   |
+| Internode encryption      | Yes (v2.0.11)  | Yes (v1.0.8) |
+| Module data types         | Yes            | Yes          |
+| Persistence (AOF)         | Yes (v1.4)     | Yes (v1.0)   |
+| Persistence (snapshot)    | Yes (v1.6)     | Yes (v1.0)   |
+| Auto Tiering [^4]         | Yes (v2.0)     | Yes (v1.0)   |
+| Replica Of                | Yes (v1.6)[^2] | Yes (v1.0)   |
+| Reshard/rebalance         | Yes (v2.0)     | Yes (v1.0)   |
+
+[^1]: Graphs are compatible with clustering; however, individual graphs contained in a key reside in a single shard, which can affect pricing.  To learn more, [contact support](https://redis.com/company/support/).
+
+[^2]: RediSearch version 1.6 supported Replica Of only between databases with the same number of shards.  This limitation was fixed in v2.0. 
+
+[^3]: You cannot use search and query with the [OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}).
+
+[^4]: You currently cannot combine Auto Tiering with Redis Open Source features in Redis Cloud. 
+
+[^5]: With the exception of JSON, you currently cannot combine Active-Active with Redis Open Source features in Redis Cloud.
+
+[^6]: Although time series are compatible with Auto Tiering, the entire series either lives in RAM or on flash.
+
+| Feature name/capability | [Time series]({{< relref "/operate/oss_and_stack/stack-with-enterprise/timeseries" >}}) | [Probabilistic]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom" >}}) | [Gears]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1" >}}) |
+|--------------------------|:--------------:|:------------:|:----------:|
+| Active-Active (CRDB)[^5] | No             | No           | Yes (v1.0) |
+| Backup/Restore           | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Clustering               | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Custom hashing policy    | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Eviction expiration      | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Failover/migration       | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Internode encryption     | Yes (v1.4.9)   | Yes (v2.2.6) | Yes (v1.2) |
+| Module data types        | Yes            | Yes          | Yes        |
+| Persistence (AOF)        | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Persistence (snapshot)   | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+| Auto Tiering [^4]        | Yes (v1.6)[^6] | Yes (vTBD)   | Yes (vTBD) |
+| Replica Of               | Yes (v1.2)     | Yes (v2.0)   | No         |
+| Reshard/rebalance        | Yes (v1.2)     | Yes (v2.0)   | Yes (v1.0) |
+
+
+## Feature descriptions
+
+The following table briefly describes each feature shown in the earlier tables.
+
+| Feature name/capability | Description |
+|-------------------------|-------------|
+| Active-Active (CRDB)    | Compatible with Active-Active (CRDB) databases  |
+| Backup/Restore          | Supports import and export features |
+| Clustering              | Compatible with sharded databases and shard migration |
+| Custom hashing policy   | Compatible with databases using custom hashing policies |
+| Eviction expiration     | Allows data to be evicted when the database reaches memory limits |
+| Failover/migration      | Compatible with primary/replica failover and the migration of shards between nodes within the cluster |
+| Internode encryption    | Compatible with encryption on the data plane |
+| Persistence (AOF)       | Compatible with databases using AoF persistence |
+| Persistence (snapshot)  | Compatible with databases using snapshot persistence | 
+| Auto Tiering    | Compatible with Auto Tiering |
+| Replica Of              | Compatible with Active-Passive replication | 
+| Reshard/rebalance       | Compatible with database scaling for clustered databases, which redistributes data between the new shards. |
+
+<!-- 
+    Individual footnotes are rendered below the following heading.  
+    Thus, any additional sections need to be placed above this comment.
+-->
+## Footnotes
+---
+Title: Probabilistic data structure commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Lists probabilistic data structure commands and provides links to the
+  command reference pages.
+linkTitle: Commands
+toc: 'true'
+weight: 25
+---
+
+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<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [BF.ADD]({{< relref "commands/bf.add" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds an item to the filter. |
+| [BF.EXISTS]({{< relref "commands/bf.exists" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Checks if an item exists in the filter. |
+| [BF.INFO]({{< relref "commands/bf.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns information about a Bloom filter. |
+| [BF.INSERT]({{< relref "commands/bf.insert" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds multiple items to a filter. If the key does not exist, it creates a new filter. |
+| [BF.LOADCHUNK]({{< relref "commands/bf.loadchunk" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Restores a Bloom filter previously saved with [BF.SCANDUMP]({{< relref "commands/bf.scandump" >}}). |
+| [BF.MADD]({{< relref "commands/bf.madd" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds multiple items to the filter. |
+| [BF.MEXISTS]({{< relref "commands/bf.mexists" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | For multiple items, checks if each item exists in the filter. |
+| [BF.RESERVE]({{< relref "commands/bf.reserve" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Creates a Bloom filter. Sets the false positive rate and capacity. |
+| [BF.SCANDUMP]({{< relref "commands/bf.scandump" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Starts an incremental save of a Bloom filter. |
+
+## Cuckoo filter commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [CF.ADD]({{< relref "commands/cf.add" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds an item to a filter. |
+| [CF.ADDNX]({{< relref "commands/cf.addnx" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds an item to a filter only if the item does not already exist. |
+| [CF.COUNT]({{< relref "commands/cf.count" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the probable number of times an item occurs in the filter. |
+| [CF.DEL]({{< relref "commands/cf.del" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes one instance of an item from the filter. |
+| [CF.EXISTS]({{< relref "commands/cf.exists" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Checks if an item exists in the filter. |
+| [CF.INFO]({{< relref "commands/cf.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns information about a cuckoo filter. |
+| [CF.INSERT]({{< relref "commands/cf.insert" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds multiple items to a filter. Optionally sets the capacity if the filter does not already exist. |
+| [CF.INSERTNX]({{< relref "commands/cf.insertnx" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | 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]({{< relref "commands/cf.loadchunk" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Restores a cuckoo filter previously saved with [CF.SCANDUMP]({{< relref "commands/cf.scandump" >}}). |
+| [CF.MEXISTS]({{< relref "commands/cf.mexists" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | For multiple items, checks if each item exists in the filter. |
+| [CF.RESERVE]({{< relref "commands/cf.reserve" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Creates a cuckoo filter and sets its capacity. |
+| [CF.SCANDUMP]({{< relref "commands/cf.scandump" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Starts an incremental save of a cuckoo filter. |
+
+## Count-min sketch commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [CMS.INCRBY]({{< relref "commands/cms.incrby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Increases item counts. |
+| [CMS.INFO]({{< relref "commands/cms.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns width, depth, and total count of the sketch. |
+| [CMS.INITBYDIM]({{< relref "commands/cms.initbydim" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Initializes a count-min sketch to the specified dimensions (width and depth). |
+| [CMS.INITBYPROB]({{< relref "commands/cms.initbyprob" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Initializes a count-min sketch to allow the specified overestimation percent for the item count and the probability of overestimation. |
+| [CMS.MERGE]({{< relref "commands/cms.merge" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Merges several sketches into one sketch. |
+| [CMS.QUERY]({{< relref "commands/cms.query" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the count for one or more items in a sketch. |
+
+## Top-k commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [TOPK.ADD]({{< relref "commands/topk.add" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds an item to the data structure. |
+| [TOPK.COUNT]({{< relref "commands/topk.count" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns probable item counts. |
+| [TOPK.INCRBY]({{< relref "commands/topk.incrby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Increases the score of an item by the specified number. |
+| [TOPK.INFO]({{< relref "commands/topk.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the number of required items (k), width, depth, and decay values. |
+| [TOPK.LIST]({{< relref "commands/topk.list" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the keys of items in the top-k list. Optionally returns their item counts. |
+| [TOPK.QUERY]({{< relref "commands/topk.query" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Checks whether an item is one of top-k items. |
+| [TOPK.RESERVE]({{< relref "commands/topk.reserve" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Initializes a top-k with the specified number of top occurring items to keep, width, depth, and decay. |
+
+## T-digest sketch commands
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [TDIGEST.ADD]({{< relref "commands/tdigest.add" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Adds one or more samples to a t-digest sketch. |
+| [TDIGEST.CDF]({{< relref "commands/tdigest.cdf" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Estimates the fraction of all observations which are less than or equal to the specified value. |
+| [TDIGEST.CREATE]({{< relref "commands/tdigest.create" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Allocates memory and initializes a t-digest sketch. |
+| [TDIGEST.INFO]({{< relref "commands/tdigest.info" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns information about the t-digest sketch. |
+| [TDIGEST.MAX]({{< relref "commands/tdigest.max" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the maximum value from the sketch. |
+| [TDIGEST.MERGE]({{< relref "commands/tdigest.merge" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Copies values from one sketch to another. |
+| [TDIGEST.MIN]({{< relref "commands/tdigest.min" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the minimum value from the sketch. |
+| [TDIGEST.QUANTILE]({{< relref "commands/tdigest.quantile" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Estimates one or more cutoffs. |
+| [TDIGEST.RESET]({{< relref "commands/tdigest.reset" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Resets the sketch and reinitializes it. |
+| [TDIGEST.TRIMMED_MEAN]({{< relref "commands/tdigest.trimmed_mean" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Estimates the mean value from the sketch, excluding values outside the specified range. |
+---
+Title: Probabilistic data structure configuration compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Probabilistic data structure configuration settings supported by Redis Enterprise Software and Redis Cloud.
+linkTitle: Configuration
+toc: 'false'
+weight: 30
+---
+
+## Configure probabilistic data structures in Redis Software
+
+[Redis Enterprise Software]({{< relref "/operate/rs" >}}) lets you manually change any [RedisBloom configuration setting]({{< relref "/develop/data-types/probabilistic/" >}}configuration/#redisbloom-configuration-parameters).
+
+To change the RedisBloom configuration using the Redis Software Cluster Manager UI:
+
+  1. From the **Databases** list, select the database, then click **Configuration**.
+
+  1. Select the **Edit** button.
+
+  1. In the **Capabilities** section, click **Parameters**.
+
+  1. After you finish editing the module's configuration parameters, click **Done** to close the parameter editor.
+
+  1. Click **Save**.
+
+## Configure probabilistic data structures in Redis Cloud
+
+[Redis Cloud]({{< relref "/operate/rc" >}}) does not let you configure RedisBloom manually. However, if you have a Flexible or Annual [subscription]({{< relref "/operate/rc/subscriptions" >}}), you can contact [support](https://redis.com/company/support/) to request a configuration change. You cannot change RedisBloom configuration for Free or Fixed subscriptions.
+
+## Configuration settings
+
+See [configuration parameters]({{< relref "/develop/data-types/probabilistic/configuration" >}}) in the Develop section for parameter details and compatibility with Redis Software and Redis Cloud.
+---
+Title: Probabilistic data structures
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Probabilistic data structures
+hideListLinks: true
+linkTitle: Probabilistic
+weight: 60
+---
+A Bloom filter is a probabilistic data structure which provides an
+efficient way to verify that an entry is certainly *not* in a set. This
+makes it especially ideal when trying to search for items on
+expensive-to-access resources (such as over a network or disk): If I
+have a large on-disk database and I want to know if the key *foo* exists
+in it, I can query the Bloom filter first, which tells me with a
+certainty whether it potentially exists (and then the disk lookup can
+continue) or whether it does *not* exist, and in this case I can forego
+the expensive disk lookup and simply send a negative reply up the stack.
+
+While it's possible to use other data structures (such as a hash table)
+to perform this, Bloom filters are also especially useful in that they
+occupy very little space per element, typically counted in the number of
+*bits* (not bytes!). There exists a percentage of false positives
+(which is controllable), but for an initial test of whether a key exists
+in a set, they provide excellent speed and most importantly excellent
+space efficiency.
+
+Bloom filters are used in a wide variety of applications such as ad
+serving - making sure a user doesn't see an ad too often; likewise in
+content recommendation systems - ensuring recommendations don't appear
+too often, in databases - quickly checking if an entry exists in a
+table before accessing it on disk, and so on.
+
+## How Bloom filters work
+
+Most of the literature on Bloom filter uses highly symbolic and/or
+mathematical descriptions to describe it. If you're mathematically
+challenged like yours truly, you might find my explanation more useful.
+
+A Bloom filter is an array of many bits. When an element is 'added' to a
+bloom filter, the element is hashed. Then *bit\[hashval % nbits\]* is
+set to 1. This looks fairly similar to how buckets in a hash table are
+mapped. To check if an item is present or not, the hash is computed and
+the filter sees if the corresponding bit is set or not.
+
+{{< image filename="/images/rs/rebloom-hash1.png" >}}
+
+Of course, this is subject to collisions. If a collision happens, the
+filter returns a false positive - indicating that the entry is
+indeed found (note that a bloom filter never returns a false
+negative, that is, claim that something does not exist when it fact it
+is present).
+
+In order to reduce the risk of collisions, an entry may use more than
+one bit: the entry is hashed *bits_per_element (bpe)* times with a
+different seed for each iteration resulting in a different hash value,
+and for each hash value, the corresponding *hash % nbits* bit is set. To
+check if an entry exists, the candidate key is also hashed *bpe* times,
+and if any corresponding bit is *unset*, then it can be determined with
+certainty that the item does *not* exist.
+
+The actual value of *bpe* is determined at the time the filter is
+created. Generally the more bits per element, the lower the likelihood
+of false positives.
+
+{{< image filename="/images/rs/rebloom-hash3.png" >}}
+
+In the example above, all three bits would need to be set in order for
+the filter to return a positive result.
+
+Another value affecting the accuracy of a Bloom filter is its *fill
+ratio*, or how many bits in the filter are actually set. If a filter has
+a vast majority of bits set, the likelihood of any specific lookup
+returning false is decreased, and thus the possibility of the filter
+returning false positives is increased.
+
+## Scalable Bloom filters
+
+Typically Bloom filters must be created with a foreknowledge of how many
+entries they contain. The *bpe* number needs to be fixed, and
+likewise, the width of the bit array is also fixed.
+Unlike hash tables, Bloom filters cannot be "rebalanced" because there
+is no way to know *which* entries are part of the filter (the filter can
+only determine whether a given entry is *not* present, but does not
+actually store the entries which *are* present).
+
+In order to allow Bloom filters to 'scale' and be able to accommodate
+more elements than they've been designed to, they may be stacked. Once a
+single Bloom filter reaches capacity, a new one is created atop it.
+Typically the new filter has greater capacity than the previous
+one in order to reduce the likelihood of needing to stack yet another
+filter.
+
+In a stackable (scalable) Bloom filter, checking for membership now
+involves inspecting each layer for presence. Adding new items now
+involves checking that it does not exist beforehand, and adding it to
+the current filter. Hashes still only need to be computed once, however.
+
+When creating a Bloom filter - even a scalable one, it's important to
+have a good idea of how many items it is expected to contain. A filter
+whose initial layer can only contain a small number of elements will
+degrade performance significantly because it will take more layers to
+reach a larger capacity.
+
+## More info
+
+- [Probabilistic data structures quick start]({{< relref "/develop/data-types/probabilistic/bloom-filter" >}})
+- [Probabilistic data structure commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom/commands" >}})
+- [Probabilistic data structure configuration]({{< relref "/operate/oss_and_stack/stack-with-enterprise/bloom/config" >}})
+- [RedisBloom source](https://github.com/RedisBloom/RedisBloom/)---
+Title: RedisTimeSeries 1.12 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisTimeSeries 1.12 adds a highly requested feature - insertion-filter for close samples.
+linkTitle: v1.12 (July 2024)
+min-version-db: '7.4'
+min-version-rs: 7.8
+toc: 'true'
+weight: 94
+---
+## Requirements
+
+RedisTimeSeries v1.12.6 requires:
+
+- Minimum Redis compatibility version (database): 7.4
+- Minimum Redis Enterprise Software version (cluster): 7.8
+
+## v1.12.6 (April 2025)
+
+This is a maintenance release for RedisTimeSeries 1.12.
+
+Update urgency: `MODERATE`: Plan an upgrade of the server, but it's not urgent.
+
+Details:
+
+Bug fixes:
+- [#1725](https://github.com/redistimeseries/redistimeseries/pull/1725) `TS.DEL` crashes on keys with compactions if the deletion removes the last compaction bucket (MOD-8936)
+- [LibMR#58](https://github.com/RedisGears/LibMR/pull/58) Crash when a cluster contains both 1.8 and newer nodes (MOD-8976, MOD-9192)
+
+Improvements:
+- [#1712](https://github.com/redistimeseries/redistimeseries/pull/1712) Added support for Azure Linux 3 (MOD-9170)
+- [#1736](https://github.com/redistimeseries/redistimeseries/pull/1736) (Redis Enterprise only) Cross-key commands are handled by a random shard rather than the first shard (MOD-9262, MOD-9314)
+
+## v1.12.5 (January 2025)
+
+This is a maintenance release for RedisTimeSeries 1.12.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- **Security and privacy:**
+  - [#1674](https://github.com/redistimeseries/redistimeseries/pull/1674) (CVE-2024-51480) `TS.QUERYINDEX`, `TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE` - potential integer overflow leading to an out-of-bounds write (MOD-7548)
+
+- Improvements:
+  - [#1662](https://github.com/redistimeseries/redistimeseries/pull/1662) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v1.12 GA (v1.12.2) (July 2024)
+
+This is the General Availability release of RedisTimeSeries 1.12
+
+### Headlines
+
+RedisTimeSeries 1.12 adds a highly requested feature: insertion-filter for close samples. Many sensors report data periodically. Often, the difference between the measured value and the previous measured value is negligible and related to random noise or to measurement accuracy limitations. When both the time difference and the value difference between the current and the previous sample are small, it may be preferable to ignore (not to add) the new measurement.
+
+### What's new in 1.12
+
+- [#1543](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1543) insertion-filter for close samples:
+
+  - Two new [module configuration parameters](https://redis.io/docs/data-types/timeseries/configuration/) are introduced: `IGNORE_MAX_TIME_DIFF` and `IGNORE_MAX_VAL_DIFF`.
+  - Two new similar per-key parameters are introduced: `ignoreMaxTimeDiff` and `ignoreMaxValDiff`.
+  - `TS.ADD`, `TS.INCRBY`, and `TS.DECRBY` now have a new optional argument: `[IGNORE ignoreMaxTimeDiff ignoreMaxValDiff]`.
+    When creating a new time series, these two values are used to set the per-key parameters and override the two module configuration parameters. These values are ignored when specified with an existing time series.
+  - `[IGNORE ignoreMaxTimeDiff ignoreMaxValDiff]` is also supported by `TS.ALTER`.
+  - For each call to `TS.ADD`, if the following conditions are met:
+      - series is not a compaction
+      - the series' `DUPLICATE_POLICY` is `LAST`
+      - `timestamp` ≥ `max_timestamp`
+      - `timestamp` - `max_timestamp` ≤ `ignoreMaxTimeDiff`
+      - abs(`value` - `value_at_max_timestamp`) ≤ `ignoreMaxValDiff`))
+    then this sample is ignored (not added) to the time series. `max_timestamp` is the maximal timestamp in the time series.
+  - The same logic also applies for each call to `TS.MADD` based on the values of the per-key parameters.
+  - When a sample is ignored, the returned value for `TS.ADD` and for the applicable array element in `TS.MADD` is `max_timestamp`.
+
+### Details
+
+- Bug fixes (since 1.12-RC1)
+
+  - [#1607](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1607) Potential crash after deleting and recreating a source key of a compaction rule (MOD-7338)
+  - [#1610](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1610) `COUNT` argument accepts non-positive values (MOD-5413)
+
+{{< note >}}
+- The version inside Redis will be 1.12.2 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+- Minimal Redis version: 7.4
+{{< /note >}}
+---
+Title: RedisTimeSeries 1.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Downsampling/compaction. Secondary indexing. Aggregation at read time.
+  Integration with Prometheus, Grafana, and Telegraph.
+linkTitle: v1.0 (June 2019)
+min-version-db: 5.0.0
+min-version-rs: 5.4.0
+weight: 100
+---
+## Requirements
+
+RedisTimeSeries v1.0.3 requires:
+
+- Minimum Redis compatibility version (database): 5.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.4.0
+
+## v1.0.3 (September 2019)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.0.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Main features:
+
+- #[143](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/143) Standard Deviation for Aggregations
+- #[163](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/163) `TS.RANGE` and `TS.MRANGE` can limit results via optional `COUNT` flag
+- #[161](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/161) Support for ARM architectures
+- #[160](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/160) Optional `TIMESTAMP` in `TS.INCRBY` and `TS.DECRBY`
+
+Main Fixes:
+
+- #[199](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/199) `RETENTION` is now 64bit
+- #[211](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/211) write commands to return OOM error when redis reaches max memory
+
+Main Performance improvements:
+
+- #[3651](https://github.com/RedisTimeSeries/RedisTimeSeries/commit/3651ef8eb65b390e333053b91a64617fc2382f6e) Do not use `_union` if there's only 1 leaf in the index
+- #[0a68](https://github.com/RedisTimeSeries/RedisTimeSeries/commit/0a68d4eca95108595ac7dfbae68d3f0371e41470) Make _difference faster by iterating over the left dict (which is always smaller)
+
+## v1.0.1 (July 2019)
+
+Update urgency: Minor
+
+This is a maintenance release for version 1.0.
+
+Secondary index should work faster when a filter consists of a list of k=v predicates.
+
+## v1.0.0 (June 2019)
+
+This is the General Availability release of RedisTimeSeries!  Read the [full story here](https://redislabs.com/blog/redistimeseries-ga-making-4th-dimension-truly-immersive)
+
+### Features
+
+In RedisTimeSeries, we are introducing a new data type that uses chunks of memory of fixed size for time series samples, indexed by the same [Radix Tree implementation](https://github.com/antirez/rax) as Redis Streams. With Streams, you can create a [capped stream]({{< relref "/commands/xadd" >}}, effectively limiting the number of messages by count. In RedisTimeSeries, you can apply a retention policy in milliseconds. This is better for time series use cases, because they are typically interested in the data during a given time window, rather than a fixed number of samples.
+
+#### Downsampling/compaction
+
+If you want to keep all of your raw data points indefinitely, your data set will grow linearly over time. However, if your use case allows you to have less fine-grained data further back in time, downsampling can be applied. This allows you to keep fewer historical data points by aggregating raw data for a given time window using a given aggregation function. RedisTimeSeries supports downsampling with the following aggregations: avg, sum, min, max, range, count, first and last.  
+
+#### Secondary indexing
+
+When using Redis’ core data structures, you can only retrieve a time series by knowing the exact key holding the time series. Unfortunately, for many time series use cases (such as root cause analysis or monitoring), your application won’t know the exact key it’s looking for. These use cases typically want to query a set of time series that relate to each other in a couple of dimensions to extract the insight you need. You could create your own secondary index with core Redis data structures to help with this, but it would come with a high development cost and require you to manage edge cases to make sure the index is correct.
+
+RedisTimeSeries does this indexing for you based on `field value` pairs (a.k.a labels) you can add to each time series, and use to filter at query time (a full list of these filters is available in our documentation). Here’s an example of creating a time series with two labels (sensor_id and area_id are the fields with values 2 and 32 respectively) and a retention window of 60,000 milliseconds:
+
+```sh
+TS.CREATE temperature RETENTION 60000 LABELS sensor_id 2 area_id 32
+```
+
+#### Aggregation at read time
+
+When you need to query a time series, it’s cumbersome to stream all raw data points if you’re only interested in, say, an average over a given time interval. RedisTimeSeries follows the Redis philosophy to only transfer the minimum required data to ensure lowest latency. Below is an example of aggregation query over time buckets of 5,000 milliseconds with an aggregation function:  
+
+```sh
+127.0.0.1:6379> TS.RANGE temperature:3:32 1548149180000 1548149210000 AGGREGATION avg 5000
+1) 1) (integer) 1548149180000
+   2) "26.199999999999999"
+2) 1) (integer) 1548149185000
+   2) "27.399999999999999"
+3) 1) (integer) 1548149190000
+   2) "24.800000000000001"
+4) 1) (integer) 1548149195000
+   2) "23.199999999999999"
+5) 1) (integer) 1548149200000
+   2) "25.199999999999999"
+6) 1) (integer) 1548149205000
+   2) "28"
+7) 1) (integer) 1548149210000
+   2) "20"
+```
+
+#### Integrations
+
+RedisTimeSeries comes with several integrations into existing time series tools. One such integration is our [RedisTimeSeries adapter for Prometheus](https://github.com/RedisTimeSeries/prometheus-redistimeseries-adapter), which keeps all your monitoring metrics inside RedisTimeSeries while leveraging the entire Prometheus ecosystem.
+Furthermore, we also created direct integration for [Grafana](https://github.com/RedisTimeSeries/grafana-redistimeseries). [This repository](https://github.com/RedisTimeSeries/prometheus-demos) contains a docker-compose setup of RedisTimeSeries, its remote write adaptor, Prometheus and Grafana. It also comes with a set of data generators and pre-built Grafana dashboards.
+---
+Title: RedisTimeSeries 1.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added ability to backfill time series.
+linkTitle: v1.4 (September 2020)
+min-version-db: 5.0.0
+min-version-rs: 6.0.12
+weight: 98
+---
+## Requirements
+
+RedisTimeSeries v1.4.14 requires:
+
+- Minimum Redis compatibility version (database): 5.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.12
+
+## v1.4.14 (February 2022)
+
+This is a maintenance release for RedisTimeSeries 1.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Bug fixes:
+
+- [#891](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/891), [#892](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/892) Fixed memory leak in parseCreateArgs when parsing error occurs (MOD-1958)
+
+## v1.4.13 (November 2021)
+
+This is a maintenance release for RedisTimeSeries 1.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Bug fixes:
+
+- [#881](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/881) Replicate only successful insertion of `TS.MADD`
+
+## v1.4.11 (November 2021)
+
+This is a maintenance release for RedisTimeSeries 1.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Bug fixes:
+
+- [#862](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/862) Index dictionary should be freed on removing the last element
+
+## v1.4.10 (July 2021)
+
+This is a maintenance release for RedisTimeSeries 1.4.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+
+- [#760](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/760) Avoid closing the same key twice, causing server crash on [`RENAME`]({{< relref "/commands/rename" >}}) of other keys
+
+## v1.4.9 (May 2021)
+
+This is a maintenance release for version 1.4.
+
+Update urgency: Medium
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Bug fixes:
+
+- #[#712](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/712) Missing keytype check on TS.INCRBY/DECRBY causes shards to crash
+- #[#719](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/719) Support for renaming time series keys
+
+## v1.4.8 (March 2021)
+
+This is a maintenance release for version 1.4.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Bug fixes:
+
+- [#612](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/612) Crash on `MGET`/`MRANGE`
+- [#606](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/606) Memory leak when key loaded from RDB
+- [#624](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/624) Uninitialised memory access on log
+
+
+## v1.4.7 (December 2020)
+
+This is a maintenance release for version 1.4.
+
+Headlines:
+
+- This release improves overall stability, and provides fixes for issues found after the previous release.
+
+Bug fixes:
+
+- [#581](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/581) Misaligned allocators usage might crash Redis.
+- [#588](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/588) `ON_DUPLICATE` min/max rules not working for negative value.
+
+## v1.4.6 (November 2020)
+
+This is a maintenance release for version 1.4.
+
+Headlines:
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Minor enhancements:
+
+- [#565](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/565)
+    duplicate policy: add `SUM` option: If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new).
+    If no previous sample exists, set the updated value equal to the new value. (PR [#565](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/565)
+- [#559](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/559)
+    Compressed chunk will be be the default global option
+- [#559](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/559)
+    Added `chunkType` to `TS.INFO`
+
+Bug fixes:
+
+- [#528](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/528)
+    Out of order insert might crash Redis if there's an update to an empty downsampled key
+- [#561](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/561)
+    `TS.MRANGE` command might crash if there's an expired key that was deleted in the result set
+
+## v1.4 GA (September 2020)
+
+This is the General Availability release for RedisTimeSeries 1.4.
+
+Highlights:
+
+**Ability to backfill time series!** You can now add samples to a time series where the time of the sample is older than the newest sample in the series. This enables:
+
+- Adding out of order of samples to time series.
+- Batch loading of historical samples into an existing series.
+- Updating existing samples (for example for compliance reasons).
+
+This has been the most requested feature for RedisTimeSeries. We look forward to your feedback so we can move to a general availability release soon.
+
+Details:
+
+- Added functionality:
+    - [#254](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/254) TS.REVRANGE and TS.MREVRANGE commands allow for querying in descending order of Timestamps.
+    - [#503](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/503) - RDB saves the whole chunk instead of individual samples giving a speed and space improvement when saving or loading an RDB file
+    - [#502](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/502) - The ability to set, at creation time, the data section size of each chunk using flag `CHUNK_SIZE`. TS.INFO uses `chunkSize` instead of `maxSamplesPerChunk`.
+    - [#437](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/437) Allow backfilling of samples and updating of existing samples
+        - Works with [compressed](https://redislabs.com/blog/redistimeseries-version-1-2-is-here/) and uncompressed series.
+        - This comes with a performance hit when a sample is written out-of-order. We will publish numbers once we are generally available, but are still considering optimisations.
+    - [#521](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/521) `DUPLICATE_POLICY` allows to configure on module, series and sample level how to handle duplicate samples. A duplicate sample is a sample for which the series holds already a sample on the same timestamp. Note that the default behaviour is equal to v1.2: `BLOCK`
+
+Notes:
+The version inside Redis will be 10405 or 1.4.5 in semantic versioning. Since the version of a module in Redis is numeric, we could not add an GA flag.
+---
+Title: RedisTimeSeries 1.8 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added a time-weighted average aggregator, gap filling, ability to control
+  bucket timestamps, ability to control alignment for compaction rules, new reducer
+  types, and ability to include the latest (possibly partial) raw bucket samples when
+  retrieving compactions
+linkTitle: v1.8 (November 2022)
+min-version-db: 6.0.16
+min-version-rs: 6.2.8
+weight: 96
+---
+## Requirements
+
+RedisTimeSeries v1.8.17 requires:
+
+- Minimum Redis compatibility version (database): 6.0.16
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v1.8.17 (April 2025)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `MODERATE`: Plan an upgrade of the server, but it's not urgent.
+
+Details:
+
+*Bug fixes:
+- [#1725](https://github.com/redistimeseries/redistimeseries/pull/1725) `TS.DEL` crashes on keys with compactions if the deletion removes the last compaction bucket (MOD-8936)
+- [LibMR#58](https://github.com/RedisGears/LibMR/pull/58) Crash when a cluster contains both 1.8 and newer nodes (MOD-8976, MOD-9192)
+
+Improvements:
+- [#1712](https://github.com/redistimeseries/redistimeseries/pull/1712) Added support for Azure Linux 3 (MOD-9170)
+- [#1736](https://github.com/redistimeseries/redistimeseries/pull/1736) (Redis Enterprise only) Cross-key commands are handled by a random shard rather than the first shard (MOD-9262, MOD-9314)
+
+## v1.8.16 (January 2025)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details
+
+- **Security and privacy:**
+  - [#1672](https://github.com/redistimeseries/redistimeseries/pull/1672) (CVE-2024-51480) `TS.QUERYINDEX`, `TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE` - potential integer overflow leading to an out-of-bounds write (MOD-7548)
+
+- Improvements:
+  - [#1664](https://github.com/redistimeseries/redistimeseries/pull/1664) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v1.8.13 (March 2024)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+### Details
+
+- Bug fixes:
+
+  - [LibMR#51](https://github.com/RedisGears/LibMR/pull/51) Crash on SSL initialization failure (MOD-5647)
+
+- Improvements:
+
+  - [#1593](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1593) More detailed LibMR error messages
+
+## v1.8.12 (December 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- Security and privacy:
+
+  - [#1506](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1506) Don’t expose internal commands (MOD-5643)
+
+- Bug fixes:
+
+  - [#1494](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1494) Potential crash when using an invalid argument value
+
+- Improvements:
+
+  - [#1516](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1516) Added support for CBL-Mariner 2
+
+## v1.8.11 (July 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1486](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1486) When using `LATEST`, results may contain samples earlier than `fromTimestamp` (`TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`)
+    - [#1471](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1471) Potential crash on `TS.MRANGE` when aggregating millions of time series
+    - [#1469](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1469) Potential memory leak in `TS.MRANGE` after eviction
+
+- Performance enhancements:
+
+    - [#1476](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1476) Significant performance improvement when using multiple label filters (`TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE`, and `TS.QUERYINDEX`) (MOD-5338)
+
+## v1.8.10 (April 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1455](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1455) `TS.ADD` - optional arguments are not replicated (MOD-5110)
+
+## v1.8.9 (March 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1421](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1421) Potential crash after deleting from a time series with an `AVG` compaction (MOD-4972)
+    - [#1422](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1422) Incorrectly return an error when deleting from a time series with a compaction and with no expiry
+
+## v1.8.8 (March 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1290](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1290) Potential crash when using `FILTER_BY_TS`
+    - [#1397](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1397) Memory leak when trying to create an already existing key (MOD-4724, RED-93418)
+
+## v1.8.5 (January 2023)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#1388](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1388) Potential crash when upgrading from v1.6 to 1.8 if there are compactions with `min` or `max` aggregation (MOD-4695)
+
+## v1.8.4 (December 2022)
+
+This is a maintenance release for RedisTimeSeries 1.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#1360](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1360) Potential crash when upgrading from v1.6 to 1.8 if there are compactions with `min` or `max` aggregation (MOD-4559)
+    - [#1370](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1370) Potential crash when using [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}) or [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}) with aggregation
+    - [#1347](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1347) When adding samples with [TS.ADD]({{< relref "commands/ts.add" >}}) or [TS.MADD]({{< relref "commands/ts.madd" >}}) using  `*` as timestamp, the timestamp could differ between master and replica shards
+
+- Improvements:
+    - [#1215](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1215) OSS cluster: Support TLS and IPv6; introduce new configuration parameter: [OSS_GLOBAL_PASSWORD]({{< relref "/develop/data-types/timeseries/" >}}configuration/#oss_global_password)
+
+
+## v1.8 GA (v1.8.3) (November 2022)
+
+This is the General Availability release of RedisTimeSeries 1.8.
+
+### Highlights
+
+RedisTimeSeries 1.8 introduces seven highly requested features, performance improvements, and bug fixes.
+
+### What's new in 1.8
+
+* **Optionally retrieving aggregation results for the latest (still open) bucket for compactions**
+
+  Till version 1.8, when a time series is a compaction, [TS.GET]({{< relref "commands/ts.get" >}}), [TS.MGET]({{< relref "commands/ts.mget" >}}), [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}) did not report the compacted value of the latest bucket. The reason is that the data in the latest bucket of a compaction is still partial. A bucket is ‘closed’ and compacted only upon the arrival of data that ‘opens’ a ‘new latest’ bucket.
+
+  There are use cases, however, where the compaction of the latest bucket should be retrieved as well. For example, a user may want to receive the count of events since the start of the decade, and the retention period for raw data is only one month. Till version 1.8, the user would have to run two queries - one on a compaction and one on the latest raw data, and then sum the results. Since version 1.8, by specifying `LATEST`, it is possible to retrieve the latest (possibly partial) bucket as well.
+
+  To report aggregations for the latest bucket, use the new optional `LATEST` flag to [TS.GET]({{< relref "commands/ts.get" >}}), [TS.MGET]({{< relref "commands/ts.mget" >}}), [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), and [TS.REVRANGE]({{< relref "commands/ts.mrevrange" >}}).
+
+* **Optionally retrieving aggregation results for empty buckets**
+
+  The commands [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), and [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}) have an optional `[AGGREGATION aggregator bucketDuration]` parameter. When this parameter is specified, raw reports are aggregated per bucket.
+
+  Till version 1.8, results were not reported for empty buckets. With `EMPTY`, it is now possible to report aggregations for empty buckets as well.
+
+  The two primary reasons for wanting to retrieve values for empty buckets:
+
+  - It is easier to align results from similar queries over multiple time series
+
+  - It is easier to use the retrieved results with some external tools (e.g., charting tools)
+
+  For the `sum` and `count` aggregators, the value 0 is reported for empty buckets.
+
+  For the `min`, `max`, `range`, `avg`, `first`, `std.p`, and `std.s` aggregators, the value NaN (not a number) is reported.
+
+  For the `last` aggregator and the new `twa` aggregator, the `EMPTY` flag is used for gap filling (see below).
+
+  To report aggregations for empty buckets, use the new optional `EMPTY` flag in [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), and [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}).
+
+  Regardless of the values of `fromTimestamp` and `toTimestamp`, no data is reported for empty buckets that end before the earliest sample or begin after the latest sample in the time series.
+
+* **A new aggregator: time-weighted average**
+
+  When a time series holds discrete samples of a continuous signal (e.g., temperature), using `avg` to estimate the average value over a given timeframe would produce a good estimate only when the signal is sampled at constant intervals. If, however, samples are available at non-constant intervals (e.g., when some samples are missing), the `twa` aggregator produces a more accurate estimate by averaging samples over time instead of simply averaging the samples.
+
+  {{<image filename="images/modules/twa.png" alt="A graph showing the difference between average and time-weighted average.">}}
+
+  This is an extreme example: the signal in the diagram above has 4 samples in its ‘high’ value and 13 samples in its ‘low’ value. However, the period in each of those states is about the same. It is easy to see that the simple average (avg) of all the 17 samples does not represent the signal’s average over time.
+
+  Time-weighted average (`twa`) adds weight to each sample. The weight is proportional to the time interval that the sample represents. In the diagram, the time-weighted average over the whole period assigns appropriate weight to each sample, so the result represents the signal’s average value over the whole period much more accurately.
+
+* **Gap filling: optionally interpolate or repeat last value for empty buckets**
+
+  Gap filling is performed when using `EMPTY` together with either `last` or `twa` aggregator.
+
+  Using `EMPTY` with the `twa` aggregator allows us to estimate the average of a continuous signal even for buckets where no samples were collected (gap-filling).
+
+  {{<image filename="images/modules/GapFilling.png" alt="A graph that illustrates gap-filling.">}}
+
+  Consider we want to use [TS.RANGE]({{< relref "commands/ts.range" >}}) to calculate the average value of each bucket (p1, p2, p3 in the diagram above). Using avg, the value reported for bucket p2 would be NaN, as this bucket contains no samples. If we use `EMPTY` with `twa`, on the other hand, the average value for bucket p2 would be calculated based on the linear interpolation of the value left of p2 and the value right of p2.
+
+  When sampling a continuous signal, we can use this ‘gap-filling’ capability to calculate the average value of the signal over equal-width buckets without concern about bucket alignment or missing samples.
+
+  Using `EMPTY` with the last aggregator allows filling empty buckets by repeating the value of the previous sample. This is useful, for example, when values in the time series represent stock prices and the price has not been changed during a bucket’s timeframe.
+
+* **Ability to control how bucket timestamps are reported**
+
+  Till version 1.8, [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), and [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}) returned the start time of each reported bucket as its timestamp.
+
+  Changing this behavior and reporting each bucket’s start time, end time, or mid-time is now possible. This is required in many use cases. For example, when drawing bars in trading applications, annotating each bar with the end timestamp of the bucket it represents is very common.
+
+  The way bucket timestamps are reported can be specified with the new optional `BUCKETTIMESTAMP` parameter of [TS.RANGE]({{< relref "commands/ts.range" >}}), [TS.REVRANGE]({{< relref "commands/ts.revrange" >}}), [TS.MRANGE]({{< relref "commands/ts.mrange" >}}), and [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}).
+
+  `-` or `low`: the bucket's start time (default)
+
+  `+` or `high`: the bucket's end time
+
+  `~` or `mid`: the bucket's mid-time (rounded down if not an integer)
+
+* **Ability to control alignment for compaction rules**
+
+  Till version 1.8, compaction rules could not be aligned. One could specify a compaction rule with 24-hour buckets, and as a result, each bucket would aggregate events from midnight till the next midnight. The first bucket always started at the epoch and all other buckets were aligned accordingly.
+
+  But what if we want to aggregate daily events from 06:00 to 06:00 the next day? We can now specify alignment for compaction rules.
+
+  Alignment can be specified with the new optional `alignTimestamp` parameter of [TS.CREATERULE]({{< relref "commands/ts.createrule" >}}) and the [COMPACTION_POLICY]({{< relref "/develop/data-types/timeseries/configuration" >}}) configuration parameter. Specifying `alignTimestamp` ensures that there is a bucket that starts exactly at `alignTimestamp` and all other buckets are aligned accordingly. `alignTimestamp` is expressed in milliseconds. The default value is 0 (aligned with the epoch).
+
+* **New reducers**
+
+  Till version 1.8, only the `sum`, `min`, and `max` could be used as reducer types.
+
+  It is now possible, for example, to calculate the maximal temperature per timeframe for each sensor and then report the average temperature (avg reducer) over groups of sensors (grouped by a given label's value).
+
+  This can be specified with the new reducer types ([TS.MRANGE]({{< relref "commands/ts.mrange" >}}) and [TS.MREVRANGE]({{< relref "commands/ts.mrevrange" >}}): `avg`, `range`, `count`, `std.p`, `std.s`, `var.p`, and `var.s`.
+
+{{<note>}}
+New RDB version (v7). RDB files created with v1.8.3 are not backward compatible. 
+{{</note>}}
+---
+Title: RedisTimeSeries 1.2 release rotes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added compression. Stable ingestion time independent of the number of
+  the data points on a time series. API performance improvements. Extended client
+  support.
+linkTitle: v1.2 (January 2020)
+min-version-db: 5.0.0
+min-version-rs: 6.0.12
+weight: 99
+---
+## Requirements
+
+RedisTimeSeries v1.2.7 requires:
+
+- Minimum Redis compatibility version (database): 5.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.12
+
+## v1.2.7 (June 2020)
+
+This is a maintenance release for version 1.2.
+
+Details:
+
+- Bugfixes:
+
+    - #[414](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/414) Crash when a query had an empty label `(foo,)`
+
+## v1.2.6 (May 2020)
+
+This is a maintenance release for version 1.2.
+
+Details:
+
+- Minor enhancements:
+
+    - #[403](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/403) Support for multi-value filtering in `TS.MGET` and `TS.MRANGE`.
+
+- Bugfixes:
+
+    - #[378](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/378) Using `snprintf` to ensure the same precision of floating-point value replies.
+    - #[374](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/374) `TS.RANGE` crashed when COUNT argument was missing.
+    - #[395](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/395) Check minimum compatible Redis version at module load time.
+
+## v1.2.5 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[358](https://github.com/redistimeseries/redistimeseries/issues/358) [Wrong behaviour](https://groups.google.com/forum/?utm_medium=email&utm_source=footer#!topic/redistimeseries/wH0R69e8lOs) in `TS.RANGE` due to shifting left.
+    - #[353](https://github.com/redistimeseries/redistimeseries/issues/353) Crash where the name of a time-series was already taken due to auto-compaction.
+
+## v1.2.3 (February 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[338](https://github.com/redistimeseries/redistimeseries/issues/338) reverting #[319](https://github.com/redistimeseries/redistimeseries/issues/319).  Aggregation should happen on deterministic time buckets.
+
+## v1.2 GA (1.2.2 - January 2020)
+
+This is the general availability (GA) release of RedisTimeSeries 1.2 (1.2.2).
+
+Headlines:
+
+- Compression added which can reduce memory up to 98% and improve read performance up to 50%.
+- Stable ingestion time independent of the number of the data points on a time-series.
+- Reviewed API with performance improvements and removed ambiguity.
+- Extended [client support]({{<relref "/develop/data-types/timeseries/clients">}})
+
+(we will blog about this release soon including performance improvements results and the link here)
+
+Full details:
+
+- Added functionality
+    - #[261](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/261) Samples are compressed using `Double Delta compression` which results in cost savings and faster query times.
+    - Based on the [Gorilla paper](https://www.vldb.org/pvldb/vol8/p1816-teller.pdf).
+        - In theory, this can save space up to 98%. (2 bits per sample in stead of 128).
+        - In practice, a memory reduction of 5-8x is common but depends on the use case.
+    - Initial benchmarks show 94% memory savings and performance improvements in reads up to XX%.
+    - `UNCOMPRESSED` option in `TS.CREATE`.
+
+- API changes / Enhancements
+    - #[241](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/241) Overwriting the last sample with the same timestamp is not allowed.
+    - #[242](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/242) revised `TS.INCRBY/DECRBY`
+    - Returns a timestamp.  The behaviour is now aligned with `TS.ADD`.
+    - The `RESET` functionality was removed. `RESET` contradicted the rewriting of the last sample (#[241](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/241)).
+    Alternatively, you can reconstruct similar behaviour by
+        - `TS.ADD ts * 1` + `sum` aggregation
+        - `TS.INCRBY ts 1` + `range` aggregation
+    - #[317](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/317) Aligning response on empty series of `TS.GET` with `TS.RANGE`.
+    - #[285](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/285) #[318](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/318) Changed default behaviour of `TS.MRANGE` and `TS.MGET` to no longer returns the labels of each time-series in order reduce network traffic. Optional `WITHLABELS` argument added.
+    - #[319](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/319) `TS.RANGE` and `TS.MRANGE` aggregation starting from requested timestamp.
+
+- Performance improvements
+    - #[237](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/237) Downsampling after time window is closed vs. downsampling with each sample.
+    - #[285](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/285) #[318](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/318) Optional `WITHLABELS` argument added.  This feature improves read performance drastically.
+
+- Minor Enhancements
+    - #[230](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/230) `TS.INFO` now includes `total samples`, `memory usage`,`first time stamp`, ...
+    - #[230](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/230) `MEMORY` calculates series memory footprint.
+
+- Bugfixes since 1.0.3
+    - #[204](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/204) Module initialization params changed to 64 bits.
+    - #[266](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/266) Memory leak in the aggregator context.
+    - #[260](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/260) Better error messages.
+    - #[259](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/259) #[257](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/257) #[219](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/219) Miscellaneous.
+    - #[320](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/320) Delete the existing key prior to restoring it.
+    - #[323](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/323) Empty first sample on aggregation.
+
+{{< note >}}
+The version inside Redis will be 10202 or 1.2.2 in semantic versioning.
+{{< /note >}}---
+Title: RedisTimeSeries 1.10 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RESP3 support. Performance improvements.
+linkTitle: v1.10 (July 2023)
+min-version-db: '7.2'
+min-version-rs: 7.2.4
+toc: 'true'
+weight: 95
+---
+## Requirements
+
+RedisTimeSeries v1.10.17 requires:
+
+- Minimum Redis compatibility version (database): 7.2
+- Minimum Redis Enterprise Software version (cluster): 7.2.4
+
+## v1.10.17 (April 2025)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `MODERATE`: Plan an upgrade of the server, but it's not urgent.
+
+Details:
+
+Bug fixes:
+- [#1725](https://github.com/redistimeseries/redistimeseries/pull/1725) `TS.DEL` crashes on keys with compactions if the deletion removes the last compaction bucket (MOD-8936)
+- [LibMR#58](https://github.com/RedisGears/LibMR/pull/58) Crash when a cluster contains both 1.8 and newer nodes (MOD-8976, MOD-9192)
+
+Improvements:
+- [#1712](https://github.com/redistimeseries/redistimeseries/pull/1712) Added support for Azure Linux 3 (MOD-9170)
+- [#1736](https://github.com/redistimeseries/redistimeseries/pull/1736) (Redis Enterprise only) Cross-key commands are handled by a random shard rather than the first shard (MOD-9262, MOD-9314)
+
+## v1.10.16 (January 2025)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- **Security and privacy:**
+  - [#1673](https://github.com/redistimeseries/redistimeseries/pull/1673) (CVE-2024-51480) `TS.QUERYINDEX`, `TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE` - potential integer overflow leading to an out-of-bounds write (MOD-7548)
+
+- Improvements:
+  - [#1663](https://github.com/redistimeseries/redistimeseries/pull/1663) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v1.10.12 (March 2024)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - [#1593](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1593) More detailed LibMR error messages
+
+## v1.10.11 (October 2023)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [LibMR#51](https://github.com/RedisGears/LibMR/pull/51) Crash on SSL initialization failure (MOD-5647)
+  - [#1538](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1538) Amazon Linux 2: crash on SSL initialization. We now use openssl11-devel instead of openssl-devel (MOD-6015)
+
+## v1.10.9 (October 2023)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - [#1516](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1516) Added support for CBL-Mariner 2
+  - [#1514](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1514) Added support for Rocky Linux 9 and RHEL9
+
+## v1.10.6 (September 2023)
+
+This is a maintenance release for RedisTimeSeries 1.10.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- Security and privacy:
+
+  - [#1506](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1506) Don’t expose internal commands (MOD-5643)
+
+## v1.10 GA (v1.10.4) (July 2023)
+
+This is the General Availability release of RedisTimeSeries 1.10.
+
+### Headlines
+
+RedisTimeSeries 1.10 introduces support for RESP3, performance improvements, and bug fixes.
+
+### Details
+
+Bug fixes (since 1.10-RC3):
+
+- [#1494](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1494) Potential crash when using an invalid argument value
+
+{{<note>}}
+- The version inside Redis will be 1.10.4 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+
+- Minimal Redis version: 7.2
+{{</note>}}
+---
+Title: RedisTimeSeries 1.6 release notes
+linkTitle: v1.6 (January 2022)
+description: Added support for aggregating across multiple time series (multi-key). Can compute queries such as “the maximum observed value of a set of time series” server-side instead of client-side.
+min-version-db: "6.0.16"
+min-version-rs: "6.2.8"
+weight: 97
+alwaysopen: false
+categories: ["Modules"]
+aliases: /modules/redistimeseries/release-notes/redistimeseries-1.6-release-notes/
+---
+## Requirements
+
+RedisTimeSeries v1.6.19 requires:
+
+- Minimum Redis compatibility version (database): 6.0.16
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v1.6.19 (February 2023)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1397](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1397) Memory leak when trying to create an already existing key (MOD-4724, RED-93418)
+
+## v1.6.17 (July 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#1240](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1240) Compaction rules are not saved to [RoF](https://docs.redis.com/latest/rs/databases/redis-on-flash) (Redis Enterprise)
+
+## v1.6.16 (June 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Features:
+
+    - [#1193](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1193) Commands that don’t execute on the main thread now appear in [SLOWLOG]({{< relref "/commands/slowlog" >}})
+
+- Bug fixes:
+
+    - [#1203](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1203) Compaction rules are not replicated (Replica Of) on Redis Enterprise
+    - [#1204](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1204) When the last sample is deleted with [`TS.DEL`]({{< relref "commands/ts.del" >}}), it may still be accessible with [`TS.GET`]({{< relref "commands/ts.get" >}})
+    - [#1226](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1226) [`TS.MRANGE`]({{< relref "commands/ts.mrange" >}}), [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange" >}}): on a multi-shard environment, some chunks may be skipped
+
+{{<note>}}
+New RDB version (v5). RDB files created with 1.6.16 are not backward compatible.
+{{</note>}}
+
+## v1.6.13 (June 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#1176](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1176), [#1187](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1187) When executing [`DEL`]({{< relref "commands/ts.del" >}}), chunk index could be set to a wrong value and cause some data to be inaccessible
+    - [#1180](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1180) When executing [`MADD`]({{< relref "commands/ts.madd" >}}), make sure that only successful insertions are replicated
+
+## v1.6.11 (May 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#1166](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1166) Stop forwarding multi-shard commands during cluster resharding and upgrade (MOD-3154)
+    - [#1165](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1165) Stop forwarding multi-shard commands during transactions (`MULTI EXEC`) (MOD-3182)
+    - [LibMR](https://github.com/RedisGears/LibMR): Fixed crash on multi-shard commands in some rare scenarios (MOD-3182)
+
+## v1.6.10 (May 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#1074](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1074) [`RANGE`]({{< relref "commands/ts.range" >}}), [`REVRANGE`]({{< relref "commands/ts.revrange" >}}), [`MRANGE`]({{< relref "commands/ts.mrange" >}}), and [`MREVRANGE`]({{< relref "commands/ts.mrevrange" >}}): Possibly incorrect result when using `ALIGN` and aggregating a bucket with a timestamp close to 0
+    - [#1094](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1094) [LibMR](https://github.com/RedisGears/LibMR): Potential memory leak; memory release delay
+    - [#1127](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1127) Memory leak on [`RANGE`]({{< relref "commands/ts.range" >}}) and [`REVRANGE`]({{< relref "commands/ts.revrange" >}}) when argument parsing fails
+    - [#1096](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1096) [`RANGE`]({{< relref "commands/ts.range" >}}), [`REVRANGE`]({{< relref "commands/ts.revrange" >}}), [`MRANGE`]({{< relref "commands/ts.mrange" >}}), and [`MREVRANGE`]({{< relref "commands/ts.mrevrange" >}}): Using `FILTER_BY_TS` without specifying timestamps now returns an error as expected
+
+## v1.6.9 (February 2022)
+
+This is a maintenance release for RedisTimeSeries 1.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Security and privacy:
+
+    - [#1061](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1061) Internode communications encryption: support passphrases for PEM files
+
+- Bug fixes:
+
+    - [#1056](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1056) Return an error when a shard is down (in v1.6.8, returned an empty result)
+
+
+## v1.6 GA (v1.6.8) (January 2022)
+
+This is the General Availability release of RedisTimeSeries 1.6.
+
+### Highlights
+
+RedisTimeSeries 1.6 adds support for aggregating across multiple time series (multi-key). Before this version, queries such as “the maximum observed value of a set of time series” needed to be calculated client-side. Such queries can now be computed server-side, leveraging the heart of RedisGears ([LibMR](https://github.com/RedisGears/LibMR)) for clustered databases.
+
+### What's new in 1.6
+
+- Introduction of `GROUPBY` and `REDUCE` in `TS.MRANGE` and `TS.MREVRANGE` to add support for "multi-key aggregation" and support for such aggregations spanning multiple shards, leveraging [LibMR](https://github.com/RedisGears/LibMR). Currently, we support `min`, `max`, and `sum` as reducers and grouping by a label.
+
+- [#722](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/722), [#275](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/275) Filter results using `FILTER_BY_TS` by providing a list of timestamps and `FILTER_BY_VALUE` by providing a `min` and a `max` value (`TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`).
+
+- [#603](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/603), [#611](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/611), [#841](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/841) Introduction of TS.DEL which allows deleting samples in a time series within two timestamps (inclusive).
+
+- [#762](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/762) Limit the number of returned labels in the response of read commands (`TS.MRANGE`, `TS.MREVRANGE`, and `TS.MGET`) using `SELECTED_LABELS`. This can be a significant performance improvement when returning a large number of series.
+
+- [#655](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/655), [#801](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/801) Ability to align the aggregation buckets with the requested start, end, or specific timestamp on aggregation queries using `ALIGN` (`TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`).
+
+- [#675](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/675) Add keyspace notifications for all CRUD commands. Check out [this test](https://github.com/RedisTimeSeries/RedisTimeSeries/blob/master/tests/flow/test_ts_keyspace.py) for the details.
+
+- [#882](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/882) [Auto Tiering ](https://docs.redis.com/latest/rs/databases/redis-on-flash//#:~:text=Redis%20on%20Flash%20%20offers,dedicated%20flash%20memory%20(SSD).) support.
+---
+Title: RedisTimeSeries release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisTimeSeries release notes for version 1.12 and earlier
+hideListLinks: true
+linkTitle: RedisTimeSeries
+tags:
+- visible
+weight: 50
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: RediSearch 1.1 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Aggregations engine.
+linkTitle: v1.1 (April 2018)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 99
+---
+## Requirements
+
+RediSearch v1.1.0 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## RediSearch 1.1.0 (April 2018)
+
+This is a major version (we almost named it 2.0), which includes months of work, mostly on the brand new aggregations engine.
+
+### Aggregations
+
+Aggregations are a way to process the results of a search query, group, sort and transform them - and extract analytic insights from them. Much like aggregation queries in other databases and search engines, they can be used to create analytics report, or to perform Faceted Search style queries.
+
+#### Example aggregation request
+
+For example, indexing a web-server's logs, we can create report for unique users by hour. Suppose our schema includes the **SORTABLE** fields `timestamp` (Unix-timestamp) and `userId`:
+
+```sh
+FT.AGGREGATE idx "*"
+   APPLY hour(@timestamp) AS hour
+   GROUPBY 1 @hour
+      REDUCE COUNT_DISTINCT 1 @userId AS unique_users
+   SORTBY 2 @hour ASC
+```
+
+See [the full documentation on aggregations for more details](http://redisearch.io/Aggregations/)
+
+### Bug fixes over 1.0.10
+
+- Fixed #[313](https://github.com/RediSearch/RediSearch/issues/313) - removed -mpopcnt compile flag.
+
+- Fixed #[312](https://github.com/RediSearch/RediSearch/issues/312) - crash on highlighting
+---
+Title: RediSearch 1.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Hamming distance scoring. Wildcard queries. Optional deletion of documents
+  in FT.DEL. Optionally keep document hashes in FT.DROP. Delete geo-sets when dropping
+  an index. Tag prefix completion support.
+linkTitle: v1.0 (April 2018)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 100
+---
+## Requirements
+
+RediSearch v1.0.10 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## RediSearch 1.0.10 (April 2018)
+
+This is a bug-fix release with some stability fixes, a few processing bug fixes, and a few small additions:
+
+### Fixes
+
+- Fixed false positives in NOT iterator (5fe948e)
+
+- Prevent crashing with uninitialized sorting vectors (96f2473)
+
+- Fixed overflow bug in triemap, and limited tag length to 4KB (09e682f)
+
+- Fixed false positives in intersects and negative intersects (4998772)
+
+- Fixed bug in union of id lists (b8e74ef3)
+
+### New features
+
+- Added support for tag prefix completions (137b346)
+
+## RediSearch 1.0.9 (March 2018)
+
+This is a maintenance release from the 1.0 branch, that does not yet contain the aggregation engine that's already in master. It includes a few small fixes and API additions that were backported from master.
+
+### Changes
+
+#### 1. Hamming distance scoring
+
+RediSearch can now sort the search result by the inverse Hamming Distance between document payloads and the query payloads (provided they are both the same length). This can be used as a nearest neighbor search ranking when a feature vector is encoded as a bitmap and the distance metric is Hamming distance.
+
+#### 2. Wildcard queries
+
+It's now possible to search for just `*`, scanning all the documents in the index. This is useful in conjunction with the Hamming Distance scorer.
+
+#### 3. Optional deletion of documents in FT.DEL
+
+Up until now, FT.DEL did not delete the Hash key containing the actual document. As of this version, you can call it with an optional DD (Delete Document) argument, and it will also delete the document.
+
+For example: `FT.DEL myIndex myDoc DD`.
+
+#### 4. Optionally keep document hashes in FT.DROP
+
+Up until now, FT.DROP always deleted the document Hash keys. As of this version, you can specify the `KEEPDOCS` argument to FT.DROP and it will not touch them.
+
+#### 5. Delete geo-sets when dropping an index
+
+Until now we did not delete the geo-set keys where documents were geographically indexed. This version fixes this (#[295](https://github.com/RediSearch/RediSearch/issues/295))
+---
+Title: RediSearch 2.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Vector Similarity Search (VSS). New query syntax Dialect version 2. Choose
+  between Dialect 1 and Dialect 2 for query parser behavior. Hybrid queries.
+linkTitle: v2.4 (March 2022)
+min-version-db: 6.0.0
+min-version-rs: 6.0.0
+weight: 93
+---
+## Requirements
+
+RediSearch v2.4.16 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.0
+
+## v2.4.16 (November 2022)
+
+This is a maintenance release for RediSearch 2.4
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2962](https://github.com/RediSearch/RediSearch/pull/2962) Crash upon AOF preload - Use local GC context in periodic callback (MOD-3951)
+  - [#2863](https://github.com/RediSearch/RediSearch/pull/2863) High CPU Utilization - Change MAX_LEV_DISTANCE to 4 (MOD-3563)
+  - [#3041](https://github.com/RediSearch/RediSearch/pull/3041), [#3063](https://github.com/RediSearch/RediSearch/pull/3063), [#3051](https://github.com/RediSearch/RediSearch/pull/3051), [#3143](https://github.com/RediSearch/RediSearch/pull/3143) Several memory leaks (MOD-4121, MOD-4252)
+  - [#3119](https://github.com/RediSearch/RediSearch/pull/3119) Crash on intersect iterator GetCriteriaTester (MOD-4200)
+  - [#3128](https://github.com/RediSearch/RediSearch/pull/3128) Filter rules must be reevaluated per index per document (MOD-4207)
+  - [#3127](https://github.com/RediSearch/RediSearch/pull/3127) Fix assertion failure on wrong result counting, which leads to a crash (MOD-4214)
+  - [#3171](https://github.com/RediSearch/RediSearch/pull/3171) Missing implementation of NumericRangeIterator_OnReopen which lead to crash (MOD-4255)
+  - [#3191](https://github.com/RediSearch/RediSearch/pull/3191) Wrong query iterator casting which resulted in 100% CPU utilization (MOD-4290)
+  - [#3197](https://github.com/RediSearch/RediSearch/pull/3197) Release failed to create temporary indices on the main thread (MOD-4388)
+  - [#2981](https://github.com/RediSearch/RediSearch/pull/2981) Double freeing in iterators of hybrid queries resulting in crash (MOD-4411)
+  - [#3161](https://github.com/RediSearch/RediSearch/pull/3161) Latency used to increase over time when combining INKEYS and wildcard query (MOD-4343)
+
+## v2.4.15 (October 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3095](https://github.com/RediSearch/RediSearch/pull/3095) Replace order of parsing the parameters and query in the coordinator (MOD-4205)
+  - [#3012](https://github.com/RediSearch/RediSearch/pull/3012) Improved efficiency of LLAPI `findInfo`, which could reduce stability during upgrade in Redis Enterprise (MOD-4197, MOD-4052)
+  - [#3040](https://github.com/RediSearch/RediSearch/pull/3040), [#3049](https://github.com/RediSearch/RediSearch/pull/3049) Fix for `SORTBY` numeric field for non-SORTABLE fields on the coordinator (MOD-4115)
+  - [#3050](https://github.com/RediSearch/RediSearch/pull/3050) Results from fields from a missing value should come last when combined with `SORTBY` (MOD-4120)
+
+- Improvements:
+
+  - [#3047](https://github.com/RediSearch/RediSearch/pull/3047) Add `strlen` string function to `FT.AGGREGATE` (MOD-4141)
+  - [#3038](https://github.com/RediSearch/RediSearch/pull/3038) Add `number_of_uses` to `FT.INFO` for the number of times the index was queried
+
+## v2.4.14 (August 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Improvements:
+
+  - [Vector similarity v0.3.2](https://github.com/RedisAI/VectorSimilarity/releases/tag/v0.3.2)
+  - [#2955](https://github.com/RediSearch/RediSearch/pull/2955) Add timeout during prefix query (MOD-3949)
+  - [#2957](https://github.com/RediSearch/RediSearch/pull/2957) Efficient removal from prefix list for cases with many indices
+
+- Bug fixes:
+
+  - [#2937](https://github.com/RediSearch/RediSearch/pull/2937) Returning `NULL` response after encountering an expired document (MOD-3515)
+  - [#2962](https://github.com/RediSearch/RediSearch/pull/2962) Crash upon AOF preload (MOD-3951)
+  - [#2986](https://github.com/RediSearch/RediSearch/pull/2986) Memory leak related to schema prefixes
+
+## v2.4.11 (July 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2892](https://github.com/RediSearch/RediSearch/pull/2892) Combining `SORTBY` with `MAX` on `FT.SEARCH` (which is not supported) caused an inconsistent response and out-of-memory error (MOD-3540, MOD-3644)
+  - [VecSim v0.3.1](https://github.com/RedisAI/VectorSimilarity/releases/tag/v0.3.1)
+    - HNSW indices: reclaim memory upon deletion - HNSW index's data structures now reclaim memory and shrink upon deletion
+
+- Improvements:
+
+  - [VecSim v0.3.1](https://github.com/RedisAI/VectorSimilarity/releases/tag/v0.3.1)
+    - HNSW indices: delete procedure is up to 40% faster
+    - More accurate memory consumption reporting for HNSW indices
+
+## v2.4.10 (July 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2863](https://github.com/RediSearch/RediSearch/pull/2863) Crash due to too high (Levenshtein) `DISTANCE` in `FT.SPELLCHECK`. This fix limits the `DISTANCE` to 4. (MOD-3563)
+  - [#2875](https://github.com/RediSearch/RediSearch/pull/2875) Not all documents with vector fields were indexed with Auto Tiering (MOD-3584)
+  - [#2846](https://github.com/RediSearch/RediSearch/pull/2846) Enforce Redis Enterprise memory limit for vector indices
+
+## v2.4.9 (June 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2837](https://github.com/RediSearch/RediSearch/pull/2837), [#2836](https://github.com/RediSearch/RediSearch/issues/2836) Crash on `FT.AGGREGATE` "... APPLY '-INF % -1'..."
+  - [#2814](https://github.com/RediSearch/RediSearch/pull/2814) `FT.EXPLAIN` without parameters causes a crash
+  - [#2790](https://github.com/RediSearch/RediSearch/pull/2790) Incorrect `num_terms` value in `FT.INFO` after a term is deleted from all the docs (garbage collection)
+  - [#2804](https://github.com/RediSearch/RediSearch/pull/2804) Freeze when `OFFSET`+`LIMIT` was greater than `maxSearchResults` (config)
+  - [#2791](https://github.com/RediSearch/RediSearch/pull/2791) Add `BlockedClientMeasureTime` to coordinator for more accurate performance stats
+  - [#2802](https://github.com/RediSearch/RediSearch/pull/2802) Tagged parts of keys (curly brackets `{}`) are now returned by `FT.SEARCH`
+
+- Improvements:
+
+  - [#2806](https://github.com/RediSearch/RediSearch/pull/2806) Do not load the JSON API when RediSearch is initialized as a library
+
+- Minor breaking change:
+
+  - As pointed out above, [#2802](https://github.com/RediSearch/RediSearch/pull/2802) is a bug fix. However, if your application relies on RediSearch incorrectly trimming the tagged part of a key (using `{}`), this could break your application. This only applies to users who are using RediSearch in clustered databases.
+
+## v2.4.8 (May 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+However, if you're using Vector Similarity (introduced in RediSearch 2.4), there are some critical bugs that may affect a subset of users. In this case, you should upgrade.
+
+Details:
+
+- Bug fixes:
+
+  - [#2739](https://github.com/RediSearch/RediSearch/pull/2739) Memory leak in coordinator related to Vector Similarity (MOD-3023)
+  - [#2736](https://github.com/RediSearch/RediSearch/pull/2736), [#2782](https://github.com/RediSearch/RediSearch/pull/2782) Memory allocation restrictions for Vector Similarity indices (causing OOM) (MOD-3195)
+  - [#2755](https://github.com/RediSearch/RediSearch/pull/2755) Compare the entire vector field name instead of a prefix when creating a new vector index
+  - [#2780](https://github.com/RediSearch/RediSearch/pull/2780) Initialize all variables in `EvalContext` (which might have led to crashes in clustered databases)
+
+- Improvements:
+
+  - [#2740](https://github.com/RediSearch/RediSearch/pull/2740) Performance optimization for hybrid vector queries
+
+## v2.4.6 (May 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2716](https://github.com/RediSearch/RediSearch/pull/2716) Removed assert statement that could cause crashes with replica of (MOD-3008, MOD-3012)
+  - [#2734](https://github.com/RediSearch/RediSearch/pull/2734) `ON_TIMEOUT RETURN` policy fix: return results obtained until timeout rather than discarding them
+  - [#2714](https://github.com/RediSearch/RediSearch/pull/2714) Memory leak on non-TLS setup in coordinator
+
+## v2.4.5 (April 2022)
+
+This is a maintenance release for RediSearch 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2702](https://github.com/RediSearch/RediSearch/pull/2702) `INKEYS` combined with Vector Similarity caused server unresponsiveness (MOD-2952)
+  - [#2705](https://github.com/RediSearch/RediSearch/pull/2705) Incorrect results when deleting a document that was skipped at index time
+  - [#2698](https://github.com/RediSearch/RediSearch/issues/2698) Synonyms in Chinese
+
+- Improvements:
+
+  - [#2694](https://github.com/RediSearch/RediSearch/pull/2694) Performance: In a `TEXT` field, skip term iterator if term does not appear in requested field
+
+## v2.4.3 (March 2022)
+
+This is the General Availability release of RediSearch 2.4.
+
+### Headlines
+
+RediSearch 2.4 introduces a new capability, Vector Similarity Search (VSS), which allows indexing and querying vector data stored (as BLOBs) in Redis hashes.
+
+It also introduces a new query syntax to address query parser inconsistencies found in previous versions of RediSearch. Users can now choose between Dialect version 1 (to keep existing query parser behavior) or Dialect version 2 (to switch to the updated behavior).
+
+All VSS queries or any query using the `PARAMS` option must use Dialect version 2.
+
+### What's new in 2.4
+
+- `FT.CREATE` is extended to support the creation of 2 popular types of vector indexes:
+
+  - **FLAT Index**
+
+    This type of index is used when the recall is more important than the speed of query execution. A query vector will be compared to all vectors in a flat index. The search results will return the exact top k nearest neighbors to the query vector.
+
+  - **Hierarchical Navigable Small World (HNSW) Index**
+
+    This index is a modified implementation of the library written by the author of this influential [academic paper](https://arxiv.org/abs/1603.09320). An HNSW vector index is used when the speed of query execution is preferred over recall. The results returned are approximate nearest neighbors (ANNs).
+
+    You can try out different HNSW index parameters (`M`, `EFCONSTRUCTION`, `EFRUNTIME`) to improve the “recall versus speed” balance.
+
+- Use `FT.SEARCH` to retrieve the top K hashes with the most similar vectors to a given query vector.
+
+- Hybrid queries in `FT.SEARCH`:
+
+  Use hybrid queries to retrieve Redis hashes that match a combination of vector and non-vector search criteria. Non-vector search criteria can include expressions combining `NUMERIC`, `TEXT`, `TAG`, and `GEO` fields.
+
+  Hybrid queries are often used in modern ecommerce search applications featuring “visual” similarity plus metadata similarity.
+  For example, you can use a single hybrid query to find products that are visually similar to a given image within a price range and/or geo-location.
+
+- Use [`FT.CONFIG SET`]({{< relref "commands/ft.config-set" >}}) to set `DEFAULT_DIALECT` at the module level. By default, `DEFAULT_DIALECT` is set to 1.
+
+- Override `DIALECT`:
+
+  It is possible to override the module-level dialect for a specific command at runtime. You can specify the dialect when executing any of the following commands:
+
+    - [`FT.SEARCH`]({{< relref "commands/ft.search" >}})
+
+    - [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate" >}})
+
+    - [`FT.EXPLAIN`]({{< relref "commands/ft.explain" >}})
+
+    - [`FT.EXPLAINCLI`]({{< relref "commands/ft.explaincli" >}})
+
+    - [`FT.SPELLCHECK`]({{< relref "commands/ft.spellcheck" >}})
+
+  If you do not specify dialect when running any of these commands, they will use the default module-level dialect value.
+
+### Details
+
+- Features:
+
+  - [#2671](https://github.com/RediSearch/RediSearch/pull/2671) Add Dialect support
+
+- Performance enhancements (since 2.4-RC1):
+
+  - [#2647](https://github.com/RediSearch/RediSearch/pull/2647) Normalize vector once for ad-hoc flat search
+  - [#2638](https://github.com/RediSearch/RediSearch/pull/2638) Optimized hybrid query when no scores are required
+  - [#2653](https://github.com/RediSearch/RediSearch/pull/2653) Updating specific field load optimization rule
+  - [#2670](https://github.com/RediSearch/RediSearch/pull/2670) Use `REDISMODULE_EVENT_SHUTDOWN` to clear resources
+
+- Security and privacy (since 2.4-RC1):
+
+  - [#2584](https://github.com/RediSearch/RediSearch/pull/2584) Fix MOD-2086, added support for TLS passphrase
+
+- Bug fixes (since 2.4-RC1):
+
+  - [#2651](https://github.com/RediSearch/RediSearch/pull/2651) Fix client freeze on docs expire during query
+  - [#2641](https://github.com/RediSearch/RediSearch/pull/2641) Memory leak in the coordinator
+  - [#2645](https://github.com/RediSearch/RediSearch/pull/2645) Ignore NULL value on ingest
+  - [#2654](https://github.com/RediSearch/RediSearch/pull/2654) VecSim hybrid query - return empty iterator for invalid intersection child iterator
+
+### Introducing DIALECT
+
+RediSearch 2.4.3 introduces a new query syntax to address query parser inconsistencies found in previous versions of RediSearch. Users can now choose between:
+
+- Dialect version 1 (to keep the query dialect as in RediSearch 2.2)
+
+- Dialect version 2 (to use the updated dialect)
+
+Existing RediSearch 2.2 users will not have to modify their queries since the default dialect is 1.
+However, all RediSearch users should gradually update their queries to use dialect version 2.
+
+#### Background
+
+Under certain conditions, some query parsing rules did not behave as originally intended.
+Queries containing the following operators could return unexpected results:
+
+- `AND`
+- quotes, ~, -, and % (exact, optional, negation, fuzzy)
+- `OR`
+
+To minimize the impact on existing, unaffected RediSearch users, a DIALECT setting was introduced to allow:
+
+- Existing queries to run without any modification (DIALECT 1)
+
+- New queries to benefit from the updated query-parsing behavior (DIALECT 2)
+
+
+#### Examples of impacted queries
+
+Your existing queries may behave differently under different DIALECT versions, if they fall into any of the following categories:
+
+- Your query has a field modifier followed by multiple words.
+
+  Consider this simple query <nobr>`@name:James Brown`</nobr>.
+
+  The field modifier `@name` is followed by 2 words: `James` and `Brown`.
+
+  With DIALECT 1, the parser interprets this query as "find `James Brown` in the `@name` field."
+
+  With DIALECT 2, the parser interprets it as "find `James` in the `@name` field AND `Brown` in ANY text field." In other words, the query parser interprets it as <nobr>`(@name:James) Brown`</nobr>.
+
+  With DIALECT 2, you could achieve the default behavior from DIALECT 1 by updating your query to <nobr>`@name:(James Brown)`</nobr>.
+
+- Your query uses quotes, ~, -, % (exact, optional, negation, fuzzy).
+
+  Consider a simple query with negation <nobr>`-hello world`</nobr>.
+
+  With DIALECT 1, the parser interprets this query as "find values in any field that does not contain `hello` AND does not contain `world`." This is the equivalent of <nobr>`-(hello world)`</nobr> or <nobr>`-hello -world`</nobr>.
+
+  With DIALECT 2, the parser interprets it as `-hello` AND `world`, so only `hello` is negated.
+
+  With DIALECT 2, you could achieve the default behavior from dialect 1 by updating your query to <nobr>`-(hello world)`</nobr>.
+
+Another example that illustrates the differences in parser behavior is
+`hello world | "goodbye" moon`:
+
+- With DIALECT 1, the parser interprets this query as searching for `(hello world | "goodbye") moon`
+
+- With DIALECT 2, the parser interprets it as searching for either `hello world` OR `"goodbye" moon`.
+
+{{<note>}}
+This is the first GA version of 2.4. The version inside Redis will be 2.4.3 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+{{</note>}}
+---
+Title: RediSearch 2.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Automatically indexes data based on a key pattern. Scale a single index
+  over multiple Redis shards. Improved query performance.
+linkTitle: v2.0 (September 2020)
+min-version-db: 6.0.0
+min-version-rs: 6.0.0
+weight: 95
+---
+## Requirements
+
+RediSearch v2.0.13 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.0
+
+## v2.0.15 (December 2021)
+
+This is a maintenance release for RediSearch 2.0.
+
+Update urgency: `MODERATE` - Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+    - [#2388](https://github.com/RediSearch/RediSearch/pull/2388) Garbage Collection (GC) for empty ranges in numeric index
+    - [#2409](https://github.com/RediSearch/RediSearch/pull/2409) Introduction of `FORK_GC_CLEAN_NUMERIC_EMPTY_NODES true` module argument to enable [#2388](https://github.com/RediSearch/RediSearch/pull/2388) (off by default)
+    - [#325](https://github.com/RediSearch/RediSearch/pull/325) Used Redis allocator in hiredis (RSCoordinator)
+    - [#2362](https://github.com/RediSearch/RediSearch/pull/2362) Crash on empty field name
+
+## v2.0.13 (November 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Enhancements:
+  - #[2243](https://github.com/redisearch/redisearch/issues/2243) Add `LOAD *` for FT.AGGREGATE which will load all fields
+
+- Bug fixes:
+  - #[2269](https://github.com/redisearch/redisearch/issues/2269) #[2291](https://github.com/redisearch/redisearch/issues/2291) Remove TAG values from trie with no entries on Garbage Collection.
+  - #[2287](https://github.com/redisearch/redisearch/issues/2287) Uninitialized read on `FT.ADD`
+  - #[2342](https://github.com/redisearch/redisearch/issues/2342) Check for NULL result on intersect iterator
+  - #[2350](https://github.com/redisearch/redisearch/issues/2350) Crash on `FT.AGGREGATE` with `LIMIT 0 0`
+
+
+## v2.0.12 (September 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Enhancements:
+  - #[2184](https://github.com/redisearch/redisearch/issues/2184) API: getter functions for score, language and stop words list
+  - #[2188](https://github.com/redisearch/redisearch/issues/2188) Introduced the UNF parameter to SORTABLE to disable normalisation on TAG/TEXT fields
+  - #[2218](https://github.com/redisearch/redisearch/issues/2218) API: added RediSearch_CreateDocument2
+
+- Bug fix:
+  - #[2153](https://github.com/redisearch/redisearch/issues/2153) Restore FT.INFO complexity to O(1)
+  - #[2203](https://github.com/redisearch/redisearch/issues/2203) FT.AGGREGATE returns inaccurate results when TAG field is not set in hash
+
+
+## v2.0.11 (August 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Enhancements:
+  - #[2156](https://github.com/redisearch/redisearch/issues/2156) TAG fields can now be case sensitive using the `CASESENSITIVE` parameter
+  - #[2113](https://github.com/redisearch/redisearch/issues/2113) An already existing document that can't be updated is removed from the index (JIRA MOD-1266)
+  - #[267](https://github.com/RediSearch/RSCoordinator/pull/267) #[287](https://github.com/RediSearch/RSCoordinator/pull/287) Updated Hiredis to support Intershard TLS
+
+- Bug Fixes:
+  - #[2117](https://github.com/redisearch/redisearch/issues/2117) #[2115](https://github.com/redisearch/redisearch/issues/2115) Fix crash on coordinator on first value reducer
+
+## v2.0.10 (July 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Enhancements:
+    - #[2025](https://github.com/redisearch/redisearch/issues/2025) Improve performances on numeric range search
+    - #[1958](https://github.com/redisearch/redisearch/issues/1958) #[2033](https://github.com/redisearch/redisearch/issues/2033) Support of sortable on the `GEO` type
+    - #[2079](https://github.com/redisearch/redisearch/issues/2079) Update to Snowball 2.1.0, adds Armenian, Serbian and Yiddish stemming support
+    - #[2002](https://github.com/redisearch/redisearch/issues/2002) Add stopwords list support in the API
+
+- Bug fix:
+    - #[2045](https://github.com/redisearch/redisearch/issues/2045) Possible crash when loading an RDB file (silently ignore double load of alias)
+    - #[2099](https://github.com/redisearch/redisearch/issues/2099) #[2101](https://github.com/redisearch/redisearch/issues/2101) Fixes possible crash with CRDT on `FT.DROPINDEX`
+    - #[1994](https://github.com/redisearch/redisearch/issues/1994) Skip intersect iterator qsort if `INORDER` flag is used 
+    - #[257](https://github.com/redisearch/rscoordinator/issues/257) Switch coordinator to send _FT.CURSOR instead FT.CURSOR to prevent data access without holding the lock
+
+## v2.0.9 (May 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Bug fix in RSCoordinator:
+    - #[259](https://github.com/RediSearch/RSCoordinator/pull/259): Fix deadlock on cursor read by performing cursor command on background thread
+
+## v2.0.8 (May 2021)
+
+This is a maintenance release for version 2.0.
+
+This release fixes an important regression introduced by the 2.0 release. The payload is supposed to be returned only when the WITHPAYLOADS parameter is set.
+
+Details:
+
+- Bug fixes:
+    - #[1959](https://github.com/redisearch/redisearch/issues/1959) Renamed parse_time() to parsetime()
+    - #[1932](https://github.com/redisearch/redisearch/issues/1932) Fixed crash resulted from LIMIT arguments
+    - #[1919](https://github.com/redisearch/redisearch/issues/1919) Prevent GC fork from crashing
+- Minor enhancements:
+    - #[1880](https://github.com/redisearch/redisearch/issues/1880) Optimisation of intersect iterator
+    - #[1914](https://github.com/redisearch/redisearch/issues/1914) Do not return payload as a field
+
+## v2.0.7 (May 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Major enhancements:
+    - #[1864](https://github.com/redisearch/redisearch/issues/1864) Improve query time by predetermining reply array length.
+    - #[1879](https://github.com/redisearch/redisearch/issues/1879) Improve loading time by calling RM_ScanKey instead of RM_Call
+- Major bug fix:
+    - #[1866](https://github.com/redisearch/redisearch/issues/1866) Fix a linking issue causing incompatibility with Redis 6.2.0.
+    - #[1842](https://github.com/redisearch/redisearch/issues/1842) #1852 Fix macOS build.
+- Minor bug fixes:
+    - #[1850](https://github.com/redisearch/redisearch/issues/1850) Fix a race condition on drop temporary index.
+    - #[1855](https://github.com/redisearch/redisearch/issues/1855) Fix a binary payload corruption.
+    - #[1876](https://github.com/redisearch/redisearch/issues/1876) Fix crash if the depth of the reply array is larger than 7.
+    - #[1843](https://github.com/redisearch/redisearch/issues/1843) #[1860](https://github.com/redisearch/redisearch/issues/1860) Fix low-level API issues.
+
+## v2.0.6 (February 2021)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Minor additions:
+    - #[1696](https://github.com/redisearch/redisearch/issues/1696) The maximum number of results produced by `FT.AGGREGATE` is now configurable: `MAXAGGREGATERESULTS`.
+    - #[1708](https://github.com/redisearch/redisearch/issues/1708) [Stemming]({{<relref "/develop/interact/search-and-query/advanced-concepts/stemming">}}) updated with support of new languages: Basque, Catalan, Greek, Indonesian, Irish, Lithuanian, Nepali.
+- Minor bugfixes:
+    - #[1668](https://github.com/redisearch/redisearch/issues/1668) Fixes support of stop words in [tag fields]({{<relref "/develop/interact/search-and-query/advanced-concepts/tags">}}). Solves also the following related issues: #[166](https://github.com/redisearch/redisearch/issues/166),  #[984](https://github.com/redisearch/redisearch/issues/984), #[1237](https://github.com/redisearch/redisearch/issues/1237), #[1294](https://github.com/redisearch/redisearch/issues/1294).
+    - #[1689](https://github.com/redisearch/redisearch/issues/1689) Consistency fix and performance improvement when using `FT.SUGGET` with [RSCoordinator](https://github.com/RediSearch/RSCoordinator).
+    - #[1774](https://github.com/redisearch/redisearch/issues/1774) `MINPREFIX` and `MAXFILTEREXPANSION` configuration options can be changed at runtime.
+    - #[1745](https://github.com/redisearch/redisearch/issues/1745) Enforce 0 value for `REDUCER COUNT`.
+    - #[1757](https://github.com/redisearch/redisearch/issues/1757) Return an error when reaching the maximum number of sortable fields, instead of crashing.
+    - #[1762](https://github.com/redisearch/redisearch/issues/1762) Align the maximum number of sortable fields with the maximum number of fields (1024)
+
+
+## v2.0.5 (December 2020)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Minor features:
+    - [#1696](https://github.com/RediSearch/RediSearch/pull/1696) Add `MAXAGGREGATERESULTS` module configuration for `FT.AGGREGATE`. Similar to `MAXSEARCHRESULTS` for `FT.SEARCH`, it limits the maximum number of results returned.
+
+## v2.0.4 (December 2020)
+
+This is a maintenance release for version 2.0.
+
+Details:
+
+- Bugfixes in RediSearch:
+    - [#1668](https://github.com/RediSearch/RediSearch/pull/1668) Stopwords are not filtered out on tag fields.
+- Bugfixes in RSCoordinator:
+    - [#206](https://github.com/RediSearch/RediSearch/pull/206) `FT.AGGREGATE` with `LIMIT` and `offset` greater than `0` returned fewer results than requested.
+
+## v2.0.3 (November 2020)
+
+This is a maintenance release for version 2.0.
+
+Minor bugfixes:
+
+- Added [`OSS_GLOBAL_PASSWORD`](https://github.com/RediSearch/RSCoordinator#running-rscoordinator) config argument to allow specify shards password on OSS cluster.
+- Update `min_redis_pack_version` to 6.0.8
+
+## v2.0.2 (November 2020)
+
+This is a maintenance release for version 2.0.
+
+- Minor enhancements:
+
+    - [#1625](https://github.com/RediSearch/RediSearch/pull/1625) MAXPREFIXEXPANSIONS configuration which replaces the now deprecated config MAXEXPANSIONS. Same behaviour, more declarative naming.
+    - [#1614](https://github.com/RediSearch/RediSearch/pull/1614) Prevent multiple sortby steps on FT.AGGREGATE
+
+- Minor bug fixes:
+
+    - [#1605](https://github.com/RediSearch/RediSearch/pull/1605) Rare bug where identical results would get a lower score
+
+## v2.0.1 (October 2020)
+
+This is a maintenance release for version 2.0.
+
+- Minor additions:
+
+    - [#1432](https://github.com/RediSearch/RediSearch/pull/1432) FT.AGGREGATE allows filtering by key and returning the key by using LOAD "@__key" .
+
+- Minor bug fixes:
+
+    - [#1571](https://github.com/RediSearch/RediSearch/pull/1571) Using FILTER in FT.CREATE might cause index to not be in sync with data.
+    - [#1572](https://github.com/RediSearch/RediSearch/pull/1572) Crash when using WITHSORTKEYS without SORTBY.
+    - [#1540](https://github.com/RediSearch/RediSearch/pull/1540) SORTBY should raise an error if the field is not defined as SORTABLE.
+
+## v2.0.0 (September 2020)
+
+RediSearch 2.0 is a public preview release meeting GA standards. This release includes several improvements in performance and usability over RediSearch 1.0. These improvements necessitate a few backward-breaking changes to the API.
+
+### Highlights
+
+For this release, we changed the way in which the search indexes are kept in sync with your data. In RediSearch 1.x, you had to manually add data to your indexes using the `FT.ADD` command. In RediSearch 2.x, your data is indexed automatically based on a key pattern.
+
+These changes are designed to enhance developer productivity, and to ensure that
+your search indexes are always kept in sync with your data. To support this, we've
+made a few changes to the API.
+
+In addition to simplifying indexing, RediSearch 2.0 allows you to scale a single index over multiple Redis shards using the Redis cluster API.
+
+Finally, RediSearch 2.x keeps its indexes outside of the main Redis key space. Improvements to the indexing code have increased query performance 2.4x.
+
+You can read more details in [the RediSearch 2.0 announcement blog post](https://redislabs.com/blog/introducing-redisearch-2-0/), and you can get started by checking out this [quick start blog post](https://redislabs.com/blog/getting-started-with-redisearch-2-0/).
+
+{{<image filename="images/modules/redisearch-2-0-architecture.png" alt="Compares the architecture of RediSearch 2.0 to architecture of earlier versions." >}}
+
+### Details
+
+- When you create an index, you must specify a prefix condition and/or a filter. This determines which hashes RediSearch will index.
+- Several RediSearch commands now map to their Redis equivalents: `FT.ADD` -> `HSET`, `FT.DEL` -> `DEL` (equivalent to `FT.DEL` with the DD flag in RediSearch 1.x), `FT.GET` -> `HGETALL`, `FT.MGET` -> `HGETALL`.
+- RediSearch indexes no longer reside within the key space, and the indexes are no longer saved to the RDB.
+- You can upgrade from RediSearch 1.x to RediSearch 2.x.
+
+### Noteworthy changes
+
+- [#1246](https://github.com/RediSearch/RediSearch/pull/1246): `geodistance` function for `FT.AGGREGATE` APPLY operation.
+- [#1394](https://github.com/RediSearch/RediSearch/pull/1394): Expired documents (TTL) will be removed from the index.
+- [#1394](https://github.com/RediSearch/RediSearch/pull/1394): Optimization to avoid reindexing documents when non-indexed fields are updated.
+- After index creation, an initial scan starts for existing documents.  You can check the status of this scan by calling `FT.INFO` and looking at the `indexing` and `percent_indexed` values.  While `indexing` is true, queries return partial results.
+- [#1435](https://github.com/RediSearch/RediSearch/pull/1435): `NOINITIALINDEX` flag on `FT.CREATE` to skip the initial scan of documents on index creation.
+- [#1401](https://github.com/RediSearch/RediSearch/pull/1401): Support upgrade from v1.x and for reading RDB's created by RediSearch 1.x.
+- [#1445](https://github.com/RediSearch/RediSearch/pull/1445): Support for load event. This event indexes documents when they are loaded from RDB, ensuring that indexes are fully available when RDB loading is complete (available from Redis 6.0.7 and above).
+- [#1384](https://github.com/RediSearch/RediSearch/pull/1384): `FT.DROPINDEX`, which by default does not delete documents underlying the index (see deprecated `FT.DROP`).
+- [#1385](https://github.com/RediSearch/RediSearch/pull/1385): Add index definition to `FT.INFO` response.
+- [#1097](https://github.com/RediSearch/RediSearch/pull/1097): Add Hindi snowball stemmer.
+- The `FT._LIST` command returns a list of all available indices.  Note that this is a temporary command, as indicated by the `_` in the name, so it's not documented. We're working on a [`SCAN`]({{< relref "/commands/scan" >}}-like command for databases with many indexes.
+- The RediSearch version will appear in Redis as `20000`, which is equivalent to 2.0.0 in semantic versioning. Since the version of a module in Redis is numeric, we cannot explicitly add an GA flag.
+- RediSearch 2.x requires Redis 6.0 or later.
+
+### Behavior changes
+
+Make sure you review these changes before upgrading to RediSearch 2.0:
+
+- [#1381](https://github.com/RediSearch/RediSearch/pull/1381): `FT.SYNADD` is removed; use `FT.SYNUPDATE` instead. `FT.SYNUPDATE` requires both
+and index name and a synonym group ID. This ID can be any ASCII string.
+- [#1437](https://github.com/RediSearch/RediSearch/pull/1437): Documents that expire during query execution time will not appear in the results (but might have been counted in the number of produced documents).
+- [#1221](https://github.com/RediSearch/RediSearch/pull/1221): Synonyms support for lower case. This can result in a different result set on FT.SEARCH when using synonyms.
+- RediSearch will not index hashes whose fields do not match an existing index schema. You can see the number of hashes not indexed using `FT.INFO` - `hash_indexing_failures `.  The requirement for adding support for partially indexing and blocking is captured here: [#1455](https://github.com/RediSearch/RediSearch/pull/1455).
+- Removed support for `NOSAVE`.
+- RDB loading will take longer due to the index not being persisted.
+- Field names in the [query syntax]({{<relref "/develop/interact/search-and-query/advanced-concepts/query_syntax">}}) are now case-sensitive.
+- Deprecated commands:
+    - `FT.DROP` (replaced by `FT.DROPINDEX`, which by default keeps the documents)
+    - `FT.ADD` (mapped to `HSET` for backward compatibility)
+    - `FT.DEL` (mapped to `DEL` for backward compatibility)
+    - `FT.GET` (mapped to `HGETALL` for backward compatibility)
+    - `FT.MGET` (mapped to `HGETALL` for backward compatibility)
+- Removed commands:
+    - `FT.ADDHASH` (no longer makes sense)
+    - `FT.SYNADD` (see [#1381](https://github.com/RediSearch/RediSearch/pull/1381))
+    - `FT.OPTIMIZE`
+---
+Title: RediSearch 1.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Conditional updates. Schema modification. Query spelling correction.
+  Phonetic matching. More fuzziness in search. Retrieve and change runtime configuration.
+  Unlimited autocomplete results.
+linkTitle: v1.4 (August 2018)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 97
+---
+## Requirements
+
+RediSearch v1.4.28 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v1.4.28 (May 2020)
+
+This is a maintenance release for version 1.4.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1218](https://github.com/RediSearch/RediSearch/pull/1218) Potential crash when running without concurrency and using the cursor API.
+
+## v1.4.27 (April 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Features:
+    - #[1172](https://github.com/redisearch/redisearch/issues/1172) Added `exists` function that can be used on conditional updates `REPLACE PARTIAL` to check if a field exists in the document.
+- Minor Enhancements:
+    - #[1172](https://github.com/redisearch/redisearch/issues/1172) Lazy evaluation of the right side of 'or'/'and' clauses in IF condition.
+- Bugfixes:
+    - #[1110](https://github.com/redisearch/redisearch/issues/1110) Rare GC failure when accessing uninitialized variable.
+    - #[1131](https://github.com/redisearch/redisearch/issues/1131) Crash on highlighting a search query where the document no longer exists.
+
+## v1.4.26 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Fix rare `FORK GC` crash which caused by accessing uninitialized variable.
+
+## v1.4.25 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Features:
+    - #[1051](https://github.com/RediSearch/RediSearch/issues/1051) Added support for updating tag fields on document updates with `NOINDEX` fields.
+- Bugfixes:
+    - #[1051](https://github.com/RediSearch/RediSearch/issues/1051) `FORK GC` was not updating the unique sum of the numeric index.
+
+## v1.4.24 (January 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1038](https://github.com/RediSearch/RediSearch/issues/1038) Memory leak on cursor.
+    - #[1049](https://github.com/RediSearch/RediSearch/issues/1049) Crash on conversion error when freeing other indexed fields.
+
+## v1.4.23
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - Memory leak when cursor timed out and cursor wasn't consumed.
+
+## v1.4.22
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - FILTER option was not working correctly with coordinator.
+    - Memory leak when cursor was combined with sorted fields.
+
+## v1.4.21
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1031](https://github.com/RediSearch/RediSearch/issues/1031) Highlighting crashed when used with `NOINDEX` fields.
+
+## v1.4.20 (January 2020)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Improvements
+    - #[1020](https://github.com/RediSearch/RediSearch/issues/1020) Performance improvement for reading fields that are not sortable.
+- Bugfixes
+    - #[1022](https://github.com/RediSearch/RediSearch/issues/1022) Illegal memory access by queries during `GC` run.
+    - #[1022](https://github.com/RediSearch/RediSearch/issues/1022) Recreating the index with the same name (delete+create) removed the index from cursor list.
+    - #[1022](https://github.com/RediSearch/RediSearch/issues/1022) Memory leak when performing `FT.AGGREGATE` on non-existing index.
+    - #[1022](https://github.com/RediSearch/RediSearch/issues/1022) Potential data corruption during `GC` run.
+    - #[1025](https://github.com/RediSearch/RediSearch/issues/1025) Aliasing not working properly with `FT.AGGREGATE`.
+
+## v1.4.19 (December 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bugfixes
+    - #[1000](https://github.com/RediSearch/RediSearch/issues/1000) - `FT.DEL` was not replicated to replica correctly
+    - #[1004](https://github.com/RediSearch/RediSearch/issues/1004) -  Memory leak on `TAG` array on certain situations
+    - #[1006](https://github.com/RediSearch/RediSearch/issues/1006) - Unexposed error on conditional update `IF` that caused the error message to leak
+
+## v1.4.18 (November 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bug fixes
+    - [#947](https://github.com/RediSearch/RediSearch/issues/947) Fix short read on FORK GC pipe that could result in a crash and potential data corruption
+
+## v1.4.17 (October 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Features:
+    - #[779](https://github.com/RediSearch/RediSearch/issues/779) Added `to_number()` and `to_str()` functions for ambiguity reasons
+- Improvements
+    - #[891](https://github.com/RediSearch/RediSearch/issues/891) All memory allocations will now use the redis memory allocator.  This means that all the memory will be exposed correctly in the redis `INFO MEMORY` command.
+
+## v1.4.16 (September 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Main features:
+
+- #[883](https://github.com/RediSearch/RediSearch/issues/883) Forkgc optimizations - introduce new config parameter `FORK_GC_CLEAN_THRESHOLD`. RediSearch will only start to clean when the number of not cleaned documents is exceeding this threshold.
+
+Main Fixes:
+
+- #[848](https://github.com/RediSearch/RediSearch/issues/848) RediSearch will not crash when sorting on fields that don't exists in all documents.
+- #[884](https://github.com/RediSearch/RediSearch/issues/884) Fix wrong results on intersect iterator.
+
+## v1.4.15 (28 August 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Main Fixes:
+
+- #[866](https://github.com/RediSearch/RediSearch/issues/866) - Fix RDB corruption caused by deleting none-existing terms from the suggestion trie.
+- When Redis exits, forked processes by FORK Garbage Collection will now be closed accordingly.
+- For indices that are not temporary and interleaved: When an index is dropped, the indexer thread is now closed.
+
+## v1.4.14 (20 August 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Main Fixes:
+
+- #[851](https://github.com/RediSearch/RediSearch/issues/851) In interleaved mode (non safemode), documents deleted by concurrent updates, will be ignored.
+
+## v1.4.13 (8 August 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- #[798](https://github.com/RediSearch/RediSearch/issues/798) fix issue where phonetic queries return wrong results
+- #[820](https://github.com/RediSearch/RediSearch/issues/820) fix crash on getting a none existing doc from a doc table
+- Fix issue with invalid memory read when using tags with ' ' (space) separator
+
+## v1.4.12 (5 August 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main features:
+
+- #[741](https://github.com/RediSearch/RediSearch/issues/741) Allow Chinese tokenizing to recognise \-escape for punctuations
+
+Main Fixes:
+
+- #[739](https://github.com/RediSearch/RediSearch/issues/739) Fix crash on search error
+- #[346](https://github.com/RediSearch/RediSearch/issues/346) Fix issue where fuzzy can not be used with numbers
+- #[769](https://github.com/RediSearch/RediSearch/issues/769) Fix rare crash on rdb loading
+- #[749](https://github.com/RediSearch/RediSearch/issues/749) On prefix searches, do not expand prefixes to terms which have no documents
+
+## v1.4.11 (June 2019)
+
+Update urgency: Medium
+
+This release only add support for aliasing to the previews 1.4.10 release.
+
+- Added functionality
+    - #[731](https://github.com/RediSearch/RediSearch/issues/731) Add index aliasing. This allows users to provide (or remove) ‘links’ to indexes. The commands are FT.ALIASADD, FT.ALIASDEL, and FT.ALIASUPDATE.
+
+## v1.4.10 (28 May 2019)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Fix memory leak when combining SORT with APPLY on FT.AGGREGATE
+
+## v1.4.9 (18 May 2019)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Fork GC will now squash the empty blocks of the inverted indexes.
+- Fix invalid memory access when using aggregate with GROUPBY.
+- Fix issue where using limit with SORTBY might return duplicate results.
+
+Known Issue:
+
+- Memory leak when combining SORT and APPLY in FT.AGGREGATE. This issue is fixed on 1.4.10. It's recommended to skip directly to 1.4.10.
+
+## v1.4.8 (29 April 2019)
+
+Update urgency: Low
+
+Technical release, no changes nor fixes.
+
+## v1.4.7 (29 April 2019)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Fix issue where Dropping and recreating the same index while querying might cause crashes.
+
+## v1.4.6 (8 April 2019)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Loading a potentially corrupted RDB files generated by versions lower than 1.4
+- Fix issue where `REPLACE PARTIAL` might not work properly (#[621](https://github.com/RediSearch/RediSearch/issues/621))
+
+## v1.4.5 (March 2019)
+
+Update urgency: Low
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Fixed issue where FORK GC causing redis rdb fork to fail
+
+## v1.4.4 (21 February 2019)
+
+Update urgency: Low
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+- Fixed memory leak on Fork GC
+- Fixed key close after releasing GIL on Fork GC (might cause crashed on rare situations)
+
+## v1.4.3 (4 February 2019)
+
+Update urgency: Low
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes for issues found after the previous release .
+
+Main Fixes:
+
+1. Fixed memory leak on mempool destroy
+1. Fixed process crash when running with fork GC (preview)
+1. Fixed fork GC  (preview)  deadlock when using Tags
+1. Fixed memory leaks on index creation and deletion
+
+## v1.4.2 (27 November 2018)
+
+Update urgency: Low
+
+This is a maintenance release for version 1.4.
+
+This release improves overall stability and provides fixes to issues found.
+
+## v1.4.1 (12 November 2018)
+
+Update urgency: Medium
+
+This is a maintenance release for version 1.4, with the next version planned for release being 2.0.
+
+This release improves overall stability and focuses on performance improvements of the garbage collector. It also includes:
+
+- New: Runtime Configuration
+- Change: Unlimited Autocomplete Results
+
+### Garbage collector
+
+RediSearch employs a garbage collector that removes deleted documents from the internal data structures.
+
+In this release the garbage collection mechanism was improved in terms of efficiency, i.e. the amount of memory it reclaims, as well as in terms of performance (i.e. it is faster). The improved mechanism uses forked threads. Additional details can be found in this post: [How We Increased Garbage Collection Performance with RediSearch 1.4.1](https://redislabs.com/blog/increased-garbage-collection-performance-redisearch-1-4-1/).
+
+The improved collection mechanism is currently **experimental*- and is not enabled by default. Enabling the new garbage collection mechanism requires setting the `GC_POLICY` configuration option to `FORK` at load time, for example:
+
+```sh
+redis-server --loadmodule ./redisearch.so GC_POLICY FORK
+```
+
+### Runtime configuration
+
+RediSearch's [configuration]({{<relref "/develop/interact/search-and-query/administration/configuration">}}) is applied via arguments passed to the module at load time. This release introduces the new `FT.CONFIG` command that allows to retrieve the current configuration as well as change it during runtime.
+
+### Unlimited autocomplete results
+
+This version removes the limit of 10 results from `FT.SUGGET` - you can set the `MAX num` as high as needed.
+
+## v1.4.0 (August 2018)
+
+**Update urgency:*- Medium - mainly due to numerous fixes
+
+This version improves overall stability and performance of RediSearch. It also delivers better support for use cases in which documents are continuously updated. New features:
+
+- Conditional updates
+- Schema modification
+- Query spelling correction
+- Phonetic matching
+- Enhancement: More fuzziness in search
+
+### Continuous updates
+
+Like most search engines, RediSearch was designed for maintaining append-mostly indices. To update an existing document, the document is actually replaced - that is deleted and added to the index.
+
+Because RediSearch provides realtime indexing and searching, it is sometimes used to search near-realtime data (or the results of its processing). In such cases, the number of indexed documents stays mostly static, but their contents are continuously updated.
+
+To support this use case, RediSearch has been reworked internally to use 64-bit internal document IDs so that an index can sustain high update throughputs without overflowing. Furthermore and as a result, significant effort has been put into improving memory management and garbage collection.
+
+### Conditional updates
+
+The `IF` subcommand has been add to `FT.ADD`. When used with the existing `REPLACE [PARTIAL]` subcommand, the document will be updated only if the condition provided evaluates to a truth value, otherwise a special `NOADD` reply is returned.
+
+### Schema modification
+
+The `FT.ALTER` command has been introduced, and provides the ability to add new fields to the definition of an existing index. The contents of such newly-added fields are indexed only for new or updated documents.
+
+### Query spelling correction
+
+Query spelling correction, a.k.a "did you mean", is now provided via the `FT.SPELLCHECK` command. It enables generating suggestions for search terms that could be misspelled. For more details see [Query Spelling Correction]({{<relref "/develop/interact/search-and-query/advanced-concepts/spellcheck">}}).
+
+### Phonetic matching
+
+Phonetic matching, a.k.a "Jon or John?", is now supported via the `PHONETIC` text field attribute. The terms in such fields are also indexed by their phonetic equivalents, and search results include these by default. For more details see [Phonetic Matching]({{<relref "/develop/interact/search-and-query/advanced-concepts/phonetic_matching">}}).
+
+### More fuzziness in search
+
+The fuzzy match operator, '%', can now be repeated up to three times to specify the Levenshtein distance. That means that the queries `%hello%`, `%%hello%%` and `%%%hello%%%` will perform fuzzy matching on 'hello' for all terms with LD of 1, 2 and 3, respectively.
+---
+Title: RediSearch 2.8 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RESP3 support. Geo Polygon Search. Performance improvements.
+linkTitle: v2.8 (July 2023)
+min-version-db: '7.2'
+min-version-rs: 7.2.4
+weight: 91
+---
+## Requirements
+
+RediSearch v2.8.26 requires:
+
+- Minimum Redis compatibility version (database): 7.2
+- Minimum Redis Enterprise Software version (cluster): 7.2.4
+
+## v2.8.26 (April 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5864](https://github.com/redisearch/redisearch/pull/5864) Last query result using `FT.AGGREGATE` with `ON_TIMEOUT RETURN` and using multi-threading could be missing (MOD-9222)
+- [#5863](https://github.com/redisearch/redisearch/pull/5863) Collecting empty results from shards during `FT.AGGREGATE` with RESP3 could cause a crash (MOD-9174)
+
+Improvements:
+- [#5938](https://github.com/redisearch/redisearch/pull/5938) Improved performance (reduced CPU time) of collecting vector index statistics(MOD-9354)
+- [#5800](https://github.com/redisearch/redisearch/pull/5800) Improved accuracy of index memory reporting by correcting a bug that caused negative memory counts (MOD-5904)
+
+
+Created on: 2025-04-21T14:51:40Z
+
+## v2.8.25 (March 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5709](https://github.com/redisearch/redisearch/pull/5709) Weights in the query string are ignored if using `SCORER BM25` (MOD-7896)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Cursor with `SORTBY` is never depleted, blocking queries if the cursor limit is reached (MOD-8483)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Empty results with RESP3 due to the `TIMEOUT`, even if `ON_TIMEOUT` is set to `RETURN`(MOD-8482)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Cursor with RESP3 on `FT.AGGREGATE` is never depleted, blocking queries if cursor the limit is achieved (MOD-8515)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Using `FT.CURSOR READ` on queries that timed out led to fewer results than expected (MOD-8606)
+- [#5810](https://github.com/redisearch/redisearch/pull/5810) The `total_results` field of the `FT.AGGREGATE` command is not correct in RESP3 (MOD-9054)
+
+Improvements:
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Corrected a coordinator race condition that prevented premature release, avoiding errors and inconsistencies during query executions (MOD-8794)
+
+## v2.8.24 (February 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Bug fixes:
+- [#5647](https://github.com/redisearch/redisearch/pull/5647) `FT.SEARCH` using Cyrillic characters and wildcards delivering no results (MOD-7944)
+
+## v2.8.23 (February 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5605](https://github.com/redisearch/redisearch/pull/5605) Changes on the memory block reading logic could cause crash on `FT.SEARCH` with error "_Redis 7.4.2 crashed by signal: 11, si_code: 128_"
+
+Known limitations:
+- Only the first 128 characters of string fields are normalized to lowercase during ingestion (for example, on `HSET`).
+    Example:
+
+    ```
+    HSET doc __score 1.0 name "idx1S...S" mynum 1          # Assume "S...S" is a string of 252 capital S's
+    FT.CREATE "idx" SCHEMA "name" "TEXT" "mynum" "NUMERIC"
+    FT.SEARCH "idx" "@name:idx1S...S"                      # Assume "S...S" is a string of 252 capital S's
+    ```
+
+    The `FT.SEARCH` command will return no documents.
+
+## v2.8.22 (January 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5475](https://github.com/redisearch/redisearch/pull/5475) NOSTEM option does not work on query, just tokenising (MOD-7634)
+- [#5542](https://github.com/redisearch/redisearch/pull/5542) Querying for the latest document added to the index may result in a crash if the last block is not read (MOD-8561).
+
+## v2.8.21 (January 2025)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+**Security and privacy:**
+- [#5457](https://github.com/redisearch/redisearch/pull/5457) (CVE-2024-51737) Query: potential out-of-bounds write (MOD-8486)
+
+Bug fixes:
+- [#5299](https://github.com/redisearch/redisearch/pull/5299) Prefix/Infix/Suffix queries longer than 1024 chars could cause a crash (MOD-7882)
+- [#5303](https://github.com/redisearch/redisearch/pull/5303) Expired keys while background indexing could cause cross slot error when using `replicaof` (MOD-7949)
+- [#5280](https://github.com/redisearch/redisearch/pull/5280) `FT.CURSOR READ` retrieving deleted `TAG` fields cause a crash (MOD-8011)
+- [#5427](https://github.com/redisearch/redisearch/pull/5427) `FT.AGGREGATE` on numeric fields lead to `failed_calls` count increase on clustered DBs (MOD-8058)
+- [#5242](https://github.com/redisearch/redisearch/pull/5242) Memory count on `bytes_collected` by the index sanitiser with missing values (MOD-8097, MOD-8114)
+- [#5167](https://github.com/redisearch/redisearch/pull/5167) Cursors from queries that timed out weren't depleted causing exhaustion of number of cursors available(MOD-8009)
+
+Improvements:
+- [#5260](https://github.com/redisearch/redisearch/pull/5260) Optimizing index consumed memory with the creation only upon write operations (MOD-8125)
+
+## v2.8.17 (August 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+- Bug fixes:
+
+  - [#4941](https://github.com/redisearch/redisearch/pull/4941) Adjusting the module configuration to avoid routing overload on the first shard in a clustered database (MOD-7505)
+  - [#4950](https://github.com/redisearch/redisearch/pull/4950) `FT.PROFILE` on `AGGREGATE` numeric queries could cause a crash due to reusing internal `CURSOR` in large range of numeric values (MOD-7454)
+
+## v2.8.16 (August 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+- Bug fixes:
+
+  - [#4896](https://github.com/redisearch/redisearch/pull/4896) - `FT.AGGREGATE` with `VERBATIM` option is not handled by the shards in cluster mode (MOD-7463)
+  - [#4917](https://github.com/redisearch/redisearch/pull/4917) - Union query, similar to `"is|the"`, starting with 2 [stopwords](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/stopwords/) could cause a crash (MOD-7495)
+  - [#4921](https://github.com/redisearch/redisearch/pull/4921) - Counting twice the field statistics at the `#search` section of an `INFO` response (MOD-7339)
+  - [#4939](https://github.com/redisearch/redisearch/pull/4939) - Query warning when using RESP3 response for reaching `MAXPREFIXEXPANSION` (MOD-7588)
+  - [#4930](https://github.com/redisearch/redisearch/pull/4930) - Loop when using the wildcard `w'term'` and prefix/infix/suffix pattern `'ter*'` leading shard to restart (MOD-7453)
+  - [#4912](https://github.com/redisearch/redisearch/pull/4912) - Avoid stemming expansion when querying for numeric values (MOD-7025)
+
+## v2.8.15 (July 2024)
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+- Bug fixes:
+  - [#4754](https://github.com/RediSearch/RediSearch/pull/4754) - Correct return the maximum value for negative values when using `MAX` reducer (MOD-7252)
+  - [#4737](https://github.com/RediSearch/RediSearch/pull/4737) - Separators ignored when escaping backslash `\` after the escaped character such as in `hello\\,world` ignoring `,` (MOD-7240)
+  - [#4717](https://github.com/RediSearch/RediSearch/pull/4717) - Sorting by multiple fields `SORTBY 2 @field1 @field2` was ignoring the subsequent field(MOD-7206)
+  - [#4803](https://github.com/RediSearch/RediSearch/pull/4803) - Keys expiring during query returning empty array (MOD-7010)
+  - [#4794](https://github.com/RediSearch/RediSearch/pull/4794) - Index sanitiser (GC) trying to clean deleted numeric index could cause a crash (MOD-7303)
+
+- Improvements:
+  - [#4792](https://github.com/RediSearch/RediSearch/pull/4792) - Add character validations to simple string replies and escape it when required(MOD-7258)
+  - [#4768](https://github.com/RediSearch/RediSearch/pull/4768) - Indicate which value is missing on the error message at the aggregation pipeline (MOD-7201)
+  - [#4745](https://github.com/RediSearch/RediSearch/pull/4745) - `GROUPBY` recursion cleanup (MOD-7245)
+  - [#4823](https://github.com/RediSearch/RediSearch/pull/4823) - Mechanism of keys expiration during the query execution clearing intermediate results
+
+## v2.8.14 (June 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+- Bug fixes:
+
+  - [#4614](https://github.com/RediSearch/RediSearch/pull/4614) Shards become unresponsive when using `FT.AGGREGATE` with `APPLY 'split(...)'`(MOD-6759)
+  - [#4556](https://github.com/RediSearch/RediSearch/pull/4556) `FT.EXPLAIN` returns additional `}` when querying using wildcards (MOD-6768)
+  - [#4646](https://github.com/RediSearch/RediSearch/pull/4646) `FT.DROPINDEX` with `DD` flag deleted keys in one AA cluster but not the others (MOD-1855)
+
+- Improvements:
+  - [#4595](https://github.com/RediSearch/RediSearch/pull/4595) Report memory of the `TAG` and `TEXT` tries (MOD-5902)
+  - [#4669](https://github.com/RediSearch/RediSearch/pull/4669) Inverted index memory counting (MOD-5977,MOD-5866)
+  - [#4687](https://github.com/RediSearch/RediSearch/pull/4687) Add missing `FT.INFO` fields when used within a cluster (MOD-6920)
+
+## v2.8.13 (March 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#4481](https://github.com/RediSearch/RediSearch/pull/4481) Query syntax on `GEOSHAPE` accepting just prefix instead of complete predicate (MOD-6663)
+  - [#4513](https://github.com/RediSearch/RediSearch/pull/4513) `FT.CURSOR READ` in a numeric query causing a crash (MOD-6597)
+  - [#4534](https://github.com/RediSearch/RediSearch/pull/4534) `FT.PROFILE` with incorrect arguments could cause a crash on cluster setup (MOD-6791)
+  - [#4530](https://github.com/RediSearch/RediSearch/pull/4530) Some parameter settings using just prefixes instead of full values were working (MOD-6709)
+  - [#4539](https://github.com/RediSearch/RediSearch/pull/4539) Unfree memory while re-indexing a new RDB as it's loading could cause a crash (MOD-6831, 6810)
+  - [#4498](https://github.com/RediSearch/RediSearch/pull/4498) Vector pre-filtered query (hybrid query) that times out causing a crash due to deadlock when trying to write a new document (MOD-6510, MOD-6244)
+  - [#4495](https://github.com/RediSearch/RediSearch/pull/4495) `FT.SEARCH` accessing an inexistent memory address causes a crash if using the deprecated `FT.ADD` command (MOD-6599)
+
+- Improvements:
+
+  - [#4502](https://github.com/RediSearch/RediSearch/pull/4502) Handle error properly when trying to execute Search commands on cluster setup as part of `MULTI ... EXEC` or LUA script (MOD-6541)
+  - [#4526](https://github.com/RediSearch/RediSearch/pull/4526) Adding detailed geometry info on error messages (MOD-6701)
+
+## v2.8.12 (March 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#4476](https://github.com/RediSearch/RediSearch/pull/4476) Split `INFIX` and `SUFFIX` report on `FT.EXPLAIN` and `FT.EXPLAINCLI` (MOD-6186)
+  - [#4467](https://github.com/RediSearch/RediSearch/pull/4467) Memory leak upon suffix query for a `TAG` indexed with `WITHSUFFIXTRIE` (MOD-6644)
+  - [#4403](https://github.com/RediSearch/RediSearch/pull/4403) Clustered `FT.SEARCH` hangs forever without replying when an invalid topology is found (MOD-6557)
+  - [#4355](https://github.com/RediSearch/RediSearch/pull/4355) Searching for a synonym will iterate in the same group multiple times, causing a performance hit (MOD-6490)
+
+- Improvements:
+
+  - [#4313](https://github.com/RediSearch/RediSearch/pull/4313) Memory allocation patterns on the memory used to query `GEOSHAPE` types (MOD-6431)
+
+## v2.8.11 (January 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#4324](https://github.com/RediSearch/RediSearch/pull/4324) Internal cluster mechanism not waiting until all replies from shards causing a crash (MOD-6287)
+  - [#4297](https://github.com/RediSearch/RediSearch/pull/4297) Execution loader when using `FT.AGGREGATE` with `LOAD` stage failing to buffer the right results potentially causing a crash (MOD-6385)
+
+- Improvements:
+
+  - [#4264](https://github.com/RediSearch/RediSearch/pull/4264) Granularity of the time reporting counters on `FT.PROFILE` (MOD-6002)
+
+## v2.8.10 (January 2024)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#4287](https://github.com/RediSearch/RediSearch/pull/4287) Re-index process while syncing from the replica causes a crash due to internal index variable initialization (MOD-6337, MOD-6336)
+  - [#4249](https://github.com/RediSearch/RediSearch/pull/4249) Memory tracking on cluster setups causing high memory usage and potentially Out-of-Memory (MOD-6123, MOD-5639)
+  - [#4244](https://github.com/RediSearch/RediSearch/pull/4244) Profiling `FT.AGGREGATE` using the `WITHCURSOR` flag with a `-` clause causes a crash due to timeout (MOD-5512)
+  - [#3916](https://github.com/RediSearch/RediSearch/pull/3916) Expiring `JSON` documents while querying it causing a crash due to deadlock (MOD-5769, MOD-5895, MOD-6189, MOD-5895)
+  - [#4235](https://github.com/RediSearch/RediSearch/pull/4235) Memory excessively growing on databases caused by unbalanced nodes on inverted index trie (MOD-5880, MOD-5952, MOD-6003) 
+  - [#4190](https://github.com/RediSearch/RediSearch/pull/4190) Profiling `FT.AGGREGATE` causes a crash on RESP3 replies (MOD-6250, MOD-6295)
+  - [#4148](https://github.com/RediSearch/RediSearch/pull/4148), [#4038](https://github.com/RediSearch/RediSearch/pull/4038) `ON_TIMEOUT FAIL\RETURN` policies in the cluster setup not being respected (MOD-6035, MOD-5948, MOD-6090)
+  - [#4110](https://github.com/RediSearch/RediSearch/pull/4110) Format of error response contains inconsistencies when timing out (MOD-6011, MOD-5965)
+  - [#4104](https://github.com/RediSearch/RediSearch/pull/4104) `FT.SEARCH` not responding when using TLS encryption on Amazon Linux 2 (MOD-6012)
+  - [#4009](https://github.com/RediSearch/RediSearch/pull/4009) In cluster setup does not return a timeout error for `FT.SEARCH` (MOD-5911)
+  - [#3920](https://github.com/RediSearch/RediSearch/pull/3920) In cluster setup does not return a timeout error for `FT.AGGREGATE` (MOD-5209)
+  - [#3914](https://github.com/RediSearch/RediSearch/pull/3914) `FT.CURSOR READ` with geo queries causing a crash when data is updated between the cursor reads (MOD-5646) 
+  - [#4220](https://github.com/RediSearch/RediSearch/pull/4220) Server crash when attempting to run the ForkGC (Garbage Collection routine) after dropping the index (MOD-6276)
+
+- Improvements:
+
+  - [#3682](https://github.com/RediSearch/RediSearch/pull/3682) Report last key error and field type indexing failures on `FT.INFO` (MOD-5364)
+  - [#4236](https://github.com/RediSearch/RediSearch/pull/4236) Adding Vector index parameters at the `FT.INFO` report (MOD-6198)
+  - [#4196](https://github.com/RediSearch/RediSearch/pull/4196) Check for timeout after results processing in `FT.SEARCH` on cluster setup (MOD-6278)
+  - [#4164](https://github.com/RediSearch/RediSearch/pull/4164) Report `TIMEOUT`, `MAXPREFIXEXPANSION` warnings in RESP3 replies (MOD-6234)
+  - [#4165](https://github.com/RediSearch/RediSearch/pull/4165) Indicate timeout on `FT.PROFILE` report (MOD-6184)
+  - [#4149](https://github.com/RediSearch/RediSearch/pull/4149) Indicate timeout from Cursor on `FAIL` timeout policy (MOD-5990)
+  - [#4147](https://github.com/RediSearch/RediSearch/pull/4147) Initialization of the maximum numeric value range leading to a better balance of the index leaf splitting (MOD-6232)
+  - [#3940](https://github.com/RediSearch/RediSearch/pull/3940) Query optimization when predicate contains multiple `INTERSECTION` (AND) of `UNION` (OR) (MOD-5910)
+  - [#4059](https://github.com/RediSearch/RediSearch/pull/4059) Return cursor id when experiencing a timeout, when the policy is `ON_TIMEOUT RETURN` (MOD-5966)
+  - [#4006](https://github.com/RediSearch/RediSearch/pull/4006) Possibly problematic index name alias validation (MOD-5945)
+
+## v2.8.9 (October 2023)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#3874](https://github.com/RediSearch/RediSearch/pull/3874) Heavy document updates causing memory growth once memory blocks weren't properly released (MOD-5181)
+  - [#3967](https://github.com/RediSearch/RediSearch/pull/3967) Resharding optimizations causing the process to get stuck (MOD-5874, MOD-5864)
+  - [#3892](https://github.com/RediSearch/RediSearch/pull/3892) After cleaning the index the GC could cause corruption on unique values (MOD-5815)
+  - [#3853](https://github.com/RediSearch/RediSearch/pull/3853) Queries with `WITHCURSOR` making memory growth since `CURSOR` wasn't invalidated in the shards (MOD-5580)
+
+- Improvements:
+
+  - [#3938](https://github.com/RediSearch/RediSearch/pull/3938) Propagating error messages in multiple shards database, instead of failing silently (MOD-5211)
+  - [#3903](https://github.com/RediSearch/RediSearch/pull/3903) Added support for Rocky Linux 9 and RHEL9 (MOD-5759)
+
+## v2.8.8 (September 2023)
+
+This is a maintenance release for RediSearch 2.8.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- Security and privacy:
+
+  - [#3788](https://github.com/RediSearch/RediSearch/pull/3788) Don’t expose internal cluster commands (MOD-5706)
+  - [#3844](https://github.com/RediSearch/RediSearch/pull/3844) Limits maximum phonetic length avoiding to be exploit (MOD 5767)
+
+- Bug fixes:
+
+  - [#3771](https://github.com/RediSearch/RediSearch/pull/3771) Broken `lower()` and `upper()` functions on `APPLY` stage in `FT.AGGREGATE` in `DIALECT 3` (MOD-5041)
+  - [#3752](https://github.com/RediSearch/RediSearch/pull/3752) Setting low `MAXIDLE` parameter value in `FT.AGGREGATE` cause a crash (MOD-5608)
+  - [#3780](https://github.com/RediSearch/RediSearch/pull/3780) Wrong document length calculation causing incorrect score values (MOD-5622)
+  - [#3808](https://github.com/RediSearch/RediSearch/pull/3808) `LOAD` step after a `FILTER` step could cause a crash on `FT.AGGREGATE` (MOD-5267)
+  - [#3823](https://github.com/RediSearch/RediSearch/pull/3823) `APPLY` or `FILTER` parser leak (MOD-5751)
+  - [#3837](https://github.com/RediSearch/RediSearch/pull/3837) Connection using TLS fail on Redis 7.2 (MOD-5768)
+  - [#3856](https://github.com/RediSearch/RediSearch/pull/3856) Adding new nodes to OSS cluster causing a crash (MOD-5778)
+  - [#3854](https://github.com/RediSearch/RediSearch/pull/3854) Vector range query could cause Out-of-Memory due to a memory corruption (MOD-5791)
+
+- Improvements:
+
+  - [#3534](https://github.com/RediSearch/RediSearch/pull/3534) Vector Similarity 0.7.1 (MOD-5624)
+
+## v2.8 GA (v2.8.4) (July 2023)
+
+This is the General Availability release of RediSearch 2.8.
+
+### Headlines
+
+RediSearch 2.8 introduces support for RESP3, new features, performance improvements, and bug fixes.
+
+### What's new in 2.8.4
+
+This new major version introduces new and frequently asked for Geo Polygon Search, adding the `GEOSHAPE` field type that supports polygon shapes using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry). Besides the current `GEO` (alias for `GEOPOINT`) used in geo range queries, we add support for `POLYGON` and `POINT` as new geo shape formats (new `GEOSHAPE`). In addition, 2.8 brings performance improvements for `SORT BY` operations using `FT.SEARCH` and `FT.AGGREGATE`, and new `FORMAT` for enhanced responses on `FT.SEARCH` and `FT.AGGREGATE` in RESP3 only.
+
+Features:
+
+- Introduce support for geo polygon shapes and queries:
+
+  - Adding `GEOSHAPE` [field type]({{< relref "commands/ft.create" >}}) to map polygons in the `SCHEMA` on `FT.CREATE` (MOD-4798)
+
+  - Support for polygons `POLYGON` and `POINT` using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry), for example `POLYGON((lon1 lat1, lon2 lat2, ...))`
+
+  - Adjust the [query syntax]({{< relref "commands/ft.search#examples" >}}) on `FT.SEARCH` for polygons using the predicate `@geom:[OPERATOR $poly]` and defining polygon in WKT format as `PARAMS 2 poly "POLYGON((10 20, ...))"` using `DIALECT 3`
+
+  - Initially `WITHIN` and `CONTAINS` operators with `GEOSHAPES` for now
+
+  - Support multiple coordinate systems: cartesian (X,Y) with the flag `FLAT` for flat earth and geographic (lon, lat) using the flag `SPHERICAL` (MOD-5303). Geographic coordinate system using spherical indexing as default (`SPHERICAL`)
+
+  - Add memory usage per Geometry Index in the `FT.INFO` response report (MOD-5278)
+
+- Introduce performance optimization for sorting operations on `FT.SEARCH` and `FT.AGGREGATE` as default on `DIALECT 4`. It will improve performance in 4 different scenarios, listed below:
+
+  - Skip Sorter - applied when there is no sort of any kind. The query can return once it reaches the `LIMIT` requested results.
+
+  - Partial Range - applied when there is a `SORTBY` a numeric field, with no filter or filter by the same numeric field, the query iterates on a range large enough to satisfy the `LIMIT` requested results.
+
+  - Hybrid - applied when there is a `SORTBY` a numeric field in addition to another non-numeric filter. Some results will get filtered, and the initial range may not be large enough. The iterator then is rewinded with the following ranges, and an additional iteration takes place to collect `LIMIT` requested results.
+
+  - No optimization - If there is a sort by score or by non-numeric field, there is no other option but to retrieve all results and compare their values.
+
+- Add `WITHCOUNT` argument that allow return accurate counts for the query results with sorting. This operation processes all results in order to get accurate count, being less performant than the optimized option (default behavior on `DIALECT 4`) (MOD-5311)
+
+- New `FORMAT` argument in `FT.SEARCH` and `FT.AGGREGATE` to retrieve the results as JSON strings or RESP3 hierarchical structures (RESP3 only) (MOD-5390)
+
+Improvements (since 2.8.3):
+
+- [#3717](https://github.com/RediSearch/RediSearch/pull/3717) - Polygon shapes validation and orientation correction when clockwise (MOD-5575)
+
+- [#3534](https://github.com/RediSearch/RediSearch/pull/3534) - Vector Similarity \[[0.7.0](https://github.com/RedisAI/VectorSimilarity/releases/tag/v0.7.0)\]
+
+- [#3657](https://github.com/RediSearch/RediSearch/pull/3657) - Allow GC calls for all tiered indexes in the schema
+
+- [#3701](https://github.com/RediSearch/RediSearch/pull/3701) - HNSW is now using data blocks to store vectors and metadata instead of array
+
+Changed behavior:
+
+- [#3355](https://github.com/RediSearch/RediSearch/pull/3355), [#3635](https://github.com/RediSearch/RediSearch/pull/3635) Expired keys deleted from replica's index, returning an empty array instead of `nil` (MOD-4739)
+
+{{<note>}}
+- The version inside Redis will be 2.8.4 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+
+- Minimal Redis version: 7.2
+
+- If indexing and querying RedisJSON data structures, this version is best combined with RedisJSON 2.6 (v2.6.0 onwards).
+{{</note>}}
+---
+Title: RediSearch 2.6 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Search using wildcard queries for TEXT and TAG fields, multi-value indexing
+  and querying of attributes for any attribute type, and indexing double-precision
+  floating-point vectors and range queries from a given vector.
+linkTitle: v2.6 (November 2022)
+min-version-db: 6.0.16
+min-version-rs: 6.2.8
+weight: 92
+---
+## Requirements
+
+RediSearch v2.6.29 requires:
+
+- Minimum Redis compatibility version (database): 6.0.16
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v2.6.29 (April 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Improvements:
+- [#5940](https://github.com/redisearch/redisearch/pull/5940) Improved performance (reduced CPU time) of collecting vector index statistics (MOD-9354)
+- [#5816](https://github.com/redisearch/redisearch/pull/5816) Improved accuracy of index memory reporting by correcting a bug that caused negative memory counts (MOD-5904)
+
+## v2.6.28 (March 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Bug fixes:
+- [#5712](https://github.com/redisearch/redisearch/pull/5712) Weights in the query string are ignored if using `SCORER BM25` (MOD-7896)
+
+## v2.6.27 (February 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Bug fixes:
+
+- [#5648](https://github.com/redisearch/redisearch/pull/5648) `FT.SEARCH` using Cyrillic characters and wildcards delivering no results (MOD-7944)
+
+## v2.6.26 (February 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5606](https://github.com/redisearch/redisearch/pull/5606) Changes on the memory block reading logic could cause crash on `FT.SEARCH` with error "_Redis 7.4.2 crashed by signal: 11, si_code: 128_"
+
+Known limitations:
+- Only the first 128 characters of string fields are normalized to lowercase during ingestion (for example, on `HSET`).
+    Example:
+
+    ```
+    HSET doc __score 1.0 name "idx1S...S" mynum 1          # Assume "S...S" is a string of 252 capital S's
+    FT.CREATE "idx" SCHEMA "name" "TEXT" "mynum" "NUMERIC"
+    FT.SEARCH "idx" "@name:idx1S...S"                      # Assume "S...S" is a string of 252 capital S's
+    ```
+
+    The `FT.SEARCH` command will return no documents.
+
+## v2.6.25 (January 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5484](https://github.com/redisearch/redisearch/pull/5484) NOSTEM option does not work on query, just tokenising (MOD-7634)
+- [#5543](https://github.com/redisearch/redisearch/pull/5543) Querying for the latest document added to the index may result in a crash if the last block is not read (MOD-8561).
+
+## v2.6.24 (January 2025)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+- **Security and privacy:**
+  - [#5458](https://github.com/redisearch/redisearch/pull/5458) (CVE-2024-51737) Query: potential out-of-bounds write (MOD-8486)
+
+- Bug fixes:
+  - [#5302](https://github.com/redisearch/redisearch/pull/5302) Prefix/Infix/Suffix queries longer than 1024 chars could cause a crash (MOD-7882)
+  - [#5281](https://github.com/redisearch/redisearch/pull/5281) `FT.CURSOR READ` retrieving deleted `TAG` fields cause a crash (MOD-8011)
+  - [#5168](https://github.com/redisearch/redisearch/pull/5168) Cursors from queries that timed out weren't depleted causing exhaustion of number of cursors available(MOD-8009)
+
+## v2.6.21 (August 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+- Bug fixes:
+  - [#4944](https://github.com/redisearch/redisearch/pull/4944) Adjusting the module configuration to avoid routing overload on the first shard in a clustered database (MOD-7505)
+  - [#4897](https://github.com/redisearch/redisearch/pull/4897) - `FT.AGGREGATE` with `VERBATIM` option is not handled by the shards in cluster mode (MOD-7463)
+  - [#4918](https://github.com/redisearch/redisearch/pull/4918) - Union query, similar to `"is|the"`, starting with 2 [stopwords](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/stopwords/) could cause a crash (MOD-7495)
+  - [#4919](https://github.com/redisearch/redisearch/pull/4919) - Counting twice the field statistics at the `#search` section of an `INFO` response (MOD-7339)
+  - [#4923](https://github.com/redisearch/redisearch/pull/4923) - Loop when using the wildcard `w'term'` and prefix/infix/suffix pattern `'ter*'`, causing the shard to restart (MOD-7453)
+  - [#4954](https://github.com/redisearch/redisearch/pull/4954) `FT.PROFILE` on `AGGREGATE` numeric queries could cause a crash due to reusing the internal `CURSOR` in a large range of numeric values (MOD-7454)
+
+## v2.6.20 (July 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+- Bug fixes:
+  - [#4755](https://github.com/RediSearch/RediSearch/pull/4755) - Correct return the maximum value for negative values when using `MAX` reducer (MOD-7252)
+  - [#4733](https://github.com/RediSearch/RediSearch/pull/4733) - Separators ignored when escaping backslash `\` after the escaped character such as in `hello\\,world` ignoring `,` (MOD-7240)
+  - [#4717](https://github.com/RediSearch/RediSearch/pull/4717) - Sorting by multiple fields as in `SORTBY 2 @field1 @field2` was ignoring the subsequent field (MOD-7206)
+
+- Improvements:
+  - [#4793](https://github.com/RediSearch/RediSearch/pull/4793) - Add character validations to simple string replies and escape it when required(MOD-7258)
+  - [#4769](https://github.com/RediSearch/RediSearch/pull/4769) - Indicate which value is missing on the error message at the aggregation pipeline (MOD-7201)
+  - [#4746](https://github.com/RediSearch/RediSearch/pull/4746) - `GROUPBY` recursion cleanup (MOD-7245)
+
+## v2.6.19 (June 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+- Bug fixes:
+
+  - [#4616](https://github.com/RediSearch/RediSearch/pull/4616) Shards become unresponsive when using FT.AGGREGATE with APPLY 'split(...)' (MOD-6759)
+  - [#4557](https://github.com/RediSearch/RediSearch/pull/4557) FT.EXPLAIN returns additional } when querying using wildcards (MOD-6768)
+  - [#4647](https://github.com/RediSearch/RediSearch/pull/4647) FT.DROPINDEX with DD flag deleted keys in one AA cluster but not the others (MOD-1855)
+
+- Improvements:
+
+  - [#4599](https://github.com/RediSearch/RediSearch/pull/4599) Report additional memory consumed by the TAG and TEXT tries (MOD-5902)
+  - [#4688](https://github.com/RediSearch/RediSearch/pull/4688) Add missing FT.INFO fields when used within a cluster (MOD-6920)
+
+## v2.6.18 (April 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [#4557](https://github.com/RediSearch/RediSearch/pull/4557) Additional "`}`" on wildcards replies for `FT.EXPLAIN` (MOD-6768)
+
+## v2.6.17 (April 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#4524](https://github.com/RediSearch/RediSearch/pull/4524) `FT.CURSOR READ` in a numeric query causing a crash (MOD-6597)
+  - [#4543](https://github.com/RediSearch/RediSearch/pull/4543) `FT.SEARCH` accessing an inexistent memory address causes a crash if using deprecated `FT.ADD` command (MOD-6599)
+  - [#4535](https://github.com/RediSearch/RediSearch/pull/4535) `FT.PROFILE` with incorrect arguments could cause a crash on cluster setup (MOD-6791)
+  - [#4540](https://github.com/RediSearch/RediSearch/pull/4540) Unfree memory from an existing RDB while re-indexing loading a new RDB could cause a crash (MOD-6831, 6810)
+  - [#4485](https://github.com/RediSearch/RediSearch/pull/4485) Some parameter settings using just prefixes instead of full values were working (MOD-6709)
+
+- Improvements:
+
+  - [#4502](https://github.com/RediSearch/RediSearch/pull/4502) Handle error properly when trying to execute Search commands on cluster setup as part of `MULTI ... EXEC` or LUA script (MOD-6541)
+
+## v2.6.16 (March 2024)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `MODERATE` : Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#4477](https://github.com/RediSearch/RediSearch/pull/4477) Split `INFIX` and `SUFFIX` report on `FT.EXPLAIN` and `FT.EXPLAINCLI` (MOD-6186)
+  - [#4468](https://github.com/RediSearch/RediSearch/pull/4468) Memory leak upon suffix query for a `TAG` indexed with `WITHSUFFIXTRIE` (MOD-6644)
+  - [#4407](https://github.com/RediSearch/RediSearch/pull/4407) Clustered `FT.SEARCH` hangs forever without replying when an invalid topology is found (MOD-6557)
+  - [#4359](https://github.com/RediSearch/RediSearch/pull/4359) Searching for a synonym will iterate in the same group multiple times, causing a performance hit (MOD-6490)
+  - [#4310](https://github.com/RediSearch/RediSearch/pull/4310) Memory tracking on cluster setups causing high memory usage and potentially Out-of-Memory (MOD-6123, MOD-5639)
+
+## v2.6.15 (December 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#4244](https://github.com/RediSearch/RediSearch/pull/4244), [#4255](https://github.com/RediSearch/RediSearch/pull/4255) Profiling `FT.AGGREGATE` using the `WITHCURSOR` flag causes a crash due to timeout (MOD-5512)
+  - [#4238](https://github.com/RediSearch/RediSearch/pull/4238) Memory excessively growing on databases caused by unbalanced nodes on inverted index trie (MOD-5880, MOD-5952, MOD-6003) 
+  - [#3995](https://github.com/RediSearch/RediSearch/pull/3995) `FT.CURSOR READ` with geo queries causing a crash when data is updated between the cursor reads (MOD-5646) 
+  - [#4155](https://github.com/RediSearch/RediSearch/pull/4155) `FT.SEARCH` not responding when using TLS encryption on Amazon Linux 2 (MOD-6012)
+
+- Improvements:
+
+  - [#4176](https://github.com/RediSearch/RediSearch/pull/4176) Initialization of the maximum numeric value range leading to a better balance of the index leaf splitting (MOD-6232) 
+  - [#4123](https://github.com/RediSearch/RediSearch/pull/4123) Possibly problematic index name alias check-in command multiplexing (MOD-5945)
+  - [#4195](https://github.com/RediSearch/RediSearch/pull/4195) Query optimization when predicate contains multiple `INTERSECTION` (AND) of `UNION` (OR) (MOD-5910)
+
+## v2.6.14 (November 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- Bug fixes:
+
+  - [#3783](https://github.com/RediSearch/RediSearch/pull/3783) Broken lower and upper `APPLY` functions in `FT.AGGREGATE` on `DIALECT 3` (MOD-5041)
+  - [#3823](https://github.com/RediSearch/RediSearch/pull/3823) `APPLY` or `FILTER` expression causing a leak (MOD-5751)
+  - [#3899](https://github.com/RediSearch/RediSearch/pull/3899) Connection using TLS fail on Redis (MOD-5768)
+  - [#3910](https://github.com/RediSearch/RediSearch/pull/3910) Heavy document updates causing memory growth if memory blocks weren't properly released (MOD-5181)(MOD-5757)
+  - [#3928](https://github.com/RediSearch/RediSearch/pull/3928) Queries with `WITHCURSOR` making memory growth since `CURSOR` wasn't invalidated in the shards (MOD-5580)
+  - [#3946](https://github.com/RediSearch/RediSearch/pull/3946) Vector range query could cause Out-of-Memory due to memory corruption (MOD-5791)
+  - [#3972](https://github.com/RediSearch/RediSearch/pull/3972) Adding new nodes to OSS cluster can cause a crash (MOD-5778)
+  - [#3957](https://github.com/RediSearch/RediSearch/pull/3957) After cleaning the index, the GC could corrupt unique values (MOD-5815)
+  - [#4002](https://github.com/RediSearch/RediSearch/pull/4002) Setting a low `MAXIDLE` parameter value in `FT.AGGREGATE` causes a crash (MOD-5608)
+
+- Security and privacy:
+
+  - [#3844](https://github.com/RediSearch/RediSearch/pull/3844) Limits maximum phonetic length to avoid vulnerability (MOD 5767)
+
+## v2.6.12 (July 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#3557](https://github.com/RediSearch/RediSearch/pull/3557) `TIMEOUT` configuration on `FT.AGGREGATE` query being ignored (MOD-5208)
+  - [#3552](https://github.com/RediSearch/RediSearch/pull/3552) `FT.CURSOR READ` on `JSON` numeric queries not returning results (MOD-4830)
+  - [#3606](https://github.com/RediSearch/RediSearch/pull/3606) Update numeric inverted index `numEntries` avoiding excessive memory consumption (MOD-5181)
+  - [#3597](https://github.com/RediSearch/RediSearch/pull/3597) Duplicating alias as output name on `FT.AGGREGATE` reducer (`REDUCE` argument) doesn't return results (MOD-5268)
+  - [#3654](https://github.com/RediSearch/RediSearch/pull/3654) Added check for `@` prefix on `GROUPBY` fields returning an error instead of wrong results
+
+- Improvements:
+
+  - [#3628](https://github.com/RediSearch/RediSearch/pull/3628) Background indexing scanning performance (MOD-5259)
+  - [#3259](https://github.com/RediSearch/RediSearch/pull/3259) Allow alias name beginning with `as`
+  - [#3641](https://github.com/RediSearch/RediSearch/pull/3641) Indexing sanitizing trigger in heavy data updates scenario
+
+## v2.6.9 (April 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#3468](https://github.com/RediSearch/RediSearch/pull/3468) KNN searching for 0 vectors with a filter resulted in crash (MOD-5006)
+  - [#3499](https://github.com/RediSearch/RediSearch/pull/3499) `MAXSEARCHRESULTS` set to `0` causing `FT.SEARCH` to crash (MOD-5062)
+  - [#3494](https://github.com/RediSearch/RediSearch/pull/3494) Removing `MAXSEARCHRESULTS` limit causes crash on `FT.AGGREGATE` (MOD-4974)
+  - [#3504](https://github.com/RediSearch/RediSearch/pull/3504) Uninitialised vector similarity query parameter bug (MOD-5063)
+
+- Improvements:
+
+  - [#3430](https://github.com/RediSearch/RediSearch/pull/3430) Improve min-max heap structure for better readability and performance
+  - [#3450](https://github.com/RediSearch/RediSearch/pull/3450) Display `NOHL` option in `FT.INFO` command
+  - [#3534](https://github.com/RediSearch/RediSearch/pull/3534) Vector Similarity 0.6.1: Improve multi-value index deletion logic ([#346](https://github.com/RedisAI/VectorSimilarity/pull/346))
+
+## v2.6.6 (March 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3403](https://github.com/RediSearch/RediSearch/pull/3403) Fix suffix and prefix matching when using `CASESENSITIVE` flag (MOD-4872)
+
+- Improvements:
+
+  - [#3397](https://github.com/RediSearch/RediSearch/pull/3397) Improve the Vecsim initial capacity default value
+
+## v2.6.5 (February 2023)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#3354](https://github.com/RediSearch/RediSearch/pull/3354) Library update preventing a crash during cluster failover (MOD-4560)
+  - [#3357](https://github.com/RediSearch/RediSearch/pull/3357) Handling division by zero in expressions preventing nodes to restart (MOD-4296)
+  - [#3332](https://github.com/RediSearch/RediSearch/pull/3332) Fix wildcards `*` queries on `DIALECT 2` and `DIALECT 3`
+
+- Improvements:
+  
+  - [#3361](https://github.com/RediSearch/RediSearch/pull/3361) Enable the use of IPv6 for all cluster and module communication
+
+## v2.6.4 (December 2022)
+
+This is a maintenance release for RediSearch 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3289](https://github.com/RediSearch/RediSearch/pull/3289) Potential crash when querying multiple fields (MOD-4639)
+  - [#3279](https://github.com/RediSearch/RediSearch/pull/3279) Potential crash when querying using wildcard `*` on TAG field (MOD-4653)
+
+- Improvements:
+  
+  - [#3256](https://github.com/RediSearch/RediSearch/pull/3256) Support IPv6 on cluster set command
+  - [#3194](https://github.com/RediSearch/RediSearch/pull/3194) Add the query dialects that are in use to `FT.INFO` and `INFO MODULE` commands (MOD-4232)
+  - [#3258](https://github.com/RediSearch/RediSearch/pull/3258) Add the module version and Redis version to `INFO MODULE`  
+
+## v2.6 GA (v2.6.3) (November 2022)
+
+This is the General Availability release of RediSearch 2.6.
+
+### Highlights
+
+This new major version introduces the ability to search using **wildcard queries** for TEXT and TAG fields. This enables the frequently requested feature **suffix search** (`*vatore` and `ant?rez` are now supported).
+In addition, the 2.6 release is all about **multi-value indexing and querying of attributes** for any attribute type ( [Text]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-text), [Tag]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-tag), [Numeric]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-numeric), [Geo]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-geo) and [Vector]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-vector)) defined by a [JSONPath]({{< relref "/develop/data-types/json/path" >}}) leading to an array or to multiple scalar values.
+Lastly, this version adds support for indexing double-precision floating-point vectors and range queries from a given vector.
+
+### What's new in 2.6
+
+### Details
+
+- Improvements:
+
+  - [#2886](https://github.com/RediSearch/RediSearch/pull/2886) Support for [wildcard queries]({{< relref "/develop/interact/search-and-query/advanced-concepts/query_syntax" >}}#wildcard-matching) for TEXT and TAG fields, where
+    - `?` matches any single character
+    - `*` matches zero or more characters
+    - use `'` and `\` for escaping, other special characters are ignored
+    - [#2932](https://github.com/RediSearch/RediSearch/pull/2932) Optimized wildcard query support (i.e., suffix trie)
+  - Multi-value indexing and querying
+    - [#2819](https://github.com/RediSearch/RediSearch/pull/2819), [#2947](https://github.com/RediSearch/RediSearch/pull/2947) Multi-value text search - perform full-text search on an [array of strings or on a JSONPath]({{< relref "/develop/interact/search-and-query/indexing/" >}}#index-json-arrays-as-tag) leading to multiple strings
+    - [#3131](https://github.com/RediSearch/RediSearch/pull/3131) Geo [#3118](https://github.com/RediSearch/RediSearch/pull/3118) Vector [#2985](https://github.com/RediSearch/RediSearch/pull/2985) Numeric [#3180](https://github.com/RediSearch/RediSearch/pull/3180) Tag
+    - [#3060](https://github.com/RediSearch/RediSearch/pull/3060) Return JSON rather than scalars from multi-value attributes.  This is enabled via Dialect 3 in order not to break existing applications.
+    - Support indexing and querying of multi-value JSONPath attributes and/or arrays (requires JSON >2.4.1)
+    - [#3182](https://github.com/RediSearch/RediSearch/pull/3182) Support for `SORTABLE` fields on JSON in an implicit un-normalized form (UNF)
+  - [#3156](https://github.com/RediSearch/RediSearch/pull/3156) Vector similarity 0.5.1:
+    - Better space optimization selection ([#175](https://github.com/RedisAI/VectorSimilarity/pull/175)) 
+    - Aligning index capacity with block size ([#177](https://github.com/RedisAI/VectorSimilarity/pull/177)) 
+    - [#3129](https://github.com/RediSearch/RediSearch/pull/3129) Support FLOAT64 as vector data type 
+    - [#3176](https://github.com/RediSearch/RediSearch/pull/3176) Range query support
+    - [#3105](https://github.com/RediSearch/RediSearch/pull/3105) Support query attributes for vector queries
+
+- Bugs (since 2.6-RC1 / v2.6.1):
+
+  - [#3197](https://github.com/RediSearch/RediSearch/pull/3197) Failure to create temporary indices
+  - [#3098](https://github.com/RediSearch/RediSearch/pull/3098) Wrong return value in Geo query
+  - [#3230](https://github.com/RediSearch/RediSearch/issues/3230) Use the correct total number of matching records
+
+{{<note>}}
+With this release, we stop supporting direct upgrades from RediSearch v1.4 and v1.6 that are End-of-Life. Such RDB files can still be upgraded to RediSearch 2.0 first.
+{{</note>}}
+
+{{<note>}}
+If indexing and querying RedisJSON data structures, this version is best combined with RedisJSON 2.4 GA (v2.4.1 onwards).
+{{</note>}}
+---
+Title: RediSearch 1.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Aggregation filters. Query attributes. Fuzzy matching. Conditional updates.
+  Backslash escaping. Synonyms support.
+linkTitle: v1.2 (June 2018)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 98
+---
+## Requirements
+
+RediSearch v1.2.0 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## RediSearch 1.2.0 (June 2018)
+
+This version is the last version that I (@dvirsky) will be releasing, and it includes a lot of new cool features, and actually NO bug-fixes over 1.1.0! So long and thanks for all the fish!
+
+### New features
+
+#### Aggregation filters
+
+As an addition to the aggregation API in `FT.AGGREGATE`, it is possible to do post-index filtering of the pipeline, using the `FILTER` keyword. e.g.:
+
+```sh
+FT.AGGREGATE idx "*"
+   GROUPBY 1 @foo
+     REDUCE count 0 AS num
+   FILTER "@num < 100"
+```
+
+See [http://redisearch.io/Aggregations/](http://redisearch.io/Aggregations/) for more details.
+
+#### Query attributes
+
+It is now possible to apply specific query modifying attributes to specific clauses of the query (see #[212](https://github.com/RediSearch/RediSearch/issues/212)).
+
+The syntax is `(foo bar) => { $attribute: value; $attribute:value; ...}`, e.g:
+
+```sh
+(foo bar) => { $weight: 2.0; $slop: 1 }
+~(bar baz) => { $weight: 0.5; }
+```
+
+The supported attributes are:
+
+1. $weight: determines the weight of the sub-query or token in the overall ranking on the result.
+1. $slop: determines the maximum allowed "slop" (space between terms) in the query clause.
+1. $inorder: whether or not the terms in a query clause must appear in the same order as in the query.
+
+#### Fuzzy matching
+
+Wrapping a search term with `%` will cause the index to expand the query to terms that are within an Edit Distance of 1 from the original term. For example, querying for `%redis%` will expand it to query for `redis, jedis, credis, predis`, etc (provided the terms appear in documents in the index).
+
+Notice that each query term needs to be wrapped independently, and that we limit the maximum amount of expansions to 200 per term, as this hurts performance significantly.
+
+#### Conditional updates
+
+It is now possible to update documents (`FT.ADD ... REPLACE [PARTIAL]`) only if a certain condition is met regarding the document's state **before** the updates. So for example, if our document has a timestamp field, and we would like to update its title only if the timestamp is below a certain value, we can do the following:
+
+```sh
+FT.ADD myIndex myDoc 1.0
+   REPLACE PARTIAL
+   IF "@timestamp < 12313134523"
+   FIELDS
+       title "new title"
+```
+
+#### Backslash escaping
+
+Following several user requests, it is now possible to escape separator characters in documents (it is already done in the query itself), and avoid tokenization when needed.
+
+For example, indexing the text `hello\-world hello world` will create the tokenization `["hello-world", "hello", "world"]`. Notice that in most languages and in redis-cli, you will need to escape the backslash itself, so instead of `hello\-world` you will need to send the string `hello\\-world`.
+
+The same goes to the query string: If the document contains the token `hello-world`, it can be found by running in redis-cli: `FT.SEARCH idx "hello\\-world", which will cause the query not to be separated.
+
+#### Synonyms support
+
+It is now possible to provide the index with synonym groups (.e.g boy, child, kid), and have it automatically index synonymous terms so that searching for one will return documents containing another.
+
+See [http://redisearch.io/Synonyms/](http://redisearch.io/Synonyms/) for more details and examples.
+---
+Title: RediSearch 2.10 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: New vector data types. Enhanced indexing capabilities. Simplified query syntax. Expanded geospatial search.
+linkTitle: v2.10 (July 2024)
+min-version-db: '7.4'
+min-version-rs: 7.6 (TBD)
+weight: 90
+---
+## Requirements
+
+RediSearch v2.10.17 requires:
+
+- Minimum Redis compatibility version (database): 7.4
+- Minimum Redis Enterprise Software version (cluster): 7.6 (TBD)
+
+## v2.10.17 (April 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5859](https://github.com/redisearch/redisearch/pull/5859) Last query result using `FT.AGGREGATE` with `ON_TIMEOUT RETURN` and using multi-threading could be missing (MOD-9222)
+- [#5858](https://github.com/redisearch/redisearch/pull/5858) Collecting empty results from shards during `FT.AGGREGATE` with RESP3 could cause a crash (MOD-9174)
+
+Improvements:
+- [#5938](https://github.com/redisearch/redisearch/pull/5938) Improved performance (reduced CPU time) of collecting vector index statistics(MOD-9354)
+- [#5800](https://github.com/redisearch/redisearch/pull/5800) Improved accuracy of index memory reporting by correcting a bug that caused negative memory counts (MOD-5904)
+
+## v2.10.15 (March 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Cursor with `SORTBY` is never depleted, blocking queries if the cursor limit is reached (MOD-8483)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Empty results with RESP3 due to the `TIMEOUT`, even if `ON_TIMEOUT` is set to `RETURN`(MOD-8482)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Cursor with RESP3 on `FT.AGGREGATE` is never depleted, blocking queries if cursor the limit is achieved (MOD-8515)
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Using `FT.CURSOR READ` on queries that timed out led to fewer results than expected (MOD-8606)
+- [#5810](https://github.com/redisearch/redisearch/pull/5810) The `total_results` field of the `FT.AGGREGATE` command is not correct in RESP3 (MOD-9054)
+
+Improvements:
+- [#5788](https://github.com/redisearch/redisearch/pull/5788) Corrected a coordinator race condition that prevented premature release, avoiding errors and inconsistencies during query executions (MOD-8794)
+
+## v2.10.14 (March 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Bug fixes:
+- [#5704](https://github.com/redisearch/redisearch/pull/5704) Weights in the query string are ignored if using `SCORER BM25` (MOD-7896).
+
+## v2.10.13 (February 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `LOW` No need to upgrade unless there are new features you want to use.
+
+Bug fixes:
+- [#5646](https://github.com/redisearch/redisearch/pull/5646) `FT.SEARCH` using Cyrillic characters and wildcards delivering no results (MOD-7944)
+
+## v2.10.12 (February 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5596](https://github.com/redisearch/redisearch/pull/5596) Changes on the memory block reading logic could cause crash on `FT.SEARCH` with error "_Redis 7.4.2 crashed by signal: 11, si_code: 128"_
+
+Known limitations:
+- Only the first 128 characters of string fields are normalized to lowercase during ingestion (for example, on `HSET`).
+    Example:
+
+    ```
+    HSET doc __score 1.0 name "idx1S...S" mynum 1          # Assume "S...S" is a string of 252 capital S's
+    FT.CREATE "idx" SCHEMA "name" "TEXT" "mynum" "NUMERIC"
+    FT.SEARCH "idx" "@name:idx1S...S"                      # Assume "S...S" is a string of 252 capital S's
+    ```
+
+    The `FT.SEARCH` command will return no documents.
+
+## v2.10.11 (January 2025)
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#5536](https://github.com/redisearch/redisearch/pull/5536) Querying for the latest document added to the index may result in a crash if the last block is not read (MOD-8561).
+
+## v2.10.10 (January 2025)
+
+This is a maintenance release for RediSearch 2.10
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+**Security and privacy**:
+- [#5459](https://github.com/redisearch/redisearch/pull/5459) (CVE-2024-51737) Query: potential out-of-bounds write (MOD-8486)
+
+Bug fixes:
+- [#5392](https://github.com/redisearch/redisearch/pull/5392) `NOSTEM` option does not work on query, just on tokenisation (index creation) (MOD-7634)
+- [#5300](https://github.com/redisearch/redisearch/pull/5300) Prefix/Infix/Suffix queries longer than 1024 chars could cause a crash (MOD-7882)
+- [#5294](https://github.com/redisearch/redisearch/pull/5294) Expired keys while background indexing could cause cross slot error when using `replicaof` (MOD-7949)
+- [#5282](https://github.com/redisearch/redisearch/pull/5282) `FT.CURSOR READ` retrieving deleted `TAG` fields cause a crash (MOD-8011)
+- [#5424](https://github.com/redisearch/redisearch/pull/5424) `FT.AGGREGATE` on numeric fields lead to `failed_calls` count increase on clustered DBs (MOD-8058)
+- [#5241](https://github.com/redisearch/redisearch/pull/5241) Memory count on `bytes_collected` by the index sanitiser with missing values (MOD-8097, MOD-8114)
+
+Improvements:
+- [#5257](https://github.com/redisearch/redisearch/pull/5257) Optimizing index consumed memory with the creation only upon write operations (MOD-8125)
+
+## v2.10.7 (Septermber 2024)
+
+This is a maintenance release for RediSearch 2.10
+
+Update urgency: `HIGH` : There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug Fixes:
+- https://github.com/RediSearch/RediSearch/pull/4941 Adjusting the module configuration to avoid routing overload on the first shard in a clustered database (MOD-7505)
+- https://github.com/RediSearch/RediSearch/pull/4950 `FT.PROFILE` on `AGGREGATE` numeric queries could cause a crash due to reuse of an internal CURSOR in a large range of numeric values (MOD-7454)
+
+## v2.10.6 (August 2024):
+
+This is a maintenance release for RediSearch 2.10.
+
+Update urgency: `HIGH` - There is a critical bug that may affect a subset of users. Upgrade!
+
+Bug fixes:
+- [#4916](https://github.com/redisearch/redisearch/pull/4916) - Union query, similar to `"is|the"`, starting with 2 [storwords](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/stopwords/) could cause a crash (MOD-7495)
+- [#4895](https://github.com/redisearch/redisearch/pull/4895) - `FT.AGGREGATE` with `VERBATIM` option is not handled by the shards in cluster mode (MOD-7463) 
+- [#4922](https://github.com/redisearch/redisearch/pull/4922) - Counting twice the field statistics at `#search` section of `INFO` response (MOD-7339)
+
+## v2.10 GA (v2.10.5) (July 2024)
+
+This is the General Availability release of RediSearch 2.10
+
+### Headlines:
+
+This latest RediSearch introduces memory-efficient vector data types, enhanced indexing capabilities with support for empty and missing fields, simplified query syntax, and expanded geospatial search features.
+
+### What's new in 2.10.5
+
+This new major version introduces new `BFLOAT16` and `FLOAT16` vector data types, reducing memory consumed by vectors while preserving accuracy. This update also includes highly-requested support for indexing empty and missing values and enhances the developer experience for queries with exact matching capabilities. Developers can now match `TAG` fields without needing to escape special characters, making the onboarding process and use of the query syntax easier. Lastly, Geospatial search capabilities have been expanded with new `INTERSECT` and `DISJOINT` operators, and ergonomics have been improved by providing better reporting of the memory consumed by the index and exposing the full-text scoring in an aggregation pipeline.
+
+Features:
+
+- Enhancing exact matching queries with `TAG` avoiding escaping special meaning characters using the [simpler syntax](https://redis.io/docs/latest/develop/interact/search-and-query/query/exact-match/#tag-field) `'@tag:{"my-query%term"}'` and `NUMERIC` queries:
+  - [#4802](https://github.com/RediSearch/RediSearch/pull/4802) - Using double quotes to wrap exact matching query terms such as `@email:{"test@redis.com"}` in `DIALECT 2` ( MOD-7299)
+  - [#4676](https://github.com/RediSearch/RediSearch/pull/4676), [#4433](https://github.com/RediSearch/RediSearch/pull/4433) - Enhancing query parser to avoid unnecessary escaping (MOD-5756)
+  - [#4527](https://github.com/RediSearch/RediSearch/pull/4527) - Enhancing exact matching queries for `NUMERIC` using single value `FT.SEARCH idx @numeric:[3456]` (MOD-6623)
+  - [#4802](https://github.com/RediSearch/RediSearch/pull/4802) - Enabling support for single operators in `NUMERIC` queries such as equivalence `==`, difference `!=`, greater than `>` and `>=` and less than `<` and `<=` as in `FT.SEARCH idx '@numeric==3456'` (MOD-6749)
+
+- Adding new keywords to support indexing empty values using `INDEXEMPTY` and missing values using `INDEXMISSING` per field in the `SCHEMA` while defining the [index](https://redis.io/docs/latest/commands/ft.create/) with `FT.CREATE`
+  - [#4663](https://github.com/RediSearch/RediSearch/pull/4663), [#4721](https://github.com/RediSearch/RediSearch/pull/4721) - Indexing empty strings values `""` for `TAG` and `TEXT` fields (MOD-6540, MOD-7200)
+  - [#4721](https://github.com/RediSearch/RediSearch/pull/4721) - Updating the query parser to support empty value queries for `TEXT` as `FT.SEARCH idx '@text_field:""'`or `FT.SEARCH idx '""'` and for `TAG` as in `FT.SEARCH idx '@tag_field:{""}'` (MOD-7200)
+  - [#4720](https://github.com/RediSearch/RediSearch/pull/4720), [#4635](https://github.com/RediSearch/RediSearch/pull/4635) - Indexing missing values for all field types introducing the query syntax function `ismissing(@field)` enabling query for missing fields as in `FT.SEARCH idx 'ismissing(@text)'` (MOD-6532)
+
+
+- Enabling new vector data types reducing memory consumed by vectors with the new `BFLOAT16` and `FLOAT16`
+  - [#4674](https://github.com/RediSearch/RediSearch/pull/4674) - Adding support `BFLOAT16` and `FLOAT16` in the [vector index definition](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/vectors/#creation-attributes-per-algorithm) (MOD-6765, MOD-6776)
+
+- Exposing the full-text score values during the aggregation pipeline using `ADDSCORE`. When calling the scores you can use `@__score` in the pipeline as in `FT.AGGREGATE idx 'hello' ADDSCORES SORTBY 2 @__score DESC`
+  - [#4859](https://github.com/RediSearch/RediSearch/pull/4859) - Expose scores to `FT.AGGREGATE` pipeline (MOD-7190)
+
+- [#4227](https://github.com/RediSearch/RediSearch/pull/4227) - Adding support for new operators `INTERSECT` and `DISJOINT` when querying for `GEOSHAPE` [polygons](https://redis.io/docs/latest/develop/interact/search-and-query/query/geo-spatial/) (MOD-6178)
+
+
+Bug fixes (since 2.10.4):
+- [#4854](https://github.com/RediSearch/RediSearch/pull/4854) - Avoid expansion on stemming from numeric values (MOD-7025)
+
+Improvements (since 2.10.4):
+- [#4865](https://github.com/RediSearch/RediSearch/pull/4865) - Add coverage for cleaning garbage entries when indexing missing fields (MOD-7415)
+
+{{< note >}}
+- The version inside Redis will be 2.10.5 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a Release Candidate flag.
+- Minimal Redis version: 7.4
+- If indexing and querying RedisJSON data structures, this version is best combined with RedisJSON 2.8 (v2.8.2 onwards)
+- If one or more fields of a hash key expire after a query begins (using FT.SEARCH or FT.AGGREGATE), Redis does not account for these lazily expired fields. As a result, keys with expired fields may still be included in the query results, leading to potentially incorrect or inconsistent results.
+{{< /note >}}
+---
+Title: RediSearch release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RediSearch release notes for version 2.10 and earlier
+hideListLinks: true
+linkTitle: RediSearch
+tags:
+- visible
+weight: 20
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: RediSearch 1.6 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Improved performance of full-text search and aggregation queries. Support
+  for aliasing of indices. Added a C API to embed RediSearch in other modules. Forked
+  process garbage collection.
+linkTitle: v1.6 (January 2020)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 96
+---
+## Requirements
+
+RediSearch v1.6.16 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v1.6.16 (June 2021)
+
+This is a maintenance release for version 1.6.
+
+Update urgency: MODERATE - Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fix:
+
+    - #[2018](https://github.com/RediSearch/RediSearch/pull/2018): FT.ADD REPLACE leaves fields from the previous document that are not included in the new document #[647](https://github.com/RediSearch/RediSearch/pull/647) #[1193](https://github.com/RediSearch/RediSearch/pull/1193)
+
+## v1.6.15 (February 2021)
+
+This is a maintenance release for version 1.6.
+
+Update urgency: Low
+
+Details:
+
+- Minor enhancements:
+    - #[1225](https://github.com/RediSearch/RediSearch/pull/1225) Allow scientific representation of numbers for numeric fields.
+    - #[1574](https://github.com/RediSearch/RediSearch/pull/1574) Allow SORTBY for non-sortable fields.
+
+- Minor bugfixes:
+    - #[1683](https://github.com/RediSearch/RediSearch/pull/1683) Add a module parameter _NUMERIC_COMPRESS which prevent <nobr>double -> float</nobr> compression. It prevents an issue where an exact match on some floating-point numbers is not found.
+    - #[1757](https://github.com/RediSearch/RediSearch/pull/1757) Remove assertion on the limitation of the number of sortable fields, instead return an error.
+    - #[1668](https://github.com/RediSearch/RediSearch/pull/1668) Query words from stopword list on tag fields.
+    - #[1745](https://github.com/RediSearch/RediSearch/pull/1745) Enforce 0 value for count reducer.
+    - #[1774](https://github.com/RediSearch/RediSearch/pull/1774) MINPREFIX & MAXEXPANSION can be changed in runtime.
+    - #[1861](https://github.com/RediSearch/RediSearch/pull/1761) Fix issue for FT.SCOREEXPLAIN where reply array depth can exceed 7.
+    - #[1689](https://github.com/RediSearch/RediSearch/pull/1689) FT.SUGGET results from RSCoordinator are more consistent.
+    - Various small tweaks under the hood.
+
+
+## v1.6.14 (September 2020)
+
+- This is a maintenance release for version 1.6.
+
+Details:
+
+- Minor features:
+
+    - #[1420](https://github.com/RediSearch/RediSearch/pull/1420) The hard limit of the number of results produced by FT.SEARCH is now configurable with MAXSEARCHRESULTS.
+
+- Bug fixes:
+
+    - #[1313](https://github.com/RediSearch/RediSearch/pull/1313) Wrong error of unsupported phonetic field.
+    - #[1286](https://github.com/RediSearch/RediSearch/pull/1286) Possible crash on optional search.
+    - #[1449](https://github.com/RediSearch/RediSearch/pull/1449) Rare file descriptor leak on FORK GC.
+    - #[1469](https://github.com/RediSearch/RediSearch/pull/1469) Endless loop when reaching internal docid above uint32_max.
+
+## v1.6.13 (May 2020)
+
+This is a maintenance release for version 1.6.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1186](https://github.com/RediSearch/RediSearch/pull/1186) #[1188](https://github.com/RediSearch/RediSearch/pull/1188) incorrect values for `inverted_sz_mb` and `num_records` in `FT.INFO` command.
+
+## v1.6.12 (April 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Features:
+    - #[1172](https://github.com/redisearch/redisearch/issues/1172) Added `exists` function that can be used on conditional updates (`REPLACE PARTIAL`) to check if a field exists in the document.
+- Minor Enhancements:
+    - #[1172](https://github.com/redisearch/redisearch/issues/1172) Lazy evaluation of the right side of 'or'/'and' clauses in IF condition.
+    - #[1134](https://github.com/redisearch/redisearch/issues/1134) Remove hard limit on LIMIT when using FT.SEARCH.
+- Bugfixes:
+    - #[1124](https://github.com/redisearch/redisearch/issues/1124) NOINDEX tag fields could not be updated on UPDATE PARTIAL with no indexed fields.
+    - #[1120](https://github.com/redisearch/redisearch/issues/1120) Release loop in II_GetCriteriaTester which released the same criteria tester multiple times.
+    - #[1161](https://github.com/redisearch/redisearch/issues/1161) Case where setting `MAXDOCTABLESIZE` had no effect.
+    - #[1169](https://github.com/redisearch/redisearch/issues/1169) `FIRST_VALUE` reducer crashed when value did not exist.
+    - #[1159](https://github.com/redisearch/redisearch/issues/1159) Infinite loop on `NOT` criteria tester.%
+
+## v1.6.11 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1126](https://github.com/redisearch/redisearch/issues/1126) Memory leak introduced by queries for tag fields that have no results.
+
+## v1.6.10 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+- This release fixes certain backwards compatibility issues compared to 1.4.  Although they are rare cases, it is recommended when upgrading to 1.6 to use this version or newer.
+
+Details:
+
+- Minor Enhancements:
+    - #[1062](https://github.com/redisearch/redisearch/issues/1062) Added Custom stopwords list in `FT.INFO`
+- Fixed backwards incompatible issues:
+    - #[1075](https://github.com/redisearch/redisearch/issues/1075) Fields should always be returned to the user as a string.
+    - #[1074](https://github.com/redisearch/redisearch/issues/1074) Don't truncate possible integral values when printing.
+    - #[1065](https://github.com/redisearch/redisearch/issues/1065) Revert "Change how generated reducer aliases are made".
+- Bugfixes:
+    - #[1085](https://github.com/redisearch/redisearch/issues/1085) Min and max value on non leaf nodes in the numeric tree should not be updated.
+    - #[1106](https://github.com/redisearch/redisearch/issues/1106)  Pipe leak on `FORK GC` caused by closing the fork without holding the lock.
+    - #[1114](https://github.com/redisearch/redisearch/issues/1114)  PR #[986](https://github.com/redisearch/redisearch/issues/986) reverted the work from #[985](https://github.com/redisearch/redisearch/issues/985), #[989](https://github.com/redisearch/redisearch/issues/989). This PR reintroduces these features.
+
+## v1.6.9 (February 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1052](https://github.com/redisearch/redisearch/issues/1052) Remove wrong optimization on Quantile.
+    - #[1057](https://github.com/redisearch/redisearch/issues/1057) Memory pool did not release memory when certain limit was reached.
+
+## v1.6.8 (February 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1052](https://github.com/redisearch/redisearch/issues/1052) Remove wrong optimization on Quantile.
+    - #[1057](https://github.com/redisearch/redisearch/issues/1057) Memory pool did not release memory when certain limit was reached.
+
+## v1.6 GA (January 2020)
+
+This is the General Availability Release of RediSearch 1.6 (v1.6.7).
+
+Headlines:
+
+- Several performance improvements increasing full-text search queries up to 60% and aggregation queries up to 73%.
+- Support for aliasing of indices.
+- Low-level API in C (and [Rust bindings](https://github.com/RediSearch/redisearch-api-rs)) to make RediSearch embeddable in other Redis modules. [RedisGraph]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/graph" >}}) is the first GA consumer.
+- Forked process Garbage Collection (FORK GC) allows for stable read latencies.
+
+Full details:
+
+- Added functionality
+    - #[658](https://github.com/RediSearch/RediSearch/issues/658) `FT.ADD … REPLACE … NOCREATE` will not add the document if the document does not exist.
+    - #[575](https://github.com/RediSearch/RediSearch/issues/575) Add index aliasing. This allows users to provide (or remove) ‘links’ to indexes. The commands are `FT.ALIASADD`, `FT.ALIASDEL`, and `FT.ALIASUPDATE`.
+    - New C API to make RediSearch embeddable in other Redis modules. This API allows other Redis modules to use functionality of RedisSearch without actually having the “module” functionality active. Note that this must still be used on Redis proper. Modules that are already incorporating this API
+    - [RedisGraph](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.0.1) GA
+    - [RedisTimeSeries](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/186) (WIP)
+    - [RedisJSON](https://github.com/RedisJSON/RedisJSON2) (WIP)
+
+- Performance improvements
+    - Improve performance when using many union (|) iterators
+    - Improve performance when using many intersect iterators
+    - Improve overall index reading performance
+    - #[598](https://github.com/RediSearch/RediSearch/issues/598) Do not return `foo: NULL` if `foo` is not present in the document. This conserves network bandwidth
+
+- Bugfixes - Semantics
+    - #[688](https://github.com/RediSearch/RediSearch/issues/688) #[623](https://github.com/RediSearch/RediSearch/issues/623) Fix various issues with optional (~) search operator:
+        - Fixes omitted results when using union operators in addition to optional iterators.
+        - Allow optional iterator to be used in isolation in promotion-only mode (without a filter query)
+        - Fix issue where weight attribute was being ignored
+    - #[653](https://github.com/RediSearch/RediSearch/issues/653) FT.GET will no longer return a document as existing if it was not added by FT.ADD, even if the document exists in the server as a plain redis hash
+    - FT.AGGREGATE is now more stringent with its semantics, avoiding nonsensical queries or referencing fields which do not exist in the schema or LOADed.
+    - #[779](https://github.com/RediSearch/RediSearch/issues/779) Added `to_number()` and `to_str()` functions for ambiguity reasons
+    - #[906](https://github.com/RediSearch/RediSearch/issues/906) A description of how scores were calculated can be added by adding 'EXPLAINSCORE'
+    - #[897](https://github.com/RediSearch/RediSearch/issues/897) `FORK GC` has now lowest priority over indexing and read queries
+    - Added automated tests to ensure macOs build works
+
+- Bugfixes - Crash/Stability
+    - Improved overall architectural stability
+    - #[666](https://github.com/RediSearch/RediSearch/issues/666) Fix crash when conflict between internal key name and user key name is encountered; e.g. creating a new document with `ft:two/two`
+    - #[697](https://github.com/RediSearch/RediSearch/issues/697) #[588](https://github.com/RediSearch/RediSearch/issues/588) Fix memory leaks
+    - #[691](https://github.com/RediSearch/RediSearch/issues/691) Fix crash on `FT.EXPLAIN`
+    - Proper module-level and index-level cleanup functionality
+    - Simplified concurrency model
+    - #[898](https://github.com/RediSearch/RediSearch/issues/898) Fix rare issue where `FORK GC` doesn't exists on termination of Redis
+    - #[865](https://github.com/RediSearch/RediSearch/issues/865) When using `FT.SEARCH` with `SORTBY`, it will only be possible to sort by one field
+    - #[917](https://github.com/RediSearch/RediSearch/issues/917) Fix wrong results introduced in a skip optimisation
+    - #[888](https://github.com/RediSearch/RediSearch/issues/888) `NULL` terms cause `FORK` GC to crash
+    - #[887](https://github.com/RediSearch/RediSearch/issues/887) Chinese searches not being converted to simplified Chinese.
+    - Fix `FORK GC` issue where read from pipe did not returned all the data
+---
+Title: RediSearch 2.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Search and index JSON documents. Profiling queries. Field aliasing.
+linkTitle: v2.2 (November 2021)
+min-version-db: 6.0.0
+min-version-rs: 6.0.0
+weight: 94
+---
+## Requirements
+
+RediSearch v2.2.10 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.0
+
+## v2.2.10 (March 2022)
+
+This is a maintenance release for RediSearch 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Improvements:
+
+  - Mac M1 support
+  - [#2645](https://github.com/RediSearch/RediSearch/pull/2645) Ignore `NULL` values in JSON documents on indexing (prior behaviour would ignore the entire document)
+  - [#2623](https://github.com/RediSearch/RediSearch/pull/2623) Improved Multi Sortby error message for `FT.SEARCH`
+
+- Bug fixes:
+
+  - [#2641](https://github.com/RediSearch/RediSearch/pull/2641) Memory leak in Coordinator
+  - [#2651](https://github.com/RediSearch/RediSearch/pull/2651) Client freeze on docs expire during query
+  - [#2670](https://github.com/RediSearch/RediSearch/pull/2670) Memory leak in RediSearch found in Active-Active (MOD-2518)
+
+## v2.2.9 (March 2022)
+
+This is a maintenance release for RediSearch 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Improvements:
+
+  - [#2605](https://github.com/RediSearch/RediSearch/pull/2605) Added support for `tls-key-file-pass` capability (MOD-2086)
+  - [#2583](https://github.com/RediSearch/RediSearch/pull/2583) Release index-specific information off the main thread (performance enhancement)
+
+- Bug fixes:
+
+  - [#2436](https://github.com/RediSearch/RediSearch/pull/2436) When indexing JSON documents, filters cause no documents to be indexed (MOD-2214)
+  - [#2507](https://github.com/RediSearch/RediSearch/pull/2507) `QUANTILE` aggregation function outputting wrong values (MOD-2432)
+  - [#2521](https://github.com/RediSearch/RediSearch/pull/2521) `contains()` with an empty string argument leaves Redis hanging at CPU 100% indefinitely (MOD-2428)
+  - [#2560](https://github.com/RediSearch/RediSearch/pull/2560) Free prefix and cursor efficiently for cases with many indices (MOD-2080)
+  - [#2541](https://github.com/RediSearch/RediSearch/pull/2541) Numeric types for `FT.INFO` on coordinator
+  - [#2553](https://github.com/RediSearch/RediSearch/pull/2553) Fix union high iterator
+  - [#2404](https://github.com/RediSearch/RediSearch/pull/2404) Update coordination strategy of `FlatSearchCommandHandler`
+
+## v2.2.7 (February 2022)
+
+This is a maintenance release for RediSearch 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+  - [#2466](https://github.com/RediSearch/RediSearch/pull/2466) `FT.PROFILE` for `FT.AGGREGATE` on clustered databases
+  - [#2473](https://github.com/RediSearch/RediSearch/pull/2473) `FT.PROFILE` with no result processor present
+  - [#2490](https://github.com/RediSearch/RediSearch/pull/2490) Case sensitivity issue in searches of TAG field on JSON
+
+- Improvements:
+  - [#2469](https://github.com/RediSearch/RediSearch/pull/2469) Add API for TAG children query nodes
+
+## v2.2.6 (January 2022)
+
+This is a maintenance release for RediSearch 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#2362](https://github.com/RediSearch/RediSearch/pull/2362) Crash on empty field name
+    - [#2407](https://github.com/RediSearch/RediSearch/pull/2407) Inconsistency with `FT.CREATE` and `ON`: return error for spec without fields parameters
+    - [#2392](https://github.com/RediSearch/RediSearch/pull/2392) Remove limit on Geo field precision
+    - [#2440](https://github.com/RediSearch/RediSearch/pull/2440) Fix in NOT(-) iterator
+    - [#2414](https://github.com/RediSearch/RediSearch/pull/2414) Prevent server freeze when `FT.SEARCH` timeout while sorting
+    - [#2386](https://github.com/RediSearch/RediSearch/pull/2386) Memory leak in numeric field index
+
+- Improvements:
+
+    - [#2424](https://github.com/RediSearch/RediSearch/pull/2424), [#2425](https://github.com/RediSearch/RediSearch/pull/2425) Performance improvements for numeric indices
+    - [#2408](https://github.com/RediSearch/RediSearch/pull/2408) API: Added `RediSearch_IndexInfo`
+    - [#2448](https://github.com/RediSearch/RediSearch/pull/2448) API: Added `setLang` and `setScore`
+
+## v2.2.5 (November 2021)
+
+This is the General Availability release of RediSearch 2.2.
+
+### Headlines
+
+#### Searching and indexing JSON documents
+
+This release introduces the ability to [index, query, and full-text search JSON documents]({{<relref "/develop/interact/search-and-query/indexing">}}) using JSONPath queries.
+
+On the schema creation `FT.CREATE`, it is now possible to map a JSONPath query with a field. When a JSON document is indexed, the value extracted by the JSONPath query is indexed in the given field.
+
+ _This features require the module [RedisJSON 2.0](https://www.redisjson.io) to be installed._ 
+
+#### Profiling queries
+
+With the new `FT.PROFILE` command, it is now possible to profile in detail the execution time of several internal steps involved in the execution of `FT.SEARCH` and `FT.AGGREGATE`.
+That way, it is possible to understand which part of the query is taking most of the resources.
+
+#### Field aliasing
+
+With the support of JSON document indexing, it is now possible to map a JSONPath query to an alias. Therefore, it is possible to index the same value in different indexing attributes with different indexing strategies.
+
+{{<note>}}
+As of RediSearch v2.2, index `fields` are now known as `attributes` in order to avoid confusion with hash fields. This change impacts the `FT.INFO` command's response, which might break clients.  It is advised to upgrade your application to the latest supported Redis clients prior to upgrading to RediSearch 2.2.
+{{</note>}}
+
+### Details
+
+- Enhancements:
+  - #[2337](https://github.com/redisearch/redisearch/issues/2337) Add support for Redis COPY command 
+  - #[2243](https://github.com/redisearch/redisearch/issues/2243) Add `LOAD *` for `FT.AGGREGATE`
+  - #[2207](https://github.com/redisearch/redisearch/issues/2207) Add multi value recursive decent tag
+  - #[2188](https://github.com/redisearch/redisearch/issues/2188) Add `UNF` flag for `SORTABLE` fields
+  - #[2184](https://github.com/redisearch/redisearch/issues/2184) LLAPI getter functions for score, language, and stopwords list
+  - #[2133](https://github.com/redisearch/redisearch/issues/2133) JSON array can be stored in a TAG field
+  - #[2153](https://github.com/redisearch/redisearch/issues/2153) Improve FT.INFO complexity to O(1) 
+  - #[2138](https://github.com/redisearch/redisearch/issues/2138) Add `CASESENSITIVE` to `TAG` fields
+  - #[2137](https://github.com/redisearch/redisearch/issues/2137) `FT.INFO` has identifier and attribute for fields
+
+- Bug fixes:
+  - #[2341](https://github.com/redisearch/redisearch/issues/2341) Fix score field for JSON
+  - #[2325](https://github.com/redisearch/redisearch/issues/2325) Fix escaping for tags
+  - #[2269](https://github.com/redisearch/redisearch/issues/2269) Remove empty tag values
+  - #[2223](https://github.com/redisearch/redisearch/issues/2223) Replace NULL with empty iterator for child of negative iterator
+  - #[2215](https://github.com/redisearch/redisearch/issues/2215) Update field limit on tags
+  - #[2143](https://github.com/redisearch/redisearch/issues/2143) Partial JSON documents are not indexed
+  - #[2109](https://github.com/redisearch/redisearch/issues/2109) Field loaded with 'AS' can't be used by functions
+
+Notes:
+This is the first GA version of 2.2. The version inside Redis will be 2.2.5 in semantic versioning.
+_Since the version of a module in Redis is numeric, we could not add a GA flag._
+---
+Title: RedisBloom 2.8 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisBloom 2.8 introduces improvements and bug fixes.
+linkTitle: v2.8 (July 2024)
+min-version-db: '7.4'
+min-version-rs: 7.8
+toc: 'true'
+weight: 94
+---
+
+## Requirements
+
+RedisBloom v2.8.7 requires:
+
+- Minimum Redis compatibility version (database): 7.4
+- Minimum Redis Enterprise Software version (cluster): 7.8
+
+## v2.8.7 (April 2025)
+
+This is a maintenance release for RedisBloom 2.8
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Improvements:
+- [#865](https://github.com/redisbloom/redisbloom/pull/865) Added support for Azure Linux 3 (MOD-9171)
+
+## v2.8.5 (January 2025)
+
+This is a maintenance release for RedisBloom 2.8.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- **Security and privacy:**
+  - [#843](https://github.com/redisbloom/redisbloom/pull/843) (CVE-2024-53993) CMS: potential out-of-bounds write (MOD-6970)
+
+- Bug fixes:
+  - [#843](https://github.com/redisbloom/redisbloom/pull/843) `CMS.MERGE` crashes or hangs on negative number of keys (MOD-6964)
+  - [#699](https://github.com/redisbloom/redisbloom/pull/699) `BF.RESERVE` crashes (OOM) on huge initialization values (MOD-7057)
+  - [#843](https://github.com/redisbloom/redisbloom/pull/843) `CF.RESERVE` crashes (OOM) on huge initialization values (MOD-7058)
+  - [#843](https://github.com/redisbloom/redisbloom/pull/843) `TOPK.RESERVE` crashes (OOM) on huge initialization values (MOD-7059)
+  - [#843](https://github.com/redisbloom/redisbloom/pull/843) `CMS.INITBYDIM` and `CMS.INITBYPROB` crash (OOM) on huge initialization values (MOD-7060)
+  - [#828](https://github.com/redisbloom/redisbloom/pull/828) `CMS.INCRBY` does not notify `WATCH`ers or client-side caching (MOD-8193)
+  - [#827](https://github.com/redisbloom/redisbloom/pull/827) Top-K - suboptimal results after RDB load due to missing initialization (MOD-8194)
+
+- Improvements:
+  - [#801](https://github.com/redisbloom/redisbloom/pull/801) Support active memory defragmentation (MOD-7890)
+  - [#829](https://github.com/redisbloom/redisbloom/pull/829) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v2.8 GA (v2.8.2) (July 2024)
+
+This is the General Availability release of RedisBloom 2.8
+
+### Headlines:
+
+RedisBloom 2.8 introduces improvements and bug fixes.
+
+### Details
+
+- Bug fixes
+
+  - [#773](https://github.com/RedisBloom/RedisBloom/pull/773) `CMS.MERGE`: reply with an error on overflow and underflow (MOD-6962)
+  - [#720](https://github.com/RedisBloom/RedisBloom/pull/720) `BF` crashes on high error rate (MOD-6268)
+
+{{< note >}}
+- The version inside Redis will be 2.8.2 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+- Minimal Redis version: 7.4
+{{</note>}}
+---
+Title: RedisBloom 2.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: BF.INFO returns bloom filter details. CF.INFO returns cuckoo filter details.
+  Scalable bloom and cuckoo filters. Configurable bucket size for cuckoo filters.
+  CMS.INCRBY returns count.
+linkTitle: v2.2 (December 2019)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 97
+---
+## Requirements
+
+RedisBloom v2.2.18 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v2.2.18 (July 2022)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#481](https://github.com/RedisBloom/RedisBloom/issues/481) CF crashes on expansion 0
+    - [#478](https://github.com/RedisBloom/RedisBloom/pull/478) [`BF.INFO`]({{< relref "commands/bf.info" >}}) reports an inaccurate result about the memory footprint
+
+## v2.2.17 (June 2022)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#451](https://github.com/RedisBloom/RedisBloom/pull/451) [`TOPK.INCRBY`]({{< relref "commands/topk.incrby" >}}): fix calculation when old fingerprint count is reduced to 0
+    - [#462](https://github.com/RedisBloom/RedisBloom/pull/462) [`CF.RESERVE`]({{< relref "commands/cf.reserve" >}}): fix potential crash on incorrect number of parameters
+    - [#434](https://github.com/RedisBloom/RedisBloom/pull/434) [`CF.INSERT`]({{< relref "commands/cf.insert" >}}): fix crash when capacity is negative
+    - [#450](https://github.com/RedisBloom/RedisBloom/pull/450) [`TOPK.INCRBY`]({{< relref "commands/topk.incrby" >}}): limit increment to 100,000 to prevent potential long freezes
+
+## v2.2.15 (May 2022)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: None.
+
+Details:
+
+- Enhancements:
+
+    - Added support for RedisBloom for AArch64 Linux
+
+## v2.2.14 (March 2022)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#419](https://github.com/RedisBloom/RedisBloom/pull/419) `CMS.INCRBY` now returns an error on overflow
+    - [#412](https://github.com/RedisBloom/RedisBloom/pull/412) Fixed macOS build
+
+## v2.2.12 (February 2022)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#392](https://github.com/RedisBloom/RedisBloom/pull/392) Fixed a potential crash on Bloom filter expansion when loading from [AOF]({{< relref "/operate/oss_and_stack/management/persistence" >}})
+    - [#404](https://github.com/RedisBloom/RedisBloom/pull/404) Fixed a potential crash on Cuckoo filter when calling `CF.LOADCHUNK` on a filter with `EXPANSION` greater than 1
+
+## v2.2.9 (November 2021)
+
+This is a maintenance release for RedisBloom 2.2.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#281](https://github.com/RedisBloom/RedisBloom/pull/281) Memory leak when loading TOPK keys from RDB.
+
+    - [#303](https://github.com/RedisBloom/RedisBloom/pull/303) `CMS.INCRBY` for negative or non-number
+
+    - [#354](https://github.com/RedisBloom/RedisBloom/pull/354) TOPK List Duplicate entries
+
+    - [#369](https://github.com/RedisBloom/RedisBloom/pull/369) Free only latest filter on `CF.COMPACT`
+
+    - [#371](https://github.com/RedisBloom/RedisBloom/pull/371) `CF.SCANDUMP` for cuckoo filter
+ 
+    - [#374](https://github.com/RedisBloom/RedisBloom/pull/374) ReplicateVerbatim for `CF.LOADCHUNK` (similar to [#309](https://github.com/RedisBloom/RedisBloom/pull/309))
+
+- Improvements:
+
+    - [#331](https://github.com/RedisBloom/RedisBloom/pull/331) Add `WITHCOUNT` flag to `TOPK.LIST`
+
+## v2.2.6 (August 2021)
+
+This is a maintenance release for version 1.0.
+
+Update urgency: `LOW` -  No need to upgrade unless there are new features you want to use.
+
+Details:
+- Enhancements:
+    - #[333](https://github.com/redisbloom/redisbloom/issues/333) Support inter shards TLS capability
+
+## v2.2.4 (July 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for found issues.
+
+Details:
+
+- Bug fixes:
+    - #[215](https://github.com/redisbloom/redisbloom/issues/215) Count-Min-Sketch CMS.INCRBY command to reply with correct min result.
+    - #[219](https://github.com/redisbloom/redisbloom/issues/219) Cuckoo Filter CF.DEBUG correct response formatting.
+
+## v2.2.3 (July 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for found issues.
+
+Details:
+
+- Bug fixes:
+    - [#217](https://github.com/RedisBloom/RedisBloom/pull/217) Client hung on `BF.INSERT` with multiple new items when a non-scaling filter is full.
+
+## v2.2.2 (March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor enhancements:
+    - Bloom
+        - #[180](https://github.com/redisbloom/redisbloom/issues/180) Removed the upper limit on Bloom Filter capacity.
+
+## v2.2.1 (January 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor Enhancements:
+    - Bloom
+        - #[179](https://github.com/RedisBloom/RedisBloom/issues/179) Allow storing filters with size over 4294967295 (UINT32_MAX). Now 64 bits.
+        - #[177](https://github.com/RedisBloom/RedisBloom/issues/177) Prevent passing both `EXPANSION` *and* `NONSCALING` parameters to `BF.RESERVE`.
+
+## v2.2.0 (December 2019)
+
+- Added functionality
+    - Bloom
+        - #[149](https://github.com/RedisBloom/RedisBloom/issues/149) `BF.INFO` returns details about a specific bloom filter
+        - Scalable
+            - #[153](https://github.com/RedisBloom/RedisBloom/issues/153) Ability to change the `EXPANSION` rate. This means each subsequent sub-filter will be `expansion` times larger as the previous one.
+            - #[160](https://github.com/RedisBloom/RedisBloom/issues/160) Optimise the scaling up of filter according to the [Scalable Bloom Filter](https://core.ac.uk/download/pdf/55607643.pdf) paper
+            - #[161](https://github.com/RedisBloom/RedisBloom/issues/161) Optional `NONSCALING` argument to disable scaling.  (This saves space since less hash functions are used)
+        - #[155](https://github.com/RedisBloom/RedisBloom/issues/155) Disabling rounding up functionality
+    - Cuckoo
+        - #[149](https://github.com/RedisBloom/RedisBloom/issues/149) `CF.INFO` returns details about a specific cuckoo filter
+        - Scalable
+            - #[138](https://github.com/RedisBloom/RedisBloom/issues/138) Configurable `EXPANSION`. When an additional filter is created, its size will be the size of the current filter multiplied by the `expansion`.  Higher expansion rates will result in lower error rates.
+            - #[142](https://github.com/RedisBloom/RedisBloom/issues/142) The maximum number of expansions limited to 32.
+            - #[131](https://github.com/RedisBloom/RedisBloom/issues/131) Configurable `MAXITERATIONS`. Number of attempts to swap buckets before declaring filter as full and creating an additional filter.
+        - #[135](https://github.com/RedisBloom/RedisBloom/issues/135) Configurable  `BUCKETSIZE`. Number of items in each bucket. Higher bucket size value improves the fill rate but result in a higher error rate and slightly slower operation speed.
+        - #[142](https://github.com/RedisBloom/RedisBloom/issues/142) use of 64bit hash function
+        - #[136](https://github.com/RedisBloom/RedisBloom/issues/136) expose compaction of filters in the API
+    - CMS
+        - #[97](https://github.com/RedisBloom/RedisBloom/issues/97) `CMS.INCRBY` returns count instead of ‘OK’
+
+- Minor bug fixes
+    - Bloom
+        - #[154](https://github.com/RedisBloom/RedisBloom/issues/154) Check error rate is 1< (cannot be equal)
+    - Cuckoo
+        - #[134](https://github.com/RedisBloom/RedisBloom/issues/134) Added `CuckooInsert_MemAllocFailed` exception
+        - #[130](https://github.com/RedisBloom/RedisBloom/issues/130) Number of deletes wasn’t saved to RDB
+    - General
+        - #[117](https://github.com/RedisBloom/RedisBloom/issues/117) Using `RMUtil_RegisterWriteDenyOOMCmd`
+        - #[121](https://github.com/RedisBloom/RedisBloom/issues/121) Moved `ReplicaVerbatim` to end of functions
+---
+Title: RedisBloom 2.6 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RESP3 support. Bug fixes.
+linkTitle: v2.6 (July 2023)
+min-version-db: '7.2'
+min-version-rs: 7.2.4
+toc: 'true'
+weight: 95
+---
+## Requirements
+
+RedisBloom v2.6.18 requires:
+
+- Minimum Redis compatibility version (database): 7.2
+- Minimum Redis Enterprise Software version (cluster): 7.2.4
+
+## v2.6.18 (April 2025)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Improvements:
+- [#865](https://github.com/redisbloom/redisbloom/pull/865) Added support for Azure Linux 3 (MOD-9171)
+
+## v2.6.17 (February 2025)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+  - [#828](https://github.com/redisbloom/redisbloom/pull/828) `CMS.INCRBY` does not notify `WATCH`ers or client-side caching (MOD-8193)
+  - [#827](https://github.com/redisbloom/redisbloom/pull/827) Top-K - suboptimal results after RDB load due to missing initialization (MOD-8194)
+
+## v2.6.16 (January 2025)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- **Security and privacy:**
+  - [#844](https://github.com/redisbloom/redisbloom/pull/844) (CVE-2024-53993) CMS: potential out-of-bounds write (MOD-6970)
+
+- Bug fixes:
+  - [#844](https://github.com/redisbloom/redisbloom/pull/844) `CMS.MERGE` crashes or hangs on negative number of keys (MOD-6964)
+
+- Improvements:
+  - [#830](https://github.com/redisbloom/redisbloom/pull/830) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v2.6.13 (July 2024)
+
+This is a maintenance release for RedisBloom 2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#720](https://github.com/RedisBloom/RedisBloom/pull/720) `BF` crashes on high error rate (MOD-6268)
+  - [#773](https://github.com/RedisBloom/RedisBloom/pull/773) `CMS.MERGE`: reply with an error on overflow and underflow (MOD-6962)
+
+## v2.6.12 (March 2024)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#753](https://github.com/RedisBloom/RedisBloom/issues/753) Potential crash on `CMS.MERGE` when using invalid arguments
+
+## v2.6.11 (January 2024)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Additional fixes for potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+## v2.6.10 (January 2024)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#735](https://github.com/RedisBloom/RedisBloom/pull/735) Potential crash on `CF.RESERVE` (MOD-6343)
+  - [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+## v2.6.9 (December 2023)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [#707](https://github.com/RedisBloom/RedisBloom/pull/707) Top-K: `TOPK.ADD` and `TOPK.QUERY` crash when an item name is an empty string (RED-114676)
+
+## v2.6.8 (October 2023)
+
+This is a maintenance release for RedisBloom 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - [#684](https://github.com/RedisBloom/RedisBloom/pull/684), [#685](https://github.com/RedisBloom/RedisBloom/pull/685) Added support for CBL-Mariner 2
+  - [#677](https://github.com/RedisBloom/RedisBloom/pull/677), [#678](https://github.com/RedisBloom/RedisBloom/pull/678) Added support for Rocky Linux 9 and RHEL9
+
+## v2.6 GA (v2.6.3) (July 2023)
+
+This is the General Availability release of RedisBloom 2.6.
+
+### Headlines
+
+RedisBloom 2.6 introduces support for RESP3 and bug fixes.
+
+### Details
+
+Improvements: 
+
+- [#664](https://github.com/RedisBloom/RedisBloom/pull/664) `TOPK.ADD`, `TOPK.INCRBY`, and `TOPK.LIST` reply with blob string instead of simple string.
+
+{{<note>}}
+- The version inside Redis will be 2.6.3 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+
+- Minimal Redis version: 7.2
+{{</note>}}
+---
+Title: RedisBloom 1.1 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Updated version.
+linkTitle: v1.1 (February 2019)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 99
+---
+## Requirements
+
+RedisBloom v1.1.1 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## RedisBloom 1.1.1 (21 February 2019)
+
+Update version to 1.1.1
+
+## RedisBloom 1.1.0 (12 February 2019)
+
+Release of 1.1.0---
+LinkTitle: v2.0 (June 2019)
+Title: RedisBloom 2.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added more probabilistic data structures, including top-K and count-min
+  sketch.
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 98
+---
+## Requirements
+
+RedisBloom v2.0.3 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v2.0.3 (July 2019)
+
+- Performance improvements:
+    - #[95](https://github.com/RedisBloom/RedisBloom/issues/95) Top-K - Reduce checks on heap, now only checks if item count is larger than minimum in heap.
+    - #[95](https://github.com/RedisBloom/RedisBloom/issues/95) Top-K - The power of decay was calculated every time. Changed to use a lookup table.
+- Major bug fix:
+    - #[88](https://github.com/RedisBloom/RedisBloom/issues/88) Replication available for newly added Top-K and Count-min sketch
+- Minor bug fixes:
+    - #[89](https://github.com/RedisBloom/RedisBloom/issues/89) Module update broke rdb files
+    - #[98](https://github.com/RedisBloom/RedisBloom/issues/98) Compilation for macOS
+
+## v2.0.0 (June 2019)
+
+We are proud to announce that we doubled the number of probabilistic data structures that are generally available in RedisBloom.  Full documentation is available on [redisbloom.io](https://redisbloom.io)
+
+- #[70](https://github.com/RedisBloom/RedisBloom/issues/70) Top-K
+    - [Commands]({{<relref "/develop/data-types/probabilistic/top-k">}})
+    - [Algorithm](https://www.usenix.org/conference/atc18/presentation/gong)
+
+- #[65](https://github.com/RedisBloom/RedisBloom/issues/65) Count-min Sketch
+    - [Commands]({{<relref "/develop/data-types/probabilistic/count-min-sketch">}})
+    - [Algorithm](https://en.wikipedia.org/wiki/Count%E2%80%93min_sketch)
+---
+Title: RedisBloom 1.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: First GA release of RedisBloom.
+linkTitle: v1.0 (September 2017)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 100
+---
+## Requirements
+
+RedisBloom v1.0.3 requires:
+
+- Minimum Redis compatibility version (database): 4.0
+- Minimum Redis Enterprise Software version (cluster): 5.0
+
+## v1.0.3 (December 2017)
+
+This contains a single fix, issue #[19](https://github.com/RedisBloom/RedisBloom/issues/19).
+
+From this version onwards, `EXISTS`/`MEXISTS` returns 0 if the (Redis) key does not exist in the database.  Earlier versions returned an error.
+
+## v1.0.2 (November 2017)
+
+This fixes a build issue (fixed s3 config in circle yaml).
+
+## v1.0.0 (September 2017)
+
+This is the first GA release of ReBloom.
+---
+Title: RedisBloom 2.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added t-digest - a probabilistic data structure for estimating quantiles
+  based on a data stream or a large dataset of floating-point values.
+linkTitle: v2.4 (November 2022)
+min-version-db: 6.0.16
+min-version-rs: 6.2.8
+weight: 96
+---
+## Requirements
+
+RedisBloom v2.4.15 requires:
+
+- Minimum Redis compatibility version (database): 6.0.16
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v2.4.15 (April 2025)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Improvements:
+- [#865](https://github.com/redisbloom/redisbloom/pull/865) Added support for Azure Linux 3 (MOD-9171)
+
+## v2.4.14 (February 2025)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+  - [#828](https://github.com/redisbloom/redisbloom/pull/828) `CMS.INCRBY` does not notify `WATCH`ers or client-side caching (MOD-8193)
+  - [#827](https://github.com/redisbloom/redisbloom/pull/827) Top-K - suboptimal results after RDB load due to missing initialization (MOD-8194)
+
+## v2.4.13 (January 2025)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+Details:
+
+- **Security and privacy:**
+  - [#845](https://github.com/redisbloom/redisbloom/pull/845) (CVE-2024-53993) CMS: potential out-of-bounds write (MOD-6970)
+
+- Bug fixes:
+  - [#845](https://github.com/redisbloom/redisbloom/pull/845) `CMS.MERGE` crashes or hangs on negative number of keys (MOD-6964)
+
+- Improvements:
+  - [#831](https://github.com/redisbloom/redisbloom/pull/831) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v2.4.9 (March 2024)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#753](https://github.com/RedisBloom/RedisBloom/issues/753) Potential crash on `CMS.MERGE` when using invalid arguments
+
+## v2.4.8 (January 2024)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Additional fixes for potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+## v2.4.7 (January 2024)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#735](https://github.com/RedisBloom/RedisBloom/pull/735) Potential crash on `CF.RESERVE` (MOD-6343)
+  - [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+## v2.4.6 (December 2023)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [#707](https://github.com/RedisBloom/RedisBloom/pull/707) Top-K: `TOPK.ADD` and `TOPK.QUERY` crash when an item name is an empty string (RED-114676)
+
+- Improvements:
+
+  - [#706](https://github.com/RedisBloom/RedisBloom/pull/706) Added support for CBL-Mariner 2 (MOD-6200)
+
+## v2.4.5 (April 2023)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - Internal changes for supporting future Redis Enterprise releases
+
+## v2.4.4 (February 2023)
+
+This is a maintenance release for RedisBloom 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#609](https://github.com/RedisBloom/RedisBloom/issues/609) [CF.INFO]({{< relref "commands/cf.info" >}}) - incorrect information for large filters
+
+- Improvements:
+
+  - [#389](https://github.com/RedisBloom/RedisBloom/issues/389) Introduce [BF.CARD]({{< relref "commands/bf.card" >}}) to retrieve the cardinality of a Bloom filter or 0 when such key does not exist
+
+## v2.4 GA (v2.4.3) (November 2022)
+
+This is the General Availability release of RedisBloom 2.4.
+
+### Highlights
+
+RedisBloom 2.4 introduces a new sketch data structure: **t-digest**.
+
+### What's new in 2.4
+
+[t-digest](https://www.sciencedirect.com/science/article/pii/S2665963820300403) is a probabilistic data structure for estimating quantiles based on a data stream or a large dataset of floating-point values. It can be used to answer the following questions:
+
+- What 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?
+- Which value is smaller than _p_ percent of the values in the data stream? (what is the _p_-percentile value)?
+- What is the mean value between the _p1_-percentile value and the _p2_-percentile value?
+- What is the value of the _n_-th smallest / largest value in the data stream? (what is the value with [reverse] rank _n_)?
+
+As for any other probabilistic data structures, t-digest requires sublinear space and has controllable space-accuracy tradeoffs.
+
+Using t-digest is simple and straightforward:
+
+* **Creating a sketch and adding observations**
+
+  `TDIGEST.CREATE key [COMPRESSION compression]` initializes a new t-digest sketch (and errors if the key already exists). The `COMPRESSION` argument is used to specify the tradeoff between accuracy and memory consumption. The default is 100. Higher values mean more accuracy.
+
+  `TDIGEST.ADD key value...` adds new observations (floating-point values) to the sketch. You can repeat calling [TDIGEST.ADD]({{< relref "commands/tdigest.add" >}}) whenever new observations are available.
+
+* **Estimating fractions or ranks by values**
+
+  Use `TDIGEST.CDF key value...` to retrieve, for each input **value**, an estimation of the **fraction** of (observations **smaller** than the given value + half the observations equal to the given value).
+
+  `TDIGEST.RANK key value...` is similar to [TDIGEST.CDF]({{< relref "commands/tdigest.cdf" >}}), but used for estimating the number of observations instead of the fraction of observations. More accurately it returns, for each input **value**, an estimation of the **number** of (observations **smaller** than a given value + half the observations equal to the given value).
+
+  And lastly, `TDIGEST.REVRANK key value...` is similar to [TDIGEST.RANK]({{< relref "commands/tdigest.rank" >}}), but returns, for each input **value**, an estimation of the **number** of (observations **larger** than a given value + half the observations equal to the given value).
+
+* **Estimating values by fractions or ranks**
+
+  `TDIGEST.QUANTILE key fraction...` returns, for each input **fraction**, an estimation of the **value** (floating point) that is **smaller** than the given fraction of observations.
+
+  `TDIGEST.BYRANK key rank...` returns, for each input **rank**, an estimation of the **value** (floating point) with that rank.
+
+  `TDIGEST.BYREVRANK key rank...` returns, for each input **reverse rank**, an estimation of the **value** (floating point) with that reverse rank.
+
+* **Estimating trimmed mean**
+
+  Use `TDIGEST.TRIMMED_MEAN key lowFraction highFraction` to retrieve an estimation of the mean value between the specified fractions.
+
+  This is especially useful for calculating the average value ignoring outliers. For example, calculating the average value between the 20th percentile and the 80th percentile.
+
+* **Merging sketches**
+
+  Sometimes it is useful to merge sketches. For example, suppose we measure latencies for 3 servers, and we want to calculate the 90%, 95%, and 99% latencies for all the servers combined.
+
+  `TDIGEST.MERGE destKey numKeys sourceKey... [COMPRESSION compression] [OVERRIDE]` merges multiple sketches into a single sketch.
+
+  If `destKey` does not exist, a new sketch is created.
+
+  If `destKey` is an existing sketch, its values are merged with the values of the source keys. To override the destination key contents, use `OVERRIDE`.
+
+* **Retrieving sketch information**
+
+  Use `TDIGEST.MIN` key and `TDIGEST.MAX key` to retrieve the minimal and maximal values in the sketch, respectively.
+
+  Both return NaN (Not a Number) when the sketch is empty.
+
+  Both commands return accurate results and are equivalent to `TDIGEST.BYRANK key 0` and `TDIGEST.BYREVRANK key 0` respectively.
+
+  Use `TDIGEST.INFO key` to retrieve some additional information about the sketch.
+
+* **Resetting a sketch**
+
+  `TDIGEST.RESET key` empties the sketch and reinitializes it.
+---
+Title: RedisBloom release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisBloom release notes for version 2.8 and earlier
+hideListLinks: true
+linkTitle: RedisBloom
+tags:
+- visible
+weight: 40
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: RedisJSON 2.8 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisJSON 2.8 introduces bug fixes.
+linkTitle: v2.8 (July 2024)
+min-version-db: '7.4'
+min-version-rs: 7.8
+toc: 'true'
+weight: 95
+---
+
+## Requirements
+
+RedisJSON v2.8.9 requires:
+
+- Minimum Redis compatibility version (database): 7.4
+- Minimum Redis Enterprise Software version (cluster): 7.8
+
+## v2.8.9 (April 2025)
+
+This is a maintenance release for RedisJSON 2.8.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Bug fixes
+- [#1329](https://github.com/redisjson/redisjson/pull/1329) Memory usage calculation: some allocations are counted twice (MOD-9169) 
+
+Improvements:
+- [#1335](https://github.com/redisjson/redisjson/pull/1335) Added support for Azure Linux 3 (MOD-9172)
+
+## v2.8.8 (January 2025)
+
+This is a maintenance release for RedisJSON 2.8
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:  
+
+- Bug fixes:
+  - [#1313](https://github.com/redisjson/redisjson/pull/1313) (Redis Enterprise A-A only) Potential crash on `JSON.DEBUG MEMORY` (MOD-8412)
+
+- Improvements:
+  - [#1262](https://github.com/redisjson/redisjson/pull/1262) Support active memory defragmentation (MOD-7888)
+  - [#1308](https://github.com/redisjson/redisjson/pull/1308) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v2.8.4 (September 2024)
+
+This is a maintenance release for RedisJSON 2.8
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#1225](https://github.com/redisjson/redisjson/pull/1225) Crash on SET commands with recursive overlapping paths (MOD-7279)
+  - HDT#261 (Redis Enterprise A-A only) Crash when a JSON contains an EOF character (MOD-7464)
+
+## v2.8 GA (v2.8.3) (July 2024)
+
+This is the General Availability release of RedisJSON 2.8
+
+### Headlines:
+
+RedisJSON 2.8 introduces bug fixes.
+
+Details
+
+- Bug fixes
+
+  - [#1212](https://github.com/RedisJSON/RedisJSON/pull/1212) `JSON.MSET`- AOF commands are duplicated multiple times (MOD-7293)
+
+{{< note >}}
+- The version inside Redis will be 2.8.3 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+- Minimal Redis version: 7.4
+{{< /note >}}
+---
+Title: RedisJSON 2.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Preview of Active-Active support for JSON.
+linkTitle: v2.2 (July 2022)
+min-version-db: 6.0.0
+min-version-rs: 6.2.12
+weight: 98
+---
+## Requirements
+
+RedisJSON v2.2.0 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.2.18
+
+## v2.2.0 (July 2022)
+
+A preview of RedisJSON 2.2 is available for Free and Fixed subscription plans in Redis Cloud.
+
+### Headlines
+
+This release adds support for the JSON data structure as a CRDT (Conflict-free Replicated Data Type) when used with Redis Enterprise [Active-Active databases]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}active-active/).
+
+Active-Active JSON requires Redis Enterprise Software v6.2.12. Contact your account manager or support to access the preview of RedisJSON 2.2. 
+
+### Details
+
+- Enhancements:
+
+  - [#758](https://github.com/RedisJSON/RedisJSON/pull/758) Add support for [`COPY`]({{< relref "/commands/copy" >}})
+---
+Title: RedisJSON 2.6 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RESP3 support. New commands JSON.MERGE and JSON.MSET.
+linkTitle: v2.6 (July 2023)
+min-version-db: '7.2'
+min-version-rs: 7.2.4
+toc: 'true'
+weight: 96
+---
+## Requirements
+
+RedisJSON v2.6.15 requires:
+
+- Minimum Redis compatibility version (database): 7.2
+- Minimum Redis Enterprise Software version (cluster): 7.2.4
+
+## v2.6.15 (April 2025)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Bug fixes
+- [#1329](https://github.com/redisjson/redisjson/pull/1329) Memory usage calculation: some allocations are counted twice (MOD-9169) 
+
+Improvements:
+- [#1335](https://github.com/redisjson/redisjson/pull/1335) Added support for Azure Linux 3 (MOD-9172)
+
+## v2.6.14 (January 2025)
+
+This is a maintenance release for RedisJSON 2.6
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+  - [#1313](https://github.com/redisjson/redisjson/pull/1313) (Redis Enterprise A-A only) Potential crash on `JSON.DEBUG MEMORY` (MOD-8412)
+
+- Improvements:
+  - [#1312](https://github.com/redisjson/redisjson/pull/1312) Added support for Ubuntu 22 and macOS 13 and 14
+
+
+## v2.6.12 (September 2024)
+
+This is a maintenance release for RedisJSON 2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#1225](https://github.com/redisjson/redisjson/pull/1225) Crash on SET commands with recursive overlapping paths (MOD-7279)
+  - HDT#261 (Redis Enterprise A-A only) Crash when a JSON contains an EOF character (MOD-7464)
+
+## v2.6.10 (April 2024)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#1192](https://github.com/RedisJSON/RedisJSON/pull/1192) Crashes with numeric values greater than i64::MAX (MOD-6501, MOD-4551, MOD-4856, MOD-5714)
+  - HDT#228 (Redis Enterprise A-A only) Incorrect error when processing escaped characters (MOD-6645)
+
+## v2.6.9 (January 2024)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Improvements:
+
+   - [#1131](https://github.com/RedisJSON/RedisJSON/issues/1131), [#1143](https://github.com/RedisJSON/RedisJSON/pull/1143) **BREAKING** - Revert JSONPath default path value from `$` to `.` under RESP3 (MOD-6156)
+
+- Bug fixes:
+
+  - [#1095](https://github.com/RedisJSON/RedisJSON/pull/1095) Fix for RediSearch deadlock. See RediSearch 2.8.10 release notes (MOD-5895)
+
+## v2.6.8 (November 2023)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+{{<note>}}
+RHEL 7 is no longer supported as of v2.6.8.
+{{</note>}}
+
+This is a version number alignment with RedisJSON for Redis Enterprise (with Active-Active support).
+
+## v2.6.7 (October 2023)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - [#1102](https://github.com/RedisJSON/RedisJSON/pull/1102) Added support for CBL-Mariner 2
+  - [#1099](https://github.com/RedisJSON/RedisJSON/pull/1099) Added support for RHEL9 and Rocky Linux 9
+
+## v2.6.6 (August 2023)
+
+This is a maintenance release for RedisJSON 2.6.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+This is just a version number alignment with RedisJSON for Redis Enterprise (with Active-Active support).
+
+## v2.6 GA (v2.6.4) (July 2023)
+
+This is the General Availability release of RedisJSON 2.6.
+
+### Headlines
+
+RedisJSON 2.6 introduces support for RESP3 and new commands.
+
+### What's new in 2.6
+
+- Introduce [`JSON.MERGE`]({{< relref "commands/json.merge" >}}) in compliance with [RFC 7396](https://datatracker.ietf.org/doc/html/rfc7396), supporting:
+
+  - Creating new attributes on an existing JSON document
+
+  - Updating and replacing values in parent and child attributes
+
+  - Deleting existing attributes (by setting the value to `null`)
+
+  - Array update - replacing an entire array with the new value
+
+- Introduce [`JSON.MSET`]({{< relref "commands/json.mset" >}}), supporting atomic multiple sets for keys in the same hash slot
+
+- New `FORMAT` argument in `JSON.ARRPOP` and `JSON.GET` to retrieve the results as JSON strings or RESP3 hierarchical structures (RESP3 only)
+
+- `JSON.RESP` is now regarded as deprecated
+
+- Legacy paths (paths that don't start with either `$.` or `$[` or equal to `$`), except those starting with `.`, are now deprecated
+
+{{<note>}}
+- The version inside Redis will be 2.6.4 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+
+- Minimal Redis version: 7.2
+{{</note>}}
+---
+Title: RedisJSON 2.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Index JSON documents. JSONPath support. Commands operate on multiple
+  paths.
+linkTitle: v2.0 (November 2021)
+min-version-db: 6.0.0
+min-version-rs: 6.0.0
+weight: 99
+---
+## Requirements
+
+RedisJSON v2.0.11 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.0
+
+## v2.0.11 (July 2022)
+
+This is a maintenance release for RedisJSON 2.0.
+Update urgency: `LOW` - No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - Minor documentation changes and internal build improvements
+
+## v2.0.9 (June 2022)
+
+This is a maintenance release for RedisJSON 2.0.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [#721](https://github.com/RedisJSON/RedisJSON/pull/721) Skip String and Boolean scalars in `JSON.CLEAR` (MOD-3136)
+
+- Improvements:
+
+  - [#709](https://github.com/RedisJSON/RedisJSON/pull/709) Allow internal JSON API's `getdouble` to succeed with integer values
+
+## v2.0.8 (April 2022)
+
+This is a maintenance release for RedisJSON 2.0.
+
+Update urgency: `LOW` - No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+  - [#691](https://github.com/RedisJSON/RedisJSON/pull/691), [#667](https://github.com/RedisJSON/RedisJSON/issues/667) Duplicate results in JSONPath query
+
+## v2.0.7 (March 2022)
+
+This is a maintenance release for RedisJSON 2.0.
+
+Update urgency: `LOW` - No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - [#632](https://github.com/RedisJSON/RedisJSON/pull/632), [#605](https://github.com/RedisJSON/RedisJSON/pull/605) Support `JSON.CLEAR` for string, bool, and numeric scalars (MOD-2394)
+  - [#637](https://github.com/RedisJSON/RedisJSON/pull/637) Add `intershard_tls_pass` support (MOD-2522)
+  - [#594](https://github.com/RedisJSON/RedisJSON/pull/594) Support for `MEMORY USAGE` and memory info in `JSON.DEBUG` (MOD- 2079)
+
+- Bug fixes:
+
+  - [#646](https://github.com/RedisJSON/RedisJSON/pull/646), [#644](https://github.com/RedisJSON/RedisJSON/pull/644) Do not fail `JSON.MGET` on wrong/unregistered key type (MOD-2511)
+  - [#643](https://github.com/RedisJSON/RedisJSON/pull/643) Null-terminate JSON string in `rdb_save`
+  - [#591](https://github.com/RedisJSON/RedisJSON/pull/591) Avoid crash on overflow in `JSON.NUMINCRBY` or `JSON.NUMMULTBY` (MOD-2513)
+  - [#593](https://github.com/RedisJSON/RedisJSON/pull/593) Return no updates when performing `JSON.SET` with `NX` to an existing array element (MOD-2512)
+
+## v2.0.6 (December 2021)
+
+This is a maintenance release for RedisJSON 2.0.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+This patch neutralizes the increased memory consumption from v1 to v2.
+
+Details:
+
+- Improvements:
+
+  - [#563](https://github.com/RedisJSON/RedisJSON/pull/563) Introduction of [ijson](https://libraries.io/cargo/ijson).
+
+## v2.0.5 (December 2021)
+
+This is a maintenance release for RedisJSON 2.0.
+
+Details:
+
+- Bug fixes:
+  - #[553](https://github.com/RedisJSON/RedisJSON/pull/553) Return an empty array on a nonexistent path
+  - #[548](https://github.com/RedisJSON/RedisJSON/pull/548) Align error handling behavior
+  - #[546](https://github.com/RedisJSON/RedisJSON/pull/546) #[545](https://github.com/RedisJSON/RedisJSON/pull/545) Fix key location in `JSON.DEBUG MEMORY`
+
+## v2.0.4 (November 2021)
+
+This is the General Availability release of RedisJSON 2.0.
+
+### Headlines
+
+RedisJSON is a [high-performance JSON document store](https://redis.com/blog/redisjson-public-preview-performance-benchmarking/) that allows developers to build modern applications. It stores and processes JSON in-memory, supporting millions of operations per second with sub-millisecond response times. The combination of `RediSearch`, native indexing, querying, and full-text search of JSON documents allows developers to create secondary indexes and query data at lightning speed.
+
+#### Indexing JSON documents
+
+Using [RediSearch](https://redisearch.io), it is now possible to [index, query, and search JSON documents]({{<relref "/develop/interact/search-and-query/indexing">}}), gaining full-text search capabilities and document retrieving based on their content.
+
+To do so, you must install both modules, `RedisJSON` and `RediSearch`, on the same database.
+
+#### Support of JSON Path
+
+The commands [support JSONPath]({{<relref "/develop/data-types/json/path">}}) as specified in the [original specifications](https://goessner.net/articles/JsonPath).
+
+The legacy path syntax is still supported.
+
+#### Commands operate on multiple paths
+
+A `JSONPath` query may resolve to several paths. Every command supports multiple paths and applies the operation to all the encountered paths.
+
+Notice that the output of the commands evolved to provide multiple results according to the number of paths impacted. 
+
+### Details
+
+- Enhancements
+  - #[477](https://github.com/RedisJSON/RedisJSON/pull/477) Support of Multipath
+  - #[336](https://github.com/RedisJSON/RedisJSON/pull/336) Added generic JSON path implementation 
+  - #[525](https://github.com/RedisJSON/RedisJSON/pull/525) Error messages prefixed with ERR or WRONGTYPE 
+  - #[490](https://github.com/RedisJSON/RedisJSON/pull/490) Performance: Discard `to_value` method
+  - #[426](https://github.com/RedisJSON/RedisJSON/pull/426) Move from next_string to next_str 
+  - #[464](https://github.com/RedisJSON/RedisJSON/pull/464) Initial RedisJSON commands.json file 
+  - #[488](https://github.com/RedisJSON/RedisJSON/pull/488) Docker with RediSearch revisited 
+
+- Bug fixes
+  - #[515](https://github.com/RedisJSON/RedisJSON/pull/515) JSON.DEL count deleted null value 
+  - #[499](https://github.com/RedisJSON/RedisJSON/pull/499) Avoid crash in ARRTRIM 
+  - #[458](https://github.com/RedisJSON/RedisJSON/pull/458) Docker/Debian: moved from Buster to Bullseye 
+  - #[397](https://github.com/RedisJSON/RedisJSON/pull/397) Support RDB Short Read in RedisJSON (a.k.a diskless-load) 
+  - #[398](https://github.com/RedisJSON/RedisJSON/pull/398) Avoid path clone when not needed 
+  - #[416](https://github.com/RedisJSON/RedisJSON/pull/416) Add testGetWithBracketNotation
+---
+Title: RedisJSON release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisJSON release notes for version 2.8 and earlier
+hideListLinks: true
+linkTitle: RedisJSON
+tags:
+- visible
+weight: 30
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: RedisJSON 2.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Low-level API changes in order to support the multi-value indexing and
+  querying support that comes with RediSearch 2.6. RediSearch 2.6 comes with multi-value
+  indexing and querying of attributes for any attribute type (Text, Tag, Numeric,
+  Geo and Vector) defined by a JSONPath leading to an array or to multiple scalar
+  values.
+linkTitle: v2.4 (November 2022)
+min-version-db: 6.0.16
+min-version-rs: 6.2.18
+weight: 97
+---
+## Requirements
+
+RedisJSON v2.4.12 requires:
+
+- Minimum Redis compatibility version (database): 6.0.16
+- Minimum Redis Enterprise Software version (cluster): 6.2.18
+
+## v2.4.12 (April 2025)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+Improvements:
+- [#1335](https://github.com/redisjson/redisjson/pull/1335) Added support for Azure Linux 3 (MOD-9172)
+
+## v2.4.11 (January 2025)
+
+This is a maintenance release for RedisJSON 2.4
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details
+
+- Bug fixes:
+  - [#1313](https://github.com/redisjson/redisjson/pull/1313) (Redis Enterprise A-A only) Potential crash on `JSON.DEBUG MEMORY` (MOD-8412)
+
+- Improvements:
+  - [#1310](https://github.com/redisjson/redisjson/pull/1310) Added support for Ubuntu 22 and macOS 13 and 14
+
+## v2.4.9 (April 2024)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#1192](https://github.com/RedisJSON/RedisJSON/pull/1192) Crashes with numeric values greater than i64::MAX (MOD-6501, MOD-4551, MOD-4856, MOD-5714)
+  - HDT#228 (Redis Enterprise A-A only) Incorrect error when processing escaped characters (MOD-6645)
+
+## v2.4.8 (January 2024)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+{{<note>}}
+Ubuntu 16.04 and RHEL 7 are no longer supported as of v2.4.8.
+{{</note>}}
+
+Details:
+
+- Improvements:
+
+  - [#1149](https://github.com/RedisJSON/RedisJSON/pull/1149) Added support for CBL-Mariner 2
+
+- Bug fixes:
+
+  - [#1025](https://github.com/RedisJSON/RedisJSON/pull/1025) `JSON.TOGGLE` - missing keyspace notification
+
+## v2.4.7 (April 2023)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#947](https://github.com/RedisJSON/RedisJSON/issues/947) Crash when using array slice operator (`[start:end:step]`) with step `0`
+
+## v2.4.6 (March 2023)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#912](https://github.com/RedisJSON/RedisJSON/pull/912) Fix actual memory usage calculation (MOD-4787) 
+
+## v2.4.5 (February 2023)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+  - Adds support to Redis Enterprise on Ubuntu Linux 20.04 LTS (Focal Fossa)
+
+## v2.4.4 (February 2023)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#919](https://github.com/RedisJSON/RedisJSON/pull/919) Possible failure loading RDB files (MOD-4822)
+  
+- Improvements:
+
+  - [#725](https://github.com/RedisJSON/RedisJSON/issues/725) Improve error messages
+  - [#918](https://github.com/RedisJSON/RedisJSON/pull/918) Add IPv6 to the capabilities list
+
+## v2.4.3 (December 2022)
+
+This is a maintenance release for RedisJSON 2.4.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#890](https://github.com/RedisJSON/RedisJSON/pull/890) JSONPath ignores any filter condition beyond the second (MOD-4602)
+  
+- Improvements:
+
+  - [#892](https://github.com/RedisJSON/RedisJSON/pull/892) Allow `JSON.ARRINDEX` with nonscalar values
+
+## v2.4 GA (v2.4.2) (November 2022)
+
+This is the General Availability release of RedisJSON 2.4.
+
+### Highlights
+
+RedisJSON 2.4 contains several low-level API changes in order to support the multi-value indexing and querying support that comes with RediSearch 2.6. RediSearch 2.6 comes with multi-value indexing and querying of attributes for any attribute type (Text, Tag, Numeric, Geo and Vector) defined by a JSONPath leading to an array or to multiple scalar values.
+
+### What's new in 2.4
+
+- Features:
+
+  - [#848](https://github.com/RedisJSON/RedisJSON/pull/848) Add JSONPath filter the regexp match operator (MOD-4432)
+  - [#861](https://github.com/RedisJSON/RedisJSON/pull/861) Support legacy JSONPath with the dollar sign $ (MOD-4436)
+
+- Performance enhancements:
+
+  - [#699](https://github.com/RedisJSON/RedisJSON/pull/699) A new JSONPath library which enhances the performance of parsing any JSONPath expression in RedisJSON.
+
+- Changing behaviour:
+
+  - [#699](https://github.com/RedisJSON/RedisJSON/pull/699) Floating point numbers which become round numbers due to some operation, such as `JSON.NUMINCRBY`, will now return as a floating point with a trailing `.0`, e.g., instead of just `42`, now `42.0` will be returned.
+
+- Bugs fixes (since 2.4-RC1/ v2.4.0):
+
+  - [#850](https://github.com/RedisJSON/RedisJSON/pull/850) Allow repetition of filter relation instead of optional (MOD-4431)
+
+---
+Title: RedisJSON 1.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Serialization cache for JSON.GET.
+linkTitle: v1.0 (December 2017)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 100
+---
+## Requirements
+
+RedisJSON v1.0.8 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v1.0.8 (August 2021)
+
+This is a maintenance release for version 1.0.
+
+Update urgency: `LOW` -  No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Enhancements:
+    - #[257](https://github.com/redisjson/redisjson/issues/257) Support inter shards TLS capability
+
+- Bug fixes:
+   - #[282](https://github.com/redisjson/redisjson/issues/282) Change `JSON.DEBUG` first key index to 2
+
+
+## v1.0.7 (December 2020)
+
+This is a maintenance release for version 1.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- [#222](https://github.com/RedisJSON/RedisJSON/pull/222) Validate path is not empty.
+- [#253](https://github.com/RedisJSON/RedisJSON/pull/253) `NULL` de-reference after error.
+
+## v1.0.5 (September 2020)
+
+This is a maintenance release for version 1.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Enhancements:
+    - Republish docker image based on Redis 6
+- Bugfixes:
+    - #[200](https://github.com/RedisJSON/RedisJSON/issues/200) Following a call to JSON.ARRPOP and JSON.STRAPPEND, the LRU cache should be invalidated.
+
+## v1.0.4 (February 2019)
+
+This release updates the version to 1.0.4.
+
+## v1.0.3 (12 September 2018)
+
+This release disables the cache by default, and allows an explicit `CACHE` `<ON|OFF>` module argument to enable it.
+
+## v1.0.2 (10 September 2018)
+
+This release contains some bug fixes over 1.0.2. It also includes some ci changes as well.
+
+## v1.0.1 (December 2017)
+
+This version provides a serialization cache for JSON.GET (when used with the
+default parameters). The cache policy is LRU (last recently used), and extremely
+small items are not cached.
+
+In the future, options may be added to configure the cache, but for the time being
+the cache is intended to be small and transparent.
+---
+Title: RedisGraph 2.8 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Introduces multi-labeled nodes, indexes over relationship properties,
+  and additional expressivity (Cypher construct, functions, and operators). Major
+  performance enhancements. Many bug fixes.
+linkTitle: v2.8 (February 2022)
+min-version-db: 6.2.0
+min-version-rs: 6.2.8
+weight: 95
+---
+## Requirements
+
+RedisGraph v2.8.26 requires:
+
+- Minimum Redis compatibility version (database): 6.2.0
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v2.8.26 (March 2023)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2880](https://github.com/RedisGraph/RedisGraph/issues/2880) Potential crash when using WITH * expressions
+  - [#2917](https://github.com/RedisGraph/RedisGraph/issues/2917) Potential crash when using CASE expressions (MOD-4873)
+  - [#2836](https://github.com/RedisGraph/RedisGraph/issues/2836) Potential crash on *0 variable-length path (MOD-4817)
+  - [#2916](https://github.com/RedisGraph/RedisGraph/issues/2916) Potential crash when executing concurrent queries that utilize full-text indices (MOD-4818)
+
+
+## v2.8.25 (February 2023)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#2890](https://github.com/RedisGraph/RedisGraph/issues/2890) Potential wrong results on variable-length path
+
+## v2.8.24 (February 2023)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2777](https://github.com/RedisGraph/RedisGraph/issues/2777), [#2841](https://github.com/RedisGraph/RedisGraph/issues/2841) Potential crash when sending queries from multiple connections and timeout is not 0
+  - [#2844](https://github.com/RedisGraph/RedisGraph/issues/2844) Potential partial results when same parametrized query is running from multiple connections
+  - [#2739](https://github.com/RedisGraph/RedisGraph/issues/2739), [#2774](https://github.com/RedisGraph/RedisGraph/issues/2774) Paths with exact variable length >1 are not matched
+
+- Improvements:
+
+  - [#2758](https://github.com/RedisGraph/RedisGraph/pull/2758) Improved edge deletion performance
+
+
+## v2.8.21 (January 2023)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2754](https://github.com/RedisGraph/RedisGraph/pull/2754) Partial sync may hang (MOD-4594)
+    - [#2695](https://github.com/RedisGraph/RedisGraph/pull/2695) Potential crash on certain write queries (MOD-4286, MOD-4545)
+    - [#2637](https://github.com/RedisGraph/RedisGraph/issues/2637), [#2460](https://github.com/RedisGraph/RedisGraph/issues/2460), [#2680](https://github.com/RedisGraph/RedisGraph/issues/2680) Crash on invalid queries
+    - [#2484](https://github.com/RedisGraph/RedisGraph/issues/2484) Indexes can be created on invalid property names
+    - [#2672](https://github.com/RedisGraph/RedisGraph/issues/2672) Wrong matching result on multiple labels
+    - [#2643](https://github.com/RedisGraph/RedisGraph/issues/2643) Duplicate reports when matching relationship type `:R|R`
+    - [#2687](https://github.com/RedisGraph/RedisGraph/issues/2687), [#2414](https://github.com/RedisGraph/RedisGraph/issues/2414) Error when `UNWIND`ing relationships
+    - [#2635](https://github.com/RedisGraph/RedisGraph/issues/2635) Cannot `UNWIND` an expression that is not a list
+    - [#2636](https://github.com/RedisGraph/RedisGraph/issues/2636) `MERGE` ... `ON` ... - cannot remove a property by setting it to null
+
+- Improvements:
+
+    - [#2790](https://github.com/RedisGraph/RedisGraph/pull/2790) Improved performance by disabling SuiteSparse:GraphBLAS' global free pool
+    - [#2757](https://github.com/RedisGraph/RedisGraph/pull/2757) Improved performance of `indegree` and `outdegree`
+    - [#2740](https://github.com/RedisGraph/RedisGraph/issues/2740) Don’t show partial results for timed out `GRAPH.PROFILE`
+
+## v2.8.20 (September 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#2591](https://github.com/RedisGraph/RedisGraph/issues/2591) Potential crash trying to utilize a nonexistent index
+    - [#2558](https://github.com/RedisGraph/RedisGraph/issues/2558) Multi-relationship properties created before index creation are not indexed
+    - [#2571](https://github.com/RedisGraph/RedisGraph/issues/2571) `min` and `max` return wrong results when the argument is an array
+    - [#2587](https://github.com/RedisGraph/RedisGraph/issues/2587) Some queries generate a "forced unlocking commit flow" warning
+
+- Improvements:
+
+    - [#2533](https://github.com/RedisGraph/RedisGraph/issues/2533) Graph slow log can be reset with `GRAPH.SLOWLOG g RESET`
+
+## v2.8.19 (August 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#2517](https://github.com/RedisGraph/RedisGraph/issues/2517) Crash on invalid `REDUCE` queries
+    - [#2525](https://github.com/RedisGraph/RedisGraph/issues/2525) `toJSON` - node labels are not separated with a comma (`,`)
+    - [#2467](https://github.com/RedisGraph/RedisGraph/issues/2467) Possibly wrong results when using a variable named `anon_N`
+    - [#2522](https://github.com/RedisGraph/RedisGraph/pull/2522) Deleting an edge index leaves traces
+    - [#2477](https://github.com/RedisGraph/RedisGraph/issues/2477) Cannot extract the latitude or the longitude of a point
+
+- Improvements:
+
+    - [#2519](https://github.com/RedisGraph/RedisGraph/pull/2519) When a query is cached and then a relevant index is created, recalculate the execution plan
+
+## v2.8.17 (July 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2499](https://github.com/RedisGraph/RedisGraph/pull/2499) Potential crash with concurrent connections due to missing lock - additional fixes
+    - [#2424](https://github.com/RedisGraph/RedisGraph/issues/2424) Potential crash when using `ORDER BY`
+    - [#2491](https://github.com/RedisGraph/RedisGraph/issues/2491) Whitespaces between `MATCH` terms can render the query invalid
+
+## v2.8.16 (July 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2478](https://github.com/RedisGraph/RedisGraph/pull/2478) Potential crash with concurrent connections due to missing lock
+    - [#2370](https://github.com/RedisGraph/RedisGraph/issues/2370) Potential crash / wrong results / warning messages when using edge indexes
+    - [#2473](https://github.com/RedisGraph/RedisGraph/issues/2473) Crash on invalid `distance()` query with index
+
+## v2.8.15 (June 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2241](https://github.com/RedisGraph/RedisGraph/issues/2241) Possible crash on queries with `MERGE` operation in a Cartesian product (MOD-3500)
+    - [#2394](https://github.com/RedisGraph/RedisGraph/issues/2394) Possible crash when freeing an index immediately after its creation
+
+## v2.8.14 (June 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Features:
+
+    - [#2403](https://github.com/RedisGraph/RedisGraph/pull/2403) Introduce `toFloat` function
+    - [#2365](https://github.com/RedisGraph/RedisGraph/issues/2365) Commands that don't execute on the main thread now also appear in [SLOWLOG]({{< relref "/commands/slowlog" >}})
+
+- Bug fixes:
+
+    - [#2381](https://github.com/RedisGraph/RedisGraph/pull/2381) Rare data corruption on data encoding
+    - [#2393](https://github.com/RedisGraph/RedisGraph/issues/2393), [#2395](https://github.com/RedisGraph/RedisGraph/issues/2395) Crash when searching an index for a runtime-determined value
+    - [#2377](https://github.com/RedisGraph/RedisGraph/issues/2377) Crash on `INT_MIN % -1`
+    - [#2390](https://github.com/RedisGraph/RedisGraph/issues/2390) Crash on distance filter
+    - [#2407](https://github.com/RedisGraph/RedisGraph/issues/2407) Crash on double to string
+    - [#2422](https://github.com/RedisGraph/RedisGraph/pull/2422) `toJSON` returned floating points cropped to 6 decimals
+
+{{<note>}}
+New RDB version (v12). RDB files created with v2.8.14 or later are not backward compatible.
+{{</note>}}
+
+## v2.8.13 (May 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2351](https://github.com/RedisGraph/RedisGraph/pull/2351) Potential memory leak on query timeout
+    - [#2348](https://github.com/RedisGraph/RedisGraph/issues/2348) Crash when converting certain Cypher queries to RediSearch queries
+    - [#2331](https://github.com/RedisGraph/RedisGraph/pull/2331) Two memory leaks (one on failed RDB loading, one on certain invalid queries)
+    - [#2328](https://github.com/RedisGraph/RedisGraph/pull/2328), [#2306](https://github.com/RedisGraph/RedisGraph/issues/2306), [#2307](https://github.com/RedisGraph/RedisGraph/issues/2307), [#2326](https://github.com/RedisGraph/RedisGraph/issues/2326) Disallow redeclaration of variables; fixed false redeclaration errors
+    - [#2363](https://github.com/RedisGraph/RedisGraph/pull/2363) Nodes were sometimes created with more labels than those specified
+
+## v2.8.12 (May 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2278](https://github.com/RedisGraph/RedisGraph/issues/2278), [#2301](https://github.com/RedisGraph/RedisGraph/pull/2301) Potential crash on bulk update
+    - [#2262](https://github.com/RedisGraph/RedisGraph/issues/2262), [#2271](https://github.com/RedisGraph/RedisGraph/issues/2271), [#2272](https://github.com/RedisGraph/RedisGraph/issues/2272), [#2273](https://github.com/RedisGraph/RedisGraph/issues/2273), [#2282](https://github.com/RedisGraph/RedisGraph/issues/2282), [#2288](https://github.com/RedisGraph/RedisGraph/issues/2288), [#2299](https://github.com/RedisGraph/RedisGraph/issues/2299), [#2312](https://github.com/RedisGraph/RedisGraph/issues/2312), [#2321](https://github.com/RedisGraph/RedisGraph/issues/2321), [#2325](https://github.com/RedisGraph/RedisGraph/issues/2325), [#2323](https://github.com/RedisGraph/RedisGraph/issues/2323) Potential crash on certain queries
+    - [#1441](https://github.com/RedisGraph/RedisGraph/issues/1441) Query returns wrong result: projection before Cartesian product causes only one result to be returned
+    - [#2298](https://github.com/RedisGraph/RedisGraph/issues/2298) Query returns wrong result: wrong value when fetching a string property from a map
+    - [#2318](https://github.com/RedisGraph/RedisGraph/pull/2318) Memory leak
+
+{{<note>}}
+Duplicate column names in a query are no longer valid. For example, the query `GRAPH.QUERY g "MATCH (e) RETURN e, e"` is not valid. If you need to return the same column twice, you can rewrite the query as `GRAPH.QUERY g "MATCH (e) RETURN e, e as e2"`.
+{{</note>}}
+
+## v2.8.11 (March 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+    - [#2259](https://github.com/RedisGraph/RedisGraph/issues/2259), [#2258](https://github.com/RedisGraph/RedisGraph/pull/2258) Fix memory leak and potential crash on [RDB]({{< relref "/operate/oss_and_stack/management/persistence" >}}) saving
+
+## v2.8.10 (March 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details: 
+
+- Features:
+
+    - [#2245](https://github.com/RedisGraph/RedisGraph/pull/2245) Support graphs [eviction]({{< relref "/develop/reference/eviction" >}})
+
+- Bug fixes:
+
+    - [#1493](https://github.com/RedisGraph/RedisGraph/issues/1493), [#2240](https://github.com/RedisGraph/RedisGraph/pull/2240) Fixed crash on certain queries
+    - [#2229](https://github.com/RedisGraph/RedisGraph/issues/2229), [#2222](https://github.com/RedisGraph/RedisGraph/pull/2222) Fixed crash on certain queries
+    - [#2209](https://github.com/RedisGraph/RedisGraph/issues/2209), [#2228](https://github.com/RedisGraph/RedisGraph/pull/2228) Fixed crash on certain invalid `DELETE` queries
+    - [#2237](https://github.com/RedisGraph/RedisGraph/issues/2237), [#2242](https://github.com/RedisGraph/RedisGraph/pull/2242) Fixed crash on certain `PROFILE` queries
+    - [#2230](https://github.com/RedisGraph/RedisGraph/issues/2230), [#2232](https://github.com/RedisGraph/RedisGraph/pull/2232) Fixed wrong number of reported deleted relationships on certain queries
+    - [#2233](https://github.com/RedisGraph/RedisGraph/pull/2233) Certain valid queries were reported invalid
+    - [#2246](https://github.com/RedisGraph/RedisGraph/issues/2246) Fixed memory leaks
+
+- Improvements:
+
+    - [#2235](https://github.com/RedisGraph/RedisGraph/pull/2235) Improved [RDB]({{< relref "/operate/oss_and_stack/management/persistence" >}}) loading performance
+
+## v2.8.9 (March 2022)
+
+This is a maintenance release for RedisGraph 2.8.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details: 
+
+- Features:
+
+    - [#2181](https://github.com/RedisGraph/RedisGraph/pull/2181), [#2182](https://github.com/RedisGraph/RedisGraph/pull/2182) Full support for ARM builds
+
+- Bug fixes:
+
+    - [#2167](https://github.com/RedisGraph/RedisGraph/pull/2167) Fixed a potential crash: filter placement in `OPTIONAL` subtrees
+    - [#2176](https://github.com/RedisGraph/RedisGraph/pull/2176) Fixed a potential crash: invalid memory access in nested `DISTINCT` functions
+    - [#2217](https://github.com/RedisGraph/RedisGraph/pull/2217) Fixed a potential crash: memory access after free on `FLUSHALL`
+    - [#2207](https://github.com/RedisGraph/RedisGraph/pull/2207) Fixed memory leak when `MAX_QUEUED_QUERIES` is used
+    - [#2220](https://github.com/RedisGraph/RedisGraph/pull/2220) `WITH * WHERE` - the `WHERE` filters were ignored
+    - [#2151](https://github.com/RedisGraph/RedisGraph/pull/2151) Return correct results for aggregations with no inputs
+    - [#2163](https://github.com/RedisGraph/RedisGraph/pull/2163) Emit error correctly on multi-query inputs
+
+- Improvements:
+
+    - [#2173](https://github.com/RedisGraph/RedisGraph/pull/2173) Improve performance of breadth-first search
+
+## v2.8 GA (v2.8.8) (February 2022)
+
+This is the General Availability release of RedisGraph 2.8.
+
+### Highlights
+
+RedisGraph 2.8 introduces multi-labeled nodes, indexes over relationship properties, additional expressivity (construct, functions, and operators), major performance enhancements, and many bug fixes.
+
+#### What's new in 2.8
+
+- Multi-labeled nodes
+
+    {{<note>}}
+The `labels` function's signature has changed. The function now returns a list of labels instead of a single label.
+<br /><br />
+If you are using this function and upgrading to RedisGraph 2.8, a simple fix is to replace any call to `labels(x)` with `labels(x)[0]`. This returns the first label associated with node `x`. For uni-labeled nodes, the result in RedisGraph 2.8 is similar to the results of `labels(x)` in RedisGraph 2.4.
+    {{</note>}}
+  
+- Indexes over relationship properties
+- Enhanced full-text search
+- Delta matrices: node and relationships additions and deletions are much faster, as they are first updated in small delta matrices. The main matrices are then bulk-updated.
+- Additional Cypher construct, functions, and operators
+- RediSearch 2.2.7
+- [SuiteSparse](https://github.com/DrTimothyAldenDavis/GraphBLAS) (GraphBLAS) 6.0.0
+
+### Details
+
+- Features (since 2.8-M02):
+
+    - [#2109](https://github.com/RedisGraph/RedisGraph/pull/2109) Introduce `allShortestPaths` BFS function
+    - [#2099](https://github.com/RedisGraph/RedisGraph/pull/2099) Introduce `keys` function
+    - [#2047](https://github.com/RedisGraph/RedisGraph/pull/2047) Introduce `reduce` function
+    - [#2076](https://github.com/RedisGraph/RedisGraph/pull/2076) Introduce XOR operation in filter trees
+    - [#2088](https://github.com/RedisGraph/RedisGraph/pull/2088) Introduce pattern comprehensions
+    - [#2051](https://github.com/RedisGraph/RedisGraph/pull/2051) Allow copying of entity attribute sets in `SET` clauses
+    - [#2067](https://github.com/RedisGraph/RedisGraph/pull/2067) Allow modification of virtual key entity count (`VKEY_MAX_ENTITY_COUNT`) at runtime
+    - [#2102](https://github.com/RedisGraph/RedisGraph/pull/2102) New load time configuration option `NODE_CREATION_BUFFER` - see [documentation](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#node_creation_buffer) (MOD-2348)
+    - [#2049](https://github.com/RedisGraph/RedisGraph/pull/2049) RediSearch supports field definitions
+
+- Performance improvements (since 2.8-M02):
+
+    - [#2097](https://github.com/RedisGraph/RedisGraph/pull/2097) Locks favor writers to prevent write exhaustion
+    - [#1945](https://github.com/RedisGraph/RedisGraph/pull/1945) Track node count per label in graph statistics
+    - [#1872](https://github.com/RedisGraph/RedisGraph/pull/1872) Delta matrices are always [hypersparse](https://fossies.org/linux/SuiteSparse/GraphBLAS/docs/graphblas_demo.html#40)
+    - [#1871](https://github.com/RedisGraph/RedisGraph/pull/1871) Matrix sync policies reduce the number of syncs required
+    - [#1869](https://github.com/RedisGraph/RedisGraph/pull/1869) Transposed matrices are always boolean
+    - [#2101](https://github.com/RedisGraph/RedisGraph/pull/2101) Entity annotation has been replaced with an AST `toString` function
+    - [#1878](https://github.com/RedisGraph/RedisGraph/pull/1878) Slowlog queries no longer create graphs
+    - [#2067](https://github.com/RedisGraph/RedisGraph/pull/2067) Index graph entities incrementally on restore
+    - Faster AOF recovery (PM-1252)
+
+- Bug fixes (since 2.8-M02):
+
+    - [#2016](https://github.com/RedisGraph/RedisGraph/pull/2016) Implement new BFS algorithm
+    - [#2105](https://github.com/RedisGraph/RedisGraph/pull/2105) Creating a node with multiple properties using the same key only accepts the last value
+    - [#2055](https://github.com/RedisGraph/RedisGraph/pull/2055) Avoid arithmetic overflow in `avg` function
+    - [#2048](https://github.com/RedisGraph/RedisGraph/pull/2048) Modulo by zero emits division by zero error
+    - [#2020](https://github.com/RedisGraph/RedisGraph/pull/2020) Fix evaluation of variable-length edges in expression ordering
+    - [#2028](https://github.com/RedisGraph/RedisGraph/pull/2028) Fix utilization of record offset in procedure calls, refactor outputs
+    - [#2014](https://github.com/RedisGraph/RedisGraph/pull/2014) Update label for every node in the AST
+    - [#2002](https://github.com/RedisGraph/RedisGraph/pull/2002) Fix crash in index utilization using wrong query_graph
+    - [#1976](https://github.com/RedisGraph/RedisGraph/pull/1976) Use operand matrix when available
+    - [#1973](https://github.com/RedisGraph/RedisGraph/pull/1973) Emit error on a query that only contains parameters
+    - [#1950](https://github.com/RedisGraph/RedisGraph/pull/1950) Print ExecutionPlan in `GRAPH.EXPLAIN` only if no errors are encountered in the construction
+    - [#1933](https://github.com/RedisGraph/RedisGraph/pull/1933) Free thread-local data on graph deletion
+    - [#1942](https://github.com/RedisGraph/RedisGraph/pull/1942) Fix dimensions of transposed delta matrices
+    - [#1940](https://github.com/RedisGraph/RedisGraph/pull/1940) Do not use block client if deny blocking is specified
+    - [#1898](https://github.com/RedisGraph/RedisGraph/pull/1898) Error when setting a property to an array containing an invalid type
+    - [#1931](https://github.com/RedisGraph/RedisGraph/pull/1931) Sync matrices on parent process before serialization fork
+    - [#1897](https://github.com/RedisGraph/RedisGraph/pull/1897) Aliases in `WITH` ... `ORDER BY` must be valid references
+    - [#1913](https://github.com/RedisGraph/RedisGraph/pull/1913) Update thread-local AST for every cloned operation
+    - [#1915](https://github.com/RedisGraph/RedisGraph/pull/1915) Validate function references in parameters
+    - [#1911](https://github.com/RedisGraph/RedisGraph/pull/1911) Refactor `cron` task for managing query timeouts
+    - [#1902](https://github.com/RedisGraph/RedisGraph/pull/1902) Fix incorrect behavior on `NULL` values in `CASE`...`WHEN` expressions
+    - [#1904](https://github.com/RedisGraph/RedisGraph/pull/1904) Allow reconfiguring query timeout to 0
+    - [#1888](https://github.com/RedisGraph/RedisGraph/pull/1888) Synchronize matrices on creation in RDB load
+    - [#1892](https://github.com/RedisGraph/RedisGraph/pull/1892) Validate values specified in `SET` clauses
+    - [#1889](https://github.com/RedisGraph/RedisGraph/pull/1889) Tuple iterator now updates properly when changing matrix to serialize
+    - [#1870](https://github.com/RedisGraph/RedisGraph/pull/1870) Fix crash in `range` function
+    - [#2125](https://github.com/RedisGraph/RedisGraph/issues/2125) Fix crash on `UNION` ... `RETURN` * queries (MOD-2524)
+    - [#2043](https://github.com/RedisGraph/RedisGraph/pull/2043) Avoid serialization of duplicate graph keys
+    - [#2067](https://github.com/RedisGraph/RedisGraph/pull/2067) Numeric indices no longer lose precision on very large values
+    - [#2072](https://github.com/RedisGraph/RedisGraph/issues/2072), [#2081](https://github.com/RedisGraph/RedisGraph/pull/2081) CRLF sequences embedded in strings no longer trigger a protocol error when being emitted
+    - [#2139](https://github.com/RedisGraph/RedisGraph/pull/2139) Fix crash when trying to retrieve an out-of-bounds item
+    - [#2149](https://github.com/RedisGraph/RedisGraph/pull/2149) Fix crash when matching a node engages an index to search for a value that is a RediSearch stop word
+---
+Title: RedisGraph 1.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Support multiple relationships of the same type R connecting two nodes.
+  Lexer elides escape characters in string creation. Performance improvements.
+linkTitle: v1.2 (April 2019)
+min-version-db: 4.0.0
+min-version-rs: 5.0.0
+weight: 99
+---
+## Requirements
+
+RedisGraph v1.2.2 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v1.2.2 (May 2019)
+
+Update urgency: Medium
+This is a maintenance release for version 1.2.
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+## v1.2.0 (April 2019)
+
+This is a major release for RedisGraph.
+Compared to previous release 1.0.15:
+
+- Added functionality
+    - #[452](https://github.com/RedisGraph/RedisGraph/issues/452) Support multiple relationships of the same type R connecting two nodes
+    - #[392](https://github.com/RedisGraph/RedisGraph/issues/392) Lexer elides escape characters in string creation: support for property values with `'` or `"`
+- Performance improvements
+    - #[442](https://github.com/RedisGraph/RedisGraph/issues/442) Seek graph entity by id: `MATCH (n) WHERE ID(n) = 5 RETURN n`
+    - #[422](https://github.com/RedisGraph/RedisGraph/issues/422) `MATCH (n) RETURN COUNT(n)` is now O(1)
+    - #[421](https://github.com/RedisGraph/RedisGraph/issues/421) and #[459](https://github.com/RedisGraph/RedisGraph/issues/459) Lazy loading of matrices on subsequent writes of relationships and nodes
+    - #[399](https://github.com/RedisGraph/RedisGraph/issues/399) Single transpose of matrices
+- Minor Bugfixes:
+    - #[456](https://github.com/RedisGraph/RedisGraph/issues/456) Memory leaks
+    - #[439](https://github.com/RedisGraph/RedisGraph/issues/439) When label doesn't exists, the node count should return 0 #[439](https://github.com/RedisGraph/RedisGraph/issues/439)
+    - #[435](https://github.com/RedisGraph/RedisGraph/issues/435) Referencing non existing properties #[435](https://github.com/RedisGraph/RedisGraph/issues/435)
+
+Compared to 1.0:
+
+- Added functionality
+    - #[390](https://github.com/RedisGraph/RedisGraph/issues/390) GraphBLAS 2.3.0 [release notes](https://github.com/RedisLabsModules/RedisGraph/pull/390#issuecomment-470620353)
+    - #[452](https://github.com/RedisGraph/RedisGraph/issues/452) Support multiple relationships of the same type R connecting two nodes
+    - #[392](https://github.com/RedisGraph/RedisGraph/issues/392) Lexer elides escape characters in string creation: support for property values with ' or "
+    - Enhanced cypher
+        - Initial support for WITH clause: Allows query parts to be chained together, piping the results from one to be used as starting points or criteria of the next. [ref p.78](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)
+        - #[247](https://github.com/RedisGraph/RedisGraph/issues/247) Initial support for UNWIND
+        - #[244](https://github.com/RedisGraph/RedisGraph/issues/244) RETURN * (give me everything bro)
+        - #[236](https://github.com/RedisGraph/RedisGraph/issues/236) TYPE function (returns the type of a relationship)
+        - #[288](https://github.com/RedisGraph/RedisGraph/issues/288) Querying patterns where a relationship between two nodes can be of different types. ()-[:A|:B]->()
+        - #[252](https://github.com/RedisGraph/RedisGraph/issues/252) Multiple MATCH clauses
+        - #[327](https://github.com/RedisGraph/RedisGraph/issues/327) Multiple CREATE clauses
+        - #[305](https://github.com/RedisGraph/RedisGraph/issues/305) MERGE + SET
+        - #[348](https://github.com/RedisGraph/RedisGraph/issues/348) Smaller memory footprint - encode properties
+    - [Faster and better bulk loading](https://github.com/RedisGraph/redisgraph-bulk-loader)
+- Performance improvements
+    - #[442](https://github.com/RedisGraph/RedisGraph/issues/442) Seek graph entity by id: MATCH (n) WHERE ID(n) = 5 RETURN n
+    - #[422](https://github.com/RedisGraph/RedisGraph/issues/422) MATCH (n) RETURN COUNT(n) is now O(1)
+    - #[421](https://github.com/RedisGraph/RedisGraph/issues/421) and #[459](https://github.com/RedisGraph/RedisGraph/issues/459) Lazy loading of matrices on subsequent writes of relationships and nodes
+    - #[399](https://github.com/RedisGraph/RedisGraph/issues/399) Single transpose of matrices
+    - #[393](https://github.com/RedisGraph/RedisGraph/issues/393) Discard distinct when performing aggregation
+    - #[289](https://github.com/RedisGraph/RedisGraph/issues/289) Index utilization when performing Cartesian product
+    - #[308](https://github.com/RedisGraph/RedisGraph/issues/308) Granular writer locking
+- Most noticeable bugfixes
+    - #[456](https://github.com/RedisGraph/RedisGraph/issues/456) Memory leaks
+    - #[439](https://github.com/RedisGraph/RedisGraph/issues/439) When label doesn't exists, the node count should return 0
+    - #[435](https://github.com/RedisGraph/RedisGraph/issues/435) Referencing non existing properties
+    - #[359](https://github.com/RedisGraph/RedisGraph/issues/359) Adding ORDER BY changes the number of returned hits when used in combination with LIMIT
+    - #[363](https://github.com/RedisGraph/RedisGraph/issues/363) Remove graph entity property when it is set to null
+    - #[386](https://github.com/RedisGraph/RedisGraph/issues/386) Return updated values on queries that modify data
+    - #[249](https://github.com/RedisGraph/RedisGraph/issues/249) reset operation within execution plan should propagate upwards
+    - #[259](https://github.com/RedisGraph/RedisGraph/issues/259) Replace operations appropriately when rewriting execution plan
+    - #[262](https://github.com/RedisGraph/RedisGraph/issues/262) Entity returned from datablock should have its internals cleared
+    - #[264](https://github.com/RedisGraph/RedisGraph/issues/264) Loaded triemap strings are not guaranteed space for a null terminator
+---
+Title: RedisGraph 2.10 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Introduces new path algorithms, additional expressivity (constructs and
+  functions), performance improvements, and bug fixes.
+linkTitle: v2.10 (November 2022)
+min-version-db: 6.2.0
+min-version-rs: 6.2.8
+weight: 94
+---
+## Requirements
+
+RedisGraph v2.10.15 requires:
+
+- Minimum Redis compatibility version (database): 6.2.0
+- Minimum Redis Enterprise Software version (cluster): 6.2.8
+
+## v2.10.15 (September 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3172](https://github.com/RedisGraph/RedisGraph/pull/3172) Crash on certain write queries (MOD-5645)
+  - [#3179](https://github.com/RedisGraph/RedisGraph/pull/3179) High CPU on idle
+
+- Improvements:
+
+  - [#3184](https://github.com/RedisGraph/RedisGraph/pull/3184) Revert breaking change introduced in 2.10: `toString` supports list argument again
+  - [#3185](https://github.com/RedisGraph/RedisGraph/pull/3185) Don’t write AUX field in the RDB file when there are no graphs in the keyspace
+
+## v2.10.12 (July 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3129](https://github.com/RedisGraph/RedisGraph/pull/3129) Crash on certain queries (`INDEX SCAN` followed by `DEL` followed by `SET`) (MOD-5430)
+
+## v2.10.11 (June 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3096](https://github.com/RedisGraph/RedisGraph/pull/3096) Potential crash on query timeout (MOD-5202)
+  - [#3042](https://github.com/RedisGraph/RedisGraph/issues/3042), [#3052](https://github.com/RedisGraph/RedisGraph/issues/3052) Potential crashes due to false assertions
+
+## v2.10.10 (April 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+  - [#3038](https://github.com/RedisGraph/RedisGraph/issues/3038) Potential crash when a query with a `UNION` clause sets or modifies an indexed property
+  - [#2631](https://github.com/RedisGraph/RedisGraph/issues/2631), [#2968](https://github.com/RedisGraph/RedisGraph/issues/2968) Potential crash on certain `MATCH` clauses where label filters are used (MOD-5093)
+  - [#2957](https://github.com/RedisGraph/RedisGraph/issues/2957) Label filters in expressions such as `WITH n MATCH (n:X)` are ignored
+  - [#2931](https://github.com/RedisGraph/RedisGraph/issues/2931), [#3027](https://github.com/RedisGraph/RedisGraph/issues/3027) Wrong overflow error message
+
+## v2.10.9 (March 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2880](https://github.com/RedisGraph/RedisGraph/issues/2880) Potential crash when using `WITH *` expressions
+  - [#2917](https://github.com/RedisGraph/RedisGraph/issues/2917) Potential crash when using `CASE` expressions (MOD-4873)
+  - [#2836](https://github.com/RedisGraph/RedisGraph/issues/2836) Potential crash on `*0` variable-length path (MOD-4817)
+  - [#2916](https://github.com/RedisGraph/RedisGraph/issues/2916) Potential crash when executing concurrent queries that utilize full-text indices (MOD-4818)
+
+## v2.10.8 (February 2023)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2777](https://github.com/RedisGraph/RedisGraph/issues/2777), [#2841](https://github.com/RedisGraph/RedisGraph/issues/2841) Potential crash when sending queries from multiple connections and timeout is not 0
+  - [#2844](https://github.com/RedisGraph/RedisGraph/issues/2844) Potential partial results when same parametrized query is running from multiple connections
+  - [#2739](https://github.com/RedisGraph/RedisGraph/issues/2739), [#2774](https://github.com/RedisGraph/RedisGraph/issues/2774) Paths with exact variable length >1 are not matched
+  - [#2794](https://github.com/RedisGraph/RedisGraph/issues/2794) `toInteger` and `toIntegerOrNull` don't convert Booleans
+  - [#2798](https://github.com/RedisGraph/RedisGraph/issues/2798) `right` and `left` should reply with an error when `length` is null
+  - [#2809](https://github.com/RedisGraph/RedisGraph/issues/2809) `TIMEOUT_MAX` configuration parameter is not enforced when `TIMEOUT_DEFAULT` is 0
+  - [#2780](https://github.com/RedisGraph/RedisGraph/issues/2780) `indegree` and `outdegree` - relationships are counted more than once when same relationship type is supplied more than once
+
+- Improvements:
+
+  - [#2790](https://github.com/RedisGraph/RedisGraph/pull/2790) Improved performance by disabling SuiteSparse:GraphBLAS' global free pool
+  - [#2758](https://github.com/RedisGraph/RedisGraph/pull/2758) Improved edge deletion performance
+  - [#2781](https://github.com/RedisGraph/RedisGraph/issues/2781) `indegree` and `outdegree` now also accept an argument which is a list of labels
+
+## v2.10.5 (December 2022)
+
+This is a maintenance release for RedisGraph 2.10.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+
+  - [#2754](https://github.com/RedisGraph/RedisGraph/pull/2754) Partial sync may hang (MOD-4594)
+
+- Improvements:
+
+  - [#2757](https://github.com/RedisGraph/RedisGraph/pull/2757) Improved performance of `indegree` and `outdegree`
+  - [#2681](https://github.com/RedisGraph/RedisGraph/issues/2681) Fixed some error messages
+  - [#2740](https://github.com/RedisGraph/RedisGraph/issues/2740) Don’t show partial results for timed-out `GRAPH.PROFILE`
+
+## v2.10 GA (v2.10.4) (November 2022)
+
+This is the General Availability release of RedisGraph 2.10.
+
+### Highlights
+
+RedisGraph 2.10 introduces new path algorithms, additional expressivity (constructs and functions), performance improvements, and bug fixes.
+
+#### What's new in 2.10
+
+- New pathfinding algorithms: 
+  - The `algo.SPpaths` procedure yields one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths between a given pair of nodes.
+  - The `algo.SSpaths` procedure yields one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths from a given node.
+- Introduce `SET` for adding node labels and `REMOVE` for removing node labels, node properties, and edge properties.
+- Support deleting paths with `DELETE`.
+- Introduce 29 functions: `toBoolean`, `toBooleanOrNull`, `toFloatOrNull`, `toIntegerOrNull`, `toStringOrNull`, `toBooleanList`, `toFloatList`, `toIntegerList`, `toStringList`, `properties`, `split`, `last`, `isEmpty`, `e`, `exp`, `log`, `log10`, `sin`, `cos`, `tan`, `cot`, `asin`, `acos`, `atan`, `atan2`, `degrees`, `radians`, `pi`, and `haversin`.
+- Graph slow log can be reset with `GRAPH.SLOWLOG g RESET`.
+- Queries are now atomic (_Atomicity_ is the guarantee that each query either succeeds or fails with no side effects). Whenever a failure occurs, the query effect is rolled back from an undo log.
+
+### Details
+
+- Bug fixes (since 2.10-RC1):
+
+  - [#2695](https://github.com/RedisGraph/RedisGraph/pull/2695) Potential crash on certain write queries (MOD-4286, MOD-4545)
+  - [#2724](https://github.com/RedisGraph/RedisGraph/issues/2724) Potential crash when setting property values based on nonexistent properties
+  - [#2460](https://github.com/RedisGraph/RedisGraph/issues/2460), [#2637](https://github.com/RedisGraph/RedisGraph/issues/2637), [#2680](https://github.com/RedisGraph/RedisGraph/issues/2680) Crash on invalid queries
+  - [#2672](https://github.com/RedisGraph/RedisGraph/issues/2672) Wrong matching result on multiple labels
+  - [#2643](https://github.com/RedisGraph/RedisGraph/issues/2643) Duplicate reports when matching relationship type `:R|R`
+  - [#2687](https://github.com/RedisGraph/RedisGraph/issues/2687), [#2414](https://github.com/RedisGraph/RedisGraph/issues/2414) Error when `UNWIND`ing relationships
+  - [#2636](https://github.com/RedisGraph/RedisGraph/issues/2636) `MERGE` ... `ON` ... - cannot remove property by setting it to null
+  - [#2710](https://github.com/RedisGraph/RedisGraph/pull/2710) Undo log fix
+  - [#2435](https://github.com/RedisGraph/RedisGraph/issues/2435) Incorrect result when comparing a value to NaN
+  - [#2497](https://github.com/RedisGraph/RedisGraph/issues/2497) Incorrect result when comparing a value to null
+  - [#2676](https://github.com/RedisGraph/RedisGraph/issues/2676) `sqrt`, `log`, `log10` - incorrect result for negative values
+  - [#2213](https://github.com/RedisGraph/RedisGraph/issues/2213) Division and Modulo by zero - wrong behavior
+---
+Title: RedisGraph 2.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Support for scaling reads, OPTIONAL MATCH, query caching, and GRAPH.SLOWLOG.
+linkTitle: v2.2 (November 2020)
+min-version-db: 5.0.7
+min-version-rs: 6.0.8
+weight: 97
+---
+## Requirements
+
+RedisGraph v2.2.16 requires:
+
+- Minimum Redis compatibility version (database): 5.0.7
+- Minimum Redis Enterprise Software version (cluster): 6.0.8
+
+## v2.2.16 (April 2021)
+
+This is a maintenance release for version 2.2.
+
+Update urgency: Medium
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Enhancements:
+
+    - #[1610](https://github.com/RedisGraph/RedisGraph/pull/1610) Add module-level configuration for query timeouts
+    - #[1572](https://github.com/RedisGraph/RedisGraph/pull/1572) Remove query size limitation from parser
+    - #[1590](https://github.com/RedisGraph/RedisGraph/pull/1590) Improve reporting of runtime errors
+    - #[1596](https://github.com/RedisGraph/RedisGraph/pull/1596) Run bulk loader commands on a non-blocking thread
+
+- Performance Improvements:
+
+    - #[1569](https://github.com/RedisGraph/RedisGraph/pull/1569) Avoid network overhead of emitting arrays with postponed length values
+
+- Bugfixes:
+
+    - #[1573](https://github.com/RedisGraph/RedisGraph/pull/1573) Lock graph on building/deleting full-text indexes, fixing a bug in full-text index replication
+    - #[1618](https://github.com/RedisGraph/RedisGraph/pull/1618) Fix error in traversals of 3 or more possible relationship types
+
+- Infrastructure:
+
+    - #[1557](https://github.com/RedisGraph/RedisGraph/pull/1557) Add automated performance benchmarks and regression testing
+    - #[1587](https://github.com/RedisGraph/RedisGraph/pull/1587), #[1598](https://github.com/RedisGraph/RedisGraph/pull/1598) Create build artifacts for multiple environments
+
+## v2.2.14 (16 February 2021)
+
+This is a maintenance release for version 2.2.
+
+Update urgency: Medium
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Performance improvements:
+
+    - #[1565](https://github.com/RedisGraph/RedisGraph/pull/1565) Reserve a single thread for performing all write queries.
+    - #[1548](https://github.com/RedisGraph/RedisGraph/pull/1548), #[1553](https://github.com/RedisGraph/RedisGraph/pull/1553), #[1554](https://github.com/RedisGraph/RedisGraph/pull/1554) only perform SET property updates when property value is changed.
+    - #[1543](https://github.com/RedisGraph/RedisGraph/pull/1543) Enable O3 compiler optimizations on libcypher-parser.
+
+- Bugfixes:
+
+    - #[1556](https://github.com/RedisGraph/RedisGraph/pull/1556) Avoid premature freeing of Records in create and update contexts.
+    - #[1541](https://github.com/RedisGraph/RedisGraph/pull/1541) Fix excessive memory consumption in OpApply.
+
+## v2.2.13 (16 February 2021)
+
+This is a maintenance release for version 2.2.
+
+Update urgency: Medium
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor enhancements:
+
+    - #[1490](https://github.com/RedisGraph/RedisGraph/pull/1490) Add support for startNode() and endNode() functions.
+    - #[1519](https://github.com/RedisGraph/RedisGraph/pull/1519) Add support for db.indexes() procedure.
+
+- Performance improvements:
+
+    - #[1393](https://github.com/RedisGraph/RedisGraph/pull/1393) Use one unified cache for all RedisGraph worker threads.
+    - #[1498](https://github.com/RedisGraph/RedisGraph/pull/1498) Consider both filters and labels in selecting a traversal's starting point.
+    - #[1468](https://github.com/RedisGraph/RedisGraph/pull/1468) Unify logic and error handling for aggregate and scalar functions.
+
+- Bugfixes:
+
+    - #[1534](https://github.com/RedisGraph/RedisGraph/pull/1534) Outdated label information used when performing index scans.
+    - #[1532](https://github.com/RedisGraph/RedisGraph/pull/1532) Invalid optimization of IN \[array] lookups when values are indexed.
+    - #[1524](https://github.com/RedisGraph/RedisGraph/pull/1524) Memory error in accessing complex values after CREATE operations.
+    - #[1523](https://github.com/RedisGraph/RedisGraph/pull/1523) Erroneous results when traversing over some transposed matrix sequences.
+    - #[1499](https://github.com/RedisGraph/RedisGraph/pull/1499) Erroneous results on variable-length traversals on repeatedly-transposed arrays.
+    - #[1504](https://github.com/RedisGraph/RedisGraph/pull/1504) Crash on certain constructions of 0-hop traversals.
+    - #[1495](https://github.com/RedisGraph/RedisGraph/pull/1495) Disallow access of properties that have not yet been created.
+    - #[1503](https://github.com/RedisGraph/RedisGraph/pull/1503) Only allow literal values as parameters.
+    - #[1496](https://github.com/RedisGraph/RedisGraph/pull/1496) Disallow assignment of complex data types to property values in MERGE contexts.
+    - #[1494](https://github.com/RedisGraph/RedisGraph/pull/1494) Disallow assignment of values to properties on deleted entities.
+
+- Build:
+
+    - #[1524](https://github.com/RedisGraph/RedisGraph/pull/1524) Update test suite to run under Python 3.
+
+
+## v2.2.11 (20 December 2020)
+
+This is a maintenance release for version 2.2.
+
+Headlines:
+
+This release introduces support for runtime configuration of the maximum number of results to be returned.
+
+Details:
+
+- Features
+    - #[1480](https://github.com/RedisGraph/RedisGraph/pull/1480) Introduce GRAPH.CONFIG SET/GET to allow result-set size to be configured at runtime.
+
+## v2.2.10 (20 December 2020)
+
+This is a maintenance release for version 2.2.
+
+Headlines:
+
+This release improves overall stability and fixes an issue with backwards compatibility logic for indexing.
+
+Details:
+
+- Bugfixes:
+    - #[1475](https://github.com/RedisGraph/RedisGraph/pull/1475) Fix erroneous property update when using `SET` with an unindexed property followed by an indexed one.
+    - #[1473](https://github.com/RedisGraph/RedisGraph/pull/1473) Fix backwards compatibility issue in rebuilding and dropping exact-match and full-text indexes.
+
+## v2.2.9 (4 December 2020)
+
+This is a maintenance release for version 2.2.
+
+Headlines:
+
+This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Performance improvements:
+    - #[1426](https://github.com/RedisGraph/RedisGraph/pull/1426) Improve load times of adjacency matrices that always have different source and destination nodes.
+- Minor enhancements:
+    - #[1463](https://github.com/RedisGraph/RedisGraph/pull/1463) Remove all assertions from production builds.
+    - #[1442](https://github.com/RedisGraph/RedisGraph/pull/1442) NULL property values should be ignored in `CREATE` clauses and trigger errors in MERGE clauses.
+    - #[1429](https://github.com/RedisGraph/RedisGraph/pull/1429) Improve error handling of a number of invalid query constructions.
+    - #[1431](https://github.com/RedisGraph/RedisGraph/pull/1431) Traversal patterns are only allowed in `MATCH`, `MERGE`, `CREATE`, and `WHERE` contexts.
+- Bugfixes:
+    - #[1429](https://github.com/RedisGraph/RedisGraph/pull/1429) Fix potential misapplications of `WHERE` filters.
+    - #[1460](https://github.com/RedisGraph/RedisGraph/pull/1460) `RETURN` clauses can only be followed by `UNION` clauses.
+    - #[1467](https://github.com/RedisGraph/RedisGraph/pull/1467) Disallow assignment of complex data types to property values.
+    - #[1437](https://github.com/RedisGraph/RedisGraph/pull/1437) Failed property updates on `MERGE` should be handled gracefully.
+    - #[1446](https://github.com/RedisGraph/RedisGraph/pull/1446) Fix errors in Cartesian Product filter placement.
+
+## v2.2 GA (November 2020)
+
+This is the General Availability Release of RedisGraph 2.2 (v2.2.8)!
+
+Headlines:
+
+- Enhanced support for scaling reads
+- `OPTIONAL MATCH` (Left outer join)
+- Query cache: Improve performance by caching the query execution plan
+- Tooling to increase developer experience
+
+Details:
+
+- Support for scaling reads
+    - #[1054](https://github.com/RedisGraph/RedisGraph/pull/1054)
+ Drastic reduction of memory consumption during replication (and [Active-Passive]({{< relref "/operate/rs/databases/import-export/replica-of/create" >}})). Break down a large graph into several portions, each accommodating a virtual key and distribute those for reconstruction at the replica end, by doing so we reduce memory consumption on the replica's end.
+
+- `OPTIONAL MATCH` support
+    Unlike MATCH, which requires for a pattern to exist, `OPTIONAL MATCH` continues processing when the optional pattern doesn't exist. We can easily compare `OPTIONAL MATCH` in Cypher to an outer join in SQL. It works just like a regular `MATCH` with the difference that if no matches are found, `OPTIONAL MATCH` will use a null for missing parts of the pattern.
+
+    - Query cache: Improve performance by caching the query execution plan
+
+        When executing parameterised queries, RedisGraph will cache the execution plan for increased performance. By caching query's execution-plan, RedisGraph skips the parsing and execution-plan construction phase.
+        Cache size can be configured at module load time. The default value is 25.
+
+- Tooling to increase developer experience
+
+    Introduction of `GRAPH.SLOWLOG` command which returns the longest running queries.
+    In addition #[1274](https://github.com/RedisGraph/RedisGraph/pull/1274)
+ introduces query timeouts with an optional query flag.
+
+- Smaller features and enhancements:
+    - #[1225](https://github.com/RedisGraph/RedisGraph/pull/1225)
+ Only update index on change of relevant Node properties.
+    - #[1229](https://github.com/RedisGraph/RedisGraph/pull/1229)
+ RediSearch 1.8.2. (Dependency update)
+    - #[1266](https://github.com/RedisGraph/RedisGraph/pull/1266)
+, #[1277](https://github.com/RedisGraph/RedisGraph/pull/1277)
+ Add support for `any()` and `all()` functions in list comprehension.
+    - #[877](https://github.com/RedisGraph/RedisGraph/pull/877)
+ Transpose matrices: maintain transpose relationship matrices such that we won't have to compute the transpose of a matrix at run-time. This feature is on by default but can be configured to reduce memory consumption.
+
+- Small updates compared to RC7
+    - Minor enhancements:
+        - #[1365](https://github.com/RedisGraph/RedisGraph/pull/1365)
+ Support array properties in bulk loader.
+        - #[1377](https://github.com/RedisGraph/RedisGraph/pull/1377)
+ Adding a new procedure `dbms.procedures` that returns all the procedures in the system.
+        - #[1389](https://github.com/RedisGraph/RedisGraph/pull/1389)
+ Allow property accesses on non-identifier entity references.
+    - Bug fixes:
+        - #[1406](https://github.com/RedisGraph/RedisGraph/pull/1406)
+ Query validation should not check if procedure outputs have been defined.
+        - #[1382](https://github.com/RedisGraph/RedisGraph/pull/1382)
+ Add graph version to graph context object, response with an error when client graph version mismatch.
+        - #[1361](https://github.com/RedisGraph/RedisGraph/pull/1361)
+ Don't migrate `WITH` filters into Merge and Apply operation scope.
+
+Notes:
+This is the GA version of 2.2. The version inside Redis will be 20208 or 2.2.8 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+---
+Title: RedisGraph 1.0 release notes
+linkTitle: v1.0 (November 2018)
+description: Fixed memory leaks. Support ‘*’ within RETURN clause. Added TYPE function. Initial support for UNWIND clause.
+min-version-db: "4.0.0"
+min-version-rs: "5.0.0"
+weight: 100
+alwaysopen: false
+categories: ["Modules"]
+aliases: /modules/redisgraph/release-notes/redisgraph-1.0-release-notes/
+---
+## Requirements
+
+RedisGraph v1.0.15 requires:
+
+- Minimum Redis compatibility version (database): 4.0.0
+- Minimum Redis Enterprise Software version (cluster): 5.0.0
+
+## v1.0.15 (March 2019)
+
+- GraphBLAS 2.3.0 [release notes](https://github.com/RedisLabsModules/RedisGraph/pull/390#issuecomment-470620353)
+- WITH clause: Allows query parts to be chained together, piping the results from one to be used as starting points or criteria of the next. [ref p.78](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf)
+- Enhancements
+    - #[393](https://github.com/RedisGraph/RedisGraph/issues/393) Discard distinct when performing aggregation
+- Minor bugfixes
+    - #[359](https://github.com/RedisGraph/RedisGraph/issues/359) Adding ORDER BY changes the number of returned hits when used in combination with LIMIT
+    - #[363](https://github.com/RedisGraph/RedisGraph/issues/363) Remove graph entity property when it is set to null
+    - #[386](https://github.com/RedisGraph/RedisGraph/issues/386) Return updated values on queries that modify data
+
+## v1.0.14 (21 February 2019)
+
+License update, REDIS SOURCE AVAILABLE LICENSE AGREEMENT.
+
+## v1.0.13 (6 February 2019)
+
+Reuse attribute name to avoid duplication
+
+## v1.0.12 (28 January 2019)
+
+Traverse direction optimization to reduce number of matrix transpose
+
+## v1.0.11 (17 January 2019)
+
+- Removed OpenMP requirement
+- Traverse from multiple nodes concurrently
+
+## v1.0.10 (9 January 2019)
+
+Update indices when MERGE creates new entities
+
+## v1.0.9 (6 January 2019)
+
+- Support for mixing MERGE and SET clauses
+- Granular writer locking
+- Fix graph serialization error in duplicate edge handling
+
+## v1.0.8 (24 December 2018)
+
+- Index utilization when performing cartesian product
+- Increase usage of rm_malloc functions in module
+- Allow serialization of NULL-valued properties
+- Support for multiple relationship types
+
+## v1.0.7 (18 December 2018)
+
+- Bulk-insert support unicode
+- Bulk-insert better progress reporting
+- Multiple relationship types
+
+## v1.0.5 (15 December 2018)
+
+Bulk insert supports ID specifying + relationships attributes
+
+## v1.0.4 (9 December 2018)
+
+- Compact GraphBLAS, using structural semiring
+
+## v1.0.3 (2 December 2018)
+
+- GraphBLAS 2.2
+- Multiple CREATE clauses
+- Multiple MATCH clauses
+- Bug fixes:
+    - Replace operations appropriately when rewriting execution plan
+    - Entity returned from datablock should have its internals cleared
+    - Loaded triemap strings are not guaranteed space for a null terminator
+
+## v1.0.2 (25 November 2018)
+
+- Bug fix #[249](https://github.com/RedisGraph/RedisGraph/issues/249) reset operation within execution plan should propagate upwards
+
+## v1.0.1 (22 November 2018)
+
+- Resolved a number of memory leaks
+- Support '*' within RETURN clause
+- Add TYPE function
+- Initial support for UNWIND clause
+---
+Title: RedisGraph 2.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Added Map and Geospatial Point data types.
+linkTitle: v2.4 (March 2021)
+min-version-db: 6.0.0
+min-version-rs: 6.0.8
+weight: 96
+---
+
+## Requirements
+
+RedisGraph v2.4.14 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.8
+
+## v2.4.14 (May 2022)
+
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Bug fixes:
+
+    - [#2072](https://github.com/RedisGraph/RedisGraph/issues/2072), [#2081](https://github.com/RedisGraph/RedisGraph/pull/2081) CRLF sequences embedded in strings no longer trigger a protocol error when being emitted
+
+- Improvements:
+
+    - [#2102](https://github.com/RedisGraph/RedisGraph/pull/2102) New load-time configuration option `NODE_CREATION_BUFFER` - see [documentation](https://github.com/RedisGraph/RedisGraph/blob/master/docs/docs/configuration.md#node_creation_buffer) (MOD-2348)
+
+{{<note>}}
+For Redis Enterprise users who want to upgrade to this patch, this version requires being on version 6.2.8 or later.
+{{</note>}}
+
+## v2.4.13 (December 2021)
+
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Performance improvements
+    - [#2040](https://github.com/RedisGraph/RedisGraph/pull/2040) Use optimal order of traversals
+
+- Bug fixes:
+    - [#2046](https://github.com/RedisGraph/RedisGraph/pull/2046) Avoid serialization of duplicate graph keys (high urgency)
+    - [#2033](https://github.com/RedisGraph/RedisGraph/pull/2033) Update RediSearch to 2.0.13
+
+## v2.4.12 (October 2021)
+
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+
+- Bug fixes:
+    - [#1981](https://github.com/RedisGraph/RedisGraph/pull/1981) Crash in index scan
+
+## v2.4.11 (October 2021)
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: `MODERATE` : Program an upgrade of the server, but it's not urgent.
+
+Details:
+- Bug fixes:
+    - #[1931](https://github.com/RedisGraph/RedisGraph/issues/1931) Fix race condition on calling [`BGSAVE`]({{< relref "/commands/bgsave" >}}) while flushing matrices
+    - #[1898](https://github.com/RedisGraph/RedisGraph/issues/1898) Error when setting a property to an array containing an invalid type
+    - #[1897](https://github.com/RedisGraph/RedisGraph/issues/1897) Aliases in `WITH...ORDER BY` must be valid references%
+
+## v2.4.10 (September 2021)
+
+This is a maintenance release for RedisGraph 2.4
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+- Critical bug fixes:
+    - #[1911](https://github.com/RedisGraph/RedisGraph/issues/1911) When a query timeout is set and the graph contained indexes, a crash could occur while releasing indexes
+
+- Bug fixes:
+    - #[1913](https://github.com/RedisGraph/RedisGraph/issues/1913) Update thread-local AST for every cloned operation
+    - #[1915](https://github.com/RedisGraph/RedisGraph/issues/1915) Validate function references in parameters%
+
+## v2.4.7 (July 2021)
+
+This is a maintenance release for RedisGraph 2.4
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details:
+- Bug fixes:
+    - #[1746](https://github.com/redisgraph/redisgraph/issues/1746) Avoid invalid memory access after reallocating labels array
+    - #[1748](https://github.com/redisgraph/redisgraph/issues/1748) Only allocate space for deleted nodes and edges
+    - #[1749](https://github.com/redisgraph/redisgraph/issues/1749), #[1730](https://github.com/redisgraph/redisgraph/issues/1730) Support updating properties with map referenced by parameter or variable
+    - #[1754](https://github.com/redisgraph/redisgraph/issues/1754) Map should return volatile data
+    - #[1773](https://github.com/redisgraph/redisgraph/issues/1773) Matrix resize doesn't set both rows and columns atomically
+    - #[1799](https://github.com/redisgraph/redisgraph/issues/1799) Always instantiate new persistent matrices as sparse%
+
+## v2.4.6 (June 2021)
+
+This is a maintenance release for RedisGraph 2.4
+
+Update urgency: Medium
+
+Details:
+
+- Performance improvements:
+    - #[1702](https://github.com/redisgraph/redisgraph/issues/1702) Optimize matrix synchronization in GRAPH.BULK commands
+    - #[1716](https://github.com/redisgraph/redisgraph/issues/1716) Reduce lock calls in retrieving matrices for reading
+    - #[1741](https://github.com/redisgraph/redisgraph/issues/1741) Improve edge extraction
+    - #[1388](https://github.com/redisgraph/redisgraph/issues/1388) Node creation buffer
+    - #[1724](https://github.com/redisgraph/redisgraph/issues/1724) Update RediSearch 2.0
+    - #[1731](https://github.com/redisgraph/redisgraph/issues/1731) Release lock after MergeCreate builds entities
+    - #[1734](https://github.com/redisgraph/redisgraph/issues/1734) Added multi edge flag
+
+- Bug fixes:
+    - #[1726](https://github.com/redisgraph/redisgraph/issues/1726) JsonEncoder: invalid cast
+    - #[1709](https://github.com/redisgraph/redisgraph/issues/1709) #1712 Fix potential deadlock in BGSAVE
+    - #[1703](https://github.com/redisgraph/redisgraph/issues/1703) Uniquing logic in UNION subqueries
+    - #[1720](https://github.com/redisgraph/redisgraph/issues/1720) Propagate configuration updates to replicas
+    - #[1714](https://github.com/redisgraph/redisgraph/issues/1714) Don't build scan operations for bound variables
+    - #[1708](https://github.com/redisgraph/redisgraph/issues/1708) Regression in GRAPH.CONFIG GET *
+    - #[1715](https://github.com/redisgraph/redisgraph/issues/1715) Validate function private data before freeing it
+
+- Miscellaneous:
+
+    - #[1691](https://github.com/redisgraph/redisgraph/issues/1691) Reword error message on setting property value to invalid type
+
+## v2.4.4 (15 May 2021)
+
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: Medium
+
+Details:
+
+- Minor Enhancements:
+    - #[1666](https://github.com/redisgraph/redisgraph/issues/1666) Add configuration parameter to limit the memory usage of queries
+    - #[1639](https://github.com/redisgraph/redisgraph/issues/1639) Add functionality to SET all properties on an entity to a map
+
+- Bug fixes:
+    - #[1678](https://github.com/redisgraph/redisgraph/issues/1678) Crash on multiple procedure calls in a single query
+
+## v2.4.3 (8 May 2021)
+
+This is a maintenance release for RedisGraph 2.4.
+
+Update urgency: Medium
+
+Details:
+
+- Features:
+    - #[1657](https://github.com/redisgraph/redisgraph/issues/1657) Support filtering on variable-length edges in traversals
+    - #[1514](https://github.com/redisgraph/redisgraph/issues/1514) Add support for shortestPath in MATCH clauses
+    - #[1664](https://github.com/redisgraph/redisgraph/issues/1664) Add support for limiting max queued queries
+    - #[1653](https://github.com/redisgraph/redisgraph/issues/1653), #[1655](https://github.com/redisgraph/redisgraph/issues/1655) Add support for square root (sqrt) function
+
+- Performance improvements:
+    - #[1641](https://github.com/redisgraph/redisgraph/issues/1641) Use indexes when filters can only be resolved at runtime
+    - #[1668](https://github.com/redisgraph/redisgraph/issues/1668) Apply path filters after all other filters
+
+- Bug fixes:
+    - #[1650](https://github.com/redisgraph/redisgraph/issues/1650) Fix memory leak on allocated keys in OpAggregate
+    - #[1671](https://github.com/redisgraph/redisgraph/issues/1671) Disallow nested aggregates in map values, circumventing a bug that introduced invalid group keys
+    - #[1644](https://github.com/redisgraph/redisgraph/issues/1644) Fix bug in which values for unknown schema types are cached
+    - #[1656](https://github.com/redisgraph/redisgraph/issues/1656) Fix potential crash when releasing thread pools on server shutdown
+
+
+## v2.4 GA (March 2021)
+
+Headlines:
+
+- This release introduces the Map and Geospatial Point data types.
+
+Details:
+
+- Features:
+  - #[1514](https://github.com/redisgraph/redisgraph/issues/1514) Add support for Map data type.
+  - #[1516](https://github.com/redisgraph/redisgraph/issues/1516) Add support for Geospatial Point data type.
+  - #[1562](https://github.com/redisgraph/redisgraph/issues/1562) Add `toJSON` function.
+  - #[1607](https://github.com/redisgraph/redisgraph/issues/1607) Querying full-text indexes can yield the `score` of each result.
+  - #[1610](https://github.com/redisgraph/redisgraph/issues/1610) Expose runtime configuration for read query timeouts.
+
+- Performance improvements:
+  - #[1596](https://github.com/redisgraph/redisgraph/issues/1596) [Redisgraph-bulk-loader](https://github.com/RedisGraph/redisgraph-bulk-loader) no longer blocks the server.
+
+- Minor Enhancements
+  - #[1590](https://github.com/redisgraph/redisgraph/issues/1590) Improve handling of runtime errors.
+  - #[1580](https://github.com/redisgraph/redisgraph/issues/1580) Enable assertions in debug mode.
+
+- Bugfixes (compared to RC1)
+  - #[1618](https://github.com/redisgraph/redisgraph/issues/1618) Fix relationship types being omitted in traversals of 3 or more types.
+
+{{< note >}}
+This is the first GA version of 2.4. The version inside Redis will be 2.4.2 in semantic versioning. Since the version of a module in Redis is numeric, we could not add an GA flag.
+{{< /note >}}
+---
+Title: RedisGraph 2.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Enabled graph-aided search and graph visualisation. Cypher coverage.
+  Performance improvements.
+linkTitle: v2.0 (January 2020)
+min-version-db: 5.0.7
+min-version-rs: 5.4.11
+weight: 98
+---
+## Requirements
+
+RedisGraph v2.0.21 requires:
+
+- Minimum Redis compatibility version (database): 5.0.7
+- Minimum Redis Enterprise Software version (cluster): 5.4.11
+
+## v2.0.21 (October 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor enhancements:
+
+    - #[1326](https://github.com/RedisGraph/RedisGraph/pull/1326), #[1330](https://github.com/RedisGraph/RedisGraph/pull/1330) Enable comments in Cypher queries.
+
+- Bug fixes:
+
+- #[1338](https://github.com/RedisGraph/RedisGraph/pull/1338) Update parser to support negative values.
+- #[1319](https://github.com/RedisGraph/RedisGraph/pull/1319) Replace assertion with runtime error - execution plan building process is unable locate an operation suitable for a filter.
+- #[1184](https://github.com/RedisGraph/RedisGraph/pull/1184) EXPLAIN and PROFILE are invalid clauses. They have counterpart commands `GRAPH.EXPLAIN` and `GRAPH.PROFILE`
+- #[1212](https://github.com/RedisGraph/RedisGraph/pull/1212) Emit error on the creation of undirected edges.
+
+## v2.0.20 (September 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor updates:
+
+    - #[1315](https://github.com/RedisGraph/RedisGraph/pull/1315) RediSearch 1.8.3
+    - #[1276](https://github.com/RedisGraph/RedisGraph/pull/1276) Graph info is added to Redis crash report.
+    - #[1265](https://github.com/RedisGraph/RedisGraph/pull/1265) Debug assertion functionality.
+
+## v2.0.19 (August 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor updates:
+    - #[1229](https://github.com/RedisGraph/RedisGraph/pull/1229) Upgrade RediSearch dependency to 1.8.2
+- Performance enhancements:
+    - #[1218](https://github.com/RedisGraph/RedisGraph/pull/1218) Enable parameters support for ID-based entity retrieval
+    - #[1242](https://github.com/RedisGraph/RedisGraph/pull/1242) Improve update logic, update RediSearch indices only once per update
+    - #[1226](https://github.com/RedisGraph/RedisGraph/pull/1226) Let RediSearch perform document deletion when replacing a document
+- Bug Fixes:
+    - #[1223](https://github.com/RedisGraph/RedisGraph/pull/1223) Resolve race condition in accessing/updating attribute maps.
+    - #[1196](https://github.com/RedisGraph/RedisGraph/pull/1196) Enable RediSearch [Garbage Collection]({{<relref "/develop/interact/search-and-query/administration/gc">}})
+
+## v2.0.15 (25 June 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bug Fixes:
+    - #[1159](https://github.com/RedisGraph/RedisGraph/pull/1159) `IN` operator didn't result in an index array lookup with parameterised array (`IN $param`).
+
+## v2.0.14 (22 June 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bug Fixes:
+    - #[1157](https://github.com/RedisGraph/RedisGraph/pull/1157) Index search not using query parameters.
+
+## v2.0.13 (15 June 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Enhancements:
+    - #[1118](https://github.com/RedisGraph/RedisGraph/pull/1118) Added module configuration parameters for the number of threads in OpenMP and concurrent queries.
+    - #[1121](https://github.com/RedisGraph/RedisGraph/pull/1121) [RediSearch](https://github.com/RediSearch/RediSearch/) v1.8.1
+
+## v2.0.12 (May 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Enhancements:
+    - #[1103](https://github.com/RedisGraph/RedisGraph/pull/1103) RediSearch 1.8. This upgrade will reduce the resources required for Garbage Collection of indices inside RedisGraph.
+
+## v2.0.11 (April 2020)
+
+This is a maintenance release for version 2.0.
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor Enhancements:
+    - #[1056](https://github.com/RedisGraph/RedisGraph/pull/1056) Added `DISTINCT` support for paths and arrays.
+- Minor Bugfixes:
+    - #[1056](https://github.com/RedisGraph/RedisGraph/pull/1056) Streamlined logic for uniquing entities.
+    - #[1056](https://github.com/RedisGraph/RedisGraph/pull/1056) Enabled comparison routine for paths.
+
+## v2.0.10 (29 March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Minor Enhancements:
+    - #[1035](https://github.com/redisgraph/redisgraph/issues/1035) - RediSearch version [1.6.11](https://github.com/RediSearch/RediSearch/releases/tag/v1.6.11).
+- Bugfixes:
+    - #[1017](https://github.com/redisgraph/redisgraph/issues/1017), #[1019](https://github.com/redisgraph/redisgraph/issues/1019) - Algebraic expressions correctness.
+    - #[1020](https://github.com/redisgraph/redisgraph/issues/1020) - Support parameterised SKIP and LIMIT.
+
+## v2.0.9 (19 March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1028](https://github.com/redisgraph/redisgraph/issues/1028) Ensure proper placement of Index Scans when partially replacing Filter ops.
+
+## v2.0.8 (18 March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Bugfixes:
+    - #[1023](https://github.com/redisgraph/redisgraph/issues/1023) Fix regression in checking argument counts to GRAPH endpoints.
+
+## v2.0.6 (15 March 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- #[897](https://github.com/redisgraph/redisgraph/issues/897) GRAPH.SLOWLOG
+- #[1004](https://github.com/redisgraph/redisgraph/issues/1004) Re-enable GRAPH.PROFILE
+- #[917](https://github.com/redisgraph/redisgraph/issues/917), #[991](https://github.com/redisgraph/redisgraph/issues/991), #[940](https://github.com/redisgraph/redisgraph/issues/940), #[984](https://github.com/redisgraph/redisgraph/issues/984) Memory leak fixes
+- #[925](https://github.com/redisgraph/redisgraph/issues/925) Bug fix within RediSearch
+- #[1001](https://github.com/redisgraph/redisgraph/issues/1001) Bug fix label scan invalid range
+
+## v2.0.5 (23 February 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Enhancement:
+    - #[955](https://github.com/redisgraph/redisgraph/issues/955)  Switch OR,AND boolean semiring to ANY,PAIR.
+
+## v2.0.4 (23 February 2020)
+
+Details:
+
+- Enhancement:
+    - Reduce GraphBLAS size
+
+## v2.0.2 (23 February 2020)
+
+Headlines:
+
+- This release improves overall stability and provides fixes for issues found after the previous release.
+
+Details:
+
+- Improved error reporting:
+    - #[925](https://github.com/redisgraph/redisgraph/issues/925) RediSearch query error reporting
+    - #[919](https://github.com/redisgraph/redisgraph/issues/919) Added non existing entity runtime error
+- Enhancements:
+    - #[942](https://github.com/redisgraph/redisgraph/issues/942) Update GraphBLAS version (3.2.0)
+    - #[922](https://github.com/redisgraph/redisgraph/issues/922) Filter tree compaction
+    - #[906](https://github.com/redisgraph/redisgraph/issues/906) Optimize cartesian product
+    - #[898](https://github.com/redisgraph/redisgraph/issues/898) Granular matrix locking
+- Bug fixes:
+    - #[917](https://github.com/redisgraph/redisgraph/issues/917) #[940](https://github.com/redisgraph/redisgraph/issues/940) Resolve memory leaks
+    - #[938](https://github.com/RedisGraph/RedisGraph/pull/938) Label matrix should be fetch right before eval
+
+## v2.0 GA (2.0.1 - January 2020)
+
+This is the General Availability (GA) release of RedisGraph 2.0 (2.0.1)!
+
+Headlines:
+
+- Full Text Search (FTS) enabling Graph-aided Search.
+- Full graph response enabling visualisation.
+- Substantial amount of Cypher coverage.
+- Performance improvements of up to 4x compared to RedisGraph 1.2.
+
+(We will blog about this release soon including performance improvements results and the link here)
+
+Full details:
+
+- Major features
+    - #[339](https://github.com/RedisGraph/RedisGraph/issues/339) Full Graph Response.  RedisGraph now allows to return Graph entities such as Nodes and Relationships.  This feature also enables graph visualisation.
+    - #[558](https://github.com/RedisGraph/RedisGraph/issues/558) Indexing functionality replaced by [RediSearch](redisearch.io). This results in support for
+        - compound indices
+        - full text search
+        - graph-aided search
+    - #[691](https://github.com/RedisGraph/RedisGraph/issues/691) RediSearch index is used with `IN` operator on indexed properties.
+    - #[488](https://github.com/RedisGraph/RedisGraph/issues/488) Replace flex/lemon parser with [libcypher-parser](https://github.com/cleishm/libcypher-parser).
+    - #[574](https://github.com/RedisGraph/RedisGraph/issues/574) Introduction of the array data type. This introduces significant support of Cypher as well as properties can be arrays on both nodes and relationships.
+    - Cypher
+        - #[714](https://github.com/RedisGraph/RedisGraph/issues/714) `MERGE` can be combined with any other clause. `MERGE` will take into account bounded entities.
+        - #[786](https://github.com/RedisGraph/RedisGraph/issues/786) Support for passing all supported graph data types (Node, Relationship, Array,...) as arguments to procedure calls, rather than requiring all arguments to be Strings.
+        - #[708](https://github.com/RedisGraph/RedisGraph/issues/708) Named path support.
+        - #[717](https://github.com/RedisGraph/RedisGraph/issues/717) `count(*)`
+        - #[730](https://github.com/RedisGraph/RedisGraph/issues/730) `UNION`
+        - #[757](https://github.com/RedisGraph/RedisGraph/issues/757) `coalesce`
+        - #[658](https://github.com/RedisGraph/RedisGraph/issues/658) Support for `COUNT DISTINCT`
+        - #[574](https://github.com/RedisGraph/RedisGraph/issues/574) with the array data support comes `IN`, `collect`, `head`,`range`, `reverse`, `size`, `tail`
+        - #[624](https://github.com/RedisGraph/RedisGraph/issues/624) `randomUUID()`
+        - #[632](https://github.com/RedisGraph/RedisGraph/issues/632) `IS NULL` and `IS NOT NULL`.
+        - #[594](https://github.com/RedisGraph/RedisGraph/issues/594) Support dynamic inline properties for `CREATE` and `MERGE` patterns.
+        - #[583](https://github.com/RedisGraph/RedisGraph/issues/583) `NOT` Operator.
+        - #[569](https://github.com/RedisGraph/RedisGraph/issues/569) `timestamp()` function.
+        - #[586](https://github.com/RedisGraph/RedisGraph/issues/586) `CASE WHEN` (simple form).
+        - #[582](https://github.com/RedisGraph/RedisGraph/issues/582) `contains` function.
+        - #[596](https://github.com/RedisGraph/RedisGraph/issues/596) `indegree` and `outdegree` functions for nodes.
+        - #[587](https://github.com/RedisGraph/RedisGraph/issues/587) improved boolean logic.
+        - #[539](https://github.com/RedisGraph/RedisGraph/issues/539) Reusable entities in pattern matching.
+    - #[668](https://github.com/RedisGraph/RedisGraph/issues/668) PageRank support.
+    - #[713](https://github.com/RedisGraph/RedisGraph/issues/713) Parameterised queries support. Most client drivers are updated. This enables future performance enhancements for query caching.
+    - #[662](https://github.com/RedisGraph/RedisGraph/issues/662) Support for AOF.
+- Enhancements
+    - #[752](https://github.com/RedisGraph/RedisGraph/issues/752) Use GraphBLAS 3.1.1.
+    - #[674](https://github.com/RedisGraph/RedisGraph/issues/674) `GRAPH.QUERY` will not fail even if graph doesn't exist.
+    - #[613](https://github.com/RedisGraph/RedisGraph/issues/613) Runtime arithmetic error handling.
+- Performance Improvements
+    - #[773](https://github.com/RedisGraph/RedisGraph/issues/773) Bulk deletion of relationships. Deletion of relationships within the same query will be efficiently handled by batch operations in GraphBLAS.
+    - #[783](https://github.com/RedisGraph/RedisGraph/issues/783) Better replication support. Only write queries that mutate the graph or create indices will be replicated to AOF and slaves.
+    - #[783](https://github.com/RedisGraph/RedisGraph/issues/783) Better commit flow. The Redis Global Lock and RedisGraphs's R/W lock are released once writes are done. Fixed duplicate replications in queries with multiple write segments.
+    - #[640](https://github.com/RedisGraph/RedisGraph/issues/640) GraphBlas to support OpenMP.
+    - #[532](https://github.com/RedisGraph/RedisGraph/issues/532) #[535](https://github.com/RedisGraph/RedisGraph/issues/535) Counting edges of given type by reducing matrices.
+    - #[534](https://github.com/RedisGraph/RedisGraph/issues/534) #[571](https://github.com/RedisGraph/RedisGraph/issues/571) Query parsing and `GRAPH.EXPLAIN` in dedicated thread.
+    - #[550](https://github.com/RedisGraph/RedisGraph/issues/550) #[555](https://github.com/RedisGraph/RedisGraph/issues/555) Optimize cartesian product by reducing to join.
+    - #[641](https://github.com/RedisGraph/RedisGraph/issues/641) Cartesian products with multiple incoming streams >2 can now be optimized with "HashJoin".
+- Bugfixes
+    - #[783](https://github.com/RedisGraph/RedisGraph/issues/783) Master-replica replication - slaves were dropping index mutations caused by procedure calls.
+    - #[785](https://github.com/RedisGraph/RedisGraph/issues/785) Solved several major memory leaks.
+    - #[795](https://github.com/RedisGraph/RedisGraph/issues/795) The underlying graph object's attributes were not updated on `RENAME`.
+    - #[720](https://github.com/RedisGraph/RedisGraph/issues/720) Validation of function calls in `WITH` and `CREATE` clauses e.g. `CREATE (a {v: fake()})`.
+    - #[732](https://github.com/RedisGraph/RedisGraph/issues/732), #[736](https://github.com/RedisGraph/RedisGraph/issues/736), #[747](https://github.com/RedisGraph/RedisGraph/issues/747) Detect cycles in graph and generate algebraic expression.
+    - #[734](https://github.com/RedisGraph/RedisGraph/issues/734) Fix access of uninitialised GrB_Info.
+    - #[735](https://github.com/RedisGraph/RedisGraph/issues/735) Index scans with `IN` filters did not compare with strings properly,
+    - #[758](https://github.com/RedisGraph/RedisGraph/issues/758) Validate that during `UNION` all return clauses are annotated.
+    - #[412](https://github.com/RedisGraph/RedisGraph/issues/412) Better handling for `GRAPH.DELETE`.
+    - #[537](https://github.com/RedisGraph/RedisGraph/issues/537) Wrong row index within expand-into, enabled few TCK tests.
+    - #[591](https://github.com/RedisGraph/RedisGraph/issues/591) Emit validation error when an alias refers to both nodes and edges.
+    - #[606](https://github.com/RedisGraph/RedisGraph/issues/606) Fix Record ID of edges held in ExpandInto op.
+    - #[607](https://github.com/RedisGraph/RedisGraph/issues/607) All ops NULL-set variables in their free routines (memory).
+    - #[893](https://github.com/RedisGraph/RedisGraph/issues/893) Preserve the children array order when replacing operations.
+
+{{< note >}}
+The version inside Redis will be 20001 or 2.0.1 in semantic versioning.
+{{< /note >}}---
+Title: RedisGraph release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisGraph release notes for version 2.10 and earlier
+hideListLinks: true
+linkTitle: RedisGraph
+tags:
+- visible
+weight: 70
+---
+
+{{<banner-article>}}
+Redis, Inc. has announced the end of life for RedisGraph. We will carry out the process gradually and in accordance with our commitment to our customers. See [details](https://redis.com/blog/redisgraph-eol/).
+{{</banner-article>}}
+
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: Redis Open Source 8.0.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Open Source 8.0.0 release notes.
+linkTitle: v8.0.0 (May 2025)
+min-version-db: blah
+min-version-rs: blah
+weight: 10
+---
+
+## Redis Open Source 8.0.0 (May 2025)
+
+This is the General Availability release of Redis Open Source 8.0.
+
+Redis 8.0 deprecates previous Redis and Redis Stack versions.
+
+Stand alone RediSearch, RedisJSON, RedisTimeSeries, and RedisBloom modules are no longer needed as they are now part of Redis.
+
+
+### Major changes compared to 7.4.2
+
+- Name change: Redis Community Edition is now Redis Open Source
+- License change: licensed under your choice of 
+  - (a) the Redis Source Available License 2.0 (RSALv2); or
+  - (b) the Server Side Public License v1 (SSPLv1); or
+  - (c) the GNU Affero General Public License (AGPLv3)
+- Redis Query Engine and 8 new data structures are now an integral part of Redis 8.
+  - (1) Redis Query Engine, which now supports both horizontal and vertical scaling for search, query, and vector workloads.
+  - (2) JSON, a queryable JSON document data type.
+  - (3) Time series.
+  - (4-8) Five probabilistic data structures: Bloom filter, Cuckoo filter, Count-min sketch, Top-k, and t-digest.
+  - (9) Vector set [preview], a data structure designed for vector similarity search, inspired by sorted set.
+  - These nine components are included in all binary distributions.
+
+  - See the [build instructions]({{< relref "/operate/oss_and_stack/install/build-stack" >}}) for information about building from source code.
+  - New configuration file: `redis-full.conf`, loads Redis with all components, 
+    and contains new configuration parameters for Redis Query Engine and the new data structures .
+  - New ACL categories: `@search`, `@json`, `@timeseries`, `@bloom`, `@cuckoo`, `@cms`, `@topk`, and `@tdigest`.
+  - Commands are also included in the existing ACL categories such as `@read` and `@write`.
+
+- More than 30 performance and resource utilization improvements.
+- A new I/O threading implementation, which enables throughput increase on multi-core environments
+  (set with the `io-threads` configuration parameter).
+- An improved replication mechanism that is more performant and robust.
+- New hash commands: [HGETDEL]({{< relref "/commands/hgetdel/" >}}), [HGETEX]({{< relref "/commands/hgetex" >}}), and [HSETEX]({{< relref "/commands/hsetex/" >}})
+
+For more details, see the release notes for the [8.0-M01](https://github.com/redis/redis/releases/tag/8.0-m01), [8.0-M02](https://github.com/redis/redis/releases/tag/8.0-m02), [8.0-M03](https://github.com/redis/redis/releases/tag/8.0-m03), [8.0-M04](https://github.com/redis/redis/releases/tag/8.0-m04), and [8.0-RC1](https://github.com/redis/redis/releases/tag/8.0-rc1) releases of Redis Open Source.
+
+### Binary distributions
+
+- [Alpine and Debian Docker images](https://hub.docker.com/_/redis)
+- [Install using snap](https://github.com/redis/redis-snap)
+- [Install using brew](https://github.com/redis/homebrew-redis)
+- [Install using RPM](https://github.com/redis/redis-rpm)
+- [Install using Debian APT](https://github.com/redis/redis-debian)
+
+### Redis 8.0.0 was tested on the following operating systems
+- Ubuntu 20.04 (Focal Fossa), 22.04 (Jammy Jellyfish), and 24.04 (Noble Numbat).
+- Rocky Linux 8.10 and 9.5.
+- AlmaLinux 8.10 and 9.5.
+- Debian 11 (Bullseye) and 12 (Bookworm).
+- macOS 13 (Ventura), 14 (Sonoma), and 15 (Sequoia).
+
+### Supported upgrade paths (by replication or persistence)
+
+- From previous Redis versions without modules.
+- From previous Redis versions with modules (RediSearch, RedisJSON, RedisTimeSeries, RedisBloom).
+- From Redis Stack 7.2 or 7.4.
+
+### Security fixes (compared to 8.0-RC1)
+
+* (CVE-2025-21605) An unauthenticated client can cause an unlimited growth of output buffers
+
+### Bug fixes (compared to 8.0-RC1)
+
+- [#13966](https://github.com/redis/redis/pull/13966), [#13932](https://github.com/redis/redis/pull/13932) `CLUSTER SLOTS` - TLS port update not reflected.
+- [#13958](https://github.com/redis/redis/pull/13958) `XTRIM`, `XADD` - incorrect lag due to trimming stream.
+- [#13931](https://github.com/redis/redis/pull/13931) `HGETEX` - wrong order of keyspace notifications.
+---
+Title: Redis Open Source 8.0.1 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Open Source 8.0.1 release notes.
+linkTitle: v8.0.1 (May 2025)
+min-version-db: blah
+min-version-rs: blah
+weight: 9
+---
+
+## Redis Open Source 8.0.1 (May 2025)
+
+Update urgency: `MODERATE`: Plan an upgrade of the server, but it's not urgent.
+
+### Performance and resource utilization improvements
+
+- [#13959](https://github.com/redis/redis/pull/13959) Vector sets - faster `VSIM` `FILTER` parsing.
+
+### Bug fixes
+
+- [#QE6083](https://github.com/RediSearch/RediSearch/pull/6083) Query Engine - revert default policy `search-on-timeout` to `RETURN`.
+- [#QE6050](https://github.com/RediSearch/RediSearch/pull/6050) Query Engine - `@__key` on `FT.AGGREGATE` used as reserved field name preventing access to Redis keyspace.
+- [#QE6077](https://github.com/RediSearch/RediSearch/pull/6077) Query Engine - crash when calling `FT.CURSOR DEL` while reading from the CURSOR.
+
+### Notes
+
+- Fixed incorrect text in the license files.
+---
+Title: Redis Community Edition 7.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Community Edition 7.4 release notes.
+linkTitle: v7.4.0 (July 2024)
+min-version-db: blah
+min-version-rs: blah
+weight: 100
+---
+
+## Redis Community Edition 7.4.2 (Jan 2025)
+
+Upgrade urgency SECURITY: See security fixes below.
+
+### Security fixes
+
+- (CVE-2024-46981) Lua script commands may lead to remote code execution
+- (CVE-2024-51741) Denial-of-service due to malformed ACL selectors
+
+### Bug fixes
+
+- [#13627](https://github.com/redis/redis/pull/13627) Crash on module memory defragmentation
+- [#13338](https://github.com/redis/redis/pull/13338) Streams: `XINFO` lag field is wrong when tombstone is after the `last_id` of the consume group
+- [#13473](https://github.com/redis/redis/pull/13473) Streams: `XTRIM` does not update the maximal tombstone, leading to an incorrect lag
+- [#13470](https://github.com/redis/redis/pull/13470) `INFO` after `HDEL` show wrong number of hash keys with expiration
+- [#13476](https://github.com/redis/redis/pull/13476) Fix a race condition in the `cache_memory` of `functionsLibCtx`
+- [#13626](https://github.com/redis/redis/pull/13626) Memory leak on failed RDB loading
+- [#13539](https://github.com/redis/redis/pull/13539) Hash: fix key ref for a hash that no longer has fields with expiration on `RENAME`/`MOVE`/`SWAPDB`/`RESTORE`
+- [#13443](https://github.com/redis/redis/pull/13443) Cluster: crash when loading cluster config
+- [#13422](https://github.com/redis/redis/pull/13422) Cluster: `CLUSTER SHARDS` returns empty array
+- [#13465](https://github.com/redis/redis/pull/13465) Cluster: incompatibility with older node versions
+- [#13608](https://github.com/redis/redis/pull/13608) Cluster: `SORT ... GET #`: incorrect error message
+
+## Redis Community Edition 7.4.1 (October 2024)
+
+Upgrade urgency SECURITY: See security fixes below.
+
+### Security fixes
+* (CVE-2024-31449) Lua library commands may lead to stack overflow and potential RCE.
+* (CVE-2024-31227) Potential Denial-of-service due to malformed ACL selectors.
+* (CVE-2024-31228) Potential Denial-of-service due to unbounded pattern matching.
+
+For more information, see the [Redis blog post](https://redis.io/blog/security-advisory-cve-2024-31449-cve-2024-31227-cve-2024-31228/) about these vulnerabilities.
+
+## Redis Community Edition 7.4 (July 2024)
+
+This is the General Availability release of Redis Community Edition 7.4.
+
+**Changes to new 7.4 features (compared to 7.4 RC2)**
+* [#13391](https://github.com/redis/redis/pull/13391),[#13438](https://github.com/redis/redis/pull/13438) Hash - expiration of individual fields: RDB file format changes
+* [#13372](https://github.com/redis/redis/pull/13372) Hash - expiration of individual fields: rename and fix counting of `expired_subkeys` metric
+* [#13372](https://github.com/redis/redis/pull/13372) Hash - expiration of individual fields: rename `INFO` keyspace field to `subexpiry`
+
+**Configuration parameters**
+* [#13400](https://github.com/redis/redis/pull/13400) Add hide-user-data-from-log - allows hiding user data from the log file
+
+**Bug fixes**
+* [#13407](https://github.com/redis/redis/pull/13407) Trigger Lua GC after `SCRIPT LOAD`
+* [#13380](https://github.com/redis/redis/pull/13380) Fix possible crash due to OOM panic on invalid command
+* [#13383](https://github.com/redis/redis/pull/13383) `FUNCTION FLUSH` - improve Lua GC behavior and fix thread race in ASYNC mode
+* [#13408](https://github.com/redis/redis/pull/13408) `HEXPIRE`-like commands should emit `HDEL` keyspace notification if expire time is in the past
+
+## Redis Community Edition 7.4-rc2 (June 2024)
+Upgrade urgency LOW: This is the second Release Candidate for Redis Community Edition 7.4.
+
+**Performance and resource utilization improvements**
+* [#13296](https://github.com/redis/redis/pull/13296) Optimize CPU cache efficiency
+
+**Changes to new 7.4 new features (compared to 7.4 RC1)**
+* [#13343](https://github.com/redis/redis/pull/13343) Hash - expiration of individual fields: when key does not exist - reply with an array (nonexisting code for each field)
+* [#13329](https://github.com/redis/redis/pull/13329) Hash - expiration of individual fields: new keyspace event: `hexpired`
+
+**Modules API - Potentially breaking changes to new 7.4 features (compared to 7.4 RC1)**
+* [#13326](https://github.com/redis/redis/pull/13326) Hash - expiration of individual fields: avoid lazy expire when called from a Modules API function
+
+## Redis Community Edition 7.4-rc1 (June 2024)
+
+Upgrade urgency LOW: This is the first Release Candidate for Redis Community Edition 7.4.
+
+Here is a comprehensive list of changes in this release compared to 7.2.5.
+
+**New Features**
+* [#13303](https://github.com/redis/redis/pull/13303) Hash - expiration of individual fields. 9 commands were introduced:
+  - `HEXPIRE` and `HPEXPIRE` set the remaining time to live for specific fields
+  - `HEXPIREAT` and `HPEXPIREAT` set the expiration time to a UNIX timestamp for specific fields
+  - `HPERSIST` removes the expiration for specific fields
+  - `HEXPIRETIME` and `HPEXPIRETIME` get the expiration time for specific fields
+  - `HTTL` and `HPTTL` get the remaining time to live for specific fields
+* [#13117](https://github.com/redis/redis/pull/13117) `XREAD`: new id value `+` to start reading from the last message
+* [#12765](https://github.com/redis/redis/pull/12765) `HSCAN`: new `NOVALUES` flag to report only field names
+* [#12728](https://github.com/redis/redis/pull/12728) `SORT`, `SORT_RO`: allow `BY` and `GET` options in cluster mode when the pattern maps to the same slot as the key
+* [#12299](https://github.com/redis/redis/pull/12299) `CLIENT KILL`: new optional filter: `MAXAGE maxage` - kill connections older than `maxage` seconds
+* [#12971](https://github.com/redis/redis/pull/12971) Lua: expose `os.clock()` API for getting the elapsed time of Lua code execution
+* [#13276](https://github.com/redis/redis/pull/13276) Allow `SPUBLISH` command within `MULTI ... EXEC` transactions on replica
+
+**Bug fixes**
+* [#12898](https://github.com/redis/redis/pull/12898) `XREADGROUP`: fix entries-read inconsistency between master and replicas
+* [#13042](https://github.com/redis/redis/pull/13042) `SORT ... STORE`: fix created lists to respect list compression and packing configs
+* [#12817](https://github.com/redis/redis/pull/12817), [#12905](https://github.com/redis/redis/pull/12905) Fix race condition issues between the main thread and module threads
+* [#12577](https://github.com/redis/redis/pull/12577) Unsubscribe all clients from replica for shard channel if the master ownership changes
+* [#12622](https://github.com/redis/redis/pull/12622) `WAITAOF` could timeout or hang if used after a module command that propagated effects only to replicas and not to AOF
+* [#11734](https://github.com/redis/redis/pull/11734) `BITCOUNT` and `BITPOS` with nonexistent key and illegal arguments return an error, not 0
+* [#12394](https://github.com/redis/redis/pull/12394) `BITCOUNT`: check for wrong argument before checking if key exists
+* [#12961](https://github.com/redis/redis/pull/12961) Allow execution of read-only transactions when out of memory
+* [#13274](https://github.com/redis/redis/pull/13274) Fix crash when a client performs ACL change that disconnects itself
+* [#13311](https://github.com/redis/redis/pull/13311) Cluster: Fix crash due to unblocking client during slot migration
+
+**Security improvements**
+* [#13108](https://github.com/redis/redis/pull/13108) Lua: LRU eviction for scripts generated with `EVAL` *** BEHAVIOR CHANGE ***
+* [#12961](https://github.com/redis/redis/pull/12961) Restrict the total request size of `MULTI ... EXEC` transactions
+* [#12860](https://github.com/redis/redis/pull/12860) Redact ACL username information and mark `*-key-file-pass configs` as sensitive
+
+
+**Performance and resource utilization improvements**
+* [#12838](https://github.com/redis/redis/pull/12838) Improve performance when many clients call `PUNSUBSCRIBE` / `SUNSUBSCRIBE` simultaneously
+* [#12627](https://github.com/redis/redis/pull/12627) Reduce lag when waking `WAITAOF` clients and there is not much traffic
+* [#12754](https://github.com/redis/redis/pull/12754) Optimize `KEYS` when pattern includes hashtag and implies a single slot
+* [#11695](https://github.com/redis/redis/pull/11695) Reduce memory and improve performance by replacing cluster metadata with slot specific dictionaries
+* [#13087](https://github.com/redis/redis/pull/13087) `SCRIPT FLUSH ASYNC` now does not block the main thread
+* [#12996](https://github.com/redis/redis/pull/12996) Active memory defragmentation efficiency improvements
+* [#12899](https://github.com/redis/redis/pull/12899) Improve performance of read/update operation during rehashing
+* [#12536](https://github.com/redis/redis/pull/12536) `SCAN ... MATCH`: Improve performance when the pattern implies cluster slot
+* [#12450](https://github.com/redis/redis/pull/12450) `ZRANGE ... LIMIT`: improved performance
+
+
+**Other general improvements**
+* [#13133](https://github.com/redis/redis/pull/13133) Lua: allocate VM code with jemalloc instead of libc and count it as used memory *** BEHAVIOR CHANGE ***
+* [#12171](https://github.com/redis/redis/pull/12171) `ACL LOAD`: do not disconnect all clients *** BEHAVIOR CHANGE ***
+* [#13020](https://github.com/redis/redis/pull/13020) Allow adjusting defrag configurations while active defragmentation is running
+* [#12949](https://github.com/redis/redis/pull/12949) Increase the accuracy of avg_ttl (the average keyspace keys TTL)
+* [#12977](https://github.com/redis/redis/pull/12977) Allow running `WAITAOF` in scripts
+* [#12782](https://github.com/redis/redis/pull/12782) Implement TCP Keep-Alives across most Unix-like systems
+* [#12707](https://github.com/redis/redis/pull/12707) Improved error codes when rejecting scripts in cluster mode
+* [#12596](https://github.com/redis/redis/pull/12596) Support `XREAD ... BLOCK` in scripts; rejected only if it ends up blocking
+
+**New metrics**
+* [#12849](https://github.com/redis/redis/pull/12849) `INFO`: `pubsub_clients` - number of clients in Pub/Sub mode
+* [#12966](https://github.com/redis/redis/pull/12966) `INFO`: `watching_clients` - number of clients that are watching keys
+* [#12966](https://github.com/redis/redis/pull/12966) `INFO`: `total_watched_keys` - number of watched keys
+* [#12476](https://github.com/redis/redis/pull/12476) `INFO`: `client_query_buffer_limit_disconnections` - count client input buffer OOM events
+* [#12476](https://github.com/redis/redis/pull/12476) `INFO`: `client_output_buffer_limit_disconnections` - count client output buffer OOM events
+* [#12996](https://github.com/redis/redis/pull/12996) `INFO`: `allocator_muzzy` - memory returned to the OS but still shows as RSS until the OS reclaims it
+* [#13108](https://github.com/redis/redis/pull/13108) `INFO`: `evicted_scripts` - number of evicted eval scripts. Users can check it to see if they are abusing EVAL
+* [#12996](https://github.com/redis/redis/pull/12996) `MEMORY STATS`: `allocator.muzzy` - memory returned to the OS but still shows as RSS until the OS reclaims it
+* [#12913](https://github.com/redis/redis/pull/12913) `INFO MEMORY` `mem_overhead_db_hashtable_rehashing` - memory resharding overhead (only the memory that will be released soon)
+* [#12913](https://github.com/redis/redis/pull/12913) `MEMORY STATS`: `overhead.db.hashtable.lut` - total overhead of dictionary buckets in databases
+* [#12913](https://github.com/redis/redis/pull/12913) `MEMORY STATS`: `overhead.db.hashtable.rehashing` - temporary memory overhead of database dictionaries currently being rehashed 
+* [#12913](https://github.com/redis/redis/pull/12913) `MEMORY STATS`: `db.dict.rehashing.count` - number of top level dictionaries currently being rehashed
+* [#12966](https://github.com/redis/redis/pull/12966) `CLIENT LIST`: `watch` - number of keys each client is currently watching
+
+**Modules API**
+* [#12985](https://github.com/redis/redis/pull/12985) New API calls: `RM_TryCalloc` and `RM_TryRealloc` - allow modules to handle memory allocation failures gracefully
+* [#13069](https://github.com/redis/redis/pull/13069) New API call: `RM_ClusterKeySlot` - which slot a key will hash to
+* [#13069](https://github.com/redis/redis/pull/13069) New API call: `RM_ClusterCanonicalKeyNameInSlot` - get a consistent key that will map to a slot 
+* [#12486](https://github.com/redis/redis/pull/12486) New API call: `RM_AddACLCategory` - allow modules to declare new ACL categories
+
+
+**Configuration parameters**
+* [#12178](https://github.com/redis/redis/pull/12178) New configuration parameters: `max-new-connections-per-cycle` and `max-new-tls-connections-per-cycle` to limit the number of new client connections per event-loop cycle
+* [#7351](https://github.com/redis/redis/pull/7351) Rename some CPU configuration parameters for style alignment. Added alias to the old names to avoid breaking change
+
+**CLI tools**
+* [#10609](https://github.com/redis/redis/pull/10609) redis-cli: new `-t <timeout>` argument: specify server connection timeout in seconds
+* [#11315](https://github.com/redis/redis/pull/11315) redis-cli: new `-4` and `-6` flags to prefer IPV4 or IPV6 on DNS lookup
+* [#12862](https://github.com/redis/redis/pull/12862) redis-cli: allows pressing up arrow to return any command (including sensitive commands which are still not persisted)
+* [#12543](https://github.com/redis/redis/pull/12543) redis-cli: add reverse history search (like Ctrl+R in terminals)
+* [#12826](https://github.com/redis/redis/pull/12826) redis-cli: add `--keystats` and `--keystats-samples` to combines `--memkeys` and `--bigkeys` with additional distribution data
+* [#12735](https://github.com/redis/redis/pull/12735) redis-cli: fix: `--bigkeys` and `--memkeys` now work on cluster replicas
+* [#9411](https://github.com/redis/redis/pull/9411) redis-benchmark: add support for binary strings
+* [#12986](https://github.com/redis/redis/pull/12986) redis-benchmark: fix: pick random slot for a node to distribute operation across slots
+---
+Title: Redis Open Source release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Open Source release notes for version 7.4 and later
+hideListLinks: true
+linkTitle: Redis Open Source
+tags:
+- visible
+weight: 10
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: RedisGears 1.0 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: First GA release of RedisGears. Built-in C-API and Python interpreter.
+  Run a serverless engine in memory next to your Redis data.
+linkTitle: v1.0 (May 2020)
+min-version-db: 6.0.0
+min-version-rs: 6.0.0
+weight: 100
+---
+Here's what's changed recently in RedisGears. 
+
+To learn more, see the linked pull requests.
+
+## Requirements
+
+RedisGears v1.0.9 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.0
+
+## v1.0.9 (January 2022)
+
+This is a maintenance release for RedisGears 1.0
+
+Update urgency: `LOW` : No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+    - [#652](https://github.com/RedisGears/RedisGears/pull/652) Support for keys space notifications coming from other modules.
+
+## v1.0.8 (November 2021)
+
+This is a maintenance release for RedisGears 1.0.
+
+Update urgency: `MODERATE` - Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Minor features:
+
+    - [#624](https://github.com/RedisGears/RedisGears/pull/624), [#626](https://github.com/RedisGears/RedisGears/pull/626) Update Python interpreter version to 3.7.12
+
+- Bug fixes:
+
+    - [#610](https://github.com/RedisGears/RedisGears/pull/610) Fix symbol collision with RediSearch and RedisGraph that causes deadlock
+
+    - [#609](https://github.com/RedisGears/RedisGears/pull/609), [#611](https://github.com/RedisGears/RedisGears/pull/611) Crash on stream reader where stream is deleted during read
+
+    - [#612](https://github.com/RedisGears/RedisGears/pull/612) Return error when GearsBuilder is used after `registered` or `run`
+
+    - [#613](https://github.com/RedisGears/RedisGears/pull/613) Rare issue where stream reader might trigger executions on replica
+
+    - [#629](https://github.com/RedisGears/RedisGears/pull/629) Rare deadlock on stream reader
+
+## v1.0.7 (August 2021)
+
+This is a maintenance release for version 1.0.
+
+Update urgency: `LOW` - No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Minor Features:
+
+    - [#594](https://github.com/RedisGears/RedisGears/pull/594) Added RedisGears info section to Redis info command
+
+    - [#587](https://github.com/RedisGears/RedisGears/pull/587) `inorder` option for the command reader
+    
+    - [#592](https://github.com/RedisGears/RedisGears/pull/592), [#586](https://github.com/RedisGears/RedisGears/pull/586) Background executions will now appear on Redis slowlog, available in Redis 6.2 and above.
+
+## v1.0.6 (March 2021)
+
+This is a maintenance release for version 1.0.
+
+- Update urgency: Medium
+
+- Highlights:
+
+    This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bug fixes:
+
+    - #[496](https://github.com/RedisGears/RedisGears/pull/496) Allow parallel execution on Command Reader.
+
+    - #[505](https://github.com/RedisGears/RedisGears/pull/505) Crash on a client that sends cluster set and disconnects.
+
+## v1.0.5 (18 January 2021)
+
+This is a maintenance release for version 1.0.
+
+- Update urgency: High
+
+- Highlights:
+
+    This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bug fixes:
+
+    - #[480](https://github.com/RedisGears/RedisGears/pull/480) Crash when map/accumulate/accumulateby raises an error which causes the same pyobject to be freed twice.
+
+    - #[480](https://github.com/RedisGears/RedisGears/pull/480) 'Cluster set' happened before resending hello request, which caused a crash.
+
+    - #[480](https://github.com/RedisGears/RedisGears/pull/480) Memory leaks on 'cluster set'.
+
+## v1.0.4 (17 January 2021)
+
+This is a maintenance release for version 1.0.
+
+- Highights:
+
+    This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bug fixes:
+
+    - #[458](https://github.com/RedisGears/RedisGears/pull/458) Crash on StreamReader when the stream is dropped during processing of the function.
+
+    - #[477](https://github.com/RedisGears/RedisGears/pull/477) Rare crash on accumulate step.
+
+## v1.0.3 (November 2020)
+
+This is a maintenance release for version 1.0.
+
+- Highlights:
+
+    This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Bug fixes:
+
+    - #[427](https://github.com/RedisGears/RedisGears/pull/427) Rare issue where messages might get lost and cause executions timeouts.
+
+    - #[434](https://github.com/RedisGears/RedisGears/pull/434) Triggering an execution on uninitialized cluster state should raise a cluster uninitialized error.
+
+## v1.0.2 (October 2020)
+
+This is a maintenance release for version 1.0.
+
+- Highlights:
+
+    This release improves overall stability and provides fixes for issues found after the previous release.
+
+- Details:
+
+    - Minor Features:
+        - #[368](https://github.com/RedisGears/RedisGears/pull/368) Support for buffer input on `createTensorFromBlob` when integrating with [RedisAI](https://github.com/RedisAI/RedisAI) API.
+
+        - #[373](https://github.com/RedisGears/RedisGears/pull/373) Registered execution plans will not re-send their metadata when they are triggered (this feature reduces network overhead and improve performance of distributed registrations).
+
+        - #[371](https://github.com/RedisGears/RedisGears/pull/371) Full details on import requirement failure.
+
+    - Bug fixes:
+
+        - #[374](https://github.com/RedisGears/RedisGears/pull/374) Fix RedisAI `toFlatList` function to handle long long encoding.
+
+        - #[375](https://github.com/RedisGears/RedisGears/pull/375) Call `OnRegister` on RDBLoad.
+        
+        - #[388](https://github.com/RedisGears/RedisGears/pull/388) Fix crash on hello request failure (internal protocol between shards), a retry will be triggered after 1 second.
+
+        - #[395](https://github.com/RedisGears/RedisGears/pull/395) Fix rare wrong results on `aggregate` and `aggregateby`. Use deep copy on the zero value to avoid those incorrect results.
+
+## v1.0.1 (July 2020)
+
+This is a maintenance release for version 1.0.
+
+- Highlights:
+
+    - *Import and Export requirements* - With this capability, you can export the python requirements present in RedisGears and import them into another instance using [gears-cli](https://github.com/RedisGears/gears-cli). 
+    
+        This enables, amongst others, to import requirements to environments without internet access. Notice that the requirement should be exported from and imported into machines with the same OS and version. This is the recommended tool to use for productionising RedisGears functions (for example to be used in your CI).
+
+    - *Optimised requirements installation mechanism* - requirements will now be distributed once to each shard and not each time an execution is triggered.
+
+    - *RedisAI API fixes and additions* - fixes/additions related to the integration with RedisAI.
+
+- Details:
+
+    - Features:
+
+        - #[330](https://github.com/RedisGears/RedisGears/pull/330) `SendMsgRetries` configuration parameter indicating how many times RedisGears should try sending messages between shards.
+
+        - #[330](https://github.com/RedisGears/RedisGears/pull/330) `PythonInstallReqMaxIdleTime` configuration parameter for the maximum amount of time to wait for requirements to be installed.
+
+        - #[330](https://github.com/RedisGears/RedisGears/pull/330) `RG.PYDUMPREQ` command that output all the currently available python requirements.
+
+        - Added the following API functionality to the RedisAI integration:
+
+            - #[346](https://github.com/RedisGears/RedisGears/pull/346) Script run will now return a list of tensors.
+
+            - #[347](https://github.com/RedisGears/RedisGears/pull/347) Allow tensor creation from bytes.
+
+            - #[350](https://github.com/RedisGears/RedisGears/pull/350) Added mget and mset to get/set multiple tensors from/to the keyspace.
+
+            - #[345](https://github.com/RedisGears/RedisGears/pull/345) Free python GIL before calling redisAI model/script run.
+
+    - Bug fixes:
+
+        - #[325](https://github.com/RedisGears/RedisGears/pull/325) Circular reference that caused a logical memory leak.
+
+        - #[330](https://github.com/RedisGears/RedisGears/pull/330) Crash on wrong reply status.
+
+        - #[345](https://github.com/RedisGears/RedisGears/pull/345) Crash on python session (private data on rg.dumpregistration) 'tostr' function when there is no requirements.
+
+        - #[334](https://github.com/RedisGears/RedisGears/pull/334) Type check to RedisAI API to prevent potential crashes.
+
+## v1.0.0 (May 2020)
+
+This is the first general availability (GA) release of RedisGears (v1.0.0).
+
+- Highlights:
+
+    - Program everything you want in Redis - With a built-in C-API and Python interpreter, RedisGears lets you use full-fledged Python scripts and libraries to process data inside Redis.
+
+    - Write once, deploy anywhere - Write your functions against a standalone Redis database and deploy them to production clusters—with no changes required.
+
+    - Run your serverless engine where your data lives - RedisGears lets you process events and streams faster by running in memory next to your data in Redis.
+
+    Bug fixes (compared to RC1):
+
+    - #[288](https://github.com/RedisGears/RedisGears/issues/288) dependencies with version will not crash the server.
+
+    - #[309](https://github.com/RedisGears/RedisGears/issues/309), #[313](https://github.com/RedisGears/RedisGears/issues/313) Prevent crashes on RedisAI intergration and update the low level C api of RedisAI.
+
+    - #[311](https://github.com/RedisGears/RedisGears/issues/311) Fix out-of-order reply in certain situations.
+
+    - #[321](https://github.com/RedisGears/RedisGears/issues/321) Return error when unknown argument is given.
+
+{{< note >}}
+- The version inside Redis will be 10000 or 1.0.0 in semantic versioning.
+- This version requires the Redis version to be 6.0 and above.
+{{< /note >}}
+---
+Title: RedisGears 1.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Plugins and JVM support. Python async await. Override commands API. Register
+  functions on key miss events. Tracks new statistics. Python profiler support. Extended
+  RedisAI integration.
+linkTitle: v1.2 (February 2022)
+min-version-db: 6.0.0
+min-version-rs: 6.0.12
+weight: 99
+---
+
+## Requirements
+
+RedisGears v1.2.12 requires:
+
+- Minimum Redis compatibility version (database): 6.0.0
+- Minimum Redis Enterprise Software version (cluster): 6.0.12
+
+## 1.2.12 (December 2024)
+
+This is a maintenance release for RedisGears 1.2
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+Details
+
+- Bug fixes:
+  - [#1125](https://github.com/redisgears/redisgears/pull/1125) The same registration ID might be generated twice. This may lead to an RDB corruption.
+  - [#1121](https://github.com/redisgears/redisgears/pull/1121) Recreate the virtual environment on startup. Fixes an issue where the virtual environment might point to the old version of the Python interpreter.
+  - [#1122](https://github.com/redisgears/redisgears/pull/1122) Clear the last error after a successful run to avoid confusion if the error is relevant.
+  - [#1122](https://github.com/redisgears/redisgears/pull/1122) Clear not-yet-started executions after unregister, pause, or error on registration occcurs. (MOD-8184)
+
+## 1.2.10 (October 2024)
+
+This is a maintenance release for RedisGears 1.2
+
+Update urgency: `LOW`: No need to upgrade unless there are new features or fixes.
+
+Details
+
+- Bug fixes:
+  - [#1114](https://github.com/redisgears/redisgears/pull/1114) (REPLICAOF and Redis Enterprise A-A only) Cross slot violation. Avoid using `RM_Call` + `SCAN` command which might replicate multiple keys deletion inside a `MULTI EXEC` block when a lazy expire takes place
+
+- Notes:
+  - RHEL7 is no longer supported
+
+## 1.2.9 (March 2024)
+
+This is a maintenance release for RedisGears 1.2
+
+Update urgency: `LOW`: No need to upgrade unless there are new features or fixes.
+
+Details
+
+- Features:
+
+  - [#1087](https://github.com/RedisGears/RedisGears/pull/1087) Support for RHEL9
+  - [#986](https://github.com/RedisGears/RedisGears/pull/986) Added execution mode parameter to `run` function: allows choosing the execution mode: `sync`/`async`/`async_local` - same as when used with register
+
+- Bug fixes:
+
+  - [#1097](https://github.com/RedisGears/RedisGears/pull/1097) Fix stream reader missing notification due to wrong key name comparison (comparing using case sensitive)
+
+## 1.2.7 (July 2023)
+
+This is a maintenance release for RedisGears 1.2
+
+Update urgency: `LOW`: No need to upgrade unless there are new features or fixes.
+
+Details
+
+- Features:
+
+  - [#972](https://github.com/RedisGears/RedisGears/pull/972) Upgrade JVM to 17.0.7
+
+## 1.2.6 (March 2023)
+
+This is a maintenance release for RedisGears 1.2.
+
+Update urgency: `LOW` : No need to upgrade unless there are new features or fixes.
+
+Details
+
+- Features:
+
+  - [#832](https://github.com/RedisGears/RedisGears/pull/832), [#844](https://github.com/RedisGears/RedisGears/pull/844) Added IPV6 support
+  - [#841](https://github.com/RedisGears/RedisGears/pull/841) Generate artifacts with dependencies included
+
+- Bug fixes:
+
+  - [#810](https://github.com/RedisGears/RedisGears/pull/810) Fix invalid memory access when checking if a trigger is already registered
+
+## v1.2.5 (July 2022)
+
+This is a maintenance release for RedisGears 1.2.
+
+Update urgency: `MODERATE` : Program an upgrade of the server, but it's not urgent.
+
+Details:
+
+- Bug fixes:
+
+    - [#792](https://github.com/RedisGears/RedisGears/issues/792), [#798](https://github.com/RedisGears/RedisGears/pull/798) Execution was triggered infinitely when trimming is turned off.
+    - [#791](https://github.com/RedisGears/RedisGears/issues/791), [#796](https://github.com/RedisGears/RedisGears/pull/796) Stop triggering executions during pause even on failure.
+    - [#794](https://github.com/RedisGears/RedisGears/pull/794), [#797](https://github.com/RedisGears/RedisGears/pull/797) Use `PythonInstallationDir` configuration to find the virtual environment location on Redis Enterprise. (MOD-1734)
+
+## v1.2.4 (May 2022)
+
+This is a maintenance release for RedisGears 1.2.
+
+Update urgency: `LOW` : No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+    - [#772](https://github.com/RedisGears/RedisGears/pull/772) Added the ability to upgrade a dependency at runtime with `FORCE_REQUIREMENTS_REINSTALLATION` on `RG.PYEXECUTE`.
+    - [#765](https://github.com/RedisGears/RedisGears/pull/765) Allow deactivating override Python allocators for performance improvements.
+
+- Bug fixes:
+
+    - [#761](https://github.com/RedisGears/RedisGears/issues/761), [#760](https://github.com/RedisGears/RedisGears/issues/760), [#778](https://github.com/RedisGears/RedisGears/pull/778) `StreamReader` fixes to pause and unregister stream processing.
+
+## v1.2.3 (April 2022)
+
+This is a maintenance release for RedisGears 1.2.
+
+Update urgency: `LOW` : No need to upgrade unless there are new features you want to use.
+
+Details:
+
+- Improvements:
+
+    - [#739](https://github.com/RedisGears/RedisGears/pull/739) Added TLS support
+    - [#734](https://github.com/RedisGears/RedisGears/pull/734) Pause/Unpause registrations
+    - [#741](https://github.com/RedisGears/RedisGears/pull/741) Added build for Python-only artifacts
+
+- Bug fixes:
+
+    - [#740](https://github.com/RedisGears/RedisGears/pull/740) Fix -nan value on registration stats
+
+## v1.2.2 (February 2022)
+
+This is the General Availability release of RedisGears 1.2.
+
+### Headlines
+
+#### Plugins and JVM support
+
+RedisGears 1.2 comes with a new plugin mechanism that allows you to decide which languages you want to load into RedisGears. Currently, we support two languages: Python and Java (JVM languages). You can decide which language you want to use using the new `Plugin` configuration.
+
+Full documentation for JVM support can be found on the [Redis documentation website]({{< relref "/operate/oss_and_stack/stack-with-enterprise/gears-v1/jvm" >}}).
+
+#### Python async await support
+
+RedisGears provides support for Python coroutines. Each step of your gears function can now be a Python coroutine that will take the execution to the background or will wait for some event to happen. Refer to the following links for more information:
+
+- Async Await Support
+- Async Await Advanced Topics
+
+#### Override commands API
+
+You can override Redis vanilla commands with a function. For more information, refer to the RedisGears command hooks documentation.
+
+#### Key miss event for read-through pattern
+
+Requested by many users, RedisGears 1.2 allows you to register functions on key miss event. One use case for this is to implement a read-through caching pattern. For more information about this topic, refer to the following links:
+
+- Key Miss Event in the RedisGears documentation.
+- [rghibernate](https://github.com/RedisGears/rghibernate) recipe that leverages the key miss event to implement read-through from external databases.
+
+#### Better visibility and analyzing tools
+
+We improved the experience during the development phase by enabling better debugging and troubleshooting. There is still room for improvement but RedisGears 1.2 makes the first steps toward a simpler API that is easier to use. This new version allows you to name your code and upgrade it with a single Redis command. For more information, refer to the upgrade section of the RedisGears introduction documentation.
+
+RedisGears now tracks the following new statistics to better analyze your registrations:
+
+- `lastRunDurationMS` - duration in milliseconds of the last execution
+- `totalRunDurationMS` - total runtime of all executions in milliseconds
+- `avgRunDurationMS` - average execution runtime in milliseconds
+
+For streams, RedisGears also tracks the following data:
+
+- `lastEstimatedLagMS` - gives the last batch lag (the time difference between the first batch entry in the stream and the time the entire batch finished processing)
+- `avgEstimatedLagMS` - average of the `lastEstimatedLagMS` field.
+
+The `RG.DUMPREGISTRATIONS` command exposes these new statistics.
+
+RedisGears 1.2 also adds support for a Python profiler, specifically [`cProfile`](https://docs.python.org/3.7/library/profile.html#module-cProfile). For more information, refer to the documentation for the following commands:
+
+- `RG.PYPROFILE STATS`
+- `RG.PYPROFILE RESET`
+
+#### RedisAI integration
+
+Although RedisAI integration was already supported in v1.0, RedisGears 1.2 adds official support for all capabilities in RedisAI v1.2. The API was extended to support RedisAI DAG and was combined with the new async await API to achieve the best performance possible.
+
+### Details
+
+Bug fixes (since 1.0.9):
+
+- [#557](https://github.com/RedisGears/RedisGears/pull/557), [#554](https://github.com/RedisGears/RedisGears/issues/554) `RG.CONFIGGET` returns user-defined configuration
+- [#572](https://github.com/RedisGears/RedisGears/pull/572) Lock Redis GIL when creating RedisAI DAG
+- [#661](https://github.com/RedisGears/RedisGears/pull/661), [#536](https://github.com/RedisGears/RedisGears/issues/536) Added `RG.TRIGGERONKEY`
+- [#650](https://github.com/RedisGears/RedisGears/issues/650) Do not propagate `MULTI EXEC` on Redis 7
+- [#671](https://github.com/RedisGears/RedisGears/pull/671), [#558](https://github.com/RedisGears/RedisGears/issues/558) Wait for cluster to be initialized when reading stream data
+- [#656](https://github.com/RedisGears/RedisGears/pull/656) Stream reader creates more than one execution on a stream
+- [#676](https://github.com/RedisGears/RedisGears/pull/676) Globals dictionary not set correctly after deserialization
+- [#665](https://github.com/RedisGears/RedisGears/issues/665), [#679](https://github.com/RedisGears/RedisGears/pull/679) Allow case-insensitive event type on command reader
+- [#697](https://github.com/RedisGears/RedisGears/pull/697) `hashtag()` function for Redis Enterprise
+- [#688](https://github.com/RedisGears/RedisGears/pull/688), [#545](https://github.com/RedisGears/RedisGears/issues/545) Check `REDISMODULE_CTX_FLAGS_DENY_BLOCKING` flag before blocking the client
+
+{{<note>}}
+- This is the first GA version of 1.2. The version inside Redis is 1.2.2 in semantic versioning. Since the version of a module in Redis is numeric, we could not add a GA flag.
+
+- Minimum Redis version: 6.0.0
+{{</note>}}
+---
+Title: RedisGears release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: RedisGears release notes for version 1.2 and earlier
+hideListLinks: true
+linkTitle: RedisGears
+tags:
+- visible
+weight: 80
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes,Min&nbsp;Redis<br/>version,Min&nbsp;cluster<br/>version" columnSources="LinkTitle,Description,min-version-db,min-version-rs" enableLinks="LinkTitle" >}}
+---
+Title: Redis Open Source and modules release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Open Source and modules release notes
+hideListLinks: true
+linkTitle: Release notes
+weight: 99
+---
+
+See the following release notes for new features, enhancements, and other changes to Redis Open Source capabilities.
+
+{{<table-children columnNames="Release notes,Description" columnSources="LinkTitle,Description" enableLinks="LinkTitle" limitTags="visible">}}---
+Title: Redis Stack 7.2 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Stack 7.2 release notes.
+linkTitle: v7.2.0-v0 (August 2023)
+weight: 100
+---
+## Redis Stack 7.2.0-v13 (October 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `SECURITY`: there are security fixes in the release.
+
+[Docker](https://hub.docker.com/r/redis/redis-stack) | [Download](https://redis.io/downloads/#stack)
+
+### Headlines:
+This version includes security fixes for the **Redis** server, addressing potential vulnerabilities such as an RCE when using Lua library components, and a denial-of-service (DoS) risk due to malformed ACL selectors or unbounded pattern matching.
+Additionally, this maintenance release contains a bug fix to prevent crashes in cluster mode and includes the latest version of **Redis Insight**.
+
+### Details:
+ **Security and privacy**
+* **Redis**:
+  * (CVE-2024-31449) Lua library commands may lead to stack overflow and potential RCE.
+  * (CVE-2024-31227) Potential Denial-of-service due to malformed ACL selectors.
+  * (CVE-2024-31228) Potential Denial-of-service due to unbounded pattern matching.
+
+**Bug Fixes**
+* **Redis**:
+  *  [#13315](https://github.com/redis/redis/pull/13315) Fixed crashes in cluster mode
+
+* **Redis version**:
+  * __[Redis 7.2.6](https://github.com/redis/redis/releases/tag/7.2.6)__
+
+**Module versions**	
+* __[RediSearch 2.8.15](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.15)__
+* __[RedisJSON 2.6.11](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.11)__
+* __[RedisTimeSeries 1.10.13](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.12)__
+* __[RedisBloom 2.6.12](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.12)__
+* __[RedisGears 2.0.23](https://github.com/RedisGears/RedisGears/releases)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.2.0 or greater](https://github.com/redis/jedis/releases/tag/v5.2.0)
+  * [redis-om-spring 0.9.5 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.9.5)
+* Python
+  * [redis-py 5.1.0 or greater](https://github.com/redis/redis-py/releases/tag/v5.1.0)
+  * [redis-om-python 0.3.2 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.3.2)
+* NodeJS
+  * [node-redis 4.7.0 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.4 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.4)
+  * [NRedisStack 0.13.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.13.0)
+* Go
+  * [go-redis 9.6.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+  * [rueidis 1.0.47 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.47)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.58](https://github.com/RedisInsight/RedisInsight/releases/tag/2.58.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v12 (August 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+The updated **search and query**  version introduces several new features and important bug fixes, including a critical one. This new release of Redis Stack 7.2.0 also includes updated versions of **JSON** and **time series** data structures, each incorporating several bug fixes.
+
+This maintenance release also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4792](https://github.com/RediSearch/RediSearch/pull/4792) - Add character validations to simple string replies and escape it when required (MOD-7258)
+  * [#4768](https://github.com/RediSearch/RediSearch/pull/4768) - Indicate which value is missing on the error message at the aggregation pipeline (MOD-7201)
+  * [#4745](https://github.com/RediSearch/RediSearch/pull/4745) - `GROUPBY` recursion cleanup (MOD-7245)
+  * [#4823](https://github.com/RediSearch/RediSearch/pull/4823) - Mechanism of keys expiration during the query execution clearing intermediate results
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4754](https://github.com/RediSearch/RediSearch/pull/4754) - Correct return the maximum value for negative values when using `MAX` reducer (MOD-7252)
+  * [#4737](https://github.com/RediSearch/RediSearch/pull/4737) - Separators ignored when escaping backslash `\` after the escaped character such as in `hello\\,world` ignoring `,` (MOD-7240)
+  * [#4717](https://github.com/RediSearch/RediSearch/pull/4717) - Sorting by multiple fields `SORTBY 2 @field1 @field2` was ignoring the subsequent field(MOD-7206)
+  * [#4803](https://github.com/RediSearch/RediSearch/pull/4803) - Keys expiring during query returning empty array (MOD-7010)
+  * [#4794](https://github.com/RediSearch/RediSearch/pull/4794) - Index sanitiser (GC) trying to clean deleted numeric index could cause a crash (MOD-7303)
+
+* **JSON**:
+  * [#1212](https://github.com/RedisJSON/RedisJSON/pull/1212) `JSON.MSET`- AOF commands are duplicated multiple times (MOD-7293)
+
+* **Time series**:
+  * [#1607](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1607) Potential crash after deleting and recreating a source key of a compaction rule (MOD-7338)
+  * [#1610](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1610) `COUNT` argument accepts non-positive values (MOD-5413)
+
+* **Redis version**:
+  * __[Redis 7.2.5](https://github.com/redis/redis/releases/tag/7.2.5)__
+
+**Module versions**	
+* __[RediSearch 2.8.15](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.15)__
+* __[RedisJSON 2.6.11](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.11)__
+* __[RedisTimeSeries 1.10.13](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.12)__
+* __[RedisBloom 2.6.12](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.12)__
+* __[RedisGears 2.0.23](https://github.com/RedisGears/RedisGears/releases)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.4 or greater](https://github.com/redis/jedis/releases/tag/v5.1.4)
+  * [redis-om-spring 0.9.4 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.9.4)
+* Python
+  * [redis-py 5.0.9 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.9)
+  * [redis-om-python 0.3.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.3.1)
+* NodeJS
+  * [node-redis 4.7.0 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.4 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.4)
+  * [NRedisStack 0.12.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.6.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+  * [rueidis 1.0.43 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.43)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.54](https://github.com/RedisInsight/RedisInsight/releases/tag/2.54.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v11 (June 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+[Docker](https://hub.docker.com/r/redis/redis-stack) | [Download](https://redis.io/downloads/#stack)
+
+### Headlines:
+Redis Stack 7.2.0-v11 introduces a new version of the **Redis** server with several bug fixes, and an updated **search and query** capability with numerous enhancements and bug fixes.
+
+The updated **search and query** version features improved memory reporting that accounts for additional memory consumed by `TAG` and `TEXT` tries, as well as enhanced memory counting for inverted indexes.  Also, it includes additional fields in the `FT.INFO` command when used within a cluster.
+
+This maintenance release also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4595](https://github.com/RediSearch/RediSearch/pull/4595) - Report memory of the `TAG` and `TEXT` tries (MOD-5902)
+  * [#4669](https://github.com/RediSearch/RediSearch/pull/4669) - Inverted index memory counting (MOD-5977,MOD-5866)
+  * [#4687](https://github.com/RediSearch/RediSearch/pull/4687) - Add missing `FT.INFO` fields when used within a cluster (MOD-6920)	
+
+**Bug Fixes**
+* **Redis**:
+  * [#12824](https://github.com/redis/redis/pull/12824) A single shard cluster leaves failed replicas in CLUSTER SLOTS instead of removing them
+  * [#12955](https://github.com/redis/redis/pull/12955) Crash in LSET command when replacing small items and exceeding 4GB
+  * [#13004](https://github.com/redis/redis/pull/13004) Blocking commands timeout is reset due to re-processing command
+  * [#13115](https://github.com/redis/redis/pull/13115) Conversion of numbers in Lua args to redis args can fail. Bug introduced in 7.2.0
+
+* **CLI tools**:
+  * [#13092](https://github.com/redis/redis/pull/13092) redis-cli: --count (for --scan, --bigkeys, etc) was ignored unless --pattern was also used
+  * [#12958](https://github.com/redis/redis/pull/12958) redis-check-aof: incorrectly considering data in manifest format as MP-AOF
+
+* **Search and query**:
+  * [#4614](https://github.com/RediSearch/RediSearch/pull/4614) - Shards become unresponsive when using `FT.AGGREGATE` with `APPLY 'split(...)'`(MOD-6759)
+  * [#4556](https://github.com/RediSearch/RediSearch/pull/4556) - `FT.EXPLAIN` returns additional } when querying using wildcards (MOD-6768)
+  * [#4646](https://github.com/RediSearch/RediSearch/pull/4646) - `FT.DROPINDEX` with `DD` flag deleted keys in one AA cluster but not the others (MOD-1855)
+
+* **Redis version**:
+  * __[Redis 7.2.5](https://github.com/redis/redis/releases/tag/7.2.5)__
+
+**Module versions**	
+* __[RediSearch 2.8.14](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.14)__
+* __[RedisJSON 2.6.10](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.10)__
+* __[RedisTimeSeries 1.10.12](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.12)__
+* __[RedisBloom 2.6.12](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.12)__
+* __[RedisGears 2.0.23](https://github.com/RedisGears/RedisGears/releases)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.3 or later](https://github.com/redis/jedis/releases/tag/v5.1.3)
+  * [redis-om-spring 0.9.1 or later](https://github.com/redis/redis-om-spring/releases/tag/v0.9.1)
+* Python
+  * [redis-py 5.0.5 or later](https://github.com/redis/redis-py/releases/tag/v5.0.5)
+  * [redis-om-python 0.3.1 or later](https://github.com/redis/redis-om-python/releases/tag/v0.3.1)
+* NodeJS
+  * [node-redis 4.6.14 or later](https://github.com/redis/node-redis/releases/tag/redis%404.6.14)
+  * [redis-om-node 0.2.0 or later](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.1 or later](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.1)
+  * [NRedisStack 0.12.0 or later](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.5.2 or later](https://github.com/redis/go-redis/releases/tag/v9.5.2)
+  * [rueidis 1.0.38 or later](https://github.com/redis/rueidis/releases/tag/v1.0.38)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.50](https://github.com/RedisInsight/RedisInsight/releases/tag/2.50.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v10 (April 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest **search and query** capability with several improvements and bug fixes, including critical bug fixes. This release also includes the latest **JSON** data structure with a fix for a potential crash, the **time series** data structure with more detailed LibMR error messages, and the latest version of **triggers and functions** with updated v8 version and a bug fix. It also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4502](https://github.com/RediSearch/RediSearch/pull/4502) Handle error properly when trying to execute Search commands on cluster setup as part of `MULTI`/`EXEC` or LUA script (MOD-6541)
+  * [#4526](https://github.com/RediSearch/RediSearch/pull/4526) Adding detailed geometry info on error messages (MOD-6701)
+
+* **Time series**:
+  * [#1593](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1593) More detailed LibMR error messages
+
+* **Triggers and Functions**:
+  * [#1100](https://github.com/RedisGears/RedisGears/pull/1100) Update v8 version to 12.3.219.15
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4481](https://github.com/RediSearch/RediSearch/pull/4481) Query syntax on `GEOSHAPE` accepting just prefix instead of complete predicate (MOD-6663)
+  * [#4513](https://github.com/RediSearch/RediSearch/pull/4513) `FT.CURSOR READ` in a numeric query causing a crash (MOD-6597) [**critical bug**]
+  * [#4534](https://github.com/RediSearch/RediSearch/pull/4534) `FT.PROFILE` with incorrect arguments could cause a crash on cluster setup (MOD-6791) [**critical bug**]
+  * [#4530](https://github.com/RediSearch/RediSearch/pull/4530) Some parameter settings using just prefixes instead of full values were working (MOD-6709)
+  * [#4539](https://github.com/RediSearch/RediSearch/pull/4539) Unfree memory while re-indexing loading a new RDB could cause a crash (MOD-6831, 6810) [**critical bug**]
+  * [#4498](https://github.com/RediSearch/RediSearch/pull/4498) Vector pre-filtered query (hybrid query) that timeout causing a crash due to deadlock when trying to write a new document(MOD-6510, MOD-6244) [**critical bug**]
+  * [#4495](https://github.com/RediSearch/RediSearch/pull/4495) `FT.SEARCH` accessing an inexistent memory address causes a crash if using the deprecated `FT.ADD` command (MOD-6599) [**critical bug**]
+
+* **JSON**:
+  * [#1192](https://github.com/RedisJSON/RedisJSON/pull/1192) Crashes with numeric values greater than i64::MAX (MOD-6501, MOD-4551, MOD-4856, MOD-5714)
+
+* **Triggers and Functions**:
+  * [#1093](https://github.com/RedisGears/RedisGears/pull/1093) Crash when logging NULL characters
+
+**Redis version**:
+  * __[Redis 7.2.4](https://github.com/redis/redis/releases/tag/7.2.4)__
+
+**Module versions**	
+* __[RediSearch 2.8.13](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.13)__
+* __[RedisJSON 2.6.10](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.10)__
+* __[RedisTimeSeries 1.10.12](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.12)__
+* __[RedisBloom 2.6.12](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.12)__
+* __[RedisGears 2.0.20](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.2 or later](https://github.com/redis/jedis/releases/tag/v5.1.2)
+  * [redis-om-spring 0.8.9 or later](https://github.com/redis/redis-om-spring/releases/tag/v0.8.9)
+* Python
+  * [redis-py 5.0.3 or later](https://github.com/redis/redis-py/releases/tag/v5.0.3)
+  * [redis-om-python 0.2.2 or later](https://github.com/redis/redis-om-python/releases/tag/v0.2.2)
+* NodeJS
+  * [node-redis 4.6.13 or later](https://github.com/redis/node-redis/releases/tag/redis%404.6.13)
+  * [redis-om-node 0.2.0 or later](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or later](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.12.0 or later](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.5.1 or later](https://github.com/redis/go-redis/releases/tag/v9.5.1)
+  * [rueidis 1.0.33 or later](https://github.com/redis/rueidis/releases/tag/v1.0.33)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.46](https://github.com/RedisInsight/RedisInsight/releases/tag/2.46.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Downloads
+
+* macOS: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.catalina.x86_64.zip), [arm64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.monterey.arm64.zip)
+* AppImage: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10-x86_64.AppImage)
+* Ubuntu: [Bionic x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.bionic.x86_64.tar.gz), [Bionic arm64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.bionic.arm64.tar.gz), [Focal x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.focal.x86_64.tar.gz), [Focal arm64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.focal.arm64.tar.gz), [Snap x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.x86_64.snap), [Snap arm64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.arm64.snap), [Jammy x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.jammy.x86_64.tar.gz), [Jammy arm64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.jammy.arm64.tar.gz)
+* Debian: [Bullseye x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.bullseye.x86_64.tar.gz)
+* RHEL 7/CentOS Linux 7: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.rhel7.x86_64.tar.gz)
+* RHEL 8/CentOS Linux 8: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.rhel8.x86_64.tar.gz)
+* RHEL 9/Rocky Linux 9/CentOS Linux 9: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-7.2.0-v10.rhel9.x86_64.tar.gz)
+* Redis Stack on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack)
+* Redis Stack server on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack-server)
+
+## Redis Stack 7.2.0-v9 (March 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+### Headlines:
+This version contains the latest **search and query** capability with an improvement for memory allocation patterns on the memory used to query `GEOSHAPE` types, and several bug fixes. This release also includes the latest **probabilistic** data structures with a fix for a potential crash, and **triggers and functions** capability with an updated v8 version. It also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4313](https://github.com/RediSearch/RediSearch/pull/4313) Memory allocation patterns on the memory used to query `GEOSHAPE` types (MOD 6431)
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4476](https://github.com/RediSearch/RediSearch/pull/4476) Split `INFIX` and `SUFFIX` report on `FT.EXPLAIN` and `FT.EXPLAINCLI` (MOD-6186)
+  * [#4467](https://github.com/RediSearch/RediSearch/pull/4467) Memory leak upon suffix query for a `TAG` indexed with `WITHSUFFIXTRIE` (MOD-6644)
+  * [#4403](https://github.com/RediSearch/RediSearch/pull/4403) Clustered `FT.SEARCH` hangs forever without replying when an invalid topology is found (MOD-6557)
+  * [#4355](https://github.com/RediSearch/RediSearch/pull/4355) Searching for a synonym will iterate in the same group multiple times, causing a performance hit (MOD-6490)
+
+* **Probabilistic data structures**:
+  * [#753](https://github.com/RedisBloom/RedisBloom/issues/753) Potential crash on `CMS.MERGE` when using invalid arguments
+
+* **Triggers and Functions**:
+  * [#1089](https://github.com/RedisGears/RedisGears/pull/1089) Update v8 version to 12.2.281.21
+
+* **Redis version**:
+  * __[Redis 7.2.4](https://github.com/redis/redis/releases/tag/7.2.4)__
+
+**Module versions**	
+* __[RediSearch 2.8.12](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.12)__
+* __[RedisJSON 2.6.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.9)__
+* __[RedisTimeSeries 1.10.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.11)__
+* __[RedisBloom 2.6.12](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.12)__
+* __[RedisGears 2.0.19](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.19-m20)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.1 or greater](https://github.com/redis/jedis/releases/tag/v5.1.1)
+  * [redis-om-spring 0.8.8 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.8)
+* Python
+  * [redis-py 5.0.2 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.2)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.13 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.13)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.5.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.5.1)
+  * [rueidis 1.0.31 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.31)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.44](https://github.com/RedisInsight/RedisInsight/releases/tag/2.44.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v8 (January 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `HIGH`: There is a critical bug fixed in the probabilistic data structures that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest **probabilistic** data structures with a critical bug fix, as well as the latest **JSON** data structure with a breaking change to revert JSONPath default path value from `$` to `.` under RESP3, and a fix for RediSearch deadlock. This version contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **JSON**:
+  * [#1131](https://github.com/RedisJSON/RedisJSON/issues/1131), [#1143](https://github.com/RedisJSON/RedisJSON/pull/1143) BREAKING - Revert JSONPath default path value from `$` to `.` under RESP3 (MOD-6156)
+
+**Bug Fixes**
+* **JSON**:
+  * [#1095](https://github.com/RedisJSON/RedisJSON/pull/1095) Fix for RediSearch deadlock. See RediSearch 2.8.10 release notes (MOD-5895)
+
+* **Probabilistic data structures**:
+  * [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Potential crash on CF.LOADCHUNK (MOD-6344) - Additional fixes
+
+* **Redis version**:
+  * __[Redis 7.2.4](https://github.com/redis/redis/releases/tag/7.2.4)__
+
+**Module versions**	
+* __[RediSearch 2.8.11](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.11)__
+* __[RedisJSON 2.6.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.9)__
+* __[RedisTimeSeries 1.10.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.11)__
+* __[RedisBloom 2.6.11](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.11)__
+* __[RedisGears 2.0.16](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.16-m17)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.0 or greater](https://github.com/redis/jedis/releases/tag/v5.1.0)
+  * [redis-om-spring 0.8.8 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.8)
+* Python
+  * [redis-py 5.0.1 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.12 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.12)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.4.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.4.0)
+  * [rueidis 1.0.27 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.27)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.40](https://github.com/RedisInsight/RedisInsight/releases/tag/2.40.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v7 (January 2024)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+This version contains security fixes for the **Redis** server to properly handle the resizing of memory buffers, as well as security fixes for **probabilistic data structures** to avoid potential crashes. The new Redis Stack version also contains several improvements and bug fixes for the **Search and query** capability, including fixes of critical bugs. It also offers the latest **time series data structure**, the latest **Triggers and Functions** capability with various improvements and bug fixes, and it contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Security and privacy**
+* **Redis**:
+  * (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution
+
+* **Probabilistic data structures**:
+  * [#721](https://github.com/RedisBloom/RedisBloom/issues/721) Potential crash on `CF.RESERVE` (MOD-6343)
+  * [#722](https://github.com/RedisBloom/RedisBloom/issues/722) Potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+ **Improvements**
+* **Search and query**:
+  * [#3682](https://github.com/RediSearch/RediSearch/pull/3682) Report last key error and field type indexing failures on `FT.INFO` (MOD-5364)
+  * [#4236](https://github.com/RediSearch/RediSearch/pull/4236) Adding Vector index parameters at the `FT.INFO` report (MOD-6198)
+  * [#4196](https://github.com/RediSearch/RediSearch/pull/4196) Check for timeout after results processing in `FT.SEARCH` on cluster setup (MOD-6278)
+  * [#4164](https://github.com/RediSearch/RediSearch/pull/4164) Report `TIMEOUT`, `MAXPREFIXEXPANSION` warnings in RESP3 replies (MOD-6234)
+  * [#4165](https://github.com/RediSearch/RediSearch/pull/4165) Indicate timeout on `FT.PROFILE` report (MOD-6184)
+  * [#4149](https://github.com/RediSearch/RediSearch/pull/4149) Indicate timeout from Cursor on `FAIL` timeout policy (MOD-5990)
+  * [#4147](https://github.com/RediSearch/RediSearch/pull/4147) Initialization of the maximum numeric value range leading to a better balance of the index leaf splitting (MOD-6232)
+  * [#3940](https://github.com/RediSearch/RediSearch/pull/3940) Query optimisation when predicate contains multiple `INTERSECTION` (AND) of `UNION` (OR) (MOD-5910)
+  * [#4059](https://github.com/RediSearch/RediSearch/pull/4059) Return cursor id when experiencing a timeout, when the policy is `ON_TIMEOUT RETURN` (MOD-5966)
+  * [#4006](https://github.com/RediSearch/RediSearch/pull/4006) Possibly problematic index name alias validation (MOD-5945)
+  * [#4264](https://github.com/RediSearch/RediSearch/pull/4264) Granularity of the time reporting counters on `FT.PROFILE` (MOD-6002)
+
+* **Triggers and Functions**:
+  * Update v8 version to 12.0/267.13
+
+**Bug Fixes**
+* **Redis**:
+  * [#12805](https://github.com/redis/redis/pull/12805), [#12832](https://github.com/redis/redis/pull/12832) Fix crashes of cluster commands clusters with mixed versions of 7.0 and 7.2
+  * [#12564](https://github.com/redis/redis/pull/12564) Fix slot ownership not being properly handled when deleting a slot from a node
+  * [#12733](https://github.com/redis/redis/pull/12733) Fix atomicity issues with the RedisModuleEvent_Key module API event
+  * [#4324](https://github.com/RediSearch/RediSearch/pull/4324) Internal cluster mechanism not waiting until all replies from shards causing a crash (MOD-6287)
+  * [#4297](https://github.com/RediSearch/RediSearch/pull/4297) Execution loader when using `FT.AGGREGATE` with `LOAD` stage failing to buffer the right results potentially causing a crash (MOD-6385)
+
+* **Search and query**:
+  * [#4287](https://github.com/RediSearch/RediSearch/pull/4287) Re-index process while syncing from the replica causes a crash due to internal index variable initialisation
+(MOD-6337, MOD-6336)
+  * [#4249](https://github.com/RediSearch/RediSearch/pull/4249) Memory tracking on cluster setups causing high memory usage and potentially Out-of-Memory (MOD-6123, MOD-5639)
+  * [#4244](https://github.com/RediSearch/RediSearch/pull/4244) Profiling `FT.AGGREGATE` using the `WITHCURSOR` flag with - clause causes a crash due to timeout (MOD-5512)
+  * [#3916](https://github.com/RediSearch/RediSearch/pull/3916) Expiring `JSON` documents while querying it causing a crash due to deadlock (MOD-5769, MOD-5895, MOD-6189, MOD-5895)
+  * [#4235](https://github.com/RediSearch/RediSearch/pull/4235) Memory excessively growing on databases caused by unbalanced nodes on inverted index trie (MOD-5880, MOD-5952, MOD-6003)
+  * [#4190](https://github.com/RediSearch/RediSearch/pull/4190) Profiling `FT.AGGREGATE` causes a crash on RESP3 replies (MOD-6250, MOD-6295)
+  * [#4148](https://github.com/RediSearch/RediSearch/pull/4148), [#4038](https://github.com/RediSearch/RediSearch/pull/4038) `ON_TIMEOUT FAIL\RETURN` policies in the cluster setup not being respected (MOD-6035, MOD-5948, MOD-6090)
+  * [#4110](https://github.com/RediSearch/RediSearch/pull/4110) Format of error response contains inconsistencies when timing out(MOD-6011, MOD-5965)
+  * [#4104](https://github.com/RediSearch/RediSearch/pull/4104) `FT.SEARCH` not responding when using TLS encryption on Amazon Linux 2 (MOD-6012)
+  * [#4009](https://github.com/RediSearch/RediSearch/pull/4009) In cluster setup does not return a timeout error for `FT.SEARCH` (MOD-5911)
+  * [#3920](https://github.com/RediSearch/RediSearch/pull/3920) In cluster setup does not return a timeout error for `FT.AGGREGATE` (MOD-5209)
+  * [#3914](https://github.com/RediSearch/RediSearch/pull/3914) `FT.CURSOR READ` with geo queries causing a crash when data is updated between the cursor reads (MOD-5646)
+  * [#4220](https://github.com/RediSearch/RediSearch/pull/4220) Server crash when attempting to run the ForkGC (Garbage Collection routine) after dropping the index (MOD-6276)
+
+* **Time series**:
+  * [LibMR#51](https://github.com/RedisGears/LibMR/pull/51) Crash on SSL initialization failure (MOD-5647)
+  * [#1538](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1538) Amazon Linux 2: crash on SSL initialization. We now use openssl11-devel instead of openssl-devel (MOD-6015)
+
+* **Probabilistic data structures**:
+  * [#707](https://github.com/RedisBloom/RedisBloom/pull/707) Top-K: `TOPK.ADD` and `TOPK.QUERY` crash when an item name is an empty string (RED-114676)
+
+* **Triggers and Functions**:
+  * [#1069](https://github.com/RedisGears/RedisGears/pull/1069) Fixed an issue where a keyspace notification could be lost
+
+* **Redis version**:
+  * __[Redis 7.2.4](https://github.com/redis/redis/releases/tag/7.2.4)__
+
+**Module versions**	
+* __[RediSearch 2.8.11](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.11)__
+* __[RedisJSON 2.6.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.7)__
+* __[RedisTimeSeries 1.10.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.11)__
+* __[RedisBloom 2.6.10](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.10)__
+* __[RedisGears 2.0.16](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.16-m17)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.0 or greater](https://github.com/redis/jedis/releases/tag/v5.1.0)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.12 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.12)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.4.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.4.0)
+  * [rueidis 1.0.26 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.26)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.40](https://github.com/RedisInsight/RedisInsight/releases/tag/2.40.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v5 (October 2023)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest Search and Query with various improvements and fixes for critical bugs, triggers and functions with an updated v8 version, as well as new JSON, time series, and probabilistic data structures with several improvements. The new version introduces support for RHEL 9 and Rocky Linux 9. It also includes the latest version of RedisInsight.
+
+### Details:
+
+ **Improvements**
+* **Search and Query**:
+  * [#3938](https://github.com/RediSearch/RediSearch/pull/3938) Propagating error messages in a multi-shard database, instead of failing silently (MOD-5211)
+
+* **JSON**:
+  * [#1102](https://github.com/RedisJSON/RedisJSON/pull/1102) Added support for CBL-Mariner 2
+
+* **Time series**:
+  * [#1516](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1516) Added support for CBL-Mariner 2
+
+* **Probabilistic data structures**:
+  * [#684](https://github.com/RedisBloom/RedisBloom/pull/684), [#685](https://github.com/RedisBloom/RedisBloom/pull/685) Added support for CBL-Mariner 2
+
+**Bug Fixes**
+* **Redis**:
+  * Fix for the "The RDB file contains AUX module data I can't load: no matching module 'graphdata'" [error message](https://github.com/redis/redis/issues/12490) when upgrading Redis Stack
+
+* **Search and Query**:
+  * [#3874](https://github.com/RediSearch/RediSearch/pull/3874) Heavy document updates cause memory growth once memory blocks aren't properly released (MOD-5181)
+  * [#3967](https://github.com/RediSearch/RediSearch/pull/3967) Resharding optimizations cause the process to get stuck (MOD-5874, MOD-5864)
+  * [#3892](https://github.com/RediSearch/RediSearch/pull/3892) After cleaning the index the GC could cause corruption on unique values (MOD-5815)
+  * [#3853](https://github.com/RediSearch/RediSearch/pull/3853) Queries with `WITHCURSOR` making memory growth since `CURSOR` wasn't invalidated in the shards (MOD-5580)
+
+* **Triggers and Functions**:
+  * Update v8 version to 11.8.172.15
+
+**Redis version**
+* __[Redis 7.2.2](https://github.com/redis/redis/releases/tag/7.2.2)__
+
+**Module versions**	
+* __[RediSearch 2.8.9](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.9)__
+* __[RedisJSON 2.6.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.7)__
+* __[RedisTimeSeries 1.10.9](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.9)__
+* __[RedisBloom 2.6.8](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.8)__
+* __[RedisGears 2.0.14](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.14-m15)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.2 or greater](https://github.com/redis/jedis/releases/tag/v5.0.2)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.10 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.10)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.3 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.3)
+  * [NRedisStack 0.10.1 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.10.1)
+* Go
+  * [go-redis 9.2.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.2.1)
+  * [rueidis 1.0.20 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.20)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.36](https://github.com/RedisInsight/RedisInsight/releases/tag/2.36.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v4 (October 2023)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+### Headlines:
+This version contains a security fix for the Redis server to avoid bypassing desired Unix socket permissions on startup, as well as several improvements and bug fixes.
+
+### Details:
+
+**Security and privacy**
+* **Redis**:
+  * (CVE-2023-45145) The wrong order of `listen(2)` and `chmod(2)` calls creates a
+race condition that can be used by another process to bypass desired Unix
+socket permissions on startup.
+
+ **Improvements**
+* **Redis**:
+  * [#12611](https://github.com/redis/redis/pull/12611) Fix compilation error on MacOS 13
+  * [#12604](https://github.com/redis/redis/pull/12604) Fix crash when running rebalance command in a mixed cluster of 7.0 and 7.2
+Nodes
+  * [#12561](https://github.com/redis/redis/pull/12561) Fix the return type of the slot number in cluster shards to integer, which
+makes it consistent with past behavior
+  * [#12569](https://github.com/redis/redis/pull/12569) Fix CLUSTER commands are called from modules or scripts to return TLS info
+appropriately
+ * [#12571](https://github.com/redis/redis/pull/12571) redis-cli, fix crash on reconnect when in SUBSCRIBE mode
+ * [#12474](https://github.com/redis/redis/pull/12474) Fix overflow calculation for next timer event
+
+**Bug Fixes**
+* **Redis**:
+ * [#12620](https://github.com/redis/redis/pull/12620) WAITAOF could timeout in the absence of write traffic in case a new AOF is
+created and an AOF rewrite can't immediately start
+
+**Redis version**
+* __[Redis 7.2.2](https://github.com/redis/redis/releases/tag/7.2.2)__
+
+**Module versions**	
+* __[RediSearch 2.8.8](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.8)__
+* __[RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)__
+* __[RedisTimeSeries 1.10.6](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.6)__
+* __[RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)__
+* __[RedisGears 2.0.13](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.13-m14)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.1 or greater](https://github.com/redis/jedis/releases/tag/v5.0.1)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.10 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.10)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.3 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.3)
+  * [NRedisStack 0.9.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.9.0)
+* Go
+  * [go-redis 9.2.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.2.1)
+  * [rueidis 1.0.20 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.20)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.34](https://github.com/RedisInsight/RedisInsight/releases/tag/2.34.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v3 (October 2023)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+### Headlines:
+This version contains the latest Search and Query capability v. 2.8.8, and triggers and functions v. 2.0.13 with various improvements, security fixes for Search and Query, and several bug fixes. It also includes the latest version of RedisInsight.
+
+### Details:
+
+**Security and privacy**
+* **Search and Query**:
+  * [#3788](https://github.com/RediSearch/RediSearch/pull/3788) Don’t expose internal cluster commands
+  * [#3844](https://github.com/RediSearch/RediSearch/pull/3844) Limits maximum phonetic length avoiding to be exploited
+
+ **Improvements**
+* **Search and Query**:
+  * [#3534](https://github.com/RediSearch/RediSearch/pull/3534) - Vector Similarity [0.7.1](https://github.com/RedisAI/VectorSimilarity/releases/tag/v0.7.1)
+
+**Bug Fixes**
+* **Search and Query**:
+  * [#3771](https://github.com/RediSearch/RediSearch/pull/3771)  Broken `lower()` and `upper()` functions on `APPLY` stage in `FT.AGGREGATE` in `DIALECT 3`
+  * [#3752](https://github.com/RediSearch/RediSearch/pull/3752) Setting a low `MAXIDLE` parameter value in `FT.AGGREGATE` causes a crash
+  * [#3780](https://github.com/RediSearch/RediSearch/pull/3780) Wrong document length calculation causing incorrect score values
+  * [#3808](https://github.com/RediSearch/RediSearch/pull/3808) `LOAD` step after a `FILTER` step could cause a crash on `FT.AGGREGATE`
+  * [#3823](https://github.com/RediSearch/RediSearch/pull/3823) `APPLY` or `FILTER` parser leak
+  * [#3837](https://github.com/RediSearch/RediSearch/pull/3837) Connection using TLS fails on Redis 7.2
+  * [#3856](https://github.com/RediSearch/RediSearch/pull/3856) Adding new nodes to OSS cluster causing a crash
+  * [#3854](https://github.com/RediSearch/RediSearch/pull/3854) Vector range query could cause Out-of-Memory due a memory corruption
+
+* **Triggers and Functions**:
+  * Update v8 version to 11.7.439.17.
+
+**Redis version**
+* __[Redis 7.2.1](https://github.com/redis/redis/releases/tag/7.2.1)__
+
+**Module versions**	
+* __[RediSearch 2.8.8](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.8)__
+* __[RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)__
+* __[RedisTimeSeries 1.10.6](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.6)__
+* __[RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)__
+* __[RedisGears 2.0.13](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.13-m14)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.1 or greater](https://github.com/redis/jedis/releases/tag/v5.0.1)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.10 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.10)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.3 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.3)
+  * [NRedisStack 0.9.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.9.0)
+* Go
+  * [go-redis 9.2.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.2.1)
+  * [rueidis 1.0.19 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.19)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.34](https://github.com/RedisInsight/RedisInsight/releases/tag/2.34.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v2 (September 2023)
+
+This is a maintenance release for Redis Stack Server 7.2.0.
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+### Headlines:
+This version contains security improvements for time series to not expose internal commands and several bug fixes for triggers and functions.
+
+### Details:
+
+**Security and privacy**
+
+* **Time series**:
+  * [#1506](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1506) Don’t expose internal commands
+
+**Bug Fixes**
+
+* **Triggers and Functions**:
+  * [#1023](https://github.com/RedisGears/RedisGears/pull/1023) Add TCONFIG_GET and redisgears_2.FORCESHARDSCONNECTION to exclude commands.
+  * [#1008](https://github.com/RedisGears/RedisGears/pull/1008) and [#1020](https://github.com/RedisGears/RedisGears/pull/1020) Fix when the data is read when a StreamTrigger is fired.
+  * [#1010](https://github.com/RedisGears/RedisGears/pull/1010) Apply loading timeout on AOF and replication stream.
+  * Minor patch update for the V8 JavaScript engine.
+
+**Redis version**
+* __[Redis 7.2.1](https://github.com/redis/redis/releases/tag/7.2.1)__
+
+**Module versions**	
+* __[RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)__
+* __[RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)__
+* __[RedisTimeSeries 1.10.6](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.6)__
+* __[RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)__
+* __[RedisGears 2.0.12](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.12-m13)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.0 or greater](https://github.com/redis/jedis/releases/tag/v5.0.0)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.0 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.0)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.8 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.8)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.3 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.3)
+  * [NRedisStack 0.9.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.9.0)
+* Go
+  * [go-redis 9.1.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.1.0)
+  * [rueidis 1.0.17 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.17)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.32](https://github.com/RedisInsight/RedisInsight/releases/tag/2.32).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v1 (September 2023)
+
+This is a maintenance release for Redis Stack Server 7.2.0
+
+Update urgency: `SECURITY`: There are security fixes in the release.
+
+### Headlines:
+This version contains security fixes for the Redis server for cases when users may access keys that are not explicitly authorized by the ACL configuration using the [SORT_RO](https://redis.io/commands/sort_ro/) command.
+
+### Details:
+
+ **Security Fixes**
+* **Redis**:
+  * (CVE-2023-41053) Redis does not correctly identify keys accessed by SORT_RO and,
+as a result, may grant users executing this command access to keys that are not
+explicitly authorized by the ACL configuration.
+
+**Bug Fixes**
+* **Redis**:
+  * [#12538](https://github.com/redis/redis/pull/12538) Fix crashes when joining a node to an existing 7.0 Redis Cluster
+  * [#12545](https://github.com/redis/redis/pull/12545), [#12530](https://github.com/redis/redis/pull/12530) Correct request_policy and response_policy command tips on for some admin /
+configuration commands
+
+**Redis version**
+* __[Redis 7.2.1](https://github.com/redis/redis/releases/tag/7.2.1)__
+
+**Module versions**	
+* __[RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)__
+* __[RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)__
+* __[RedisTimeSeries 1.10.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.4)__
+* __[RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)__
+* __[RedisGears 2.0.11](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.11-m12)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.0 or greater](https://github.com/redis/jedis/releases/tag/v5.0.0)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.0 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.0)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.8 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.8)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.3 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.3)
+  * [NRedisStack 0.9.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.9.0)
+* Go
+  * [go-redis 9.1.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.1.0)
+  * [rueidis 1.0.17 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.17)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.32](https://github.com/RedisInsight/RedisInsight/releases/tag/2.32).
+
+Note: version numbers follow the following pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-v0 (August 2023)
+
+This is a GA release of Redis Stack version 7.2.
+
+### Headlines:
+Redis server 7.2 introduces significant memory and speed optimizations for lists, sets, and sorted sets, several improvements, including encoding improvements for sets and lists, stream consumer group improvements, and improved durability.
+Search and Query brings the frequently asked Geo polygons queries for basic shapes and improved query performance on sorting in different scenarios. 
+JSON introduces two new commands: [JSON.MERGE](https://redis.io/commands/json.merge/) and [JSON.MSET](https://redis.io/commands/json.mset/) for more efficient data manipulation.
+Preview of triggers and functions that allows developers to run JavaScript functions inside the Redis process.
+Lastly, 7.2 adds the option to use the new protocol [RESP3](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md) improving the response format for all commands.
+
+**Redis server**:
+Redis server 7.2 brings performance and resource utilization improvements, including significant memory and speed optimizations for lists, sets, and sorted sets. This new version adds a new `WITHSCORE` command argument for [ZRANK](https://redis.io/commands/zrank/) and [ZREVRANK](https://redis.io/commands/zrevrank/), new commands, such as [CLIENT NO-TOUCH](https://redis.io/commands/client-no-touch/) for clients to run commands without affecting LRU/LFU of keys, and more. Redis 7.2 brings behavior changes by introducing a new format (version 11) for RDB files, which is incompatible with older versions, changing module API, and other changes.
+
+**Search and Query**:
+This new major version introduces the frequently asked [Geo Polygon](https://redis.io/commands/ft.search/#examples) Search. Adding the [GEOSHAPE](https://redis.io/commands/ft.create/) field type that supports polygon shapes using the [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry). In addition to the existing `GEO` for geo range queries, now an alias for `GEOPOINT`, we add `GEOSHAPE` with the support for `POLYGON` and `POINT` as new shapes formats and polygons operations.
+
+In addition, 7.2 brings improvements in performance for `SORT BY` operations using [`FT.SEARCH`](https://redis.io/commands/ft.search/#optional-arguments) and [`FT.AGGREGATE`](https://redis.io/commands/ft.aggregate/#optional-arguments), and the new `FORMAT` for better readability and future support for better error handling responses on `FT.SEARCH` and `FT.AGGREGATE` in RESP3 only.
+
+**JSON**:
+JSON introduces two new commands:
+ - [JSON.MERGE](https://redis.io/commands/json.merge/) merges a given JSON value into matching paths so that the JSON values at the matching paths are updated, deleted, or expanded.
+ - [JSON.MSET](https://redis.io/commands/json.mset/) sets or updates one or more JSON values according to specified key-path-value triplets.
+
+**Graph**:
+
+Graph capabilities are no longer included in Redis Stack. See the [RedisGraph End-of-Life Announcement](https://redis.com/blog/redisgraph-eol/).
+
+> [!WARNING]  
+If you are using graph capabilities with an older version of Redis Stack - please don't upgrade.
+
+**Triggers and functions preview**:
+Triggers and functions is part of Redis Stack 7.2 as public preview, any feedback is highly appreciated.
+
+Triggers and functions provides support for running JavaScript functions inside the Redis process. These functions can be executed on-demand, by an event-driven trigger, or by a stream processing trigger. Triggers and functions empowers developers to build and maintain real-time applications by moving logic closer to the data, ensuring a lower latency whilst delivering the best developer experience.
+
+Try it out with the [triggers and functions quick start](https://redis.io/docs/interact/programmability/triggers-and-functions/quick_start/).
+
+
+### Details:
+Find more details about features and optimizations introduced with Redis Stack 7.2 here:
+* [Redis server](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)
+* [Search and Query](https://github.com/RediSearch/RediSearch/releases/)
+* [JSON](https://github.com/RedisJSON/RedisJSON/releases)
+* [Triggers and functions](https://github.com/RedisGears/RedisGears/releases)
+
+**Redis version**
+* __[Redis 7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)__
+
+**Module versions**	
+* __[RediSearch 2.8.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.4)__
+* __[RedisJSON 2.6.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.6)__
+* __[RedisTimeSeries 1.10.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.4)__
+* __[RedisBloom 2.6.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.3)__
+* __[RedisGears 2.0.11](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.11-m12)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.4.3 or greater](https://github.com/redis/jedis/releases/tag/v4.4.3)
+  * [redis-om-spring 0.8.6 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.6)
+* Python
+  * [redis-py 5.0.0 or greater ](https://github.com/redis/redis-py/releases/tag/v5.0.0)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.7 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.7)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.2 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.2)
+  * [NRedisStack 0.8.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.8.0)
+* Go
+  * [go-redis 9.0.5 or greater](https://github.com/redis/go-redis/releases/tag/v9.0.5)
+  * [rueidis 1.0.15 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.15)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.30](https://github.com/RedisInsight/RedisInsight/releases/tag/2.30.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-rc2 (July 2023)
+
+This is the third release of Redis Stack version 7.2.0.
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+
+This version contains security improvements for the Redis server.
+
+### Details:
+
+**Features**
+* **Redis**:
+  * [#10362](https://github.com/redis/redis/pull/10362) Make SENTINEL CONFIG [SET|GET] variadic
+  * [#12133](https://github.com/redis/redis/pull/12133) Add a new loglevel "nothing" to disable logging
+  * [#9564](https://github.com/redis/redis/pull/9564) Add cluster-announce-human-nodename - a unique identifier for a node that is
+be used in logs for debugging
+
+ **Improvements**
+* **Redis**:
+  * ([CVE-2022-24834](https://github.com/redis/redis/security/advisories/GHSA-p8x2-9v9q-c838)) A specially crafted Lua script executing in Redis can trigger
+a heap overflow in the cjson and cmsgpack libraries, and result in heap
+corruption and potentially remote code execution. The problem exists in all
+versions of Redis with Lua scripting support, starting from 2.6, and affects
+only authenticated and authorized users.
+  * ([CVE-2023-36824](https://github.com/redis/redis/security/advisories/GHSA-4cfx-h9gq-xpx3)) Extracting key names from a command and a list of arguments
+may, in some cases, trigger a heap overflow and result in reading random heap
+memory, heap corruption and potentially remote code execution. Specifically:
+using COMMAND GETKEYS* and validation of key names in ACL rules.
+  * [#12269](https://github.com/redis/redis/pull/12269) Allow CLUSTER SLOTS / SHARDS commands during loading
+  * [#12233](https://github.com/redis/redis/pull/12233) Support TLS service when "tls-cluster" is not enabled and persist both plain
+and TLS port in nodes.conf
+  * [#12320](https://github.com/redis/redis/pull/12320) Update SPOP and RESTORE commands to replicate unlink commands to replicas
+when the server is configured to use async server deletes
+  * [#12229](https://github.com/redis/redis/pull/12229) Try lazyfree the temporary zset in ZUNION / ZINTER / ZDIFF
+  * [#12298](https://github.com/redis/redis/pull/12298) Optimize PSUBSCRIBE and PUNSUBSCRIBE from O(N*M) to O(N)
+  * [#12209](https://github.com/redis/redis/pull/12209) Optimize SCAN, SSCAN, HSCAN, ZSCAN commands
+  * [#12315](https://github.com/redis/redis/pull/12315) Set Jemalloc --disable-cache-oblivious to reduce memory overhead
+  * [#12229](https://github.com/redis/redis/pull/12229) Optimize ZINTERCARD to avoid create a temporary zset
+  * [#12205](https://github.com/redis/redis/pull/12205) Optimize HRANDFIELD and ZRANDMEMBER listpack encoded ()
+  * [#12155](https://github.com/redis/redis/pull/12155), [#12082](https://github.com/redis/redis/pull/12082), [#11626](https://github.com/redis/redis/pull/11626), [#11944](https://github.com/redis/redis/pull/11944), [#12316](https://github.com/redis/redis/pull/12316), [#12250](https://github.com/redis/redis/pull/12250),
+[#12177](https://github.com/redis/redis/pull/12177), [#12185](https://github.com/redis/redis/pull/12185) Numerous other optimizations
+  * [#12254](https://github.com/redis/redis/pull/12254) redis-cli: Handle RESP3 double responses that contain a NaN
+  * [#11834](https://github.com/redis/redis/pull/11834) redis-cli: Support URIs with IPv6
+
+**Changed Behavior**
+* **Redis**:
+  * [#10536](https://github.com/redis/redis/pull/10536), [#12166](https://github.com/redis/redis/pull/12166) Cluster SHARD IDs are no longer visible in the cluster nodes output
+  * [#12326](https://github.com/redis/redis/pull/12326) When calling PUBLISH with a RESP3 client that's also subscribed to the same channel, the order is changed and the reply is sent before the published message
+  * [#12321](https://github.com/redis/redis/pull/12321) Align semantics of the new (v7.2 RC2) RM_ReplyWithErrorFormat with RM_ReplyWithError.
+This is a breaking change that affects the generated error code
+  * [#12304](https://github.com/redis/redis/pull/12304) Forbid RM_AddPostNotificationJob on loading and on read-only replicas
+  * [#12219](https://github.com/redis/redis/pull/12219) Add ability for module command filter to know which client is being handled
+
+**Bug Fixes**
+* **Redis**:
+  * [#12326](https://github.com/redis/redis/pull/12326) Fix broken protocol when PUBLISH is used inside MULTI when the RESP3
+publishing client is also subscribed for the channel
+  * [#12220](https://github.com/redis/redis/pull/12220) Fix WAIT to be effective after a blocked module command being unblocked
+  * [#12276](https://github.com/redis/redis/pull/12276) Re-enable downscale rehashing while there is a fork child
+  * [#12276](https://github.com/redis/redis/pull/12276) Fix possible hang in HRANDFIELD, SRANDMEMBER, ZRANDMEMBER when used with `<count>`
+  * [#12276](https://github.com/redis/redis/pull/12276) Improve fairness issue in RANDOMKEY, HRANDFIELD, SRANDMEMBER, ZRANDMEMBER, SPOP, and eviction
+  * [#12344](https://github.com/redis/redis/pull/12344) Cluster: fix a race condition where a slot migration may revert on a subsequent failover or node joining
+  * [#12301](https://github.com/redis/redis/pull/12301)Fix XREADGROUP BLOCK with ">" from hanging
+  * [#12247](https://github.com/redis/redis/pull/12247)Fix assertion when a blocked command is rejected when re-processed
+  * [#12342](https://github.com/redis/redis/pull/12342)Fix use after free on a blocking RM_Call
+
+**Redis version**
+* __[Redis 7.2 RC3](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)__
+
+
+**Module versions**	
+* __[RediSearch 2.8.3](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.3)__
+* __[RedisJSON 2.6.2](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.2)__
+* __[RedisTimeSeries 1.10.1](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.1)__
+* __[RedisBloom 2.6.1](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.1)__
+* __[RedisGears 2.0.6](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.6-m07)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.4.3 or greater](https://github.com/redis/jedis/releases/tag/v4.4.3)
+  * [redis-om-spring 0.8.1 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.1)
+* Python
+  * [redis-py 4.5.5 or greater ](https://github.com/redis/redis-py/releases/tag/v4.5.5)
+  * [redis-om-python 0.1.2 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.1.2)
+* NodeJS
+  * [node-redis 4.6.7 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.7)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.1)
+  * [NRedisStack 0.7.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.7.0)
+* Go
+  * [go-redis 9.0.4 or greater](https://github.com/redis/go-redis/releases/tag/v9.0.4)
+  * [rueidis 1.0.3 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.3)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.26](https://github.com/RedisInsight/RedisInsight/releases/tag/2.26.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-rc2 (June 2023)
+
+This is the second release of Redis Stack version 7.2.0.
+
+### Headlines:
+This version contains a new capability - **Triggers and Functions**, improvements to the **Search and Query** capability, and improvements to the **JSON**, **time series** and **probabilistic data structures**. It also includes the latest version of **RedisInsight**.
+
+The new **Search and Query** version introduces new and frequently asked **Geo Polygon Search**. Adding the `GEOSHAPE` field type that supports polygon shapes using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry). Besides the current `GEO` (alias for `GEOPOINT`) used already geo range queries, we add the support for `POLYGON` as new shapes. In addition, it brings improvements in performance for `SORT BY` operations using `FT.SEARCH` and `FT.AGGREGATE`.
+
+This release includes a new capability - [Triggers and Functions](https://github.com/RedisGears/RedisGears/tree/master) that brings the ability to execute and trigger business logic inside Redis using JavaScript (JS). Detailed documentation and examples can be found in this [GitHub repository](https://github.com/RedisGears/RedisGears#redisgears-20). The Triggers and Functions commands are aligned with the Redis Functions command. The API is not yet final and might change based on feedback. **Any [feedback](https://github.com/RedisGears/RedisGears) is highly appreciated.**
+### Details:
+**Features**
+* **Search and Query**:
+  * [#3553](https://github.com/RediSearch/RediSearch/pull/3553) Introduce support for Geo-polygon shapes and queries
+    * [#3476](https://github.com/RediSearch/RediSearch/pull/3476), [#3660](https://github.com/RediSearch/RediSearch/pull/3660) Adding `GEOSHAPE` [field type](https://redis.io/commands/ft.create/) to map polygons in the `SCHEMA` on `FT.CREATE`.
+    * Support for polygons `POLYGON` using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry), for example `POLYGON((x1 y1, x2 y2, ...))`.
+    * [#3556](https://github.com/RediSearch/RediSearch/pull/3556) Adjust the [query syntax](https://redis.io/commands/ft.search/#examples) on `FT.SEARCH` for Polygons using the predicate `@geom:[OPERATOR $poly]` and defining polygon in WKT format as `PARAMS 2 poly "POLYGON((10 20, ...))"` using `DIALECT 3`.
+    * Initially `WITHIN` and `CONTAINS` operators with `GEOSHAPES` for now.
+    * [#3645](https://github.com/RediSearch/RediSearch/pull/3645) Support multiple coordinate systems cartesian (X,Y) and geographic (lon, lat). Geographic coordinate system using spherical indexing as default (`SPHERICAL`).
+  * [#3046](https://github.com/RediSearch/RediSearch/pull/3046) Introduce performance optimization for sorting operations on `FT.SEARCH` and `FT.AGGREGATE` as default on `DIALECT 4`. It will improve performance in 4 different scenarios, listed below:
+    * Skip Sorter - applied when there is no sort of any kind. The query can return once it reaches the `LIMIT` requested results.
+    * Partial Range - applied when there is a `SORTBY` a numeric field, with no filter or filter by the same numeric field, the query iterate on a range large enough to satisfy the `LIMIT` requested results.
+    * Hybrid - applied when there is a `SORTBY` a numeric field in addition to another non-numeric filter. Some results will get filtered, and the initial range may not be large enough. The iterator then is rewinded with the following ranges, and an additional iteration takes place to collect `LIMIT` requested results.
+    * No optimization - If there is a sort by score or by non-numeric field, there is no other option but to retrieve all results and compare their values.
+    * [#3651](https://github.com/RediSearch/RediSearch/pull/3651) Add `WITHCOUNT` argument that allow return accurate counts for the query results with sorting. This operation processes all results in order to get accurate count, being less performant than the optimised option (default behaviour on `DIALECT 4`).
+
+
+* **JSON**:
+  * [#916](https://github.com/RedisJSON/RedisJSON/pull/916) Introduce the new `JSON.MERGE` in compliance with [RFC 7396](https://datatracker.ietf.org/doc/html/rfc7396), supporting:
+    * Creating new attributes on an existing JSON document
+    * Updating and replacing values in parent and child attributes
+    * Deleting existing attributes (giving `null` as value)
+    * Array update - replacing an entire array with the new value.
+  * [#944](https://github.com/RedisJSON/RedisJSON/pull/944) Introduce `JSON.MSET`, supporting atomic multiple sets for keys in the same hash slot.
+
+* **Triggers and Functions**:
+  * [#875](https://github.com/RedisGears/RedisGears/pull/875) The api_version was added to the library prologue indicating the minimum required API version. Indicating the library works on the specified API version and later minor versions.
+[#896](https://github.com/RedisGears/RedisGears/pull/896) Additional optional callback on a KeySpace trigger that can perform read operations exactly when the notification happens.
+  * [#910](https://github.com/RedisGears/RedisGears/pull/910) The JavaScript API is updated to be inline with JavaScript best practices. Registrations of functions and triggers is done with mandatory arguments and a single optional object.
+  * [#935](https://github.com/RedisGears/RedisGears/pull/935) Ability to load an RDB from a Redis Server with the RedisGears module loaded but NOT used into a Redis Server without the RedisGears module.
+  * Updated commands:
+    * [#910](https://github.com/RedisGears/RedisGears/pull/910) `TFUNCTION` and `TFCALL` is used instead of `RG.FUNCTION` and `RG.FCALL`.
+    * [#939](https://github.com/RedisGears/RedisGears/pull/939) The commands are updated to match the Redis Functions commands. `TFCALL` combines the library and function in a single argument with '.' separated. Example: `TFCALL <library_name>.<function_name>`.
+    * [#900](https://github.com/RedisGears/RedisGears/pull/900) rated the ability to run functions as a coroutine in `TFCALLASYNC`. Clients rely on `TFCALL` to never block shared connections so other commands are not delayed on such connections.
+
+
+ **Improvements**
+* **Search and Query**:
+  * [#3641](https://github.com/RediSearch/RediSearch/pull/3641) Indexing sanitizing trigger in heavily data updates scenario.
+  * [#3614](https://github.com/RediSearch/RediSearch/pull/3614) Several improvements in the aggregations execution pipeline.
+
+* **Triggers and Functions**:
+  * [#906](https://github.com/RedisGears/RedisGears/pull/906) Limit the total memory usage of all combined libraries, the values can be configured during module load.
+  * [#940](https://github.com/RedisGears/RedisGears/pull/940) Validate the current memory usage when uploading a new library to not exceed the max memory limit.
+
+
+
+**Changed Behavior**
+* **Search and Query**:
+  * [#3355](https://github.com/RediSearch/RediSearch/pull/3355), [#3635](https://github.com/RediSearch/RediSearch/pull/3635) Expired keys deleted from slave's index, returning an empty array instead of `nil`.
+
+**Bug Fixes**
+* **Search and Query**:
+  * [#3597](https://github.com/RediSearch/RediSearch/pull/3597) Duplicating alias as output name on `FT.AGGREGATE` reducer (`REDUCE` argument) isn't return results.
+  * [#3654](https://github.com/RediSearch/RediSearch/pull/3654) Added check for `@` prefix on `GROUPBY` fields returnig an error instead of wrong results.
+  * [#3501](https://github.com/RediSearch/RediSearch/pull/3501) Sorting by 2 or more fields follow the order not ignoring the second argument.
+  * [#3582](https://github.com/RediSearch/RediSearch/pull/3582) Sorter will set lower rank in documents expired during query time, preventing clients to freeze.
+
+* **JSON**:
+  * [#1025](https://github.com/RedisJSON/RedisJSON/pull/1025) `JSON.TOGGLE` key space notification fix.
+
+* **Time series**:
+  * [#1471](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1471) Potential crash on `MRANGE` when aggregating millions of time series.
+  * [#1469](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1469) Potential memory leak in `MRANGE` after eviction.
+
+* **Triggers and Functions**:
+  * [#913](https://github.com/RedisGears/RedisGears/pull/913) Do not trigger notifications when Redis is loading from a persistence file.
+
+**Redis version**
+* __[Redis 7.2 RC2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)__
+
+**Module versions**	
+* __[RediSearch 2.8.3](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.3)__
+* __[RedisJSON 2.6.2](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.2)__
+* __[RedisTimeSeries 1.10.1](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.1)__
+* __[RedisBloom 2.6.1](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.1)__
+* __[RedisGears 2.0.6](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.6-m07)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.4.3 or greater](https://github.com/redis/jedis/releases/tag/v4.4.3)
+  * [redis-om-spring 0.8.1 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.1)
+* Python
+  * [redis-py 4.5.5 or greater ](https://github.com/redis/redis-py/releases/tag/v4.5.5)
+  * [redis-om-python 0.1.2 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.1.2)
+* NodeJS
+  * [node-redis 4.6.7 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.7)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.1)
+  * [NRedisStack 0.7.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.7.0)
+* Go
+  * [go-redis 9.0.4 or greater](https://github.com/redis/go-redis/releases/tag/v9.0.4)
+  * [rueidis 1.0.3 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.3)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.26](https://github.com/RedisInsight/RedisInsight/releases/tag/2.26.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 7.2.0-rc1 (June 2023)
+
+This is the first release of Redis Stack version 7.2.0.
+
+### Headlines:
+This version contains the latest **Search and Query** capability, **JSON** capability, and a new version of RedisInsight. 
+The latest **Search and Query** capability introduces new and frequently asked Geo Polygon Search. Adding the `GEOMETRY` field type that supports polygon shapes using [WKT](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) notation. In addition, it brings improvements in performance for `SORT BY` operations using `FT.SEARCH` and `FT.AGGREGATE`.
+The latest **JSON** capability introduces the new `JSON.MERGE` in compliance with [RFC 7396](https://datatracker.ietf.org/doc/html/rfc7396), and `JSON.MSET`, which supports atomic multiple sets for keys in the same hash slot.
+
+### Details:
+**Features**
+* **Search and Query**:
+  * [#3553](https://github.com/RediSearch/RediSearch/pull/3553) Introduce support for Geo-polygon shapes and queries
+    * [#3476](https://github.com/RediSearch/RediSearch/pull/3476) Adding `GEOMETRY` [field type](https://redis.io/commands/ft.create/) to map polygons in the `SCHEMA` on `FT.CREATE`
+    * Adding polygons using [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry), for example `POLYGON((x1 y1, x2 y2, ...))`
+    * [#3556](https://github.com/RediSearch/RediSearch/pull/3556) Adjust the [query syntax](https://redis.io/commands/ft.search/#examples) on `FT.SEARCH` for Polygons using the predicate `@geom:[OPERATOR $poly]` and defining polygon in WKT format as `PARAMS 2 poly "POLYGON((10 20, ...))"` using `DIALECT 3`
+    * Initially `WITHIN` and `CONTAINS` operators with Geometries only
+  * [#3046](https://github.com/RediSearch/RediSearch/pull/3046) Introduce the `OPTIMIZE` keyword to `SORTBY` queries using `FT.SEARCH` and `FT.AGGREGATE` that improve performance in 4 different scenarios:
+    * **Skip Sorter** - applied when there is no sort of any kind. The query can return once it reaches the `LIMIT` requested results.
+    * **Partial Range** - applied when there is a `SORTBY` numeric field, with no filter or filter by the same numeric field, the query iterate on a range large enough to satisfy the `LIMIT` requested results.
+    * **Hybrid** - applied when there is a `SORTBY` numeric field in addition to another non-numeric filter. Some results will get filtered, and the initial range may not be large enough. The iterator then is rewinded with the following ranges, and an additional iteration takes place to collect the `LIMIT` requested results.
+    * **No optimization** - If there is a sort by score or non-numeric field, there is no other option but to retrieve all results and compare their values.
+
+* **JSON**:
+  * [#916](https://github.com/RedisJSON/RedisJSON/pull/916) Introduce the new `JSON.MERGE` in compliance with [RFC 7396](https://datatracker.ietf.org/doc/html/rfc7396), supporting:
+    * Creating new attributes on an existing JSON document
+    * Updating and replacing values in parent and child attributes
+    * Deleting existing attributes (giving `null` as value)
+    * Array update - replacing an entire array with the new value
+  * [#944](https://github.com/RedisJSON/RedisJSON/pull/944) Introduce `JSON.MSET`, supporting atomic multiple sets for keys in the same hash slot
+
+ **Improvements**
+* **Search and Query**:
+  * [#3628](https://github.com/RediSearch/RediSearch/pull/3628) Background indexing scanning performance
+
+**Changed Behavior**
+* **Search and Query**:
+  * [#3355](https://github.com/RediSearch/RediSearch/pull/3355) Expired keys deleted from the slave's index, returning an empty array instead of `nil`
+
+**Bug Fixes**
+* **Search and Query**:
+  * [#3562](https://github.com/RediSearch/RediSearch/pull/3562) Index definition may load several times when using `REPLICAOF` causing a failure
+  * [#3557](https://github.com/RediSearch/RediSearch/pull/3557) `TIMEOUT` configuration on `FT.AGGREGATE` query being ignored
+  * [#3606](https://github.com/RediSearch/RediSearch/pull/3606) Update numeric inverted index `numEntries` avoiding excessive memory consumption
+  * [#3552](https://github.com/RediSearch/RediSearch/pull/3552) `FT.CURSOR READ` on `JSON` numeric queries not returning results
+
+**Redis version**
+* __[Redis 7.2 RC2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES)__
+
+**Module versions**	
+* __[RediSearch 2.8.2](https://github.com/RediSearch/RediSearch/releases/tag/v2.8.2)__
+* __[RedisJSON 2.6.1](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.6.1)__
+* __[RedisTimeSeries 1.10.0](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.10.0)__
+* __[RedisBloom 2.6.0](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.6.0)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.4.0 or greater](https://github.com/redis/jedis/releases/)
+  * [redis-om-spring 0.8.1 or greater](https://github.com/redis/redis-om-spring/releases)
+* Python
+  * [redis-py 4.5.5 or greater ](https://github.com/redis/redis-py/releases)
+  * [redis-om-python 0.1.2 or greater](https://github.com/redis/redis-om-python/releases)
+* NodeJS
+  * [node-redis 4.6.6 or greater](https://github.com/redis/node-redis/releases)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/tags)
+* .NET
+  * [redis-om-dotnet 0.5.1 or greater](https://github.com/redis/redis-om-dotnet/releases)
+  * [NRedisStack 0.6.1 or greater](https://github.com/redis/NRedisStack/releases)
+* Go
+  * [go-redis 9.0.4 or greater](https://github.com/redis/go-redis/releases)
+  * [rueidis 1.0.3 or greater](https://github.com/redis/rueidis/releases)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.26](https://github.com/RedisInsight/RedisInsight/releases/tag/2.26.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+---
+Title: Redis Stack 7.4 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Stack 7.4 release notes.
+linkTitle: v7.4.0-v0 (July 2024)
+weight: 100
+---
+## Redis Stack 7.4.0-v1 (October 2024)
+
+This is a maintenance release for Redis Stack Server 7.4.0.
+
+Update urgency: `SECURITY`: there are security fixes in the release.
+
+[Docker](https://hub.docker.com/r/redis/redis-stack) | [Download](https://redis.io/downloads/#stack)
+
+### Headlines
+
+This version includes security fixes for the **Redis** server, addressing potential vulnerabilities such as an RCE when using Lua library components, and a denial-of-service (DoS) risk due to malformed ACL selectors or unbounded pattern matching.
+Additionally, this maintenance release includes the latest version of **Redis Insight**.
+
+### Details
+
+**Security and privacy**
+* **Redis**:
+  * (CVE-2024-31449) Lua library commands may lead to stack overflow and potential RCE.
+  * (CVE-2024-31227) Potential Denial-of-service due to malformed ACL selectors.
+  * (CVE-2024-31228) Potential Denial-of-service due to unbounded pattern matching.
+	
+**Redis Community Edition version**
+  * [Redis 7.4.1](https://github.com/redis/redis/releases/tag/7.4.1)
+
+**Module versions**	
+* [RediSearch 2.10.5](https://github.com/RediSearch/RediSearch/releases/tag/v2.10.5)
+* [RedisJSON 2.8.3](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.8.3)
+* [RedisTimeSeries 1.12.2](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.12.2)
+* [RedisBloom 2.8.2](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.8.2)
+
+**Recommended client libraries**
+* Java
+  * [Jedis 5.2.0 or later](https://github.com/redis/jedis/releases/tag/v5.2.0)
+  * [Lettuce 6.4.0 or later](https://github.com/redis/lettuce/releases/tag/6.4.0.RELEASE)
+* Python
+  * [redis-py 5.1.0 or later](https://github.com/redis/redis-py/releases/tag/v5.1.0)
+* NodeJS
+  * [node-redis 4.7.0 or later](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+* Go
+  * [go-redis 9.6.1 or later](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.58](https://github.com/RedisInsight/RedisInsight/releases/tag/2.58.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis Major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Community Edition 7.4.0-v0 (July 2024)
+
+This is a GA release of Redis Stack version 7.4.
+
+[Docker](https://hub.docker.com/r/redis/redis-stack) | [Download](https://redis.io/downloads/#stack)
+
+### Headlines
+**Data Structures**
+
+`Hash`: Redis now supports expiration of individual hash fields. Redis already supports key expiration. For each key, users can specify a time when it should expire, or specify the remaining time-to-live (TTL) after which it would expire. One very frequent request was to allow specifying expiration time or TTL also for individual hash fields, which is now supported using nine new Redis commands:
+- `HEXPIRE`, `HPEXPIRE`, `HEXPIREAT`, `HPEXPIREAT` - set the time when specific hash fields should expire, or the remaining time-to-live for specific fields. 
+- `HTTL`, `HPTTL`, `HEXPIRETIME`, `HPEXPIRETIME` - retrieve the time when specific hash fields should expire, or the remaining time-to-live for specific fields
+- `HPERSIST` - remove the expiration of specific hash fields.
+
+`Streams`: It is now possible to start reading from the last stream message using `XREAD` with the new id value `+`.
+There are many additional improvements, including new command arguments, security, performance, and resource utilization enhancements, several new metrics and configuration parameters were introduced, and multiple bugs were fixed.
+
+`Time series`: The latest time series data structure adds a highly requested feature: insertion-filter for close samples. Many sensors report data periodically. Often, the difference between the measured value and the previously measured value is negligible and related to random noise or to measurement accuracy limitations. When both the time difference and the value difference between the current and the previous sample are small, it may be preferable to ignore (not to add) the new measurement.
+
+`JSON`: Introduces a fix to avoid duplicating AOF commands multiple times in `JSON.MSET`.
+
+`Probabilistic`: Now, an error is returned if `CMS.MERGE` results in an overflow or underflow.
+
+**Search and query**
+
+- New `BFLOAT16` and `FLOAT16` vector data types reduce memory consumed by vectors while preserving accuracy.
+- Support for indexing empty and missing values and enhanced developer experience for queries with exact matching capabilities.
+- Developers can now match `TAG` fields without needing to escape special characters, making the onboarding process and use of the query syntax simpler.
+- Geospatial search capabilities have been expanded with new `INTERSECT` and `DISJOINT` operators, and ergonomics have been improved by providing better reporting of the memory consumed by the index and exposing the Full-text scoring in the aggregation pipeline.
+
+{{< warning >}}
+If one or more fields of a hash key expire after a query begins (using FT.SEARCH or FT.AGGREGATE), Redis does not account for these lazily expired fields. As a result, keys with expired fields may still be included in the query results, leading to potentially incorrect or inconsistent results.
+{{< /warning >}}
+
+**Removal of triggers and functions**
+
+Redis Stack 7.4 will no longer include triggers and functions. To ensure a seamless upgrade, remove any T&F functions created before loading an RDB file into the new Redis Stack.
+
+### Details
+Find more details about features and optimizations introduced with Redis Stack 7.4 here:
+  * [Redis server](https://github.com/redis/redis/blob/7.4.0/00-RELEASENOTES)
+  * [Search and query capability](https://github.com/RediSearch/RediSearch/releases/tag/v2.10.5)
+  * [JSON data structure](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.8.3)
+  * [Time series data structure](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.12.2)
+  * [Probabilistic data structures](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.8.2)
+
+**Redis version**
+  * [Redis 7.4.0](https://github.com/redis/redis/releases/tag/7.4.0)
+
+**Module versions**	
+* [RediSearch 2.10.5](https://github.com/RediSearch/RediSearch/releases/tag/v2.10.5)
+* [RedisJSON 2.8.3](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.8.3)
+* [RedisTimeSeries 1.12.2](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.12.2)
+* [RedisBloom 2.8.2](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.8.2)
+
+**Recommended client libraries**
+* Java
+  * [Jedis 5.1.4 or later](https://github.com/redis/jedis/releases/tag/v5.1.4)
+  * [Lettuce 6.4.0 or later](https://github.com/redis/lettuce/releases/tag/6.4.0.RELEASE)
+* Python
+  * [redis-py 5.0.8 or later](https://github.com/redis/redis-py/releases/tag/v5.0.8)
+* NodeJS
+  * [node-redis 4.7.0 or later](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+* Go
+  * [go-redis 9.6.1 or later](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.52](https://github.com/RedisInsight/RedisInsight/releases/tag/2.52.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis Major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+---
+Title: Redis Stack 6.2.6 release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Stack 6.2.6 release notes.
+linkTitle: v6.2.6-v0 (December 2022)
+weight: 100
+---
+
+## Redis Stack Server 6.2.6-v17 (October 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `SECURITY`: there are security fixes in the release.
+
+[Docker](https://hub.docker.com/r/redis/redis-stack) | [Download](https://redis.io/downloads/#stack)
+
+### Headlines:
+This version includes security fixes for the **Redis** server, addressing potential vulnerabilities such as an RCE when using Lua library components, and a denial-of-service (DoS) risk due to unbounded pattern matching.
+Additionally, this maintenance release includes the latest version of **Redis Insight**.
+
+### Details:
+ **Security and privacy**
+* **Redis**:
+  * (CVE-2024-31449) Lua library commands may lead to stack overflow and potential RCE.
+  * (CVE-2024-31228) Potential Denial-of-service due to unbounded pattern matching.
+
+**Redis version**
+* [Redis 6.2.16](https://github.com/redis/redis/releases/tag/6.2.16)
+
+**Module versions**	
+* __[RediSearch 2.6.20](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.20)__
+* __[RedisJSON 2.4.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.9)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.15)__
+* __[RedisTimeSeries 1.8.14](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.14)__
+* __[RedisBloom 2.4.9](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.9)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.2.0 or greater](https://github.com/redis/jedis/releases/tag/v5.2.0)
+  * [redis-om-spring 0.9.5 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.9.5)
+* Python
+  * [redis-py 5.1.0 or greater](https://github.com/redis/redis-py/releases/tag/v5.1.0)
+  * [redis-om-python 0.3.2 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.3.2)
+* NodeJS
+  * [node-redis 4.7.0 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.4 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.4)
+  * [NRedisStack 0.13.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.13.0)
+* Go
+  * [go-redis 9.6.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+  * [rueidis 1.0.47 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.47)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.58](https://github.com/RedisInsight/RedisInsight/releases/tag/2.58.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v16 (August 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+### Headlines:
+The updated **search and query**  version introduces several new features and bug fixes. This new release of Redis Stack 6.2.6 also includes updated versions of **JSON** and **time series** data structures, each incorporating several bug fixes.
+
+This maintenance release also contains the latest version of **RedisInsight**.
+
+ ### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4793](https://github.com/RediSearch/RediSearch/pull/4793) - Add character validations to simple string replies and escape it when required(MOD-7258)
+  * [#4769](https://github.com/RediSearch/RediSearch/pull/4769) - Indicate which value is missing on the error message at the aggregation pipeline (MOD-7201)
+  * [#4746](https://github.com/RediSearch/RediSearch/pull/4746) - `GROUPBY` recursion cleanup (MOD-7245)
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4755](https://github.com/RediSearch/RediSearch/pull/4755) - Correct return the maximum value for negative values when using `MAX` reducer (MOD-7252)
+  * [#4733](https://github.com/RediSearch/RediSearch/pull/4733) - Separators ignored when escaping backslash `\` after the escaped character such as in `hello\\,world` ignoring `,` (MOD-7240)
+  * [#4717](https://github.com/RediSearch/RediSearch/pull/4717) - Sorting by multiple fields as in `SORTBY 2 @field1 @field2` was ignoring the subsequent field (MOD-7206)
+
+* **Time series**:
+  * [#1607](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1607) Potential crash after deleting and recreating a source key of a compaction rule (MOD-7338)
+  * [#1610](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1610) `COUNT` argument accepts non-positive values (MOD-5413)
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.20](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.20)__
+* __[RedisJSON 2.4.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.9)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.15)__
+* __[RedisTimeSeries 1.8.14](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.14)__
+* __[RedisBloom 2.4.9](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.9)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.4 or greater](https://github.com/redis/jedis/releases/tag/v5.1.4)
+  * [redis-om-spring 0.9.4 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.9.4)
+* Python
+  * [redis-py 5.0.9 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.9)
+  * [redis-om-python 0.3.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.3.1)
+* NodeJS
+  * [node-redis 4.7.0 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.7.0)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.4 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.4)
+  * [NRedisStack 0.12.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.6.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.6.1)
+  * [rueidis 1.0.43 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.43)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.54](https://github.com/RedisInsight/RedisInsight/releases/tag/2.54.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v15 (June 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+### Headlines:
+Redis Stack 6.2.6-v15 introduces an updated **search and query** capability with several enhancements and bug fixes.
+The updated **search and query** version features improved memory reporting that accounts for additional memory consumed by `TAG` and `TEXT` tries. Also, it includes additional fields in the `FT.INFO` command when used within a cluster.
+This maintenance release also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4599](https://github.com/RediSearch/RediSearch/pull/4599) - Report additional memory consumed by the `TAG` and `TEXT` tries (MOD-5902)
+  * [#4688](https://github.com/RediSearch/RediSearch/pull/4688) - Add missing `FT.INFO` fields when used within a cluster (MOD-6920)
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4616](https://github.com/RediSearch/RediSearch/pull/4616) - Shards become unresponsive when using `FT.AGGREGATE` with `APPLY 'split(...)'`(MOD-6759)
+  * [#4557](https://github.com/RediSearch/RediSearch/pull/4557) - `FT.EXPLAIN` returns additional `}` when querying using wildcards (MOD-6768)
+  * [#4647](https://github.com/RediSearch/RediSearch/pull/4647) - `FT.DROPINDEX` with `DD` flag deleted keys in one AA cluster but not the others (MOD-1855)
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.19](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.19)__
+* __[RedisJSON 2.4.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.9)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.15)__
+* __[RedisTimeSeries 1.8.13](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.13)__
+* __[RedisBloom 2.4.9](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.9)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.3 or later](https://github.com/redis/jedis/releases/tag/v5.1.3)
+  * [redis-om-spring 0.9.1 or later](https://github.com/redis/redis-om-spring/releases/tag/v0.9.1)
+* Python
+  * [redis-py 5.0.5 or later](https://github.com/redis/redis-py/releases/tag/v5.0.5)
+  * [redis-om-python 0.3.1 or later](https://github.com/redis/redis-om-python/releases/tag/v0.3.1)
+* NodeJS
+  * [node-redis 4.6.14 or later](https://github.com/redis/node-redis/releases/tag/redis%404.6.14)
+  * [redis-om-node 0.2.0 or later](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.7.1 or later](https://github.com/redis/redis-om-dotnet/releases/tag/v0.7.1)
+  * [NRedisStack 0.12.0 or later](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.5.2 or later](https://github.com/redis/go-redis/releases/tag/v9.5.2)
+  * [rueidis 1.0.38 or later](https://github.com/redis/rueidis/releases/tag/v1.0.38)
+
+Compatible with [Redis Insight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [Redis Insight 2.50](https://github.com/RedisInsight/RedisInsight/releases/tag/2.50.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Downloads
+
+* macOS: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.catalina.x86_64.zip), [arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.monterey.arm64.zip)
+* AppImage: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15-x86_64.AppImage)
+* Ubuntu: [Bionic x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.bionic.x86_64.tar.gz), [Bionic arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.bionic.arm64.tar.gz), [Focal x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.focal.x86_64.tar.gz), [Focal arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.focal.arm64.tar.gz), [Snap x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.x86_64.snap), [Snap arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.arm64.snap), [Jammy x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.jammy.x86_64.tar.gz), [Jammy arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.jammy.arm64.tar.gz)
+* Debian: [Bullseye x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.bullseye.x86_64.tar.gz)
+* RHEL 7/CentOS Linux 7: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.rhel7.x86_64.tar.gz)
+* RHEL 8/CentOS Linux 8: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v15.rhel8.x86_64.tar.gz)
+* Redis Stack on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack)
+* Redis Stack server on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack-server)
+
+## Redis Stack Server 6.2.6-v14 (April 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest **search and query** capability with several improvements and bug fixes, including a critical bug fix. This release also includes the latest **JSON** data structure with a fix for a potential crash, and the **time series** data structure with more detailed LibMR error messages and a fix for a potential crash. It also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **Search and query**:
+  * [#4502](https://github.com/RediSearch/RediSearch/pull/4502) Handle error properly when trying to execute Search commands on cluster setup as part of `MULTI`/`EXEC` or LUA script (MOD-6541)
+
+* **Time series**:
+  * [#1593](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1593) More detailed LibMR error messages
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4524](https://github.com/RediSearch/RediSearch/pull/4524) `FT.CURSOR READ` in a numeric query causing a crash (MOD-6597)
+  * [#4543](https://github.com/RediSearch/RediSearch/pull/4543) `FT.SEARCH` accessing an inexistent memory address causes a crash if using deprecated `FT.ADD` command (MOD-6599)
+  * [#4535](https://github.com/RediSearch/RediSearch/pull/4535) `FT.PROFILE` with incorrect arguments could cause a crash on cluster setup (MOD-6791)
+  * [#4540](https://github.com/RediSearch/RediSearch/pull/4540) Unfree memory from an existing RDB while re-indexing loading a new RDB could cause a crash (MOD-6831, 6810)
+  * [#4485](https://github.com/RediSearch/RediSearch/pull/4485) Some parameter settings using just prefixes instead of full values were working (MOD-6709)
+  * [#4557](https://github.com/RediSearch/RediSearch/pull/4557) Additional "`}`" on wildcards replies for `FT.EXPLAIN` (MOD-6768)
+
+* **JSON**:
+  * [#1192](https://github.com/RedisJSON/RedisJSON/pull/1192) Crashes with numeric values greater than i64::MAX (MOD-6501, MOD-4551, MOD-4856, MOD-5714)
+
+* **Time series**:
+  * [LibMR#51](https://github.com/RedisGears/LibMR/pull/51) Crash on SSL initialization failure (MOD-5647)
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.18](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.18)__
+* __[RedisJSON 2.4.9](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.9)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.15)__
+* __[RedisTimeSeries 1.8.13](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.13)__
+* __[RedisBloom 2.4.9](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.9)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.2 or later](https://github.com/redis/jedis/releases/tag/v5.1.2)
+  * [redis-om-spring 0.8.9 or later](https://github.com/redis/redis-om-spring/releases/tag/v0.8.9)
+* Python
+  * [redis-py 5.0.3 or later](https://github.com/redis/redis-py/releases/tag/v5.0.3)
+  * [redis-om-python 0.2.2 or later](https://github.com/redis/redis-om-python/releases/tag/v0.2.2)
+* NodeJS
+  * [node-redis 4.6.13 or later](https://github.com/redis/node-redis/releases/tag/redis%404.6.13)
+  * [redis-om-node 0.2.0 or later](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or later](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.12.0 or later](https://github.com/redis/NRedisStack/releases/tag/v0.12.0)
+* Go
+  * [go-redis 9.5.1 or later](https://github.com/redis/go-redis/releases/tag/v9.5.1)
+  * [rueidis 1.0.33 or later](https://github.com/redis/rueidis/releases/tag/v1.0.33)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.46](https://github.com/RedisInsight/RedisInsight/releases/tag/2.46.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Downloads
+
+* macOS: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.catalina.x86_64.zip), [arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.monterey.arm64.zip)
+* AppImage: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14-x86_64.AppImage)
+* Ubuntu: [Bionic x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.bionic.x86_64.tar.gz), [Bionic arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.bionic.arm64.tar.gz), [Focal x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.focal.x86_64.tar.gz), [Focal arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.focal.arm64.tar.gz), [Snap x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.x86_64.snap), [Snap arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.arm64.snap), [Jammy x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.jammy.x86_64.tar.gz), [Jammy arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.jammy.arm64.tar.gz)
+* Debian: [Bullseye x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.bullseye.x86_64.tar.gz)
+* RHEL 7/CentOS Linux 7: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.rhel7.x86_64.tar.gz)
+* RHEL 8/CentOS Linux 8: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v14.rhel8.x86_64.tar.gz)
+* Redis Stack on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack)
+* Redis Stack server on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack-server)
+
+## Redis Stack Server 6.2.6-v13 (March 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+### Headlines:
+This version contains the latest **search and query** capability and **probabilistic** data structures with several bug fixes. It also contains the latest version of **RedisInsight**.
+
+### Details:
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4477](https://github.com/RediSearch/RediSearch/pull/4477) Split `INFIX` and `SUFFIX` report on `FT.EXPLAIN` and `FT.EXPLAINCLI` (MOD-6186)
+  * [#4468](https://github.com/RediSearch/RediSearch/pull/4468) Memory leak upon suffix query for a `TAG` indexed with `WITHSUFFIXTRIE` (MOD-6644)
+  * [#4407](https://github.com/RediSearch/RediSearch/pull/4407) Clustered `FT.SEARCH` hangs forever without replying when an invalid topology is found (MOD-6557)
+  * [#4359](https://github.com/RediSearch/RediSearch/pull/4359) Searching for a synonym will iterate in the same group multiple times, causing a performance hit (MOD-6490)
+  * [#4310](https://github.com/RediSearch/RediSearch/pull/4310) Memory tracking on cluster setups causing high memory usage and potentially Out-of-Memory (MOD-6123, MOD-5639)
+
+* **Probabilistic data structures**:
+  * [#753](https://github.com/RedisBloom/RedisBloom/issues/753) Potential crash on `CMS.MERGE` when using invalid arguments
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.16](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.16)__
+* __[RedisJSON 2.4.8](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.8)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.15)__
+* __[RedisTimeSeries 1.8.12](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.12)__
+* __[RedisBloom 2.4.9](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.9)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.1 or greater](https://github.com/redis/jedis/releases/tag/v5.1.1)
+  * [redis-om-spring 0.8.8 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.8)
+* Python
+  * [redis-py 5.0.2 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.2)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.13 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.13)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.5.1 or greater](https://github.com/redis/go-redis/releases/tag/v9.5.1)
+  * [rueidis 1.0.31 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.31)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.44](https://github.com/RedisInsight/RedisInsight/releases/tag/2.44.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Downloads
+
+* macOS: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.catalina.x86_64.zip), [arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.monterey.arm64.zip)
+* AppImage: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13-x86_64.AppImage)
+* Ubuntu: [Bionic x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.bionic.x86_64.tar.gz), [Bionic arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.bionic.arm64.tar.gz), [Focal x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.focal.x86_64.tar.gz), [Focal arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.focal.arm64.tar.gz), [Snap x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.x86_64.snap), [Snap arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.arm64.snap), [Jammy x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.jammy.x86_64.tar.gz), [Jammy arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.jammy.arm64.tar.gz)
+* Debian: [Bullseye x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.bullseye.x86_64.tar.gz)
+* RHEL 7/CentOS Linux 7: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.rhel7.x86_64.tar.gz)
+* RHEL 8/CentOS Linux 8: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v13.rhel8.x86_64.tar.gz)
+* Redis Stack on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack)
+* Redis Stack server on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack-server)
+
+## Redis Stack Server 6.2.6-v12 (January 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug fixed in the probabilistic data structures that may affect a subset of users. Upgrade!
+
+### Headlines:
+This maintenance release contains the new version of **probabilistic** data structures with a critical bug fix, the new version of  **JSON** data structure with added support for CBL-Mariner 2, and a fix to add keyspace notifications for `JSON.TOGGLE`. It also contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Improvements**
+* **JSON**:
+  * [#1149](https://github.com/RedisJSON/RedisJSON/pull/1149) Added support for CBL-Mariner 2
+
+**Bug Fixes**
+* **JSON**:
+  * [#1025](https://github.com/RedisJSON/RedisJSON/pull/1025) `JSON.TOGGLE` - missing keyspace notification
+
+* **Probabilistic data structures**:
+  * [#727](https://github.com/RedisBloom/RedisBloom/pull/727) Potential crash on `CF.LOADCHUNK` (MOD-6344) - Additional fixes
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.15](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.15)__
+* __[RedisJSON 2.4.8](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.8)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.12)__
+* __[RedisTimeSeries 1.8.12](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.12)__
+* __[RedisBloom 2.4.8](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.8)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.0 or greater](https://github.com/redis/jedis/releases/tag/v5.1.0)
+  * [redis-om-spring 0.8.8 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.8)
+* Python
+  * [redis-py 5.0.1 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.12 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.12)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.4.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.4.0)
+  * [rueidis 1.0.27 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.27)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.40](https://github.com/RedisInsight/RedisInsight/releases/tag/2.40.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v11 (January 2024)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+This version contains the latest **time series data** structure with a security fix to not expose internal commands, a fix for potential crashes when using an invalid argument value, and support for CBL-Mariner 2. The new Redis Stack version introduces security fixes for **probabilistic data structures** to avoid potential crashes. It also includes the latest **search and query** capability with several bug fixes and improvements. This version contains the latest version of **RedisInsight**.
+
+### Details:
+
+ **Security and privacy**
+* **Time series**:
+  * [#1506](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1506)​​ Don’t expose internal commands (MOD-5643)
+
+* **Probabilistic data structures**:
+  * [#721](https://github.com/RedisBloom/RedisBloom/issues/721) Potential crash on `CF.RESERVE` (MOD-6343)
+  * [#722](https://github.com/RedisBloom/RedisBloom/issues/722) Potential crash on `CF.LOADCHUNK` (MOD-6344)
+
+ **Improvements**
+* **Search and query**:
+  * [#4176](https://github.com/RediSearch/RediSearch/pull/4176) Initialization of the maximum numeric value range leading to a better balance of the index leaf splitting (MOD-6232)
+  * [#4123](https://github.com/RediSearch/RediSearch/pull/4123) Possibly problematic index name alias check-in command multiplexing (MOD-5945)
+  * [#4195](https://github.com/RediSearch/RediSearch/pull/4195) Query optimisation when predicate contains multiple `INTERSECTION` (AND) of `UNION` (OR) (MOD-5910)
+
+* **Time series**:
+  * [#1516](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1516) Added support for CBL-Mariner 2
+
+**Bug Fixes**
+* **Search and query**:
+  * [#4244](https://github.com/RediSearch/RediSearch/pull/4244), [#4255](https://github.com/RediSearch/RediSearch/pull/4255) Profiling `FT.AGGREGATE` using the `WITHCURSOR` flag cause a crash due to timeout (MOD-5512)
+  * [#4238](https://github.com/RediSearch/RediSearch/pull/4238) Memory excessively growing on databases caused by unbalanced nodes on inverted index trie (MOD-5880, MOD-5952, MOD-6003)
+  * [#3995](https://github.com/RediSearch/RediSearch/pull/3995) `FT.CURSOR READ` with geo queries causing a crash when data is updated between the cursor reads (MOD-5646)
+  * [#4155](https://github.com/RediSearch/RediSearch/pull/4155) `FT.SEARCH` not responding when using TLS encryption on Amazon Linux 2 (MOD-6012)
+
+* **Time series**:
+  * [#1494](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1494) Potential crash when using an invalid argument value
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.15](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.15)__
+* __[RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.12)__
+* __[RedisTimeSeries 1.8.12](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.12)__
+* __[RedisBloom 2.4.7](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.7)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.1.0 or greater](https://github.com/redis/jedis/releases/tag/v5.1.0)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.12 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.12)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.6.1 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.6.1)
+  * [NRedisStack 0.11.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.11.0)
+* Go
+  * [go-redis 9.4.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.4.0)
+  * [rueidis 1.0.26 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.26)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.40](https://github.com/RedisInsight/RedisInsight/releases/tag/2.40.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v10 (November 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+This version contains a security fix for the Redis server to avoid bypassing desired Unix socket permissions on startup. It also includes the latest Search and Query capability with a fix to limit the maximum phonetic length and several bug fixes. This version contains the latest version of RedisInsight.
+
+### Details:
+
+ **Security and privacy:**
+* **Redis**:
+  * (CVE-2023-45145) The wrong order of `listen(2)` and `chmod(2)` calls creates a race condition that can be used by another process to bypass desired Unix socket permissions on startup.
+
+* **Search and Query**:
+  * [#3844](https://github.com/RediSearch/RediSearch/pull/3844) Limits maximum phonetic length avoiding to be exploited (MOD 5767)
+
+**Bug Fixes**
+* **Search and Query**:
+  * [#3771](https://github.com/RediSearch/RediSearch/pull/3771) Broken lower and upper `APPLY` functions in `FT.AGGREGATE` on `DIALECT 3` (MOD-5041)
+  * [#3910](https://github.com/RediSearch/RediSearch/pull/3910) Heavy document updates causing memory growth once memory blocks weren't properly released (MOD-5181)
+  * [#3853](https://github.com/RediSearch/RediSearch/pull/3853) Queries with `WITHCURSOR` making memory growth since `CURSOR` wasn't invalidated in the shards (MOD-5580)
+  * [#3752](https://github.com/RediSearch/RediSearch/pull/3752) Setting low `MAXIDLE` parameter value in `FT.AGGREGATE` causes a crash (MOD-5608)
+  * [#3823](https://github.com/RediSearch/RediSearch/pull/3823) `APPLY` or `FILTER` expression causing a leak (MOD-5751)
+  * [#3837](https://github.com/RediSearch/RediSearch/pull/3837) Connection using TLS fails on Redis (MOD-5768)
+  * [#3856](https://github.com/RediSearch/RediSearch/pull/3856) Adding new nodes to OSS cluster causing a crash (MOD-5778)
+  * [#3854](https://github.com/RediSearch/RediSearch/pull/3854) Vector range query could cause Out-of-Memory due a memory corruption (MOD-5791)
+  * [#3892](https://github.com/RediSearch/RediSearch/pull/3892) After cleaning the index the GC could cause corruption on unique values (MOD-5815)
+
+
+
+**Redis version**
+* [Redis 6.2.14](https://github.com/redis/redis/releases/tag/6.2.14)
+
+**Module versions**	
+* __[RediSearch 2.6.14](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.14)__
+* __[RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.12)__
+* __[RedisTimeSeries 1.8.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.11)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 5.0.2 or greater](https://github.com/redis/jedis/releases/tag/v5.0.2)
+  * [redis-om-spring 0.8.7 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.7)
+* Python
+  * [redis-py 5.0.1 or greater](https://github.com/redis/redis-py/releases/tag/v5.0.1)
+  * [redis-om-python 0.2.1 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.2.1)
+* NodeJS
+  * [node-redis 4.6.10 or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.10)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.4 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.4)
+  * [NRedisStack 0.10.1 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.10.1)
+* Go
+  * [go-redis 9.3.0 or greater](https://github.com/redis/go-redis/releases/tag/v9.3.0)
+  * [rueidis 1.0.22 or greater](https://github.com/redis/rueidis/releases/tag/v1.0.22)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.36](https://github.com/RedisInsight/RedisInsight/releases/tag/2.36.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Downloads
+
+* macOS: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.catalina.x86_64.zip), [arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.monterey.arm64.zip)
+* AppImage: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10-x86_64.AppImage)
+* Ubuntu: [Bionic x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.bionic.x86_64.tar.gz), [Bionic arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.bionic.arm64.tar.gz), [Focal x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.focal.x86_64.tar.gz), [Focal arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.focal.arm64.tar.gz), [Snap x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.x86_64.snap), [Snap arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.arm64.snap), [Jammy x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.jammy.x86_64.tar.gz), [Jammy arm64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.jammy.arm64.tar.gz)
+* Debian: [Bullseye x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.bullseye.x86_64.tar.gz)
+* RHEL 7/CentOS Linux 7: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.rhel7.x86_64.tar.gz)
+* RHEL 8/CentOS Linux 8: [x86_64](https://packages.redis.io/redis-stack/redis-stack-server-6.2.6-v10.rhel8.x86_64.tar.gz)
+* Redis Stack on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack)
+* Redis Stack server on [Dockerhub](https://hub.docker.com/u/redis): [x86_64 and arm64](https://hub.docker.com/r/redis/redis-stack-server)
+
+## Redis Stack Server 6.2.6-v9 (July 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest Search and Query capability v. 2.6.12, time series v. 1.8.11, and graph v. 2.10.12 with fixes and improvements. It also includes the latest version of RedisInsight.
+
+### Details:
+
+ **Improvements**
+* **Search and Query**:
+  * [#3628](https://github.com/RediSearch/RediSearch/pull/3628) Background indexing scanning performance
+  * [#3259](https://github.com/RediSearch/RediSearch/pull/3259) Allow alias name beginning with `as`
+  * [#3641](https://github.com/RediSearch/RediSearch/pull/3641) Indexing sanitizing trigger in heavily data updates scenario
+
+* **Time series**:
+  * [#1476](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1476) Significant performance improvement when using multiple label filters (`TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE`, and `TS.QUERYINDEX`)
+
+**Bug Fixes**
+* **Search and Query**:
+  * [#3557](https://github.com/RediSearch/RediSearch/pull/3557) `TIMEOUT` configuration on `FT.AGGREGATE` query being ignored
+  * [#3552](https://github.com/RediSearch/RediSearch/pull/3552) `FT.CURSOR READ` on `JSON` numeric queries not returning results
+  * [#3606](https://github.com/RediSearch/RediSearch/pull/3606) Update numeric inverted index `numEntries` avoiding excessive memory consumption
+  * [#3597](https://github.com/RediSearch/RediSearch/pull/3597) Duplicating alias as output name on `FT.AGGREGATE` reducer (`REDUCE` argument) isn't return results
+  * [#3654](https://github.com/RediSearch/RediSearch/pull/3654) Added check for @ prefix on `GROUPBY` fields returnig an error instead of wrong results
+
+* **Time series**:
+  * [#1486](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1486) When using `LATEST`, results may contain samples earlier than `fromTimestamp` (`TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`)
+  * [#1471](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1471) Potential crash on `TS.MRANGE` when aggregating millions of time series
+  * [#1469](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1469) Potential memory leak in `TS.MRANGE` after eviction
+
+* **Graph**:
+  * [#3129](https://github.com/RedisGraph/RedisGraph/pull/3129) Crash on certain queries (`INDEX SCAN` followed by `DEL` followed by `SET`)
+
+**Redis version**
+* [Redis 6.2.13](https://github.com/redis/redis/blob/6.2.13/00-RELEASENOTES)
+
+**Module versions**	
+* __[RediSearch 2.6.12](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.12)__
+* __[RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)__
+* __[RedisGraph 2.10.12](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.12)__
+* __[RedisTimeSeries 1.8.11](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.11)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.4.3 or greater ](https://github.com/redis/jedis/releases/tag/v4.4.3)
+  * [redis-om-spring 0.8.4 or greater](https://github.com/redis/redis-om-spring/releases/tag/v0.8.4)
+* Python
+  * [redis-py 4.6.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.6.0)
+  * [redis-om-python 0.1.2 or greater](https://github.com/redis/redis-om-python/releases/tag/v0.1.2)
+* NodeJS
+  * [node-redis 4.6.7  or greater](https://github.com/redis/node-redis/releases/tag/redis%404.6.7)
+  * [redis-om-node 0.2.0 or greater](https://github.com/redis/redis-om-node/releases/tag/v0.2.0)
+* .NET
+  * [redis-om-dotnet 0.5.2 or greater](https://github.com/redis/redis-om-dotnet/releases/tag/v0.5.2)
+  * [NRedisStack 0.8.0 or greater](https://github.com/redis/NRedisStack/releases/tag/v0.8.0)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.28](https://github.com/RedisInsight/RedisInsight/releases/tag/2.28.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v8 (July 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+This version contains security improvements for the Redis server.
+
+### Details:
+
+ **Improvements**
+* **Redis**:
+  * ([CVE-2022-24834](https://github.com/redis/redis/security/advisories/GHSA-p8x2-9v9q-c838)) A specially crafted Lua script executing in Redis can trigger
+a heap overflow in the cjson and cmsgpack libraries, and result in heap
+corruption and potentially remote code execution. The problem exists in all
+versions of Redis with Lua scripting support, starting from 2.6, and affects
+only authenticated and authorized users.
+  * ([CVE-2023-36824](https://github.com/redis/redis/security/advisories/GHSA-4cfx-h9gq-xpx3)) Extracting key names from a command and a list of arguments
+may, in some cases, trigger a heap overflow and result in reading random heap
+memory, heap corruption and potentially remote code execution. Specifically:
+using COMMAND GETKEYS* and validation of key names in ACL rules.
+
+**Bug Fixes**
+* **Redis**:
+  * [#12276](https://github.com/redis/redis/pull/12276) Re-enable downscale rehashing while there is a fork child
+
+**Redis version**
+* [Redis 6.2.13](https://github.com/redis/redis/blob/6.2.13/00-RELEASENOTES)
+
+**Module versions**
+* __[RediSearch 2.6.9](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.9)__
+* __[RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)__
+* __[RedisGraph 2.10.10](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.10)__
+* __[RedisTimeSeries 1.8.10](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.10)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.5.4 or greater ](https://github.com/redis/redis-py/releases/tag/v4.5.4)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.6.5  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+  * [NRedisStack](https://github.com/redis/NRedisStack)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight](https://github.com/RedisInsight/RedisInsight/releases/).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v7 (April 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `SECURITY`:  there are security fixes in the release.
+
+### Headlines:
+This version contains the latest RediSearch 2.6.9, RedisJSON 2.4.7, RedisGraph 2.10.10, RedisTimeSeries 1.8.10, and RedisBloom 2.4.5, RedisInsight 2.22 and new Redis server 6.2.12 with fixes to security issues.
+
+### Details:
+
+**Improvements**:
+* Redis [#12057](https://github.com/redis/redis/pull/12057) Authenticated users can use the [HINCRBYFLOAT](https://redis.io/commands/hincrbyfloat/) command to create an invalid hash field that will crash Redis on access
+* RediSearch [#3430](https://github.com/RediSearch/RediSearch/pull/3430) Improve `min-max heap` structure for better readability and performance
+* RediSearch [#3450](https://github.com/RediSearch/RediSearch/pull/3450) Display `NOHL` option in `FT.INFO` command
+* RediSearch [#3534](https://github.com/RediSearch/RediSearch/pull/3534) Vector Similarity 0.6.1: Improve multi-value index deletion logic [(#346)](https://github.com/RedisAI/VectorSimilarity/pull/346)
+
+**Bug Fixes**
+* RediSearch [#3468](https://github.com/RediSearch/RediSearch/pull/3468) KNN searching for 0 vectors with a filter resulted in crash
+* RediSearch [#3499](https://github.com/RediSearch/RediSearch/pull/3499) `MAXSEARCHRESULTS` set to `0` causing `FT.SEARCH` crash
+* RediSearch [#3494](https://github.com/RediSearch/RediSearch/pull/3494) Removing `MAXSEARCHRESULTS`limit causes crash on `FT.AGGREGATE`
+* RediSearch [#3504](https://github.com/RediSearch/RediSearch/pull/3504) Uninitialised vector similarity query parameter bug
+* RedisJSON [#947](https://github.com/RedisJSON/RedisJSON/issues/947) Using array slice operator (`[start:end:step]`) with step `0` causes crash
+* RedisGraph [#3038](https://github.com/RedisGraph/RedisGraph/issues/3038) Potential crash when a query with a `UNION` clause sets or modifies an indexed property
+* RedisGraph [#2631](https://github.com/RedisGraph/RedisGraph/issues/2631), [#2968](https://github.com/RedisGraph/RedisGraph/issues/2968) Potential crash on certain `MATCH` clauses where label filters are used
+* RedisGraph [#2957](https://github.com/RedisGraph/RedisGraph/issues/2957) Label filters in expressions such as `WITH n MATCH (n:X)` are ignored
+* RedisGraph [#2931](https://github.com/RedisGraph/RedisGraph/issues/2931), [#3027](https://github.com/RedisGraph/RedisGraph/issues/3027) Wrong overflow error message
+* RedisTimeSeries [#1455](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1455) [TS.ADD](https://redis.io/commands/ts.add/) - optional arguments are not replicated
+
+**Redis version**
+* [Redis 6.2.12](https://github.com/redis/redis/blob/6.2.12/00-RELEASENOTES)
+
+**Module versions**
+* __[RediSearch 2.6.9](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.9)__
+* __[RedisJSON 2.4.7](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.7)__
+* __[RedisGraph 2.10.10](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.10)__
+* __[RedisTimeSeries 1.8.10](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.10)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.5.4 or greater ](https://github.com/redis/redis-py/releases/tag/v4.5.4)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.6.5  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+  * [NRedisStack](https://github.com/redis/NRedisStack)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.22](https://github.com/RedisInsight/RedisInsight/releases/tag/2.22.1).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v6 (March 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `MODERATE`: Program an upgrade of the server, but it's not urgent.
+
+### Headlines:
+This version contains the latest RedisTimeSeries 1.8.9 with bugs fixed.
+
+### Details:
+
+**Bug Fixes**
+* RedisTimeSeries [#1421](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1421) Potential crash after deleting from a time series with an `AVG` compaction
+* RedisTimeSeries [#1422](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1422) Incorrectly return an error when deleting from a time series with a compaction and with no expiry
+
+
+**Redis version**
+* [Redis 6.2.11](https://github.com/redis/redis/blob/6.2.11/00-RELEASENOTES)
+
+
+**Module versions**
+* __[RediSearch 2.6.6](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.6)__
+* __[RedisJSON 2.4.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.6)__
+* __[RedisGraph 2.10.9](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.9)__
+* __[RedisTimeSeries 1.8.9](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.9)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+  * [NRedisStack](https://github.com/redis/NRedisStack)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.20](https://github.com/RedisInsight/RedisInsight/releases/tag/2.20.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v5 (March 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest RediSearch 2.6.6, RedisJSON 2.4.6, RedisGraph 2.10.9, RedisTimeSeries 1.8.8, RedisBloom 2.4.5, and RedisInsight 2.20 with improvements and bugs fixed.
+
+### Details:
+**Improvements**
+* RediSearch [ #3397](https://github.com/RediSearch/RediSearch/pull/3397) Improve the Vecsim initial capacity default value
+* RediSearch and RedisJSON [#3418](https://github.com/RediSearch/RediSearch/pull/3418) Add support to OS Amazon Linux 2
+* RediSearch and RedisJSON - Add full OS list on RAMP file
+* RedisBloom - Internal changes for supporting future Redis Enterprise releases
+
+**Bug Fixes**
+* RediSearch [#3403](https://github.com/RediSearch/RediSearch/pull/3403) Fix suffix and prefix matching when using `CASESENSITIVE` flag
+* RedisJSON [#912](https://github.com/RedisJSON/RedisJSON/pull/912) Fix actual memory usage calculation
+* RedisGraph [#2880](https://github.com/RedisGraph/RedisGraph/issues/2880) Potential crash when using `WITH *` expressions
+* RedisGraph [#2917](https://github.com/RedisGraph/RedisGraph/issues/2917) Potential crash when using `CASE` expressions
+* RedisGraph [#2836](https://github.com/RedisGraph/RedisGraph/issues/2836) Potential crash on `*0` variable-length path
+* RedisGraph [#2916](https://github.com/RedisGraph/RedisGraph/issues/2916) Potential crash when executing concurrent queries that utilize full-text indices
+* RedisTimeSeries [#1290](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1290) Potential crash when using `FILTER_BY_TS`
+* RedisTimeSeries [#1397](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1397) Memory leak when trying to create an already existing key
+
+**Redis version**
+* [Redis 6.2.11](https://github.com/redis/redis/blob/6.2.11/00-RELEASENOTES)
+
+**Module versions**
+* __[RediSearch 2.6.6](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.6)__
+* __[RedisJSON 2.4.6](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.6)__
+* __[RedisGraph 2.10.9](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.9)__
+* __[RedisTimeSeries 1.8.8](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.8)__
+* __[RedisBloom 2.4.5](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.5)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+  * [NRedisStack](https://github.com/redis/NRedisStack)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.20](https://github.com/RedisInsight/RedisInsight/releases/tag/2.20.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v4 (February 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `LOW`: No need to upgrade unless there are new features you want to use.
+
+### Headlines:
+This version contains the latest RedisJSON 2.4.5 with support for Ubuntu 20 - Focal Fossa OS.
+
+**Module versions**
+* __[RediSearch 2.6.5](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.5)__
+* __[RedisJSON 2.4.5](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.5)__
+* __[RedisGraph 2.10.8](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.8)__
+* __[RedisTimeSeries 1.8.5](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.5)__
+* __[RedisBloom 2.4.4](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.4)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+  * [NRedisStack](https://github.com/redis/NRedisStack)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.18](https://github.com/RedisInsight/RedisInsight/releases/tag/2.18.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v3 (February 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest RediSearch 2.6.5, RedisJSON 2.4.4, RedisGraph 2.10.8, RedisBloom 2.4.4, and RedisInsight 2.18 with new features and bugs fixed.
+
+### Details:
+**Improvements**
+* RediSearch [#3361](https://github.com/RediSearch/RediSearch/pull/3361) Enable the use of IPv6 for all cluster and module communication
+* RedisJSON [#813](https://github.com/RedisJSON/RedisJSON/pull/813) - Improve the errors messages in modules [#725](https://github.com/RedisJSON/RedisJSON/issues/725)
+* RedisJSON [#918](https://github.com/RedisJSON/RedisJSON/pull/918) - Add IPv6 on the capability list
+* RedisGraph [#2790](https://github.com/RedisGraph/RedisGraph/pull/2790) Improved performance by disabling SuiteSparse:GraphBLAS' global free pool
+* RedisGraph [#2758](https://github.com/RedisGraph/RedisGraph/pull/2758) Improved edge deletion performance
+* RedisGraph [#2781](https://github.com/RedisGraph/RedisGraph/issues/2781) `indegree` and `outdegree` now also accept an argument which is a list of labels
+* RedisBloom [#389](https://github.com/RedisBloom/RedisBloom/issues/389) Introduce `BF.CARD` to retrieve the cardinality of a Bloom filter or 0 when such key does not exist
+
+**Bug Fixes**
+* RediSearch [#3354](https://github.com/RediSearch/RediSearch/pull/3354) Library update preventing a crash during cluster failover
+* RediSearch [#3357](https://github.com/RediSearch/RediSearch/pull/3357) Handling division by zero in expressions preventing nodes to restart
+* RediSearch [#3332](https://github.com/RediSearch/RediSearch/pull/3332) Fix wildcards * queries on `DIALECT 2` and `DIALECT 3`
+* RedisJSON [#919](https://github.com/RedisJSON/RedisJSON/pull/919) Possible failure loading `.rdb` files
+* RedisGraph [#2777](https://github.com/RedisGraph/RedisGraph/issues/2777), [#2841](https://github.com/RedisGraph/RedisGraph/issues/2841) Potential crash when sending queries from multiple connections and timeout is not 0
+* RedisGraph [#2844](https://github.com/RedisGraph/RedisGraph/issues/2844) Potential partial results when same parametrized query is running from multiple connections
+* RedisGraph [#2739](https://github.com/RedisGraph/RedisGraph/issues/2739), [#2774](https://github.com/RedisGraph/RedisGraph/issues/2774) Paths with exact variable length >1 are not matched
+* RedisGraph [#2794](https://github.com/RedisGraph/RedisGraph/issues/2794) `toInteger` and `toIntegerOrNull` don't convert Booleans
+* RedisGraph [#2798](https://github.com/RedisGraph/RedisGraph/issues/2798) `right` and `left` should reply with an error when `length` is null
+* RedisGraph [#2809](https://github.com/RedisGraph/RedisGraph/issues/2809) `TIMEOUT_MAX` configuration parameter in not enforced when `TIMEOUT_DEFAULT` is 0
+* RedisGraph [#2780](https://github.com/RedisGraph/RedisGraph/issues/2780) `indegree` and `outdegree` - relationships are counted more than once when same relationship type is supplied more than once
+* RedisBloom [#609](https://github.com/RedisBloom/RedisBloom/issues/609) `CF.INFO` - incorrect information for large filters
+
+**Redis version**
+* [Redis 6.2.10](https://github.com/redis/redis/blob/6.2.10/00-RELEASENOTES)
+
+**Module versions**
+* __[RediSearch 2.6.5](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.5)__
+* __[RedisJSON 2.4.4](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.4)__
+* __[RedisGraph 2.10.8](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.8)__
+* __[RedisTimeSeries 1.8.5](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.5)__
+* __[RedisBloom 2.4.4](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.4)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [nredisstack 0.5.0  or greater](https://www.nuget.org/packages/nredisstack/)
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for is bundled with [RedisInsight 2.18](https://github.com/RedisInsight/RedisInsight/releases/tag/2.18.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v2  (January 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest RedisInsight 2.16 and RedisTimeSeries 1.8.5 with bugs fixed.
+
+### Details:
+**Bug Fixes**
+* RedisTimeSeries [#1388](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1388) Potential crash when upgrading from v1.6 to 1.8 if there are compactions with `min` or `max` aggregation
+ 
+**Redis version** (no changes)
+* [Redis 6.2.8](https://github.com/redis/redis/blob/6.2.7/00-RELEASENOTES)
+ 
+**Module versions**
+* __[RediSearch 2.6.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.4)__
+* __[RedisJSON 2.4.3](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.3)__
+* __[RedisGraph 2.10.5](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.5)__
+* __[RedisTimeSeries 1.8.5](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.5)__
+* __[RedisBloom 2.4.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.3)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.16](https://github.com/RedisInsight/RedisInsight/releases/tag/2.16.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack 6.2.6-v1 (January 2023)
+
+This is a maintenance release for Redis Stack Server 6.2.6
+
+Update urgency: `HIGH`: There is a critical bug that may affect a subset of users. Upgrade!
+
+### Headlines:
+This version contains the latest RediSearch 2.6.4, RedisJSON 2.4.3, RedisGraph 2.10.5, and RedisTimeSeries 1.8.4 with new features and bugs fixed.
+
+### Details:
+**Improvements**
+* RediSearch [#3256](https://github.com/RediSearch/RediSearch/pull/3256) Support IPv6 on cluster set command
+* RediSearch [#3194](https://github.com/RediSearch/RediSearch/pull/3194) Add the query dialects that are in use to `FT.INFO` and `INFO MODULE` commands
+* RediSearch [#3258](https://github.com/RediSearch/RediSearch/pull/3258) Add the module version and Redis version to `INFO MODULE`
+* RedisJSON [#892](https://github.com/RedisJSON/RedisJSON/pull/892) Allow `JSON.ARRINDEX` with none scalar values
+* RedisGraph [#2757](https://github.com/RedisGraph/RedisGraph/pull/2757) Improved performance of `indegree` and `outdegree`
+* RedisGraph [#2681](https://github.com/RedisGraph/RedisGraph/issues/2681) Fixed some error messages
+* RedisGraph [#2740](https://github.com/RedisGraph/RedisGraph/issues/2740) Don’t show partial results for timed-out [GRAPH.PROFILE](https://redis.io/commands/graph.profile/)
+* RedisTimeSeries [#1215](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1215) OSS cluster: Support TLS and IPv6; Introduce new configuration parameter: [OSS_GLOBAL_PASSWORD](https://redis.io/docs/stack/timeseries/configuration/#oss_global_password)
+ 
+**Bug Fixes**
+* RediSearch [#3289](https://github.com/RediSearch/RediSearch/pull/3289) Potential crash when querying multiple fields
+* RediSearch [#3279](https://github.com/RediSearch/RediSearch/pull/3279) Potential crash when querying using wildcard * on TAG field
+* RedisJSON [#890](https://github.com/RedisJSON/RedisJSON/pull/890) JSONPath ignores any filter condition beyond the second
+* RedisGraph [#2754](https://github.com/RedisGraph/RedisGraph/pull/2754) Partial sync may hang
+* RedisTimeSeries [#1360](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1360) Potential crash when upgrading from v1.6 to 1.8 if there are compactions with `min` or `min` aggregation
+* RedisTimeSeries [#1370](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1370) Potential crash when using [TS.REVRANGE](https://redis.io/commands/ts.revrange/) or [TS.MREVRANGE](https://redis.io/commands/ts.mrevrange/) with aggregation
+* RedisTimeSeries [#1347](https://github.com/RedisTimeSeries/RedisTimeSeries/pull/1347) When adding samples with [TS.ADD](https://redis.io/commands/ts.add/) or [TS.MADD](https://redis.io/commands/ts.madd/) using * as timestamp, the timestamp could differ between master and replica shards
+ 
+**Redis version** (no changes)
+* [Redis 6.2.8](https://github.com/redis/redis/blob/6.2.8/00-RELEASENOTES)
+ 
+**Module versions**
+* __[RediSearch 2.6.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.4)__
+* __[RedisJSON 2.4.3](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.3)__
+* __[RedisGraph 2.10.5](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.5)__
+* __[RedisTimeSeries 1.8.4](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.4)__
+* __[RedisBloom 2.4.3 (v2.4.3)](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.3)__
+
+**Recommended Client Libraries**
+* Java
+  * [Jedis 4.3.1 or greater ](https://github.com/redis/jedis/releases/tag/v4.3.1)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.4.0 or greater ](https://github.com/redis/redis-py/releases/tag/v4.4.0)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.5.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+
+Compatible with [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.14](https://github.com/RedisInsight/RedisInsight/releases/tag/2.14.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-v0 (December 2022)
+
+This is a GA release of Redis Stack version 6.2.6
+
+### Headlines:
+* Query & Search:
+  - multi-value index and query for: text, tag, numeric, geo and vector!
+  - suffix search `*vatore` and wildcard search `ant?rez`
+  - support for FP64 vectors and range queries from a given vector
+* New faster JSONPath parser
+* New probabilistic data structure: t-digest
+* New path-finding algorithms `algo.SPpaths` and `algo.SSpaths` for Graph
+* Support for gap filling for Time series
+
+### Details:
+**RediSearch**  introduces the following features:
+* Support for [wildcard queries](https://redis.io/docs/stack/search/reference/query_syntax/#wildcard-matching)  for TEXT and TAG fields, where
+  - `?` matches any single character
+  - `*` matches zero or more characters
+  - use `'` and `\` for escaping, other special characters are ignored
+  - Optimized wildcard query support (i.e., suffix trie)
+* Multi-value indexing and querying
+  - Multi-value text search - perform full-text search on [array of string or on a JSONPath](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-tag) leading to multiple strings
+  - Support for Geo, Vector, Numeric, Tag
+  - Return JSON rather than scalars from multi-value attributes. This is enabled via Dialect 3 in order not to break existing applications.
+  - Support indexing and querying of multi-value JSONPath attributes and/or arrays (requires JSON >2.4.1)
+  - Support for `SORTABLE` fields on JSON in an implicit un-normalized form (UNF)
+* Vector similarity 0.5.1:
+  - Better space optimization selection
+  - Aligning index capacity with block size
+  - Support FLOAT64 as vector data type
+  - Range query support
+  - Support query attributes for vector queries
+
+**RedisJSON**  introduces the following features:
+* Add JSONPath filter the regexp match operator
+* Support legacy JSONpath with dollar `$`
+* A new JSONPath library which enhances the performance of parsing any JSONPath expression in RedisJSON.
+* Floating point numbers which become round numbers due to some operation, for example by `JSON.NUMINCRBY`, will now return as a floating point with a trailing `.0`, e.g., instead of just `42`, now `42.0` will be returned.
+
+**RedisBloom** introduces the following new features:
+* A new sketch data structure: t-digest. t-digest is a sketch data structure for estimating quantiles based on a data stream or a large dataset of values. As for other sketch data structures, t-digest requires sublinear space and has controllable space-accuracy tradeoffs.
+
+**RedisGraph** introduces the following new features:
+* New path-finding algorithms: 
+  - The `algo.SPpaths` procedure returns one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths between a given pair of nodes.
+  - The `algo.SSpaths` procedure returns one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths from a given node.
+* Introduce `SET` for adding node labels and `REMOVE` for removing node labels, node properties, and edge properties
+* Support deleting paths with `DELETE`
+* Introduce `toBoolean`, `toBooleanOrNull`, `toFloatOrNull`, `toIntegerOrNull`, `toStringOrNull`, `toBooleanList`, `toFloatList`, `toIntegerList`, `toStringList`, `properties`, `split`, `last`, `isEmpty`,`e`, `exp`, `log`, `log10`, `sin`, `cos`, `tan`, `cot`, `asin`, `acos`, `atan`, `atan2`, `degrees`, `radians`, `pi`, and `haversin` functions.
+* Graph slow log can be reset with `GRAPH.SLOWLOG g RESET`
+* Queries are now atomic (_Atomicity_ is the guarantee that each query either succeeds or fails with no side effects). Whenever a failure occurs, the query effect is rolled-back from an undo-log.
+ 
+**RedisTimeSeries** introduces the following new features:
+* Introduction of a new aggregator: `twa` (time-weighted average)
+* Introduction of a new optional `EMPTY` flag to `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE` to retrieve aggregations for empty buckets as well.
+* Gap-filling: Using `EMPTY` when the aggregator is `twa` allows estimating the average of a continuous signal even for empty buckets based on linear interpolation of previous and next samples. Using `EMPTY` when the aggregator is `last` would repeat the value of the previous sample when the bucket is empty.
+* Introduction of a new optional `BUCKETTIMESTAMP` parameter to `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`. It is now possible to report the start time, the end time, or the mid time for each bucket.
+* Introduction of a new optional `alignTimestamp` parameter to `TS.CREATERULE` and to `COMPACTION_POLICY` configuration parameter.  It is now possible to define alignment for compaction rules, so one can, for example, aggregate daily events from 06:00 to 06:00 the next day.
+* Introduction of additional reducer types in `GROUPBY` (`TS.MRANGE`, and `TS.MREVRANGE`): `avg`, `range`, `count`, `std.p`, `std.s`, `var.p`, and `var.s`
+* Introduction of a new optional `LATEST` flag to `TS.GET`, `TS.MGET`, `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`. it is possible to retrieve the latest (possibly partial) bucket as well.
+
+**Bug Fixes** (since 6.2.6-RC1):
+* RediSearch [#3098](https://github.com/RediSearch/RediSearch/pull/3098) Wrong return value in Geo query
+* RediSearch [#3230](https://github.com/RediSearch/RediSearch/pull/3230) Precalculated number of replies must be equal to actual number
+* RediSearch [#3171](https://github.com/RediSearch/RediSearch/pull/3171) Shard of DB with RedisSearch 2.4.8/11 got restarted by node_wd
+* RediSearch [#3197](https://github.com/RediSearch/RediSearch/pull/3197) RediSearch 2.4.15 crashed
+* RediSearch [#3197](https://github.com/RediSearch/RediSearch/pull/3197) failure to create temporary indices
+* RedisJSON [#850](https://github.com/RedisJSON/RedisJSON/pull/850) Allow repetition of filter relation instead of optional
+* RedisGraph [#2695](https://github.com/RedisGraph/RedisGraph/pull/2695) Potential crash on certain write queries
+* RedisGraph [#2724](https://github.com/RedisGraph/RedisGraph/pull/2724) Potential crash when setting property values based on nonexistent properties
+* RedisGraph [#2460](https://github.com/RedisGraph/RedisGraph/issues/2460), [#2637](https://github.com/RedisGraph/RedisGraph/issues/2637), [#2680](https://github.com/RedisGraph/RedisGraph/issues/2680) Crash on invalid queries
+* RedisGraph [#2672](https://github.com/RedisGraph/RedisGraph/pull/2672) Wrong matching result on multiple labels
+* RedisGraph [#2643](https://github.com/RedisGraph/RedisGraph/issues/2643) Duplicate reports when matching relationship type `:R|R`
+* RedisGraph [#2687](https://github.com/RedisGraph/RedisGraph/issues/2687), [#2414](https://github.com/RedisGraph/RedisGraph/issues/2414) Error when `UNWIND`ing relationships
+* RedisGraph [#2636](https://github.com/RedisGraph/RedisGraph/issues/2636) `MERGE` …` ON` ... - cannot remove property by setting it to null
+* RedisGraph [#2710](https://github.com/RedisGraph/RedisGraph/pull/2710) Undo-log fix
+* RedisGraph [#2435](https://github.com/RedisGraph/RedisGraph/pull/2435) Incorrect result when comparing a value to NaN
+* RedisGraph [#2497](https://github.com/RedisGraph/RedisGraph/pull/2497) Incorrect result when comparing a value to null
+* RedisGraph [#2676](https://github.com/RedisGraph/RedisGraph/issues/2676) `sqrt`, `log`, `log10` - incorrect result for negative values
+* RedisGraph [#2213](https://github.com/RedisGraph/RedisGraph/issues/2213) Division and Modulo by zero - wrong behavior
+* RedisTimeSeries [#1333](https://github.com/RedisTimeSeries/RedisTimeSeries/issues/1333) Potential crash when aggregating over a compaction with the `avg` aggregator and the `LATEST` flag
+ 
+**Redis version** (no changes)
+* [Redis 6.2.7](https://github.com/redis/redis/blob/6.2.7/00-RELEASENOTES)
+ 
+**Module versions**
+* __[RediSearch 2.6.3](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.3)__
+* __[RedisJSON 2.4.2](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.2)__
+* __[RedisGraph 2.10.4](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.4)__
+* __[RedisTimeSeries 1.8.3](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.3)__
+* __[RedisBloom 2.4.3](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.3)__
+
+**Recommended Client Libraries  (no changes)**
+* Java
+  * [Jedis 4.2.0 or greater ](https://github.com/redis/jedis/releases/tag/v4.2.0)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.3.1 or greater ](https://github.com/redis/redis-py/releases/tag/v4.3.1)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.4.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with [RedisInsight 2.14](https://github.com/RedisInsight/RedisInsight/releases/tag/2.14.0).
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+## Redis Stack Server 6.2.6-RC1 (November 2022)
+
+This is a Release Candidate of Redis Stack Server 6.2.6
+
+### Headlines:
+* Query & Search:
+  - multi-value index and query for: text, tag, numeric, geo and vector!
+  - affix search `*oolman` and wildcard search `y?fta*`
+  - support for FP64 vectors
+* New faster JSONPath parser
+* New probabilistic data structure: t-digest
+* New path-finding algorithms `algo.SPpaths` and `algo.SSpaths` for Graph
+* Support for gap filling for Time series
+
+### Details:
+**RediSearch**  introduces the following features:
+* the ability to search using wildcard queries for TEXT and TAG fields. This enables the frequently asked feature of affix search and includes optimized wildcard query support :
+   - `?` matches any single character
+   - `*` matches zero or more characters
+   - use `’` and `\` for escaping, other special characters are ignored
+* Multi-value indexing and querying of attributes for any attribute type ([Text](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-text), [Tag](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-tag), [Numeric](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-numeric), [Geo](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-geo) and [Vector](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-vector)) defined by a [JSONPath](https://redis.io/docs/stack/json/path/) leading to an array:
+  - Multi-value text search - perform full-text search on [array of string or on a JSONPath](https://redis.io/docs/stack/search/indexing_json/#index-json-arrays-as-tag) leading to multiple strings
+  - Return JSON rather than scalars from multi-value attributes. This is enabled via Dialect 3 in order not to break existing applications.
+  - Support for `SORTABLE` fields on JSON in an implicit un-normalized form (UNF)
+* Support for indexing double-precision floating-point vectors and range queries from a given vector:
+  - Better space optimization selection
+  - Aligning index capacity with block size
+  - Support FLOAT64 as vector data type
+  - Range query support
+  - Support query attributes for vector queries
+ 
+**RedisJSON**  introduces the following features:
+* A new JSONPath library which enhances the performance of parsing any JSONPath expression in RedisJSON.
+ 
+**RedisBloom** introduces the following new features:
+* A new sketch data structure: t-digest. t-digest is a sketch data structure for estimating quantiles based on a data stream or a large dataset of values. As for other sketch data structures, t-digest requires sublinear space and has controllable space-accuracy tradeoffs.
+
+**RedisGraph** introduces the following new features:
+* New path-finding algorithms: 
+  - The `algo.SPpaths` procedure returns one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths between a given pair of nodes.
+  - The `algo.SSpaths` procedure returns one, _n_, or all minimal-weight, optionally bounded-cost, optionally bounded-length paths from a given node.
+* Introduce `SET` for adding node labels and `REMOVE` for removing node labels, node properties, and edge properties
+* Support deleting paths with `DELETE`
+* Introduce `toBoolean`, `toBooleanOrNull`, `toFloatOrNull`, `toIntegerOrNull`, `toStringOrNull`, `toBooleanList`, `toFloatList`, `toIntegerList`, `toStringList`, `properties`, `split`, `last`, `isEmpty`,`e`, `exp`, `log`, `log10`, `sin`, `cos`, `tan`, `cot`, `asin`, `acos`, `atan`, `atan2`, `degrees`, `radians`, `pi`, and `haversin` functions.
+* Graph slow log can be reset with `GRAPH.SLOWLOG g RESET` (also added in 2.8.20)
+* Queries are now atomic (_Atomicity_ is the guarantee that each query either succeeds or fails with no side effects). Whenever a failure occurs, the query effect is rolled-back from an undo-log.
+ 
+**RedisTimeSeries** introduces the following new features:
+* Introduction of a new aggregator: `twa` (time-weighted average)
+* Introduction of a new optional `EMPTY` flag to `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE` to retrieve aggregations for empty buckets as well.
+* Gap-filling: Using `EMPTY` when the aggregator is `twa` allows estimating the average of a continuous signal even for empty buckets based on linear interpolation of previous and next samples. Using `EMPTY` when the aggregator is `last` would repeat the value of the previous sample when the bucket is empty.
+* Introduction of a new optional `BUCKETTIMESTAMP` parameter to `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`. It is now possible to report the start time, the end time, or the mid time for each bucket.
+* Introduction of a new optional `alignTimestamp` parameter to `TS.CREATERULE` and to `COMPACTION_POLICY` configuration parameter.  It is now possible to define alignment for compaction rules, so one can, for example, aggregate daily events from 06:00 to 06:00 the next day.
+* Introduction of additional reducer types in `GROUPBY` (`TS.MRANGE`, and `TS.MREVRANGE`): `avg`, `range`, `count`, `std.p`, `std.s`, `var.p`, and `var.s`
+* Introduction of a new optional `LATEST` flag to `TS.GET`, `TS.MGET`, `TS.RANGE`, `TS.REVRANGE`, `TS.MRANGE`, and `TS.MREVRANGE`. it is possible to retrieve the latest (possibly partial) bucket as well.
+
+ 
+**Redis version** (no changes)
+* [Redis 6.2.7](https://github.com/redis/redis/blob/6.2.7/00-RELEASENOTES)
+ 
+
+**Module versions**
+* __[RediSearch 2.6.1](https://github.com/RediSearch/RediSearch/releases/tag/v2.6.1)__
+* __[RedisJSON 2.4.0](https://github.com/RedisJSON/RedisJSON/releases/tag/v2.4.0)__
+* __[RedisGraph 2.10-RC1 (v2.10.2)](https://github.com/RedisGraph/RedisGraph/releases/tag/v2.10.2)__
+* __[RedisTimeSeries 1.8-RC3 (v1.8.2)](https://github.com/RedisTimeSeries/RedisTimeSeries/releases/tag/v1.8.2)__
+* __[RedisBloom 2.4-RC3 (v2.4.2)](https://github.com/RedisBloom/RedisBloom/releases/tag/v2.4.2)__
+
+**Recommended Client Libraries  (no changes)**
+* Java
+  * [Jedis 4.2.0 or greater ](https://github.com/redis/jedis/releases/tag/v4.2.0)
+  * [redis-om-spring](https://github.com/redis/redis-om-spring)
+* Python
+  * [redis-py 4.3.1 or greater ](https://github.com/redis/redis-py/releases/tag/v4.3.1)
+  * [redis-om-python](https://github.com/redis/redis-om-python)
+* NodeJS
+  * [node-redis 4.4.0  or greater](https://www.npmjs.com/package/redis)
+  * [redis-om-node](https://github.com/redis/redis-om-node)
+* .NET
+  * [redis-om-dotnet](https://github.com/redis/redis-om-dotnet)
+
+Compatible with the latest [RedisInsight](https://redis.io/download). The docker image redis/redis-stack for this version is bundled with RedisInsight 2.12.0.
+
+Note: version numbers follow the pattern:
+
+`x.y.z-b`
+* `x.y` Redis major version
+* `z` increases with even numbers as a module x.y version increases.
+* `b` denotes a patch to Redis or a module (any `z` of Redis or modules). `b` will consist of a `v` + numeric value.
+
+---
+Title: Redis Stack release notes
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Stack release notes for version 7.2 and later
+hideListLinks: true
+linkTitle: Redis Stack
+tags:
+- visible
+weight: 15
+---
+{{< table-children columnNames="Version&nbsp;(Release&nbsp;date)&nbsp;,Major&nbsp;changes" columnSources="LinkTitle,Description" enableLinks="LinkTitle" >}}
+---
+Title: Search and query commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Lists search and query commands and provides links to the command reference
+  pages.
+linkTitle: Commands
+toc: 'false'
+weight: 10
+---
+
+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<br />Flexible & Annual | Redis Cloud<br />Free & Fixed | Description |
+|:--------|:----------------------|:-----------------|:-----------------|:------|
+| [FT.AGGREGATE]({{< relref "commands/ft.aggregate" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Runs a search query on an index and groups, sorts, transforms, limits, and/or filters the results. |
+| [FT.ALIASADD]({{< relref "commands/ft.aliasadd" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Adds an alias to an index.  |
+| [FT.ALIASDEL]({{< relref "commands/ft.aliasdel" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Removes an alias from an index. |
+| [FT.ALIASUPDATE]({{< relref "commands/ft.aliasupdate" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | 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]({{< relref "commands/ft.alter" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Adds a new field to an index. |
+| [FT.CONFIG GET]({{< relref "commands/ft.config-get" >}}) |  <span title="Not supported"><nobr>&#x274c; Not supported</span> | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[2](#table-note-2)</sup> | <span title="Not supported"><nobr>&#x274c; Not supported</nobr></span> | Displays configuration options. |
+| [FT.CONFIG HELP]({{< relref "commands/ft.config-help" >}}) |   <span title="Not supported"><nobr>&#x274c; Not supported</span> | <span title="Not supported"><nobr>&#x274c; Not supported</span> | <span title="Not supported"><nobr>&#x274c; Not supported</nobr></span> | Describes configuration options. |
+| [FT.CONFIG SET]({{< relref "commands/ft.config-set" >}}) | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[1](#table-note-1)</sup> | <span title="Not supported"><nobr>&#x26A0;&#xFE0F; Not supported</span><sup>[2](#table-note-2)</sup> | <span title="Not supported"><nobr>&#x274c; Not supported</nobr></span> | Sets configuration options. |
+| [FT.CREATE]({{< relref "commands/ft.create" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Creates an index. |
+| [FT.CURSOR DEL]({{< relref "commands/ft.cursor-del" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Deletes a cursor. |
+| [FT.CURSOR&nbsp;READ]({{< relref "commands/ft.cursor-read/" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Reads the next results from an existing cursor. |
+| [FT.DICTADD]({{< relref "commands/ft.dictadd" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Adds terms to a dictionary. |
+| [FT.DICTDEL]({{< relref "commands/ft.dictdel" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Deletes terms from a dictionary. |
+| [FT.DICTDUMP]({{< relref "commands/ft.dictdump" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns all terms in the specified dictionary. |
+| [FT.DROPINDEX]({{< relref "commands/ft.dropindex" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Deletes an index. |
+| [FT.EXPLAIN]({{< relref "commands/ft.explain" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns the execution plan for a complex query as a string. |
+| [FT.EXPLAINCLI]({{< relref "commands/ft.explaincli" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns the execution plan for a complex query as an [array]({{< relref "develop/reference/protocol-spec/#arrays" >}}). |
+| [FT.INFO]({{< relref "commands/ft.info" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns index information and statistics.  |
+| [FT._LIST]({{< relref "commands/ft._list" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Lists all indexes. |
+| [FT.PROFILE]({{< relref "commands/ft.profile" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Runs [FT.SEARCH]({{< relref "commands/ft.search" >}}) or [FT.AGGREGATE]({{< relref "commands/ft.aggregate" >}}) and reports performance information. |
+| [FT.SEARCH]({{< relref "commands/ft.search" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Searches an index for a text query and returns matching documents or document IDs. |
+| [FT.SPELLCHECK]({{< relref "commands/ft.spellcheck" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Suggests spelling corrections for misspelled terms in a query. |
+| [FT.SYNDUMP]({{< relref "commands/ft.syndump" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns a list of synonym terms and their synonym group IDs. |
+| [FT.SYNUPDATE]({{< relref "commands/ft.synupdate" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Creates or updates a synonym group with additional terms. |
+| [FT.TAGVALS]({{< relref "commands/ft.tagvals" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</nobr></span> | Returns all distinct values indexed in a tag field. |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>Use [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}) or the [REST API]({{< relref "/operate/rs/references/rest-api" >}}) to change search and query configuration for Redis Enterprise Software. See [search and query configuration compatibility with Redis Enterprise]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/config" >}}) for more information and examples.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>[Contact support](https://redis.com/company/support/) to view the current configuration values or request configuration changes for Flexible or Annual Redis Cloud subscriptions.
+---
+Title: Search and query configuration compatibility with Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Search and query configuration settings supported by Redis Enterprise Software and Redis Cloud.
+linkTitle: Configuration
+toc: 'false'
+weight: 15
+---
+
+To configure RediSearch in [Redis Enterprise Software]({{< relref "/operate/rs" >}}) or [Redis Cloud]({{< relref "/operate/rc" >}}), use one of the following methods instead of [`FT.CONFIG SET`]({{< relref "commands/ft.config-set" >}}).
+
+## Configure search in Redis Cloud
+
+For Redis Cloud:
+
+- _Flexible or Annual [subscriptions]({{< relref "/operate/rc/subscriptions" >}})_: contact [support](https://redis.com/company/support/) to request a configuration change.
+    
+- _Free or Fixed subscriptions_: you cannot change RediSearch configuration.
+
+## Configure search in Redis Software
+
+For Redis Enterprise Software, use one of the following methods:
+
+- Cluster Manager UI:
+
+  1. From the **Databases** list, select the database, then click **Configuration**.
+
+  1. Select the **Edit** button.
+
+  1. In the **Capabilities** section, click **Parameters**.
+
+  1. Enter the setting name and setting value in the **RediSearch** box.
+  
+      In the **Query Performance Factor** section, you can configure settings to improve query performance. See [Configure the query performance factor for Redis Query Engine in Redis Enterprise]({{<relref "/operate/oss_and_stack/stack-with-enterprise/search/query-performance-factor">}}) for more information.
+
+      {{<image filename="images/rs/screenshots/databases/rs-config-search-params.png" alt="The Parameters dialog includes sections to edit RediSearch settings and the Query Performance Factor settings.">}}
+
+  1. After you finish editing the module's configuration parameters, click **Done** to close the parameter editor.
+
+  1. Click **Save**.
+
+- [`rladmin tune db`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-db" >}}):
+
+    ```sh
+    $ rladmin tune db db:<ID|name> module_name search \
+        module_config_params "setting-name setting-value"
+    ```
+
+- [Configure module]({{< relref "/operate/rs/references/rest-api/requests/modules/config" >}}) REST API request:
+
+    ```sh
+    POST /v1/modules/config/bdb/<ID>
+    {
+      "modules": [
+        {
+          "module_name": "search",
+          "module_args": "setting-name setting-value"
+        }
+      ]
+    }
+    ```
+
+## Configuration settings
+
+See [configuration parameters]({{< relref "/develop/interact/search-and-query/administration/configuration" >}}) in the Develop section for parameter details and compatibility with Redis Software and Redis Cloud.
+---
+Title: Search and query Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Search and query Active-Active databases.
+linkTitle: Search Active-Active databases
+weight: 30
+---
+Starting with RediSearch 2.x, supported in Redis Enterprise Software (RS) 6.0 and later, you can [enable search and query]({{< relref "/operate/oss_and_stack/stack-with-enterprise/install/add-module-to-database" >}}) for [Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}) at the time of creation.
+
+You can run search operations on any instance of an Active-Active database.
+
+## How it works
+
+1. Create an Active-Active database with RediSearch 2.x enabled.
+1. [Create the index]({{< relref "commands/ft.create" >}}) on each instance of the database.
+1. If you are using [synonyms]({{< relref "/develop/interact/search-and-query/advanced-concepts/synonyms" >}}), you need to add them to each replica.
+1. 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: 
+
+- [`FT.DROPINDEX` ]({{< relref "commands/ft.dropindex" >}})
+- [`FT.SUGADD`]({{< relref "commands/ft.sugadd" >}})
+- [`FT.SUGGET`]({{< relref "commands/ft.sugget" >}})
+- [`FT.SUGDEL`]({{< relref "commands/ft.sugdel" >}})
+- [`FT.SUGLEN`]({{< relref "commands/ft.suglen" >}})
+
+## Example
+
+Here's an example to help visualize Active-Active search and query:
+
+| Time  | Description | CRDB Instance1 | RediSearch Instance 1 | CRDB Instance 2 | RediSearch Instance 2 |
+| :---: | :--- | :--- | :--- | :--- | :--- |
+|  t0 | Create the index on each instance |  | FT.CREATE idx .... |  | FT.CREATE idx .... |
+|  t1 | Add doc1 as a hash on instance 1; RediSearch indexes doc1 on instance 1 | HSET doc1 field1 "a" | (Index doc1 field1 "a") |  |  |
+|  t2 | Add doc2 as a hash on instance 2; RediSearch indexes doc2 on instance 2 |  |  | HSET doc1 field2 "b" | (Index doc1 field2 "b") |
+|  t3 | Searching for "a" in each instance only finds the result in instance 1 |  | FT.Search idx "a"<br/>1) 1<br/>2) doc1 |  | FT.Search idx "a"<br/>1) 0 |
+|  t4 | Active-Active synchronization | - Sync - |  | - Sync - |  |
+|  t5 | Both hashes are found in each instance | HGETALL doc1<br/>1) "field2"<br/>2) "b"<br/>3) "field1"<br/>4) "a" |  | HGETALL doc1<br/>1) "field2"<br/>2) "b"<br/>3) "field1"<br/>4) "a" |  |
+|  t6 | Searching for "a" in each instance finds both documents |  | FT.Search idx "a"<br/>1) 1<br/>2) doc1 |  | FT.Search idx "a"<br/>1) 1<br/>2) doc1 |
+
+The practical result is that you have a geo-distributed database with a high level of consistency that can also run search operations on any instance.
+---
+Title: Best practices for scalable Redis Query Engine
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Best practices for scalable Redis Query Engine in Redis Software and Redis Cloud.
+linkTitle: Best practices for scalable Redis Query Engine
+weight: 25
+---
+
+[Vertical scaling of Redis Query Engine]({{<relref "/operate/oss_and_stack/stack-with-enterprise/search/query-performance-factor">}}) requires configuring query performance factors. With careful crafting of search indices and queries, query performance factors allow throughput scaling up to 16X. The following recommendations help queries avoid accessing the keyspace and enable Redis Query Engine to benefit from additional CPUs allocated by query performance factors.
+
+## Best candidates for query performance factor improvements
+
+- Query types:
+
+    - [Full-text]({{<relref "/develop/interact/search-and-query/query/full-text">}})
+
+    - [Tag]({{<relref "/develop/interact/search-and-query/advanced-concepts/tags">}})
+
+    - [Vector]({{<relref "/develop/interact/search-and-query/query/vector-search">}})
+
+- Result set types: 
+
+    - Small result sets
+
+    - Document subsets that are indexed in their [non-normalized]({{<relref "/develop/interact/search-and-query/advanced-concepts/sorting#normalization-unf-option">}}) form
+
+## Indexing best practices
+
+Follow these best practices for [indexing]({{<relref "/develop/interact/search-and-query/indexing">}}):
+
+- Include fields in the index definition that are used in the query or the required result sets (projections).
+
+- Use `SORTABLE` for all fields returned in result sets.
+
+- Use the `UNF` option for `TAG` and `GEO` fields.
+
+- Use the `NOSTEM` option for `TEXT` fields.
+
+## Query best practices
+
+Follow these best practices for [queries]({{<relref "/develop/interact/search-and-query/query">}}):
+
+- Specify the result set fields in the `RETURN` or `LOAD` clauses and include them in the index definition. Don’t just return the default result set from [`FT.SEARCH`]({{< relref "commands/ft.search/" >}})  or `LOAD *` from [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}).
+
+- Use `LIMIT` to reduce the result set size.
+
+- Use [`DIALECT 3`]({{<relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-3">}}) or higher for any queries against JSON.
+
+## Index and query examples
+
+The following examples depict an anti-pattern index schema and query, followed by a corrected schema and query, which allows for scalability with the Redis Query Engine.
+
+### Anti-pattern index schema
+
+The following index schema is not optimized for vertical scaling:
+
+```sh
+FT.CREATE jsonidx:profiles ON JSON PREFIX 1 profiles: 
+          SCHEMA $.tags.* as t NUMERIC SORTABLE 
+                 $.firstName as name TEXT 
+                 $.location as loc GEO
+```
+
+### Anti-pattern query
+
+The following query is not optimized for vertical scaling:
+
+```sh
+FT.AGGREGATE jsonidx:profiles '@t:[1299 1299]' LOAD * LIMIT 0 10
+```
+
+### Improved index schema
+
+Here's an improved index schema that follows best practices for vertical scaling:
+
+```sh
+FT.CREATE jsonidx:profiles ON JSON PREFIX 1 profiles: 
+          SCHEMA $.tags.* as t NUMERIC SORTABLE 
+                 $.firstName as name TEXT NOSTEM SORTABLE 
+                 $.lastName as lastname TEXT NOSTEM SORTABLE 
+                 $.location as loc GEO SORTABLE 
+                 $.id as id TAG SORTABLE UNF 
+                 $.ver as ver TAG SORTABLE UNF
+```
+
+### Improved query
+
+Here's an improved query that follows best practices for vertical scaling:
+
+```sh
+FT.AGGREGATE jsonidx:profiles '@t:[1299 1299]' 
+                LOAD 6 id t name lastname loc ver
+                LIMIT 0 10
+                DIALECT 3
+```
+---
+Title: "Upgrade a database to Search\_2.x"
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: "Upgrade a database from Search 1.x to Search\_2.x."
+linkTitle: Upgrade a database
+module: RediSearch
+weight: 30
+---
+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]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/search-active-active" >}})
+- Database cluster re-sharding
+- Replica Of to a sharded destination database
+- [EXPIRE]({{< relref "/commands/ttl" >}}) 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.
+
+To upgrade a Redis Enterprise Software database with RediSearch 1.x to RediSearch 2.x, you have to set up a new database with RediSearch 2.x and use the `RediSearch_Syncer.py` script to replicate the data from the old database into the new database.
+
+{{< note >}}
+After you create the database or after you replicate the data, [create an index]({{< relref "commands/ft.create" >}}) with a prefix or filter that defines the keys that you want to index.
+{{< /note >}}
+
+## Prerequisites
+
+Install Python 3 on the host where you plan to run the synchronization script:
+
+```sh
+sudo apt install python3
+```
+
+## Limitations
+
+- Suggestions (`FT.SUG` APIs) and spell check dictionaries are not replicated from the source database. You need to add them manually.
+- If there are multiple indexes on the source and the documents do not have prefixes that identify them with an index, RediSearch 2.x can't index the documents in their respective indexes.
+- The `NOSAVE` option is no longer supported. Indexes created with the `NOSAVE` option can't be upgraded.
+- Databases that contain temporary indexes can't be upgraded.
+- Any attempt to add, delete, or modify an index during the upgrade will cause the replication process to fail. During the upgrade, the source database can only receive `FT.ADD` and `FT.DEL` commands.
+
+## Replicate data from RediSearch 1.x to RediSearch 2.x
+
+To replicate a RediSearch 1.x database to a RediSearch 2.x database:
+
+1. Sign in to the admin console of the Redis Enterprise cluster where you want to host the new RediSearch 2.x database.
+
+1. [Add the RediSearch 2.x module](#add-new-module) to the cluster.
+
+1. [Create a new database](#create-db) with RediSearch 2.x.
+
+1. [Migrate data](#migrate-data) to the RediSearch 2.x database.
+
+### Add RediSearch 2.x to the cluster {#add-new-module}
+
+1. Download the RediSearch 2.x module package from the [Redis Download Center](https://redis.io/downloads).
+
+1. In the Redis Enterprise admin console, select **settings**.
+
+1. In **redis modules**, select the **Add module** button.
+
+    {{< image filename="/images/rs/upgrade_module.png" >}}
+
+1. Use the file browser to select the module package and upload it to the cluster.
+
+### Create a RediSearch 2.x database {#create-db}
+
+1. [Create a database]({{< relref "/operate/rs/databases/create" >}}) and configure its settings.
+
+1. In the **Redis Modules** section:
+
+    1. Select the **Add** button:
+    
+        {{<image filename="images/rs/icon_add.png" width="30px" alt="The Add icon">}}
+    
+    1. Select **RediSearch 2** from the dropdown list.
+
+    1. Select the **OK** button to confirm:
+
+        {{<image filename="images/rs/icon_save.png" width="30px" alt="The Save icon">}}
+
+1. Select the **Activate** button to create the database.
+
+### Migrate data {#migrate-data}
+
+1. Download the RediSearch_Syncer package for your operating system:
+
+    - [RedHat Enterprise Linux 7](http://redismodules.s3.amazonaws.com/redisearch/RediSearchSyncer/RediSearchSyncer-rhel7.zip)
+    - [Ubuntu 18.04](http://redismodules.s3.amazonaws.com/redisearch/RediSearchSyncer/RediSearchSyncer-bionic.zip)
+    - [Ubuntu 16.04](http://redismodules.s3.amazonaws.com/redisearch/RediSearchSyncer/RediSearchSyncer-xenial.zip)
+    - [Ubuntu 14.04](http://redismodules.s3.amazonaws.com/redisearch/RediSearchSyncer/RediSearchSyncer-trusty.zip)
+
+1. Extract the package: 
+
+    ```sh
+    unzip <package_name>
+    ```
+
+1. In the extracted directory, run the RediSearch_Syncer.py script:
+
+    ```sh
+    python3 RediSearch_Syncer.py -d <destination_url> -s <source_url> [--add-prefix <prefix>]
+    ```
+
+    Replace the following variables with your own values:
+
+    - `destination url` - The replication URL of the RediSearch 2.x database. To find this value, go to the database configuration screen in the admin console and select **Get Replica of source URL**.
+
+    - `source url` - The replication URL of the RediSearch 1.x database. To find this value, go to the database configuration screen in the admin console and select **Get Replica of source URL**.
+
+    - `--add-prefix <prefix>` (optional) - Adds a prefix to all of the hashes that are replicated to the new database.
+
+        {{<note>}}
+Only use the `add-prefix` option if you want to index all of the hashes in the same index in the source database.
+        {{</note>}}
+
+    The script shows a table with the progress of the replication process.
+    Press **F5** to see the updated status.
+
+    For example:
+
+    ```sh
+    python RediSearch_Syncer.py -d redis://admin:IBrS0xaL6rShfB1wKTtUkcQG1g3UWAlTd53AotPdTcQvGIVP@redis-19472.cluster1.local:19472 -s redis://admin:1GjFuUbBqTSPDbRfaxEPLSoXpFmRdFxmBKMD0BuxwMJ2DEaO@redis-19636.cluster1.local:19636
+    ```
+
+1. Stop the processes that are sending requests to the source database so all of the data gets synchronized to the destination database.
+
+1. Run `FT.INFO` on both source and destination databases and compare the number of indexed documents. The replication process is complete when the number of indexed documents is the same in both databases.
+
+1. When the status field is `st_in_sync`, you can press **Ctrl-C** to cancel the synchronization process.
+
+1. Press **Q** to quit the `RediSearch_Syncer.py`.
+
+You can now redirect your database connections to the RediSearch 2.x database.
+---
+Title: Search and query
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: true
+linkTitle: Search and query
+weight: 20
+---
+The [RediSearch 2.x module](https://redis.com/blog/introducing-redisearch-2-0/) is a source-available project that lets you build powerful search queries for open source Redis databases.
+When combined with Redis Enterprise Software, you can use the same protocols and [commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/commands" >}})
+to run geo-replicated queries and full-text searches over efficient in-memory indexes.
+
+## Index documents
+
+The search and query engine indexes documents, which are objects that represent data as field-value pairs. You can index more than one field per document, and these fields can represent text, numeric, or geospatial data types.
+
+As the documents in your database change, the index automatically processes these changes to keep the search results up to date.
+
+With indexes, you can do:
+- Language-aware [fuzzy matching]({{< relref "develop/interact/search-and-query/advanced-concepts/query_syntax#fuzzy-matching" >}})
+- Fast [auto-complete]({{< relref "develop/interact/search-and-query/administration/overview#auto-complete" >}})
+- [Exact phrase matching]({{< relref "develop/interact/search-and-query/advanced-concepts/query_syntax" >}})
+- [Numeric filtering]({{< relref "develop/interact/search-and-query/advanced-concepts/query_syntax#numeric-filters-in-query" >}})
+- [Geo-radius queries]({{< relref "develop/interact/search-and-query/advanced-concepts/query_syntax#geo-filters" >}})
+
+## Supported document types
+
+You can store documents as Redis [hashes]({{< relref "/develop/data-types/hashes" >}}) or [JSON]({{< relref "/develop/data-types/json" >}}). To search and query JSON documents, you also need to enable [JSON]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json" >}}) in your database.
+
+### Hash documents
+
+With Redis [hashes]({{< relref "/develop/data-types/hashes" >}}), each document is assigned to a single key and uses field-value pairs to represent the document's contents.
+
+You can run [`HGETALL`]({{< relref "/commands/hgetall" >}}) to retrieve the entire hash document.
+
+### JSON documents
+
+You can index, search, and query JSON documents stored in your database.
+
+For more information about how to search and query JSON documents, see the [quick start]({{< relref "/develop/get-started/document-database" >}}).
+
+## Search features
+
+For full-text searches, you can customize the field queries and ranking of the search results.
+When querying, you can use multiple predicates that query text, numeric, and geospatial fields in one query.
+You can also sort by a specific field and limit the results with an offset to produce customized results pages.
+
+Redis Open Source supports [over 15 natural languages]({{< relref "/develop/interact/search-and-query/advanced-concepts/stemming" >}}) for stemming and includes auto-complete engines with specific commands that can provide real-time [interactive search suggestions]({{< relref "/commands/ft.sugadd" >}}).
+
+## Search and query Active-Active databases
+
+As a result of the new RediSearch architecture and methodology, [RediSearch 2.x supports Active-Active databases]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/search-active-active" >}}).
+You can now serve your index information from geo-distributed database instances.
+
+## Resharding indexed data
+
+By moving the index out of the keyspace and structuring the data as hashes, RediSearch 2.x makes it possible to reshard the database.
+When half of the data moves to the new shard, the index related to that data is created synchronously and Redis removes the keys from the index when it detects that the keys were deleted.
+Because the index on the new shard is created synchronously though, it's expected that the resharding process will take longer than resharding of a database without search and query enabled.
+
+## Limitations
+
+- You cannot use search and query capabilities with the [OSS Cluster API]({{< relref "/operate/rs/databases/configure/oss-cluster-api" >}}).
+
+## More info
+
+- [Getting Started with RediSearch 2.0](https://redis.com/blog/getting-started-with-redisearch-2-0/)
+- [Search and query quick start]({{< relref "/develop/get-started/document-database" >}})
+- [Search and query configuration]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/config" >}})
+- [Search and query commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/search/commands" >}})
+- [Search and query references]({{< relref "/develop/interact/search-and-query/advanced-concepts/" >}})
+- [RediSearch source](https://github.com/RediSearch/RediSearch)
+---
+Title: Configure the query performance factor for Redis Query Engine in Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Configure the query performance factor for Redis Query Engine in Redis Enterprise to increase the performance of queries.
+linkTitle: Configure query performance factor
+weight: 20
+aliases: /operate/oss_and_stack/stack-with-enterprise/search/scalable-search/
+         /operate/oss_and_stack/stack-with-enterprise/search/query-performance-factor/
+---
+
+Query performance factors are intended to increase the performance of queries, including [vector search]({{<relref "/develop/interact/search-and-query/query/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.
+{{</note>}}
+
+## Prerequisites
+
+Redis Query Engine requires a cluster running Redis Enterprise Software version 7.4.2-54 or later.
+
+If you do not have a cluster that supports Redis Query Engine, [install Redis Enterprise Software]({{<relref "/operate/rs/installing-upgrading/install/install-on-linux">}}) version 7.4.2-54 or later on a new cluster, or [upgrade an existing cluster]({{<relref "/operate/rs/installing-upgrading/upgrading/upgrade-cluster">}}).
+
+## Sizing
+
+1. Calculate the hardware requirements for your Redis database:
+
+    1. Use the [hardware requirements documentation]({{<relref "/operate/rs/installing-upgrading/install/plan-deployment/hardware-requirements">}}) to derive the overall cluster architecture.
+
+    1. Calculate the RAM requirements using the [Index Size Calculator](https://redis.io/redisearch-sizing-calculator/). The total RAM required is the sum of the dataset and index sizes.
+
+1. [Determine the query performance factor](#calculate-query-performance-factor) you want and the required number of CPUs. Unused CPUs, above the 20% necessary for Redis, can be used for the scalable Redis Query Engine.
+
+1. Create a new Redis database with the number of CPUs configured for the query performance factor.
+
+## Calculate query performance factor
+
+### CPUs for query performance factor
+
+Vertical scaling of the Redis Query Engine is achieved by provisioning additional CPUs for the RediSearch module. At least 20% of the available CPUs must be reserved for Redis internal processing. Use the following formula to define the maximum number of CPUs that can be allocated to search.
+
+| Variable | Value |
+|----------|-------|
+| CPUs per node | x |
+| Redis internals | 20% |
+| Available CPUs for Redis Query Engine | floor(0.8 * x) |
+
+### Query performance factor versus CPUs
+
+The following table shows the number of CPUs required for each performance factor. This calculation is sensitive to how the search index and queries are defined. Certain scenarios might yield less throughput than the ratios in the following table.
+
+| Scale factor | Minimum CPUs required for Redis Query Engine <WORKERS> |
+|----------------|-----------------------------------------|
+| None (default) | 1 |
+| 2 | 3 |
+| 4 | 6 |
+| 6 | 9 |
+| 8 | 12 |
+| 10 | 15 |
+| 12 | 18 |
+| 14 | 21 |
+| 16 | 24 |
+
+### Example performance factor calculation
+
+| Variable | Value |
+|----------|-------|
+| CPUs per node | 8 |
+| Available CPUs | floor(0.8 * 8)=6 |
+| Scale factor | 4x |
+| Minimum CPUs required for scale factor - WORKERS | 6 |
+
+## Configure query performance factor manually
+
+To manually configure the query performance factor in Redis Enterprise Software:
+
+1. [Configure query performance factor parameters](#config-db-ui) when you create a new database or edit an existing database's configuration in the Cluster Manager UI.
+
+1. If you configure the query performance factor for an existing database, you also need to [restart shards](#restart-shards). Newly created databases can skip this step.
+
+### Configure query performance factor parameters in the Cluster Manager UI {#config-db-ui}
+
+You can use the Cluster Manager UI to configure the query performance factor when you [create a new database]({{<relref "/operate/rs/databases/create">}}) or [edit an existing database]({{<relref "/operate/rs/databases/configure#edit-database-settings">}}) with search enabled.
+
+1. In the **Capabilities** section of the database configuration screen, click **Parameters**.
+
+1. If you are creating a new database, select **Search and query**.
+
+1. Adjust the **RediSearch** parameters to include: 
+
+    `WORKERS <NUMBER_OF_THREADS>`
+
+    See [Calculate query performance factor](#calculate-query-performance-factor) to determine the minimum CPUs required to use for `<NUMBER_OF_THREADS>`.
+    
+1. Expand the **Query Performance Factor** section and enter the following values:
+
+    - `mnp` for **Connections routing**
+
+    - `32` for **Connections limit**
+
+    {{<image filename="images/rs/screenshots/databases/rs-config-query-performance-factor.png" alt="Configure search parameters and query performance factor.">}}
+    
+1. Click **Done** to close the parameter editor.
+
+1. Click **Create** or **Save**.
+
+### Restart shards {#restart-shards}
+
+After you update the query performance factor for an existing database, restart all shards to apply the new settings. You can migrate shards to restart them. Newly created databases can skip this step.
+
+1. Use [`rladmin status shards db <db-name>`]({{<relref "/operate/rs/references/cli-utilities/rladmin/status#status-shards">}}) to list all shards for your database:
+
+    ```sh
+    rladmin status shards db db-name
+    ```
+
+    Example output:
+
+    ```sh
+    SHARDS:
+    DB:ID   NAME                ID      NODE   ROLE   SLOTS   USED_MEMORY STATUS
+    db:2    db-name             redis:1 node:1 master 0-16383 1.95MB      OK    
+    db:2    db-name             redis:2 node:2 slave  0-16383 1.95MB      OK    
+    ```
+
+    Note the following fields for the next steps: 
+    - `ID`: the Redis shard's ID.
+    - `NODE`: the node on which the shard currently resides.
+    - `ROLE`: `master` is a primary shard; `slave` is a replica shard.
+
+1. For each replica shard, use [`rladmin migrate shard`]({{<relref "/operate/rs/references/cli-utilities/rladmin/migrate">}}) to move it to a different node and restart it:
+
+    ```sh
+    rladmin migrate shard <shard_id> target_node <node_id>
+    ```
+
+1. After you migrate the replica shards, migrate the original primary shards.
+
+1. Rerun `rladmin status shards db <db-name>` to verify the shards migrated to different nodes:
+
+    ```sh
+    rladmin status shards db db-name
+    ```
+
+    Example output:
+
+    ```sh
+    SHARDS:
+    DB:ID   NAME                ID      NODE   ROLE   SLOTS   USED_MEMORY STATUS
+    db:2    db-name             redis:1 node:2 master 0-16383 1.95MB      OK    
+    db:2    db-name             redis:2 node:1 slave  0-16383 1.95MB      OK    
+    ```
+
+## Configure query performance factor with the REST API
+
+You can configure the query performance factor when you [create a new database](#create-db-rest-api) or [update an existing database](#update-db-rest-api) using the Redis Enterprise Software [REST API]({{<relref "/operate/rs/references/rest-api">}}).
+
+### Create new database with the REST API {#create-db-rest-api}
+
+To create a database and configure the query performance factor, use the [create database REST API endpoint]({{<relref "/operate/rs/references/rest-api/requests/bdbs#post-bdbs-v1">}}) with a [BDB object]({{<relref "/operate/rs/references/rest-api/objects/bdb">}}) that includes the following parameters:
+
+```json
+{
+    "sched_policy": "mnp",
+    "conns": 32,
+    "module_list": [{
+        "module_name": "search",
+        "module_args": "WORKERS <NUMBER_OF_THREADS>"
+    }]
+}
+```
+
+See [Calculate performance factor](#calculate-query-performance-factor) to determine the value to use for `<NUMBER_OF_CPUS>`.
+
+#### Example REST API request for a new database
+
+The following JSON is an example request body used to create a new database with a 4x query performance factor configured:
+
+```json
+{
+    "name": "scalable-search-db",
+    "type": "redis",
+    "memory_size": 10000000,
+    "port": 13000,
+    "authentication_redis_pass": "<your default db pwd>",
+    "proxy_policy": "all-master-shards",
+    "sched_policy": "mnp",
+    "conns": 32,
+    "sharding": true,
+    "shards_count": 3,
+    "shards_placement": "sparse",
+    "shard_key_regex": [{"regex": ".*\\{(?<tag>.*)\\}.*"}, {"regex": "(?<tag>.*)"}],
+    "replication": false,
+    "module_list": [{
+        "module_name": "search",
+        "module_args": "WORKERS 6"
+    }]
+}
+```
+
+The following [cURL](https://curl.se/docs/) request creates a new database from the JSON example:
+
+```sh
+curl -k -u "<user>:<password>" https://<host>:9443/v1/bdbs -H "Content-Type:application/json" -d @scalable-search-db.json
+```
+
+### Update existing database with the REST API {#update-db-rest-api}
+
+To configure the query performance factor for an existing database, use the following REST API requests:
+
+- [Update database configuration]({{<relref "/operate/rs/references/rest-api/requests/bdbs#put-bdbs">}}) to modify the DMC proxy.
+
+- [Upgrade module]({{<relref "/operate/rs/references/rest-api/requests/bdbs/modules/upgrade#post-bdb-modules-upgrade">}}) to set the search module’s query performance factor.
+
+{{<note>}}
+- Because this procedure also restarts the database shards, you should perform it during a maintenance period.
+- This procedure overwrites any existing module configuration parameters.
+{{</note>}}
+
+The following example script uses both endpoints to configure a 4x query performance factor:
+
+```sh
+#!/bin/bash
+export DB_ID=1
+export CPU=6
+export MODULE_ID=`curl -s -k -u "<user>:<password>" https://<host>:9443/v1/bdbs/$DB_ID | jq '.module_list[] | select(.module_name=="search").module_id' | tr -d '"'`
+
+curl -o /dev/null -s -k -u "<user>:<password>" -X PUT https://<host>:9443/v1/bdbs/$DB_ID -H "Content-Type:application/json" -d '{
+    "sched_policy": "mnp",
+    "conns": 32
+}'
+
+sleep 1
+
+curl -o /dev/null -s -k -u "<user>:<password>" https://<host>:9443/v1/bdbs/$DB_ID/modules/upgrade -H "Content-Type:application/json" -d '{
+    "modules": [
+      {
+        "module_name": "search",
+        "new_module_args": "WORKERS '$CPU'",
+        "current_module": "'$MODULE_ID'",
+        "new_module": "'$MODULE_ID'"
+      }
+    ]
+}'
+```
+
+## Monitoring Redis Query Engine
+
+To monitor a database with a query performance factor configured:
+
+1. Integrate your Redis Enterprise deployment with Prometheus. See [Prometheus and Grafana with Redis Enterprise]({{<relref "/integrate/prometheus-with-redis-enterprise">}}) for instructions.
+
+1. Monitor the `redis_process_cpu_usage_percent` shard metric.
+
+    The following Prometheus UI screenshot shows `redis_process_cpu_usage_percent` spikes for a database with two shards:
+
+    - 1st 100% spike: [`memtier_benchmark`](https://github.com/RedisLabs/memtier_benchmark) search test at the default (no additional CPUs for search).
+
+    - 2nd 100% spike: reconfiguration and shard restart for a 4x query performance factor.
+
+    - 3rd 600% spike: `memtier_benchmark` search test with threading at a 4x query performance factor (6 CPUs per shard).
+
+    {{<image filename="images/rs/screenshots/monitor-rs-scalable-search-cpu-usage.png" alt="The Prometheus graph shows three spikes for redis_process_cpu_usage_percent: 100%, another 100%, then 600%.">}}
+---
+Title: JSON commands
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Lists JSON commands and provides links to the command reference pages.
+linkTitle: Commands
+toc: 'false'
+weight: 25
+---
+
+The following table lists JSON commands. See the command links for more information about each command's syntax, arguments, and examples.
+
+| Command | Redis<br />Enterprise | Redis<br />Cloud | Description |
+|:--------|:----------------------|:-----------------|:------|
+| [JSON.ARRAPPEND]({{< relref "commands/json.arrappend" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported"><nobr>&#x2705; Flexible & Annual</nobr></span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Appends an element to a JSON array. |
+| [JSON.ARRINDEX]({{< relref "commands/json.arrindex" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the index of a value's first occurrence in a JSON array. |
+| [JSON.ARRINSERT]({{< relref "commands/json.arrinsert" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Inserts JSON values into a JSON array before the given index. |
+| [JSON.ARRLEN]({{< relref "commands/json.arrlen" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the length of a JSON array. |
+| [JSON.ARRPOP]({{< relref "commands/json.arrpop" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes and returns an element located at the index in the JSON array. |
+| [JSON.ARRTRIM]({{< relref "commands/json.arrtrim" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Trims a JSON array so that it contains only the specified inclusive range of elements. |
+| [JSON.CLEAR]({{< relref "commands/json.clear" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Clears container values (arrays/objects) and sets numeric values to 0. |
+| [JSON.DEBUG]({{< relref "commands/json.debug" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Debugging container command. |
+| [JSON.DEBUG HELP]({{< relref "commands/json.debug-help" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns helpful information about the [JSON.DEBUG]({{< relref "commands/json.debug" >}}) command. |
+| [JSON.DEBUG MEMORY]({{< relref "commands/json.debug-memory/" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Reports a JSON element's memory usage in bytes. |
+| [JSON.DEL]({{< relref "commands/json.del" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes a JSON element. |
+| [JSON.FORGET]({{< relref "commands/json.forget" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Removes a JSON element, the same as [JSON.DEL]({{< relref "commands/json.del" >}}). |
+| [JSON.GET]({{< relref "commands/json.get" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the value of an element in JSON-serialized form. |
+| [JSON.MGET]({{< relref "commands/json.mget" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the values of multiple elements. |
+| [JSON.NUMINCRBY]({{< relref "commands/json.numincrby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Increments the number stored at path by the specified number. |
+| [JSON.NUMMULTBY]({{< relref "commands/json.nummultby" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Multiplies the number stored at path by the specified number. (deprecated as of RedisJSON v2.0) |
+| [JSON.OBJKEYS]({{< relref "commands/json.objkeys" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the keys contained in the specified JSON object. |
+| [JSON.OBJLEN]({{< relref "commands/json.objlen" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the number of keys in the specified JSON object. |
+| [JSON.RESP]({{< relref "commands/json.resp" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns a JSON element in [Redis Serialization Protocol (RESP)]({{< relref "/develop/reference/protocol-spec" >}}) format. |
+| [JSON.SET]({{< relref "commands/json.set" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Sets the value of a JSON element. |
+| [JSON.STRAPPEND]({{< relref "commands/json.strappend" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Appends the given string to the specified key's existing strings. |
+| [JSON.STRLEN]({{< relref "commands/json.strlen" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns the length of a string. |
+| [JSON.TOGGLE]({{< relref "commands/json.toggle" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | If the boolean is `true`, changes it to `false`. If the boolean is `false`, changes it to `true`. |
+| [JSON.TYPE]({{< relref "commands/json.type" >}}) | <span title="Supported">&#x2705; Supported</span><br /><span><br /></span> | <span title="Supported">&#x2705; Flexible & Annual</span><br /><span title="Supported">&#x2705; Free & Fixed</nobr></span> | Returns a JSON element's type. |
+---
+Title: Store JSON in Active-Active databases
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: JSON support and conflict resolution rules for Active-Active databases.
+linkTitle: Active-Active databases
+weight: 50
+tocEmbedHeaders: true
+---
+
+RedisJSON v2.2 adds support for JSON in [Active-Active Redis Enterprise databases]({{< relref "/operate/rs/databases/active-active" >}}).
+
+The design is based on [A Conflict-Free Replicated JSON Datatype](https://arxiv.org/abs/1608.03960) by Kleppmann and Beresford, but the implementation includes some changes. Several [conflict resolution rule](#conflict-resolution-rules) 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.
+
+Active-Active Redis Cloud databases add JSON by default. See [Create an Active-Active database]({{< relref "/operate/rc/databases/create-database/create-active-active-database#select-capabilities" >}}) in the Redis Cloud documentation for details.
+
+In Redis Enterprise Software, JSON is not enabled by default for Active-Active databases. To create an Active-Active JSON database in Redis Enterprise Software:
+
+1. See [Create an Active-Active geo-replicated database]({{< relref "/operate/rs/databases/active-active/create" >}}) in the Redis Enterprise Software documentation for prerequisites and detailed steps.
+
+1. In the **Capabilities** section of the **Create Active-Active database** screen, select **JSON**:
+
+    {{<image filename="images/rs/screenshots/databases/active-active-databases/create-a-a-db-json-search.png" alt="Select JSON from the Capabilities section.">}}
+
+    {{<note>}}
+When you select **JSON**, **Search and Query** is also selected by default to allow you to index and query JSON documents. If you do not want to use these additional features, you can clear the **Search and Query** check box.
+    {{</note>}}
+
+1. Configure additional database settings.
+
+1. Select **Create**.
+
+{{<embed-md "json-active-active-command-differences.md">}}
+
+{{<embed-md "json-active-active-conflict-resolution.md">}}---
+Title: JSON
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: Redis Open Source adds support for JSON to Redis databases.
+hideListLinks: true
+linkTitle: JSON
+toc: 'true'
+weight: 30
+---
+
+Redis Open Source adds support for the [JSON data structure](http://www.json.org/) to Redis databases.
+
+Applications developed with the [source available version of RedisJSON](https://github.com/RedisJSON/RedisJSON) are 100%
+compatible with Redis Enterprise databases with JSON enabled.
+
+## JSON paths
+
+[Paths]({{< relref "/develop/data-types/json/path" >}}) let you traverse the structure of a JSON document, starting from the root, and interact only with the data you want. You can also use paths to perform operations on specific JSON elements.
+
+Since there is no standard for JSON path syntax, Redis Open Source implements its own.
+
+### JSONPath syntax
+
+RedisJSON v2.0 and later support the [JSONPath syntax]({{< relref "/develop/data-types/json/path" >}}), which resembles [Goessner's design](https://goessner.net/articles/JsonPath/):
+  
+  - Paths start with a dollar sign (`$`), which represents the root of the JSON document.
+
+  - See the [JSONPath syntax table]({{< relref "/develop/data-types/json/path" >}}) to learn how to access various elements within a JSON document.
+
+The following path refers to `headphones`, which is a child of `inventory` under the root:
+
+`$.inventory.headphones`
+  
+See [JSONPath examples]({{< relref "/develop/data-types/json/path" >}}) for examples with more complex syntax.
+
+### Legacy path syntax
+
+The [legacy path syntax]({{< relref "/develop/data-types/json/path" >}}#legacy-path-syntax) refers to the path implementation in RedisJSON v1. RedisJSON v2 still supports this legacy path syntax in addition to JSONPath syntax.
+
+The legacy path syntax works as follows:
+
+  - A period character represents the root.
+  
+  - For paths to the root's children, it is optional to prefix the path with a period.
+
+  - Supports both dot notation and bracket notation for JSON object key access.
+  
+The following paths refer to `headphones`, which is a child of `inventory` under the root:
+
+`.inventory.headphones`
+ 
+`inventory["headphones"]`
+
+`['inventory']["headphones"]`
+
+### Key name rules
+
+You can only use the legacy path syntax to access JSON keys if they follow these name syntax rules:
+
+- Key names must begin with a letter, a dollar sign (`$`), or an underscore (`_`).
+- Key names can contain letters, digits, dollar signs, and underscores.
+- Key names are case-sensitive.
+
+## Index and search JSON documents
+
+You can index, search, and query stored JSON documents.
+
+For more information about how to search and query JSON documents, see the [quick start]({{< relref "/develop/get-started/document-database" >}}).
+
+## JSON in Active-Active databases
+
+RedisJSON v2.2 and later support the JSON data structure as a conflict-free replicated data type [(CRDT)](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type) in [Active-Active Redis Enterprise databases]({{< relref "/operate/rs/databases/active-active" >}}).
+
+For details about how Redis Enterprise resolves JSON operation conflicts that can arise when replicas attempt to sync, see the JSON [conflict resolution rules]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/active-active#conflict-resolution-rules" >}}).
+
+## More info
+
+- [JSON quick start]({{< relref "/develop/data-types/json/" >}}#use-redisjson)
+- [JSON commands]({{< relref "/operate/oss_and_stack/stack-with-enterprise/json/commands" >}})
+- [RedisJSON source](https://github.com/RedisJSON/RedisJSON)
+---
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+linkTitle: Quick start
+title: Redis Open Source quick start
+weight: 1
+---
+To quickly set up a database with Redis Stack (Redis Open Source) features,
+you can sign up for a free [Redis Cloud](https://cloud.redis.io/#/sign-up) subscription and create a Redis Stack database.
+
+Alternatively, you can use one of these methods:
+
+- [Redis Enterprise Software]({{< relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- Redis Enterprise Software in a [Docker container]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+- [Other platforms]({{< relref "/operate/kubernetes" >}}) for Redis Enterprise Software
+
+## Set up a Redis Cloud database
+
+To set up a Redis Cloud database with Redis Stack features, follow these steps:
+
+1. [Create a new Redis Cloud subscription](#create-a-subscription).
+
+1. [Create a Redis Stack database](#create-a-redis-stack-database).
+
+1. [Connect to the database](#connect-to-the-database).
+
+For more details, see the Redis Cloud [quick start]({{< relref "/operate/rc/rc-quickstart" >}}).
+
+### Create a subscription
+
+To create a new subscription:
+
+1. Sign in to the Redis Cloud [admin console](http://cloud.redis.io) or create a new account.
+
+1. Select the **New subscription** button:
+
+    {{<image filename="images/rc/button-subscription-new.png" alt="The New subscriptions button in the admin console menu." width="150px">}}
+
+1. Configure your subscription:
+
+    1. Select **Fixed plans**.
+    1. For the cloud vendor, select **Amazon Web Services** (AWS), **Google Cloud** (GCP), or **Microsoft Azure**.
+    1. Select a region to deploy the subscription to.
+    1. From the dataset size list, select the Free tier (30MB).
+    1. Enter a name for the subscription.
+
+1. Select the **Create subscription** button:
+
+    {{<image filename="images/rc/button-subscription-create.png" alt="The Create Subscription button." width="150px">}}
+
+### Create a Redis Stack database
+
+After you create a subscription, follow these steps to create a Redis Stack database:
+
+1. Select the **New database** button:
+
+    {{<image filename="images/rc/button-database-new.png" alt="The New Database button creates a new database for your subscription." width="120px">}}
+
+1. In **General** settings, enter a **Database name**.
+
+1. For database **Type**, select **Redis Stack**.
+
+1. Select the **Activate database** button:
+
+    {{<image filename="images/rc/button-database-activate.png" alt="Use the Activate database button to create and activate your database." width="150px">}}
+
+### Connect to the database
+
+After creating the database, you can view its **Configuration** settings. You will need the following information to connect to your new database:
+
+- **Public endpoint**: The host address of the database
+- **Redis password**/**Default user password**: The password used to authenticate with the database
+
+With this information, you can connect to your database with the [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}) command-line tool, an application, or [Redis Insight](https://redislabs.com/redisinsight/).
+
+## Try Redis Open Source features
+
+To try out Redis Open Source features, follow the examples provided by the corresponding guides:
+
+- [Redis Query Engine quick start]({{< relref "/develop/get-started/document-database" >}})
+- [JSON quick start]({{< relref "/develop/data-types/json/" >}}#use-redisjson)
+- [Time series quick start]({{< relref "/develop/data-types/timeseries/quickstart" >}})
+- [Probabilistic data structures quick start]({{< relref "/develop/data-types/probabilistic/" >}})
+---
+Title: Redis Open Source and Redis Enterprise
+alwaysopen: false
+categories:
+- docs
+- operate
+- stack
+description: null
+hideListLinks: false
+linkTitle: Redis Open Source and Redis Enterprise
+weight: 70
+aliases:
+    - /operate/modules
+---
+
+[Redis Enterprise Software]({{< relref "/operate/rs" >}}) and [Redis Cloud]({{< relref "/operate/rc" >}}) support all [Redis Open Source]({{< relref "/operate/oss_and_stack/stack-with-enterprise/enterprise-capabilities" >}}) features. Some of the capabilities Redis Open Source provides include querying, indexing, and full-text search and support for JSON, time series, and probabilistic data structures.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: 'Exploring Redis on the ARM CPU Architecture
+
+  '
+linkTitle: ARM support
+title: ARM support
+weight: 11
+---
+
+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.
+
+We believe that Redis is ideal for IoT and embedded devices for several
+reasons:
+
+* Redis has a very small memory footprint and CPU requirements. It can run in small devices like the Raspberry Pi Zero without impacting the overall performance, using a small amount of memory while delivering good performance for many use cases.
+* The data structures of Redis are often an ideal way to model IoT/embedded use cases. Some examples include accumulating time series data, receiving or queuing commands to execute or respond to send back to the remote servers, and so forth.
+* Modeling data inside Redis can be very useful in order to make in-device decisions for appliances that must respond very quickly or when the remote servers are offline.
+* Redis can be used as a communication system between the processes running in the device.
+* The append-only file storage of Redis is well suited for SSD cards.
+* The stream data structure included in Redis versions 5.0 and higher was specifically designed for time series applications and has a very low memory overhead.
+
+## Redis /proc/cpu/alignment requirements
+
+Linux on ARM allows to trap unaligned accesses and fix them inside the kernel
+in order to continue the execution of the offending program instead of
+generating a `SIGBUS`. Redis 4.0 and greater are fixed in order to avoid any kind
+of unaligned access, so there is no need to have a specific value for this
+kernel configuration. Even when kernel alignment fixing set as disabled Redis should
+run as expected.
+
+## Building Redis in the Pi
+
+* Download Redis version 4.0 or higher.
+* Use `make` as usual to create the executable.
+
+There is nothing special in the process. The only difference is that by
+default, Redis uses the `libc` allocator instead of defaulting to `jemalloc`
+as it does in other Linux based environments. This is because we believe
+that for the small use cases inside embedded devices, memory fragmentation
+is unlikely to be a problem. Moreover `jemalloc` on ARM may not be as tested
+as the `libc` allocator.
+
+## Performance
+
+Performance testing of Redis was performed on the Raspberry Pi 3 and Pi 1 model B. The difference between the two Pis in terms of delivered performance is quite big. The benchmarks were performed via the
+loopback interface, since most use cases will probably use Redis from within
+the device and not via the network. The following numbers were obtained using
+Redis 4.0.
+
+Raspberry Pi 3:
+
+* Test 1 : 5 millions writes with 1 million keys (even distribution among keys).  No persistence, no pipelining. 28,000 ops/sec.
+* Test 2: Like test 1 but with pipelining using groups of 8 operations: 80,000 ops/sec.
+* Test 3: Like test 1 but with AOF enabled, fsync 1 sec: 23,000 ops/sec
+* Test 4: Like test 3, but with an AOF rewrite in progress: 21,000 ops/sec
+
+Raspberry Pi 1 model B:
+
+* Test 1 : 5 millions writes with 1 million keys (even distribution among keys).  No persistence, no pipelining.  2,200 ops/sec.
+* Test 2: Like test 1 but with pipelining using groups of 8 operations: 8,500 ops/sec.
+* Test 3: Like test 1 but with AOF enabled, fsync 1 sec: 1,820 ops/sec
+* Test 4: Like test 3, but with an AOF rewrite in progress: 1,000 ops/sec
+
+The benchmarks above are referring to simple [`SET`](/commands/set)/[`GET`](/commands/get) operations. The performance is similar for all the Redis fast operations (not running in linear time). However sorted sets may show slightly slower numbers.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Guide to the original implementation of Redis strings
+linkTitle: String internals
+title: String internals
+weight: 1
+---
+
+**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](https://github.com/antirez/sds).
+
+The C structure `sdshdr` declared in `sds.h` represents a Redis string:
+
+    struct sdshdr {
+        long len;
+        long free;
+        char buf[];
+    };
+
+The `buf` character array stores the actual string.
+
+The `len` field stores the length of `buf`. This makes obtaining the length
+of a Redis string an O(1) operation.
+
+The `free` field stores the number of additional bytes available for use.
+
+Together the `len` and `free` field can be thought of as holding the metadata of the `buf` character array.
+
+Creating Redis Strings
+---
+
+A new data type named `sds` is defined in `sds.h` to be a synonym for a character pointer:
+
+    typedef char *sds;
+
+`sdsnewlen` function defined in `sds.c` creates a new Redis String:
+
+    sds sdsnewlen(const void *init, size_t initlen) {
+        struct sdshdr *sh;
+
+        sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
+    #ifdef SDS_ABORT_ON_OOM
+        if (sh == NULL) sdsOomAbort();
+    #else
+        if (sh == NULL) return NULL;
+    #endif
+        sh->len = initlen;
+        sh->free = 0;
+        if (initlen) {
+            if (init) memcpy(sh->buf, init, initlen);
+            else memset(sh->buf,0,initlen);
+        }
+        sh->buf[initlen] = '\0';
+        return (char*)sh->buf;
+    }
+
+Remember a Redis string is a variable of type `struct sdshdr`. But `sdsnewlen` returns a character pointer!!
+
+That's a trick and needs some explanation.
+
+Suppose I create a Redis string using `sdsnewlen` like below:
+
+    sdsnewlen("redis", 5);
+
+This creates a new variable of type `struct sdshdr` allocating memory for `len` and `free`
+fields as well as for the `buf` character array.
+
+    sh = zmalloc(sizeof(struct sdshdr)+initlen+1); // initlen is length of init argument.
+
+After `sdsnewlen` successfully creates a Redis string the result is something like:
+
+    -----------
+    |5|0|redis|
+    -----------
+    ^   ^
+    sh  sh->buf
+
+`sdsnewlen` returns `sh->buf` to the caller.
+
+What do you do if you need to free the Redis string pointed by `sh`?
+
+You want the pointer `sh` but you only have the pointer `sh->buf`.
+
+Can you get the pointer `sh` from `sh->buf`?
+
+Yes. Pointer arithmetic. Notice from the above ASCII art that if you subtract
+the size of two longs from `sh->buf` you get the pointer `sh`.
+
+The `sizeof` two longs happens to be the size of `struct sdshdr`.
+
+Look at `sdslen` function and see this trick at work:
+
+    size_t sdslen(const sds s) {
+        struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr)));
+        return sh->len;
+    }
+
+Knowing this trick you could easily go through the rest of the functions in `sds.c`.
+
+The Redis string implementation is hidden behind an interface that accepts only character pointers. The users of Redis strings need not care about how it's implemented and can treat Redis strings as a character pointer.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: A description of the Redis virtual memory system that was deprecated
+  in 2.4 and removed in 2.6. This document exists for historical interest.
+linkTitle: Virtual memory
+title: Virtual memory (deprecated)
+weight: 1
+---
+
+**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.
+
+Keys vs Values: what is swapped out?
+---
+
+The goal of the VM subsystem is to free memory transferring Redis Objects from memory to disk. This is a very generic command, but specifically, Redis transfers only objects associated with _values_. In order to understand better this concept we'll show, using the DEBUG command, how a key holding a value looks from the point of view of the Redis internals:
+
+    redis> set foo bar
+    OK
+    redis> debug object foo
+    Key at:0x100101d00 refcount:1, value at:0x100101ce0 refcount:1 encoding:raw serializedlength:4
+
+As you can see from the above output, the Redis top level hash table maps Redis Objects (keys) to other Redis Objects (values). The Virtual Memory is only able to swap _values_ on disk, the objects associated to _keys_ are always taken in memory: this trade off guarantees very good lookup performances, as one of the main design goals of the Redis VM is to have performances similar to Redis with VM disabled when the part of the dataset frequently used fits in RAM.
+
+How does a swapped value looks like internally
+---
+
+When an object is swapped out, this is what happens in the hash table entry:
+
+ * The key continues to hold a Redis Object representing the key.
+ * The value is set to NULL
+
+So you may wonder where we store the information that a given value (associated to a given key) was swapped out. Just in the key object!
+
+This is how the Redis Object structure _robj_ looks like:
+
+    /* The actual Redis Object */
+    typedef struct redisObject {
+        void *ptr;
+        unsigned char type;
+        unsigned char encoding;
+        unsigned char storage;  /* If this object is a key, where is the value?
+                                 * REDIS_VM_MEMORY, REDIS_VM_SWAPPED, ... */
+        unsigned char vtype; /* If this object is a key, and value is swapped out,
+                              * this is the type of the swapped out object. */
+        int refcount;
+        /* VM fields, this are only allocated if VM is active, otherwise the
+         * object allocation function will just allocate
+         * sizeof(redisObject) minus sizeof(redisObjectVM), so using
+         * Redis without VM active will not have any overhead. */
+        struct redisObjectVM vm;
+    } robj;
+
+As you can see there are a few fields about VM. The most important one is _storage_, that can be one of this values:
+
+ * `REDIS_VM_MEMORY`: the associated value is in memory.
+ * `REDIS_VM_SWAPPED`: the associated values is swapped, and the value entry of the hash table is just set to NULL.
+ * `REDIS_VM_LOADING`: the value is swapped on disk, the entry is NULL, but there is a job to load the object from the swap to the memory (this field is only used when threaded VM is active).
+ * `REDIS_VM_SWAPPING`: the value is in memory, the entry is a pointer to the actual Redis Object, but there is an I/O job in order to transfer this value to the swap file.
+
+If an object is swapped on disk (`REDIS_VM_SWAPPED` or `REDIS_VM_LOADING`), how do we know where it is stored, what type it is, and so forth? That's simple: the _vtype_ field is set to the original type of the Redis object swapped, while the _vm_ field (that is a _redisObjectVM_ structure) holds information about the location of the object. This is the definition of this additional structure:
+
+    /* The VM object structure */
+    struct redisObjectVM {
+        off_t page;         /* the page at which the object is stored on disk */
+        off_t usedpages;    /* number of pages used on disk */
+        time_t atime;       /* Last access time */
+    } vm;
+
+As you can see the structure contains the page at which the object is located in the swap file, the number of pages used, and the last access time of the object (this is very useful for the algorithm that select what object is a good candidate for swapping, as we want to transfer on disk objects that are rarely accessed).
+
+As you can see, while all the other fields are using unused bytes in the old Redis Object structure (we had some free bit due to natural memory alignment concerns), the _vm_ field is new, and indeed uses additional memory. Should we pay such a memory cost even when VM is disabled? No! This is the code to create a new Redis Object:
+
+    ... some code ...
+            if (server.vm_enabled) {
+                pthread_mutex_unlock(&server.obj_freelist_mutex);
+                o = zmalloc(sizeof(*o));
+            } else {
+                o = zmalloc(sizeof(*o)-sizeof(struct redisObjectVM));
+            }
+    ... some code ...
+
+As you can see if the VM system is not enabled we allocate just `sizeof(*o)-sizeof(struct redisObjectVM)` of memory. Given that the _vm_ field is the last in the object structure, and that this fields are never accessed if VM is disabled, we are safe and Redis without VM does not pay the memory overhead.
+
+The Swap File
+---
+
+The next step in order to understand how the VM subsystem works is understanding how objects are stored inside the swap file. The good news is that's not some kind of special format, we just use the same format used to store the objects in .rdb files, that are the usual dump files produced by Redis using the [`SAVE`](/commands/save) command.
+
+The swap file is composed of a given number of pages, where every page size is a given number of bytes. This parameters can be changed in redis.conf, since different Redis instances may work better with different values: it depends on the actual data you store inside it. The following are the default values:
+
+    vm-page-size 32
+    vm-pages 134217728
+
+Redis takes a "bitmap" (a contiguous array of bits set to zero or one) in memory, every bit represent a page of the swap file on disk: if a given bit is set to 1, it represents a page that is already used (there is some Redis Object stored there), while if the corresponding bit is zero, the page is free.
+
+Taking this bitmap (that will call the page table) in memory is a huge win in terms of performances, and the memory used is small: we just need 1 bit for every page on disk. For instance in the example below 134217728 pages of 32 bytes each (4GB swap file) is using just 16 MB of RAM for the page table.
+
+Transferring objects from memory to swap
+---
+
+In order to transfer an object from memory to disk we need to perform the following steps (assuming non threaded VM, just a simple blocking approach):
+
+ * Find how many pages are needed in order to store this object on the swap file. This is trivially accomplished just calling the function `rdbSavedObjectPages` that returns the number of pages used by an object on disk. Note that this function does not duplicate the .rdb saving code just to understand what will be the length *after* an object will be saved on disk, we use the trick of opening /dev/null and writing the object there, finally calling `ftello` in order check the amount of bytes required. What we do basically is to save the object on a virtual very fast file, that is, /dev/null.
+ * Now that we know how many pages are required in the swap file, we need to find this number of contiguous free pages inside the swap file. This task is accomplished by the `vmFindContiguousPages` function. As you can guess this function may fail if the swap is full, or so fragmented that we can't easily find the required number of contiguous free pages. When this happens we just abort the swapping of the object, that will continue to live in memory.
+ * Finally we can write the object on disk, at the specified position, just calling the function `vmWriteObjectOnSwap`.
+
+As you can guess once the object was correctly written in the swap file, it is freed from memory, the storage field in the associated key is set to `REDIS_VM_SWAPPED`, and the used pages are marked as used in the page table.
+
+Loading objects back in memory
+---
+
+Loading an object from swap to memory is simpler, as we already know where the object is located and how many pages it is using. We also know the type of the object (the loading functions are required to know this information, as there is no header or any other information about the object type on disk), but this is stored in the _vtype_ field of the associated key as already seen above.
+
+Calling the function `vmLoadObject` passing the key object associated to the value object we want to load back is enough. The function will also take care of fixing the storage type of the key (that will be `REDIS_VM_MEMORY`), marking the pages as freed in the page table, and so forth.
+
+The return value of the function is the loaded Redis Object itself, that we'll have to set again as value in the main hash table (instead of the NULL value we put in place of the object pointer when the value was originally swapped out).
+
+How blocking VM works
+---
+
+Now we have all the building blocks in order to describe how the blocking VM works. First of all, an important detail about configuration. In order to enable blocking VM in Redis `server.vm_max_threads` must be set to zero.
+We'll see later how this max number of threads info is used in the threaded VM, for now all it's needed to now is that Redis reverts to fully blocking VM when this is set to zero.
+
+We also need to introduce another important VM parameter, that is, `server.vm_max_memory`. This parameter is very important as it is used in order to trigger swapping: Redis will try to swap objects only if it is using more memory than the max memory setting, otherwise there is no need to swap as we are matching the user requested memory usage.
+
+Blocking VM swapping
+---
+
+Swapping of object from memory to disk happens in the cron function. This function used to be called every second, while in the recent Redis versions on git it is called every 100 milliseconds (that is, 10 times per second).
+If this function detects we are out of memory, that is, the memory used is greater than the vm-max-memory setting, it starts transferring objects from memory to disk in a loop calling the function `vmSwapOneObect`. This function takes just one argument, if 0 it will swap objects in a blocking way, otherwise if it is 1, I/O threads are used. In the blocking scenario we just call it with zero as argument.
+
+vmSwapOneObject acts performing the following steps:
+
+ * The key space in inspected in order to find a good candidate for swapping (we'll see later what a good candidate for swapping is).
+ * The associated value is transferred to disk, in a blocking way.
+ * The key storage field is set to `REDIS_VM_SWAPPED`, while the _vm_ fields of the object are set to the right values (the page index where the object was swapped, and the number of pages used to swap it).
+ * Finally the value object is freed and the value entry of the hash table is set to NULL.
+
+The function is called again and again until one of the following happens: there is no way to swap more objects because either the swap file is full or nearly all the objects are already transferred on disk, or simply the memory usage is already under the vm-max-memory parameter.
+
+What values to swap when we are out of memory?
+---
+
+Understanding what's a good candidate for swapping is not too hard. A few objects at random are sampled, and for each their _swappability_ is commuted as:
+
+    swappability = age*log(size_in_memory)
+
+The age is the number of seconds the key was not requested, while size_in_memory is a fast estimation of the amount of memory (in bytes) used by the object in memory. So we try to swap out objects that are rarely accessed, and we try to swap bigger objects over smaller one, but the latter is a less important factor (because of the logarithmic function used). This is because we don't want bigger objects to be swapped out and in too often as the bigger the object the more I/O and CPU is required in order to transfer it.
+
+Blocking VM loading
+---
+
+What happens if an operation against a key associated with a swapped out object is requested? For instance Redis may just happen to process the following command:
+
+    GET foo
+
+If the value object of the `foo` key is swapped we need to load it back in memory before processing the operation. In Redis the key lookup process is centralized in the `lookupKeyRead` and `lookupKeyWrite` functions, this two functions are used in the implementation of all the Redis commands accessing the keyspace, so we have a single point in the code where to handle the loading of the key from the swap file to memory.
+
+So this is what happens:
+
+ * The user calls some command having as argument a swapped key
+ * The command implementation calls the lookup function
+ * The lookup function search for the key in the top level hash table. If the value associated with the requested key is swapped (we can see that checking the _storage_ field of the key object), we load it back in memory in a blocking way before to return to the user.
+
+This is pretty straightforward, but things will get more _interesting_ with the threads. From the point of view of the blocking VM the only real problem is the saving of the dataset using another process, that is, handling [`BGSAVE`](/commands/bgsave) and [`BGREWRITEAOF`](/commands/bgrewriteaof) commands.
+
+Background saving when VM is active
+---
+
+The default Redis way to persist on disk is to create .rdb files using a child process. Redis calls the fork() system call in order to create a child, that has the exact copy of the in memory dataset, since fork duplicates the whole program memory space (actually thanks to a technique called Copy on Write memory pages are shared between the parent and child process, so the fork() call will not require too much memory).
+
+In the child process we have a copy of the dataset in a given point in the time. Other commands issued by clients will just be served by the parent process and will not modify the child data.
+
+The child process will just store the whole dataset into the dump.rdb file and finally will exit. But what happens when the VM is active? Values can be swapped out so we don't have all the data in memory, and we need to access the swap file in order to retrieve the swapped values. While child process is saving the swap file is shared between the parent and child process, since:
+
+* The parent process needs to access the swap file in order to load values back into memory if an operation against swapped out values are performed.
+* The child process needs to access the swap file in order to retrieve the full dataset while saving the data set on disk.
+
+In order to avoid problems while both the processes are accessing the same swap file we do a simple thing, that is, not allowing values to be swapped out in the parent process while a background saving is in progress. This way both the processes will access the swap file in read only. This approach has the problem that while the child process is saving no new values can be transferred on the swap file even if Redis is using more memory than the max memory parameters dictates. This is usually not a problem as the background saving will terminate in a short amount of time and if still needed a percentage of values will be swapped on disk ASAP.
+
+An alternative to this scenario is to enable the Append Only File that will have this problem only when a log rewrite is performed using the [`BGREWRITEAOF`](/commands/bgrewriteaof) command.
+
+The problem with the blocking VM
+---
+
+The problem of blocking VM is that... it's blocking :)
+This is not a problem when Redis is used in batch processing activities, but for real-time usage one of the good points of Redis is the low latency. The blocking VM will have bad latency behaviors as when a client is accessing a swapped out value, or when Redis needs to swap out values, no other clients will be served in the meantime.
+
+Swapping out keys should happen in background. Similarly when a client is accessing a swapped out value other clients accessing in memory values should be served mostly as fast as when VM is disabled. Only the clients dealing with swapped out keys should be delayed.
+
+All this limitations called for a non-blocking VM implementation.
+
+Threaded VM
+---
+
+There are basically three main ways to turn the blocking VM into a non blocking one.
+* 1: One way is obvious, and in my opinion, not a good idea at all, that is, turning Redis itself into a threaded server: if every request is served by a different thread automatically other clients don't need to wait for blocked ones. Redis is fast, exports atomic operations, has no locks, and is just 10k lines of code, *because* it is single threaded, so this was not an option for me.
+* 2: Using non-blocking I/O against the swap file. After all you can think Redis already event-loop based, why don't just handle disk I/O in a non-blocking fashion? I also discarded this possibility because of two main reasons. One is that non blocking file operations, unlike sockets, are an incompatibility nightmare. It's not just like calling select, you need to use OS-specific things. The other problem is that the I/O is just one part of the time consumed to handle VM, another big part is the CPU used in order to encode/decode data to/from the swap file. This is I picked option three, that is...
+* 3: Using I/O threads, that is, a pool of threads handling the swap I/O operations. This is what the Redis VM is using, so let's detail how this works.
+
+I/O Threads
+---
+
+The threaded VM design goals where the following, in order of importance:
+
+ * Simple implementation, little room for race conditions, simple locking, VM system more or less completely decoupled from the rest of Redis code.
+ * Good performances, no locks for clients accessing values in memory.
+ * Ability to decode/encode objects in the I/O threads.
+
+The above goals resulted in an implementation where the Redis main thread (the one serving actual clients) and the I/O threads communicate using a queue of jobs, with a single mutex.
+Basically when main thread requires some work done in the background by some I/O thread, it pushes an I/O job structure in the `server.io_newjobs` queue (that is, just a linked list). If there are no active I/O threads, one is started. At this point some I/O thread will process the I/O job, and the result of the processing is pushed in the `server.io_processed` queue. The I/O thread will send a byte using an UNIX pipe to the main thread in order to signal that a new job was processed and the result is ready to be processed.
+
+This is how the `iojob` structure looks like:
+
+    typedef struct iojob {
+        int type;   /* Request type, REDIS_IOJOB_* */
+        redisDb *db;/* Redis database */
+        robj *key;  /* This I/O request is about swapping this key */
+        robj *val;  /* the value to swap for REDIS_IOREQ_*_SWAP, otherwise this
+                     * field is populated by the I/O thread for REDIS_IOREQ_LOAD. */
+        off_t page; /* Swap page where to read/write the object */
+        off_t pages; /* Swap pages needed to save object. PREPARE_SWAP return val */
+        int canceled; /* True if this command was canceled by blocking side of VM */
+        pthread_t thread; /* ID of the thread processing this entry */
+    } iojob;
+
+There are just three type of jobs that an I/O thread can perform (the type is specified by the `type` field of the structure):
+
+* `REDIS_IOJOB_LOAD`: load the value associated to a given key from swap to memory. The object offset inside the swap file is `page`, the object type is `key->vtype`. The result of this operation will populate the `val` field of the structure.
+* `REDIS_IOJOB_PREPARE_SWAP`: compute the number of pages needed in order to save the object pointed by `val` into the swap. The result of this operation will populate the `pages` field.
+* `REDIS_IOJOB_DO_SWAP`: Transfer the object pointed by `val` to the swap file, at page offset `page`.
+
+The main thread delegates just the above three tasks. All the rest is handled by the I/O thread itself, for instance finding a suitable range of free pages in the swap file page table (that is a fast operation), deciding what object to swap, altering the storage field of a Redis object to reflect the current state of a value.
+
+Non blocking VM as probabilistic enhancement of blocking VM
+---
+
+So now we have a way to request background jobs dealing with slow VM operations. How to add this to the mix of the rest of the work done by the main thread? While blocking VM was aware that an object was swapped out just when the object was looked up, this is too late for us: in C it is not trivial to start a background job in the middle of the command, leave the function, and re-enter in the same point the computation when the I/O thread finished what we requested (that is, no co-routines or continuations or alike).
+
+Fortunately there was a much, much simpler way to do this. And we love simple things: basically consider the VM implementation a blocking one, but add an optimization (using non the no blocking VM operations we are able to perform) to make the blocking *very* unlikely.
+
+This is what we do:
+
+ * Every time a client sends us a command, *before* the command is executed, we examine the argument vector of the command in search for swapped keys. After all we know for every command what arguments are keys, as the Redis command format is pretty simple.
+ * If we detect that at least a key in the requested command is swapped on disk, we block the client instead of really issuing the command. For every swapped value associated to a requested key, an I/O job is created, in order to bring the values back in memory. The main thread continues the execution of the event loop, without caring about the blocked client.
+ * In the meanwhile, I/O threads are loading values in memory. Every time an I/O thread finished loading a value, it sends a byte to the main thread using an UNIX pipe. The pipe file descriptor has a readable event associated in the main thread event loop, that is the function `vmThreadedIOCompletedJob`. If this function detects that all the values needed for a blocked client were loaded, the client is restarted and the original command called.
+
+So you can think of this as a blocked VM that almost always happen to have the right keys in memory, since we pause clients that are going to issue commands about swapped out values until this values are loaded.
+
+If the function checking what argument is a key fails in some way, there is no problem: the lookup function will see that a given key is associated to a swapped out value and will block loading it. So our non blocking VM reverts to a blocking one when it is not possible to anticipate what keys are touched.
+
+For instance in the case of the [`SORT`](/commands/sort) command used together with the [`GET`](/commands/get) or `BY` options, it is not trivial to know beforehand what keys will be requested, so at least in the first implementation, `SORT BY/GET` resorts to the blocking VM implementation.
+
+Blocking clients on swapped keys
+---
+
+How to block clients? To suspend a client in an event-loop based server is pretty trivial. All we do is canceling its read handler. Sometimes we do something different (for instance for BLPOP) that is just marking the client as blocked, but not processing new data (just accumulating the new data into input buffers).
+
+Aborting I/O jobs
+---
+
+There is something hard to solve about the interactions between our blocking and non blocking VM, that is, what happens if a blocking operation starts about a key that is also "interested" by a non blocking operation at the same time?
+
+For instance while SORT BY is executed, a few keys are being loaded in a blocking manner by the sort command. At the same time, another client may request the same keys with a simple _GET key_ command, that will trigger the creation of an I/O job to load the key in background.
+
+The only simple way to deal with this problem is to be able to kill I/O jobs in the main thread, so that if a key that we want to load or swap in a blocking way is in the `REDIS_VM_LOADING` or `REDIS_VM_SWAPPING` state (that is, there is an I/O job about this key), we can just kill the I/O job about this key, and go ahead with the blocking operation we want to perform.
+
+This is not as trivial as it is. In a given moment an I/O job can be in one of the following three queues:
+
+ * server.io_newjobs: the job was already queued but no thread is handling it.
+ * server.io_processing: the job is being processed by an I/O thread.
+ * server.io_processed: the job was already processed.
+The function able to kill an I/O job is `vmCancelThreadedIOJob`, and this is what it does:
+ * If the job is in the newjobs queue, that's simple, removing the iojob structure from the queue is enough as no thread is still executing any operation.
+ * If the job is in the processing queue, a thread is messing with our job (and possibly with the associated object!). The only thing we can do is waiting for the item to move to the next queue in a *blocking way*. Fortunately this condition happens very rarely so it's not a performance problem.
+ * If the job is in the processed queue, we just mark it as _canceled_ marking setting the `canceled` field to 1 in the iojob structure. The function processing completed jobs will just ignored and free the job instead of really processing it.
+
+Questions?
+---
+
+This document is in no way complete, the only way to get the whole picture is reading the source code, but it should be a good introduction in order to make the code review / understanding a lot simpler.
+
+Something is not clear about this page? Please leave a comment and I'll try to address the issue possibly integrating the answer in this document.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: What's an event library, and how was the original Redis event library
+  implemented?
+linkTitle: Event library
+title: Event library
+weight: 1
+---
+
+**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.
+
+Q: What do you expect a network server to be doing all the time? <br/>
+A: Watch for inbound connections on the port its listening and accept them.
+
+Q: Calling [accept](http://man.cx/accept%282%29) yields a descriptor. What do I do with it?<br/>
+A: Save the descriptor and do a non-blocking read/write operation on it.
+
+Q: Why does the read/write have to be non-blocking?<br/>
+A: If the file operation ( even a socket in Unix is a file ) is blocking how could the server for example accept other connection requests when its blocked in a file I/O operation.
+
+Q: I guess I have to do many such non-blocking operations on the socket to see when it's ready. Am I right?<br/>
+A: Yes. That is what an event library does for you. Now you get it.
+
+Q: How do Event Libraries do what they do?<br/>
+A: They use the operating system's polling facility along with timers.
+
+Q: So are there any open source event libraries that do what you just described? <br/>
+A: Yes. `libevent` and `libev` are two such event libraries that I can recall off the top of my head.
+
+Q: Does Redis use such open source event libraries for handling socket I/O?<br/>
+A: No. For various [reasons](http://groups.google.com/group/redis-db/browse_thread/thread/b52814e9ef15b8d0/) Redis uses its own event library.
+
+## The Redis event library
+
+Redis implements its own event library. The event library is implemented in `ae.c`.
+
+The best way to understand how the Redis event library works is to understand how Redis uses it.
+
+Event Loop Initialization
+---
+
+`initServer` function defined in `redis.c` initializes the numerous fields of the `redisServer` structure variable. One such field is the Redis event loop `el`:
+
+    aeEventLoop *el
+
+`initServer` initializes `server.el` field by calling `aeCreateEventLoop` defined in `ae.c`. The definition of `aeEventLoop` is below:
+
+    typedef struct aeEventLoop
+    {
+        int maxfd;
+        long long timeEventNextId;
+        aeFileEvent events[AE_SETSIZE]; /* Registered events */
+        aeFiredEvent fired[AE_SETSIZE]; /* Fired events */
+        aeTimeEvent *timeEventHead;
+        int stop;
+        void *apidata; /* This is used for polling API specific data */
+        aeBeforeSleepProc *beforesleep;
+    } aeEventLoop;
+
+`aeCreateEventLoop`
+---
+
+`aeCreateEventLoop` first `malloc`s `aeEventLoop` structure then calls `ae_epoll.c:aeApiCreate`.
+
+`aeApiCreate` `malloc`s `aeApiState` that has two fields - `epfd` that holds the `epoll` file descriptor returned by a call from [`epoll_create`](http://man.cx/epoll_create%282%29) and `events` that is of type `struct epoll_event` define by the Linux `epoll` library. The use of the `events` field will be  described later.
+
+Next is `ae.c:aeCreateTimeEvent`. But before that `initServer` call `anet.c:anetTcpServer` that creates and returns a _listening descriptor_. The descriptor listens on *port 6379* by default. The returned  _listening descriptor_ is stored in `server.fd` field.
+
+`aeCreateTimeEvent`
+---
+
+`aeCreateTimeEvent` accepts the following as parameters:
+
+  * `eventLoop`: This is `server.el` in `redis.c`
+  * milliseconds: The number of milliseconds from the current time after which the timer expires.
+  * `proc`: Function pointer. Stores the address of the function that has to be called after the timer expires.
+  * `clientData`: Mostly `NULL`.
+  * `finalizerProc`: Pointer to the function that has to be called before the timed event is removed from the list of timed events.
+
+`initServer` calls `aeCreateTimeEvent` to add a timed event to `timeEventHead` field of `server.el`. `timeEventHead` is a pointer to a list of such timed events. The call to `aeCreateTimeEvent` from `redis.c:initServer` function is given below:
+
+    aeCreateTimeEvent(server.el /*eventLoop*/, 1 /*milliseconds*/, serverCron /*proc*/, NULL /*clientData*/, NULL /*finalizerProc*/);
+
+`redis.c:serverCron` performs many operations that helps keep Redis running properly.
+
+`aeCreateFileEvent`
+---
+
+The essence of `aeCreateFileEvent` function is to execute [`epoll_ctl`](http://man.cx/epoll_ctl) system call which adds a watch for `EPOLLIN` event on the _listening descriptor_ create by `anetTcpServer` and associate it with the `epoll` descriptor created by a call to `aeCreateEventLoop`.
+
+Following is an explanation of what precisely `aeCreateFileEvent` does when called from `redis.c:initServer`.
+
+`initServer` passes the following arguments to `aeCreateFileEvent`:
+
+  * `server.el`: The event loop created by `aeCreateEventLoop`. The `epoll` descriptor is got from `server.el`.
+  * `server.fd`: The _listening descriptor_ that also serves as an index to access the relevant file event structure from the `eventLoop->events` table and store extra information like the callback function.
+  * `AE_READABLE`: Signifies that `server.fd` has to be watched for `EPOLLIN` event.
+  * `acceptHandler`: The function that has to be executed when the event being watched for is ready. This function pointer is stored in `eventLoop->events[server.fd]->rfileProc`.
+
+This completes the initialization of Redis event loop.
+
+Event Loop Processing
+---
+
+`ae.c:aeMain` called from `redis.c:main` does the job of processing the event loop that is initialized in the previous phase.
+
+`ae.c:aeMain` calls `ae.c:aeProcessEvents` in a while loop that processes pending time and file events.
+
+`aeProcessEvents`
+---
+
+`ae.c:aeProcessEvents` looks for the time event that will be pending in the smallest amount of time by calling `ae.c:aeSearchNearestTimer` on the event loop. In our case there is only one timer event in the event loop that was created by `ae.c:aeCreateTimeEvent`.
+
+Remember, that the timer event created by `aeCreateTimeEvent` has probably elapsed by now because it had an expiry time of one millisecond. Since the timer has already expired, the seconds and microseconds fields of the `tvp` `timeval` structure variable is initialized to zero.
+
+The `tvp` structure variable along with the event loop variable is passed to `ae_epoll.c:aeApiPoll`.
+
+`aeApiPoll` functions does an [`epoll_wait`](http://man.cx/epoll_wait) on the `epoll` descriptor and populates the `eventLoop->fired` table with the details:
+
+  * `fd`: The descriptor that is now ready to do a read/write operation depending on the mask value.
+  * `mask`: The read/write event that can now be performed on the corresponding descriptor.
+
+`aeApiPoll` returns the number of such file events ready for operation. Now to put things in context, if any client has requested for a connection then `aeApiPoll` would have noticed it and populated the `eventLoop->fired` table with an entry of the descriptor being the _listening descriptor_ and mask being `AE_READABLE`.
+
+Now, `aeProcessEvents` calls the `redis.c:acceptHandler` registered as the callback. `acceptHandler` executes [accept](http://man.cx/accept) on the _listening descriptor_ returning a _connected descriptor_ with the client. `redis.c:createClient` adds a file event on the _connected descriptor_ through a call to `ae.c:aeCreateFileEvent` like below:
+
+    if (aeCreateFileEvent(server.el, c->fd, AE_READABLE,
+        readQueryFromClient, c) == AE_ERR) {
+        freeClient(c);
+        return NULL;
+    }
+
+`c` is the `redisClient` structure variable and `c->fd` is the connected descriptor.
+
+Next the `ae.c:aeProcessEvent` calls `ae.c:processTimeEvents`
+
+`processTimeEvents`
+---
+
+`ae.processTimeEvents` iterates over list of time events starting at `eventLoop->timeEventHead`.
+
+For every timed event that has elapsed `processTimeEvents` calls the registered callback. In this case it calls the only timed event callback registered, that is, `redis.c:serverCron`. The callback returns the time in milliseconds after which the callback must be called again. This change is recorded via a call to `ae.c:aeAddMilliSeconds` and will be handled on the next iteration of `ae.c:aeMain` while loop.
+
+That's all.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: A design for the RDB format written in the early days of Redis
+linkTitle: Redis design draft
+title: 'Redis design draft #2 (historical)'
+weight: 2
+---
+
+**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](https://github.com/redis/redis/issues/1048)
+
+### History of revisions
+
+1.0, 10 April 2013 - Initial draft.
+
+### Overview
+
+The Redis RDB format lacks a simple way to add info fields to an RDB file
+without causing a backward compatibility issue even if the added meta data
+is not required in order to load data from the RDB file.
+
+For example thanks to the info fields specified in this document it will
+be possible to add to RDB information like file creation time, Redis version
+generating the file, and any other useful information, in a way that not
+every field is required for an RDB version 7 file to be correctly processed.
+
+Also with minimal changes it will be possible to add RDB version 7 support to
+Redis 2.6 without actually supporting the additional fields but just skipping
+them when loading an RDB file.
+
+RDB info fields may have semantic meaning if needed, so that the presence
+of the field may add information about the data set specified in the RDB
+file format, however when an info field is required to be correctly decoded
+in order to understand and load the data set content of the RDB file, the
+RDB file format must be increased so that previous versions of Redis will not
+attempt to load it.
+
+However currently the info fields are designed to only hold additional
+information that are not useful to load the dataset, but can better specify
+how the RDB file was created.
+
+### Info fields representation
+
+The RDB format 6 has the following layout:
+
+* A 9 bytes magic "REDIS0006"
+* key-value pairs
+* An EOF opcode
+* CRC64 checksum
+
+The proposal for RDB format 7 is to add the optional fields immediately
+after the first 9 bytes magic, so that the new format will be:
+
+* A 9 bytes magic "REDIS0007"
+* Info field 1
+* Info field 2
+* ...
+* Info field N
+* Info field end-of-fields
+* key-value pairs
+* An EOF opcode
+* CRC64 checksum
+
+Every single info field has the following structure:
+
+* A 16 bit identifier
+* A 64 bit data length
+* A data section of the exact length as specified
+
+Both the identifier and the data length are stored in little endian byte
+ordering.
+
+The special identifier 0 means that there are no other info fields, and that
+the remaining of the RDB file contains the key-value pairs.
+
+### Handling of info fields
+
+A program can simply skip every info field it does not understand, as long
+as the RDB version matches the one that it is capable to load.
+
+### Specification of info fields IDs and content.
+
+#### Info field 0 -- End of info fields
+
+This just means there are no longer info fields to process.
+
+#### Info field 1 -- Creation date
+
+This field represents the unix time at which the RDB file was created.
+The format of the unix time is a 64 bit little endian integer representing
+seconds since 1th January 1970.
+
+#### Info field 2 -- Redis version
+
+This field represents a null-terminated string containing the Redis version
+that generated the file, as displayed in the Redis version INFO field.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: Documents describing internals in early Redis implementations
+linkTitle: Internals
+title: Redis internals
+weight: 12
+---
+
+**The following Redis documents were written by the creator of Redis, Salvatore Sanfilippo, early in the development of Redis (c. 2010), and do not necessarily reflect the latest Redis implementation.**
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: How Redis handles common Unix signals
+linkTitle: Signal handling
+title: Redis signal handling
+weight: 8
+---
+
+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`](/commands/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.
+
+If the server is blocked by a long-running Lua script,
+kill the script with [`SCRIPT KILL`](/commands/script-kill) if possible. The scheduled shutdown will
+run just after the script is killed or terminates spontaneously.
+
+This shutdown process includes the following actions:
+
+* If there are any replicas lagging behind in replication:
+  * Pause clients attempting to write with [`CLIENT PAUSE`](/commands/client-pause) and the `WRITE` option.
+  * Wait up to the configured `shutdown-timeout` (default 10 seconds) for replicas to catch up with the master's replication offset.
+* If a background child is saving the RDB file or performing an AOF rewrite, the child process is killed.
+* If the AOF is active, Redis calls the `fsync` system call on the AOF file descriptor to flush the buffers on disk.
+* If Redis is configured to persist on disk using RDB files, a synchronous (blocking) save is performed. Since the save is synchronous, it doesn't use any additional memory.
+* If the server is daemonized, the PID file is removed.
+* If the Unix domain socket is enabled, it gets removed.
+* The server exits with an exit code of zero.
+
+IF the RDB file can't be saved, the shutdown fails, and the server continues to run in order to ensure no data loss.
+Likewise, if the user just turned on AOF, and the server triggered the first AOF rewrite in order to create the initial AOF file but this file can't be saved, the shutdown fails and the server continues to run.
+Since Redis 2.6.11, no further attempt to shut down will be made unless a new `SIGTERM` is received or the [`SHUTDOWN`](/commands/shutdown) command is issued.
+
+Since Redis 7.0, the server waits for lagging replicas up to a configurable `shutdown-timeout`, 10 seconds by default, before shutting down.
+This provides a best effort to minimize the risk of data loss in a situation where no save points are configured and AOF is deactivated.
+Before version 7.0, shutting down a heavily loaded master node in a diskless setup was more likely to result in data loss.
+To minimize the risk of data loss in such setups, trigger a manual [`FAILOVER`](/commands/failover) (or [`CLUSTER FAILOVER`](/commands/cluster-failover)) to demote the master to a replica and promote one of the replicas to a new master before shutting down a master node.
+
+## SIGSEGV, SIGBUS, SIGFPE and SIGILL
+
+The following signals are handled as a Redis crash:
+
+* SIGSEGV
+* SIGBUS
+* SIGFPE
+* SIGILL
+
+Once one of these signals is trapped, Redis stops any current operation and performs the following actions:
+
+* Adds a bug report to the log file. This includes a stack trace, dump of registers, and information about the state of clients.
+* Since Redis 2.8, a fast memory test is performed as a first check of the reliability of the crashing system.
+* If the server was daemonized, the PID file is removed.
+* Finally the server unregisters its own signal handler for the received signal and resends the same signal to itself to make sure that the default action is performed, such as dumping the core on the file system.
+
+## What happens when a child process gets killed
+
+When the child performing the Append Only File rewrite gets killed by a signal,
+Redis handles this as an error and discards the (probably partial or corrupted)
+AOF file. It will attempt the rewrite again later.
+
+When the child performing an RDB save is killed, Redis handles the
+condition as a more severe error. While the failure of an
+AOF file rewrite can cause AOF file enlargement, failed RDB file
+creation reduces durability.
+
+As a result of the child producing the RDB file being killed by a signal,
+or when the child exits with an error (non zero exit code), Redis enters
+a special error condition where no further write command is accepted.
+
+* Redis will continue to reply to read commands.
+* Redis will reply to all write commands with a `MISCONFIG` error.
+
+This error condition will persist until it becomes possible to create an RDB file successfully.
+
+## Kill the RDB file without errors
+
+Sometimes the user may want to kill the RDB-saving child process without
+generating an error. Since Redis version 2.6.10, this can be done using the signal `SIGUSR1`. This signal is handled in a special way:
+it kills the child process like any other signal, but the parent process will
+not detect this as a critical error and will continue to serve write
+requests.
+---
+categories:
+- docs
+- operate
+- stack
+- oss
+description: 'Detailed specification for Redis cluster
+
+  '
+linkTitle: Cluster spec
+title: Redis cluster specification
+weight: 9
+---
+
+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:
+
+* High performance and linear scalability up to 1000 nodes. There are no proxies, asynchronous replication is used, and no merge operations are performed on values.
+* Acceptable degree of write safety: the system tries (in a best-effort way) to retain all the writes originating from clients connected with the majority of the master nodes. Usually there are small windows where acknowledged writes can be lost. Windows to lose acknowledged writes are larger when clients are in a minority partition.
+* Availability: Redis Cluster is able to survive partitions where the majority of the master nodes are reachable and there is at least one reachable replica for every master node that is no longer reachable. Moreover using *replicas migration*, masters no longer replicated by any replica will receive one from a master which is covered by multiple replicas.
+
+What is described in this document is implemented in Redis 3.0 or greater.
+
+### Implemented subset
+
+Redis Cluster implements all the single key commands available in the
+non-distributed version of Redis. Commands performing complex multi-key
+operations like set unions and intersections are implemented for cases where
+all of the keys involved in the operation hash to the same slot.
+
+Redis Cluster implements a concept called **hash tags** that can be used
+to force certain keys to be stored in the same hash slot. However, during
+manual resharding, multi-key operations may become unavailable for some time
+while single-key operations are always available.
+
+Redis Cluster does not support multiple databases like the standalone version
+of Redis. We only support database `0`; the [`SELECT`](/commands/select) command is not allowed.
+
+## Client and Server roles in the Redis cluster protocol
+
+In Redis Cluster, nodes are responsible for holding the data,
+and taking the state of the cluster, including mapping keys to the right nodes.
+Cluster nodes are also able to auto-discover other nodes, detect non-working
+nodes, and promote replica nodes to master when needed in order
+to continue to operate when a failure occurs.
+
+To perform their tasks all the cluster nodes are connected using a
+TCP bus and a binary protocol, called the **Redis Cluster Bus**.
+Every node is connected to every other node in the cluster using the cluster
+bus. Nodes use a gossip protocol to propagate information about the cluster
+in order to discover new nodes, to send ping packets to make sure all the
+other nodes are working properly, and to send cluster messages needed to
+signal specific conditions. The cluster bus is also used in order to
+propagate Pub/Sub messages across the cluster and to orchestrate manual
+failovers when requested by users (manual failovers are failovers which
+are not initiated by the Redis Cluster failure detector, but by the
+system administrator directly).
+
+Since cluster nodes are not able to proxy requests, clients may be redirected
+to other nodes using redirection errors `-MOVED` and `-ASK`.
+The client is in theory free to send requests to all the nodes in the cluster,
+getting redirected if needed, so the client is not required to hold the
+state of the cluster. However clients that are able to cache the map between
+keys and nodes can improve the performance in a sensible way.
+
+### Write safety
+
+Redis Cluster uses asynchronous replication between nodes, and **last failover wins** implicit merge function. This means that the last elected master dataset eventually replaces all the other replicas. There is always a window of time when it is possible to lose writes during partitions. However these windows are very different in the case of a client that is connected to the majority of masters, and a client that is connected to the minority of masters.
+
+Redis Cluster tries harder to retain writes that are performed by clients connected to the majority of masters, compared to writes performed in the minority side.
+The following are examples of scenarios that lead to loss of acknowledged
+writes received in the majority partitions during failures:
+
+1. A write may reach a master, but while the master may be able to reply to the client, the write may not be propagated to replicas via the asynchronous replication used between master and replica nodes. If the master dies without the write reaching the replicas, the write is lost forever if the master is unreachable for a long enough period that one of its replicas is promoted. This is usually hard to observe in the case of a total, sudden failure of a master node since masters try to reply to clients (with the acknowledge of the write) and replicas (propagating the write) at about the same time. However it is a real world failure mode.
+
+2. Another theoretically possible failure mode where writes are lost is the following:
+
+* A master is unreachable because of a partition.
+* It gets failed over by one of its replicas.
+* After some time it may be reachable again.
+* A client with an out-of-date routing table may write to the old master before it is converted into a replica (of the new master) by the cluster.
+
+The second failure mode is unlikely to happen because master nodes unable to communicate with the majority of the other masters for enough time to be failed over will no longer accept writes, and when the partition is fixed writes are still refused for a small amount of time to allow other nodes to inform about configuration changes. This failure mode also requires that the client's routing table has not yet been updated.
+
+Writes targeting the minority side of a partition have a larger window in which to get lost. For example, Redis Cluster loses a non-trivial number of writes on partitions where there is a minority of masters and at least one or more clients, since all the writes sent to the masters may potentially get lost if the masters are failed over in the majority side.
+
+Specifically, for a master to be failed over it must be unreachable by the majority of masters for at least `NODE_TIMEOUT`, so if the partition is fixed before that time, no writes are lost. When the partition lasts for more than `NODE_TIMEOUT`, all the writes performed in the minority side up to that point may be lost. However the minority side of a Redis Cluster will start refusing writes as soon as `NODE_TIMEOUT` time has elapsed without contact with the majority, so there is a maximum window after which the minority becomes no longer available. Hence, no writes are accepted or lost after that time.
+
+### Availability
+
+Redis Cluster is not available in the minority side of the partition. In the majority side of the partition assuming that there are at least the majority of masters and a replica for every unreachable master, the cluster becomes available again after `NODE_TIMEOUT` time plus a few more seconds required for a replica to get elected and failover its master (failovers are usually executed in a matter of 1 or 2 seconds).
+
+This means that Redis Cluster is designed to survive failures of a few nodes in the cluster, but it is not a suitable solution for applications that require availability in the event of large net splits.
+
+In the example of a cluster composed of N master nodes where every node has a single replica, the majority side of the cluster will remain available as long as a single node is partitioned away, and will remain available with a probability of `1-(1/(N*2-1))` when two nodes are partitioned away (after the first node fails we are left with `N*2-1` nodes in total, and the probability of the only master without a replica to fail is `1/(N*2-1))`.
+
+For example, in a cluster with 5 nodes and a single replica per node, there is a `1/(5*2-1) = 11.11%` probability that after two nodes are partitioned away from the majority, the cluster will no longer be available.
+
+Thanks to a Redis Cluster feature called **replicas migration** the Cluster
+availability is improved in many real world scenarios by the fact that
+replicas migrate to orphaned masters (masters no longer having replicas).
+So at every successful failure event, the cluster may reconfigure the replicas
+layout in order to better resist the next failure.
+
+### Performance
+
+In Redis Cluster nodes don't proxy commands to the right node in charge for a given key, but instead they redirect clients to the right nodes serving a given portion of the key space.
+
+Eventually clients obtain an up-to-date representation of the cluster and which node serves which subset of keys, so during normal operations clients directly contact the right nodes in order to send a given command.
+
+Because of the use of asynchronous replication, nodes do not wait for other nodes' acknowledgment of writes (if not explicitly requested using the [`WAIT`](/commands/wait) command).
+
+Also, because multi-key commands are only limited to *near* keys, data is never moved between nodes except when resharding.
+
+Normal operations are handled exactly as in the case of a single Redis instance. This means that in a Redis Cluster with N master nodes you can expect the same performance as a single Redis instance multiplied by N as the design scales linearly. At the same time the query is usually performed in a single round trip, since clients usually retain persistent connections with the nodes, so latency figures are also the same as the single standalone Redis node case.
+
+Very high performance and scalability while preserving weak but
+reasonable forms of data safety and availability is the main goal of
+Redis Cluster.
+
+### Why merge operations are avoided
+
+The Redis Cluster design avoids conflicting versions of the same key-value pair in multiple nodes as in the case of the Redis data model this is not always desirable. Values in Redis are often very large; it is common to see lists or sorted sets with millions of elements. Also data types are semantically complex. Transferring and merging these kind of values can be a major bottleneck and/or may require the non-trivial involvement of application-side logic, additional memory to store meta-data, and so forth.
+
+There are no strict technological limits here. CRDTs or synchronously replicated
+state machines can model complex data types similar to Redis. However, the
+actual run time behavior of such systems would not be similar to Redis Cluster.
+Redis Cluster was designed in order to cover the exact use cases of the
+non-clustered Redis version.
+
+## Overview of Redis Cluster main components
+
+### Key distribution model
+
+The cluster's key space is split into 16384 slots, effectively setting an upper limit
+for the cluster size of 16384 master nodes (however, the suggested max size of
+nodes is on the order of ~ 1000 nodes).
+
+Each master node in a cluster handles a subset of the 16384 hash slots.
+The cluster is **stable** when there is no cluster reconfiguration in
+progress (i.e. where hash slots are being moved from one node to another).
+When the cluster is stable, a single hash slot will be served by a single node
+(however the serving node can have one or more replicas that will replace it in the case of net splits or failures,
+and that can be used in order to scale read operations where reading stale data is acceptable).
+
+The base algorithm used to map keys to hash slots is the following
+(read the next paragraph for the hash tag exception to this rule):
+
+    HASH_SLOT = CRC16(key) mod 16384
+
+The CRC16 is specified as follows:
+
+* Name: XMODEM (also known as ZMODEM or CRC-16/ACORN)
+* Width: 16 bit
+* Poly: 1021 (That is actually x^16 + x^12 + x^5 + 1)
+* Initialization: 0000
+* Reflect Input byte: False
+* Reflect Output CRC: False
+* Xor constant to output CRC: 0000
+* Output for "123456789": 31C3
+
+14 out of 16 CRC16 output bits are used (this is why there is
+a modulo 16384 operation in the formula above).
+
+In our tests CRC16 behaved remarkably well in distributing different kinds of
+keys evenly across the 16384 slots.
+
+**Note**: A reference implementation of the CRC16 algorithm used is available in the Appendix A of this document.
+
+### Hash tags
+
+There is an exception for the computation of the hash slot that is used in order
+to implement **hash tags**. Hash tags are a way to ensure that multiple keys
+are allocated in the same hash slot. This is used in order to implement
+multi-key operations in Redis Cluster.
+
+To implement hash tags, the hash slot for a key is computed in a
+slightly different way in certain conditions.
+If the key contains a "{...}" pattern only the substring between
+`{` and `}` is hashed in order to obtain the hash slot. However since it is
+possible that there are multiple occurrences of `{` or `}` the algorithm is
+well specified by the following rules:
+
+* IF the key contains a `{` character.
+* AND IF there is a `}` character to the right of `{`.
+* AND IF there are one or more characters between the first occurrence of `{` and the first occurrence of `}`.
+
+Then instead of hashing the key, only what is between the first occurrence of `{` and the following first occurrence of `}` is hashed.
+
+Examples:
+
+* The two keys `{user1000}.following` and `{user1000}.followers` will hash to the same hash slot since only the substring `user1000` will be hashed in order to compute the hash slot.
+* For the key `foo{}{bar}` the whole key will be hashed as usual since the first occurrence of `{` is followed by `}` on the right without characters in the middle.
+* For the key `foo{{bar}}zap` the substring `{bar` will be hashed, because it is the substring between the first occurrence of `{` and the first occurrence of `}` on its right.
+* For the key `foo{bar}{zap}` the substring `bar` will be hashed, since the algorithm stops at the first valid or invalid (without bytes inside) match of `{` and `}`.
+* What follows from the algorithm is that if the key starts with `{}`, it is guaranteed to be hashed as a whole. This is useful when using binary data as key names.
+
+#### Glob-style patterns
+
+Commands accepting a glob-style pattern, including [`KEYS`](/commands/keys), [`SCAN`](/commands/scan) and [`SORT`](/commands/sort), are optimized for patterns that imply a single slot.
+This means that if all keys that can match a pattern must belong to a specific slot, only this slot is searched for keys matching the pattern.
+The pattern slot optimization is introduced in Redis 8.0.
+
+The optimization kicks in when the pattern meets the following conditions:
+
+* the pattern contains a hashtag,
+* there are no wildcards or escape characters before the hashtag, and
+* the hashtag within curly braces doesn't contain any wildcards or escape characters.
+
+For example, `SCAN 0 MATCH {abc}*` can successfully recognize the hashtag and scans only the slot corresponding to `abc`.
+However, the patterns `*{abc}`, `{a*c}`, or `{a\*bc}` cannot recognize the hashtag, so all slots need to be scanned.
+
+#### Hash slot example code
+
+Adding the hash tags exception, the following is an implementation of the `HASH_SLOT` function in Ruby and C language.
+
+Ruby example code:
+
+    def HASH_SLOT(key)
+        s = key.index "{"
+        if s
+            e = key.index "}",s+1
+            if e && e != s+1
+                key = key[s+1..e-1]
+            end
+        end
+        crc16(key) % 16384
+    end
+
+C example code:
+
+    unsigned int HASH_SLOT(char *key, int keylen) {
+        int s, e; /* start-end indexes of { and } */
+
+        /* Search the first occurrence of '{'. */
+        for (s = 0; s < keylen; s++)
+            if (key[s] == '{') break;
+
+        /* No '{' ? Hash the whole key. This is the base case. */
+        if (s == keylen) return crc16(key,keylen) & 16383;
+
+        /* '{' found? Check if we have the corresponding '}'. */
+        for (e = s+1; e < keylen; e++)
+            if (key[e] == '}') break;
+
+        /* No '}' or nothing between {} ? Hash the whole key. */
+        if (e == keylen || e == s+1) return crc16(key,keylen) & 16383;
+
+        /* If we are here there is both a { and a } on its right. Hash
+         * what is in the middle between { and }. */
+        return crc16(key+s+1,e-s-1) & 16383;
+    }
+
+### Cluster node attributes
+
+Every node has a unique name in the cluster. The node name is the
+hex representation of a 160 bit random number, obtained the first time a
+node is started (usually using /dev/urandom).
+The node will save its ID in the node configuration file, and will use the
+same ID forever, or at least as long as the node configuration file is not
+deleted by the system administrator, or a *hard reset* is requested
+via the [`CLUSTER RESET`](/commands/cluster-reset) command.
+
+The node ID is used to identify every node across the whole cluster.
+It is possible for a given node to change its IP address without any need
+to also change the node ID. The cluster is also able to detect the change
+in IP/port and reconfigure using the gossip protocol running over the cluster
+bus.
+
+The node ID is not the only information associated with each node, but is
+the only one that is always globally consistent. Every node has also the
+following set of information associated. Some information is about the
+cluster configuration detail of this specific node, and is eventually
+consistent across the cluster. Some other information, like the last time
+a node was pinged, is instead local to each node.
+
+Every node maintains the following information about other nodes that it is
+aware of in the cluster: The node ID, IP and port of the node, a set of
+flags, what is the master of the node if it is flagged as `replica`, last time
+the node was pinged and the last time the pong was received, the current
+*configuration epoch* of the node (explained later in this specification),
+the link state and finally the set of hash slots served.
+
+A detailed [explanation of all the node fields]({{< relref "/commands/cluster-nodes" >}}) is described in the [`CLUSTER NODES`](/commands/cluster-nodes) documentation.
+
+The [`CLUSTER NODES`](/commands/cluster-nodes) command can be sent to any node in the cluster and provides the state of the cluster and the information for each node according to the local view the queried node has of the cluster.
+
+The following is sample output of the [`CLUSTER NODES`](/commands/cluster-nodes) command sent to a master
+node in a small cluster of three nodes.
+
+    $ redis-cli cluster nodes
+    d1861060fe6a534d42d8a19aeb36600e18785e04 127.0.0.1:6379 myself - 0 1318428930 1 connected 0-1364
+    3886e65cc906bfd9b1f7e7bde468726a052d1dae 127.0.0.1:6380 master - 1318428930 1318428931 2 connected 1365-2729
+    d289c575dcbc4bdd2931585fd4339089e461a27d 127.0.0.1:6381 master - 1318428931 1318428931 3 connected 2730-4095
+
+In the above listing the different fields are in order: node id, address:port, flags, last ping sent, last pong received, configuration epoch, link state, slots. Details about the above fields will be covered as soon as we talk of specific parts of Redis Cluster.
+
+### The cluster bus
+
+Every Redis Cluster node has an additional TCP port for receiving
+incoming connections from other Redis Cluster nodes. This port will be derived by adding 10000 to the data port or it can be specified with the cluster-port config. 
+
+Example 1:
+
+If a Redis node is listening for client connections on port 6379, 
+and you do not add cluster-port parameter in redis.conf,
+the Cluster bus port 16379 will be opened.
+
+Example 2:
+
+If a Redis node is listening for client connections on port 6379, 
+and you set cluster-port 20000 in redis.conf,
+the Cluster bus port 20000 will be opened.
+
+Node-to-node communication happens exclusively using the Cluster bus and
+the Cluster bus protocol: a binary protocol composed of frames
+of different types and sizes. The Cluster bus binary protocol is not
+publicly documented since it is not intended for external software devices
+to talk with Redis Cluster nodes using this protocol. However you can
+obtain more details about the Cluster bus protocol by reading the
+`cluster.h` and `cluster.c` files in the Redis Cluster source code.
+
+### Cluster topology
+
+Redis Cluster is a full mesh where every node is connected with every other node using a TCP connection.
+
+In a cluster of N nodes, every node has N-1 outgoing TCP connections, and N-1 incoming connections.
+
+These TCP connections are kept alive all the time and are not created on demand.
+When a node expects a pong reply in response to a ping in the cluster bus, before waiting long enough to mark the node as unreachable, it will try to
+refresh the connection with the node by reconnecting from scratch.
+
+While Redis Cluster nodes form a full mesh, **nodes use a gossip protocol and
+a configuration update mechanism in order to avoid exchanging too many
+messages between nodes during normal conditions**, so the number of messages
+exchanged is not exponential.
+
+### Node handshake
+
+Nodes always accept connections on the cluster bus port, and even reply to
+pings when received, even if the pinging node is not trusted.
+However, all other packets will be discarded by the receiving node if the
+sending node is not considered part of the cluster.
+
+A node will accept another node as part of the cluster only in two ways:
+
+* If a node presents itself with a `MEET` message ([`CLUSTER MEET`](/commands/cluster-meet) command). A meet message is exactly
+like a [`PING`](/commands/ping) message, but forces the receiver to accept the node as part of
+the cluster. Nodes will send `MEET` messages to other nodes **only if** the system administrator requests this via the following command:
+
+    CLUSTER MEET ip port
+
+* A node will also register another node as part of the cluster if a node that is already trusted will gossip about this other node. So if A knows B, and B knows C, eventually B will send gossip messages to A about C. When this happens, A will register C as part of the network, and will try to connect with C.
+
+This means that as long as we join nodes in any connected graph, they'll eventually form a fully connected graph automatically. This means that the cluster is able to auto-discover other nodes, but only if there is a trusted relationship that was forced by the system administrator.
+
+This mechanism makes the cluster more robust but prevents different Redis clusters from accidentally mixing after change of IP addresses or other network related events.
+
+## Redirection and resharding
+
+### MOVED Redirection
+
+A Redis client is free to send queries to every node in the cluster, including
+replica nodes. The node will analyze the query, and if it is acceptable
+(that is, only a single key is mentioned in the query, or the multiple keys
+mentioned are all to the same hash slot) it will lookup what
+node is responsible for the hash slot where the key or keys belong.
+
+If the hash slot is served by the node, the query is simply processed, otherwise
+the node will check its internal hash slot to node map, and will reply
+to the client with a MOVED error, like in the following example:
+
+    GET x
+    -MOVED 3999 127.0.0.1:6381
+
+The error includes the hash slot of the key (3999) and the endpoint:port of the instance that can serve the query.
+The client needs to reissue the query to the specified node's endpoint address and port. 
+The endpoint can be either an IP address, a hostname, or it can be empty (e.g. `-MOVED 3999 :6380`). 
+An empty endpoint indicates that the server node has an unknown endpoint, and the client should send the next request to the same endpoint as the current request but with the provided port. 
+
+Note that even if the client waits a long time before reissuing the query,
+and in the meantime the cluster configuration changed, the destination node
+will reply again with a MOVED error if the hash slot 3999 is now served by
+another node. The same happens if the contacted node had no updated information.
+
+So while from the point of view of the cluster nodes are identified by
+IDs we try to simplify our interface with the client just exposing a map
+between hash slots and Redis nodes identified by endpoint:port pairs.
+
+The client is not required to, but should try to memorize that hash slot
+3999 is served by 127.0.0.1:6381. This way once a new command needs to
+be issued it can compute the hash slot of the target key and have a
+greater chance of choosing the right node.
+
+An alternative is to just refresh the whole client-side cluster layout
+using the [`CLUSTER SHARDS`](/commands/cluster-shards), or the deprecated [`CLUSTER SLOTS`](/commands/cluster-slots), command
+when a MOVED redirection is received. When a redirection is encountered, it
+is likely multiple slots were reconfigured rather than just one, so updating
+the client configuration as soon as possible is often the best strategy.
+
+Note that when the Cluster is stable (no ongoing changes in the configuration),
+eventually all the clients will obtain a map of hash slots -> nodes, making
+the cluster efficient, with clients directly addressing the right nodes
+without redirections, proxies or other single point of failure entities.
+
+A client **must be also able to handle -ASK redirections** that are described
+later in this document, otherwise it is not a complete Redis Cluster client.
+
+### Live reconfiguration
+
+Redis Cluster supports the ability to add and remove nodes while the cluster
+is running. Adding or removing a node is abstracted into the same
+operation: moving a hash slot from one node to another. This means
+that the same basic mechanism can be used in order to rebalance the cluster, add
+or remove nodes, and so forth.
+
+* To add a new node to the cluster an empty node is added to the cluster and some set of hash slots are moved from existing nodes to the new node.
+* To remove a node from the cluster the hash slots assigned to that node are moved to other existing nodes.
+* To rebalance the cluster a given set of hash slots are moved between nodes.
+
+The core of the implementation is the ability to move hash slots around.
+From a practical point of view a hash slot is just a set of keys, so
+what Redis Cluster really does during *resharding* is to move keys from
+an instance to another instance. Moving a hash slot means moving all the keys
+that happen to hash into this hash slot.
+
+To understand how this works we need to show the [`CLUSTER`](/commands/cluster) subcommands
+that are used to manipulate the slots translation table in a Redis Cluster node.
+
+The following subcommands are available (among others not useful in this case):
+
+* [`CLUSTER ADDSLOTS`](/commands/cluster-addslots) slot1 [slot2] ... [slotN]
+* [`CLUSTER DELSLOTS`](/commands/cluster-delslots) slot1 [slot2] ... [slotN]
+* [`CLUSTER ADDSLOTSRANGE`](/commands/cluster-addslotsrange) start-slot1 end-slot1 [start-slot2 end-slot2] ... [start-slotN end-slotN]
+* [`CLUSTER DELSLOTSRANGE`](/commands/cluster-delslotsrange) start-slot1 end-slot1 [start-slot2 end-slot2] ... [start-slotN end-slotN]
+* [`CLUSTER SETSLOT`](/commands/cluster-setslot) slot NODE node
+* [`CLUSTER SETSLOT`](/commands/cluster-setslot) slot MIGRATING node
+* [`CLUSTER SETSLOT`](/commands/cluster-setslot) slot IMPORTING node
+
+The first four commands, `ADDSLOTS`, `DELSLOTS`, `ADDSLOTSRANGE` and `DELSLOTSRANGE`, are simply used to assign
+(or remove) slots to a Redis node. Assigning a slot means to tell a given
+master node that it will be in charge of storing and serving content for
+the specified hash slot.
+
+After the hash slots are assigned they will propagate across the cluster
+using the gossip protocol, as specified later in the
+*configuration propagation* section.
+
+The `ADDSLOTS` and `ADDSLOTSRANGE` commands are usually used when a new cluster is created
+from scratch to assign each master node a subset of all the 16384 hash
+slots available.
+
+The `DELSLOTS`  and `DELSLOTSRANGE` are mainly used for manual modification of a cluster configuration
+or for debugging tasks: in practice it is rarely used.
+
+The `SETSLOT` subcommand is used to assign a slot to a specific node ID if
+the `SETSLOT <slot> NODE` form is used. Otherwise the slot can be set in the
+two special states `MIGRATING` and `IMPORTING`. Those two special states
+are used in order to migrate a hash slot from one node to another.
+
+* When a slot is set as MIGRATING, the node will accept all queries that
+are about this hash slot, but only if the key in question
+exists, otherwise the query is forwarded using a `-ASK` redirection to the
+node that is target of the migration.
+* When a slot is set as IMPORTING, the node will accept all queries that
+are about this hash slot, but only if the request is
+preceded by an [`ASKING`](/commands/asking) command. If the [`ASKING`](/commands/asking) command was not given
+by the client, the query is redirected to the real hash slot owner via
+a `-MOVED` redirection error, as would happen normally.
+
+Let's make this clearer with an example of hash slot migration.
+Assume that we have two Redis master nodes, called A and B.
+We want to move hash slot 8 from A to B, so we issue commands like this:
+
+* We send B: CLUSTER SETSLOT 8 IMPORTING A
+* We send A: CLUSTER SETSLOT 8 MIGRATING B
+
+All the other nodes will continue to point clients to node "A" every time
+they are queried with a key that belongs to hash slot 8, so what happens
+is that:
+
+* All queries about existing keys are processed by "A".
+* All queries about non-existing keys in A are processed by "B", because "A" will redirect clients to "B".
+
+This way we no longer create new keys in "A".
+In the meantime, `redis-cli` used during reshardings
+and Redis Cluster configuration will migrate existing keys in
+hash slot 8 from A to B.
+This is performed using the following command:
+
+    CLUSTER GETKEYSINSLOT slot count
+
+The above command will return `count` keys in the specified hash slot.
+For keys returned, `redis-cli` sends node "A" a [`MIGRATE`](/commands/migrate) command, that
+will migrate the specified keys from A to B in an atomic way (both instances
+are locked for the time (usually very small time) needed to migrate keys so
+there are no race conditions). This is how [`MIGRATE`](/commands/migrate) works:
+
+    MIGRATE target_host target_port "" target_database id timeout KEYS key1 key2 ...
+
+[`MIGRATE`](/commands/migrate) will connect to the target instance, send a serialized version of
+the key, and once an OK code is received, the old key from its own dataset
+will be deleted. From the point of view of an external client a key exists
+either in A or B at any given time.
+
+In Redis Cluster there is no need to specify a database other than 0, but
+[`MIGRATE`](/commands/migrate) is a general command that can be used for other tasks not
+involving Redis Cluster.
+[`MIGRATE`](/commands/migrate) is optimized to be as fast as possible even when moving complex
+keys such as long lists, but in Redis Cluster reconfiguring the
+cluster where big keys are present is not considered a wise procedure if
+there are latency constraints in the application using the database.
+
+When the migration process is finally finished, the `SETSLOT <slot> NODE <node-id>` command is sent to the two nodes involved in the migration in order to
+set the slots to their normal state again. The same command is usually
+sent to all other nodes to avoid waiting for the natural
+propagation of the new configuration across the cluster.
+
+### ASK redirection
+
+In the previous section, we briefly talked about ASK redirection. Why can't
+we simply use MOVED redirection? Because while MOVED means that
+we think the hash slot is permanently served by a different node and the
+next queries should be tried against the specified node. ASK means to
+send only the next query to the specified node.
+
+This is needed because the next query about hash slot 8 can be about a
+key that is still in A, so we always want the client to try A and
+then B if needed. Since this happens only for one hash slot out of 16384
+available, the performance hit on the cluster is acceptable.
+
+We need to force that client behavior, so to make sure
+that clients will only try node B after A was tried, node B will only
+accept queries of a slot that is set as IMPORTING if the client sends the
+ASKING command before sending the query.
+
+Basically the ASKING command sets a one-time flag on the client that forces
+a node to serve a query about an IMPORTING slot.
+
+The full semantics of ASK redirection from the point of view of the client is as follows:
+
+* If ASK redirection is received, send only the query that was redirected to the specified node but continue sending subsequent queries to the old node.
+* Start the redirected query with the ASKING command.
+* Don't yet update local client tables to map hash slot 8 to B.
+
+Once hash slot 8 migration is completed, A will send a MOVED message and
+the client may permanently map hash slot 8 to the new endpoint and port pair.
+Note that if a buggy client performs the map earlier this is not
+a problem since it will not send the ASKING command before issuing the query,
+so B will redirect the client to A using a MOVED redirection error.
+
+Slots migration is explained in similar terms but with different wording
+(for the sake of redundancy in the documentation) in the [`CLUSTER SETSLOT`](/commands/cluster-setslot)
+command documentation.
+
+### Client connections and redirection handling
+
+To be efficient, Redis Cluster clients maintain a map of the current slot
+configuration. However, this configuration is not *required* to be up to date.
+When contacting the wrong node results in a redirection, the client
+can update its internal slot map accordingly.
+
+Clients usually need to fetch a complete list of slots and mapped node
+addresses in two different situations:
+
+* At startup, to populate the initial slots configuration
+* When the client receives a `MOVED` redirection
+
+Note that a client may handle the `MOVED` redirection by updating just the
+moved slot in its table; however this is usually not efficient because often
+the configuration of multiple slots will be modified at once. For example, if a
+replica is promoted to master, all of the slots served by the old master will
+be remapped). It is much simpler to react to a `MOVED` redirection by
+fetching the full map of slots to nodes from scratch.
+
+Client can issue a [`CLUSTER SLOTS`](/commands/cluster-slots) command to retrieve an array of slot
+ranges and the associated master and replica nodes serving the specified ranges.
+
+The following is an example of output of [`CLUSTER SLOTS`](/commands/cluster-slots):
+
+```
+127.0.0.1:7000> cluster slots
+1) 1) (integer) 5461
+   2) (integer) 10922
+   3) 1) "127.0.0.1"
+      2) (integer) 7001
+   4) 1) "127.0.0.1"
+      2) (integer) 7004
+2) 1) (integer) 0
+   2) (integer) 5460
+   3) 1) "127.0.0.1"
+      2) (integer) 7000
+   4) 1) "127.0.0.1"
+      2) (integer) 7003
+3) 1) (integer) 10923
+   2) (integer) 16383
+   3) 1) "127.0.0.1"
+      2) (integer) 7002
+   4) 1) "127.0.0.1"
+      2) (integer) 7005
+```
+
+The first two sub-elements of every element of the returned array are the
+start and end slots of the range. The additional elements represent address-port
+pairs. The first address-port pair is the master serving the slot, and the
+additional address-port pairs are the replicas serving the same slot. Replicas
+will be listed only when not in an error condition (i.e., when their FAIL flag is not set).
+
+The first element in the output above says that slots from 5461 to 10922
+(start and end included) are served by 127.0.0.1:7001, and it is possible
+to scale read-only load contacting the replica at 127.0.0.1:7004.
+
+[`CLUSTER SLOTS`](/commands/cluster-slots) is not guaranteed to return ranges that cover the full
+16384 slots if the cluster is misconfigured, so clients should initialize the
+slots configuration map filling the target nodes with NULL objects, and
+report an error if the user tries to execute commands about keys
+that belong to unassigned slots.
+
+Before returning an error to the caller when a slot is found to
+be unassigned, the client should try to fetch the slots configuration
+again to check if the cluster is now configured properly.
+
+### Multi-keys operations
+
+Using hash tags, clients are free to use multi-key operations.
+For example the following operation is valid:
+
+    MSET {user:1000}.name Angela {user:1000}.surname White
+
+Multi-key operations may become unavailable when a resharding of the
+hash slot the keys belong to is in progress.
+
+More specifically, even during a resharding the multi-key operations targeting
+keys that all exist and all still hash to the same slot (either the source or
+destination node) are still available.
+
+Operations on keys that don't exist or are - during the resharding - split
+between the source and destination nodes, will generate a `-TRYAGAIN` error.
+The client can try the operation after some time, or report back the error.
+
+As soon as migration of the specified hash slot has terminated, all
+multi-key operations are available again for that hash slot.
+
+### Scaling reads using replica nodes
+
+Normally replica nodes will redirect clients to the authoritative master for
+the hash slot involved in a given command, however clients can use replicas
+in order to scale reads using the [`READONLY`](/commands/readonly) command.
+
+[`READONLY`](/commands/readonly) tells a Redis Cluster replica node that the client is ok reading
+possibly stale data and is not interested in running write queries.
+
+When the connection is in readonly mode, the cluster will send a redirection
+to the client only if the operation involves keys not served
+by the replica's master node. This may happen because:
+
+1. The client sent a command about hash slots never served by the master of this replica.
+2. The cluster was reconfigured (for example resharded) and the replica is no longer able to serve commands for a given hash slot.
+
+When this happens the client should update its hash slot map as explained in
+the previous sections.
+
+The readonly state of the connection can be cleared using the [`READWRITE`](/commands/readwrite) command.
+
+## Fault Tolerance
+
+### Heartbeat and gossip messages
+
+Redis Cluster nodes continuously exchange ping and pong packets. Those two kinds of packets have the same structure, and both carry important configuration information. The only actual difference is the message type field. We'll refer to the sum of ping and pong packets as *heartbeat packets*.
+
+Usually nodes send ping packets that will trigger the receivers to reply with pong packets. However this is not necessarily true. It is possible for nodes to just send pong packets to send information to other nodes about their configuration, without triggering a reply. This is useful, for example, in order to broadcast a new configuration as soon as possible.
+
+Usually a node will ping a few random nodes every second so that the total number of ping packets sent (and pong packets received) by each node is a constant amount regardless of the number of nodes in the cluster.
+
+However every node makes sure to ping every other node that hasn't sent a ping or received a pong for longer than half the `NODE_TIMEOUT` time. Before `NODE_TIMEOUT` has elapsed, nodes also try to reconnect the TCP link with another node to make sure nodes are not believed to be unreachable only because there is a problem in the current TCP connection.
+
+The number of messages globally exchanged can be sizable if `NODE_TIMEOUT` is set to a small figure and the number of nodes (N) is very large, since every node will try to ping every other node for which they don't have fresh information every half the `NODE_TIMEOUT` time.
+
+For example in a 100 node cluster with a node timeout set to 60 seconds, every node will try to send 99 pings every 30 seconds, with a total amount of pings of 3.3 per second. Multiplied by 100 nodes, this is 330 pings per second in the total cluster.
+
+There are ways to lower the number of messages, however there have been no
+reported issues with the bandwidth currently used by Redis Cluster failure
+detection, so for now the obvious and direct design is used. Note that even
+in the above example, the 330 packets per second exchanged are evenly
+divided among 100 different nodes, so the traffic each node receives
+is acceptable.
+
+### Heartbeat packet content
+
+Ping and pong packets contain a header that is common to all types of packets (for instance packets to request a failover vote), and a special gossip section that is specific to Ping and Pong packets.
+
+The common header has the following information:
+
+* Node ID, a 160 bit pseudorandom string that is assigned the first time a node is created and remains the same for all the life of a Redis Cluster node.
+* The `currentEpoch` and `configEpoch` fields of the sending node that are used to mount the distributed algorithms used by Redis Cluster (this is explained in detail in the next sections). If the node is a replica the `configEpoch` is the last known `configEpoch` of its master.
+* The node flags, indicating if the node is a replica, a master, and other single-bit node information.
+* A bitmap of the hash slots served by the sending node, or if the node is a replica, a bitmap of the slots served by its master.
+* The sender TCP base port that is the port used by Redis to accept client commands.
+* The cluster port that is the port used by Redis for node-to-node communication.
+* The state of the cluster from the point of view of the sender (down or ok).
+* The master node ID of the sending node, if it is a replica.
+
+Ping and pong packets also contain a gossip section. This section offers to the receiver a view of what the sender node thinks about other nodes in the cluster. The gossip section only contains information about a few random nodes among the set of nodes known to the sender. The number of nodes mentioned in a gossip section is proportional to the cluster size.
+
+For every node added in the gossip section the following fields are reported:
+
+* Node ID.
+* IP and port of the node.
+* Node flags.
+
+Gossip sections allow receiving nodes to get information about the state of other nodes from the point of view of the sender. This is useful both for failure detection and to discover other nodes in the cluster.
+
+### Failure detection
+
+Redis Cluster failure detection is used to recognize when a master or replica node is no longer reachable by the majority of nodes and then respond by promoting a replica to the role of master. When replica promotion is not possible the cluster is put in an error state to stop receiving queries from clients.
+
+As already mentioned, every node takes a list of flags associated with other known nodes. There are two flags that are used for failure detection that are called `PFAIL` and `FAIL`. `PFAIL` means *Possible failure*, and is a non-acknowledged failure type. `FAIL` means that a node is failing and that this condition was confirmed by a majority of masters within a fixed amount of time.
+
+**PFAIL flag:**
+
+A node flags another node with the `PFAIL` flag when the node is not reachable for more than `NODE_TIMEOUT` time. Both master and replica nodes can flag another node as `PFAIL`, regardless of its type.
+
+The concept of non-reachability for a Redis Cluster node is that we have an **active ping** (a ping that we sent for which we have yet to get a reply) pending for longer than `NODE_TIMEOUT`. For this mechanism to work the `NODE_TIMEOUT` must be large compared to the network round trip time. In order to add reliability during normal operations, nodes will try to reconnect with other nodes in the cluster as soon as half of the `NODE_TIMEOUT` has elapsed without a reply to a ping. This mechanism ensures that connections are kept alive so broken connections usually won't result in false failure reports between nodes.
+
+**FAIL flag:**
+
+The `PFAIL` flag alone is just local information every node has about other nodes, but it is not sufficient to trigger a replica promotion. For a node to be considered down the `PFAIL` condition needs to be escalated to a `FAIL` condition.
+
+As outlined in the node heartbeats section of this document, every node sends gossip messages to every other node including the state of a few random known nodes. Every node eventually receives a set of node flags for every other node. This way every node has a mechanism to signal other nodes about failure conditions they have detected.
+
+A `PFAIL` condition is escalated to a `FAIL` condition when the following set of conditions are met:
+
+* Some node, that we'll call A, has another node B flagged as `PFAIL`.
+* Node A collected, via gossip sections, information about the state of B from the point of view of the majority of masters in the cluster.
+* The majority of masters signaled the `PFAIL` or `FAIL` condition within `NODE_TIMEOUT * FAIL_REPORT_VALIDITY_MULT` time. (The validity factor is set to 2 in the current implementation, so this is just two times the `NODE_TIMEOUT` time).
+
+If all the above conditions are true, Node A will:
+
+* Mark the node as `FAIL`.
+* Send a `FAIL` message (as opposed to a `FAIL` condition within a heartbeat message) to all the reachable nodes.
+
+The `FAIL` message will force every receiving node to mark the node in `FAIL` state, whether or not it already flagged the node in `PFAIL` state.
+
+Note that *the FAIL flag is mostly one way*. That is, a node can go from `PFAIL` to `FAIL`, but a `FAIL` flag can only be cleared in the following situations:
+
+* The node is already reachable and is a replica. In this case the `FAIL` flag can be cleared as replicas are not failed over.
+* The node is already reachable and is a master not serving any slot. In this case the `FAIL` flag can be cleared as masters without slots do not really participate in the cluster and are waiting to be configured in order to join the cluster.
+* The node is already reachable and is a master, but a long time (N times the `NODE_TIMEOUT`) has elapsed without any detectable replica promotion. It's better for it to rejoin the cluster and continue in this case.
+
+It is useful to note that while the `PFAIL` -> `FAIL` transition uses a form of agreement, the agreement used is weak:
+
+1. Nodes collect views of other nodes over some time period, so even if the majority of master nodes need to "agree", actually this is just state that we collected from different nodes at different times and we are not sure, nor we require, that at a given moment the majority of masters agreed. However we discard failure reports which are old, so the failure was signaled by the majority of masters within a window of time.
+2. While every node detecting the `FAIL` condition will force that condition on other nodes in the cluster using the `FAIL` message, there is no way to ensure the message will reach all the nodes. For instance a node may detect the `FAIL` condition and because of a partition will not be able to reach any other node.
+
+However the Redis Cluster failure detection has a liveness requirement: eventually all the nodes should agree about the state of a given node. There are two cases that can originate from split brain conditions. Either some minority of nodes believe the node is in `FAIL` state, or a minority of nodes believe the node is not in `FAIL` state. In both the cases eventually the cluster will have a single view of the state of a given node:
+
+**Case 1**: If a majority of masters have flagged a node as `FAIL`, because of failure detection and the *chain effect* it generates, every other node will eventually flag the master as `FAIL`, since in the specified window of time enough failures will be reported.
+
+**Case 2**: When only a minority of masters have flagged a node as `FAIL`, the replica promotion will not happen (as it uses a more formal algorithm that makes sure everybody knows about the promotion eventually) and every node will clear the `FAIL` state as per the `FAIL` state clearing rules above (i.e. no promotion after N times the `NODE_TIMEOUT` has elapsed).
+
+**The `FAIL` flag is only used as a trigger to run the safe part of the algorithm** for the replica promotion. In theory a replica may act independently and start a replica promotion when its master is not reachable, and wait for the masters to refuse to provide the acknowledgment if the master is actually reachable by the majority. However the added complexity of the `PFAIL -> FAIL` state, the weak agreement, and the `FAIL` message forcing the propagation of the state in the shortest amount of time in the reachable part of the cluster, have practical advantages. Because of these mechanisms, usually all the nodes will stop accepting writes at about the same time if the cluster is in an error state. This is a desirable feature from the point of view of applications using Redis Cluster. Also erroneous election attempts initiated by replicas that can't reach its master due to local problems (the master is otherwise reachable by the majority of other master nodes) are avoided.
+
+## Configuration handling, propagation, and failovers
+
+### Cluster current epoch
+
+Redis Cluster uses a concept similar to the Raft algorithm "term". In Redis Cluster the term is called epoch instead, and it is used in order to give incremental versioning to events. When multiple nodes provide conflicting information, it becomes possible for another node to understand which state is the most up to date.
+
+The `currentEpoch` is a 64 bit unsigned number.
+
+At node creation every Redis Cluster node, both replicas and master nodes, set the `currentEpoch` to 0.
+
+Every time a packet is received from another node, if the epoch of the sender (part of the cluster bus messages header) is greater than the local node epoch, the `currentEpoch` is updated to the sender epoch.
+
+Because of these semantics, eventually all the nodes will agree to the greatest `currentEpoch` in the cluster.
+
+This information is used when the state of the cluster is changed and a node seeks agreement in order to perform some action.
+
+Currently this happens only during replica promotion, as described in the next section. Basically the epoch is a logical clock for the cluster and dictates that given information wins over one with a smaller epoch.
+
+### Configuration epoch
+
+Every master always advertises its `configEpoch` in ping and pong packets along with a bitmap advertising the set of slots it serves.
+
+The `configEpoch` is set to zero in masters when a new node is created.
+
+A new `configEpoch` is created during replica election. replicas trying to replace
+failing masters increment their epoch and try to get authorization from
+a majority of masters. When a replica is authorized, a new unique `configEpoch`
+is created and the replica turns into a master using the new `configEpoch`.
+
+As explained in the next sections the `configEpoch` helps to resolve conflicts when different nodes claim divergent configurations (a condition that may happen because of network partitions and node failures).
+
+replica nodes also advertise the `configEpoch` field in ping and pong packets, but in the case of replicas the field represents the `configEpoch` of its master as of the last time they exchanged packets. This allows other instances to detect when a replica has an old configuration that needs to be updated (master nodes will not grant votes to replicas with an old configuration).
+
+Every time the `configEpoch` changes for some known node, it is permanently stored in the nodes.conf file by all the nodes that receive this information. The same also happens for the `currentEpoch` value. These two variables are guaranteed to be saved and `fsync-ed` to disk when updated before a node continues its operations.
+
+The `configEpoch` values generated using a simple algorithm during failovers
+are guaranteed to be new, incremental, and unique.
+
+### Replica election and promotion
+
+Replica election and promotion is handled by replica nodes, with the help of master nodes that vote for the replica to promote.
+A replica election happens when a master is in `FAIL` state from the point of view of at least one of its replicas that has the prerequisites in order to become a master.
+
+In order for a replica to promote itself to master, it needs to start an election and win it. All the replicas for a given master can start an election if the master is in `FAIL` state, however only one replica will win the election and promote itself to master.
+
+A replica starts an election when the following conditions are met:
+
+* The replica's master is in `FAIL` state.
+* The master was serving a non-zero number of slots.
+* The replica replication link was disconnected from the master for no longer than a given amount of time, in order to ensure the promoted replica's data is reasonably fresh. This time is user configurable.
+
+In order to be elected, the first step for a replica is to increment its `currentEpoch` counter, and request votes from master instances.
+
+Votes are requested by the replica by broadcasting a `FAILOVER_AUTH_REQUEST` packet to every master node of the cluster. Then it waits for a maximum time of two times the `NODE_TIMEOUT` for replies to arrive (but always for at least 2 seconds).
+
+Once a master has voted for a given replica, replying positively with a `FAILOVER_AUTH_ACK`, it can no longer vote for another replica of the same master for a period of `NODE_TIMEOUT * 2`. In this period it will not be able to reply to other authorization requests for the same master. This is not needed to guarantee safety, but useful for preventing multiple replicas from getting elected (even if with a different `configEpoch`) at around the same time, which is usually not wanted.
+
+A replica discards any `AUTH_ACK` replies with an epoch that is less than the `currentEpoch` at the time the vote request was sent. This ensures it doesn't count votes intended for a previous election.
+
+Once the replica receives ACKs from the majority of masters, it wins the election.
+Otherwise if the majority is not reached within the period of two times `NODE_TIMEOUT` (but always at least 2 seconds), the election is aborted and a new one will be tried again after `NODE_TIMEOUT * 4` (and always at least 4 seconds).
+
+### Replica rank
+
+As soon as a master is in `FAIL` state, a replica waits a short period of time before trying to get elected. That delay is computed as follows:
+
+    DELAY = 500 milliseconds + random delay between 0 and 500 milliseconds +
+            REPLICA_RANK * 1000 milliseconds.
+
+The fixed delay ensures that we wait for the `FAIL` state to propagate across the cluster, otherwise the replica may try to get elected while the masters are still unaware of the `FAIL` state, refusing to grant their vote.
+
+The random delay is used to desynchronize replicas so they're unlikely to start an election at the same time.
+
+The `REPLICA_RANK` is the rank of this replica regarding the amount of replication data it has processed from the master.
+Replicas exchange messages when the master is failing in order to establish a (best effort) rank:
+the replica with the most updated replication offset is at rank 0, the second most updated at rank 1, and so forth.
+In this way the most updated replicas try to get elected before others.
+
+Rank order is not strictly enforced; if a replica of higher rank fails to be
+elected, the others will try shortly.
+
+Once a replica wins the election, it obtains a new unique and incremental `configEpoch` which is higher than that of any other existing master. It starts advertising itself as master in ping and pong packets, providing the set of served slots with a `configEpoch` that will win over the past ones.
+
+In order to speedup the reconfiguration of other nodes, a pong packet is broadcast to all the nodes of the cluster. Currently unreachable nodes will eventually be reconfigured when they receive a ping or pong packet from another node or will receive an `UPDATE` packet from another node if the information it publishes via heartbeat packets are detected to be out of date.
+
+The other nodes will detect that there is a new master serving the same slots served by the old master but with a greater `configEpoch`, and will upgrade their configuration. Replicas of the old master (or the failed over master if it rejoins the cluster) will not just upgrade the configuration but will also reconfigure to replicate from the new master. How nodes rejoining the cluster are configured is explained in the next sections.
+
+### Masters reply to replica vote request
+
+In the previous section, we discussed how replicas try to get elected. This section explains what happens from the point of view of a master that is requested to vote for a given replica.
+
+Masters receive requests for votes in form of `FAILOVER_AUTH_REQUEST` requests from replicas.
+
+For a vote to be granted the following conditions need to be met:
+
+1. A master only votes a single time for a given epoch, and refuses to vote for older epochs: every master has a lastVoteEpoch field and will refuse to vote again as long as the `currentEpoch` in the auth request packet is not greater than the lastVoteEpoch. When a master replies positively to a vote request, the lastVoteEpoch is updated accordingly, and safely stored on disk.
+2. A master votes for a replica only if the replica's master is flagged as `FAIL`.
+3. Auth requests with a `currentEpoch` that is less than the master `currentEpoch` are ignored. Because of this the master reply will always have the same `currentEpoch` as the auth request. If the same replica asks again to be voted, incrementing the `currentEpoch`, it is guaranteed that an old delayed reply from the master can not be accepted for the new vote.
+
+Example of the issue caused by not using rule number 3:
+
+Master `currentEpoch` is 5, lastVoteEpoch is 1 (this may happen after a few failed elections)
+
+* Replica `currentEpoch` is 3.
+* Replica tries to be elected with epoch 4 (3+1), master replies with an ok with `currentEpoch` 5, however the reply is delayed.
+* Replica will try to be elected again, at a later time, with epoch 5 (4+1), the delayed reply reaches the replica with `currentEpoch` 5, and is accepted as valid.
+
+4. Masters don't vote for a replica of the same master before `NODE_TIMEOUT * 2` has elapsed if a replica of that master was already voted for. This is not strictly required as it is not possible for two replicas to win the election in the same epoch. However, in practical terms it ensures that when a replica is elected it has plenty of time to inform the other replicas and avoid the possibility that another replica will win a new election, performing an unnecessary second failover.
+5. Masters make no effort to select the best replica in any way. If the replica's master is in `FAIL` state and the master did not vote in the current term, a positive vote is granted. The best replica is the most likely to start an election and win it before the other replicas, since it will usually be able to start the voting process earlier because of its *higher rank* as explained in the previous section.
+6. When a master refuses to vote for a given replica there is no negative response, the request is simply ignored.
+7. Masters don't vote for replicas sending a `configEpoch` that is less than any `configEpoch` in the master table for the slots claimed by the replica. Remember that the replica sends the `configEpoch` of its master, and the bitmap of the slots served by its master. This means that the replica requesting the vote must have a configuration for the slots it wants to failover that is newer or equal the one of the master granting the vote.
+
+### Practical example of configuration epoch usefulness during partitions
+
+This section illustrates how the epoch concept is used to make the replica promotion process more resistant to partitions.
+
+* A master is no longer reachable indefinitely. The master has three replicas A, B, C.
+* Replica A wins the election and is promoted to master.
+* A network partition makes A not available for the majority of the cluster.
+* Replica B wins the election and is promoted as master.
+* A partition makes B not available for the majority of the cluster.
+* The previous partition is fixed, and A is available again.
+
+At this point B is down and A is available again with a role of master (actually `UPDATE` messages would reconfigure it promptly, but here we assume all `UPDATE` messages were lost). At the same time, replica C will try to get elected in order to fail over B. This is what happens:
+
+1. C will try to get elected and will succeed, since for the majority of masters its master is actually down. It will obtain a new incremental `configEpoch`.
+2. A will not be able to claim to be the master for its hash slots, because the other nodes already have the same hash slots associated with a higher configuration epoch (the one of B) compared to the one published by A.
+3. So, all the nodes will upgrade their table to assign the hash slots to C, and the cluster will continue its operations.
+
+As you'll see in the next sections, a stale node rejoining a cluster
+will usually get notified as soon as possible about the configuration change
+because as soon as it pings any other node, the receiver will detect it
+has stale information and will send an `UPDATE` message.
+
+### Hash slots configuration propagation
+
+An important part of Redis Cluster is the mechanism used to propagate the information about which cluster node is serving a given set of hash slots. This is vital to both the startup of a fresh cluster and the ability to upgrade the configuration after a replica was promoted to serve the slots of its failing master.
+
+The same mechanism allows nodes partitioned away for an indefinite amount of
+time to rejoin the cluster in a sensible way.
+
+There are two ways hash slot configurations are propagated:
+
+1. Heartbeat messages. The sender of a ping or pong packet always adds information about the set of hash slots it (or its master, if it is a replica) serves.
+2. `UPDATE` messages. Since in every heartbeat packet there is information about the sender `configEpoch` and set of hash slots served, if a receiver of a heartbeat packet finds the sender information is stale, it will send a packet with new information, forcing the stale node to update its info.
+
+The receiver of a heartbeat or `UPDATE` message uses certain simple rules in
+order to update its table mapping hash slots to nodes. When a new Redis Cluster node is created, its local hash slot table is simply initialized to `NULL` entries so that each hash slot is not bound or linked to any node. This looks similar to the following:
+
+```
+0 -> NULL
+1 -> NULL
+2 -> NULL
+...
+16383 -> NULL
+```
+
+The first rule followed by a node in order to update its hash slot table is the following:
+
+**Rule 1**: If a hash slot is unassigned (set to `NULL`), and a known node claims it, I'll modify my hash slot table and associate the claimed hash slots to it.
+
+So if we receive a heartbeat from node A claiming to serve hash slots 1 and 2 with a configuration epoch value of 3, the table will be modified to:
+
+```
+0 -> NULL
+1 -> A [3]
+2 -> A [3]
+...
+16383 -> NULL
+```
+
+When a new cluster is created, a system administrator needs to manually assign (using the [`CLUSTER ADDSLOTS`](/commands/cluster-addslots) command, via the redis-cli command line tool, or by any other means) the slots served by each master node only to the node itself, and the information will rapidly propagate across the cluster.
+
+However this rule is not enough. We know that hash slot mapping can change
+during two events:
+
+1. A replica replaces its master during a failover.
+2. A slot is resharded from a node to a different one.
+
+For now let's focus on failovers. When a replica fails over its master, it obtains
+a configuration epoch which is guaranteed to be greater than the one of its
+master (and more generally greater than any other configuration epoch
+generated previously). For example node B, which is a replica of A, may failover
+A with configuration epoch of 4. It will start to send heartbeat packets
+(the first time mass-broadcasting cluster-wide) and because of the following
+second rule, receivers will update their hash slot tables:
+
+**Rule 2**: If a hash slot is already assigned, and a known node is advertising it using a `configEpoch` that is greater than the `configEpoch` of the master currently associated with the slot, I'll rebind the hash slot to the new node.
+
+So after receiving messages from B that claim to serve hash slots 1 and 2 with configuration epoch of 4, the receivers will update their table in the following way:
+
+```
+0 -> NULL
+1 -> B [4]
+2 -> B [4]
+...
+16383 -> NULL
+```
+
+Liveness property: because of the second rule, eventually all nodes in the cluster will agree that the owner of a slot is the one with the greatest `configEpoch` among the nodes advertising it.
+
+This mechanism in Redis Cluster is called **last failover wins**.
+
+The same happens during resharding. When a node importing a hash slot completes
+the import operation, its configuration epoch is incremented to make sure the
+change will be propagated throughout the cluster.
+
+### UPDATE messages, a closer look
+
+With the previous section in mind, it is easier to see how update messages
+work. Node A may rejoin the cluster after some time. It will send heartbeat
+packets where it claims it serves hash slots 1 and 2 with configuration epoch
+of 3. All the receivers with updated information will instead see that
+the same hash slots are associated with node B having a higher configuration
+epoch. Because of this they'll send an `UPDATE` message to A with the new
+configuration for the slots. A will update its configuration because of the
+**rule 2** above.
+
+### How nodes rejoin the cluster
+
+The same basic mechanism is used when a node rejoins a cluster.
+Continuing with the example above, node A will be notified
+that hash slots 1 and 2 are now served by B. Assuming that these two were
+the only hash slots served by A, the count of hash slots served by A will
+drop to 0! So A will **reconfigure to be a replica of the new master**.
+
+The actual rule followed is a bit more complex than this. In general it may
+happen that A rejoins after a lot of time, in the meantime it may happen that
+hash slots originally served by A are served by multiple nodes, for example
+hash slot 1 may be served by B, and hash slot 2 by C.
+
+So the actual *Redis Cluster node role switch rule* is: **A master node will change its configuration to replicate (be a replica of) the node that stole its last hash slot**.
+
+During reconfiguration, eventually the number of served hash slots will drop to zero, and the node will reconfigure accordingly. Note that in the base case this just means that the old master will be a replica of the replica that replaced it after a failover. However in the general form the rule covers all possible cases.
+
+Replicas do exactly the same: they reconfigure to replicate the node that
+stole the last hash slot of its former master.
+
+### Replica migration
+
+Redis Cluster implements a concept called *replica migration* in order to
+improve the availability of the system. The idea is that in a cluster with
+a master-replica setup, if the map between replicas and masters is fixed
+availability is limited over time if multiple independent failures of single
+nodes happen.
+
+For example in a cluster where every master has a single replica, the cluster
+can continue operations as long as either the master or the replica fail, but not
+if both fail the same time. However there is a class of failures that are
+the independent failures of single nodes caused by hardware or software issues
+that can accumulate over time. For example:
+
+* Master A has a single replica A1.
+* Master A fails. A1 is promoted as new master.
+* Three hours later A1 fails in an independent manner (unrelated to the failure of A). No other replica is available for promotion since node A is still down. The cluster cannot continue normal operations.
+
+If the map between masters and replicas is fixed, the only way to make the cluster
+more resistant to the above scenario is to add replicas to every master, however
+this is costly as it requires more instances of Redis to be executed, more
+memory, and so forth.
+
+An alternative is to create an asymmetry in the cluster, and let the cluster
+layout automatically change over time. For example the cluster may have three
+masters A, B, C. A and B have a single replica each, A1 and B1. However the master
+C is different and has two replicas: C1 and C2.
+
+Replica migration is the process of automatic reconfiguration of a replica
+in order to *migrate* to a master that has no longer coverage (no working
+replicas). With replica migration the scenario mentioned above turns into the
+following:
+
+* Master A fails. A1 is promoted.
+* C2 migrates as replica of A1, that is otherwise not backed by any replica.
+* Three hours later A1 fails as well.
+* C2 is promoted as new master to replace A1.
+* The cluster can continue the operations.
+
+### Replica migration algorithm
+
+The migration algorithm does not use any form of agreement since the replica
+layout in a Redis Cluster is not part of the cluster configuration that needs
+to be consistent and/or versioned with config epochs. Instead it uses an
+algorithm to avoid mass-migration of replicas when a master is not backed.
+The algorithm guarantees that eventually (once the cluster configuration is
+stable) every master will be backed by at least one replica.
+
+This is how the algorithm works. To start we need to define what is a
+*good replica* in this context: a good replica is a replica not in `FAIL` state
+from the point of view of a given node.
+
+The execution of the algorithm is triggered in every replica that detects that
+there is at least a single master without good replicas. However among all the
+replicas detecting this condition, only a subset should act. This subset is
+actually often a single replica unless different replicas have in a given moment
+a slightly different view of the failure state of other nodes.
+
+The *acting replica* is the replica among the masters with the maximum number
+of attached replicas, that is not in FAIL state and has the smallest node ID.
+
+So for example if there are 10 masters with 1 replica each, and 2 masters with
+5 replicas each, the replica that will try to migrate is - among the 2 masters
+having 5 replicas - the one with the lowest node ID. Given that no agreement
+is used, it is possible that when the cluster configuration is not stable,
+a race condition occurs where multiple replicas believe themselves to be
+the non-failing replica with the lower node ID (it is unlikely for this to happen
+in practice). If this happens, the result is multiple replicas migrating to the
+same master, which is harmless. If the race happens in a way that will leave
+the ceding master without replicas, as soon as the cluster is stable again
+the algorithm will be re-executed again and will migrate a replica back to
+the original master.
+
+Eventually every master will be backed by at least one replica. However,
+the normal behavior is that a single replica migrates from a master with
+multiple replicas to an orphaned master.
+
+The algorithm is controlled by a user-configurable parameter called
+`cluster-migration-barrier`: the number of good replicas a master
+must be left with before a replica can migrate away. For example, if this
+parameter is set to 2, a replica can try to migrate only if its master remains
+with two working replicas.
+
+### configEpoch conflicts resolution algorithm
+
+When new `configEpoch` values are created via replica promotion during
+failovers, they are guaranteed to be unique.
+
+However there are two distinct events where new configEpoch values are
+created in an unsafe way, just incrementing the local `currentEpoch` of
+the local node and hoping there are no conflicts at the same time.
+Both the events are system-administrator triggered:
+
+1. [`CLUSTER FAILOVER`](/commands/cluster-failover) command with `TAKEOVER` option is able to manually promote a replica node into a master *without the majority of masters being available*. This is useful, for example, in multi data center setups.
+2. Migration of slots for cluster rebalancing also generates new configuration epochs inside the local node without agreement for performance reasons.
+
+Specifically, during manual resharding, when a hash slot is migrated from
+a node A to a node B, the resharding program will force B to upgrade
+its configuration to an epoch which is the greatest found in the cluster,
+plus 1 (unless the node is already the one with the greatest configuration
+epoch), without requiring agreement from other nodes.
+Usually a real world resharding involves moving several hundred hash slots
+(especially in small clusters). Requiring an agreement to generate new
+configuration epochs during resharding, for each hash slot moved, is
+inefficient. Moreover it requires a fsync in each of the cluster nodes
+every time in order to store the new configuration. Because of the way it is
+performed instead, we only need a new config epoch when the first hash slot is moved,
+making it much more efficient in production environments.
+
+However because of the two cases above, it is possible (though unlikely) to end
+with multiple nodes having the same configuration epoch. A resharding operation
+performed by the system administrator, and a failover happening at the same
+time (plus a lot of bad luck) could cause `currentEpoch` collisions if
+they are not propagated fast enough.
+
+Moreover, software bugs and filesystem corruptions can also contribute
+to multiple nodes having the same configuration epoch.
+
+When masters serving different hash slots have the same `configEpoch`, there
+are no issues. It is more important that replicas failing over a master have
+unique configuration epochs.
+
+That said, manual interventions or resharding may change the cluster
+configuration in different ways. The Redis Cluster main liveness property
+requires that slot configurations always converge, so under every circumstance
+we really want all the master nodes to have a different `configEpoch`.
+
+In order to enforce this, **a conflict resolution algorithm** is used in the
+event that two nodes end up with the same `configEpoch`.
+
+* IF a master node detects another master node is advertising itself with
+the same `configEpoch`.
+* AND IF the node has a lexicographically smaller Node ID compared to the other node claiming the same `configEpoch`.
+* THEN it increments its `currentEpoch` by 1, and uses it as the new `configEpoch`.
+
+If there are any set of nodes with the same `configEpoch`, all the nodes but the one with the greatest Node ID will move forward, guaranteeing that, eventually, every node will pick a unique configEpoch regardless of what happened.
+
+This mechanism also guarantees that after a fresh cluster is created, all
+nodes start with a different `configEpoch` (even if this is not actually
+used) since `redis-cli` makes sure to use [`CLUSTER SET-CONFIG-EPOCH`](/commands/cluster-set-config-epoch) at startup.
+However if for some reason a node is left misconfigured, it will update
+its configuration to a different configuration epoch automatically.
+
+### Node resets
+
+Nodes can be software reset (without restarting them) in order to be reused
+in a different role or in a different cluster. This is useful in normal
+operations, in testing, and in cloud environments where a given node can
+be reprovisioned to join a different set of nodes to enlarge or create a new
+cluster.
+
+In Redis Cluster nodes are reset using the [`CLUSTER RESET`](/commands/cluster-reset) command. The
+command is provided in two variants:
+
+* `CLUSTER RESET SOFT`
+* `CLUSTER RESET HARD`
+
+The command must be sent directly to the node to reset. If no reset type is
+provided, a soft reset is performed.
+
+The following is a list of operations performed by a reset:
+
+1. Soft and hard reset: If the node is a replica, it is turned into a master, and its dataset is discarded. If the node is a master and contains keys the reset operation is aborted.
+2. Soft and hard reset: All the slots are released, and the manual failover state is reset.
+3. Soft and hard reset: All the other nodes in the nodes table are removed, so the node no longer knows any other node.
+4. Hard reset only: `currentEpoch`, `configEpoch`, and `lastVoteEpoch` are set to 0.
+5. Hard reset only: the Node ID is changed to a new random ID.
+
+Master nodes with non-empty data sets can't be reset (since normally you want to reshard data to the other nodes). However, under special conditions when this is appropriate (e.g. when a cluster is totally destroyed with the intent of creating a new one), [`FLUSHALL`](/commands/flushall) must be executed before proceeding with the reset.
+
+### Removing nodes from a cluster
+
+It is possible to practically remove a node from an existing cluster by
+resharding all its data to other nodes (if it is a master node) and
+shutting it down. However, the other nodes will still remember its node
+ID and address, and will attempt to connect with it.
+
+For this reason, when a node is removed we want to also remove its entry
+from all the other nodes tables. This is accomplished by using the
+`CLUSTER FORGET <node-id>` command.
+
+The command does two things:
+
+1. It removes the node with the specified node ID from the nodes table.
+2. It sets a 60 second ban which prevents a node with the same node ID from being re-added.
+
+The second operation is needed because Redis Cluster uses gossip in order to auto-discover nodes, so removing the node X from node A, could result in node B gossiping about node X to A again. Because of the 60 second ban, the Redis Cluster administration tools have 60 seconds in order to remove the node from all the nodes, preventing the re-addition of the node due to auto discovery.
+
+Further information is available in the [`CLUSTER FORGET`](/commands/cluster-forget) documentation.
+
+## Publish/Subscribe
+
+In a Redis Cluster, clients can subscribe to every node, and can also
+publish to every other node. The cluster will make sure that published
+messages are forwarded as needed.
+
+The clients can send SUBSCRIBE to any node and can also send PUBLISH to any node. 
+It will simply broadcast each published message to all other nodes.
+
+Redis 7.0 and later features sharded pub/sub, in which shard channels are assigned to slots by the same algorithm used to assign keys to slots. 
+A shard message must be sent to a node that owns the slot the shard channel is hashed to. 
+The cluster makes sure the published shard messages are forwarded to all nodes in the shard, so clients can subscribe to a shard channel by connecting to either the master responsible for the slot, or to any of its replicas.
+
+## Appendix
+
+### Appendix A: CRC16 reference implementation in ANSI C
+
+    /*
+     * Copyright 2001-2010 Georges Menie (www.menie.org)
+     * Copyright 2010 Salvatore Sanfilippo (adapted to Redis coding style)
+     * All rights reserved.
+     * Redistribution and use in source and binary forms, with or without
+     * modification, are permitted provided that the following conditions are met:
+     *
+     *     * Redistributions of source code must retain the above copyright
+     *       notice, this list of conditions and the following disclaimer.
+     *     * Redistributions in binary form must reproduce the above copyright
+     *       notice, this list of conditions and the following disclaimer in the
+     *       documentation and/or other materials provided with the distribution.
+     *     * Neither the name of the University of California, Berkeley nor the
+     *       names of its contributors may be used to endorse or promote products
+     *       derived from this software without specific prior written permission.
+     *
+     * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+     * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+     * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+     * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+     * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+     * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+     * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+     * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+     * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+     */
+
+    /* CRC16 implementation according to CCITT standards.
+     *
+     * Note by @antirez: this is actually the XMODEM CRC 16 algorithm, using the
+     * following parameters:
+     *
+     * Name                       : "XMODEM", also known as "ZMODEM", "CRC-16/ACORN"
+     * Width                      : 16 bit
+     * Poly                       : 1021 (That is actually x^16 + x^12 + x^5 + 1)
+     * Initialization             : 0000
+     * Reflect Input byte         : False
+     * Reflect Output CRC         : False
+     * Xor constant to output CRC : 0000
+     * Output for "123456789"     : 31C3
+     */
+
+    static const uint16_t crc16tab[256]= {
+        0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
+        0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
+        0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
+        0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
+        0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
+        0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
+        0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
+        0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
+        0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
+        0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
+        0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
+        0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
+        0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
+        0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
+        0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
+        0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
+        0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
+        0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
+        0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
+        0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
+        0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
+        0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
+        0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
+        0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
+        0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
+        0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
+        0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
+        0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
+        0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
+        0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
+        0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
+        0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
+    };
+
+    uint16_t crc16(const char *buf, int len) {
+        int counter;
+        uint16_t crc = 0;
+        for (counter = 0; counter < len; counter++)
+                crc = (crc<<8) ^ crc16tab[((crc>>8) ^ *buf++)&0x00FF];
+        return crc;
+    }
+---
+title: Reference
+description: Redis Open Source reference documentation
+linkTitle: Reference
+------
+title: Redis Open Source
+description: Operate Redis Open Source. Redis 8 in Redis Open Source replaces Redis Stack.
+linkTitle: Redis Open Source
+weight: 40
+---
+---
+title: Redis products
+description: Products, services, and tools to operate a Redis database.
+linkTitle: Operate
+hideListLinks: true
+---
+
+| {{<color-bubble color="bg-blue-bubble">}} Redis Cloud | {{<color-bubble color="bg-yellow-bubble">}} Redis Software |
+|:-----------|:--------------|
+| <ul><li> [Get started with Redis Cloud]({{< relref "/operate/rc/rc-quickstart" >}}) </li><li> [Create a database]({{< relref "/operate/rc/databases/create-database" >}}) </li><li> [Connect to your database]({{< relref "/operate/rc/databases/connect" >}}) </li><li> [Subscriptions]({{< relref "/operate/rc/subscriptions" >}}) </li><li>[REST API]({{< relref "/operate/rc/api/" >}})</li></ul> | <ul><li> [Install Redis Software]({{< relref "/operate/rs/installing-upgrading" >}}) </li><li> [Set up a new cluster]({{< relref "/operate/rs/clusters/new-cluster-setup" >}}) </li><li> [Create a database]({{< relref "/operate/rs/databases/create" >}}) </li><li> [Connect to your database]({{< relref "/operate/rs/databases/connect" >}}) </li><li>[REST API]({{< relref "/operate/rs/references/rest-api/" >}})</li></ul> |
+| {{<color-bubble color="bg-purple-bubble">}} **Redis Open Source** | {{<color-bubble color="bg-gray-bubble">}} **Redis for Kubernetes** |
+| <ul><li> [Install Redis 8 in Redis Open Source]({{< relref "/operate/oss_and_stack/install/install-stack" >}}) </li><li> [Install Redis Stack]({{< relref "/operate/oss_and_stack/install/archive/install-stack/" >}}) (&#8804; 7.4) </li><li> [Manage Redis]({{< relref "/operate/oss_and_stack/management" >}}) </li></ul> | <ul><li> [Deploy Redis for Kubernetes]({{< relref "/operate/kubernetes/deployment" >}}) </li><li> [Architecture]({{< relref "/operate/kubernetes/architecture" >}}) </li><li> [API Reference]({{< relref "/operate/kubernetes/reference" >}}) </li></ul> |
+| {{<color-bubble color="bg-red-bubble">}} **Redis Insight** | |
+| <ul><li> [Install Redis Insight]({{< relref "/operate/redisinsight/install" >}}) </li><li> [Use Redis Insight]({{< relref "/develop/tools/insight" >}}) </li></ul> | |
+
+## Product features
+
+### High availability and durability
+
+<!-- | Feature | RC        | RS         | Open Source       | K8s          | -->
+| | <nobr>{{<color-bubble color="bg-blue-bubble">}} Redis</nobr> Cloud | <nobr>{{<color-bubble color="bg-yellow-bubble">}} Redis</nobr> Software | <nobr>{{<color-bubble color="bg-purple-bubble">}} Redis</nobr> Open Source | <nobr>{{<color-bubble color="bg-gray-bubble">}} Redis for</nobr> Kubernetes |
+|:-----------|:--------------|:-----------|:--------------|:--------------|
+| Clustering | [Clustering]({{< relref "/operate/rc/databases/configuration/clustering" >}}) | [Clustering]({{<relref "/operate/rs/databases/durability-ha/clustering">}}) | [Scale with Redis Cluster]({{< relref "/operate/oss_and_stack/management/scaling" >}}) | [Redis Enterprise clusters (REC)]({{<relref "/operate/kubernetes/re-clusters">}}) |
+| Replication | [Replication]({{< relref "/operate/rc/databases/configuration/high-availability" >}}) | [Replication]({{<relref "/operate/rs/databases/durability-ha/replication">}}) | [Replication]({{< relref "/operate/oss_and_stack/management/replication" >}}) | [Create replica databases]({{<relref "/operate/kubernetes/re-databases/replica-redb/">}})|
+| Active-Active geo-distribution | [Active-Active Redis]({{< relref "/operate/rc/databases/configuration/active-active-redis" >}}) | [Active-Active Redis]({{<relref "/operate/rs/databases/active-active">}}) |  | [Active-Active databases]({{<relref "/operate/kubernetes/active-active/">}}) |
+| Rolling upgrades | [Upgrade database version]({{< relref "/operate/rc/databases/upgrade-version" >}}) | [Upgrade Redis Software]({{<relref "/operate/rs/installing-upgrading/upgrading">}}) |  | [Upgrade Redis for K8s]({{<relref "/operate/kubernetes/upgrade/">}}) |
+| Redis Flex/Auto tiering | [Create a Redis Flex database]({{< relref "/operate/rc/databases/create-database/create-flex-database" >}}) | [Auto Tiering]({{<relref "/operate/rs/databases/auto-tiering">}}) |  | [Auto Tiering]({{<relref "/operate/kubernetes/re-clusters/auto-tiering/">}}) |
+| Persistence | [Data persistence]({{< relref "/operate/rc/databases/configuration/data-persistence" >}}) | [Persistence]({{<relref "/operate/rs/databases/configure/database-persistence">}}) | [Persistence]({{< relref "/operate/oss_and_stack/management/replication" >}}) | [Persistence volumes]({{<relref "/operate/kubernetes/recommendations/persistent-volumes/">}})|
+| Recovery | Automatic | [Recover cluster]({{<relref "/operate/rs/clusters/cluster-recovery">}}) | [Manual failover]({{< relref "/operate/oss_and_stack/management/scaling#manual-failover" >}}) | [Cluster recovery]({{<relref "/operate/kubernetes/re-clusters/cluster-recovery/">}}) |
+| Backups | [Back up a database]({{< relref "/operate/rc/databases/back-up-data" >}}) | [Schedule backups]({{<relref "/operate/rs/databases/import-export/schedule-backups">}}) | [Persistence]({{< relref "/operate/oss_and_stack/management/replication" >}}) | [REDB spec.backup]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api/#specbackup">}}) |
+
+### Logging and monitoring
+
+<!-- | Feature | RC        | RS         | Open Source       | K8s          | -->
+| | <nobr>{{<color-bubble color="bg-blue-bubble">}} Redis</nobr> Cloud | <nobr>{{<color-bubble color="bg-yellow-bubble">}} Redis</nobr> Software | <nobr>{{<color-bubble color="bg-purple-bubble">}} Redis</nobr> Open Source | <nobr>{{<color-bubble color="bg-gray-bubble">}} Redis for</nobr> Kubernetes |
+|:-----------|:--------------|:-----------|:--------------|:--------------|
+| Monitoring | [Monitor performance]({{< relref "/operate/rc/databases/monitor-performance" >}}) | [Monitoring]({{<relref "/operate/rs/monitoring">}}) | [INFO]({{< relref "/commands/info" >}}), [MONITOR]({{< relref "/commands/monitor" >}}), and [LATENCY DOCTOR]({{< relref "/commands/latency-doctor" >}})<br/>[Analysis with Redis Insight]({{< relref "/develop/tools/insight#database-analysis" >}}) | [Export metrics to Prometheus]({{<relref "/operate/kubernetes/re-clusters/connect-prometheus-operator/">}}) |
+| Logging | [System logs]({{< relref "/operate/rc/logs-reports/system-logs" >}}) | [Logging]({{<relref "/operate/rs/clusters/logging">}}) | `/var/log/redis/redis.log`<br/>[SLOWLOG]({{< relref "/commands/slowlog" >}})<br/>[Keyspace notifications]({{< relref "/develop/use/keyspace-notifications" >}}) | [Logs]({{<relref "/operate/kubernetes/logs/">}}) |
+| Alerts | [Alerts]({{< relref "/operate/rc/databases/view-edit-database#alerts-section" >}}) | [Alerts and events]({{<relref "/operate/rs/clusters/logging/alerts-events">}}) | [Pub/sub with Redis Sentinel]({{< relref "/operate/oss_and_stack/management/sentinel#pubsub-messages" >}}) | [REDB alertSettings]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api/#specalertsettings">}}) |
+| Support | [Contact support](https://redis.io/support/) | [Create support package]({{<relref "/operate/rs/installing-upgrading/creating-support-package">}}) |  | [Contact support](https://redis.io/support/) |
+
+### Security
+
+<!-- | Feature | RC        | RS         | Open Source       | K8s          | -->
+| | <nobr>{{<color-bubble color="bg-blue-bubble" >}} Redis</nobr> Cloud | <nobr>{{<color-bubble color="bg-yellow-bubble">}} Redis</nobr> Software | <nobr>{{<color-bubble color="bg-purple-bubble">}} Redis</nobr> Open Source | <nobr><div class="h-3 w-3 rounded-md border border-redis-pen-600 inline-block mr-1" style="background-color: #8A99A0"></div> Redis for</nobr> Kubernetes |
+|:-----------|:--------------|:-----------|:--------------|:--------------|
+| Transport Layer Security (TLS) | [TLS]({{<relref "/operate/rc/security/database-security/tls-ssl">}}) | [TLS]({{<relref "/operate/rs/security/encryption/tls">}}) | [TLS]({{< relref "/operate/oss_and_stack/management/security/encryption" >}}) | [REDB tlsMode]({{<relref "/operate/kubernetes/reference/redis_enterprise_database_api/#spec">}}) |
+| Role-based access control (RBAC) | [Role-based access control]({{<relref "/operate/rc/security/access-control/data-access-control/role-based-access-control">}}) | [Access control]({{<relref "/operate/rs/security/access-control">}}) | [Access control list]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) | [REC credentials]({{<relref "/operate/kubernetes/security/manage-rec-credentials/">}}) |
+| Lightweight Directory Access Protocol (LDAP) |  | [LDAP authentication]({{<relref "/operate/rs/security/access-control/ldap">}}) |  | [Enable LDAP]({{<relref "/operate/kubernetes/security/ldap/">}}) |
+| Single sign-on (SSO) | [SAML SSO]({{< relref "/operate/rc/security/access-control/saml-sso" >}}) |  |  |  |
+| Self-signed certificates |  | [Certificates]({{<relref "/operate/rs/security/certificates">}}) | [Certificate configuration]({{< relref "/operate/oss_and_stack/management/security/encryption#certificate-configuration" >}}) | [REC certificates]({{<relref "operate/kubernetes/security/manage-rec-certificates/">}}) |
+| Internode encryption | [Encryption at rest]({{< relref "/operate/rc/security/encryption-at-rest" >}}) | [Internode encryption]({{<relref "/operate/rs/security/encryption/internode-encryption">}}) |  | [Enable internode encryption]({{<relref "operate/kubernetes/security/internode-encryption/">}}) |
+| Auditing |  | [Audit events]({{<relref "/operate/rs/security/audit-events">}}) | [Keyspace notifications]({{< relref "/develop/use/keyspace-notifications" >}}) |  |
+
+---
+Title: Glossary
+description:
+weight: 100
+alwaysopen: false
+categories: ["Glossary"]
+aliases: /glossary/
+---
+<dl class="glossary">
+
+<!--- 
+{{%definition ""%}}
+{{%/definition%}}
+--->
+
+## A, B {#letter-a}
+
+{{%definition "access control list (ACL)"%}}
+Allows you to manage permissions based on key patterns.
+
+More info: [redis.io/operate/oss_and_stack/management/security/acl]({{< relref "/operate/oss_and_stack/management/security/acl" >}}); [ACL wikipedia](https://en.wikipedia.org/wiki/Access-control_list); [Database access control]({{<relref "/operate/rs/security/access-control">}}); [Update database ACLs]({{<relref "/operate/rs/security/access-control/ldap/update-database-acls">}}); [Role-based access control]({{<relref "/operate/rc/security/access-control/data-access-control/role-based-access-control">}})
+{{%/definition%}}
+
+<a name="active-active"></a>
+{{%definition "Active-Active database (CRDB)"%}}
+Geo-distributed databases that span multiple [Redis Enterprise Software]({{<relref "#redis-enterprise-software">}}) [clusters]({{<relref "#cluster">}}). Active-Active databases, also known as conflict-free replicated databases (CRDB), depend on [multi-master replication (MMR)]({{<relref "#multi-master-replication-mmr">}}) and [conflict-free replicated data types (CRDTs)]({{<relref "#conflict-free-replicated-data-types-crdt">}}) to power a simple development experience for geo-distributed applications.
+
+More info: [Active-Active geo-distributed Redis]({{<relref "/operate/rs/databases/active-active">}}), [Geo-distributed Active-Active Redis applications]({{<relref "/operate/rs/databases/active-active/" >}}), [Developing applications for Active-Active databases]({{<relref "/operate/rs/databases/active-active/develop/">}})
+{{%/definition%}}
+
+{{%definition "Active-Active database instance"%}}
+A “member database” of a global Active-Active database which is made up of its own master and replica shards spanning a single cluster.
+{{%/definition%}}
+
+{{%definition "active-passive database replication"%}}
+Provides applications read-only access to replicas of the data set from different geographical locations. The Redis Enterprise implementation of active-passive replication is called [Replica Of]({{<relref "#replica-of">}}).
+{{%/definition%}}
+
+{{%definition"admin console"%}}
+Each node runs a web server that is used to provide the user with access to the Redis Enterprise Software admin console (previously known as management UI). The admin console allows viewing and managing the entire cluster, so it does not matter which node is used to access it.
+{{%/definition%}}
+
+{{%definition "admission controller"%}}
+A piece of code that intercepts requests to the Kubernetes API server prior to persistence of the object.
+
+More info: [Using Admission Controllers](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)
+{{%/definition%}}
+
+{{%definition "append-only file (AoF)"%}}
+Log files that keep a record of data changes by writing to the end of a file. This happens with every write, or every second to allow data recovering the entire
+dataset by replaying the append-only log from the beginning to the end.
+
+More info: [Data Persistence]({{<relref "/operate/rc/databases/configuration/data-persistence" >}}), [Data Persistence with Redis Enterprise Software]({{<relref "/operate/rs/databases/configure/database-persistence" >}})
+{{%/definition%}}
+
+## C {#letter-c}
+
+{{%definition "causal consistency"%}}
+A distributed database is causally consistent if it maintains the same order of operations on a piece of data across all database copies.
+
+More info: [Causal consistency wikipedia](https://en.wikipedia.org/wiki/Causal_consistency), [Causal consistency in an Active-Active database]({{<relref "/operate/rs/databases/active-active/causal-consistency">}})
+{{%/definition%}}
+
+{{%definition "CIDR allowlist"%}}
+Classless Inter-Domain Routing (CIDR) is a method to allocate and route IP addresses. A CIDR allowlist defines a range of IP addresses and permits connections to them.
+
+More info: [CIDR wikipedia](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing), [Configure CIDR allowlist]({{<relref "/operate/rc/security/cidr-whitelist">}})
+{{%/definition%}}
+
+{{%definition "concurrent writes"%}}
+
+Concurrency or updates and writes refer to more than events that happen at the same wall clock time across member Active-Active databases. Concurrent updates refer to the fact that updates happen in between sync events that catch up member Active-Active databases with updates that happened on other member Active-Active databases.
+
+{{%/definition%}}
+
+{{%definition "consistency"%}}
+
+Consistency models describe the way a distributed system keeps replicated data consistent between copies.
+
+More info: [Consistency models](https://en.wikipedia.org/wiki/Consistency_model)
+
+{{%/definition%}}
+
+{{%definition "cluster"%}}
+A Redis Enterprise cluster is composed of identical nodes that are deployed within a data center or stretched across local availability zones.
+
+More info: [Database clustering]({{<relref "/operate/rc/databases/configuration/clustering" >}})
+{{%/definition%}}
+
+{{%definition "Cluster Configuration Store (CCS)"%}}
+An internally managed Redis database that acts as a single repository for all cluster metadata.
+{{%/definition%}}
+
+{{%definition "Cluster Node Manager (CNM)"%}}
+A collection of Redis Enterprise services responsible for provisioning, migration, monitoring, re-sharding, re-balancing, de-provisioning, auto-scaling
+{{%/definition%}}
+
+{{%definition "conflict-free replicated databases (CRDB)"%}}
+
+Conflict-free replicated databases (CRDB) are an alternate name for [Active-Active databases](#active-active).
+{{%/definition%}}
+
+{{%definition "conflict-free replicated data types (CRDT)"%}}
+Techniques used by Redis data types in Active-Active databases that handle conflicting concurrent writes across member Active-Active databases. The Redis Enterprise implementation of CRDT is called an Active-Active database (formerly known as CRDB).
+
+More info: [CRDT info]({{<relref "/operate/rs/databases/active-active/develop/#info" >}}), [Active-Active geo-distributed Redis]({{< relref "/operate/rs/databases/active-active" >}}), [CRDT wikipedia](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)
+{{%/definition%}}
+
+{{%definition "CustomResourceDefinition (CRD)"%}}
+Custom code that defines a resource to add to your Kubernetes API server without building a complete custom server. 
+
+More info: [CustomResourceDefinition](https://kubernetes.io/docs/reference/glossary/?fundamental=true#term-CustomResourceDefinition), [Custom Resources](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)
+{{%/definition%}}
+
+## D - F {#letter-d}
+
+{{%definition "data eviction policy"%}}
+Defines how excess data is handled when the database exceeds the memory limit.
+
+More info: [Data Eviction Policy]({{<relref "/operate/rc/databases/configuration/data-eviction-policies">}})
+{{%/definition%}}
+
+{{%definition "deprecated"%}}
+Features are marked as _deprecated_ when they're scheduled to be removed from our products, generally because they've been replaced by new features.
+
+For details, see [obsolete](#obsolete).
+{{%/definition%}}
+
+{{%definition "Domain Name Service (DNS)"%}}
+Naming system for computers, services, or other resources connected to the Internet or a private network. It associates various information with domain names assigned to each of the participating entities.
+
+More info: [DNS wikipedia](https://en.wikipedia.org/wiki/Domain_Name_System)
+{{%/definition%}}
+
+{{%definition "eventual consistency"%}}
+
+After updating data on one instance of a distributed database, the other database copies may have stale data for a short time while they sync. Eventual consistency means that the updated data will eventually be the same across all database copies.
+
+More info: [Eventual consistency wikipedia](https://en.wikipedia.org/wiki/Eventual_consistency)
+{{%/definition%}}
+
+{{%definition "Fully qualified domain name (FQDN)"%}}
+A domain name that includes a list of domain labels to specify the exact location in the DNS.
+
+More info: [FQDN wikipedia](https://en.wikipedia.org/wiki/Fully_qualified_domain_name)
+
+{{%/definition%}}
+
+{{%definition "`fysnc`"%}}
+Linux command to synchronize a file's in-core state with a storage device
+
+More info: [`fsync` man page](https://man7.org/linux/man-pages/man2/fsync.2.html)
+{{%/definition%}}
+
+## G - J {#letter-g}
+
+{{%definition "hash slot"%}}
+The result of a hash calculation.
+
+More info: [Database clustering]({{<relref "/operate/rs/databases/durability-ha/clustering">}})
+{{%/definition%}}
+
+{{%definition "hash tag"%}}
+A part of the key that is used in the hash calculation.
+
+More info: [Database clustering]({{<relref "/operate/rs/databases/durability-ha/clustering">}})
+{{%/definition%}}
+
+{{%definition "high availability"%}}
+
+High availability (HA) is a characteristic of distributed systems that keeps systems available for users for longer than normal periods of time. This is done by reducing single points of failure, increasing redundancy, and making recovering from failures easier.
+
+More info: [Redis Enterprise durability and high availability]({{<relref "/operate/rs/databases/durability-ha/">}}), [High availability wikipedia](https://en.wikipedia.org/wiki/High_availability)
+{{%/definition%}}
+
+{{%definition "ingress"%}}
+An API object that manages external access to the services in a Kubernetes cluster, typically HTTP.
+
+More info: [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/), [Ingress routing for Redis Enterprise for Kubernetes]({{<relref "/operate/kubernetes/networking/ingress">}})
+{{%/definition%}}
+
+## K, L {#letter-k}
+
+{{%definition "kubectl"%}}
+A command-line tool for communicating with a Kubernetes API server.
+
+More info: [Overview of kubectl](https://kubernetes.io/docs/reference/kubectl/overview/)
+{{%/definition%}}
+
+{{%definition "Lightweight Directory Access Protocol (LDAP)"%}}
+A protocol for accessing and maintaining distributed directory services over an IP network, often used to authenticate users.
+
+More info: [LDAP wikipedia](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol), [LDAP authentication]({{<relref "/operate/rs/security/access-control/ldap">}})
+{{%/definition%}}
+
+## M - O {#letter-m}
+
+{{%definition "master node"%}}
+Node that operates as the leader of a cluster. Also known as the primary node.
+{{%/definition%}}
+
+{{%definition "migration"%}}
+Deciding when and where shards will be moved if more network throughput, memory, or CPU resources are needed
+{{%/definition%}}
+
+{{%definition "multicast DNS (mDNS)"%}}
+Protocol that resolves hostnames to the IP addresses that do not include a local name server.
+
+More info: [multicast DNS wikipedia](https://en.wikipedia.org/wiki/Multicast_DNS)
+{{%/definition%}}
+
+{{%definition "multi-factor authentication (MFA)"%}}
+Method of authenticating users with pieces of evidence of the user's identity. When MFA is enabled on Redis Cloud, users must enter their username, password, and an authentication code when logging in.
+
+More info: [Multi-factor authentication]({{<relref "/operate/rc/security/access-control/multi-factor-authentication">}})
+{{%/definition%}}
+
+{{%definition "multi-primary replication"%}}
+Also known as multi-master replication, Active-Active databases have multiple primary nodes (one on each participating cluster) to enable concurrent writes operations.
+
+More info: [Multi-primary replication]({{<relref "/operate/rs/databases/active-active/#multi-primary-replication">}})
+
+{{%/definition%}}
+
+{{%definition "namespace"%}}
+An abstraction used by Kubernetes to support multiple virtual clusters on the same physical cluster.
+
+More info: [Namespaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)
+{{%/definition%}}
+
+{{%definition "obsolete"%}}
+When features are removed from our products, they're generally replaced by new features that provide a better experience, more functionality, improved security, and other benefits.  
+
+To provide a transition period, we mark older features as _deprecated_ when introducing replacement features.  This gives you time to adjust your deployments, apps, and processes to support the new features.  During this transition, the older features continue to work as a courtesy.
+
+Eventually, older features are removed from the product.  When this happens, they're considered _obsolete_, partly because they can no longer be used.  
+
+For best results, we advise against relying on deprecated features for any length of time.  
+{{%/definition%}}
+
+{{%definition "operator"%}}
+Operators are software extensions to Kubernetes that make use of custom resources to manage applications and their components.
+
+More info: [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/)
+{{%/definition%}}
+
+{{%definition "Out-of-Memory (OOM)"%}}
+If a member Active-Active database is in an out of memory situation, that member is marked “inconsistent” by Redis Enterprise Software, the member stops responding to user traffic, and the syncer initiates full reconciliation with other peers in the Active-Active database.
+{{%/definition%}}
+
+## P - Q {#letter-p}
+
+{{%definition "participating clusters"%}}
+Clusters participating in the multi-primary replication of an Active-Active database.
+{{%/definition%}}
+
+{{%definition "provisioning"%}}
+Deciding where shards will be created and placed.
+{{%/definition%}}
+
+{{%definition "proxy policy"%}}
+Determines the number and location of active proxies tied to a single endpoint that receive incoming traffic for a database.
+
+For more info, see [Proxy policy]({{<relref "/operate/rs/databases/configure/proxy-policy">}}).
+{{%/definition%}}
+
+{{%definition "quorum node"%}}
+Node provisioned only for cluster operations that can be elected as a master node. The quorum node participates in the cluster quorum and must be explicitly assigned this role via the `rladmin` command.
+{{%/definition%}}
+
+## R {#letter-r}
+
+{{%definition "rack-zone awareness"%}}
+Redis Enterprise feature that helps to ensure high availability in the event of a rack or zone failure. In the event of a rack or zone failure, the replicas and endpoints in the remaining racks/zones will be promoted.
+
+More info: [Rack-zone awareness in Redis Enterprise Software]({{<relref "/operate/rs/clusters/configure/rack-zone-awareness">}})
+{{%/definition%}}
+
+{{%definition "replication backlog"%}}
+Databases using replication or Active-Active maintain a backlog to synchronize the primary and replica shards.
+{{%/definition%}}
+
+{{%definition "re-sharding"%}}
+Distributing keys and their values among new shards.
+{{%/definition%}}
+
+{{%definition "rebalancing"%}}
+Moving shards to nodes where more resources are available.
+{{%/definition%}}
+
+{{%definition "Redis Cloud"%}}
+The cloud version of Redis Enterprise.
+{{%/definition%}}
+
+{{%definition "Redis Enterprise cluster"%}}
+Collection of Redis Enterprise nodes. A cluster pools system resources across nodes in the cluster and supports multi-tenant database instances.
+{{%/definition%}}
+
+{{%definition "Redis Enterprise database"%}}
+Logical entity that manages your entire dataset across multiple Redis instances. It segments the data into shards and distributes them among nodes.
+{{%/definition%}}
+
+{{%definition "Redis Enterprise nodes"%}}
+Physical or virtual machines or containers that runs a collection of Redis Enterprise services
+{{%/definition%}}
+
+{{%definition "Redis Enterprise Software"%}}
+The on-premises version of Redis Enterprise.
+{{%/definition%}}
+
+{{%definition "Redis instance"%}}
+Single-threaded Redis Open Source database. Redis OSS was renamed Redis Open Source with the Redis 8 in Redis Open Source release.
+{{%/definition%}}
+
+{{%definition "Auto Tiering "%}}
+Previously known as Redis on Flash. Enables your Redis databases to span both RAM and dedicated flash memory (SSD). Auto Tiering manages the location of key values (RAM vs Flash) in the database via a LRU-based (least-recently-used) mechanism.
+
+More info: [Auto Tiering]({{<relref "/operate/rs/databases/auto-tiering/">}}), [Auto Tiering  quick start]({{<relref "/operate/rs/databases/auto-tiering/quickstart">}})
+{{%/definition%}}
+
+{{%definition "replica high availability (replicaHA)"%}}
+High availability feature of Redis Enterprise Software. After a node failure, the cluster automatically migrates remaining replica shards to available nodes. Previously known as "Slave HA" or `slave_ha`.
+
+More info: [High availability for replica shards]({{<relref "/operate/rs/databases/configure/replica-ha">}})
+{{%/definition%}}
+
+{{%definition "Replica Of"%}}
+The Redis Enterprise implementation of active-passive database replication.
+
+More info: [Replica Of
+]({{<relref "/operate/rs/databases/import-export/replica-of/">}})
+{{%/definition%}}
+
+{{%definition "ReplicaSet"%}}
+A ReplicaSet is a type of Kubernetes resource that (aims to) maintain a set of replica pods running at any given time.
+
+More info: [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)
+{{%/definition%}}
+
+{{%definition "replication"%}}
+
+Database replication provides a mechanism to 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.
+
+More info: [Database replication]({{<relref "/operate/rs/databases/durability-ha/replication">}})
+{{%/definition%}}
+
+{{%definition "role-based access control (RBAC)"%}}
+A security approach that restricts system access to authorized users.
+
+More info: [RBAC wikipedia](https://en.wikipedia.org/wiki/Role-based_access_control); [Database access control]({{<relref "/operate/rs/security/access-control">}}); [Role-based access control]({{<relref "/operate/rc/security/access-control/data-access-control/role-based-access-control">}})
+{{%/definition%}}
+
+## S {#letter-s}
+
+{{%definition "secret"%}}
+Kubernetes term for object that stores sensitive information, such as passwords, OAuth tokens, and ssh keys.
+{{%/definition%}}
+
+{{%definition "shard"%}}
+Redis process that is part of the Redis clustered database.
+
+More info: [Database clustering]({{<relref "/operate/rs/databases/durability-ha/clustering">}}), [terminology]({{<relref "/operate/rs/references/terminology">}})
+{{%/definition%}}
+
+{{%definition "sharding"%}}
+Technique that has been used to scale larger data storage and processing loads. Sharding take your data, partitions it into smaller pieces and then send the data to different locations depending on which partition the data has been assigned to.
+{{%/definition%}}
+
+{{%definition "Simple Authentication and Security Layer (SASL)"%}}
+Framework for adding authentication support and data security to connection-based protocols via replaceable mechanisms.
+
+More info: [SASL wikipedia](https://en.wikipedia.org/wiki/Simple_Authentication_and_Security_Layer)
+{{%/definition%}}
+
+{{%definition "snapshot (RDB)"%}}
+Data persistence file that performs a data dump every one, six, or twelve hours.
+{{%/definition%}}
+
+{{%definition "syncer"%}}
+Process on each node hosting an Active-Active database instance that synchronizes a backlog of operations between participating clusters.
+
+More info: [Syncer process]({{<relref "/operate/rs/databases/active-active/syncer">}})
+{{%/definition%}}
+
+## T - Z {#letter-t}
+
+{{%definition "tombstone"%}}
+
+A key that is logically deleted but stays in memory until it is collected by the garbage collector.
+
+{{%/definition%}}
+
+{{%definition "Transport Layer Security (TLS)"%}}
+Protocols that provide communications security over a computer network.
+
+More info: [TLS wikipedia](https://en.wikipedia.org/wiki/Transport_Layer_Security), [Cloud database TLS]({{<relref "/operate/rc/security/database-security/tls-ssl">}}), [Redis Enterprise TLS]({{<relref "/operate/rs/security/encryption/tls">}})
+{{%/definition%}}
+
+{{%definition "VPC peering"%}}
+Networking connection between two VPCs that enables you to route traffic between them using private IP addresses. Instances in either VPC can communicate with each other as if they are within the same network.
+
+More info: [VPC wikipedia](https://en.wikipedia.org/wiki/Virtual_private_cloud), [Enable VPC peering]({{<relref "/operate/rc/security/vpc-peering">}})
+{{%/definition%}}
+
+
+</dl>
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: stop
+  name: stop
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements removed by the operation.
+description: Removes members in a sorted set within a range of indexes. Deletes the
+  sorted set if all members were removed.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREMRANGEBYRANK
+since: 2.0.0
+summary: Removes members in a sorted set within a range of indexes. Deletes the sorted
+  set if all members were removed.
+syntax_fmt: ZREMRANGEBYRANK key start stop
+syntax_str: start stop
+title: ZREMRANGEBYRANK
+---
+Removes all elements in the sorted set stored at `key` with rank between `start`
+and `stop`.
+Both `start` and `stop` are `0` -based indexes with `0` being the element with
+the lowest score.
+These indexes can be negative numbers, where they indicate offsets starting at
+the element with the highest score.
+For example: `-1` is the element with the highest score, `-2` the element with
+the second highest score and so forth.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREMRANGEBYRANK myzset 0 1
+ZRANGE myzset 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Return information about a vector set.
+group: vector_set
+hidden: false
+linkTitle: VINFO
+since: 8.0.0
+summary: Return information about a vector set.
+syntax_fmt: "VINFO key"
+title: VINFO
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return metadata and internal details about a vector set, including size, dimensions, quantization type, and graph structure.
+
+```shell
+VINFO word_embeddings
+1) quant-type
+2) int8
+3) vector-dim
+4) (integer) 300
+5) size
+6) (integer) 3000000
+7) max-level
+8) (integer) 12
+9) vset-uid
+10) (integer) 1
+11) hnsw-max-node-uid
+12) (integer) 3000000
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: string
+- display_text: max
+  name: max
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(log(N)) with N being the number of elements in the sorted set.
+description: Returns the number of members in a sorted set within a lexicographical
+  range.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZLEXCOUNT
+since: 2.8.9
+summary: Returns the number of members in a sorted set within a lexicographical range.
+syntax_fmt: ZLEXCOUNT key min max
+syntax_str: min max
+title: ZLEXCOUNT
+---
+When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns the number of elements in the sorted set at `key` with a value between `min` and `max`.
+
+The `min` and `max` arguments have the same meaning as described for
+[`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}).
+
+Note: the command has a complexity of just O(log(N)) because it uses elements ranks (see [`ZRANK`]({{< relref "/commands/zrank" >}})) to get an idea of the range. Because of this there is no need to do a work proportional to the size of the range.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 0 a 0 b 0 c 0 d 0 e
+ZADD myzset 0 f 0 g
+ZLEXCOUNT myzset - +
+ZLEXCOUNT myzset [b [f
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: query
+  type: string
+- name: dialect
+  optional: true
+  since: 2.4.3
+  token: DIALECT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the execution plan for a complex query
+group: search
+hidden: false
+linkTitle: FT.EXPLAIN
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Returns the execution plan for a complex query
+syntax: "FT.EXPLAIN index query \n  [DIALECT dialect]\n"
+syntax_fmt: "FT.EXPLAIN index query [DIALECT\_dialect]"
+syntax_str: "query [DIALECT\_dialect]"
+title: FT.EXPLAIN
+---
+
+Return the execution plan for a complex query
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>query</code></summary>
+
+is query string, as if sent to FT.SEARCH`.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>DIALECT {dialect_version}</code></summary>
+
+is dialect version under which to execute the query. If not specified, the query executes under the default dialect version set during module initial loading or via [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) command.
+</details>
+
+{{% alert title="Notes" color="warning" %}}
+ 
+- In the returned response, a `+` on a term is an indication of stemming.
+- Use `redis-cli --raw` to properly read line-breaks in the returned response.
+
+{{% /alert %}}
+
+## Return
+
+FT.EXPLAIN returns a string representing the execution plan.
+
+## Examples
+
+<details open>
+<summary><b>Return the execution plan for a complex query</b></summary>
+
+{{< highlight bash >}}
+$ redis-cli --raw
+
+127.0.0.1:6379> FT.EXPLAIN rd "(foo bar)|(hello world) @date:[100 200]|@date:[500 +inf]"
+INTERSECT {
+  UNION {
+    INTERSECT {
+      foo
+      bar
+    }
+    INTERSECT {
+      hello
+      world
+    }
+  }
+  UNION {
+    NUMERIC {100.000000 <= x <= 200.000000}
+    NUMERIC {500.000000 <= x <= inf}
+  }
+}
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) | [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) | [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: stop
+  name: stop
+  type: integer
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements returned.
+deprecated_since: 6.2.0
+description: Returns members in a sorted set within a range of indexes in reverse
+  order.
+doc_flags:
+- deprecated
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREVRANGE
+replaced_by: '[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `REV` argument'
+since: 1.2.0
+summary: Returns members in a sorted set within a range of indexes in reverse order.
+syntax_fmt: ZREVRANGE key start stop [WITHSCORES]
+syntax_str: start stop [WITHSCORES]
+title: ZREVRANGE
+---
+Returns the specified range of elements in the sorted set stored at `key`.
+The elements are considered to be ordered from the highest to the lowest score.
+Descending lexicographical order is used for elements with equal score.
+
+Apart from the reversed ordering, `ZREVRANGE` is similar to [`ZRANGE`]({{< relref "/commands/zrange" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREVRANGE myzset 0 -1
+ZREVRANGE myzset 2 3
+ZREVRANGE myzset -2 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Advances the cluster config epoch.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER BUMPEPOCH
+since: 3.0.0
+summary: Advances the cluster config epoch.
+syntax_fmt: CLUSTER BUMPEPOCH
+syntax_str: ''
+title: CLUSTER BUMPEPOCH
+---
+Advances the cluster config epoch.
+
+The `CLUSTER BUMPEPOCH` command triggers an increment to the cluster's config epoch from the connected node. The epoch will be incremented if the node's config epoch is zero, or if it is less than the cluster's greatest epoch.
+
+**Note:** config epoch management is performed internally by the cluster, and relies on obtaining a consensus of nodes. The `CLUSTER BUMPEPOCH` attempts to increment the config epoch **WITHOUT** getting the consensus, so using it may violate the "last failover wins" rule. Use it with caution.
+---
+acl_categories:
+- '@read'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  name: element
+  type: string
+- display_text: rank
+  name: rank
+  optional: true
+  token: RANK
+  type: integer
+- display_text: num-matches
+  name: num-matches
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: len
+  name: len
+  optional: true
+  token: MAXLEN
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the number of elements in the list, for the average case.
+  When searching for elements near the head or the tail of the list, or when the MAXLEN
+  option is provided, the command may run in constant time.
+description: Returns the index of matching elements in a list.
+group: list
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LPOS
+since: 6.0.6
+summary: Returns the index of matching elements in a list.
+syntax_fmt: "LPOS key element [RANK\_rank] [COUNT\_num-matches] [MAXLEN\_len]"
+syntax_str: "element [RANK\_rank] [COUNT\_num-matches] [MAXLEN\_len]"
+title: LPOS
+---
+The command returns the index of matching elements inside a Redis list.
+By default, when no options are given, it will scan the list from head to tail,
+looking for the first match of "element". If the element is found, its index (the zero-based position in the list) is returned. Otherwise, if no match is found, `nil` is returned.
+
+```
+> RPUSH mylist a b c 1 2 3 c c
+> LPOS mylist c
+2
+```
+
+The optional arguments and options can modify the command's behavior.
+The `RANK` option specifies the "rank" of the first element to return, in case there are multiple matches. A rank of 1 means to return the first match, 2 to return the second match, and so forth.
+
+For instance, in the above example the element "c" is present multiple times, if I want the index of the second match, I'll write:
+
+```
+> LPOS mylist c RANK 2
+6
+```
+
+That is, the second occurrence of "c" is at position 6.
+A negative "rank" as the `RANK` argument tells `LPOS` to invert the search direction, starting from the tail to the head.
+
+So, we want to say, give me the first element starting from the tail of the list:
+
+```
+> LPOS mylist c RANK -1
+7
+```
+
+Note that the indexes are still reported in the "natural" way, that is, considering the first element starting from the head of the list at index 0, the next element at index 1, and so forth. This basically means that the returned indexes are stable whatever the rank is positive or negative.
+
+Sometimes we want to return not just the Nth matching element, but the position of all the first N matching elements. This can be achieved using the `COUNT` option.
+
+```
+> LPOS mylist c COUNT 2
+[2,6]
+```
+
+We can combine `COUNT` and `RANK`, so that `COUNT` will try to return up to the specified number of matches, but starting from the Nth match, as specified by the `RANK` option.
+
+```
+> LPOS mylist c RANK -1 COUNT 2
+[7,6]
+```
+
+When `COUNT` is used, it is possible to specify 0 as the number of matches, as a way to tell the command we want all the matches found returned as an array of indexes. This is better than giving a very large `COUNT` option because it is more general.
+
+```
+> LPOS mylist c COUNT 0
+[2,6,7]
+```
+
+When `COUNT` is used and no match is found, an empty array is returned. However when `COUNT` is not used and there are no matches, the command returns `nil`.
+
+Finally, the `MAXLEN` option tells the command to compare the provided element only with a given maximum number of list items. So for instance specifying `MAXLEN 1000` will make sure that the command performs only 1000 comparisons, effectively running the algorithm on a subset of the list (the first part or the last part depending on the fact we use a positive or negative rank). This is useful to limit the maximum complexity of the command. It is also useful when we expect the match to be found very early, but want to be sure that in case this is not true, the command does not take too much time to run.
+
+When `MAXLEN` is used, it is possible to specify 0 as the maximum number of comparisons, as a way to tell the command we want unlimited comparisons. This is better than giving a very large `MAXLEN` option because it is more general.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist a b c d 1 2 3 4 3 3 3
+LPOS mylist 3
+LPOS mylist 3 COUNT 0 RANK 2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: command
+  multiple: true
+  name: command
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of commands with latency information being
+  retrieved.
+description: Returns the cumulative distribution of latencies of a subset or all commands.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_nodes
+- response_policy:special
+linkTitle: LATENCY HISTOGRAM
+since: 7.0.0
+summary: Returns the cumulative distribution of latencies of a subset or all commands.
+syntax_fmt: LATENCY HISTOGRAM [command [command ...]]
+syntax_str: ''
+title: LATENCY HISTOGRAM
+---
+`LATENCY HISTOGRAM` returns a cumulative distribution of commands' latencies in histogram format.
+
+By default, all available latency histograms are returned.
+You can filter the reply by providing specific command names.
+
+Each histogram consists of the following fields:
+
+* Command name
+* The total calls for that command
+* A map of time buckets:
+  * Each bucket represents a latency range
+  * Each bucket covers twice the previous bucket's range
+  * Empty buckets are excluded from the reply
+  * The tracked latencies are between 1 nanosecond and roughly 1 second
+  * Everything above 1 second is considered +Inf
+  * At max, there will be log2(1,000,000,000) = 30 buckets
+
+This command requires the extended latency monitoring feature to be enabled, which is the default.
+If you need to enable it, call `CONFIG SET latency-tracking yes`.
+
+To delete the latency histograms' data use the [`CONFIG RESETSTAT`]({{< relref "/commands/config-resetstat" >}}) command.
+
+## Examples
+
+```
+127.0.0.1:6379> LATENCY HISTOGRAM set
+1# "set" =>
+   1# "calls" => (integer) 100000
+   2# "histogram_usec" =>
+      1# (integer) 1 => (integer) 99583
+      2# (integer) 2 => (integer) 99852
+      3# (integer) 4 => (integer) 99914
+      4# (integer) 8 => (integer) 99940
+      5# (integer) 16 => (integer) 99968
+      6# (integer) 33 => (integer) 100000
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: slot
+  name: slot
+  type: integer
+- arguments:
+  - display_text: node-id
+    name: importing
+    token: IMPORTING
+    type: string
+  - display_text: node-id
+    name: migrating
+    token: MIGRATING
+    type: string
+  - display_text: node-id
+    name: node
+    token: NODE
+    type: string
+  - display_text: stable
+    name: stable
+    token: STABLE
+    type: pure-token
+  name: subcommand
+  type: oneof
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Binds a hash slot to a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER SETSLOT
+since: 3.0.0
+summary: Binds a hash slot to a node.
+syntax_fmt: "CLUSTER SETSLOT slot <IMPORTING\_node-id | MIGRATING\_node-id |\n  NODE\_\
+  node-id | STABLE>"
+syntax_str: "<IMPORTING\_node-id | MIGRATING\_node-id | NODE\_node-id | STABLE>"
+title: CLUSTER SETSLOT
+---
+`CLUSTER SETSLOT` is responsible of changing the state of a hash slot in the receiving node in different ways. It can, depending on the subcommand used:
+
+1. `MIGRATING` subcommand: Set a hash slot in *migrating* state.
+2. `IMPORTING` subcommand: Set a hash slot in *importing* state.
+3. `STABLE` subcommand: Clear any importing / migrating state from hash slot.
+4. `NODE` subcommand: Bind the hash slot to a different node.
+
+The command with its set of subcommands is useful in order to start and end cluster live resharding operations, which are accomplished by setting a hash slot in migrating state in the source node, and importing state in the destination node.
+
+Each subcommand is documented below. At the end you'll find a description of
+how live resharding is performed using this command and other related commands.
+
+## CLUSTER SETSLOT `<slot>` MIGRATING `<destination-node-id>`
+
+This subcommand sets a slot to *migrating* state. In order to set a slot
+in this state, the node receiving the command must be the hash slot owner,
+otherwise an error is returned.
+
+When a slot is set in migrating state, the node changes behavior in the
+following way:
+
+1. If a command is received about an existing key, the command is processed as usually.
+2. If a command is received about a key that does not exists, an `ASK` redirection is emitted by the node, asking the client to retry only that specific query into `destination-node`. In this case the client should not update its hash slot to node mapping.
+3. If the command contains multiple keys, in case none exist, the behavior is the same as point 2, if all exist, it is the same as point 1, however if only a partial number of keys exist, the command emits a `TRYAGAIN` error in order for the keys interested to finish being migrated to the target node, so that the multi keys command can be executed.
+
+## CLUSTER SETSLOT `<slot>` IMPORTING `<source-node-id>`
+
+This subcommand is the reverse of `MIGRATING`, and prepares the destination
+node to import keys from the specified source node. The command only works if
+the node is not already owner of the specified hash slot.
+
+When a slot is set in importing state, the node changes behavior in the following way:
+
+1. Commands about this hash slot are refused and a `MOVED` redirection is generated as usually, but in the case the command follows an [`ASKING`]({{< relref "/commands/asking" >}}) command, in this case the command is executed.
+
+In this way when a node in migrating state generates an `ASK` redirection, the client contacts the target node, sends [`ASKING`]({{< relref "/commands/asking" >}}), and immediately after sends the command. This way commands about non-existing keys in the old node or keys already migrated to the target node are executed in the target node, so that:
+
+1. New keys are always created in the target node. During a hash slot migration we'll have to move only old keys, not new ones.
+2. Commands about keys already migrated are correctly processed in the context of the node which is the target of the migration, the new hash slot owner, in order to guarantee consistency.
+3. Without [`ASKING`]({{< relref "/commands/asking" >}}) the behavior is the same as usually. This guarantees that clients with a broken hash slots mapping will not write for error in the target node, creating a new version of a key that has yet to be migrated.
+
+## CLUSTER SETSLOT `<slot>` STABLE
+
+This subcommand just clears migrating / importing state from the slot. It is
+mainly used to fix a cluster stuck in a wrong state by `redis-cli --cluster fix`.
+Normally the two states are cleared automatically at the end of the migration
+using the `SETSLOT ... NODE ...` subcommand as explained in the next section.
+
+## CLUSTER SETSLOT `<slot>` NODE `<node-id>`
+
+The `NODE` subcommand is the one with the most complex semantics. It
+associates the hash slot with the specified node, however the command works
+only in specific situations and has different side effects depending on the
+slot state. The following is the set of pre-conditions and side effects of the
+command:
+
+1. If the current hash slot owner is the node receiving the command, but for effect of the command the slot would be assigned to a different node, the command will return an error if there are still keys for that hash slot in the node receiving the command.
+2. If the slot is in *migrating* state, the state gets cleared when the slot is assigned to another node.
+3. If the slot was in *importing* state in the node receiving the command, and the command assigns the slot to this node (which happens in the target node at the end of the resharding of a hash slot from one node to another), the command has the following side effects: A) the *importing* state is cleared. B) If the node config epoch is not already the greatest of the cluster, it generates a new one and assigns the new config epoch to itself. This way its new hash slot ownership will win over any past configuration created by previous failovers or slot migrations.
+
+It is important to note that step 3 is the only time when a Redis Cluster node will create a new config epoch without agreement from other nodes. This only happens when a manual configuration is operated. However it is impossible that this creates a non-transient setup where two nodes have the same config epoch, since Redis Cluster uses a config epoch collision resolution algorithm.
+
+## Redis Cluster live resharding explained
+
+The `CLUSTER SETSLOT` command is an important piece used by Redis Cluster in order to migrate all the keys contained in one hash slot from one node to another. This is how the migration is orchestrated, with the help of other commands as well. We'll call the node that has the current ownership of the hash slot the `source` node, and the node where we want to migrate the `destination` node.
+
+1. Set the destination node slot to *importing* state using `CLUSTER SETSLOT <slot> IMPORTING <source-node-id>`.
+2. Set the source node slot to *migrating* state using `CLUSTER SETSLOT <slot> MIGRATING <destination-node-id>`.
+3. Get keys from the source node with [`CLUSTER GETKEYSINSLOT`]({{< relref "/commands/cluster-getkeysinslot" >}}) command and move them into the destination node using the [`MIGRATE`]({{< relref "/commands/migrate" >}}) command.
+4. Send `CLUSTER SETSLOT <slot> NODE <destination-node-id>` to the destination node.
+5. Send `CLUSTER SETSLOT <slot> NODE <destination-node-id>` to the source node.
+6. Send `CLUSTER SETSLOT <slot> NODE <destination-node-id>` to the other master nodes (optional).
+
+Notes:
+
+* The order of step 1 and 2 is important. We want the destination node to be ready to accept `ASK` redirections when the source node is configured to redirect.
+* The order of step 4 and 5 is important.
+  The destination node is responsible for propagating the change to the rest of the cluster.
+  If the source node is informed before the destination node and the destination node crashes before it is set as new slot owner, the slot is left with no owner, even after a successful failover.
+* Step 6, sending `SETSLOT` to the nodes not involved in the resharding, is not technically necessary since the configuration will eventually propagate itself.
+  However, it is a good idea to do so in order to stop nodes from pointing to the wrong node for the hash slot moved as soon as possible, resulting in less redirections to find the right node.
+---
+acl_categories:
+- '@write'
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: replace
+  name: replace
+  optional: true
+  token: REPLACE
+  type: pure-token
+- display_text: function-code
+  name: function-code
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- noscript
+complexity: O(1) (considering compilation time is redundant)
+description: Creates a library.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: FUNCTION LOAD
+since: 7.0.0
+summary: Creates a library.
+syntax_fmt: FUNCTION LOAD [REPLACE] function-code
+syntax_str: function-code
+title: FUNCTION LOAD
+---
+Load a library to Redis.
+
+The command's gets a single mandatory parameter which is the source code that implements the library.
+The library payload must start with Shebang statement that provides a metadata about the library (like the engine to use and the library name).
+Shebang format: `#!<engine name> name=<library name>`. Currently engine name must be `lua`.
+
+For the Lua engine, the implementation should declare one or more entry points to the library with the [`redis.register_function()` API]({{< relref "develop/interact/programmability/lua-api#redis.register_function" >}}).
+Once loaded, you can call the functions in the library with the [`FCALL`]({{< relref "/commands/fcall" >}}) (or [`FCALL_RO`]({{< relref "/commands/fcall_ro" >}}) when applicable) command.
+
+When attempting to load a library with a name that already exists, the Redis server returns an error.
+The `REPLACE` modifier changes this behavior and overwrites the existing library with the new contents.
+
+The command will return an error in the following circumstances:
+
+* An invalid _engine-name_ was provided.
+* The library's name already exists without the `REPLACE` modifier.
+* A function in the library is created with a name that already exists in another library (even when `REPLACE` is specified).
+* The engine failed in creating the library's functions (due to a compilation error, for example).
+* No functions were declared by the library.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+
+## Examples
+
+The following example will create a library named `mylib` with a single function, `myfunc`, that returns the first argument it gets.
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib \n redis.register_function('myfunc', function(keys, args) return args[1] end)"
+mylib
+redis> FCALL myfunc 0 hello
+"hello"
+```
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Enables read-only queries for a connection to a Redis Cluster replica
+  node.
+group: cluster
+hidden: false
+linkTitle: READONLY
+since: 3.0.0
+summary: Enables read-only queries for a connection to a Redis Cluster replica node.
+syntax_fmt: READONLY
+syntax_str: ''
+title: READONLY
+---
+Enables read queries for a connection to a Redis Cluster replica node. 
+
+Normally replica nodes will redirect clients to the authoritative master for
+the hash slot involved in a given command, however clients can use replicas
+in order to scale reads using the `READONLY` command.
+
+`READONLY` tells a Redis Cluster replica node that the client is willing to
+read possibly stale data and is not interested in running write queries.
+
+When the connection is in readonly mode, the cluster will send a redirection
+to the client only if the operation involves keys not served by the replica's
+master node. This may happen because:
+
+1. The client sent a command about hash slots never served by the master of this replica.
+2. The cluster was reconfigured (for example resharded) and the replica is no longer able to serve commands for a given hash slot.
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- name: low_cut_quantile
+  type: double
+- name: high_cut_quantile
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of centroids
+description: Returns an estimation of the mean value from the sketch, excluding observation
+  values outside the low and high cutoff quantiles
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.TRIMMED_MEAN
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns an estimation of the mean value from the sketch, excluding observation
+  values outside the low and high cutoff quantiles
+syntax_fmt: TDIGEST.TRIMMED_MEAN key low_cut_quantile high_cut_quantile
+syntax_str: low_cut_quantile high_cut_quantile
+title: TDIGEST.TRIMMED_MEAN
+---
+Returns an estimation of the mean value from the sketch, excluding observation values outside the low and high cutoff quantiles.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>low_cut_quantile</code></summary> 
+  
+Foating-point value in the range [0..1], should be lower than `high_cut_quantile`
+  
+When equal to 0: No low cut.
+  
+When higher than 0: Exclude observation values lower than this quantile.
+</details>
+
+<details open><summary><code>high_cut_quantile</code></summary> 
+  
+Floating-point value in the range [0..1], should be higher than `low_cut_quantile`  
+  
+When lower than 1: Exclude observation values higher than or equal to this quantile.
+
+When equal to 1: No high cut.
+</details>
+
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) estimation of the mean value. 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 1000
+OK
+redis> TDIGEST.ADD t 1 2 3 4 5 6 7 8 9 10
+OK
+redis> TDIGEST.TRIMMED_MEAN t 0.1 0.6
+"4"
+redis> TDIGEST.TRIMMED_MEAN t 0.3 0.9
+"6.5"
+redis> TDIGEST.TRIMMED_MEAN t 0 1
+"5.5"
+
+{{< / highlight >}}
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Get the sample with the highest timestamp from a given time series
+group: timeseries
+hidden: false
+linkTitle: TS.GET
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Get the sample with the highest timestamp from a given time series
+syntax: "TS.GET key \n  [LATEST]\n"
+syntax_fmt: TS.GET key [LATEST]
+syntax_str: '[LATEST]'
+title: TS.GET
+---
+
+Get the sample with the highest timestamp from a given time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary> 
+
+is used when a time series is a compaction. With `LATEST`, TS.GET reports the compacted value of the latest (possibly partial) bucket. Without `LATEST`, TS.GET does not report the latest (possibly partial) bucket. When a time series is not a compaction, `LATEST` is ignored.
+  
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest (possibly partial) bucket is also required. In such a case, use `LATEST`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of a single ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})) pair representing (timestamp, value(double)) of the sample with the highest timestamp
+- An empty [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - when the time series is empty
+- [] (invalid arguments, wrong key type, key does not exist, etc.)
+
+## Examples
+
+<details open>
+<summary><b>Get latest measured temperature for a city</b></summary>
+
+Create a time series to store the temperatures measured in Tel Aviv and add four measurements for Sun Jan 01 2023
+  
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+127.0.0.1:6379> TS.MADD temp:TLV 1672534800 12 temp:TLV 1672556400 16 temp:TLV 1672578000 21 temp:TLV 1672599600 14
+{{< / highlight >}}
+  
+Next, get the latest measured temperature (the temperature with the highest timestamp)
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.GET temp:TLV
+1) (integer) 1672599600
+2) 14
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Get latest maximal daily temperature for a city</b></summary>
+
+Create a time series to store the temperatures measured in Jerusalem
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:JLM LABELS type temp location JLM
+OK
+{{< / highlight >}}
+
+Next, create a compacted time series named _dailyAvgTemp:JLM_ containing one compacted sample per 24 hours: the maximum of all measurements taken from midnight to next midnight.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE dailyMaxTemp:JLM LABELS type temp location JLM
+OK
+127.0.0.1:6379> TS.CREATERULE temp:JLM dailyMaxTemp:JLM AGGREGATION max 86400000
+OK
+{{< / highlight >}}
+
+Add four measurements for Sun Jan 01 2023 and three measurements for Mon Jan 02 2023
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MADD temp:JLM 1672534800000 12 temp:JLM 1672556400000 16 temp:JLM 1672578000000 21 temp:JLM 1672599600000 14
+1) (integer) 1672534800000
+2) (integer) 1672556400000
+3) (integer) 1672578000000
+4) (integer) 1672599600000
+127.0.0.1:6379> TS.MADD temp:JLM 1672621200000 11 temp:JLM 1672642800000 21 temp:JLM 1672664400000 26
+1) (integer) 1672621200000
+2) (integer) 1672642800000
+3) (integer) 1672664400000
+{{< / highlight >}}
+  
+Next, get the latest maximum daily temperature; do not report the latest, possibly partial, bucket 
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.GET dailyMaxTemp:JLM
+1) (integer) 1672531200000
+2) 21
+{{< / highlight >}}
+
+Get the latest maximum daily temperature (the temperature with the highest timestamp); report the latest, possibly partial, bucket
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.GET dailyMaxTemp:JLM LATEST
+1) (integer) 1672617600000
+2) 26
+{{< / highlight >}}
+
+</details>
+  
+## See also
+
+[`TS.MGET`]({{< relref "commands/ts.mget/" >}})  
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@read'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: stop
+  name: stop
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(S+N) where S is the distance of start offset from HEAD for small lists,
+  from nearest end (HEAD or TAIL) for large lists; and N is the number of elements
+  in the specified range.
+description: Returns a range of elements from a list.
+group: list
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LRANGE
+since: 1.0.0
+summary: Returns a range of elements from a list.
+syntax_fmt: LRANGE key start stop
+syntax_str: start stop
+title: LRANGE
+---
+Returns the specified elements of the list stored at `key`.
+The offsets `start` and `stop` are zero-based indexes, with `0` being the first
+element of the list (the head of the list), `1` being the next element and so
+on.
+
+These offsets can also be negative numbers indicating offsets starting at the
+end of the list.
+For example, `-1` is the last element of the list, `-2` the penultimate, and so
+on.
+
+## Consistency with range functions in various programming languages
+
+Note that if you have a list of numbers from 0 to 100, `LRANGE list 0 10` will
+return 11 elements, that is, the rightmost item is included.
+This **may or may not** be consistent with behavior of range-related functions
+in your programming language of choice (think Ruby's `Range.new`, `Array#slice`
+or Python's `range()` function).
+
+## Out-of-range indexes
+
+Out of range indexes will not produce an error.
+If `start` is larger than the end of the list, an empty list is returned.
+If `stop` is larger than the actual end of the list, Redis will treat it like
+the last element of the list.
+
+## Examples
+
+{{< clients-example cmds_list lrange >}}
+redis> RPUSH mylist "one"
+(integer) 1
+redis> RPUSH mylist "two"
+(integer) 2
+redis> RPUSH mylist "three"
+(integer) 3
+redis> LRANGE mylist 0 0
+1) "one"
+redis> LRANGE mylist -3 2
+1) "one"
+2) "two"
+3) "three"
+redis> LRANGE mylist -100 100
+1) "one"
+2) "two"
+3) "three"
+redis> LRANGE mylist 5 10
+(empty array)
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+RPUSH mylist "one"
+RPUSH mylist "two"
+RPUSH mylist "three"
+LRANGE mylist 0 0
+LRANGE mylist -3 2
+LRANGE mylist -100 100
+LRANGE mylist 5 10
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: db
+  name: db
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Moves a key to another database.
+group: generic
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: MOVE
+since: 1.0.0
+summary: Moves a key to another database.
+syntax_fmt: MOVE key db
+syntax_str: db
+title: MOVE
+---
+Move `key` from the currently selected database (see [`SELECT`]({{< relref "/commands/select" >}})) to the specified
+destination database.
+When `key` already exists in the destination database, or it does not exist in
+the source database, it does nothing.
+It is possible to use `MOVE` as a locking primitive because of this.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the number of keys in the database.
+group: server
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:agg_sum
+linkTitle: DBSIZE
+since: 1.0.0
+summary: Returns the number of keys in the database.
+syntax_fmt: DBSIZE
+syntax_str: ''
+title: DBSIZE
+---
+Return the number of keys in the currently-selected database.
+---
+acl_categories:
+- '@topk'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: withcount
+  optional: true
+  token: WITHCOUNT
+  type: pure-token
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k*log(k)) where k is the value of top-k
+description: Return full list of items in Top K list
+group: topk
+hidden: false
+linkTitle: TOPK.LIST
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Return full list of items in Top K list
+syntax_fmt: TOPK.LIST key [WITHCOUNT]
+syntax_str: '[WITHCOUNT]'
+title: TOPK.LIST
+---
+Return full list of items in Top K list.
+
+### Parameters
+
+* **key**: Name of sketch where item is counted.
+* **WITHCOUNT**: Count of each element is returned.  
+
+## Return
+
+k (or less) items in Top K list.
+
+The list is sorted by decreased count estimation.
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - the names of items in the TopK list.
+If `WITHCOUNT` is requested, [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) and 
+[Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) pairs of the names of items in the TopK list and their count.
+
+## Examples
+
+```
+TOPK.LIST topk
+1) foo
+2) 42
+3) bar
+```
+
+```
+TOPK.LIST topk WITHCOUNT
+1) foo
+2) (integer) 12
+3) 42
+4) (integer) 7
+5) bar
+6) (integer) 2
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: 'on'
+    name: 'on'
+    token: 'ON'
+    type: pure-token
+  - display_text: 'off'
+    name: 'off'
+    token: 'OFF'
+    type: pure-token
+  name: enabled
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Sets the client eviction mode of the connection.
+group: connection
+hidden: false
+linkTitle: CLIENT NO-EVICT
+since: 7.0.0
+summary: Sets the client eviction mode of the connection.
+syntax_fmt: CLIENT NO-EVICT <ON | OFF>
+syntax_str: ''
+title: CLIENT NO-EVICT
+---
+The `CLIENT NO-EVICT` command sets the [client eviction]({{< relref "/develop/reference/clients" >}}#client-eviction) mode for the current connection.
+
+When turned on and client eviction is configured, the current connection will be excluded from the client eviction process even if we're above the configured client eviction threshold.
+
+When turned off, the current client will be re-included in the pool of potential clients to be evicted (and evicted if needed).
+
+See [client eviction]({{< relref "/develop/reference/clients" >}}#client-eviction) for more details.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the internal encoding of a Redis object.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: OBJECT ENCODING
+since: 2.2.3
+summary: Returns the internal encoding of a Redis object.
+syntax_fmt: OBJECT ENCODING key
+syntax_str: ''
+title: OBJECT ENCODING
+---
+Returns the internal encoding for the Redis object stored at `<key>`
+
+Redis objects can be encoded in different ways:
+
+* Strings can be encoded as: 
+
+    - `raw`, normal string encoding.
+    - `int`, strings representing integers in a 64-bit signed interval, encoded in this way to save space.
+    - `embstr`, an embedded string, which is an object where the internal simple dynamic string, `sds`, is an unmodifiable string allocated in the same chuck as the object itself.
+      `embstr` can be strings with lengths up to the hardcoded limit of `OBJ_ENCODING_EMBSTR_SIZE_LIMIT` or 44 bytes. 
+
+* Lists can be encoded as:
+ 
+    - `linkedlist`, simple list encoding. No longer used, an old list encoding.
+    - `ziplist`, Redis <= 6.2, a space-efficient encoding used for small lists.
+    - `listpack`, Redis >= 7.0, a space-efficient encoding used for small lists.
+    - `quicklist`, encoded as linkedlist of ziplists or listpacks.
+
+* Sets can be encoded as:
+
+    - `hashtable`, normal set encoding.
+    - `intset`, a special encoding used for small sets composed solely of integers.
+    - `listpack`, Redis >= 7.2, a space-efficient encoding used for small sets.
+
+* Hashes can be encoded as:
+
+    - `zipmap`, no longer used, an old hash encoding.
+    - `hashtable`, normal hash encoding.
+    - `ziplist`, Redis <= 6.2, a space-efficient encoding used for small hashes.
+    - `listpack`, Redis >= 7.0, a space-efficient encoding used for small hashes.
+
+* Sorted Sets can be encoded as:
+
+    - `skiplist`, normal sorted set encoding.
+    - `ziplist`, Redis <= 6.2, a space-efficient encoding used for small sorted sets.
+    - `listpack`, Redis >= 7.0, a space-efficient encoding used for small sorted sets.
+
+* Streams can be encoded as:
+
+  - `stream`, encoded as a radix tree of listpacks.
+
+All the specially encoded types are automatically converted to the general type once you perform an operation that makes it impossible for Redis to retain the space saving encoding.
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: capacity
+  optional: true
+  token: CAPACITY
+  type: integer
+- name: nocreate
+  optional: true
+  token: NOCREATE
+  type: pure-token
+- name: items
+  token: ITEMS
+  type: pure-token
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n * (k + i)), where n is the number of items, k is the number of sub-filters
+  and i is maxIterations
+description: Adds one or more items to a Cuckoo Filter if the items did not exist
+  previously. A filter will be created if it does not exist
+group: cf
+hidden: false
+linkTitle: CF.INSERTNX
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds one or more items to a Cuckoo Filter if the items did not exist previously.
+  A filter will be created if it does not exist
+syntax_fmt: "CF.INSERTNX key [CAPACITY\_capacity] [NOCREATE] ITEMS item [item ...]"
+syntax_str: "[CAPACITY\_capacity] [NOCREATE] ITEMS item [item ...]"
+title: CF.INSERTNX
+---
+Adds one or more items to a cuckoo filter if they did not exist previously, allowing the filter to be created with a custom capacity if it does not exist yet.
+
+This command is similar to [`CF.ADDNX`]({{< relref "commands/cf.addnx/" >}}), except that more than one item can be added and capacity can be specified.
+
+<note><b>Notes:</b>
+
+- This command is slower than [`CF.INSERT`]({{< relref "commands/cf.insert/" >}}) because it first checks whether each item exists.
+- Since [`CF.EXISTS`]({{< relref "commands/cf.exists/" >}}) can result in false positive, `CF.INSERTNX` may not add an item because it is supposedly already exist, which may be wrong.
+    
+</note>
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to add items to.
+
+If `key` does not exist - a new cuckoo filter is created.
+</details>
+
+<details open><summary><code>ITEMS item...</code></summary>
+
+One or more items to add.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>CAPACITY capacity</code></summary>
+    
+Specifies the desired capacity of the new filter, if this filter does not exist yet.
+    
+If the filter already exists, then this parameter is ignored.
+    
+If the filter does not exist yet and this parameter is *not* specified, then the filter is created with the module-level default capacity which is 1024.
+
+See [`CF.RESERVE`]({{< relref "commands/cf.reserve/" >}}) for more information on cuckoo filter capacities.
+</details>
+    
+<details open><summary><code>NOCREATE</code></summary>
+  
+If specified, prevents automatic filter creation if the filter does not exist (Instead, an error is returned).
+    
+This option is mutually exclusive with `CAPACITY`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where `0` means that the item's fingerprint already exists in the filter, `1` means that the item has been successfully added to the filter, and `-1` means that the item was not added because the filter is full.
+- [] on error (invalid arguments, wrong key type, etc.) and also when `NOCREATE` is specified and `key` does not exist.
+
+### Complexity
+
+O(n + i), where n is the number of `sub-filters` and i is `maxIterations`.
+Adding items requires up to 2 memory accesses per `sub-filter`.
+But as the filter fills up, both locations for an item might be full. The filter attempts to `Cuckoo` swap items up to `maxIterations` times.
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INSERTNX cf CAPACITY 1000 ITEMS item1 item2 
+1) (integer) 1
+2) (integer) 1
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> CF.INSERTNX cf CAPACITY 1000 ITEMS item1 item2 item3
+1) (integer) 0
+2) (integer) 0
+3) (integer) 1
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> CF.INSERTNX cf_new CAPACITY 1000 NOCREATE ITEMS item1 item2 
+(error) ERR not found
+{{< / highlight >}}
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: synonym_group_id
+  type: string
+- name: skipinitialscan
+  optional: true
+  token: SKIPINITIALSCAN
+  type: pure-token
+- multiple: true
+  name: term
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Creates or updates a synonym group with additional terms
+group: search
+hidden: false
+linkTitle: FT.SYNUPDATE
+module: Search
+since: 1.2.0
+stack_path: docs/interact/search-and-query
+summary: Creates or updates a synonym group with additional terms
+syntax: "FT.SYNUPDATE index synonym_group_id \n  [SKIPINITIALSCAN] term [term ...]\n"
+syntax_fmt: "FT.SYNUPDATE index synonym_group_id [SKIPINITIALSCAN] term [term\n  ...]"
+syntax_str: synonym_group_id [SKIPINITIALSCAN] term [term ...]
+title: FT.SYNUPDATE
+---
+
+Update a synonym group
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name.
+</details>
+
+<details open>
+<summary><code>synonym_group_id</code></summary>
+
+is synonym group to return.
+</details>
+
+Use FT.SYNUPDATE to create or update a synonym group with additional terms. The command triggers a scan of all documents.
+
+## Optional parameters
+
+<details open>
+<summary><code>SKIPINITIALSCAN</code></summary>
+
+does not scan and index, and only documents that are indexed after the update are affected.
+</details>
+
+## Return
+
+FT.SYNUPDATE returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Update a synonym group</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SYNUPDATE idx synonym hello hi shalom
+OK
+{{< / highlight >}}
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SYNUPDATE idx synonym SKIPINITIALSCAN hello hi shalom
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SYNDUMP`]({{< relref "commands/ft.syndump/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Returns the value of a field and deletes it from the hash.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HGETDEL
+since: 8.0.0
+summary: Returns the value of a field and deletes it from the hash.
+syntax_fmt: "HGETDEL key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HGETDEL
+---
+Get and delete the value of one or more fields of a given hash key. When the last field is deleted, the key will also be deleted.
+
+## Example
+
+```
+redis> HSET mykey field1 "Hello" field2 "World" field3 "!"
+(integer) 3
+redis> HGETALL mykey
+1) "field1"
+2) "Hello"
+3) "field2"
+4) "World"
+5) "field3"
+6) "!"
+redis> HGETDEL mykey FIELDS 2 field3 field4
+1) "!"
+2) (nil)
+redis> HGETALL mykey
+1) "field1"
+2) "Hello"
+3) "field2"
+4) "World"
+redis> HGETDEL mykey FIELDS 2 field1 field2
+1) "Hello"
+2) "World"
+redis> KEYS *
+(empty array)
+```
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Enables read-write queries for a connection to a Redis Cluster replica
+  node.
+group: cluster
+hidden: false
+linkTitle: READWRITE
+since: 3.0.0
+summary: Enables read-write queries for a connection to a Reids Cluster replica node.
+syntax_fmt: READWRITE
+syntax_str: ''
+title: READWRITE
+---
+Disables read queries for a connection to a Redis Cluster replica node.
+
+Read queries against a Redis Cluster replica node are disabled by default,
+but you can use the [`READONLY`]({{< relref "/commands/readonly" >}}) command to change this behavior on a per-
+connection basis. The `READWRITE` command resets the readonly mode flag
+of a connection back to readwrite.
+---
+acl_categories:
+- '@write'
+- '@hyperloglog'
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: subcommand
+  name: subcommand
+  type: string
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- admin
+complexity: N/A
+description: Internal commands for debugging HyperLogLog values.
+doc_flags:
+- syscmd
+group: hyperloglog
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: PFDEBUG
+since: 2.8.9
+summary: Internal commands for debugging HyperLogLog values.
+syntax_fmt: PFDEBUG subcommand key
+syntax_str: key
+title: PFDEBUG
+---
+The `PFDEBUG` command is an internal command.
+It is meant to be used for developing and testing Redis.---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N*M) worst case where N is the cardinality of the smallest set and M
+  is the number of sets.
+description: Returns the intersect of multiple sets.
+group: set
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SINTER
+since: 1.0.0
+summary: Returns the intersect of multiple sets.
+syntax_fmt: SINTER key [key ...]
+syntax_str: ''
+title: SINTER
+---
+Returns the members of the set resulting from the intersection of all the given
+sets.
+
+For example:
+
+```
+key1 = {a,b,c,d}
+key2 = {c}
+key3 = {a,c,e}
+SINTER key1 key2 key3 = {c}
+```
+
+Keys that do not exist are considered to be empty sets.
+With one of the keys being an empty set, the resulting set is also empty (since
+set intersection with an empty set always results in an empty set).
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SINTER key1 key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- arguments:
+  - display_text: 'yes'
+    name: 'yes'
+    token: 'YES'
+    type: pure-token
+  - display_text: sync
+    name: sync
+    token: SYNC
+    type: pure-token
+  - display_text: 'no'
+    name: 'no'
+    token: 'NO'
+    type: pure-token
+  name: mode
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+complexity: O(1)
+description: Sets the debug mode of server-side Lua scripts.
+group: scripting
+hidden: false
+linkTitle: SCRIPT DEBUG
+since: 3.2.0
+summary: Sets the debug mode of server-side Lua scripts.
+syntax_fmt: SCRIPT DEBUG <YES | SYNC | NO>
+syntax_str: ''
+title: SCRIPT DEBUG
+---
+Set the debug mode for subsequent scripts executed with [`EVAL`]({{< relref "/commands/eval" >}}). Redis includes a
+complete Lua debugger, codename LDB, that can be used to make the task of
+writing complex scripts much simpler. In debug mode Redis acts as a remote
+debugging server and a client, such as `redis-cli`, can execute scripts step by
+step, set breakpoints, inspect variables and more - for additional information
+about LDB refer to the [Redis Lua debugger]({{< relref "/develop/interact/programmability/lua-debugging" >}}) page.
+
+**Important note:** avoid debugging Lua scripts using your Redis production
+server. Use a development server instead.
+
+LDB can be enabled in one of two modes: asynchronous or synchronous. In
+asynchronous mode the server creates a forked debugging session that does not
+block and all changes to the data are **rolled back** after the session
+finishes, so debugging can be restarted using the same initial state. The
+alternative synchronous debug mode blocks the server while the debugging session
+is active and retains all changes to the data set once it ends.
+
+* `YES`. Enable non-blocking asynchronous debugging of Lua scripts (changes are discarded).
+* `SYNC`. Enable blocking synchronous debugging of Lua scripts (saves changes to data).
+* `NO`. Disables scripts debug mode.
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: cursor
+  name: cursor
+  type: integer
+- display_text: pattern
+  name: pattern
+  optional: true
+  token: MATCH
+  type: pattern
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for every call. O(N) for a complete iteration, including enough command
+  calls for the cursor to return back to 0. N is the number of elements inside the
+  collection.
+description: Iterates over members and scores of a sorted set.
+group: sorted-set
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZSCAN
+since: 2.8.0
+summary: Iterates over members and scores of a sorted set.
+syntax_fmt: "ZSCAN key cursor [MATCH\_pattern] [COUNT\_count]"
+syntax_str: "cursor [MATCH\_pattern] [COUNT\_count]"
+title: ZSCAN
+---
+See [`SCAN`]({{< relref "/commands/scan" >}}) for `ZSCAN` documentation.
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: function
+  name: function
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the function that is executed.
+description: Invokes a read-only function.
+group: scripting
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+  notes: We cannot tell how the keys will be used so we assume the worst, RO and ACCESS
+linkTitle: FCALL_RO
+since: 7.0.0
+summary: Invokes a read-only function.
+syntax_fmt: FCALL_RO function numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: FCALL_RO
+---
+This is a read-only variant of the [`FCALL`]({{< relref "/commands/fcall" >}}) command that cannot execute commands that modify data.
+
+For more information about when to use this command vs [`FCALL`]({{< relref "/commands/fcall" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability/#read-only_scripts" >}}).
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@topk'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of items
+deprecated_since: '2.4'
+description: Return the count for one or more items are in a sketch
+group: topk
+hidden: false
+linkTitle: TOPK.COUNT
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Return the count for one or more items are in a sketch
+syntax_fmt: TOPK.COUNT key item [item ...]
+syntax_str: item [item ...]
+title: TOPK.COUNT
+---
+Returns count for an item. 
+Multiple items can be requested at once.
+Please note this number will never be higher than the real count and likely to be lower.
+
+This command has been deprecated. The count value is not a representative of
+the number of appearances of an item.
+
+### Parameters
+
+* **key**: Name of sketch where item is counted.
+* **item**: Item/s to be counted.
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - count for responding item.
+
+## Examples
+
+```
+redis> TOPK.COUNT topk foo 42 nonexist
+1) (integer) 3
+2) (integer) 1
+3) (integer) 0
+```
+---
+acl_categories:
+- '@pubsub'
+- '@fast'
+arguments:
+- display_text: shardchannel
+  name: shardchannel
+  type: string
+- display_text: message
+  name: message
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+- fast
+complexity: O(N) where N is the number of clients subscribed to the receiving shard
+  channel.
+description: Post a message to a shard channel
+group: pubsub
+hidden: false
+key_specs:
+- begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  not_key: true
+linkTitle: SPUBLISH
+since: 7.0.0
+summary: Post a message to a shard channel
+syntax_fmt: SPUBLISH shardchannel message
+syntax_str: message
+title: SPUBLISH
+---
+Posts a message to the given shard channel.
+
+In Redis Cluster, shard channels are assigned to slots by the same algorithm used to assign keys to slots.
+A shard message must be sent to a node that owns the slot the shard channel is hashed to. 
+The cluster makes sure that published shard messages are forwarded to all the nodes in the shard, so clients can subscribe to a shard channel by connecting to any one of the nodes in the shard.
+
+For more information about sharded pubsub, see [Sharded Pubsub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}).
+
+## Examples
+
+For example the following command publishes to the `orders` channel with a subscriber already waiting for message(s).
+    
+```
+> spublish orders hello
+(integer) 1
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arguments:
+- display_text: client-id
+  name: client-id
+  type: integer
+- arguments:
+  - display_text: timeout
+    name: timeout
+    token: TIMEOUT
+    type: pure-token
+  - display_text: error
+    name: error
+    token: ERROR
+    type: pure-token
+  name: unblock-type
+  optional: true
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(log N) where N is the number of client connections
+description: Unblocks a client blocked by a blocking command from a different connection.
+group: connection
+hidden: false
+linkTitle: CLIENT UNBLOCK
+since: 5.0.0
+summary: Unblocks a client blocked by a blocking command from a different connection.
+syntax_fmt: CLIENT UNBLOCK client-id [TIMEOUT | ERROR]
+syntax_str: '[TIMEOUT | ERROR]'
+title: CLIENT UNBLOCK
+---
+This command can unblock, from a different connection, a client blocked in a blocking operation, such as for instance [`BRPOP`]({{< relref "/commands/brpop" >}}) or [`XREAD`]({{< relref "/commands/xread" >}}) or [`WAIT`]({{< relref "/commands/wait" >}}).
+
+By default the client is unblocked as if the timeout of the command was
+reached, however if an additional (and optional) argument is passed, it is possible to specify the unblocking behavior, that can be **TIMEOUT** (the default) or **ERROR**. If **ERROR** is specified, the behavior is to unblock the client returning as error the fact that the client was force-unblocked. Specifically the client will receive the following error:
+
+    -UNBLOCKED client unblocked via CLIENT UNBLOCK
+
+Note: of course as usually it is not guaranteed that the error text remains
+the same, however the error code will remain `-UNBLOCKED`.
+
+This command is useful especially when we are monitoring many keys with
+a limited number of connections. For instance we may want to monitor multiple
+streams with [`XREAD`]({{< relref "/commands/xread" >}}) without using more than N connections. However at some
+point the consumer process is informed that there is one more stream key
+to monitor. In order to avoid using more connections, the best behavior would
+be to stop the blocking command from one of the connections in the pool, add
+the new key, and issue the blocking command again.
+
+To obtain this behavior the following pattern is used. The process uses
+an additional *control connection* in order to send the `CLIENT UNBLOCK` command
+if needed. In the meantime, before running the blocking operation on the other
+connections, the process runs [`CLIENT ID`]({{< relref "/commands/client-id" >}}) in order to get the ID associated
+with that connection. When a new key should be added, or when a key should
+no longer be monitored, the relevant connection blocking command is aborted
+by sending `CLIENT UNBLOCK` in the control connection. The blocking command
+will return and can be finally reissued.
+
+This example shows the application in the context of Redis streams, however
+the pattern is a general one and can be applied to other cases.
+
+## Examples
+
+```
+Connection A (blocking connection):
+> CLIENT ID
+2934
+> BRPOP key1 key2 key3 0
+(client is blocked)
+
+... Now we want to add a new key ...
+
+Connection B (control connection):
+> CLIENT UNBLOCK 2934
+1
+
+Connection A (blocking connection):
+... BRPOP reply with timeout ...
+NULL
+> BRPOP key1 key2 key3 key4 0
+(client is blocked again)
+```
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: sha1
+  name: sha1
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the script that is executed.
+description: Executes a server-side Lua script by SHA1 digest.
+group: scripting
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+  update: true
+linkTitle: EVALSHA
+since: 2.6.0
+summary: Executes a server-side Lua script by SHA1 digest.
+syntax_fmt: EVALSHA sha1 numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: EVALSHA
+---
+Evaluate a script from the server's cache by its SHA1 digest.
+
+The server caches scripts by using the [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}}) command.
+The command is otherwise identical to [`EVAL`]({{< relref "/commands/eval" >}}).
+
+Please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) for more information about Lua scripts.
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: value
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of values specified.
+description: Returns, for each input value (floating-point), the estimated rank of
+  the value (the number of observations in the sketch that are smaller than the value
+  + half the number of observations that are equal to the value)
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.RANK
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input value (floating-point), the estimated rank of the
+  value (the number of observations in the sketch that are smaller than the value
+  + half the number of observations that are equal to the value)
+syntax_fmt: TDIGEST.RANK key value [value ...]
+syntax_str: value [value ...]
+title: TDIGEST.RANK
+---
+Returns, for each input value (floating-point), the estimated rank of the value (the number of observations in the sketch that are smaller than the value + half the number of observations that are equal to the value).
+
+Multiple ranks can be retrieved in a single call.
+
+## Required arguments
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>value</code></summary>
+is input value for which the rank should be estimated.
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - an array of integers populated with rank_1, rank_2, ..., rank_V:
+  
+- -1 - when `value` is smaller than the value of the smallest observation.
+- The number of observations - when `value` is larger than the value of the largest observation.
+- Otherwise: an estimation of the number of (observations smaller than `value` + half the observations equal to `value`).
+
+0 is the rank of the value of the smallest observation.
+
+_n_-1 is the rank of the value of the largest observation; _n_ denotes the number of observations added to the sketch.
+
+All values are -2 if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE s COMPRESSION 1000
+OK
+redis> TDIGEST.ADD s 10 20 30 40 50 60
+OK
+redis> TDIGEST.RANK s 0 10 20 30 40 50 60 70
+1) (integer) -1
+2) (integer) 0
+3) (integer) 1
+4) (integer) 2
+5) (integer) 3
+6) (integer) 4
+7) (integer) 5
+8) (integer) 6
+redis> TDIGEST.REVRANK s 0 10 20 30 40 50 60 70
+1) (integer) 6
+2) (integer) 5
+3) (integer) 4
+4) (integer) 3
+5) (integer) 2
+6) (integer) 1
+7) (integer) 0
+8) (integer) -1  
+{{< / highlight >}}
+  
+{{< highlight bash >}}
+redis> TDIGEST.CREATE s COMPRESSION 1000
+OK
+redis> TDIGEST.ADD s 10 10 10 10 20 20
+OK
+redis> TDIGEST.RANK s 10 20
+1) (integer) 2
+2) (integer) 5
+redis> TDIGEST.REVRANK s 10 20
+1) (integer) 4
+2) (integer) 1
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns the authenticated username of the current connection.
+group: server
+hidden: false
+linkTitle: ACL WHOAMI
+since: 6.0.0
+summary: Returns the authenticated username of the current connection.
+syntax_fmt: ACL WHOAMI
+syntax_str: ''
+title: ACL WHOAMI
+---
+Return the username the current connection is authenticated with.
+New connections are authenticated with the "default" user. They
+can change user using [`AUTH`]({{< relref "/commands/auth" >}}).
+
+## Examples
+
+```
+> ACL WHOAMI
+"default"
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- loading
+- stale
+complexity: O(1)
+description: Returns the number of entries in the slow log.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:agg_sum
+- nondeterministic_output
+linkTitle: SLOWLOG LEN
+since: 2.2.12
+summary: Returns the number of entries in the slow log.
+syntax_fmt: SLOWLOG LEN
+syntax_str: ''
+title: SLOWLOG LEN
+---
+This command returns the current number of entries in the slow log.
+
+A new entry is added to the slow log whenever a command exceeds the execution time threshold defined by the `slowlog-log-slower-than` configuration directive.
+The maximum number of entries in the slow log is governed by the `slowlog-max-len` configuration directive.
+Once the slog log reaches its maximal size, the oldest entry is removed whenever a new entry is created.
+The slow log can be cleared with the [`SLOWLOG RESET`]({{< relref "/commands/slowlog-reset" >}}) command.
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: skipinitialscan
+  optional: true
+  token: SKIPINITIALSCAN
+  type: pure-token
+- name: schema
+  token: SCHEMA
+  type: pure-token
+- name: add
+  token: ADD
+  type: pure-token
+- name: field
+  type: string
+- name: options
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of keys in the keyspace
+description: Adds a new field to the index
+group: search
+hidden: false
+linkTitle: FT.ALTER
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Adds a new field to the index
+syntax: 'FT.ALTER {index} [SKIPINITIALSCAN] SCHEMA ADD {attribute} {options} ...
+
+  '
+syntax_fmt: FT.ALTER index [SKIPINITIALSCAN] SCHEMA ADD field options
+syntax_str: '[SKIPINITIALSCAN] SCHEMA ADD field options'
+title: FT.ALTER
+---
+
+Add a new attribute to the index. Adding an attribute to the index causes any future document updates to use the new attribute when indexing and reindexing existing documents.
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary> 
+
+is index name to create. 
+</details>
+
+<details open>
+<summary><code>SKIPINITIALSCAN</code></summary> 
+
+if set, does not scan and index.
+</details>
+
+<details open>
+<summary><code>SCHEMA ADD {attribute} {options} ...</code></summary>
+
+after the SCHEMA keyword, declares which fields to add:
+
+- `attribute` is attribute to add.
+- `options` are attribute options. Refer to [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) for more information.
+
+<note><b>Note:</b>
+
+Depending on how the index was created, you may be limited by the number of additional text
+attributes which can be added to an existing index. If the current index contains fewer than 32
+text attributes, then `SCHEMA ADD` will only be able to add attributes up to 32 total attributes (meaning that the
+index will only ever be able to contain 32 total text attributes). If you wish for the index to
+contain more than 32 attributes, create it with the `MAXTEXTFIELDS` option.
+</note>
+</details>
+
+## Return
+
+FT.ALTER returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Alter an index</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.ALTER idx SCHEMA ADD id2 NUMERIC SORTABLE
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) 
+
+## Related topics
+
+- [RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+
+
+
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: timeout
+  name: timeout
+  type: double
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+complexity: O(N) where N is the number of provided keys.
+description: Removes and returns the first element in a list. Blocks until an element
+  is available otherwise. Deletes the list if the last element was popped.
+group: list
+hidden: false
+history:
+- - 6.0.0
+  - '`timeout` is interpreted as a double instead of an integer.'
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -2
+      limit: 0
+    type: range
+linkTitle: BLPOP
+since: 2.0.0
+summary: Removes and returns the first element in a list. Blocks until an element
+  is available otherwise. Deletes the list if the last element was popped.
+syntax_fmt: BLPOP key [key ...] timeout
+syntax_str: timeout
+title: BLPOP
+---
+`BLPOP` is a blocking list pop primitive.
+It is the blocking version of [`LPOP`]({{< relref "/commands/lpop" >}}) because it blocks the connection when there
+are no elements to pop from any of the given lists.
+An element is popped from the head of the first list that is non-empty, with the
+given keys being checked in the order that they are given.
+
+## Non-blocking behavior
+
+When `BLPOP` is called, if at least one of the specified keys contains a
+non-empty list, an element is popped from the head of the list and returned to
+the caller together with the `key` it was popped from.
+
+Keys are checked in the order that they are given.
+Let's say that the key `list1` doesn't exist and `list2` and `list3` hold
+non-empty lists.
+Consider the following command:
+
+```
+BLPOP list1 list2 list3 0
+```
+
+`BLPOP` guarantees to return an element from the list stored at `list2` (since
+it is the first non empty list when checking `list1`, `list2` and `list3` in
+that order).
+
+## Blocking behavior
+
+If none of the specified keys exist, `BLPOP` blocks the connection until another
+client performs an [`LPUSH`]({{< relref "/commands/lpush" >}}) or [`RPUSH`]({{< relref "/commands/rpush" >}}) operation against one of the keys.
+
+Once new data is present on one of the lists, the client returns with the name
+of the key unblocking it and the popped value.
+
+When `BLPOP` causes a client to block and a non-zero timeout is specified,
+the client will unblock returning a `nil` multi-bulk value when the specified
+timeout has expired without a push operation against at least one of the
+specified keys.
+
+**The timeout argument is interpreted as a double value specifying the maximum number of seconds to block**. A timeout of zero can be used to block indefinitely.
+
+## What key is served first? What client? What element? Priority ordering details.
+
+* If the client tries to blocks for multiple keys, but at least one key contains elements, the returned key / element pair is the first key from left to right that has one or more elements. In this case the client is not blocked. So for instance `BLPOP key1 key2 key3 key4 0`, assuming that both `key2` and `key4` are non-empty, will always return an element from `key2`.
+* If multiple clients are blocked for the same key, the first client to be served is the one that was waiting for more time (the first that blocked for the key). Once a client is unblocked it does not retain any priority, when it blocks again with the next call to `BLPOP` it will be served accordingly to the number of clients already blocked for the same key, that will all be served before it (from the first to the last that blocked).
+* When a client is blocking for multiple keys at the same time, and elements are available at the same time in multiple keys (because of a transaction or a Lua script added elements to multiple lists), the client will be unblocked using the first key that received a push operation (assuming it has enough elements to serve our client, as there may be other clients as well waiting for this key). Basically after the execution of every command Redis will run a list of all the keys that received data AND that have at least a client blocked. The list is ordered by new element arrival time, from the first key that received data to the last. For every key processed, Redis will serve all the clients waiting for that key in a FIFO fashion, as long as there are elements in this key. When the key is empty or there are no longer clients waiting for this key, the next key that received new data in the previous command / transaction / script is processed, and so forth.
+
+## Behavior of `BLPOP` when multiple elements are pushed inside a list.
+
+There are times when a list can receive multiple elements in the context of the same conceptual command:
+
+* Variadic push operations such as `LPUSH mylist a b c`.
+* After an [`EXEC`]({{< relref "/commands/exec" >}}) of a [`MULTI`]({{< relref "/commands/multi" >}}) block with multiple push operations against the same list.
+* Executing a Lua Script with Redis 2.6 or newer.
+
+When multiple elements are pushed inside a list where there are clients blocking, the behavior is different for Redis 2.4 and Redis 2.6 or newer.
+
+For Redis 2.6 what happens is that the command performing multiple pushes is executed, and *only after* the execution of the command the blocked clients are served. Consider this sequence of commands.
+
+    Client A:   BLPOP foo 0
+    Client B:   LPUSH foo a b c
+
+If the above condition happens using a Redis 2.6 server or greater, Client **A** will be served with the `c` element, because after the [`LPUSH`]({{< relref "/commands/lpush" >}}) command the list contains `c,b,a`, so taking an element from the left means to return `c`.
+
+Instead Redis 2.4 works in a different way: clients are served *in the context* of the push operation, so as long as `LPUSH foo a b c` starts pushing the first element to the list, it will be delivered to the Client **A**, that will receive `a` (the first element pushed).
+
+The behavior of Redis 2.4 creates a lot of problems when replicating or persisting data into the AOF file, so the much more generic and semantically simpler behavior was introduced into Redis 2.6 to prevent problems.
+
+Note that for the same reason a Lua script or a `MULTI/EXEC` block may push elements into a list and afterward **delete the list**. In this case the blocked clients will not be served at all and will continue to be blocked as long as no data is present on the list after the execution of a single command, transaction, or script.
+
+## `BLPOP` inside a `MULTI` / `EXEC` transaction
+
+`BLPOP` can be used with pipelining (sending multiple commands and
+reading the replies in batch), however this setup makes sense almost solely
+when it is the last command of the pipeline.
+
+Using `BLPOP` inside a [`MULTI`]({{< relref "/commands/multi" >}}) / [`EXEC`]({{< relref "/commands/exec" >}}) block does not make a lot of sense
+as it would require blocking the entire server in order to execute the block
+atomically, which in turn does not allow other clients to perform a push
+operation. For this reason the behavior of `BLPOP` inside [`MULTI`]({{< relref "/commands/multi" >}}) / [`EXEC`]({{< relref "/commands/exec" >}}) when the list is empty is to return a `nil` multi-bulk reply, which is the same
+thing that happens when the timeout is reached.
+
+If you like science fiction, think of time flowing at infinite speed inside a
+[`MULTI`]({{< relref "/commands/multi" >}}) / [`EXEC`]({{< relref "/commands/exec" >}}) block...
+
+## Examples
+
+```
+redis> DEL list1 list2
+(integer) 0
+redis> RPUSH list1 a b c
+(integer) 3
+redis> BLPOP list1 list2 0
+1) "list1"
+2) "a"
+```
+
+## Reliable queues
+
+When `BLPOP` returns an element to the client, it also removes the element from the list. This means that the element only exists in the context of the client: if the client crashes while processing the returned element, it is lost forever.
+
+This can be a problem with some application where we want a more reliable messaging system. When this is the case, please check the [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}) command, that is a variant of `BLPOP` that adds the returned element to a target list before returning it to the client.
+
+## Pattern: Event notification
+
+Using blocking list operations it is possible to mount different blocking
+primitives.
+For instance for some application you may need to block waiting for elements
+into a Redis Set, so that as far as a new element is added to the Set, it is
+possible to retrieve it without resort to polling.
+This would require a blocking version of [`SPOP`]({{< relref "/commands/spop" >}}) that is not available, but using
+blocking list operations we can easily accomplish this task.
+
+The consumer will do:
+
+```
+LOOP forever
+    WHILE SPOP(key) returns elements
+        ... process elements ...
+    END
+    BRPOP helper_key
+END
+```
+
+While in the producer side we'll use simply:
+
+```
+MULTI
+SADD key element
+LPUSH helper_key x
+EXEC
+```
+---
+acl_categories:
+- '@search'
+arguments:
+- name: dict
+  type: string
+- multiple: true
+  name: term
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Adds terms to a dictionary
+group: search
+hidden: false
+linkTitle: FT.DICTADD
+module: Search
+since: 1.4.0
+stack_path: docs/interact/search-and-query
+summary: Adds terms to a dictionary
+syntax: 'FT.DICTADD dict term [term ...]
+
+  '
+syntax_fmt: FT.DICTADD dict term [term ...]
+syntax_str: term [term ...]
+title: FT.DICTADD
+---
+
+Add terms to a dictionary
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>dict</code></summary>
+
+is dictionary name.
+</details>
+
+<details open>
+<summary><code>term</code></summary>
+
+term to add to the dictionary.
+</details>
+
+## Return
+
+FT.DICTADD returns an integer reply, the number of new terms that were added.
+
+## Examples
+
+<details open>
+<summary><b>Add terms to a dictionary</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.DICTADD dict foo bar "hello world"
+(integer) 3
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.DICTDEL`]({{< relref "commands/ft.dictdel/" >}}) | [`FT.DICTDUMP`]({{< relref "commands/ft.dictdump/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: unix-time-seconds
+  name: unix-time-seconds
+  type: unix-time
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Set expiration for hash fields using an absolute Unix timestamp (seconds)
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HEXPIREAT
+since: 7.4.0
+summary: Set expiry for hash field using an absolute Unix timestamp (seconds)
+syntax_fmt: "HEXPIREAT key unix-time-seconds [NX | XX | GT | LT] FIELDS\_numfields\n\
+  \  field [field ...]"
+syntax_str: "unix-time-seconds [NX | XX | GT | LT] FIELDS\_numfields field [field\
+  \ ...]"
+title: HEXPIREAT
+---
+`HEXPIREAT` has the same effect and semantics as [`HEXPIRE`]({{< relref "/commands/hexpire" >}}), but instead of
+specifying the number of seconds for the TTL (time to live), it takes
+an absolute [Unix timestamp](http://en.wikipedia.org/wiki/Unix_time) in seconds since Unix epoch. A
+timestamp in the past will delete the field immediately.
+
+For the specific semantics of the command, see [`HEXPIRE`]({{< relref "/commands/hexpire" >}}).
+
+## Options
+
+The `HEXPIREAT` command supports a set of options:
+
+* `NX` -- For each specified field, set expiration only when the field has no expiration.
+* `XX` -- For each specified field, set expiration only when the field has an existing expiration.
+* `GT` -- For each specified field, set expiration only when the new expiration is greater than current one.
+* `LT` -- For each specified field, set expiration only when the new expiration is less than current one.
+
+A non-volatile key is treated as an infinite TTL for the purposes of `GT` and `LT`.
+The `NS`, `XX`, `GT`, and `LT` options are mutually exclusive.
+
+## Example
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer 2)
+redis> HEXPIREAT mykey 1715704971 FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 567
+2) (integer) 567
+```
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Increments the integer value of a key by one. Uses 0 as initial value
+  if the key doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: INCR
+since: 1.0.0
+summary: Increments the integer value of a key by one. Uses 0 as initial value if
+  the key doesn't exist.
+syntax_fmt: INCR key
+syntax_str: ''
+title: INCR
+---
+Increments the number stored at `key` by one.
+If the key does not exist, it is set to `0` before performing the operation.
+An error is returned if the key contains a value of the wrong type or contains a
+string that can not be represented as integer.
+This operation is limited to 64 bit signed integers.
+
+**Note**: this is a string operation because Redis does not have a dedicated
+integer type.
+The string stored at the key is interpreted as a base-10 **64 bit signed
+integer** to execute the operation.
+
+Redis stores integers in their integer representation, so for string values
+that actually hold an integer, there is no overhead for storing the string
+representation of the integer.
+
+## Examples
+
+{{< clients-example cmds_string incr >}}
+> SET mykey "10"
+"OK"
+> INCR mykey
+(integer) 11
+> GET mykey
+"11"
+{{< /clients-example >}}
+
+Give this command a try in the interactive console:
+
+{{% redis-cli %}}
+SET mykey "10"
+INCR mykey
+GET mykey
+{{% /redis-cli %}}
+
+## Pattern: Counter
+
+The counter pattern is the most obvious thing you can do with Redis atomic
+increment operations.
+The idea is simply send an `INCR` command to Redis every time an operation
+occurs.
+For instance in a web application we may want to know how many page views this
+user did every day of the year.
+
+To do so the web application may simply increment a key every time the user
+performs a page view, creating the key name concatenating the User ID and a
+string representing the current date.
+
+This simple pattern can be extended in many ways:
+
+* It is possible to use `INCR` and [`EXPIRE`]({{< relref "/commands/expire" >}}) together at every page view to have
+  a counter counting only the latest N page views separated by less than the
+  specified amount of seconds.
+* A client may use GETSET in order to atomically get the current counter value
+  and reset it to zero.
+* Using other atomic increment/decrement commands like [`DECR`]({{< relref "/commands/decr" >}}) or [`INCRBY`]({{< relref "/commands/incrby" >}}) it
+  is possible to handle values that may get bigger or smaller depending on the
+  operations performed by the user.
+  Imagine for instance the score of different users in an online game.
+
+## Pattern: Rate limiter
+
+The rate limiter pattern is a special counter that is used to limit the rate at
+which an operation can be performed.
+The classical materialization of this pattern involves limiting the number of
+requests that can be performed against a public API.
+
+We provide two implementations of this pattern using `INCR`, where we assume
+that the problem to solve is limiting the number of API calls to a maximum of
+_ten requests per second per IP address_.
+
+## Pattern: Rate limiter 1
+
+The more simple and direct implementation of this pattern is the following:
+
+```
+FUNCTION LIMIT_API_CALL(ip)
+ts = CURRENT_UNIX_TIME()
+keyname = ip+":"+ts
+MULTI
+    INCR(keyname)
+    EXPIRE(keyname,10)
+EXEC
+current = RESPONSE_OF_INCR_WITHIN_MULTI
+IF current > 10 THEN
+    ERROR "too many requests per second"
+ELSE
+    PERFORM_API_CALL()
+END
+```
+
+Basically we have a counter for every IP, for every different second.
+But these counters are always incremented setting an expire of 10 seconds so that
+they'll be removed by Redis automatically when the current second is a different
+one.
+
+Note the used of [`MULTI`]({{< relref "/commands/multi" >}}) and [`EXEC`]({{< relref "/commands/exec" >}}) in order to make sure that we'll both
+increment and set the expire at every API call.
+
+## Pattern: Rate limiter 2
+
+An alternative implementation uses a single counter, but is a bit more complex
+to get it right without race conditions.
+We'll examine different variants.
+
+```
+FUNCTION LIMIT_API_CALL(ip):
+current = GET(ip)
+IF current != NULL AND current > 10 THEN
+    ERROR "too many requests per second"
+ELSE
+    value = INCR(ip)
+    IF value == 1 THEN
+        EXPIRE(ip,1)
+    END
+    PERFORM_API_CALL()
+END
+```
+
+The counter is created in a way that it only will survive one second, starting
+from the first request performed in the current second.
+If there are more than 10 requests in the same second the counter will reach a
+value greater than 10, otherwise it will expire and start again from 0.
+
+**In the above code there is a race condition**.
+If for some reason the client performs the `INCR` command but does not perform
+the [`EXPIRE`]({{< relref "/commands/expire" >}}) the key will be leaked until we'll see the same IP address again.
+
+This can be easily fixed by turning the `INCR` with optional [`EXPIRE`]({{< relref "/commands/expire" >}}) into a Lua
+script that is then sent using the [`EVAL`]({{< relref "/commands/eval" >}}) command (only available since Redis version
+2.6).
+
+```
+local current
+current = redis.call("incr",KEYS[1])
+if current == 1 then
+    redis.call("expire",KEYS[1],1)
+end
+```
+
+There is a different way to fix this issue without using scripting, by using
+Redis lists instead of counters.
+The implementation is more complex and uses more advanced features but has the
+advantage of remembering the IP addresses of the clients currently performing an
+API call, that may be useful or not depending on the application.
+
+```
+FUNCTION LIMIT_API_CALL(ip)
+current = LLEN(ip)
+IF current > 10 THEN
+    ERROR "too many requests per second"
+ELSE
+    IF EXISTS(ip) == FALSE
+        MULTI
+            RPUSH(ip,ip)
+            EXPIRE(ip,1)
+        EXEC
+    ELSE
+        RPUSHX(ip,ip)
+    END
+    PERFORM_API_CALL()
+END
+```
+
+The [`RPUSHX`]({{< relref "/commands/rpushx" >}}) command only pushes the element if the key already exists.
+
+Note that we have a race here, but it is not a problem: [`EXISTS`]({{< relref "/commands/exists" >}}) may return
+false but the key may be created by another client before we create it inside
+the [`MULTI`]({{< relref "/commands/multi" >}}) / [`EXEC`]({{< relref "/commands/exec" >}}) block.
+However this race will just miss an API call under rare conditions, so the rate
+limiting will still work correctly.
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k), where k is the number of sub-filters
+description: Deletes an item from a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.DEL
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Deletes an item from a Cuckoo Filter
+syntax_fmt: CF.DEL key item
+syntax_str: item
+title: CF.DEL
+---
+Deletes an item once from the filter.
+
+If the item exists only once, it will be removed from the filter. If the item was added multiple times, it will still be present.
+
+<note><b>Note:</b>
+
+- Deleting an item that are not in the filter may delete a different item, resulting in false negatives.
+</note>
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter.
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to delete.
+</details>
+
+## Complexity
+
+O(n), where n is the number of `sub-filters`. Both alternative locations are
+checked on all `sub-filters`.
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that the item has been deleted, and "0" means that such item was not found in the filter
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INSERT cf ITEMS item1 item2 item2
+1) (integer) 1
+2) (integer) 1
+3) (integer) 1
+redis> CF.DEL cf item1
+(integer) 1
+redis> CF.DEL cf item1
+(integer) 0
+redis> CF.DEL cf item2
+(integer) 1
+redis> CF.DEL cf item2
+(integer) 1
+redis> CF.DEL cf item2
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for Redis Cluster commands.
+group: cluster
+hidden: true
+linkTitle: CLUSTER
+since: 3.0.0
+summary: A container for Redis Cluster commands.
+syntax_fmt: CLUSTER
+syntax_str: ''
+title: CLUSTER
+---
+This is a container command for Redis Cluster commands.
+
+To see the list of available commands you can call [`CLUSTER HELP`]({{< relref "/commands/cluster-help" >}}).
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- display_text: consumer
+  name: consumer
+  type: string
+- display_text: min-idle-time
+  name: min-idle-time
+  type: string
+- display_text: id
+  multiple: true
+  name: id
+  type: string
+- display_text: ms
+  name: ms
+  optional: true
+  token: IDLE
+  type: integer
+- display_text: unix-time-milliseconds
+  name: unix-time-milliseconds
+  optional: true
+  token: TIME
+  type: unix-time
+- display_text: count
+  name: count
+  optional: true
+  token: RETRYCOUNT
+  type: integer
+- display_text: force
+  name: force
+  optional: true
+  token: FORCE
+  type: pure-token
+- display_text: justid
+  name: justid
+  optional: true
+  token: JUSTID
+  type: pure-token
+- display_text: lastid
+  name: lastid
+  optional: true
+  token: LASTID
+  type: string
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(log N) with N being the number of messages in the PEL of the consumer
+  group.
+description: Changes, or acquires, ownership of a message in a consumer group, as
+  if the message was delivered a consumer group member.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: XCLAIM
+since: 5.0.0
+summary: Changes, or acquires, ownership of a message in a consumer group, as if the
+  message was delivered a consumer group member.
+syntax_fmt: "XCLAIM key group consumer min-idle-time id [id ...] [IDLE\_ms]\n  [TIME\_\
+  unix-time-milliseconds] [RETRYCOUNT\_count] [FORCE] [JUSTID]\n  [LASTID\_lastid]"
+syntax_str: "group consumer min-idle-time id [id ...] [IDLE\_ms] [TIME\_unix-time-milliseconds]\
+  \ [RETRYCOUNT\_count] [FORCE] [JUSTID] [LASTID\_lastid]"
+title: XCLAIM
+---
+In the context of a stream consumer group, this command changes the ownership
+of a pending message, so that the new owner is the consumer specified as the
+command argument. Normally this is what happens:
+
+1. There is a stream with an associated consumer group.
+2. Some consumer A reads a message via [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) from a stream, in the context of that consumer group.
+3. As a side effect a pending message entry is created in the Pending Entries List (PEL) of the consumer group: it means the message was delivered to a given consumer, but it was not yet acknowledged via [`XACK`]({{< relref "/commands/xack" >}}).
+4. Then suddenly that consumer fails forever.
+5. Other consumers may inspect the list of pending messages, that are stale for quite some time, using the [`XPENDING`]({{< relref "/commands/xpending" >}}) command. In order to continue processing such messages, they use `XCLAIM` to acquire the ownership of the message and continue. Consumers can also use the [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) command to automatically scan and claim stale pending messages.
+
+This dynamic is clearly explained in the [Stream intro documentation]({{< relref "/develop/data-types/streams" >}}).
+
+Note that the message is claimed only if its idle time is greater than the minimum idle time we specify when calling `XCLAIM`. Because as a side effect `XCLAIM` will also reset the idle time (since this is a new attempt at processing the message), two consumers trying to claim a message at the same time will never both succeed: only one will successfully claim the message. This avoids that we process a given message multiple times in a trivial way (yet multiple processing is possible and unavoidable in the general case).
+
+Moreover, as a side effect, `XCLAIM` will increment the count of attempted deliveries of the message unless the `JUSTID` option has been specified (which only delivers the message ID, not the message itself). In this way messages that cannot be processed for some reason, for instance because the consumers crash attempting to process them, will start to have a larger counter and can be detected inside the system.
+
+`XCLAIM` will not claim a message in the following cases:
+
+1. The message doesn't exist in the group PEL (i.e. it was never read by any consumer)
+2. The message exists in the group PEL but not in the stream itself (i.e. the message was read but never acknowledged, and then was deleted from the stream, either by trimming or by [`XDEL`]({{< relref "/commands/xdel" >}}))
+
+In both cases the reply will not contain a corresponding entry to that message (i.e. the length of the reply array may be smaller than the number of IDs provided to `XCLAIM`).
+In the latter case, the message will also be deleted from the PEL in which it was found. This feature was introduced in Redis 7.0.
+
+## Command options
+
+The command has multiple options, however most are mainly for internal use in
+order to transfer the effects of `XCLAIM` or other commands to the AOF file
+and to propagate the same effects to the replicas, and are unlikely to be
+useful to normal users:
+
+1. `IDLE <ms>`: Set the idle time (last time it was delivered) of the message. If IDLE is not specified, an IDLE of 0 is assumed, that is, the time count is reset because the message has now a new owner trying to process it.
+2. `TIME <ms-unix-time>`: This is the same as IDLE but instead of a relative amount of milliseconds, it sets the idle time to a specific Unix time (in milliseconds). This is useful in order to rewrite the AOF file generating `XCLAIM` commands.
+3. `RETRYCOUNT <count>`: Set the retry counter to the specified value. This counter is incremented every time a message is delivered again. Normally `XCLAIM` does not alter this counter, which is just served to clients when the XPENDING command is called: this way clients can detect anomalies, like messages that are never processed for some reason after a big number of delivery attempts.
+4. `FORCE`: Creates the pending message entry in the PEL even if certain specified IDs are not already in the PEL assigned to a different client. However the message must be exist in the stream, otherwise the IDs of non existing messages are ignored.
+5. `JUSTID`: Return just an array of IDs of messages successfully claimed, without returning the actual message. Using this option means the retry counter is not incremented.
+
+## Examples
+
+```
+> XCLAIM mystream mygroup Alice 3600000 1526569498055-0
+1) 1) 1526569498055-0
+   2) 1) "message"
+      2) "orange"
+```
+
+In the above example we claim the message with ID `1526569498055-0`, only if the message is idle for at least one hour without the original consumer or some other consumer making progresses (acknowledging or claiming it), and assigns the ownership to the consumer `Alice`.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: N/A
+description: Shows helpful information
+group: json
+hidden: true
+linkTitle: JSON.DEBUG HELP
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Shows helpful information
+syntax_fmt: JSON.DEBUG HELP
+syntax_str: ''
+title: JSON.DEBUG HELP
+---
+Return helpful information about the [`JSON.DEBUG`]({{< relref "commands/json.debug/" >}}) command
+
+## Return
+
+JSON.DEBUG HELP returns an array with helpful messages.
+
+## See also
+
+[`JSON.DEBUG`]({{< relref "commands/json.debug/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(N) where N is the total number of Cluster nodes
+description: Returns a list of all TCP links to and from peer nodes.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER LINKS
+since: 7.0.0
+summary: Returns a list of all TCP links to and from peer nodes.
+syntax_fmt: CLUSTER LINKS
+syntax_str: ''
+title: CLUSTER LINKS
+---
+Each node in a Redis Cluster maintains a pair of long-lived TCP link with each peer in the cluster: One for sending outbound messages towards the peer and one for receiving inbound messages from the peer.
+
+`CLUSTER LINKS` outputs information of all such peer links as an array, where each array element is a map that contains attributes and their values for an individual link.
+
+## Examples
+
+The following is an example output:
+
+```
+> CLUSTER LINKS
+1)  1) "direction"
+    2) "to"
+    3) "node"
+    4) "8149d745fa551e40764fecaf7cab9dbdf6b659ae"
+    5) "create-time"
+    6) (integer) 1639442739375
+    7) "events"
+    8) "rw"
+    9) "send-buffer-allocated"
+   10) (integer) 4512
+   11) "send-buffer-used"
+   12) (integer) 0
+2)  1) "direction"
+    2) "from"
+    3) "node"
+    4) "8149d745fa551e40764fecaf7cab9dbdf6b659ae"
+    5) "create-time"
+    6) (integer) 1639442739411
+    7) "events"
+    8) "r"
+    9) "send-buffer-allocated"
+   10) (integer) 0
+   11) "send-buffer-used"
+   12) (integer) 0
+```
+
+Each map is composed of the following attributes of the corresponding cluster link and their values:
+
+1. `direction`: This link is established by the local node `to` the peer, or accepted by the local node `from` the peer.
+2. `node`: The node id of the peer.
+3. `create-time`: Creation time of the link. (In the case of a `to` link, this is the time when the TCP link is created by the local node, not the time when it is actually established.)
+4. `events`: Events currently registered for the link. `r` means readable event, `w` means writable event.
+5. `send-buffer-allocated`: Allocated size of the link's send buffer, which is used to buffer outgoing messages toward the peer.
+6. `send-buffer-used`: Size of the portion of the link's send buffer that is currently holding data(messages).
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns a human-readable latency analysis report.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_nodes
+- response_policy:special
+linkTitle: LATENCY DOCTOR
+since: 2.8.13
+summary: Returns a human-readable latency analysis report.
+syntax_fmt: LATENCY DOCTOR
+syntax_str: ''
+title: LATENCY DOCTOR
+---
+The `LATENCY DOCTOR` command reports about different latency-related issues and advises about possible remedies.
+
+This command is the most powerful analysis tool in the latency monitoring
+framework, and is able to provide additional statistical data like the average
+period between latency spikes, the median deviation, and a human-readable
+analysis of the event. For certain events, like `fork`, additional information
+is provided, like the rate at which the system forks processes.
+
+This is the output you should post in the Redis mailing list if you are
+looking for help about Latency related issues.
+
+## Examples
+
+```
+127.0.0.1:6379> latency doctor
+
+Dave, I have observed latency spikes in this Redis instance.
+You don't mind talking about it, do you Dave?
+
+1. command: 5 latency spikes (average 300ms, mean deviation 120ms,
+    period 73.40 sec). Worst all time event 500ms.
+
+I have a few advices for you:
+
+- Your current Slow Log configuration only logs events that are
+    slower than your configured latency monitor threshold. Please
+    use 'CONFIG SET slowlog-log-slower-than 1000'.
+- Check your Slow Log to understand what are the commands you are
+    running which are too slow to execute. Please check
+    http://redis.io/commands/slowlog for more information.
+- Deleting, expiring or evicting (because of maxmemory policy)
+    large objects is a blocking operation. If you have very large
+    objects that are often deleted, expired, or evicted, try to
+    fragment those objects into multiple smaller objects.
+```
+
+**Note:** the doctor has erratic psychological behaviors, so we recommend interacting with it carefully.
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of configured users.
+description: Saves the effective ACL rules in the configured ACL file.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: ACL SAVE
+since: 6.0.0
+summary: Saves the effective ACL rules in the configured ACL file.
+syntax_fmt: ACL SAVE
+syntax_str: ''
+title: ACL SAVE
+---
+When Redis is configured to use an ACL file (with the `aclfile` configuration
+option), this command will save the currently defined ACLs from the server memory to the ACL file.
+
+## Examples
+
+```
+> ACL SAVE
++OK
+
+> ACL SAVE
+-ERR There was an error trying to save the ACLs. Please check the server logs for more information
+```
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  type: integer
+- display_text: element
+  name: element
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N+M) where N is the length of the list and M is the number of elements
+  removed.
+description: Removes elements from a list. Deletes the list if the last element was
+  removed.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LREM
+since: 1.0.0
+summary: Removes elements from a list. Deletes the list if the last element was removed.
+syntax_fmt: LREM key count element
+syntax_str: count element
+title: LREM
+---
+Removes the first `count` occurrences of elements equal to `element` from the list
+stored at `key`.
+The `count` argument influences the operation in the following ways:
+
+* `count > 0`: Remove elements equal to `element` moving from head to tail.
+* `count < 0`: Remove elements equal to `element` moving from tail to head.
+* `count = 0`: Remove all elements equal to `element`.
+
+For example, `LREM list -2 "hello"` will remove the last two occurrences of
+`"hello"` in the list stored at `list`.
+
+Note that non-existing keys are treated like empty lists, so when `key` does not
+exist, the command will always return `0`.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "hello"
+RPUSH mylist "hello"
+RPUSH mylist "foo"
+RPUSH mylist "hello"
+LREM mylist -2 "hello"
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements
+  in all the sets, N is the size of the first set, and K is the size of the result
+  set.
+description: Returns the difference between multiple sorted sets.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZDIFF
+since: 6.2.0
+summary: Returns the difference between multiple sorted sets.
+syntax_fmt: ZDIFF numkeys key [key ...] [WITHSCORES]
+syntax_str: key [key ...] [WITHSCORES]
+title: ZDIFF
+---
+This command is similar to [`ZDIFFSTORE`]({{< relref "/commands/zdiffstore" >}}), but instead of storing the resulting
+sorted set, it is returned to the client.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset1 3 "three"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZDIFF 2 zset1 zset2
+ZDIFF 2 zset1 zset2 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - arguments:
+    - display_text: host
+      name: host
+      type: string
+    - display_text: port
+      name: port
+      type: integer
+    name: host-port
+    type: block
+  - arguments:
+    - display_text: 'no'
+      name: 'no'
+      token: 'NO'
+      type: pure-token
+    - display_text: one
+      name: one
+      token: ONE
+      type: pure-token
+    name: no-one
+    type: block
+  name: args
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- stale
+- no_async_loading
+complexity: O(1)
+description: Configures a server as replica of another, or promotes it to a master.
+group: server
+hidden: false
+linkTitle: REPLICAOF
+since: 5.0.0
+summary: Configures a server as replica of another, or promotes it to a master.
+syntax_fmt: REPLICAOF <host port | NO ONE>
+syntax_str: ''
+title: REPLICAOF
+---
+The `REPLICAOF` command can change the replication settings of a replica on the fly.
+
+If a Redis server is already acting as replica, the command `REPLICAOF` NO ONE will turn off the replication, turning the Redis server into a MASTER.  In the proper form `REPLICAOF` hostname port will make the server a replica of another server listening at the specified hostname and port.
+
+If a server is already a replica of some master, `REPLICAOF` hostname port will stop the replication against the old server and start the synchronization against the new one, discarding the old dataset.
+
+The form `REPLICAOF` NO ONE will stop replication, turning the server into a MASTER, but will not discard the already replicated data. So, if the old master stops working, it is possible to turn the replica into a master and set the application to use this new master in read/write. Later when the other Redis server is fixed, it can be reconfigured to work as a replica.
+
+## Examples
+
+```
+> REPLICAOF NO ONE
+"OK"
+
+> REPLICAOF 127.0.0.1 6799
+"OK"
+```
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: increment
+  name: increment
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Increments the integer value of a key by a number. Uses 0 as initial
+  value if the key doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: INCRBY
+since: 1.0.0
+summary: Increments the integer value of a key by a number. Uses 0 as initial value
+  if the key doesn't exist.
+syntax_fmt: INCRBY key increment
+syntax_str: increment
+title: INCRBY
+---
+Increments the number stored at `key` by `increment`.
+If the key does not exist, it is set to `0` before performing the operation.
+An error is returned if the key contains a value of the wrong type or contains a
+string that can not be represented as integer.
+This operation is limited to 64 bit signed integers.
+
+See [`INCR`]({{< relref "/commands/incr" >}}) for extra information on increment/decrement operations.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "10"
+INCRBY mykey 5
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: string
+- display_text: max
+  name: max
+  type: string
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements being returned. If M is constant (e.g. always asking for
+  the first 10 elements with LIMIT), you can consider it O(log(N)).
+deprecated_since: 6.2.0
+description: Returns members in a sorted set within a lexicographical range.
+doc_flags:
+- deprecated
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANGEBYLEX
+replaced_by: '[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYLEX` argument'
+since: 2.8.9
+summary: Returns members in a sorted set within a lexicographical range.
+syntax_fmt: "ZRANGEBYLEX key min max [LIMIT\_offset count]"
+syntax_str: "min max [LIMIT\_offset count]"
+title: ZRANGEBYLEX
+---
+When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at `key` with a value between `min` and `max`.
+
+If the elements in the sorted set have different scores, the returned elements are unspecified.
+
+The elements are considered to be ordered from lower to higher strings as compared byte-by-byte using the `memcmp()` C function. Longer strings are considered greater than shorter strings if the common part is identical.
+
+The optional `LIMIT` argument can be used to only get a range of the matching
+elements (similar to _SELECT LIMIT offset, count_ in SQL). A negative `count`
+returns all elements from the `offset`.
+Keep in mind that if `offset` is large, the sorted set needs to be traversed for
+`offset` elements before getting to the elements to return, which can add up to
+O(N) time complexity.
+
+## How to specify intervals
+
+Valid *start* and *stop* must start with `(` or `[`, in order to specify
+if the range item is respectively exclusive or inclusive.
+The special values of `+` or `-` for *start* and *stop* have the special
+meaning or positively infinite and negatively infinite strings, so for
+instance the command **ZRANGEBYLEX myzset - +** is guaranteed to return
+all the elements in the sorted set, if all the elements have the same
+score.
+
+## Details on strings comparison
+
+Strings are compared as binary array of bytes. Because of how the ASCII character
+set is specified, this means that usually this also have the effect of comparing
+normal ASCII characters in an obvious dictionary way. However this is not true
+if non plain ASCII strings are used (for example utf8 strings).
+
+However the user can apply a transformation to the encoded string so that
+the first part of the element inserted in the sorted set will compare as the
+user requires for the specific application. For example if I want to
+add strings that will be compared in a case-insensitive way, but I still
+want to retrieve the real case when querying, I can add strings in the
+following way:
+
+    ZADD autocomplete 0 foo:Foo 0 bar:BAR 0 zap:zap
+
+Because of the first *normalized* part in every element (before the colon character), we are forcing a given comparison, however after the range is queries using `ZRANGEBYLEX` the application can display to the user the second part of the string, after the colon.
+
+The binary nature of the comparison allows to use sorted sets as a general
+purpose index, for example the first part of the element can be a 64 bit
+big endian number: since big endian numbers have the most significant bytes
+in the initial positions, the binary comparison will match the numerical
+comparison of the numbers. This can be used in order to implement range
+queries on 64 bit values. As in the example below, after the first 8 bytes
+we can store the value of the element we are actually indexing.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
+ZRANGEBYLEX myzset - [c
+ZRANGEBYLEX myzset - (c
+ZRANGEBYLEX myzset [aaa (g
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k), where k is the number of hash functions used by the last sub-filter
+description: Adds an item to a Bloom Filter
+group: bf
+hidden: false
+linkTitle: BF.ADD
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds an item to a Bloom Filter
+syntax_fmt: BF.ADD key item
+syntax_str: item
+title: BF.ADD
+---
+Adds an item to a Bloom filter.
+
+This command is similar to [`BF.MADD`]({{< relref "commands/bf.madd/" >}}), except that only one item can be added.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter to add the item to.
+
+If `key` does not exist - a new Bloom filter is created with default error rate, capacity, and expansion (see [`BF.RESERVE`]({{< relref "commands/bf.reserve/" >}})).
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to add.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that the item has been added successfully, and "0" means that such item was already added to the filter (which could be wrong)
+- [] on error (invalid arguments, wrong key type, etc.) and also when the filter is full
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.ADD bf item1
+(integer) 1
+redis> BF.ADD bf item1
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@dangerous'
+- '@search'
+- '@slow'
+- '@write'
+arguments:
+- name: index
+  type: string
+- arguments:
+  - name: delete docs
+    token: DD
+    type: pure-token
+  name: delete docs
+  optional: true
+  type: oneof
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) or O(N) if documents are deleted, where N is the number of keys in
+  the keyspace
+description: Deletes the index
+group: search
+hidden: false
+linkTitle: FT.DROPINDEX
+module: Search
+since: 2.0.0
+stack_path: docs/interact/search-and-query
+summary: Deletes the index
+syntax: "FT.DROPINDEX index \n  [DD]\n"
+syntax_fmt: FT.DROPINDEX index [DD]
+syntax_str: '[DD]'
+title: FT.DROPINDEX
+---
+
+Delete an index
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is full-text index name. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>DD</code></summary>
+
+drop index operation that, if set, deletes the actual document keys. `FT.DROPINDEX index DD` is an asynchronous operation.
+
+By default, FT.DROPINDEX does not delete the documents associated with the index. Adding the `DD` option deletes the documents as well. 
+If an index creation is still running ([`FT.CREATE`]({{< relref "commands/ft.create/" >}}) is running asynchronously), only the document hashes that have already been indexed are deleted. 
+The document hashes left to be indexed remain in the database.
+To check the completion of the indexing, use [`FT.INFO`]({{< relref "commands/ft.info/" >}}).
+
+</details>
+
+## Return
+
+FT.DROPINDEX returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Delete an index</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.DROPINDEX idx DD
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) | [`FT.INFO`]({{< relref "commands/ft.info/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@stream'
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: stream
+hidden: true
+linkTitle: XGROUP HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: XGROUP HELP
+syntax_str: ''
+title: XGROUP HELP
+---
+The `XGROUP HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- allow_busy
+complexity: O(1)
+description: Terminates a function during execution.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:one_succeeded
+linkTitle: FUNCTION KILL
+since: 7.0.0
+summary: Terminates a function during execution.
+syntax_fmt: FUNCTION KILL
+syntax_str: ''
+title: FUNCTION KILL
+---
+Kill a function that is currently executing.
+
+
+The `FUNCTION KILL` command can be used only on functions that did not modify the dataset during their execution (since stopping a read-only function does not violate the scripting engine's guaranteed atomicity).
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@slow'
+- '@blocking'
+- '@connection'
+arguments:
+- display_text: numreplicas
+  name: numreplicas
+  type: integer
+- display_text: timeout
+  name: timeout
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- blocking
+complexity: O(1)
+description: Blocks until the asynchronous replication of all preceding write commands
+  sent by the connection is completed.
+group: generic
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:agg_min
+linkTitle: WAIT
+since: 3.0.0
+summary: Blocks until the asynchronous replication of all preceding write commands
+  sent by the connection is completed.
+syntax_fmt: WAIT numreplicas timeout
+syntax_str: timeout
+title: WAIT
+---
+
+This command blocks the current client until all the previous write commands
+are successfully transferred and acknowledged by at least the number
+of replicas you specify in the `numreplicas` argument. If the value
+you specify for the `timeout` argument (in milliseconds) is reached, the command
+returns even if the specified number of replicas were not yet reached.
+
+The command **will always return** the number of replicas that acknowledged
+the write commands sent by the current client before the `WAIT` command, both in the case where
+the specified number of replicas are reached, or when the timeout is reached.
+
+A few remarks:
+
+1. When `WAIT` returns, all the previous write commands sent in the context of the current connection are guaranteed to be received by the number of replicas returned by `WAIT`.
+2. If the command is sent as part of a [`MULTI`]({{< relref "/commands/multi" >}}) transaction (since Redis 7.0, any context that does not allow blocking, such as inside scripts), the command does not block but instead just return ASAP the number of replicas that acknowledged the previous write commands.
+3. A timeout of 0 means to block forever.
+4. Since `WAIT` returns the number of replicas reached both in case of failure and success, the client should check that the returned value is equal or greater to the replication level it demanded.
+
+Consistency and WAIT
+---
+
+Note that `WAIT` does not make Redis a strongly consistent store: while synchronous replication is part of a replicated state machine, it is not the only thing needed. However in the context of Sentinel or Redis Cluster failover, `WAIT` improves the real world data safety.
+
+Specifically if a given write is transferred to one or more replicas, it is more likely (but not guaranteed) that if the master fails, we'll be able to promote, during a failover, a replica that received the write: both Sentinel and Redis Cluster will do a best-effort attempt to promote the best replica among the set of available replicas.
+
+However this is just a best-effort attempt so it is possible to still lose a write synchronously replicated to multiple replicas.
+
+Implementation details
+---
+
+Since the introduction of partial resynchronization with replicas (PSYNC feature) Redis replicas asynchronously ping their master with the offset they already processed in the replication stream. This is used in multiple ways:
+
+1. Detect timed out replicas.
+2. Perform a partial resynchronization after a disconnection.
+3. Implement `WAIT`.
+
+In the specific case of the implementation of `WAIT`, Redis remembers, for each client, the replication offset of the produced replication stream when a given
+write command was executed in the context of a given client. When `WAIT` is
+called Redis checks if the specified number of replicas already acknowledged
+this offset or a greater one.
+
+## Examples
+
+```
+> SET foo bar
+OK
+> WAIT 1 0
+(integer) 1
+> WAIT 2 1000
+(integer) 1
+```
+
+In the following example the first call to `WAIT` does not use a timeout and asks for the write to reach 1 replica. It returns with success. In the second attempt instead we put a timeout, and ask for the replication of the write to two replicas. Since there is a single replica available, after one second `WAIT` unblocks and returns 1, the number of replicas reached.
+---
+acl_categories:
+- '@slow'
+arguments:
+- display_text: slot
+  name: slot
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(1)
+description: Returns the number of keys in a hash slot.
+group: cluster
+hidden: false
+linkTitle: CLUSTER COUNTKEYSINSLOT
+since: 3.0.0
+summary: Returns the number of keys in a hash slot.
+syntax_fmt: CLUSTER COUNTKEYSINSLOT slot
+syntax_str: ''
+title: CLUSTER COUNTKEYSINSLOT
+---
+Returns the number of keys in the specified Redis Cluster hash slot. The
+command only queries the local data set, so contacting a node
+that is not serving the specified hash slot will always result in a count of
+zero being returned.
+
+```
+> CLUSTER COUNTKEYSINSLOT 7000
+(integer) 50341
+```
+---
+acl_categories:
+- '@cms'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: width
+  type: integer
+- name: depth
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Initializes a Count-Min Sketch to dimensions specified by user
+group: cms
+hidden: false
+linkTitle: CMS.INITBYDIM
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Initializes a Count-Min Sketch to dimensions specified by user
+syntax_fmt: CMS.INITBYDIM key width depth
+syntax_str: width depth
+title: CMS.INITBYDIM
+---
+Initializes a Count-Min Sketch to dimensions specified by user.
+
+### Parameters:
+
+* **key**: The name of the sketch.
+* **width**: Number of counters in each array. Reduces the error size.
+* **depth**: Number of counter-arrays. Reduces the probability for an
+    error of a certain size (percentage of total count).
+
+## Return
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+```
+redis> CMS.INITBYDIM test 2000 5
+OK
+```---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: script
+  name: script
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the script that is executed.
+description: Executes a read-only server-side Lua script.
+group: scripting
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+  notes: We cannot tell how the keys will be used so we assume the worst, RO and ACCESS
+linkTitle: EVAL_RO
+since: 7.0.0
+summary: Executes a read-only server-side Lua script.
+syntax_fmt: EVAL_RO script numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: EVAL_RO
+---
+This is a read-only variant of the [`EVAL`]({{< relref "/commands/eval" >}}) command that cannot execute commands that modify data.
+
+For more information about when to use this command vs [`EVAL`]({{< relref "/commands/eval" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability#read-only-scripts" >}}).
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+
+## Examples
+
+```
+> SET mykey "Hello"
+OK
+
+> EVAL_RO "return redis.call('GET', KEYS[1])" 1 mykey
+"Hello"
+
+> EVAL_RO "return redis.call('DEL', KEYS[1])" 1 mykey
+(error) ERR Error running script (call to b0d697da25b13e49157b2c214a4033546aba2104): @user_script:1: @user_script: 1: Write commands are not allowed from read-only scripts.
+```
+---
+acl_categories:
+- '@stream'
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: stream
+hidden: true
+linkTitle: XINFO HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: XINFO HELP
+syntax_str: ''
+title: XINFO HELP
+---
+The `XINFO HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+complexity: O(1)
+description: Asynchronously rewrites the append-only file to disk.
+group: server
+hidden: false
+linkTitle: BGREWRITEAOF
+since: 1.0.0
+summary: Asynchronously rewrites the append-only file to disk.
+syntax_fmt: BGREWRITEAOF
+syntax_str: ''
+title: BGREWRITEAOF
+---
+Instruct Redis to start an [Append Only File]({{< relref "/operate/oss_and_stack/management/persistence" >}}#append-only-file) rewrite process.
+The rewrite will create a small optimized version of the current Append Only
+File.
+
+If `BGREWRITEAOF` fails, no data gets lost as the old AOF will be untouched.
+
+The rewrite will be only triggered by Redis if there is not already a background
+process doing persistence.
+
+Specifically:
+
+* If a Redis child is creating a snapshot on disk, the AOF rewrite is _scheduled_ but not started until the saving child producing the RDB file terminates. In this case the `BGREWRITEAOF` will still return a positive status reply, but with an appropriate message.  You can check if an AOF rewrite is scheduled looking at the [`INFO`]({{< relref "/commands/info" >}}) command as of Redis 2.6 or successive versions.
+* If an AOF rewrite is already in progress the command returns an error and no
+  AOF rewrite will be scheduled for a later time.
+* If the AOF rewrite could start, but the attempt at starting it fails (for instance because of an error in creating the child process), an error is returned to the caller.
+
+Since Redis 2.4 the AOF rewrite is automatically triggered by Redis, however the
+`BGREWRITEAOF` command can be used to trigger a rewrite at any time.
+
+See the [persistence documentation]({{< relref "/operate/oss_and_stack/management/persistence" >}}) for detailed information.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: slot
+  multiple: true
+  name: slot
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(N) where N is the total number of hash slot arguments
+description: Sets hash slots as unbound for a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER DELSLOTS
+since: 3.0.0
+summary: Sets hash slots as unbound for a node.
+syntax_fmt: CLUSTER DELSLOTS slot [slot ...]
+syntax_str: ''
+title: CLUSTER DELSLOTS
+---
+In Redis Cluster, each node keeps track of which master is serving
+a particular hash slot.
+
+The `CLUSTER DELSLOTS` command asks a particular Redis Cluster node to
+forget which master is serving the hash slots specified as arguments.
+
+In the context of a node that has received a `CLUSTER DELSLOTS` command and
+has consequently removed the associations for the passed hash slots,
+we say those hash slots are *unbound*. Note that the existence of
+unbound hash slots occurs naturally when a node has not been
+configured to handle them (something that can be done with the
+[`CLUSTER ADDSLOTS`]({{< relref "/commands/cluster-addslots" >}}) command) and if it has not received any information about
+who owns those hash slots (something that it can learn from heartbeat
+or update messages).
+
+If a node with unbound hash slots receives a heartbeat packet from
+another node that claims to be the owner of some of those hash
+slots, the association is established instantly. Moreover, if a
+heartbeat or update message is received with a configuration epoch
+greater than the node's own, the association is re-established.
+
+However, note that:
+
+1. The command only works if all the specified slots are already
+associated with some node.
+2. The command fails if the same slot is specified multiple times.
+3. As a side effect of the command execution, the node may go into
+*down* state because not all hash slots are covered.
+
+## Example
+
+The following command removes the association for slots 5000 and
+5001 from the node receiving the command:
+
+    > CLUSTER DELSLOTS 5000 5001
+    OK
+
+## Usage in Redis Cluster
+
+This command only works in cluster mode and may be useful for
+debugging and in order to manually orchestrate a cluster configuration
+when a new cluster is created. It is currently not used by `redis-cli`,
+and mainly exists for API completeness.
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arguments:
+- display_text: message
+  name: message
+  optional: true
+  type: string
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- fast
+complexity: O(1)
+description: Returns the server's liveliness response.
+group: connection
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: PING
+since: 1.0.0
+summary: Returns the server's liveliness response.
+syntax_fmt: PING [message]
+syntax_str: ''
+title: PING
+---
+Returns `PONG` if no argument is provided, otherwise return a copy of the
+argument as a bulk.
+This command is useful for:
+1. Testing whether a connection is still alive.
+1. Verifying the server's ability to serve data - an error is returned when this isn't the case (e.g., during load from persistence or accessing a stale replica).
+1. Measuring latency.
+
+If the client is subscribed to a channel or a pattern, it will instead return a
+multi-bulk with a "pong" in the first position and an empty bulk in the second
+position, unless an argument is provided in which case it returns a copy
+of the argument.
+
+## Examples
+
+{{% redis-cli %}}
+PING
+
+PING "hello world"
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of elements being checked for membership
+description: Determines whether multiple members belong to a set.
+group: set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SMISMEMBER
+since: 6.2.0
+summary: Determines whether multiple members belong to a set.
+syntax_fmt: SMISMEMBER key member [member ...]
+syntax_str: member [member ...]
+title: SMISMEMBER
+---
+Returns whether each `member` is a member of the set stored at `key`.
+
+For every `member`, `1` is returned if the value is a member of the set, or `0` if the element is not a member of the set or if `key` does not exist.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "one"
+SADD myset "one"
+SMISMEMBER myset "one" "notamember"
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@fast'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Returns the replication role.
+group: server
+hidden: false
+linkTitle: ROLE
+since: 2.8.12
+summary: Returns the replication role.
+syntax_fmt: ROLE
+syntax_str: ''
+title: ROLE
+---
+Provide information on the role of a Redis instance in the context of replication, by returning if the instance is currently a `master`, `slave`, or `sentinel`. The command also returns additional information about the state of the replication (if the role is master or slave) or the list of monitored master names (if the role is sentinel).
+
+## Output format
+
+The command returns an array of elements. The first element is the role of
+the instance, as one of the following three strings:
+
+* "master"
+* "slave"
+* "sentinel"
+
+The additional elements of the array depends on the role.
+
+## Master output
+
+An example of output when `ROLE` is called in a master instance:
+
+```
+1) "master"
+2) (integer) 3129659
+3) 1) 1) "127.0.0.1"
+      2) "9001"
+      3) "3129242"
+   2) 1) "127.0.0.1"
+      2) "9002"
+      3) "3129543"
+```
+
+The master output is composed of the following parts:
+
+1. The string `master`.
+2. The current master replication offset, which is an offset that masters and replicas share to understand, in partial resynchronizations, the part of the replication stream the replicas needs to fetch to continue.
+3. An array composed of three elements array representing the connected replicas. Every sub-array contains the replica IP, port, and the last acknowledged replication offset.
+
+## Output of the command on replicas
+
+An example of output when `ROLE` is called in a replica instance:
+
+```
+1) "slave"
+2) "127.0.0.1"
+3) (integer) 9000
+4) "connected"
+5) (integer) 3167038
+```
+
+The replica output is composed of the following parts:
+
+1. The string `slave`, because of backward compatibility (see note at the end of this page).
+2. The IP of the master.
+3. The port number of the master.
+4. The state of the replication from the point of view of the master, that can be `connect` (the instance needs to connect to its master), `connecting` (the master-replica connection is in progress), `sync` (the master and replica are trying to perform the synchronization), `connected` (the replica is online).
+5. The amount of data received from the replica so far in terms of master replication offset.
+
+## Sentinel output
+
+An example of Sentinel output:
+
+```
+1) "sentinel"
+2) 1) "resque-master"
+   2) "html-fragments-master"
+   3) "stats-master"
+   4) "metadata-master"
+```
+
+The sentinel output is composed of the following parts:
+
+1. The string `sentinel`.
+2. An array of master names monitored by this Sentinel instance.
+
+## Examples
+
+{{% redis-cli %}}
+ROLE
+{{% /redis-cli %}}
+
+
+**A note about the word slave used in this man page**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the total number of elements in all given sets.
+description: Returns the union of multiple sets.
+group: set
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SUNION
+since: 1.0.0
+summary: Returns the union of multiple sets.
+syntax_fmt: SUNION key [key ...]
+syntax_str: ''
+title: SUNION
+---
+Returns the members of the set resulting from the union of all the given sets.
+
+For example:
+
+```
+key1 = {a,b,c,d}
+key2 = {c}
+key3 = {a,c,e}
+SUNION key1 key2 key3 = {a,b,c,d,e}
+```
+
+Keys that do not exist are considered to be empty sets.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SUNION key1 key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: string
+- display_text: max
+  name: max
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements removed by the operation.
+description: Removes members in a sorted set within a lexicographical range. Deletes
+  the sorted set if all members were removed.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREMRANGEBYLEX
+since: 2.8.9
+summary: Removes members in a sorted set within a lexicographical range. Deletes the
+  sorted set if all members were removed.
+syntax_fmt: ZREMRANGEBYLEX key min max
+syntax_str: min max
+title: ZREMRANGEBYLEX
+---
+When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command removes all elements in the sorted set stored at `key` between the lexicographical range specified by `min` and `max`.
+
+The meaning of `min` and `max` are the same of the [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) command. Similarly, this command actually removes the same elements that [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) would return if called with the same `min` and `max` arguments.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e
+ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha
+ZRANGE myzset 0 -1
+ZREMRANGEBYLEX myzset [alpha [omega
+ZRANGE myzset 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the length of a list.
+group: list
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LLEN
+since: 1.0.0
+summary: Returns the length of a list.
+syntax_fmt: LLEN key
+syntax_str: ''
+title: LLEN
+---
+Returns the length of the list stored at `key`.
+If `key` does not exist, it is interpreted as an empty list and `0` is returned.
+An error is returned when the value stored at `key` is not a list.
+
+## Examples
+
+{{< clients-example cmds_list llen >}}
+redis> LPUSH mylist "World"
+(integer) 1
+redis> LPUSH mylist "Hello"
+(integer) 2
+redis> LLEN mylist
+(integer) 2
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+LPUSH mylist "World"
+LPUSH mylist "Hello"
+LLEN mylist
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+description: Listens for all requests received by the server in real-time.
+group: server
+hidden: false
+linkTitle: MONITOR
+since: 1.0.0
+summary: Listens for all requests received by the server in real-time.
+syntax_fmt: MONITOR
+syntax_str: ''
+title: MONITOR
+---
+`MONITOR` is a debugging command that streams back every command processed by
+the Redis server.
+It can help in understanding what is happening to the database.
+This command can both be used via `redis-cli` and via `telnet`.
+
+The ability to see all the requests processed by the server is useful in order
+to spot bugs in an application both when using Redis as a database and as a
+distributed caching system.
+
+```
+$ redis-cli monitor
+1339518083.107412 [0 127.0.0.1:60866] "keys" "*"
+1339518087.877697 [0 127.0.0.1:60866] "dbsize"
+1339518090.420270 [0 127.0.0.1:60866] "set" "x" "6"
+1339518096.506257 [0 127.0.0.1:60866] "get" "x"
+1339518099.363765 [0 127.0.0.1:60866] "eval" "return redis.call('set','x','7')" "0"
+1339518100.363799 [0 lua] "set" "x" "7"
+1339518100.544926 [0 127.0.0.1:60866] "del" "x"
+```
+
+Use `SIGINT` (Ctrl-C) to stop a `MONITOR` stream running via `redis-cli`.
+
+```
+$ telnet localhost 6379
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+MONITOR
++OK
++1339518083.107412 [0 127.0.0.1:60866] "keys" "*"
++1339518087.877697 [0 127.0.0.1:60866] "dbsize"
++1339518090.420270 [0 127.0.0.1:60866] "set" "x" "6"
++1339518096.506257 [0 127.0.0.1:60866] "get" "x"
++1339518099.363765 [0 127.0.0.1:60866] "del" "x"
++1339518100.544926 [0 127.0.0.1:60866] "get" "x"
+QUIT
++OK
+Connection closed by foreign host.
+```
+
+Manually issue the [`QUIT`]({{< relref "/commands/quit" >}}) or [`RESET`]({{< relref "/commands/reset" >}}) commands to stop a `MONITOR` stream running
+via `telnet`.
+
+## Commands not logged by MONITOR
+
+Because of security concerns, no administrative commands are logged
+by `MONITOR`'s output and sensitive data is redacted in the command [`AUTH`]({{< relref "/commands/auth" >}}).
+
+Furthermore, the command [`QUIT`]({{< relref "/commands/quit" >}}) is also not logged.
+
+## Cost of running MONITOR
+
+Because `MONITOR` streams back **all** commands, its use comes at a cost.
+The following (totally unscientific) benchmark numbers illustrate what the cost
+of running `MONITOR` can be.
+
+Benchmark result **without** `MONITOR` running:
+
+```
+$ src/redis-benchmark -c 10 -n 100000 -q
+PING_INLINE: 101936.80 requests per second
+PING_BULK: 102880.66 requests per second
+SET: 95419.85 requests per second
+GET: 104275.29 requests per second
+INCR: 93283.58 requests per second
+```
+
+Benchmark result **with** `MONITOR` running (`redis-cli monitor > /dev/null`):
+
+```
+$ src/redis-benchmark -c 10 -n 100000 -q
+PING_INLINE: 58479.53 requests per second
+PING_BULK: 59136.61 requests per second
+SET: 41823.50 requests per second
+GET: 45330.91 requests per second
+INCR: 41771.09 requests per second
+```
+
+In this particular case, running a single `MONITOR` client can reduce the
+throughput by more than 50%.
+Running more `MONITOR` clients will reduce throughput even more.
+
+## Behavior change history
+
+*   `>= 6.0.0`: [`AUTH`]({{< relref "/commands/auth" >}}) excluded from the command's output.
+*   `>= 6.2.0`: "[`RESET`]({{< relref "/commands/reset" >}}) can be called to exit monitor mode.
+*   `>= 6.2.4`: "[`AUTH`]({{< relref "/commands/auth" >}}), [`HELLO`]({{< relref "/commands/hello" >}}), [`EVAL`]({{< relref "/commands/eval" >}}), [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}), [`EVALSHA`]({{< relref "/commands/evalsha" >}}) and [`EVALSHA_RO`]({{< relref "/commands/evalsha_ro" >}}) included in the command's output.---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: N/A
+description: Debugging container command
+group: json
+hidden: false
+linkTitle: JSON.DEBUG
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Debugging container command
+syntax_fmt: JSON.DEBUG
+syntax_str: ''
+title: JSON.DEBUG
+---
+This is a container command for debugging related tasks.
+---
+acl_categories:
+- '@admin'
+- '@search'
+- '@slow'
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns a list of all existing indexes
+group: search
+hidden: false
+linkTitle: FT._LIST
+module: Search
+since: 2.0.0
+stack_path: docs/interact/search-and-query
+summary: Returns a list of all existing indexes
+syntax_fmt: FT._LIST
+syntax_str: ''
+title: FT._LIST
+---
+Returns a list of all existing indexes.
+
+
+{{% alert title="Temporary command" color="info" %}}
+The prefix `_` in the command indicates, this is a temporary command.
+
+In the future, a [`SCAN`]({{< relref "/commands/scan" >}}) type of command will be added, for use when a database
+contains a large number of indices.
+{{% /alert %}}
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with index names.
+
+## Examples
+
+```sql
+FT._LIST
+1) "idx"
+2) "movies"
+3) "imdb"
+```---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: indent
+  optional: true
+  token: INDENT
+  type: string
+- name: newline
+  optional: true
+  token: NEWLINE
+  type: string
+- name: space
+  optional: true
+  token: SPACE
+  type: string
+- multiple: true
+  name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  value, O(N) when path is evaluated to multiple values, where N is the size of the
+  key
+description: Gets the value at one or more paths in JSON serialized form
+group: json
+hidden: false
+linkTitle: JSON.GET
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Gets the value at one or more paths in JSON serialized form
+syntax_fmt: "JSON.GET key [INDENT\_indent] [NEWLINE\_newline] [SPACE\_space] [path\n\
+  \  [path ...]]"
+syntax_str: "[INDENT\_indent] [NEWLINE\_newline] [SPACE\_space] [path [path ...]]"
+title: JSON.GET
+---
+Return the value at `path` in JSON serialized form
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. JSON.GET accepts multiple `path` arguments.
+
+{{% alert title="Note" color="warning" %}}
+
+When using a single JSONPath, the root of the matching values is a JSON string with a top-level **array** of serialized JSON value. 
+In contrast, a legacy path returns a single value.
+
+When using multiple JSONPath arguments, the root of the matching values is a JSON string with a top-level **object**, with each object value being a top-level array of serialized JSON value.
+In contrast, if all paths are legacy paths, each object value is a single serialized JSON value.
+If there are multiple paths that include both legacy path and JSONPath, the returned value conforms to the JSONPath version (an array of values).
+
+{{% /alert %}}
+
+</details>
+
+<details open><summary><code>INDENT</code></summary> 
+
+sets the indentation string for nested levels.
+</details>
+
+<details open><summary><code>NEWLINE</code></summary> 
+
+sets the string that's printed at the end of each line.
+</details>
+
+<details open><summary><code>SPACE</code></summary> 
+
+sets the string that's put between a key and a value.
+</details>
+
+{{% alert title="Note" color="warning" %}}
+ 
+Produce pretty-formatted JSON with `redis-cli` by following this example:
+
+{{< highlight bash >}}
+~/$ redis-cli --raw
+redis> JSON.GET myjsonkey INDENT "\t" NEWLINE "\n" SPACE " " path.to.value[1]
+{{< / highlight >}}
+
+{{% /alert %}}
+
+## Return
+
+JSON.GET returns a bulk string representing a JSON array of string replies. 
+Each string is the JSON serialization of each JSON value that matches a path. 
+Using multiple paths, JSON.GET returns a bulk string representing a JSON object with string values. 
+Each string value is an array of the JSON serialization of each JSON value that matches a path.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Return the value at <code>path</code> in JSON serialized form</b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2, "b": 3, "nested": {"a": 4, "b": null}}'
+OK
+{{< / highlight >}}
+
+With a single JSONPath (JSON array bulk string):
+
+{{< highlight bash >}}
+redis>  JSON.GET doc $..b
+"[3,null]"
+{{< / highlight >}}
+
+Using multiple paths with at least one JSONPath returns a JSON string with a top-level object with an array of JSON values per path:
+
+{{< highlight bash >}}
+redis> JSON.GET doc ..a $..b
+"{\"$..b\":[3,null],\"..a\":[2,4]}"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.MGET`]({{< relref "commands/json.mget/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: event
+  multiple: true
+  name: event
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Resets the latency data for one or more events.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:agg_sum
+linkTitle: LATENCY RESET
+since: 2.8.13
+summary: Resets the latency data for one or more events.
+syntax_fmt: LATENCY RESET [event [event ...]]
+syntax_str: ''
+title: LATENCY RESET
+---
+The `LATENCY RESET` command resets the latency spikes time series of all, or only some, events.
+
+When the command is called without arguments, it resets all the
+events, discarding the currently logged latency spike events, and resetting
+the maximum event time register.
+
+It is possible to reset only specific events by providing the `event` names
+as arguments.
+
+Valid values for `event` are:
+* `active-defrag-cycle`
+* `aof-fsync-always`
+* `aof-stat`
+* `aof-rewrite-diff-write`
+* `aof-rename`
+* `aof-write`
+* `aof-write-active-child`
+* `aof-write-alone`
+* `aof-write-pending-fsync`
+* `command`
+* `expire-cycle`
+* `eviction-cycle`
+* `eviction-del`
+* `fast-command`
+* `fork`
+* `rdb-unlink-temp-file`
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Returns the string value of a key after deleting the key.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GETDEL
+since: 6.2.0
+summary: Returns the string value of a key after deleting the key.
+syntax_fmt: GETDEL key
+syntax_str: ''
+title: GETDEL
+---
+Get the value of `key` and delete the key.
+This command is similar to [`GET`]({{< relref "/commands/get" >}}), except for the fact that it also deletes the key on success (if and only if the key's value type is a string).
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+GETDEL mykey
+GET mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+- display_text: withscore
+  name: withscore
+  optional: true
+  token: WITHSCORE
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(log(N))
+description: Returns the index of a member in a sorted set ordered by descending scores.
+group: sorted-set
+hidden: false
+history:
+- - 7.2.0
+  - Added the optional `WITHSCORE` argument.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREVRANK
+since: 2.0.0
+summary: Returns the index of a member in a sorted set ordered by descending scores.
+syntax_fmt: ZREVRANK key member [WITHSCORE]
+syntax_str: member [WITHSCORE]
+title: ZREVRANK
+---
+Returns the rank of `member` in the sorted set stored at `key`, with the scores
+ordered from high to low.
+The rank (or index) is 0-based, which means that the member with the highest
+score has rank `0`.
+
+The optional `WITHSCORE` argument supplements the command's reply with the score of the element returned.
+
+Use [`ZRANK`]({{< relref "/commands/zrank" >}}) to get the rank of an element with the scores ordered from low to
+high.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREVRANK myzset "one"
+ZREVRANK myzset "four"
+ZREVRANK myzset "three" WITHSCORE
+ZREVRANK myzset "four" WITHSCORE
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: MEMORY HELP
+since: 4.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: MEMORY HELP
+syntax_str: ''
+title: MEMORY HELP
+---
+The `MEMORY HELP` command returns a helpful text describing the different
+subcommands.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) to access the key and additional O(N*M) to serialize it, where N
+  is the number of Redis objects composing the value and M their average size. For
+  small string values the time complexity is thus O(1)+O(1*M) where M is small, so
+  simply O(1).
+description: Returns a serialized representation of the value stored at a key.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: DUMP
+since: 2.6.0
+summary: Returns a serialized representation of the value stored at a key.
+syntax_fmt: DUMP key
+syntax_str: ''
+title: DUMP
+---
+Serialize the value stored at key in a Redis-specific format and return it to
+the user.
+The returned value can be synthesized back into a Redis key using the [`RESTORE`]({{< relref "/commands/restore" >}})
+command.
+
+The serialization format is opaque and non-standard, however it has a few
+semantic characteristics:
+
+* It contains a 64-bit checksum that is used to make sure errors will be
+  detected.
+  The [`RESTORE`]({{< relref "/commands/restore" >}}) command makes sure to check the checksum before synthesizing a
+  key using the serialized value.
+* Values are encoded in the same format used by RDB.
+* An RDB version is encoded inside the serialized value, so that different Redis
+  versions with incompatible RDB formats will refuse to process the serialized
+  value.
+
+The serialized value does NOT contain expire information.
+In order to capture the time to live of the current value the [`PTTL`]({{< relref "/commands/pttl" >}}) command
+should be used.
+
+If `key` does not exist a nil bulk reply is returned.
+
+## Examples
+
+```
+> SET mykey 10
+OK
+> DUMP mykey
+"\x00\xc0\n\n\x00n\x9fWE\x0e\xaec\xbb"
+```
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: 'yes'
+    name: 'yes'
+    token: 'YES'
+    type: pure-token
+  - display_text: 'no'
+    name: 'no'
+    token: 'NO'
+    type: pure-token
+  name: mode
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Instructs the server whether to track the keys in the next request.
+group: connection
+hidden: false
+linkTitle: CLIENT CACHING
+since: 6.0.0
+summary: Instructs the server whether to track the keys in the next request.
+syntax_fmt: CLIENT CACHING <YES | NO>
+syntax_str: ''
+title: CLIENT CACHING
+---
+This command controls the tracking of the keys in the next command executed
+by the connection, when tracking is enabled in `OPTIN` or `OPTOUT` mode.
+Please check the
+[client side caching documentation]({{< relref "/develop/clients/client-side-caching" >}}) for
+background information.
+
+When tracking is enabled Redis, using the [`CLIENT TRACKING`]({{< relref "/commands/client-tracking" >}}) command, it is
+possible to specify the `OPTIN` or `OPTOUT` options, so that keys
+in read only commands are not automatically remembered by the server to
+be invalidated later. When we are in `OPTIN` mode, we can enable the
+tracking of the keys in the next command by calling `CLIENT CACHING yes`
+immediately before it. Similarly when we are in `OPTOUT` mode, and keys
+are normally tracked, we can avoid the keys in the next command to be
+tracked using `CLIENT CACHING no`.
+
+Basically the command sets a state in the connection, that is valid only
+for the next command execution, that will modify the behavior of client
+tracking.
+---
+acl_categories:
+- '@topk'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- arguments:
+  - name: item
+    type: string
+  - name: increment
+    type: integer
+  multiple: true
+  name: items
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n * k * incr) where n is the number of items, k is the depth and incr
+  is the increment
+description: Increases the count of one or more items by increment
+group: topk
+hidden: false
+linkTitle: TOPK.INCRBY
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Increases the count of one or more items by increment
+syntax_fmt: TOPK.INCRBY key item increment [item increment ...]
+syntax_str: item increment [item increment ...]
+title: TOPK.INCRBY
+---
+Increase the score of an item in the data structure by increment. 
+Multiple items' score can be increased at once.
+If an item enters the Top-K list, the item which is expelled is returned.
+
+### Parameters
+
+* **key**: Name of sketch where item is added.
+* **item**: Item/s to be added.
+* **increment**: increment to current item score. Increment must be greater or equal to 1. Increment is limited to 100,000 to avoid server freeze.
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - if an element was dropped from the TopK list, [Nil reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}) otherwise..
+
+@example
+
+```
+redis> TOPK.INCRBY topk foo 3 bar 2 42 30
+1) (nil)
+2) (nil)
+3) foo
+```---
+acl_categories:
+- '@bloom'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns the cardinality of a Bloom filter
+group: bf
+hidden: false
+linkTitle: BF.CARD
+module: Bloom
+since: 2.4.4
+stack_path: docs/data-types/probabilistic
+summary: Returns the cardinality of a Bloom filter
+syntax_fmt: BF.CARD key
+syntax_str: ''
+title: BF.CARD
+---
+Returns the cardinality of a Bloom filter - number of items that were added to a Bloom filter and detected as unique (items that caused at least one bit to be set in at least one sub-filter)
+
+(since RedisBloom 2.4.4)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter.
+
+</details>
+
+## Return value
+ 
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the number of items that were added to this Bloom filter and detected as unique (items that caused at least one bit to be set in at least one sub-filter), or 0 when `key` does not exist.
+- [] on error (invalid arguments, wrong key type, etc.)
+
+Note: when `key` exists - return the same value as `BF.INFO key ITEMS`.
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.ADD bf1 item_foo
+(integer) 1
+redis> BF.CARD bf1
+(integer) 1
+redis> BF.CARD bf_new
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@bitmap'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: encoding
+    name: encoding
+    type: string
+  - display_text: offset
+    name: offset
+    type: integer
+  multiple: true
+  multiple_token: true
+  name: get-block
+  optional: true
+  token: GET
+  type: block
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1) for each subcommand specified
+description: Performs arbitrary read-only bitfield integer operations on strings.
+group: bitmap
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: BITFIELD_RO
+since: 6.0.0
+summary: Performs arbitrary read-only bitfield integer operations on strings.
+syntax_fmt: "BITFIELD_RO key [GET\_encoding offset [GET encoding offset ...]]"
+syntax_str: "[GET\_encoding offset [GET encoding offset ...]]"
+title: BITFIELD_RO
+---
+Read-only variant of the [`BITFIELD`]({{< relref "/commands/bitfield" >}}) command.
+It is like the original [`BITFIELD`]({{< relref "/commands/bitfield" >}}) but only accepts `GET` subcommand and can safely be used in read-only replicas.
+
+Since the original [`BITFIELD`]({{< relref "/commands/bitfield" >}}) has `SET` and `INCRBY` options it is technically flagged as a writing command in the Redis command table.
+For this reason read-only replicas in a Redis Cluster will redirect it to the master instance even if the connection is in read-only mode (see the [`READONLY`]({{< relref "/commands/readonly" >}}) command of Redis Cluster).
+
+Since Redis 6.2, the `BITFIELD_RO` variant was introduced in order to allow [`BITFIELD`]({{< relref "/commands/bitfield" >}}) behavior in read-only replicas without breaking compatibility on command flags.
+
+See original [`BITFIELD`]({{< relref "/commands/bitfield" >}}) for more details.
+
+## Examples
+
+```
+BITFIELD_RO hello GET i8 16
+```
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: value
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of values specified.
+description: Returns, for each input value (floating-point), the estimated reverse
+  rank of the value (the number of observations in the sketch that are larger than
+  the value + half the number of observations that are equal to the value)
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.REVRANK
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input value (floating-point), the estimated reverse rank
+  of the value (the number of observations in the sketch that are larger than the
+  value + half the number of observations that are equal to the value)
+syntax_fmt: TDIGEST.REVRANK key value [value ...]
+syntax_str: value [value ...]
+title: TDIGEST.REVRANK
+---
+Returns, for each input value (floating-point), the estimated reverse rank of the value (the number of observations in the sketch that are larger than the value + half the number of observations that are equal to the value).
+
+Multiple reverse ranks can be retrieved in a single call.
+
+## Required arguments
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>value</code></summary>
+is input value for which the reverse rank should be estimated.
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - an array of integers populated with revrank_1, revrank_2, ..., revrank_V:
+  
+- -1 - when `value` is larger than the value of the largest observation.
+- The number of observations - when `value` is smaller than the value of the smallest observation.
+- Otherwise: an estimation of the number of (observations larger than `value` + half the observations equal to `value`).
+  
+0 is the reverse rank of the value of the largest observation.
+
+_n_-1 is the reverse rank of the value of the smallest observation; _n_ denotes the number of observations added to the sketch.
+
+All values are -2 if the sketch is empty.  
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE s COMPRESSION 1000
+OK
+redis> TDIGEST.ADD s 10 20 30 40 50 60
+OK
+redis> TDIGEST.RANK s 0 10 20 30 40 50 60 70
+1) (integer) -1
+2) (integer) 0
+3) (integer) 1
+4) (integer) 2
+5) (integer) 3
+6) (integer) 4
+7) (integer) 5
+8) (integer) 6
+redis> TDIGEST.REVRANK s 0 10 20 30 40 50 60 70
+1) (integer) 6
+2) (integer) 5
+3) (integer) 4
+4) (integer) 3
+5) (integer) 2
+6) (integer) 1
+7) (integer) 0
+8) (integer) -1
+{{< / highlight >}}
+  
+{{< highlight bash >}}
+redis> TDIGEST.CREATE s COMPRESSION 1000
+OK
+redis> TDIGEST.ADD s 10 10 10 10 20 20
+OK
+redis> TDIGEST.RANK s 10 20
+1) (integer) 2
+2) (integer) 5
+redis> TDIGEST.REVRANK s 10 20
+1) (integer) 4
+2) (integer) 1
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- allow_busy
+complexity: O(1)
+description: Terminates a server-side Lua script during execution.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:one_succeeded
+linkTitle: SCRIPT KILL
+since: 2.6.0
+summary: Terminates a server-side Lua script during execution.
+syntax_fmt: SCRIPT KILL
+syntax_str: ''
+title: SCRIPT KILL
+---
+Kills the currently executing [`EVAL`]({{< relref "/commands/eval" >}}) script, assuming no write operation was yet
+performed by the script.
+
+This command is mainly useful to kill a script that is running for too much
+time(for instance, because it entered an infinite loop because of a bug).
+The script will be killed, and the client currently blocked into EVAL will see
+the command returning with an error.
+
+If the script has already performed write operations, it can not be killed in this
+way because it would violate Lua's script atomicity contract.
+In such a case, only `SHUTDOWN NOSAVE` can kill the script, killing
+the Redis process in a hard way and preventing it from persisting with half-written
+information.
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  multiple: true
+  name: field
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of fields to be removed.
+description: Deletes one or more fields and their values from a hash. Deletes the
+  hash if no fields remain.
+group: hash
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple `field` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HDEL
+since: 2.0.0
+summary: Deletes one or more fields and their values from a hash. Deletes the hash
+  if no fields remain.
+syntax_fmt: HDEL key field [field ...]
+syntax_str: field [field ...]
+title: HDEL
+---
+Removes the specified fields from the hash stored at `key`.
+Specified fields that do not exist within this hash are ignored.
+Deletes the hash if no fields remain.
+If `key` does not exist, it is treated as an empty hash and this command returns
+`0`.
+
+## Examples
+
+{{% redis-cli %}}
+HSET myhash field1 "foo"
+HDEL myhash field1
+HDEL myhash field2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arguments:
+- display_text: message
+  name: message
+  type: string
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Returns the given string.
+group: connection
+hidden: false
+linkTitle: ECHO
+since: 1.0.0
+summary: Returns the given string.
+syntax_fmt: ECHO message
+syntax_str: ''
+title: ECHO
+---
+Returns `message`.
+
+## Examples
+
+{{% redis-cli %}}
+ECHO "Hello World!"
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+- display_text: value
+  name: value
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Sets the value of a field in a hash only when the field doesn't exist.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: HSETNX
+since: 2.0.0
+summary: Sets the value of a field in a hash only when the field doesn't exist.
+syntax_fmt: HSETNX key field value
+syntax_str: field value
+title: HSETNX
+---
+Sets `field` in the hash stored at `key` to `value`, only if `field` does not
+yet exist.
+If `key` does not exist, a new key holding a hash is created.
+If `field` already exists, this operation has no effect.
+
+## Examples
+
+{{% redis-cli %}}
+HSETNX myhash field "Hello"
+HSETNX myhash field "World"
+HGET myhash field
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns the latest latency samples for all events.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_nodes
+- response_policy:special
+linkTitle: LATENCY LATEST
+since: 2.8.13
+summary: Returns the latest latency samples for all events.
+syntax_fmt: LATENCY LATEST
+syntax_str: ''
+title: LATENCY LATEST
+---
+The `LATENCY LATEST` command reports the latest latency events logged.
+
+Each reported event has the following fields:
+
+* Event name.
+* Unix timestamp of the latest latency spike for the event.
+* Latest event latency in millisecond.
+* All-time maximum latency for this event.
+
+"All-time" means the maximum latency since the Redis instance was
+started, or the time that events were reset [`LATENCY RESET`]({{< relref "/commands/latency-reset" >}}).
+
+## Examples
+
+```
+127.0.0.1:6379> debug sleep 1
+OK
+(1.00s)
+127.0.0.1:6379> debug sleep .25
+OK
+127.0.0.1:6379> latency latest
+1) 1) "command"
+   2) (integer) 1405067976
+   3) (integer) 251
+   4) (integer) 1001
+```
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@search'
+arguments:
+- name: dict
+  type: string
+- multiple: true
+  name: term
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Deletes terms from a dictionary
+group: search
+hidden: false
+linkTitle: FT.DICTDEL
+module: Search
+since: 1.4.0
+stack_path: docs/interact/search-and-query
+summary: Deletes terms from a dictionary
+syntax: 'FT.DICTDEL dict term [term ...]
+
+  '
+syntax_fmt: FT.DICTDEL dict term [term ...]
+syntax_str: term [term ...]
+title: FT.DICTDEL
+---
+
+Delete terms from a dictionary
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>dict</code></summary>
+
+is dictionary name.
+</details>
+
+<details open>
+<summary><code>term</code></summary>
+
+term to delete from the dictionary.
+</details>
+
+## Return
+
+FT.DICTDEL returns an integer reply, the number of new terms that were deleted.
+
+## Examples
+
+<details open>
+<summary><b>Delete terms from a dictionary</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.DICTDEL dict foo bar "hello world"
+(integer) 3
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.DICTADD`]({{< relref "commands/ft.dictadd/" >}}) | [`FT.DICTDUMP`]({{< relref "commands/ft.dictdump/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k + i), where k is the number of sub-filters and i is maxIterations
+description: Adds an item to a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.ADD
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds an item to a Cuckoo Filter
+syntax_fmt: CF.ADD key item
+syntax_str: item
+title: CF.ADD
+---
+Adds an item to the cuckoo filter.
+
+Cuckoo filters can contain the same item multiple times, and consider each addition as separate.
+Use [`CF.ADDNX`]({{< relref "commands/cf.addnx/" >}}) to add an item only if it does not exist.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to add the item to.
+
+If `key` does not exist - a new cuckoo filter is created.
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to add.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that the item has been added successfully
+- [] on error (invalid arguments, wrong key type, etc.) and also when the filter is full
+
+## Complexity
+
+O(n + i), where n is the number of `sub-filters` and i is `maxIterations`.
+Adding items requires up to 2 memory accesses per `sub-filter`.
+But as the filter fills up, both locations for an item might be full.
+The filter attempts to `Cuckoo` swap items up to `maxIterations` times.
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.ADD cf item1
+(integer) 1
+redis> CF.ADD cf item1
+(integer) 1
+{{< / highlight >}}
+---
+acl_categories:
+- '@topk'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information about a sketch
+group: topk
+hidden: false
+linkTitle: TOPK.INFO
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Returns information about a sketch
+syntax_fmt: TOPK.INFO key
+syntax_str: ''
+title: TOPK.INFO
+---
+Returns number of required items (k), width, depth and decay values.
+
+### Parameters
+
+* **key**: Name of sketch.
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with information of the filter.
+
+## Examples
+
+```
+TOPK.INFO topk
+1) k
+2) (integer) 50
+3) width
+4) (integer) 2000
+5) depth
+6) (integer) 7
+7) decay
+8) "0.92500000000000004"
+```
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: end
+  name: end
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the length of the returned string. The complexity is ultimately
+  determined by the returned length, but because creating a substring from an existing
+  string is very cheap, it can be considered O(1) for small strings.
+deprecated_since: 2.0.0
+description: Returns a substring from a string value.
+doc_flags:
+- deprecated
+group: string
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SUBSTR
+replaced_by: '[`GETRANGE`]({{< relref "/commands/getrange" >}})'
+since: 1.0.0
+summary: Returns a substring from a string value.
+syntax_fmt: SUBSTR key start end
+syntax_str: start end
+title: SUBSTR
+---
+Returns the substring of the string value stored at `key`, determined by the
+offsets `start` and `end` (both are inclusive).
+Negative offsets can be used in order to provide an offset starting from the end
+of the string.
+So -1 means the last character, -2 the penultimate and so forth.
+
+The function handles out of range requests by limiting the resulting range to
+the actual length of the string.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "This is a string"
+GETRANGE mykey 0 3
+GETRANGE mykey -3 -1
+GETRANGE mykey 0 -1
+GETRANGE mykey 10 100
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: start-slot
+    name: start-slot
+    type: integer
+  - display_text: end-slot
+    name: end-slot
+    type: integer
+  multiple: true
+  name: range
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(N) where N is the total number of the slots between the start slot and
+  end slot arguments.
+description: Assigns new hash slot ranges to a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER ADDSLOTSRANGE
+since: 7.0.0
+summary: Assigns new hash slot ranges to a node.
+syntax_fmt: CLUSTER ADDSLOTSRANGE start-slot end-slot [start-slot end-slot ...]
+syntax_str: ''
+title: CLUSTER ADDSLOTSRANGE
+---
+The `CLUSTER ADDSLOTSRANGE` is similar to the [`CLUSTER ADDSLOTS`]({{< relref "/commands/cluster-addslots" >}}) command in that they both assign hash slots to nodes.
+
+The difference between the two commands is that [`CLUSTER ADDSLOTS`]({{< relref "/commands/cluster-addslots" >}}) takes a list of slots to assign to the node, while `CLUSTER ADDSLOTSRANGE` takes a list of slot ranges (specified by start and end slots) to assign to the node.
+
+## Example
+
+To assign slots 1 2 3 4 5 to the node, the [`CLUSTER ADDSLOTS`]({{< relref "/commands/cluster-addslots" >}}) command is:
+
+    > CLUSTER ADDSLOTS 1 2 3 4 5
+    OK
+
+The same operation can be completed with the following `CLUSTER ADDSLOTSRANGE` command:
+
+    > CLUSTER ADDSLOTSRANGE 1 5
+    OK
+
+
+## Usage in Redis Cluster
+
+This command only works in cluster mode and is useful in the following Redis Cluster operations:
+
+1. To create a new cluster, `CLUSTER ADDSLOTSRANGE` is used to initially set up master nodes splitting the available hash slots among them.
+2. In order to fix a broken cluster where certain slots are unassigned.
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: value
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Increments the numeric value at path by a value
+group: json
+hidden: false
+linkTitle: JSON.NUMINCRBY
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Increments the numeric value at path by a value
+syntax_fmt: JSON.NUMINCRBY key path value
+syntax_str: path value
+title: JSON.NUMINCRBY
+---
+Increment the number value stored at `path` by `number`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is number value to increment. 
+</details>
+
+## Return 
+
+JSON.NUMINCRBY returns a bulk string reply specified as a stringified new value for each path, or `nil`, if the matching JSON value is not a number. 
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Increment number values</b></summary>
+
+Create a document.
+
+{{< highlight bash >}}
+redis> JSON.SET doc . '{"a":"b","b":[{"a":2}, {"a":5}, {"a":"c"}]}'
+OK
+{{< / highlight >}}
+
+Increment a value of `a` object by 2. The command fails to find a number and returns `null`.
+
+{{< highlight bash >}}
+redis> JSON.NUMINCRBY doc $.a 2
+"[null]"
+{{< / highlight >}}
+
+Recursively find and increment a value of all `a` objects. The command increments numbers it finds and returns `null` for nonnumber values.
+
+{{< highlight bash >}}
+redis> JSON.NUMINCRBY doc $..a 2
+"[null,4,7,null]"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: event
+  name: event
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns a latency graph for an event.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_nodes
+- response_policy:special
+linkTitle: LATENCY GRAPH
+since: 2.8.13
+summary: Returns a latency graph for an event.
+syntax_fmt: LATENCY GRAPH event
+syntax_str: ''
+title: LATENCY GRAPH
+---
+Produces an ASCII-art style graph for the specified event.
+
+`LATENCY GRAPH` lets you intuitively understand the latency trend of an `event` via state-of-the-art visualization. It can be used for quickly grasping the situation before resorting to means such parsing the raw data from [`LATENCY HISTORY`]({{< relref "/commands/latency-history" >}}) or external tooling.
+
+Valid values for `event` are:
+* `active-defrag-cycle`
+* `aof-fsync-always`
+* `aof-stat`
+* `aof-rewrite-diff-write`
+* `aof-rename`
+* `aof-write`
+* `aof-write-active-child`
+* `aof-write-alone`
+* `aof-write-pending-fsync`
+* `command`
+* `expire-cycle`
+* `eviction-cycle`
+* `eviction-del`
+* `fast-command`
+* `fork`
+* `rdb-unlink-temp-file`
+
+## Examples
+
+```
+127.0.0.1:6379> latency reset command
+(integer) 0
+127.0.0.1:6379> debug sleep .1
+OK
+127.0.0.1:6379> debug sleep .2
+OK
+127.0.0.1:6379> debug sleep .3
+OK
+127.0.0.1:6379> debug sleep .5
+OK
+127.0.0.1:6379> debug sleep .4
+OK
+127.0.0.1:6379> latency graph command
+command - high 500 ms, low 101 ms (all time high 500 ms)
+--------------------------------------------------------------------------------
+   #_
+  _||
+ _|||
+_||||
+
+11186
+542ss
+sss
+```
+
+The vertical labels under each graph column represent the amount of seconds,
+minutes, hours or days ago the event happened. For example "15s" means that the
+first graphed event happened 15 seconds ago.
+
+The graph is normalized in the min-max scale so that the zero (the underscore
+in the lower row) is the minimum, and a # in the higher row is the maximum.
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns details about memory usage.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_shards
+- response_policy:special
+linkTitle: MEMORY STATS
+since: 4.0.0
+summary: Returns details about memory usage.
+syntax_fmt: MEMORY STATS
+syntax_str: ''
+title: MEMORY STATS
+---
+The `MEMORY STATS` command returns an [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) about the memory usage of the
+server.
+
+The information about memory usage is provided as metrics and their respective
+values. The following metrics are reported:
+
+*   `peak.allocated`: Peak memory consumed by Redis in bytes (see [`INFO`]({{< relref "/commands/info" >}})'s
+     `used_memory_peak`)
+*   `total.allocated`: Total number of bytes allocated by Redis using its
+     allocator (see [`INFO`]({{< relref "/commands/info" >}})'s `used_memory`)
+*   `startup.allocated`: Initial amount of memory consumed by Redis at startup
+     in bytes (see [`INFO`]({{< relref "/commands/info" >}})'s `used_memory_startup`)
+*   `replication.backlog`: Size in bytes of the replication backlog (see
+     [`INFO`]({{< relref "/commands/info" >}})'s `repl_backlog_active`)
+*   `clients.slaves`: The total size in bytes of all replicas overheads (output
+     and query buffers, connection contexts)
+*   `clients.normal`: The total size in bytes of all clients overheads (output
+     and query buffers, connection contexts)
+*   `cluster.links`: Memory usage by cluster links (Added in Redis 7.0, see [`INFO`]({{< relref "/commands/info" >}})'s `mem_cluster_links`).
+*   `aof.buffer`: The summed size in bytes of AOF related buffers.
+*   `lua.caches`: the summed size in bytes of the overheads of the Lua scripts'
+     caches
+*   `functions.caches`: the summed size in bytes of the overheads of the Function scripts'
+     caches
+*   `dbXXX`: For each of the server's databases, the overheads of the main and
+     expiry dictionaries (`overhead.hashtable.main` and
+    `overhead.hashtable.expires`, respectively) are reported in bytes
+*   `overhead.db.hashtable.lut`: Total overhead of dictionary buckets in databases (Added in Redis 7.4)
+*   `overhead.db.hashtable.rehashing`: Temporary memory overhead of database dictionaries currently being rehashed (Added in Redis 7.4) 
+*   `overhead.total`: The sum of all overheads, i.e. `startup.allocated`,
+     `replication.backlog`, `clients.slaves`, `clients.normal`, `aof.buffer` and
+     those of the internal data structures that are used in managing the
+     Redis keyspace (see [`INFO`]({{< relref "/commands/info" >}})'s `used_memory_overhead`)
+*   `db.dict.rehashing.count`: Number of DB dictionaries currently being rehashed (Added in Redis 7.4)
+*   `keys.count`: The total number of keys stored across all databases in the
+     server
+*   `keys.bytes-per-key`: The ratio between `dataset.bytes` and `keys.count` 
+*   `dataset.bytes`: The size in bytes of the dataset, i.e. `overhead.total`
+     subtracted from `total.allocated` (see [`INFO`]({{< relref "/commands/info" >}})'s `used_memory_dataset`)
+*   `dataset.percentage`: The percentage of `dataset.bytes` out of the total
+     memory usage
+*   `peak.percentage`: The percentage of `total.allocated` out of
+     `peak.allocated`
+*   `allocator.allocated`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_allocated`
+*   `allocator.active`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_active`
+*   `allocator.resident`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_resident`
+*   `allocator.muzzy`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_muzzy`
+*   `allocator-fragmentation.ratio`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_frag_ratio`
+*   `allocator-fragmentation.bytes`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_frag_bytes`
+*   `allocator-rss.ratio`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_rss_ratio`
+*   `allocator-rss.bytes`: See [`INFO`]({{< relref "/commands/info" >}})'s `allocator_rss_bytes`
+*   `rss-overhead.ratio`: See [`INFO`]({{< relref "/commands/info" >}})'s `rss_overhead_ratio`
+*   `rss-overhead.bytes`: See [`INFO`]({{< relref "/commands/info" >}})'s `rss_overhead_bytes`
+*   `fragmentation`: See [`INFO`]({{< relref "/commands/info" >}})'s `mem_fragmentation_ratio`
+*   `fragmentation.bytes`: See [`INFO`]({{< relref "/commands/info" >}})'s `mem_fragmentation_bytes`
+
+**A note about the word slave used in this man page**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Associate or remove the JSON attributes of elements.
+group: vector_set
+hidden: false
+linkTitle: VSETATTR
+since: 8.0.0
+summary: Associate or remove the JSON attributes of elements.
+syntax_fmt: "VSETATTR key element \"{ JSON obj }\""
+title: VSETATTR
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Associate a JSON object with an element in a vector set. Use this command to store attributes that can be used in filtered similarity searches with `VSIM`.
+
+You can also update existing attributes or delete them by setting an empty string.
+
+```shell
+VSETATTR key element "{\"type\": \"fruit\", \"color\": \"red\"}"
+```
+
+To remove attributes, pass an empty JSON string:
+
+```shell
+VSETATTR key element ""
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element whose attributes you want to set or remove.
+</details>
+
+<details open>
+<summary><code>json</code></summary>
+
+is a valid JSON string. Use an empty string (`""`) to delete the attributes.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+- multiple: true
+  name: value
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Append one or more json values into the array at path after the last
+  element in it.
+group: json
+hidden: false
+linkTitle: JSON.ARRAPPEND
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Append one or more json values into the array at path after the last element
+  in it.
+syntax_fmt: JSON.ARRAPPEND key [path] value [value ...]
+syntax_str: '[path] value [value ...]'
+title: JSON.ARRAPPEND
+---
+Append the `json` values into the array at `path` after the last element in it
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is one or more values to append to one or more arrays. 
+
+{{% alert title="About using strings with JSON commands" color="warning" %}}
+To specify a string as an array value to append, wrap the quoted string with an additional set of single quotes. Example: `'"silver"'`. For more detailed use, see [Examples](#examples).
+{{% /alert %}}
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+## Return value 
+
+`JSON.ARRAPPEND` returns an [array]({{< relref "develop/reference/protocol-spec#resp-arrays" >}}) of integer replies for each path, the array's new size, or `nil`, if the matching JSON value is not an array. 
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Add a new color to a list of product colors</b></summary>
+
+Create a document for noise-cancelling headphones in black and silver colors.
+
+{{< highlight bash >}}
+redis> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"]}'
+OK
+{{< / highlight >}}
+
+Add color `blue` to the end of the `colors` array. `JSON.ARRAPPEND` returns the array's new size.
+
+{{< highlight bash >}}
+redis> JSON.ARRAPPEND item:1 $.colors '"blue"'
+1) (integer) 3
+{{< / highlight >}}
+
+Return the new length of the `colors` array.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1
+"{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\",\"blue\"]}"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: start
+  type: integer
+- name: stop
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  array, O(N) when path is evaluated to multiple values, where N is the size of the
+  key
+description: Trims the array at path to contain only the specified inclusive range
+  of indices from start to stop
+group: json
+hidden: false
+linkTitle: JSON.ARRTRIM
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Trims the array at path to contain only the specified inclusive range of
+  indices from start to stop
+syntax_fmt: JSON.ARRTRIM key path start stop
+syntax_str: path start stop
+title: JSON.ARRTRIM
+---
+Trim an array so that it contains only the specified inclusive range of elements
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+<details open><summary><code>start</code></summary> 
+
+is index of the first element to keep (previous elements are trimmed). Default is 0. 
+</details>
+
+<details open><summary><code>stop</code></summary> 
+
+is the index of the last element to keep (following elements are trimmed), including the last element. Default is 0. Negative values are interpreted as starting from the end.
+</details>
+
+{{% alert title="About out-of-range indexes" color="warning" %}}
+
+JSON.ARRTRIM is extremely forgiving, and using it with out-of-range indexes does not produce an error. Note a few differences between how RedisJSON v2.0 and legacy versions handle out-of-range indexes.
+
+Behavior as of RedisJSON v2.0:
+
+* If `start` is larger than the array's size or `start` > `stop`, returns 0 and an empty array. 
+* If `start` is < 0, then start from the end of the array.
+* If `stop` is larger than the end of the array, it is treated like the last element.
+{{% /alert %}}
+
+## Return
+
+JSON.ARRTRIM returns an array of integer replies for each path, the array's new size, or `nil`, if the matching JSON value is not an array.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Trim an array to a specific set of values</b></summary>
+
+Create two headphone products with maximum sound levels.
+
+{{< highlight bash >}}
+redis> JSON.SET key $
+"[{\"name\":\"Healthy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[60,70,80]},{\"name\":\"Noisy headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\"],\"max_level\":[85,90,100,120]}]"
+OK
+{{< / highlight >}}
+
+Add new sound level values to the second product.
+
+{{< highlight bash >}}
+redis> JSON.ARRAPPEND key $.[1].max_level 140 160 180 200 220 240 260 280
+1) (integer) 12
+{{< / highlight >}}
+
+Get the updated array.
+
+{{< highlight bash >}}
+redis> JSON.GET key $.[1].max_level
+"[[85,90,100,120,140,160,180,200,220,240,260,280]]"
+{{< / highlight >}}
+
+Keep only the values between the fifth and the ninth element, inclusive of that last element.
+
+{{< highlight bash >}}
+redis> JSON.ARRTRIM key $.[1].max_level 4 8
+1) (integer) 5
+{{< / highlight >}}
+
+Get the updated array.
+
+{{< highlight bash >}}
+redis> JSON.GET key $.[1].max_level
+"[[140,160,180,200,220]]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the reference count of a value of a key.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: OBJECT REFCOUNT
+since: 2.2.3
+summary: Returns the reference count of a value of a key.
+syntax_fmt: OBJECT REFCOUNT key
+syntax_str: ''
+title: OBJECT REFCOUNT
+---
+This command returns the reference count of the stored at `<key>`.
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for memory diagnostics commands.
+group: server
+hidden: true
+linkTitle: MEMORY
+since: 4.0.0
+summary: A container for memory diagnostics commands.
+syntax_fmt: MEMORY
+syntax_str: ''
+title: MEMORY
+---
+This is a container command for memory introspection and management commands.
+
+To see the list of available commands you can call [`MEMORY HELP`]({{< relref "/commands/memory-help" >}}).
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the expiration time in seconds of a key.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 2.8.0
+  - Added the -2 reply.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: TTL
+since: 1.0.0
+summary: Returns the expiration time in seconds of a key.
+syntax_fmt: TTL key
+syntax_str: ''
+title: TTL
+---
+Returns the remaining time to live of a key that has a timeout.
+This introspection capability allows a Redis client to check how many seconds a
+given key will continue to be part of the dataset.
+
+In Redis 2.6 or older the command returns `-1` if the key does not exist or if the key exists but has no associated expire.
+
+Starting with Redis 2.8 the return value in case of error changed:
+
+* The command returns `-2` if the key does not exist.
+* The command returns `-1` if the key exists but has no associated expire.
+
+See also the [`PTTL`]({{< relref "/commands/pttl" >}}) command that returns the same information with milliseconds resolution (Only available in Redis 2.6 or greater).
+
+## Examples
+
+{{< clients-example cmds_generic ttl >}}
+> SET mykey "Hello"
+"OK"
+> EXPIRE mykey 10
+(integer) 1
+> TTL mykey
+(integer) 10
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXPIRE mykey 10
+TTL mykey
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: async
+    name: async
+    since: 4.0.0
+    token: ASYNC
+    type: pure-token
+  - display_text: sync
+    name: sync
+    since: 6.2.0
+    token: SYNC
+    type: pure-token
+  name: flush-type
+  optional: true
+  type: oneof
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N) where N is the number of keys in the selected database
+description: Remove all keys from the current database.
+group: server
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+history:
+- - 4.0.0
+  - Added the `ASYNC` flushing mode modifier.
+- - 6.2.0
+  - Added the `SYNC` flushing mode modifier.
+linkTitle: FLUSHDB
+since: 1.0.0
+summary: Remove all keys from the current database.
+syntax_fmt: FLUSHDB [ASYNC | SYNC]
+syntax_str: ''
+title: FLUSHDB
+---
+Delete all the keys of the currently selected DB.
+This command never fails.
+
+By default, `FLUSHDB` will synchronously flush all keys from the database.
+Starting with Redis 6.2, setting the **lazyfree-lazy-user-flush** configuration directive to "yes" changes the default flush mode to asynchronous.
+
+It is possible to use one of the following modifiers to dictate the flushing mode explicitly:
+
+* `ASYNC`: flushes the database asynchronously
+* `SYNC`: flushes the database synchronously
+
+## Notes
+
+* An asynchronous `FLUSHDB` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected.
+* This command does not delete functions.
+* When using Redis Cluster, this command is identical to `FLUSHALL` since a Redis Cluster supports only one database with an ID of zero.
+
+## Behavior change history
+
+*   `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: nosave
+    name: nosave
+    token: NOSAVE
+    type: pure-token
+  - display_text: save
+    name: save
+    token: SAVE
+    type: pure-token
+  name: save-selector
+  optional: true
+  type: oneof
+- display_text: now
+  name: now
+  optional: true
+  since: 7.0.0
+  token: NOW
+  type: pure-token
+- display_text: force
+  name: force
+  optional: true
+  since: 7.0.0
+  token: FORCE
+  type: pure-token
+- display_text: abort
+  name: abort
+  optional: true
+  since: 7.0.0
+  token: ABORT
+  type: pure-token
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+- no_multi
+- allow_busy
+complexity: O(N) when saving, where N is the total number of keys in all databases
+  when saving data, otherwise O(1)
+description: Synchronously saves the database(s) to disk and shuts down the Redis
+  server.
+group: server
+hidden: false
+history:
+- - 7.0.0
+  - Added the `NOW`, `FORCE` and `ABORT` modifiers.
+linkTitle: SHUTDOWN
+since: 1.0.0
+summary: Synchronously saves the database(s) to disk and shuts down the Redis server.
+syntax_fmt: SHUTDOWN [NOSAVE | SAVE] [NOW] [FORCE] [ABORT]
+syntax_str: '[NOW] [FORCE] [ABORT]'
+title: SHUTDOWN
+---
+The command behavior is the following:
+
+* If there are any replicas lagging behind in replication:
+  * Pause clients attempting to write by performing a [`CLIENT PAUSE`]({{< relref "/commands/client-pause" >}}) with the `WRITE` option.
+  * Wait up to the configured `shutdown-timeout` (default 10 seconds) for replicas to catch up the replication offset.
+* Stop all the clients.
+* Perform a blocking SAVE if at least one **save point** is configured.
+* Flush the Append Only File if AOF is enabled.
+* Quit the server.
+
+If persistence is enabled this commands makes sure that Redis is switched off
+without any data loss.
+
+Note: A Redis instance that is configured for not persisting on disk (no AOF
+configured, nor "save" directive) will not dump the RDB file on `SHUTDOWN`, as
+usually you don't want Redis instances used only for caching to block on when
+shutting down.
+
+Also note: If Redis receives one of the signals `SIGTERM` and `SIGINT`, the same shutdown sequence is performed.
+See also [Signal Handling]({{< relref "/operate/oss_and_stack/reference/signals" >}}).
+
+## Modifiers
+
+It is possible to specify optional modifiers to alter the behavior of the command.
+Specifically:
+
+* **SAVE** will force a DB saving operation even if no save points are configured.
+* **NOSAVE** will prevent a DB saving operation even if one or more save points are configured.
+* **NOW** skips waiting for lagging replicas, i.e. it bypasses the first step in the shutdown sequence.
+* **FORCE** ignores any errors that would normally prevent the server from exiting.
+  For details, see the following section.
+* **ABORT** cancels an ongoing shutdown and cannot be combined with other flags.
+
+## Conditions where a SHUTDOWN fails
+
+When a save point is configured or the **SAVE** modifier is specified, the shutdown may fail if the RDB file can't be saved.
+Then, the server continues to run in order to ensure no data loss.
+This may be bypassed using the **FORCE** modifier, causing the server to exit anyway.
+
+When the Append Only File is enabled the shutdown may fail because the
+system is in a state that does not allow to safely immediately persist
+on disk.
+
+Normally if there is an AOF child process performing an AOF rewrite, Redis
+will simply kill it and exit.
+However, there are situations where it is unsafe to do so and, unless the **FORCE** modifier is specified, the **SHUTDOWN** command will be refused with an error instead.
+This happens in the following situations:
+
+* The user just turned on AOF, and the server triggered the first AOF rewrite in order to create the initial AOF file. In this context, stopping will result in losing the dataset at all: once restarted, the server will potentially have AOF enabled without having any AOF file at all.
+* A replica with AOF enabled, reconnected with its master, performed a full resynchronization, and restarted the AOF file, triggering the initial AOF creation process. In this case not completing the AOF rewrite is dangerous because the latest dataset received from the master would be lost. The new master can actually be even a different instance (if the **REPLICAOF** or **SLAVEOF** command was used in order to reconfigure the replica), so it is important to finish the AOF rewrite and start with the correct data set representing the data set in memory when the server was terminated.
+
+There are situations when we want just to terminate a Redis instance ASAP, regardless of what its content is.
+In such a case, the command **SHUTDOWN NOW NOSAVE FORCE** can be used.
+In versions before 7.0, where the **NOW** and **FORCE** flags are not available, the right combination of commands is to send a **CONFIG appendonly no** followed by a **SHUTDOWN NOSAVE**.
+The first command will turn off the AOF if needed, and will terminate the AOF rewriting child if there is one active.
+The second command will not have any problem to execute since the AOF is no longer enabled.
+
+## Minimize the risk of data loss
+
+Since Redis 7.0, the server waits for lagging replicas up to a configurable `shutdown-timeout`, by default 10 seconds, before shutting down.
+This provides a best effort minimizing the risk of data loss in a situation where no save points are configured and AOF is disabled.
+Before version 7.0, shutting down a heavily loaded master node in a diskless setup was more likely to result in data loss.
+To minimize the risk of data loss in such setups, it's advised to trigger a manual [`FAILOVER`]({{< relref "/commands/failover" >}}) (or [`CLUSTER FAILOVER`]({{< relref "/commands/cluster-failover" >}})) to demote the master to a replica and promote one of the replicas to be the new master, before shutting down a master node.
+
+## Behavior change history
+
+*   `>= 7.0.0`: Introduced waiting for lagging replicas before exiting.---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: DEBUG
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information and statistics for a time series
+group: timeseries
+hidden: false
+linkTitle: TS.INFO
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Returns information and statistics for a time series
+syntax: "TS.INFO key \n  [DEBUG]\n"
+syntax_fmt: TS.INFO key [DEBUG]
+syntax_str: '[DEBUG]'
+title: TS.INFO
+---
+
+Return information and statistics for a time series.
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary> 
+is key name of the time series.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>[DEBUG]</code></summary>
+
+is an optional flag to get a more detailed information about the chunks.
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with information about the time series (name-value pairs):
+
+| Name<br>[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) | Description
+| ---------------------------- | -
+| `totalSamples`    | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Total number of samples in this time series
+| `memoryUsage`     | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Total number of bytes allocated for this time series, which is the sum of <br> - The memory used for storing the series' configuration parameters (retention period, duplication policy, etc.)<br>- The memory used for storing the series' compaction rules<br>- The memory used for storing the series' labels (key-value pairs)<br>- The memory used for storing the chunks (chunk header + compressed/uncompressed data)
+| `firstTimestamp`  | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> First timestamp present in this time series (Unix timestamp in milliseconds)
+| `lastTimestamp`   | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Last timestamp present in this time series  (Unix timestamp in milliseconds)
+| `retentionTime`   | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> The retention period, in milliseconds, for this time series
+| `chunkCount`      | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of chunks used for this time series
+| `chunkSize`       | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> The initial allocation size, in bytes, for the data part of each new chunk.<br>Actual chunks may consume more memory. Changing the chunk size (using [`TS.ALTER`]({{< relref "commands/ts.alter/" >}})) does not affect existing chunks.
+| `chunkType`       | [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})<br> The chunks type: `compressed` or `uncompressed`
+| `duplicatePolicy` | [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) or [Nil reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})<br> The [duplicate policy]({{< relref "develop/data-types/timeseries/configuration#duplicate_policy" >}}) of this time series
+| `labels`          | [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) or [Nil reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})<br> Metadata labels of this time series<br> Each element is a 2-elements [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})) representing (label, value)
+| `sourceKey`       | [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}) or [Nil reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})<br>Key name for source time series in case the current series is a target of a [compaction rule]({{< relref "commands/ts.createrule" >}})
+| `rules`           | [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}})<br> [Compaction rules]({{< relref "commands/ts.createrule" >}}) defined in this time series<br> Each rule is an [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with 4 elements:<br>- [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}): The compaction key<br>- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}): The bucket duration<br>- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}): The aggregator<br>- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}): The alignment (since RedisTimeSeries v1.8)
+
+When [`DEBUG`]({{< relref "/commands/debug" >}}) is specified, the response also contains:
+
+| Name<br>[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) | Description
+| ---------------------------- | -
+| `keySelfName`     | [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})<br> Name of the key
+| `Chunks`          | [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with information about the chunks<br>Each element is an [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of information about a single chunk in a name([Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}))-value pairs:<br>- `startTimestamp` - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - First timestamp present in the chunk<br>- `endTimestamp` - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - Last timestamp present in the chunk<br>- `samples` - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - Total number of samples in the chunk<br>- `size` - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the chunk's internal data size (without overheads) in bytes<br>- `bytesPerSample` - [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}) (double) - Ratio of `size` and `samples`
+
+## Examples
+
+<details open>
+<summary><b>Find information about a temperature/humidity time series by location and sensor type</b></summary>
+
+Create a set of sensors to measure temperature and humidity in your study and kitchen.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE telemetry:study:temperature LABELS room study type temperature
+OK
+127.0.0.1:6379> TS.CREATE telemetry:study:humidity LABELS room study type humidity
+OK
+127.0.0.1:6379> TS.CREATE telemetry:kitchen:temperature LABELS room kitchen type temperature
+OK
+127.0.0.1:6379> TS.CREATE telemetry:kitchen:humidity LABELS room kitchen type humidity
+OK
+{{< / highlight >}}
+
+Find information about the time series for temperature in the kitchen.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.INFO telemetry:kitchen:temperature
+ 1) totalSamples
+ 2) (integer) 0
+ 3) memoryUsage
+ 4) (integer) 4246
+ 5) firstTimestamp
+ 6) (integer) 0
+ 7) lastTimestamp
+ 8) (integer) 0
+ 9) retentionTime
+10) (integer) 0
+11) chunkCount
+12) (integer) 1
+13) chunkSize
+14) (integer) 4096
+15) chunkType
+16) compressed
+17) duplicatePolicy
+18) (nil)
+19) labels
+20) 1) 1) "room"
+       2) "kitchen"
+    2) 1) "type"
+       2) "temperature"
+21) sourceKey
+22) (nil)
+23) rules
+24) (empty array)
+{{< / highlight >}}
+
+Query the time series using DEBUG to get more information about the chunks.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.INFO telemetry:kitchen:temperature DEBUG
+ 1) totalSamples
+ 2) (integer) 0
+ 3) memoryUsage
+ 4) (integer) 4246
+ 5) firstTimestamp
+ 6) (integer) 0
+ 7) lastTimestamp
+ 8) (integer) 0
+ 9) retentionTime
+10) (integer) 0
+11) chunkCount
+12) (integer) 1
+13) chunkSize
+14) (integer) 4096
+15) chunkType
+16) compressed
+17) duplicatePolicy
+18) (nil)
+19) labels
+20) 1) 1) "room"
+       2) "kitchen"
+    2) 1) "type"
+       2) "temperature"
+21) sourceKey
+22) (nil)
+23) rules
+24) (empty array)
+25) keySelfName
+26) "telemetry:kitchen:temperature"
+27) Chunks
+28) 1)  1) startTimestamp
+        2) (integer) 0
+        3) endTimestamp
+        4) (integer) 0
+        5) samples
+        6) (integer) 0
+        7) size
+        8) (integer) 4096
+        9) bytesPerSample
+       10) "inf"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.QUERYINDEX`]({{< relref "commands/ts.queryindex/" >}}) | [`TS.GET`]({{< relref "commands/ts.get/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@write'
+- '@bitmap'
+- '@slow'
+arguments:
+- arguments:
+  - display_text: and
+    name: and
+    token: AND
+    type: pure-token
+  - display_text: or
+    name: or
+    token: OR
+    type: pure-token
+  - display_text: xor
+    name: xor
+    token: XOR
+    type: pure-token
+  - display_text: not
+    name: not
+    token: NOT
+    type: pure-token
+  name: operation
+  type: oneof
+- display_text: destkey
+  key_spec_index: 0
+  name: destkey
+  type: key
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N)
+description: Performs bitwise operations on multiple strings, and stores the result.
+group: bitmap
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 3
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: BITOP
+since: 2.6.0
+summary: Performs bitwise operations on multiple strings, and stores the result.
+syntax_fmt: BITOP <AND | OR | XOR | NOT> destkey key [key ...]
+syntax_str: destkey key [key ...]
+title: BITOP
+---
+Perform a bitwise operation between multiple keys (containing string values) and
+store the result in the destination key.
+
+The `BITOP` command supports four bitwise operations: **AND**, **OR**, **XOR**
+and **NOT**, thus the valid forms to call the command are:
+
+
+* `BITOP AND destkey srckey1 srckey2 srckey3 ... srckeyN`
+* `BITOP OR  destkey srckey1 srckey2 srckey3 ... srckeyN`
+* `BITOP XOR destkey srckey1 srckey2 srckey3 ... srckeyN`
+* `BITOP NOT destkey srckey`
+
+As you can see **NOT** is special as it only takes an input key, because it
+performs inversion of bits so it only makes sense as a unary operator.
+
+The result of the operation is always stored at `destkey`.
+
+## Handling of strings with different lengths
+
+When an operation is performed between strings having different lengths, all the
+strings shorter than the longest string in the set are treated as if they were
+zero-padded up to the length of the longest string.
+
+The same holds true for non-existent keys, that are considered as a stream of
+zero bytes up to the length of the longest string.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "foobar"
+SET key2 "abcdef"
+BITOP AND dest key1 key2
+GET dest
+{{% /redis-cli %}}
+
+
+## Pattern: real time metrics using bitmaps
+
+`BITOP` is a good complement to the pattern documented in the [`BITCOUNT`]({{< relref "/commands/bitcount" >}}) command
+documentation.
+Different bitmaps can be combined in order to obtain a target bitmap where
+the population counting operation is performed.
+
+See the article called "[Fast easy realtime metrics using Redis
+bitmaps][hbgc212fermurb]" for an interesting use cases.
+
+[hbgc212fermurb]: http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps
+
+## Performance considerations
+
+`BITOP` is a potentially slow command as it runs in O(N) time.
+Care should be taken when running it against long input strings.
+
+For real-time metrics and statistics involving large inputs a good approach is
+to use a replica (with replica-read-only option enabled) where the bit-wise
+operations are performed to avoid blocking the master instance.
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: 'on'
+    name: 'on'
+    token: 'ON'
+    type: pure-token
+  - display_text: 'off'
+    name: 'off'
+    token: 'OFF'
+    type: pure-token
+  name: enabled
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Controls whether commands sent by the client affect the LRU/LFU of accessed
+  keys.
+group: connection
+hidden: false
+linkTitle: CLIENT NO-TOUCH
+since: 7.2.0
+summary: Controls whether commands sent by the client affect the LRU/LFU of accessed
+  keys.
+syntax_fmt: CLIENT NO-TOUCH <ON | OFF>
+syntax_str: ''
+title: CLIENT NO-TOUCH
+---
+The `CLIENT NO-TOUCH` command controls whether commands sent by the client will alter the LRU/LFU of the keys they access.
+
+When turned on, the current client will not change LFU/LRU stats, unless it sends the [`TOUCH`]({{< relref "/commands/touch" >}}) command.
+
+When turned off, the client touches LFU/LRU stats just as a normal client.
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: value
+  type: string
+- arguments:
+  - name: start
+    type: integer
+  - name: stop
+    optional: true
+    type: integer
+  name: range
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  array, O(N) when path is evaluated to multiple values, where N is the size of the
+  key
+description: Returns the index of the first occurrence of a JSON scalar value in the
+  array at path
+group: json
+hidden: false
+linkTitle: JSON.ARRINDEX
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the index of the first occurrence of a JSON scalar value in the array
+  at path
+syntax_fmt: JSON.ARRINDEX key path value [start [stop]]
+syntax_str: path value [start [stop]]
+title: JSON.ARRINDEX
+---
+Search for the first occurrence of a JSON value in an array
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is value to find its index in one or more arrays. 
+
+{{% alert title="About using strings with JSON commands" color="warning" %}}
+To specify a string as an array value to index, wrap the quoted string with an additional set of single quotes. Example: `'"silver"'`. For more detailed use, see [Examples](#examples).
+{{% /alert %}}
+</details>
+
+## Optional arguments
+
+<details open><summary><code>start</code></summary> 
+
+is inclusive start value to specify in a slice of the array to search. Default is `0`. 
+</details>
+
+
+<details open><summary><code>stop</code></summary> 
+
+is exclusive stop value to specify in a slice of the array to search, including the last element. Default is `0`. Negative values are interpreted as starting from the end.
+</details>
+
+{{% alert title="About out-of-range indexes" color="warning" %}}
+
+Out-of-range indexes round to the array's start and end. An inverse index range (such as the range from 1 to 0) returns unfound or `-1`.
+{{% /alert %}}
+
+## Return value 
+
+`JSON.ARRINDEX` returns an [array]({{< relref "develop/reference/protocol-spec#resp-arrays" >}}) of integer replies for each path, the first position in the array of each JSON value that matches the path, `-1` if unfound in the array, or `nil`, if the matching JSON value is not an array.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Find the specific place of a color in a list of product colors</b></summary>
+
+Create a document for noise-cancelling headphones in black and silver colors.
+
+{{< highlight bash >}}
+redis> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"]}'
+OK
+{{< / highlight >}}
+
+Add color `blue` to the end of the `colors` array. `JSON.ARRAPEND` returns the array's new size.
+
+{{< highlight bash >}}
+redis> JSON.ARRAPPEND item:1 $.colors '"blue"'
+1) (integer) 3
+{{< / highlight >}}
+
+Return the new length of the `colors` array.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1
+"{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\",\"blue\"]}"
+{{< / highlight >}}
+
+Get the list of colors for the product.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1 '$.colors[*]'
+"[\"black\",\"silver\",\"blue\"]"
+{{< / highlight >}}
+
+Insert two more colors after the second color. You now have five colors.
+
+{{< highlight bash >}}
+redis> JSON.ARRINSERT item:1 $.colors 2 '"yellow"' '"gold"'
+1) (integer) 5
+{{< / highlight >}}
+
+Get the updated list of colors.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1 $.colors
+"[[\"black\",\"silver\",\"yellow\",\"gold\",\"blue\"]]"
+{{< / highlight >}}
+
+Find the place where color `silver` is located.
+
+{{< highlight bash >}}
+redis> JSON.ARRINDEX item:1 $..colors '"silver"'
+1) (integer) 1
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.ARRAPPEND`]({{< relref "commands/json.arrappend/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: query
+  type: string
+- name: dialect
+  optional: true
+  since: 2.4.3
+  token: DIALECT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the execution plan for a complex query
+group: search
+hidden: false
+linkTitle: FT.EXPLAINCLI
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Returns the execution plan for a complex query
+syntax: "FT.EXPLAINCLI index query \n  [DIALECT dialect]\n"
+syntax_fmt: "FT.EXPLAINCLI index query [DIALECT\_dialect]"
+syntax_str: "query [DIALECT\_dialect]"
+title: FT.EXPLAINCLI
+---
+
+Return the execution plan for a complex query but formatted for easier reading without using `redis-cli --raw`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>query</code></summary>
+
+is query string, as if sent to FT.SEARCH`.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>DIALECT {dialect_version}</code></summary>
+
+is dialect version under which to execute the query. If not specified, the query executes under the default dialect version set during module initial loading or via [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) command.
+
+{{% alert title="Note" color="warning" %}}
+ 
+In the returned response, a `+` on a term is an indication of stemming.
+
+{{% /alert %}}
+
+</details>
+
+## Return
+
+FT.EXPLAINCLI returns an array reply with a string representing the execution plan.
+
+## Examples
+
+<details open>
+<summary><b>Return the execution plan for a complex query</b></summary>
+
+{{< highlight bash >}}
+$ redis-cli
+
+127.0.0.1:6379> FT.EXPLAINCLI rd "(foo bar)|(hello world) @date:[100 200]|@date:[500 +inf]"
+ 1) INTERSECT {
+ 2)   UNION {
+ 3)     INTERSECT {
+ 4)       UNION {
+ 5)         foo
+ 6)         +foo(expanded)
+ 7)       }
+ 8)       UNION {
+ 9)         bar
+10)         +bar(expanded)
+11)       }
+12)     }
+13)     INTERSECT {
+14)       UNION {
+15)         hello
+16)         +hello(expanded)
+17)       }
+18)       UNION {
+19)         world
+20)         +world(expanded)
+21)       }
+22)     }
+23)   }
+24)   UNION {
+25)     NUMERIC {100.000000 <= @date <= 200.000000}
+26)     NUMERIC {500.000000 <= @date <= inf}
+27)   }
+28) }
+29)
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) | [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) | [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: function
+  name: function
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the function that is executed.
+description: Invokes a function.
+group: scripting
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+  notes: We cannot tell how the keys will be used so we assume the worst, RW and UPDATE
+  update: true
+linkTitle: FCALL
+since: 7.0.0
+summary: Invokes a function.
+syntax_fmt: FCALL function numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: FCALL
+---
+Invoke a function.
+
+Functions are loaded to the server with the [`FUNCTION LOAD`]({{< relref "/commands/function-load" >}}) command.
+The first argument is the name of a loaded function.
+
+The second argument is the number of input key name arguments, followed by all the keys accessed by the function.
+In Lua, these names of input keys are available to the function as a table that is the callback's first argument.
+
+**Important:**
+To ensure the correct execution of functions, both in standalone and clustered deployments, all names of keys that a function accesses must be explicitly provided as input key arguments.
+The function **should only** access keys whose names are given as input arguments.
+Functions **should never** access keys with programmatically-generated names or based on the contents of data structures stored in the database.
+
+Any additional input argument **should not** represent names of keys.
+These are regular arguments and are passed in a Lua table as the callback's second argument.
+
+For more information please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}) pages.
+
+## Examples
+
+The following example will create a library named `mylib` with a single function, `myfunc`, that returns the first argument it gets.
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib \n redis.register_function('myfunc', function(keys, args) return args[1] end)"
+"mylib"
+redis> FCALL myfunc 0 hello
+"hello"
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: username
+  name: username
+  type: string
+- display_text: command
+  name: command
+  type: string
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1).
+description: Simulates the execution of a command by a user, without executing the
+  command.
+group: server
+hidden: false
+linkTitle: ACL DRYRUN
+since: 7.0.0
+summary: Simulates the execution of a command by a user, without executing the command.
+syntax_fmt: ACL DRYRUN username command [arg [arg ...]]
+syntax_str: command [arg [arg ...]]
+title: ACL DRYRUN
+---
+Simulate the execution of a given command by a given user.
+This command can be used to test the permissions of a given user without having to enable the user or cause the side effects of running the command.
+
+## Examples
+
+```
+> ACL SETUSER VIRGINIA +SET ~*
+"OK"
+> ACL DRYRUN VIRGINIA SET foo bar
+"OK"
+> ACL DRYRUN VIRGINIA GET foo
+"User VIRGINIA has no permissions to run the 'get' command"
+```
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: retentionPeriod
+  optional: true
+  token: RETENTION
+  type: integer
+- name: size
+  optional: true
+  token: CHUNK_SIZE
+  type: integer
+- arguments:
+  - name: block
+    token: BLOCK
+    type: pure-token
+  - name: first
+    token: FIRST
+    type: pure-token
+  - name: last
+    token: LAST
+    type: pure-token
+  - name: min
+    token: MIN
+    type: pure-token
+  - name: max
+    token: MAX
+    type: pure-token
+  - name: sum
+    token: SUM
+    type: pure-token
+  name: policy
+  optional: true
+  token: DUPLICATE_POLICY
+  type: oneof
+- arguments:
+  - name: label
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: labels
+  optional: true
+  token: LABELS
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of labels requested to update
+description: Update the retention, chunk size, duplicate policy, and labels of an
+  existing time series
+group: timeseries
+hidden: false
+linkTitle: TS.ALTER
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Update the retention, chunk size, duplicate policy, and labels of an existing
+  time series
+syntax: "TS.ALTER key \n  [RETENTION retentionPeriod] \n  [CHUNK_SIZE size] \n  [DUPLICATE_POLICY\
+  \ policy] \n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff] \n  [LABELS [label value ...]]\n"
+syntax_fmt: "TS.ALTER key [RETENTION\_retentionPeriod] [CHUNK_SIZE\_size]\n  [DUPLICATE_POLICY\_\
+  <BLOCK | FIRST | LAST | MIN | MAX | SUM>]\n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff] \n  [LABELS\ [label value ...]]"
+syntax_str: "[RETENTION\_retentionPeriod] [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_<BLOCK\
+  \ | FIRST | LAST | MIN | MAX | SUM>] [IGNORE ignoreMaxTimediff ignoreMaxValDiff] [LABELS\ [label value ...]]"
+title: TS.ALTER
+---
+
+Update the retention, chunk size, duplicate policy, and labels of an existing time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<note><b>Note:</b> This command alters only the specified element. For example, if you specify only `RETENTION` and `LABELS`, the chunk size and the duplicate policy are not altered. </note>
+
+## Optional arguments
+
+<details open><summary><code>RETENTION retentionPeriod</code></summary>
+
+is maximum retention period, compared to the maximum existing timestamp, in milliseconds. See `RETENTION` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>CHUNK_SIZE size</code></summary> 
+
+is the initial allocation size, in bytes, for the data part of each new chunk. Actual chunks may consume more memory. See `CHUNK_SIZE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}). Changing this value does not affect existing chunks.
+</details>
+
+<details open><summary><code>DUPLICATE_POLICY policy</code></summary> 
+
+is policy for handling multiple samples with identical timestamps. See `DUPLICATE_POLICY` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>IGNORE ignoreMaxTimediff ignoreMaxValDiff</code></summary> 
+
+is the policy for handling duplicate samples. See `IGNORE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>LABELS [{label value}...]</code></summary> 
+
+is set of label-value pairs that represent metadata labels of the key and serve as a secondary index.
+
+If `LABELS` is specified, the given label list is applied. Labels that are not present in the given list are removed implicitly. Specifying `LABELS` with no label-value pairs removes all existing labels. See `LABELS` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, wrong key type, key does not exist, etc.)
+
+## Examples
+
+<details open><summary><b>Alter a temperature time series</b></summary>
+
+Create a temperature time series.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temperature:2:32 RETENTION 60000 DUPLICATE_POLICY MAX LABELS sensor_id 2 area_id 32
+OK
+{{< / highlight >}}
+
+Alter the labels in the time series.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ALTER temperature:2:32 LABELS sensor_id 2 area_id 32 sub_area_id 15
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.CREATE`]({{< relref "commands/ts.create/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: parameter
+    name: parameter
+    type: string
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) when N is the number of configuration parameters provided
+description: Sets configuration parameters in-flight.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+history:
+- - 7.0.0
+  - Added the ability to set multiple parameters in one call.
+linkTitle: CONFIG SET
+since: 2.0.0
+summary: Sets configuration parameters in-flight.
+syntax_fmt: CONFIG SET parameter value [parameter value ...]
+syntax_str: ''
+title: CONFIG SET
+---
+The `CONFIG SET` command is used in order to reconfigure the server at run time
+without the need to restart Redis.
+You can change both trivial parameters or switch from one to another persistence
+option using this command.
+
+The list of configuration parameters supported by `CONFIG SET` can be obtained
+issuing a `CONFIG GET *` command, that is the symmetrical command used to obtain
+information about the configuration of a running Redis instance.
+
+All the configuration parameters set using `CONFIG SET` are immediately loaded
+by Redis and will take effect starting with the next command executed.
+
+All the supported parameters have the same meaning of the equivalent
+configuration parameter used in the [redis.conf][hgcarr22rc] file.
+
+[hgcarr22rc]: http://github.com/redis/redis/raw/unstable/redis.conf
+
+Note that you should look at the redis.conf file relevant to the version you're
+working with as configuration options might change between versions. The link
+above is to the latest development version.
+
+It is possible to switch persistence from RDB snapshotting to append-only file
+(and the other way around) using the `CONFIG SET` command.
+See the [persistence page]({{< relref "/operate/oss_and_stack/management/persistence" >}}) for more information.
+
+In general what you should know is that setting the `appendonly` parameter to
+`yes` will start a background process to save the initial append-only file
+(obtained from the in memory data set), and will append all the subsequent
+commands on the append-only file, thus obtaining exactly the same effect of a
+Redis server that started with AOF turned on since the start.
+
+You can have both the AOF enabled with RDB snapshotting if you want, the two
+options are not mutually exclusive.
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the number of fields in a hash.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HLEN
+since: 2.0.0
+summary: Returns the number of fields in a hash.
+syntax_fmt: HLEN key
+syntax_str: ''
+title: HLEN
+---
+Returns the number of fields contained in the hash stored at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HSET myhash field2 "World"
+HLEN myhash
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: channel
+  multiple: true
+  name: channel
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels
+description: Returns a count of subscribers to channels.
+group: pubsub
+hidden: false
+linkTitle: PUBSUB NUMSUB
+since: 2.8.0
+summary: Returns a count of subscribers to channels.
+syntax_fmt: PUBSUB NUMSUB [channel [channel ...]]
+syntax_str: ''
+title: PUBSUB NUMSUB
+---
+Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.
+
+Note that it is valid to call this command without channels. In this case it will just return an empty list.
+
+Cluster note: in a Redis Cluster clients can subscribe to every node, and can also publish to every other node. The cluster will make sure that published messages are forwarded as needed. That said, [`PUBSUB`]({{< relref "/commands/pubsub" >}})'s replies in a cluster only report information from the node's Pub/Sub context, rather than the entire cluster.
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: newkey
+  key_spec_index: 1
+  name: newkey
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Renames a key only when the target key name doesn't exist.
+group: generic
+hidden: false
+history:
+- - 3.2.0
+  - The command no longer returns an error when source and destination names are the
+    same.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- OW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: RENAMENX
+since: 1.0.0
+summary: Renames a key only when the target key name doesn't exist.
+syntax_fmt: RENAMENX key newkey
+syntax_str: newkey
+title: RENAMENX
+---
+Renames `key` to `newkey` if `newkey` does not yet exist.
+It returns an error when `key` does not exist.
+
+In Cluster mode, both `key` and `newkey` must be in the same **hash slot**, meaning that in practice only keys that have the same hash tag can be reliably renamed in cluster.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+SET myotherkey "World"
+RENAMENX mykey myotherkey
+GET myotherkey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Returns the expiration time of a hash field as a Unix timestamp, in msec.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HPEXPIRETIME
+since: 7.4.0
+summary: Returns the expiration time of a hash field as a Unix timestamp, in msec.
+syntax_fmt: "HPEXPIRETIME key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HPEXPIRETIME
+---
+`HPEXPIRETIME` has the same semantics as [`HEXPIRETIME`]({{< relref "/commands/hexpiretime" >}}), but returns the absolute Unix expiration timestamp in milliseconds since Unix epoch instead of seconds.
+
+## Examples
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer) 2
+redis> HEXPIRE mykey 300 FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HPEXPIRETIME mykey FIELDS 2 field1 field2
+1) (integer) 1715705913659
+2) (integer) 1715705913659
+```
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: slot
+  multiple: true
+  name: slot
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(N) where N is the total number of hash slot arguments
+description: Assigns new hash slots to a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER ADDSLOTS
+since: 3.0.0
+summary: Assigns new hash slots to a node.
+syntax_fmt: CLUSTER ADDSLOTS slot [slot ...]
+syntax_str: ''
+title: CLUSTER ADDSLOTS
+---
+This command is useful in order to modify a node's view of the cluster
+configuration. Specifically it assigns a set of hash slots to the node
+receiving the command. If the command is successful, the node will map
+the specified hash slots to itself, and will start broadcasting the new
+configuration.
+
+However note that:
+
+1. The command only works if all the specified slots are, from the point of view of the node receiving the command, currently not assigned. A node will refuse to take ownership for slots that already belong to some other node (including itself).
+2. The command fails if the same slot is specified multiple times.
+3. As a side effect of the command execution, if a slot among the ones specified as argument is set as `importing`, this state gets cleared once the node assigns the (previously unbound) slot to itself.
+
+## Example
+
+For example the following command assigns slots 1 2 3 to the node receiving
+the command:
+
+    > CLUSTER ADDSLOTS 1 2 3
+    OK
+
+However trying to execute it again results into an error since the slots
+are already assigned:
+
+    > CLUSTER ADDSLOTS 1 2 3
+    ERR Slot 1 is already busy
+
+## Usage in Redis Cluster
+
+This command only works in cluster mode and is useful in the following
+Redis Cluster operations:
+
+1. To create a new `cluster ADDSLOTS` is used in order to initially setup master nodes splitting the available hash slots among them.
+2. In order to fix a broken cluster where certain slots are unassigned.
+
+## Information about slots propagation and warnings
+
+Note that once a node assigns a set of slots to itself, it will start
+propagating this information in heartbeat packet headers. However the
+other nodes will accept the information only if they have the slot as
+not already bound with another node, or if the configuration epoch of the
+node advertising the new hash slot, is greater than the node currently listed
+in the table.
+
+This means that this command should be used with care only by applications
+orchestrating Redis Cluster, like `redis-cli`, and the command if used
+out of the right context can leave the cluster in a wrong state or cause
+data loss.
+---
+acl_categories:
+- '@read'
+- '@fast'
+arguments:
+- display_text: version
+  name: version
+  optional: true
+  token: VERSION
+  type: integer
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+description: Displays computer art and the Redis version
+group: server
+hidden: false
+linkTitle: LOLWUT
+since: 5.0.0
+summary: Displays computer art and the Redis version
+syntax_fmt: "LOLWUT [VERSION\_version]"
+syntax_str: ''
+title: LOLWUT
+---
+The LOLWUT command displays the Redis version: however as a side effect of
+doing so, it also creates a piece of generative computer art that is different
+with each version of Redis. The command was introduced in Redis 5 and announced
+with this [blog post](http://antirez.com/news/123).
+
+By default the `LOLWUT` command will display the piece corresponding to the
+current Redis version, however it is possible to display a specific version
+using the following form:
+
+    LOLWUT VERSION 5 ... other optional arguments ...
+
+Of course the "5" above is an example. Each LOLWUT version takes a different
+set of arguments in order to change the output. The user is encouraged to
+play with it to discover how the output changes adding more numerical
+arguments.
+
+LOLWUT wants to be a reminder that there is more in programming than just
+putting some code together in order to create something useful. Every
+LOLWUT version should have the following properties:
+
+1. It should display some computer art. There are no limits as long as the output works well in a normal terminal display. However the output should not be limited to graphics (like LOLWUT 5 and 6 actually do), but can be generative poetry and other non graphical things.
+2. LOLWUT output should be completely useless. Displaying some useful Redis internal metrics does not count as a valid LOLWUT.
+3. LOLWUT output should be fast to generate so that the command can be called in production instances without issues. It should remain fast even when the user experiments with odd parameters.
+4. LOLWUT implementations should be safe and carefully checked for security, and resist to untrusted inputs if they take arguments.
+5. LOLWUT must always display the Redis version at the end.
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@sortedset'
+- '@list'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: pattern
+  key_spec_index: 1
+  name: by-pattern
+  optional: true
+  token: BY
+  type: pattern
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+- display_text: pattern
+  key_spec_index: 1
+  multiple: true
+  multiple_token: true
+  name: get-pattern
+  optional: true
+  token: GET
+  type: pattern
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- display_text: sorting
+  name: sorting
+  optional: true
+  token: ALPHA
+  type: pure-token
+- display_text: destination
+  key_spec_index: 2
+  name: destination
+  optional: true
+  token: STORE
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(N+M*log(M)) where N is the number of elements in the list or set to
+  sort, and M the number of returned elements. When the elements are not sorted, complexity
+  is O(N).
+description: Sorts the elements in a list, a set, or a sorted set, optionally storing
+  the result.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RO: true
+  access: true
+  begin_search:
+    spec: {}
+    type: unknown
+  find_keys:
+    spec: {}
+    type: unknown
+  notes: For the optional BY/GET keyword. It is marked 'unknown' because the key names
+    derive from the content of the key we sort
+- OW: true
+  begin_search:
+    spec: {}
+    type: unknown
+  find_keys:
+    spec: {}
+    type: unknown
+  notes: For the optional STORE keyword. It is marked 'unknown' because the keyword
+    can appear anywhere in the argument array
+  update: true
+linkTitle: SORT
+since: 1.0.0
+summary: Sorts the elements in a list, a set, or a sorted set, optionally storing
+  the result.
+syntax_fmt: "SORT key [BY\_pattern] [LIMIT\_offset count] [GET\_pattern [GET pattern\n\
+  \  ...]] [ASC | DESC] [ALPHA] [STORE\_destination]"
+syntax_str: "[BY\_pattern] [LIMIT\_offset count] [GET\_pattern [GET pattern ...]]\
+  \ [ASC | DESC] [ALPHA] [STORE\_destination]"
+title: SORT
+---
+Returns or stores the elements contained in the [list][tdtl], [set][tdts] or
+[sorted set][tdtss] at `key`.
+
+There is also the [`SORT_RO`]({{< relref "/commands/sort_ro" >}}) read-only variant of this command.
+
+By default, sorting is numeric and elements are compared by their value
+interpreted as double precision floating point number.
+This is `SORT` in its simplest form:
+
+[tdtl]: /develop/data-types#lists
+[tdts]: /develop/data-types#set
+[tdtss]: /develop/data-types#sorted-sets
+
+```
+SORT mylist
+```
+
+Assuming `mylist` is a list of numbers, this command will return the same list
+with the elements sorted from small to large.
+In order to sort the numbers from large to small, use the `DESC` modifier:
+
+```
+SORT mylist DESC
+```
+
+When `mylist` contains string values and you want to sort them
+lexicographically, use the `ALPHA` modifier:
+
+```
+SORT mylist ALPHA
+```
+
+Redis is UTF-8 aware, assuming you correctly set the `LC_COLLATE` environment
+variable.
+
+The number of returned elements can be limited using the `LIMIT` modifier.
+This modifier takes the `offset` argument, specifying the number of elements to
+skip and the `count` argument, specifying the number of elements to return from
+starting at `offset`.
+The following example will return 10 elements of the sorted version of `mylist`,
+starting at element 0 (`offset` is zero-based):
+
+```
+SORT mylist LIMIT 0 10
+```
+
+Almost all modifiers can be used together.
+The following example will return the first 5 elements, lexicographically sorted
+in descending order:
+
+```
+SORT mylist LIMIT 0 5 ALPHA DESC
+```
+
+## Sorting by external keys
+
+Sometimes you want to sort elements using external keys as weights to compare
+instead of comparing the actual elements in the list, set or sorted set.
+Let's say the list `mylist` contains the elements `1`, `2` and `3` representing
+unique IDs of objects stored in `object_1`, `object_2` and `object_3`.
+When these objects have associated weights stored in `weight_1`, `weight_2` and
+`weight_3`, `SORT` can be instructed to use these weights to sort `mylist` with
+the following statement:
+
+```
+SORT mylist BY weight_*
+```
+
+The `BY` option takes a pattern (equal to `weight_*` in this example) that is
+used to generate the keys that are used for sorting.
+These key names are obtained substituting the first occurrence of `*` with the
+actual value of the element in the list (`1`, `2` and `3` in this example).
+
+## Skip sorting the elements
+
+The `BY` option can also take a non-existent key, which causes `SORT` to skip
+the sorting operation.
+This is useful if you want to retrieve external keys (see the `GET` option
+below) without the overhead of sorting.
+
+```
+SORT mylist BY nosort
+```
+
+## Retrieving external keys
+
+Our previous example returns just the sorted IDs.
+In some cases, it is more useful to get the actual objects instead of their IDs
+(`object_1`, `object_2` and `object_3`).
+Retrieving external keys based on the elements in a list, set or sorted set can
+be done with the following command:
+
+```
+SORT mylist BY weight_* GET object_*
+```
+
+The `GET` option can be used multiple times in order to get more keys for every
+element of the original list, set or sorted set.
+
+It is also possible to `GET` the element itself using the special pattern `#`:
+
+```
+SORT mylist BY weight_* GET object_* GET #
+```
+
+## Restrictions for using external keys
+
+Before 7.4, when enabling `Redis cluster-mode` there is no way to guarantee the existence of the external keys on the node which the command is processed on. In this case, any use of [`GET`]({{< relref "/commands/get" >}}) or `BY` which reference external key pattern will cause the command to fail with an error.
+
+Starting from 7.4, pattern with hash tag can be mapped to a slot, and so in `Redis cluster-mode`, the use of `BY` or [`GET`]({{< relref "/commands/get" >}}) is allowed when pattern contains hash tag and implies a specific slot which the key is also in, which means any key matching this pattern must be in the same slot as the key, and therefore in the same node. For example, in cluster mode, `{mylist}weight_*` is acceptable as a pattern when sorting `mylist`, while pattern `{abc}weight_*` will be denied, causing the command to fail with an error.
+
+To use pattern with hash tag, see [Hash tags]({{< relref "operate/oss_and_stack/reference/cluster-spec#hash-tags" >}}) for more information.
+
+Starting from Redis 7.0, any use of [`GET`]({{< relref "/commands/get" >}}) or `BY` which reference external key pattern will only be allowed in case the current user running the command has full key read permissions.
+Full key read permissions can be set for the user by, for example, specifying `'%R~*'` or `'~*` with the relevant command access rules.
+You can check the [`ACL SETUSER`]({{< relref "/commands/acl-setuser" >}}) command manual for more information on setting ACL access rules.
+If full key read permissions aren't set, the command will fail with an error.
+
+## Storing the result of a SORT operation
+
+By default, `SORT` returns the sorted elements to the client.
+With the `STORE` option, the result will be stored as a list at the specified
+key instead of being returned to the client.
+
+```
+SORT mylist BY weight_* STORE resultkey
+```
+
+An interesting pattern using `SORT ... STORE` consists in associating an
+[`EXPIRE`]({{< relref "/commands/expire" >}}) timeout to the resulting key so that in applications where the result
+of a `SORT` operation can be cached for some time.
+Other clients will use the cached list instead of calling `SORT` for every
+request.
+When the key will timeout, an updated version of the cache can be created by
+calling `SORT ... STORE` again.
+
+Note that for correctly implementing this pattern it is important to avoid
+multiple clients rebuilding the cache at the same time.
+Some kind of locking is needed here (for instance using [`SETNX`]({{< relref "/commands/setnx" >}})).
+
+## Using hashes in `BY` and `GET`
+
+It is possible to use `BY` and `GET` options against hash fields with the
+following syntax:
+
+```
+SORT mylist BY weight_*->fieldname GET object_*->fieldname
+```
+
+The string `->` is used to separate the key name from the hash field name.
+The key is substituted as documented above, and the hash stored at the resulting
+key is accessed to retrieve the specified hash field.
+---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: member
+    name: member
+    token: FROMMEMBER
+    type: string
+  - arguments:
+    - display_text: longitude
+      name: longitude
+      type: double
+    - display_text: latitude
+      name: latitude
+      type: double
+    name: fromlonlat
+    token: FROMLONLAT
+    type: block
+  name: from
+  type: oneof
+- arguments:
+  - arguments:
+    - display_text: radius
+      name: radius
+      token: BYRADIUS
+      type: double
+    - arguments:
+      - display_text: m
+        name: m
+        token: M
+        type: pure-token
+      - display_text: km
+        name: km
+        token: KM
+        type: pure-token
+      - display_text: ft
+        name: ft
+        token: FT
+        type: pure-token
+      - display_text: mi
+        name: mi
+        token: MI
+        type: pure-token
+      name: unit
+      type: oneof
+    name: circle
+    type: block
+  - arguments:
+    - display_text: width
+      name: width
+      token: BYBOX
+      type: double
+    - display_text: height
+      name: height
+      type: double
+    - arguments:
+      - display_text: m
+        name: m
+        token: M
+        type: pure-token
+      - display_text: km
+        name: km
+        token: KM
+        type: pure-token
+      - display_text: ft
+        name: ft
+        token: FT
+        type: pure-token
+      - display_text: mi
+        name: mi
+        token: MI
+        type: pure-token
+      name: unit
+      type: oneof
+    name: box
+    type: block
+  name: by
+  type: oneof
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- display_text: withcoord
+  name: withcoord
+  optional: true
+  token: WITHCOORD
+  type: pure-token
+- display_text: withdist
+  name: withdist
+  optional: true
+  token: WITHDIST
+  type: pure-token
+- display_text: withhash
+  name: withhash
+  optional: true
+  token: WITHHASH
+  type: pure-token
+arity: -7
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding
+  box area around the shape provided as the filter and M is the number of items inside
+  the shape
+description: Queries a geospatial index for members inside an area of a box or a circle.
+group: geo
+hidden: false
+history:
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEOSEARCH
+since: 6.2.0
+summary: Queries a geospatial index for members inside an area of a box or a circle.
+syntax_fmt: "GEOSEARCH key <FROMMEMBER\_member | FROMLONLAT\_longitude latitude>\n\
+  \  <BYRADIUS\_radius <M | KM | FT | MI> | BYBOX\_width height <M | KM |\n  FT |\
+  \ MI>> [ASC | DESC] [COUNT\_count [ANY]] [WITHCOORD] [WITHDIST]\n  [WITHHASH]"
+syntax_str: "<FROMMEMBER\_member | FROMLONLAT\_longitude latitude> <BYRADIUS\_radius\
+  \ <M | KM | FT | MI> | BYBOX\_width height <M | KM | FT | MI>> [ASC | DESC] [COUNT\_\
+  count [ANY]] [WITHCOORD] [WITHDIST] [WITHHASH]"
+title: GEOSEARCH
+---
+Return the members of a sorted set populated with geospatial information using [`GEOADD`]({{< relref "/commands/geoadd" >}}), which are within the borders of the area specified by a given shape. This command extends the [`GEORADIUS`]({{< relref "/commands/georadius" >}}) command, so in addition to searching within circular areas, it supports searching within rectangular areas.
+
+This command should be used in place of the deprecated [`GEORADIUS`]({{< relref "/commands/georadius" >}}) and [`GEORADIUSBYMEMBER`]({{< relref "/commands/georadiusbymember" >}}) commands.
+
+The query's center point is provided by one of these mandatory options:
+
+* `FROMMEMBER`: Use the position of the given existing `<member>` in the sorted set.
+* `FROMLONLAT`: Use the given `<longitude>` and `<latitude>` position.
+
+The query's shape is provided by one of these mandatory options:
+
+* `BYRADIUS`: Similar to [`GEORADIUS`]({{< relref "/commands/georadius" >}}), search inside circular area according to given `<radius>`.
+* `BYBOX`: Search inside an axis-aligned rectangle, determined by `<height>` and `<width>`.
+
+The command optionally returns additional information using the following options:
+
+* `WITHDIST`: Also return the distance of the returned items from the specified center point. The distance is returned in the same unit as specified for the radius or height and width arguments.
+* `WITHCOORD`: Also return the longitude and latitude of the matching items.
+* `WITHHASH`: Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
+
+Matching items are returned unsorted by default. To sort them, use one of the following two options:
+
+* `ASC`: Sort returned items from the nearest to the farthest, relative to the center point.
+* `DESC`: Sort returned items from the farthest to the nearest, relative to the center point.
+
+All matching items are returned by default. To limit the results to the first N matching items, use the **COUNT `<count>`** option.
+When the `ANY` option is used, the command returns as soon as enough matches are found.  This means that the results returned may not be the ones closest to the specified point, but the effort invested by the server to generate them is significantly less.
+When `ANY` is not provided, the command will perform an effort that is proportional to the number of items matching the specified area and sort them,
+so to query very large areas with a very small `COUNT` option may be slow even if just a few results are returned.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEOADD Sicily 12.758489 38.788135 "edge1"   17.241510 38.788135 "edge2" 
+GEOSEARCH Sicily FROMLONLAT 15 37 BYRADIUS 200 km ASC
+GEOSEARCH Sicily FROMLONLAT 15 37 BYBOX 400 400 km ASC WITHCOORD WITHDIST
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: string
+- display_text: end
+  name: end
+  type: string
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) with N being the number of elements being returned. If N is constant
+  (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
+description: Returns the messages from a stream within a range of IDs.
+group: stream
+hidden: false
+history:
+- - 6.2.0
+  - Added exclusive ranges.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XRANGE
+since: 5.0.0
+summary: Returns the messages from a stream within a range of IDs.
+syntax_fmt: "XRANGE key start end [COUNT\_count]"
+syntax_str: "start end [COUNT\_count]"
+title: XRANGE
+---
+The command returns the stream entries matching a given range of IDs.
+The range is specified by a minimum and maximum ID. All the entries having
+an ID between the two specified or exactly one of the two IDs specified
+(closed interval) are returned.
+
+The `XRANGE` command has a number of applications:
+
+* Returning items in a specific time range. This is possible because
+  Stream IDs are [related to time]({{< relref "/develop/data-types/streams" >}}).
+* Iterating a stream incrementally, returning just
+  a few items at every iteration. However it is semantically much more
+  robust than the [`SCAN`]({{< relref "/commands/scan" >}}) family of functions.
+* Fetching a single entry from a stream, providing the ID of the entry
+  to fetch two times: as start and end of the query interval.
+
+The command also has a reciprocal command returning items in the
+reverse order, called [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}), which is otherwise identical.
+
+## `-` and `+` special IDs
+
+The `-` and `+` special IDs mean respectively the minimum ID possible
+and the maximum ID possible inside a stream, so the following command
+will just return every entry in the stream:
+
+```
+> XRANGE somestream - +
+1) 1) 1526985054069-0
+   2) 1) "duration"
+      2) "72"
+      3) "event-id"
+      4) "9"
+      5) "user-id"
+      6) "839248"
+2) 1) 1526985069902-0
+   2) 1) "duration"
+      2) "415"
+      3) "event-id"
+      4) "2"
+      5) "user-id"
+      6) "772213"
+... other entries here ...
+```
+
+The `-` and `+` special IDs mean, respectively, the minimal and maximal range IDs,
+however they are nicer to type.
+
+## Incomplete IDs
+
+Stream IDs are composed of two parts, a Unix millisecond time stamp and a
+sequence number for entries inserted in the same millisecond. It is possible
+to use `XRANGE` specifying just the first part of the ID, the millisecond time,
+like in the following example:
+
+```
+> XRANGE somestream 1526985054069 1526985055069
+```
+
+In this case, `XRANGE` will auto-complete the start interval with `-0`
+and end interval with `-18446744073709551615`, in order to return all the
+entries that were generated between a given millisecond and the end of
+the other specified millisecond. This also means that repeating the same
+millisecond two times, we get all the entries within such millisecond,
+because the sequence number range will be from zero to the maximum.
+
+Used in this way `XRANGE` works as a range query command to obtain entries
+in a specified time. This is very handy in order to access the history
+of past events in a stream.
+
+## Exclusive ranges
+
+The range is close (inclusive) by default, meaning that the reply can include
+entries with IDs matching the query's start and end intervals. It is possible
+to specify an open interval (exclusive) by prefixing the ID with the
+character `(`. This is useful for iterating the stream, as explained below.
+
+## Returning a maximum number of entries
+
+Using the **COUNT** option it is possible to reduce the number of entries
+reported. This is a very important feature even if it may look marginal,
+because it allows, for instance, to model operations such as *give me
+the entry greater or equal to the following*:
+
+```
+> XRANGE somestream 1526985054069-0 + COUNT 1
+1) 1) 1526985054069-0
+   2) 1) "duration"
+      2) "72"
+      3) "event-id"
+      4) "9"
+      5) "user-id"
+      6) "839248"
+```
+
+In the above case the entry `1526985054069-0` exists, otherwise the server
+would have sent us the next one. Using `COUNT` is also the base in order to
+use `XRANGE` as an iterator.
+
+## Iterating a stream
+
+In order to iterate a stream, we can proceed as follows. Let's assume that
+we want two elements per iteration. We start fetching the first two
+elements, which is trivial:
+
+```
+> XRANGE writers - + COUNT 2
+1) 1) 1526985676425-0
+   2) 1) "name"
+      2) "Virginia"
+      3) "surname"
+      4) "Woolf"
+2) 1) 1526985685298-0
+   2) 1) "name"
+      2) "Jane"
+      3) "surname"
+      4) "Austen"
+```
+
+Then instead of starting the iteration again from `-`, as the start
+of the range we use the entry ID of the *last* entry returned by the
+previous `XRANGE` call as an exclusive interval.
+
+The ID of the last entry is `1526985685298-0`, so we just prefix it
+with a '(', and continue our iteration:
+
+```
+> XRANGE writers (1526985685298-0 + COUNT 2
+1) 1) 1526985691746-0
+   2) 1) "name"
+      2) "Toni"
+      3) "surname"
+      4) "Morrison"
+2) 1) 1526985712947-0
+   2) 1) "name"
+      2) "Agatha"
+      3) "surname"
+      4) "Christie"
+```
+
+And so forth. Eventually this will allow to visit all the entries in the
+stream. Obviously, we can start the iteration from any ID, or even from
+a specific time, by providing a given incomplete start ID. Moreover, we
+can limit the iteration to a given ID or time, by providing an end
+ID or incomplete ID instead of `+`.
+
+The command [`XREAD`]({{< relref "/commands/xread" >}}) is also able to iterate the stream.
+The command [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}) can iterate the stream reverse, from higher IDs
+(or times) to lower IDs (or times).
+
+### Iterating with earlier versions of Redis
+
+While exclusive range intervals are only available from Redis 6.2, it is still
+possible to use a similar stream iteration pattern with earlier versions. You
+start fetching from the stream the same way as described above to obtain the
+first entries.
+
+For the subsequent calls, you'll need to programmatically advance the last
+entry's ID returned. Most Redis client should abstract this detail, but the
+implementation can also be in the application if needed. In the example above,
+this means incrementing the sequence of `1526985685298-0` by one, from 0 to 1.
+The second call would, therefore, be:
+
+```
+> XRANGE writers 1526985685298-1 + COUNT 2
+1) 1) 1526985691746-0
+   2) 1) "name"
+      2) "Toni"
+...
+```
+
+Also, note that once the sequence part of the last ID equals 
+18446744073709551615, you'll need to increment the timestamp and reset the
+sequence part to 0. For example, incrementing the ID
+`1526985685298-18446744073709551615` should result in `1526985685299-0`.
+
+A symmetrical pattern applies to iterating the stream with [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}). The
+only difference is that the client needs to decrement the ID for the subsequent
+calls. When decrementing an ID with a sequence part of 0, the timestamp needs
+to be decremented by 1 and the sequence set to 18446744073709551615.
+
+## Fetching single items
+
+If you look for an `XGET` command you'll be disappointed because `XRANGE`
+is effectively the way to go in order to fetch a single entry from a
+stream. All you have to do is to specify the ID two times in the arguments
+of XRANGE:
+
+```
+> XRANGE mystream 1526984818136-0 1526984818136-0
+1) 1) 1526984818136-0
+   2) 1) "duration"
+      2) "1532"
+      3) "event-id"
+      4) "5"
+      5) "user-id"
+      6) "7782813"
+```
+
+## Additional information about streams
+
+For further information about Redis streams please check our
+[introduction to Redis Streams document]({{< relref "/develop/data-types/streams" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+XADD writers * name Virginia surname Woolf
+XADD writers * name Jane surname Austen
+XADD writers * name Toni surname Morrison
+XADD writers * name Agatha surname Christie
+XADD writers * name Ngozi surname Adichie
+XLEN writers
+XRANGE writers - + COUNT 2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k + i), where k is the number of sub-filters and i is maxIterations
+description: Adds an item to a Cuckoo Filter if the item did not exist previously.
+group: cf
+hidden: false
+linkTitle: CF.ADDNX
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds an item to a Cuckoo Filter if the item did not exist previously.
+syntax_fmt: CF.ADDNX key item
+syntax_str: item
+title: CF.ADDNX
+---
+Adds an item to a cuckoo filter if the item does not exist.
+
+This command is similar to the combination of [`CF.EXISTS`]({{< relref "commands/cf.exists/" >}}) and [`CF.ADD`]({{< relref "commands/cf.add/" >}}). It does not add an item into the filter if its fingerprint already exists.
+
+<note><b>Notes:</b>
+
+- This command is slower than [`CF.ADD`]({{< relref "commands/cf.add/" >}}) because it first checks whether the item exists.
+- Since [`CF.EXISTS`]({{< relref "commands/cf.exists/" >}}) can result in false positive, `CF.ADDNX` may not add an item because it is supposedly already exist, which may be wrong.
+
+</note>
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to add items to.
+
+If `key` does not exist - a new cuckoo filter is created.
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to add.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where `0` means that the item's fingerprint already exist in the filter, and `1` means that the item has been successfully added to the filter.
+- [] on error (invalid arguments, wrong key type, etc.) and also when the filter is full.
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.ADDNX cf item
+(integer) 1
+redis> CF.ADDNX cf item
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: end
+  name: end
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the length of the returned string. The complexity is ultimately
+  determined by the returned length, but because creating a substring from an existing
+  string is very cheap, it can be considered O(1) for small strings.
+description: Returns a substring of the string stored at a key.
+group: string
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GETRANGE
+since: 2.4.0
+summary: Returns a substring of the string stored at a key.
+syntax_fmt: GETRANGE key start end
+syntax_str: start end
+title: GETRANGE
+---
+Returns the substring of the string value stored at `key`, determined by the
+offsets `start` and `end` (both are inclusive).
+Negative offsets can be used in order to provide an offset starting from the end
+of the string.
+So -1 means the last character, -2 the penultimate and so forth.
+
+The function handles out of range requests by limiting the resulting range to
+the actual length of the string.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "This is a string"
+GETRANGE mykey 0 3
+GETRANGE mykey -3 -1
+GETRANGE mykey 0 -1
+GETRANGE mykey 10 100
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- arguments:
+  - name: path
+    type: string
+  - name: index
+    optional: true
+    type: integer
+  name: path
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  array and the specified index is not the last element, O(1) when path is evaluated
+  to a single value and the specified index is the last element, or O(N) when path
+  is evaluated to multiple values, where N is the size of the key
+description: Removes and returns the element at the specified index in the array at
+  path
+group: json
+hidden: false
+linkTitle: JSON.ARRPOP
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Removes and returns the element at the specified index in the array at path
+syntax_fmt: JSON.ARRPOP key [path [index]]
+syntax_str: '[path [index]]'
+title: JSON.ARRPOP
+---
+Remove and return an element from the index in the array
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>index</code></summary> 
+
+is position in the array to start popping from. Default is `-1`, meaning the last element. Out-of-range indexes round to their respective array ends. Popping an empty array returns null.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+## Return
+
+`JSON.ARRPOP` returns an [array]({{< relref "develop/reference/protocol-spec#resp-arrays" >}}) of bulk string replies for each path, each reply is the popped JSON value, or `nil`, if the matching JSON value is not an array.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Pop a value from an index and insert a new value</b></summary>
+
+Create two headphone products with maximum sound levels.
+
+{{< highlight bash >}}
+redis> JSON.SET key $ '[{"name":"Healthy headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"],"max_level":[60,70,80]},{"name":"Noisy headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"],"max_level":[80,90,100,120]}]'
+OK
+{{< / highlight >}}
+
+Get all maximum values for the second product.
+
+{{< highlight bash >}}
+redis> JSON.GET key $.[1].max_level
+"[[80,90,100,120]]"
+{{< / highlight >}}
+
+Update the `max_level` field of the product: remove an unavailable value and add a newly available value.
+
+{{< highlight bash >}}
+redis> JSON.ARRPOP key $.[1].max_level 0
+1) "80"
+{{< / highlight >}}
+
+Get the updated array.
+
+{{< highlight bash >}}
+redis> JSON.GET key $.[1].max_level
+"[[90,100,120]]"
+{{< / highlight >}}
+
+Now insert a new lowest value.
+
+{{< highlight bash >}}
+redis> JSON.ARRINSERT key $.[1].max_level 0 85
+1) (integer) 4
+{{< / highlight >}}
+
+Get the updated array.
+
+{{< highlight bash >}}
+redis> JSON.GET key $.[1].max_level
+"[[85,90,100,120]]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.ARRAPPEND`]({{< relref "commands/json.arrappend/" >}}) | [`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@write'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: longitude
+  name: longitude
+  type: double
+- display_text: latitude
+  name: latitude
+  type: double
+- display_text: radius
+  name: radius
+  type: double
+- arguments:
+  - display_text: m
+    name: m
+    token: M
+    type: pure-token
+  - display_text: km
+    name: km
+    token: KM
+    type: pure-token
+  - display_text: ft
+    name: ft
+    token: FT
+    type: pure-token
+  - display_text: mi
+    name: mi
+    token: MI
+    type: pure-token
+  name: unit
+  type: oneof
+- display_text: withcoord
+  name: withcoord
+  optional: true
+  token: WITHCOORD
+  type: pure-token
+- display_text: withdist
+  name: withdist
+  optional: true
+  token: WITHDIST
+  type: pure-token
+- display_text: withhash
+  name: withhash
+  optional: true
+  token: WITHHASH
+  type: pure-token
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    since: 6.2.0
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: key
+    key_spec_index: 1
+    name: storekey
+    token: STORE
+    type: key
+  - display_text: key
+    key_spec_index: 2
+    name: storedistkey
+    token: STOREDIST
+    type: key
+  name: store
+  optional: true
+  type: oneof
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(N+log(M)) where N is the number of elements inside the bounding box
+  of the circular area delimited by center and radius and M is the number of items
+  inside the index.
+deprecated_since: 6.2.0
+description: Queries a geospatial index for members within a distance from a coordinate,
+  optionally stores the result.
+doc_flags:
+- deprecated
+group: geo
+hidden: false
+history:
+- - 6.2.0
+  - Added the `ANY` option for `COUNT`.
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- OW: true
+  begin_search:
+    spec:
+      keyword: STORE
+      startfrom: 6
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- OW: true
+  begin_search:
+    spec:
+      keyword: STOREDIST
+      startfrom: 6
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: GEORADIUS
+replaced_by: '[`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) and [`GEOSEARCHSTORE`]({{<
+  relref "/commands/geosearchstore" >}}) with the `BYRADIUS` argument'
+since: 3.2.0
+summary: Queries a geospatial index for members within a distance from a coordinate,
+  optionally stores the result.
+syntax_fmt: "GEORADIUS key longitude latitude radius <M | KM | FT | MI>\n  [WITHCOORD]\
+  \ [WITHDIST] [WITHHASH] [COUNT\_count [ANY]] [ASC | DESC]\n  [STORE\_key | STOREDIST\_\
+  key]"
+syntax_str: "longitude latitude radius <M | KM | FT | MI> [WITHCOORD] [WITHDIST] [WITHHASH]\
+  \ [COUNT\_count [ANY]] [ASC | DESC] [STORE\_key | STOREDIST\_key]"
+title: GEORADIUS
+---
+Return the members of a sorted set populated with geospatial information using [`GEOADD`]({{< relref "/commands/geoadd" >}}), which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
+
+This manual page also covers the [`GEORADIUS_RO`]({{< relref "/commands/georadius_ro" >}}) and [`GEORADIUSBYMEMBER_RO`]({{< relref "/commands/georadiusbymember_ro" >}}) variants (see the section below for more information).
+
+The common use case for this command is to retrieve geospatial items near a specified point not farther than a given amount of meters (or other units). This allows, for example, to suggest mobile users of an application nearby places.
+
+The radius is specified in one of the following units:
+
+* **m** for meters.
+* **km** for kilometers.
+* **mi** for miles.
+* **ft** for feet.
+
+The command optionally returns additional information using the following options:
+
+* `WITHDIST`: Also return the distance of the returned items from the specified center. The distance is returned in the same unit as the unit specified as the radius argument of the command.
+* `WITHCOORD`: Also return the longitude,latitude coordinates of the matching items.
+* `WITHHASH`: Also return the raw geohash-encoded sorted set score of the item, in the form of a 52 bit unsigned integer. This is only useful for low level hacks or debugging and is otherwise of little interest for the general user.
+
+The command default is to return unsorted items. Two different sorting methods can be invoked using the following two options:
+
+* `ASC`: Sort returned items from the nearest to the farthest, relative to the center.
+* `DESC`: Sort returned items from the farthest to the nearest, relative to the center.
+
+By default all the matching items are returned. It is possible to limit the results to the first N matching items by using the **COUNT `<count>`** option.
+When `ANY` is provided the command will return as soon as enough matches are found,
+so the results may not be the ones closest to the specified point, but on the other hand, the effort invested by the server is significantly lower.
+When `ANY` is not provided, the command will perform an effort that is proportional to the number of items matching the specified area and sort them,
+so to query very large areas with a very small `COUNT` option may be slow even if just a few results are returned.
+
+By default the command returns the items to the client. It is possible to store the results with one of these options:
+
+* `STORE`: Store the items in a sorted set populated with their geospatial information.
+* `STOREDIST`: Store the items in a sorted set populated with their distance from the center as a floating point number, in the same unit specified in the radius.
+
+## Read-only variants
+
+Since `GEORADIUS` and [`GEORADIUSBYMEMBER`]({{< relref "/commands/georadiusbymember" >}}) have a `STORE` and `STOREDIST` option they are technically flagged as writing commands in the Redis command table. For this reason read-only replicas will flag them, and Redis Cluster replicas will redirect them to the master instance even if the connection is in read-only mode (see the [`READONLY`]({{< relref "/commands/readonly" >}}) command of Redis Cluster).
+
+Breaking the compatibility with the past was considered but rejected, at least for Redis 4.0, so instead two read-only variants of the commands were added. They are exactly like the original commands but refuse the `STORE` and `STOREDIST` options. The two variants are called [`GEORADIUS_RO`]({{< relref "/commands/georadius_ro" >}}) and [`GEORADIUSBYMEMBER_RO`]({{< relref "/commands/georadiusbymember_ro" >}}), and can safely be used in replicas.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEORADIUS Sicily 15 37 200 km WITHDIST
+GEORADIUS Sicily 15 37 200 km WITHCOORD
+GEORADIUS Sicily 15 37 200 km WITHDIST WITHCOORD
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: cursor_id
+  type: integer
+- name: read size
+  optional: true
+  token: COUNT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Reads from a cursor
+group: search
+hidden: false
+linkTitle: FT.CURSOR READ
+module: Search
+since: 1.1.0
+stack_path: docs/interact/search-and-query
+summary: Reads from a cursor
+syntax: 'FT.CURSOR READ index cursor_id [COUNT read_size]
+
+  '
+syntax_fmt: "FT.CURSOR READ index cursor_id [COUNT\_read size]"
+syntax_str: "cursor_id [COUNT\_read size]"
+title: FT.CURSOR READ
+---
+
+Read next results from an existing cursor
+
+[Examples](#examples)
+
+See [Cursor API]({{< relref "develop/interact/search-and-query/advanced-concepts/aggregations#cursor-api" >}}) for more details.
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name.
+</details>
+
+<details open>
+<summary><code>cursor_id</code></summary>
+
+is id of the cursor.
+</details>
+
+<details open>
+<summary><code>[COUNT read_size]</code></summary>
+
+is number of results to read. This parameter overrides `COUNT` specified in [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}).
+</details>
+
+## Return
+
+FT.CURSOR READ returns an array reply where each row is an array reply and represents a single aggregate result.
+
+## Examples
+
+<details open>
+<summary><b>Read next results from a cursor</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CURSOR READ idx 342459320 COUNT 50
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CURSOR DEL`]({{< relref "commands/ft.cursor-del/" >}}) | [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@admin'
+- '@fast'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Returns the Unix timestamp of the last successful save to disk.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: LASTSAVE
+since: 1.0.0
+summary: Returns the Unix timestamp of the last successful save to disk.
+syntax_fmt: LASTSAVE
+syntax_str: ''
+title: LASTSAVE
+---
+Return the UNIX TIME of the last DB save executed with success.
+A client may check if a [`BGSAVE`]({{< relref "/commands/bgsave" >}}) command succeeded reading the `LASTSAVE` value,
+then issuing a [`BGSAVE`]({{< relref "/commands/bgsave" >}}) command and checking at regular intervals every N
+seconds if `LASTSAVE` changed. Redis considers the database saved successfully at startup.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Resets the server's statistics.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: CONFIG RESETSTAT
+since: 2.0.0
+summary: Resets the server's statistics.
+syntax_fmt: CONFIG RESETSTAT
+syntax_str: ''
+title: CONFIG RESETSTAT
+---
+Resets the statistics reported by Redis using the [`INFO`]({{< relref "/commands/info" >}}) and [`LATENCY HISTOGRAM`]({{< relref "/commands/latency-histogram" >}}) commands.
+
+The following is a non-exhaustive list of values that are reset:
+
+* Keyspace hits and misses
+* Number of expired keys
+* Command and error statistics
+* Connections received, rejected and evicted
+* Persistence statistics
+* Active defragmentation statistics
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: library-name-pattern
+  name: library-name-pattern
+  optional: true
+  token: LIBRARYNAME
+  type: string
+- display_text: withcode
+  name: withcode
+  optional: true
+  token: WITHCODE
+  type: pure-token
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+complexity: O(N) where N is the number of functions
+description: Returns information about all libraries.
+group: scripting
+hidden: false
+hints:
+- nondeterministic_output_order
+linkTitle: FUNCTION LIST
+since: 7.0.0
+summary: Returns information about all libraries.
+syntax_fmt: "FUNCTION LIST [LIBRARYNAME\_library-name-pattern] [WITHCODE]"
+syntax_str: '[WITHCODE]'
+title: FUNCTION LIST
+---
+Return information about the functions and libraries.
+
+You can use the optional `LIBRARYNAME` argument to specify a pattern for matching library names.
+The optional `WITHCODE` modifier will cause the server to include the libraries source implementation in the reply.
+
+The following information is provided for each of the libraries in the response:
+
+* **library_name:** the name of the library.
+* **engine:** the engine of the library.
+* **functions:** the list of functions in the library.
+  Each function has the following fields:
+  * **name:** the name of the function.
+  * **description:** the function's description.
+  * **flags:** an array of [function flags]({{< relref "develop/interact/programmability/functions-intro#function-flags" >}}).
+* **library_code:** the library's source code (when given the `WITHCODE` modifier).
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: CONFIG HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: CONFIG HELP
+syntax_str: ''
+title: CONFIG HELP
+---
+The `CONFIG HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- name: fromTimestamp
+  type: string
+- name: toTimestamp
+  type: string
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+- multiple: true
+  name: Timestamp
+  optional: true
+  token: FILTER_BY_TS
+  type: integer
+- arguments:
+  - name: FILTER_BY_VALUE
+    token: FILTER_BY_VALUE
+    type: pure-token
+  - name: min
+    type: double
+  - name: max
+    type: double
+  name: fbv
+  optional: true
+  type: block
+- arguments:
+  - name: WITHLABELS
+    token: WITHLABELS
+    type: pure-token
+  - arguments:
+    - name: SELECTED_LABELS
+      token: SELECTED_LABELS
+      type: pure-token
+    - multiple: true
+      name: label1
+      type: string
+    name: SELECTED_LABELS_BLOCK
+    type: block
+  name: labels
+  optional: true
+  type: oneof
+- name: count
+  optional: true
+  token: COUNT
+  type: integer
+- arguments:
+  - name: value
+    optional: true
+    token: ALIGN
+    type: integer
+  - arguments:
+    - name: avg
+      token: AVG
+      type: pure-token
+    - name: first
+      token: FIRST
+      type: pure-token
+    - name: last
+      token: LAST
+      type: pure-token
+    - name: min
+      token: MIN
+      type: pure-token
+    - name: max
+      token: MAX
+      type: pure-token
+    - name: sum
+      token: SUM
+      type: pure-token
+    - name: range
+      token: RANGE
+      type: pure-token
+    - name: count
+      token: COUNT
+      type: pure-token
+    - name: std.p
+      token: STD.P
+      type: pure-token
+    - name: std.s
+      token: STD.S
+      type: pure-token
+    - name: var.p
+      token: VAR.P
+      type: pure-token
+    - name: var.s
+      token: VAR.S
+      type: pure-token
+    - name: twa
+      since: 1.8.0
+      token: TWA
+      type: pure-token
+    name: aggregator
+    token: AGGREGATION
+    type: oneof
+  - name: bucketDuration
+    type: integer
+  - name: buckettimestamp
+    optional: true
+    since: 1.8.0
+    token: BUCKETTIMESTAMP
+    type: pure-token
+  - name: empty
+    optional: true
+    since: 1.8.0
+    token: EMPTY
+    type: pure-token
+  name: aggregation
+  optional: true
+  type: block
+- arguments:
+  - name: l=v
+    type: string
+  - name: l!=v
+    type: string
+  - name: l=
+    type: string
+  - name: l!=
+    type: string
+  - name: l=(v1,v2,...)
+    type: string
+  - name: l!=(v1,v2,...)
+    type: string
+  multiple: true
+  name: filterExpr
+  token: FILTER
+  type: oneof
+- arguments:
+  - name: GROUPBY
+    token: GROUPBY
+    type: pure-token
+  - name: label
+    type: string
+  - name: REDUCE
+    type: string
+  - name: reducer
+    type: string
+  name: groupby
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n/m+k) where n = Number of data points, m = Chunk size (data points
+  per chunk), k = Number of data points that are in the requested ranges
+description: Query a range across multiple time-series by filters in reverse direction
+group: timeseries
+hidden: false
+linkTitle: TS.MREVRANGE
+module: TimeSeries
+since: 1.4.0
+stack_path: docs/data-types/timeseries
+summary: Query a range across multiple time-series by filters in reverse direction
+syntax: "TS.MREVRANGE fromTimestamp toTimestamp\n  [LATEST]\n  [FILTER_BY_TS ts...]\n\
+  \  [FILTER_BY_VALUE min max]\n  [WITHLABELS | <SELECTED_LABELS label...>]\n  [COUNT\
+  \ count]\n  [[ALIGN align] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP\
+  \ bt] [EMPTY]]\n  FILTER filterExpr...\n  [GROUPBY label REDUCE reducer]\n"
+syntax_fmt: "TS.MREVRANGE fromTimestamp toTimestamp [LATEST]\n  [FILTER_BY_TS\_Timestamp\
+  \ [Timestamp ...]] [FILTER_BY_VALUE min max]\n  [WITHLABELS | <SELECTED_LABELS label1\
+  \ [label1 ...]>] [COUNT\_count]\n  [[ALIGN\_value] AGGREGATION\_<AVG | FIRST | LAST\
+  \ | MIN | MAX | SUM |\n  RANGE | COUNT | STD.P | STD.S | VAR.P | VAR.S | TWA>\n\
+  \  bucketDuration [BUCKETTIMESTAMP] [EMPTY]] FILTER\_<l=v | l!=v | l=\n  | l!= |\
+  \ l=(v1,v2,...) | l!=(v1,v2,...) [l=v | l!=v | l= | l!= |\n  l=(v1,v2,...) | l!=(v1,v2,...)\
+  \ ...]> [GROUPBY label REDUCE\n  reducer]"
+syntax_str: "toTimestamp [LATEST] [FILTER_BY_TS\_Timestamp [Timestamp ...]] [FILTER_BY_VALUE\
+  \ min max] [WITHLABELS | <SELECTED_LABELS label1 [label1 ...]>] [COUNT\_count] [[ALIGN\_\
+  value] AGGREGATION\_<AVG | FIRST | LAST | MIN | MAX | SUM | RANGE | COUNT | STD.P\
+  \ | STD.S | VAR.P | VAR.S | TWA> bucketDuration [BUCKETTIMESTAMP] [EMPTY]] FILTER\_\
+  <l=v | l!=v | l= | l!= | l=(v1,v2,...) | l!=(v1,v2,...) [l=v | l!=v | l= | l!= |\
+  \ l=(v1,v2,...) | l!=(v1,v2,...) ...]> [GROUPBY label REDUCE reducer]"
+title: TS.MREVRANGE
+---
+
+Query a range across multiple time series by filters in the reverse direction.
+
+{{< note >}}
+This command will reply only if the current user has read access to all keys that match the filter.
+Otherwise, it will reply with "*(error): current user doesn't have read permission to one or more keys that match the specified filter*".
+{{< /note >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>fromTimestamp</code></summary> 
+
+is the start timestamp for the range query (integer Unix timestamp in milliseconds) or `-` to denote the timestamp of the earliest sample among all the time series that passes `FILTER filterExpr...`.
+</details>
+
+<details open>
+<summary><code>toTimestamp</code></summary> 
+
+is the end timestamp for the range query (integer Unix timestamp in milliseconds) or `+` to denote the timestamp of the latest sample among all the time series that passes `FILTER filterExpr...`.
+</details>
+
+<details open>
+<summary><code>FILTER filterExpr...</code></summary> 
+
+filters time series based on their labels and label values. Each filter expression has one of the following syntaxes:
+
+  - `label!=` - the time series has a label named `label`
+  - `label=value` - the time series has a label named `label` with a value equal to `value`
+  - `label=(value1,value2,...)` - the time series has a label named `label` with a value equal to one of the values in the list
+  - `label=` - the time series does not have a label named `label`
+  - `label!=value` - the time series does not have a label named `label` with a value equal to `value`
+  - `label!=(value1,value2,...)` - the time series does not have a label named `label` with a value equal to any of the values in the list
+
+  <note><b>Notes:</b>
+   - At least one filter expression with a syntax `label=value` or `label=(value1,value2,...)` is required.
+   - Filter expressions are conjunctive. For example, the filter `type=temperature room=study` means that a time series is a temperature time series of a study room.
+   - Whitespaces are unallowed in a filter expression except between quotes or double quotes in values - e.g., `x="y y"` or `x='(y y,z z)'`.
+   </note>
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary> 
+
+is used when a time series is a compaction. With `LATEST`, TS.MREVRANGE also reports the compacted value of the latest (possibly partial) bucket, given that this bucket's start time falls within `[fromTimestamp, toTimestamp]`. Without `LATEST`, TS.MREVRANGE does not report the latest (possibly partial) bucket. When a time series is not a compaction, `LATEST` is ignored.
+  
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon the arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest (possibly partial) bucket is also required. In such a case, use `LATEST`.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_TS ts...</code> (since RedisTimeSeries v1.6)</summary> 
+
+filters samples by a list of specific timestamps. A sample passes the filter if its exact timestamp is specified and falls within `[fromTimestamp, toTimestamp]`.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_VALUE min max</code> (since RedisTimeSeries v1.6)</summary> 
+
+filters samples by minimum and maximum values.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>WITHLABELS</code></summary> 
+
+includes in the reply all label-value pairs representing metadata labels of the time series. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+</details>
+
+<details open>
+<summary><code>SELECTED_LABELS label...</code> (since RedisTimeSeries v1.6)</summary>
+
+returns a subset of the label-value pairs that represent metadata labels of the time series. 
+Use when a large number of labels exists per series, but only the values of some of the labels are required. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+</details>
+
+<details open>
+<summary><code>COUNT count</code></summary> 
+
+When used without `AGGREGATION`: limits the number of reported samples per time series.
+
+When used together with `AGGREGATION`: limits the number of reported buckets.
+</details>
+
+<details open>
+<summary><code>ALIGN align</code> (since RedisTimeSeries v1.6)</summary> 
+
+is a time bucket alignment control for `AGGREGATION`. It controls the time bucket timestamps by changing the reference timestamp on which a bucket is defined. 
+
+Values include:
+   
+ - `start` or `-`: The reference timestamp will be the query start interval time (`fromTimestamp`) which can't be `-`
+ - `end` or `+`: The reference timestamp will be the query end interval time (`toTimestamp`) which can't be `+`
+ - A specific timestamp: align the reference timestamp to a specific time
+   
+<note><b>Note:</b> When not provided, alignment is set to `0`.</note>
+</details>
+
+<details open>
+<summary><code>AGGREGATION aggregator bucketDuration</code></summary> 
+
+per time series, aggregates samples into time buckets, where:
+
+  - `aggregator` takes one of the following aggregation types:
+
+    | `aggregator` | Description                                                                    |
+    | ------------ | ------------------------------------------------------------------------------ |
+    | `avg`        | Arithmetic mean of all values                                                  |
+    | `sum`        | Sum of all values                                                              |
+    | `min`        | Minimum value                                                                  |
+    | `max`        | Maximum value                                                                  |
+    | `range`      | Difference between maximum value and minimum value                             |
+    | `count`      | Number of values                                                               |
+    | `first`      | Value with lowest timestamp in the bucket                                      |
+    | `last`       | Value with highest timestamp in the bucket                                     |
+    | `std.p`      | Population standard deviation of the values                                    |
+    | `std.s`      | Sample standard deviation of the values                                        |
+    | `var.p`      | Population variance of the values                                              |
+    | `var.s`      | Sample variance of the values                                                  |
+    | `twa`        | Time-weighted average over the bucket's timeframe (since RedisTimeSeries v1.8) |
+
+  - `bucketDuration` is duration of each bucket, in milliseconds.
+  
+  Without `ALIGN`, bucket start times are multiples of `bucketDuration`.
+  
+  With `ALIGN align`, bucket start times are multiples of `bucketDuration` with remainder `align % bucketDuration`.
+  
+  The first bucket start time is less than or equal to `fromTimestamp`.  
+</details>
+
+<details open>
+<summary><code>[BUCKETTIMESTAMP bt]</code> (since RedisTimeSeries v1.8)</summary> 
+
+controls how bucket timestamps are reported.
+
+| `bt`             | Timestamp reported for each bucket                            |
+| ---------------- | ------------------------------------------------------------- |
+| `-` or `start`   | the bucket's start time (default)                             |
+| `+` or `end`     | the bucket's end time                                         |
+| `~` or `mid`     | the bucket's mid time (rounded down if not an integer)        |
+</details>
+
+<details open>
+<summary><code>[EMPTY]</code> (since RedisTimeSeries v1.8)</summary> 
+
+is a flag, which, when specified, reports aggregations also for empty buckets.
+
+| `aggregator`         | Value reported for each empty bucket |
+| -------------------- | ------------------------------------ |
+| `sum`, `count`       | `0`                                  |
+| `last`               | The value of the last sample before the bucket's start. `NaN` when no such sample. |
+| `twa`                | Average value over the bucket's timeframe based on linear interpolation of the last sample before the bucket's start and the first sample after the bucket's end. `NaN` when no such samples. |
+| `min`, `max`, `range`, `avg`, `first`, `std.p`, `std.s` | `NaN` |
+
+Regardless of the values of `fromTimestamp` and `toTimestamp`, no data is reported for buckets that end before the earliest sample or begin after the latest sample in the time series.
+</details>
+
+<details open>
+<summary><code>GROUPBY label REDUCE reducer</code> (since RedisTimeSeries v1.6)</summary>
+
+splits time series into groups, each group contains time series that share the same value for the provided label name, then aggregates results in each group.
+
+When combined with `AGGREGATION` the `GROUPBY`/`REDUCE` is applied post aggregation stage.
+
+  - `label` is label name. A group is created for all time series that share the same value for this label.
+
+  - `reducer` is an aggregation type used to aggregate the results in each group.
+
+    | `reducer` | Description                                                                                     |
+    | --------- | ----------------------------------------------------------------------------------------------- |
+    | `avg`     | Arithmetic mean of all non-NaN values (since RedisTimeSeries v1.8)                              |
+    | `sum`     | Sum of all non-NaN values                                                                       |
+    | `min`     | Minimum non-NaN value                                                                           |
+    | `max`     | Maximum non-NaN value                                                                           |
+    | `range`   | Difference between maximum non-NaN value and minimum non-NaN value (since RedisTimeSeries v1.8) |
+    | `count`   | Number of non-NaN values (since RedisTimeSeries v1.8)                                           |
+    | `std.p`   | Population standard deviation of all non-NaN values (since RedisTimeSeries v1.8)                |
+    | `std.s`   | Sample standard deviation of all non-NaN values (since RedisTimeSeries v1.8)                    |
+    | `var.p`   | Population variance of all non-NaN values (since RedisTimeSeries v1.8)                          |
+    | `var.s`   | Sample variance of all non-NaN values (since RedisTimeSeries v1.8)                              |
+
+<note><b>Notes:</b> 
+  - The produced time series is named `<label>=<value>`
+  - The produced time series contains two labels with these label array structures:
+    - `__reducer__`, the reducer used (e.g., `"count"`)
+    - `__source__`, the list of time series keys used to compute the grouped series (e.g., `"key1,key2,key3"`)
+</note>
+</details>
+
+<note><b>Note:</b> An `MREVRANGE` command cannot be part of a transaction when running on a Redis cluster.</note>
+
+## Return value
+
+If `GROUPBY label REDUCE reducer` is not specified:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): for each time series matching the specified filters, the following is reported:
+  - bulk-string-reply: The time series key name
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): label-value pairs ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}))
+    - By default, an empty list is reported
+    - If `WITHLABELS` is specified, all labels associated with this time series are reported
+    - If `SELECTED_LABELS label...` is specified, the selected labels are reported
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): timestamp-value pairs ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) (double)): all samples/aggregations matching the range
+
+If `GROUPBY label REDUCE reducer` is specified:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): for each group of time series matching the specified filters, the following is reported:
+  - bulk-string-reply with the format `label=value` where `label` is the `GROUPBY` label argument
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})): the `GROUPBY` label argument and value
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})):  the string `__reducer__` and the reducer argument
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})): the string `__source__` and the time series key names separated by `,`
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): timestamp-value pairs ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) (double)): all samples/aggregations matching the range
+
+## Examples
+
+<details open>
+<summary><b>Retrieve maximum stock price per timestamp</b></summary>
+
+Create two stocks and add their prices at three different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.CREATE stock:B LABELS type stock name B
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:B 1000 120 stock:B 1010 110 stock:B 1020 100
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+{{< / highlight >}}
+
+You can now retrieve the maximum stock price per timestamp.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MREVRANGE - + WITHLABELS FILTER type=stock GROUPBY type REDUCE max
+1) 1) "type=stock"
+   2) 1) 1) "type"
+         2) "stock"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "stock:A,stock:B"
+   3) 1) 1) (integer) 1020
+         2) 120
+      2) 1) (integer) 1010
+         2) 110
+      3) 1) (integer) 1000
+         2) 120
+{{< / highlight >}}
+
+The `FILTER type=stock` clause returns a single time series representing stock prices. The `GROUPBY type REDUCE max` clause splits the time series into groups with identical type values, and then, for each timestamp, aggregates all series that share the same type value using the max aggregator.
+</details>
+
+<details open>
+<summary><b>Calculate average stock price and retrieve maximum average</b></summary> 
+
+Create two stocks and add their prices at nine different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.CREATE stock:B LABELS type stock name B
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:B 1000 120 stock:B 1010 110 stock:B 1020 100
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:A 2000 200 stock:A 2010 210 stock:A 2020 220
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:B 2000 220 stock:B 2010 210 stock:B 2020 200
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:A 3000 300 stock:A 3010 310 stock:A 3020 320
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+127.0.0.1:6379> TS.MADD stock:B 3000 320 stock:B 3010 310 stock:B 3020 300
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+{{< / highlight >}}
+
+Now, for each stock, calculate the average stock price per a 1000-millisecond timeframe, and then retrieve the stock with the maximum average for that timeframe in reverse direction.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MREVRANGE - + WITHLABELS AGGREGATION avg 1000 FILTER type=stock GROUPBY type REDUCE max
+1) 1) "type=stock"
+   2) 1) 1) "type"
+         2) "stock"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "stock:A,stock:B"
+   3) 1) 1) (integer) 3000
+         2) 310
+      2) 1) (integer) 2000
+         2) 210
+      3) 1) (integer) 1000
+         2) 110
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Group query results</b></summary>
+
+Query all time series with the metric label equal to `cpu`, then group the time series by the value of their `metric_name` label value and for each group return the maximum value and the time series keys (_source_) with that value.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user
+(integer) 1548149180000
+127.0.0.1:6379> TS.MREVRANGE - + WITHLABELS FILTER metric=cpu GROUPBY metric_name REDUCE max
+1) 1) "metric_name=system"
+   2) 1) 1) "metric_name"
+         2) "system"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "ts1"
+   3) 1) 1) (integer) 1548149185000
+         2) 45
+      2) 1) (integer) 1548149180000
+         2) 90
+2) 1) "metric_name=user"
+   2) 1) 1) "metric_name"
+         2) "user"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "ts2"
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Filter query by value</b></summary>
+
+Query all time series with the metric label equal to `cpu`, then filter values larger or equal to 90.0 and smaller or equal to 100.0.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user
+(integer) 1548149180000
+127.0.0.1:6379> TS.MREVRANGE - + FILTER_BY_VALUE 90 100 WITHLABELS FILTER metric=cpu
+1) 1) "ts1"
+   2) 1) 1) "metric"
+         2) "cpu"
+      2) 1) "metric_name"
+         2) "system"
+   3) 1) 1) (integer) 1548149180000
+         2) 90
+2) 1) "ts2"
+   2) 1) 1) "metric"
+         2) "cpu"
+      2) 1) "metric_name"
+         2) "user"
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Query using a label</b></summary>
+
+Query all time series with the metric label equal to `cpu`, but only return the team label.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system team NY
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user team SF
+(integer) 1548149180000
+127.0.0.1:6379> TS.MREVRANGE - + SELECTED_LABELS team FILTER metric=cpu
+1) 1) "ts1"
+   2) 1) 1) "team"
+         2) (nil)
+   3) 1) 1) (integer) 1548149185000
+         2) 45
+      2) 1) (integer) 1548149180000
+         2) 90
+2) 1) "ts2"
+   2) 1) 1) "team"
+         2) (nil)
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.REVRANGE`]({{< relref "commands/ts.revrange/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  multiple: true
+  name: element
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each element added, so O(N) to add N elements when the command
+  is called with multiple arguments.
+description: Appends one or more elements to a list. Creates the key if it doesn't
+  exist.
+group: list
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple `element` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: RPUSH
+since: 1.0.0
+summary: Appends one or more elements to a list. Creates the key if it doesn't exist.
+syntax_fmt: RPUSH key element [element ...]
+syntax_str: element [element ...]
+title: RPUSH
+---
+Insert all the specified values at the tail of the list stored at `key`.
+If `key` does not exist, it is created as empty list before performing the push
+operation.
+When `key` holds a value that is not a list, an error is returned.
+
+It is possible to push multiple elements using a single command call just
+specifying multiple arguments at the end of the command.
+Elements are inserted one after the other to the tail of the list, from the
+leftmost element to the rightmost element.
+So for instance the command `RPUSH mylist a b c` will result into a list
+containing `a` as first element, `b` as second element and `c` as third element.
+
+## Examples
+
+{{< clients-example cmds_list rpush >}}
+redis> RPUSH mylist "hello"
+(integer) 1
+redis> RPUSH mylist "world"
+(integer) 2
+redis> LRANGE mylist 0 -1
+1) "hello"
+2) "world"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+RPUSH mylist "hello"
+RPUSH mylist "world"
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+- display_text: increment
+  name: increment
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Increments the integer value of a field in a hash by a number. Uses 0
+  as initial value if the field doesn't exist.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HINCRBY
+since: 2.0.0
+summary: Increments the integer value of a field in a hash by a number. Uses 0 as
+  initial value if the field doesn't exist.
+syntax_fmt: HINCRBY key field increment
+syntax_str: field increment
+title: HINCRBY
+---
+Increments the number stored at `field` in the hash stored at `key` by
+`increment`.
+If `key` does not exist, a new key holding a hash is created.
+If `field` does not exist the value is set to `0` before the operation is
+performed.
+
+The range of values supported by `HINCRBY` is limited to 64 bit signed integers.
+
+## Examples
+
+Since the `increment` argument is signed, both increment and decrement
+operations can be performed:
+
+{{% redis-cli %}}
+HSET myhash field 5
+HINCRBY myhash field 1
+HINCRBY myhash field -1
+HINCRBY myhash field -10
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- arguments:
+  - name: l=v
+    type: string
+  - name: l!=v
+    type: string
+  - name: l=
+    type: string
+  - name: l!=
+    type: string
+  - name: l=(v1,v2,...)
+    type: string
+  - name: l!=(v1,v2,...)
+    type: string
+  multiple: true
+  name: filterExpr
+  type: oneof
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of time-series that match the filters
+description: Get all time series keys matching a filter list
+group: timeseries
+hidden: false
+linkTitle: TS.QUERYINDEX
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Get all time series keys matching a filter list
+syntax: 'TS.QUERYINDEX filterExpr...
+
+  '
+syntax_fmt: "TS.QUERYINDEX <l=v | l!=v | l= | l!= | l=(v1,v2,...) |\n  l!=(v1,v2,...)\
+  \ [l=v | l!=v | l= | l!= | l=(v1,v2,...) |\n  l!=(v1,v2,...) ...]>"
+syntax_str: ''
+title: TS.QUERYINDEX
+---
+
+Get all time series keys matching a filter list. Note: all matching keys will be listed, whether or not the user has read access.
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>filterExpr...</code></summary>
+
+filters time series based on their labels and label values. Each filter expression has one of the following syntaxes:
+
+  - `label!=` - the time series has a label named `label`
+  - `label=value` - the time series has a label named `label` with a value equal to `value`
+  - `label=(value1,value2,...)` - the time series has a label named `label` with a value equal to one of the values in the list
+  - `label=` - the time series does not have a label named `label`
+  - `label!=value` - the time series does not have a label named `label` with a value equal to `value`
+  - `label!=(value1,value2,...)` - the time series does not have a label named `label` with a value equal to any of the values in the list
+
+  <note><b>Notes:</b>
+   - At least one filter expression with a syntax `label=value` or `label=(value1,value2,...)` is required.
+   - Filter expressions are conjunctive. For example, the filter `type=temperature room=study` means that a time series is a temperature time series of a study room.
+   - Whitespaces are unallowed in a filter expression except between quotes or double quotes in values - e.g., `x="y y"` or `x='(y y,z z)'`.
+   </note>
+</details>
+
+<note><b>Note:</b> The `QUERYINDEX` command cannot be part of a transaction when running on a Redis cluster.</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) where each element is a [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}): a time series key. The array is empty if no time series matches the filter.
+- [] (e.g., on invalid filter expression)
+
+## Examples
+
+<details open>
+<summary><b>Find keys by location and sensor type</b></summary>
+
+Create a set of sensors to measure temperature and humidity in your study and kitchen.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE telemetry:study:temperature LABELS room study type temperature
+OK
+127.0.0.1:6379> TS.CREATE telemetry:study:humidity LABELS room study type humidity
+OK
+127.0.0.1:6379> TS.CREATE telemetry:kitchen:temperature LABELS room kitchen type temperature
+OK
+127.0.0.1:6379> TS.CREATE telemetry:kitchen:humidity LABELS room kitchen type humidity
+OK
+{{< / highlight >}}
+
+Retrieve keys of all time series representing sensors located in the kitchen. 
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.QUERYINDEX room=kitchen
+1) "telemetry:kitchen:humidity"
+2) "telemetry:kitchen:temperature"
+{{< / highlight >}}
+
+To retrieve the keys of all time series representing sensors that measure temperature, use this query:
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.QUERYINDEX type=temperature
+1) "telemetry:kitchen:temperature"
+2) "telemetry:study:temperature"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.CREATE`]({{< relref "commands/ts.create/" >}}) | [`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) | [`TS.MGET`]({{< relref "commands/ts.mget/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@fast'
+- '@transaction'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- allow_busy
+complexity: O(N), when N is the number of queued commands
+description: Discards a transaction.
+group: transactions
+hidden: false
+linkTitle: DISCARD
+since: 2.0.0
+summary: Discards a transaction.
+syntax_fmt: DISCARD
+syntax_str: ''
+title: DISCARD
+---
+Flushes all previously queued commands in a [transaction][tt] and restores the
+connection state to normal.
+
+[tt]: /develop/interact/transactions
+
+If [`WATCH`]({{< relref "/commands/watch" >}}) was used, `DISCARD` unwatches all keys watched by the connection.
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: before
+    name: before
+    token: BEFORE
+    type: pure-token
+  - display_text: after
+    name: after
+    token: AFTER
+    type: pure-token
+  name: where
+  type: oneof
+- display_text: pivot
+  name: pivot
+  type: string
+- display_text: element
+  name: element
+  type: string
+arity: 5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the number of elements to traverse before seeing the value
+  pivot. This means that inserting somewhere on the left end on the list (head) can
+  be considered O(1) and inserting somewhere on the right end (tail) is O(N).
+description: Inserts an element before or after another element in a list.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: LINSERT
+since: 2.2.0
+summary: Inserts an element before or after another element in a list.
+syntax_fmt: LINSERT key <BEFORE | AFTER> pivot element
+syntax_str: <BEFORE | AFTER> pivot element
+title: LINSERT
+---
+Inserts `element` in the list stored at `key` either before or after the reference
+value `pivot`.
+
+When `key` does not exist, it is considered an empty list and no operation is
+performed.
+
+An error is returned when `key` exists but does not hold a list value.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "Hello"
+RPUSH mylist "World"
+LINSERT mylist BEFORE "World" "There"
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arguments:
+- display_text: category
+  name: category
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1) since the categories and commands are a fixed set.
+description: Lists the ACL categories, or the commands inside a category.
+group: server
+hidden: false
+linkTitle: ACL CAT
+since: 6.0.0
+summary: Lists the ACL categories, or the commands inside a category.
+syntax_fmt: ACL CAT [category]
+syntax_str: ''
+title: ACL CAT
+---
+The command shows the available ACL categories if called without arguments.
+If a category name is given, the command shows all the Redis commands in
+the specified category.
+
+ACL categories are very useful in order to create ACL rules that include or
+exclude a large set of commands at once, without specifying every single
+command. For instance, the following rule will let the user `karin` perform
+everything but the most dangerous operations that may affect the server
+stability:
+
+    ACL SETUSER karin on +@all -@dangerous
+
+We first add all the commands to the set of commands that `karin` is able
+to execute, but then we remove all the dangerous commands.
+
+Checking for all the available categories is as simple as:
+
+```
+> ACL CAT
+ 1) "keyspace"
+ 2) "read"
+ 3) "write"
+ 4) "set"
+ 5) "sortedset"
+ 6) "list"
+ 7) "hash"
+ 8) "string"
+ 9) "bitmap"
+10) "hyperloglog"
+11) "geo"
+12) "stream"
+13) "pubsub"
+14) "admin"
+15) "fast"
+16) "slow"
+17) "blocking"
+18) "dangerous"
+19) "connection"
+20) "transaction"
+21) "scripting"
+22) "json"
+23) "search"
+24) "tdigest"
+25) "cms"
+26) "bloom"
+27) "cuckoo"
+28) "topk"
+29) "timeseries"
+```
+
+Then we may want to know what commands are part of a given category:
+
+```
+> ACL CAT dangerous
+ 1) "flushdb"
+ 2) "acl"
+ 3) "slowlog"
+ 4) "debug"
+ 5) "role"
+ 6) "keys"
+ 7) "pfselftest"
+ 8) "client"
+ 9) "bgrewriteaof"
+10) "replicaof"
+11) "monitor"
+12) "restore-asking"
+13) "latency"
+14) "replconf"
+15) "pfdebug"
+16) "bgsave"
+17) "sync"
+18) "config"
+19) "flushall"
+20) "cluster"
+21) "info"
+22) "lastsave"
+23) "slaveof"
+24) "swapdb"
+25) "module"
+26) "restore"
+27) "migrate"
+28) "save"
+29) "shutdown"
+30) "psync"
+31) "sort"
+```
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of keys that will be touched.
+description: Returns the number of existing keys out of those specified after updating
+  the time they were last accessed.
+group: generic
+hidden: false
+hints:
+- request_policy:multi_shard
+- response_policy:agg_sum
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: TOUCH
+since: 3.2.1
+summary: Returns the number of existing keys out of those specified after updating
+  the time they were last accessed.
+syntax_fmt: TOUCH key [key ...]
+syntax_str: ''
+title: TOUCH
+---
+Alters the last access time of a key(s).
+A key is ignored if it does not exist.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "Hello"
+SET key2 "World"
+TOUCH key1 key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key1
+  key_spec_index: 0
+  name: key1
+  type: key
+- display_text: key2
+  key_spec_index: 0
+  name: key2
+  type: key
+- display_text: len
+  name: len
+  optional: true
+  token: LEN
+  type: pure-token
+- display_text: idx
+  name: idx
+  optional: true
+  token: IDX
+  type: pure-token
+- display_text: min-match-len
+  name: min-match-len
+  optional: true
+  token: MINMATCHLEN
+  type: integer
+- display_text: withmatchlen
+  name: withmatchlen
+  optional: true
+  token: WITHMATCHLEN
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N*M) where N and M are the lengths of s1 and s2, respectively
+description: Finds the longest common substring.
+group: string
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 1
+      limit: 0
+    type: range
+linkTitle: LCS
+since: 7.0.0
+summary: Finds the longest common substring.
+syntax_fmt: "LCS key1 key2 [LEN] [IDX] [MINMATCHLEN\_min-match-len] [WITHMATCHLEN]"
+syntax_str: "key2 [LEN] [IDX] [MINMATCHLEN\_min-match-len] [WITHMATCHLEN]"
+title: LCS
+---
+
+The LCS command implements the longest common subsequence algorithm. Note that this is different than the longest common string algorithm, since matching characters in the string does not need to be contiguous.
+
+For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings from left to right, the longest common set of characters is composed of the first "f" and then the "o".
+
+LCS is very useful in order to evaluate how similar two strings are. Strings can represent many things. For instance if two strings are DNA sequences, the LCS will provide a measure of similarity between the two DNA sequences. If the strings represent some text edited by some user, the LCS could represent how different the new text is compared to the old one, and so forth.
+
+Note that this algorithm runs in `O(N*M)` time, where N is the length of the first string and M is the length of the second string. So either spin a different Redis instance in order to run this algorithm, or make sure to run it against very small strings.
+
+```
+> MSET key1 ohmytext key2 mynewtext
+OK
+> LCS key1 key2
+"mytext"
+```
+
+Sometimes we need just the length of the match:
+
+```
+> LCS key1 key2 LEN
+(integer) 6
+```
+
+However what is often very useful, is to know the match position in each strings:
+
+```
+> LCS key1 key2 IDX
+1) "matches"
+2) 1) 1) 1) (integer) 4
+         2) (integer) 7
+      2) 1) (integer) 5
+         2) (integer) 8
+   2) 1) 1) (integer) 2
+         2) (integer) 3
+      2) 1) (integer) 0
+         2) (integer) 1
+3) "len"
+4) (integer) 6
+```
+
+Matches are produced from the last one to the first one, since this is how
+the algorithm works, and it more efficient to emit things in the same order.
+The above array means that the first match (second element of the array)
+is between positions 2-3 of the first string and 0-1 of the second.
+Then there is another match between 4-7 and 5-8.
+
+To restrict the list of matches to the ones of a given minimal length:
+
+```
+> LCS key1 key2 IDX MINMATCHLEN 4
+1) "matches"
+2) 1) 1) 1) (integer) 4
+         2) (integer) 7
+      2) 1) (integer) 5
+         2) (integer) 8
+3) "len"
+4) (integer) 6
+```
+
+Finally to also have the match len:
+
+```
+> LCS key1 key2 IDX MINMATCHLEN 4 WITHMATCHLEN
+1) "matches"
+2) 1) 1) 1) (integer) 4
+         2) (integer) 7
+      2) 1) (integer) 5
+         2) (integer) 8
+      3) (integer) 4
+3) "len"
+4) (integer) 6
+```
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for server configuration commands.
+group: server
+hidden: true
+linkTitle: CONFIG
+since: 2.0.0
+summary: A container for server configuration commands.
+syntax_fmt: CONFIG
+syntax_str: ''
+title: CONFIG
+---
+This is a container command for runtime configuration commands.
+
+To see the list of available commands you can call [`CONFIG HELP`]({{< relref "/commands/config-help" >}}).
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: cursor
+  name: cursor
+  type: integer
+- display_text: pattern
+  name: pattern
+  optional: true
+  token: MATCH
+  type: pattern
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: novalues
+  name: novalues
+  optional: true
+  token: NOVALUES
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for every call. O(N) for a complete iteration, including enough command
+  calls for the cursor to return back to 0. N is the number of elements inside the
+  collection.
+description: Iterates over fields and values of a hash.
+group: hash
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HSCAN
+since: 2.8.0
+summary: Iterates over fields and values of a hash.
+syntax_fmt: "HSCAN key cursor [MATCH\_pattern] [COUNT\_count] [NOVALUES]"
+syntax_str: "cursor [MATCH\_pattern] [COUNT\_count] [NOVALUES]"
+title: HSCAN
+---
+See [`SCAN`]({{< relref "/commands/scan" >}}) for `HSCAN` documentation.
+---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k * n), where k is the number of hash functions and n is the number
+  of items
+description: Adds one or more items to a Bloom Filter. A filter will be created if
+  it does not exist
+group: bf
+hidden: false
+linkTitle: BF.MADD
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds one or more items to a Bloom Filter. A filter will be created if it
+  does not exist
+syntax_fmt: BF.MADD key item [item ...]
+syntax_str: item [item ...]
+title: BF.MADD
+---
+Adds one or more items to a Bloom filter.
+
+This command is similar to [`BF.ADD`]({{< relref "commands/bf.add/" >}}), except that you can add more than one item.
+
+This command is similar to [`BF.INSERT`]({{< relref "commands/bf.insert/" >}}), except that the error rate, capacity, and expansion cannot be specified.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter to add the items to.
+
+If `key` does not exist - a new Bloom filter is created with default error rate, capacity, and expansion (see [`BF.RESERVE`]({{< relref "commands/bf.reserve/" >}})).
+</details>
+
+<details open><summary><code>item...</code></summary>
+
+One or more items to add.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) where each element is either
+  - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that the item has been added successfully, and "0" means that such item was already added to the filter (which could be wrong)
+  - [] when the item cannot be added because the filter is full
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.MADD bf item1 item2 item2
+1) (integer) 1
+2) (integer) 1
+3) (integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1) for each key removed regardless of its size. Then the command does
+  O(N) work in a different thread in order to reclaim memory, where N is the number
+  of allocations the deleted objects where composed of.
+description: Asynchronously deletes one or more keys.
+group: generic
+hidden: false
+hints:
+- request_policy:multi_shard
+- response_policy:agg_sum
+key_specs:
+- RM: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: UNLINK
+since: 4.0.0
+summary: Asynchronously deletes one or more keys.
+syntax_fmt: UNLINK key [key ...]
+syntax_str: ''
+title: UNLINK
+---
+This command is very similar to [`DEL`]({{< relref "/commands/del" >}}): it removes the specified keys.
+Just like [`DEL`]({{< relref "/commands/del" >}}) a key is ignored if it does not exist. However the command
+performs the actual memory reclaiming in a different thread, so it is not
+blocking, while [`DEL`]({{< relref "/commands/del" >}}) is. This is where the command name comes from: the
+command just **unlinks** the keys from the keyspace. The actual removal
+will happen later asynchronously.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "Hello"
+SET key2 "World"
+UNLINK key1 key2 key3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: offset
+  name: offset
+  type: integer
+- display_text: value
+  name: value
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1), not counting the time taken to copy the new string in place. Usually,
+  this string is very small so the amortized complexity is O(1). Otherwise, complexity
+  is O(M) with M being the length of the value argument.
+description: Overwrites a part of a string value with another by an offset. Creates
+  the key if it doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: SETRANGE
+since: 2.2.0
+summary: Overwrites a part of a string value with another by an offset. Creates the
+  key if it doesn't exist.
+syntax_fmt: SETRANGE key offset value
+syntax_str: offset value
+title: SETRANGE
+---
+Overwrites part of the string stored at _key_, starting at the specified offset,
+for the entire length of _value_.
+If the offset is larger than the current length of the string at _key_, the
+string is padded with zero-bytes to make _offset_ fit.
+Non-existing keys are considered as empty strings, so this command will make
+sure it holds a string large enough to be able to set _value_ at _offset_.
+
+Note that the maximum offset that you can set is 2^29 -1 (536870911), as Redis
+Strings are limited to 512 megabytes.
+If you need to grow beyond this size, you can use multiple keys.
+
+**Warning**: When setting the last possible byte and the string value stored at
+_key_ does not yet hold a string value, or holds a small string value, Redis
+needs to allocate all intermediate memory which can block the server for some
+time.
+On a 2010 MacBook Pro, setting byte number 536870911 (512MB allocation) takes
+~300ms, setting byte number 134217728 (128MB allocation) takes ~80ms, setting
+bit number 33554432 (32MB allocation) takes ~30ms and setting bit number 8388608
+(8MB allocation) takes ~8ms.
+Note that once this first allocation is done, subsequent calls to `SETRANGE` for
+the same _key_ will not have the allocation overhead.
+
+## Patterns
+
+Thanks to `SETRANGE` and the analogous [`GETRANGE`]({{< relref "/commands/getrange" >}}) commands, you can use Redis
+strings as a linear array with O(1) random access.
+This is a very fast and efficient storage in many real world use cases.
+
+## Examples
+
+Basic usage:
+
+{{% redis-cli %}}
+SET key1 "Hello World"
+SETRANGE key1 6 "Redis"
+GET key1
+{{% /redis-cli %}}
+
+
+Example of zero padding:
+
+{{% redis-cli %}}
+SETRANGE key2 6 "Redis"
+GET key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: ACL HELP
+since: 6.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: ACL HELP
+syntax_str: ''
+title: ACL HELP
+---
+The `ACL HELP` command returns a helpful text describing the different subcommands.
+
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: field
+    name: field
+    type: string
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of fields being set.
+deprecated_since: 4.0.0
+description: Sets the values of multiple fields.
+doc_flags:
+- deprecated
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HMSET
+replaced_by: '[`HSET`]({{< relref "/commands/hset" >}}) with multiple field-value
+  pairs'
+since: 2.0.0
+summary: Sets the values of multiple fields.
+syntax_fmt: HMSET key field value [field value ...]
+syntax_str: field value [field value ...]
+title: HMSET
+---
+Sets the specified fields to their respective values in the hash stored at
+`key`.
+This command overwrites any specified fields already existing in the hash.
+If `key` does not exist, a new key holding a hash is created.
+
+## Examples
+
+{{% redis-cli %}}
+HMSET myhash field1 "Hello" field2 "World"
+HGET myhash field1
+HGET myhash field2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: script
+  name: script
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- stale
+complexity: O(N) with N being the length in bytes of the script body.
+description: Loads a server-side Lua script to the script cache.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: SCRIPT LOAD
+since: 2.6.0
+summary: Loads a server-side Lua script to the script cache.
+syntax_fmt: SCRIPT LOAD script
+syntax_str: ''
+title: SCRIPT LOAD
+---
+Load a script into the scripts cache, without executing it.
+After the specified command is loaded into the script cache it will be callable
+using [`EVALSHA`]({{< relref "/commands/evalsha" >}}) with the correct SHA1 digest of the script, exactly like after
+the first successful invocation of [`EVAL`]({{< relref "/commands/eval" >}}).
+
+The script is guaranteed to stay in the script cache forever (unless `SCRIPT
+FLUSH` is called).
+
+The command works in the same way even if the script was already present in the
+script cache.
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: ttl
+  name: ttl
+  type: integer
+- display_text: serialized-value
+  name: serialized-value
+  type: string
+- display_text: replace
+  name: replace
+  optional: true
+  since: 3.0.0
+  token: REPLACE
+  type: pure-token
+- display_text: absttl
+  name: absttl
+  optional: true
+  since: 5.0.0
+  token: ABSTTL
+  type: pure-token
+- display_text: seconds
+  name: seconds
+  optional: true
+  since: 5.0.0
+  token: IDLETIME
+  type: integer
+- display_text: frequency
+  name: frequency
+  optional: true
+  since: 5.0.0
+  token: FREQ
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- asking
+complexity: O(1) to create the new key and additional O(N*M) to reconstruct the serialized
+  value, where N is the number of Redis objects composing the value and M their average
+  size. For small string values the time complexity is thus O(1)+O(1*M) where M is
+  small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N))
+  because inserting values into sorted sets is O(log(N)).
+description: An internal command for migrating keys in a cluster.
+doc_flags:
+- syscmd
+group: server
+hidden: false
+history:
+- - 3.0.0
+  - Added the `REPLACE` modifier.
+- - 5.0.0
+  - Added the `ABSTTL` modifier.
+- - 5.0.0
+  - Added the `IDLETIME` and `FREQ` options.
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: RESTORE-ASKING
+since: 3.0.0
+summary: An internal command for migrating keys in a cluster.
+syntax_fmt: "RESTORE-ASKING key ttl serialized-value [REPLACE] [ABSTTL]\n  [IDLETIME\_\
+  seconds] [FREQ\_frequency]"
+syntax_str: "ttl serialized-value [REPLACE] [ABSTTL] [IDLETIME\_seconds] [FREQ\_frequency]"
+title: RESTORE-ASKING
+---
+The `RESTORE-ASKING` command is an internal command.
+It is used by a Redis cluster master during slot migration.---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: milliseconds
+  name: milliseconds
+  optional: true
+  token: BLOCK
+  type: integer
+- arguments:
+  - display_text: key
+    key_spec_index: 0
+    multiple: true
+    name: key
+    type: key
+  - display_text: id
+    multiple: true
+    name: id
+    type: string
+  name: streams
+  token: STREAMS
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- blocking
+- movablekeys
+description: Returns messages from multiple streams with IDs greater than the ones
+  requested. Blocks until a message is available otherwise.
+group: stream
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      keyword: STREAMS
+      startfrom: 1
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 2
+    type: range
+linkTitle: XREAD
+since: 5.0.0
+summary: Returns messages from multiple streams with IDs greater than the ones requested.
+  Blocks until a message is available otherwise.
+syntax_fmt: "XREAD [COUNT\_count] [BLOCK\_milliseconds] STREAMS\_key [key ...] id\n\
+  \  [id ...]"
+syntax_str: "[BLOCK\_milliseconds] STREAMS\_key [key ...] id [id ...]"
+title: XREAD
+---
+Read data from one or multiple streams, only returning entries with an
+ID greater than the last received ID reported by the caller.
+This command has an option to block if items are not available, in a similar
+fashion to [`BRPOP`]({{< relref "/commands/brpop" >}}) or [`BZPOPMIN`]({{< relref "/commands/bzpopmin" >}}) and others.
+
+Please note that before reading this page, if you are new to streams,
+we recommend to read [our introduction to Redis Streams]({{< relref "/develop/data-types/streams" >}}).
+
+## Non-blocking usage
+
+If the **BLOCK** option is not used, the command is synchronous, and can
+be considered somewhat related to [`XRANGE`]({{< relref "/commands/xrange" >}}): it will return a range of items
+inside streams, however it has two fundamental differences compared to [`XRANGE`]({{< relref "/commands/xrange" >}})
+even if we just consider the synchronous usage:
+
+* This command can be called with multiple streams if we want to read at
+  the same time from a number of keys. This is a key feature of `XREAD` because
+  especially when blocking with **BLOCK**, to be able to listen with a single
+  connection to multiple keys is a vital feature.
+* While [`XRANGE`]({{< relref "/commands/xrange" >}}) returns items in a range of IDs, `XREAD` is more suited in
+  order to consume the stream starting from the first entry which is greater
+  than any other entry we saw so far. So what we pass to `XREAD` is, for each
+  stream, the ID of the last element that we received from that stream.
+
+For example, if I have two streams `mystream` and `writers`, and I want to
+read data from both the streams starting from the first element they contain,
+I could call `XREAD` like in the following example.
+
+Note: we use the **COUNT** option in the example, so that for each stream
+the call will return at maximum two elements per stream.
+
+```
+> XREAD COUNT 2 STREAMS mystream writers 0-0 0-0
+1) 1) "mystream"
+   2) 1) 1) 1526984818136-0
+         2) 1) "duration"
+            2) "1532"
+            3) "event-id"
+            4) "5"
+            5) "user-id"
+            6) "7782813"
+      2) 1) 1526999352406-0
+         2) 1) "duration"
+            2) "812"
+            3) "event-id"
+            4) "9"
+            5) "user-id"
+            6) "388234"
+2) 1) "writers"
+   2) 1) 1) 1526985676425-0
+         2) 1) "name"
+            2) "Virginia"
+            3) "surname"
+            4) "Woolf"
+      2) 1) 1526985685298-0
+         2) 1) "name"
+            2) "Jane"
+            3) "surname"
+            4) "Austen"
+```
+
+The **STREAMS** option is mandatory and MUST be the final option because
+such option gets a variable length of argument in the following format:
+
+    STREAMS key_1 key_2 key_3 ... key_N ID_1 ID_2 ID_3 ... ID_N
+
+So we start with a list of keys, and later continue with all the associated
+IDs, representing *the last ID we received for that stream*, so that the
+call will serve us only greater IDs from the same stream.
+
+For instance in the above example, the last items that we received
+for the stream `mystream` has ID `1526999352406-0`, while for the
+stream `writers` has the ID `1526985685298-0`.
+
+To continue iterating the two streams I'll call:
+
+```
+> XREAD COUNT 2 STREAMS mystream writers 1526999352406-0 1526985685298-0
+1) 1) "mystream"
+   2) 1) 1) 1526999626221-0
+         2) 1) "duration"
+            2) "911"
+            3) "event-id"
+            4) "7"
+            5) "user-id"
+            6) "9488232"
+2) 1) "writers"
+   2) 1) 1) 1526985691746-0
+         2) 1) "name"
+            2) "Toni"
+            3) "surname"
+            4) "Morrison"
+      2) 1) 1526985712947-0
+         2) 1) "name"
+            2) "Agatha"
+            3) "surname"
+            4) "Christie"
+```
+
+And so forth. Eventually, the call will not return any item, but just an
+empty array, then we know that there is nothing more to fetch from our
+stream (and we would have to retry the operation, hence this command
+also supports a blocking mode).
+
+## Incomplete IDs
+
+To use incomplete IDs is valid, like it is valid for [`XRANGE`]({{< relref "/commands/xrange" >}}). However
+here the sequence part of the ID, if missing, is always interpreted as
+zero, so the command:
+
+```
+> XREAD COUNT 2 STREAMS mystream writers 0 0
+```
+
+is exactly equivalent to
+
+```
+> XREAD COUNT 2 STREAMS mystream writers 0-0 0-0
+```
+
+## Blocking for data
+
+In its synchronous form, the command can get new data as long as there
+are more items available. However, at some point, we'll have to wait for
+producers of data to use [`XADD`]({{< relref "/commands/xadd" >}}) to push new entries inside the streams
+we are consuming. In order to avoid polling at a fixed or adaptive interval
+the command is able to block if it could not return any data, according
+to the specified streams and IDs, and automatically unblock once one of
+the requested keys accept data.
+
+It is important to understand that this command *fans out* to all the
+clients that are waiting for the same range of IDs, so every consumer will
+get a copy of the data, unlike to what happens when blocking list pop
+operations are used.
+
+In order to block, the **BLOCK** option is used, together with the number
+of milliseconds we want to block before timing out. Normally Redis blocking
+commands take timeouts in seconds, however this command takes a millisecond
+timeout, even if normally the server will have a timeout resolution near
+to 0.1 seconds. This time it is possible to block for a shorter time in
+certain use cases, and if the server internals will improve over time, it is
+possible that the resolution of timeouts will improve.
+
+When the **BLOCK** command is passed, but there is data to return at
+least in one of the streams passed, the command is executed synchronously
+*exactly like if the BLOCK option would be missing*.
+
+This is an example of blocking invocation, where the command later returns
+a null reply because the timeout has elapsed without new data arriving:
+
+```
+> XREAD BLOCK 1000 STREAMS mystream 1526999626221-0
+(nil)
+```
+
+## The special `$` ID.
+
+When blocking sometimes we want to receive just entries that are added
+to the stream via [`XADD`]({{< relref "/commands/xadd" >}}) starting from the moment we block. In such a case
+we are not interested in the history of already added entries. For
+this use case, we would have to check the stream top element ID, and use
+such ID in the `XREAD` command line. This is not clean and requires to
+call other commands, so instead it is possible to use the special `$`
+ID to signal the stream that we want only the new things.
+
+It is **very important** to understand that you should use the `$`
+ID only for the first call to `XREAD`. Later the ID should be the one
+of the last reported item in the stream, otherwise you could miss all
+the entries that are added in between.
+
+This is how a typical `XREAD` call looks like in the first iteration
+of a consumer willing to consume only new entries:
+
+```
+> XREAD BLOCK 5000 COUNT 100 STREAMS mystream $
+```
+
+Once we get some replies, the next call will be something like:
+
+```
+> XREAD BLOCK 5000 COUNT 100 STREAMS mystream 1526999644174-3
+```
+
+And so forth.
+
+## The special `+` ID
+
+You can read the last entry in a single stream easily using the `XREVRANGE` command, like so:
+
+```
+> XREVRANGE stream + - COUNT 1
+```
+But this approach becomes slow as you add more streams because you must issue a separate command for each stream.
+Instead, starting from Redis 7.4, you can use the `+` sign as a special ID.
+This requests the last available entry in a stream. For example:
+
+```
+> XREAD STREAMS streamA streamB streamC streamD + + + +
+```
+
+Note that when using this special ID for a stream, the **COUNT** option will
+be ignored (for the specific stream) since only the last entry can be returned.
+
+## How multiple clients blocked on a single stream are served
+
+Blocking list operations on lists or sorted sets have a *pop* behavior.
+Basically, the element is removed from the list or sorted set in order
+to be returned to the client. In this scenario you want the items
+to be consumed in a fair way, depending on the moment clients blocked
+on a given key arrived. Normally Redis uses the FIFO semantics in this
+use cases.
+
+However note that with streams this is not a problem: stream entries
+are not removed from the stream when clients are served, so every
+client waiting will be served as soon as an [`XADD`]({{< relref "/commands/xadd" >}}) command provides
+data to the stream.
+
+Reading the [Redis Streams introduction]({{< relref "/develop/data-types/streams" >}}) is highly
+suggested in order to understand more about the streams overall behavior
+and semantics.
+---
+acl_categories:
+- '@search'
+arguments:
+- name: key
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Gets the size of an auto-complete suggestion dictionary
+group: suggestion
+hidden: false
+linkTitle: FT.SUGLEN
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Gets the size of an auto-complete suggestion dictionary
+syntax: 'FT.SUGLEN key
+
+  '
+syntax_fmt: FT.SUGLEN key
+syntax_str: ''
+title: FT.SUGLEN
+---
+
+Get the size of an auto-complete suggestion dictionary
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is suggestion dictionary key.
+</details>
+
+## Return
+
+FT.SUGLEN returns an integer reply, which is the current size of the suggestion dictionary.
+
+## Examples
+
+<details open>
+<summary><b>Get the size of an auto-complete suggestion dictionary</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SUGLEN sug
+(integer) 2
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SUGADD`]({{< relref "commands/ft.sugadd/" >}}) | [`FT.SUGDEL`]({{< relref "commands/ft.sugdel/" >}}) | [`FT.SUGGET`]({{< relref "commands/ft.sugget/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@fast'
+- '@connection'
+arguments:
+- display_text: username
+  name: username
+  optional: true
+  since: 6.0.0
+  type: string
+- display_text: password
+  name: password
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- no_auth
+- allow_busy
+complexity: O(N) where N is the number of passwords defined for the user
+description: Authenticates the connection.
+group: connection
+hidden: false
+history:
+- - 6.0.0
+  - Added ACL style (username and password).
+linkTitle: AUTH
+since: 1.0.0
+summary: Authenticates the connection.
+syntax_fmt: AUTH [username] password
+syntax_str: password
+title: AUTH
+---
+The AUTH command authenticates the current connection in two cases:
+
+1. If the Redis server is password protected via the `requirepass` option.
+2. A Redis 6.0 instance, or greater, is using the [Redis ACL system]({{< relref "/operate/oss_and_stack/management/security/acl" >}}).
+
+Redis versions prior of Redis 6 were only able to understand the one argument
+version of the command:
+
+{{< clients-example cmds_cnxmgmt auth1 >}}
+AUTH "temp-pass"
+{{< /clients-example >}}
+
+This form just authenticates against the password set with `requirepass`.
+In this configuration Redis will deny any command executed by the just
+connected clients, unless the connection gets authenticated via `AUTH`.
+
+If the password provided via AUTH matches the password in the configuration file, the server replies with the `OK` status code and starts accepting commands.
+Otherwise, an error is returned and the clients needs to try a new password.
+
+When Redis ACLs are used, the command should be given in an extended way:
+
+{{< clients-example cmds_cnxmgmt auth2 >}}
+AUTH "test-user" "strong_password"
+{{< /clients-example >}}
+
+In order to authenticate the current connection with one of the connections
+defined in the ACL list (see [`ACL SETUSER`]({{< relref "/commands/acl-setuser" >}})) and the official [ACL guide]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) for more information.
+
+When ACLs are used, the single argument form of the command, where only the password is specified, assumes that the implicit username is "default".
+
+## Security notice
+
+Because of the high performance nature of Redis, it is possible to try
+a lot of passwords in parallel in very short time, so make sure to generate a
+strong and very long password so that this attack is infeasible.
+A good way to generate strong passwords is via the [`ACL GENPASS`]({{< relref "/commands/acl-genpass" >}}) command.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: config-epoch
+  name: config-epoch
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Sets the configuration epoch for a new node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER SET-CONFIG-EPOCH
+since: 3.0.0
+summary: Sets the configuration epoch for a new node.
+syntax_fmt: CLUSTER SET-CONFIG-EPOCH config-epoch
+syntax_str: ''
+title: CLUSTER SET-CONFIG-EPOCH
+---
+This command sets a specific *config epoch* in a fresh node. It only works when:
+
+1. The nodes table of the node is empty.
+2. The node current *config epoch* is zero.
+
+These prerequisites are needed since usually, manually altering the
+configuration epoch of a node is unsafe, we want to be sure that the node with
+the higher configuration epoch value (that is the last that failed over) wins
+over other nodes in claiming the hash slots ownership.
+
+However there is an exception to this rule, and it is when a new
+cluster is created from scratch. Redis Cluster *config epoch collision
+resolution* algorithm can deal with new nodes all configured with the
+same configuration at startup, but this process is slow and should be
+the exception, only to make sure that whatever happens, two more
+nodes eventually always move away from the state of having the same
+configuration epoch.
+
+So, using `CLUSTER SET-CONFIG-EPOCH`, when a new cluster is created, we can
+assign a different progressive configuration epoch to each node before
+joining the cluster together.
+---
+acl_categories:
+- '@admin'
+- '@search'
+arguments:
+- name: option
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+deprecated_since: 8.0.0
+description: Retrieves runtime configuration options
+doc_flags:
+- deprecated
+group: search
+hidden: false
+linkTitle: FT.CONFIG GET
+module: Search
+replaced_by: '[`CONFIG GET`]({{< relref "/commands/config-get" >}})'
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Retrieves runtime configuration options
+syntax: FT.CONFIG GET option
+syntax_fmt: FT.CONFIG GET option
+syntax_str: ''
+title: FT.CONFIG GET
+---
+
+Retrieve configuration options
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>option</code></summary> 
+
+is name of the configuration option, or '*' for all. 
+</details>
+
+## Return
+
+FT.CONFIG GET returns an array reply of the configuration name and value.
+
+## Examples
+
+<details open>
+<summary><b>Retrieve configuration options</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CONFIG GET TIMEOUT
+1) 1) TIMEOUT
+   2) 42
+{{< / highlight >}}
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CONFIG GET *
+ 1) 1) EXTLOAD
+    2) (nil)
+ 2) 1) SAFEMODE
+    2) true
+ 3) 1) CONCURRENT_WRITE_MODE
+    2) false
+ 4) 1) NOGC
+    2) false
+ 5) 1) MINPREFIX
+    2) 2
+ 6) 1) FORKGC_SLEEP_BEFORE_EXIT
+    2) 0
+ 7) 1) MAXDOCTABLESIZE
+    2) 1000000
+ 8) 1) MAXSEARCHRESULTS
+    2) 1000000
+ 9) 1) MAXAGGREGATERESULTS
+    2) unlimited
+10) 1) MAXEXPANSIONS
+    2) 200
+11) 1) MAXPREFIXEXPANSIONS
+    2) 200
+12) 1) TIMEOUT
+    2) 42
+13) 1) INDEX_THREADS
+    2) 8
+14) 1) SEARCH_THREADS
+    2) 20
+15) 1) FRISOINI
+    2) (nil)
+16) 1) ON_TIMEOUT
+    2) return
+17) 1) GCSCANSIZE
+    2) 100
+18) 1) MIN_PHONETIC_TERM_LEN
+    2) 3
+19) 1) GC_POLICY
+    2) fork
+20) 1) FORK_GC_RUN_INTERVAL
+    2) 30
+21) 1) FORK_GC_CLEAN_THRESHOLD
+    2) 100
+22) 1) FORK_GC_RETRY_INTERVAL
+    2) 5
+23) 1) FORK_GC_CLEAN_NUMERIC_EMPTY_NODES
+    2) true
+24) 1) _FORK_GC_CLEAN_NUMERIC_EMPTY_NODES
+    2) true
+25) 1) _MAX_RESULTS_TO_UNSORTED_MODE
+    2) 1000
+26) 1) UNION_ITERATOR_HEAP
+    2) 20
+27) 1) CURSOR_MAX_IDLE
+    2) 300000
+28) 1) NO_MEM_POOLS
+    2) false
+29) 1) PARTIAL_INDEXED_DOCS
+    2) false
+30) 1) UPGRADE_INDEX
+    2) Upgrade config for upgrading
+31) 1) _NUMERIC_COMPRESS
+    2) false
+32) 1) _FREE_RESOURCE_ON_THREAD
+    2) true
+33) 1) _PRINT_PROFILE_CLOCK
+    2) true
+34) 1) RAW_DOCID_ENCODING
+    2) false
+35) 1) _NUMERIC_RANGES_PARENTS
+    2) 0
+36) 1) MINSTEMLEN
+    2) 4
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) | [`FT.CONFIG HELP`]({{< relref "commands/ft.config-help/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@write'
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: library-name
+  name: library-name
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- noscript
+complexity: O(1)
+description: Deletes a library and its functions.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: FUNCTION DELETE
+since: 7.0.0
+summary: Deletes a library and its functions.
+syntax_fmt: FUNCTION DELETE library-name
+syntax_str: ''
+title: FUNCTION DELETE
+---
+Delete a library and all its functions.
+
+This command deletes the library called _library-name_ and all functions in it.
+If the library doesn't exist, the server returns an error.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+
+## Examples
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib \n redis.register_function('myfunc', function(keys, args) return 'hello' end)"
+"mylib"
+redis> FCALL myfunc 0
+"hello"
+redis> FUNCTION DELETE mylib
+OK
+redis> FCALL myfunc 0
+(error) ERR Function not found
+```
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: sha1
+  multiple: true
+  name: sha1
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+complexity: O(N) with N being the number of scripts to check (so checking a single
+  script is an O(1) operation).
+description: Determines whether server-side Lua scripts exist in the script cache.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:agg_logical_and
+linkTitle: SCRIPT EXISTS
+since: 2.6.0
+summary: Determines whether server-side Lua scripts exist in the script cache.
+syntax_fmt: SCRIPT EXISTS sha1 [sha1 ...]
+syntax_str: ''
+title: SCRIPT EXISTS
+---
+Returns information about the existence of the scripts in the script cache.
+
+This command accepts one or more SHA1 digests and returns a list of ones or
+zeros to signal if the scripts are already defined or not inside the script
+cache.
+This can be useful before a pipelining operation to ensure that scripts are
+loaded (and if not, to load them using [`SCRIPT LOAD`]({{< relref "/commands/script-load" >}})) so that the pipelining
+operation can be performed solely using [`EVALSHA`]({{< relref "/commands/evalsha" >}}) instead of [`EVAL`]({{< relref "/commands/eval" >}}) to save
+bandwidth.
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information and statistics about a t-digest sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.INFO
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns information and statistics about a t-digest sketch
+syntax_fmt: TDIGEST.INFO key
+syntax_str: ''
+title: TDIGEST.INFO
+---
+Returns information and statistics about a t-digest sketch.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for an existing t-digest sketch.
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with information about the sketch (name-value pairs):
+
+| Name<br>[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) | Description
+| ---------------------------- | -
+| `Compression`        | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> The compression (controllable trade-off between accuracy and memory consumption) of the sketch 
+| `Capacity`           | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Size of the buffer used for storing the centroids and for the incoming unmerged observations
+| `Merged nodes`       | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of merged observations
+| `Unmerged nodes`     | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of buffered nodes (uncompressed observations)
+| `Merged weight`      | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Weight of values of the merged nodes
+| `Unmerged weight`    | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Weight of values of the unmerged nodes (uncompressed observations)
+| `Observations`       | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of observations added to the sketch
+| `Total compressions` | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of times this sketch compressed data together
+| `Memory usage`       | [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})<br> Number of bytes allocated for the sketch
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t
+OK
+redis> TDIGEST.ADD t 1 2 3 4 5
+OK
+redis> TDIGEST.INFO t
+ 1) Compression
+ 2) (integer) 100
+ 3) Capacity
+ 4) (integer) 610
+ 5) Merged nodes
+ 6) (integer) 0
+ 7) Unmerged nodes
+ 8) (integer) 5
+ 9) Merged weight
+10) (integer) 0
+11) Unmerged weight
+12) (integer) 5
+13) Observations
+14) (integer) 5
+15) Total compressions
+16) (integer) 0
+17) Memory usage
+18) (integer) 9768
+{{< / highlight >}}
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  since: 6.2.0
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of elements returned
+description: Returns and removes the last elements of a list. Deletes the list if
+  the last element was popped.
+group: list
+hidden: false
+history:
+- - 6.2.0
+  - Added the `count` argument.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: RPOP
+since: 1.0.0
+summary: Returns and removes the last elements of a list. Deletes the list if the
+  last element was popped.
+syntax_fmt: RPOP key [count]
+syntax_str: '[count]'
+title: RPOP
+---
+Removes and returns the last elements of the list stored at `key`.
+
+By default, the command pops a single element from the end of the list.
+When provided with the optional `count` argument, the reply will consist of up
+to `count` elements, depending on the list's length.
+
+## Examples
+
+{{< clients-example cmds_list rpop >}}
+redis> RPUSH mylist "one" "two" "three" "four" "five"
+(integer) 5
+redis> RPOP mylist
+"five"
+redis> RPOP mylist 2
+1) "four"
+2) "three"
+redis> LRANGE mylist 0 -1
+1) "one"
+2) "two"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+RPUSH mylist "one" "two" "three" "four" "five"
+RPOP mylist
+RPOP mylist 2
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns the name of the connection.
+group: connection
+hidden: false
+linkTitle: CLIENT GETNAME
+since: 2.6.9
+summary: Returns the name of the connection.
+syntax_fmt: CLIENT GETNAME
+syntax_str: ''
+title: CLIENT GETNAME
+---
+The `CLIENT GETNAME` returns the name of the current connection as set by [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}}). Since every new connection starts without an associated name, if no name was assigned a null bulk reply is returned.
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@fast'
+arguments:
+- name: sourceKey
+  type: key
+- name: destKey
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Delete a compaction rule
+group: timeseries
+hidden: false
+linkTitle: TS.DELETERULE
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Delete a compaction rule
+syntax: 'TS.DELETERULE sourceKey destKey
+
+  '
+syntax_fmt: TS.DELETERULE sourceKey destKey
+syntax_str: destKey
+title: TS.DELETERULE
+---
+
+Delete a compaction rule
+
+## Required arguments
+
+<details open><summary><code>sourceKey</code></summary>
+
+is key name for the source time series.
+</details>
+
+<details open><summary><code>destKey</code></summary> 
+
+is key name for destination (compacted) time series.
+</details>
+
+<note><b>Note:</b> This command does not delete the compacted series.</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, etc.), or when such rule does not exist
+
+## See also
+
+[`TS.CREATERULE`]({{< relref "commands/ts.createrule/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: 'on'
+    name: 'on'
+    token: 'ON'
+    type: pure-token
+  - display_text: 'off'
+    name: 'off'
+    token: 'OFF'
+    type: pure-token
+  - display_text: skip
+    name: skip
+    token: SKIP
+    type: pure-token
+  name: action
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Instructs the server whether to reply to commands.
+group: connection
+hidden: false
+linkTitle: CLIENT REPLY
+since: 3.2.0
+summary: Instructs the server whether to reply to commands.
+syntax_fmt: CLIENT REPLY <ON | OFF | SKIP>
+syntax_str: ''
+title: CLIENT REPLY
+---
+Sometimes it can be useful for clients to completely disable replies from the Redis server. For example when the client sends fire and forget commands or performs a mass loading of data, or in caching contexts where new data is streamed constantly. In such contexts to use server time and bandwidth in order to send back replies to clients, which are going to be ignored, is considered wasteful.
+
+The `CLIENT REPLY` command controls whether the server will reply the client's commands. The following modes are available:
+
+* `ON`. This is the default mode in which the server returns a reply to every command.
+* `OFF`. In this mode the server will not reply to client commands.
+* `SKIP`. This mode skips the reply of command immediately after it.
+---
+acl_categories:
+- '@read'
+- '@bitmap'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: bit
+  name: bit
+  type: integer
+- arguments:
+  - display_text: start
+    name: start
+    type: integer
+  - arguments:
+    - display_text: end
+      name: end
+      type: integer
+    - arguments:
+      - display_text: byte
+        name: byte
+        token: BYTE
+        type: pure-token
+      - display_text: bit
+        name: bit
+        token: BIT
+        type: pure-token
+      name: unit
+      optional: true
+      since: 7.0.0
+      type: oneof
+    name: end-unit-block
+    optional: true
+    type: block
+  name: range
+  optional: true
+  type: block
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N)
+description: Finds the first set (1) or clear (0) bit in a string.
+group: bitmap
+hidden: false
+history:
+- - 7.0.0
+  - Added the `BYTE|BIT` option.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: BITPOS
+since: 2.8.7
+summary: Finds the first set (1) or clear (0) bit in a string.
+syntax_fmt: BITPOS key bit [start [end [BYTE | BIT]]]
+syntax_str: bit [start [end [BYTE | BIT]]]
+title: BITPOS
+---
+Return the position of the first bit set to 1 or 0 in a string.
+
+The position is returned, thinking of the string as an array of bits from left to
+right, where the first byte's most significant bit is at position 0, the second
+byte's most significant bit is at position 8, and so forth.
+
+The same bit position convention is followed by [`GETBIT`]({{< relref "/commands/getbit" >}}) and [`SETBIT`]({{< relref "/commands/setbit" >}}).
+
+By default, all the bytes contained in the string are examined.
+It is possible to look for bits only in a specified interval passing the additional arguments _start_ and _end_ (it is possible to just pass _start_, the operation will assume that the end is the last byte of the string. However there are semantic differences as explained later).
+By default, the range is interpreted as a range of bytes and not a range of bits, so `start=0` and `end=2` means to look at the first three bytes.
+
+You can use the optional `BIT` modifier to specify that the range should be interpreted as a range of bits.
+So `start=0` and `end=2` means to look at the first three bits.
+
+Note that bit positions are returned always as absolute values starting from bit zero even when _start_ and _end_ are used to specify a range.
+
+Like for the [`GETRANGE`]({{< relref "/commands/getrange" >}}) command start and end can contain negative values in
+order to index bytes starting from the end of the string, where -1 is the last
+byte, -2 is the penultimate, and so forth. When `BIT` is specified, -1 is the last
+bit, -2 is the penultimate, and so forth.
+
+Non-existent keys are treated as empty strings.
+
+## Examples
+
+```redis
+redis> SET mykey "\xff\xf0\x00"
+OK
+redis> BITPOS mykey 0
+(integer) 12
+redis> SET mykey "\x00\xff\xf0"
+OK
+redis> BITPOS mykey 1 0
+(integer) 8
+redis> BITPOS mykey 1 2
+(integer) 16
+redis> BITPOS mykey 1 2 -1 BYTE
+(integer) 16
+redis> BITPOS mykey 1 7 15 BIT
+(integer) 8
+redis> set mykey "\x00\x00\x00"
+OK
+redis> BITPOS mykey 1
+(integer) -1
+redis> BITPOS mykey 1 7 -3 BIT
+(integer) -1
+```---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: index
+  name: index
+  type: integer
+- display_text: element
+  name: element
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the length of the list. Setting either the first or the
+  last element of the list is O(1).
+description: Sets the value of an element in a list by its index.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: LSET
+since: 1.0.0
+summary: Sets the value of an element in a list by its index.
+syntax_fmt: LSET key index element
+syntax_str: index element
+title: LSET
+---
+Sets the list element at `index` to `element`.
+For more information on the `index` argument, see [`LINDEX`]({{< relref "/commands/lindex" >}}).
+
+An error is returned for out of range indexes.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "one"
+RPUSH mylist "two"
+RPUSH mylist "three"
+LSET mylist 0 "four"
+LSET mylist -2 "five"
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: increment
+  name: increment
+  type: double
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Increment the floating point value of a key by a number. Uses 0 as initial
+  value if the key doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: INCRBYFLOAT
+since: 2.6.0
+summary: Increment the floating point value of a key by a number. Uses 0 as initial
+  value if the key doesn't exist.
+syntax_fmt: INCRBYFLOAT key increment
+syntax_str: increment
+title: INCRBYFLOAT
+---
+Increment the string representing a floating point number stored at `key` by the
+specified `increment`. By using a negative `increment` value, the result is
+that the value stored at the key is decremented (by the obvious properties
+of addition).
+If the key does not exist, it is set to `0` before performing the operation.
+An error is returned if one of the following conditions occur:
+
+* The key contains a value of the wrong type (not a string).
+* The current key content or the specified increment are not parsable as a
+  double precision floating point number.
+
+If the command is successful the new incremented value is stored as the new
+value of the key (replacing the old one), and returned to the caller as a
+string.
+
+Both the value already contained in the string key and the increment argument
+can be optionally provided in exponential notation, however the value computed
+after the increment is stored consistently in the same format, that is, an
+integer number followed (if needed) by a dot, and a variable number of digits
+representing the decimal part of the number.
+Trailing zeroes are always removed.
+
+The precision of the output is fixed at 17 digits after the decimal point
+regardless of the actual internal precision of the computation.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey 10.50
+INCRBYFLOAT mykey 0.1
+INCRBYFLOAT mykey -5
+SET mykey 5.0e3
+INCRBYFLOAT mykey 2.0e2
+{{% /redis-cli %}}
+
+
+## Implementation details
+
+The command is always propagated in the replication link and the Append Only
+File as a [`SET`]({{< relref "/commands/set" >}}) operation, so that differences in the underlying floating point
+math implementation will not be sources of inconsistency.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(1)
+description: Returns the shard ID of a node.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER MYSHARDID
+since: 7.2.0
+summary: Returns the shard ID of a node.
+syntax_fmt: CLUSTER MYSHARDID
+syntax_str: ''
+title: CLUSTER MYSHARDID
+---
+Returns the node's shard id.
+
+The `CLUSTER MYSHARDID` command returns the unique, auto-generated identifier that is associated with the shard to which the connected cluster node belongs.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of keys to check.
+description: Determines whether one or more keys exist.
+group: generic
+hidden: false
+hints:
+- request_policy:multi_shard
+- response_policy:agg_sum
+history:
+- - 3.0.3
+  - Accepts multiple `key` arguments.
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: EXISTS
+since: 1.0.0
+summary: Determines whether one or more keys exist.
+syntax_fmt: EXISTS key [key ...]
+syntax_str: ''
+title: EXISTS
+---
+Returns if `key` exists.
+
+The user should be aware that if the same existing key is mentioned in the arguments multiple times, it will be counted multiple times. So if `somekey` exists, `EXISTS somekey somekey` will return 2.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "Hello"
+EXISTS key1
+EXISTS nosuchkey
+SET key2 "World"
+EXISTS key1 key2 nosuchkey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: pattern
+  multiple: true
+  name: pattern
+  optional: true
+  type: pattern
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of patterns to unsubscribe.
+description: Stops listening to messages published to channels that match one or more
+  patterns.
+group: pubsub
+hidden: false
+linkTitle: PUNSUBSCRIBE
+since: 2.0.0
+summary: Stops listening to messages published to channels that match one or more
+  patterns.
+syntax_fmt: PUNSUBSCRIBE [pattern [pattern ...]]
+syntax_str: ''
+title: PUNSUBSCRIBE
+---
+Unsubscribes the client from the given patterns, or from all of them if none is
+given.
+
+When no patterns are specified, the client is unsubscribed from all the
+previously subscribed patterns.
+In this case, a message for every unsubscribed pattern will be sent to the
+client.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: force
+    name: force
+    token: FORCE
+    type: pure-token
+  - display_text: takeover
+    name: takeover
+    token: TAKEOVER
+    type: pure-token
+  name: options
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Forces a replica to perform a manual failover of its master.
+group: cluster
+hidden: false
+linkTitle: CLUSTER FAILOVER
+since: 3.0.0
+summary: Forces a replica to perform a manual failover of its master.
+syntax_fmt: CLUSTER FAILOVER [FORCE | TAKEOVER]
+syntax_str: ''
+title: CLUSTER FAILOVER
+---
+This command, that can only be sent to a Redis Cluster replica node, forces
+the replica to start a manual failover of its master instance.
+
+A manual failover is a special kind of failover that is usually executed when
+there are no actual failures, but we wish to swap the current master with one
+of its replicas (which is the node we send the command to), in a safe way,
+without any window for data loss. It works in the following way:
+
+1. The replica tells the master to stop processing queries from clients.
+2. The master replies to the replica with the current *replication offset*.
+3. The replica waits for the replication offset to match on its side, to make sure it processed all the data from the master before it continues.
+4. The replica starts a failover, obtains a new configuration epoch from the majority of the masters, and broadcasts the new configuration.
+5. The old master receives the configuration update: unblocks its clients and starts replying with redirection messages so that they'll continue the chat with the new master.
+
+This way clients are moved away from the old master to the new master
+atomically and only when the replica that is turning into the new master
+has processed all of the replication stream from the old master.
+
+## FORCE option: manual failover when the master is down
+
+The command behavior can be modified by two options: **FORCE** and **TAKEOVER**.
+
+If the **FORCE** option is given, the replica does not perform any handshake
+with the master, that may be not reachable, but instead just starts a
+failover ASAP starting from point 4. This is useful when we want to start
+a manual failover while the master is no longer reachable.
+
+However using **FORCE** we still need the majority of masters to be available
+in order to authorize the failover and generate a new configuration epoch
+for the replica that is going to become master.
+
+## TAKEOVER option: manual failover without cluster consensus
+
+There are situations where this is not enough, and we want a replica to failover
+without any agreement with the rest of the cluster. A real world use case
+for this is to mass promote replicas in a different data center to masters
+in order to perform a data center switch, while all the masters are down
+or partitioned away.
+
+The **TAKEOVER** option implies everything **FORCE** implies, but also does
+not use any cluster authorization in order to failover. A replica receiving
+`CLUSTER FAILOVER TAKEOVER` will instead:
+
+1. Generate a new `configEpoch` unilaterally, just taking the current greatest epoch available and incrementing it if its local configuration epoch is not already the greatest.
+2. Assign itself all the hash slots of its master, and propagate the new configuration to every node which is reachable ASAP, and eventually to every other node.
+
+Note that **TAKEOVER violates the last-failover-wins principle** of Redis Cluster, since the configuration epoch generated by the replica violates the normal generation of configuration epochs in several ways:
+
+1. There is no guarantee that it is actually the higher configuration epoch, since, for example, we can use the **TAKEOVER** option within a minority, nor any message exchange is performed to generate the new configuration epoch.
+2. If we generate a configuration epoch which happens to collide with another instance, eventually our configuration epoch, or the one of another instance with our same epoch, will be moved away using the *configuration epoch collision resolution algorithm*.
+
+Because of this the **TAKEOVER** option should be used with care.
+
+## Implementation details and notes
+
+* `CLUSTER FAILOVER`, unless the **TAKEOVER** option is specified, does not execute a failover synchronously.
+  It only *schedules* a manual failover, bypassing the failure detection stage.
+* An `OK` reply is no guarantee that the failover will succeed.
+* A replica can only be promoted to a master if it is known as a replica by a majority of the masters in the cluster.
+  If the replica is a new node that has just been added to the cluster (for example after upgrading it), it may not yet be known to all the masters in the cluster.
+  To check that the masters are aware of a new replica, you can send [`CLUSTER NODES`]({{< relref "/commands/cluster-nodes" >}}) or [`CLUSTER REPLICAS`]({{< relref "/commands/cluster-replicas" >}}) to each of the master nodes and check that it appears as a replica, before sending `CLUSTER FAILOVER` to the replica.
+* To check that the failover has actually happened you can use [`ROLE`]({{< relref "/commands/role" >}}), `INFO REPLICATION` (which indicates "role:master" after successful failover), or [`CLUSTER NODES`]({{< relref "/commands/cluster-nodes" >}}) to verify that the state of the cluster has changed sometime after the command was sent.
+* To check if the failover has failed, check the replica's log for "Manual failover timed out", which is logged if the replica has given up after a few seconds.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: event
+  name: event
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns timestamp-latency samples for an event.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_nodes
+- response_policy:special
+linkTitle: LATENCY HISTORY
+since: 2.8.13
+summary: Returns timestamp-latency samples for an event.
+syntax_fmt: LATENCY HISTORY event
+syntax_str: ''
+title: LATENCY HISTORY
+---
+The `LATENCY HISTORY` command returns the raw data of the `event`'s latency spikes time series.
+
+This is useful to an application that wants to fetch raw data in order to perform monitoring, display graphs, and so forth.
+
+The command will return up to 160 timestamp-latency pairs for the `event`.
+
+Valid values for `event` are:
+* `active-defrag-cycle`
+* `aof-fsync-always`
+* `aof-stat`
+* `aof-rewrite-diff-write`
+* `aof-rename`
+* `aof-write`
+* `aof-write-active-child`
+* `aof-write-alone`
+* `aof-write-pending-fsync`
+* `command`
+* `expire-cycle`
+* `eviction-cycle`
+* `eviction-del`
+* `fast-command`
+* `fork`
+* `rdb-unlink-temp-file`
+
+## Examples
+
+```
+127.0.0.1:6379> latency history command
+1) 1) (integer) 1405067822
+   2) (integer) 251
+2) 1) (integer) 1405067941
+   2) (integer) 1001
+```
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: shardchannel
+  multiple: true
+  name: shardchannel
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of shard channels to subscribe to.
+description: Listens for messages published to shard channels.
+group: pubsub
+hidden: false
+key_specs:
+- begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+  not_key: true
+linkTitle: SSUBSCRIBE
+since: 7.0.0
+summary: Listens for messages published to shard channels.
+syntax_fmt: SSUBSCRIBE shardchannel [shardchannel ...]
+syntax_str: ''
+title: SSUBSCRIBE
+---
+Subscribes the client to the specified shard channels.
+
+In a Redis cluster, shard channels are assigned to slots by the same algorithm used to assign keys to slots. 
+Client(s) can subscribe to a node covering a slot (primary/replica) to receive the messages published. 
+All the specified shard channels needs to belong to a single slot to subscribe in a given `SSUBSCRIBE` call,
+A client can subscribe to channels across different slots over separate `SSUBSCRIBE` call.
+
+For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}).
+
+## Examples
+
+```
+> ssubscribe orders
+Reading messages... (press Ctrl-C to quit)
+1) "ssubscribe"
+2) "orders"
+3) (integer) 1
+1) "smessage"
+2) "orders"
+3) "hello"
+```
+---
+acl_categories:
+- '@search'
+arguments:
+- name: alias
+  type: string
+- name: index
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Adds an alias to the index
+group: search
+hidden: false
+linkTitle: FT.ALIASADD
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Adds an alias to the index
+syntax: 'FT.ALIASADD alias index
+
+  '
+syntax_fmt: FT.ALIASADD alias index
+syntax_str: index
+title: FT.ALIASADD
+---
+
+Add an alias to an index
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>alias index</code></summary>
+
+is alias to be added to an index.
+</details>
+
+Indexes can have more than one alias, but an alias cannot refer to another
+alias.
+
+FT.ALIASADD allows administrators to transparently redirect application queries to alternative indexes.
+
+## Return
+
+FT.ALIASADD returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Add an alias to an index</b></summary>
+
+Add an alias to an index.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.ALIASADD alias idx
+OK
+{{< / highlight >}}
+
+Attempting to add the same alias returns a message that the alias already exists.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.ALIASADD alias idx
+(error) Alias already exists
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.ALIASDEL`]({{< relref "commands/ft.aliasdel/" >}}) | [`FT.ALIASUPDATE`]({{< relref "commands/ft.aliasupdate/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: start-slot
+    name: start-slot
+    type: integer
+  - display_text: end-slot
+    name: end-slot
+    type: integer
+  multiple: true
+  name: range
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(N) where N is the total number of the slots between the start slot and
+  end slot arguments.
+description: Sets hash slot ranges as unbound for a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER DELSLOTSRANGE
+since: 7.0.0
+summary: Sets hash slot ranges as unbound for a node.
+syntax_fmt: CLUSTER DELSLOTSRANGE start-slot end-slot [start-slot end-slot ...]
+syntax_str: ''
+title: CLUSTER DELSLOTSRANGE
+---
+The `CLUSTER DELSLOTSRANGE` command is similar to the [`CLUSTER DELSLOTS`]({{< relref "/commands/cluster-delslots" >}}) command in that they both remove hash slots from the node.
+The difference is that [`CLUSTER DELSLOTS`]({{< relref "/commands/cluster-delslots" >}}) takes a list of hash slots to remove from the node, while `CLUSTER DELSLOTSRANGE` takes a list of slot ranges (specified by start and end slots) to remove from the node.
+
+## Example
+
+To remove slots 1 2 3 4 5 from the node, the [`CLUSTER DELSLOTS`]({{< relref "/commands/cluster-delslots" >}}) command is:
+
+    > CLUSTER DELSLOTS 1 2 3 4 5
+    OK
+
+The same operation can be completed with the following `CLUSTER DELSLOTSRANGE` command:
+
+    > CLUSTER DELSLOTSRANGE 1 5
+    OK
+
+However, note that:
+
+1. The command only works if all the specified slots are already associated with the node.
+2. The command fails if the same slot is specified multiple times.
+3. As a side effect of the command execution, the node may go into *down* state because not all hash slots are covered.
+
+## Usage in Redis Cluster
+
+This command only works in cluster mode and may be useful for
+debugging and in order to manually orchestrate a cluster configuration
+when a new cluster is created. It is currently not used by `redis-cli`,
+and mainly exists for API completeness.
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: sha1
+  name: sha1
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the script that is executed.
+description: Executes a read-only server-side Lua script by SHA1 digest.
+group: scripting
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: EVALSHA_RO
+since: 7.0.0
+summary: Executes a read-only server-side Lua script by SHA1 digest.
+syntax_fmt: EVALSHA_RO sha1 numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: EVALSHA_RO
+---
+This is a read-only variant of the [`EVALSHA`]({{< relref "/commands/evalsha" >}}) command that cannot execute commands that modify data.
+
+For more information about when to use this command vs [`EVALSHA`]({{< relref "/commands/evalsha" >}}), please refer to [Read-only scripts]({{< relref "develop/interact/programmability#read-only-scripts" >}}).
+
+For more information about [`EVALSHA`]({{< relref "/commands/evalsha" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(M*log(N)) with N being the number of elements in the sorted set and
+  M the number of elements to be removed.
+description: Removes one or more members from a sorted set. Deletes the sorted set
+  if all members were removed.
+group: sorted-set
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple elements.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREM
+since: 1.2.0
+summary: Removes one or more members from a sorted set. Deletes the sorted set if
+  all members were removed.
+syntax_fmt: ZREM key member [member ...]
+syntax_str: member [member ...]
+title: ZREM
+---
+Removes the specified members from the sorted set stored at `key`.
+Non existing members are ignored.
+
+An error is returned when `key` exists and does not hold a sorted set.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREM myzset "two"
+ZRANGE myzset 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@fast'
+- '@transaction'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- allow_busy
+complexity: O(1)
+description: Starts a transaction.
+group: transactions
+hidden: false
+linkTitle: MULTI
+since: 1.2.0
+summary: Starts a transaction.
+syntax_fmt: MULTI
+syntax_str: ''
+title: MULTI
+---
+Marks the start of a [transaction][tt] block.
+Subsequent commands will be queued for atomic execution using [`EXEC`]({{< relref "/commands/exec" >}}).
+
+[tt]: /develop/interact/transactions
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for module commands.
+group: server
+hidden: true
+linkTitle: MODULE
+since: 4.0.0
+summary: A container for module commands.
+syntax_fmt: MODULE
+syntax_str: ''
+title: MODULE
+---
+This is a container command for module management commands.
+
+To see the list of available commands you can call [`MODULE HELP`]({{< relref "/commands/module-help" >}}).
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: pattern
+  name: pattern
+  optional: true
+  type: pattern
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+complexity: O(N) where N is the number of active shard channels, and assuming constant
+  time pattern matching (relatively short shard channels).
+description: Returns the active shard channels.
+group: pubsub
+hidden: false
+linkTitle: PUBSUB SHARDCHANNELS
+since: 7.0.0
+summary: Returns the active shard channels.
+syntax_fmt: PUBSUB SHARDCHANNELS [pattern]
+syntax_str: ''
+title: PUBSUB SHARDCHANNELS
+---
+Lists the currently *active shard channels*.
+
+An active shard channel is a Pub/Sub shard channel with one or more subscribers.
+
+If no `pattern` is specified, all the channels are listed, otherwise if pattern is specified only channels matching the specified glob-style pattern are listed.
+
+The information returned about the active shard channels are at the shard level and not at the cluster level.
+
+## Examples
+
+```
+> PUBSUB SHARDCHANNELS
+1) "orders"
+> PUBSUB SHARDCHANNELS o*
+1) "orders"
+```
+---
+acl_categories:
+- '@hyperloglog'
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+complexity: N/A
+description: An internal command for testing HyperLogLog values.
+doc_flags:
+- syscmd
+group: hyperloglog
+hidden: false
+linkTitle: PFSELFTEST
+since: 2.8.9
+summary: An internal command for testing HyperLogLog values.
+syntax_fmt: PFSELFTEST
+syntax_str: ''
+title: PFSELFTEST
+---
+The `PFSELFTEST` command is an internal command.
+It is meant to be used for developing and testing Redis.---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  since: 2.6.0
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: Without the count argument O(1), otherwise O(N) where N is the absolute
+  value of the passed count.
+description: Get one or multiple random members from a set
+group: set
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 2.6.0
+  - Added the optional `count` argument.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SRANDMEMBER
+since: 1.0.0
+summary: Get one or multiple random members from a set
+syntax_fmt: SRANDMEMBER key [count]
+syntax_str: '[count]'
+title: SRANDMEMBER
+---
+When called with just the `key` argument, return a random element from the set value stored at `key`.
+
+If the provided `count` argument is positive, return an array of **distinct elements**.
+The array's length is either `count` or the set's cardinality ([`SCARD`]({{< relref "/commands/scard" >}})), whichever is lower.
+
+If called with a negative `count`, the behavior changes and the command is allowed to return the **same element multiple times**.
+In this case, the number of returned elements is the absolute value of the specified `count`.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset one two three
+SRANDMEMBER myset
+SRANDMEMBER myset 2
+SRANDMEMBER myset -5
+{{% /redis-cli %}}
+
+
+## Specification of the behavior when count is passed
+
+When the `count` argument is a positive value this command behaves as follows:
+
+* No repeated elements are returned.
+* If `count` is bigger than the set's cardinality, the command will only return the whole set without additional elements.
+* The order of elements in the reply is not truly random, so it is up to the client to shuffle them if needed.
+
+When the `count` is a negative value, the behavior changes as follows:
+
+* Repeating elements are possible.
+* Exactly `count` elements, or an empty array if the set is empty (non-existing key), are always returned.
+* The order of elements in the reply is truly random.
+
+## Distribution of returned elements
+
+Note: this section is relevant only for Redis 5 or below, as Redis 6 implements a fairer algorithm. 
+
+The distribution of the returned elements is far from perfect when the number of elements in the set is small, this is due to the fact that we used an approximated random element function that does not really guarantees good distribution.
+
+The algorithm used, that is implemented inside dict.c, samples the hash table buckets to find a non-empty one. Once a non empty bucket is found, since we use chaining in our hash table implementation, the number of elements inside the bucket is checked and a random element is selected.
+
+This means that if you have two non-empty buckets in the entire hash table, and one has three elements while one has just one, the element that is alone in its bucket will be returned with much higher probability.
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: value
+  name: value
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+deprecated_since: 6.2.0
+description: Returns the previous string value of a key after setting it to a new
+  value.
+doc_flags:
+- deprecated
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: GETSET
+replaced_by: '[`SET`]({{< relref "/commands/set" >}}) with the `GET` argument'
+since: 1.0.0
+summary: Returns the previous string value of a key after setting it to a new value.
+syntax_fmt: GETSET key value
+syntax_str: value
+title: GETSET
+---
+Atomically sets `key` to `value` and returns the old value stored at `key`.
+Returns an error when `key` exists but does not hold a string value.  Any 
+previous time to live associated with the key is discarded on successful 
+[`SET`]({{< relref "/commands/set" >}}) operation.
+
+## Design pattern
+
+`GETSET` can be used together with [`INCR`]({{< relref "/commands/incr" >}}) for counting with atomic reset.
+For example: a process may call [`INCR`]({{< relref "/commands/incr" >}}) against the key `mycounter` every time
+some event occurs, but from time to time we need to get the value of the counter
+and reset it to zero atomically.
+This can be done using `GETSET mycounter "0"`:
+
+{{% redis-cli %}}
+INCR mycounter
+GETSET mycounter "0"
+GET mycounter
+{{% /redis-cli %}}
+
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+GETSET mykey "World"
+GET mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+complexity: O(1)
+description: Returns a count of unique pattern subscriptions.
+group: pubsub
+hidden: false
+linkTitle: PUBSUB NUMPAT
+since: 2.8.0
+summary: Returns a count of unique pattern subscriptions.
+syntax_fmt: PUBSUB NUMPAT
+syntax_str: ''
+title: PUBSUB NUMPAT
+---
+Returns the number of unique patterns that are subscribed to by clients (that are performed using the [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}}) command).
+
+Note that this isn't the count of clients subscribed to patterns, but the total number of unique patterns all the clients are subscribed to.
+
+Cluster note: in a Redis Cluster clients can subscribe to every node, and can also publish to every other node. The cluster will make sure that published messages are forwarded as needed. That said, [`PUBSUB`]({{< relref "/commands/pubsub" >}})'s replies in a cluster only report information from the node's Pub/Sub context, rather than the entire cluster.
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: index
+  type: integer
+- multiple: true
+  name: value
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  array, O(N) when path is evaluated to multiple values, where N is the size of the
+  key
+description: Inserts the JSON scalar(s) value at the specified index in the array
+  at path
+group: json
+hidden: false
+linkTitle: JSON.ARRINSERT
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Inserts the JSON scalar(s) value at the specified index in the array at path
+syntax_fmt: JSON.ARRINSERT key path index value [value ...]
+syntax_str: path index value [value ...]
+title: JSON.ARRINSERT
+---
+Insert the `json` values into the array at `path` before the `index` (shifts to the right)
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is one or more values to insert in one or more arrays. 
+
+{{% alert title="About using strings with JSON commands" color="warning" %}}
+To specify a string as an array value to insert, wrap the quoted string with an additional set of single quotes. Example: `'"silver"'`. For more detailed use, see [Examples](#examples).
+{{% /alert %}}
+</details>
+
+<details open><summary><code>index</code></summary> 
+
+is position in the array where you want to insert a value. The index must be in the array's range. Inserting at `index` 0 prepends to the array. Negative index values start from the end of the array.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+## Return value 
+
+`JSON.ARRINSERT` returns an [array]({{< relref "develop/reference/protocol-spec#resp-arrays" >}}) of integer replies for each path, the array's new size, or `nil`, if the matching JSON value is not an array. 
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Add new colors to a specific place in a list of product colors</b></summary>
+
+Create a document for noise-cancelling headphones in black and silver colors.
+
+{{< highlight bash >}}
+redis> JSON.SET item:1 $ '{"name":"Noise-cancelling Bluetooth headphones","description":"Wireless Bluetooth headphones with noise-cancelling technology","connection":{"wireless":true,"type":"Bluetooth"},"price":99.98,"stock":25,"colors":["black","silver"]}'
+OK
+{{< / highlight >}}
+
+Add color `blue` to the end of the `colors` array. `JSON.ARRAPEND` returns the array's new size.
+
+{{< highlight bash >}}
+redis> JSON.ARRAPPEND item:1 $.colors '"blue"'
+1) (integer) 3
+{{< / highlight >}}
+
+Return the new length of the `colors` array.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1
+"{\"name\":\"Noise-cancelling Bluetooth headphones\",\"description\":\"Wireless Bluetooth headphones with noise-cancelling technology\",\"connection\":{\"wireless\":true,\"type\":\"Bluetooth\"},\"price\":99.98,\"stock\":25,\"colors\":[\"black\",\"silver\",\"blue\"]}"
+{{< / highlight >}}
+
+Get the list of colors for the product.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1 '$.colors[*]'
+"[\"black\",\"silver\",\"blue\"]"
+{{< / highlight >}}
+
+Insert two more colors after the second color. You now have five colors.
+
+{{< highlight bash >}}
+redis> JSON.ARRINSERT item:1 $.colors 2 '"yellow"' '"gold"'
+1) (integer) 5
+{{< / highlight >}}
+
+Get the updated list of colors.
+
+{{< highlight bash >}}
+redis> JSON.GET item:1 $.colors
+"[[\"black\",\"silver\",\"yellow\",\"gold\",\"blue\"]]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.ARRAPPEND`]({{< relref "commands/json.arrappend/" >}}) | [`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- no_auth
+- allow_busy
+complexity: O(1)
+description: Resets the connection.
+group: connection
+hidden: false
+linkTitle: RESET
+since: 6.2.0
+summary: Resets the connection.
+syntax_fmt: RESET
+syntax_str: ''
+title: RESET
+---
+This command performs a full reset of the connection's server-side context, 
+mimicking the effect of disconnecting and reconnecting again.
+
+When the command is called from a regular client connection, it does the
+following:
+
+* Discards the current [`MULTI`]({{< relref "/commands/multi" >}}) transaction block, if one exists.
+* Unwatches all keys [`WATCH`]({{< relref "/commands/watch" >}})ed by the connection.
+* Disables [`CLIENT TRACKING`]({{< relref "/commands/client-tracking" >}}), if in use.
+* Sets the connection to [`READWRITE`]({{< relref "/commands/readwrite" >}}) mode.
+* Cancels the connection's [`ASKING`]({{< relref "/commands/asking" >}}) mode, if previously set.
+* Sets [`CLIENT REPLY`]({{< relref "/commands/client-reply" >}}) to `ON`.
+* Sets the protocol version to RESP2.
+* [`SELECT`]({{< relref "/commands/select" >}})s database 0.
+* Exits [`MONITOR`]({{< relref "/commands/monitor" >}}) mode, when applicable.
+* Aborts Pub/Sub's subscription state ([`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}) and [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}})), when
+  appropriate.
+* Deauthenticates the connection, requiring a call [`AUTH`]({{< relref "/commands/auth" >}}) to reauthenticate when
+  authentication is enabled.
+* Turns off `NO-EVICT` mode.
+* Turns off `NO-TOUCH` mode.
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value, where N is the size of
+  the value, O(N) when path is evaluated to multiple values, where N is the size of
+  the key
+deprecated_since: '2.6'
+description: Returns the JSON value at path in Redis Serialization Protocol (RESP)
+group: json
+hidden: false
+linkTitle: JSON.RESP
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the JSON value at path in Redis Serialization Protocol (RESP)
+syntax_fmt: JSON.RESP key [path]
+syntax_str: '[path]'
+title: JSON.RESP
+---
+Return the JSON in `key` in [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}) form 
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. This command uses the following mapping from JSON to RESP:
+
+*   JSON `null` maps to the bulk string reply.
+*   JSON `false` and `true` values map to the simple string reply.
+*   JSON number maps to the integer reply or bulk string reply, depending on type.
+*   JSON string maps to the bulk string reply.
+*   JSON array is represented as an array reply in which the first element is the simple string reply `[`, followed by the array's elements.
+*   JSON object is represented as an array reply in which the first element is the simple string reply `{`. Each successive entry represents a key-value pair as a two-entry array reply of the bulk string reply.
+
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+</details>
+
+## Return
+
+JSON.RESP returns an array reply specified as the JSON's RESP form detailed in [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Return an array of RESP details about a document</b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":64.99,"stock":17,"colors":["black","white"], "max_level":[80, 100, 120]}'
+OK
+{{< / highlight >}}
+
+Get all RESP details about the document.
+
+{{< highlight bash >}}
+redis> JSON.RESP item:2
+ 1) {
+ 2) "name"
+ 3) "Wireless earbuds"
+ 4) "description"
+ 5) "Wireless Bluetooth in-ear headphones"
+ 6) "connection"
+ 7) 1) {
+    2) "wireless"
+    3) true
+    4) "type"
+    5) "Bluetooth"
+ 8) "price"
+ 9) "64.989999999999995"
+10) "stock"
+11) (integer) 17
+12) "colors"
+13) 1) [
+    2) "black"
+    3) "white"
+14) "max_level"
+15) 1) [
+    2) (integer) 80
+    3) (integer) 100
+    4) (integer) 120
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.ARRLEN`]({{< relref "commands/json.arrlen/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: field
+    name: field
+    type: string
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each field/value pair added, so O(N) to add N field/value pairs
+  when the command is called with multiple field/value pairs.
+description: Creates or modifies the value of a field in a hash.
+group: hash
+hidden: false
+history:
+- - 4.0.0
+  - Accepts multiple `field` and `value` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HSET
+since: 2.0.0
+summary: Creates or modifies the value of a field in a hash.
+syntax_fmt: HSET key field value [field value ...]
+syntax_str: field value [field value ...]
+title: HSET
+---
+Sets the specified fields to their respective values in the hash stored at `key`.
+
+This command overwrites the values of specified fields that exist in the hash.
+If `key` doesn't exist, a new key holding a hash is created.
+
+## Examples
+
+{{< clients-example cmds_hash hset >}}
+> HSET myhash field1 "Hello"
+(integer) 1
+> HGET myhash field1
+"Hello"
+> HSET myhash field2 "Hi" field3 "World"
+(integer) 2
+> HGET myhash field2
+"Hi"
+> HGET myhash field3
+"World"
+> HGETALL myhash
+1) "field1"
+2) "Hello"
+3) "field2"
+4) "Hi"
+5) "field3"
+6) "World"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HGET myhash field1
+HSET myhash field2 "Hi" field3 "World"
+HGET myhash field2
+HGET myhash field3
+HGETALL myhash
+{{% /redis-cli %}}---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the logarithmic access frequency counter of a Redis object.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: OBJECT FREQ
+since: 4.0.0
+summary: Returns the logarithmic access frequency counter of a Redis object.
+syntax_fmt: OBJECT FREQ key
+syntax_str: ''
+title: OBJECT FREQ
+---
+This command returns the logarithmic access frequency counter of a Redis object stored at `<key>`.
+
+The command is only available when the `maxmemory-policy` configuration directive is set to one of the LFU policies.
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: value
+  name: value
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1). The amortized time complexity is O(1) assuming the appended value
+  is small and the already present value is of any size, since the dynamic string
+  library used by Redis will double the free space available on every reallocation.
+description: Appends a string to the value of a key. Creates the key if it doesn't
+  exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: APPEND
+since: 2.0.0
+summary: Appends a string to the value of a key. Creates the key if it doesn't exist.
+syntax_fmt: APPEND key value
+syntax_str: value
+title: APPEND
+---
+If `key` already exists and is a string, this command appends the `value` at the
+end of the string.
+If `key` does not exist it is created and set as an empty string, so `APPEND`
+will be similar to [`SET`]({{< relref "/commands/set" >}}) in this special case.
+
+## Examples
+
+{{% redis-cli %}}
+EXISTS mykey
+APPEND mykey "Hello"
+APPEND mykey " World"
+GET mykey
+{{% /redis-cli %}}
+
+
+## Pattern: Time series
+
+The `APPEND` command can be used to create a very compact representation of a
+list of fixed-size samples, usually referred as _time series_.
+Every time a new sample arrives we can store it using the command
+
+```
+APPEND timeseries "fixed-size sample"
+```
+
+Accessing individual elements in the time series is not hard:
+
+* [`STRLEN`]({{< relref "/commands/strlen" >}}) can be used in order to obtain the number of samples.
+* [`GETRANGE`]({{< relref "/commands/getrange" >}}) allows for random access of elements.
+  If our time series have associated time information we can easily implement
+  a binary search to get range combining [`GETRANGE`]({{< relref "/commands/getrange" >}}) with the Lua scripting
+  engine available in Redis 2.6.
+* [`SETRANGE`]({{< relref "/commands/setrange" >}}) can be used to overwrite an existing time series.
+
+The limitation of this pattern is that we are forced into an append-only mode
+of operation, there is no way to cut the time series to a given size easily
+because Redis currently lacks a command able to trim string objects.
+However the space efficiency of time series stored in this way is remarkable.
+
+Hint: it is possible to switch to a different key based on the current Unix
+time, in this way it is possible to have just a relatively small amount of
+samples per key, to avoid dealing with very big keys, and to make this pattern
+more friendly to be distributed across many Redis instances.
+
+An example sampling the temperature of a sensor using fixed-size strings (using
+a binary format is better in real implementations).
+
+{{% redis-cli %}}
+APPEND ts "0043"
+APPEND ts "0035"
+GETRANGE ts 0 3
+GETRANGE ts 4 7
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  name: condition
+  optional: true
+  since: 3.0.2
+  type: oneof
+- arguments:
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: comparison
+  optional: true
+  since: 6.2.0
+  type: oneof
+- display_text: change
+  name: change
+  optional: true
+  since: 3.0.2
+  token: CH
+  type: pure-token
+- display_text: increment
+  name: increment
+  optional: true
+  since: 3.0.2
+  token: INCR
+  type: pure-token
+- arguments:
+  - display_text: score
+    name: score
+    type: double
+  - display_text: member
+    name: member
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(log(N)) for each item added, where N is the number of elements in the
+  sorted set.
+description: Adds one or more members to a sorted set, or updates their scores. Creates
+  the key if it doesn't exist.
+group: sorted-set
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple elements.
+- - 3.0.2
+  - Added the `XX`, `NX`, `CH` and `INCR` options.
+- - 6.2.0
+  - Added the `GT` and `LT` options.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: ZADD
+since: 1.2.0
+summary: Adds one or more members to a sorted set, or updates their scores. Creates
+  the key if it doesn't exist.
+syntax_fmt: "ZADD key [NX | XX] [GT | LT] [CH] [INCR] score member [score member\n\
+  \  ...]"
+syntax_str: '[NX | XX] [GT | LT] [CH] [INCR] score member [score member ...]'
+title: ZADD
+---
+Adds all the specified members with the specified scores to the sorted set
+stored at `key`.
+It is possible to specify multiple score / member pairs.
+If a specified member is already a member of the sorted set, the score is
+updated and the element reinserted at the right position to ensure the correct
+ordering.
+
+If `key` does not exist, a new sorted set with the specified members as sole
+members is created, like if the sorted set was empty. If the key exists but does not hold a sorted set, an error is returned.
+
+The score values should be the string representation of a double precision floating point number. `+inf` and `-inf` values are valid values as well.
+
+ZADD options
+---
+
+ZADD supports a list of options, specified after the name of the key and before
+the first score argument. Options are:
+
+* **XX**: Only update elements that already exist. Don't add new elements.
+* **NX**: Only add new elements. Don't update already existing elements.
+* **LT**: Only update existing elements if the new score is **less than** the current score. This flag doesn't prevent adding new elements.
+* **GT**: Only update existing elements if the new score is **greater than** the current score. This flag doesn't prevent adding new elements.
+* **CH**: Modify the return value from the number of new elements added, to the total number of elements changed (CH is an abbreviation of *changed*). Changed elements are **new elements added** and elements already existing for which **the score was updated**. So elements specified in the command line having the same score as they had in the past are not counted. Note: normally the return value of `ZADD` only counts the number of new elements added.
+* **INCR**: When this option is specified `ZADD` acts like [`ZINCRBY`]({{< relref "/commands/zincrby" >}}). Only one score-element pair can be specified in this mode.
+
+Note: The **GT**, **LT** and **NX** options are mutually exclusive.
+
+Range of integer scores that can be expressed precisely
+---
+
+Redis sorted sets use a *double 64-bit floating point number* to represent the score. In all the architectures we support, this is represented as an **IEEE 754 floating point number**, that is able to represent precisely integer numbers between `-(2^53)` and `+(2^53)` included. In more practical terms, all the integers between -9007199254740992 and 9007199254740992 are perfectly representable. Larger integers, or fractions, are internally represented in exponential form, so it is possible that you get only an approximation of the decimal number, or of the very big integer, that you set as score.
+
+Sorted sets 101
+---
+
+Sorted sets are sorted by their score in an ascending way.
+The same element only exists a single time, no repeated elements are
+permitted. The score can be modified both by `ZADD` that will update the
+element score, and as a side effect, its position on the sorted set, and
+by [`ZINCRBY`]({{< relref "/commands/zincrby" >}}) that can be used in order to update the score relatively to its
+previous value.
+
+The current score of an element can be retrieved using the [`ZSCORE`]({{< relref "/commands/zscore" >}}) command,
+that can also be used to verify if an element already exists or not.
+
+For an introduction to sorted sets, see the data types page on [sorted
+sets][tdtss].
+
+[tdtss]: /develop/data-types#sorted-sets
+
+Elements with the same score
+---
+
+While the same element can't be repeated in a sorted set since every element
+is unique, it is possible to add multiple different elements *having the same score*. When multiple elements have the same score, they are *ordered lexicographically* (they are still ordered by score as a first key, however, locally, all the elements with the same score are relatively ordered lexicographically).
+
+The lexicographic ordering used is binary, it compares strings as array of bytes.
+
+If the user inserts all the elements in a sorted set with the same score (for example 0), all the elements of the sorted set are sorted lexicographically, and range queries on elements are possible using the command [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) (Note: it is also possible to query sorted sets by range of scores using [`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}})).
+
+## Examples
+
+{{< clients-example cmds_sorted_set zadd >}}
+> ZADD myzset 1 "one"
+(integer) 1
+> ZADD myzset 1 "uno"
+(integer) 1
+> ZADD myzset 2 "two" 3 "three"
+(integer) 2
+> ZRANGE myzset 0 -1 WITHSCORES
+1) "one"
+2) "1"
+3) "uno"
+4) "1"
+5) "two"
+6) "2"
+7) "three"
+8) "3"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 1 "uno"
+ZADD myzset 2 "two" 3 "three"
+ZRANGE myzset 0 -1 WITHSCORES
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@search'
+- '@write'
+arguments:
+- name: key
+  type: string
+- name: string
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Deletes a string from a suggestion index
+group: suggestion
+hidden: false
+linkTitle: FT.SUGDEL
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Deletes a string from a suggestion index
+syntax: 'FT.SUGDEL key string
+
+  '
+syntax_fmt: FT.SUGDEL key string
+syntax_str: string
+title: FT.SUGDEL
+---
+
+Delete a string from a suggestion index
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is suggestion dictionary key.
+</details>
+
+<details open>
+<summary><code>string</code></summary> 
+
+is suggestion string to index.
+</details>
+
+## Return
+
+FT.SUGDEL returns an integer reply, 1 if the string was found and deleted, 0 otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Delete a string from a suggestion index</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SUGDEL sug "hello"
+(integer) 1
+127.0.0.1:6379> FT.SUGDEL sug "hello"
+(integer) 0
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SUGGET`]({{< relref "commands/ft.sugget/" >}}) | [`FT.SUGADD`]({{< relref "commands/ft.sugadd/" >}}) | [`FT.SUGLEN`]({{< relref "commands/ft.suglen/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: double
+- display_text: max
+  name: max
+  type: double
+- display_text: withscores
+  name: withscores
+  optional: true
+  since: 2.0.0
+  token: WITHSCORES
+  type: pure-token
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements being returned. If M is constant (e.g. always asking for
+  the first 10 elements with LIMIT), you can consider it O(log(N)).
+deprecated_since: 6.2.0
+description: Returns members in a sorted set within a range of scores.
+doc_flags:
+- deprecated
+group: sorted-set
+hidden: false
+history:
+- - 2.0.0
+  - Added the `WITHSCORES` modifier.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANGEBYSCORE
+replaced_by: '[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `BYSCORE` argument'
+since: 1.0.5
+summary: Returns members in a sorted set within a range of scores.
+syntax_fmt: "ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT\_offset count]"
+syntax_str: "min max [WITHSCORES] [LIMIT\_offset count]"
+title: ZRANGEBYSCORE
+---
+Returns all the elements in the sorted set at `key` with a score between `min`
+and `max` (including elements with score equal to `min` or `max`).
+The elements are considered to be ordered from low to high scores.
+
+The elements having the same score are returned in lexicographical order (this
+follows from a property of the sorted set implementation in Redis and does not
+involve further computation).
+
+The optional `LIMIT` argument can be used to only get a range of the matching
+elements (similar to _SELECT LIMIT offset, count_ in SQL). A negative `count`
+returns all elements from the `offset`.
+Keep in mind that if `offset` is large, the sorted set needs to be traversed for
+`offset` elements before getting to the elements to return, which can add up to
+O(N) time complexity.
+
+The optional `WITHSCORES` argument makes the command return both the element and
+its score, instead of the element alone.
+This option is available since Redis 2.0.
+
+## Exclusive intervals and infinity
+
+`min` and `max` can be `-inf` and `+inf`, so that you are not required to know
+the highest or lowest score in the sorted set to get all elements from or up to
+a certain score.
+
+By default, the interval specified by `min` and `max` is closed (inclusive).
+It is possible to specify an open interval (exclusive) by prefixing the score
+with the character `(`.
+For example:
+
+```
+ZRANGEBYSCORE zset (1 5
+```
+
+Will return all elements with `1 < score <= 5` while:
+
+```
+ZRANGEBYSCORE zset (5 (10
+```
+
+Will return all the elements with `5 < score < 10` (5 and 10 excluded).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZRANGEBYSCORE myzset -inf +inf
+ZRANGEBYSCORE myzset 1 2
+ZRANGEBYSCORE myzset (1 2
+ZRANGEBYSCORE myzset (1 (2
+{{% /redis-cli %}}
+
+
+## Pattern: weighted random selection of an element
+
+Normally `ZRANGEBYSCORE` is simply used in order to get range of items
+where the score is the indexed integer key, however it is possible to do less
+obvious things with the command.
+
+For example a common problem when implementing Markov chains and other algorithms
+is to select an element at random from a set, but different elements may have
+different weights that change how likely it is they are picked.
+
+This is how we use this command in order to mount such an algorithm:
+
+Imagine you have elements A, B and C with weights 1, 2 and 3.
+You compute the sum of the weights, which is 1+2+3 = 6
+
+At this point you add all the elements into a sorted set using this algorithm:
+
+```
+SUM = ELEMENTS.TOTAL_WEIGHT // 6 in this case.
+SCORE = 0
+FOREACH ELE in ELEMENTS
+    SCORE += ELE.weight / SUM
+    ZADD KEY SCORE ELE
+END
+```
+
+This means that you set:
+
+```
+A to score 0.16
+B to score .5
+C to score 1
+```
+
+Since this involves approximations, in order to avoid C is set to,
+like, 0.998 instead of 1, we just modify the above algorithm to make sure
+the last score is 1 (left as an exercise for the reader...).
+
+At this point, each time you want to get a weighted random element,
+just compute a random number between 0 and 1 (which is like calling
+`rand()` in most languages), so you can just do:
+
+    RANDOM_ELE = ZRANGEBYSCORE key RAND() +inf LIMIT 0 1
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of configured users.
+description: Reloads the rules from the configured ACL file.
+group: server
+hidden: false
+linkTitle: ACL LOAD
+since: 6.0.0
+summary: Reloads the rules from the configured ACL file.
+syntax_fmt: ACL LOAD
+syntax_str: ''
+title: ACL LOAD
+---
+When Redis is configured to use an ACL file (with the `aclfile` configuration
+option), this command will reload the ACLs from the file, replacing all
+the current ACL rules with the ones defined in the file. The command makes
+sure to have an *all or nothing* behavior, that is:
+
+* If every line in the file is valid, all the ACLs are loaded.
+* If one or more line in the file is not valid, nothing is loaded, and the old ACL rules defined in the server memory continue to be used.
+
+## Examples
+
+```
+> ACL LOAD
++OK
+
+> ACL LOAD
+-ERR /tmp/foo:1: Unknown command or category name in ACL...
+```
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: scripting
+hidden: true
+linkTitle: SCRIPT HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: SCRIPT HELP
+syntax_str: ''
+title: SCRIPT HELP
+---
+The `SCRIPT HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- arguments:
+  - name: key
+    type: key
+  - name: path
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: triplet
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(K*(M+N)) where k is the number of keys in the command, when path is
+  evaluated to a single value where M is the size of the original value (if it exists)
+  and N is the size of the new value, or O(K*(M+N)) when path is evaluated to multiple
+  values where M is the size of the key and N is the size of the new value * the number
+  of original values in the key
+description: Sets or updates the JSON value of one or more keys
+group: json
+hidden: false
+linkTitle: JSON.MSET
+module: JSON
+since: 2.6.0
+stack_path: docs/data-types/json
+summary: Sets or updates the JSON value of one or more keys
+syntax_fmt: JSON.MSET key path value [key path value ...]
+syntax_str: ''
+title: JSON.MSET
+---
+Set or update one or more JSON values according to the specified `key`-`path`-`value` triplets
+
+`JSON.MSET` is atomic, hence, all given additions or updates are either applied or not. It is not possible for clients to see that some of the keys were updated while others are unchanged.
+
+A JSON value is a hierarchical structure. If you change a value in a specific path - nested values are affected.
+
+{{% warning %}}
+When cluster mode is enabled, all specified keys must reside on the same [hash slot](https://redis.io/docs/latest/operate/oss_and_stack/reference/cluster-spec/#key-distribution-model).
+{{% /warning %}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key to modify.
+</details>
+
+<details open><summary><code>path</code></summary>
+
+is JSONPath to specify. For new Redis keys the `path` must be the root. For existing keys, when the entire `path` exists, the value that it contains is replaced with the `json` value. For existing keys, when the `path` exists, except for the last element, a new child is added with the `json` value.
+
+</details>
+
+<details open><summary><code>value</code></summary>
+
+is value to set at the specified path
+</details>
+
+## Return value
+
+JSET.MSET returns a simple string reply: `OK` if executed correctly or `error` if fails to set the new values
+
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Add a new values in multiple keys</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.MSET doc1 $ '{"a":1}' doc2 $ '{"f":{"a":2}}' doc3 $ '{"f1":{"a":0},"f2":{"a":0}}'
+OK
+redis> JSON.MSET doc1 $ '{"a":2}' doc2 $.f.a '3' doc3 $ '{"f1":{"a":1},"f2":{"a":2}}'
+OK
+redis> JSON.GET doc1 $
+"[{\"a\":2}]"
+redis> JSON.GET doc2 $
+"[{\"f\":{\"a\":3}}]"
+redis> JSON.GET doc3
+"{\"f1\":{\"a\":1},\"f2\":{\"a\":2}}"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.MGET`]({{< relref "commands/json.mget/" >}}) | [`JSON.GET`]({{< relref "commands/json.get/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: ip
+  name: ip
+  type: string
+- display_text: port
+  name: port
+  type: integer
+- display_text: cluster-bus-port
+  name: cluster-bus-port
+  optional: true
+  since: 4.0.0
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Forces a node to handshake with another node.
+group: cluster
+hidden: false
+history:
+- - 4.0.0
+  - Added the optional `cluster_bus_port` argument.
+linkTitle: CLUSTER MEET
+since: 3.0.0
+summary: Forces a node to handshake with another node.
+syntax_fmt: CLUSTER MEET ip port [cluster-bus-port]
+syntax_str: port [cluster-bus-port]
+title: CLUSTER MEET
+---
+`CLUSTER MEET` is used in order to connect different Redis nodes with cluster
+support enabled, into a working cluster.
+
+The basic idea is that nodes by default don't trust each other, and are
+considered unknown, so that it is unlikely that different cluster nodes will
+mix into a single one because of system administration errors or network
+addresses modifications.
+
+So in order for a given node to accept another one into the list of nodes
+composing a Redis Cluster, there are only two ways:
+
+1. The system administrator sends a `CLUSTER MEET` command to force a node to meet another one.
+2. An already known node sends a list of nodes in the gossip section that we are not aware of. If the receiving node trusts the sending node as a known node, it will process the gossip section and send a handshake to the nodes that are still not known.
+
+Note that Redis Cluster needs to form a full mesh (each node is connected with each other node), but in order to create a cluster, there is no need to send all the `CLUSTER MEET` commands needed to form the full mesh. What matter is to send enough `CLUSTER MEET` messages so that each node can reach each other node through a *chain of known nodes*. Thanks to the exchange of gossip information in heartbeat packets, the missing links will be created.
+
+So, if we link node A with node B via `CLUSTER MEET`, and B with C, A and C will find their ways to handshake and create a link.
+
+Another example: if we imagine a cluster formed of the following four nodes called A, B, C and D, we may send just the following set of commands to A:
+
+1. `CLUSTER MEET B-ip B-port`
+2. `CLUSTER MEET C-ip C-port`
+3. `CLUSTER MEET D-ip D-port`
+
+As a side effect of `A` knowing and being known by all the other nodes, it will send gossip sections in the heartbeat packets that will allow each other node to create a link with each other one, forming a full mesh in a matter of seconds, even if the cluster is large.
+
+Moreover `CLUSTER MEET` does not need to be reciprocal. If I send the command to A in order to join B, I don't need to also send it to B in order to join A.
+
+If the optional `cluster_bus_port` argument is not provided, the default of port + 10000 will be used.
+
+## Implementation details: MEET and PING packets
+
+When a given node receives a `CLUSTER MEET` message, the node specified in the
+command still does not know the node we sent the command to. So in order for
+the node to force the receiver to accept it as a trusted node, it sends a
+`MEET` packet instead of a [`PING`]({{< relref "/commands/ping" >}}) packet. The two packets have exactly the
+same format, but the former forces the receiver to acknowledge the node as
+trusted.
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: value
+  type: double
+- name: timestamp
+  optional: true
+  token: TIMESTAMP
+  type: string
+- name: retentionPeriod
+  optional: true
+  token: RETENTION
+  type: integer
+- arguments:
+  - name: uncompressed
+    token: UNCOMPRESSED
+    type: pure-token
+  - name: compressed
+    token: COMPRESSED
+    type: pure-token
+  name: enc
+  optional: true
+  token: ENCODING
+  type: oneof
+- name: size
+  optional: true
+  token: CHUNK_SIZE
+  type: integer
+- name: policy
+  optional: true
+  token: DUPLICATE_POLICY
+  type: oneof
+- arguments:
+  - name: label
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: labels
+  optional: true
+  token: LABELS
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M) when M is the amount of compaction rules or O(1) with no compaction
+description: Increase the value of the sample with the maximum existing timestamp,
+  or create a new sample with a value equal to the value of the sample with the maximum
+  existing timestamp with a given increment
+group: timeseries
+hidden: false
+linkTitle: TS.INCRBY
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Increase the value of the sample with the maximum existing timestamp, or
+  create a new sample with a value equal to the value of the sample with the maximum
+  existing timestamp with a given increment
+syntax: "TS.INCRBY key addend \n  [TIMESTAMP timestamp] \n  [RETENTION retentionPeriod]\
+  \ \n  [ENCODING <COMPRESSED|UNCOMPRESSED>] \n  [CHUNK_SIZE size] \n  [DUPLICATE_POLICY policy] \n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff]\ 
+  \ \n  [LABELS [label value ...]]\n"
+syntax_fmt: "TS.INCRBY key value [TIMESTAMP\_timestamp]\n  [RETENTION\_retentionPeriod]\
+  \ [ENCODING\_<COMPRESSED|UNCOMPRESSED>] [CHUNK_SIZE\_size]\n [DUPLICATE_POLICY\_policy] [LABELS\_[label value ...]]"
+syntax_str: "value [TIMESTAMP\_timestamp] [RETENTION\_retentionPeriod] [ENCODING\_<COMPRESSED|UNCOMPRESSED>]\
+  \ [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_policy] [LABELS\_[label value ...]]"
+title: TS.INCRBY
+---
+
+Increase the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given increment
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<details open><summary><code>addend</code></summary> 
+
+is numeric value of the addend (double).
+</details>
+
+<note><b>Notes</b>
+- When specified key does not exist, a new time series is created.  
+- You can use this command as a counter or gauge that automatically gets history as a time series.
+- If a policy for handling duplicate samples (`IGNORE`) is defined for this time series - `TS.INCRBY` operations are affected as well (sample additions/modifications can be filtered).
+- Explicitly adding samples to a compacted time series (using [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), `TS.INCRBY`, or [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}})) may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples.  
+</note>
+
+## Optional arguments
+
+<details open><summary><code>TIMESTAMP timestamp</code></summary> 
+
+is Unix time (integer, in milliseconds) specifying the sample timestamp or `*` to set the sample timestamp to the Unix time of the server's clock.
+
+Unix time is the number of milliseconds that have elapsed since 00:00:00 UTC on 1 January 1970, the Unix epoch, without adjustments made due to leap seconds.
+
+`timestamp` must be equal to or higher than the maximum existing timestamp. When equal, the value of the sample with the maximum existing timestamp is increased. If it is higher, a new sample with a timestamp set to `timestamp` is created, and its value is set to the value of the sample with the maximum existing timestamp plus `addend`.
+
+If the time series is empty, the value is set to `addend`. 
+  
+When not specified, the timestamp is set to the Unix time of the server's clock.
+</details>
+
+<details open><summary><code>RETENTION retentionPeriod</code></summmary> 
+
+is maximum retention period, compared to the maximum existing timestamp, in milliseconds.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `RETENTION` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>ENCODING enc</code></summary> 
+
+specifies the series sample encoding format.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `ENCODING` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>CHUNK_SIZE size</code></summary> 
+
+is memory size, in bytes, allocated for each data chunk.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `CHUNK_SIZE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>DUPLICATE_POLICY policy</code></summary>
+
+is policy for handling insertion ([`TS.ADD`]({{< relref "commands/ts.add/" >}}) and [`TS.MADD`]({{< relref "commands/ts.madd/" >}})) of multiple samples with identical timestamps.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `DUPLICATE_POLICY` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>IGNORE ignoreMaxTimediff ignoreMaxValDiff</code></summary> 
+
+is the policy for handling duplicate samples. A new sample is considered a duplicate and is ignored if the following conditions are met:
+
+  - The time series is not a compaction;
+  - The time series' `DUPLICATE_POLICY` IS `LAST`;
+  - The sample is added in-order (`timestamp ≥ max_timestamp`);
+  - The difference of the current timestamp from the previous timestamp (`timestamp - max_timestamp`) is less than or equal to `IGNORE_MAX_TIME_DIFF`;
+  - The absolute value difference of the current value from the value at the previous maximum timestamp (`abs(value - value_at_max_timestamp`) is less than or equal to `IGNORE_MAX_VAL_DIFF`.
+
+where `max_timestamp` is the timestamp of the sample with the largest timestamp in the time series, and `value_at_max_timestamp` is the value at `max_timestamp`.
+
+When not specified: set to the global [IGNORE_MAX_TIME_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}) and [IGNORE_MAX_VAL_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}), which are, by default, both set to 0.
+
+These parameters are used when creating a new time series to set the per-key parameters, and are ignored when called with an existing time series (the existing per-key configuration parameters are used).
+</details>
+
+<details open><summary><code>LABELS [{label value}...]</code></summary> 
+
+is set of label-value pairs that represent metadata labels of the key and serve as a secondary index.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `LABELS` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<note><b>Notes</b>
+- You can use this command to create a new time series and add a sample to it in a single command.
+  `RETENTION`, `ENCODING`, `CHUNK_SIZE`, `DUPLICATE_POLICY`, `IGNORE`, and `LABELS` are used only when creating a new time series, and ignored when adding or modifying samples in an existing time series.
+- Setting `RETENTION` and `LABELS` introduces additional time complexity.
+</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the timestamp of the upserted sample. If the sample is ignored (See `IGNORE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}})), the reply will be the largest timestamp in the time series.
+- [] on error (invalid arguments, wrong key type, etc.), or when `timestamp` is not equal to or higher than the maximum existing timestamp
+
+## Examples
+
+<details open><summary><b>Store sum of data from several sources</b></summary> 
+
+Suppose you are getting number of orders or total income per minute from several points of sale, and you want to store only the combined value. Call TS.INCRBY for each point-of-sale report.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.INCRBY a 232 TIMESTAMP 1657811829000		// point-of-sale #1
+(integer) 1657811829000
+127.0.0.1:6379> TS.INCRBY a 157 TIMESTAMP 1657811829000		// point-of-sale #2
+(integer) 1657811829000
+127.0.0.1:6379> TS.INCRBY a 432 TIMESTAMP 1657811829000		// point-of-sale #3
+(integer) 1657811829000
+{{< / highlight >}}
+
+Note that the timestamps must arrive in non-decreasing order.
+
+{{< highlight bash >}}
+127.0.0.1:6379> ts.incrby a 100 TIMESTAMP 50
+(error) TSDB: timestamp must be equal to or higher than the maximum existing timestamp
+{{< / highlight >}}
+
+You can achieve similar results without such protection using `TS.ADD key timestamp value ON_DUPLICATE sum`.
+</details>
+
+<details open><summary><b>Count sensor captures</b></summary>
+
+Suppose a sensor ticks whenever a car is passed on a road, and you want to count occurrences. Whenever you get a tick from the sensor you can simply call:
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.INCRBY a 1
+(integer) 1658431553109
+{{< / highlight >}}
+
+The timestamp is filled automatically. 
+</details>
+
+## See also
+
+[`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}}) | [`TS.CREATE`]({{< relref "commands/ts.create/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  values, O(N) when path is evaluated to multiple values, where N is the size of the
+  key
+description: Clears all values from an array or an object and sets numeric values
+  to `0`
+group: json
+hidden: false
+linkTitle: JSON.CLEAR
+module: JSON
+since: 2.0.0
+stack_path: docs/data-types/json
+summary: Clears all values from an array or an object and sets numeric values to `0`
+syntax_fmt: JSON.CLEAR key [path]
+syntax_str: '[path]'
+title: JSON.CLEAR
+---
+Clear container values (arrays/objects) and set numeric values to `0`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. Nonexisting paths are ignored.
+</details>
+
+## Return
+
+JSON.CLEAR returns an integer reply specifying the number of matching JSON arrays and objects cleared + number of matching JSON numerical values zeroed.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+{{% alert title="Note" color="warning" %}}
+ 
+Already cleared values are ignored for empty containers and zero numbers.
+
+{{% /alert %}}
+
+## Examples
+
+<details open>
+<summary><b>Clear container values and set numeric values to <code>0</code></b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"obj":{"a":1, "b":2}, "arr":[1,2,3], "str": "foo", "bool": true, "int": 42, "float": 3.14}'
+OK
+{{< / highlight >}}
+
+Clear all container values. This returns the number of objects with cleared values.
+
+{{< highlight bash >}}
+redis> JSON.CLEAR doc $.*
+(integer) 4
+{{< / highlight >}}
+
+Get the updated document. Note that numeric values have been set to `0`.
+
+{{< highlight bash >}}
+redis> JSON.GET doc $
+"[{\"obj\":{},\"arr\":[],\"str\":\"foo\",\"bool\":true,\"int\":0,\"float\":0}]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: pubsub
+hidden: true
+linkTitle: PUBSUB HELP
+since: 6.2.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: PUBSUB HELP
+syntax_str: ''
+title: PUBSUB HELP
+---
+The `PUBSUB HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- arguments:
+  - display_text: id
+    name: id
+    type: string
+  - display_text: new-id
+    name: new-id
+    token: $
+    type: pure-token
+  name: id-selector
+  type: oneof
+- display_text: mkstream
+  name: mkstream
+  optional: true
+  token: MKSTREAM
+  type: pure-token
+- display_text: entries-read
+  name: entriesread
+  optional: true
+  token: ENTRIESREAD
+  type: integer
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+description: Creates a consumer group.
+group: stream
+hidden: false
+history:
+- - 7.0.0
+  - Added the `entries_read` named argument.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: XGROUP CREATE
+since: 5.0.0
+summary: Creates a consumer group.
+syntax_fmt: "XGROUP CREATE key group <id | $> [MKSTREAM]\n  [ENTRIESREAD\_entries-read]"
+syntax_str: "group <id | $> [MKSTREAM] [ENTRIESREAD\_entries-read]"
+title: XGROUP CREATE
+---
+Create a new consumer group uniquely identified by `<groupname>` for the stream stored at `<key>`
+
+Every group has a unique name in a given stream. 
+When a consumer group with the same name already exists, the command returns a `-BUSYGROUP` error.
+
+The command's `<id>` argument specifies the last delivered entry in the stream from the new group's perspective.
+The special ID `$` is the ID of the last entry in the stream, but you can substitute it with any valid ID.
+
+For example, if you want the group's consumers to fetch the entire stream from the beginning, use zero as the starting ID for the consumer group:
+
+    XGROUP CREATE mystream mygroup 0
+
+By default, the `XGROUP CREATE` command expects that the target stream exists, and returns an error when it doesn't.
+If a stream does not exist, you can create it automatically with length of 0 by using the optional `MKSTREAM` subcommand as the last argument after the `<id>`:
+
+    XGROUP CREATE mystream mygroup $ MKSTREAM
+
+To enable consumer group lag tracking, specify the optional `entries_read` named argument with an arbitrary ID.
+An arbitrary ID is any ID that isn't the ID of the stream's first entry, last entry, or zero ("0-0") ID.
+Use it to find out how many entries are between the arbitrary ID (excluding it) and the stream's last entry.
+Set the `entries_read` the stream's `entries_added` subtracted by the number of entries.
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for slow log commands.
+group: server
+hidden: true
+linkTitle: SLOWLOG
+since: 2.2.12
+summary: A container for slow log commands.
+syntax_fmt: SLOWLOG
+syntax_str: ''
+title: SLOWLOG
+---
+The Redis Slow Log is a system to log queries that exceeded a specified execution time.
+The execution time does not include I/O operations like talking with the client, just the time needed to execute the command (this is the only stage of command execution where the thread is blocked and cannot serve other requests).
+
+A new entry is added to the slow log whenever a command exceeds the execution time threshold defined by the `slowlog-log-slower-than` configuration directive.
+
+The maximum number of entries in the slow log is governed by the `slowlog-max-len` configuration directive.
+This is a container command for slow log management commands.
+
+See [`SLOWLOG GET`]({{< relref "/commands/slowlog-get" >}}) for a description of what's stored in the Redis slow log. To see the list of available commands use the [`SLOWLOG HELP`]({{< relref "/commands/slowlog-help" >}}) command.
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the number of members in a sorted set.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZCARD
+since: 1.2.0
+summary: Returns the number of members in a sorted set.
+syntax_fmt: ZCARD key
+syntax_str: ''
+title: ZCARD
+---
+Returns the sorted set cardinality (number of elements) of the sorted set stored
+at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZCARD myzset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@search'
+arguments:
+- name: dict
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N), where N is the size of the dictionary
+description: Dumps all terms in the given dictionary
+group: search
+hidden: false
+linkTitle: FT.DICTDUMP
+module: Search
+since: 1.4.0
+stack_path: docs/interact/search-and-query
+summary: Dumps all terms in the given dictionary
+syntax: 'FT.DICTDUMP dict
+
+  '
+syntax_fmt: FT.DICTDUMP dict
+syntax_str: ''
+title: FT.DICTDUMP
+---
+
+Dump all terms in the given dictionary
+
+[Examples](#examples)
+
+## Required argumemts
+
+<details open>
+<summary><code>dict</code></summary>
+
+is dictionary name.
+</details>
+
+## Return
+
+FT.DICTDUMP returns an array, where each element is term (string).
+
+## Examples
+
+<details open>
+<summary><b>Dump all terms in the dictionary</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.DICTDUMP dict
+1) "foo"
+2) "bar"
+3) "hello world"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.DICTADD`]({{< relref "commands/ft.dictadd/" >}}) | [`FT.DICTDEL`]({{< relref "commands/ft.dictdel/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+
+
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the set cardinality.
+description: Returns all members of a set.
+group: set
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SMEMBERS
+since: 1.0.0
+summary: Returns all members of a set.
+syntax_fmt: SMEMBERS key
+syntax_str: ''
+title: SMEMBERS
+---
+Returns all the members of the set value stored at `key`.
+
+This has the same effect as running [`SINTER`]({{< relref "/commands/sinter" >}}) with one argument `key`.
+
+## Examples
+
+{{< clients-example cmds_set smembers >}}
+redis> SADD myset "Hello"
+(integer) 1
+redis> SADD myset "World"
+(integer) 1
+redis> SMEMBERS myset
+1) "Hello"
+2) "World"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+SADD myset "Hello"
+SADD myset "World"
+SMEMBERS myset
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- no_auth
+- allow_busy
+complexity: O(1)
+deprecated_since: 7.2.0
+description: Closes the connection.
+doc_flags:
+- deprecated
+group: connection
+hidden: false
+linkTitle: QUIT
+replaced_by: just closing the connection
+since: 1.0.0
+summary: Closes the connection.
+syntax_fmt: QUIT
+syntax_str: ''
+title: QUIT
+---
+Ask the server to close the connection.
+The connection is closed as soon as all pending replies have been written to the
+client.
+
+**Note:** Clients should not use this command.
+Instead, clients should simply close the connection when they're not used anymore.
+Terminating a connection on the client side is preferable, as it eliminates `TIME_WAIT` lingering sockets on the server side.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: node-id
+  name: node-id
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+complexity: O(N) where N is the number of replicas.
+deprecated_since: 5.0.0
+description: Lists the replica nodes of a master node.
+doc_flags:
+- deprecated
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER SLAVES
+replaced_by: '[`CLUSTER REPLICAS`]({{< relref "/commands/cluster-replicas" >}})'
+since: 3.0.0
+summary: Lists the replica nodes of a master node.
+syntax_fmt: CLUSTER SLAVES node-id
+syntax_str: ''
+title: CLUSTER SLAVES
+---
+**A note about the word slave used in this man page and command name**: starting with Redis version 5, if not for backward compatibility, the Redis project no longer uses the word slave. Please use the new command [`CLUSTER REPLICAS`]({{< relref "/commands/cluster-replicas" >}}). The command `CLUSTER SLAVES` will continue to work for backward compatibility.
+
+The command provides a list of replica nodes replicating from the specified
+master node. The list is provided in the same format used by [`CLUSTER NODES`]({{< relref "/commands/cluster-nodes" >}}) (please refer to its documentation for the specification of the format).
+
+The command will fail if the specified node is not known or if it is not
+a master according to the node table of the node receiving the command.
+
+Note that if a replica is added, moved, or removed from a given master node,
+and we ask `CLUSTER SLAVES` to a node that has not yet received the
+configuration update, it may show stale information. However eventually
+(in a matter of seconds if there are no network partitions) all the nodes
+will agree about the set of nodes associated with a given master.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(1)
+description: Returns the ID of a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER MYID
+since: 3.0.0
+summary: Returns the ID of a node.
+syntax_fmt: CLUSTER MYID
+syntax_str: ''
+title: CLUSTER MYID
+---
+Returns the node's id.
+
+The `CLUSTER MYID` command returns the unique, auto-generated identifier that is associated with the connected cluster node.
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Returns the number of keys of the object at path
+group: json
+hidden: false
+linkTitle: JSON.OBJLEN
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the number of keys of the object at path
+syntax_fmt: JSON.OBJLEN key [path]
+syntax_str: '[path]'
+title: JSON.OBJLEN
+---
+Report the number of keys in the JSON object at `path` in `key`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse. Returns `null` for nonexistent keys.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. Returns `null` for nonexistant path.
+
+</details>
+
+## Return
+
+JSON.OBJLEN returns an array of integer replies for each path specified as the number of keys in the object or `nil`, if the matching JSON value is not an object.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":[3], "nested": {"a": {"b":2, "c": 1}}}'
+OK
+redis> JSON.OBJLEN doc $..a
+1) (nil)
+2) (integer) 2
+{{< / highlight >}}
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of configured users.
+description: Dumps the effective rules in ACL file format.
+group: server
+hidden: false
+linkTitle: ACL LIST
+since: 6.0.0
+summary: Dumps the effective rules in ACL file format.
+syntax_fmt: ACL LIST
+syntax_str: ''
+title: ACL LIST
+---
+The command shows the currently active ACL rules in the Redis server. Each
+line in the returned array defines a different user, and the format is the
+same used in the redis.conf file or the external ACL file, so you can
+cut and paste what is returned by the ACL LIST command directly inside a
+configuration file if you wish (but make sure to check [`ACL SAVE`]({{< relref "/commands/acl-save" >}})).
+
+## Examples
+
+```
+> ACL LIST
+1) "user antirez on #9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08 ~objects:* &* +@all -@admin -@dangerous"
+2) "user default on nopass ~* &* +@all"
+```
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns a random key name from the database.
+group: generic
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:special
+- nondeterministic_output
+linkTitle: RANDOMKEY
+since: 1.0.0
+summary: Returns a random key name from the database.
+syntax_fmt: RANDOMKEY
+syntax_str: ''
+title: RANDOMKEY
+---
+Return a random key from the currently selected database.
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: max
+  name: max
+  type: double
+- display_text: min
+  name: min
+  type: double
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements being returned. If M is constant (e.g. always asking for
+  the first 10 elements with LIMIT), you can consider it O(log(N)).
+deprecated_since: 6.2.0
+description: Returns members in a sorted set within a range of scores in reverse order.
+doc_flags:
+- deprecated
+group: sorted-set
+hidden: false
+history:
+- - 2.1.6
+  - '`min` and `max` can be exclusive.'
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREVRANGEBYSCORE
+replaced_by: '[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `REV` and `BYSCORE`
+  arguments'
+since: 2.2.0
+summary: Returns members in a sorted set within a range of scores in reverse order.
+syntax_fmt: "ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT\_offset count]"
+syntax_str: "max min [WITHSCORES] [LIMIT\_offset count]"
+title: ZREVRANGEBYSCORE
+---
+Returns all the elements in the sorted set at `key` with a score between `max`
+and `min` (including elements with score equal to `max` or `min`).
+In contrary to the default ordering of sorted sets, for this command the
+elements are considered to be ordered from high to low scores.
+
+The elements having the same score are returned in reverse lexicographical
+order.
+
+Apart from the reversed ordering, `ZREVRANGEBYSCORE` is similar to
+[`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREVRANGEBYSCORE myzset +inf -inf
+ZREVRANGEBYSCORE myzset 2 1
+ZREVRANGEBYSCORE myzset 2 (1
+ZREVRANGEBYSCORE myzset (2 (1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: scripting
+hidden: true
+linkTitle: FUNCTION HELP
+since: 7.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: FUNCTION HELP
+syntax_str: ''
+title: FUNCTION HELP
+---
+The `FUNCTION HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- display_text: consumer
+  name: consumer
+  type: string
+arity: 5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+description: Creates a consumer in a consumer group.
+group: stream
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: XGROUP CREATECONSUMER
+since: 6.2.0
+summary: Creates a consumer in a consumer group.
+syntax_fmt: XGROUP CREATECONSUMER key group consumer
+syntax_str: group consumer
+title: XGROUP CREATECONSUMER
+---
+Create a consumer named `<consumername>` in the consumer group `<groupname>` of the stream that's stored at `<key>`.
+
+Consumers are also created automatically whenever an operation, such as [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), references a consumer that doesn't exist.
+This is valid for [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) only when there is data in the stream.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: node-id
+  name: node-id
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Removes a node from the nodes table.
+group: cluster
+hidden: false
+history:
+- - 7.2.0
+  - Forgotten nodes are automatically propagated across the cluster via gossip.
+linkTitle: CLUSTER FORGET
+since: 3.0.0
+summary: Removes a node from the nodes table.
+syntax_fmt: CLUSTER FORGET node-id
+syntax_str: ''
+title: CLUSTER FORGET
+---
+The command is used in order to remove a node, specified via its node ID,
+from the set of *known nodes* of the Redis Cluster node receiving the command.
+In other words the specified node is removed from the *nodes table* of the
+node receiving the command.
+
+Because when a given node is part of the cluster, all the other nodes
+participating in the cluster knows about it, in order for a node to be
+completely removed from a cluster, the `CLUSTER FORGET` command must be
+sent to all the remaining nodes, regardless of the fact they are masters
+or replicas.
+
+However the command cannot simply drop the node from the internal node
+table of the node receiving the command, it also implements a ban-list, not
+allowing the same node to be added again as a side effect of processing the
+*gossip section* of the heartbeat packets received from other nodes.
+
+Starting with Redis 7.2.0, the ban-list is included in cluster gossip ping/pong messages. 
+This means that `CLUSTER FORGET` doesn't need to be sent to all nodes in a cluster.
+You can run the command on one or more nodes, after which it will be propagated to the rest of the nodes in most cases.
+
+## Details on why the ban-list is needed
+
+In the following example we'll show why the command must not just remove
+a given node from the nodes table, but also prevent it for being re-inserted
+again for some time.
+
+Let's assume we have four nodes, A, B, C and D. In order to
+end with just a three nodes cluster A, B, C we may follow these steps:
+
+1. Reshard all the hash slots from D to nodes A, B, C.
+2. D is now empty, but still listed in the nodes table of A, B and C.
+3. We contact A, and send `CLUSTER FORGET D`.
+4. B sends node A a heartbeat packet, where node D is listed.
+5. A does no longer known node D (see step 3), so it starts a handshake with D.
+6. D ends re-added in the nodes table of A.
+
+As you can see in this way removing a node is fragile, we need to send
+`CLUSTER FORGET` commands to all the nodes ASAP hoping there are no
+gossip sections processing in the meantime. Because of this problem the
+command implements a ban-list with an expire time for each entry.
+
+So what the command really does is:
+
+1. The specified node gets removed from the nodes table.
+2. The node ID of the removed node gets added to the ban-list, for 1 minute.
+3. The node will skip all the node IDs listed in the ban-list when processing gossip sections received in heartbeat packets from other nodes.
+
+This way we have a 60 second window to inform all the nodes in the cluster that
+we want to remove a node.
+
+## Special conditions not allowing the command execution
+
+The command does not succeed and returns an error in the following cases:
+
+1. The specified node ID is not found in the nodes table.
+2. The node receiving the command is a replica, and the specified node ID identifies its current master.
+3. The node ID identifies the same node we are sending the command to.
+
+## Behavior change history
+
+*   `>= 7.2.0`: Automatically propagate node deletion to other nodes in a cluster, allowing nodes to be deleted with a single call
+  in most cases.
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Return the dimension of vectors in the vector set.
+group: vector_set
+hidden: false
+linkTitle: VDIM
+since: 8.0.0
+summary: Return the dimension of vectors in the vector set.
+syntax_fmt: "VDIM key"
+title: VDIM
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return the number of dimensions of the vectors in the specified vector set.
+
+```shell
+VDIM word_embeddings
+(integer) 300
+```
+
+If the vector set was created using the `REDUCE` option for dimensionality reduction, this command reports the reduced dimension. However, you must still use full-size vectors when performing queries with the `VSIM` command.
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Decrements the integer value of a key by one. Uses 0 as initial value
+  if the key doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: DECR
+since: 1.0.0
+summary: Decrements the integer value of a key by one. Uses 0 as initial value if
+  the key doesn't exist.
+syntax_fmt: DECR key
+syntax_str: ''
+title: DECR
+---
+Decrements the number stored at `key` by one.
+If the key does not exist, it is set to `0` before performing the operation.
+An error is returned if the key contains a value of the wrong type or contains a
+string that can not be represented as integer.
+This operation is limited to **64 bit signed integers**.
+
+See [`INCR`]({{< relref "/commands/incr" >}}) for extra information on increment/decrement operations.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "10"
+DECR mykey
+SET mykey "234293482390480948029348230948"
+DECR mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@cuckoo'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k * n), where k is the number of sub-filters and n is the number of
+  items
+description: Checks whether one or more items exist in a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.MEXISTS
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Checks whether one or more items exist in a Cuckoo Filter
+syntax_fmt: CF.MEXISTS key item [item ...]
+syntax_str: item [item ...]
+title: CF.MEXISTS
+---
+Determines whether one or more items were added to a cuckoo filter.
+
+This command is similar to [`CF.EXISTS`]({{< relref "commands/cf.exists/" >}}), except that more than one item can be checked.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter.
+
+</details>
+
+<details open><summary><code>item...</code></summary>
+
+One or more items to check.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that, with high probability, `item` was already added to the filter, and "0" means that `key` does not exist or that `item` had not added to the filter. See note in [`CF.DEL`]({{< relref "commands/cf.del/" >}}).
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INSERT cf ITEMS item1 item2
+1) (integer) 1
+2) (integer) 1
+redis> CF.MEXISTS cf item1 item2 item3
+1) (integer) 1
+2) (integer) 1
+3) (integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: end
+  name: end
+  type: string
+- display_text: start
+  name: start
+  type: string
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) with N being the number of elements returned. If N is constant (e.g.
+  always asking for the first 10 elements with COUNT), you can consider it O(1).
+description: Returns the messages from a stream within a range of IDs in reverse order.
+group: stream
+hidden: false
+history:
+- - 6.2.0
+  - Added exclusive ranges.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XREVRANGE
+since: 5.0.0
+summary: Returns the messages from a stream within a range of IDs in reverse order.
+syntax_fmt: "XREVRANGE key end start [COUNT\_count]"
+syntax_str: "end start [COUNT\_count]"
+title: XREVRANGE
+---
+This command is exactly like [`XRANGE`]({{< relref "/commands/xrange" >}}), but with the notable difference of
+returning the entries in reverse order, and also taking the start-end
+range in reverse order: in `XREVRANGE` you need to state the *end* ID
+and later the *start* ID, and the command will produce all the element
+between (or exactly like) the two IDs, starting from the *end* side.
+
+So for instance, to get all the elements from the higher ID to the lower
+ID one could use:
+
+    XREVRANGE somestream + -
+
+Similarly to get just the last element added into the stream it is
+enough to send:
+
+    XREVRANGE somestream + - COUNT 1
+
+## Examples
+
+{{% redis-cli %}}
+XADD writers * name Virginia surname Woolf
+XADD writers * name Jane surname Austen
+XADD writers * name Toni surname Morrison
+XADD writers * name Agatha surname Christie
+XADD writers * name Ngozi surname Adichie
+XLEN writers
+XREVRANGE writers + - COUNT 1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@bloom'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k * n), where k is the number of hash functions and n is the number
+  of items
+description: Checks whether one or more items exist in a Bloom Filter
+group: bf
+hidden: false
+linkTitle: BF.MEXISTS
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Checks whether one or more items exist in a Bloom Filter
+syntax_fmt: BF.MEXISTS key item [item ...]
+syntax_str: item [item ...]
+title: BF.MEXISTS
+---
+Determines whether one or more items were added to a Bloom filter.
+
+This command is similar to [`BF.EXISTS`]({{< relref "commands/bf.exists/" >}}), except that more than one item can be checked.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter.
+
+</details>
+
+<details open><summary><code>item...</code></summary>
+
+One or more items to check.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that, with high probability, `item` was already added to the filter, and "0" means that `key` does not exist or that `item` was definitely not added to the filter.
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.MADD bf item1 item2
+1) (integer) 1
+2) (integer) 1
+redis> BF.MEXISTS bf item1 item2 item3
+1) (integer) 1
+2) (integer) 1
+3) (integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Determines whether a field exists in a hash.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HEXISTS
+since: 2.0.0
+summary: Determines whether a field exists in a hash.
+syntax_fmt: HEXISTS key field
+syntax_str: field
+title: HEXISTS
+---
+Returns if `field` is an existing field in the hash stored at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+HSET myhash field1 "foo"
+HEXISTS myhash field1
+HEXISTS myhash field2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: dst
+  key_spec_index: 0
+  name: dst
+  type: key
+- display_text: src
+  key_spec_index: 1
+  name: src
+  type: key
+- display_text: min
+  name: min
+  type: string
+- display_text: max
+  name: max
+  type: string
+- arguments:
+  - display_text: byscore
+    name: byscore
+    token: BYSCORE
+    type: pure-token
+  - display_text: bylex
+    name: bylex
+    token: BYLEX
+    type: pure-token
+  name: sortby
+  optional: true
+  type: oneof
+- display_text: rev
+  name: rev
+  optional: true
+  token: REV
+  type: pure-token
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements stored into the destination key.
+description: Stores a range of members from sorted set in a key.
+group: sorted-set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANGESTORE
+since: 6.2.0
+summary: Stores a range of members from sorted set in a key.
+syntax_fmt: "ZRANGESTORE dst src min max [BYSCORE | BYLEX] [REV] [LIMIT\_offset\n\
+  \  count]"
+syntax_str: "src min max [BYSCORE | BYLEX] [REV] [LIMIT\_offset count]"
+title: ZRANGESTORE
+---
+This command is like [`ZRANGE`]({{< relref "/commands/zrange" >}}), but stores the result in the `<dst>` destination key.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD srczset 1 "one" 2 "two" 3 "three" 4 "four"
+ZRANGESTORE dstzset srczset 2 -1
+ZRANGE dstzset 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: value
+  name: value
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+deprecated_since: 2.6.12
+description: Set the string value of a key only when the key doesn't exist.
+doc_flags:
+- deprecated
+group: string
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: SETNX
+replaced_by: '[`SET`]({{< relref "/commands/set" >}}) with the `NX` argument'
+since: 1.0.0
+summary: Set the string value of a key only when the key doesn't exist.
+syntax_fmt: SETNX key value
+syntax_str: value
+title: SETNX
+---
+Set `key` to hold string `value` if `key` does not exist.
+In that case, it is equal to [`SET`]({{< relref "/commands/set" >}}).
+When `key` already holds a value, no operation is performed.
+`SETNX` is short for "**SET** if **N**ot e**X**ists".
+
+## Examples
+
+{{% redis-cli %}}
+SETNX mykey "Hello"
+SETNX mykey "World"
+GET mykey
+{{% /redis-cli %}}
+
+
+## Design pattern: Locking with `SETNX`
+
+**Please note that:**
+
+1. The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/use/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant.
+2. We document the old pattern anyway because certain existing implementations link to this page as a reference. Moreover it is an interesting example of how Redis commands can be used in order to mount programming primitives.
+3. Anyway even assuming a single-instance locking primitive, starting with 2.6.12 it is possible to create a much simpler locking primitive, equivalent to the one discussed here, using the [`SET`]({{< relref "/commands/set" >}}) command to acquire the lock, and a simple Lua script to release the lock. The pattern is documented in the [`SET`]({{< relref "/commands/set" >}}) command page.
+
+That said, `SETNX` can be used, and was historically used, as a locking primitive. For example, to acquire the lock of the key `foo`, the client could try the
+following:
+
+```
+SETNX lock.foo <current Unix time + lock timeout + 1>
+```
+
+If `SETNX` returns `1` the client acquired the lock, setting the `lock.foo` key
+to the Unix time at which the lock should no longer be considered valid.
+The client will later use `DEL lock.foo` in order to release the lock.
+
+If `SETNX` returns `0` the key is already locked by some other client.
+We can either return to the caller if it's a non blocking lock, or enter a loop
+retrying to hold the lock until we succeed or some kind of timeout expires.
+
+### Handling deadlocks
+
+In the above locking algorithm there is a problem: what happens if a client
+fails, crashes, or is otherwise not able to release the lock?
+It's possible to detect this condition because the lock key contains a UNIX
+timestamp.
+If such a timestamp is equal to the current Unix time the lock is no longer
+valid.
+
+When this happens we can't just call [`DEL`]({{< relref "/commands/del" >}}) against the key to remove the lock
+and then try to issue a `SETNX`, as there is a race condition here, when
+multiple clients detected an expired lock and are trying to release it.
+
+* C1 and C2 read `lock.foo` to check the timestamp, because they both received
+  `0` after executing `SETNX`, as the lock is still held by C3 that crashed
+  after holding the lock.
+* C1 sends `DEL lock.foo`
+* C1 sends `SETNX lock.foo` and it succeeds
+* C2 sends `DEL lock.foo`
+* C2 sends `SETNX lock.foo` and it succeeds
+* **ERROR**: both C1 and C2 acquired the lock because of the race condition.
+
+Fortunately, it's possible to avoid this issue using the following algorithm.
+Let's see how C4, our sane client, uses the good algorithm:
+
+*   C4 sends `SETNX lock.foo` in order to acquire the lock
+
+*   The crashed client C3 still holds it, so Redis will reply with `0` to C4.
+
+*   C4 sends `GET lock.foo` to check if the lock expired.
+    If it is not, it will sleep for some time and retry from the start.
+
+*   Instead, if the lock is expired because the Unix time at `lock.foo` is older
+    than the current Unix time, C4 tries to perform:
+
+    ```
+    GETSET lock.foo <current Unix timestamp + lock timeout + 1>
+    ```
+
+*   Because of the [`GETSET`]({{< relref "/commands/getset" >}}) semantic, C4 can check if the old value stored at
+    `key` is still an expired timestamp.
+    If it is, the lock was acquired.
+
+*   If another client, for instance C5, was faster than C4 and acquired the lock
+    with the [`GETSET`]({{< relref "/commands/getset" >}}) operation, the C4 [`GETSET`]({{< relref "/commands/getset" >}}) operation will return a non
+    expired timestamp.
+    C4 will simply restart from the first step.
+    Note that even if C4 set the key a bit a few seconds in the future this is
+    not a problem.
+
+In order to make this locking algorithm more robust, a
+client holding a lock should always check the timeout didn't expire before
+unlocking the key with [`DEL`]({{< relref "/commands/del" >}}) because client failures can be complex, not just
+crashing but also blocking a lot of time against some operations and trying
+to issue [`DEL`]({{< relref "/commands/del" >}}) after a lot of time (when the LOCK is already held by another
+client).
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the string value of a key.
+group: string
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GET
+since: 1.0.0
+summary: Returns the string value of a key.
+syntax_fmt: GET key
+syntax_str: ''
+title: GET
+---
+Get the value of `key`.
+If the key does not exist the special value `nil` is returned.
+An error is returned if the value stored at `key` is not a string, because `GET`
+only handles string values.
+
+## Examples
+
+{{% redis-cli %}}
+GET nonexisting
+SET mykey "Hello"
+GET mykey
+{{% /redis-cli %}}
+
+
+### Code examples
+
+{{< clients-example set_and_get />}}
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: fromTimestamp
+  type: string
+- name: toTimestamp
+  type: string
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+- multiple: true
+  name: Timestamp
+  optional: true
+  token: FILTER_BY_TS
+  type: integer
+- arguments:
+  - name: FILTER_BY_VALUE
+    token: FILTER_BY_VALUE
+    type: pure-token
+  - name: min
+    type: double
+  - name: max
+    type: double
+  name: fbv
+  optional: true
+  type: block
+- name: count
+  optional: true
+  token: COUNT
+  type: integer
+- arguments:
+  - name: value
+    optional: true
+    token: ALIGN
+    type: integer
+  - arguments:
+    - name: avg
+      token: AVG
+      type: pure-token
+    - name: first
+      token: FIRST
+      type: pure-token
+    - name: last
+      token: LAST
+      type: pure-token
+    - name: min
+      token: MIN
+      type: pure-token
+    - name: max
+      token: MAX
+      type: pure-token
+    - name: sum
+      token: SUM
+      type: pure-token
+    - name: range
+      token: RANGE
+      type: pure-token
+    - name: count
+      token: COUNT
+      type: pure-token
+    - name: std.p
+      token: STD.P
+      type: pure-token
+    - name: std.s
+      token: STD.S
+      type: pure-token
+    - name: var.p
+      token: VAR.P
+      type: pure-token
+    - name: var.s
+      token: VAR.S
+      type: pure-token
+    - name: twa
+      since: 1.8.0
+      token: TWA
+      type: pure-token
+    name: aggregator
+    token: AGGREGATION
+    type: oneof
+  - name: bucketDuration
+    type: integer
+  - name: buckettimestamp
+    optional: true
+    since: 1.8.0
+    token: BUCKETTIMESTAMP
+    type: pure-token
+  - name: empty
+    optional: true
+    since: 1.8.0
+    token: EMPTY
+    type: pure-token
+  name: aggregation
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n/m+k) where n = Number of data points, m = Chunk size (data points
+  per chunk), k = Number of data points that are in the requested range
+description: Query a range in forward direction
+group: timeseries
+hidden: false
+linkTitle: TS.RANGE
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Query a range in forward direction
+syntax: "TS.RANGE key fromTimestamp toTimestamp\n  [LATEST]\n  [FILTER_BY_TS ts...]\n\
+  \  [FILTER_BY_VALUE min max]\n  [COUNT count] \n  [[ALIGN align] AGGREGATION aggregator\
+  \ bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]\n"
+syntax_fmt: "TS.RANGE key fromTimestamp toTimestamp [LATEST]\n  [FILTER_BY_TS\_Timestamp\
+  \ [Timestamp ...]] [FILTER_BY_VALUE min max]\n  [COUNT\_count] [[ALIGN\_value] AGGREGATION\_\
+  <AVG | FIRST | LAST | MIN\n  | MAX | SUM | RANGE | COUNT | STD.P | STD.S | VAR.P\
+  \ | VAR.S | TWA>\n  bucketDuration [BUCKETTIMESTAMP] [EMPTY]]"
+syntax_str: "fromTimestamp toTimestamp [LATEST] [FILTER_BY_TS\_Timestamp [Timestamp\
+  \ ...]] [FILTER_BY_VALUE min max] [COUNT\_count] [[ALIGN\_value] AGGREGATION\_<AVG\
+  \ | FIRST | LAST | MIN | MAX | SUM | RANGE | COUNT | STD.P | STD.S | VAR.P | VAR.S\
+  \ | TWA> bucketDuration [BUCKETTIMESTAMP] [EMPTY]]"
+title: TS.RANGE
+---
+
+Query a range in forward direction
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary> 
+
+is the key name for the time series.
+</details>
+
+<details open>
+<summary><code>fromTimestamp</code></summary> 
+
+is start timestamp for the range query (integer Unix timestamp in milliseconds) or `-` to denote the timestamp of the earliest sample in the time series.
+</details>
+
+<details open>
+<summary><code>toTimestamp</code></summary> 
+
+is end timestamp for the range query (integer Unix timestamp in milliseconds) or `+` to denote the timestamp of the latest sample in the time series.
+
+<note><b>Note:</b>    When the time series is a compaction, the last compacted value may aggregate raw values with timestamp beyond `toTimestamp`. That is because `toTimestamp` only limits the timestamp of the compacted value, which is the start time of the raw bucket that was compacted.</note>
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary>
+
+is used when a time series is a compaction. With `LATEST`, TS.RANGE also reports the compacted value of the latest, possibly partial, bucket, given that this bucket's start time falls within `[fromTimestamp, toTimestamp]`. Without `LATEST`, TS.RANGE does not report the latest, possibly partial, bucket. When a time series is not a compaction, `LATEST` is ignored.
+  
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest, possibly partial, bucket is also required. In such a case, use `LATEST`.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_TS ts...</code> (since RedisTimeSeries v1.6)</summary> 
+
+filters samples by a list of specific timestamps. A sample passes the filter if its exact timestamp is specified and falls within `[fromTimestamp, toTimestamp]`.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_VALUE min max</code> (since RedisTimeSeries v1.6)</summary> 
+
+filters samples by minimum and maximum values.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>COUNT count</code></summary> 
+
+When used without `AGGREGATION`: limits the number of reported samples.
+
+When used together with `AGGREGATION`: limits the number of reported buckets.
+</details>
+
+<details open>
+<summary><code>ALIGN align</code> (since RedisTimeSeries v1.6)</summary> 
+
+is a time bucket alignment control for `AGGREGATION`. It controls the time bucket timestamps by changing the reference timestamp on which a bucket is defined.
+
+`align` values include:
+   
+ - `start` or `-`: The reference timestamp will be the query start interval time (`fromTimestamp`) which can't be `-`
+ - `end` or `+`: The reference timestamp will be the query end interval time (`toTimestamp`) which can't be `+`
+ - A specific timestamp: align the reference timestamp to a specific time
+   
+<note><b>Note:</b> When not provided, alignment is set to `0`.</note>
+</details>
+
+<details open>
+<summary><code>AGGREGATION aggregator bucketDuration</code></summary> 
+
+aggregates samples into time buckets, where:
+
+  - `aggregator` takes one of the following aggregation types:
+
+    | `aggregator` | Description                                                                    |
+    | ------------ | ------------------------------------------------------------------------------ |
+    | `avg`        | Arithmetic mean of all values                                                  |
+    | `sum`        | Sum of all values                                                              |
+    | `min`        | Minimum value                                                                  |
+    | `max`        | Maximum value                                                                  |
+    | `range`      | Difference between the maximum and the minimum value                           |
+    | `count`      | Number of values                                                               |
+    | `first`      | Value with lowest timestamp in the bucket                                      |
+    | `last`       | Value with highest timestamp in the bucket                                     |
+    | `std.p`      | Population standard deviation of the values                                    |
+    | `std.s`      | Sample standard deviation of the values                                        |
+    | `var.p`      | Population variance of the values                                              |
+    | `var.s`      | Sample variance of the values                                                  |
+    | `twa`        | Time-weighted average over the bucket's timeframe (since RedisTimeSeries v1.8) |
+
+  - `bucketDuration` is duration of each bucket, in milliseconds.
+  
+  Without `ALIGN`, bucket start times are multiples of `bucketDuration`.
+  
+  With `ALIGN align`, bucket start times are multiples of `bucketDuration` with remainder `align % bucketDuration`.
+  
+  The first bucket start time is less than or equal to `fromTimestamp`.
+</details>
+
+<details open>
+<summary><code>[BUCKETTIMESTAMP bt]</code> (since RedisTimeSeries v1.8)</summary> 
+
+controls how bucket timestamps are reported.
+
+| `bt`             | Timestamp reported for each bucket                            |
+| ---------------- | ------------------------------------------------------------- |
+| `-` or `start`   | the bucket's start time (default)                             |
+| `+` or `end`     | the bucket's end time                                         |
+| `~` or `mid`     | the bucket's mid time (rounded down if not an integer)        |
+</details>
+
+<details open>
+<summary><code>[EMPTY]</code> (since RedisTimeSeries v1.8)</summary> 
+
+is a flag, which, when specified, reports aggregations also for empty buckets.
+
+| `aggregator`         | Value reported for each empty bucket |
+| -------------------- | ------------------------------------ |
+| `sum`, `count`       | `0`                                  |
+| `last`               | The value of the last sample before the bucket's start. `NaN` when no such sample. |
+| `twa`                | Average value over the bucket's timeframe based on linear interpolation of the last sample before the bucket's start and the first sample after the bucket's end. `NaN` when no such samples. |
+| `min`, `max`, `range`, `avg`, `first`, `std.p`, `std.s` | `NaN` |
+
+Regardless of the values of `fromTimestamp` and `toTimestamp`, no data is reported for buckets that end before the earliest sample or begin after the latest sample in the time series.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})) pairs representing (timestamp, value(double))
+- [] (e.g., on invalid filter value)
+
+## Complexity
+
+TS.RANGE complexity can be improved in the future by using binary search to find the start of the range, which makes this `O(Log(n/m)+k*m)`.
+But, because `m` is small, you can disregard it and look at the operation as `O(Log(n)+k)`.
+
+## Examples
+
+<details open><summary><b>Filter results by timestamp or sample value</b></summary>
+
+Consider a metric where acceptable values are between -100 and 100, and the value 9999 is used as an indication of bad measurement.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+127.0.0.1:6379> TS.MADD temp:TLV 1000 30 temp:TLV 1010 35 temp:TLV 1020 9999 temp:TLV 1030 40
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+4) (integer) 1030
+{{< / highlight >}}
+
+Now, retrieve all values except out-of-range values.
+
+{{< highlight bash >}}
+TS.RANGE temp:TLV - + FILTER_BY_VALUE -100 100
+1) 1) (integer) 1000
+   2) 30
+2) 1) (integer) 1010
+   2) 35
+3) 1) (integer) 1030
+   2) 40
+{{< / highlight >}}
+
+Now, retrieve the average value, while ignoring out-of-range values.
+
+{{< highlight bash >}}
+TS.RANGE temp:TLV - + FILTER_BY_VALUE -100 100 AGGREGATION avg 1000
+1) 1) (integer) 1000
+   2) 35
+{{< / highlight >}}
+</details>
+
+<details open><summary><b>Align aggregation buckets</b></summary>
+
+To demonstrate alignment, let’s create a stock and add prices at nine different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:A 2000 200 stock:A 2010 210 stock:A 2020 220
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:A 3000 300 stock:A 3010 310 stock:A 3020 320
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+{{< / highlight >}}
+
+Next, aggregate without using `ALIGN`, defaulting to alignment 0.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.RANGE stock:A - + AGGREGATION min 20
+1) 1) (integer) 1000
+   2) 100
+2) 1) (integer) 1020
+   2) 120
+3) 1) (integer) 1040
+   2) 210
+4) 1) (integer) 1060
+   2) 300
+5) 1) (integer) 1080
+   2) 320
+{{< / highlight >}}
+
+And now set `ALIGN` to 10 to have a bucket start at time 10, and align all the buckets with a 20 milliseconds duration.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.RANGE stock:A - + ALIGN 10 AGGREGATION min 20
+1) 1) (integer) 990
+   2) 100
+2) 1) (integer) 1010
+   2) 110
+3) 1) (integer) 1990
+   2) 200
+4) 1) (integer) 2010
+   2) 210
+5) 1) (integer) 2990
+   2) 300
+6) 1) (integer) 3010
+   2) 310
+{{< / highlight >}}
+
+When the start timestamp for the range query is explicitly stated (not `-`), you can set `ALIGN` to that time by setting align to `-` or to `start`.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.RANGE stock:A 5 + ALIGN - AGGREGATION min 20
+1) 1) (integer) 985
+   2) 100
+2) 1) (integer) 1005
+   2) 110
+3) 1) (integer) 1985
+   2) 200
+4) 1) (integer) 2005
+   2) 210
+5) 1) (integer) 2985
+   2) 300
+6) 1) (integer) 3005
+   2) 310
+{{< / highlight >}}
+
+Similarly, when the end timestamp for the range query is explicitly stated, you can set `ALIGN` to that time by setting align to `+` or to `end`.
+</details>
+
+## See also
+
+[`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.REVRANGE`]({{< relref "commands/ts.revrange/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@read'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: index
+  name: index
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the number of elements to traverse to get to the element
+  at index. This makes asking for the first or the last element of the list O(1).
+description: Returns an element from a list by its index.
+group: list
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LINDEX
+since: 1.0.0
+summary: Returns an element from a list by its index.
+syntax_fmt: LINDEX key index
+syntax_str: index
+title: LINDEX
+---
+Returns the element at index `index` in the list stored at `key`.
+The index is zero-based, so `0` means the first element, `1` the second element
+and so on.
+Negative indices can be used to designate elements starting at the tail of the
+list.
+Here, `-1` means the last element, `-2` means the penultimate and so forth.
+
+When the value at `key` is not a list, an error is returned.
+
+## Examples
+
+{{% redis-cli %}}
+LPUSH mylist "World"
+LPUSH mylist "Hello"
+LINDEX mylist 0
+LINDEX mylist -1
+LINDEX mylist 3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: limit
+  name: limit
+  optional: true
+  token: LIMIT
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(N*K) worst case with N being the smallest input sorted set, K being
+  the number of input sorted sets.
+description: Returns the number of members of the intersect of multiple sorted sets.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZINTERCARD
+since: 7.0.0
+summary: Returns the number of members of the intersect of multiple sorted sets.
+syntax_fmt: "ZINTERCARD numkeys key [key ...] [LIMIT\_limit]"
+syntax_str: "key [key ...] [LIMIT\_limit]"
+title: ZINTERCARD
+---
+This command is similar to [`ZINTER`]({{< relref "/commands/zinter" >}}), but instead of returning the result set, it returns just the cardinality of the result.
+
+Keys that do not exist are considered to be empty sets.
+With one of the keys being an empty set, the resulting set is also empty (since set intersection with an empty set always results in an empty set).
+
+By default, the command calculates the cardinality of the intersection of all given sets.
+When provided with the optional `LIMIT` argument (which defaults to 0 and means unlimited), if the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality.
+Such implementation ensures a significant speedup for queries where the limit is lower than the actual intersection cardinality.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZADD zset2 3 "three"
+ZINTER 2 zset1 zset2
+ZINTERCARD 2 zset1 zset2
+ZINTERCARD 2 zset1 zset2 LIMIT 1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+- arguments:
+  - name: WITHLABELS
+    token: WITHLABELS
+    type: pure-token
+  - arguments:
+    - name: SELECTED_LABELS
+      token: SELECTED_LABELS
+      type: pure-token
+    - multiple: true
+      name: label1
+      type: string
+    name: SELECTED_LABELS_BLOCK
+    type: block
+  name: labels
+  optional: true
+  type: oneof
+- arguments:
+  - name: l=v
+    type: string
+  - name: l!=v
+    type: string
+  - name: l=
+    type: string
+  - name: l!=
+    type: string
+  - name: l=(v1,v2,...)
+    type: string
+  - name: l!=(v1,v2,...)
+    type: string
+  multiple: true
+  name: filterExpr
+  token: FILTER
+  type: oneof
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of time-series that match the filters
+description: Get the sample with the highest timestamp from each time series matching
+  a specific filter
+group: timeseries
+hidden: false
+linkTitle: TS.MGET
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Get the sample with the highest timestamp from each time series matching
+  a specific filter
+syntax: 'TS.MGET [LATEST] [WITHLABELS | <SELECTED_LABELS label...>] FILTER filterExpr...
+
+  '
+syntax_fmt: "TS.MGET [LATEST] [WITHLABELS | <SELECTED_LABELS label1 [label1 ...]>]\n\
+  \  FILTER\_<l=v | l!=v | l= | l!= | l=(v1,v2,...) | l!=(v1,v2,...)\n  [l=v | l!=v\
+  \ | l= | l!= | l=(v1,v2,...) | l!=(v1,v2,...) ...]>"
+syntax_str: "[WITHLABELS | <SELECTED_LABELS label1 [label1 ...]>] FILTER\_<l=v | l!=v\
+  \ | l= | l!= | l=(v1,v2,...) | l!=(v1,v2,...) [l=v | l!=v | l= | l!= | l=(v1,v2,...)\
+  \ | l!=(v1,v2,...) ...]>"
+title: TS.MGET
+---
+
+Get the sample with the highest timestamp from each time series matching a specific filter.
+
+{{< note >}}
+This command will reply only if the current user has read access to all keys that match the filter.
+Otherwise, it will reply with "*(error): current user doesn't have read permission to one or more keys that match the specified filter*".
+{{< /note >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>FILTER filterExpr...</code></summary>
+
+filters time series based on their labels and label values. Each filter expression has one of the following syntaxes:
+
+  - `label!=` - the time series has a label named `label`
+  - `label=value` - the time series has a label named `label` with a value equal to `value`
+  - `label=(value1,value2,...)` - the time series has a label named `label` with a value equal to one of the values in the list
+  - `label=` - the time series does not have a label named `label`
+  - `label!=value` - the time series does not have a label named `label` with a value equal to `value`
+  - `label!=(value1,value2,...)` - the time series does not have a label named `label` with a value equal to any of the values in the list
+
+  <note><b>Notes:</b>
+   - At least one filter expression with a syntax `label=value` or `label=(value1,value2,...)` is required.
+   - Filter expressions are conjunctive. For example, the filter `type=temperature room=study` means that a time series is a temperature time series of a study room.
+   - Whitespaces are unallowed in a filter expression except between quotes or double quotes in values - e.g., `x="y y"` or `x='(y y,z z)'`.
+   </note>
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary> 
+
+is used when a time series is a compaction. With `LATEST`, TS.MGET also reports the compacted value of the latest (possibly partial) bucket, given that this bucket's start time falls within `[fromTimestamp, toTimestamp]`. Without `LATEST`, TS.MGET does not report the latest (possibly partial) bucket. When a time series is not a compaction, `LATEST` is ignored.
+  
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon the arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest (possibly partial) bucket is also required. In such a case, use `LATEST`.
+</details>
+
+<details open>
+<summary><code>WITHLABELS</code></summary> 
+
+includes in the reply all label-value pairs representing metadata labels of the time series. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+
+</details>
+
+<details open>
+<summary><code>SELECTED_LABELS label...</code> (since RedisTimeSeries v1.6)</summary> 
+
+returns a subset of the label-value pairs that represent metadata labels of the time series. 
+Use when a large number of labels exists per series, but only the values of some of the labels are required. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+
+</details>
+
+<note><b>Note:</b> The [`MGET`]({{< relref "/commands/mget" >}}) command cannot be part of a transaction when running on a Redis cluster.</note>
+
+## Return value
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): for each time series matching the specified filters, the following is reported:
+  - bulk-string-reply: The time series key name
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): label-value pairs ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}))
+    - By default, an empty array is reported
+    - If `WITHLABELS` is specified, all labels associated with this time series are reported
+    - If `SELECTED_LABELS label...` is specified, the selected labels are reported (null value when no such label defined)
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single timestamp-value pair ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) (double))
+
+## Examples
+
+<details open>
+<summary><b>Select labels to retrieve</b></summary>
+
+Create time series for temperature in Tel Aviv and Jerusalem, then add different temperature samples.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+127.0.0.1:6379> TS.CREATE temp:JLM LABELS type temp location JLM
+OK
+127.0.0.1:6379> TS.MADD temp:TLV 1000 30 temp:TLV 1010 35 temp:TLV 1020 9999 temp:TLV 1030 40
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+4) (integer) 1030
+127.0.0.1:6379> TS.MADD temp:JLM 1005 30 temp:JLM 1015 35 temp:JLM 1025 9999 temp:JLM 1035 40
+1) (integer) 1005
+2) (integer) 1015
+3) (integer) 1025
+4) (integer) 1035
+{{< / highlight >}}
+
+Get all the labels associated with the last sample.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MGET WITHLABELS FILTER type=temp
+1) 1) "temp:JLM"
+   2) 1) 1) "type"
+         2) "temp"
+      2) 1) "location"
+         2) "JLM"
+   3) 1) (integer) 1035
+      2) 40
+2) 1) "temp:TLV"
+   2) 1) 1) "type"
+         2) "temp"
+      2) 1) "location"
+         2) "TLV"
+   3) 1) (integer) 1030
+      2) 40
+{{< / highlight >}}
+
+To get only the `location` label for each last sample, use `SELECTED_LABELS`.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MGET SELECTED_LABELS location FILTER type=temp
+1) 1) "temp:JLM"
+   2) 1) 1) "location"
+         2) "JLM"
+   3) 1) (integer) 1035
+      2) 40
+2) 1) "temp:TLV"
+   2) 1) 1) "location"
+         2) "TLV"
+   3) 1) (integer) 1030
+      2) 40
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) | [`TS.REVRANGE`]({{< relref "commands/ts.revrange/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: quantile
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of quantiles specified.
+description: Returns, for each input fraction, an estimation of the value (floating
+  point) that is smaller than the given fraction of observations
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.QUANTILE
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input fraction, an estimation of the value (floating point)
+  that is smaller than the given fraction of observations
+syntax_fmt: TDIGEST.QUANTILE key quantile [quantile ...]
+syntax_str: quantile [quantile ...]
+title: TDIGEST.QUANTILE
+---
+Returns, for each input fraction, an estimation of the value (floating point) that is smaller than the given fraction of observations.
+
+Multiple quantiles can be retrieved in a single call.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>quantile</code></summary> 
+is the input fraction (between 0 and 1 inclusively)
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - an array of estimates (floating-point) populated with value_1, value_2, ..., value_N.
+
+- Return an accurate result when `quantile` is 0 (the value of the smallest observation)
+- Return an accurate result when `quantile` is 1 (the value of the largest observation)
+
+All values are 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 1000
+OK
+redis> TDIGEST.ADD t 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
+OK
+redis> TDIGEST.QUANTILE t 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
+ 1) "1"
+ 2) "2"
+ 3) "3"
+ 4) "3"
+ 5) "4"
+ 6) "4"
+ 7) "4"
+ 8) "5"
+ 9) "5"
+10) "5"
+11) "5"
+
+{{< / highlight >}}
+---
+acl_categories:
+- '@search'
+- '@write'
+arguments:
+- name: key
+  type: string
+- name: string
+  type: string
+- name: score
+  type: double
+- arguments:
+  - name: incr
+    token: INCR
+    type: pure-token
+  name: increment score
+  optional: true
+  type: oneof
+- name: payload
+  optional: true
+  token: PAYLOAD
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Adds a suggestion string to an auto-complete suggestion dictionary
+group: suggestion
+hidden: false
+linkTitle: FT.SUGADD
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Adds a suggestion string to an auto-complete suggestion dictionary
+syntax: "FT.SUGADD key string score \n  [INCR] \n  [PAYLOAD payload]\n"
+syntax_fmt: "FT.SUGADD key string score [INCR] [PAYLOAD\_payload]"
+syntax_str: "string score [INCR] [PAYLOAD\_payload]"
+title: FT.SUGADD
+---
+
+Add a suggestion string to an auto-complete suggestion dictionary
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is suggestion dictionary key.
+</details>
+
+<details open>
+<summary><code>string</code></summary> 
+
+is suggestion string to index.
+</details>
+
+<details open>
+<summary><code>score</code></summary> 
+
+is floating point number of the suggestion string's weight.
+</details>
+
+The auto-complete suggestion dictionary is disconnected from the index definitions and leaves creating and updating suggestions dictionaries to the user.
+
+## Optional arguments
+
+<details open>
+<summary><code>INCR</code></summary> 
+
+increments the existing entry of the suggestion by the given score, instead of replacing the score. This is useful for updating the dictionary based on user queries in real time.
+</details>
+
+<details open>
+<summary><code>PAYLOAD {payload}</code></summary> 
+
+saves an extra payload with the suggestion, that can be fetched by adding the `WITHPAYLOADS` argument to [`FT.SUGGET`]({{< relref "commands/ft.sugget/" >}}).
+</details>
+
+## Return
+
+FT.SUGADD returns an integer reply, which is the current size of the suggestion dictionary.
+
+## Examples
+
+<details open>
+<summary><b>Add a suggestion string to an auto-complete suggestion dictionary</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SUGADD sug "hello world" 1
+(integer) 3
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SUGGET`]({{< relref "commands/ft.sugget/" >}}) | [`FT.SUGDEL`]({{< relref "commands/ft.sugdel/" >}}) | [`FT.SUGLEN`]({{< relref "commands/ft.suglen/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: node-id
+  name: node-id
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+complexity: O(N) where N is the number of failure reports
+description: Returns the number of active failure reports active for a node.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER COUNT-FAILURE-REPORTS
+since: 3.0.0
+summary: Returns the number of active failure reports active for a node.
+syntax_fmt: CLUSTER COUNT-FAILURE-REPORTS node-id
+syntax_str: ''
+title: CLUSTER COUNT-FAILURE-REPORTS
+---
+The command returns the number of *failure reports* for the specified node.
+Failure reports are the way Redis Cluster uses in order to promote a
+`PFAIL` state, that means a node is not reachable, to a `FAIL` state,
+that means that the majority of masters in the cluster agreed within
+a window of time that the node is not reachable.
+
+A few more details:
+
+* A node flags another node with `PFAIL` when the node is not reachable for a time greater than the configured *node timeout*, which is a fundamental configuration parameter of a Redis Cluster.
+* Nodes in `PFAIL` state are provided in gossip sections of heartbeat packets.
+* Every time a node processes gossip packets from other nodes, it creates (and refreshes the TTL if needed) **failure reports**, remembering that a given node said another given node is in `PFAIL` condition.
+* Each failure report has a time to live of two times the *node timeout* time.
+* If at a given time a node has another node flagged with `PFAIL`, and at the same time collected the majority of other master nodes *failure reports* about this node (including itself if it is a master), then it elevates the failure state of the node from `PFAIL` to `FAIL`, and broadcasts a message forcing all the nodes that can be reached to flag the node as `FAIL`.
+
+This command returns the number of failure reports for the current node which are currently not expired (so received within two times the *node timeout* time). The count does not include what the node we are asking this count believes about the node ID we pass as argument, the count *only* includes the failure reports the node received from other nodes.
+
+This command is mainly useful for debugging, when the failure detector of
+Redis Cluster is not operating as we believe it should.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the total number of Cluster nodes
+deprecated_since: 7.0.0
+description: Returns the mapping of cluster slots to nodes.
+doc_flags:
+- deprecated
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 4.0.0
+  - Added node IDs.
+- - 7.0.0
+  - Added additional networking metadata field.
+linkTitle: CLUSTER SLOTS
+replaced_by: '[`CLUSTER SHARDS`]({{< relref "/commands/cluster-shards" >}})'
+since: 3.0.0
+summary: Returns the mapping of cluster slots to nodes.
+syntax_fmt: CLUSTER SLOTS
+syntax_str: ''
+title: CLUSTER SLOTS
+---
+`CLUSTER SLOTS` returns details about which cluster slots map to which Redis instances. 
+The command is suitable to be used by Redis Cluster client libraries implementations in order to retrieve (or update when a redirection is received) the map associating cluster *hash slots* with actual nodes network information, so that when a command is received, it can be sent to what is likely the right instance for the keys specified in the command. 
+
+The networking information for each node is an array containing the following elements:
+
+* Preferred endpoint (Either an IP address, hostname, or NULL)
+* Port number
+* The node ID
+* A map of additional networking metadata
+
+The preferred endpoint, along with the port, defines the location that clients should use to send requests for a given slot.
+A NULL value for the endpoint indicates the node has an unknown endpoint and the client should connect to the same endpoint it used to send the `CLUSTER SLOTS` command but with the port returned from the command.
+This unknown endpoint configuration is useful when the Redis nodes are behind a load balancer that Redis doesn't know the endpoint of.
+Which endpoint is set as preferred is determined by the `cluster-preferred-endpoint-type` config.
+An empty string `""` is another abnormal value of the endpoint field, as well as for the ip field, which is returned if the node doesn't know its own IP address.
+This can happen in a cluster that consists of only one node or the node has not yet been joined with the rest of the cluster.
+The value `?` is displayed if the node is incorrectly configured to use announced hostnames but no hostname is configured using `cluster-announce-hostname`.
+Clients may treat the empty string in the same way as NULL, that is the same endpoint it used to send the current command to, while `"?"` should be treated as an unknown node, not necessarily the same node as the one serving the current command.
+
+Additional networking metadata is provided as a map on the fourth argument for each node. 
+The following networking metadata may be returned:
+
+* IP: When the preferred endpoint is not set to IP.
+* Hostname: When a node has an announced hostname but the primary endpoint is not set to hostname.
+
+## Nested Result Array
+Each nested result is:
+
+  - Start slot range
+  - End slot range
+  - Master for slot range represented as nested networking information
+  - First replica of master for slot range
+  - Second replica
+  - ...continues until all replicas for this master are returned.
+
+Each result includes all active replicas of the master instance
+for the listed slot range.  Failed replicas are not returned.
+
+The third nested reply is guaranteed to be the networking information of the master instance for the slot range.
+All networking information after the third nested reply are replicas of the master.
+
+If a cluster instance has non-contiguous slots (e.g. 1-400,900,1800-6000) then master and replica networking information results will be duplicated for each top-level slot range reply.
+
+```
+> CLUSTER SLOTS
+1) 1) (integer) 0
+   2) (integer) 5460
+   3) 1) "127.0.0.1"
+      2) (integer) 30001
+      3) "09dbe9720cda62f7865eabc5fd8857c5d2678366"
+      4) 1) hostname
+         2) "host-1.redis.example.com"
+   4) 1) "127.0.0.1"
+      2) (integer) 30004
+      3) "821d8ca00d7ccf931ed3ffc7e3db0599d2271abf"
+      4) 1) hostname
+         2) "host-2.redis.example.com"
+2) 1) (integer) 5461
+   2) (integer) 10922
+   3) 1) "127.0.0.1"
+      2) (integer) 30002
+      3) "c9d93d9f2c0c524ff34cc11838c2003d8c29e013"
+      4) 1) hostname
+         2) "host-3.redis.example.com"
+   4) 1) "127.0.0.1"
+      2) (integer) 30005
+      3) "faadb3eb99009de4ab72ad6b6ed87634c7ee410f"
+      4) 1) hostname
+         2) "host-4.redis.example.com"
+3) 1) (integer) 10923
+   2) (integer) 16383
+   3) 1) "127.0.0.1"
+      2) (integer) 30003
+      3) "044ec91f325b7595e76dbcb18cc688b6a5b434a1"
+      4) 1) hostname
+         2) "host-5.redis.example.com"
+   4) 1) "127.0.0.1"
+      2) (integer) 30006
+      3) "58e6e48d41228013e5d9c1c37c5060693925e97e"
+      4) 1) hostname
+         2) "host-6.redis.example.com"
+```
+
+**Warning:** In future versions there could be more elements describing the node better.
+In general a client implementation should just rely on the fact that certain parameters are at fixed positions as specified, but more parameters may follow and should be ignored.
+Similarly a client library should try if possible to cope with the fact that older versions may just have the primary endpoint and port parameter.
+
+## Behavior change history
+
+*   `>= 7.0.0`: Added support for hostnames and unknown endpoints in first field of node response.
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N*M) worst case where N is the cardinality of the smallest set and M
+  is the number of sets.
+description: Stores the intersect of multiple sets in a key.
+group: set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SINTERSTORE
+since: 1.0.0
+summary: Stores the intersect of multiple sets in a key.
+syntax_fmt: SINTERSTORE destination key [key ...]
+syntax_str: key [key ...]
+title: SINTERSTORE
+---
+This command is equal to [`SINTER`]({{< relref "/commands/sinter" >}}), but instead of returning the resulting set,
+it is stored in `destination`.
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SINTERSTORE key key1 key2
+SMEMBERS key
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- display_text: command-name
+  multiple: true
+  name: command-name
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the number of commands to look up
+description: Returns documentary information about one, multiple or all commands.
+group: server
+hidden: false
+hints:
+- nondeterministic_output_order
+linkTitle: COMMAND DOCS
+since: 7.0.0
+summary: Returns documentary information about one, multiple or all commands.
+syntax_fmt: COMMAND DOCS [command-name [command-name ...]]
+syntax_str: ''
+title: COMMAND DOCS
+---
+Return documentary information about commands.
+
+By default, the reply includes all of the server's commands.
+You can use the optional _command-name_ argument to specify the names of one or more commands.
+
+The reply includes a map for each returned command.
+The following keys may be included in the mapped reply:
+
+* **summary:** short command description.
+* **since:** the Redis version that added the command (or for module commands, the module version).
+* **group:** the functional group to which the command belongs.
+  Possible values are:
+  - _bitmap_
+  - _cluster_
+  - _connection_
+  - _generic_
+  - _geo_
+  - _hash_
+  - _hyperloglog_
+  - _list_
+  - _module_
+  - _pubsub_
+  - _scripting_
+  - _sentinel_
+  - _server_
+  - _set_
+  - _sorted-set_
+  - _stream_
+  - _string_
+  - _transactions_
+* **complexity:** a short explanation about the command's time complexity.
+* **doc_flags:** an array of documentation flags.
+  Possible values are:
+  - _deprecated:_ the command is deprecated.
+  - _syscmd:_ a system command that isn't meant to be called by users.
+* **deprecated_since:** the Redis version that deprecated the command (or for module commands, the module version)..
+* **replaced_by:** the alternative for a deprecated command.
+* **history:** an array of historical notes describing changes to the command's output or arguments. It should not contain information about behavioral changes.
+  Each entry is an array itself, made up of two elements:
+  1. The Redis version that the entry applies to.
+  2. The description of the change.
+* **arguments:** an array of maps that describe the command's arguments.
+  Please refer to the [Redis command arguments][td] page for more information.
+
+[td]: /develop/reference/command-arguments
+
+## Examples
+
+{{% redis-cli %}}
+COMMAND DOCS SET
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: wherefrom
+  type: oneof
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: whereto
+  type: oneof
+- display_text: timeout
+  name: timeout
+  type: double
+arity: 6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- blocking
+complexity: O(1)
+description: Pops an element from a list, pushes it to another list and returns it.
+  Blocks until an element is available otherwise. Deletes the list if the last element
+  was moved.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: BLMOVE
+since: 6.2.0
+summary: Pops an element from a list, pushes it to another list and returns it. Blocks
+  until an element is available otherwise. Deletes the list if the last element was
+  moved.
+syntax_fmt: BLMOVE source destination <LEFT | RIGHT> <LEFT | RIGHT> timeout
+syntax_str: destination <LEFT | RIGHT> <LEFT | RIGHT> timeout
+title: BLMOVE
+---
+`BLMOVE` is the blocking variant of [`LMOVE`]({{< relref "/commands/lmove" >}}).
+When `source` contains elements, this command behaves exactly like [`LMOVE`]({{< relref "/commands/lmove" >}}).
+When used inside a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) block, this command behaves exactly like [`LMOVE`]({{< relref "/commands/lmove" >}}).
+When `source` is empty, Redis will block the connection until another client
+pushes to it or until `timeout` (a double value specifying the maximum number of seconds to block) is reached.
+A `timeout` of zero can be used to block indefinitely.
+
+This command comes in place of the now deprecated [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}). Doing
+`BLMOVE RIGHT LEFT` is equivalent.
+
+See [`LMOVE`]({{< relref "/commands/lmove" >}}) for more information.
+
+## Pattern: Reliable queue
+
+Please see the pattern description in the [`LMOVE`]({{< relref "/commands/lmove" >}}) documentation.
+
+## Pattern: Circular list
+
+Please see the pattern description in the [`LMOVE`]({{< relref "/commands/lmove" >}}) documentation.
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: double
+- display_text: max
+  name: max
+  type: double
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(log(N)) with N being the number of elements in the sorted set.
+description: Returns the count of members in a sorted set that have scores within
+  a range.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZCOUNT
+since: 2.0.0
+summary: Returns the count of members in a sorted set that have scores within a range.
+syntax_fmt: ZCOUNT key min max
+syntax_str: min max
+title: ZCOUNT
+---
+Returns the number of elements in the sorted set at `key` with a score between
+`min` and `max`.
+
+The `min` and `max` arguments have the same semantic as described for
+[`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}}).
+
+Note: the command has a complexity of just O(log(N)) because it uses elements ranks (see [`ZRANK`]({{< relref "/commands/zrank" >}})) to get an idea of the range. Because of this there is no need to do a work proportional to the size of the range.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZCOUNT myzset -inf +inf
+ZCOUNT myzset (1 3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- name: fromTimestamp
+  type: string
+- name: toTimestamp
+  type: string
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+- multiple: true
+  name: Timestamp
+  optional: true
+  token: FILTER_BY_TS
+  type: integer
+- arguments:
+  - name: FILTER_BY_VALUE
+    token: FILTER_BY_VALUE
+    type: pure-token
+  - name: min
+    type: double
+  - name: max
+    type: double
+  name: fbv
+  optional: true
+  type: block
+- arguments:
+  - name: WITHLABELS
+    token: WITHLABELS
+    type: pure-token
+  - arguments:
+    - name: SELECTED_LABELS
+      token: SELECTED_LABELS
+      type: pure-token
+    - multiple: true
+      name: label1
+      type: string
+    name: SELECTED_LABELS_BLOCK
+    type: block
+  name: labels
+  optional: true
+  type: oneof
+- name: count
+  optional: true
+  token: COUNT
+  type: integer
+- arguments:
+  - name: value
+    optional: true
+    token: ALIGN
+    type: integer
+  - arguments:
+    - name: avg
+      token: AVG
+      type: pure-token
+    - name: first
+      token: FIRST
+      type: pure-token
+    - name: last
+      token: LAST
+      type: pure-token
+    - name: min
+      token: MIN
+      type: pure-token
+    - name: max
+      token: MAX
+      type: pure-token
+    - name: sum
+      token: SUM
+      type: pure-token
+    - name: range
+      token: RANGE
+      type: pure-token
+    - name: count
+      token: COUNT
+      type: pure-token
+    - name: std.p
+      token: STD.P
+      type: pure-token
+    - name: std.s
+      token: STD.S
+      type: pure-token
+    - name: var.p
+      token: VAR.P
+      type: pure-token
+    - name: var.s
+      token: VAR.S
+      type: pure-token
+    - name: twa
+      since: 1.8.0
+      token: TWA
+      type: pure-token
+    name: aggregator
+    token: AGGREGATION
+    type: oneof
+  - name: bucketDuration
+    type: integer
+  - name: buckettimestamp
+    optional: true
+    since: 1.8.0
+    token: BUCKETTIMESTAMP
+    type: pure-token
+  - name: empty
+    optional: true
+    since: 1.8.0
+    token: EMPTY
+    type: pure-token
+  name: aggregation
+  optional: true
+  type: block
+- arguments:
+  - name: l=v
+    type: string
+  - name: l!=v
+    type: string
+  - name: l=
+    type: string
+  - name: l!=
+    type: string
+  - name: l=(v1,v2,...)
+    type: string
+  - name: l!=(v1,v2,...)
+    type: string
+  multiple: true
+  name: filterExpr
+  token: FILTER
+  type: oneof
+- arguments:
+  - name: GROUPBY
+    token: GROUPBY
+    type: pure-token
+  - name: label
+    type: string
+  - name: REDUCE
+    type: string
+  - name: reducer
+    type: string
+  name: groupby
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n/m+k) where n = Number of data points, m = Chunk size (data points
+  per chunk), k = Number of data points that are in the requested ranges
+description: Query a range across multiple time series by filters in forward direction
+group: timeseries
+hidden: false
+linkTitle: TS.MRANGE
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Query a range across multiple time series by filters in forward direction
+syntax: "TS.MRANGE fromTimestamp toTimestamp\n  [LATEST]\n  [FILTER_BY_TS ts...]\n\
+  \  [FILTER_BY_VALUE min max]\n  [WITHLABELS | <SELECTED_LABELS label...>]\n  [COUNT\
+  \ count]\n  [[ALIGN align] AGGREGATION aggregator bucketDuration [BUCKETTIMESTAMP\
+  \ bt] [EMPTY]]\n  FILTER filterExpr...\n  [GROUPBY label REDUCE reducer]\n"
+syntax_fmt: "TS.MRANGE fromTimestamp toTimestamp [LATEST] [FILTER_BY_TS\_Timestamp\n\
+  \  [Timestamp ...]] [FILTER_BY_VALUE min max] [WITHLABELS |\n  <SELECTED_LABELS label1\
+  \ [label1 ...]>] [COUNT\_count] [[ALIGN\_value]\n  AGGREGATION\_<AVG | FIRST | LAST\
+  \ | MIN | MAX | SUM | RANGE | COUNT\n  | STD.P | STD.S | VAR.P | VAR.S | TWA> bucketDuration\n\
+  \  [BUCKETTIMESTAMP] [EMPTY]] FILTER\_<l=v | l!=v | l= | l!= |\n  l=(v1,v2,...)\
+  \ | l!=(v1,v2,...) [l=v | l!=v | l= | l!= |\n  l=(v1,v2,...) | l!=(v1,v2,...) ...]>\
+  \ [GROUPBY label REDUCE\n  reducer]"
+syntax_str: "toTimestamp [LATEST] [FILTER_BY_TS\_Timestamp [Timestamp ...]] [FILTER_BY_VALUE\
+  \ min max] [WITHLABELS | <SELECTED_LABELS label1 [label1 ...]>] [COUNT\_count] [[ALIGN\_\
+  value] AGGREGATION\_<AVG | FIRST | LAST | MIN | MAX | SUM | RANGE | COUNT | STD.P\
+  \ | STD.S | VAR.P | VAR.S | TWA> bucketDuration [BUCKETTIMESTAMP] [EMPTY]] FILTER\_\
+  <l=v | l!=v | l= | l!= | l=(v1,v2,...) | l!=(v1,v2,...) [l=v | l!=v | l= | l!= |\
+  \ l=(v1,v2,...) | l!=(v1,v2,...) ...]> [GROUPBY label REDUCE reducer]"
+title: TS.MRANGE
+---
+
+Query a range across multiple time series by filters in the forward direction.
+
+{{< note >}}
+This command will reply only if the current user has read access to all keys that match the filter.
+Otherwise, it will reply with "*(error): current user doesn't have read permission to one or more keys that match the specified filter*".
+{{< /note >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>fromTimestamp</code></summary>
+
+is the start timestamp for the range query (integer Unix timestamp in milliseconds) or `-` to denote the timestamp of the earliest sample among all the time series that passes `FILTER filterExpr...`.
+</details>
+
+<details open>
+<summary><code>toTimestamp</code></summary>
+
+is the end timestamp for the range query (integer Unix timestamp in milliseconds) or `+` to denote the timestamp of the latest sample among all the time series that passes `FILTER filterExpr...`.
+</details>
+
+<details open>
+<summary><code>FILTER filterExpr...</code></summary>
+
+filters time series based on their labels and label values. Each filter expression has one of the following syntaxes:
+
+  - `label!=` - the time series has a label named `label`
+  - `label=value` - the time series has a label named `label` with a value equal to `value`
+  - `label=(value1,value2,...)` - the time series has a label named `label` with a value equal to one of the values in the list
+  - `label=` - the time series does not have a label named `label`
+  - `label!=value` - the time series does not have a label named `label` with a value equal to `value`
+  - `label!=(value1,value2,...)` - the time series does not have a label named `label` with a value equal to any of the values in the list
+
+  <note><b>Notes:</b>
+   - At least one filter expression with a syntax `label=value` or `label=(value1,value2,...)` is required.
+   - Filter expressions are conjunctive. For example, the filter `type=temperature room=study` means that a time series is a temperature time series of a study room.
+   - Whitespaces are unallowed in a filter expression except between quotes or double quotes in values - e.g., `x="y y"` or `x='(y y,z z)'`.
+   </note>
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary>
+
+is used when a time series is a compaction. With `LATEST`, TS.MRANGE also reports the compacted value of the latest (possibly partial) bucket, given that this bucket's start time falls within `[fromTimestamp, toTimestamp]`. Without `LATEST`, TS.MRANGE does not report the latest (possibly partial) bucket. When a time series is not a compaction, `LATEST` is ignored.
+
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon the arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest (possibly partial) bucket is also required. In such a case, use `LATEST`.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_TS ts...</code> (since RedisTimeSeries v1.6)</summary>
+
+filters samples by a list of specific timestamps. A sample passes the filter if its exact timestamp is specified and falls within `[fromTimestamp, toTimestamp]`.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_VALUE min max</code> (since RedisTimeSeries v1.6)</summary>
+
+filters samples by minimum and maximum values.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>WITHLABELS</code></summary>
+
+includes in the reply all label-value pairs representing metadata labels of the time series. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+</details>
+
+<details open>
+<summary><code>SELECTED_LABELS label...</code> (since RedisTimeSeries v1.6)</summary>
+
+returns a subset of the label-value pairs that represent metadata labels of the time series. 
+Use when a large number of labels exists per series, but only the values of some of the labels are required. 
+If `WITHLABELS` or `SELECTED_LABELS` are not specified, by default, an empty list is reported as label-value pairs.
+</details>
+
+<details open>
+<summary><code>COUNT count</code></summary>
+
+When used without `AGGREGATION`: limits the number of reported samples per time series.
+
+When used together with `AGGREGATION`: limits the number of reported buckets.
+</details>
+
+<details open>
+<summary><code>ALIGN align</code> (since RedisTimeSeries v1.6)</summary>
+
+is a time bucket alignment control for `AGGREGATION`. It controls the time bucket timestamps by changing the reference timestamp on which a bucket is defined. 
+
+Values include:
+   
+ - `start` or `-`: The reference timestamp will be the query start interval time (`fromTimestamp`) which can't be `-`
+ - `end` or `+`: The reference timestamp will be the query end interval time (`toTimestamp`) which can't be `+`
+ - A specific timestamp: align the reference timestamp to a specific time
+   
+<note><b>Note:</b> When not provided, alignment is set to `0`.</note>
+</details>
+
+<details open>
+<summary><code>AGGREGATION aggregator bucketDuration</code></summary>
+
+per time series, aggregates samples into time buckets, where:
+
+  - `aggregator` takes one of the following aggregation types:
+
+    | `aggregator` | Description                                                                    |
+    | ------------ | ------------------------------------------------------------------------------ |
+    | `avg`        | Arithmetic mean of all values                                                  |
+    | `sum`        | Sum of all values                                                              |
+    | `min`        | Minimum value                                                                  |
+    | `max`        | Maximum value                                                                  |
+    | `range`      | Difference between maximum value and minimum value                             |
+    | `count`      | Number of values                                                               |
+    | `first`      | Value with lowest timestamp in the bucket                                      |
+    | `last`       | Value with highest timestamp in the bucket                                     |
+    | `std.p`      | Population standard deviation of the values                                    |
+    | `std.s`      | Sample standard deviation of the values                                        |
+    | `var.p`      | Population variance of the values                                              |
+    | `var.s`      | Sample variance of the values                                                  |
+    | `twa`        | Time-weighted average over the bucket's timeframe (since RedisTimeSeries v1.8) |
+
+  - `bucketDuration` is duration of each bucket, in milliseconds.
+  
+  Without `ALIGN`, bucket start times are multiples of `bucketDuration`.
+  
+  With `ALIGN align`, bucket start times are multiples of `bucketDuration` with remainder `align % bucketDuration`.
+  
+  The first bucket start time is less than or equal to `fromTimestamp`.  
+</details>
+
+<details open>
+<summary><code>[BUCKETTIMESTAMP bt]</code> (since RedisTimeSeries v1.8)</summary>
+
+controls how bucket timestamps are reported.
+
+| `bt`             | Timestamp reported for each bucket                            |
+| ---------------- | ------------------------------------------------------------- |
+| `-` or `start`   | the bucket's start time (default)                             |
+| `+` or `end`     | the bucket's end time                                         |
+| `~` or `mid`     | the bucket's mid time (rounded down if not an integer)        |
+</details>
+
+<details open>
+<summary><code>[EMPTY]</code> (since RedisTimeSeries v1.8)</summary>
+
+is a flag, which, when specified, reports aggregations also for empty buckets.
+
+| `aggregator`         | Value reported for each empty bucket |
+| -------------------- | ------------------------------------ |
+| `sum`, `count`       | `0`                                  |
+| `last`               | The value of the last sample before the bucket's start. `NaN` when no such sample. |
+| `twa`                | Average value over the bucket's timeframe based on linear interpolation of the last sample before the bucket's start and the first sample after the bucket's end. `NaN` when no such samples. |
+| `min`, `max`, `range`, `avg`, `first`, `std.p`, `std.s` | `NaN` |
+
+Regardless of the values of `fromTimestamp` and `toTimestamp`, no data is reported for buckets that end before the earliest sample or begin after the latest sample in the time series.
+</details>
+
+<details open>
+<summary><code>GROUPBY label REDUCE reducer</code> (since RedisTimeSeries v1.6)</summary>
+
+splits time series into groups, each group contains time series that share the same value for the provided label name, then aggregates results in each group.
+
+When combined with `AGGREGATION` the `GROUPBY`/`REDUCE` is applied post aggregation stage.
+
+  - `label` is label name. A group is created for all time series that share the same value for this label.
+
+  - `reducer` is an aggregation type used to aggregate the results in each group.
+
+    | `reducer` | Description                                                                                     |
+    | --------- | ----------------------------------------------------------------------------------------------- |
+    | `avg`     | Arithmetic mean of all non-NaN values (since RedisTimeSeries v1.8)                              |
+    | `sum`     | Sum of all non-NaN values                                                                       |
+    | `min`     | Minimum non-NaN value                                                                           |
+    | `max`     | Maximum non-NaN value                                                                           |
+    | `range`   | Difference between maximum non-NaN value and minimum non-NaN value (since RedisTimeSeries v1.8) |
+    | `count`   | Number of non-NaN values (since RedisTimeSeries v1.8)                                           |
+    | `std.p`   | Population standard deviation of all non-NaN values (since RedisTimeSeries v1.8)                |
+    | `std.s`   | Sample standard deviation of all non-NaN values (since RedisTimeSeries v1.8)                    |
+    | `var.p`   | Population variance of all non-NaN values (since RedisTimeSeries v1.8)                          |
+    | `var.s`   | Sample variance of all non-NaN values (since RedisTimeSeries v1.8)                              |
+
+<note><b>Notes:</b> 
+  - The produced time series is named `<label>=<value>`
+  - The produced time series contains two labels with these label array structures:
+    - `__reducer__`, the reducer used (e.g., `"count"`)
+    - `__source__`, the list of time series keys used to compute the grouped series (e.g., `"key1,key2,key3"`)
+</note>
+
+</details>
+
+<note><b>Note:</b> An `MRANGE` command cannot be part of a transaction when running on a Redis cluster.</note>
+
+## Return value
+
+If `GROUPBY label REDUCE reducer` is not specified:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): for each time series matching the specified filters, the following is reported:
+  - bulk-string-reply: The time series key name
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): label-value pairs ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}))
+    - By default, an empty array is reported
+    - If `WITHLABELS` is specified, all labels associated with this time series are reported
+    - If `SELECTED_LABELS label...` is specified, the selected labels are reported (null value when no such label defined)
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): timestamp-value pairs ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) (double)): all samples/aggregations matching the range
+
+If `GROUPBY label REDUCE reducer` is specified:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): for each group of time series matching the specified filters, the following is reported:
+  - bulk-string-reply with the format `label=value` where `label` is the `GROUPBY` label argument
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): label-value pairs ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})):
+    - By default, an empty array is reported
+    - If `WITHLABELS` is specified, the `GROUPBY` label argument and value are reported
+    - If `SELECTED_LABELS label...` is specified, the selected labels are reported (null value when no such label defined or label does not have the same value for all grouped time series)
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): either a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})): the `GROUPBY` label argument and value, or empty array if 
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})):  the string `__reducer__` and the reducer argument
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): a single pair ([Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}), [Bulk string reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}})): the string `__source__` and the time series key names separated by `,`
+  - [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}): timestamp-value pairs ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) (double)): all samples/aggregations matching the range
+
+## Examples
+
+<details open>
+<summary><b>Retrieve maximum stock price per timestamp</b></summary>
+
+Create two stocks and add their prices at three different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.CREATE stock:B LABELS type stock name B
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:B 1000 120 stock:B 1010 110 stock:B 1020 100
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+{{< / highlight >}}
+
+You can now retrieve the maximum stock price per timestamp.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MRANGE - + WITHLABELS FILTER type=stock GROUPBY type REDUCE max
+1) 1) "type=stock"
+   2) 1) 1) "type"
+         2) "stock"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "stock:A,stock:B"
+   3) 1) 1) (integer) 1000
+         2) 120
+      2) 1) (integer) 1010
+         2) 110
+      3) 1) (integer) 1020
+         2) 120
+{{< / highlight >}}
+
+The `FILTER type=stock` clause returns a single time series representing stock prices. The `GROUPBY type REDUCE max` clause splits the time series into groups with identical type values, and then, for each timestamp, aggregates all series that share the same type value using the max aggregator.
+</details>
+
+<details open>
+<summary><b>Calculate average stock price and retrieve maximum average</b></summary> 
+
+Create two stocks and add their prices at nine different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.CREATE stock:B LABELS type stock name B
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:B 1000 120 stock:B 1010 110 stock:B 1020 100
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:A 2000 200 stock:A 2010 210 stock:A 2020 220
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:B 2000 220 stock:B 2010 210 stock:B 2020 200
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:A 3000 300 stock:A 3010 310 stock:A 3020 320
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+127.0.0.1:6379> TS.MADD stock:B 3000 320 stock:B 3010 310 stock:B 3020 300
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+{{< / highlight >}}
+
+Now, for each stock, calculate the average stock price per a 1000-millisecond timeframe, and then retrieve the stock with the maximum average for that timeframe.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.MRANGE - + WITHLABELS AGGREGATION avg 1000 FILTER type=stock GROUPBY type REDUCE max
+1) 1) "type=stock"
+   2) 1) 1) "type"
+         2) "stock"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "stock:A,stock:B"
+   3) 1) 1) (integer) 1000
+         2) 110
+      2) 1) (integer) 2000
+         2) 210
+      3) 1) (integer) 3000
+         2) 310
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Group query results</b></summary>
+
+Query all time series with the metric label equal to `cpu`, then group the time series by the value of their `metric_name` label value and for each group return the maximum value and the time series keys (_source_) with that value.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user
+(integer) 1548149180000
+127.0.0.1:6379> TS.MRANGE - + WITHLABELS FILTER metric=cpu GROUPBY metric_name REDUCE max
+1) 1) "metric_name=system"
+   2) 1) 1) "metric_name"
+         2) "system"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "ts1"
+   3) 1) 1) (integer) 1548149180000
+         2) 90
+      2) 1) (integer) 1548149185000
+         2) 45
+2) 1) "metric_name=user"
+   2) 1) 1) "metric_name"
+         2) "user"
+      2) 1) "__reducer__"
+         2) "max"
+      3) 1) "__source__"
+         2) "ts2"
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Filter query by value</b></summary>
+
+Query all time series with the metric label equal to `cpu`, then filter values larger or equal to 90.0 and smaller or equal to 100.0.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user
+(integer) 1548149180000
+127.0.0.1:6379> TS.MRANGE - + FILTER_BY_VALUE 90 100 WITHLABELS FILTER metric=cpu
+1) 1) "ts1"
+   2) 1) 1) "metric"
+         2) "cpu"
+      2) 1) "metric_name"
+         2) "system"
+   3) 1) 1) (integer) 1548149180000
+         2) 90
+2) 1) "ts2"
+   2) 1) 1) "metric"
+         2) "cpu"
+      2) 1) "metric_name"
+         2) "user"
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Query using a label</b></summary>
+
+Query all time series with the metric label equal to `cpu`, but only return the team label.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD ts1 1548149180000 90 labels metric cpu metric_name system team NY
+(integer) 1548149180000
+127.0.0.1:6379> TS.ADD ts1 1548149185000 45
+(integer) 1548149185000
+127.0.0.1:6379> TS.ADD ts2 1548149180000 99 labels metric cpu metric_name user team SF
+(integer) 1548149180000
+127.0.0.1:6379> TS.MRANGE - + SELECTED_LABELS team FILTER metric=cpu
+1) 1) "ts1"
+   2) 1) 1) "team"
+         2) "NY"
+   3) 1) 1) (integer) 1548149180000
+         2) 90
+      2) 1) (integer) 1548149185000
+         2) 45
+2) 1) "ts2"
+   2) 1) 1) "team"
+         2) "SF"
+   3) 1) 1) (integer) 1548149180000
+         2) 99
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) | [`TS.REVRANGE`]({{< relref "commands/ts.revrange/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for latency diagnostics commands.
+group: server
+hidden: true
+linkTitle: LATENCY
+since: 2.8.13
+summary: A container for latency diagnostics commands.
+syntax_fmt: LATENCY
+syntax_str: ''
+title: LATENCY
+---
+This is a container command for latency diagnostics commands.
+
+To see the list of available commands you can call [`LATENCY HELP`]({{< relref "/commands/latency-help" >}}).---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns a count of commands.
+group: server
+hidden: false
+linkTitle: COMMAND COUNT
+since: 2.8.13
+summary: Returns a count of commands.
+syntax_fmt: COMMAND COUNT
+syntax_str: ''
+title: COMMAND COUNT
+---
+Returns [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) of number of total commands in this Redis server.
+
+## Examples
+
+{{% redis-cli %}}
+COMMAND COUNT
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@cms'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of items
+description: Returns the count for one or more items in a sketch
+group: cms
+hidden: false
+linkTitle: CMS.QUERY
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Returns the count for one or more items in a sketch
+syntax_fmt: CMS.QUERY key item [item ...]
+syntax_str: item [item ...]
+title: CMS.QUERY
+---
+Returns the count for one or more items in a sketch.
+
+### Parameters:
+
+* **key**: The name of the sketch.
+* **item**: One or more items for which to return the count.
+
+## Return
+
+Count of one or more items
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) with a min-count of each of the items in the sketch.
+
+## Examples
+
+```
+redis> CMS.QUERY test foo bar
+1) (integer) 10
+2) (integer) 42
+```---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for function commands.
+group: scripting
+hidden: true
+linkTitle: FUNCTION
+since: 7.0.0
+summary: A container for function commands.
+syntax_fmt: FUNCTION
+syntax_str: ''
+title: FUNCTION
+---
+This is a container command for function commands.
+
+To see the list of available commands you can call [`FUNCTION HELP`]({{< relref "/commands/function-help" >}}).---
+acl_categories:
+- '@write'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  since: 3.2.0
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: Without the count argument O(1), otherwise O(N) where N is the value of
+  the passed count.
+description: Returns one or more random members from a set after removing them. Deletes
+  the set if the last member was popped.
+group: set
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 3.2.0
+  - Added the `count` argument.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SPOP
+since: 1.0.0
+summary: Returns one or more random members from a set after removing them. Deletes
+  the set if the last member was popped.
+syntax_fmt: SPOP key [count]
+syntax_str: '[count]'
+title: SPOP
+---
+Removes and returns one or more random members from the set value store at `key`.
+
+This operation is similar to [`SRANDMEMBER`]({{< relref "/commands/srandmember" >}}), that returns one or more random elements from a set but does not remove it.
+
+By default, the command pops a single member from the set. When provided with
+the optional `count` argument, the reply will consist of up to `count` members,
+depending on the set's cardinality.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "one"
+SADD myset "two"
+SADD myset "three"
+SPOP myset
+SMEMBERS myset
+SADD myset "four"
+SADD myset "five"
+SPOP myset 3
+SMEMBERS myset
+{{% /redis-cli %}}
+
+## Distribution of returned elements
+
+Note that this command is not suitable when you need a guaranteed uniform distribution of the returned elements. For more information about the algorithms used for `SPOP`, look up both the Knuth sampling and Floyd sampling algorithms.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: cursor
+  name: cursor
+  type: integer
+- display_text: pattern
+  name: pattern
+  optional: true
+  token: MATCH
+  type: pattern
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: type
+  name: type
+  optional: true
+  since: 6.0.0
+  token: TYPE
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for every call. O(N) for a complete iteration, including enough command
+  calls for the cursor to return back to 0. N is the number of elements inside the
+  collection.
+description: Iterates over the key names in the database.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:special
+- response_policy:special
+history:
+- - 6.0.0
+  - Added the `TYPE` subcommand.
+linkTitle: SCAN
+since: 2.8.0
+summary: Iterates over the key names in the database.
+syntax_fmt: "SCAN cursor [MATCH\_pattern] [COUNT\_count] [TYPE\_type]"
+syntax_str: "[MATCH\_pattern] [COUNT\_count] [TYPE\_type]"
+title: SCAN
+---
+The `SCAN` command and the closely related commands [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}}) are used in order to incrementally iterate over a collection of elements.
+
+* `SCAN` iterates the set of keys in the currently selected Redis database.
+* [`SSCAN`]({{< relref "/commands/sscan" >}}) iterates elements of Sets types.
+* [`HSCAN`]({{< relref "/commands/hscan" >}}) iterates fields of Hash types and their associated values.
+* [`ZSCAN`]({{< relref "/commands/zscan" >}}) iterates elements of Sorted Set types and their associated scores.
+
+Since these commands allow for incremental iteration, returning only a small number of elements per call, they can be used in production without the downside of commands like [`KEYS`]({{< relref "/commands/keys" >}}) or [`SMEMBERS`]({{< relref "/commands/smembers" >}}) that may block the server for a long time (even several seconds) when called against big collections of keys or elements.
+
+However while blocking commands like [`SMEMBERS`]({{< relref "/commands/smembers" >}}) are able to provide all the elements that are part of a Set in a given moment, The SCAN family of commands only offer limited guarantees about the returned elements since the collection that we incrementally iterate can change during the iteration process.
+
+Note that `SCAN`, [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}}) all work very similarly, so this documentation covers all four commands. However an obvious difference is that in the case of [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}}) the first argument is the name of the key holding the Set, Hash or Sorted Set value. The `SCAN` command does not need any key name argument as it iterates keys in the current database, so the iterated object is the database itself.
+
+## SCAN basic usage
+
+SCAN is a cursor based iterator. This means that at every call of the command, the server returns an updated cursor that the user needs to use as the cursor argument in the next call.
+
+An iteration starts when the cursor is set to 0, and terminates when the cursor returned by the server is 0. The following is an example of SCAN iteration:
+
+```
+> scan 0
+1) "17"
+2)  1) "key:12"
+    2) "key:8"
+    3) "key:4"
+    4) "key:14"
+    5) "key:16"
+    6) "key:17"
+    7) "key:15"
+    8) "key:10"
+    9) "key:3"
+   10) "key:7"
+   11) "key:1"
+> scan 17
+1) "0"
+2) 1) "key:5"
+   2) "key:18"
+   3) "key:0"
+   4) "key:2"
+   5) "key:19"
+   6) "key:13"
+   7) "key:6"
+   8) "key:9"
+   9) "key:11"
+```
+
+In the example above, the first call uses zero as a cursor, to start the iteration. The second call uses the cursor returned by the previous call as the first element of the reply, that is, 17.
+
+As you can see the **SCAN return value** is an array of two values: the first value is the new cursor to use in the next call, the second value is an array of elements.
+
+Since in the second call the returned cursor is 0, the server signaled to the caller that the iteration finished, and the collection was completely explored. Starting an iteration with a cursor value of 0, and calling `SCAN` until the returned cursor is 0 again is called a **full iteration**.
+
+## Return value
+
+`SCAN`, [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}}) return a two element multi-bulk reply, where the first element is a string representing an unsigned 64 bit number (the cursor), and the second element is a multi-bulk with an array of elements.
+
+* `SCAN` array of elements is a list of keys.
+* [`SSCAN`]({{< relref "/commands/sscan" >}}) array of elements is a list of Set members.
+* [`HSCAN`]({{< relref "/commands/hscan" >}}) array of elements contain two elements, a field and a value, for every returned element of the Hash.
+* [`ZSCAN`]({{< relref "/commands/zscan" >}}) array of elements contain two elements, a member and its associated score, for every returned element of the Sorted Set.
+
+## Scan guarantees
+
+The `SCAN` command, and the other commands in the `SCAN` family, are able to provide to the user a set of guarantees associated to full iterations.
+
+* A full iteration always retrieves all the elements that were present in the collection from the start to the end of a full iteration. This means that if a given element is inside the collection when an iteration is started, and is still there when an iteration terminates, then at some point `SCAN` returned it to the user.
+* A full iteration never returns any element that was NOT present in the collection from the start to the end of a full iteration. So if an element was removed before the start of an iteration, and is never added back to the collection for all the time an iteration lasts, `SCAN` ensures that this element will never be returned.
+
+However because `SCAN` has very little state associated (just the cursor) it has the following drawbacks:
+
+* A given element may be returned multiple times. It is up to the application to handle the case of duplicated elements, for example only using the returned elements in order to perform operations that are safe when re-applied multiple times.
+* Elements that were not constantly present in the collection during a full iteration, may be returned or not: it is undefined.
+
+## Number of elements returned at every SCAN call
+
+`SCAN` family functions do not guarantee that the number of elements returned per call are in a given range. The commands are also allowed to return zero elements, and the client should not consider the iteration complete as long as the returned cursor is not zero.
+
+However the number of returned elements is reasonable, that is, in practical terms `SCAN` may return a maximum number of elements in the order of a few tens of elements when iterating a large collection, or may return all the elements of the collection in a single call when the iterated collection is small enough to be internally represented as an encoded data structure (this happens for small Sets, Hashes and Sorted Sets).
+
+However there is a way for the user to tune the order of magnitude of the number of returned elements per call using the **COUNT** option.
+
+## The COUNT option
+
+While `SCAN` does not provide guarantees about the number of elements returned at every iteration, it is possible to empirically adjust the behavior of `SCAN` using the **COUNT** option. Basically with COUNT the user specifies the *amount of work that should be done at every call in order to retrieve elements from the collection*. This is **just a hint** for the implementation, however generally speaking this is what you could expect most of the times from the implementation.
+
+* The default `COUNT` value is 10.
+* When iterating the key space, or a Set, Hash or Sorted Set that is big enough to be represented by a hash table, assuming no **MATCH** option is used, the server will usually return *count* or a few more than *count* elements per call. Please check the *why SCAN may return all the elements at once* section later in this document.
+* When iterating Sets encoded as intsets (small sets composed of just integers), or Hashes and Sorted Sets encoded as ziplists (small hashes and sets composed of small individual values), usually all the elements are returned in the first `SCAN` call regardless of the `COUNT` value.
+
+Important: **there is no need to use the same COUNT value** for every iteration. The caller is free to change the count from one iteration to the other as required, as long as the cursor passed in the next call is the one obtained in the previous call to the command.
+
+## The MATCH option
+
+It is possible to only iterate elements matching a given glob-style pattern, similarly to the behavior of the [`KEYS`]({{< relref "/commands/keys" >}}) command that takes a pattern as its only argument.
+
+To do so, just append the `MATCH <pattern>` arguments at the end of the `SCAN` command (it works with all the `SCAN` family commands).
+
+This is an example of iteration using **MATCH**:
+
+{{< clients-example cmds_generic scan1 >}}
+> sadd myset 1 2 3 foo foobar feelsgood
+(integer) 6
+> sscan myset 0 match f*
+1) "0"
+2) 1) "foo"
+   2) "feelsgood"
+   3) "foobar"
+{{< /clients-example >}}
+
+It is important to note that the **MATCH** filter is applied after elements are retrieved from the collection, just before returning data to the client. This means that if the pattern matches very little elements inside the collection, `SCAN` will likely return no elements in most iterations. An example is shown below:
+
+{{< clients-example cmds_generic scan2 >}}
+> scan 0 MATCH *11*
+1) "288"
+2) 1) "key:911"
+> scan 288 MATCH *11*
+1) "224"
+2) (empty list or set)
+> scan 224 MATCH *11*
+1) "80"
+2) (empty list or set)
+> scan 80 MATCH *11*
+1) "176"
+2) (empty list or set)
+> scan 176 MATCH *11* COUNT 1000
+1) "0"
+2)  1) "key:611"
+    2) "key:711"
+    3) "key:118"
+    4) "key:117"
+    5) "key:311"
+    6) "key:112"
+    7) "key:111"
+    8) "key:110"
+    9) "key:113"
+   10) "key:211"
+   11) "key:411"
+   12) "key:115"
+   13) "key:116"
+   14) "key:114"
+   15) "key:119"
+   16) "key:811"
+   17) "key:511"
+   18) "key:11"
+{{< /clients-example >}}
+
+As you can see most of the calls returned zero elements, but the last call where a `COUNT` of 1000 was used in order to force the command to do more scanning for that iteration.
+
+When using [Redis Cluster]({{< relref "/operate/oss_and_stack/management/scaling" >}}), the search is optimized for patterns that imply a single slot.
+If a pattern can only match keys of one slot,
+Redis only iterates over keys in that slot, rather than the whole database,
+when searching for keys matching the pattern.
+For example, with the pattern `{a}h*llo`, Redis would only try to match it with the keys in slot 15495, which hash tag `{a}` implies.
+To use pattern with hash tag, see [Hash tags]({{< relref "operate/oss_and_stack/reference/cluster-spec#hash-tags" >}}) in the Cluster specification for more information.
+
+## The TYPE option
+
+You can use the `TYPE` option to ask `SCAN` to only return objects that match a given `type`, allowing you to iterate through the database looking for keys of a specific type. The **TYPE** option is only available on the whole-database `SCAN`, not [`HSCAN`]({{< relref "/commands/hscan" >}}) or [`ZSCAN`]({{< relref "/commands/zscan" >}}) etc.
+
+The `type` argument is the same string name that the [`TYPE`]({{< relref "/commands/type" >}}) command returns. Note a quirk where some Redis types, such as GeoHashes, HyperLogLogs, Bitmaps, and Bitfields, may internally be implemented using other Redis types, such as a string or zset, so can't be distinguished from other keys of that same type by `SCAN`. For example, a ZSET and GEOHASH:
+
+{{< clients-example cmds_generic scan3 >}}
+> GEOADD geokey 0 0 value
+(integer) 1
+> ZADD zkey 1000 value
+(integer) 1
+> TYPE geokey
+zset
+> TYPE zkey
+zset
+> SCAN 0 TYPE zset
+1) "0"
+2) 1) "geokey"
+   2) "zkey"
+{{< /clients-example >}}
+
+It is important to note that the **TYPE** filter is also applied after elements are retrieved from the database, so the option does not reduce the amount of work the server has to do to complete a full iteration, and for rare types you may receive no elements in many iterations.
+
+## The NOVALUES option
+
+When using [`HSCAN`]({{< relref "/commands/hscan" >}}), you can use the `NOVALUES` option to make Redis return only the keys in the hash table without their corresponding values.
+
+{{< clients-example cmds_generic scan4 >}}
+> HSET myhash a 1 b 2
+OK
+> HSCAN myhash 0
+1) "0"
+2) 1) "a"
+   2) "1"
+   3) "b"
+   4) "2"
+> HSCAN myhash 0 NOVALUES
+1) "0"
+2) 1) "a"
+   2) "b"
+{{< /clients-example >}}
+
+## Multiple parallel iterations
+
+It is possible for an infinite number of clients to iterate the same collection at the same time, as the full state of the iterator is in the cursor, that is obtained and returned to the client at every call. No server side state is taken at all.
+
+## Terminating iterations in the middle
+
+Since there is no state server side, but the full state is captured by the cursor, the caller is free to terminate an iteration half-way without signaling this to the server in any way. An infinite number of iterations can be started and never terminated without any issue.
+
+## Calling SCAN with a corrupted cursor
+
+Calling `SCAN` with a broken, negative, out of range, or otherwise invalid cursor, will result in undefined behavior but never in a crash. What will be undefined is that the guarantees about the returned elements can no longer be ensured by the `SCAN` implementation.
+
+The only valid cursors to use are:
+
+* The cursor value of 0 when starting an iteration.
+* The cursor returned by the previous call to SCAN in order to continue the iteration.
+
+## Guarantee of termination
+
+The `SCAN` algorithm is guaranteed to terminate only if the size of the iterated collection remains bounded to a given maximum size, otherwise iterating a collection that always grows may result into `SCAN` to never terminate a full iteration.
+
+This is easy to see intuitively: if the collection grows there is more and more work to do in order to visit all the possible elements, and the ability to terminate the iteration depends on the number of calls to `SCAN` and its COUNT option value compared with the rate at which the collection grows.
+
+## Why SCAN may return all the items of an aggregate data type in a single call?
+
+In the `COUNT` option documentation, we state that sometimes this family of commands may return all the elements of a Set, Hash or Sorted Set at once in a single call, regardless of the `COUNT` option value. The reason why this happens is that the cursor-based iterator can be implemented, and is useful, only when the aggregate data type that we are scanning is represented as a hash table. However Redis uses a [memory optimization]({{< relref "/operate/oss_and_stack/management/optimization/memory-optimization" >}}) where small aggregate data types, until they reach a given amount of items or a given max size of single elements, are represented using a compact single-allocation packed encoding. When this is the case, `SCAN` has no meaningful cursor to return, and must iterate the whole data structure at once, so the only sane behavior it has is to return everything in a call.
+
+However once the data structures are bigger and are promoted to use real hash tables, the `SCAN` family of commands will resort to the normal behavior. Note that since this special behavior of returning all the elements is true only for small aggregates, it has no effects on the command complexity or latency. However the exact limits to get converted into real hash tables are [user configurable]({{< relref "/operate/oss_and_stack/management/optimization/memory-optimization" >}}), so the maximum number of elements you can see returned in a single call depends on how big an aggregate data type could be and still use the packed representation.
+
+Also note that this behavior is specific of [`SSCAN`]({{< relref "/commands/sscan" >}}), [`HSCAN`]({{< relref "/commands/hscan" >}}) and [`ZSCAN`]({{< relref "/commands/zscan" >}}). `SCAN` itself never shows this behavior because the key space is always represented by hash tables.
+
+## Further reading
+
+For more information about managing keys, please refer to the [The Redis Keyspace]({{< relref "/develop/use/keyspace" >}}) tutorial.
+
+## Additional examples
+
+Give the following commands, showing iteration of a hash key, a try in the interactive console:
+
+{{% redis-cli %}}
+HMSET hash name Jack age 33
+HSCAN hash 0
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@search'
+arguments:
+- name: alias
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Deletes an alias from the index
+group: search
+hidden: false
+linkTitle: FT.ALIASDEL
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Deletes an alias from the index
+syntax: 'FT.ALIASDEL alias
+
+  '
+syntax_fmt: FT.ALIASDEL alias
+syntax_str: ''
+title: FT.ALIASDEL
+---
+
+Remove an alias from an index
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>alias</code></summary>
+
+is index alias to be removed.
+</details>
+
+## Return
+
+FT.ALIASDEL returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Remove an alias from an index</b></summary>
+
+Remove an alias from an index.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.ALIASDEL alias
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.ALIASADD`]({{< relref "commands/ft.aliasadd/" >}}) | [`FT.ALIASUPDATE`]({{< relref "commands/ft.aliasupdate/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: channel
+  multiple: true
+  name: channel
+  optional: true
+  type: string
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of channels to unsubscribe.
+description: Stops listening to messages posted to channels.
+group: pubsub
+hidden: false
+linkTitle: UNSUBSCRIBE
+since: 2.0.0
+summary: Stops listening to messages posted to channels.
+syntax_fmt: UNSUBSCRIBE [channel [channel ...]]
+syntax_str: ''
+title: UNSUBSCRIBE
+---
+Unsubscribes the client from the given channels, or from all of them if none is
+given.
+
+When no channels are specified, the client is unsubscribed from all the
+previously subscribed channels.
+In this case, a message for every unsubscribed channel will be sent to the
+client.
+---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: iterator
+  type: integer
+- name: data
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n), where n is the capacity
+description: Restores a filter previously saved using SCANDUMP
+group: bf
+hidden: false
+linkTitle: BF.LOADCHUNK
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Restores a filter previously saved using SCANDUMP
+syntax_fmt: BF.LOADCHUNK key iterator data
+syntax_str: iterator data
+title: BF.LOADCHUNK
+---
+Restores a Bloom filter previously saved using [`BF.SCANDUMP`]({{< relref "commands/bf.scandump/" >}}).
+
+See the [`BF.SCANDUMP`]({{< relref "commands/bf.scandump/" >}}) command for example usage.
+
+<note><b>Notes</b>
+
+- This command overwrites the Bloom filter stored under `key`. 
+- Make sure that the Bloom filter is not changed between invocations.
+
+</note>
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter to restore.
+</details>
+
+<details open><summary><code>iterator</code></summary>
+
+Iterator value associated with `data` (returned by [`BF.SCANDUMP`]({{< relref "commands/bf.scandump/" >}}))
+</details>
+
+<details open><summary><code>data</code></summary>
+
+Current data chunk (returned by [`BF.SCANDUMP`]({{< relref "commands/bf.scandump/" >}}))
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, wrong key type, wrong data, etc.)
+
+## Examples
+
+See [`BF.SCANDUMP`]({{< relref "commands/bf.scandump/" >}}) for an example.
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- arguments:
+  - display_text: key
+    key_spec_index: 0
+    name: key
+    type: key
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the number of keys to set.
+description: Atomically creates or modifies the string values of one or more keys.
+group: string
+hidden: false
+hints:
+- request_policy:multi_shard
+- response_policy:all_succeeded
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 2
+      lastkey: -1
+      limit: 0
+    type: range
+  update: true
+linkTitle: MSET
+since: 1.0.1
+summary: Atomically creates or modifies the string values of one or more keys.
+syntax_fmt: MSET key value [key value ...]
+syntax_str: ''
+title: MSET
+---
+Sets the given keys to their respective values.
+`MSET` replaces existing values with new values, just as regular [`SET`]({{< relref "/commands/set" >}}).
+See [`MSETNX`]({{< relref "/commands/msetnx" >}}) if you don't want to overwrite existing values.
+
+`MSET` is atomic, so all given keys are set at once.
+It is not possible for clients to see that some of the keys were updated while
+others are unchanged.
+
+## Examples
+
+{{% redis-cli %}}
+MSET key1 "Hello" key2 "World"
+GET key1
+GET key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: username
+  name: username
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of password, command and pattern rules that
+  the user has.
+description: Lists the ACL rules of a user.
+group: server
+hidden: false
+history:
+- - 6.2.0
+  - Added Pub/Sub channel patterns.
+- - 7.0.0
+  - Added selectors and changed the format of key and channel patterns from a list
+    to their rule representation.
+linkTitle: ACL GETUSER
+since: 6.0.0
+summary: Lists the ACL rules of a user.
+syntax_fmt: ACL GETUSER username
+syntax_str: ''
+title: ACL GETUSER
+---
+The command returns all the rules defined for an existing ACL user.
+
+Specifically, it lists the user's ACL flags, password hashes, commands, key patterns, channel patterns (Added in version 6.2) and selectors (Added in version 7.0).
+Additional information may be returned in the future if more metadata is added to the user.
+
+Command rules are always returned in the same format as the one used in the [`ACL SETUSER`]({{< relref "/commands/acl-setuser" >}}) command.
+Before version 7.0, keys and channels were returned as an array of patterns, however in version 7.0 later they are now also returned in same format as the one used in the [`ACL SETUSER`]({{< relref "/commands/acl-setuser" >}}) command.
+Note: This description of command rules reflects the user's effective permissions, so while it may not be identical to the set of rules used to configure the user, it is still functionally identical.
+
+Selectors are listed in the order they were applied to the user, and include information about commands, key patterns, and channel patterns.
+
+## Examples
+
+Here's an example configuration for a user
+
+```
+> ACL SETUSER sample on nopass +GET allkeys &* (+SET ~key2)
+"OK"
+> ACL GETUSER sample
+1) "flags"
+2) 1) "on"
+   2) "allkeys"
+   3) "nopass"
+3) "passwords"
+4) (empty array)
+5) "commands"
+6) "+@all"
+7) "keys"
+8) "~*"
+9) "channels"
+10) "&*"
+11) "selectors"
+12) 1) 1) "commands"
+       6) "+SET"
+       7) "keys"
+       8) "~key2"
+       9) "channels"
+       10) "&*"
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: schedule
+  name: schedule
+  optional: true
+  since: 3.2.2
+  token: SCHEDULE
+  type: pure-token
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+complexity: O(1)
+description: Asynchronously saves the database(s) to disk.
+group: server
+hidden: false
+history:
+- - 3.2.2
+  - Added the `SCHEDULE` option.
+linkTitle: BGSAVE
+since: 1.0.0
+summary: Asynchronously saves the database(s) to disk.
+syntax_fmt: BGSAVE [SCHEDULE]
+syntax_str: ''
+title: BGSAVE
+---
+Save the DB in background.
+
+Normally the OK code is immediately returned.
+Redis forks, the parent continues to serve the clients, the child saves the DB
+on disk then exits.
+
+An error is returned if there is already a background save running or if there
+is another non-background-save process running, specifically an in-progress AOF
+rewrite.
+
+If `BGSAVE SCHEDULE` is used, the command will immediately return `OK` when an
+AOF rewrite is in progress and schedule the background save to run at the next
+opportunity.
+
+A client may be able to check if the operation succeeded using the [`LASTSAVE`]({{< relref "/commands/lastsave" >}})
+command.
+
+See the [persistence documentation]({{< relref "/operate/oss_and_stack/management/persistence" >}}) for detailed information.
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- display_text: consumer
+  name: consumer
+  type: string
+- display_text: min-idle-time
+  name: min-idle-time
+  type: string
+- display_text: start
+  name: start
+  type: string
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: justid
+  name: justid
+  optional: true
+  token: JUSTID
+  type: pure-token
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1) if COUNT is small.
+description: Changes, or acquires, ownership of messages in a consumer group, as if
+  the messages were delivered to as consumer group member.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 7.0.0
+  - Added an element to the reply array, containing deleted entries the command cleared
+    from the PEL
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XAUTOCLAIM
+since: 6.2.0
+summary: Changes, or acquires, ownership of messages in a consumer group, as if the
+  messages were delivered to as consumer group member.
+syntax_fmt: "XAUTOCLAIM key group consumer min-idle-time start [COUNT\_count]\n  [JUSTID]"
+syntax_str: "group consumer min-idle-time start [COUNT\_count] [JUSTID]"
+title: XAUTOCLAIM
+---
+This command transfers ownership of pending stream entries that match the specified criteria. Conceptually, `XAUTOCLAIM`  is equivalent to calling [`XPENDING`]({{< relref "/commands/xpending" >}}) and then [`XCLAIM`]({{< relref "/commands/xclaim" >}}),
+but provides a more straightforward way to deal with message delivery failures via [`SCAN`]({{< relref "/commands/scan" >}})-like semantics.
+
+Like [`XCLAIM`]({{< relref "/commands/xclaim" >}}), the command operates on the stream entries at `<key>` and in the context of the provided `<group>`.
+It transfers ownership to `<consumer>` of messages pending for more than `<min-idle-time>` milliseconds and having an equal or greater ID than `<start>`.
+
+The optional `<count>` argument, which defaults to 100, is the upper limit of the number of entries that the command attempts to claim.
+Internally, the command begins scanning the consumer group's Pending Entries List (PEL) from `<start>` and filters out entries having an idle time less than or equal to `<min-idle-time>`.
+The maximum number of pending entries that the command scans is the product of multiplying `<count>`'s value by 10 (hard-coded).
+It is possible, therefore, that the number of entries claimed will be less than the specified value.
+
+The optional `JUSTID` argument changes the reply to return just an array of IDs of messages successfully claimed, without returning the actual message.
+Using this option means the retry counter is not incremented.
+
+The command returns the claimed entries as an array. It also returns a stream ID intended for cursor-like use as the `<start>` argument for its subsequent call.
+When there are no remaining PEL entries, the command returns the special `0-0` ID to signal completion.
+However, note that you may want to continue calling `XAUTOCLAIM` even after the scan is complete with the `0-0` as `<start>` ID, because enough time passed, so older pending entries may now be eligible for claiming.
+
+Note that only messages that are idle longer than `<min-idle-time>` are claimed, and claiming a message resets its idle time.
+This ensures that only a single consumer can successfully claim a given pending message at a specific instant of time and trivially reduces the probability of processing the same message multiple times.
+
+While iterating the PEL, if `XAUTOCLAIM` stumbles upon a message which doesn't exist in the stream anymore (either trimmed or deleted by [`XDEL`]({{< relref "/commands/xdel" >}})) it does not claim it, and deletes it from the PEL in which it was found. This feature was introduced in Redis 7.0.
+These message IDs are returned to the caller as a part of `XAUTOCLAIM`s reply.
+
+Lastly, claiming a message with `XAUTOCLAIM` also increments the attempted deliveries count for that message, unless the `JUSTID` option has been specified (which only delivers the message ID, not the message itself).
+Messages that cannot be processed for some reason - for example, because consumers systematically crash when processing them - will exhibit high attempted delivery counts that can be detected by monitoring.
+
+## Examples
+
+```
+> XAUTOCLAIM mystream mygroup Alice 3600000 0-0 COUNT 25
+1) "0-0"
+2) 1) 1) "1609338752495-0"
+      2) 1) "field"
+         2) "value"
+3) (empty array)
+```
+
+In the above example, we attempt to claim up to 25 entries that are pending and idle (not having been acknowledged or claimed) for at least an hour, starting at the stream's beginning.
+The consumer "Alice" from the "mygroup" group acquires ownership of these messages.
+Note that the stream ID returned in the example is `0-0`, indicating that the entire stream was scanned.
+We can also see that `XAUTOCLAIM` did not stumble upon any deleted messages (the third reply element is an empty array).
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+- allow_busy
+complexity: O(1)
+description: An internal command for configuring the replication stream.
+doc_flags:
+- syscmd
+group: server
+hidden: false
+linkTitle: REPLCONF
+since: 3.0.0
+summary: An internal command for configuring the replication stream.
+syntax_fmt: REPLCONF
+syntax_str: ''
+title: REPLCONF
+---
+The `REPLCONF` command is an internal command.
+It is used by a Redis master to configure a connected replica.---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: replicationid
+  name: replicationid
+  type: string
+- display_text: offset
+  name: offset
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+- no_multi
+description: An internal command used in replication.
+group: server
+hidden: false
+linkTitle: PSYNC
+since: 2.8.0
+summary: An internal command used in replication.
+syntax_fmt: PSYNC replicationid offset
+syntax_str: offset
+title: PSYNC
+---
+Initiates a replication stream from the master.
+
+The `PSYNC` command is called by Redis replicas for initiating a replication
+stream from the master.
+
+For more information about replication in Redis please check the
+[replication page]({{< relref "/operate/oss_and_stack/management/replication" >}}).
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the total number of elements in all given sets.
+description: Stores the union of multiple sets in a key.
+group: set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SUNIONSTORE
+since: 1.0.0
+summary: Stores the union of multiple sets in a key.
+syntax_fmt: SUNIONSTORE destination key [key ...]
+syntax_str: key [key ...]
+title: SUNIONSTORE
+---
+This command is equal to [`SUNION`]({{< relref "/commands/sunion" >}}), but instead of returning the resulting set,
+it is stored in `destination`.
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SUNIONSTORE key key1 key2
+SMEMBERS key
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements
+  in all the sets, N is the size of the first set, and K is the size of the result
+  set.
+description: Stores the difference of multiple sorted sets in a key.
+group: sorted-set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZDIFFSTORE
+since: 6.2.0
+summary: Stores the difference of multiple sorted sets in a key.
+syntax_fmt: ZDIFFSTORE destination numkeys key [key ...]
+syntax_str: numkeys key [key ...]
+title: ZDIFFSTORE
+---
+Computes the difference between the first and all successive input sorted sets
+and stores the result in `destination`. The total number of input keys is
+specified by `numkeys`.
+
+Keys that do not exist are considered to be empty sets.
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset1 3 "three"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZDIFFSTORE out 2 zset1 zset2
+ZRANGE out 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for Lua scripts management commands.
+group: scripting
+hidden: true
+linkTitle: SCRIPT
+since: 2.6.0
+summary: A container for Lua scripts management commands.
+syntax_fmt: SCRIPT
+syntax_str: ''
+title: SCRIPT
+---
+This is a container command for script management commands.
+
+To see the list of available commands you can call [`SCRIPT HELP`]({{< relref "/commands/script-help" >}}).
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- allow_busy
+complexity: O(1)
+description: Returns information about a function during execution.
+group: scripting
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_shards
+- response_policy:special
+linkTitle: FUNCTION STATS
+since: 7.0.0
+summary: Returns information about a function during execution.
+syntax_fmt: FUNCTION STATS
+syntax_str: ''
+title: FUNCTION STATS
+---
+Return information about the function that's currently running and information about the available execution engines.
+
+The reply is map with two keys:
+
+1. `running_script`: information about the running script.
+  If there's no in-flight function, the server replies with a _nil_.
+  Otherwise, this is a map with the following keys:
+  * **name:** the name of the function.
+  * **command:** the command and arguments used for invoking the function.
+  * **duration_ms:** the function's runtime duration in milliseconds.
+2. `engines`: this is a map of maps. Each entry in the map represent a single engine.
+   Engine map contains statistics about the engine like number of functions and number of libraries.
+
+
+You can use this command to inspect the invocation of a long-running function and decide whether kill it with the [`FUNCTION KILL`]({{< relref "/commands/function-kill" >}}) command.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: wherefrom
+  type: oneof
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: whereto
+  type: oneof
+arity: 5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+description: Returns an element after popping it from one list and pushing it to another.
+  Deletes the list if the last element was moved.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: LMOVE
+since: 6.2.0
+summary: Returns an element after popping it from one list and pushing it to another.
+  Deletes the list if the last element was moved.
+syntax_fmt: LMOVE source destination <LEFT | RIGHT> <LEFT | RIGHT>
+syntax_str: destination <LEFT | RIGHT> <LEFT | RIGHT>
+title: LMOVE
+---
+Atomically returns and removes the first/last element (head/tail depending on
+the `wherefrom` argument) of the list stored at `source`, and pushes the
+element at the first/last element (head/tail depending on the `whereto`
+argument) of the list stored at `destination`.
+
+For example: consider `source` holding the list `a,b,c`, and `destination`
+holding the list `x,y,z`.
+Executing `LMOVE source destination RIGHT LEFT` results in `source` holding
+`a,b` and `destination` holding `c,x,y,z`.
+
+If `source` does not exist, the value `nil` is returned and no operation is
+performed.
+If `source` and `destination` are the same, the operation is equivalent to
+removing the first/last element from the list and pushing it as first/last
+element of the list, so it can be considered as a list rotation command (or a
+no-op if `wherefrom` is the same as `whereto`).
+
+This command comes in place of the now deprecated [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}). Doing
+`LMOVE RIGHT LEFT` is equivalent.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "one"
+RPUSH mylist "two"
+RPUSH mylist "three"
+LMOVE mylist myotherlist RIGHT LEFT
+LMOVE mylist myotherlist LEFT RIGHT
+LRANGE mylist 0 -1
+LRANGE myotherlist 0 -1
+{{% /redis-cli %}}
+
+
+## Pattern: Reliable queue
+
+Redis is often used as a messaging server to implement processing of background
+jobs or other kinds of messaging tasks.
+A simple form of queue is often obtained pushing values into a list in the
+producer side, and waiting for this values in the consumer side using [`RPOP`]({{< relref "/commands/rpop" >}})
+(using polling), or [`BRPOP`]({{< relref "/commands/brpop" >}}) if the client is better served by a blocking
+operation.
+
+However in this context the obtained queue is not _reliable_ as messages can
+be lost, for example in the case there is a network problem or if the consumer
+crashes just after the message is received but it is still to process.
+
+`LMOVE` (or [`BLMOVE`]({{< relref "/commands/blmove" >}}) for the blocking variant) offers a way to avoid
+this problem: the consumer fetches the message and at the same time pushes it
+into a _processing_ list.
+It will use the [`LREM`]({{< relref "/commands/lrem" >}}) command in order to remove the message from the
+_processing_ list once the message has been processed.
+
+An additional client may monitor the _processing_ list for items that remain
+there for too much time, and will push those timed out items into the queue
+again if needed.
+
+## Pattern: Circular list
+
+Using `LMOVE` with the same source and destination key, a client can visit
+all the elements of an N-elements list, one after the other, in O(N) without
+transferring the full list from the server to the client using a single [`LRANGE`]({{< relref "/commands/lrange" >}})
+operation.
+
+The above pattern works even in the following conditions:
+
+* There are multiple clients rotating the list: they'll fetch different
+  elements, until all the elements of the list are visited, and the process
+  restarts.
+* Even if other clients are actively pushing new items at the end of the list.
+
+The above makes it very simple to implement a system where a set of items must
+be processed by N workers continuously as fast as possible.
+An example is a monitoring system that must check that a set of web sites are
+reachable, with the smallest delay possible, using a number of parallel workers.
+
+Note that this implementation of workers is trivially scalable and reliable,
+because even if a message is lost the item is still in the queue and will be
+processed at the next iteration.
+---
+acl_categories:
+- '@fast'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Returns the server time.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: TIME
+since: 2.6.0
+summary: Returns the server time.
+syntax_fmt: TIME
+syntax_str: ''
+title: TIME
+---
+The `TIME` command returns the current server time as a two items lists: a Unix
+timestamp and the amount of microseconds already elapsed in the current second.
+Basically the interface is very similar to the one of the `gettimeofday` system
+call.
+
+## Examples
+
+{{% redis-cli %}}
+TIME
+TIME
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@tdigest'
+- '@write'
+- '@slow'
+arguments:
+- name: destination-key
+  type: key
+- name: numkeys
+  type: integer
+- multiple: true
+  name: source-key
+  type: key
+- arguments:
+  - name: compression
+    token: COMPRESSION
+    type: pure-token
+  - name: compression
+    type: integer
+  name: config
+  optional: true
+  type: block
+- name: override
+  optional: true
+  token: OVERRIDE
+  type: pure-token
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N*K), where N is the number of centroids and K being the number of input
+  sketches
+description: Merges multiple t-digest sketches into a single sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.MERGE
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Merges multiple t-digest sketches into a single sketch
+syntax_fmt: "TDIGEST.MERGE destination-key numkeys source-key [source-key ...]\n \
+  \ [COMPRESSION compression] [OVERRIDE]"
+syntax_str: numkeys source-key [source-key ...] [COMPRESSION compression] [OVERRIDE]
+title: TDIGEST.MERGE
+---
+Merges multiple t-digest sketches into a single sketch.
+
+## Required arguments
+<details open><summary><code>destination-key</code></summary>
+
+is key name for a t-digest sketch to merge observation values to.
+
+If `destination-key` does not exist - a new sketch is created.
+
+If `destination-key` is an existing sketch, its values are merged with the values of the source keys. To override the destination key contents use `OVERRIDE`.
+</details>
+
+<details open><summary><code>numkeys</code></summary>
+Number of sketches to merge observation values from (1 or more).
+</details>
+
+<details open><summary><code>source-key</code></summary>
+each is a key name for a t-digest sketch to merge observation values from.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>COMPRESSION compression</code></summary>
+  
+is a controllable tradeoff between accuracy and memory consumption. 100 is a common value for normal uses. 1000 is more accurate. If no value is passed by default the compression will be 100. For more information on scaling of accuracy versus the compression parameter see [_The t-digest: Efficient estimates of distributions_](https://www.sciencedirect.com/science/article/pii/S2665963820300403).
+  
+When `COMPRESSION` is not specified:
+- If `destination-key` does not exist or if `OVERRIDE` is specified, the compression is set to the maximal value among all source sketches.
+- If `destination-key` already exists and `OVERRIDE` is not specified, its compression is not changed.
+
+</details>
+
+<details open><summary><code>OVERRIDE</code></summary>
+When specified, if `destination-key` already exists, it is overwritten.
+</details>
+
+## Return value
+
+OK on success, error otherwise.
+
+## Examples
+{{< highlight bash >}}
+redis> TDIGEST.CREATE s1
+OK
+redis> TDIGEST.CREATE s2
+OK
+redis> TDIGEST.ADD s1 10.0 20.0
+OK
+redis> TDIGEST.ADD s2 30.0 40.0
+OK
+redis> TDIGEST.MERGE sM 2 s1 s2
+OK
+redis> TDIGEST.BYRANK sM 0 1 2 3 4
+1) "10"
+2) "20"
+3) "30"
+4) "40"
+5) "inf"
+{{< / highlight >}}
+---
+acl_categories:
+- '@dangerous'
+- '@read'
+- '@search'
+- '@slow'
+arguments:
+- name: index
+  type: string
+- name: field_name
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N)
+description: Returns the distinct tags indexed in a Tag field
+doc_flags:
+- deprecated
+group: search
+hidden: false
+linkTitle: FT.TAGVALS
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Returns the distinct tags indexed in a Tag field
+syntax: 'FT.TAGVALS index field_name
+
+  '
+syntax_fmt: FT.TAGVALS index field_name
+syntax_str: field_name
+title: FT.TAGVALS
+---
+
+Return a distinct set of values indexed in a Tag field
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is full-text index name. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>field_name</code></summary>
+
+is name of a Tag file defined in the schema.
+</details>
+
+Use FT.TAGVALS if your tag indexes things like cities, categories, and so on.
+
+## Limitations
+
+FT.TAGVALS provides no paging or sorting, and the tags are not alphabetically sorted. FT.TAGVALS only operates on [tag fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}).
+The returned strings are lowercase with whitespaces removed, but otherwise unchanged.
+
+## Return
+
+FT.TAGVALS returns an array reply of all distinct tags in the tag index.
+
+## Examples
+
+<details open>
+<summary><b>Return a set of values indexed in a Tag field</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.TAGVALS idx myTag
+1) "Hello"
+2) "World"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) 
+
+## Related topics
+
+- [Tag fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}})
+- [RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: path
+  name: path
+  type: string
+- arguments:
+  - display_text: name
+    name: name
+    type: string
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  multiple_token: true
+  name: configs
+  optional: true
+  token: CONFIG
+  type: block
+- display_text: args
+  multiple: true
+  name: args
+  optional: true
+  token: ARGS
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+complexity: O(1)
+description: Loads a module using extended parameters.
+group: server
+hidden: false
+linkTitle: MODULE LOADEX
+since: 7.0.0
+summary: Loads a module using extended parameters.
+syntax_fmt: "MODULE LOADEX path [CONFIG\_name value [CONFIG name value ...]]\n  [ARGS\_\
+  args [args ...]]"
+syntax_str: "[CONFIG\_name value [CONFIG name value ...]] [ARGS\_args [args ...]]"
+title: MODULE LOADEX
+---
+Loads a module from a dynamic library at runtime with configuration directives.
+
+This is an extended version of the [`MODULE LOAD`]({{< relref "/commands/module-load" >}}) command.
+
+It loads and initializes the Redis module from the dynamic library specified by the `path` argument. The `path` should be the absolute path of the library, including the full filename.
+
+You can use the optional `CONFIG` argument to provide the module with configuration directives.
+Any additional arguments that follow the `ARGS` keyword are passed unmodified to the module.
+
+**Note**: modules can also be loaded at server startup with `loadmodule`
+configuration directive in `redis.conf`.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: count
+    name: count
+    type: integer
+  - display_text: reset
+    name: reset
+    token: RESET
+    type: pure-token
+  name: operation
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) with N being the number of entries shown.
+description: Lists recent security events generated due to ACL rules.
+group: server
+hidden: false
+history:
+- - 7.2.0
+  - Added entry ID, timestamp created, and timestamp last updated.
+linkTitle: ACL LOG
+since: 6.0.0
+summary: Lists recent security events generated due to ACL rules.
+syntax_fmt: ACL LOG [count | RESET]
+syntax_str: ''
+title: ACL LOG
+---
+The command shows a list of recent ACL security events:
+
+1. Failures to authenticate their connections with [`AUTH`]({{< relref "/commands/auth" >}}) or [`HELLO`]({{< relref "/commands/hello" >}}).
+2. Commands denied because against the current ACL rules.
+3. Commands denied because accessing keys not allowed in the current ACL rules.
+
+The optional argument specifies how many entries to show. By default
+up to ten failures are returned. The special [`RESET`]({{< relref "/commands/reset" >}}) argument clears the log.
+Entries are displayed starting from the most recent.
+
+## Examples
+
+```
+> AUTH someuser wrongpassword
+(error) WRONGPASS invalid username-password pair
+> ACL LOG 1
+1)  1) "count"
+    2) (integer) 1
+    3) "reason"
+    4) "auth"
+    5) "context"
+    6) "toplevel"
+    7) "object"
+    8) "AUTH"
+    9) "username"
+   10) "someuser"
+   11) "age-seconds"
+   12) "8.038"
+   13) "client-info"
+   14) "id=3 addr=127.0.0.1:57275 laddr=127.0.0.1:6379 fd=8 name= age=16 idle=0 flags=N db=0 sub=0 psub=0 ssub=0 multi=-1 qbuf=48 qbuf-free=16842 argv-mem=25 multi-mem=0 rbs=1024 rbp=0 obl=0 oll=0 omem=0 tot-mem=18737 events=r cmd=auth user=default redir=-1 resp=2"
+   15) "entry-id"
+   16) (integer) 0
+   17) "timestamp-created"
+   18) (integer) 1675361492408
+   19) "timestamp-last-updated"
+   20) (integer) 1675361492408
+```
+
+Each log entry is composed of the following fields:
+
+1. `count`: The number of security events detected within a 60 second period that are represented by this entry.
+2. `reason`: The reason that the security events were logged. Either `command`, `key`, `channel`, or `auth`.
+3. `context`: The context that the security events were detected in. Either `toplevel`, `multi`, `lua`, or `module`.
+4. `object`: The resource that the user had insufficient permissions to access. `auth` when the reason is `auth`.
+5. `username`: The username that executed the command that caused the security events or the username that had a failed authentication attempt.
+6. `age-seconds`: Age of the log entry in seconds.
+7. `client-info`: Displays the client info of a client which caused one of the security events.
+8. `entry-id`: The sequence number of the entry (starting at 0) since the server process started. Can also be used to check if items were “lost”, if they fell between periods.
+9. `timestamp-created`: A UNIX timestamp in `milliseconds` at the time the entry was first created.
+10. `timestamp-last-updated`: A UNIX timestamp in `milliseconds` at the time the entry was last updated.---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  multiple: true
+  name: element
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each element added, so O(N) to add N elements when the command
+  is called with multiple arguments.
+description: Appends an element to a list only when the list exists.
+group: list
+hidden: false
+history:
+- - 4.0.0
+  - Accepts multiple `element` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: RPUSHX
+since: 2.2.0
+summary: Appends an element to a list only when the list exists.
+syntax_fmt: RPUSHX key element [element ...]
+syntax_str: element [element ...]
+title: RPUSHX
+---
+Inserts specified values at the tail of the list stored at `key`, only if `key`
+already exists and holds a list.
+In contrary to [`RPUSH`]({{< relref "/commands/rpush" >}}), no operation will be performed when `key` does not yet
+exist.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "Hello"
+RPUSHX mylist "World"
+RPUSHX myotherlist "World"
+LRANGE mylist 0 -1
+LRANGE myotherlist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@json'
+- '@read'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value, where N is the size of
+  the value, O(N) when path is evaluated to multiple values, where N is the size of
+  the key
+description: Reports the size in bytes of a key
+group: json
+hidden: false
+linkTitle: JSON.DEBUG MEMORY
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Reports the size in bytes of a key
+syntax_fmt: JSON.DEBUG MEMORY key [path]
+syntax_str: '[path]'
+title: JSON.DEBUG MEMORY
+---
+Report a value's memory usage in bytes 
+
+{{< warning >}}
+The actual total memory consumption by a key could be much lower than the value reported by this command because of an internal JSON string reuse mechanism. For more information, see the [JSON memory usage page]({{< relref "/develop/data-types/json/ram#json-string-reuse-mechanism" >}}).
+{{< /warning >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. 
+</details>
+
+## Return
+
+JSON.DEBUG MEMORY returns an integer reply specified as the value size in bytes.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Report a value's memory usage in bytes</b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":64.99,"stock":17,"colors":["black","white"], "max_level":[80, 100, 120]}'
+OK
+{{< / highlight >}}
+
+Get the values' memory usage in bytes.
+
+{{< highlight bash >}}
+redis> JSON.DEBUG MEMORY item:2
+(integer) 573
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.ARRLEN`]({{< relref "commands/json.arrlen/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: count
+    name: count
+    type: integer
+  - display_text: withvalues
+    name: withvalues
+    optional: true
+    token: WITHVALUES
+    type: pure-token
+  name: options
+  optional: true
+  type: block
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the number of fields returned
+description: Returns one or more random fields from a hash.
+group: hash
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HRANDFIELD
+since: 6.2.0
+summary: Returns one or more random fields from a hash.
+syntax_fmt: HRANDFIELD key [count [WITHVALUES]]
+syntax_str: '[count [WITHVALUES]]'
+title: HRANDFIELD
+---
+When called with just the `key` argument, return a random field from the hash value stored at `key`.
+
+If the provided `count` argument is positive, return an array of **distinct fields**.
+The array's length is either `count` or the hash's number of fields ([`HLEN`]({{< relref "/commands/hlen" >}})), whichever is lower.
+
+If called with a negative `count`, the behavior changes and the command is allowed to return the **same field multiple times**.
+In this case, the number of returned fields is the absolute value of the specified `count`.
+
+The optional `WITHVALUES` modifier changes the reply so it includes the respective values of the randomly selected hash fields.
+
+## Examples
+
+{{% redis-cli %}}
+HSET coin heads obverse tails reverse edge null
+HRANDFIELD coin
+HRANDFIELD coin
+HRANDFIELD coin -5 WITHVALUES
+{{% /redis-cli %}}
+
+
+## Specification of the behavior when count is passed
+
+When the `count` argument is a positive value this command behaves as follows:
+
+* No repeated fields are returned.
+* If `count` is bigger than the number of fields in the hash, the command will only return the whole hash without additional fields.
+* The order of fields in the reply is not truly random, so it is up to the client to shuffle them if needed.
+
+When the `count` is a negative value, the behavior changes as follows:
+
+* Repeating fields are possible.
+* Exactly `count` fields, or an empty array if the hash is empty (non-existing key), are always returned.
+* The order of fields in the reply is truly random.
+---
+acl_categories:
+- '@cms'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: error
+  type: double
+- name: probability
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Initializes a Count-Min Sketch to accommodate requested tolerances.
+group: cms
+hidden: false
+linkTitle: CMS.INITBYPROB
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Initializes a Count-Min Sketch to accommodate requested tolerances.
+syntax_fmt: CMS.INITBYPROB key error probability
+syntax_str: error probability
+title: CMS.INITBYPROB
+---
+Initializes a Count-Min Sketch to accommodate requested tolerances.
+
+### Parameters:
+
+* **key**: The name of the sketch.
+* **error**: Estimate size of error. The error is a percent of total counted
+    items. This effects the width of the sketch.
+* **probability**: The desired probability for inflated count. This should
+    be a decimal value between 0 and 1. This effects the depth of the sketch.
+    For example, for a desired false positive rate of 0.1% (1 in 1000),
+    error_rate should be set to 0.001. The closer this number is to zero, the
+    greater the memory consumption per item and the more CPU usage per operation. 
+    
+## Return
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+```
+redis> CMS.INITBYPROB test 0.001 0.01
+OK
+```---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  multiple: true
+  name: field
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of fields being requested.
+description: Returns the values of all fields in a hash.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HMGET
+since: 2.0.0
+summary: Returns the values of all fields in a hash.
+syntax_fmt: HMGET key field [field ...]
+syntax_str: field [field ...]
+title: HMGET
+---
+Returns the values associated with the specified `fields` in the hash stored at
+`key`.
+
+For every `field` that does not exist in the hash, a `nil` value is returned.
+Because non-existing keys are treated as empty hashes, running `HMGET` against
+a non-existing `key` will return a list of `nil` values.
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HSET myhash field2 "World"
+HMGET myhash field1 field2 nofield
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- arguments:
+  - display_text: key
+    key_spec_index: 0
+    name: key
+    type: key
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the number of keys to set.
+description: Atomically modifies the string values of one or more keys only when all
+  keys don't exist.
+group: string
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 2
+      lastkey: -1
+      limit: 0
+    type: range
+  insert: true
+linkTitle: MSETNX
+since: 1.0.1
+summary: Atomically modifies the string values of one or more keys only when all keys
+  don't exist.
+syntax_fmt: MSETNX key value [key value ...]
+syntax_str: ''
+title: MSETNX
+---
+Sets the given keys to their respective values.
+`MSETNX` will not perform any operation at all even if just a single key already
+exists.
+
+Because of this semantic `MSETNX` can be used in order to set different keys
+representing different fields of a unique logic object in a way that ensures
+that either all the fields or none at all are set.
+
+`MSETNX` is atomic, so all given keys are set at once.
+It is not possible for clients to see that some of the keys were updated while
+others are unchanged.
+
+## Examples
+
+{{% redis-cli %}}
+MSETNX key1 "Hello" key2 "there"
+MSETNX key2 "new" key3 "world"
+MGET key1 key2 key3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: seconds
+    name: seconds
+    token: EX
+    type: integer
+  - display_text: milliseconds
+    name: milliseconds
+    token: PX
+    type: integer
+  - display_text: unix-time-seconds
+    name: unix-time-seconds
+    token: EXAT
+    type: unix-time
+  - display_text: unix-time-milliseconds
+    name: unix-time-milliseconds
+    token: PXAT
+    type: unix-time
+  - display_text: persist
+    name: persist
+    token: PERSIST
+    type: pure-token
+  name: expiration
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Returns the string value of a key after setting its expiration time.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  notes: RW and UPDATE because it changes the TTL
+  update: true
+linkTitle: GETEX
+since: 6.2.0
+summary: Returns the string value of a key after setting its expiration time.
+syntax_fmt: "GETEX key [EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds |\n\
+  \  PXAT\_unix-time-milliseconds | PERSIST]"
+syntax_str: "[EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds | PXAT\_unix-time-milliseconds\
+  \ | PERSIST]"
+title: GETEX
+---
+Get the value of `key` and optionally set its expiration.
+`GETEX` is similar to [`GET`]({{< relref "/commands/get" >}}), but is a write command with additional options.
+
+## Options
+
+The `GETEX` command supports a set of options that modify its behavior:
+
+* `EX` *seconds* -- Set the specified expire time, in seconds.
+* `PX` *milliseconds* -- Set the specified expire time, in milliseconds.
+* `EXAT` *timestamp-seconds* -- Set the specified Unix time at which the key will expire, in seconds.
+* `PXAT` *timestamp-milliseconds* -- Set the specified Unix time at which the key will expire, in milliseconds.
+* [`PERSIST`]({{< relref "/commands/persist" >}}) -- Remove the time to live associated with the key.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+GETEX mykey
+TTL mykey
+GETEX mykey EX 60
+TTL mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: nomkstream
+  name: nomkstream
+  optional: true
+  since: 6.2.0
+  token: NOMKSTREAM
+  type: pure-token
+- arguments:
+  - arguments:
+    - display_text: maxlen
+      name: maxlen
+      token: MAXLEN
+      type: pure-token
+    - display_text: minid
+      name: minid
+      since: 6.2.0
+      token: MINID
+      type: pure-token
+    name: strategy
+    type: oneof
+  - arguments:
+    - display_text: equal
+      name: equal
+      token: '='
+      type: pure-token
+    - display_text: approximately
+      name: approximately
+      token: '~'
+      type: pure-token
+    name: operator
+    optional: true
+    type: oneof
+  - display_text: threshold
+    name: threshold
+    type: string
+  - display_text: count
+    name: count
+    optional: true
+    since: 6.2.0
+    token: LIMIT
+    type: integer
+  name: trim
+  optional: true
+  type: block
+- arguments:
+  - display_text: auto-id
+    name: auto-id
+    token: '*'
+    type: pure-token
+  - display_text: id
+    name: id
+    type: string
+  name: id-selector
+  type: oneof
+- arguments:
+  - display_text: field
+    name: field
+    type: string
+  - display_text: value
+    name: value
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) when adding a new entry, O(N) when trimming where N being the number
+  of entries evicted.
+description: Appends a new message to a stream. Creates the key if it doesn't exist.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 6.2.0
+  - Added the `NOMKSTREAM` option, `MINID` trimming strategy and the `LIMIT` option.
+- - 7.0.0
+  - Added support for the `<ms>-*` explicit ID form.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  notes: UPDATE instead of INSERT because of the optional trimming feature
+  update: true
+linkTitle: XADD
+since: 5.0.0
+summary: Appends a new message to a stream. Creates the key if it doesn't exist.
+syntax_fmt: "XADD key [NOMKSTREAM] [<MAXLEN | MINID> [= | ~] threshold\n  [LIMIT\_\
+  count]] <* | id> field value [field value ...]"
+syntax_str: "[NOMKSTREAM] [<MAXLEN | MINID> [= | ~] threshold [LIMIT\_count]] <* |\
+  \ id> field value [field value ...]"
+title: XADD
+---
+Appends the specified stream entry to the stream at the specified key.
+If the key does not exist, as a side effect of running this command the
+key is created with a stream value. The creation of stream's key can be
+disabled with the `NOMKSTREAM` option.
+
+An entry is composed of a list of field-value pairs.
+The field-value pairs are stored in the same order they are given by the user.
+Commands that read the stream, such as [`XRANGE`]({{< relref "/commands/xrange" >}}) or [`XREAD`]({{< relref "/commands/xread" >}}), are guaranteed to return the fields and values exactly in the same order they were added by `XADD`.
+
+`XADD` is the *only Redis command* that can add data to a stream, but 
+there are other commands, such as [`XDEL`]({{< relref "/commands/xdel" >}}) and [`XTRIM`]({{< relref "/commands/xtrim" >}}), that are able to
+remove data from a stream.
+
+## Specifying a Stream ID as an argument
+
+A stream entry ID identifies a given entry inside a stream.
+
+The `XADD` command will auto-generate a unique ID for you if the ID argument
+specified is the `*` character (asterisk ASCII character). However, while
+useful only in very rare cases, it is possible to specify a well-formed ID, so
+that the new entry will be added exactly with the specified ID.
+
+IDs are specified by two numbers separated by a `-` character:
+
+    1526919030474-55
+
+Both quantities are 64-bit numbers. When an ID is auto-generated, the
+first part is the Unix time in milliseconds of the Redis instance generating
+the ID. The second part is just a sequence number and is used in order to
+distinguish IDs generated in the same millisecond.
+
+You can also specify an incomplete ID, that consists only of the milliseconds part, which is interpreted as a zero value for sequence part.
+To have only the sequence part automatically generated, specify the milliseconds part followed by the `-` separator and the `*` character:
+
+```
+> XADD mystream 1526919030474-55 message "Hello,"
+"1526919030474-55"
+> XADD mystream 1526919030474-* message " World!"
+"1526919030474-56"
+```
+
+IDs are guaranteed to be always incremental: If you compare the ID of the
+entry just inserted it will be greater than any other past ID, so entries
+are totally ordered inside a stream. In order to guarantee this property,
+if the current top ID in the stream has a time greater than the current
+local time of the instance, the top entry time will be used instead, and
+the sequence part of the ID incremented. This may happen when, for instance,
+the local clock jumps backward, or if after a failover the new master has
+a different absolute time.
+
+When a user specified an explicit ID to `XADD`, the minimum valid ID is
+`0-1`, and the user *must* specify an ID which is greater than any other
+ID currently inside the stream, otherwise the command will fail and return an error. Usually
+resorting to specific IDs is useful only if you have another system generating
+unique IDs (for instance an SQL table) and you really want the Redis stream
+IDs to match the one of this other system.
+
+## Capped streams
+
+`XADD` incorporates the same semantics as the [`XTRIM`]({{< relref "/commands/xtrim" >}}) command - refer to its documentation page for more information.
+This allows adding new entries and keeping the stream's size in check with a single call to `XADD`, effectively capping the stream with an arbitrary threshold.
+Although exact trimming is possible and is the default, due to the internal representation of streams it is more efficient to add an entry and trim stream with `XADD` using **almost exact** trimming (the `~` argument).
+
+For example, calling `XADD` in the following form:
+
+    XADD mystream MAXLEN ~ 1000 * ... entry fields here ...
+ 
+Will add a new entry but will also evict old entries so that the stream will contain only 1000 entries, or at most a few tens more.
+
+## Additional information about streams
+
+For further information about Redis streams please check our
+[introduction to Redis Streams document]({{< relref "/develop/data-types/streams" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+XADD mystream * name Sara surname OConnor
+XADD mystream * field1 value1 field2 value2 field3 value3
+XLEN mystream
+XRANGE mystream - +
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@topk'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of items
+description: Checks whether one or more items are in a sketch
+group: topk
+hidden: false
+linkTitle: TOPK.QUERY
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Checks whether one or more items are in a sketch
+syntax_fmt: TOPK.QUERY key item [item ...]
+syntax_str: item [item ...]
+title: TOPK.QUERY
+---
+Checks whether an item is one of Top-K items.
+Multiple items can be checked at once.
+
+### Parameters
+
+* **key**: Name of sketch where item is queried.
+* **item**: Item/s to be queried.
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - "1" if item is in Top-K, otherwise "0".
+
+## Examples
+
+```
+redis> TOPK.QUERY topk 42 nonexist
+1) (integer) 1
+2) (integer) 0
+```---
+acl_categories:
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: section
+  multiple: true
+  name: section
+  optional: true
+  type: string
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns information and statistics about the server.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_shards
+- response_policy:special
+history:
+- - 7.0.0
+  - Added support for taking multiple section arguments.
+linkTitle: INFO
+since: 1.0.0
+summary: Returns information and statistics about the server.
+syntax_fmt: INFO [section [section ...]]
+syntax_str: ''
+title: INFO
+---
+The `INFO` command returns information and statistics about the server in a
+format that is simple to parse by computers and easy to read by humans.
+
+The optional parameter can be used to select a specific section of information:
+
+*   `server`: General information about the Redis server
+*   `clients`: Client connections section
+*   `memory`: Memory consumption related information
+*   `persistence`: RDB and AOF related information
+*   `threads`: I/O threads information
+*   `stats`: General statistics
+*   `replication`: Master/replica replication information
+*   `cpu`: CPU consumption statistics
+*   `commandstats`: Redis command statistics
+*   `latencystats`: Redis command latency percentile distribution statistics
+*   `sentinel`: Redis Sentinel section (only applicable to Sentinel instances)
+*   `cluster`: Redis Cluster section
+*   `modules`: Modules section
+*   `keyspace`: Database related statistics
+*   `errorstats`: Redis error statistics
+
+It can also take the following values:
+
+*   `all`: Return all sections (excluding module generated ones)
+*   `default`: Return only the default set of sections
+*   `everything`: Includes `all` and `modules`
+
+When no parameter is provided, the `default` option is assumed.
+
+{{< clients-example cmds_servermgmt info >}}
+INFO
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+INFO
+{{% /redis-cli %}}
+
+
+## Notes
+
+Please note depending on the version of Redis some of the fields have been
+added or removed. A robust client application should therefore parse the
+result of this command by skipping unknown properties, and gracefully handle
+missing fields.
+
+Here is the description of fields for Redis >= 2.4.
+
+
+Here is the meaning of all fields in the **server** section:
+
+*   `redis_version`: Version of the Redis server
+*   `redis_git_sha1`:  Git SHA1
+*   `redis_git_dirty`: Git dirty flag
+*   `redis_build_id`: The build id
+*   `redis_mode`: The server's mode ("standalone", "sentinel" or "cluster")
+*   `os`: Operating system hosting the Redis server
+*   `arch_bits`: Architecture (32 or 64 bits)
+*   `multiplexing_api`: Event loop mechanism used by Redis
+*   `atomicvar_api`: Atomicvar API used by Redis
+*   `gcc_version`: Version of the GCC compiler used to compile the Redis server
+*   `process_id`: PID of the server process
+*   `process_supervised`: Supervised system ("upstart", "systemd", "unknown" or "no")
+*   `run_id`: Random value identifying the Redis server (to be used by Sentinel
+     and Cluster)
+*   `tcp_port`: TCP/IP listen port
+*   `server_time_usec`: Epoch-based system time with microsecond precision
+*   `uptime_in_seconds`: Number of seconds since Redis server start
+*   `uptime_in_days`: Same value expressed in days
+*   `hz`: The server's current frequency setting
+*   `configured_hz`: The server's configured frequency setting
+*   `lru_clock`: Clock incrementing every minute, for LRU management
+*   `executable`: The path to the server's executable
+*   `config_file`: The path to the config file
+*   `io_threads_active`: Flag indicating if I/O threads are active
+*   `shutdown_in_milliseconds`: The maximum time remaining for replicas to catch up the replication before completing the shutdown sequence.
+    This field is only present during shutdown.
+
+Here is the meaning of all fields in the **clients** section:
+
+*   `connected_clients`: Number of client connections (excluding connections
+     from replicas)
+*   `cluster_connections`: An approximation of the number of sockets used by the
+     cluster's bus
+*   `maxclients`: The value of the `maxclients` configuration directive. This is
+    the upper limit for the sum of `connected_clients`, `connected_slaves` and
+    `cluster_connections`.
+*   `client_recent_max_input_buffer`: Biggest input buffer among current client connections
+*   `client_recent_max_output_buffer`: Biggest output buffer among current client connections
+*   `blocked_clients`: Number of clients pending on a blocking call ([`BLPOP`]({{< relref "/commands/blpop" >}}),
+     [`BRPOP`]({{< relref "/commands/brpop" >}}), [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}), [`BLMOVE`]({{< relref "/commands/blmove" >}}), [`BZPOPMIN`]({{< relref "/commands/bzpopmin" >}}), [`BZPOPMAX`]({{< relref "/commands/bzpopmax" >}}))
+*   `tracking_clients`: Number of clients being tracked ([`CLIENT TRACKING`]({{< relref "/commands/client-tracking" >}}))
+*   `pubsub_clients`: Number of clients in pubsub mode ([`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}), [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}}), [`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}})). Added in Redis 7.4
+*   `watching_clients`: Number of clients in watching mode ([`WATCH`]({{< relref "/commands/watch" >}})). Added in Redis 7.4
+*   `clients_in_timeout_table`: Number of clients in the clients timeout table
+*   `total_watched_keys`: Number of watched keys. Added in Redis 7.4.
+*   `total_blocking_keys`: Number of blocking keys. Added in Redis 7.2.
+*   `total_blocking_keys_on_nokey`: Number of blocking keys that one or more clients that would like to be unblocked when the key is deleted. Added in Redis 7.2.
+
+Here is the meaning of all fields in the **memory** section:
+
+*   `used_memory`: Total number of bytes allocated by Redis using its
+     allocator (either standard **libc**, **jemalloc**, or an alternative
+     allocator such as [**tcmalloc**][hcgcpgp])
+*   `used_memory_human`: Human readable representation of previous value
+*   `used_memory_rss`: Number of bytes that Redis allocated as seen by the
+     operating system (a.k.a resident set size). This is the number reported by
+     tools such as `top(1)` and `ps(1)`
+*   `used_memory_rss_human`: Human readable representation of previous value
+*   `used_memory_peak`: Peak memory consumed by Redis (in bytes)
+*   `used_memory_peak_human`: Human readable representation of previous value
+*   `used_memory_peak_perc`: The percentage of `used_memory` out of `used_memory_peak`
+*   `used_memory_overhead`: The sum in bytes of all overheads that the server
+     allocated for managing its internal data structures
+*   `used_memory_startup`: Initial amount of memory consumed by Redis at startup
+     in bytes
+*   `used_memory_dataset`: The size in bytes of the dataset
+     (`used_memory_overhead` subtracted from `used_memory`)
+*   `used_memory_dataset_perc`: The percentage of `used_memory_dataset` out of
+     the net memory usage (`used_memory` minus `used_memory_startup`)
+*   `total_system_memory`: The total amount of memory that the Redis host has
+*   `total_system_memory_human`: Human readable representation of previous value
+*   `used_memory_lua`: Number of bytes used by the Lua engine for EVAL scripts. Deprecated in Redis 7.0, renamed to `used_memory_vm_eval`
+*   `used_memory_vm_eval`: Number of bytes used by the script VM engines for EVAL framework (not part of used_memory). Added in Redis 7.0
+*   `used_memory_lua_human`: Human readable representation of previous value. Deprecated in Redis 7.0
+*   `used_memory_scripts_eval`: Number of bytes overhead by the EVAL scripts (part of used_memory). Added in Redis 7.0
+*   `number_of_cached_scripts`: The number of EVAL scripts cached by the server. Added in Redis 7.0
+*   `number_of_functions`: The number of functions. Added in Redis 7.0
+*   `number_of_libraries`: The number of libraries. Added in Redis 7.0
+*   `used_memory_vm_functions`: Number of bytes used by the script VM engines for Functions framework (not part of used_memory). Added in Redis 7.0
+*   `used_memory_vm_total`: `used_memory_vm_eval` + `used_memory_vm_functions` (not part of used_memory). Added in Redis 7.0
+*   `used_memory_vm_total_human`: Human readable representation of previous value.
+*   `used_memory_functions`: Number of bytes overhead by Function scripts (part of used_memory). Added in Redis 7.0
+*   `used_memory_scripts`: `used_memory_scripts_eval` + `used_memory_functions` (part of used_memory). Added in Redis 7.0
+*   `used_memory_scripts_human`: Human readable representation of previous value
+*   `maxmemory`: The value of the `maxmemory` configuration directive
+*   `maxmemory_human`: Human readable representation of previous value
+*   `maxmemory_policy`: The value of the `maxmemory-policy` configuration
+     directive
+*   `mem_fragmentation_ratio`: Ratio between `used_memory_rss` and `used_memory`.
+    Note that this doesn't only includes fragmentation, but also other process overheads (see the `allocator_*` metrics), and also overheads like code, shared libraries, stack, etc.
+*   `mem_fragmentation_bytes`: Delta between `used_memory_rss` and `used_memory`.
+    Note that when the total fragmentation bytes is low (few megabytes), a high ratio (e.g. 1.5 and above) is not an indication of an issue.
+*   `allocator_frag_ratio:`: Ratio between `allocator_active` and `allocator_allocated`. This is the true (external) fragmentation metric (not `mem_fragmentation_ratio`).
+*   `allocator_frag_bytes` Delta between `allocator_active` and `allocator_allocated`. See note about `mem_fragmentation_bytes`.
+*   `allocator_rss_ratio`: Ratio between `allocator_resident` and `allocator_active`. This usually indicates pages that the allocator can and probably will soon release back to the OS.
+*   `allocator_rss_bytes`: Delta between `allocator_resident` and `allocator_active`
+*   `rss_overhead_ratio`: Ratio between `used_memory_rss` (the process RSS) and `allocator_resident`. This includes RSS overheads that are not allocator or heap related.
+*   `rss_overhead_bytes`: Delta between `used_memory_rss` (the process RSS) and `allocator_resident`
+*   `allocator_allocated`: Total bytes allocated form the allocator, including internal-fragmentation. Normally the same as `used_memory`.
+*   `allocator_active`: Total bytes in the allocator active pages, this includes external-fragmentation.
+*   `allocator_resident`: Total bytes resident (RSS) in the allocator, this includes pages that can be released to the OS (by [`MEMORY PURGE`]({{< relref "/commands/memory-purge" >}}), or just waiting).
+*   `allocator_muzzy`: Total bytes of 'muzzy' memory (RSS) in the allocator. Muzzy memory is memory that has been freed, but not yet fully returned to the operating system. It can be reused immediately when needed or reclaimed by the OS when system pressure increases.
+*   `mem_not_counted_for_evict`: Used memory that's not counted for key eviction. This is basically transient replica and AOF buffers.
+*   `mem_clients_slaves`: Memory used by replica clients - Starting Redis 7.0, replica buffers share memory with the replication backlog, so this field can show 0 when replicas don't trigger an increase of memory usage.
+*   `mem_clients_normal`: Memory used by normal clients
+*   `mem_cluster_links`: Memory used by links to peers on the cluster bus when cluster mode is enabled.
+*   `mem_aof_buffer`: Transient memory used for AOF and AOF rewrite buffers
+*   `mem_replication_backlog`: Memory used by replication backlog
+*   `mem_total_replication_buffers`: Total memory consumed for replication buffers - Added in Redis 7.0.
+*   `mem_allocator`: Memory allocator, chosen at compile time.
+*   `mem_overhead_db_hashtable_rehashing`: Temporary memory overhead of database dictionaries currently being rehashed - Added in 7.4.
+*   `active_defrag_running`: When `activedefrag` is enabled, this indicates whether defragmentation is currently active, and the CPU percentage it intends to utilize.
+*   `lazyfree_pending_objects`: The number of objects waiting to be freed (as a
+     result of calling [`UNLINK`]({{< relref "/commands/unlink" >}}), or [`FLUSHDB`]({{< relref "/commands/flushdb" >}}) and [`FLUSHALL`]({{< relref "/commands/flushall" >}}) with the **ASYNC**
+     option)
+*   `lazyfreed_objects`: The number of objects that have been lazy freed.
+
+Ideally, the `used_memory_rss` value should be only slightly higher than
+`used_memory`.
+When rss >> used, a large difference may mean there is (external) memory fragmentation, which can be evaluated by checking
+`allocator_frag_ratio`, `allocator_frag_bytes`.
+When used >> rss, it means part of Redis memory has been swapped off by the
+operating system: expect some significant latencies.
+
+Because Redis does not have control over how its allocations are mapped to
+memory pages, high `used_memory_rss` is often the result of a spike in memory
+usage.
+
+When Redis frees memory, the memory is given back to the allocator, and the
+allocator may or may not give the memory back to the system. There may be
+a discrepancy between the `used_memory` value and memory consumption as
+reported by the operating system. It may be due to the fact memory has been
+used and released by Redis, but not given back to the system. The
+`used_memory_peak` value is generally useful to check this point.
+
+Additional introspective information about the server's memory can be obtained
+by referring to the [`MEMORY STATS`]({{< relref "/commands/memory-stats" >}}) command and the [`MEMORY DOCTOR`]({{< relref "/commands/memory-doctor" >}}).
+
+Here is the meaning of all fields in the **persistence** section:
+
+*   `loading`: Flag indicating if the load of a dump file is on-going
+*   `async_loading`: Currently loading replication data-set asynchronously while serving old data. This means `repl-diskless-load` is enabled and set to `swapdb`. Added in Redis 7.0.
+*   `current_cow_peak`: The peak size in bytes of copy-on-write memory
+     while a child fork is running
+*   `current_cow_size`: The size in bytes of copy-on-write memory
+     while a child fork is running
+*   `current_cow_size_age`: The age, in seconds, of the `current_cow_size` value.
+*   `current_fork_perc`: The percentage of progress of the current fork process. For AOF and RDB forks it is the percentage of `current_save_keys_processed` out of `current_save_keys_total`.
+*   `current_save_keys_processed`: Number of keys processed by the current save operation
+*   `current_save_keys_total`: Number of keys at the beginning of the current save operation 
+*   `rdb_changes_since_last_save`: Number of changes since the last dump
+*   `rdb_bgsave_in_progress`: Flag indicating a RDB save is on-going
+*   `rdb_last_save_time`: Epoch-based timestamp of last successful RDB save
+*   `rdb_last_bgsave_status`: Status of the last RDB save operation
+*   `rdb_last_bgsave_time_sec`: Duration of the last RDB save operation in
+     seconds
+*   `rdb_current_bgsave_time_sec`: Duration of the on-going RDB save operation
+     if any
+*   `rdb_last_cow_size`: The size in bytes of copy-on-write memory during
+     the last RDB save operation
+*   `rdb_last_load_keys_expired`: Number of volatile keys deleted during the last RDB loading. Added in Redis 7.0.
+*   `rdb_last_load_keys_loaded`: Number of keys loaded during the last RDB loading. Added in Redis 7.0.
+*   `aof_enabled`: Flag indicating AOF logging is activated
+*   `aof_rewrite_in_progress`: Flag indicating a AOF rewrite operation is
+     on-going
+*   `aof_rewrite_scheduled`: Flag indicating an AOF rewrite operation
+     will be scheduled once the on-going RDB save is complete.
+*   `aof_last_rewrite_time_sec`: Duration of the last AOF rewrite operation in
+     seconds
+*   `aof_current_rewrite_time_sec`: Duration of the on-going AOF rewrite
+     operation if any
+*   `aof_last_bgrewrite_status`: Status of the last AOF rewrite operation
+*   `aof_last_write_status`: Status of the last write operation to the AOF
+*   `aof_last_cow_size`: The size in bytes of copy-on-write memory during
+     the last AOF rewrite operation
+*   `module_fork_in_progress`: Flag indicating a module fork is on-going
+*   `module_fork_last_cow_size`: The size in bytes of copy-on-write memory
+     during the last module fork operation
+*   `aof_rewrites`: Number of AOF rewrites performed since startup
+*   `rdb_saves`: Number of RDB snapshots performed since startup
+
+`rdb_changes_since_last_save` refers to the number of operations that produced
+some kind of changes in the dataset since the last time either [`SAVE`]({{< relref "/commands/save" >}}) or
+[`BGSAVE`]({{< relref "/commands/bgsave" >}}) was called.
+
+If AOF is activated, these additional fields will be added:
+
+*   `aof_current_size`: AOF current file size
+*   `aof_base_size`: AOF file size on latest startup or rewrite
+*   `aof_pending_rewrite`: Flag indicating an AOF rewrite operation
+     will be scheduled once the on-going RDB save is complete.
+*   `aof_buffer_length`: Size of the AOF buffer
+*   `aof_rewrite_buffer_length`: Size of the AOF rewrite buffer. Note this field was removed in Redis 7.0
+*   `aof_pending_bio_fsync`: Number of fsync pending jobs in background I/O
+     queue
+*   `aof_delayed_fsync`: Delayed fsync counter
+
+If a load operation is on-going, these additional fields will be added:
+
+*   `loading_start_time`: Epoch-based timestamp of the start of the load
+     operation
+*   `loading_total_bytes`: Total file size
+*   `loading_rdb_used_mem`: The memory usage of the server that had generated
+    the RDB file at the time of the file's creation
+*   `loading_loaded_bytes`: Number of bytes already loaded
+*   `loading_loaded_perc`: Same value expressed as a percentage
+*   `loading_eta_seconds`: ETA in seconds for the load to be complete
+
+The **threads** section provides statistics on I/O threads.
+ The statistics are the number of assigned clients,
+ the number of read events processed, and the number of write events processed.
+ Added in Redis 8.0.
+
+For each I/O thread, the following line is added:
+
+*   `io_thread_XXX`: `clients=XXX,reads=XXX,writes=XXX`
+
+Here is the meaning of all fields in the **stats** section:
+
+*   `total_connections_received`: Total number of connections accepted by the
+     server
+*   `total_commands_processed`: Total number of commands processed by the server
+*   `instantaneous_ops_per_sec`: Number of commands processed per second
+*   `total_net_input_bytes`: The total number of bytes read from the network
+*   `total_net_output_bytes`: The total number of bytes written to the network
+*   `total_net_repl_input_bytes`: The total number of bytes read from the network for replication purposes
+*   `total_net_repl_output_bytes`: The total number of bytes written to the network for replication purposes
+*   `instantaneous_input_kbps`: The network's read rate per second in KB/sec
+*   `instantaneous_output_kbps`: The network's write rate per second in KB/sec
+*   `instantaneous_input_repl_kbps`: The network's read rate per second in KB/sec for replication purposes
+*   `instantaneous_output_repl_kbps`: The network's write rate per second in KB/sec for replication purposes
+*   `rejected_connections`: Number of connections rejected because of
+     `maxclients` limit
+*   `sync_full`: The number of full resyncs with replicas
+*   `sync_partial_ok`: The number of accepted partial resync requests
+*   `sync_partial_err`: The number of denied partial resync requests
+*   `expired_subkeys`: The number of hash field expiration events
+*   `expired_keys`: Total number of key expiration events
+*   `expired_stale_perc`: The percentage of keys probably expired
+*   `expired_time_cap_reached_count`: The count of times that active expiry cycles have stopped early
+*   `expire_cycle_cpu_milliseconds`: The cumulative amount of time spent on active expiry cycles
+*   `evicted_keys`: Number of evicted keys due to `maxmemory` limit
+*   `evicted_clients`: Number of evicted clients due to `maxmemory-clients` limit. Added in Redis 7.0.
+*   `evicted_scripts`: Number of evicted EVAL scripts due to LRU policy, see [`EVAL`]({{< relref "/commands/eval" >}}) for more details. Added in Redis 7.4.
+*   `total_eviction_exceeded_time`:  Total time `used_memory` was greater than `maxmemory` since server startup, in milliseconds
+*   `current_eviction_exceeded_time`: The time passed since `used_memory` last rose above `maxmemory`, in milliseconds
+*   `keyspace_hits`: Number of successful lookup of keys in the main dictionary
+*   `keyspace_misses`: Number of failed lookup of keys in the main dictionary
+*   `pubsub_channels`: Global number of pub/sub channels with client
+     subscriptions
+*   `pubsub_patterns`: Global number of pub/sub pattern with client
+     subscriptions
+*   `pubsubshard_channels`: Global number of pub/sub shard channels with client subscriptions. Added in Redis 7.0.3
+*   `latest_fork_usec`: Duration of the latest fork operation in microseconds
+*   `total_forks`: Total number of fork operations since the server start
+*   `migrate_cached_sockets`: The number of sockets open for [`MIGRATE`]({{< relref "/commands/migrate" >}}) purposes
+*   `slave_expires_tracked_keys`: The number of keys tracked for expiry purposes
+     (applicable only to writable replicas)
+*   `active_defrag_hits`: Number of value reallocations performed by active the
+     defragmentation process
+*   `active_defrag_misses`: Number of aborted value reallocations started by the
+     active defragmentation process
+*   `active_defrag_key_hits`: Number of keys that were actively defragmented
+*   `active_defrag_key_misses`: Number of keys that were skipped by the active
+     defragmentation process
+*   `total_active_defrag_time`: Total time memory fragmentation was over the limit, in milliseconds
+*   `current_active_defrag_time`: The time passed since memory fragmentation last was over the limit, in milliseconds
+*   `tracking_total_keys`: Number of keys being tracked by the server
+*   `tracking_total_items`: Number of items, that is the sum of clients number for
+     each key, that are being tracked
+*   `tracking_total_prefixes`: Number of tracked prefixes in server's prefix table
+    (only applicable for broadcast mode)
+*   `unexpected_error_replies`: Number of unexpected error replies, that are types
+    of errors from an AOF load or replication
+*   `total_error_replies`: Total number of issued error replies, that is the sum of
+    rejected commands (errors prior command execution) and
+    failed commands (errors within the command execution)
+*   `dump_payload_sanitizations`: Total number of dump payload deep integrity validations (see `sanitize-dump-payload` config).
+*   `total_reads_processed`: Total number of read events processed
+*   `total_writes_processed`: Total number of write events processed
+*   `io_threaded_reads_processed`: Number of read events processed by I/O threads
+*   `io_threaded_writes_processed`: Number of write events processed by I/O threads
+*   `client_query_buffer_limit_disconnections`: Total number of disconnections due to client reaching query buffer limit
+*   `client_output_buffer_limit_disconnections`: Total number of disconnections due to client reaching output buffer limit
+*   `reply_buffer_shrinks`: Total number of output buffer shrinks
+*   `reply_buffer_expands`: Total number of output buffer expands
+*   `eventloop_cycles`: Total number of eventloop cycles
+*   `eventloop_duration_sum`: Total time spent in the eventloop in microseconds (including I/O and command processing)
+*   `eventloop_duration_cmd_sum`: Total time spent on executing commands in microseconds
+*   `instantaneous_eventloop_cycles_per_sec`: Number of eventloop cycles per second
+*   `instantaneous_eventloop_duration_usec`: Average time spent in a single eventloop cycle in microseconds
+*   `acl_access_denied_auth`: Number of authentication failures
+*   `acl_access_denied_cmd`: Number of commands rejected because of access denied to the command
+*   `acl_access_denied_key`: Number of commands rejected because of access denied to a key
+*   `acl_access_denied_channel`: Number of commands rejected because of access denied to a channel 
+
+Here is the meaning of all fields in the **replication** section:
+
+*   `role`: Value is "master" if the instance is replica of no one, or "slave" if the instance is a replica of some master instance.
+     Note that a replica can be master of another replica (chained replication).
+*   `master_failover_state`: The state of an ongoing failover, if any.
+*   `master_replid`: The replication ID of the Redis server.
+*   `master_replid2`: The secondary replication ID, used for PSYNC after a failover.
+*   `master_repl_offset`: The server's current replication offset
+*   `second_repl_offset`: The offset up to which replication IDs are accepted
+*   `repl_backlog_active`: Flag indicating replication backlog is active
+*   `repl_backlog_size`: Total size in bytes of the replication backlog buffer
+*   `repl_backlog_first_byte_offset`: The master offset of the replication
+     backlog buffer
+*   `repl_backlog_histlen`: Size in bytes of the data in the replication backlog
+     buffer
+
+If the instance is a replica, these additional fields are provided:
+
+*   `master_host`: Host or IP address of the master
+*   `master_port`: Master listening TCP port
+*   `master_link_status`: Status of the link (up/down)
+*   `master_last_io_seconds_ago`: Number of seconds since the last interaction
+     with master
+*   `master_sync_in_progress`: Indicate the master is syncing to the replica
+*   `slave_read_repl_offset`: The read replication offset of the replica instance.
+*   `slave_repl_offset`: The replication offset of the replica instance
+*   `slave_priority`: The priority of the instance as a candidate for failover
+*   `slave_read_only`: Flag indicating if the replica is read-only
+*   `replica_announced`: Flag indicating if the replica is announced by Sentinel.
+
+If a SYNC operation is on-going, these additional fields are provided:
+
+*   `master_sync_total_bytes`: Total number of bytes that need to be 
+    transferred. this may be 0 when the size is unknown (for example, when
+    the `repl-diskless-sync` configuration directive is used)
+*   `master_sync_read_bytes`: Number of bytes already transferred
+*   `master_sync_left_bytes`: Number of bytes left before syncing is complete
+    (may be negative when `master_sync_total_bytes` is 0)
+*   `master_sync_perc`: The percentage `master_sync_read_bytes` from 
+    `master_sync_total_bytes`, or an approximation that uses
+    `loading_rdb_used_mem` when `master_sync_total_bytes` is 0
+*   `master_sync_last_io_seconds_ago`: Number of seconds since last transfer I/O
+     during a SYNC operation
+
+If the link between master and replica is down, an additional field is provided:
+
+*   `master_link_down_since_seconds`: Number of seconds since the link is down
+
+The following field is always provided:
+
+*   `connected_slaves`: Number of connected replicas
+
+If the server is configured with the `min-slaves-to-write` (or starting with Redis 5 with the `min-replicas-to-write`) directive, an additional field is provided:
+
+*   `min_slaves_good_slaves`: Number of replicas currently considered good
+
+For each replica, the following line is added:
+
+*   `slaveXXX`: id, IP address, port, state, offset, lag
+
+Here is the meaning of all fields in the **cpu** section:
+
+*   `used_cpu_sys`: System CPU consumed by the Redis server, which is the sum of system CPU consumed by all threads of the server process (main thread and background threads)
+*   `used_cpu_user`: User CPU consumed by the Redis server, which is the sum of user CPU consumed by all threads of the server process (main thread and background threads)
+*   `used_cpu_sys_children`: System CPU consumed by the background processes
+*   `used_cpu_user_children`: User CPU consumed by the background processes
+*   `used_cpu_sys_main_thread`: System CPU consumed by the Redis server main thread
+*   `used_cpu_user_main_thread`: User CPU consumed by the Redis server main thread
+
+The **commandstats** section provides statistics based on the command type,
+ including the number of calls that reached command execution (not rejected),
+ the total CPU time consumed by these commands, the average CPU consumed
+ per command execution, the number of rejected calls
+ (errors prior command execution), and the number of failed calls
+ (errors within the command execution).
+
+For each command type, the following line is added:
+
+*   `cmdstat_XXX`: `calls=XXX,usec=XXX,usec_per_call=XXX,rejected_calls=XXX,failed_calls=XXX`
+
+The **latencystats** section provides latency percentile distribution statistics based on the command type.
+
+ By default, the exported latency percentiles are the p50, p99, and p999.
+ If you need to change the exported percentiles, use `CONFIG SET latency-tracking-info-percentiles "50.0 99.0 99.9"`.
+
+ This section requires the extended latency monitoring feature to be enabled (by default it's enabled).
+ If you need to enable it, use `CONFIG SET latency-tracking yes`.
+
+For each command type, the following line is added:
+
+*   `latency_percentiles_usec_XXX: p<percentile 1>=<percentile 1 value>,p<percentile 2>=<percentile 2 value>,...`
+
+The **errorstats** section enables keeping track of the different errors that occurred within Redis, 
+ based upon the reply error prefix ( The first word after the "-", up to the first space. Example: `ERR` ).
+
+For each error type, the following line is added:
+
+*   `errorstat_XXX`: `count=XXX`
+
+If the server detects that this section was flooded with an excessive number of errors, it will be disabled, show a single `ERRORSTATS_DISABLED` error, and print the errors to the server log.
+This can be reset by `CONFIG RESETSTAT`.
+
+The **sentinel** section is only available in Redis Sentinel instances. It consists of the following fields:
+
+*   `sentinel_masters`: Number of Redis masters monitored by this Sentinel instance
+*   `sentinel_tilt`: A value of 1 means this sentinel is in TILT mode
+*   `sentinel_tilt_since_seconds`: Duration in seconds of current TILT, or -1 if not TILTed. Added in Redis 7.0.0
+*   `sentinel_running_scripts`: The number of scripts this Sentinel is currently executing
+*   `sentinel_scripts_queue_length`: The length of the queue of user scripts that are pending execution
+*   `sentinel_simulate_failure_flags`: Flags for the `SENTINEL SIMULATE-FAILURE` command
+    
+The **cluster** section currently only contains a unique field:
+
+*   `cluster_enabled`: Indicate Redis cluster is enabled
+
+The **modules** section contains additional information about loaded modules if the modules provide it. The field part of property lines in this section are always prefixed with the module's name.
+
+**RediSearch fields**
+
+*   `search_gc_bytes_collected`: The total amount of memory freed by the garbage collectors from indexes in the shard's memory in bytes. <sup>[3](#tnote-3)</sup>
+*   `search_bytes_collected`: The total amount of memory freed by the garbage collectors from indexes in the shard's memory in bytes. Deprecated in 8.0 (renamed `search_gc_bytes_collected`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_gc_marked_deleted_vectors`: The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. <sup>[3](#tnote-3)</sup>
+*   `search_marked_deleted_vectors`: The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. Deprecated in 8.0 (renamed `search_gc_marked_delete_vectors`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_gc_total_cycles`: The total number of garbage collection cycles executed. <sup>[3](#tnote-3)</sup>
+*   `search_total_cycles`: The total number of garbage collection cycles executed. Deprecated in 8.0 (renamed `search_gc_total_cycles`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_gc_total_docs_not_collected_by_gc`: The number of documents marked as deleted, whose memory has not yet been freed by the garbage collector. <sup>[3](#tnote-3)</sup>
+*   `search_total_docs_not_collected_by_gc`: The number of documents marked as deleted, whose memory has not yet been freed by the garbage collector. Deprecated in 8.0 (renamed `search_gc_total_docs_not_collected`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_gc_total_ms_run`: The total duration of all garbage collection cycles in the shard, measured in milliseconds. <sup>[3](#tnote-3)</sup>
+*   `search_total_ms_run`: The total duration of all garbage collection cycles in the shard, measured in milliseconds. Deprecated in 8.0 (renamed `search_gc_total_ms_run`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+
+*   `search_cursors_internal_idle`: The total number of coordinator cursors that are currently holding pending results in the shard. <sup>[3](#tnote-3)</sup>
+*   `search_cursors_user_idle`: The total number of cursors that were explicitly requested by users, that are currently holding pending results in the shard. <sup>[3](#tnote-3)</sup>
+*   `search_global_idle`: The total number of user and internal cursors currently holding pending results in the shard. Deprecated in 8.0 (split into `search_cursors_internal_idle` and `search_cursors_user_idle`) but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_cursors_internal_active`: The total number of coordinator cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. <sup>[3](#tnote-3)</sup>
+*   `search_cursors_user_active`: The total number of user cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. <sup>[3](#tnote-3)</sup>
+*   `search_global_total`: The total number of user and internal cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. Deprecated in 8.0 (split into `search_cursors_internal_active` and `search_cursors_user_active`), but still available in older versions. <sup>[1](#tnote-1)</sup>
+*   `search_number_of_indexes`: The total number of indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_number_of_active_indexes`: The total number of indexes running a background indexing and/or background query processing operation. Background indexing refers to vector ingestion process, or in-progress background indexer. <sup>[1](#tnote-1)</sup>
+*   `search_number_of_active_indexes_running_queries`: The total count of indexes currently running a background query process. <sup>[1](#tnote-1)</sup>
+*   `search_number_of_active_indexes_indexing`: The total count of indexes currently undergoing a background indexing process. Background indexing refers to a vector ingestion process, or an in-progress background indexer. This metric is limited by the number of WORKER threads allocated for writing operations plus the number of indexes. <sup>[1](#tnote-1)</sup>
+*   `search_total_active_write_threads`: The total count of background write (indexing) processes currently running in the shard. Background indexing refers to a vector ingestion process, or an in-progress background indexer. This metric is limited by the number of threads allocated for writing operations. <sup>[1](#tnote-1)</sup>
+*   `search_fields_text_Text`: The total number of `TEXT` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_text_Sortable`: The total number of `SORTABLE TEXT` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_text_NoIndex`: The total number of `NOINDEX TEXT` fields across all indexes in the shard, which are used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_numeric_Numeric`: The total number of `NUMERIC` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_numeric_Sortable`: The total number of `SORTABLE NUMERIC` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_numeric_NoIndex`: The total number of `NOINDEX NUMERIC` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_tag_Tag`: The total number of `TAG` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_tag_Sortable`: The total number of `SORTABLE TAG` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_tag_NoIndex`: The total number of `NOINDEX TAG` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_tag_CaseSensitive`: The total number of `CASESENSITIVE TAG` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_geo_Geo`: The total number of `GEO` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_geo_Sortable`: The total number of `SORTABLE GEO` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_geo_NoIndex`: The total number of `NOINDEX GEO` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup>
+*   `search_fields_vector_Vector`: The total number of `VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_vector_Flat`: The total number of `FLAT VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_vector_HNSW`: The total number of `HNSW VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_fields_geoshape_Geoshape`: The total number of `GEOSHAPE` fields across all indexes in the shard. <sup>[2](#tnote-2)</sup>
+*   `search_fields_geoshape_Sortable`: The total number of `SORTABLE GEOSHAPE` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[2](#tnote-2)</sup>
+*   `search_fields_geoshape_NoIndex`: The total number of `NOINDEX GEOSHAPE` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[2](#tnote-2)</sup>
+*   `search_fields_<field>_IndexErrors`: The total number of indexing failures caused by attempts to index a document containing <field> field. <sup>[1](#tnote-1)</sup>
+*   `search_used_memory_indexes`: The total memory allocated by all indexes in the shard in bytes. <sup>[1](#tnote-1)</sup>
+*   `search_used_memory_indexes_human`: The total memory allocated by all indexes in the shard in MB. <sup>[1](#tnote-1)</sup>
+*   `search_smallest_memory_index`: The memory usage of the index with the smallest memory usage in the shard in bytes. <sup>[1](#tnote-1)</sup>
+*   `search_smallest_memory_index_human`: The memory usage of the index with the smallest memory usage in the shard in MB. <sup>[1](#tnote-1)</sup>
+*   `search_largest_memory_index`: The memory usage of the index with the largest memory usage in the shard in bytes. <sup>[1](#tnote-1)</sup>
+*   `search_largest_memory_index_human`: The memory usage of the index with the largest memory usage in the shard in MB. <sup>[1](#tnote-1)</sup>
+*   `search_total_indexing_time`: The total time spent on indexing operations, excluding the background indexing of vectors in the HNSW graph. <sup>[1](#tnote-1)</sup>
+*   `search_used_memory_vector_index`: The total memory usage of all vector indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_bytes_collected`: The total amount of memory freed by the garbage collectors from indexes in the shard memory in bytes. <sup>[1](#tnote-1)</sup>
+*   `search_total_cycles`: The total number of garbage collection cycles executed. <sup>[1](#tnote-1)</sup>
+*   `search_total_ms_run`: The total duration of all garbage collection cycles in the shard, measured in milliseconds. <sup>[1](#tnote-1)</sup>
+*   `search_total_docs_not_collected_by_gc`: The number of documents marked as deleted whose memory has not yet been freed by the garbage collector. <sup>[1](#tnote-1)</sup>
+*   `search_marked_deleted_vectors`: The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. <sup>[1](#tnote-1)</sup>
+*   `search_total_queries_processed`: The total number of successful query executions (When using cursors, not counting reading from existing cursors) in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_total_query_commands`: The total number of successful query command executions (including `FT.SEARCH`, `FT.AGGREGATE`, and `FT.CURSOR READ`). <sup>[1](#tnote-1)</sup>
+*   `search_total_query_execution_time_ms`: The cumulative execution time of all query commands, including `FT.SEARCH`, `FT.AGGREGATE`, and `FT.CURSOR` READ, measured in ms. <sup>[1](#tnote-1)</sup>
+*   `search_total_active_queries`: The total number of background queries currently being executed in the shard, excluding `FT.CURSOR READ`. <sup>[1](#tnote-1)</sup>
+*   `search_errors_indexing_failures`: The total number of indexing failures recorded across all indexes in the shard. <sup>[1](#tnote-1)</sup>
+*   `search_errors_for_index_with_max_failures`: The number of indexing failures in the index with the highest count of failures. <sup>[1](#tnote-1)</sup>
+
+1. <a name="tnote-1"></a> Available in RediSearch 2.6.
+2. <a name="tnote-2"></a> Available in RediSearch 2.8.
+3. <a name="tnote-3"></a> Available in RediSearch 8.0.
+
+The **keyspace** section provides statistics on the main dictionary of each database.
+The statistics are the number of keys, and the number of keys with an expiration.
+
+For each database, the following line is added:
+
+*   `dbXXX`: `keys=XXX,expires=XXX,avg_ttl=XXX,subexpiry=XXX`
+
+The **debug** section contains experimental metrics, which might change or get removed in future versions.
+It won't be included when `INFO` or `INFO ALL` are called, and it is returned only when `INFO DEBUG` is used.
+
+*   `eventloop_duration_aof_sum`: Total time spent on flushing AOF in eventloop in microseconds.
+*   `eventloop_duration_cron_sum`: Total time consumption of cron in microseconds (including serverCron and beforeSleep, but excluding IO and AOF flushing).
+*   `eventloop_duration_max`: The maximal time spent in a single eventloop cycle in microseconds.
+*   `eventloop_cmd_per_cycle_max`: The maximal number of commands processed in a single eventloop cycle.
+*   `allocator_allocated_lua`: Total bytes allocated from the allocator specifically for Lua, including internal-fragmentation.
+*   `allocator_active_lua`: Total bytes in the allocator active pages specifically for Lua, including external-fragmentation.
+*   `allocator_resident_lua`: Total bytes resident (RSS) in the allocator specifically for Lua. This includes pages that can be released to the OS (by `MEMORY PURGE`, or just waiting).
+*   `allocator_frag_bytes_lua`: Delta between `allocator_active_lua` and `allocator_allocated_lua`.
+
+[hcgcpgp]: http://code.google.com/p/google-perftools/
+
+**A note about the word slave used in this man page**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+
+**Modules generated sections**: Starting with Redis 6, modules can inject their information into the `INFO` command. These are excluded by default even when the `all` argument is provided (it will include a list of loaded modules but not their generated info fields). To get these you must use either the `modules` argument or `everything`.
+
+## Redis Software and Redis Cloud compatibility
+
+| Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:----------------------|:-----------------|:------|
+| <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | In Redis Enterprise, `INFO` returns a different set of fields than Redis Open Source.<br />Not supported for [scripts]({{<relref "/develop/interact/programmability">}}). |
+
+Note: key memory usage is different on Redis Software or Redis Cloud active-active databases than on non-active-active databases. This is because memory usage includes some amount of CRDB overhead.
+
+Additionally, for JSON keys, Redis implements a “shared string” mechanism to save memory when the same JSON field names or field values of type string are used more than once (either inter-key or intra-key).
+In such cases, instead of storing the field names or values many times, Redis stores them only once. This mechanism is not in place for active-active databases.
+
+On non-active-active databases, `INFO` (Memory > used_memory) reports that the shared memory is counted, but only once for all keys. On active-active databases, there is no shared memory, so if strings are repeated, they are stored multiple times.
+
+**Example**
+
+Suppose you have ten JSON keys, and each key has 5KB of unique content and 5KB of shared content.
+
+For non-active-active databases, `INFO` (used_memory) would report (10 keys * 5KB) + 5KB ~= 55KB. The last term, "+ 5KB", is the size of the shared content.
+
+For active-active databases, `INFO` (used_memory) would report 10 keys * 20KB ~= 200KB. This number includes some amount of CRDB overhead per JSON key.---
+acl_categories:
+- '@read'
+- '@hash'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the size of the hash.
+description: Returns all fields in a hash.
+group: hash
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HKEYS
+since: 2.0.0
+summary: Returns all fields in a hash.
+syntax_fmt: HKEYS key
+syntax_str: ''
+title: HKEYS
+---
+Returns all field names in the hash stored at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HSET myhash field2 "World"
+HKEYS myhash
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  since: 6.2.0
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of elements returned
+description: Returns the first elements in a list after removing it. Deletes the list
+  if the last element was popped.
+group: list
+hidden: false
+history:
+- - 6.2.0
+  - Added the `count` argument.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LPOP
+since: 1.0.0
+summary: Returns the first elements in a list after removing it. Deletes the list
+  if the last element was popped.
+syntax_fmt: LPOP key [count]
+syntax_str: '[count]'
+title: LPOP
+---
+Removes and returns the first elements of the list stored at `key`.
+
+By default, the command pops a single element from the beginning of the list.
+When provided with the optional `count` argument, the reply will consist of up
+to `count` elements, depending on the list's length.
+
+## Examples
+
+{{< clients-example cmds_list lpop >}}
+redis> RPUSH mylist "one" "two" "three" "four" "five"
+(integer) 5
+redis> LPOP mylist
+"one"
+redis> LPOP mylist 2
+1) "two"
+2) "three"
+redis> LRANGE mylist 0 -1
+1) "four"
+2) "five"
+{{< /clients-example>}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+RPUSH mylist "one" "two" "three" "four" "five"
+LPOP mylist
+LPOP mylist 2
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@topk'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: items
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n * k) where n is the number of items and k is the depth
+description: Increases the count of one or more items by increment
+group: topk
+hidden: false
+linkTitle: TOPK.ADD
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Increases the count of one or more items by increment
+syntax_fmt: TOPK.ADD key items [items ...]
+syntax_str: items [items ...]
+title: TOPK.ADD
+---
+
+Adds an item to the data structure. 
+Multiple items can be added at once.
+If an item enters the Top-K list, the item which is expelled is returned.
+This allows dynamic heavy-hitter detection of items being entered or expelled from Top-K list. 
+
+### Parameters
+
+* **key**: Name of sketch where item is added.
+* **item**: Item/s to be added.
+
+### Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - if an element was dropped from the TopK list, [Nil reply]({{< relref "/develop/reference/protocol-spec#bulk-strings" >}}) otherwise..
+
+#### Example
+
+```
+redis> TOPK.ADD topk foo bar 42
+1) (nil)
+2) baz
+3) (nil)
+```---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the expiration time of a key as a Unix timestamp.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: EXPIRETIME
+since: 7.0.0
+summary: Returns the expiration time of a key as a Unix timestamp.
+syntax_fmt: EXPIRETIME key
+syntax_str: ''
+title: EXPIRETIME
+---
+Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire.
+
+See also the [`PEXPIRETIME`]({{< relref "/commands/pexpiretime" >}}) command which returns the same information with milliseconds resolution.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXPIREAT mykey 33177117420
+EXPIRETIME mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@bloom'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- arguments:
+  - name: capacity
+    token: CAPACITY
+    type: pure-token
+  - name: size
+    token: SIZE
+    type: pure-token
+  - name: filters
+    token: FILTERS
+    type: pure-token
+  - name: items
+    token: ITEMS
+    type: pure-token
+  - name: expansion
+    token: EXPANSION
+    type: pure-token
+  name: single_value
+  optional: true
+  type: oneof
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information about a Bloom Filter
+group: bf
+hidden: false
+linkTitle: BF.INFO
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Returns information about a Bloom Filter
+syntax_fmt: BF.INFO key [CAPACITY | SIZE | FILTERS | ITEMS | EXPANSION]
+syntax_str: '[CAPACITY | SIZE | FILTERS | ITEMS | EXPANSION]'
+title: BF.INFO
+---
+Returns information about a Bloom filter.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>CAPACITY</code></summary>
+
+Return the number of unique items that can be stored in this Bloom filter before scaling would be required (including already added items).
+</details>
+
+<details open><summary><code>SIZE</code></summary>
+
+Return the memory size: number of bytes allocated for this Bloom filter.
+</details>
+
+<details open><summary><code>FILTERS</code></summary>
+
+Return the number of sub-filters.
+</details>
+
+<details open><summary><code>ITEMS</code></summary>
+
+Return the number of items that were added to this Bloom filter and detected as unique (items that caused at least one bit to be set in at least one sub-filter).
+</details>
+
+<details open><summary><code>EXPANSION</code></summary>
+
+Return the expansion rate.
+</details>
+
+When no optional argument is specified: return all information fields.
+
+## Return value
+
+When no optional argument is specified, returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with argument name ([Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})) and value ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})) pairs
+- [] on error (invalid arguments, key does not exist, wrong key type, and so on)
+
+When an optional argument is specified, returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - argument value
+- [] on error (invalid arguments, key does not exist, wrong key type, and so on)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.ADD bf1 observation1
+(integer) 1
+redis> BF.INFO bf1
+ 1) Capacity
+ 2) (integer) 100
+ 3) Size
+ 4) (integer) 240
+ 5) Number of filters
+ 6) (integer) 1
+ 7) Number of items inserted
+ 8) (integer) 1
+ 9) Expansion rate
+10) (integer) 2
+redis> BF.INFO bf1 CAPACITY
+1) (integer) 100
+{{< / highlight >}}
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: parameter
+  multiple: true
+  name: parameter
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) when N is the number of configuration parameters provided
+description: Returns the effective values of configuration parameters.
+group: server
+hidden: false
+history:
+- - 7.0.0
+  - Added the ability to pass multiple pattern parameters in one call
+linkTitle: CONFIG GET
+since: 2.0.0
+summary: Returns the effective values of configuration parameters.
+syntax_fmt: CONFIG GET parameter [parameter ...]
+syntax_str: ''
+title: CONFIG GET
+---
+The `CONFIG GET` command is used to read the configuration parameters of a
+running Redis server.
+Not all the configuration parameters are supported in Redis 2.4, while Redis 2.6
+can read the whole configuration of a server using this command.
+
+The symmetric command used to alter the configuration at run time is `CONFIG
+SET`.
+
+`CONFIG GET` takes multiple arguments, which are glob-style patterns.
+Any configuration parameter matching any of the patterns are reported as a list
+of key-value pairs.
+Example:
+
+```
+redis> config get *max-*-entries* maxmemory
+ 1) "maxmemory"
+ 2) "0"
+ 3) "hash-max-listpack-entries"
+ 4) "512"
+ 5) "hash-max-ziplist-entries"
+ 6) "512"
+ 7) "set-max-intset-entries"
+ 8) "512"
+ 9) "zset-max-listpack-entries"
+10) "128"
+11) "zset-max-ziplist-entries"
+12) "128"
+```
+
+You can obtain a list of all the supported configuration parameters by typing
+`CONFIG GET *` in an open `redis-cli` prompt.
+
+All the supported parameters have the same meaning of the equivalent
+configuration parameter used in the [redis.conf][hgcarr22rc] file:
+
+[hgcarr22rc]: http://github.com/redis/redis/raw/unstable/redis.conf
+
+Note that you should look at the redis.conf file relevant to the version you're
+working with as configuration options might change between versions. The link
+above is to the latest development version.
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: channel
+  multiple: true
+  name: channel
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of channels to subscribe to.
+description: Listens for messages published to channels.
+group: pubsub
+hidden: false
+linkTitle: SUBSCRIBE
+since: 2.0.0
+summary: Listens for messages published to channels.
+syntax_fmt: SUBSCRIBE channel [channel ...]
+syntax_str: ''
+title: SUBSCRIBE
+---
+Subscribes the client to the specified channels.
+
+Once the client enters the subscribed state it is not supposed to issue any
+other commands, except for additional `SUBSCRIBE`, [`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}}), [`PSUBSCRIBE`]({{< relref "/commands/psubscribe" >}}), [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}), [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}), 
+[`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}), [`PING`]({{< relref "/commands/ping" >}}), [`RESET`]({{< relref "/commands/reset" >}}) and [`QUIT`]({{< relref "/commands/quit" >}}) commands.
+However, if RESP3 is used (see [`HELLO`]({{< relref "/commands/hello" >}})) it is possible for a client to issue any commands while in subscribed state.
+
+For more information, see [Pub/sub]({{< relref "/develop/interact/pubsub" >}}).
+
+## Behavior change history
+
+*   `>= 6.2.0`: [`RESET`]({{< relref "/commands/reset" >}}) can be called to exit subscribed state.
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: async
+    name: async
+    since: 4.0.0
+    token: ASYNC
+    type: pure-token
+  - display_text: sync
+    name: sync
+    since: 6.2.0
+    token: SYNC
+    type: pure-token
+  name: flush-type
+  optional: true
+  type: oneof
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N) where N is the total number of keys in all databases
+description: Removes all keys from all databases.
+group: server
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+history:
+- - 4.0.0
+  - Added the `ASYNC` flushing mode modifier.
+- - 6.2.0
+  - Added the `SYNC` flushing mode modifier.
+linkTitle: FLUSHALL
+since: 1.0.0
+summary: Removes all keys from all databases.
+syntax_fmt: FLUSHALL [ASYNC | SYNC]
+syntax_str: ''
+title: FLUSHALL
+---
+Delete all the keys of all the existing databases, not just the currently selected one.
+This command never fails.
+
+By default, `FLUSHALL` will synchronously flush all the databases.
+Starting with Redis 6.2, setting the **lazyfree-lazy-user-flush** configuration directive to "yes" changes the default flush mode to asynchronous.
+
+It is possible to use one of the following modifiers to dictate the flushing mode explicitly:
+
+* `ASYNC`: flushes the databases asynchronously
+* `SYNC`: flushes the databases synchronously
+
+{{< clients-example cmds_servermgmt flushall >}}
+FLUSHALL SYNC
+{{< /clients-example >}}
+
+## Notes
+
+* An asynchronous `FLUSHALL` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected.
+* This command does not delete functions.
+* Other than emptying all databases (similar to `FLUSHDB`), this command clears the RDB persistence file, aborts any snapshot that is in progress, and, if the `save` config is enabled, saves an empty RDB file.
+
+## Behavior change history
+
+*   `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. 
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: rank
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of ranks specified.
+description: Returns, for each input rank, an estimation of the value (floating-point)
+  with that rank
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.BYRANK
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input rank, an estimation of the value (floating-point)
+  with that rank
+syntax_fmt: TDIGEST.BYRANK key rank [rank ...]
+syntax_str: rank [rank ...]
+title: TDIGEST.BYRANK
+---
+Returns, for each input rank, an estimation of the value (floating-point) with that rank.
+
+Multiple estimations can be retrieved in a signle call.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>rank</code></summary>
+
+Rank, for which the value should be retrieved.
+
+0 is the rank of the value of the smallest observation.
+
+_n_-1 is the rank of the value of the largest observation; _n_ denotes the number of observations added to the sketch.
+
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - an array of floating-points populated with value_1, value_2, ..., value_R:
+
+- Return an accurate result when `rank` is 0 (the value of the smallest observation)
+- Return an accurate result when `rank` is _n_-1 (the value of the largest observation), where _n_ denotes the number of observations added to the sketch.
+- Return 'inf' when `rank` is equal to _n_ or larger than _n_
+
+All values are 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 1000
+OK
+redis> TDIGEST.ADD t 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
+OK
+redis> TDIGEST.BYRANK t 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ 1) "1"
+ 2) "2"
+ 3) "2"
+ 4) "3"
+ 5) "3"
+ 6) "3"
+ 7) "4"
+ 8) "4"
+ 9) "4"
+10) "4"
+11) "5"
+12) "5"
+13) "5"
+14) "5"
+15) "5"
+16) "inf"
+{{< / highlight >}}
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+- display_text: timeout
+  name: timeout
+  type: double
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- blocking
+complexity: O(1)
+deprecated_since: 6.2.0
+description: Pops an element from a list, pushes it to another list and returns it.
+  Block until an element is available otherwise. Deletes the list if the last element
+  was popped.
+doc_flags:
+- deprecated
+group: list
+hidden: false
+history:
+- - 6.0.0
+  - '`timeout` is interpreted as a double instead of an integer.'
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: BRPOPLPUSH
+replaced_by: '[`BLMOVE`]({{< relref "/commands/blmove" >}}) with the `RIGHT` and `LEFT`
+  arguments'
+since: 2.2.0
+summary: Pops an element from a list, pushes it to another list and returns it. Block
+  until an element is available otherwise. Deletes the list if the last element was
+  popped.
+syntax_fmt: BRPOPLPUSH source destination timeout
+syntax_str: destination timeout
+title: BRPOPLPUSH
+---
+`BRPOPLPUSH` is the blocking variant of [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}).
+When `source` contains elements, this command behaves exactly like [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}).
+When used inside a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) block, this command behaves exactly like [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}).
+When `source` is empty, Redis will block the connection until another client
+pushes to it or until `timeout` is reached.
+A `timeout` of zero can be used to block indefinitely.
+
+See [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}) for more information.
+
+## Pattern: Reliable queue
+
+Please see the pattern description in the [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}) documentation.
+
+## Pattern: Circular list
+
+Please see the pattern description in the [`RPOPLPUSH`]({{< relref "/commands/rpoplpush" >}}) documentation.
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@fast'
+arguments:
+- name: sourceKey
+  type: key
+- name: destKey
+  type: key
+- arguments:
+  - name: avg
+    token: AVG
+    type: pure-token
+  - name: first
+    token: FIRST
+    type: pure-token
+  - name: last
+    token: LAST
+    type: pure-token
+  - name: min
+    token: MIN
+    type: pure-token
+  - name: max
+    token: MAX
+    type: pure-token
+  - name: sum
+    token: SUM
+    type: pure-token
+  - name: range
+    token: RANGE
+    type: pure-token
+  - name: count
+    token: COUNT
+    type: pure-token
+  - name: std.p
+    token: STD.P
+    type: pure-token
+  - name: std.s
+    token: STD.S
+    type: pure-token
+  - name: var.p
+    token: VAR.P
+    type: pure-token
+  - name: var.s
+    token: VAR.S
+    type: pure-token
+  - name: twa
+    since: 1.8.0
+    token: TWA
+    type: pure-token
+  name: aggregator
+  token: AGGREGATION
+  type: oneof
+- name: bucketDuration
+  type: integer
+- name: alignTimestamp
+  optional: true
+  since: 1.8.0
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Create a compaction rule
+group: timeseries
+hidden: false
+linkTitle: TS.CREATERULE
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Create a compaction rule
+syntax: "TS.CREATERULE sourceKey destKey \n  AGGREGATION aggregator bucketDuration\
+  \ \n  [alignTimestamp]\n"
+syntax_fmt: "TS.CREATERULE sourceKey destKey AGGREGATION\_<AVG | FIRST | LAST |\n\
+  \  MIN | MAX | SUM | RANGE | COUNT | STD.P | STD.S | VAR.P | VAR.S |\n  TWA> bucketDuration\
+  \ [alignTimestamp]"
+syntax_str: "destKey AGGREGATION\_<AVG | FIRST | LAST | MIN | MAX | SUM | RANGE |\
+  \ COUNT | STD.P | STD.S | VAR.P | VAR.S | TWA> bucketDuration [alignTimestamp]"
+title: TS.CREATERULE
+---
+
+Create a compaction rule
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>sourceKey</code></summary>
+
+is key name for the source time series.
+</details>
+
+<details open><summary><code>destKey</code></summary> 
+
+is key name for destination (compacted) time series. It must be created before `TS.CREATERULE` is called. 
+</details>
+
+<details open><summary><code>AGGREGATION aggregator bucketDuration</code></summary> 
+
+aggregates results into time buckets.
+
+  - `aggregator` takes one of the following aggregation types:
+
+    | `aggregator` | Description                                                                    |
+    | ------------ | ------------------------------------------------------------------------------ |
+    | `avg`        | Arithmetic mean of all values                                                  |
+    | `sum`        | Sum of all values                                                              |
+    | `min`        | Minimum value                                                                  |
+    | `max`        | Maximum value                                                                  |
+    | `range`      | Difference between the highest and the lowest value                            |
+    | `count`      | Number of values                                                               |
+    | `first`      | Value with lowest timestamp in the bucket                                      |
+    | `last`       | Value with highest timestamp in the bucket                                     |
+    | `std.p`      | Population standard deviation of the values                                    |
+    | `std.s`      | Sample standard deviation of the values                                        |
+    | `var.p`      | Population variance of the values                                              |
+    | `var.s`      | Sample variance of the values                                                  |
+    | `twa`        | Time-weighted average over the bucket's timeframe (since RedisTimeSeries v1.8) |
+
+  - `bucketDuration` is duration of each bucket, in milliseconds.
+  
+<note><b>Notes</b>
+
+- Only new samples that are added into the source series after the creation of the rule will be aggregated.
+- Calling `TS.CREATERULE` with a nonempty `destKey` may result in inconsistencies between the raw and the compacted data.
+- Explicitly adding samples to a compacted time series (using [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), or [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}})) may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples.
+- If no samples are added to the source time series during a bucket period. no _compacted sample_ is added to the destination time series.
+- The timestamp of a compacted sample added to the destination time series is set to the start timestamp the appropriate compaction bucket. For example, for a 10-minute compaction bucket with no alignment, the compacted samples timestamps are `x:00`, `x:10`, `x:20`, and so on.
+- Deleting `destKey` will cause the compaction rule to be deleted as well.
+
+{{% warning %}}
+In a clustered environment, you must use [hash tags]({{< relref "/operate/oss_and_stack/reference/cluster-spec" >}}#hash-tags) to force `sourceKey` and `destKey` to be stored in the same hash slot. If you don't, Redis may fail to compact the data without displaying any error messages.
+{{% /warning %}}
+  
+</note>
+
+## Optional arguments
+
+<details open><summary><code>alignTimestamp</code> (since RedisTimeSeries v1.8)</summary>
+
+ensures that there is a bucket that starts exactly at `alignTimestamp` and aligns all other buckets accordingly. It is expressed in milliseconds. The default value is 0: aligned with the Unix epoch.
+
+For example, if `bucketDuration` is 24 hours (`24 * 3600 * 1000`), setting `alignTimestamp` to 6 hours after the Unix epoch (`6 * 3600 * 1000`) ensures that each bucket’s timeframe is `[06:00 .. 06:00)`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, wrong key type, etc.), when `sourceKey` does not exist, when `destKey` does not exist, when `sourceKey` is already a destination of a compaction rule, when `destKey` is already a source or a destination of a compaction rule, or when `sourceKey` and `destKey` are identical
+
+## Examples
+
+<details open>
+<summary><b>Create a compaction rule</b></summary>
+
+Create a time series to store the temperatures measured in Tel Aviv.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+{{< / highlight >}}
+
+Next, create a compacted time series named _dailyAvgTemp_ containing one compacted sample per 24 hours: the time-weighted average of all measurements taken from midnight to next midnight.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE dailyAvgTemp:TLV LABELS type temp location TLV
+127.0.0.1:6379> TS.CREATERULE temp:TLV dailyAvgTemp:TLV AGGREGATION twa 86400000 
+{{< / highlight >}}
+
+Now, also create a compacted time series named _dailyDiffTemp_. This time series will contain one compacted sample per 24 hours: the difference between the minimum and the maximum temperature measured between 06:00 and 06:00 next day.
+ Here, 86400000 is the number of milliseconds in 24 hours, 21600000 is the number of milliseconds in 6 hours.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE dailyDiffTemp:TLV LABELS type temp location TLV
+127.0.0.1:6379> TS.CREATERULE temp:TLV dailyDiffTemp:TLV AGGREGATION range 86400000 21600000
+{{< / highlight >}}
+  
+</details>
+
+## See also
+
+[`TS.DELETERULE`]({{< relref "commands/ts.deleterule/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@cms'
+- '@write'
+arguments:
+- name: key
+  type: key
+- arguments:
+  - name: item
+    type: string
+  - name: increment
+    type: integer
+  multiple: true
+  name: items
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of items
+description: Increases the count of one or more items by increment
+group: cms
+hidden: false
+linkTitle: CMS.INCRBY
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Increases the count of one or more items by increment
+syntax_fmt: CMS.INCRBY key item increment [item increment ...]
+syntax_str: item increment [item increment ...]
+title: CMS.INCRBY
+---
+
+Increases the count of item by increment. Multiple items can be increased with one call. 
+
+### Parameters:
+
+* **key**: The name of the sketch.
+* **item**: The item which counter is to be increased.
+* **increment**: Amount by which the item counter is to be increased.
+
+## Return
+
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) with an updated min-count of each of the items in the sketch.
+
+Count of each item after increment.
+
+## Examples
+
+```
+redis> CMS.INCRBY test foo 10 bar 42
+1) (integer) 10
+2) (integer) 42
+```
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(1)
+description: Returns information about the state of a node.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER INFO
+since: 3.0.0
+summary: Returns information about the state of a node.
+syntax_fmt: CLUSTER INFO
+syntax_str: ''
+title: CLUSTER INFO
+---
+`CLUSTER INFO` provides [`INFO`]({{< relref "/commands/info" >}}) style information about Redis Cluster vital parameters.
+The following fields are always present in the reply:
+
+```
+cluster_state:ok
+cluster_slots_assigned:16384
+cluster_slots_ok:16384
+cluster_slots_pfail:0
+cluster_slots_fail:0
+cluster_known_nodes:6
+cluster_size:3
+cluster_current_epoch:6
+cluster_my_epoch:2
+cluster_stats_messages_sent:1483972
+cluster_stats_messages_received:1483968
+total_cluster_links_buffer_limit_exceeded:0
+```
+
+* `cluster_state`: State is `ok` if the node is able to receive queries. `fail` if there is at least one hash slot which is unbound (no node associated), in error state (node serving it is flagged with FAIL flag), or if the majority of masters can't be reached by this node.
+* `cluster_slots_assigned`: Number of slots which are associated to some node (not unbound). This number should be 16384 for the node to work properly, which means that each hash slot should be mapped to a node.
+* `cluster_slots_ok`: Number of hash slots mapping to a node not in `FAIL` or `PFAIL` state.
+* `cluster_slots_pfail`: Number of hash slots mapping to a node in `PFAIL` state. Note that those hash slots still work correctly, as long as the `PFAIL` state is not promoted to `FAIL` by the failure detection algorithm. `PFAIL` only means that we are currently not able to talk with the node, but may be just a transient error.
+* `cluster_slots_fail`: Number of hash slots mapping to a node in `FAIL` state. If this number is not zero the node is not able to serve queries unless `cluster-require-full-coverage` is set to `no` in the configuration.
+* `cluster_known_nodes`: The total number of known nodes in the cluster, including nodes in `HANDSHAKE` state that may not currently be proper members of the cluster.
+* `cluster_size`: The number of master nodes serving at least one hash slot in the cluster.
+* `cluster_current_epoch`: The local `Current Epoch` variable. This is used in order to create unique increasing version numbers during fail overs.
+* `cluster_my_epoch`: The `Config Epoch` of the node we are talking with. This is the current configuration version assigned to this node.
+* `cluster_stats_messages_sent`: Number of messages sent via the cluster node-to-node binary bus.
+* `cluster_stats_messages_received`: Number of messages received via the cluster node-to-node binary bus.
+* `total_cluster_links_buffer_limit_exceeded`: Accumulated count of cluster links freed due to exceeding the `cluster-link-sendbuf-limit` configuration.
+
+The following message-related fields may be included in the reply if the value is not 0:
+Each message type includes statistics on the number of messages sent and received.
+Here are the explanation of these fields:
+
+* `cluster_stats_messages_ping_sent` and `cluster_stats_messages_ping_received`: Cluster bus PING (not to be confused with the client command [`PING`]({{< relref "/commands/ping" >}})).
+* `cluster_stats_messages_pong_sent` and `cluster_stats_messages_pong_received`: PONG (reply to PING).
+* `cluster_stats_messages_meet_sent` and `cluster_stats_messages_meet_received`: Handshake message sent to a new node, either through gossip or [`CLUSTER MEET`]({{< relref "/commands/cluster-meet" >}}).
+* `cluster_stats_messages_fail_sent` and `cluster_stats_messages_fail_received`: Mark node xxx as failing.
+* `cluster_stats_messages_publish_sent` and `cluster_stats_messages_publish_received`: Pub/Sub Publish propagation, see [Pubsub]({{< relref "/develop/interact/pubsub#pubsub" >}}).
+* `cluster_stats_messages_auth-req_sent` and `cluster_stats_messages_auth-req_received`: Replica initiated leader election to replace its master.
+* `cluster_stats_messages_auth-ack_sent` and `cluster_stats_messages_auth-ack_received`: Message indicating a vote during leader election.
+* `cluster_stats_messages_update_sent` and `cluster_stats_messages_update_received`: Another node slots configuration.
+* `cluster_stats_messages_mfstart_sent` and `cluster_stats_messages_mfstart_received`: Pause clients for manual failover.
+* `cluster_stats_messages_module_sent` and `cluster_stats_messages_module_received`: Module cluster API message.
+* `cluster_stats_messages_publishshard_sent` and `cluster_stats_messages_publishshard_received`: Pub/Sub Publish shard propagation, see [Sharded Pubsub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}).
+
+More information about the Current Epoch and Config Epoch variables are available in the [Redis Cluster specification document]({{< relref "/operate/oss_and_stack/reference/cluster-spec#cluster-current-epoch" >}}).
+---
+acl_categories:
+- '@write'
+- '@bitmap'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - arguments:
+    - display_text: encoding
+      name: encoding
+      type: string
+    - display_text: offset
+      name: offset
+      type: integer
+    name: get-block
+    token: GET
+    type: block
+  - arguments:
+    - arguments:
+      - display_text: wrap
+        name: wrap
+        token: WRAP
+        type: pure-token
+      - display_text: sat
+        name: sat
+        token: SAT
+        type: pure-token
+      - display_text: fail
+        name: fail
+        token: FAIL
+        type: pure-token
+      name: overflow-block
+      optional: true
+      token: OVERFLOW
+      type: oneof
+    - arguments:
+      - arguments:
+        - display_text: encoding
+          name: encoding
+          type: string
+        - display_text: offset
+          name: offset
+          type: integer
+        - display_text: value
+          name: value
+          type: integer
+        name: set-block
+        token: SET
+        type: block
+      - arguments:
+        - display_text: encoding
+          name: encoding
+          type: string
+        - display_text: offset
+          name: offset
+          type: integer
+        - display_text: increment
+          name: increment
+          type: integer
+        name: incrby-block
+        token: INCRBY
+        type: block
+      name: write-operation
+      type: oneof
+    name: write
+    type: block
+  multiple: true
+  name: operation
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1) for each subcommand specified
+description: Performs arbitrary bitfield integer operations on strings.
+group: bitmap
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  notes: This command allows both access and modification of the key
+  update: true
+  variable_flags: true
+linkTitle: BITFIELD
+since: 3.2.0
+summary: Performs arbitrary bitfield integer operations on strings.
+syntax_fmt: "BITFIELD key [GET\_encoding offset | [OVERFLOW\_<WRAP | SAT | FAIL>]\n\
+  \  <SET\_encoding offset value | INCRBY\_encoding offset increment>\n  [GET\_encoding\
+  \ offset | [OVERFLOW\_<WRAP | SAT | FAIL>]\n  <SET\_encoding offset value | INCRBY\_\
+  encoding offset increment>\n  ...]]"
+syntax_str: "[GET\_encoding offset | [OVERFLOW\_<WRAP | SAT | FAIL>] <SET\_encoding\
+  \ offset value | INCRBY\_encoding offset increment> [GET\_encoding offset | [OVERFLOW\_\
+  <WRAP | SAT | FAIL>] <SET\_encoding offset value | INCRBY\_encoding offset increment>\
+  \ ...]]"
+title: BITFIELD
+---
+The command treats a Redis string as an array of bits, and is capable of addressing specific integer fields of varying bit widths and arbitrary non (necessary) aligned offset. In practical terms using this command you can set, for example, a signed 5 bits integer at bit offset 1234 to a specific value, retrieve a 31 bit unsigned integer from offset 4567. Similarly the command handles increments and decrements of the specified integers, providing guaranteed and well specified overflow and underflow behavior that the user can configure.
+
+`BITFIELD` is able to operate with multiple bit fields in the same command call. It takes a list of operations to perform, and returns an array of replies, where each array matches the corresponding operation in the list of arguments.
+
+For example the following command increments a 5 bit signed integer at bit offset 100, and gets the value of the 4 bit unsigned integer at bit offset 0:
+
+    > BITFIELD mykey INCRBY i5 100 1 GET u4 0
+    1) (integer) 1
+    2) (integer) 0
+
+Note that:
+
+1. Addressing with `GET` bits outside the current string length (including the case the key does not exist at all), results in the operation to be performed like the missing part all consists of bits set to 0.
+2. Addressing with `SET` or `INCRBY` bits outside the current string length will enlarge the string, zero-padding it, as needed, for the minimal length needed, according to the most far bit touched.
+
+## Supported subcommands and integer encoding
+
+The following is the list of supported commands.
+
+* **GET** `<encoding>` `<offset>` -- Returns the specified bit field.
+* **SET** `<encoding>` `<offset>` `<value>` -- Set the specified bit field and returns its old value.
+* **INCRBY** `<encoding>` `<offset>` `<increment>` -- Increments or decrements (if a negative increment is given) the specified bit field and returns the new value.
+
+There is another subcommand that only changes the behavior of successive
+`INCRBY` and `SET` subcommands calls by setting the overflow behavior:
+
+* **OVERFLOW** `[WRAP|SAT|FAIL]`
+
+Where an integer encoding is expected, it can be composed by prefixing with `i` for signed integers and `u` for unsigned integers with the number of bits of our integer encoding. So for example `u8` is an unsigned integer of 8 bits and `i16` is a
+signed integer of 16 bits.
+
+The supported encodings are up to 64 bits for signed integers, and up to 63 bits for
+unsigned integers. This limitation with unsigned integers is due to the fact
+that currently the Redis protocol is unable to return 64 bit unsigned integers
+as replies.
+
+## Bits and positional offsets
+
+There are two ways in order to specify offsets in the bitfield command.
+If a number without any prefix is specified, it is used just as a zero based
+bit offset inside the string.
+
+However if the offset is prefixed with a `#` character, the specified offset
+is multiplied by the integer encoding's width, so for example:
+
+    BITFIELD mystring SET i8 #0 100 SET i8 #1 200
+
+Will set the first i8 integer at offset 0 and the second at offset 8.
+This way you don't have to do the math yourself inside your client if what
+you want is a plain array of integers of a given size.
+
+## Overflow control
+
+Using the `OVERFLOW` command the user is able to fine-tune the behavior of
+the increment or decrement overflow (or underflow) by specifying one of
+the following behaviors:
+
+* **WRAP**: wrap around, both with signed and unsigned integers. In the case of unsigned integers, wrapping is like performing the operation modulo the maximum value the integer can contain (the C standard behavior). With signed integers instead wrapping means that overflows restart towards the most negative value and underflows towards the most positive ones, so for example if an `i8` integer is set to the value 127, incrementing it by 1 will yield `-128`.
+* **SAT**: uses saturation arithmetic, that is, on underflows the value is set to the minimum integer value, and on overflows to the maximum integer value. For example incrementing an `i8` integer starting from value 120 with an increment of 10, will result into the value 127, and further increments will always keep the value at 127. The same happens on underflows, but towards the value is blocked at the most negative value.
+* **FAIL**: in this mode no operation is performed on overflows or underflows detected. The corresponding return value is set to NULL to signal the condition to the caller.
+
+Note that each `OVERFLOW` statement only affects the `INCRBY` and `SET`
+commands that follow it in the list of subcommands, up to the next `OVERFLOW`
+statement.
+
+By default, **WRAP** is used if not otherwise specified.
+
+    > BITFIELD mykey incrby u2 100 1 OVERFLOW SAT incrby u2 102 1
+    1) (integer) 1
+    2) (integer) 1
+    > BITFIELD mykey incrby u2 100 1 OVERFLOW SAT incrby u2 102 1
+    1) (integer) 2
+    2) (integer) 2
+    > BITFIELD mykey incrby u2 100 1 OVERFLOW SAT incrby u2 102 1
+    1) (integer) 3
+    2) (integer) 3
+    > BITFIELD mykey incrby u2 100 1 OVERFLOW SAT incrby u2 102 1
+    1) (integer) 0
+    2) (integer) 3
+
+The following is an example of `OVERFLOW FAIL` returning NULL.
+
+    > BITFIELD mykey OVERFLOW FAIL incrby u2 102 1
+    1) (nil)
+
+## Motivations
+
+The motivation for this command is that the ability to store many small integers
+as a single large bitmap (or segmented over a few keys to avoid having huge keys) is extremely memory efficient, and opens new use cases for Redis to be applied, especially in the field of real time analytics. This use cases are supported by the ability to specify the overflow in a controlled way.
+
+Fun fact: Reddit's 2017 April fools' project [r/place](https://reddit.com/r/place) was [built using the Redis BITFIELD command](https://redditblog.com/2017/04/13/how-we-built-rplace/) in order to take an in-memory representation of the collaborative canvas.
+
+## Performance considerations
+
+Usually `BITFIELD` is a fast command, however note that addressing far bits of currently short strings will trigger an allocation that may be more costly than executing the command on bits already existing.
+
+## Orders of bits
+
+The representation used by `BITFIELD` considers the bitmap as having the
+bit number 0 to be the most significant bit of the first byte, and so forth, so
+for example setting a 5 bits unsigned integer to value 23 at offset 7 into a
+bitmap previously set to all zeroes, will produce the following representation:
+
+    +--------+--------+
+    |00000001|01110000|
+    +--------+--------+
+
+When offsets and integer sizes are aligned to bytes boundaries, this is the
+same as big endian, however when such alignment does not exist, its important
+to also understand how the bits inside a byte are ordered.
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: capacity
+  optional: true
+  token: CAPACITY
+  type: integer
+- name: nocreate
+  optional: true
+  token: NOCREATE
+  type: pure-token
+- name: items
+  token: ITEMS
+  type: pure-token
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n * (k + i)), where n is the number of items, k is the number of sub-filters
+  and i is maxIterations
+description: Adds one or more items to a Cuckoo Filter. A filter will be created if
+  it does not exist
+group: cf
+hidden: false
+linkTitle: CF.INSERT
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds one or more items to a Cuckoo Filter. A filter will be created if it
+  does not exist
+syntax_fmt: "CF.INSERT key [CAPACITY\_capacity] [NOCREATE] ITEMS item [item ...]"
+syntax_str: "[CAPACITY\_capacity] [NOCREATE] ITEMS item [item ...]"
+title: CF.INSERT
+---
+Adds one or more items to a cuckoo filter, allowing the filter to be created with a custom capacity if it does not exist yet.
+
+This command is similar to [`CF.ADD`]({{< relref "commands/cf.add/" >}}), except that more than one item can be added and capacity can be specified.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to add items to.
+
+If `key` does not exist - a new cuckoo filter is created.
+</details>
+
+<details open><summary><code>ITEMS item...</code></summary>
+
+One or more items to add.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>CAPACITY capacity</code></summary>
+    
+Specifies the desired capacity of the new filter, if this filter does not exist yet.
+    
+If the filter already exists, then this parameter is ignored.
+    
+If the filter does not exist yet and this parameter is *not* specified, then the filter is created with the module-level default capacity which is 1024.
+
+See [`CF.RESERVE`]({{< relref "commands/cf.reserve/" >}}) for more information on cuckoo filter capacities.
+</details>
+    
+<details open><summary><code>NOCREATE</code></summary>
+  
+If specified, prevents automatic filter creation if the filter does not exist (Instead, an error is returned).
+    
+This option is mutually exclusive with `CAPACITY`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - where "1" means that the item has been successfully added to the filter, and "-1" means that the item was not added because the filter is full.
+- [] on error (invalid arguments, wrong key type, and so on) and also when `NOCREATE` is specified and `key` does not exist.
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INSERT cf CAPACITY 1000 ITEMS item1 item2 
+1) (integer) 1
+2) (integer) 1
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> CF.INSERT cf1 CAPACITY 1000 NOCREATE ITEMS item1 item2 
+(error) ERR not found
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> CF.RESERVE cf2 2 BUCKETSIZE 1 EXPANSION 0
+OK
+redis> CF.INSERT cf2 ITEMS 1 1 1 1
+1) (integer) 1
+2) (integer) 1
+3) (integer) -1
+4) (integer) -1
+{{< / highlight >}}
+---
+acl_categories:
+- '@pubsub'
+- '@fast'
+arguments:
+- display_text: channel
+  name: channel
+  type: string
+- display_text: message
+  name: message
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+- fast
+complexity: O(N+M) where N is the number of clients subscribed to the receiving channel
+  and M is the total number of subscribed patterns (by any client).
+description: Posts a message to a channel.
+group: pubsub
+hidden: false
+linkTitle: PUBLISH
+since: 2.0.0
+summary: Posts a message to a channel.
+syntax_fmt: PUBLISH channel message
+syntax_str: message
+title: PUBLISH
+---
+Posts a message to the given channel.
+
+In a Redis Cluster clients can publish to every node. The cluster makes sure
+that published messages are forwarded as needed, so clients can subscribe to any
+channel by connecting to any one of the nodes.
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: weight
+  multiple: true
+  name: weight
+  optional: true
+  token: WEIGHTS
+  type: integer
+- arguments:
+  - display_text: sum
+    name: sum
+    token: SUM
+    type: pure-token
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: aggregate
+  optional: true
+  token: AGGREGATE
+  type: oneof
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted
+  sets, and M being the number of elements in the resulting sorted set.
+description: Returns the union of multiple sorted sets.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZUNION
+since: 6.2.0
+summary: Returns the union of multiple sorted sets.
+syntax_fmt: "ZUNION numkeys key [key ...] [WEIGHTS\_weight [weight ...]]\n  [AGGREGATE\_\
+  <SUM | MIN | MAX>] [WITHSCORES]"
+syntax_str: "key [key ...] [WEIGHTS\_weight [weight ...]] [AGGREGATE\_<SUM | MIN |\
+  \ MAX>] [WITHSCORES]"
+title: ZUNION
+---
+This command is similar to [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}), but instead of storing the resulting
+sorted set, it is returned to the client.
+
+For a description of the `WEIGHTS` and `AGGREGATE` options, see [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZADD zset2 3 "three"
+ZUNION 2 zset1 zset2
+ZUNION 2 zset1 zset2 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: LATENCY HELP
+since: 2.8.13
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: LATENCY HELP
+syntax_str: ''
+title: LATENCY HELP
+---
+The `LATENCY HELP` command returns a helpful text describing the different
+subcommands.
+
+For more information refer to the [Latency Monitoring Framework page][lm].
+
+[lm]: /operate/oss_and_stack/management/optimization/latency-monitor.md
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- display_text: command-name
+  multiple: true
+  name: command-name
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the number of commands to look up
+description: Returns information about one, multiple or all commands.
+group: server
+hidden: false
+hints:
+- nondeterministic_output_order
+history:
+- - 7.0.0
+  - Allowed to be called with no argument to get info on all commands.
+linkTitle: COMMAND INFO
+since: 2.8.13
+summary: Returns information about one, multiple or all commands.
+syntax_fmt: COMMAND INFO [command-name [command-name ...]]
+syntax_str: ''
+title: COMMAND INFO
+---
+Returns [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of details about multiple Redis commands.
+
+Same result format as [`COMMAND`]({{< relref "/commands/command" >}}) except you can specify which commands
+get returned.
+
+If you request details about non-existing commands, their return
+position will be nil.
+
+## Examples
+
+{{% redis-cli %}}
+COMMAND INFO get set eval
+COMMAND INFO foo evalsha config bar
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: query
+  type: string
+- name: nocontent
+  optional: true
+  token: NOCONTENT
+  type: pure-token
+- name: verbatim
+  optional: true
+  token: VERBATIM
+  type: pure-token
+- name: nostopwords
+  optional: true
+  token: NOSTOPWORDS
+  type: pure-token
+- name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+- name: withpayloads
+  optional: true
+  token: WITHPAYLOADS
+  type: pure-token
+- name: withsortkeys
+  optional: true
+  token: WITHSORTKEYS
+  type: pure-token
+- arguments:
+  - name: numeric_field
+    token: FILTER
+    type: string
+  - name: min
+    type: double
+  - name: max
+    type: double
+  multiple: true
+  name: filter
+  optional: true
+  type: block
+- arguments:
+  - name: geo_field
+    token: GEOFILTER
+    type: string
+  - name: lon
+    type: double
+  - name: lat
+    type: double
+  - name: radius
+    type: double
+  - arguments:
+    - name: m
+      token: m
+      type: pure-token
+    - name: km
+      token: km
+      type: pure-token
+    - name: mi
+      token: mi
+      type: pure-token
+    - name: ft
+      token: ft
+      type: pure-token
+    name: radius_type
+    type: oneof
+  multiple: true
+  name: geo_filter
+  optional: true
+  type: block
+- arguments:
+  - name: count
+    token: INKEYS
+    type: string
+  - multiple: true
+    name: key
+    type: string
+  name: in_keys
+  optional: true
+  type: block
+- arguments:
+  - name: count
+    token: INFIELDS
+    type: string
+  - multiple: true
+    name: field
+    type: string
+  name: in_fields
+  optional: true
+  type: block
+- arguments:
+  - name: count
+    token: RETURN
+    type: string
+  - arguments:
+    - name: identifier
+      type: string
+    - name: property
+      optional: true
+      token: AS
+      type: string
+    multiple: true
+    name: identifiers
+    type: block
+  name: return
+  optional: true
+  type: block
+- arguments:
+  - name: summarize
+    token: SUMMARIZE
+    type: pure-token
+  - arguments:
+    - name: count
+      token: FIELDS
+      type: string
+    - multiple: true
+      name: field
+      type: string
+    name: fields
+    optional: true
+    type: block
+  - name: num
+    optional: true
+    token: FRAGS
+    type: integer
+  - name: fragsize
+    optional: true
+    token: LEN
+    type: integer
+  - name: separator
+    optional: true
+    token: SEPARATOR
+    type: string
+  name: summarize
+  optional: true
+  type: block
+- arguments:
+  - name: highlight
+    token: HIGHLIGHT
+    type: pure-token
+  - arguments:
+    - name: count
+      token: FIELDS
+      type: string
+    - multiple: true
+      name: field
+      type: string
+    name: fields
+    optional: true
+    type: block
+  - arguments:
+    - name: tags
+      token: TAGS
+      type: pure-token
+    - name: open
+      type: string
+    - name: close
+      type: string
+    name: tags
+    optional: true
+    type: block
+  name: highlight
+  optional: true
+  type: block
+- name: slop
+  optional: true
+  token: SLOP
+  type: integer
+- name: timeout
+  optional: true
+  token: TIMEOUT
+  type: integer
+- name: inorder
+  optional: true
+  token: INORDER
+  type: pure-token
+- name: language
+  optional: true
+  token: LANGUAGE
+  type: string
+- name: expander
+  optional: true
+  token: EXPANDER
+  type: string
+- name: scorer
+  optional: true
+  token: SCORER
+  type: string
+- name: explainscore
+  optional: true
+  token: EXPLAINSCORE
+  type: pure-token
+- name: payload
+  optional: true
+  token: PAYLOAD
+  type: string
+- arguments:
+  - name: sortby
+    token: SORTBY
+    type: string
+  - arguments:
+    - name: asc
+      token: ASC
+      type: pure-token
+    - name: desc
+      token: DESC
+      type: pure-token
+    name: order
+    optional: true
+    type: oneof
+  name: sortby
+  optional: true
+  type: block
+- arguments:
+  - name: limit
+    token: LIMIT
+    type: pure-token
+  - name: offset
+    type: integer
+  - name: num
+    type: integer
+  name: limit
+  optional: true
+  type: block
+- arguments:
+  - name: params
+    token: PARAMS
+    type: pure-token
+  - name: nargs
+    type: integer
+  - arguments:
+    - name: name
+      type: string
+    - name: value
+      type: string
+    multiple: true
+    name: values
+    type: block
+  name: params
+  optional: true
+  type: block
+- name: dialect
+  optional: true
+  since: 2.4.3
+  token: DIALECT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N)
+description: Searches the index with a textual query, returning either documents or
+  just ids
+group: search
+hidden: false
+history:
+- - 2.0.0
+  - Deprecated `WITHPAYLOADS` and `PAYLOAD` arguments
+- - 2.6
+  - Deprecated `GEOFILTER` argument
+- - "2.10"
+  - Deprecated `FILTER` argument
+linkTitle: FT.SEARCH
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Searches the index with a textual query, returning either documents or just
+  ids
+syntax: "FT.SEARCH index query \n  [NOCONTENT] \n  [VERBATIM] \n  [NOSTOPWORDS] \n  [WITHSCORES]\
+  \ \n  [WITHPAYLOADS] \n  [WITHSORTKEYS] \n  [FILTER numeric_field min max [ FILTER\
+  \ numeric_field min max ...]] \n  [GEOFILTER geo_field lon lat radius m | km | mi\
+  \ | ft [ GEOFILTER geo_field lon lat radius m | km | mi | ft ...]] \n  [INKEYS count\
+  \ key [key ...]] \n  [INFIELDS count field [field ...]] \n  [RETURN count identifier\
+  \ [AS property] [ identifier [AS property] ...]] \n  [SUMMARIZE [ FIELDS count field\
+  \ [field ...]] [FRAGS num] [LEN fragsize] [SEPARATOR separator]] \n  [HIGHLIGHT\
+  \ [ FIELDS count field [field ...]] [ TAGS open close]] \n  [SLOP slop] \n  [TIMEOUT\
+  \ timeout] \n  [INORDER] \n  [LANGUAGE language] \n  [EXPANDER expander] \n  [SCORER\
+  \ scorer] \n  [EXPLAINSCORE] \n  [PAYLOAD payload] \n  [SORTBY sortby [ ASC | DESC]\
+  \ [WITHCOUNT]] \n  [LIMIT offset num] \n  [PARAMS nargs name value [ name value\
+  \ ...]] \n  [DIALECT dialect]\n"
+syntax_fmt: "FT.SEARCH index query [NOCONTENT] [VERBATIM] [NOSTOPWORDS]\n  [WITHSCORES]\
+  \ [WITHPAYLOADS] [WITHSORTKEYS] [FILTER\_numeric_field\n  min max [FILTER\_numeric_field\
+  \ min max ...]] [GEOFILTER\_geo_field\n  lon lat radius <m | km | mi | ft> [GEOFILTER\_\
+  geo_field lon lat\n  radius <m | km | mi | ft> ...]] [INKEYS\_count key [key ...]]\n\
+  \  [INFIELDS\_count field [field ...]] [RETURN\_count identifier\n  [AS\_property]\
+  \ [identifier [AS\_property] ...]] [SUMMARIZE\n  [FIELDS\_count field [field ...]]\
+  \ [FRAGS\_num] [LEN\_fragsize]\n  [SEPARATOR\_separator]] [HIGHLIGHT [FIELDS\_count\
+  \ field [field ...]]\n  [TAGS open close]] [SLOP\_slop] [TIMEOUT\_timeout] [INORDER]\n\
+  \  [LANGUAGE\_language] [EXPANDER\_expander] [SCORER\_scorer]\n  [EXPLAINSCORE]\
+  \ [PAYLOAD\_payload] [SORTBY\_sortby [ASC | DESC]]\n  [LIMIT offset num] [PARAMS\
+  \ nargs name value [name value ...]]\n  [DIALECT\_dialect]"
+syntax_str: "query [NOCONTENT] [VERBATIM] [NOSTOPWORDS] [WITHSCORES] [WITHPAYLOADS]\
+  \ [WITHSORTKEYS] [FILTER\_numeric_field min max [FILTER\_numeric_field min max ...]]\
+  \ [GEOFILTER\_geo_field lon lat radius <m | km | mi | ft> [GEOFILTER\_geo_field\
+  \ lon lat radius <m | km | mi | ft> ...]] [INKEYS\_count key [key ...]] [INFIELDS\_\
+  count field [field ...]] [RETURN\_count identifier [AS\_property] [identifier [AS\_\
+  property] ...]] [SUMMARIZE [FIELDS\_count field [field ...]] [FRAGS\_num] [LEN\_\
+  fragsize] [SEPARATOR\_separator]] [HIGHLIGHT [FIELDS\_count field [field ...]] [TAGS\
+  \ open close]] [SLOP\_slop] [TIMEOUT\_timeout] [INORDER] [LANGUAGE\_language] [EXPANDER\_\
+  expander] [SCORER\_scorer] [EXPLAINSCORE] [PAYLOAD\_payload] [SORTBY\_sortby [ASC\
+  \ | DESC]] [LIMIT offset num] [PARAMS nargs name value [name value ...]] [DIALECT\_\
+  dialect]"
+title: FT.SEARCH
+---
+
+Search the index with a textual query, returning either documents or just ids.
+
+{{< note >}}
+This command will only return keys to which the user has read access.
+{{< /note >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>query</code></summary> 
+
+is text query to search. If it's more than a single word, put it in quotes. Refer to [Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}}) for more details.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>NOCONTENT</code></summary>
+
+returns the document ids and not the content. This is useful if RediSearch is only an index on an external document collection.
+</details>
+
+<details open>
+<summary><code>VERBATIM</code></summary>
+
+does not try to use stemming for query expansion but searches the query terms verbatim.
+</details>
+
+<details open>
+<summary><code>NOSTOPWORDS</code></summary>
+
+ignores any defined stop words in full text searches.
+</details>
+
+
+<details open>
+<summary><code>WITHSCORES</code></summary>
+
+also returns the relative internal score of each document. This can be used to merge results from multiple instances.
+</details>
+
+<details open>
+<summary><code>WITHPAYLOADS</code></summary>
+
+retrieves optional document payloads. See [`FT.CREATE`]({{< relref "commands/ft.create/" >}}). The payloads follow the document id and, if `WITHSCORES` is set, the scores.
+</details>
+
+<details open>
+<summary><code>WITHSORTKEYS</code></summary>
+
+returns the value of the sorting key, right after the id and score and/or payload, if requested. This is usually not needed, and exists for distributed search coordination purposes. This option is relevant only if used in conjunction with `SORTBY`.
+</details>
+
+<details open>
+<summary><code>FILTER numeric_attribute min max</code></summary>
+
+limits results to those having numeric values ranging between `min` and `max`, if numeric_attribute is defined as a numeric attribute in [`FT.CREATE`]({{< relref "commands/ft.create/" >}}). 
+  `min` and `max` follow [`ZRANGE`]({{< relref "/commands/zrange" >}}) syntax, and can be `-inf`, `+inf`, and use `(` for exclusive ranges. Multiple numeric filters for different attributes are supported in one query.
+**Deprecated since v2.10**: [Query dialect 2]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}) explains the query syntax for numeric fields that replaces this argument.
+</details>
+
+<details open>
+<summary><code>GEOFILTER {geo_attribute} {lon} {lat} {radius} m|km|mi|ft</code></summary>
+
+filter the results to a given `radius` from `lon` and `lat`. Radius is given as a number and units. See [`GEORADIUS`]({{< relref "/commands/georadius" >}}) for more details.
+**Deprecated since v2.6**: [Query dialect 3]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-3" >}}) explains the query syntax for geospatial fields that replaces this argument.
+</details>
+
+<details open>
+<summary><code>INKEYS {num} {attribute} ...</code></summary>
+
+limits the result to a given set of keys specified in the list. The first argument must be the length of the list and greater than zero. Non-existent keys are ignored, unless all the keys are non-existent.
+</details>
+
+<details open>
+<summary><code>INFIELDS {num} {attribute} ...</code></summary>
+
+filters the results to those appearing only in specific attributes of the document, like `title` or `URL`. You must include `num`, which is the number of attributes you're filtering by. For example, if you request `title` and `URL`, then `num` is 2.
+</details>
+
+<details open>
+<summary><code>RETURN {num} {identifier} AS {property} ...</code></summary>
+
+limits the attributes returned from the document. `num` is the number of attributes following the keyword. If `num` is 0, it acts like `NOCONTENT`.
+  `identifier` is either an attribute name (for hashes and JSON) or a JSON Path expression (for JSON).
+  `property` is an optional name used in the result. If not provided, the `identifier` is used in the result.
+</details>
+
+<details open>
+<summary><code>SUMMARIZE ...</code></summary>
+
+returns only the sections of the attribute that contain the matched text. See [Highlighting]({{< relref "/develop/interact/search-and-query/advanced-concepts/highlight" >}}) for more information.
+</details>
+
+<details open>
+<summary><code>HIGHLIGHT ...</code></summary>
+
+formats occurrences of matched text. See [Highlighting]({{< relref "/develop/interact/search-and-query/advanced-concepts/highlight" >}}) for more information.
+</details>
+
+<details open>
+<summary><code>SLOP {slop}</code></summary>
+
+is the number of intermediate terms allowed to appear between the terms of the query. 
+Suppose you're searching for a phrase _hello world_.
+If some terms appear in-between _hello_ and _world_, a `SLOP` greater than `0` allows for these text attributes to match.
+By default, there is no `SLOP` constraint.
+</details>
+
+<details open>
+<summary><code>INORDER</code></summary>
+
+requires the terms in the document to have the same order as the terms in the query, regardless of the offsets between them. Typically used in conjunction with `SLOP`. Default is `false`.
+
+</details>
+
+<details open>
+<summary><code>LANGUAGE {language}</code></summary>
+
+use a stemmer for the supplied language during search for query expansion. If querying documents in Chinese, set to `chinese` to
+  properly tokenize the query terms. Defaults to English. If an unsupported language is sent, the command returns an error.
+  See [`FT.CREATE`]({{< relref "commands/ft.create/" >}}) for the list of languages. If `LANGUAGE` was specified as part of index
+  creation, it doesn't need to specified with `FT.SEARCH`.
+</details>
+
+<details open>
+<summary><code>EXPANDER {expander}</code></summary>
+
+uses a custom query expander instead of the stemmer. See [Extensions]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}).
+</details>
+
+<details open>
+<summary><code>SCORER {scorer}</code></summary>
+
+uses a [built-in]({{< relref "/develop/interact/search-and-query/advanced-concepts/scoring" >}}) or a [user-provided]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}) scoring function.
+</details>
+
+<details open>
+<summary><code>EXPLAINSCORE</code></summary>
+
+returns a textual description of how the scores were calculated. Using this option requires `WITHSCORES`.
+</details>
+
+<details open>
+<summary><code>PAYLOAD {payload}</code></summary>
+
+adds an arbitrary, binary safe payload that is exposed to custom scoring functions. See [Extensions]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}).
+</details>
+
+<details open>
+<summary><code>SORTBY {attribute} [ASC|DESC] [WITHCOUNT]</code></summary>
+
+orders the results by the value of this attribute. This applies to both text and numeric attributes. Attributes needed for `SORTBY` should be declared as `SORTABLE` in the index, in order to be available with very low latency. Note that this adds memory overhead.
+
+**Sorting Optimizations**: performance is optimized for sorting operations on `DIALECT 4` in different scenarios:
+  - Skip Sorter - applied when there is no sort of any kind. The query can return after it reaches the `LIMIT` requested results.
+  - Partial Range - applied when there is a `SORTBY` clause over a numeric field, with no filter or filter by the same numeric field, the query iterate on a range large enough to satisfy the `LIMIT` requested results.
+  - Hybrid - applied when there is a `SORTBY` clause over a numeric field and another non-numeric filter. Some results will get filtered, and the initial range may not be large enough. The iterator is then rewinding with the following ranges, and an additional iteration takes place to collect the `LIMIT` requested results.
+  - No optimization - If there is a sort by score or by non-numeric field, there is no other option but to retrieve all results and compare their values.
+
+**Counts behavior**: optional`WITHCOUNT`argument returns accurate counts for the query results with sorting. This operation processes all results in order to get an accurate count, being less performant than the optimized option (default behavior on `DIALECT 4`)
+
+
+</details>
+
+<details open>
+<summary><code>LIMIT first num</code></summary>
+
+limits the results to the offset and number of results given. Note that the offset is zero-indexed. The default is 0 10, which returns 10 items starting from the first result. You can use `LIMIT 0 0` to count the number of documents in the result set without actually returning them.
+
+**`LIMIT` behavior**:  If you use the `LIMIT` option without sorting, the results returned are non-deterministic, which means that subsequent queries may return duplicated or missing values. Add `SORTBY` with a unique field, or use `FT.AGGREGATE` with the `WITHCURSOR` option to ensure deterministic result set paging.
+</details>
+
+<details open>
+<summary><code>TIMEOUT {milliseconds}</code></summary>
+
+overrides the timeout parameter of the module.
+</details>
+
+<details open>
+<summary><code>PARAMS {nargs} {name} {value}</code></summary>
+
+defines one or more value parameters. Each parameter has a name and a value. 
+
+You can reference parameters in the `query` by a `$`, followed by the parameter name, for example, `$user`. Each such reference in the search query to a parameter name is substituted by the corresponding parameter value. For example, with parameter definition `PARAMS 4 lon 29.69465 lat 34.95126`, the expression `@loc:[$lon $lat 10 km]` is evaluated to `@loc:[29.69465 34.95126 10 km]`. You cannot reference parameters in the query string where concrete values are not allowed, such as in field names, for example, `@loc`. To use `PARAMS`, set
+[`DIALECT`]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}})
+to `2` or greater than `2` (this requires [RediSearch v2.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.4.3) or above).
+</details>
+
+<details open>
+<summary><code>DIALECT {dialect_version}</code></summary>
+
+selects the dialect version under which to execute the query. If not specified, the query will execute under the default dialect version set during module initial loading or via [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) command. See [Query dialects]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects" >}}) for more information.
+</details>
+
+## Return
+
+FT.SEARCH returns an array reply, where the first element is an integer reply of the total number of results, and then array reply pairs of document ids, and array replies of attribute/value pairs.
+
+{{% alert title="Notes" color="warning" %}}
+ 
+- If `NOCONTENT` is given, an array is returned where the first element is the total number of results, and the rest of the members are document ids.
+- If a relevant key expires while a query is running, an attempt to load the key's value will return a null array. However, the key is still counted in the total number of results.
+
+{{% /alert %}}
+
+### Return multiple values
+
+When the index is defined `ON JSON`, a reply for a single attribute or a single JSONPath may return multiple values when the JSONPath matches multiple values, or when the JSONPath matches an array.
+
+Prior to RediSearch v2.6, only the first of the matched values was returned.
+Starting with RediSearch v2.6, all values are returned, wrapped with a top-level array.
+
+In order to maintain backward compatibility, the default behavior with RediSearch v2.6 is to return only the first value.
+
+To return all the values, use `DIALECT` 3 (or greater, when available).
+
+The `DIALECT` can be specified as a parameter in the FT.SEARCH command. If it is not specified, the `DEFAULT_DIALECT` is used, which can be set using [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) or by passing it as an argument to the `redisearch` module when it is loaded.
+
+For example, with the following document and index:
+
+
+```sh
+127.0.0.1:6379> JSON.SET doc:1 $ '[{"arr": [1, 2, 3]}, {"val": "hello"}, {"val": "world"}]'
+OK
+127.0.0.1:6379> FT.CREATE idx ON JSON PREFIX 1 doc: SCHEMA $..arr AS arr NUMERIC $..val AS val TEXT
+OK
+```
+Notice the different replies, with and without `DIALECT 3`:
+
+```sh
+127.0.0.1:6379> FT.SEARCH idx * RETURN 2 arr val
+1) (integer) 1
+2) "doc:1"
+3) 1) "arr"
+   2) "[1,2,3]"
+   3) "val"
+   4) "hello"
+
+127.0.0.1:6379> FT.SEARCH idx * RETURN 2 arr val DIALECT 3
+1) (integer) 1
+2) "doc:1"
+3) 1) "arr"
+   2) "[[1,2,3]]"
+   3) "val"
+   4) "[\"hello\",\"world\"]"
+```
+
+## Complexity
+
+FT.SEARCH complexity is O(n) for single word queries. `n` is the number of the results in the result set. Finding all the documents that have a specific term is O(1), however, a scan on all those documents is needed to load the documents data from redis hashes and return them.
+
+The time complexity for more complex queries varies, but in general it's proportional to the number of words, the number of intersection points between them and the number of results in the result set.
+
+## Examples
+
+<details open>
+<summary><b>Search for a term in every text attribute</b></summary>
+
+Search for the term "wizard" in every TEXT attribute of an index containing book data.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "wizard"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a term in title attribute</b></summary>
+
+Search for the term _dogs_ in the `title` attribute.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "@title:dogs"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for books from specific years</b></summary>
+
+Search for books published in 2020 or 2021.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "@published_at:[2020 2021]"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a restaurant by distance from longitude/latitude</b></summary>
+
+Search for Chinese restaurants within 5 kilometers of longitude -122.41, latitude 37.77 (San Francisco).
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH restaurants-idx "chinese @location:[-122.41 37.77 5 km]"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by terms but boost specific term</b></summary>
+
+Search for the term _dogs_ or _cats_ in the `title` attribute, but give matches of _dogs_ a higher relevance score (also known as _boosting_).
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "(@title:dogs | @title:cats) | (@title:dogs) => { $weight: 5.0; }"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by a term and EXPLAINSCORE</b></summary>
+
+Search for books with _dogs_ in any TEXT attribute in the index and request an explanation of scoring for each result.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "dogs" WITHSCORES EXPLAINSCORE
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by a term and TAG</b></summary>
+
+Search for books with _space_ in the title that have `science` in the TAG attribute `categories`.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "@title:space @categories:{science}"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by a term but limit the number</b></summary>
+
+Search for books with _Python_ in any `TEXT` attribute, returning 10 results starting with the 11th result in the entire result set (the offset parameter is zero-based), and return only the `title` attribute for each result.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "python" LIMIT 10 10 RETURN 1 title
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by a term and price</b></summary>
+
+Search for books with _Python_ in any `TEXT` attribute, returning the price stored in the original JSON document.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "python" RETURN 3 $.book.price AS price
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a book by title and distance</b></summary>
+
+Search for books with semantically similar title to _Planet Earth_. Return top 10 results sorted by distance.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH books-idx "*=>[KNN 10 @title_embedding $query_vec AS title_score]" PARAMS 2 query_vec <"Planet Earth" embedding BLOB> SORTBY title_score DIALECT 2
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Search for a phrase using SLOP</b></summary>
+
+Search for a phrase _hello world_.
+First, create an index.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE memes SCHEMA phrase TEXT
+OK
+{{< / highlight >}}
+
+Add variations of the phrase _hello world_.
+
+{{< highlight bash >}}
+127.0.0.1:6379> HSET s1 phrase "hello world"
+(integer) 1
+127.0.0.1:6379> HSET s2 phrase "hello simple world"
+(integer) 1
+127.0.0.1:6379> HSET s3 phrase "hello somewhat less simple world"
+(integer) 1
+127.0.0.1:6379> HSET s4 phrase "hello complicated yet encouraging problem solving world"
+(integer) 1
+127.0.0.1:6379> HSET s5 phrase "hello complicated yet amazingly encouraging problem solving world"
+(integer) 1
+{{< / highlight >}}
+
+Then, search for the phrase _hello world_. The result returns all documents that contain the phrase.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello world)' NOCONTENT 
+1) (integer) 5
+2) "s1"
+3) "s2"
+4) "s3"
+5) "s4"
+6) "s5"
+{{< / highlight >}}
+
+Now, return all documents that have one of fewer words between _hello_ and _world_.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello world)' NOCONTENT SLOP 1
+1) (integer) 2
+2) "s1"
+3) "s2"
+{{< / highlight >}}
+
+Now, return all documents with three or fewer words between _hello_ and _world_.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello world)' NOCONTENT SLOP 3
+1) (integer) 3
+2) "s1"
+3) "s2"
+4) "s3"
+{{< / highlight >}}
+
+`s5` needs a higher `SLOP` to match, `SLOP 6` or higher, to be exact. See what happens when you set `SLOP` to `5`.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello world)' NOCONTENT SLOP 5
+1) (integer) 4
+2) "s1"
+3) "s2"
+4) "s3"
+5) "s4"
+{{< / highlight >}}
+
+If you add additional terms (and stemming), you get these results.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello amazing world)' NOCONTENT 
+1) (integer) 1
+2) "s5"
+{{< / highlight >}}
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello encouraged world)' NOCONTENT SLOP 5
+1) (integer) 2
+2) "s4"
+3) "s5"
+{{< / highlight >}}
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(hello encouraged world)' NOCONTENT SLOP 4
+1) (integer) 1
+2) "s4"
+{{< / highlight >}}
+
+If you swap the terms, you can still retrieve the correct phrase.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(amazing hello world)' NOCONTENT
+1) (integer) 1
+2) "s5"
+{{< / highlight >}}
+
+But, if you use `INORDER`, you get zero results.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(amazing hello world)' NOCONTENT INORDER
+1) (integer) 0
+{{< / highlight >}}
+
+Likewise, if you use a query attribute `$inorder` set to `true`, `s5` is not retrieved.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH memes '@phrase:(amazing hello world)=>{$inorder: true;}' NOCONTENT
+1) (integer) 0
+{{< / highlight >}}
+
+To sum up, the `INORDER` argument or `$inorder` query attribute require the query terms to match terms with similar ordering.
+
+</details>
+
+<details open>
+<summary><b>Polygon Search with WITHIN, CONTAINS, INTERSECTS, and DISJOINT operators</b></summary>
+
+Query for polygons which:
+
+- contain a given geoshape
+- are within a given geoshape
+- intersect with a given geoshape
+- are disjoint (nothing in common) with a given shape
+
+`INTERSECTS` and `DISJOINT` were introduced in v2.10.
+
+First, create an index using `GEOSHAPE` type with a `FLAT` coordinate system:
+
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE idx SCHEMA geom GEOSHAPE FLAT
+OK
+{{< / highlight >}}
+
+Adding a couple of geometries using [`HSET`]({{< relref "/commands/hset" >}}):
+
+
+{{< highlight bash >}}
+127.0.0.1:6379> HSET small geom 'POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))'
+(integer) 1
+127.0.0.1:6379> HSET large geom 'POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))'
+(integer) 1
+{{< / highlight >}}
+
+Query with `WITHIN` operator:
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH idx '@geom:[WITHIN $poly]' PARAMS 2 poly 'POLYGON((0 0, 0 150, 150 150, 150 0, 0 0))' DIALECT 3
+
+1) (integer) 1
+2) "small"
+3) 1) "geom"
+   2) "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))"
+{{< / highlight >}}
+
+Query with `CONTAINS` operator:
+
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SEARCH idx '@geom:[CONTAINS $poly]' PARAMS 2 poly 'POLYGON((2 2, 2 50, 50 50, 50 2, 2 2))' DIALECT 3
+
+1) (integer) 2
+2) "small"
+3) 1) "geom"
+   2) "POLYGON((1 1, 1 100, 100 100, 100 1, 1 1))"
+4) "large"
+5) 1) "geom"
+   2) "POLYGON((1 1, 1 200, 200 200, 200 1, 1 1))"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) | [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) 
+
+## Related topics
+
+- [Extensions]({{< relref "/develop/interact/search-and-query/administration/extensions" >}})
+- [Highlighting]({{< relref "/develop/interact/search-and-query/advanced-concepts/highlight" >}})
+- [Query syntax]({{< relref "/develop/interact/search-and-query/query/" >}})
+- [RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@cms'
+- '@write'
+arguments:
+- name: destination
+  type: key
+- name: numKeys
+  type: integer
+- multiple: true
+  name: source
+  type: key
+- arguments:
+  - name: weights
+    token: WEIGHTS
+    type: pure-token
+  - multiple: true
+    name: weight
+    type: double
+  name: weight
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n) where n is the number of sketches
+description: Merges several sketches into one sketch
+group: cms
+hidden: false
+linkTitle: CMS.MERGE
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Merges several sketches into one sketch
+syntax_fmt: "CMS.MERGE destination numKeys source [source ...] [WEIGHTS weight\n \
+  \ [weight ...]]"
+syntax_str: numKeys source [source ...] [WEIGHTS weight [weight ...]]
+title: CMS.MERGE
+---
+Merges several sketches into one sketch. All sketches must have identical width and depth. Weights can be used to multiply certain sketches. Default weight is 1. 
+
+### Parameters:
+
+* **dest**: The name of destination sketch. Must be initialized. 
+* **numKeys**: Number of sketches to be merged.
+* **src**: Names of source sketches to be merged.
+* **weight**: Multiple of each sketch. Default =1.
+
+## Return
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+```
+redis> CMS.MERGE dest 2 test1 test2 WEIGHTS 1 3
+OK
+```
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N) where N is the number of entries in the group's pending entries list
+  (PEL).
+description: Destroys a consumer group.
+group: stream
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XGROUP DESTROY
+since: 5.0.0
+summary: Destroys a consumer group.
+syntax_fmt: XGROUP DESTROY key group
+syntax_str: group
+title: XGROUP DESTROY
+---
+The `XGROUP DESTROY` command completely destroys a consumer group.
+
+The consumer group will be destroyed even if there are active consumers, and pending messages, so make sure to call this command only when really needed.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+complexity: O(N) where N is the number of loaded modules.
+description: Returns all loaded modules.
+group: server
+hidden: false
+hints:
+- nondeterministic_output_order
+linkTitle: MODULE LIST
+since: 4.0.0
+summary: Returns all loaded modules.
+syntax_fmt: MODULE LIST
+syntax_str: ''
+title: MODULE LIST
+---
+Returns information about the modules loaded to the server.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Determines the type of value stored at a key.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: TYPE
+since: 1.0.0
+summary: Determines the type of value stored at a key.
+syntax_fmt: TYPE key
+syntax_str: ''
+title: TYPE
+---
+Returns the string representation of the type of the value stored at `key`.
+The different types that can be returned are: `string`, `list`, `set`, `zset`,
+`hash`, `stream`, and `vectorset`.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "value"
+LPUSH key2 "value"
+SADD key3 "value"
+TYPE key1
+TYPE key2
+TYPE key3
+{{% /redis-cli %}}
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(log(N)) where N is the number of elements in the vector set.
+description: Return elements by vector similarity.
+group: vector_set
+hidden: false
+linkTitle: VSIM
+since: 8.0.0
+summary: Return elements by vector similarity.
+syntax_fmt: "VSIM key (ELE | FP32 | VALUES num) (vector | element) [WITHSCORES] [COUNT num] [EF search-exploration-factor]\n  [FILTER expression] [FILTER-EF max-filtering-effort] [TRUTH] [NOTHREAD]"
+title: VSIM
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return elements similar to a given vector or element. Use this command to perform approximate or exact similarity searches within a vector set.
+
+You can query using either a vector (via `FP32` or `VALUES num`) or by referencing another element (using `ELE`). Optional parameters let you control the search behavior, such as score output, result count, and filtering options.
+
+```shell
+VSIM word_embeddings ELE apple
+1) "apple"
+2) "apples"
+3) "pear"
+4) "fruit"
+5) "berry"
+6) "pears"
+7) "strawberry"
+8) "peach"
+9) "potato"
+10) "grape"
+```
+
+You can include similarity scores and limit the number of results:
+
+```shell
+VSIM word_embeddings ELE apple WITHSCORES COUNT 3
+1) "apple"
+2) "0.9998867657923256"
+3) "apples"
+4) "0.8598527610301971"
+5) "pear"
+6) "0.8226882219314575"
+```
+
+Set the `EF` (exploration factor) to improve recall at the cost of performance. Use the `TRUTH` option to perform an exact linear scan, useful for benchmarking. The `NOTHREAD` option runs the search in the main thread and may increase server latency.
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set data.
+</details>
+
+<details open>
+<summary><code>ELE | FP32 | VALUES num</code></summary>
+
+specifies how the input vector is provided. Use `ELE` to refer to an existing element, `FP32` for binary float format, or `VALUES num` for a list of stringified float values.
+</details>
+
+<details open>
+<summary><code>vector or element</code></summary>
+
+is either the vector data (for `FP32` or `VALUES`) or the name of the element (for `ELE`) to use as the similarity reference.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>WITHSCORES</code></summary>
+
+returns the similarity score (from 1 to 0) alongside each result. A score of 1 is identical; 0 is the opposite.
+</details>
+
+<details open>
+<summary><code>COUNT num</code></summary>
+
+limits the number of returned results to `num`.
+</details>
+
+<details open>
+<summary><code>EF search-exploration-factor</code></summary>
+
+controls the search effort. Higher values explore more nodes, improving recall at the cost of speed. Typical values range from 50 to 1000.
+</details>
+
+<details open>
+<summary><code>FILTER expression</code></summary>
+
+applies a filter expression to restrict matching elements. See the filtered search section for syntax details.
+</details>
+
+<details open>
+<summary><code>FILTER-EF max-filtering-effort</code></summary>
+
+limits the number of filtering attempts for the `FILTER` expression. See the filtered search section for more.
+</details>
+
+<details open>
+<summary><code>TRUTH</code></summary>
+
+forces an exact linear scan of all elements, bypassing the HNSW graph. Use for benchmarking or to calculate recall. This is significantly slower (O(N)).
+</details>
+
+<details open>
+<summary><code>NOTHREAD</code></summary>
+
+executes the search in the main thread instead of a background thread. Useful for small vector sets or benchmarks. This may block the server during execution.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: connection
+hidden: true
+linkTitle: CLIENT HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: CLIENT HELP
+syntax_str: ''
+title: CLIENT HELP
+---
+The `CLIENT HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: seconds
+  name: seconds
+  type: integer
+- display_text: value
+  name: value
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+deprecated_since: 2.6.12
+description: Sets the string value and expiration time of a key. Creates the key if
+  it doesn't exist.
+doc_flags:
+- deprecated
+group: string
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: SETEX
+replaced_by: '[`SET`]({{< relref "/commands/set" >}}) with the `EX` argument'
+since: 2.0.0
+summary: Sets the string value and expiration time of a key. Creates the key if it
+  doesn't exist.
+syntax_fmt: SETEX key seconds value
+syntax_str: seconds value
+title: SETEX
+---
+Set `key` to hold the string `value` and set `key` to timeout after a given
+number of seconds.
+This command is equivalent to:
+
+```
+SET key value EX seconds
+```
+
+An error is returned when `seconds` is invalid.
+
+## Examples
+
+{{% redis-cli %}}
+SETEX mykey 10 "Hello"
+TTL mykey
+GET mykey
+{{% /redis-cli %}}
+
+## See also
+
+[`TTL`]({{< relref "/commands/ttl" >}})---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: host
+  name: host
+  type: string
+- display_text: port
+  name: port
+  type: integer
+- arguments:
+  - display_text: key
+    key_spec_index: 0
+    name: key
+    type: key
+  - display_text: empty-string
+    name: empty-string
+    token: ''
+    type: pure-token
+  name: key-selector
+  type: oneof
+- display_text: destination-db
+  name: destination-db
+  type: integer
+- display_text: timeout
+  name: timeout
+  type: integer
+- display_text: copy
+  name: copy
+  optional: true
+  since: 3.0.0
+  token: COPY
+  type: pure-token
+- display_text: replace
+  name: replace
+  optional: true
+  since: 3.0.0
+  token: REPLACE
+  type: pure-token
+- arguments:
+  - display_text: password
+    name: auth
+    since: 4.0.7
+    token: AUTH
+    type: string
+  - arguments:
+    - display_text: username
+      name: username
+      type: string
+    - display_text: password
+      name: password
+      type: string
+    name: auth2
+    since: 6.0.0
+    token: AUTH2
+    type: block
+  name: authentication
+  optional: true
+  type: oneof
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: keys
+  optional: true
+  since: 3.0.6
+  token: KEYS
+  type: key
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- movablekeys
+complexity: This command actually executes a DUMP+DEL in the source instance, and
+  a RESTORE in the target instance. See the pages of these commands for time complexity.
+  Also an O(N) data transfer between the two instances is performed.
+description: Atomically transfers a key from one Redis instance to another.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 3.0.0
+  - Added the `COPY` and `REPLACE` options.
+- - 3.0.6
+  - Added the `KEYS` option.
+- - 4.0.7
+  - Added the `AUTH` option.
+- - 6.0.0
+  - Added the `AUTH2` option.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 3
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      keyword: KEYS
+      startfrom: -2
+    type: keyword
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+  incomplete: true
+linkTitle: MIGRATE
+since: 2.6.0
+summary: Atomically transfers a key from one Redis instance to another.
+syntax_fmt: "MIGRATE host port <key | \"\"> destination-db timeout [COPY] [REPLACE]\n\
+  \  [AUTH\_password | AUTH2\_username password] [KEYS\_key [key ...]]"
+syntax_str: "port <key | \"\"> destination-db timeout [COPY] [REPLACE] [AUTH\_password\
+  \ | AUTH2\_username password] [KEYS\_key [key ...]]"
+title: MIGRATE
+---
+Atomically transfer a key from a source Redis instance to a destination Redis
+instance.
+On success the key is deleted from the original instance and is guaranteed to
+exist in the target instance.
+
+The command is atomic and blocks the two instances for the time required to
+transfer the key, at any given time the key will appear to exist in a given
+instance or in the other instance, unless a timeout error occurs. In 3.2 and
+above, multiple keys can be pipelined in a single call to `MIGRATE` by passing
+the empty string ("") as key and adding the `KEYS` clause.
+
+The command internally uses [`DUMP`]({{< relref "/commands/dump" >}}) to generate the serialized version of the key
+value, and [`RESTORE`]({{< relref "/commands/restore" >}}) in order to synthesize the key in the target instance.
+The source instance acts as a client for the target instance.
+If the target instance returns OK to the [`RESTORE`]({{< relref "/commands/restore" >}}) command, the source instance
+deletes the key using [`DEL`]({{< relref "/commands/del" >}}).
+
+The timeout specifies the maximum idle time in any moment of the communication
+with the destination instance in milliseconds.
+This means that the operation does not need to be completed within the specified
+amount of milliseconds, but that the transfer should make progresses without
+blocking for more than the specified amount of milliseconds.
+
+`MIGRATE` needs to perform I/O operations and to honor the specified timeout.
+When there is an I/O error during the transfer or if the timeout is reached the
+operation is aborted and the special error - `IOERR` returned.
+When this happens the following two cases are possible:
+
+* The key may be on both the instances.
+* The key may be only in the source instance.
+
+It is not possible for the key to get lost in the event of a timeout, but the
+client calling `MIGRATE`, in the event of a timeout error, should check if the
+key is _also_ present in the target instance and act accordingly.
+
+When any other error is returned (starting with `ERR`) `MIGRATE` guarantees that
+the key is still only present in the originating instance (unless a key with the
+same name was also _already_ present on the target instance).
+
+If there are no keys to migrate in the source instance `NOKEY` is returned.
+Because missing keys are possible in normal conditions, from expiry for example,
+`NOKEY` isn't an error. 
+
+## Migrating multiple keys with a single command call
+
+Starting with Redis 3.0.6 `MIGRATE` supports a new bulk-migration mode that
+uses pipelining in order to migrate multiple keys between instances without
+incurring in the round trip time latency and other overheads that there are
+when moving each key with a single `MIGRATE` call.
+
+In order to enable this form, the `KEYS` option is used, and the normal *key*
+argument is set to an empty string. The actual key names will be provided
+after the `KEYS` argument itself, like in the following example:
+
+    MIGRATE 192.168.1.34 6379 "" 0 5000 KEYS key1 key2 key3
+
+When this form is used the `NOKEY` status code is only returned when none
+of the keys is present in the instance, otherwise the command is executed, even if
+just a single key exists.
+
+## Options
+
+* `COPY` -- Do not remove the key from the local instance.
+* `REPLACE` -- Replace existing key on the remote instance.
+* `KEYS` -- If the key argument is an empty string, the command will instead migrate all the keys that follow the `KEYS` option (see the above section for more info).
+* `AUTH` -- Authenticate with the given password to the remote instance.
+* `AUTH2` -- Authenticate with the given username and password pair (Redis 6 or greater ACL auth style).
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: value
+  type: string
+- arguments:
+  - name: nx
+    token: NX
+    type: pure-token
+  - name: xx
+    token: XX
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M+N) when path is evaluated to a single value where M is the size of
+  the original value (if it exists) and N is the size of the new value, O(M+N) when
+  path is evaluated to multiple values where M is the size of the key and N is the
+  size of the new value * the number of original values in the key
+description: Sets or updates the JSON value at a path
+group: json
+hidden: false
+linkTitle: JSON.SET
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Sets or updates the JSON value at a path
+syntax_fmt: JSON.SET key path value [NX | XX]
+syntax_str: path value [NX | XX]
+title: JSON.SET
+---
+Set the JSON value at `path` in `key`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. For new Redis keys the `path` must be the root. For existing keys, when the entire `path` exists, the value that it contains is replaced with the `json` value. For existing keys, when the `path` exists, except for the last element, a new child is added with the `json` value. 
+
+Adds a key (with its respective value) to a JSON Object (in a RedisJSON data type key) only if it is the last child in the `path`, or it is the parent of a new child being added in the `path`. Optional arguments `NX` and `XX` modify this behavior for both new RedisJSON data type keys as well as the JSON Object keys in them.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is value to set at the specified path
+</details>
+
+## Optional arguments
+
+<details open><summary><code>NX</code></summary> 
+
+sets the key only if it does not already exist.
+</details>
+
+<details open><summary><code>XX</code></summary> 
+
+sets the key only if it already exists.
+</details>
+
+## Return value 
+
+Returns one of these replies:
+- A simple string reply: `OK` if executed correctly
+- `nil`
+  - if `key` exists but `path` does not exist and cannot be created
+  - if an `NX` or `XX` condition is unmet
+- error if `key` does not exist and `path` is not root  (`.` or `$`)
+
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Replace an existing value</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2}'
+OK
+redis> JSON.SET doc $.a '3'
+OK
+redis> JSON.GET doc $
+"[{\"a\":3}]"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Add a new value</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2}'
+OK
+redis> JSON.SET doc $.b '8'
+OK
+redis> JSON.GET doc $
+"[{\"a\":2,\"b\":8}]"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Update multi-paths</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"f1": {"a":1}, "f2":{"a":2}}'
+OK
+redis> JSON.SET doc $..a 3
+OK
+redis> JSON.GET doc
+"{\"f1\":{\"a\":3},\"f2\":{\"a\":3}}"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>path does not exist and cannot be created</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ 1
+OK
+redis> JSON.SET doc $.x.y 2
+(nil)
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>XX condition unmet</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET nonexistentkey $ 5 XX
+(nil)
+redis> JSON.GET nonexistentkey
+(nil)
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>key does not exist and path is not root</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET nonexistentkey $.x 5
+(error) ERR new objects must be created at the root
+{{< / highlight >}}
+</details>
+
+
+## See also
+
+[`JSON.GET`]({{< relref "commands/json.get/" >}}) | [`JSON.MGET`]({{< relref "commands/json.mget/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: name
+  name: name
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+complexity: O(1)
+description: Unloads a module.
+group: server
+hidden: false
+linkTitle: MODULE UNLOAD
+since: 4.0.0
+summary: Unloads a module.
+syntax_fmt: MODULE UNLOAD name
+syntax_str: ''
+title: MODULE UNLOAD
+---
+Unloads a module.
+
+This command unloads the module specified by `name`. Note that the module's name
+is reported by the [`MODULE LIST`]({{< relref "/commands/module-list" >}}) command, and may differ from the dynamic
+library's filename.
+
+Known limitations:
+
+*   Modules that register custom data types can not be unloaded.
+---
+acl_categories:
+- '@write'
+- '@bitmap'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: offset
+  name: offset
+  type: integer
+- display_text: value
+  name: value
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+description: Sets or clears the bit at offset of the string value. Creates the key
+  if it doesn't exist.
+group: bitmap
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: SETBIT
+since: 2.2.0
+summary: Sets or clears the bit at offset of the string value. Creates the key if
+  it doesn't exist.
+syntax_fmt: SETBIT key offset value
+syntax_str: offset value
+title: SETBIT
+---
+Sets or clears the bit at _offset_ in the string value stored at _key_.
+
+The bit is either set or cleared depending on _value_, which can be either 0 or
+1.
+
+When _key_ does not exist, a new string value is created.
+The string is grown to make sure it can hold a bit at _offset_.
+The _offset_ argument is required to be greater than or equal to 0, and smaller
+than 2^32 (this limits bitmaps to 512MB).
+When the string at _key_ is grown, added bits are set to 0.
+
+**Warning**: When setting the last possible bit (_offset_ equal to 2^32 -1) and
+the string value stored at _key_ does not yet hold a string value, or holds a
+small string value, Redis needs to allocate all intermediate memory which can
+block the server for some time.
+On a 2010 MacBook Pro, setting bit number 2^32 -1 (512MB allocation) takes
+~300ms, setting bit number 2^30 -1 (128MB allocation) takes ~80ms, setting bit
+number 2^28 -1 (32MB allocation) takes ~30ms and setting bit number 2^26 -1 (8MB
+allocation) takes ~8ms.
+Note that once this first allocation is done, subsequent calls to `SETBIT` for
+the same _key_ will not have the allocation overhead.
+
+## Examples
+
+{{% redis-cli %}}
+SETBIT mykey 7 1
+SETBIT mykey 7 0
+GET mykey
+{{% /redis-cli %}}
+
+
+## Pattern: accessing the entire bitmap
+
+There are cases when you need to set all the bits of single bitmap at once, for
+example when initializing it to a default non-zero value. It is possible to do
+this with multiple calls to the `SETBIT` command, one for each bit that needs to
+be set. However, so as an optimization you can use a single [`SET`]({{< relref "/commands/set" >}}) command to set
+the entire bitmap.
+
+Bitmaps are not an actual data type, but a set of bit-oriented operations
+defined on the String type (for more information refer to the
+[Bitmaps section of the Data Types Introduction page][ti]). This means that
+bitmaps can be used with string commands, and most importantly with [`SET`]({{< relref "/commands/set" >}}) and
+[`GET`]({{< relref "/commands/get" >}}).
+
+Because Redis' strings are binary-safe, a bitmap is trivially encoded as a bytes
+stream. The first byte of the string corresponds to offsets 0..7 of
+the bitmap, the second byte to the 8..15 range, and so forth.
+
+For example, after setting a few bits, getting the string value of the bitmap
+would look like this:
+
+```
+> SETBIT bitmapsarestrings 2 1
+> SETBIT bitmapsarestrings 3 1
+> SETBIT bitmapsarestrings 5 1
+> SETBIT bitmapsarestrings 10 1
+> SETBIT bitmapsarestrings 11 1
+> SETBIT bitmapsarestrings 14 1
+> GET bitmapsarestrings
+"42"
+```
+
+By getting the string representation of a bitmap, the client can then parse the
+response's bytes by extracting the bit values using native bit operations in its
+native programming language. Symmetrically, it is also possible to set an entire
+bitmap by performing the bits-to-bytes encoding in the client and calling [`SET`]({{< relref "/commands/set" >}})
+with the resultant string.
+
+[ti]: /develop/data-types-intro#bitmaps
+
+## Pattern: setting multiple bits
+
+`SETBIT` excels at setting single bits, and can be called several times when
+multiple bits need to be set. To optimize this operation you can replace
+multiple `SETBIT` calls with a single call to the variadic [`BITFIELD`]({{< relref "/commands/bitfield" >}}) command
+and the use of fields of type `u1`.
+
+For example, the example above could be replaced by:
+
+```
+> BITFIELD bitsinabitmap SET u1 2 1 SET u1 3 1 SET u1 5 1 SET u1 10 1 SET u1 11 1 SET u1 14 1
+```
+
+## Advanced Pattern: accessing bitmap ranges
+
+It is also possible to use the [`GETRANGE`]({{< relref "/commands/getrange" >}}) and [`SETRANGE`]({{< relref "/commands/setrange" >}}) string commands to
+efficiently access a range of bit offsets in a bitmap. Below is a sample
+implementation in idiomatic Redis Lua scripting that can be run with the [`EVAL`]({{< relref "/commands/eval" >}})
+command:
+
+```
+--[[
+Sets a bitmap range
+
+Bitmaps are stored as Strings in Redis. A range spans one or more bytes,
+so we can call [`SETRANGE`]({{< relref "/commands/setrange" >}}) when entire bytes need to be set instead of flipping
+individual bits. Also, to avoid multiple internal memory allocations in
+Redis, we traverse in reverse.
+Expected input:
+  KEYS[1] - bitfield key
+  ARGV[1] - start offset (0-based, inclusive)
+  ARGV[2] - end offset (same, should be bigger than start, no error checking)
+  ARGV[3] - value (should be 0 or 1, no error checking)
+]]--
+
+-- A helper function to stringify a binary string to semi-binary format
+local function tobits(str)
+  local r = ''
+  for i = 1, string.len(str) do
+    local c = string.byte(str, i)
+    local b = ' '
+    for j = 0, 7 do
+      b = tostring(bit.band(c, 1)) .. b
+      c = bit.rshift(c, 1)
+    end
+    r = r .. b
+  end
+  return r
+end
+
+-- Main
+local k = KEYS[1]
+local s, e, v = tonumber(ARGV[1]), tonumber(ARGV[2]), tonumber(ARGV[3])
+
+-- First treat the dangling bits in the last byte
+local ms, me = s % 8, (e + 1) % 8
+if me > 0 then
+  local t = math.max(e - me + 1, s)
+  for i = e, t, -1 do
+    redis.call('SETBIT', k, i, v)
+  end
+  e = t
+end
+
+-- Then the danglings in the first byte
+if ms > 0 then
+  local t = math.min(s - ms + 7, e)
+  for i = s, t, 1 do
+    redis.call('SETBIT', k, i, v)
+  end
+  s = t + 1
+end
+
+-- Set a range accordingly, if at all
+local rs, re = s / 8, (e + 1) / 8
+local rl = re - rs
+if rl > 0 then
+  local b = '\255'
+  if 0 == v then
+    b = '\0'
+  end
+  redis.call('SETRANGE', k, rs, string.rep(b, rl))
+end
+```
+
+**Note:** the implementation for getting a range of bit offsets from a bitmap is
+left as an exercise to the reader.
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- arguments:
+  - name: key
+    type: key
+  - name: timestamp
+    type: string
+  - name: value
+    type: double
+  multiple: true
+  name: ktv
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N*M) when N is the amount of series updated and M is the amount of compaction
+  rules or O(N) with no compaction
+description: Append new samples to one or more time series
+group: timeseries
+hidden: false
+linkTitle: TS.MADD
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Append new samples to one or more time series
+syntax: 'TS.MADD {key timestamp value}...
+
+  '
+syntax_fmt: TS.MADD key timestamp value [key timestamp value ...]
+syntax_str: ''
+title: TS.MADD
+---
+
+Append new samples to one or more time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary> 
+
+is the key name for the time series.
+</details>
+
+<details open>
+<summary><code>timestamp</code></summary>
+
+is Unix time (integer, in milliseconds) specifying the sample timestamp or `*` to set the sample timestamp to the Unix time of the server's clock.
+
+Unix time is the number of milliseconds that have elapsed since 00:00:00 UTC on 1 January 1970, the Unix epoch, without adjustments made due to leap seconds.
+</details>
+
+<details open>
+<summary><code>value</code></summary>
+
+is numeric data value of the sample (double). The double number should follow <a href="https://tools.ietf.org/html/rfc7159">RFC 7159</a> (a JSON standard). The parser rejects overly large values that would not fit in binary64. It does not accept NaN or infinite values.
+</details>
+
+<note><b>Notes:</b>
+- If `timestamp` is older than the retention period compared to the maximum existing timestamp, the sample is discarded and an error is returned.
+- Explicitly adding samples to a compacted time series (using [`TS.ADD`]({{< relref "commands/ts.add/" >}}), `TS.MADD`, [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), or [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}})) may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples.
+- `ignoreMaxTimeDiff` and `ignoreMaxValDiff` cannot be specified as is the case with `TS.ADD`. However, the same logic still applies based on the values of the per-key configuration parameters. See the [`TS.ADD`]({{< relref "commands/ts.add/" >}}) command page for more information.
+</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}), where each element is an [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) representing the timestamp of a upserted sample or an [] (when duplication policy is `BLOCK`, or when `timestamp` is older than the retention period compared to the maximum existing timestamp). For each element that is ignored (see `IGNORE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}})), the reply element value will be the largest timestamp in the time series.
+- [] (invalid arguments, wrong key type, etc.)
+
+## Complexity
+
+If a compaction rule exits on a time series, TS.MADD performance might be reduced.
+The complexity of TS.MADD is always `O(N*M)`, where `N` is the amount of series updated and `M` is the number of compaction rules or `O(N)` with no compaction.
+
+## Examples
+
+<details open>
+<summary><b>Add stock prices at different timestamps</b></summary>
+
+Create two stocks and add their prices at three different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.CREATE stock:B LABELS type stock name B
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120 stock:B 1000 120 stock:B 1010 110 stock:B 1020 100
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+4) (integer) 1000
+5) (integer) 1010
+6) (integer) 1020
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) | [`TS.REVRANGE`]({{< relref "commands/ts.revrange/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Dumps the contents of a synonym group
+group: search
+hidden: false
+linkTitle: FT.SYNDUMP
+module: Search
+since: 1.2.0
+stack_path: docs/interact/search-and-query
+summary: Dumps the contents of a synonym group
+syntax: 'FT.SYNDUMP index
+
+  '
+syntax_fmt: FT.SYNDUMP index
+syntax_str: ''
+title: FT.SYNDUMP
+---
+
+Dump the contents of a synonym group
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name.
+</details>
+
+Use FT.SYNDUMP to dump the synonyms data structure. This command returns a list of synonym terms and their synonym group ids.
+
+## Return
+
+FT.SYNDUMP returns an array reply, with a pair of `term` and an array of synonym groups.
+
+## Examples
+
+<details open>
+<summary><b>Return the contents of a synonym group</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SYNDUMP idx
+1) "shalom"
+2) 1) "synonym1"
+   2) "synonym2"
+3) "hi"
+4) 1) "synonym1"
+5) "hello"
+6) 1) "synonym1"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SYNUPDATE`]({{< relref "commands/ft.synupdate/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: milliseconds
+  name: milliseconds
+  type: integer
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Set expiration for hash fields using relative time to expire (milliseconds)
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HPEXPIRE
+since: 7.4.0
+summary: Set expiry for hash field using relative time to expire (milliseconds)
+syntax_fmt: "HPEXPIRE key milliseconds [NX | XX | GT | LT] FIELDS\_numfields field\n\
+  \  [field ...]"
+syntax_str: "milliseconds [NX | XX | GT | LT] FIELDS\_numfields field [field ...]"
+title: HPEXPIRE
+---
+This command works like [`HEXPIRE`]({{< relref "/commands/hexpire" >}}), but the expiration of a field is
+specified in milliseconds instead of seconds.
+
+## Options
+
+The `HPEXPIRE` command supports a set of options:
+
+* `NX` -- For each specified field, set expiration only when the field has no expiration.
+* `XX` -- For each specified field, set expiration only when the field has an existing expiration.
+* `GT` -- For each specified field, set expiration only when the new expiration is greater than current one.
+* `LT` -- For each specified field, set expiration only when the new expiration is less than current one.
+
+A non-volatile key is treated as an infinite TTL for the purposes of `GT` and `LT`.
+The `NX`, `XX`, `GT`, and `LT` options are mutually exclusive.
+
+## Example
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer 2)
+redis> HPEXPIRE mykey 2000 FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HGETALL mykey
+(empty array)
+```
+
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+- '@blocking'
+arguments:
+- arguments:
+  - display_text: group
+    name: group
+    type: string
+  - display_text: consumer
+    name: consumer
+    type: string
+  name: group-block
+  token: GROUP
+  type: block
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+- display_text: milliseconds
+  name: milliseconds
+  optional: true
+  token: BLOCK
+  type: integer
+- display_text: noack
+  name: noack
+  optional: true
+  token: NOACK
+  type: pure-token
+- arguments:
+  - display_text: key
+    key_spec_index: 0
+    multiple: true
+    name: key
+    type: key
+  - display_text: id
+    multiple: true
+    name: id
+    type: string
+  name: streams
+  token: STREAMS
+  type: block
+arity: -7
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+- movablekeys
+complexity: 'For each stream mentioned: O(M) with M being the number of elements returned.
+  If M is constant (e.g. always asking for the first 10 elements with COUNT), you
+  can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the
+  O(N) time in order to serve the N clients blocked on the stream getting new data.'
+description: Returns new or historical messages from a stream for a consumer in a
+  group. Blocks until a message is available otherwise.
+group: stream
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      keyword: STREAMS
+      startfrom: 4
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 2
+    type: range
+linkTitle: XREADGROUP
+since: 5.0.0
+summary: Returns new or historical messages from a stream for a consumer in a group.
+  Blocks until a message is available otherwise.
+syntax_fmt: "XREADGROUP GROUP\_group consumer [COUNT\_count] [BLOCK\_milliseconds]\n\
+  \  [NOACK] STREAMS\_key [key ...] id [id ...]"
+syntax_str: "[COUNT\_count] [BLOCK\_milliseconds] [NOACK] STREAMS\_key [key ...] id\
+  \ [id ...]"
+title: XREADGROUP
+---
+The `XREADGROUP` command is a special version of the [`XREAD`]({{< relref "/commands/xread" >}}) command
+with support for consumer groups. Probably you will have to understand the
+[`XREAD`]({{< relref "/commands/xread" >}}) command before reading this page will makes sense.
+
+Moreover, if you are new to streams, we recommend to read our
+[introduction to Redis Streams]({{< relref "/develop/data-types/streams" >}}).
+Make sure to understand the concept of consumer group in the introduction
+so that following how this command works will be simpler.
+
+## Consumer groups in 30 seconds
+
+The difference between this command and the vanilla [`XREAD`]({{< relref "/commands/xread" >}}) is that this
+one supports consumer groups.
+
+Without consumer groups, just using [`XREAD`]({{< relref "/commands/xread" >}}), all the clients are served with all the entries arriving in a stream. Instead using consumer groups with `XREADGROUP`, it is possible to create groups of clients that consume different parts of the messages arriving in a given stream. If, for instance, the stream gets the new entries A, B, and C and there are two consumers reading via a consumer group, one client will get, for instance, the messages A and C, and the other the message B, and so forth.
+
+Within a consumer group, a given consumer (that is, just a client consuming messages from the stream), has to identify with a unique *consumer name*. Which is just a string.
+
+One of the guarantees of consumer groups is that a given consumer can only see the history of messages that were delivered to it, so a message has just a single owner. However there is a special feature called *message claiming* that allows other consumers to claim messages in case there is a non recoverable failure of some consumer. In order to implement such semantics, consumer groups require explicit acknowledgment of the messages successfully processed by the consumer, via the [`XACK`]({{< relref "/commands/xack" >}}) command. This is needed because the stream will track, for each consumer group, who is processing what message.
+
+This is how to understand if you want to use a consumer group or not:
+
+1. If you have a stream and multiple clients, and you want all the clients to get all the messages, you do not need a consumer group.
+2. If you have a stream and multiple clients, and you want the stream to be *partitioned* or *sharded* across your clients, so that each client will get a sub set of the messages arriving in a stream, you need a consumer group.
+
+## Differences between XREAD and XREADGROUP
+
+From the point of view of the syntax, the commands are almost the same,
+however `XREADGROUP` *requires* a special and mandatory option:
+
+    GROUP <group-name> <consumer-name>
+
+The group name is just the name of a consumer group associated to the stream.
+The group is created using the [`XGROUP`]({{< relref "/commands/xgroup" >}}) command. The consumer name is the
+string that is used by the client to identify itself inside the group.
+The consumer is auto created inside the consumer group the first time it
+is seen. Different clients should select a different consumer name.
+
+When you read with `XREADGROUP`, the server will *remember* that a given
+message was delivered to you: the message will be stored inside the
+consumer group in what is called a Pending Entries List (PEL), that is
+a list of message IDs delivered but not yet acknowledged.
+
+The client will have to acknowledge the message processing using [`XACK`]({{< relref "/commands/xack" >}})
+in order for the pending entry to be removed from the PEL. The PEL
+can be inspected using the [`XPENDING`]({{< relref "/commands/xpending" >}}) command.
+
+The `NOACK` subcommand can be used to avoid adding the message to the PEL in
+cases where reliability is not a requirement and the occasional message loss
+is acceptable. This is equivalent to acknowledging the message when it is read.
+
+The ID to specify in the **STREAMS** option when using `XREADGROUP` can
+be one of the following two:
+
+* The special `>` ID, which means that the consumer want to receive only messages that were *never delivered to any other consumer*. It just means, give me new messages.
+* Any other ID, that is, 0 or any other valid ID or incomplete ID (just the millisecond time part), will have the effect of returning entries that are pending for the consumer sending the command with IDs greater than the one provided. So basically if the ID is not `>`, then the command will just let the client access its pending entries: messages delivered to it, but not yet acknowledged. Note that in this case, both `BLOCK` and `NOACK` are ignored.
+
+Like [`XREAD`]({{< relref "/commands/xread" >}}) the `XREADGROUP` command can be used in a blocking way. There
+are no differences in this regard.
+
+## What happens when a message is delivered to a consumer?
+
+Two things:
+
+1. If the message was never delivered to anyone, that is, if we are talking about a new message, then a PEL (Pending Entries List) is created.
+2. If instead the message was already delivered to this consumer, and it is just re-fetching the same message again, then the *last delivery counter* is updated to the current time, and the *number of deliveries* is incremented by one. You can access those message properties using the [`XPENDING`]({{< relref "/commands/xpending" >}}) command.
+
+## Usage example
+
+Normally you use the command like that in order to get new messages and
+process them. In pseudo-code:
+
+```
+WHILE true
+    entries = XREADGROUP GROUP $GroupName $ConsumerName BLOCK 2000 COUNT 10 STREAMS mystream >
+    if entries == nil
+        puts "Timeout... try again"
+        CONTINUE
+    end
+
+    FOREACH entries AS stream_entries
+        FOREACH stream_entries as message
+            process_message(message.id,message.fields)
+
+            # ACK the message as processed
+            XACK mystream $GroupName message.id
+        END
+    END
+END
+```
+
+In this way the example consumer code will fetch only new messages, process
+them, and acknowledge them via [`XACK`]({{< relref "/commands/xack" >}}). However the example code above is
+not complete, because it does not handle recovering after a crash. What
+will happen if we crash in the middle of processing messages, is that our
+messages will remain in the pending entries list, so we can access our
+history by giving `XREADGROUP` initially an ID of 0, and performing the same
+loop. Once providing an ID of 0 the reply is an empty set of messages, we
+know that we processed and acknowledged all the pending messages: we
+can start to use `>` as ID, in order to get the new messages and rejoin the
+consumers that are processing new things.
+
+To see how the command actually replies, please check the [`XREAD`]({{< relref "/commands/xread" >}}) command page.
+
+## What happens when a pending message is deleted?
+
+Entries may be deleted from the stream due to trimming or explicit calls to [`XDEL`]({{< relref "/commands/xdel" >}}) at any time.
+By design, Redis doesn't prevent the deletion of entries that are present in the stream's PELs.
+When this happens, the PELs retain the deleted entries' IDs, but the actual entry payload is no longer available.
+Therefore, when reading such PEL entries, Redis will return a null value in place of their respective data.
+
+Example:
+
+```
+> XADD mystream 1 myfield mydata
+"1-0"
+> XGROUP CREATE mystream mygroup 0
+OK
+> XREADGROUP GROUP mygroup myconsumer STREAMS mystream >
+1) 1) "mystream"
+   2) 1) 1) "1-0"
+         2) 1) "myfield"
+            2) "mydata"
+> XDEL mystream 1-0
+(integer) 1
+> XREADGROUP GROUP mygroup myconsumer STREAMS mystream 0
+1) 1) "mystream"
+   2) 1) 1) "1-0"
+         2) (nil)
+```
+
+Reading the [Redis Streams introduction]({{< relref "/develop/data-types/streams" >}}) is highly
+suggested in order to understand more about the streams overall behavior
+and semantics.
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for object introspection commands.
+group: generic
+hidden: true
+linkTitle: OBJECT
+since: 2.2.3
+summary: A container for object introspection commands.
+syntax_fmt: OBJECT
+syntax_str: ''
+title: OBJECT
+---
+This is a container command for object introspection commands.
+
+To see the list of available commands you can call [`OBJECT HELP`]({{< relref "/commands/object-help" >}}).
+---
+acl_categories:
+- '@search'
+arguments:
+- name: key
+  type: string
+- name: prefix
+  type: string
+- name: fuzzy
+  optional: true
+  token: FUZZY
+  type: pure-token
+- name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+- name: withpayloads
+  optional: true
+  token: WITHPAYLOADS
+  type: pure-token
+- name: max
+  optional: true
+  token: MAX
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Gets completion suggestions for a prefix
+group: suggestion
+hidden: false
+linkTitle: FT.SUGGET
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Gets completion suggestions for a prefix
+syntax: "FT.SUGGET key prefix \n  [FUZZY] \n  [WITHSCORES] \n  [WITHPAYLOADS] \n \
+  \ [MAX max]\n"
+syntax_fmt: "FT.SUGGET key prefix [FUZZY] [WITHSCORES] [WITHPAYLOADS] [MAX\_max]"
+syntax_str: "prefix [FUZZY] [WITHSCORES] [WITHPAYLOADS] [MAX\_max]"
+title: FT.SUGGET
+---
+
+Get completion suggestions for a prefix
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is suggestion dictionary key.
+</details>
+
+<details open>
+<summary><code>prefix</code></summary>
+
+is prefix to complete on.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>FUZZY</code></summary> 
+
+performs a fuzzy prefix search, including prefixes at Levenshtein distance of 1 from the prefix sent.
+</details>
+
+<details open>
+<summary><code>MAX num</code></summary> 
+
+limits the results to a maximum of `num` (default: 5).
+</details>
+
+<details open>
+<summary><code>WITHSCORES</code></summary> 
+
+also returns the score of each suggestion. This can be used to merge results from multiple instances.
+</details>
+
+<details open>
+<summary><code>WITHPAYLOADS</code></summary> 
+
+returns optional payloads saved along with the suggestions. If no payload is present for an entry, it returns a null reply.
+</details>
+
+## Return
+
+FT.SUGGET returns an array reply, which is a list of the top suggestions matching the prefix, optionally with score after each entry.
+
+## Example
+
+<details open>
+<summary><b>Get completion suggestions for a prefix</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SUGGET sug hell FUZZY MAX 3 WITHSCORES
+1) "hell"
+2) "2147483648"
+3) "hello"
+4) "0.70710676908493042"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.SUGADD`]({{< relref "commands/ft.sugadd/" >}}) | [`FT.SUGDEL`]({{< relref "commands/ft.sugdel/" >}}) | [`FT.SUGLEN`]({{< relref "commands/ft.suglen/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@sortedset'
+- '@list'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: pattern
+  key_spec_index: 1
+  name: by-pattern
+  optional: true
+  token: BY
+  type: pattern
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+- display_text: pattern
+  key_spec_index: 1
+  multiple: true
+  multiple_token: true
+  name: get-pattern
+  optional: true
+  token: GET
+  type: pattern
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- display_text: sorting
+  name: sorting
+  optional: true
+  token: ALPHA
+  type: pure-token
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(N+M*log(M)) where N is the number of elements in the list or set to
+  sort, and M the number of returned elements. When the elements are not sorted, complexity
+  is O(N).
+description: Returns the sorted elements of a list, a set, or a sorted set.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RO: true
+  access: true
+  begin_search:
+    spec: {}
+    type: unknown
+  find_keys:
+    spec: {}
+    type: unknown
+  notes: For the optional BY/GET keyword. It is marked 'unknown' because the key names
+    derive from the content of the key we sort
+linkTitle: SORT_RO
+since: 7.0.0
+summary: Returns the sorted elements of a list, a set, or a sorted set.
+syntax_fmt: "SORT_RO key [BY\_pattern] [LIMIT\_offset count] [GET\_pattern [GET\n\
+  \  pattern ...]] [ASC | DESC] [ALPHA]"
+syntax_str: "[BY\_pattern] [LIMIT\_offset count] [GET\_pattern [GET pattern ...]]\
+  \ [ASC | DESC] [ALPHA]"
+title: SORT_RO
+---
+Read-only variant of the [`SORT`]({{< relref "/commands/sort" >}}) command. It is exactly like the original [`SORT`]({{< relref "/commands/sort" >}}) but refuses the `STORE` option and can safely be used in read-only replicas.
+
+Since the original [`SORT`]({{< relref "/commands/sort" >}}) has a `STORE` option it is technically flagged as a writing command in the Redis command table. For this reason read-only replicas in a Redis Cluster will redirect it to the master instance even if the connection is in read-only mode (see the [`READONLY`]({{< relref "/commands/readonly" >}}) command of Redis Cluster).
+
+The `SORT_RO` variant was introduced in order to allow [`SORT`]({{< relref "/commands/sort" >}}) behavior in read-only replicas without breaking compatibility on command flags.
+
+See original [`SORT`]({{< relref "/commands/sort" >}}) for more details.
+
+## Examples
+
+```
+SORT_RO mylist BY weight_*->fieldname GET object_*->fieldname
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Retrieve the JSON attributes of elements.
+group: vector_set
+hidden: false
+linkTitle: VGETATTR
+since: 8.0.0
+summary: Retrieve the JSON attributes of elements.
+syntax_fmt: "VGETATTR key element"
+title: VGETATTR
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return the JSON attributes associated with an element in a vector set.
+
+```shell
+VGETATTR key element
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element whose attributes you want to retrieve.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of configured users.
+description: Lists all ACL users.
+group: server
+hidden: false
+linkTitle: ACL USERS
+since: 6.0.0
+summary: Lists all ACL users.
+syntax_fmt: ACL USERS
+syntax_str: ''
+title: ACL USERS
+---
+The command shows a list of all the usernames of the currently configured
+users in the Redis ACL system.
+
+## Examples
+
+```
+> ACL USERS
+1) "anna"
+2) "antirez"
+3) "default"
+```
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the number of members in a set.
+group: set
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SCARD
+since: 1.0.0
+summary: Returns the number of members in a set.
+syntax_fmt: SCARD key
+syntax_str: ''
+title: SCARD
+---
+Returns the set cardinality (number of elements) of the set stored at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "Hello"
+SADD myset "World"
+SCARD myset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) where path is evaluated to a single value, O(N) where path is evaluated
+  to multiple values, where N is the size of the key
+description: Returns the length of the array at path
+group: json
+hidden: false
+linkTitle: JSON.ARRLEN
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the length of the array at path
+syntax_fmt: JSON.ARRLEN key [path]
+syntax_str: '[path]'
+title: JSON.ARRLEN
+---
+Report the length of the JSON array at `path` in `key`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`, if not provided. Returns null if the `key` or `path` do not exist.
+</details>
+
+## Return
+
+`JSON.ARRLEN` returns an [array]({{< relref "develop/reference/protocol-spec#resp-arrays" >}}) of integer replies, an integer for each matching value, each is the array's length, or `nil`, if the matching value is not an array.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+<details open>
+<summary><b>Get lengths of JSON arrays in a document</b></summary>
+
+Create a document for wireless earbuds.
+
+{{< highlight bash >}}
+redis> JSON.SET item:2 $ '{"name":"Wireless earbuds","description":"Wireless Bluetooth in-ear headphones","connection":{"wireless":true,"type":"Bluetooth"},"price":64.99,"stock":17,"colors":["black","white"], "max_level":[80, 100, 120]}'
+OK
+{{< / highlight >}}
+
+Find lengths of arrays in all objects of the document.
+
+{{< highlight bash >}}
+redis> JSON.ARRLEN item:2 '$.[*]'
+1) (nil)
+2) (nil)
+3) (nil)
+4) (nil)
+5) (nil)
+6) (integer) 2
+7) (integer) 3
+{{< / highlight >}}
+
+Return the length of the `max_level` array.
+
+{{< highlight bash >}}
+redis> JSON.ARRLEN item:2 '$..max_level'
+1) (integer) 3
+{{< / highlight >}}
+
+Get all the maximum level values.
+
+{{< highlight bash >}}
+redis> JSON.GET item:2 '$..max_level'
+"[[80,100,120]]"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Deletes all slots information from a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER FLUSHSLOTS
+since: 3.0.0
+summary: Deletes all slots information from a node.
+syntax_fmt: CLUSTER FLUSHSLOTS
+syntax_str: ''
+title: CLUSTER FLUSHSLOTS
+---
+Deletes all slots from a node.
+
+The `CLUSTER FLUSHSLOTS` deletes all information about slots from the connected node. It can only be called when the database is empty.
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- arguments:
+  - display_text: min-idle-time
+    name: min-idle-time
+    optional: true
+    since: 6.2.0
+    token: IDLE
+    type: integer
+  - display_text: start
+    name: start
+    type: string
+  - display_text: end
+    name: end
+    type: string
+  - display_text: count
+    name: count
+    type: integer
+  - display_text: consumer
+    name: consumer
+    optional: true
+    type: string
+  name: filters
+  optional: true
+  type: block
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) with N being the number of elements returned, so asking for a small
+  fixed number of entries per call is O(1). O(M), where M is the total number of entries
+  scanned when used with the IDLE filter. When the command returns just the summary
+  and the list of consumers is small, it runs in O(1) time; otherwise, an additional
+  O(N) time for iterating every consumer.
+description: Returns the information and entries from a stream consumer group's pending
+  entries list.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 6.2.0
+  - Added the `IDLE` option and exclusive range intervals.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XPENDING
+since: 5.0.0
+summary: Returns the information and entries from a stream consumer group's pending
+  entries list.
+syntax_fmt: "XPENDING key group [[IDLE\_min-idle-time] start end count [consumer]]"
+syntax_str: "group [[IDLE\_min-idle-time] start end count [consumer]]"
+title: XPENDING
+---
+Fetching data from a stream via a consumer group, and not acknowledging
+such data, has the effect of creating *pending entries*. This is
+well explained in the [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) command, and even better in our
+[introduction to Redis Streams]({{< relref "/develop/data-types/streams" >}}). The [`XACK`]({{< relref "/commands/xack" >}}) command
+will immediately remove the pending entry from the Pending Entries List (PEL)
+since once a message is successfully processed, there is no longer need
+for the consumer group to track it and to remember the current owner
+of the message.
+
+The `XPENDING` command is the interface to inspect the list of pending
+messages, and is as thus a very important command in order to observe
+and understand what is happening with a streams consumer groups: what
+clients are active, what messages are pending to be consumed, or to see
+if there are idle messages. Moreover this command, together with [`XCLAIM`]({{< relref "/commands/xclaim" >}})
+is used in order to implement recovering of consumers that are failing
+for a long time, and as a result certain messages are not processed: a
+different consumer can claim the message and continue. This is better
+explained in the [streams intro]({{< relref "/develop/data-types/streams" >}}) and in the
+[`XCLAIM`]({{< relref "/commands/xclaim" >}}) command page, and is not covered here.
+
+## Summary form of XPENDING
+
+When `XPENDING` is called with just a key name and a consumer group
+name, it just outputs a summary about the pending messages in a given
+consumer group. In the following example, we create a consumer group and
+immediately create a pending message by reading from the group with
+[`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}).
+
+```
+> XGROUP CREATE mystream group55 0-0
+OK
+
+> XREADGROUP GROUP group55 consumer-123 COUNT 1 STREAMS mystream >
+1) 1) "mystream"
+   2) 1) 1) 1526984818136-0
+         2) 1) "duration"
+            2) "1532"
+            3) "event-id"
+            4) "5"
+            5) "user-id"
+            6) "7782813"
+```
+
+We expect the pending entries list for the consumer group `group55` to
+have a message right now: consumer named `consumer-123` fetched the
+message without acknowledging its processing. The simple `XPENDING`
+form will give us this information:
+
+```
+> XPENDING mystream group55
+1) (integer) 1
+2) 1526984818136-0
+3) 1526984818136-0
+4) 1) 1) "consumer-123"
+      2) "1"
+```
+
+In this form, the command outputs the total number of pending messages for this
+consumer group, which is one, followed by the smallest and greatest ID among the
+pending messages, and then list every consumer in the consumer group with
+at least one pending message, and the number of pending messages it has.
+
+## Extended form of XPENDING
+
+The summary provides a good overview, but sometimes we are interested in the
+details. In order to see all the pending messages with more associated
+information we need to also pass a range of IDs, in a similar way we do it with
+[`XRANGE`]({{< relref "/commands/xrange" >}}), and a non optional *count* argument, to limit the number
+of messages returned per call:
+
+```
+> XPENDING mystream group55 - + 10
+1) 1) 1526984818136-0
+   2) "consumer-123"
+   3) (integer) 196415
+   4) (integer) 1
+```
+
+In the extended form we no longer see the summary information, instead there
+is detailed information for each message in the pending entries list. For
+each message four attributes are returned:
+
+1. The ID of the message.
+2. The name of the consumer that fetched the message and has still to acknowledge it. We call it the current *owner* of the message.
+3. The number of milliseconds that elapsed since the last time this message was delivered to this consumer.
+4. The number of times this message was delivered.
+
+The deliveries counter, that is the fourth element in the array, is incremented
+when some other consumer *claims* the message with [`XCLAIM`]({{< relref "/commands/xclaim" >}}), or when the
+message is delivered again via [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), when accessing the history
+of a consumer in a consumer group (see the [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) page for more info).
+
+It is possible to pass an additional argument to the command, in order
+to see the messages having a specific owner:
+
+```
+> XPENDING mystream group55 - + 10 consumer-123
+```
+
+But in the above case the output would be the same, since we have pending
+messages only for a single consumer. However what is important to keep in
+mind is that this operation, filtering by a specific consumer, is not
+inefficient even when there are many pending messages from many consumers:
+we have a pending entries list data structure both globally, and for
+every consumer, so we can very efficiently show just messages pending for
+a single consumer.
+
+## Idle time filter
+
+It is also possible to filter pending stream entries by their idle-time,
+given in milliseconds (useful for [`XCLAIM`]({{< relref "/commands/xclaim" >}})ing entries that have not been
+processed for some time):
+
+```
+> XPENDING mystream group55 IDLE 9000 - + 10
+> XPENDING mystream group55 IDLE 9000 - + 10 consumer-123
+```
+
+The first case will return the first 10 (or less) PEL entries of the entire group
+that are idle for over 9 seconds, whereas in the second case only those of
+`consumer-123`.
+
+## Exclusive ranges and iterating the PEL
+
+The `XPENDING` command allows iterating over the pending entries just like
+[`XRANGE`]({{< relref "/commands/xrange" >}}) and [`XREVRANGE`]({{< relref "/commands/xrevrange" >}}) allow for the stream's entries. You can do this by
+prefixing the ID of the last-read pending entry with the `(` character that
+denotes an open (exclusive) range, and proving it to the subsequent call to the
+command.
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N) where N is the number of keys that will be removed. When a key to
+  remove holds a value other than a string, the individual complexity for this key
+  is O(M) where M is the number of elements in the list, set, sorted set or hash.
+  Removing a single key that holds a string value is O(1).
+description: Deletes one or more keys.
+group: generic
+hidden: false
+hints:
+- request_policy:multi_shard
+- response_policy:agg_sum
+key_specs:
+- RM: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: DEL
+since: 1.0.0
+summary: Deletes one or more keys.
+syntax_fmt: DEL key [key ...]
+syntax_str: ''
+title: DEL
+---
+Removes the specified keys.
+A key is ignored if it does not exist.
+
+## Examples
+
+{{< clients-example cmds_generic del >}}
+> SET key1 "Hello"
+"OK"
+> SET key2 "World"
+"OK"
+> DEL key1 key2 key3
+(integer) 2
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+SET key1 "Hello"
+SET key2 "World"
+DEL key1 key2 key3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: node-id
+  name: node-id
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Configure a node as replica of a master node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER REPLICATE
+since: 3.0.0
+summary: Configure a node as replica of a master node.
+syntax_fmt: CLUSTER REPLICATE node-id
+syntax_str: ''
+title: CLUSTER REPLICATE
+---
+The command reconfigures a node as a replica of the specified master.
+If the node receiving the command is an *empty master*, as a side effect
+of the command, the node role is changed from master to replica.
+
+Once a node is turned into the replica of another master node, there is no need
+to inform the other cluster nodes about the change: heartbeat packets exchanged
+between nodes will propagate the new configuration automatically.
+
+A replica will always accept the command, assuming that:
+
+1. The specified node ID exists in its nodes table.
+2. The specified node ID does not identify the instance we are sending the command to.
+3. The specified node ID is a master.
+
+If the node receiving the command is not already a replica, but is a master,
+the command will only succeed, and the node will be converted into a replica,
+only if the following additional conditions are met:
+
+1. The node is not serving any hash slots.
+2. The node is empty, no keys are stored at all in the key space.
+
+If the command succeeds the new replica will immediately try to contact its master in order to replicate from it.
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: milliseconds
+  name: milliseconds
+  type: integer
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  since: 7.0.0
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Sets the expiration time of a key in milliseconds.
+group: generic
+hidden: false
+history:
+- - 7.0.0
+  - 'Added options: `NX`, `XX`, `GT` and `LT`.'
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: PEXPIRE
+since: 2.6.0
+summary: Sets the expiration time of a key in milliseconds.
+syntax_fmt: PEXPIRE key milliseconds [NX | XX | GT | LT]
+syntax_str: milliseconds [NX | XX | GT | LT]
+title: PEXPIRE
+---
+This command works exactly like [`EXPIRE`]({{< relref "/commands/expire" >}}) but the time to live of the key is
+specified in milliseconds instead of seconds.
+
+## Options
+
+The `PEXPIRE` command supports a set of options since Redis 7.0:
+
+* `NX` -- Set expiry only when the key has no expiry
+* `XX` -- Set expiry only when the key has an existing expiry
+* `GT` -- Set expiry only when the new expiry is greater than current one
+* `LT` -- Set expiry only when the new expiry is less than current one
+
+A non-volatile key is treated as an infinite TTL for the purpose of `GT` and `LT`.
+The `GT`, `LT` and `NX` options are mutually exclusive.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+PEXPIRE mykey 1500
+TTL mykey
+PTTL mykey
+PEXPIRE mykey 1000 XX
+TTL mykey
+PEXPIRE mykey 1000 NX
+TTL mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member1
+  name: member1
+  type: string
+- display_text: member2
+  name: member2
+  type: string
+- arguments:
+  - display_text: m
+    name: m
+    token: M
+    type: pure-token
+  - display_text: km
+    name: km
+    token: KM
+    type: pure-token
+  - display_text: ft
+    name: ft
+    token: FT
+    type: pure-token
+  - display_text: mi
+    name: mi
+    token: MI
+    type: pure-token
+  name: unit
+  optional: true
+  type: oneof
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the distance between two members of a geospatial index.
+group: geo
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEODIST
+since: 3.2.0
+summary: Returns the distance between two members of a geospatial index.
+syntax_fmt: GEODIST key member1 member2 [M | KM | FT | MI]
+syntax_str: member1 member2 [M | KM | FT | MI]
+title: GEODIST
+---
+Return the distance between two members in the geospatial index represented by the sorted set.
+
+Given a sorted set representing a geospatial index, populated using the [`GEOADD`]({{< relref "/commands/geoadd" >}}) command, the command returns the distance between the two specified members in the specified unit.
+
+If one or both the members are missing, the command returns NULL.
+
+The unit must be one of the following, and defaults to meters:
+
+* **m** for meters.
+* **km** for kilometers.
+* **mi** for miles.
+* **ft** for feet.
+
+The distance is computed assuming that the Earth is a perfect sphere, so errors up to 0.5% are possible in edge cases.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEODIST Sicily Palermo Catania
+GEODIST Sicily Palermo Catania km
+GEODIST Sicily Palermo Catania mi
+GEODIST Sicily Foo Bar
+{{% /redis-cli %}}
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Return the neighbors of an element at each layer in the HNSW graph.
+group: vector_set
+hidden: false
+linkTitle: VLINKS
+since: 8.0.0
+summary: Return the neighbors of an element at each layer in the HNSW graph.
+syntax_fmt: "VLINKS key element [WITHSCORES]"
+title: VLINKS
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return the neighbors of a specified element in a vector set. The command shows the connections for each layer of the HNSW graph.
+
+```shell
+VLINKS key element
+```
+
+Use the `WITHSCORES` option to include similarity scores for each neighbor.
+
+```shell
+VLINKS key element WITHSCORES
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element whose HNSW neighbors you want to inspect.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>WITHSCORES</code></summary>
+
+includes similarity scores for each neighbor.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: query
+  type: string
+- name: distance
+  optional: true
+  token: DISTANCE
+  type: integer
+- arguments:
+  - arguments:
+    - name: include
+      token: INCLUDE
+      type: pure-token
+    - name: exclude
+      token: EXCLUDE
+      type: pure-token
+    name: inclusion
+    type: oneof
+  - name: dictionary
+    type: string
+  - multiple: true
+    name: terms
+    optional: true
+    type: string
+  name: terms
+  optional: true
+  token: TERMS
+  type: block
+- name: dialect
+  optional: true
+  since: 2.4.3
+  token: DIALECT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Performs spelling correction on a query, returning suggestions for misspelled
+  terms
+group: search
+hidden: false
+linkTitle: FT.SPELLCHECK
+module: Search
+since: 1.4.0
+stack_path: docs/interact/search-and-query
+summary: Performs spelling correction on a query, returning suggestions for misspelled
+  terms
+syntax: "FT.SPELLCHECK index query \n  [DISTANCE distance] \n  [TERMS INCLUDE | EXCLUDE\
+  \ dictionary [terms [terms ...]]] \n  [DIALECT dialect]\n"
+syntax_fmt: "FT.SPELLCHECK index query [DISTANCE\_distance] [TERMS\_<INCLUDE |\n \
+  \ EXCLUDE> dictionary [terms [terms ...]]] [DIALECT\_dialect]"
+syntax_str: "query [DISTANCE\_distance] [TERMS\_<INCLUDE | EXCLUDE> dictionary [terms\
+  \ [terms ...]]] [DIALECT\_dialect]"
+title: FT.SPELLCHECK
+---
+
+Perform spelling correction on a query, returning suggestions for misspelled terms
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index with the indexed terms.
+</details>
+
+<details open>
+<summary><code>query</code></summary> 
+
+is search query.
+</details>
+
+See [Spellchecking]({{< relref "/develop/interact/search-and-query/advanced-concepts/spellcheck" >}}) for more details.
+
+## Optional arguments
+
+<details open>
+<summary><code>TERMS</code></summary>
+
+specifies an inclusion (`INCLUDE`) or exclusion (`EXCLUDE`) of a custom dictionary. To learn more about managing custom dictionaries, see [`FT.DICTADD`]({{< relref "commands/ft.dictadd/" >}}), [`FT.DICTDEL`]({{< relref "commands/ft.dictdel/" >}}), and [`FT.DICTDUMP`]({{< relref "commands/ft.dictdump/" >}}).
+
+You can specify multiple inclusion and exclusion `TERMS`.
+</details>
+
+<details open>
+<summary><code>DISTANCE</code></summary> 
+
+is maximum Levenshtein distance for spelling suggestions (default: 1, max: 4).
+</details>
+
+<details open>
+<summary><code>DIALECT {dialect_version}</code></summary> 
+
+selects the dialect version under which to execute the query. If not specified, the query will execute under the default dialect version set during module initial loading or via [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) command.
+</details>
+
+## Return
+
+FT.SPELLCHECK returns an array reply, in which each element represents a misspelled term from the query. The misspelled terms are ordered by their order of appearance in the query. 
+Each misspelled term, in turn, is a 3-element array consisting of the constant string `TERM`, the term itself and an array of suggestions for spelling corrections.
+Each element in the spelling corrections array consists of the score of the suggestion and the suggestion itself. The suggestions array, per misspelled term, is ordered in descending order by score.
+The score is calculated by dividing the number of documents in which the suggested term exists by the total number of documents in the index. Results can be normalized by dividing scores by the highest score.
+
+## Examples
+
+<details open>
+<summary><b>Perform spelling correction on a query</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.SPELLCHECK idx held DISTANCE 2
+1) 1) "TERM"
+   2) "held"
+   3) 1) 1) "0.66666666666666663"
+         2) "hello"
+      2) 1) "0.33333333333333331"
+         2) "help"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) | [`FT.DICTADD`]({{< relref "commands/ft.dictadd/" >}}) | [`FT.DICTDEL`]({{< relref "commands/ft.dictdel/" >}}) | [`FT.DICTDUMP`]({{< relref "commands/ft.dictdump/" >}})
+
+## Related topics
+
+- [Spellchecking]({{< relref "/develop/interact/search-and-query/advanced-concepts/spellcheck" >}})
+- [RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: capacity
+  optional: true
+  token: CAPACITY
+  type: integer
+- name: error
+  optional: true
+  token: ERROR
+  type: double
+- name: expansion
+  optional: true
+  token: EXPANSION
+  type: integer
+- name: nocreate
+  optional: true
+  token: NOCREATE
+  type: pure-token
+- name: nonscaling
+  optional: true
+  token: NONSCALING
+  type: pure-token
+- name: items
+  token: ITEMS
+  type: pure-token
+- multiple: true
+  name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k * n), where k is the number of hash functions and n is the number
+  of items
+description: Adds one or more items to a Bloom Filter. A filter will be created if
+  it does not exist
+group: bf
+hidden: false
+linkTitle: BF.INSERT
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Adds one or more items to a Bloom Filter. A filter will be created if it
+  does not exist
+syntax_fmt: "BF.INSERT key [CAPACITY\_capacity] [ERROR\_error]\n  [EXPANSION\_expansion]\
+  \ [NOCREATE] [NONSCALING] ITEMS item [item\n  ...]"
+syntax_str: "[CAPACITY\_capacity] [ERROR\_error] [EXPANSION\_expansion] [NOCREATE]\
+  \ [NONSCALING] ITEMS item [item ...]"
+title: BF.INSERT
+---
+Creates a new Bloom filter if the `key` does not exist using the specified error rate, capacity, and expansion, then adds all specified items to the Bloom Filter.
+
+This command is similar to [`BF.MADD`]({{< relref "commands/bf.madd/" >}}), except that the error rate, capacity, and expansion can be specified. It is a sugarcoated combination of [`BF.RESERVE`]({{< relref "commands/bf.reserve/" >}}) and [`BF.MADD`]({{< relref "commands/bf.madd/" >}}).
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter to add items to.
+
+If `key` does not exist, a new Bloom filter is created.
+</details>
+
+<details open><summary><code>ITEMS item...</code></summary>
+
+One or more items to add.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>NOCREATE</code></summary>
+
+Indicates that the filter should not be created if it does not already exist.
+If the filter does not yet exist, an error is returned rather than creating it automatically.
+This may be used where a strict separation between filter creation and filter addition is desired.
+It is an error to specify `NOCREATE` together with either `CAPACITY` or `ERROR`.
+</details>
+
+<details open><summary><code>CAPACITY capacity</code></summary>
+
+Specifies the desired `capacity` for the filter to be created.
+This parameter is ignored if the filter already exists.
+If the filter is automatically created and this parameter is absent, then the module-level `capacity` is used.
+See [`BF.RESERVE`]({{< relref "commands/bf.reserve/" >}}) for more information about the impact of this value.
+</details>
+
+<details open><summary><code>ERROR error</code></summary>
+    
+Specifies the `error` ratio of the newly created filter if it does not yet exist.
+If the filter is automatically created and `error` is not specified then the module-level error rate is used.
+See [`BF.RESERVE`]({{< relref "commands/bf.reserve/" >}}) for more information about the format of this value.
+</details>
+
+<details open><summary><code>NONSCALING</code></summary>
+
+Prevents the filter from creating additional sub-filters if initial capacity is reached.
+Non-scaling filters require slightly less memory than their scaling counterparts. The filter returns an error when `capacity` is reached.
+</details>
+
+<details open><summary><code>EXPANSION expansion</code></summary>
+
+When `capacity` is reached, an additional sub-filter is created.
+The size of the new sub-filter is the size of the last sub-filter multiplied by `expansion`, specified as a positive integer.
+
+If the number of elements to be stored in the filter is unknown, use an `expansion` of `2` or more to reduce the number of sub-filters.
+Otherwise, use an `expansion` of `1` to reduce memory consumption. The default value is `2`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) where each element is one of these options:
+  - [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where `1` denotes that the item has been added successfully, and `0` means that such item had already added to the filter (which could be wrong)
+  - [] when the item cannot be added because the filter is full
+- [], for example, when the number of arguments or key type is wrong, and also when `NOCREATE` is specified and `key` does not exist.
+
+## Examples
+
+Add three items to a filter, then create the filter with default parameters if it does not already exist.
+
+{{< highlight bash >}}
+BF.INSERT filter ITEMS foo bar baz
+{{< / highlight >}}
+
+Add one item to a filter, then create the filter with a capacity of 10000 if it does not already exist.
+
+{{< highlight bash >}}
+BF.INSERT filter CAPACITY 10000 ITEMS hello
+{{< / highlight >}}
+
+Add two items to a filter, then return error if the filter does not already exist.
+
+{{< highlight bash >}}
+BF.INSERT filter NOCREATE ITEMS foo bar
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for consumer groups commands.
+group: stream
+hidden: true
+linkTitle: XGROUP
+since: 5.0.0
+summary: A container for consumer groups commands.
+syntax_fmt: XGROUP
+syntax_str: ''
+title: XGROUP
+---
+This is a container command for stream consumer group management commands.
+
+To see the list of available commands you can call [`XGROUP HELP`]({{< relref "/commands/xgroup-help" >}}).
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+- display_text: increment
+  name: increment
+  type: double
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Increments the floating point value of a field by a number. Uses 0 as
+  initial value if the field doesn't exist.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HINCRBYFLOAT
+since: 2.6.0
+summary: Increments the floating point value of a field by a number. Uses 0 as initial
+  value if the field doesn't exist.
+syntax_fmt: HINCRBYFLOAT key field increment
+syntax_str: field increment
+title: HINCRBYFLOAT
+---
+Increment the specified `field` of a hash stored at `key`, and representing a
+floating point number, by the specified `increment`. If the increment value
+is negative, the result is to have the hash field value **decremented** instead of incremented.
+If the field does not exist, it is set to `0` before performing the operation.
+An error is returned if one of the following conditions occur:
+
+* The key contains a value of the wrong type (not a hash).
+* The current field content or the specified increment are not parsable as a
+  double precision floating point number.
+
+The exact behavior of this command is identical to the one of the [`INCRBYFLOAT`]({{< relref "/commands/incrbyfloat" >}})
+command, please refer to the documentation of [`INCRBYFLOAT`]({{< relref "/commands/incrbyfloat" >}}) for further
+information.
+
+## Examples
+
+{{% redis-cli %}}
+HSET mykey field 10.50
+HINCRBYFLOAT mykey field 0.1
+HINCRBYFLOAT mykey field -5
+HSET mykey field 5.0e3
+HINCRBYFLOAT mykey field 2.0e2
+{{% /redis-cli %}}
+
+
+## Implementation details
+
+The command is always propagated in the replication link and the Append Only
+File as a [`HSET`]({{< relref "/commands/hset" >}}) operation, so that differences in the underlying floating point
+math implementation will not be sources of inconsistency.
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: capacity
+  type: integer
+- name: bucketsize
+  optional: true
+  token: BUCKETSIZE
+  type: integer
+- name: maxiterations
+  optional: true
+  token: MAXITERATIONS
+  type: integer
+- name: expansion
+  optional: true
+  token: EXPANSION
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Creates a new Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.RESERVE
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Creates a new Cuckoo Filter
+syntax_fmt: "CF.RESERVE key capacity [BUCKETSIZE\_bucketsize]\n  [MAXITERATIONS\_\
+  maxiterations] [EXPANSION\_expansion]"
+syntax_str: "capacity [BUCKETSIZE\_bucketsize] [MAXITERATIONS\_maxiterations] [EXPANSION\_\
+  expansion]"
+title: CF.RESERVE
+---
+Creates an empty cuckoo filter with a single sub-filter for the initial specified capacity.
+
+According to the cuckoo filter behavior, the filter is likely to declare itself full before `capacity` is reached; therefore, the fill rate will likely never reach 100 percent.
+The fill rate can be improved by using a larger `bucketsize` at the cost of a higher error rate.
+When the filter self-declare itself `full`, it will auto-expand by generating additional sub-filters at the cost of reduced performance and increased error rate.
+The new sub-filter is created with size of the previous sub-filter multiplied by `expansion`.
+Like bucket size, additional sub-filters grow the error rate linearly.
+
+The minimal false positive error rate is 2/255 ≈ 0.78% when bucket size of 1 is used.
+Larger buckets increase the error rate linearly (for example, a bucket size of 3 yields a 2.35% error rate) but improve the fill rate of the filter.
+
+`maxiterations` dictates the number of attempts to find a slot for the incoming fingerprint.
+Once the filter gets full, high `maxIterations` value will slow down insertions.
+
+Unused capacity in prior sub-filters is automatically used when possible. 
+The filter can grow up to 32 times.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for the the cuckoo filter to be created.
+</details>
+
+<details open><summary><code>capacity</code></summary>
+
+Estimated capacity for the filter.
+
+Capacity is rounded to the next `2^n` number.
+
+The filter will likely not fill up to 100% of it's capacity. Make sure to reserve extra capacity if you want to avoid expansions.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>BUCKETSIZE bucketsize</code></summary>
+
+Number of items in each bucket.
+
+A higher bucket size value improves the fill rate but also causes a higher error rate and slightly slower performance.
+
+`bucketsize` is an integer between 1 and 255. The default value is 2.
+</details>
+
+<details open><summary><code>MAXITERATIONS maxiterations</code></summary>
+
+Number of attempts to swap items between buckets before declaring filter as full and creating an additional filter. 
+
+A low value is better for performance and a higher number is better for filter fill rate.
+
+`maxiterations` is an integer between 1 and 65535. The default value is 20.
+</details>
+
+<details open><summary><code>EXPANSION expansion</code></summary>
+
+When a new filter is created, its size is the size of the current filter multiplied by `expansion`.
+
+`expansion` is an integer between 0 and 32768. The default value is 1.
+
+Expansion is rounded to the next `2^n` number. 
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if filter created successfully
+- [] on error (invalid arguments, key already exists, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.RESERVE cf 1000
+OK
+
+redis> CF.RESERVE cf 1000
+(error) ERR item exists
+
+redis> CF.RESERVE cf_params 1000 BUCKETSIZE 8 MAXITERATIONS 20 EXPANSION 2
+OK
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for each member requested.
+description: Returns members from a geospatial index as geohash strings.
+group: geo
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEOHASH
+since: 3.2.0
+summary: Returns members from a geospatial index as geohash strings.
+syntax_fmt: GEOHASH key [member [member ...]]
+syntax_str: '[member [member ...]]'
+title: GEOHASH
+---
+Return valid [Geohash](https://en.wikipedia.org/wiki/Geohash) strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using [`GEOADD`]({{< relref "/commands/geoadd" >}})).
+
+Normally Redis represents positions of elements using a variation of the Geohash
+technique where positions are encoded using 52 bit integers. The encoding is
+also different compared to the standard because the initial min and max
+coordinates used during the encoding and decoding process are different. This
+command however **returns a standard Geohash** in the form of a string as
+described in the [Wikipedia article](https://en.wikipedia.org/wiki/Geohash) and compatible with the [geohash.org](http://geohash.org) web site.
+
+Geohash string properties
+---
+
+The command returns 11 characters Geohash strings, so no precision is lost
+compared to the Redis internal 52 bit representation. The returned Geohashes
+have the following properties:
+
+1. They can be shortened removing characters from the right. It will lose precision but will still point to the same area.
+2. It is possible to use them in `geohash.org` URLs such as `http://geohash.org/<geohash-string>`. This is an [example of such URL](http://geohash.org/sqdtr74hyu0).
+3. Strings with a similar prefix are nearby, but the contrary is not true, it is possible that strings with different prefixes are nearby too.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEOHASH Sicily Palermo Catania
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: error_rate
+  type: double
+- name: capacity
+  type: integer
+- name: expansion
+  optional: true
+  token: EXPANSION
+  type: integer
+- name: nonscaling
+  optional: true
+  token: NONSCALING
+  type: pure-token
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Creates a new Bloom Filter
+group: bf
+hidden: false
+linkTitle: BF.RESERVE
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Creates a new Bloom Filter
+syntax_fmt: "BF.RESERVE key error_rate capacity [EXPANSION\_expansion]\n  [NONSCALING]"
+syntax_str: "error_rate capacity [EXPANSION\_expansion] [NONSCALING]"
+title: BF.RESERVE
+---
+Creates an empty Bloom filter with a single sub-filter for the initial specified capacity and with an upper bound `error_rate`.
+
+By default, the filter auto-scales by creating additional sub-filters when `capacity` is reached.
+The new sub-filter is created with size of the previous sub-filter multiplied by `expansion`.
+
+Though the filter can scale up by creating sub-filters, it is recommended to reserve the estimated required `capacity` since maintaining and querying
+sub-filters requires additional memory (each sub-filter uses an extra bits and hash function) and consume  further CPU time than an equivalent filter that had
+the right capacity at creation time.
+
+The optimal number of hash functions is `ceil(-ln(error_rate) / ln(2))`.
+
+The required number of bits per item, given the desired `error_rate` and the optimal number of hash functions, is `-ln(error_rate) / ln(2)^2`. Hence, the required number of bits in the filter is `capacity * -ln(error_rate) / ln(2)^2`.
+
+* **1%**    error rate requires  7 hash functions and  9.585 bits per item.
+* **0.1%**  error rate requires 10 hash functions and 14.378 bits per item.
+* **0.01%** error rate requires 14 hash functions and 19.170 bits per item.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for the the Bloom filter to be created.
+</details>
+
+<details open><summary><code>error_rate</code></summary>
+
+The desired probability for false positives. The rate is a decimal value between 0 and 1.
+For example, for a desired false positive rate of 0.1% (1 in 1000), error_rate should be set to 0.001.
+</details>
+
+<details open><summary><code>capacity</code></summary>
+
+The number of entries intended to be added to the filter.
+If your filter allows scaling, performance will begin to degrade after adding more items than this number.
+The actual degradation depends on how far the limit has been exceeded. Performance degrades linearly with the number of `sub-filters`.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>NONSCALING</code></summary>
+
+Prevents the filter from creating additional sub-filters if initial capacity is reached.
+Non-scaling filters requires slightly less memory than their scaling counterparts. The filter returns an error when `capacity` is reached.
+</details>
+
+<details open><summary><code>EXPANSION expansion</code></summary>
+
+When `capacity` is reached, an additional sub-filter is created.
+The size of the new sub-filter is the size of the last sub-filter multiplied by `expansion`, specified as a positive integer.
+
+If the number of items to be stored in the filter is unknown, you use an `expansion` of `2` or more to reduce the number of sub-filters.
+Otherwise, you use an `expansion` of `1` to reduce memory consumption. The default value is `2`.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if filter created successfully
+- [] on error (invalid arguments, key already exists, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.RESERVE bf 0.01 1000
+OK
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> BF.RESERVE bf 0.01 1000
+(error) ERR item exists
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> BF.RESERVE bf_exp 0.01 1000 EXPANSION 2
+OK
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> BF.RESERVE bf_non 0.01 1000 NONSCALING
+OK
+{{< / highlight >}}
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: shardchannel
+  multiple: true
+  name: shardchannel
+  optional: true
+  type: string
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of shard channels to unsubscribe.
+description: Stops listening to messages posted to shard channels.
+group: pubsub
+hidden: false
+key_specs:
+- begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+  not_key: true
+linkTitle: SUNSUBSCRIBE
+since: 7.0.0
+summary: Stops listening to messages posted to shard channels.
+syntax_fmt: SUNSUBSCRIBE [shardchannel [shardchannel ...]]
+syntax_str: ''
+title: SUNSUBSCRIBE
+---
+Unsubscribes the client from the given shard channels, or from all of them if none is given.
+
+When no shard channels are specified, the client is unsubscribed from all the previously subscribed shard channels. 
+In this case a message for every unsubscribed shard channel will be sent to the client. 
+
+Note: The global channels and shard channels needs to be unsubscribed from separately.
+
+For more information about sharded Pub/Sub, see [Sharded Pub/Sub]({{< relref "/develop/interact/pubsub#sharded-pubsub" >}}).
+---
+acl_categories:
+- '@cuckoo'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k), where k is the number of sub-filters
+description: Return the number of times an item might be in a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.COUNT
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Return the number of times an item might be in a Cuckoo Filter
+syntax_fmt: CF.COUNT key item
+syntax_str: item
+title: CF.COUNT
+---
+Returns an estimation of the number of times a given item was added to a cuckoo filter.
+
+If you just want to check that a given item was added to a cuckoo filter, use [`CF.EXISTS`]({{< relref "commands/cf.exists/" >}}).
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter.
+
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to check.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where a positive value is an estimation of the number of times `item` was added to the filter. An overestimation is possible, but not an underestimation. `0` means that `key` does not exist or that `item` had not been added to the filter. See note in [`CF.DEL`]({{< relref "commands/cf.del/" >}}).
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INSERT cf ITEMS item1 item2 item2
+1) (integer) 1
+2) (integer) 1
+3) (integer) 1
+redis> CF.COUNT cf item1
+(integer) 1
+redis> CF.COUNT cf item2
+(integer) 2
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+- display_text: withscore
+  name: withscore
+  optional: true
+  token: WITHSCORE
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(log(N))
+description: Returns the index of a member in a sorted set ordered by ascending scores.
+group: sorted-set
+hidden: false
+history:
+- - 7.2.0
+  - Added the optional `WITHSCORE` argument.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANK
+since: 2.0.0
+summary: Returns the index of a member in a sorted set ordered by ascending scores.
+syntax_fmt: ZRANK key member [WITHSCORE]
+syntax_str: member [WITHSCORE]
+title: ZRANK
+---
+Returns the rank of `member` in the sorted set stored at `key`, with the scores
+ordered from low to high.
+The rank (or index) is 0-based, which means that the member with the lowest
+score has rank `0`.
+
+The optional `WITHSCORE` argument supplements the command's reply with the score of the element returned.
+
+Use [`ZREVRANK`]({{< relref "/commands/zrevrank" >}}) to get the rank of an element with the scores ordered from high
+to low.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZRANK myzset "three"
+ZRANK myzset "four"
+ZRANK myzset "three" WITHSCORE
+ZRANK myzset "four" WITHSCORE
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: reverse_rank
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of reverse ranks specified.
+description: Returns, for each input reverse rank, an estimation of the value (floating-point)
+  with that reverse rank
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.BYREVRANK
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input reverse rank, an estimation of the value (floating-point)
+  with that reverse rank
+syntax_fmt: TDIGEST.BYREVRANK key reverse_rank [reverse_rank ...]
+syntax_str: reverse_rank [reverse_rank ...]
+title: TDIGEST.BYREVRANK
+---
+Returns, for each input reverse rank, an estimation of the value (floating-point) with that reverse rank.
+
+Multiple estimations can be retrieved in a signle call.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>revrank</code></summary>
+
+Reverse rank, for which the value should be retrieved.
+
+0 is the reverse rank of the value of the largest observation.
+  
+_n_-1 is the reverse rank of the value of the smallest observation; _n_ denotes the number of observations added to the sketch.
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - an array of floating-points populated with value_1, value_2, ..., value_R:
+
+- Return an accurate result when `revrank` is 0 (the value of the largest observation)
+- Return an accurate result when `revrank` is _n_-1 (the value of the smallest observation), where _n_ denotes the number of observations added to the sketch.
+- Return '-inf' when `revrank` is equal to _n_ or larger than _n_
+
+All values are 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 1000
+OK
+redis> TDIGEST.ADD t 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
+OK
+redis> TDIGEST.BYREVRANK t 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+ 1) "5"
+ 2) "5"
+ 3) "5"
+ 4) "5"
+ 5) "5"
+ 6) "4"
+ 7) "4"
+ 8) "4"
+ 9) "4"
+10) "3"
+11) "3"
+12) "3"
+13) "2"
+14) "2"
+15) "1"
+16) "-inf"
+{{< / highlight >}}
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the expiration time in milliseconds of a key.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 2.8.0
+  - Added the -2 reply.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: PTTL
+since: 2.6.0
+summary: Returns the expiration time in milliseconds of a key.
+syntax_fmt: PTTL key
+syntax_str: ''
+title: PTTL
+---
+Like [`TTL`]({{< relref "/commands/ttl" >}}) this command returns the remaining time to live of a key that has an
+expire set, with the sole difference that [`TTL`]({{< relref "/commands/ttl" >}}) returns the amount of remaining
+time in seconds while `PTTL` returns it in milliseconds.
+
+In Redis 2.6 or older the command returns `-1` if the key does not exist or if the key exist but has no associated expire.
+
+Starting with Redis 2.8 the return value in case of error changed:
+
+* The command returns `-2` if the key does not exist.
+* The command returns `-1` if the key exists but has no associated expire.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXPIRE mykey 1
+PTTL mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: retentionPeriod
+  optional: true
+  token: RETENTION
+  type: integer
+- arguments:
+  - name: uncompressed
+    token: UNCOMPRESSED
+    type: pure-token
+  - name: compressed
+    token: COMPRESSED
+    type: pure-token
+  name: enc
+  optional: true
+  token: ENCODING
+  type: oneof
+- name: size
+  optional: true
+  token: CHUNK_SIZE
+  type: integer
+- arguments:
+  - name: block
+    token: BLOCK
+    type: pure-token
+  - name: first
+    token: FIRST
+    type: pure-token
+  - name: last
+    token: LAST
+    type: pure-token
+  - name: min
+    token: MIN
+    type: pure-token
+  - name: max
+    token: MAX
+    type: pure-token
+  - name: sum
+    token: SUM
+    type: pure-token
+  name: policy
+  optional: true
+  token: DUPLICATE_POLICY
+  type: oneof
+- arguments:
+  - name: label
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: labels
+  optional: true
+  token: LABELS
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Create a new time series
+group: timeseries
+hidden: false
+linkTitle: TS.CREATE
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Create a new time series
+syntax: "TS.CREATE key \n  [RETENTION retentionPeriod] \n  [ENCODING <COMPRESSED|UNCOMPRESSED>]\
+  \ \n  [CHUNK_SIZE size] \n  [DUPLICATE_POLICY policy] \n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff] \n  [LABELS [label value ...]]\n"
+syntax_fmt: "TS.CREATE key [RETENTION\_retentionPeriod] [ENCODING\_<COMPRESSED |\n\
+  \  UNCOMPRESSED>] [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_<BLOCK | FIRST |\n  LAST |\
+  \ MIN | MAX | SUM>]\n\ \ [IGNORE\_ignoreMaxTimediff\_ignoreMaxValDiff]\n\ \ [LABELS\_[label value ...]]"
+syntax_str: "[RETENTION\_retentionPeriod] [ENCODING\_<COMPRESSED | UNCOMPRESSED>]\
+  \ [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_<BLOCK | FIRST | LAST | MIN | MAX | SUM>]\
+  \ [IGNORE\_ignoreMaxTimediff\_ignoreMaxValDiff] [LABELS\_[label value ...]]"
+title: TS.CREATE
+---
+
+Create a new time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<note><b>Notes:</b>
+
+- If a key already exists, you get a Redis error reply, `TSDB: key already exists`. You can check for the existence of a key with the [`EXISTS`]({{< relref "/commands/exists" >}}) command.
+- Other commands that also create a new time series when called with a key that does not exist are [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), and [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}}).
+</note>
+
+## Optional arguments
+
+<details open><summary><code>RETENTION retentionPeriod</code></summary> 
+
+is maximum age for samples compared to the highest reported timestamp, in milliseconds. Samples are expired based solely on the difference between their timestamp and the timestamps passed to subsequent [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), and [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}}) calls with this key.
+
+When set to 0, samples never expire. When not specified, the option is set to the global [RETENTION_POLICY]({{< relref "develop/data-types/timeseries/configuration#retention_policy" >}}) configuration of the database, which by default is 0.
+</details>
+
+<details open><summary><code>ENCODING enc</code></summary> 
+
+specifies the series samples encoding format as one of the following values:
+ - `COMPRESSED`, applies compression to the series samples.
+ - `UNCOMPRESSED`, keeps the raw samples in memory. Adding this flag keeps data in an uncompressed form. 
+
+`COMPRESSED` is almost always the right choice. Compression not only saves memory but usually improves performance due to a lower number of memory accesses. It can result in about 90% memory reduction. The exception are highly irregular timestamps or values, which occur rarely.
+
+When not specified, the option is set to `COMPRESSED`.
+</details>
+
+<details open><summary><code>CHUNK_SIZE size</code></summary> 
+
+is initial allocation size, in bytes, for the data part of each new chunk. Actual chunks may consume more memory. Changing chunkSize (using [`TS.ALTER`]({{< relref "commands/ts.alter/" >}})) does not affect existing chunks.
+
+Must be a multiple of 8 in the range [48 .. 1048576]. When not specified, it is set to the global [CHUNK_SIZE_BYTES]({{< relref "develop/data-types/timeseries/configuration#chunk_size_bytes" >}}) configuration of the database, which by default is 4096 (a single memory page).
+
+Note: Before v1.6.10 no minimum was enforced. Between v1.6.10 and v1.6.17 and in v1.8.0 the minimum value was 128. Since v1.8.1 the minimum value is 48.
+
+The data in each key is stored in chunks. Each chunk contains header and data for a given timeframe. An index contains all chunks. Iterations occur inside each chunk. Depending on your use case, consider these tradeoffs for having smaller or larger sizes of chunks:
+
+  - Insert performance: Smaller chunks result in slower inserts (more chunks need to be created).
+  - Query performance: Queries for a small subset when the chunks are very large are slower, as we need to iterate over the chunk to find the data.
+  - Larger chunks may take more memory when you have a very large number of keys and very few samples per key, or less memory when you have many samples per key.
+
+ If you are unsure about your use case, select the default.
+</details>
+
+<details open><summary><code>DUPLICATE_POLICY policy</code></summary> 
+
+is policy for handling insertion ([`TS.ADD`]({{< relref "commands/ts.add/" >}}) and [`TS.MADD`]({{< relref "commands/ts.madd/" >}})) of multiple samples with identical timestamps, with one of the following values:
+  - `BLOCK`: ignore any newly reported value and reply with an error
+  - `FIRST`: ignore any newly reported value
+  - `LAST`: override with the newly reported value
+  - `MIN`: only override if the value is lower than the existing value
+  - `MAX`: only override if the value is higher than the existing value
+  - `SUM`: If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value.
+
+  When not specified: set to the global [DUPLICATE_POLICY]({{< relref "develop/data-types/timeseries/configuration#duplicate_policy" >}}) configuration of the database (which, by default, is `BLOCK`).
+
+`BLOCK` is often used to avoid accidental changes. `FIRST` can be used as an optimization when duplicate reports are possible. `LAST` can be used when updates are being reported. `SUM` is used for counters (e.g., the number of cars entering a parking lot per minute when there are multiple reporting counting devices). `MIN` and `MAX` can be used, for example, to store the minimal/maximal stock price per minute (instead of storing all the samples and defining a compaction rule).
+
+</details>
+
+<details open><summary><code>IGNORE ignoreMaxTimediff ignoreMaxValDiff</code></summary> 
+
+is the policy for handling duplicate samples. A new sample is considered a duplicate and is ignored if the following conditions are met:
+
+  - The time series is not a compaction;
+  - The time series' `DUPLICATE_POLICY` IS `LAST`;
+  - The sample is added in-order (`timestamp ≥ max_timestamp`);
+  - The difference of the current timestamp from the previous timestamp (`timestamp - max_timestamp`) is less than or equal to `IGNORE_MAX_TIME_DIFF`;
+  - The absolute value difference of the current value from the value at the previous maximum timestamp (`abs(value - value_at_max_timestamp`) is less than or equal to `IGNORE_MAX_VAL_DIFF`.
+ 
+where `max_timestamp` is the timestamp of the sample with the largest timestamp in the time series, and `value_at_max_timestamp` is the value at `max_timestamp`.
+
+When not specified: set to the global [IGNORE_MAX_TIME_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}) and [IGNORE_MAX_VAL_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}), which are, by default, both set to 0.
+</details>
+
+<details open><summary><code>LABELS {label value}...</code></summary> 
+
+is set of label-value pairs that represent metadata labels of the key and serve as a secondary index.
+
+The [`TS.MGET`]({{< relref "commands/ts.mget/" >}}), [`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}), and [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) commands operate on multiple time series based on their labels. The [`TS.QUERYINDEX`]({{< relref "commands/ts.queryindex/" >}}) command returns all time series keys matching a given filter based on their labels.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, key already exists, etc.)
+
+## Examples 
+
+<details open><summary><b>Create a temperature time series</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temperature:2:32 RETENTION 60000 DUPLICATE_POLICY MAX LABELS sensor_id 2 area_id 32
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.ADD`]({{< relref "commands/ts.add/" >}}) | [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}) | [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}}) | [`TS.MGET`]({{< relref "commands/ts.mget/" >}}) | [`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}}) | [`TS.QUERYINDEX`]({{< relref "commands/ts.queryindex/" >}})
+
+## Related topics
+
+- [RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+- [RedisTimeSeries Version 1.2 Is Here!](https://redis.com/blog/redistimeseries-version-1-2-is-here/)
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on how much memory is allocated, could be slow
+description: Asks the allocator to release memory.
+group: server
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: MEMORY PURGE
+since: 4.0.0
+summary: Asks the allocator to release memory.
+syntax_fmt: MEMORY PURGE
+syntax_str: ''
+title: MEMORY PURGE
+---
+The `MEMORY PURGE` command attempts to purge dirty pages so these can be
+reclaimed by the allocator.
+
+This command is currently implemented only when using **jemalloc** as an
+allocator, and evaluates to a benign NOOP for all others.
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: 'on'
+    name: 'on'
+    token: 'ON'
+    type: pure-token
+  - display_text: 'off'
+    name: 'off'
+    token: 'OFF'
+    type: pure-token
+  name: status
+  type: oneof
+- display_text: client-id
+  name: client-id
+  optional: true
+  token: REDIRECT
+  type: integer
+- display_text: prefix
+  multiple: true
+  multiple_token: true
+  name: prefix
+  optional: true
+  token: PREFIX
+  type: string
+- display_text: bcast
+  name: bcast
+  optional: true
+  token: BCAST
+  type: pure-token
+- display_text: optin
+  name: optin
+  optional: true
+  token: OPTIN
+  type: pure-token
+- display_text: optout
+  name: optout
+  optional: true
+  token: OPTOUT
+  type: pure-token
+- display_text: noloop
+  name: noloop
+  optional: true
+  token: NOLOOP
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1). Some options may introduce additional complexity.
+description: Controls server-assisted client-side caching for the connection.
+group: connection
+hidden: false
+linkTitle: CLIENT TRACKING
+since: 6.0.0
+summary: Controls server-assisted client-side caching for the connection.
+syntax_fmt: "CLIENT TRACKING <ON | OFF> [REDIRECT\_client-id] [PREFIX\_prefix\n  [PREFIX\
+  \ prefix ...]] [BCAST] [OPTIN] [OPTOUT] [NOLOOP]"
+syntax_str: "[REDIRECT\_client-id] [PREFIX\_prefix [PREFIX prefix ...]] [BCAST] [OPTIN]\
+  \ [OPTOUT] [NOLOOP]"
+title: CLIENT TRACKING
+---
+This command enables the tracking feature of the Redis server, that is used
+for [server assisted client side caching]({{< relref "/develop/clients/client-side-caching#tracking" >}}).
+
+When tracking is enabled Redis remembers the keys that the connection
+requested, in order to send later invalidation messages when such keys are
+modified. Invalidation messages are sent in the same connection (only available
+when the RESP3 protocol is used) or redirected in a different connection
+(available also with RESP2 and Pub/Sub). A special *broadcasting* mode is
+available where clients participating in this protocol receive every
+notification just subscribing to given key prefixes, regardless of the
+keys that they requested. Given the complexity of the argument please
+refer to [the main client side caching documentation]({{< relref "/develop/reference/client-side-caching" >}}) for the details. This manual page is only a reference for the options of this subcommand.
+
+In order to enable tracking, use:
+
+    CLIENT TRACKING on ... options ...
+
+The feature will remain active in the current connection for all its life,
+unless tracking is turned off with `CLIENT TRACKING off` at some point.
+
+The following are the list of options that modify the behavior of the
+command when enabling tracking:
+
+* `REDIRECT <id>`: send invalidation messages to the connection with the specified ID. The connection must exist. You can get the ID of a connection using [`CLIENT ID`]({{< relref "/commands/client-id" >}}). If the connection we are redirecting to is terminated, when in RESP3 mode the connection with tracking enabled will receive `tracking-redir-broken` push messages in order to signal the condition.
+* `BCAST`: enable tracking in broadcasting mode. In this mode invalidation messages are reported for all the prefixes specified, regardless of the keys requested by the connection. Instead when the broadcasting mode is not enabled, Redis will track which keys are fetched using read-only commands, and will report invalidation messages only for such keys.
+* `PREFIX <prefix>`: for broadcasting, register a given key prefix, so that notifications will be provided only for keys starting with this string. This option can be given multiple times to register multiple prefixes. If broadcasting is enabled without this option, Redis will send notifications for every key. You can't delete a single prefix, but you can delete all prefixes by disabling and re-enabling tracking. Using this option adds the additional time complexity of O(N^2), where N is the total number of prefixes tracked. 
+* `OPTIN`: when broadcasting is NOT active, normally don't track keys in read only commands, unless they are called immediately after a `CLIENT CACHING yes` command.
+* `OPTOUT`: when broadcasting is NOT active, normally track keys in read only commands, unless they are called immediately after a `CLIENT CACHING no` command.
+* `NOLOOP`: don't send notifications about keys modified by this connection itself.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: path
+  name: path
+  type: string
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+complexity: O(1)
+description: Loads a module.
+group: server
+hidden: false
+linkTitle: MODULE LOAD
+since: 4.0.0
+summary: Loads a module.
+syntax_fmt: MODULE LOAD path [arg [arg ...]]
+syntax_str: '[arg [arg ...]]'
+title: MODULE LOAD
+---
+Loads a module from a dynamic library at runtime.
+
+This command loads and initializes the Redis module from the dynamic library
+specified by the `path` argument. The `path` should be the absolute path of the
+library, including the full filename. Any additional arguments are passed
+unmodified to the module.
+
+**Note**: modules can also be loaded at server startup with `loadmodule`
+configuration directive in `redis.conf`.
+
+{{< note >}}
+As of Redis 8 in Redis Open Source, loading a module using the Redis CLI with configuration parameters is deprecated.
+{{< /note >}}---
+acl_categories:
+- '@read'
+- '@bitmap'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: offset
+  name: offset
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns a bit value by offset.
+group: bitmap
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GETBIT
+since: 2.2.0
+summary: Returns a bit value by offset.
+syntax_fmt: GETBIT key offset
+syntax_str: offset
+title: GETBIT
+---
+Returns the bit value at _offset_ in the string value stored at _key_.
+
+When _offset_ is beyond the string length, the string is assumed to be a
+contiguous space with 0 bits.
+When _key_ does not exist it is assumed to be an empty string, so _offset_ is
+always out of range and the value is also assumed to be a contiguous space with
+0 bits.
+
+## Examples
+
+{{% redis-cli %}}
+SETBIT mykey 7 1
+GETBIT mykey 0
+GETBIT mykey 7
+GETBIT mykey 100
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: increment
+  name: increment
+  type: integer
+- display_text: member
+  name: member
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(log(N)) where N is the number of elements in the sorted set.
+description: Increments the score of a member in a sorted set.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: ZINCRBY
+since: 1.2.0
+summary: Increments the score of a member in a sorted set.
+syntax_fmt: ZINCRBY key increment member
+syntax_str: increment member
+title: ZINCRBY
+---
+Increments the score of `member` in the sorted set stored at `key` by
+`increment`.
+If `member` does not exist in the sorted set, it is added with `increment` as
+its score (as if its previous score was `0.0`).
+If `key` does not exist, a new sorted set with the specified `member` as its
+sole member is created.
+
+An error is returned when `key` exists but does not hold a sorted set.
+
+The `score` value should be the string representation of a numeric value, and
+accepts double precision floating point numbers.
+It is possible to provide a negative value to decrement the score.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZINCRBY myzset 2 "one"
+ZRANGE myzset 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@fast'
+- '@transaction'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- allow_busy
+complexity: O(1)
+description: Forgets about watched keys of a transaction.
+group: transactions
+hidden: false
+linkTitle: UNWATCH
+since: 2.2.0
+summary: Forgets about watched keys of a transaction.
+syntax_fmt: UNWATCH
+syntax_str: ''
+title: UNWATCH
+---
+Flushes all the previously watched keys for a [transaction][tt].
+
+[tt]: /develop/interact/transactions
+
+If you call [`EXEC`]({{< relref "/commands/exec" >}}) or [`DISCARD`]({{< relref "/commands/discard" >}}), there's no need to manually call `UNWATCH`.
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: pattern
+  name: pattern
+  optional: true
+  type: pattern
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+complexity: O(N) where N is the number of active channels, and assuming constant time
+  pattern matching (relatively short channels and patterns)
+description: Returns the active channels.
+group: pubsub
+hidden: false
+linkTitle: PUBSUB CHANNELS
+since: 2.8.0
+summary: Returns the active channels.
+syntax_fmt: PUBSUB CHANNELS [pattern]
+syntax_str: ''
+title: PUBSUB CHANNELS
+---
+Lists the currently *active channels*.
+
+An active channel is a Pub/Sub channel with one or more subscribers (excluding clients subscribed to patterns).
+
+If no `pattern` is specified, all the channels are listed, otherwise if pattern is specified only channels matching the specified glob-style pattern are listed.
+
+Cluster note: in a Redis Cluster clients can subscribe to every node, and can also publish to every other node. The cluster will make sure that published messages are forwarded as needed. That said, [`PUBSUB`]({{< relref "/commands/pubsub" >}})'s replies in a cluster only report information from the node's Pub/Sub context, rather than the entire cluster.
+---
+acl_categories:
+- '@read'
+- '@hyperloglog'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) with a very small average constant time when called with a single
+  key. O(N) with N being the number of keys, and much bigger constant times, when
+  called with multiple keys.
+description: Returns the approximated cardinality of the set(s) observed by the HyperLogLog
+  key(s).
+group: hyperloglog
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+  notes: RW because it may change the internal representation of the key, and propagate
+    to replicas
+linkTitle: PFCOUNT
+since: 2.8.9
+summary: Returns the approximated cardinality of the set(s) observed by the HyperLogLog
+  key(s).
+syntax_fmt: PFCOUNT key [key ...]
+syntax_str: ''
+title: PFCOUNT
+---
+When called with a single key, returns the approximated cardinality computed by the HyperLogLog data structure stored at the specified variable, which is 0 if the variable does not exist.
+
+When called with multiple keys, returns the approximated cardinality of the union of the HyperLogLogs passed, by internally merging the HyperLogLogs stored at the provided keys into a temporary HyperLogLog.
+
+The HyperLogLog data structure can be used in order to count **unique** elements in a set using just a small constant amount of memory, specifically 12k bytes for every HyperLogLog (plus a few bytes for the key itself).
+
+The returned cardinality of the observed set is not exact, but approximated with a standard error of 0.81%.
+
+For example in order to take the count of all the unique search queries performed in a day, a program needs to call [`PFADD`]({{< relref "/commands/pfadd" >}}) every time a query is processed. The estimated number of unique queries can be retrieved with `PFCOUNT` at any time.
+
+Note: as a side effect of calling this function, it is possible that the HyperLogLog is modified, since the last 8 bytes encode the latest computed cardinality
+for caching purposes. So `PFCOUNT` is technically a write command.
+
+## Examples
+
+{{% redis-cli %}}
+PFADD hll foo bar zap
+PFADD hll zap zap zap
+PFADD hll foo bar
+PFCOUNT hll
+PFADD some-other-hll 1 2 3
+PFCOUNT hll some-other-hll
+{{% /redis-cli %}}
+
+
+Performances
+---
+
+When `PFCOUNT` is called with a single key, performances are excellent even if
+in theory constant times to process a dense HyperLogLog are high. This is
+possible because the `PFCOUNT` uses caching in order to remember the cardinality
+previously computed, that rarely changes because most [`PFADD`]({{< relref "/commands/pfadd" >}}) operations will
+not update any register. Hundreds of operations per second are possible.
+
+When `PFCOUNT` is called with multiple keys, an on-the-fly merge of the
+HyperLogLogs is performed, which is slow, moreover the cardinality of the union
+can't be cached, so when used with multiple keys `PFCOUNT` may take a time in
+the order of magnitude of the millisecond, and should be not abused.
+
+The user should take in mind that single-key and multiple-keys executions of
+this command are semantically different and have different performances.
+
+HyperLogLog representation
+---
+
+Redis HyperLogLogs are represented using a double representation: the *sparse* representation suitable for HLLs counting a small number of elements (resulting in a small number of registers set to non-zero value), and a *dense* representation suitable for higher cardinalities. Redis automatically switches from the sparse to the dense representation when needed.
+
+The sparse representation uses a run-length encoding optimized to store efficiently a big number of registers set to zero. The dense representation is a Redis string of 12288 bytes in order to store 16384 6-bit counters. The need for the double representation comes from the fact that using 12k (which is the dense representation memory requirement) to encode just a few registers for smaller cardinalities is extremely suboptimal.
+
+Both representations are prefixed with a 16 bytes header, that includes a magic, an encoding / version field, and the cached cardinality estimation computed, stored in little endian format (the most significant bit is 1 if the estimation is invalid since the HyperLogLog was updated since the cardinality was computed).
+
+The HyperLogLog, being a Redis string, can be retrieved with [`GET`]({{< relref "/commands/get" >}}) and restored with [`SET`]({{< relref "/commands/set" >}}). Calling [`PFADD`]({{< relref "/commands/pfadd" >}}), `PFCOUNT` or [`PFMERGE`]({{< relref "/commands/pfmerge" >}}) commands with a corrupted HyperLogLog is never a problem, it may return random values but does not affect the stability of the server. Most of the times when corrupting a sparse representation, the server recognizes the corruption and returns an error.
+
+The representation is neutral from the point of view of the processor word size and endianness, so the same representation is used by 32 bit and 64 bit processor, big endian or little endian.
+
+More details about the Redis HyperLogLog implementation can be found in [this blog post](http://antirez.com/news/75). The source code of the implementation in the `hyperloglog.c` file is also easy to read and understand, and includes a full specification for the exact encoding used for the sparse and dense representations.
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Return the number of messages in a stream.
+group: stream
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XLEN
+since: 5.0.0
+summary: Return the number of messages in a stream.
+syntax_fmt: XLEN key
+syntax_str: ''
+title: XLEN
+---
+Returns the number of entries inside a stream. If the specified key does not
+exist the command returns zero, as if the stream was empty.
+However note that unlike other Redis types, zero-length streams are
+possible, so you should call [`TYPE`]({{< relref "/commands/type" >}}) or [`EXISTS`]({{< relref "/commands/exists" >}}) in order to check if
+a key exists or not.
+
+Streams are not auto-deleted once they have no entries inside (for instance
+after an [`XDEL`]({{< relref "/commands/xdel" >}}) call), because the stream may have consumer groups
+associated with it.
+
+## Examples
+
+{{% redis-cli %}}
+XADD mystream * item 1
+XADD mystream * item 2
+XADD mystream * item 3
+XLEN mystream
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- loading
+- stale
+complexity: O(N) where N is the number of entries in the slowlog
+description: Clears all entries from the slow log.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: SLOWLOG RESET
+since: 2.2.12
+summary: Clears all entries from the slow log.
+syntax_fmt: SLOWLOG RESET
+syntax_str: ''
+title: SLOWLOG RESET
+---
+This command resets the slow log, clearing all entries in it.
+
+Once deleted the information is lost forever.
+---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: shardchannel
+  multiple: true
+  name: shardchannel
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- loading
+- stale
+complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested
+  shard channels
+description: Returns the count of subscribers of shard channels.
+group: pubsub
+hidden: false
+linkTitle: PUBSUB SHARDNUMSUB
+since: 7.0.0
+summary: Returns the count of subscribers of shard channels.
+syntax_fmt: PUBSUB SHARDNUMSUB [shardchannel [shardchannel ...]]
+syntax_str: ''
+title: PUBSUB SHARDNUMSUB
+---
+Returns the number of subscribers for the specified shard channels.
+
+Note that it is valid to call this command without channels, in this case it will just return an empty list.
+
+Cluster note: in a Redis Cluster, [`PUBSUB`]({{< relref "/commands/pubsub" >}})'s replies in a cluster only report information from the node's Pub/Sub context, rather than the entire cluster.
+
+## Examples
+
+```
+> PUBSUB SHARDNUMSUB orders
+1) "orders"
+2) (integer) 1
+```
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Returns the TTL in seconds of a hash field.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HTTL
+since: 7.4.0
+summary: Returns the TTL in seconds of a hash field.
+syntax_fmt: "HTTL key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HTTL
+---
+Returns the remaining TTL (time to live) of a hash key's field(s) that have a set expiration.
+This introspection capability allows you to check how many seconds a
+given hash field will continue to be part of the hash key.
+
+See also the [`HPTTL`]({{< relref "/commands/hpttl" >}}) command that returns the same information with millisecond resolution.
+
+## Example
+
+```
+redis> HTTL no-key FIELDS 3 field1 field2 field3
+(nil)
+redis> HSET mykey field1 "hello" field2 "world"
+(integer) 2
+redis> HEXPIRE mykey 300 FIELDS 2 field1 field3
+1) (integer) 1
+2) (integer) -2
+redis> HTTL mykey FIELDS 3 field1 field2 field3
+1) (integer) 283
+2) (integer) -1
+3) (integer) -2
+```
+
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: value
+  type: double
+- name: timestamp
+  optional: true
+  token: TIMESTAMP
+  type: string
+- name: retentionPeriod
+  optional: true
+  token: RETENTION
+  type: integer
+- arguments:
+  - name: uncompressed
+    token: UNCOMPRESSED
+    type: pure-token
+  - name: compressed
+    token: COMPRESSED
+    type: pure-token
+  name: enc
+  optional: true
+  token: ENCODING
+  type: oneof
+- name: size
+  optional: true
+  token: CHUNK_SIZE
+  type: integer
+- name: policy
+  optional: true
+  token: DUPLICATE_POLICY
+  type: oneof
+- arguments:
+  - name: label
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: labels
+  optional: true
+  token: LABELS
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M) when M is the amount of compaction rules or O(1) with no compaction
+description: Decrease the value of the sample with the maximum existing timestamp,
+  or create a new sample with a value equal to the value of the sample with the maximum
+  existing timestamp with a given decrement
+group: timeseries
+hidden: false
+linkTitle: TS.DECRBY
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Decrease the value of the sample with the maximum existing timestamp, or
+  create a new sample with a value equal to the value of the sample with the maximum
+  existing timestamp with a given decrement
+syntax: "TS.DECRBY key subtrahend \n  [TIMESTAMP timestamp] \n  [RETENTION retentionPeriod]\
+  \ \n  [ENCODING <COMPRESSED|UNCOMPRESSED>] \n  [CHUNK_SIZE size] \n  [DUPLICATE_POLICY policy] \n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff]\ \ \n\ \ [LABELS [label value ...]]\n"
+syntax_fmt: "TS.DECRBY key value [TIMESTAMP\_timestamp]\n  [RETENTION\_retentionPeriod]\
+  \ [ENCODING\_<COMPRESSED|UNCOMPRESSED>] [CHUNK_SIZE\_size]\n [DUPLICATE_POLICY\_policy] [LABELS\_[label value ...]]"
+syntax_str: "value [TIMESTAMP\_timestamp] [RETENTION\_retentionPeriod] [ENCODING\_<COMPRESSED|UNCOMPRESSED>]\
+  \ [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_policy] [LABELS\_[label value ...]]"
+title: TS.DECRBY
+---
+
+Decrease the value of the sample with the maximum existing timestamp, or create a new sample with a value equal to the value of the sample with the maximum existing timestamp with a given decrement
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<details open><summary><code>subtrahend</code></summary> 
+
+is numeric value of the subtrahend (double).
+</details>
+
+<note><b>Notes</b>
+- When specified key does not exist, a new time series is created.
+- You can use this command as a counter or gauge that automatically gets history as a time series.
+- If a policy for handling duplicate samples (`IGNORE`) is defined for this time series - `TS.DECRBY` operations are affected as well (sample additions/modifications can be filtered).
+- Explicitly adding samples to a compacted time series (using [`TS.ADD`]({{< relref "commands/ts.add/" >}}), [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), or `TS.DECRBY`) may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples.
+</note>
+
+## Optional arguments
+
+<details open><summary><code>TIMESTAMP timestamp</code></summary> 
+
+is Unix time (integer, in milliseconds) specifying the sample timestamp or `*` to set the sample timestamp to the Unix time of the server's clock.
+
+Unix time is the number of milliseconds that have elapsed since 00:00:00 UTC on 1 January 1970, the Unix epoch, without adjustments made due to leap seconds.
+
+`timestamp` must be equal to or higher than the maximum existing timestamp. When equal, the value of the sample with the maximum existing timestamp is decreased. If it is higher, a new sample with a timestamp set to `timestamp` is created, and its value is set to the value of the sample with the maximum existing timestamp minus `subtrahend`. 
+
+If the time series is empty, the value is set to `subtrahend`.
+  
+When not specified, the timestamp is set to the Unix time of the server's clock.
+</details>
+
+<details open><summary><code>RETENTION retentionPeriod</code></summmary> 
+
+is maximum retention period, compared to the maximum existing timestamp, in milliseconds.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `RETENTION` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>ENCODING enc</code></summary> 
+
+specifies the series sample encoding format.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `ENCODING` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>CHUNK_SIZE size</code></summary> 
+
+is memory size, in bytes, allocated for each data chunk.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `CHUNK_SIZE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>DUPLICATE_POLICY policy</code></summary>
+
+is policy for handling insertion ([`TS.ADD`]({{< relref "commands/ts.add/" >}}) and [`TS.MADD`]({{< relref "commands/ts.madd/" >}})) of multiple samples with identical timestamps.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `DUPLICATE_POLICY` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>IGNORE ignoreMaxTimediff ignoreMaxValDiff</code></summary> 
+
+is the policy for handling duplicate samples. A new sample is considered a duplicate and is ignored if the following conditions are met:
+
+  - The time series is not a compaction;
+  - The time series' `DUPLICATE_POLICY` IS `LAST`;
+  - The sample is added in-order (`timestamp ≥ max_timestamp`);
+  - The difference of the current timestamp from the previous timestamp (`timestamp - max_timestamp`) is less than or equal to `IGNORE_MAX_TIME_DIFF`;
+  - The absolute value difference of the current value from the value at the previous maximum timestamp (`abs(value - value_at_max_timestamp`) is less than or equal to `IGNORE_MAX_VAL_DIFF`.
+
+where `max_timestamp` is the timestamp of the sample with the largest timestamp in the time series, and `value_at_max_timestamp` is the value at `max_timestamp`.
+
+When not specified: set to the global [IGNORE_MAX_TIME_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}) and [IGNORE_MAX_VAL_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}), which are, by default, both set to 0.
+
+These parameters are used when creating a new time series to set the per-key parameters, and are ignored when called with an existing time series (the existing per-key configuration parameters are used).
+</details>
+
+<details open><summary><code>LABELS [{label value}...]</code></summary> 
+
+is set of label-value pairs that represent metadata labels of the key and serve as a secondary index.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `LABELS` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<note><b>Notes</b>
+- You can use this command to create a new time series and add a sample to it in a single command.
+  `RETENTION`, `ENCODING`, `CHUNK_SIZE`, `DUPLICATE_POLICY`, `IGNORE`, and `LABELS` are used only when creating a new time series, and ignored when adding or modifying samples in an existing time series.
+- Setting `RETENTION` and `LABELS` introduces additional time complexity.
+</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the timestamp of the upserted sample. If the sample is ignored (See `IGNORE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}})), the reply will be the largest timestamp in the time series.
+- [] on error (invalid arguments, wrong key type, etc.), or when `timestamp` is not equal to or higher than the maximum existing timestamp
+
+## See also
+
+[`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}) | [`TS.CREATE`]({{< relref "commands/ts.create/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: libname
+    name: libname
+    token: LIB-NAME
+    type: string
+  - display_text: libver
+    name: libver
+    token: LIB-VER
+    type: string
+  name: attr
+  type: oneof
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Sets information specific to the client or connection.
+group: connection
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: CLIENT SETINFO
+since: 7.2.0
+summary: Sets information specific to the client or connection.
+syntax_fmt: "CLIENT SETINFO <LIB-NAME\_libname | LIB-VER\_libver>"
+syntax_str: ''
+title: CLIENT SETINFO
+---
+The `CLIENT SETINFO` command assigns various info attributes to the current connection which are displayed in the output of [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) and [`CLIENT INFO`]({{< relref "/commands/client-info" >}}).
+
+Client libraries are expected to pipeline this command after authentication on all connections
+and ignore failures since they could be connected to an older version that doesn't support them.
+
+Currently the supported attributes are:
+* `lib-name` - meant to hold the name of the client library that's in use.
+* `lib-ver` - meant to hold the client library's version.
+
+There is no limit to the length of these attributes. However it is not possible to use spaces, newlines, or other non-printable characters that would violate the format of the [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) reply.
+
+[Official client libraries](https://redis.io/docs/latest/develop/connect/clients/) allow extending `lib-name` with a custom suffix to expose additional information about the client. 
+For example, high-level libraries like [redis-om-spring](https://github.com/redis/redis-om-spring) can report their version. 
+The resulting `lib-name` would be `jedis(redis-om-spring_v1.0.0)`. 
+Brace characters are used to delimit the custom suffix and should be avoided in the suffix itself.
+We recommend using the following format for the custom suffixes for third-party libraries `(?<custom-name>[ -~]+)[ -~]v(?<custom-version>[\d\.]+)` and use `;` to delimit multiple suffixes.
+
+Note that these attributes are **not** cleared by the RESET command.
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Determines whether a member belongs to a set.
+group: set
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SISMEMBER
+since: 1.0.0
+summary: Determines whether a member belongs to a set.
+syntax_fmt: SISMEMBER key member
+syntax_str: member
+title: SISMEMBER
+---
+Returns if `member` is a member of the set stored at `key`.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "one"
+SISMEMBER myset "one"
+SISMEMBER myset "two"
+{{% /redis-cli %}}
+
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Return the number of elements in a vector set.
+group: vector_set
+hidden: false
+linkTitle: VCARD
+since: 8.0.0
+summary: Return the number of elements in a vector set.
+syntax_fmt: "VCARD key"
+title: VCARD
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return the number of elements in the specified vector set.
+
+```shell
+VCARD word_embeddings
+(integer) 3000000
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@fast'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+- display_text: member
+  name: member
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Moves a member from one set to another.
+group: set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: SMOVE
+since: 1.0.0
+summary: Moves a member from one set to another.
+syntax_fmt: SMOVE source destination member
+syntax_str: destination member
+title: SMOVE
+---
+Move `member` from the set at `source` to the set at `destination`.
+This operation is atomic.
+In every given moment the element will appear to be a member of `source` **or**
+`destination` for other clients.
+
+If the source set does not exist or does not contain the specified element, no
+operation is performed and `0` is returned.
+Otherwise, the element is removed from the source set and added to the
+destination set.
+When the specified element already exists in the destination set, it is only
+removed from the source set.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "one"
+SADD myset "two"
+SADD myotherset "three"
+SMOVE myset myotherset "two"
+SMEMBERS myset
+SMEMBERS myotherset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: value
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+deprecated_since: '2.0'
+description: Multiplies the numeric value at path by a value
+group: json
+hidden: false
+linkTitle: JSON.NUMMULTBY
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Multiplies the numeric value at path by a value
+syntax_fmt: JSON.NUMMULTBY key path value
+syntax_str: path value
+title: JSON.NUMMULTBY
+---
+Multiply the number value stored at `path` by `number`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is number value to multiply. 
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+## Return
+
+JSON.NUMMULTBY returns a bulk string reply specified as a stringified new values for each path, or `nil` element if the matching JSON value is not a number.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc . '{"a":"b","b":[{"a":2}, {"a":5}, {"a":"c"}]}'
+OK
+redis> JSON.NUMMULTBY doc $.a 2
+"[null]"
+redis> JSON.NUMMULTBY doc $..a 2
+"[null,4,10,null]"
+{{< / highlight >}}
+
+## See also
+
+[`JSON.NUMINCRBY`]({{< relref "commands/json.numincrby/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@slow'
+- '@transaction'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- skip_slowlog
+complexity: Depends on commands in the transaction
+description: Executes all commands in a transaction.
+group: transactions
+hidden: false
+linkTitle: EXEC
+since: 1.2.0
+summary: Executes all commands in a transaction.
+syntax_fmt: EXEC
+syntax_str: ''
+title: EXEC
+---
+Executes all previously queued commands in a [transaction][tt] and restores the
+connection state to normal.
+
+[tt]: /develop/interact/transactions
+
+When using [`WATCH`]({{< relref "/commands/watch" >}}), `EXEC` will execute commands only if the watched keys were
+not modified, allowing for a [check-and-set mechanism][ttc].
+
+[ttc]: /develop/interact/transactions#cas
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: module-name
+    name: module-name
+    token: MODULE
+    type: string
+  - display_text: category
+    name: category
+    token: ACLCAT
+    type: string
+  - display_text: pattern
+    name: pattern
+    token: PATTERN
+    type: pattern
+  name: filterby
+  optional: true
+  token: FILTERBY
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the total number of Redis commands
+description: Returns a list of command names.
+group: server
+hidden: false
+hints:
+- nondeterministic_output_order
+linkTitle: COMMAND LIST
+since: 7.0.0
+summary: Returns a list of command names.
+syntax_fmt: "COMMAND LIST [FILTERBY\_<MODULE\_module-name | ACLCAT\_category |\n \
+  \ PATTERN\_pattern>]"
+syntax_str: ''
+title: COMMAND LIST
+---
+Return an array of the server's command names.
+
+You can use the optional _FILTERBY_ modifier to apply one of the following filters:
+
+ - **MODULE module-name**: get the commands that belong to the module specified by _module-name_.
+ - **ACLCAT category**: get the commands in the [ACL category]({{< relref "operate/oss_and_stack/management/security/acl#command-categories" >}}) specified by _category_.
+ - **PATTERN pattern**: get the commands that match the given glob-like _pattern_.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the total number of cluster nodes
+description: Returns the mapping of cluster slots to shards.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER SHARDS
+since: 7.0.0
+summary: Returns the mapping of cluster slots to shards.
+syntax_fmt: CLUSTER SHARDS
+syntax_str: ''
+title: CLUSTER SHARDS
+---
+`CLUSTER SHARDS` returns details about the shards of the cluster.
+A shard is defined as a collection of nodes that serve the same set of slots and that replicate from each other.
+A shard may only have a single master at a given time, but may have multiple or no replicas.
+It is possible for a shard to not be serving any slots while still having replicas.
+
+This command replaces the [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) command, by providing a more efficient and extensible representation of the cluster. 
+
+The command is suitable to be used by Redis Cluster client libraries in order to understand the topology of the cluster.
+A client should issue this command on startup in order to retrieve the map associating cluster *hash slots* with actual node information.
+This map should be used to direct commands to the node that is likely serving the slot associated with a given command.
+In the event the command is sent to the wrong node, in that it received a '-MOVED' redirect, this command can then be used to update the topology of the cluster.
+
+The command returns an array of shards, with each shard containing two fields, 'slots' and 'nodes'. 
+
+The 'slots' field is a list of slot ranges served by this shard, stored as pair of integers representing the inclusive start and end slots of the ranges.
+For example, if a node owns the slots 1, 2, 3, 5, 7, 8 and 9, the slots ranges would be stored as [1-3], [5-5], [7-9].
+The slots field would therefore be represented by the following list of integers.
+
+```
+1) 1) "slots"
+   2) 1) (integer) 1
+      2) (integer) 3
+      3) (integer) 5
+      4) (integer) 5
+      5) (integer) 7
+      6) (integer) 9
+```
+
+The 'nodes' field contains a list of all nodes within the shard.
+Each individual node is a map of attributes that describe the node. 
+Some attributes are optional and more attributes may be added in the future. 
+The current list of attributes:
+
+* id: The unique node id for this particular node.
+* endpoint: The preferred endpoint to reach the node, see below for more information about the possible values of this field.
+* ip: The IP address to send requests to for this node.
+* hostname (optional): The announced hostname to send requests to for this node.
+* port (optional): The TCP (non-TLS) port of the node. At least one of port or tls-port will be present.
+* tls-port (optional): The TLS port of the node. At least one of port or tls-port will be present.
+* role: The replication role of this node.
+* replication-offset: The replication offset of this node. This information can be used to send commands to the most up to date replicas.
+* health: Either `online`, `failed`, or `loading`. This information should be used to determine which nodes should be sent traffic. The `loading` health state should be used to know that a node is not currently eligible to serve traffic, but may be eligible in the future. 
+
+The endpoint, along with the port, defines the location that clients should use to send requests for a given slot.
+A NULL value for the endpoint indicates the node has an unknown endpoint and the client should connect to the same endpoint it used to send the `CLUSTER SHARDS` command but with the port returned from the command.
+This unknown endpoint configuration is useful when the Redis nodes are behind a load balancer that Redis doesn't know the endpoint of.
+Which endpoint is set is determined by the `cluster-preferred-endpoint-type` config.
+An empty string `""` is another abnormal value of the endpoint field, as well as for the ip field, which is returned if the node doesn't know its own IP address.
+This can happen in a cluster that consists of only one node or the node has not yet been joined with the rest of the cluster.
+The value `?` is displayed if the node is incorrectly configured to use announced hostnames but no hostname is configured using `cluster-announce-hostname`.
+Clients may treat the empty string in the same way as NULL, that is the same endpoint it used to send the current command to, while `"?"` should be treated as an unknown node, not necessarily the same node as the one serving the current command.
+
+## Examples
+
+```
+> CLUSTER SHARDS
+1) 1) "slots"
+   2) 1) (integer) 0
+      2) (integer) 5460
+   3) "nodes"
+   4) 1)  1) "id"
+          2) "e10b7051d6bf2d5febd39a2be297bbaea6084111"
+          3) "port"
+          4) (integer) 30001
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "master"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+      2)  1) "id"
+          2) "1901f5962d865341e81c85f9f596b1e7160c35ce"
+          3) "port"
+          4) (integer) 30006
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "replica"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+2) 1) "slots"
+   2) 1) (integer) 10923
+      2) (integer) 16383
+   3) "nodes"
+   4) 1)  1) "id"
+          2) "fd20502fe1b32fc32c15b69b0a9537551f162f1f"
+          3) "port"
+          4) (integer) 30003
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "master"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+      2)  1) "id"
+          2) "6daa25c08025a0c7e4cc0d1ab255949ce6cee902"
+          3) "port"
+          4) (integer) 30005
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "replica"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+3) 1) "slots"
+   2) 1) (integer) 5461
+      2) (integer) 10922
+   3) "nodes"
+   4) 1)  1) "id"
+          2) "a4a3f445ead085eb3eb9ee7d8c644ec4481ec9be"
+          3) "port"
+          4) (integer) 30002
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "master"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+      2)  1) "id"
+          2) "da6d5847aa019e9b9d2a8aa24a75f856fd3456cc"
+          3) "port"
+          4) (integer) 30004
+          5) "ip"
+          6) "127.0.0.1"
+          7) "endpoint"
+          8) "127.0.0.1"
+          9) "role"
+         10) "replica"
+         11) "replication-offset"
+         12) (integer) 72156
+         13) "health"
+         14) "online"
+```
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+deprecated_since: 6.2.0
+description: Returns the last element of a list after removing and pushing it to another
+  list. Deletes the list if the last element was popped.
+doc_flags:
+- deprecated
+group: list
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: RPOPLPUSH
+replaced_by: '[`LMOVE`]({{< relref "/commands/lmove" >}}) with the `RIGHT` and `LEFT`
+  arguments'
+since: 1.2.0
+summary: Returns the last element of a list after removing and pushing it to another
+  list. Deletes the list if the last element was popped.
+syntax_fmt: RPOPLPUSH source destination
+syntax_str: destination
+title: RPOPLPUSH
+---
+Atomically returns and removes the last element (tail) of the list stored at
+`source`, and pushes the element at the first element (head) of the list stored
+at `destination`.
+
+For example: consider `source` holding the list `a,b,c`, and `destination`
+holding the list `x,y,z`.
+Executing `RPOPLPUSH` results in `source` holding `a,b` and `destination`
+holding `c,x,y,z`.
+
+If `source` does not exist, the value `nil` is returned and no operation is
+performed.
+If `source` and `destination` are the same, the operation is equivalent to
+removing the last element from the list and pushing it as first element of the
+list, so it can be considered as a list rotation command.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "one"
+RPUSH mylist "two"
+RPUSH mylist "three"
+RPOPLPUSH mylist myotherlist
+LRANGE mylist 0 -1
+LRANGE myotherlist 0 -1
+{{% /redis-cli %}}
+
+
+## Pattern: Reliable queue
+
+Redis is often used as a messaging server to implement processing of background
+jobs or other kinds of messaging tasks.
+A simple form of queue is often obtained pushing values into a list in the
+producer side, and waiting for this values in the consumer side using [`RPOP`]({{< relref "/commands/rpop" >}})
+(using polling), or [`BRPOP`]({{< relref "/commands/brpop" >}}) if the client is better served by a blocking
+operation.
+
+However in this context the obtained queue is not _reliable_ as messages can
+be lost, for example in the case there is a network problem or if the consumer
+crashes just after the message is received but before it can be processed.
+
+`RPOPLPUSH` (or [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}) for the blocking variant) offers a way to avoid
+this problem: the consumer fetches the message and at the same time pushes it
+into a _processing_ list.
+It will use the [`LREM`]({{< relref "/commands/lrem" >}}) command in order to remove the message from the
+_processing_ list once the message has been processed.
+
+An additional client may monitor the _processing_ list for items that remain
+there for too much time, pushing timed out items into the queue
+again if needed.
+
+## Pattern: Circular list
+
+Using `RPOPLPUSH` with the same source and destination key, a client can visit
+all the elements of an N-elements list, one after the other, in O(N) without
+transferring the full list from the server to the client using a single [`LRANGE`]({{< relref "/commands/lrange" >}})
+operation.
+
+The above pattern works even if one or both of the following conditions occur:
+
+* There are multiple clients rotating the list: they'll fetch different 
+  elements, until all the elements of the list are visited, and the process 
+  restarts.
+* Other clients are actively pushing new items at the end of the list.
+
+The above makes it very simple to implement a system where a set of items must
+be processed by N workers continuously as fast as possible.
+An example is a monitoring system that must check that a set of web sites are
+reachable, with the smallest delay possible, using a number of parallel workers.
+
+Note that this implementation of workers is trivially scalable and reliable,
+because even if a message is lost the item is still in the queue and will be
+processed at the next iteration.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(N) where N is the total number of Cluster nodes
+description: Returns the cluster configuration for a node.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER NODES
+since: 3.0.0
+summary: Returns the cluster configuration for a node.
+syntax_fmt: CLUSTER NODES
+syntax_str: ''
+title: CLUSTER NODES
+---
+Each node in a Redis Cluster has its view of the current cluster configuration,
+given by the set of known nodes, the state of the connection we have with such
+nodes, their flags, properties and assigned slots, and so forth.
+
+`CLUSTER NODES` provides all this information, that is, the current cluster
+configuration of the node we are contacting, in a serialization format which
+happens to be exactly the same as the one used by Redis Cluster itself in
+order to store on disk the cluster state (however the on disk cluster state
+has a few additional info appended at the end).
+
+Note that normally clients willing to fetch the map between Cluster
+hash slots and node addresses should use [`CLUSTER SLOTS`]({{< relref "/commands/cluster-slots" >}}) instead.
+`CLUSTER NODES`, that provides more information, should be used for
+administrative tasks, debugging, and configuration inspections.
+It is also used by `redis-cli` in order to manage a cluster.
+
+## Serialization format
+
+The output of the command is just a space-separated CSV string, where
+each line represents a node in the cluster. The following
+is an example of output on Redis 7.2.0.
+
+```
+07c37dfeb235213a872192d90877d0cd55635b91 127.0.0.1:30004@31004,hostname4 slave e7d1eecce10fd6bb5eb35b9f99a514335d9ba9ca 0 1426238317239 4 connected
+67ed2db8d677e59ec4a4cefb06858cf2a1a89fa1 127.0.0.1:30002@31002,hostname2 master - 0 1426238316232 2 connected 5461-10922
+292f8b365bb7edb5e285caf0b7e6ddc7265d2f4f 127.0.0.1:30003@31003,hostname3 master - 0 1426238318243 3 connected 10923-16383
+6ec23923021cf3ffec47632106199cb7f496ce01 127.0.0.1:30005@31005,hostname5 slave 67ed2db8d677e59ec4a4cefb06858cf2a1a89fa1 0 1426238316232 5 connected
+824fe116063bc5fcf9f4ffd895bc17aee7731ac3 127.0.0.1:30006@31006,hostname6 slave 292f8b365bb7edb5e285caf0b7e6ddc7265d2f4f 0 1426238317741 6 connected
+e7d1eecce10fd6bb5eb35b9f99a514335d9ba9ca 127.0.0.1:30001@31001,hostname1 myself,master - 0 0 1 connected 0-5460
+```
+
+Each line is composed of the following fields:
+
+```
+<id> <ip:port@cport[,hostname]> <flags> <master> <ping-sent> <pong-recv> <config-epoch> <link-state> <slot> <slot> ... <slot>
+```
+
+The meaning of each field is the following:
+
+1. `id`: The node ID, a 40-character globally unique string generated when a node is created and never changed again (unless `CLUSTER RESET HARD` is used).
+2. `ip:port@cport`: The node address that clients should contact to run queries, along with the used cluster bus port.
+   `:0@0` can be expected when the address is no longer known for this node ID, hence flagged with `noaddr`.
+3. `hostname`: A human readable string that can be configured via the `cluster-annouce-hostname` setting. The max length of the string is 256 characters, excluding the null terminator. The name can contain ASCII alphanumeric characters, '-', and '.' only.
+5. `flags`: A list of comma separated flags: `myself`, `master`, `slave`, `fail?`, `fail`, `handshake`, `noaddr`, `nofailover`, `noflags`. Flags are explained below.
+6. `master`: If the node is a replica, and the primary is known, the primary node ID, otherwise the "-" character.
+7. `ping-sent`: Unix time at which the currently active ping was sent, or zero if there are no pending pings, in milliseconds.
+8. `pong-recv`: Unix time the last pong was received, in milliseconds.
+9. `config-epoch`: The configuration epoch (or version) of the current node (or of the current primary if the node is a replica). Each time there is a failover, a new, unique, monotonically increasing configuration epoch is created. If multiple nodes claim to serve the same hash slots, the one with the higher configuration epoch wins.
+10. `link-state`: The state of the link used for the node-to-node cluster bus. Use this link to communicate with the node. Can be `connected` or `disconnected`.
+11. `slot`: A hash slot number or range. Starting from argument number 9, but there may be up to 16384 entries in total (limit never reached). This is the list of hash slots served by this node. If the entry is just a number, it is parsed as such.  If it is a range, it is in the form `start-end`, and means that the node is responsible for all the hash slots from `start` to `end` including the start and end values.
+
+Flags are:
+
+* `myself`: The node you are contacting.
+* `master`: Node is a primary.
+* `slave`: Node is a replica.
+* `fail?`: Node is in `PFAIL` state. Not reachable for the node you are contacting, but still logically reachable (not in `FAIL` state).
+* `fail`: Node is in `FAIL` state. It was not reachable for multiple nodes that promoted the `PFAIL` state to `FAIL`.
+* `handshake`: Untrusted node, we are handshaking.
+* `noaddr`: No address known for this node.
+* `nofailover`: Replica will not try to failover.
+* `noflags`: No flags at all.
+
+## Notes on published config epochs
+
+Replicas broadcast their primary's config epochs (in order to get an `UPDATE`
+message if they are found to be stale), so the real config epoch of the
+replica (which is meaningless more or less, since they don't serve hash slots)
+can be only obtained checking the node flagged as `myself`, which is the entry
+of the node we are asking to generate `CLUSTER NODES` output. The other
+replicas epochs reflect what they publish in heartbeat packets, which is, the
+configuration epoch of the primaries they are currently replicating.
+
+## Special slot entries
+
+Normally hash slots associated to a given node are in one of the following formats,
+as already explained above:
+
+1. Single number: 3894
+2. Range: 3900-4000
+
+However node hash slots can be in a special state, used in order to communicate errors after a node restart (mismatch between the keys in the AOF/RDB file, and the node hash slots configuration), or when there is a resharding operation in progress. This two states are **importing** and **migrating**.
+
+The meaning of the two states is explained in the Redis Specification, however the gist of the two states is the following:
+
+* **Importing** slots are yet not part of the nodes hash slot, there is a migration in progress. The node will accept queries about these slots only if the `ASK` command is used.
+* **Migrating** slots are assigned to the node, but are being migrated to some other node. The node will accept queries if all the keys in the command exist already, otherwise it will emit what is called an **ASK redirection**, to force new keys creation directly in the importing node.
+
+Importing and migrating slots are emitted in the `CLUSTER NODES` output as follows:
+
+* **Importing slot:** `[slot_number-<-importing_from_node_id]`
+* **Migrating slot:** `[slot_number->-migrating_to_node_id]`
+
+The following are a few examples of importing and migrating slots:
+
+* `[93-<-292f8b365bb7edb5e285caf0b7e6ddc7265d2f4f]`
+* `[1002-<-67ed2db8d677e59ec4a4cefb06858cf2a1a89fa1]`
+* `[77->-e7d1eecce10fd6bb5eb35b9f99a514335d9ba9ca]`
+* `[16311->-292f8b365bb7edb5e285caf0b7e6ddc7265d2f4f]`
+
+Note that the format does not have any space, so `CLUSTER NODES` output format is plain CSV with space as separator even when this special slots are emitted. However a complete parser for the format should be able to handle them.
+
+Note that:
+
+1. Migration and importing slots are only added to the node flagged as `myself`. This information is local to a node, for its own slots.
+2. Importing and migrating slots are provided as **additional info**. If the node has a given hash slot assigned, it will be also a plain number in the list of hash slots, so clients that don't have a clue about hash slots migrations can just skip this special fields.
+
+**A note about the word slave used in this man page and command name**: Starting with Redis 5, if not for backward compatibility, the Redis project no longer uses the word slave. Unfortunately in this command the word slave is part of the protocol, so we'll be able to remove such occurrences only when this API will be naturally deprecated.
+---
+acl_categories:
+- '@slow'
+arguments:
+- display_text: key
+  name: key
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(N) where N is the number of bytes in the key
+description: Returns the hash slot for a key.
+group: cluster
+hidden: false
+linkTitle: CLUSTER KEYSLOT
+since: 3.0.0
+summary: Returns the hash slot for a key.
+syntax_fmt: CLUSTER KEYSLOT key
+syntax_str: ''
+title: CLUSTER KEYSLOT
+---
+Returns an integer identifying the hash slot the specified key hashes to.
+This command is mainly useful for debugging and testing, since it exposes
+via an API the underlying Redis implementation of the hashing algorithm.
+Example use cases for this command:
+
+1. Client libraries may use Redis in order to test their own hashing algorithm, generating random keys and hashing them with both their local implementation and using Redis `CLUSTER KEYSLOT` command, then checking if the result is the same.
+2. Humans may use this command in order to check what is the hash slot, and then the associated Redis Cluster node, responsible for a given key.
+
+## Example
+
+```
+> CLUSTER KEYSLOT somekey
+(integer) 11058
+> CLUSTER KEYSLOT foo{hash_tag}
+(integer) 2515
+> CLUSTER KEYSLOT bar{hash_tag}
+(integer) 2515
+```
+
+Note that the command implements the full hashing algorithm, including support for **hash tags**, that is the special property of Redis Cluster key hashing algorithm, of hashing just what is between `{` and `}` if such a pattern is found inside the key name, in order to force multiple keys to be handled by the same node.
+---
+acl_categories:
+- '@read'
+- '@bitmap'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: start
+    name: start
+    type: integer
+  - display_text: end
+    name: end
+    type: integer
+  - arguments:
+    - display_text: byte
+      name: byte
+      token: BYTE
+      type: pure-token
+    - display_text: bit
+      name: bit
+      token: BIT
+      type: pure-token
+    name: unit
+    optional: true
+    since: 7.0.0
+    type: oneof
+  name: range
+  optional: true
+  type: block
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N)
+description: Counts the number of set bits (population counting) in a string.
+group: bitmap
+hidden: false
+history:
+- - 7.0.0
+  - Added the `BYTE|BIT` option.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: BITCOUNT
+since: 2.6.0
+summary: Counts the number of set bits (population counting) in a string.
+syntax_fmt: BITCOUNT key [start end [BYTE | BIT]]
+syntax_str: '[start end [BYTE | BIT]]'
+title: BITCOUNT
+---
+Count the number of set bits (population counting) in a string.
+
+By default all the bytes contained in the string are examined.
+It is possible to specify the counting operation only in an interval passing the
+additional arguments _start_ and _end_.
+
+Like for the [`GETRANGE`]({{< relref "/commands/getrange" >}}) command start and end can contain negative values in
+order to index bytes starting from the end of the string, where -1 is the last
+byte, -2 is the penultimate, and so forth.
+
+Non-existent keys are treated as empty strings, so the command will return zero.
+
+By default, the additional arguments _start_ and _end_ specify a byte index.
+We can use an additional argument `BIT` to specify a bit index.
+So 0 is the first bit, 1 is the second bit, and so forth.
+For negative values, -1 is the last bit, -2 is the penultimate, and so forth.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "foobar"
+BITCOUNT mykey
+BITCOUNT mykey 0 0
+BITCOUNT mykey 1 1
+BITCOUNT mykey 1 1 BYTE
+BITCOUNT mykey 5 30 BIT
+{{% /redis-cli %}}
+
+
+## Pattern: real-time metrics using bitmaps
+
+Bitmaps are a very space-efficient representation of certain kinds of
+information.
+One example is a Web application that needs the history of user visits, so that
+for instance it is possible to determine what users are good targets of beta
+features.
+
+Using the [`SETBIT`]({{< relref "/commands/setbit" >}}) command this is trivial to accomplish, identifying every day
+with a small progressive integer.
+For instance day 0 is the first day the application was put online, day 1 the
+next day, and so forth.
+
+Every time a user performs a page view, the application can register that in
+the current day the user visited the web site using the [`SETBIT`]({{< relref "/commands/setbit" >}}) command setting
+the bit corresponding to the current day.
+
+Later it will be trivial to know the number of single days the user visited the
+web site simply calling the `BITCOUNT` command against the bitmap.
+
+A similar pattern where user IDs are used instead of days is described
+in the article called "[Fast easy realtime metrics using Redis
+bitmaps][hbgc212fermurb]".
+
+[hbgc212fermurb]: http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps
+
+## Performance considerations
+
+In the above example of counting days, even after 10 years the application is
+online we still have just `365*10` bits of data per user, that is just 456 bytes
+per user.
+With this amount of data `BITCOUNT` is still as fast as any other O(1) Redis
+command like [`GET`]({{< relref "/commands/get" >}}) or [`INCR`]({{< relref "/commands/incr" >}}).
+
+When the bitmap is big, there are two alternatives:
+
+* Taking a separated key that is incremented every time the bitmap is modified.
+  This can be very efficient and atomic using a small Redis Lua script.
+* Running the bitmap incrementally using the `BITCOUNT` _start_ and _end_
+  optional parameters, accumulating the results client-side, and optionally
+  caching the result into a key.
+---
+acl_categories:
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  token: SAMPLES
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the number of samples.
+description: Estimates the memory usage of a key.
+group: server
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: MEMORY USAGE
+since: 4.0.0
+summary: Estimates the memory usage of a key.
+syntax_fmt: "MEMORY USAGE key [SAMPLES\_count]"
+syntax_str: "[SAMPLES\_count]"
+title: MEMORY USAGE
+---
+The `MEMORY USAGE` command reports the number of bytes that a key and its value
+require to be stored in RAM.
+
+The reported usage is the total of memory allocations for data and
+administrative overheads that a key and its value require.
+
+For nested data types, the optional `SAMPLES` option can be provided, where
+`count` is the number of sampled nested values. The samples are averaged to estimate the total size.
+By default, this option is set to `5`. To sample the all of the nested values, use `SAMPLES 0`.
+
+## Examples
+
+With Redis v7.2.0 64-bit and **jemalloc**, the empty string measures as follows:
+
+```
+> SET "" ""
+OK
+> MEMORY USAGE ""
+(integer) 56
+```
+
+These bytes are pure overhead at the moment as no actual data is stored, and are
+used for maintaining the internal data structures of the server (include internal allocator fragmentation). Longer keys and
+values show asymptotically linear usage.
+
+```
+> SET foo bar
+OK
+> MEMORY USAGE foo
+(integer) 56
+> SET foo2 mybar
+OK
+> MEMORY USAGE foo2
+(integer) 64
+> SET foo3 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
+OK
+> MEMORY USAGE foo3
+(integer) 160
+```
+
+## Redis Software and Redis Cloud compatibility
+
+| Redis<br />Enterprise | Redis<br />Cloud | <span style="min-width: 9em; display: table-cell">Notes</span> |
+|:----------------------|:-----------------|:------|
+|<span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | <span title="Supported">&#x2705; Standard</span><br /><span title="Supported"><nobr>&#x2705; Active-Active</nobr></span> | Not supported for [scripts]({{<relref "/develop/interact/programmability">}}) in Redis versions earlier than 7. |
+
+Note: key memory usage is different on Redis Software or Redis Cloud active-active databases than on non-active-active databases. This is because memory usage includes some amount of CRDB overhead.---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- display_text: consumer
+  name: consumer
+  type: string
+arity: 5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(1)
+description: Deletes a consumer from a consumer group.
+group: stream
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XGROUP DELCONSUMER
+since: 5.0.0
+summary: Deletes a consumer from a consumer group.
+syntax_fmt: XGROUP DELCONSUMER key group consumer
+syntax_str: group consumer
+title: XGROUP DELCONSUMER
+---
+The `XGROUP DELCONSUMER` command deletes a consumer from the consumer group.
+
+Sometimes it may be useful to remove old consumers since they are no longer used.
+
+Note, however, that any pending messages that the consumer had will become unclaimable after it was deleted.
+It is strongly recommended, therefore, that any pending messages are claimed or acknowledged prior to deleting the consumer from the group.
+---
+acl_categories:
+- '@slow'
+arguments:
+- display_text: slot
+  name: slot
+  type: integer
+- display_text: count
+  name: count
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- stale
+complexity: O(N) where N is the number of requested keys
+description: Returns the key names in a hash slot.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER GETKEYSINSLOT
+since: 3.0.0
+summary: Returns the key names in a hash slot.
+syntax_fmt: CLUSTER GETKEYSINSLOT slot count
+syntax_str: count
+title: CLUSTER GETKEYSINSLOT
+---
+The command returns an array of keys names stored in the contacted node and
+hashing to the specified hash slot. The maximum number of keys to return
+is specified via the `count` argument, so that it is possible for the user
+of this API to batch-processing keys.
+
+The main usage of this command is during rehashing of cluster slots from one
+node to another. The way the rehashing is performed is exposed in the Redis
+Cluster specification, or in a more simple to digest form, as an appendix
+of the [`CLUSTER SETSLOT`]({{< relref "/commands/cluster-setslot" >}}) command documentation.
+
+```
+> CLUSTER GETKEYSINSLOT 7000 3
+1) "key_39015"
+2) "key_89793"
+3) "key_92937"
+```
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+complexity: O(N) where N is the number of functions
+description: Dumps all libraries into a serialized binary payload.
+group: scripting
+hidden: false
+linkTitle: FUNCTION DUMP
+since: 7.0.0
+summary: Dumps all libraries into a serialized binary payload.
+syntax_fmt: FUNCTION DUMP
+syntax_str: ''
+title: FUNCTION DUMP
+---
+Return the serialized payload of loaded libraries.
+You can restore the serialized payload later with the [`FUNCTION RESTORE`]({{< relref "/commands/function-restore" >}}) command.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+
+## Examples
+
+The following example shows how to dump loaded libraries using `FUNCTION DUMP` and then it calls [`FUNCTION FLUSH`]({{< relref "/commands/function-flush" >}}) deletes all the libraries.
+Then, it restores the original libraries from the serialized payload with [`FUNCTION RESTORE`]({{< relref "/commands/function-restore" >}}).
+
+```
+redis> FUNCTION LOAD "#!lua name=mylib \n redis.register_function('myfunc', function(keys, args) return args[1] end)"
+"mylib"
+redis> FUNCTION DUMP
+"\xf5\xc3@X@]\x1f#!lua name=mylib \n redis.registe\rr_function('my@\x0b\x02', @\x06`\x12\nkeys, args) 6\x03turn`\x0c\a[1] end)\x0c\x00\xba\x98\xc2\xa2\x13\x0e$\a"
+redis> FUNCTION FLUSH
+OK
+redis> FUNCTION RESTORE "\xf5\xc3@X@]\x1f#!lua name=mylib \n redis.registe\rr_function('my@\x0b\x02', @\x06`\x12\nkeys, args) 6\x03turn`\x0c\a[1] end)\x0c\x00\xba\x98\xc2\xa2\x13\x0e$\a"
+OK
+redis> FUNCTION LIST
+1) 1) "library_name"
+   2) "mylib"
+   3) "engine"
+   4) "LUA"
+   5) "functions"
+   6) 1) 1) "name"
+         2) "myfunc"
+         3) "description"
+         4) (nil)
+         5) "flags"
+         6) (empty array)
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the absolute value of the count argument.
+description: Return one or multiple random members from a vector set.
+group: vector_set
+hidden: false
+linkTitle: VRANDMEMBER
+since: 8.0.0
+summary: Return one or multiple random members from a vector set.
+syntax_fmt: "VRANDMEMBER key [count]"
+title: VRANDMEMBER
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return one or more random elements from a vector set.
+
+The behavior is similar to the `SRANDMEMBER` command:
+
+- When called without a count, returns a single element as a bulk string.
+- When called with a positive count, returns up to that many distinct elements (no duplicates).
+- When called with a negative count, returns that many elements, possibly with duplicates.
+- If the count exceeds the number of elements, the entire set is returned.
+- If the key does not exist, the command returns `null` if no count is given, or an empty array if a count is provided.
+
+```shell
+VADD vset VALUES 3 1 0 0 elem1
+VADD vset VALUES 3 0 1 0 elem2
+VADD vset VALUES 3 0 0 1 elem3
+```
+
+Return a single random element:
+
+```shell
+VRANDMEMBER vset
+"elem2"
+```
+
+Return two distinct random elements:
+
+```shell
+VRANDMEMBER vset 2
+1) "elem1"
+2) "elem3"
+```
+
+Return 3 random elements with possible duplicates:
+
+```shell
+VRANDMEMBER vset -3
+1) "elem2"
+2) "elem2"
+3) "elem1"
+```
+
+Request more elements than exist in the set:
+
+```shell
+VRANDMEMBER vset 10
+1) "elem1"
+2) "elem2"
+3) "elem3"
+```
+
+When the key doesn't exist:
+
+```shell
+VRANDMEMBER nonexistent
+(nil)
+```
+
+```shell
+VRANDMEMBER nonexistent 3
+(empty array)
+```
+
+This command is useful for:
+
+- Sampling elements for testing or training.
+- Generating random queries for performance testing.
+
+Internally:
+
+- For small counts (less than 20% of the set size), a dictionary is used to ensure uniqueness.
+- For large counts (more than 20% of the set size), a linear scan provides faster performance, though results may be less random.
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>count</code></summary>
+
+specifies the number of elements to return. Positive values return distinct elements; negative values allow duplicates.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- fast
+complexity: O(1)
+description: Signals that a cluster client is following an -ASK redirect.
+group: cluster
+hidden: false
+linkTitle: ASKING
+since: 3.0.0
+summary: Signals that a cluster client is following an -ASK redirect.
+syntax_fmt: ASKING
+syntax_str: ''
+title: ASKING
+---
+When a cluster client receives an `-ASK` redirect, the `ASKING` command is sent to the target node followed by the command which was redirected.
+This is normally done automatically by cluster clients.
+
+If an `-ASK` redirect is received during a transaction, only one ASKING command needs to be sent to the target node before sending the complete transaction to the target node.
+
+See [ASK redirection in the Redis Cluster Specification]({{< relref "/operate/oss_and_stack/reference/cluster-spec#ask-redirection" >}}) for details.
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+- '@blocking'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: timeout
+  name: timeout
+  type: double
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+- fast
+complexity: O(log(N)) with N being the number of elements in the sorted set.
+description: Removes and returns the member with the lowest score from one or more
+  sorted sets. Blocks until a member is available otherwise. Deletes the sorted set
+  if the last element was popped.
+group: sorted-set
+hidden: false
+history:
+- - 6.0.0
+  - '`timeout` is interpreted as a double instead of an integer.'
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -2
+      limit: 0
+    type: range
+linkTitle: BZPOPMIN
+since: 5.0.0
+summary: Removes and returns the member with the lowest score from one or more sorted
+  sets. Blocks until a member is available otherwise. Deletes the sorted set if the
+  last element was popped.
+syntax_fmt: BZPOPMIN key [key ...] timeout
+syntax_str: timeout
+title: BZPOPMIN
+---
+`BZPOPMIN` is the blocking variant of the sorted set [`ZPOPMIN`]({{< relref "/commands/zpopmin" >}}) primitive.
+
+It is the blocking version because it blocks the connection when there are no
+members to pop from any of the given sorted sets.
+A member with the lowest score is popped from first sorted set that is
+non-empty, with the given keys being checked in the order that they are given.
+
+The `timeout` argument is interpreted as a double value specifying the maximum
+number of seconds to block. A timeout of zero can be used to block indefinitely.
+
+See the [BLPOP documentation][cl] for the exact semantics, since `BZPOPMIN` is
+identical to [`BLPOP`]({{< relref "/commands/blpop" >}}) with the only difference being the data structure being
+popped from.
+
+[cl]: /commands/blpop
+
+## Examples
+
+```
+redis> DEL zset1 zset2
+(integer) 0
+redis> ZADD zset1 0 a 1 b 2 c
+(integer) 3
+redis> BZPOPMIN zset1 zset2 0
+1) "zset1"
+2) "a"
+3) "0"
+```
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Returns the type of the JSON value at path
+group: json
+hidden: false
+linkTitle: JSON.TYPE
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the type of the JSON value at path
+syntax_fmt: JSON.TYPE key [path]
+syntax_str: '[path]'
+title: JSON.TYPE
+---
+Report the type of JSON value at `path`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. Returns null if the `key` or `path` do not exist.
+
+</details>
+
+## Return
+
+JSON.TYPE returns an array of string replies for each path, specified as the value's type.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2, "nested": {"a": true}, "foo": "bar"}'
+OK
+redis> JSON.TYPE doc $..foo
+1) "string"
+redis> JSON.TYPE doc $..a
+1) "integer"
+2) "boolean"
+redis> JSON.TYPE doc $..dummy
+(empty array)
+{{< / highlight >}}
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.ARRLEN`]({{< relref "commands/json.arrlen/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: iterator
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n), where n is the capacity
+description: Begins an incremental save of the bloom filter
+group: cf
+hidden: false
+linkTitle: CF.SCANDUMP
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Begins an incremental save of the bloom filter
+syntax_fmt: CF.SCANDUMP key iterator
+syntax_str: iterator
+title: CF.SCANDUMP
+---
+Begins an incremental save of the cuckoo filter.
+
+This command is useful for large cuckoo filters that cannot fit into the [`DUMP`]({{< relref "/commands/dump" >}}) and [`RESTORE`]({{< relref "/commands/restore" >}}) model.
+
+The first time this command is called, the value of `iter` should be 0. 
+
+This command returns successive `(iter, data)` pairs until `(0, NULL)` indicates completion.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to save.
+</details>
+
+<details open><summary><code>iterator</code></summary>
+
+Iterator value; either 0 or the iterator from a previous invocation of this command
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) (_Iterator_) and [] (_Data_). 
+
+  The Iterator is passed as input to the next invocation of `CF.SCANDUMP`. If _Iterator_ is 0, then it means iteration has completed.
+
+  The iterator-data pair should also be passed to [`CF.LOADCHUNK`]({{< relref "commands/cf.loadchunk/" >}}) when restoring the filter.
+
+- [] on error (invalid arguments, key not found, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.RESERVE cf 8
+OK
+redis> CF.ADD cf item1
+(integer) 1
+redis> CF.SCANDUMP cf 0
+1) (integer) 1
+2) "\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x14\x00\x01\x008\x9a\xe0\xd8\xc3\x7f\x00\x00"
+redis> CF.SCANDUMP cf 1
+1) (integer) 9
+2) "\x00\x00\x00\x00\a\x00\x00\x00"
+redis> CF.SCANDUMP cf 9
+1) (integer) 0
+2) (nil)
+redis> DEL bf
+(integer) 1
+redis> CF.LOADCHUNK cf 1 "\x01\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x14\x00\x01\x008\x9a\xe0\xd8\xc3\x7f\x00\x00"
+OK
+redis> CF.LOADCHUNK cf 9 "\x00\x00\x00\x00\a\x00\x00\x00"
+OK
+redis> CF.EXISTS cf item1
+(integer) 1
+{{< / highlight >}}
+
+Python code:
+{{< highlight bash >}}
+chunks = []
+iter = 0
+while True:
+    iter, data = CF.SCANDUMP(key, iter)
+    if iter == 0:
+        break
+    else:
+        chunks.append([iter, data])
+
+# Load it back
+for chunk in chunks:
+    iter, data = chunk
+    CF.LOADCHUNK(key, iter, data)
+{{< / highlight >}}
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: node-id
+  name: node-id
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+complexity: O(N) where N is the number of replicas.
+description: Lists the replica nodes of a master node.
+group: cluster
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLUSTER REPLICAS
+since: 5.0.0
+summary: Lists the replica nodes of a master node.
+syntax_fmt: CLUSTER REPLICAS node-id
+syntax_str: ''
+title: CLUSTER REPLICAS
+---
+The command provides a list of replica nodes replicating from the specified
+master node. The list is provided in the same format used by [`CLUSTER NODES`]({{< relref "/commands/cluster-nodes" >}}) (please refer to its documentation for the specification of the format).
+
+The command will fail if the specified node is not known or if it is not
+a master according to the node table of the node receiving the command.
+
+Note that if a replica is added, moved, or removed from a given master node,
+and we ask `CLUSTER REPLICAS` to a node that has not yet received the
+configuration update, it may show stale information. However eventually
+(in a matter of seconds if there are no network partitions) all the nodes
+will agree about the set of nodes associated with a given master.
+---
+acl_categories:
+- '@write'
+- '@slow'
+- '@scripting'
+arguments:
+- arguments:
+  - display_text: async
+    name: async
+    token: ASYNC
+    type: pure-token
+  - display_text: sync
+    name: sync
+    token: SYNC
+    type: pure-token
+  name: flush-type
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- noscript
+complexity: O(N) where N is the number of functions deleted
+description: Deletes all libraries and functions.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: FUNCTION FLUSH
+since: 7.0.0
+summary: Deletes all libraries and functions.
+syntax_fmt: FUNCTION FLUSH [ASYNC | SYNC]
+syntax_str: ''
+title: FUNCTION FLUSH
+---
+Deletes all the libraries.
+
+Unless called with the optional mode argument, the `lazyfree-lazy-user-flush` configuration directive sets the effective behavior. Valid modes are:
+
+* `ASYNC`: Asynchronously flush the libraries.
+* `SYNC`: Synchronously flush the libraries.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for Pub/Sub commands.
+group: pubsub
+hidden: true
+linkTitle: PUBSUB
+since: 2.8.0
+summary: A container for Pub/Sub commands.
+syntax_fmt: PUBSUB
+syntax_str: ''
+title: PUBSUB
+---
+This is a container command for Pub/Sub introspection commands.
+
+To see the list of available commands you can call [`PUBSUB HELP`]({{< relref "/commands/pubsub-help" >}}).
+---
+acl_categories:
+- '@read'
+- '@search'
+arguments:
+- name: index
+  type: string
+- arguments:
+  - name: search
+    token: SEARCH
+    type: pure-token
+  - name: aggregate
+    token: AGGREGATE
+    type: pure-token
+  name: querytype
+  type: oneof
+- name: limited
+  optional: true
+  token: LIMITED
+  type: pure-token
+- name: queryword
+  token: QUERY
+  type: pure-token
+- name: query
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N)
+description: Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance
+  information
+group: search
+hidden: false
+linkTitle: FT.PROFILE
+module: Search
+since: 2.2.0
+stack_path: docs/interact/search-and-query
+summary: Performs a `FT.SEARCH` or `FT.AGGREGATE` command and collects performance
+  information
+syntax: 'FT.PROFILE index SEARCH | AGGREGATE [LIMITED] QUERY query
+
+  '
+syntax_fmt: FT.PROFILE index <SEARCH | AGGREGATE> [LIMITED] QUERY query
+syntax_str: <SEARCH | AGGREGATE> [LIMITED] QUERY query
+title: FT.PROFILE
+---
+
+Apply [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) or [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) command to collect performance details. For usage, see [Examples](#examples).
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is the name of an index created using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>SEARCH | AGGREGATE</code></summary>
+
+represents the profile type, either [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) or [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}).
+</details>
+
+<details open>
+<summary><code>LIMITED</code></summary>
+
+removes details of any `reader` iterators.
+</details>
+
+<details open>
+<summary><code>QUERY {query}</code></summary>
+
+is the query string, sent to `FT.SEARCH` or `FT.AGGREGATE`.
+</details>
+
+<note><b>Note:</b> To reduce the size of the output, use `NOCONTENT` or `LIMIT 0 0` to reduce the number of reply results, or `LIMITED` to not reply with details of `reader iterators` inside built-in unions, such as `fuzzy` or `prefix` iterators.</note>
+
+## Return
+
+`FT.PROFILE` returns a two-element array reply. The first element contains the results of the provided `FT.SEARCH` or `FT.AGGREGATE` command.
+The second element contains information about query creation, iterator profiles, and result processor profiles.
+Details of the second element follow in the sections below.
+
+### Results
+
+This section contains the search results.
+
+### Per-shard profiles
+
+This section contains query execution details for each shard.
+When more than one shard is in play, the shards will be labeled `Shard #1`, `Shard #2`, etc.
+If there's only one shard, the label will be omitted.
+
+| Returned field name      | Definition |
+|:--                       |:--         |
+| `Total`&nbsp;`profile`&nbsp;`time`     | The total run time (ms) of the query. Normally just a few ms. |
+| `Parsing`&nbsp;`time`           | The time (ms) spent parsing the query and its parameters into a query plan. Normally just a few ms. |
+| `Pipeline`&nbsp;`creation`&nbsp;`time` | The creation time (ms) of the execution plan, including iterators, result processors, and reducers creation. Normally just a few ms for `FT.SEARCH` queries, but expect a larger number for `FT.AGGREGATE` queries. |
+| `Warning`                | Errors that occurred during query execution. |
+
+### Iterator profiles
+
+This section contains index iterator information, including `Type`, `Query Type`, `Term` (when applicable), `Time` (in ms), `Counter`, `Child iterator`, and `Size` information.
+Each iterator represents an executor for each part of the query plan, nested per the execution plan. The operation types mentioned below (`UNION`, etc) should match up with the provided query.
+
+Inverted-index iterators also include the number of elements they contain. Hybrid vector iterators return the top results from the vector index in batches, including the number of batches.
+
+Iterator types include:
+
+* `INTERSECT` (and) with `Child iterator`
+* `UNION` (or) with `Child iterator`
+* `NOT` (`-`) with `Child iterator`
+* `Child iterator` - details of a sub-query component of a compound query.
+* `TEXT` with `Term`
+* `TAG` with `Term`
+* `NUMERIC` with `Term`
+* `VECTOR`
+* `EMPTY`
+* `WILDCARD`
+* `OPTIONAL`
+
+**Notes on `Counter` and `Size`**
+
+Counter is the number of times an iterator was interacted with. A very high value in comparison to others is a possible warning flag. `NUMERIC` and `Child interator` types are broken into ranges, and `Counter` will vary depending on the range. For `UNION`, the sum of the counters in child iterators should be equal or greater than the child iterator’s counters.
+
+`Size` is the size of the document set. `Counter` should always be equal or less than `Size`.
+
+### Result processor profiles
+
+Result processors form a powerful pipeline in Redis Query Engine. They work in stages to gather, filter, score, sort, and return results as efficiently as possible based on complex query needs. Each processor reports `Time` information, which represents the total duration (in milliseconds, or ms) spent by the processor to complete its operation, and `Counter` information, which indicates the number of times the processor was invoked during the query.
+
+| Type            | Definition |
+|:--              |:--         |
+| `Metrics`&nbsp;`Applier` | The `Metrics Applier` processor calculates or aggregates specific metrics related to the search results. For example, this might include applying a distance or similarity metric to vector search results, or calculating scores based on relevance or other parameters. |
+| `Index`           | The `Index` processor is responsible for the core retrieval of matching documents from the index based on the initial query criteria (e.g., full-text terms, filters, or numeric ranges). | 
+| `Scorer`          | The `Scorer` processor assigns a relevance score to each document based on the query’s specified scoring function. This function could involve factors like term frequency, inverse document frequency, or other weighted metrics. |
+| `Sorter`          | The `Sorter` processor arranges the query results based on a specified sorting criterion. This could be a field value (e.g., sorting by price, date, or another attribute) or by the score assigned during the scoring phase. It operates after documents are fetched and scored, ensuring the results are ordered as required by the query (e.g., ascending or descending order). `Scorer` results will always be present in `FT.SEARCH` profiles. |
+| `Loader`          | The `Loader` processor retrieves the document contents after the results have been sorted and filtered. It ensures that only the fields specified by the query are loaded, which improves efficiency, especially when dealing with large documents where only a few fields are needed. |
+| `Highlighter`     | The `Highlighter` processor is used to highlight matching terms in the search results. This is especially useful for full-text search applications, where relevant terms are often emphasized in the UI. |
+| `Paginator`       | The `Paginator` processor is responsible for handling pagination by limiting the results to a specific range (e.g., LIMIT 0 10).It trims down the set of results to fit the required pagination window, ensuring efficient memory usage when dealing with large result sets. |
+| `Vector`&nbsp;`Filter`   | For vector searches, the `Vector Filter` processor is sometimes used to pre-process results based on vector similarity thresholds before the main scoring and sorting. |
+
+### Coordinator
+
+This section is only present when run in a multi-shard environment.
+
+| Returned field name | Definition |
+|:--                  |:--         |
+| `Total coordinator time` | Time measured from the beginning of query execution until all shards have completed query execution. (ms) |
+| `Post-processing time`   | The time spent generating the FT.PROFILE output (overhead) (ms). |
+
+## Examples
+
+<details>
+<summary><b>Collect performance information about a simple JSON index.</b></summary>
+
+Imagine you have (1) a dataset consisting of 10 JSON documents, each with the following structure;
+
+```json
+{
+  "pickup_zone": "POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))",
+  "store_location": "-74.0060,40.7128",
+  "brand": "Velorim",
+  "model": "Jigger",
+  "price": 270,
+  "description": "Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids’ pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.",
+  "condition": "new"
+}
+```
+
+And (2) a corresponding index:
+
+```bash
+FT.CREATE idx:bicycle ON JSON PREFIX 1 bicycle: SCORE 1.0 SCHEMA $.pickup_zone AS pickup_zone GEOSHAPE $.store_location AS store_location GEO $.brand AS brand TEXT WEIGHT 1.0 $.model AS model TEXT WEIGHT 1.0 $.description AS description TEXT WEIGHT 1.0 $.price AS price NUMERIC $.condition AS condition TAG SEPARATOR ,
+```
+
+Here's an example of running the `FT.PROFILE` command for a compound query.
+
+{{< highlight bash >}}
+127.0.0.1:6379> ft.profile idx:bicycle search query "@description:(kids | small) @condition:{new | used}"
+1) 1) (integer) 3
+   2) "bicycle:0"
+   3) 1) "$"
+      2) "{\"pickup_zone\":\"POLYGON((-74.0610 40.7578, -73.9510 40.7578, -73.9510 40.6678, -74.0610 40.6678, -74.0610 40.7578))\",\"store_location\":\"-74.0060,40.7128\",\"brand\":\"Velorim\",\"model\":\"Jigger\",\"price\":270,\"description\":\"Small and powerful, the Jigger is the best ride for the smallest of tikes! This is the tiniest kids\xe2\x80\x99 pedal bike on the market available without a coaster brake, the Jigger is the vehicle of choice for the rare tenacious little rider raring to go.\",\"condition\":\"new\"}"
+   4) "bicycle:1"
+   5) 1) "$"
+      2) "{\"pickup_zone\":\"POLYGON((-118.2887 34.0972, -118.1987 34.0972, -118.1987 33.9872, -118.2887 33.9872, -118.2887 34.0972))\",\"store_location\":\"-118.2437,34.0522\",\"brand\":\"Bicyk\",\"model\":\"Hillcraft\",\"price\":1200,\"description\":\"Kids want to ride with as little weight as possible. Especially on an incline! They may be at the age when a 27.5\\\" wheel bike is just too clumsy coming off a 24\\\" bike. The Hillcraft 26 is just the solution they need!\",\"condition\":\"used\"}"
+   6) "bicycle:2"
+   7) 1) "$"
+      2) "{\"pickup_zone\":\"POLYGON((-87.6848 41.9331, -87.5748 41.9331, -87.5748 41.8231, -87.6848 41.8231, -87.6848 41.9331))\",\"store_location\":\"-87.6298,41.8781\",\"brand\":\"Nord\",\"model\":\"Chook air 5\",\"price\":815,\"description\":\"The Chook Air 5  gives kids aged six years and older a durable and uberlight mountain bike for their first experience on tracks and easy cruising through forests and fields. The lower  top tube makes it easy to mount and dismount in any situation, giving your kids greater safety on the trails.\",\"condition\":\"used\"}"
+2) 1) 1) Total profile time
+      2) "0"
+   2) 1) Parsing time
+      2) "0"
+   3) 1) Pipeline creation time
+      2) "0"
+   4) 1) Warning
+   5) 1) Iterators profile
+      2) 1) Type
+         2) INTERSECT
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 6
+         7) Child iterators
+         8)  1) Type
+             2) UNION
+             3) Query type
+             4) UNION
+             5) Time
+             6) "0"
+             7) Counter
+             8) (integer) 6
+             9) Child iterators
+            10)  1) Type
+                 2) UNION
+                 3) Query type
+                 4) UNION
+                 5) Time
+                 6) "0"
+                 7) Counter
+                 8) (integer) 4
+                 9) Child iterators
+                10)  1) Type
+                     2) TEXT
+                     3) Term
+                     4) kids
+                     5) Time
+                     6) "0"
+                     7) Counter
+                     8) (integer) 4
+                     9) Size
+                    10) (integer) 4
+                11)  1) Type
+                     2) TEXT
+                     3) Term
+                     4) +kid
+                     5) Time
+                     6) "0"
+                     7) Counter
+                     8) (integer) 4
+                     9) Size
+                    10) (integer) 4
+            11)  1) Type
+                 2) TEXT
+                 3) Term
+                 4) small
+                 5) Time
+                 6) "0"
+                 7) Counter
+                 8) (integer) 2
+                 9) Size
+                10) (integer) 2
+         9)  1) Type
+             2) UNION
+             3) Query type
+             4) TAG
+             5) Time
+             6) "0"
+             7) Counter
+             8) (integer) 6
+             9) Child iterators
+            10)  1) Type
+                 2) TAG
+                 3) Term
+                 4) new
+                 5) Time
+                 6) "0"
+                 7) Counter
+                 8) (integer) 4
+                 9) Size
+                10) (integer) 10
+            11)  1) Type
+                 2) TAG
+                 3) Term
+                 4) used
+                 5) Time
+                 6) "0"
+                 7) Counter
+                 8) (integer) 4
+                 9) Size
+                10) (integer) 8
+   6) 1) Result processors profile
+      2) 1) Type
+         2) Index
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      3) 1) Type
+         2) Scorer
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      4) 1) Type
+         2) Sorter
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      5) 1) Type
+         2) Loader
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+{{< / highlight >}}
+</details>
+
+<details>
+<summary><b>Collect performance information about a JSON index that includes vector data.</b></summary>
+
+For this example, you'll create a very simple vector database and index.
+
+Index:
+
+```redis
+FT.CREATE vss_idx ON JSON PREFIX 1 vec: SCHEMA $.vector AS vector VECTOR FLAT 6 TYPE FLOAT32 DIM 4 DISTANCE_METRIC L2
+```
+
+Database:
+
+```redis
+JSON.SET vec:1 $ '{"vector":[1,1,1,1]}'
+JSON.SET vec:2 $ '{"vector":[2,2,2,2]}'
+JSON.SET vec:3 $ '{"vector":[3,3,3,3]}'
+JSON.SET vec:4 $ '{"vector":[4,4,4,4]}'
+```
+
+Here's an example of running the `FT.PROFILE` command for a vector query.
+
+{{< highlight bash >}}
+127.0.0.1:6379> ft.profile vss_idx search query "*=>[KNN 3 @vector $query_vec]" PARAMS 2 query_vec "\x00\x00\x00@\x00\x00\x00@\x00\x00@@\x00\x00@@" SORTBY __vector_score DIALECT 2
+1) 1) (integer) 3
+   2) "vec:2"
+   3) 1) "__vector_score"
+      2) "2"
+      3) "$"
+      4) "{\"vector\":[2,2,2,2]}"
+   4) "vec:3"
+   5) 1) "__vector_score"
+      2) "2"
+      3) "$"
+      4) "{\"vector\":[3,3,3,3]}"
+   6) "vec:1"
+   7) 1) "__vector_score"
+      2) "10"
+      3) "$"
+      4) "{\"vector\":[1,1,1,1]}"
+2) 1) 1) Total profile time
+      2) "0"
+   2) 1) Parsing time
+      2) "0"
+   3) 1) Pipeline creation time
+      2) "0"
+   4) 1) Warning
+   5) 1) Iterators profile
+      2) 1) Type
+         2) VECTOR
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+   6) 1) Result processors profile
+      2) 1) Type
+         2) Index
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      3) 1) Type
+         2) Metrics Applier
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      4) 1) Type
+         2) Sorter
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+      5) 1) Type
+         2) Loader
+         3) Time
+         4) "0"
+         5) Counter
+         6) (integer) 3
+{{< /highlight >}}
+</details>
+
+## See also
+
+[`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) | [`FT.AGGREGATE`]({{< relref "commands/ft.aggregate/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: weight
+  multiple: true
+  name: weight
+  optional: true
+  token: WEIGHTS
+  type: integer
+- arguments:
+  - display_text: sum
+    name: sum
+    token: SUM
+    type: pure-token
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: aggregate
+  optional: true
+  token: AGGREGATE
+  type: oneof
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set,
+  K being the number of input sorted sets and M being the number of elements in the
+  resulting sorted set.
+description: Returns the intersect of multiple sorted sets.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZINTER
+since: 6.2.0
+summary: Returns the intersect of multiple sorted sets.
+syntax_fmt: "ZINTER numkeys key [key ...] [WEIGHTS\_weight [weight ...]]\n  [AGGREGATE\_\
+  <SUM | MIN | MAX>] [WITHSCORES]"
+syntax_str: "key [key ...] [WEIGHTS\_weight [weight ...]] [AGGREGATE\_<SUM | MIN |\
+  \ MAX>] [WITHSCORES]"
+title: ZINTER
+---
+This command is similar to [`ZINTERSTORE`]({{< relref "/commands/zinterstore" >}}), but instead of storing the resulting
+sorted set, it is returned to the client.
+
+For a description of the `WEIGHTS` and `AGGREGATE` options, see [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZADD zset2 3 "three"
+ZINTER 2 zset1 zset2
+ZINTER 2 zset1 zset2 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@fast'
+- '@transaction'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- allow_busy
+complexity: O(1) for every key.
+description: Monitors changes to keys to determine the execution of a transaction.
+group: transactions
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: WATCH
+since: 2.2.0
+summary: Monitors changes to keys to determine the execution of a transaction.
+syntax_fmt: WATCH key [key ...]
+syntax_str: ''
+title: WATCH
+---
+Marks the given keys to be watched for conditional execution of a
+[transaction][tt].
+
+[tt]: /develop/interact/transactions
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the score of a member in a sorted set.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZSCORE
+since: 1.2.0
+summary: Returns the score of a member in a sorted set.
+syntax_fmt: ZSCORE key member
+syntax_str: member
+title: ZSCORE
+---
+Returns the score of `member` in the sorted set at `key`.
+
+If `member` does not exist in the sorted set, or `key` does not exist, `nil` is
+returned.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZSCORE myzset "one"
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: id
+  multiple: true
+  name: id
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1) for each single item to delete in the stream, regardless of the stream
+  size.
+description: Returns the number of messages after removing them from a stream.
+group: stream
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XDEL
+since: 5.0.0
+summary: Returns the number of messages after removing them from a stream.
+syntax_fmt: XDEL key id [id ...]
+syntax_str: id [id ...]
+title: XDEL
+---
+Removes the specified entries from a stream, and returns the number of entries
+deleted.  This number may be less than the number of IDs passed to the command in
+the case where some of the specified IDs do not exist in the stream.
+
+Normally you may think at a Redis stream as an append-only data structure,
+however Redis streams are represented in memory, so we are also able to 
+delete entries. This may be useful, for instance, in order to comply with
+certain privacy policies.
+
+## Understanding the low level details of entries deletion
+
+Redis streams are represented in a way that makes them memory efficient:
+a radix tree is used in order to index macro-nodes that pack linearly tens
+of stream entries. Normally what happens when you delete an entry from a stream
+is that the entry is not *really* evicted, it just gets marked as deleted.
+
+Eventually if all the entries in a macro-node are marked as deleted, the whole
+node is destroyed and the memory reclaimed. This means that if you delete
+a large amount of entries from a stream, for instance more than 50% of the
+entries appended to the stream, the memory usage per entry may increment, since
+what happens is that the stream will become fragmented. However the stream
+performance will remain the same.
+
+In future versions of Redis it is possible that we'll trigger a node garbage
+collection in case a given macro-node reaches a given amount of deleted
+entries. Currently with the usage we anticipate for this data structure, it is
+not a good idea to add such complexity.
+
+## Examples
+
+```
+> XADD mystream * a 1
+1538561698944-0
+> XADD mystream * b 2
+1538561700640-0
+> XADD mystream * c 3
+1538561701744-0
+> XDEL mystream 1538561700640-0
+(integer) 1
+127.0.0.1:6379> XRANGE mystream - +
+1) 1) 1538561698944-0
+   2) 1) "a"
+      2) "1"
+2) 1) 1538561701744-0
+   2) 1) "c"
+      2) "3"
+```
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Toggles a boolean value
+group: json
+hidden: false
+linkTitle: JSON.TOGGLE
+module: JSON
+since: 2.0.0
+stack_path: docs/data-types/json
+summary: Toggles a boolean value
+syntax_fmt: JSON.TOGGLE key path
+syntax_str: path
+title: JSON.TOGGLE
+---
+Toggle a Boolean value stored at `path`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. 
+
+</details>
+
+## Return
+
+JSON.TOGGLE returns an array of integer replies for each path, the new value (`0` if `false` or `1` if `true`), or `nil` for JSON values matching the path that are not Boolean.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Toogle a Boolean value stored at <code>path</code></b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"bool": true}'
+OK
+{{< / highlight >}}
+
+Toggle the Boolean value.
+
+{{< highlight bash >}}
+redis> JSON.TOGGLE doc $.bool
+1) (integer) 0
+{{< / highlight >}}
+
+Get the updated document.
+
+{{< highlight bash >}}
+redis> JSON.GET doc $
+"[{\"bool\":false}]"
+{{< / highlight >}}
+
+Toggle the Boolean value.
+
+{{< highlight bash >}}
+redis> JSON.TOGGLE doc $.bool
+1) (integer) 1
+{{< / highlight >}}
+
+Get the updated document.
+
+{{< highlight bash >}}
+redis> JSON.GET doc $
+"[{\"bool\":true}]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.GET`]({{< relref "commands/json.get/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@write'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: source
+  key_spec_index: 1
+  name: source
+  type: key
+- arguments:
+  - display_text: member
+    name: member
+    token: FROMMEMBER
+    type: string
+  - arguments:
+    - display_text: longitude
+      name: longitude
+      type: double
+    - display_text: latitude
+      name: latitude
+      type: double
+    name: fromlonlat
+    token: FROMLONLAT
+    type: block
+  name: from
+  type: oneof
+- arguments:
+  - arguments:
+    - display_text: radius
+      name: radius
+      token: BYRADIUS
+      type: double
+    - arguments:
+      - display_text: m
+        name: m
+        token: M
+        type: pure-token
+      - display_text: km
+        name: km
+        token: KM
+        type: pure-token
+      - display_text: ft
+        name: ft
+        token: FT
+        type: pure-token
+      - display_text: mi
+        name: mi
+        token: MI
+        type: pure-token
+      name: unit
+      type: oneof
+    name: circle
+    type: block
+  - arguments:
+    - display_text: width
+      name: width
+      token: BYBOX
+      type: double
+    - display_text: height
+      name: height
+      type: double
+    - arguments:
+      - display_text: m
+        name: m
+        token: M
+        type: pure-token
+      - display_text: km
+        name: km
+        token: KM
+        type: pure-token
+      - display_text: ft
+        name: ft
+        token: FT
+        type: pure-token
+      - display_text: mi
+        name: mi
+        token: MI
+        type: pure-token
+      name: unit
+      type: oneof
+    name: box
+    type: block
+  name: by
+  type: oneof
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- display_text: storedist
+  name: storedist
+  optional: true
+  token: STOREDIST
+  type: pure-token
+arity: -8
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding
+  box area around the shape provided as the filter and M is the number of items inside
+  the shape
+description: Queries a geospatial index for members inside an area of a box or a circle,
+  optionally stores the result.
+group: geo
+hidden: false
+history:
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEOSEARCHSTORE
+since: 6.2.0
+summary: Queries a geospatial index for members inside an area of a box or a circle,
+  optionally stores the result.
+syntax_fmt: "GEOSEARCHSTORE destination source <FROMMEMBER\_member |\n  FROMLONLAT\_\
+  longitude latitude> <BYRADIUS\_radius <M | KM | FT | MI>\n  | BYBOX\_width height\
+  \ <M | KM | FT | MI>> [ASC | DESC] [COUNT\_count\n  [ANY]] [STOREDIST]"
+syntax_str: "source <FROMMEMBER\_member | FROMLONLAT\_longitude latitude> <BYRADIUS\_\
+  radius <M | KM | FT | MI> | BYBOX\_width height <M | KM | FT | MI>> [ASC | DESC]\
+  \ [COUNT\_count [ANY]] [STOREDIST]"
+title: GEOSEARCHSTORE
+---
+This command is like [`GEOSEARCH`]({{< relref "/commands/geosearch" >}}), but stores the result in destination key.
+
+This command replaces the now deprecated [`GEORADIUS`]({{< relref "/commands/georadius" >}}) and [`GEORADIUSBYMEMBER`]({{< relref "/commands/georadiusbymember" >}}).
+
+By default, it stores the results in the `destination` sorted set with their geospatial information.
+
+When using the `STOREDIST` option, the command stores the items in a sorted set populated with their distance from the center of the circle or box, as a floating-point number, in the same unit specified for that shape.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEOADD Sicily 12.758489 38.788135 "edge1"   17.241510 38.788135 "edge2" 
+GEOSEARCHSTORE key1 Sicily FROMLONLAT 15 37 BYBOX 400 400 km ASC COUNT 3
+GEOSEARCH key1 FROMLONLAT 15 37 BYBOX 400 400 km ASC WITHCOORD WITHDIST WITHHASH
+GEOSEARCHSTORE key2 Sicily FROMLONLAT 15 37 BYBOX 400 400 km ASC COUNT 3 STOREDIST
+ZRANGE key2 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(log(N)*M) with N being the number of elements in the sorted set, and
+  M being the number of elements popped.
+description: Returns the highest-scoring members from a sorted set after removing
+  them. Deletes the sorted set if the last member was popped.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZPOPMAX
+since: 5.0.0
+summary: Returns the highest-scoring members from a sorted set after removing them.
+  Deletes the sorted set if the last member was popped.
+syntax_fmt: ZPOPMAX key [count]
+syntax_str: '[count]'
+title: ZPOPMAX
+---
+Removes and returns up to `count` members with the highest scores in the sorted
+set stored at `key`.
+
+When left unspecified, the default value for `count` is 1. Specifying a `count`
+value that is higher than the sorted set's cardinality will not produce an
+error. When returning multiple elements, the one with the highest score will
+be the first, followed by the elements with lower scores.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZPOPMAX myzset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@topk'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+- name: topk
+  type: integer
+- arguments:
+  - name: width
+    type: integer
+  - name: depth
+    type: integer
+  - name: decay
+    type: double
+  name: params
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Initializes a TopK with specified parameters
+group: topk
+hidden: false
+linkTitle: TOPK.RESERVE
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Initializes a TopK with specified parameters
+syntax_fmt: TOPK.RESERVE key topk [width depth decay]
+syntax_str: topk [width depth decay]
+title: TOPK.RESERVE
+---
+Initializes a TopK with specified parameters.
+
+### Parameters
+
+* **key**: Key under which the sketch is to be found.
+* **topk**: Number of top occurring items to keep.
+
+Optional parameters
+* **width**: Number of counters kept in each array. (Default 8)
+* **depth**: Number of arrays. (Default 7)
+* **decay**: The probability of reducing a counter in an occupied bucket. It is raised to power of it's counter (decay ^ bucket[i].counter). Therefore, as the counter gets higher, the chance of a reduction is being reduced. (Default 0.9)
+
+## Return
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+```
+redis> TOPK.RESERVE topk 50 2000 7 0.925
+OK
+```
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns the minimum observation value from a t-digest sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.MIN
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns the minimum observation value from a t-digest sketch
+syntax_fmt: TDIGEST.MIN key
+syntax_str: ''
+title: TDIGEST.MIN
+---
+Returns the minimum observation value from a t-digest sketch.
+
+## Required arguments
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) of minimum observation value from a sketch. The result is always accurate. 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t
+OK
+redis> TDIGEST.MIN t
+"nan"
+redis> TDIGEST.ADD t 3 4 1 2 5
+OK
+redis> TDIGEST.MIN t
+"1"
+{{< / highlight >}}
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: pattern
+  name: pattern
+  type: pattern
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) with N being the number of keys in the database, under the assumption
+  that the key names in the database and the given pattern have limited length.
+description: Returns all key names that match a pattern.
+group: generic
+hidden: false
+hints:
+- request_policy:all_shards
+- nondeterministic_output_order
+linkTitle: KEYS
+since: 1.0.0
+summary: Returns all key names that match a pattern.
+syntax_fmt: KEYS pattern
+syntax_str: ''
+title: KEYS
+---
+Returns all keys matching `pattern`.
+
+While the time complexity for this operation is O(N), the constant times are
+fairly low.
+For example, Redis running on an entry level laptop can scan a 1 million key
+database in 40 milliseconds.
+
+**Warning**: consider `KEYS` as a command that should only be used in production
+environments with extreme care.
+It may ruin performance when it is executed against large databases.
+This command is intended for debugging and special operations, such as changing
+your keyspace layout.
+Don't use `KEYS` in your regular application code.
+If you're looking for a way to find keys in a subset of your keyspace, consider
+using [`SCAN`]({{< relref "/commands/scan" >}}) or [sets]({{< relref "/develop/data-types/sets" >}}).
+
+Supported glob-style patterns:
+
+* `h?llo` matches `hello`, `hallo` and `hxllo`
+* `h*llo` matches `hllo` and `heeeello`
+* `h[ae]llo` matches `hello` and `hallo,` but not `hillo`
+* `h[^e]llo` matches `hallo`, `hbllo`, ... but not `hello`
+* `h[a-b]llo` matches `hallo` and `hbllo`
+
+Use `\` to escape special characters if you want to match them verbatim.
+
+When using [Redis Cluster]({{< relref "/operate/oss_and_stack/management/scaling" >}}), the search is optimized for patterns that imply a single slot.
+If a pattern can only match keys of one slot,
+Redis only iterates over keys in that slot, rather than the whole database,
+when searching for keys matching the pattern.
+For example, with the pattern `{a}h*llo`, Redis would only try to match it with the keys in slot 15495, which hash tag `{a}` implies.
+To use pattern with hash tag, see [Hash tags]({{< relref "operate/oss_and_stack/reference/cluster-spec#hash-tags" >}}) in the Cluster specification for more information.
+
+## Examples
+
+{{% redis-cli %}}
+MSET firstname Jack lastname Stuntman age 35
+KEYS *name*
+KEYS a??
+KEYS *
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+arguments:
+- display_text: source
+  key_spec_index: 0
+  name: source
+  type: key
+- display_text: destination
+  key_spec_index: 1
+  name: destination
+  type: key
+- display_text: destination-db
+  name: destination-db
+  optional: true
+  token: DB
+  type: integer
+- display_text: replace
+  name: replace
+  optional: true
+  token: REPLACE
+  type: pure-token
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) worst case for collections, where N is the number of nested items.
+  O(1) for string values.
+description: Copies the value of a key to a new key.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- OW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: COPY
+since: 6.2.0
+summary: Copies the value of a key to a new key.
+syntax_fmt: "COPY source destination [DB\_destination-db] [REPLACE]"
+syntax_str: "destination [DB\_destination-db] [REPLACE]"
+title: COPY
+---
+This command copies the value stored at the `source` key to the `destination`
+key.
+
+By default, the `destination` key is created in the logical database used by the
+connection. The `DB` option allows specifying an alternative logical database
+index for the destination key.
+
+The command returns zero when the `destination` key already exists. The
+`REPLACE` option removes the `destination` key before copying the value to it.
+
+## Examples
+
+```
+SET dolly "sheep"
+COPY dolly clone
+GET clone
+```
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: timeout
+  name: timeout
+  type: double
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: where
+  type: oneof
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+- movablekeys
+complexity: O(N+M) where N is the number of provided keys and M is the number of elements
+  returned.
+description: Pops the first element from one of multiple lists. Blocks until an element
+  is available otherwise. Deletes the list if the last element was popped.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: BLMPOP
+since: 7.0.0
+summary: Pops the first element from one of multiple lists. Blocks until an element
+  is available otherwise. Deletes the list if the last element was popped.
+syntax_fmt: "BLMPOP timeout numkeys key [key ...] <LEFT | RIGHT> [COUNT\_count]"
+syntax_str: "numkeys key [key ...] <LEFT | RIGHT> [COUNT\_count]"
+title: BLMPOP
+---
+`BLMPOP` is the blocking variant of [`LMPOP`]({{< relref "/commands/lmpop" >}}).
+
+When any of the lists contains elements, this command behaves exactly like [`LMPOP`]({{< relref "/commands/lmpop" >}}).
+When used inside a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) block, this command behaves exactly like [`LMPOP`]({{< relref "/commands/lmpop" >}}).
+When all lists are empty, Redis will block the connection until another client pushes to it or until the `timeout` (a double value specifying the maximum number of seconds to block) elapses.
+A `timeout` of zero can be used to block indefinitely.
+
+See [`LMPOP`]({{< relref "/commands/lmpop" >}}) for more information.
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- arguments:
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: where
+  type: oneof
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- movablekeys
+complexity: O(K) + O(M*log(N)) where K is the number of provided keys, N being the
+  number of elements in the sorted set, and M being the number of elements popped.
+description: Returns the highest- or lowest-scoring members from one or more sorted
+  sets after removing them. Deletes the sorted set if the last member was popped.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZMPOP
+since: 7.0.0
+summary: Returns the highest- or lowest-scoring members from one or more sorted sets
+  after removing them. Deletes the sorted set if the last member was popped.
+syntax_fmt: "ZMPOP numkeys key [key ...] <MIN | MAX> [COUNT\_count]"
+syntax_str: "key [key ...] <MIN | MAX> [COUNT\_count]"
+title: ZMPOP
+---
+Pops one or more elements, that are member-score pairs, from the first non-empty sorted set in the provided list of key names.
+
+`ZMPOP` and [`BZMPOP`]({{< relref "/commands/bzmpop" >}}) are similar to the following, more limited, commands:
+
+- [`ZPOPMIN`]({{< relref "/commands/zpopmin" >}}) or [`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) which take only one key, and can return multiple elements.
+- [`BZPOPMIN`]({{< relref "/commands/bzpopmin" >}}) or [`BZPOPMAX`]({{< relref "/commands/bzpopmax" >}}) which take multiple keys, but return only one element from just one key.
+
+See [`BZMPOP`]({{< relref "/commands/bzmpop" >}}) for the blocking variant of this command.
+
+When the `MIN` modifier is used, the elements popped are those with the lowest scores from the first non-empty sorted set. The `MAX` modifier causes elements with the highest scores to be popped.
+The optional `COUNT` can be used to specify the number of elements to pop, and is set to 1 by default.
+
+The number of popped elements is the minimum from the sorted set's cardinality and `COUNT`'s value.
+
+## Examples
+
+{{% redis-cli %}}
+ZMPOP 1 notsuchkey MIN
+ZADD myzset 1 "one" 2 "two" 3 "three"
+ZMPOP 1 myzset MIN
+ZRANGE myzset 0 -1 WITHSCORES
+ZMPOP 1 myzset MAX COUNT 10
+ZADD myzset2 4 "four" 5 "five" 6 "six"
+ZMPOP 2 myzset myzset2 MIN COUNT 10
+ZRANGE myzset 0 -1 WITHSCORES
+ZMPOP 2 myzset myzset2 MAX COUNT 10
+ZRANGE myzset2 0 -1 WITHSCORES
+EXISTS myzset myzset2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns the unique client ID of the connection.
+group: connection
+hidden: false
+linkTitle: CLIENT ID
+since: 5.0.0
+summary: Returns the unique client ID of the connection.
+syntax_fmt: CLIENT ID
+syntax_str: ''
+title: CLIENT ID
+---
+The command just returns the ID of the current connection. Every connection
+ID has certain guarantees:
+
+1. It is never repeated, so if `CLIENT ID` returns the same number, the caller can be sure that the underlying client did not disconnect and reconnect the connection, but it is still the same connection.
+2. The ID is monotonically incremental. If the ID of a connection is greater than the ID of another connection, it is guaranteed that the second connection was established with the server at a later time.
+
+This command is especially useful together with [`CLIENT UNBLOCK`]({{< relref "/commands/client-unblock" >}}) which was
+introduced also in Redis 5 together with `CLIENT ID`. Check the [`CLIENT UNBLOCK`]({{< relref "/commands/client-unblock" >}}) command page for a pattern involving the two commands.
+
+## Examples
+
+{{% redis-cli %}}
+CLIENT ID
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Returns the expiration time of a hash field as a Unix timestamp, in seconds.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HEXPIRETIME
+since: 7.4.0
+summary: Returns the expiration time of a hash field as a Unix timestamp, in seconds.
+syntax_fmt: "HEXPIRETIME key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HEXPIRETIME
+---
+Returns the absolute Unix timestamp in seconds since Unix epoch at which the given key's field(s) will expire.
+
+See also the [`HPEXPIRETIME`]({{< relref "/commands/hpexpiretime" >}}) command, which returns the same information with millisecond resolution.
+
+## Examples
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer) 2
+redis> HEXPIRE mykey 300  FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HEXPIRETIME mykey FIELDS 2 field1 field2
+1) (integer) 1715705914
+2) (integer) 1715705914
+```
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of members being requested.
+description: Returns the score of one or more members in a sorted set.
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZMSCORE
+since: 6.2.0
+summary: Returns the score of one or more members in a sorted set.
+syntax_fmt: ZMSCORE key member [member ...]
+syntax_str: member [member ...]
+title: ZMSCORE
+---
+Returns the scores associated with the specified `members` in the sorted set stored at `key`.
+
+For every `member` that does not exist in the sorted set, a `nil` value is returned.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZMSCORE myzset "one" "two" "nofield"
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@search'
+- '@read'
+- '@fast'
+arguments:
+- name: index
+  type: string
+- name: query
+  type: string
+- name: verbatim
+  optional: true
+  token: VERBATIM
+  type: pure-token
+- arguments:
+  - name: count
+    token: LOAD
+    type: string
+  - multiple: true
+    name: field
+    type: string
+  name: load
+  optional: true
+  type: block
+- name: timeout
+  optional: true
+  token: TIMEOUT
+  type: integer
+- name: loadall
+  optional: true
+  token: LOAD *
+  type: pure-token
+- arguments:
+  - name: nargs
+    token: GROUPBY
+    type: integer
+  - multiple: true
+    name: property
+    type: string
+  - arguments:
+    - name: function
+      token: REDUCE
+      type: string
+    - name: nargs
+      type: integer
+    - multiple: true
+      name: arg
+      type: string
+    - name: name
+      optional: true
+      token: AS
+      type: string
+    multiple: true
+    name: reduce
+    optional: true
+    type: block
+  multiple: true
+  name: groupby
+  optional: true
+  type: block
+- arguments:
+  - name: nargs
+    token: SORTBY
+    type: integer
+  - arguments:
+    - name: property
+      type: string
+    - arguments:
+      - name: asc
+        token: ASC
+        type: pure-token
+      - name: desc
+        token: DESC
+        type: pure-token
+      name: order
+      type: oneof
+    multiple: true
+    name: fields
+    optional: true
+    type: block
+  - name: num
+    optional: true
+    token: MAX
+    type: integer
+  name: sortby
+  optional: true
+  type: block
+- arguments:
+  - name: expression
+    token: APPLY
+    type: string
+  - name: name
+    token: AS
+    type: string
+  multiple: true
+  name: apply
+  optional: true
+  type: block
+- arguments:
+  - name: limit
+    token: LIMIT
+    type: pure-token
+  - name: offset
+    type: integer
+  - name: num
+    type: integer
+  name: limit
+  optional: true
+  type: block
+- name: filter
+  optional: true
+  token: FILTER
+  type: string
+- arguments:
+  - name: withcursor
+    token: WITHCURSOR
+    type: pure-token
+  - name: read_size
+    optional: true
+    token: COUNT
+    type: integer
+  - name: idle_time
+    optional: true
+    token: MAXIDLE
+    type: integer
+  name: cursor
+  optional: true
+  type: block
+- arguments:
+  - name: params
+    token: PARAMS
+    type: pure-token
+  - name: nargs
+    type: integer
+  - arguments:
+    - name: name
+      type: string
+    - name: value
+      type: string
+    multiple: true
+    name: values
+    type: block
+  name: params
+  optional: true
+  type: block
+- name: scorer
+  optional: true
+  token: SCORER
+  type: string
+- name: addscores
+  optional: true
+  token: ADDSCORES
+  type: pure-token
+- name: dialect
+  optional: true
+  since: 2.4.3
+  token: DIALECT
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Run a search query on an index and perform aggregate transformations
+  on the results
+group: search
+hidden: false
+linkTitle: FT.AGGREGATE
+module: Search
+since: 1.1.0
+stack_path: docs/interact/search-and-query
+summary: Run a search query on an index and perform aggregate transformations on the
+  results
+syntax: "FT.AGGREGATE index query \n  [VERBATIM] \n  [LOAD count field [field ...]]\
+  \ \n  [TIMEOUT timeout] \n  [ GROUPBY nargs property [property ...] [ REDUCE function\
+  \ nargs arg [arg ...] [AS name] [ REDUCE function nargs arg [arg ...] [AS name]\
+  \ ...]] ...]] \n  [ SORTBY nargs [ property ASC | DESC [ property ASC | DESC ...]]\
+  \ [MAX num] [WITHCOUNT] \n  [ APPLY expression AS name [ APPLY expression AS name\
+  \ ...]] \n  [ LIMIT offset num] \n  [FILTER filter] \n  [ WITHCURSOR [COUNT read_size]\
+  \ [MAXIDLE idle_time]] \n  [ PARAMS nargs name value [ name value ...]] \n  [SCORER scorer]\n
+  \ [ADDSCORES] \n  [DIALECT\
+  \ dialect]\n"
+syntax_fmt: "FT.AGGREGATE index query [VERBATIM] [LOAD\_count field [field ...]]\n\
+  \  [TIMEOUT\_timeout] [LOAD *] [GROUPBY\_nargs property [property ...]\n  [REDUCE\_\
+  function nargs arg [arg ...] [AS\_name] [REDUCE\_function\n  nargs arg [arg ...]\
+  \ [AS\_name] ...]] [GROUPBY\_nargs property\n  [property ...] [REDUCE\_function\
+  \ nargs arg [arg ...] [AS\_name]\n  [REDUCE\_function nargs arg [arg ...] [AS\_\
+  name] ...]] ...]]\n  [SORTBY\_nargs [property <ASC | DESC> [property <ASC | DESC>\
+  \ ...]]\n  [MAX\_num]] [APPLY\_expression AS\_name [APPLY\_expression AS\_name\n\
+  \  ...]] [LIMIT offset num] [FILTER\_filter] [WITHCURSOR\n  [COUNT\_read_size] [MAXIDLE\_\
+  idle_time]] [PARAMS nargs name value\n  [name value ...]]\n  [SCORER scorer]\n [ADDSCORES]\n  [DIALECT\_dialect]"
+syntax_str: "query [VERBATIM] [LOAD\_count field [field ...]] [TIMEOUT\_timeout] [LOAD\
+  \ *] [GROUPBY\_nargs property [property ...] [REDUCE\_function nargs arg [arg ...]\
+  \ [AS\_name] [REDUCE\_function nargs arg [arg ...] [AS\_name] ...]] [GROUPBY\_nargs\
+  \ property [property ...] [REDUCE\_function nargs arg [arg ...] [AS\_name] [REDUCE\_\
+  function nargs arg [arg ...] [AS\_name] ...]] ...]] [SORTBY\_nargs [property <ASC\
+  \ | DESC> [property <ASC | DESC> ...]] [MAX\_num]] [APPLY\_expression AS\_name [APPLY\_\
+  expression AS\_name ...]] [LIMIT offset num] [FILTER\_filter] [WITHCURSOR [COUNT\_\
+  read_size] [MAXIDLE\_idle_time]] [PARAMS nargs name value [name value ...]] [SCORER scorer] [ADDSCORES] [DIALECT\_\
+  dialect]"
+title: FT.AGGREGATE
+---
+
+Run a search query on an index and perform aggregate transformations on the results.
+
+{{< note >}}
+This command will only return keys to which the user has read access.
+{{< /note >}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name against which the query is executed. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+</details>
+
+<details open>
+<summary><code>query</code></summary> 
+
+is base filtering query that retrieves the documents. It follows the exact same syntax as the search query, including filters, unions, not, optional, and so on.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>VERBATIM</code></summary>
+
+if set, does not try to use stemming for query expansion but searches the query terms verbatim.
+</details>
+
+<details open>
+<summary><code>LOAD {nargs} {identifier} AS {property} …</code></summary> 
+
+loads document attributes from the source document. 
+ - `identifier` is either an attribute name for hashes and JSON or a JSON Path expression for JSON. 
+ - `property` is the optional name used in the result. If it is not provided, the `identifier` is used. This should be avoided.
+ - If `*` is used as `nargs`, all attributes in a document are loaded.
+
+Attributes needed for aggregations should be stored as `SORTABLE`, where they are available to the aggregation pipeline with very low latency. `LOAD` hurts the performance of aggregate queries considerably because every processed record needs to execute the equivalent of [`HMGET`]({{< relref "/commands/hmget" >}}) against a Redis key, which when executed over millions of keys, amounts to high processing times.
+
+<details open>
+<summary><code>GROUPBY {nargs} {property}</code></summary> 
+
+groups the results in the pipeline based on one or more properties. Each group should have at least one _reducer_, a function that handles the group entries,
+  either counting them, or performing multiple aggregate operations (see below).
+      
+<details open>
+<summary><code>REDUCE {func} {nargs} {arg} … [AS {name}]</code></summary>
+
+reduces the matching results in each group into a single record, using a reduction function. For example, `COUNT` counts the number of records in the group. The reducers can have their own property names using the `AS {name}` optional argument. If a name is not given, the resulting name will be the name of the reduce function and the group properties. For example, if a name is not given to `COUNT_DISTINCT` by property `@foo`, the resulting name will be `count_distinct(@foo)`.
+  
+See [Supported GROUPBY reducers]({{< relref "develop/interact/search-and-query/advanced-concepts/aggregations#supported-groupby-reducers" >}}) for more details.   
+</details>
+
+<details open>
+<summary><code>SORTBY {nargs} {property} {ASC|DESC} [MAX {num}]</code></summary> 
+
+sorts the pipeline up until the point of `SORTBY`, using a list of properties. 
+
+ - By default, sorting is ascending, but `ASC` or `DESC ` can be added for each property. 
+ - `nargs` is the number of sorting parameters, including `ASC` and `DESC`, for example, `SORTBY 4 @foo ASC @bar DESC`.
+ - `MAX` is used to optimized sorting, by sorting only for the n-largest elements. Although it is not connected to `LIMIT`, you usually need just `SORTBY … MAX` for common queries.
+
+Attributes needed for `SORTBY` should be stored as `SORTABLE` to be available with very low latency.
+
+**Sorting Optimizations**: performance is optimized for sorting operations on `DIALECT 4` in different scenarios:
+   - Skip Sorter - applied when there is no sort of any kind. The query can return after it reaches the `LIMIT` requested results.
+   - Partial Range - applied when there is a `SORTBY` clause over a numeric field, with no filter or filter by the same numeric field, the query iterate on a range large enough to satisfy the `LIMIT` requested results.
+   - Hybrid - applied when there is a `SORTBY` clause over a numeric field and another non-numeric filter. Some results will get filtered, and the initial range may not be large enough. The iterator is then rewinding with the following ranges, and an additional iteration takes place to collect the `LIMIT` requested results.
+   - No optimization - If there is a sort by score or by non-numeric field, there is no other option but to retrieve all results and compare their values.
+
+**Counts behavior**: optional `WITHCOUNT` argument returns accurate counts for the query results with sorting. This operation processes all results in order to get an accurate count, being less performant than the optimized option (default behavior on `DIALECT 4`)
+
+
+<details open>
+<summary><code>APPLY {expr} AS {name}</code></summary> 
+
+applies a 1-to-1 transformation on one or more properties and either stores the result as a new property down the pipeline or replaces any property using this
+  transformation. 
+  
+`expr` is an expression that can be used to perform arithmetic operations on numeric properties, or functions that can be applied on properties depending on their types (see below), or any combination thereof. For example, `APPLY "sqrt(@foo)/log(@bar) + 5" AS baz` evaluates this expression dynamically for each record in the pipeline and store the result as a new property called `baz`, which can be referenced by further `APPLY`/`SORTBY`/`GROUPBY`/`REDUCE` operations down the
+  pipeline.
+
+See [APPLY expressions]({{< relref "develop/interact/search-and-query/advanced-concepts/aggregations/#apply-expressions" >}}) for details.
+</details>
+
+<details open>
+<summary><code>LIMIT {offset} {num}</code></summary> 
+
+limits the number of results to return just `num` results starting at index `offset` (zero-based). It is much more efficient to use `SORTBY … MAX` if you
+  are interested in just limiting the output of a sort operation.
+  If a key expires during the query, an attempt to `load` the key's value will return a null array. 
+
+However, limit can be used to limit results without sorting, or for paging the n-largest results as determined by `SORTBY MAX`. For example, getting results 50-100 of the top 100 results is most efficiently expressed as `SORTBY 1 @foo MAX 100 LIMIT 50 50`. Removing the `MAX` from `SORTBY` results in the pipeline sorting _all_ the records and then paging over results 50-100.
+</details>
+
+<details open>
+<summary><code>FILTER {expr}</code></summary> 
+
+filters the results using predicate expressions relating to values in each result.
+  They are applied post query and relate to the current state of the pipeline.
+</details>
+
+<details open>
+<summary><code>WITHCURSOR {COUNT} {read_size} [MAXIDLE {idle_time}]</code></summary> 
+
+Scan part of the results with a quicker alternative than `LIMIT`.
+See [Cursor API]({{< relref "develop/interact/search-and-query/advanced-concepts/aggregations#cursor-api" >}}) for more details.
+</details>
+
+<details open>
+<summary><code>TIMEOUT {milliseconds}</code></summary> 
+
+if set, overrides the timeout parameter of the module.
+</details>
+
+<details open>
+<summary><code>PARAMS {nargs} {name} {value}</code></summary> 
+
+defines one or more value parameters. Each parameter has a name and a value. 
+
+You can reference parameters in the `query` by a `$`, followed by the parameter name, for example, `$user`. Each such reference in the search query to a parameter name is substituted by the corresponding parameter value. For example, with parameter definition `PARAMS 4 lon 29.69465 lat 34.95126`, the expression `@loc:[$lon $lat 10 km]` is evaluated to `@loc:[29.69465 34.95126 10 km]`. You cannot reference parameters in the query string where concrete values are not allowed, such as in field names, for example, `@loc`. To use `PARAMS`, set `DIALECT` to `2` or greater than `2`.
+</details>
+
+<details open>
+<summary><code>SCORER {scorer}</code></summary>
+
+uses a [built-in]({{< relref "/develop/interact/search-and-query/advanced-concepts/scoring" >}}) or a [user-provided]({{< relref "/develop/interact/search-and-query/administration/extensions" >}}) scoring function.
+</details>
+
+<details open>
+<summary><code>ADDSCORES</code></summary>
+
+The `ADDSCORES` option exposes the full-text score values to the aggregation pipeline.
+You can use `@__score` in a pipeline as shown in the following example:
+
+`FT.AGGREGATE idx 'hello' ADDSCORES SORTBY 2 @__score DESC`
+</details>
+
+<details open>
+<summary><code>DIALECT {dialect_version}</code></summary> 
+
+selects the dialect version under which to execute the query. If not specified, the query will execute under the default dialect version set during module initial loading or via [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) command.
+</details>
+
+## Return
+
+FT.AGGREGATE returns an array reply where each row is an array reply and represents a single aggregate result.
+The [integer reply]({{< relref "develop/reference/protocol-spec#resp-integers" >}}) at position `1` does not represent a valid value.
+
+### Return multiple values
+
+See [Return multiple values]({{< relref "commands/ft.search#return-multiple-values/" >}}) in [`FT.SEARCH`]({{< relref "commands/ft.search/" >}})
+The `DIALECT` can be specified as a parameter in the FT.AGGREGATE command. If it is not specified, the `DEFAULT_DIALECT` is used, which can be set using [`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) or by passing it as an argument to the `redisearch` module when it is loaded.
+For example, with the following document and index:
+
+
+```sh
+127.0.0.1:6379> JSON.SET doc:1 $ '[{"arr": [1, 2, 3]}, {"val": "hello"}, {"val": "world"}]'
+OK
+127.0.0.1:6379> FT.CREATE idx ON JSON PREFIX 1 doc: SCHEMA $..arr AS arr NUMERIC $..val AS val TEXT
+OK
+```
+Notice the different replies, with and without `DIALECT 3`:
+
+```sh
+127.0.0.1:6379> FT.AGGREGATE idx * LOAD 2 arr val 
+1) (integer) 1
+2) 1) "arr"
+   2) "[1,2,3]"
+   3) "val"
+   4) "hello"
+
+127.0.0.1:6379> FT.AGGREGATE idx * LOAD 2 arr val DIALECT 3
+1) (integer) 1
+2) 1) "arr"
+   2) "[[1,2,3]]"
+   3) "val"
+   4) "[\"hello\",\"world\"]"
+```
+
+## Complexity
+
+Non-deterministic. Depends on the query and aggregations performed, but it is usually linear to the number of results returned.
+
+## Examples
+
+<details open>
+<summary><b>Sort page visits by day</b></summary>
+
+Find visits to the page `about.html`, group them by the day of the visit, count the number of visits, and sort them by day.
+
+{{< highlight bash >}}
+FT.AGGREGATE idx "@url:\"about.html\""
+    APPLY "day(@timestamp)" AS day
+    GROUPBY 2 @day @country
+      REDUCE count 0 AS num_visits
+    SORTBY 4 @day
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Find most books ever published</b></summary>
+
+Find most books ever published in a single year.
+
+{{< highlight bash >}}
+FT.AGGREGATE books-idx *
+    GROUPBY 1 @published_year
+      REDUCE COUNT 0 AS num_published
+    GROUPBY 0
+      REDUCE MAX 1 @num_published AS max_books_published_per_year
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Reduce all results</b></summary>
+
+The last example used `GROUPBY 0`. Use `GROUPBY 0` to apply a `REDUCE` function over all results from the last step of an aggregation pipeline -- this works on both the  initial query and subsequent `GROUPBY` operations.
+
+Search for libraries within 10 kilometers of the longitude -73.982254 and latitude 40.753181 then annotate them with the distance between their location and those coordinates.
+
+{{< highlight bash >}}
+ FT.AGGREGATE libraries-idx "@location:[-73.982254 40.753181 10 km]"
+    LOAD 1 @location
+    APPLY "geodistance(@location, -73.982254, 40.753181)"
+{{< / highlight >}}
+
+Here, notice the required use of `LOAD` to pre-load the `@location` attribute because it is a GEO attribute.    
+
+Next, count GitHub events by user (actor), to produce the most active users.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.AGGREGATE gh "*" GROUPBY 1 @actor REDUCE COUNT 0 AS num SORTBY 2 @num DESC MAX 10
+ 1) (integer) 284784
+ 2) 1) "actor"
+    2) "lombiqbot"
+    3) "num"
+    4) "22197"
+ 3) 1) "actor"
+    2) "codepipeline-test"
+    3) "num"
+    4) "17746"
+ 4) 1) "actor"
+    2) "direwolf-github"
+    3) "num"
+    4) "10683"
+ 5) 1) "actor"
+    2) "ogate"
+    3) "num"
+    4) "6449"
+ 6) 1) "actor"
+    2) "openlocalizationtest"
+    3) "num"
+    4) "4759"
+ 7) 1) "actor"
+    2) "digimatic"
+    3) "num"
+    4) "3809"
+ 8) 1) "actor"
+    2) "gugod"
+    3) "num"
+    4) "3512"
+ 9) 1) "actor"
+    2) "xdzou"
+    3) "num"
+    4) "3216"
+[10](10)) 1) "actor"
+    2) "opstest"
+    3) "num"
+    4) "2863"
+11) 1) "actor"
+    2) "jikker"
+    3) "num"
+    4) "2794"
+(0.59s)
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) | [`FT.SEARCH`]({{< relref "commands/ft.search/" >}}) 
+
+## Related topics
+
+- [Aggregations]({{< relref "/develop/interact/search-and-query/advanced-concepts/aggregations" >}})
+- [RediSearch]({{< relref "/develop/interact/search-and-query" >}})
+
+---
+acl_categories:
+- '@bloom'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k), where k is the number of hash functions used by the last sub-filter
+description: Checks whether an item exists in a Bloom Filter
+group: bf
+hidden: false
+linkTitle: BF.EXISTS
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Checks whether an item exists in a Bloom Filter
+syntax_fmt: BF.EXISTS key item
+syntax_str: item
+title: BF.EXISTS
+---
+Determines whether a given item was added to a Bloom filter.
+
+This command is similar to [`BF.MEXISTS`]({{< relref "commands/bf.mexists/" >}}), except that only one item can be checked.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter.
+
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to check.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where `1` means that, with high probability, `item` was already added to the filter, and `0` means that `key` does not exist or that `item` had not been added to the filter.
+- [] on error (invalid arguments, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.ADD bf item1
+(integer) 1
+redis> BF.EXISTS bf item1
+(integer) 1
+redis> BF.EXISTS bf item2
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: newkey
+  key_spec_index: 1
+  name: newkey
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(1)
+description: Renames a key and overwrites the destination.
+group: generic
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- OW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: RENAME
+since: 1.0.0
+summary: Renames a key and overwrites the destination.
+syntax_fmt: RENAME key newkey
+syntax_str: newkey
+title: RENAME
+---
+Renames `key` to `newkey`.
+It returns an error when `key` does not exist.
+If `newkey` already exists it is overwritten, when this happens `RENAME` executes an implicit [`DEL`]({{< relref "/commands/del" >}}) operation, so if the deleted key contains a very big value it may cause high latency even if `RENAME` itself is usually a constant-time operation.
+
+In Cluster mode, both `key` and `newkey` must be in the same **hash slot**, meaning that in practice only keys that have the same hash tag can be reliably renamed in cluster.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+RENAME mykey myotherkey
+GET myotherkey
+{{% /redis-cli %}}
+
+
+## Behavior change history
+
+*   `>= 3.2.0`: The command no longer returns an error when source and destination names are the same.---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- arguments:
+  - display_text: async
+    name: async
+    token: ASYNC
+    type: pure-token
+  - display_text: sync
+    name: sync
+    token: SYNC
+    type: pure-token
+  name: flush-type
+  optional: true
+  since: 6.2.0
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+complexity: O(N) with N being the number of scripts in cache
+description: Removes all server-side Lua scripts from the script cache.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+history:
+- - 6.2.0
+  - Added the `ASYNC` and `SYNC` flushing mode modifiers.
+linkTitle: SCRIPT FLUSH
+since: 2.6.0
+summary: Removes all server-side Lua scripts from the script cache.
+syntax_fmt: SCRIPT FLUSH [ASYNC | SYNC]
+syntax_str: ''
+title: SCRIPT FLUSH
+---
+Flush the Lua scripts cache.
+
+By default, `SCRIPT FLUSH` will synchronously flush the cache.
+Starting with Redis 6.2, setting the **lazyfree-lazy-user-flush** configuration directive to "yes" changes the default flush mode to asynchronous.
+
+It is possible to use one of the following modifiers to dictate the flushing mode explicitly:
+
+* `ASYNC`: flushes the cache asynchronously
+* `SYNC`: flushes the cache synchronously
+
+For more information about [`EVAL`]({{< relref "/commands/eval" >}}) scripts please refer to [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}).
+
+## Behavior change history
+
+*   `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. ---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Return the vector associated with an element.
+group: vector_set
+hidden: false
+linkTitle: VEMB
+since: 8.0.0
+summary: Return the vector associated with an element.
+syntax_fmt: "VEMB key element [RAW]"
+title: VEMB
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Return the approximate vector associated with a given element in the vector set.
+
+```shell
+VEMB word_embeddings SQL
+1) "0.18208661675453186"
+2) "0.08535309880971909"
+3) "0.1365649551153183"
+4) "-0.16501599550247192"
+5) "0.14225517213344574"
+... 295 more elements ...
+```
+
+Vector sets normalize and may quantize vectors on insertion. `VEMB` reverses this process to approximate the original vector by de-normalizing and de-quantizing it.
+
+To retrieve the raw internal representation, use the `RAW` option:
+
+```shell
+VEMB word_embeddings apple RAW
+1) int8
+2) "\xf1\xdc\xfd\x1e\xcc%E...\xde\x1f\xfbN" # artificially shortened for this example
+3) "3.1426539421081543"
+4) "0.17898885905742645"
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element whose vector you want to retrieve.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>RAW</code></summary>
+
+returns the raw vector data, its quantization type, and metadata such as norm and range.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: seconds
+  name: seconds
+  type: integer
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  since: 7.0.0
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Sets the expiration time of a key in seconds.
+group: generic
+hidden: false
+history:
+- - 7.0.0
+  - 'Added options: `NX`, `XX`, `GT` and `LT`.'
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: EXPIRE
+since: 1.0.0
+summary: Sets the expiration time of a key in seconds.
+syntax_fmt: EXPIRE key seconds [NX | XX | GT | LT]
+syntax_str: seconds [NX | XX | GT | LT]
+title: EXPIRE
+---
+Set a timeout on `key`.
+After the timeout has expired, the key will automatically be deleted.
+A key with an associated timeout is often said to be _volatile_ in Redis
+terminology.
+
+The timeout will only be cleared by commands that delete or overwrite the
+contents of the key, including [`DEL`]({{< relref "/commands/del" >}}), [`SET`]({{< relref "/commands/set" >}}), [`GETSET`]({{< relref "/commands/getset" >}}) and all the `*STORE`
+commands.
+This means that all the operations that conceptually _alter_ the value stored at
+the key without replacing it with a new one will leave the timeout untouched.
+For instance, incrementing the value of a key with [`INCR`]({{< relref "/commands/incr" >}}), pushing a new value
+into a list with [`LPUSH`]({{< relref "/commands/lpush" >}}), or altering the field value of a hash with [`HSET`]({{< relref "/commands/hset" >}}) are
+all operations that will leave the timeout untouched.
+
+The timeout can also be cleared, turning the key back into a persistent key,
+using the [`PERSIST`]({{< relref "/commands/persist" >}}) command.
+
+If a key is renamed with [`RENAME`]({{< relref "/commands/rename" >}}), the associated time to live is transferred to
+the new key name.
+
+If a key is overwritten by [`RENAME`]({{< relref "/commands/rename" >}}), like in the case of an existing key `Key_A`
+that is overwritten by a call like `RENAME Key_B Key_A`, it does not matter if
+the original `Key_A` had a timeout associated or not, the new key `Key_A` will
+inherit all the characteristics of `Key_B`.
+
+Note that calling `EXPIRE`/[`PEXPIRE`]({{< relref "/commands/pexpire" >}}) with a non-positive timeout or
+[`EXPIREAT`]({{< relref "/commands/expireat" >}})/[`PEXPIREAT`]({{< relref "/commands/pexpireat" >}}) with a time in the past will result in the key being
+[deleted][del] rather than expired (accordingly, the emitted [key event][ntf]
+will be `del`, not `expired`).
+
+[del]: /commands/del
+[ntf]: /develop/use/keyspace-notifications
+
+## Options
+
+The `EXPIRE` command supports a set of options:
+
+* `NX` -- Set expiry only when the key has no expiry
+* `XX` -- Set expiry only when the key has an existing expiry
+* `GT` -- Set expiry only when the new expiry is greater than current one
+* `LT` -- Set expiry only when the new expiry is less than current one
+
+A non-volatile key is treated as an infinite TTL for the purpose of `GT` and `LT`.
+The `GT`, `LT` and `NX` options are mutually exclusive.
+
+## Refreshing expires
+
+It is possible to call `EXPIRE` using as argument a key that already has an
+existing expire set.
+In this case the time to live of a key is _updated_ to the new value.
+There are many useful applications for this, an example is documented in the
+_Navigation session_ pattern section below.
+
+## Differences in Redis prior 2.1.3
+
+In Redis versions prior **2.1.3** altering a key with an expire set using a
+command altering its value had the effect of removing the key entirely.
+This semantics was needed because of limitations in the replication layer that
+are now fixed.
+
+`EXPIRE` would return 0 and not alter the timeout for a key with a timeout set.
+
+## Examples
+
+{{< clients-example cmds_generic expire >}}
+> SET mykey "Hello"
+"OK"
+> EXPIRE mykey 10
+(integer) 1
+> TTL mykey
+(integer) 10
+> SET mykey "Hello World"
+"OK"
+> TTL mykey
+(integer) -1
+> EXPIRE mykey 10 XX
+(integer) 0
+> TTL mykey
+(integer) -1
+> EXPIRE mykey 10 NX
+(integer) 1
+> TTL mykey
+(integer) 10
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXPIRE mykey 10
+TTL mykey
+SET mykey "Hello World"
+TTL mykey
+EXPIRE mykey 10 XX
+TTL mykey
+EXPIRE mykey 10 NX
+TTL mykey
+{{% /redis-cli %}}
+
+
+## Pattern: Navigation session
+
+Imagine you have a web service and you are interested in the latest N pages
+_recently_ visited by your users, such that each adjacent page view was not
+performed more than 60 seconds after the previous.
+Conceptually you may consider this set of page views as a _Navigation session_
+of your user, that may contain interesting information about what kind of
+products he or she is looking for currently, so that you can recommend related
+products.
+
+You can easily model this pattern in Redis using the following strategy: every
+time the user does a page view you call the following commands:
+
+```
+MULTI
+RPUSH pagewviews.user:<userid> http://.....
+EXPIRE pagewviews.user:<userid> 60
+EXEC
+```
+
+If the user will be idle more than 60 seconds, the key will be deleted and only
+subsequent page views that have less than 60 seconds of difference will be
+recorded.
+
+This pattern is easily modified to use counters using [`INCR`]({{< relref "/commands/incr" >}}) instead of lists
+using [`RPUSH`]({{< relref "/commands/rpush" >}}).
+
+## Appendix: Redis expires
+
+### Keys with an expire
+
+Normally Redis keys are created without an associated time to live.
+The key will simply live forever, unless it is removed by the user in an
+explicit way, for instance using the [`DEL`]({{< relref "/commands/del" >}}) command.
+
+The `EXPIRE` family of commands is able to associate an expire to a given key,
+at the cost of some additional memory used by the key.
+When a key has an expire set, Redis will make sure to remove the key when the
+specified amount of time elapsed.
+
+The key time to live can be updated or entirely removed using the `EXPIRE` and
+[`PERSIST`]({{< relref "/commands/persist" >}}) command (or other strictly related commands).
+
+### Expire accuracy
+
+In Redis 2.4 the expire might not be pin-point accurate, and it could be between
+zero to one seconds out.
+
+Since Redis 2.6 the expire error is from 0 to 1 milliseconds.
+
+### Expires and persistence
+
+Keys expiring information is stored as absolute Unix timestamps (in milliseconds
+in case of Redis version 2.6 or greater).
+This means that the time is flowing even when the Redis instance is not active.
+
+For expires to work well, the computer time must be taken stable.
+If you move an RDB file from two computers with a big desync in their clocks,
+funny things may happen (like all the keys loaded to be expired at loading
+time).
+
+Even running instances will always check the computer clock, so for instance if
+you set a key with a time to live of 1000 seconds, and then set your computer
+time 2000 seconds in the future, the key will be expired immediately, instead of
+lasting for 1000 seconds.
+
+### How Redis expires keys
+
+Redis keys are expired in two ways: a passive way and an active way.
+
+A key is passively expired when a client tries to access it and the
+key is timed out.
+
+However, this is not enough as there are expired keys that will never be
+accessed again.
+These keys should be expired anyway, so periodically, Redis tests a few keys at
+random amongst the set of keys with an expiration.
+All the keys that are already expired are deleted from the keyspace.
+
+### How expires are handled in the replication link and AOF file
+
+In order to obtain a correct behavior without sacrificing consistency, when a
+key expires, a [`DEL`]({{< relref "/commands/del" >}}) operation is synthesized in both the AOF file and gains all
+the attached replicas nodes.
+This way the expiration process is centralized in the master instance, and there
+is no chance of consistency errors.
+
+However while the replicas connected to a master will not expire keys
+independently (but will wait for the [`DEL`]({{< relref "/commands/del" >}}) coming from the master), they'll
+still take the full state of the expires existing in the dataset, so when a
+replica is elected to master it will be able to expire the keys independently,
+fully acting as a master.
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value, where N is the number of
+  keys in the object, O(N) when path is evaluated to multiple values, where N is the
+  size of the key
+description: Returns the JSON keys of the object at path
+group: json
+hidden: false
+linkTitle: JSON.OBJKEYS
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the JSON keys of the object at path
+syntax_fmt: JSON.OBJKEYS key [path]
+syntax_str: '[path]'
+title: JSON.OBJKEYS
+---
+Return the keys in the object that's referenced by `path`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse. Returns `null` for nonexistent keys.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. Returns `null` for nonexistant path.
+
+</details>
+
+## Return
+
+JSON.OBJKEYS returns an array of array replies for each path, an array of the key names in the object as a bulk string reply, or `nil` if the matching JSON value is not an object. 
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":[3], "nested": {"a": {"b":2, "c": 1}}}'
+OK
+redis> JSON.OBJKEYS doc $..a
+1) (nil)
+2) 1) "b"
+   2) "c"
+{{< / highlight >}}
+
+## See also
+
+[`JSON.ARRINDEX`]({{< relref "commands/json.arrindex/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on how much memory is allocated, could be slow
+description: Returns the allocator statistics.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_shards
+- response_policy:special
+linkTitle: MEMORY MALLOC-STATS
+since: 4.0.0
+summary: Returns the allocator statistics.
+syntax_fmt: MEMORY MALLOC-STATS
+syntax_str: ''
+title: MEMORY MALLOC-STATS
+---
+The `MEMORY MALLOC-STATS` command provides an internal statistics report from
+the memory allocator.
+
+This command is currently implemented only when using **jemalloc** as an
+allocator, and evaluates to a benign NOOP for all others.
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: protover
+    name: protover
+    type: integer
+  - arguments:
+    - display_text: username
+      name: username
+      type: string
+    - display_text: password
+      name: password
+      type: string
+    name: auth
+    optional: true
+    token: AUTH
+    type: block
+  - display_text: clientname
+    name: clientname
+    optional: true
+    token: SETNAME
+    type: string
+  name: arguments
+  optional: true
+  type: block
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+- fast
+- no_auth
+- allow_busy
+complexity: O(1)
+description: Handshakes with the Redis server.
+group: connection
+hidden: false
+history:
+- - 6.2.0
+  - '`protover` made optional; when called without arguments the command reports the
+    current connection''s context.'
+linkTitle: HELLO
+since: 6.0.0
+summary: Handshakes with the Redis server.
+syntax_fmt: "HELLO [protover [AUTH\_username password] [SETNAME\_clientname]]"
+syntax_str: ''
+title: HELLO
+---
+Switch to a different protocol, optionally authenticating and setting the
+connection's name, or provide a contextual client report.
+
+Redis version 6 and above supports two protocols: the old protocol, RESP2, and
+a new one introduced with Redis 6, RESP3. RESP3 has certain advantages since
+when the connection is in this mode, Redis is able to reply with more semantical
+replies: for instance, [`HGETALL`]({{< relref "/commands/hgetall" >}}) will return a *map type*, so a client library
+implementation no longer requires to know in advance to translate the array into
+a hash before returning it to the caller. For a full coverage of RESP3, please
+check the [RESP3 specification](https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md).
+
+In Redis 6 connections start in RESP2 mode, so clients implementing RESP2 do
+not need to updated or changed. There are no short term plans to drop support for
+RESP2, although future version may default to RESP3.
+
+`HELLO` always replies with a list of current server and connection properties,
+such as: versions, modules loaded, client ID, replication role and so forth.
+When called without any arguments in Redis 6.2 and its default use of RESP2
+protocol, the reply looks like this:
+
+    > HELLO
+     1) "server"
+     2) "redis"
+     3) "version"
+     4) "255.255.255"
+     5) "proto"
+     6) (integer) 2
+     7) "id"
+     8) (integer) 5
+     9) "mode"
+    10) "standalone"
+    11) "role"
+    12) "master"
+    13) "modules"
+    14) (empty array)
+
+Clients that want to handshake using the RESP3 mode need to call the `HELLO`
+command and specify the value "3" as the `protover` argument, like so:
+
+    > HELLO 3
+    1# "server" => "redis"
+    2# "version" => "6.0.0"
+    3# "proto" => (integer) 3
+    4# "id" => (integer) 10
+    5# "mode" => "standalone"
+    6# "role" => "master"
+    7# "modules" => (empty array)
+
+Because `HELLO` replies with useful information, and given that `protover` is
+optional or can be set to "2", client library authors may consider using this
+command instead of the canonical [`PING`]({{< relref "/commands/ping" >}}) when setting up the connection.
+
+When called with the optional `protover` argument, this command switches the
+protocol to the specified version and also accepts the following options:
+
+* `AUTH <username> <password>`: directly authenticate the connection in addition to switching to the specified protocol version. This makes calling [`AUTH`]({{< relref "/commands/auth" >}}) before `HELLO` unnecessary when setting up a new connection. Note that the `username` can be set to "default" to authenticate against a server that does not use ACLs, but rather the simpler `requirepass` mechanism of Redis prior to version 6.
+* `SETNAME <clientname>`: this is the equivalent of calling [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}}).
+---
+acl_categories:
+- '@cms'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information about a sketch
+group: cms
+hidden: false
+linkTitle: CMS.INFO
+module: Bloom
+since: 2.0.0
+stack_path: docs/data-types/probabilistic
+summary: Returns information about a sketch
+syntax_fmt: CMS.INFO key
+syntax_str: ''
+title: CMS.INFO
+---
+Returns width, depth and total count of the sketch.
+
+### Parameters:
+
+* **key**: The name of the sketch.
+
+## Return
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with information of the filter.
+
+## Examples
+
+```
+redis> CMS.INFO test
+ 1) width
+ 2) (integer) 2000
+ 3) depth
+ 4) (integer) 7
+ 5) count
+ 6) (integer) 0
+```
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: seconds
+    name: seconds
+    token: EX
+    type: integer
+  - display_text: milliseconds
+    name: milliseconds
+    token: PX
+    type: integer
+  - display_text: unix-time-seconds
+    name: unix-time-seconds
+    token: EXAT
+    type: unix-time
+  - display_text: unix-time-milliseconds
+    name: unix-time-milliseconds
+    token: PXAT
+    type: unix-time
+  - display_text: persist
+    name: persist
+    token: PERSIST
+    type: pure-token
+  name: expiration
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Get the value of one or more fields of a given hash key, and optionally
+  set their expiration.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  notes: RW and UPDATE because it changes the TTL
+  update: true
+linkTitle: HGETEX
+since: 8.0.0
+summary: Get the value of one or more fields of a given hash key, and optionally set
+  their expiration.
+syntax_fmt: "HGETEX key [EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds\
+  \ |\n  PXAT\_unix-time-milliseconds | PERSIST] FIELDS\_numfields field\n  [field\
+  \ ...]"
+syntax_str: "[EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds | PXAT\_unix-time-milliseconds\
+  \ | PERSIST] FIELDS\_numfields field [field ...]"
+title: HGETEX
+---
+
+Get the value of one or more fields of a given hash key and optionally set their expiration time or time-to-live (TTL).
+
+## Options
+
+The `HGETEX` command supports a set of options:
+
+* `EX seconds` -- Set the specified expiration time, in seconds.
+* `PX milliseconds` -- Set the specified expiration time, in milliseconds.
+* `EXAT unix-time-seconds` -- Set the specified Unix time at which the fields will expire, in seconds.
+* `PXAT unix-time-milliseconds` -- Set the specified Unix time at which the fields will expire, in milliseconds.
+* `PERSIST` -- Remove the TTL associated with the fields.
+
+The `EX`, `PX`, `EXAT`, `PXAT`, and `PERSIST` options are mutually exclusive.
+
+## Example
+
+```
+redis> HSET mykey field1 "Hello" field2 "World"
+(integer) 2
+redis> HGETEX mykey EX 120 FIELDS 1 field1
+1) "Hello"
+redis> HGETEX mykey EX 100 FIELDS 1 field2
+1) "World"
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 91
+2) (integer) 85
+redis> HTTL mykey FIELDS 3 field1 field2 field3 
+1) (integer) 75
+2) (integer) 68
+3) (integer) -2
+...
+redis> HTTL mykey FIELDS 3 field1 field2 
+1) (integer) -2
+2) (integer) -2
+redis> HGETALL mykey
+(empty array)
+```
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: unix-time-milliseconds
+  name: unix-time-milliseconds
+  type: unix-time
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  since: 7.0.0
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Sets the expiration time of a key to a Unix milliseconds timestamp.
+group: generic
+hidden: false
+history:
+- - 7.0.0
+  - 'Added options: `NX`, `XX`, `GT` and `LT`.'
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: PEXPIREAT
+since: 2.6.0
+summary: Sets the expiration time of a key to a Unix milliseconds timestamp.
+syntax_fmt: PEXPIREAT key unix-time-milliseconds [NX | XX | GT | LT]
+syntax_str: unix-time-milliseconds [NX | XX | GT | LT]
+title: PEXPIREAT
+---
+`PEXPIREAT` has the same effect and semantic as [`EXPIREAT`]({{< relref "/commands/expireat" >}}), but the Unix time at
+which the key will expire is specified in milliseconds instead of seconds.
+
+## Options
+
+The `PEXPIREAT` command supports a set of options since Redis 7.0:
+
+* `NX` -- Set expiry only when the key has no expiry
+* `XX` -- Set expiry only when the key has an existing expiry
+* `GT` -- Set expiry only when the new expiry is greater than current one
+* `LT` -- Set expiry only when the new expiry is less than current one
+
+A non-volatile key is treated as an infinite TTL for the purpose of `GT` and `LT`.
+The `GT`, `LT` and `NX` options are mutually exclusive.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+PEXPIREAT mykey 1555555555005
+TTL mykey
+PTTL mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns a list of the consumers in a consumer group.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 7.2.0
+  - Added the `inactive` field, and changed the meaning of `idle`.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XINFO CONSUMERS
+since: 5.0.0
+summary: Returns a list of the consumers in a consumer group.
+syntax_fmt: XINFO CONSUMERS key group
+syntax_str: group
+title: XINFO CONSUMERS
+---
+This command returns the list of consumers that belong to the `<groupname>` consumer group of the stream stored at `<key>`.
+
+The following information is provided for each consumer in the group:
+
+* **name**: the consumer's name
+* **pending**: the number of entries in the PEL: pending messages for the consumer, which are messages that were delivered but are yet to be acknowledged
+* **idle**: the number of milliseconds that have passed since the consumer's last attempted interaction (Examples: [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), [`XCLAIM`]({{< relref "/commands/xclaim" >}}), [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}))
+* **inactive**: the number of milliseconds that have passed since the consumer's last successful interaction (Examples: [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) that actually read some entries into the PEL, [`XCLAIM`]({{< relref "/commands/xclaim" >}})/[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) that actually claimed some entries)
+
+Note that before Redis 7.2.0, **idle** used to denote the time passed since last successful interaction.
+In 7.2.0, **inactive** was added and **idle** was changed to denote the time passed since last attempted interaction.
+
+## Examples
+
+```
+> XINFO CONSUMERS mystream mygroup
+1) 1) name
+   2) "Alice"
+   3) pending
+   4) (integer) 1
+   5) idle
+   6) (integer) 9104628
+   7) inactive
+   8) (integer) 18104698
+2) 1) name
+   2) "Bob"
+   3) pending
+   4) (integer) 1
+   5) idle
+   6) (integer) 83841983
+   7) inactive
+   8) (integer) 993841998
+```
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(log(N)) for each element removed, where N is the number of elements in the vector set.
+description: Remove one or more elements from a vector set.
+group: vector_set
+hidden: false
+linkTitle: VREM
+since: 8.0.0
+summary: Remove one or more elements from a vector set.
+syntax_fmt: "VREM key element"
+title: VREM
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Remove an element from a vector set.
+
+```shell
+VADD vset VALUES 3 1 0 1 bar
+(integer) 1
+```
+
+```shell
+VREM vset bar
+(integer) 1
+```
+
+```shell
+VREM vset bar
+(integer) 0
+```
+
+`VREM` reclaims memory immediately. It does not use tombstones or logical deletions, making it safe to use in long-running applications that frequently update the same vector set.
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that holds the vector set.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element to remove from the vector set.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the total number of Redis commands
+description: Returns detailed information about all commands.
+group: server
+hidden: false
+hints:
+- nondeterministic_output_order
+linkTitle: COMMAND
+since: 2.8.13
+summary: Returns detailed information about all commands.
+syntax_fmt: COMMAND
+syntax_str: ''
+title: COMMAND
+---
+Return an array with details about every Redis command.
+
+The `COMMAND` command is introspective.
+Its reply describes all commands that the server can process.
+Redis clients can call it to obtain the server's runtime capabilities during the handshake.
+
+`COMMAND` also has several subcommands.
+Please refer to its subcommands for further details.
+
+**Cluster note:**
+this command is especially beneficial for cluster-aware clients.
+Such clients must identify the names of keys in commands to route requests to the correct shard.
+Although most commands accept a single key as their first argument, there are many exceptions to this rule. 
+You can call `COMMAND` and then keep the mapping between commands and their respective key specification rules cached in the client.
+
+The reply it returns is an array with an element per command.
+Each element that describes a Redis command is represented as an array by itself.
+
+The command's array consists of a fixed number of elements.
+The exact number of elements in the array depends on the server's version.
+
+1. Name
+1. Arity
+1. Flags
+1. First key
+1. Last key
+1. Step
+1. [ACL categories][ta] (as of Redis 6.0)
+1. [Tips][tb] (as of Redis 7.0)
+1. [Key specifications][td] (as of Redis 7.0)
+1. Subcommands (as of Redis 7.0)
+
+## Name
+
+This is the command's name in lowercase.
+
+**Note:**
+Redis command names are case-insensitive.
+
+## Arity
+
+Arity is the number of arguments a command expects.
+It follows a simple pattern:
+
+* A positive integer means a fixed number of arguments.
+* A negative integer means a minimal number of arguments.
+
+Command arity _always includes_ the command's name itself (and the subcommand when applicable).
+
+Examples:
+
+* [`GET`]({{< relref "/commands/get" >}})'s arity is _2_ since the command only accepts one argument and always has the format `GET _key_`.
+* [`MGET`]({{< relref "/commands/mget" >}})'s arity is _-2_ since the command accepts at least one argument, but possibly multiple ones: `MGET _key1_ [key2] [key3] ...`.
+
+## Flags
+
+Command flags are an array. It can contain the following simple strings (status reply):
+
+* **admin:** the command is an administrative command.
+* **asking:** the command is allowed even during hash slot migration.
+  This flag is relevant in Redis Cluster deployments.
+* **blocking:** the command may block the requesting client.
+* **denyoom**: the command is rejected if the server's memory usage is too high (see the _maxmemory_ configuration directive).
+* **fast:** the command operates in constant or log(N) time.
+  This flag is used for monitoring latency with the [`LATENCY`]({{< relref "/commands/latency" >}}) command.
+* **loading:** the command is allowed while the database is loading.
+* **movablekeys:** the _first key_, _last key_, and _step_ values don't determine all key positions.
+  Clients need to use [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) or [key specifications][td] in this case.
+  See below for more details.
+* **no_auth:** executing the command doesn't require authentication.
+* **no_async_loading:** the command is denied during asynchronous loading (that is when a replica uses disk-less `SWAPDB SYNC`, and allows access to the old dataset).
+* **no_mandatory_keys:** the command may accept key name arguments, but these aren't mandatory.
+* **no_multi:** the command isn't allowed inside the context of a [transaction]({{< relref "/develop/interact/transactions" >}}).
+* **noscript:** the command can't be called from [scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) or [functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+* **pubsub:** the command is related to [Redis Pub/Sub]({{< relref "/develop/interact/pubsub" >}}).
+* **random**: the command returns random results, which is a concern with verbatim script replication.
+  As of Redis 7.0, this flag is a [command tip][tb].
+* **readonly:** the command doesn't modify data.
+* **sort_for_script:** the command's output is sorted when called from a script.
+* **skip_monitor:** the command is not shown in [`MONITOR`]({{< relref "/commands/monitor" >}})'s output.
+* **skip_slowlog:** the command is not shown in [`SLOWLOG`]({{< relref "/commands/slowlog" >}})'s output.
+  As of Redis 7.0, this flag is a [command tip][tb].
+* **stale:** the command is allowed while a replica has stale data.
+* **write:** the command may modify data.
+
+### Movablekeys
+
+Consider [`SORT`]({{< relref "/commands/sort" >}}):
+
+```
+1) 1) "sort"
+   2) (integer) -2
+   3) 1) write
+      2) denyoom
+      3) movablekeys
+   4) (integer) 1
+   5) (integer) 1
+   6) (integer) 1
+   ...
+```
+
+Some Redis commands have no predetermined key locations or are not easy to find.
+For those commands, the _movablekeys_ flag indicates that the _first key_, _last key_, and _step_ values are insufficient to find all the keys.
+
+Here are several examples of commands that have the _movablekeys_ flag:
+
+* [`SORT`]({{< relref "/commands/sort" >}}): the optional _STORE_, _BY_, and _GET_ modifiers are followed by names of keys.
+* [`ZUNION`]({{< relref "/commands/zunion" >}}): the _numkeys_ argument specifies the number key name arguments.
+* [`MIGRATE`]({{< relref "/commands/migrate" >}}): the keys appear _KEYS_ keyword and only when the second argument is the empty string.
+
+Redis Cluster clients need to use other measures, as follows, to locate the keys for such commands.
+
+You can use the [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) command and have your Redis server report all keys of a given command's invocation.
+
+As of Redis 7.0, clients can use the [key specifications](#key-specifications) to identify the positions of key names.
+The only commands that require using [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) are [`SORT`]({{< relref "/commands/sort" >}}) and [`MIGRATE`]({{< relref "/commands/migrate" >}}) for clients that parse keys' specifications.
+
+For more information, please refer to the [key specifications page][tr].
+
+## First key
+
+The position of the command's first key name argument.
+For most commands, the first key's position is 1.
+Position 0 is always the command name itself.
+
+## Last key
+
+The position of the command's last key name argument.
+Redis commands usually accept one, two or multiple number of keys.
+
+Commands that accept a single key have both _first key_ and _last key_ set to 1.
+
+Commands that accept two key name arguments, e.g. [`BRPOPLPUSH`]({{< relref "/commands/brpoplpush" >}}), [`SMOVE`]({{< relref "/commands/smove" >}}) and [`RENAME`]({{< relref "/commands/rename" >}}), have this value set to the position of their second key.
+
+Multi-key commands that accept an arbitrary number of keys, such as [`MSET`]({{< relref "/commands/mset" >}}), use the value -1.
+
+## Step
+
+The step, or increment, between the _first key_ and the position of the next key.
+
+Consider the following two examples:
+
+```
+1) 1) "mset"
+   2) (integer) -3
+   3) 1) write
+      2) denyoom
+   4) (integer) 1
+   5) (integer) -1
+   6) (integer) 2
+   ...
+```
+
+```
+1) 1) "mget"
+   2) (integer) -2
+   3) 1) readonly
+      2) fast
+   4) (integer) 1
+   5) (integer) -1
+   6) (integer) 1
+   ...
+```
+
+The step count allows us to find keys' positions. 
+For example [`MSET`]({{< relref "/commands/mset" >}}): Its syntax is `MSET _key1_ _val1_ [key2] [val2] [key3] [val3]...`, so the keys are at every other position (step value of _2_).
+Unlike [`MGET`]({{< relref "/commands/mget" >}}), which uses a step value of _1_.
+
+## ACL categories
+
+This is an array of simple strings that are the ACL categories to which the command belongs.
+Please refer to the [Access Control List][ta] page for more information.
+
+## Command tips
+
+Helpful information about the command.
+To be used by clients/proxies.
+
+Please check the [Command tips][tb] page for more information.
+
+## Key specifications
+
+This is an array consisting of the command's key specifications.
+Each element in the array is a map describing a method for locating keys in the command's arguments.
+
+For more information please check the [key specifications page][td].
+
+## Subcommands
+
+This is an array containing all of the command's subcommands, if any.
+Some Redis commands have subcommands (e.g., the `REWRITE` subcommand of [`CONFIG`]({{< relref "/commands/config" >}})).
+Each element in the array represents one subcommand and follows the same specifications as those of `COMMAND`'s reply.
+
+[ta]: /operate/oss_and_stack/management/security/acl
+[tb]: /develop/reference/command-tips.md
+[td]: /develop/reference/key-specs.md
+[tr]: /develop/reference/key-specs.md
+
+## Examples
+
+The following is `COMMAND`'s output for the [`GET`]({{< relref "/commands/get" >}}) command:
+
+```
+1)  1) "get"
+    2) (integer) 2
+    3) 1) readonly
+       2) fast
+    4) (integer) 1
+    5) (integer) 1
+    6) (integer) 1
+    7) 1) @read
+       2) @string
+       3) @fast
+    8) (empty array)
+    9) 1) 1) "flags"
+          2) 1) read
+          3) "begin_search"
+          4) 1) "type"
+             2) "index"
+             3) "spec"
+             4) 1) "index"
+                2) (integer) 1
+          5) "find_keys"
+          6) 1) "type"
+             2) "range"
+             3) "spec"
+             4) 1) "lastkey"
+                2) (integer) 0
+                3) "keystep"
+                4) (integer) 1
+                5) "limit"
+                6) (integer) 0
+   10) (empty array)
+...
+```
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+- display_text: weight
+  multiple: true
+  name: weight
+  optional: true
+  token: WEIGHTS
+  type: integer
+- arguments:
+  - display_text: sum
+    name: sum
+    token: SUM
+    type: pure-token
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: aggregate
+  optional: true
+  token: AGGREGATE
+  type: oneof
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted
+  sets, and M being the number of elements in the resulting sorted set.
+description: Stores the union of multiple sorted sets in a key.
+group: sorted-set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZUNIONSTORE
+since: 2.0.0
+summary: Stores the union of multiple sorted sets in a key.
+syntax_fmt: "ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS\_weight\n  [weight\
+  \ ...]] [AGGREGATE\_<SUM | MIN | MAX>]"
+syntax_str: "numkeys key [key ...] [WEIGHTS\_weight [weight ...]] [AGGREGATE\_<SUM\
+  \ | MIN | MAX>]"
+title: ZUNIONSTORE
+---
+Computes the union of `numkeys` sorted sets given by the specified keys, and
+stores the result in `destination`.
+It is mandatory to provide the number of input keys (`numkeys`) before passing
+the input keys and the other (optional) arguments.
+
+By default, the resulting score of an element is the sum of its scores in the
+sorted sets where it exists.
+
+Using the `WEIGHTS` option, it is possible to specify a multiplication factor
+for each input sorted set.
+This means that the score of every element in every input sorted set is
+multiplied by this factor before being passed to the aggregation function.
+When `WEIGHTS` is not given, the multiplication factors default to `1`.
+
+With the `AGGREGATE` option, it is possible to specify how the results of the
+union are aggregated.
+This option defaults to `SUM`, where the score of an element is summed across
+the inputs where it exists.
+When this option is set to either `MIN` or `MAX`, the resulting set will contain
+the minimum or maximum score of an element across the inputs where it exists.
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZADD zset2 3 "three"
+ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3
+ZRANGE out 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arguments:
+- arguments:
+  - display_text: normal
+    name: normal
+    token: NORMAL
+    type: pure-token
+  - display_text: master
+    name: master
+    token: MASTER
+    type: pure-token
+  - display_text: replica
+    name: replica
+    token: REPLICA
+    type: pure-token
+  - display_text: pubsub
+    name: pubsub
+    token: PUBSUB
+    type: pure-token
+  name: client-type
+  optional: true
+  since: 5.0.0
+  token: TYPE
+  type: oneof
+- display_text: client-id
+  multiple: true
+  name: client-id
+  optional: true
+  since: 6.2.0
+  token: ID
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of client connections
+description: Lists open connections.
+group: connection
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 2.8.12
+  - Added unique client `id` field.
+- - 5.0.0
+  - Added optional `TYPE` filter.
+- - 6.0.0
+  - Added `user` field.
+- - 6.2.0
+  - Added `argv-mem`, `tot-mem`, `laddr` and `redir` fields and the optional `ID`
+    filter.
+- - 7.0.0
+  - Added `resp`, `multi-mem`, `rbs` and `rbp` fields.
+- - 7.0.3
+  - Added `ssub` field.
+linkTitle: CLIENT LIST
+since: 2.4.0
+summary: Lists open connections.
+syntax_fmt: "CLIENT LIST [TYPE\_<NORMAL | MASTER | REPLICA | PUBSUB>]\n  [ID\_client-id\
+  \ [client-id ...]]"
+syntax_str: "[ID\_client-id [client-id ...]]"
+title: CLIENT LIST
+---
+The `CLIENT LIST` command returns information and statistics about the client
+connections server in a mostly human readable format.
+
+You can use one of the optional subcommands to filter the list. The `TYPE type` subcommand filters the list by clients' type, where *type* is one of `normal`, `master`, `replica`, and `pubsub`. Note that clients blocked by the [`MONITOR`]({{< relref "/commands/monitor" >}}) command belong to the `normal` class.
+
+The `ID` filter only returns entries for clients with IDs matching the `client-id` arguments.
+
+Here is the meaning of the fields:
+
+* `id`: a unique 64-bit client ID
+* `addr`: address/port of the client
+* `laddr`: address/port of local address client connected to (bind address)
+* `fd`: file descriptor corresponding to the socket
+* `name`: the name set by the client with [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}})
+* `age`: total duration of the connection in seconds
+* `idle`: idle time of the connection in seconds
+* `flags`: client flags (see below)
+* `db`: current database ID
+* `sub`: number of channel subscriptions
+* `psub`: number of pattern matching subscriptions
+* `ssub`: number of shard channel subscriptions. Added in Redis 7.0.3
+* `multi`: number of commands in a MULTI/EXEC context
+* `watch`: number of keys this client is currently watching. Added in Redis 7.4
+* `qbuf`: query buffer length (0 means no query pending)
+* `qbuf-free`: free space of the query buffer (0 means the buffer is full)
+* `argv-mem`: incomplete arguments for the next command (already extracted from query buffer)
+* `multi-mem`: memory is used up by buffered multi commands. Added in Redis 7.0
+* `obl`: output buffer length
+* `oll`: output list length (replies are queued in this list when the buffer is full)
+* `omem`: output buffer memory usage
+* `tot-mem`: total memory consumed by this client in its various buffers
+* `events`: file descriptor events (see below)
+* `cmd`: last command played
+* `user`: the authenticated username of the client
+* `redir`: client id of current client tracking redirection
+* `resp`: client RESP protocol version. Added in Redis 7.0
+* `rbp`: peak size of the client's read buffer since the client connected. Added in Redis 7.0
+* `rbs`: current size of the client's read buffer in bytes. Added in Redis 7.0
+* `io-thread`: id of I/O thread assigned to the client. Added in Redis 8.0
+* `tot-net-in`: total network input bytes read from this client.
+* `tot-net-out`: total network output bytes sent to this client.
+* `tot-cmds`: total count of commands this client executed.
+
+The client flags can be a combination of:
+
+```
+A: connection to be closed ASAP
+b: the client is waiting in a blocking operation
+c: connection to be closed after writing entire reply
+d: a watched keys has been modified - EXEC will fail
+e: the client is excluded from the client eviction mechanism
+i: the client is waiting for a VM I/O (deprecated)
+M: the client is a master
+N: no specific flag set
+O: the client is a client in MONITOR mode
+P: the client is a Pub/Sub subscriber
+r: the client is in readonly mode against a cluster node
+S: the client is a replica node connection to this instance
+u: the client is unblocked
+U: the client is connected via a Unix domain socket
+x: the client is in a MULTI/EXEC context
+t: the client enabled keys tracking in order to perform client side caching
+T: the client will not touch the LRU/LFU of the keys it accesses
+R: the client tracking target client is invalid
+B: the client enabled broadcast tracking mode 
+```
+
+The file descriptor events can be:
+
+```
+r: the client socket is readable (event loop)
+w: the client socket is writable (event loop)
+```
+
+## Notes
+
+New fields are regularly added for debugging purpose. Some could be removed
+in the future. A version safe Redis client using this command should parse
+the output accordingly (i.e. handling gracefully missing fields, skipping
+unknown fields).
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the length of the value of a field.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HSTRLEN
+since: 3.2.0
+summary: Returns the length of the value of a field.
+syntax_fmt: HSTRLEN key field
+syntax_str: field
+title: HSTRLEN
+---
+Returns the string length of the value associated with `field` in the hash stored at `key`. If the `key` or the `field` do not exist, 0 is returned.
+
+## Examples
+
+{{% redis-cli %}}
+HSET myhash f1 HelloWorld f2 99 f3 -256
+HSTRLEN myhash f1
+HSTRLEN myhash f2
+HSTRLEN myhash f3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arguments:
+- display_text: timeout
+  name: timeout
+  type: integer
+- arguments:
+  - display_text: write
+    name: write
+    token: WRITE
+    type: pure-token
+  - display_text: all
+    name: all
+    token: ALL
+    type: pure-token
+  name: mode
+  optional: true
+  since: 6.2.0
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Suspends commands processing.
+group: connection
+hidden: false
+history:
+- - 6.2.0
+  - '`CLIENT PAUSE WRITE` mode added along with the `mode` option.'
+linkTitle: CLIENT PAUSE
+since: 3.0.0
+summary: Suspends commands processing.
+syntax_fmt: CLIENT PAUSE timeout [WRITE | ALL]
+syntax_str: '[WRITE | ALL]'
+title: CLIENT PAUSE
+---
+`CLIENT PAUSE` is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds).
+
+The command performs the following actions:
+
+* It stops processing all the pending commands from normal and pub/sub clients for the given mode. However interactions with replicas will continue normally. Note that clients are formally paused when they try to execute a command, so no work is taken on the server side for inactive clients.
+* However it returns OK to the caller ASAP, so the `CLIENT PAUSE` command execution is not paused by itself.
+* When the specified amount of time has elapsed, all the clients are unblocked: this will trigger the processing of all the commands accumulated in the query buffer of every client during the pause.
+
+Client pause currently supports two modes:
+
+* `ALL`: This is the default mode. All client commands are blocked.
+* `WRITE`: Clients are only blocked if they attempt to execute a write command.
+
+For the `WRITE` mode, some commands have special behavior:
+
+* [`EVAL`]({{< relref "/commands/eval" >}})/[`EVALSHA`]({{< relref "/commands/evalsha" >}}): Will block client for all scripts.
+* [`PUBLISH`]({{< relref "/commands/publish" >}}): Will block client.
+* [`PFCOUNT`]({{< relref "/commands/pfcount" >}}): Will block client.
+* [`WAIT`]({{< relref "/commands/wait" >}}): Acknowledgments will be delayed, so this command will appear blocked.
+
+This command is useful as it makes able to switch clients from a Redis instance to another one in a controlled way. For example during an instance upgrade the system administrator could do the following:
+
+* Pause the clients using `CLIENT PAUSE`
+* Wait a few seconds to make sure the replicas processed the latest replication stream from the master.
+* Turn one of the replicas into a master.
+* Reconfigure clients to connect with the new master.
+
+Since Redis 6.2, the recommended mode for client pause is `WRITE`. This mode will stop all replication traffic, can be
+aborted with the [`CLIENT UNPAUSE`]({{< relref "/commands/client-unpause" >}}) command, and allows reconfiguring the old master without risking accepting writes after the
+failover. This is also the mode used during cluster failover.
+
+For versions before 6.2, it is possible to send `CLIENT PAUSE` in a MULTI/EXEC block together with the `INFO replication` command in order to get the current master offset at the time the clients are blocked. This way it is possible to wait for a specific offset in the replica side in order to make sure all the replication stream was processed.
+
+Since Redis 3.2.10 / 4.0.0, this command also prevents keys to be evicted or
+expired during the time clients are paused. This way the dataset is guaranteed
+to be static not just from the point of view of clients not being able to write, but also from the point of view of internal operations.
+
+## Behavior change history
+
+*   `>= 3.2.0`: Client pause prevents client pause and key eviction as well.---
+acl_categories:
+- '@read'
+- '@hash'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the size of the hash.
+description: Returns all fields and values in a hash.
+group: hash
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HGETALL
+since: 2.0.0
+summary: Returns all fields and values in a hash.
+syntax_fmt: HGETALL key
+syntax_str: ''
+title: HGETALL
+---
+Returns all fields and values of the hash stored at `key`.
+In the returned value, every field name is followed by its value, so the length
+of the reply is twice the size of the hash.
+
+## Examples
+
+{{< clients-example cmds_hash hgetall >}}
+redis> HSET myhash field1 "Hello"
+(integer) 1
+redis> HSET myhash field2 "World"
+(integer) 1
+redis> HGETALL myhash
+1) "field1"
+2) "Hello"
+3) "field2"
+4) "World"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HSET myhash field2 "World"
+HGETALL myhash
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+- display_text: radius
+  name: radius
+  type: double
+- arguments:
+  - display_text: m
+    name: m
+    token: M
+    type: pure-token
+  - display_text: km
+    name: km
+    token: KM
+    type: pure-token
+  - display_text: ft
+    name: ft
+    token: FT
+    type: pure-token
+  - display_text: mi
+    name: mi
+    token: MI
+    type: pure-token
+  name: unit
+  type: oneof
+- display_text: withcoord
+  name: withcoord
+  optional: true
+  token: WITHCOORD
+  type: pure-token
+- display_text: withdist
+  name: withdist
+  optional: true
+  token: WITHDIST
+  type: pure-token
+- display_text: withhash
+  name: withhash
+  optional: true
+  token: WITHHASH
+  type: pure-token
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: key
+    key_spec_index: 1
+    name: storekey
+    token: STORE
+    type: key
+  - display_text: key
+    key_spec_index: 2
+    name: storedistkey
+    token: STOREDIST
+    type: key
+  name: store
+  optional: true
+  type: oneof
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(N+log(M)) where N is the number of elements inside the bounding box
+  of the circular area delimited by center and radius and M is the number of items
+  inside the index.
+deprecated_since: 6.2.0
+description: Queries a geospatial index for members within a distance from a member,
+  optionally stores the result.
+doc_flags:
+- deprecated
+group: geo
+hidden: false
+history:
+- - 6.2.0
+  - Added the `ANY` option for `COUNT`.
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+- OW: true
+  begin_search:
+    spec:
+      keyword: STORE
+      startfrom: 5
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- OW: true
+  begin_search:
+    spec:
+      keyword: STOREDIST
+      startfrom: 5
+    type: keyword
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: GEORADIUSBYMEMBER
+replaced_by: '[`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) and [`GEOSEARCHSTORE`]({{<
+  relref "/commands/geosearchstore" >}}) with the `BYRADIUS` and `FROMMEMBER` arguments'
+since: 3.2.0
+summary: Queries a geospatial index for members within a distance from a member, optionally
+  stores the result.
+syntax_fmt: "GEORADIUSBYMEMBER key member radius <M | KM | FT | MI> [WITHCOORD]\n\
+  \  [WITHDIST] [WITHHASH] [COUNT\_count [ANY]] [ASC | DESC] [STORE\_key\n  | STOREDIST\_\
+  key]"
+syntax_str: "member radius <M | KM | FT | MI> [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT\_\
+  count [ANY]] [ASC | DESC] [STORE\_key | STOREDIST\_key]"
+title: GEORADIUSBYMEMBER
+---
+This command is exactly like [`GEORADIUS`]({{< relref "/commands/georadius" >}}) with the sole difference that instead
+of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
+
+The position of the specified member is used as the center of the query.
+
+Please check the example below and the [`GEORADIUS`]({{< relref "/commands/georadius" >}}) documentation for more information about the command and its options.
+
+Note that [`GEORADIUSBYMEMBER_RO`]({{< relref "/commands/georadiusbymember_ro" >}}) is also available since Redis 3.2.10 and Redis 4.0.0 in order to provide a read-only command that can be used in replicas. See the [`GEORADIUS`]({{< relref "/commands/georadius" >}}) page for more information.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.583333 37.316667 "Agrigento"
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEORADIUSBYMEMBER Sicily Agrigento 100 km
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: script
+  name: script
+  type: string
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  optional: true
+  type: key
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- stale
+- skip_monitor
+- no_mandatory_keys
+- movablekeys
+complexity: Depends on the script that is executed.
+description: Executes a server-side Lua script.
+group: scripting
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+  notes: We cannot tell how the keys will be used so we assume the worst, RW and UPDATE
+  update: true
+linkTitle: EVAL
+since: 2.6.0
+summary: Executes a server-side Lua script.
+syntax_fmt: EVAL script numkeys [key [key ...]] [arg [arg ...]]
+syntax_str: numkeys [key [key ...]] [arg [arg ...]]
+title: EVAL
+---
+Invoke the execution of a server-side Lua script.
+
+The first argument is the script's source code.
+Scripts are written in [Lua](https://lua.org) and executed by the embedded [Lua 5.1]({{< relref "develop/interact/programmability/lua-api" >}}) interpreter in Redis.
+
+The second argument is the number of input key name arguments, followed by all the keys accessed by the script.
+These names of input keys are available to the script as the [_KEYS_ global runtime variable]({{< relref "develop/interact/programmability/lua-api#the-keys-global-variable" >}})
+Any additional input arguments **should not** represent names of keys.
+
+**Important:**
+to ensure the correct execution of scripts, both in standalone and clustered deployments, all names of keys that a script accesses must be explicitly provided as input key arguments.
+The script **should only** access keys whose names are given as input arguments.
+Scripts **should never** access keys with programmatically-generated names or based on the contents of data structures stored in the database.
+
+**Note:**
+in some cases, users will abuse Lua EVAL by embedding values in the script instead of providing them as argument, and thus generating a different script on each call to EVAL.
+These are added to the Lua interpreter and cached to redis-server, consuming a large amount of memory over time.
+Starting from Redis 7.4, scripts loaded with `EVAL` or [`EVAL_RO`]({{< relref "/commands/eval_ro" >}}) will be deleted from redis after a certain number (least recently used order).
+The number of evicted scripts can be viewed through [`INFO`]({{< relref "/commands/info" >}})'s `evicted_scripts`.
+
+Please refer to the [Redis Programmability]({{< relref "/develop/interact/programmability/" >}}) and [Introduction to Eval Scripts]({{< relref "/develop/interact/programmability/eval-intro" >}}) for more information about Lua scripts.
+
+## Examples
+
+The following example will run a script that returns the first argument that it gets.
+
+```
+> EVAL "return ARGV[1]" 0 hello
+"hello"
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: username
+  name: username
+  type: string
+- display_text: rule
+  multiple: true
+  name: rule
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N). Where N is the number of rules provided.
+description: Creates and modifies an ACL user and its rules.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+history:
+- - 6.2.0
+  - Added Pub/Sub channel patterns.
+- - 7.0.0
+  - Added selectors and key based permissions.
+linkTitle: ACL SETUSER
+since: 6.0.0
+summary: Creates and modifies an ACL user and its rules.
+syntax_fmt: ACL SETUSER username [rule [rule ...]]
+syntax_str: '[rule [rule ...]]'
+title: ACL SETUSER
+---
+Create an ACL user with the specified rules or modify the rules of an
+existing user. 
+
+Manipulate Redis ACL users interactively.
+If the username does not exist, the command creates the username without any privilege.
+It then reads from left to right all the [rules](#acl-rules) provided as successive arguments, setting the user ACL rules as specified.
+If the user already exists, the provided ACL rules are simply applied
+*in addition* to the rules already set. For example:
+
+    ACL SETUSER virginia on allkeys +set
+
+The above command creates a user called `virginia` who is active(the _on_ rule), can access any key (_allkeys_ rule), and can call the set command (_+set_ rule).
+Then, you can use another `ACL SETUSER` call to modify the user rules:
+
+    ACL SETUSER virginia +get
+
+The above rule applies the new rule to the user `virginia`, so other than [`SET`]({{< relref "/commands/set" >}}), the user `virginia` can now also use the [`GET`]({{< relref "/commands/get" >}}) command.
+
+Starting from Redis 7.0, ACL rules can also be grouped into multiple distinct sets of rules, called _selectors_.
+Selectors are added by wrapping the rules in parentheses and providing them just like any other rule.
+In order to execute a command, either the root permissions (rules defined outside of parenthesis) or any of the selectors (rules defined inside parenthesis) must match the given command.
+For example:
+
+    ACL SETUSER virginia on +GET allkeys (+SET ~app1*)
+
+This sets a user with two sets of permissions, one defined on the user and one defined with a selector.
+The root user permissions only allow executing the get command, but can be executed on any keys.
+The selector then grants a secondary set of permissions: access to the [`SET`]({{< relref "/commands/set" >}}) command to be executed on any key that starts with `app1`.
+Using multiple selectors allows you to grant permissions that are different depending on what keys are being accessed.
+
+When we want to be sure to define a user from scratch, without caring if
+it had previously defined rules associated, we can use the special rule
+`reset` as first rule, in order to flush all the other existing rules:
+
+    ACL SETUSER antirez reset [... other rules ...]
+
+After resetting a user, its ACL rules revert to the default: inactive, passwordless, can't execute any command nor access any key or channel:
+
+    > ACL SETUSER antirez reset
+    +OK
+    > ACL LIST
+    1) "user antirez off -@all"
+
+ACL rules are either words like "on", "off", "reset", "allkeys", or are
+special rules that start with a special character, and are followed by
+another string (without any space in between), like "+SET".
+
+For information on persisting ACLs, see the [ACL tutorial]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#use-an-external-acl-file).
+
+The following documentation is a reference manual about the capabilities of this command, however our [ACL tutorial]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) may be a more gentle introduction to how the ACL system works in general.
+
+## ACL rules
+
+Redis ACL rules are split into two categories: rules that define command permissions or _command rules_, and rules that define the user state or _user management rules_.
+This is a list of all the supported Redis ACL rules:
+
+### Command rules
+
+* `~<pattern>`: Adds the specified key pattern (glob style pattern, like in the [`KEYS`]({{< relref "/commands/keys" >}}) command), to the list of key patterns accessible by the user. This grants both read and write permissions to keys that match the pattern. You can add multiple key patterns to the same user. Example: `~objects:*`
+* `%R~<pattern>`: (Available in Redis 7.0 and later) Adds the specified read key pattern. This behaves similar to the regular key pattern but only grants permission to read from keys that match the given pattern. See [key permissions]({{< relref "/operate/oss_and_stack/management/security/acl#key-permissions" >}}) for more information.
+* `%W~<pattern>`: (Available in Redis 7.0 and later) Adds the specified write key pattern. This behaves similar to the regular key pattern but only grants permission to write to keys that match the given pattern. See [key permissions]({{< relref "/operate/oss_and_stack/management/security/acl#key-permissions" >}}) for more information.
+* `%RW~<pattern>`: (Available in Redis 7.0 and later) Alias for `~<pattern>`.
+* `allkeys`: Alias for `~*`, it allows the user to access all the keys.
+* `resetkeys`: Removes all the key patterns from the list of key patterns the user can access.
+* `&<pattern>`: (Available in Redis 6.2 and later) Adds the specified glob style pattern to the list of Pub/Sub channel patterns accessible by the user. You can add multiple channel patterns to the same user. Example: `&chatroom:*`
+* `allchannels`: Alias for `&*`, it allows the user to access all Pub/Sub channels.
+* `resetchannels`: Removes all channel patterns from the list of Pub/Sub channel patterns the user can access.
+* `+<command>`: Adds the command to the list of commands the user can call. Can be used with `|` for allowing subcommands (e.g "+config|get").
+* `+@<category>`: Adds all the commands in the specified category to the list of commands the user is able to execute. Example: `+@string` (adds all the string commands). For a list of categories, check the [`ACL CAT`]({{< relref "/commands/acl-cat" >}}) command.
+* `+<command>|first-arg`: Allows a specific first argument of an otherwise disabled command. It is only supported on commands with no sub-commands, and is not allowed as negative form like -SELECT|1, only additive starting with "+". This feature is deprecated and may be removed in the future.
+* `allcommands`: Alias of `+@all`. Adds all the commands there are in the server, including *future commands* loaded via module, to be executed by this user.
+* `-<command>`: Remove the command to the list of commands the user can call. Starting Redis 7.0, it can be used with `|` for blocking subcommands (e.g., "-config|set").
+* `-@<category>`: Like `+@<category>` but removes all the commands in the category instead of adding them.
+* `nocommands`: Alias for `-@all`. Removes all the commands, and the user is no longer able to execute anything.
+
+### User management rules
+
+* `on`: Set the user as active, it will be possible to authenticate as this user using `AUTH <username> <password>`.
+* `off`: Set user as not active, it will be impossible to log as this user. Please note that if a user gets disabled (set to off) after there are connections already authenticated with such a user, the connections will continue to work as expected. To also kill the old connections you can use [`CLIENT KILL`]({{< relref "/commands/client-kill" >}}) with the user option. An alternative is to delete the user with [`ACL DELUSER`]({{< relref "/commands/acl-deluser" >}}), that will result in all the connections authenticated as the deleted user to be disconnected.
+* `nopass`: The user is set as a _no password_ user. It means that it will be possible to authenticate as such user with any password. By default, the `default` special user is set as "nopass". The `nopass` rule will also reset all the configured passwords for the user.
+* `>password`: Adds the specified clear text password as a hashed password in the list of the users passwords. Every user can have many active passwords, so that password rotation will be simpler. The specified password is not stored as clear text inside the server. Example: `>mypassword`.
+* `#<hashedpassword>`: Adds the specified hashed password to the list of user passwords. A Redis hashed password is hashed with SHA256 and translated into a hexadecimal string. Example: `#c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2`.
+* `<password`: Like `>password` but removes the password instead of adding it.
+* `!<hashedpassword>`: Like `#<hashedpassword>` but removes the password instead of adding it.
+* `(<rule list>)`: (Available in Redis 7.0 and later) Creates a new selector to match rules against. Selectors are evaluated after the user permissions, and are evaluated according to the order they are defined. If a command matches either the user permissions or any selector, it is allowed. See [selectors]({{< relref "operate/oss_and_stack/management/security/acl#selectors" >}}) for more information.
+* `clearselectors`: (Available in Redis 7.0 and later) Deletes all of the selectors attached to the user.
+* `reset`: Removes any capability from the user. They are set to off, without passwords, unable to execute any command, unable to access any key.
+
+## Examples
+
+```
+> ACL SETUSER alan allkeys +@string +@set -SADD >alanpassword
++OK
+
+> ACL SETUSER antirez heeyyyy
+(error) ERR Error in ACL SETUSER modifier 'heeyyyy': Syntax error
+```
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: limit
+  name: limit
+  optional: true
+  token: LIMIT
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- movablekeys
+complexity: O(N*M) worst case where N is the cardinality of the smallest set and M
+  is the number of sets.
+description: Returns the number of members of the intersect of multiple sets.
+group: set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: SINTERCARD
+since: 7.0.0
+summary: Returns the number of members of the intersect of multiple sets.
+syntax_fmt: "SINTERCARD numkeys key [key ...] [LIMIT\_limit]"
+syntax_str: "key [key ...] [LIMIT\_limit]"
+title: SINTERCARD
+---
+This command is similar to [`SINTER`]({{< relref "/commands/sinter" >}}), but instead of returning the result set, it returns just the cardinality of the result.
+Returns the cardinality of the set which would result from the intersection of all the given sets.
+
+Keys that do not exist are considered to be empty sets.
+With one of the keys being an empty set, the resulting set is also empty (since set intersection with an empty set always results in an empty set).
+
+By default, the command calculates the cardinality of the intersection of all given sets.
+When provided with the optional `LIMIT` argument (which defaults to 0 and means unlimited), if the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality.
+Such implementation ensures a significant speedup for queries where the limit is lower than the actual intersection cardinality.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key1 "d"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SINTER key1 key2
+SINTERCARD 2 key1 key2
+SINTERCARD 2 key1 key2 LIMIT 1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@blocking'
+- '@connection'
+arguments:
+- display_text: numlocal
+  name: numlocal
+  type: integer
+- display_text: numreplicas
+  name: numreplicas
+  type: integer
+- display_text: timeout
+  name: timeout
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- blocking
+complexity: O(1)
+description: Blocks until all of the preceding write commands sent by the connection
+  are written to the append-only file of the master and/or replicas.
+group: generic
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:agg_min
+linkTitle: WAITAOF
+since: 7.2.0
+summary: Blocks until all of the preceding write commands sent by the connection are
+  written to the append-only file of the master and/or replicas.
+syntax_fmt: WAITAOF numlocal numreplicas timeout
+syntax_str: numreplicas timeout
+title: WAITAOF
+---
+This command blocks the current client until all previous write commands by that client are acknowledged as having been fsynced to the AOF of the local Redis and/or at least the specified number of replicas.
+
+`numlocal` represents the number of local fsyncs required to be confirmed before proceeding.
+When `numlocal` is set to 1, the command blocks until the data written to the Redis instance is confirmed to be persisted to the local AOF file.
+The value 0 disables this check.
+
+If the timeout, specified in milliseconds, is reached, the command returns even if the specified number of acknowledgments has not been met.
+
+The command **will always return** the number of masters and replicas that have fsynced all write commands sent by the current client before the `WAITAOF` command, both in the case where the specified thresholds were met, and when the timeout is reached.
+
+A few remarks:
+
+1. When `WAITAOF` returns, all the previous write commands sent in the context of the current connection are guaranteed to be fsynced to the AOF of at least the number of masters and replicas returned by `WAITAOF`.
+2. If the command is sent as part of a [`MULTI`]({{< relref "/commands/multi" >}}) transaction (or any other context that does not allow blocking, such as inside scripts), the command does not block but instead returns immediately the number of masters and replicas that fsynced all previous write commands.
+3. A timeout of 0 means to block forever.
+4. Since `WAITAOF` returns the number of fsyncs completed both in case of success and timeout, the client should check that the returned values are equal or greater than the persistence level required.
+5. `WAITAOF` cannot be used on replica instances, and the `numlocal` argument cannot be non-zero if the local Redis does not have AOF enabled.
+
+Limitations
+---
+It is possible to write a module or Lua script that propagate writes to the AOF but not the replication stream.
+(For modules, this is done using the `fmt` argument to `RedisModule_Call` or `RedisModule_Replicate`; For Lua scripts, this is achieved using `redis.set_repl`.)
+
+These features are incompatible with the `WAITAOF` command as it is currently implemented, and using them in combination may result in incorrect behavior.
+
+Consistency and WAITAOF
+---
+
+Note that, similarly to [`WAIT`]({{< relref "/commands/wait" >}}), `WAITAOF` does not make Redis a strongly-consistent store.
+Unless waiting for all members of a cluster to fsync writes to disk, data can still be lost during a failover or a Redis restart.
+However, `WAITAOF` does improve real-world data safety.
+
+Implementation details
+---
+
+Since Redis 7.2, Redis tracks and increments the replication offset even when no replicas are configured (as long as AOF exists).
+
+In addition, Redis replicas asynchronously ping their master with two replication offsets: the offset they have processed in the replication stream, and the offset they have fsynced to their AOF.
+
+Redis remembers, for each client, the replication offset of the produced replication stream when the last write command was executed in the context of that client.
+When `WAITAOF` is called, Redis checks if the local Redis and/or the specified number of replicas have confirmed fsyncing this offset or a greater one to their AOF.
+
+## Examples
+
+```
+> SET foo bar
+OK
+> WAITAOF 1 0 0
+1) (integer) 1
+2) (integer) 0
+> WAITAOF 0 1 1000
+1) (integer) 1
+2) (integer) 0
+```
+
+In the above example, the first call to `WAITAOF` does not use a timeout and asks for the write to be fsynced to the local Redis only; it returns with [1, 0] when this is completed.
+
+In the second attempt we instead specify a timeout, and ask for the write to be confirmed as fsynced by a single replica.
+Since there are no connected replicas, the `WAITAOF` command unblocks after one second and again returns [1, 0], indicating the write has been fsynced on the local Redis but no replicas.
+---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: longitude
+  name: longitude
+  type: double
+- display_text: latitude
+  name: latitude
+  type: double
+- display_text: radius
+  name: radius
+  type: double
+- arguments:
+  - display_text: m
+    name: m
+    token: M
+    type: pure-token
+  - display_text: km
+    name: km
+    token: KM
+    type: pure-token
+  - display_text: ft
+    name: ft
+    token: FT
+    type: pure-token
+  - display_text: mi
+    name: mi
+    token: MI
+    type: pure-token
+  name: unit
+  type: oneof
+- display_text: withcoord
+  name: withcoord
+  optional: true
+  token: WITHCOORD
+  type: pure-token
+- display_text: withdist
+  name: withdist
+  optional: true
+  token: WITHDIST
+  type: pure-token
+- display_text: withhash
+  name: withhash
+  optional: true
+  token: WITHHASH
+  type: pure-token
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    since: 6.2.0
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N+log(M)) where N is the number of elements inside the bounding box
+  of the circular area delimited by center and radius and M is the number of items
+  inside the index.
+deprecated_since: 6.2.0
+description: Returns members from a geospatial index that are within a distance from
+  a coordinate.
+doc_flags:
+- deprecated
+group: geo
+hidden: false
+history:
+- - 6.2.0
+  - Added the `ANY` option for `COUNT`.
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEORADIUS_RO
+replaced_by: '[`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) with the `BYRADIUS`
+  argument'
+since: 3.2.10
+summary: Returns members from a geospatial index that are within a distance from a
+  coordinate.
+syntax_fmt: "GEORADIUS_RO key longitude latitude radius <M | KM | FT | MI>\n  [WITHCOORD]\
+  \ [WITHDIST] [WITHHASH] [COUNT\_count [ANY]] [ASC | DESC]"
+syntax_str: "longitude latitude radius <M | KM | FT | MI> [WITHCOORD] [WITHDIST] [WITHHASH]\
+  \ [COUNT\_count [ANY]] [ASC | DESC]"
+title: GEORADIUS_RO
+---
+Read-only variant of the [`GEORADIUS`]({{< relref "/commands/georadius" >}}) command.
+
+This command is identical to the [`GEORADIUS`]({{< relref "/commands/georadius" >}}) command, except that it doesn't support the optional `STORE` and `STOREDIST` parameters.
+---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  name: member
+  type: string
+- display_text: radius
+  name: radius
+  type: double
+- arguments:
+  - display_text: m
+    name: m
+    token: M
+    type: pure-token
+  - display_text: km
+    name: km
+    token: KM
+    type: pure-token
+  - display_text: ft
+    name: ft
+    token: FT
+    type: pure-token
+  - display_text: mi
+    name: mi
+    token: MI
+    type: pure-token
+  name: unit
+  type: oneof
+- display_text: withcoord
+  name: withcoord
+  optional: true
+  token: WITHCOORD
+  type: pure-token
+- display_text: withdist
+  name: withdist
+  optional: true
+  token: WITHDIST
+  type: pure-token
+- display_text: withhash
+  name: withhash
+  optional: true
+  token: WITHHASH
+  type: pure-token
+- arguments:
+  - display_text: count
+    name: count
+    token: COUNT
+    type: integer
+  - display_text: any
+    name: any
+    optional: true
+    token: ANY
+    type: pure-token
+  name: count-block
+  optional: true
+  type: block
+- arguments:
+  - display_text: asc
+    name: asc
+    token: ASC
+    type: pure-token
+  - display_text: desc
+    name: desc
+    token: DESC
+    type: pure-token
+  name: order
+  optional: true
+  type: oneof
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N+log(M)) where N is the number of elements inside the bounding box
+  of the circular area delimited by center and radius and M is the number of items
+  inside the index.
+deprecated_since: 6.2.0
+description: Returns members from a geospatial index that are within a distance from
+  a member.
+doc_flags:
+- deprecated
+group: geo
+hidden: false
+history:
+- - 6.2.0
+  - Added the `ANY` option for `COUNT`.
+- - 7.0.0
+  - Added support for uppercase unit names.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEORADIUSBYMEMBER_RO
+replaced_by: '[`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) with the `BYRADIUS`
+  and `FROMMEMBER` arguments'
+since: 3.2.10
+summary: Returns members from a geospatial index that are within a distance from a
+  member.
+syntax_fmt: "GEORADIUSBYMEMBER_RO key member radius <M | KM | FT | MI>\n  [WITHCOORD]\
+  \ [WITHDIST] [WITHHASH] [COUNT\_count [ANY]] [ASC | DESC]"
+syntax_str: "member radius <M | KM | FT | MI> [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT\_\
+  count [ANY]] [ASC | DESC]"
+title: GEORADIUSBYMEMBER_RO
+---
+Read-only variant of the [`GEORADIUSBYMEMBER`]({{< relref "/commands/georadiusbymember" >}}) command.
+
+This command is identical to the [`GEORADIUSBYMEMBER`]({{< relref "/commands/georadiusbymember" >}}) command, except that it doesn't support the optional `STORE` and `STOREDIST` parameters.
+---
+acl_categories:
+- '@write'
+- '@hyperloglog'
+- '@slow'
+arguments:
+- display_text: destkey
+  key_spec_index: 0
+  name: destkey
+  type: key
+- display_text: sourcekey
+  key_spec_index: 1
+  multiple: true
+  name: sourcekey
+  optional: true
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) to merge N HyperLogLogs, but with high constant times.
+description: Merges one or more HyperLogLog values into a single key.
+group: hyperloglog
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: PFMERGE
+since: 2.8.9
+summary: Merges one or more HyperLogLog values into a single key.
+syntax_fmt: PFMERGE destkey [sourcekey [sourcekey ...]]
+syntax_str: '[sourcekey [sourcekey ...]]'
+title: PFMERGE
+---
+Merge multiple HyperLogLog values into a unique value that will approximate
+the cardinality of the union of the observed Sets of the source HyperLogLog
+structures.
+
+The computed merged HyperLogLog is set to the destination variable, which is
+created if does not exist (defaulting to an empty HyperLogLog).
+
+If the destination variable exists, it is treated as one of the source sets 
+and its cardinality will be included in the cardinality of the computed
+HyperLogLog.
+
+## Examples
+
+{{% redis-cli %}}
+PFADD hll1 foo bar zap a
+PFADD hll2 a b c foo
+PFMERGE hll3 hll1 hll2
+PFCOUNT hll3
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: count
+  name: count
+  optional: true
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- loading
+- stale
+complexity: O(N) where N is the number of entries returned
+description: Returns the slow log's entries.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- nondeterministic_output
+history:
+- - 4.0.0
+  - Added client IP address, port and name to the reply.
+linkTitle: SLOWLOG GET
+since: 2.2.12
+summary: Returns the slow log's entries.
+syntax_fmt: SLOWLOG GET [count]
+syntax_str: ''
+title: SLOWLOG GET
+---
+The `SLOWLOG GET` command returns entries from the slow log in chronological order.
+
+The Redis Slow Log is a system to log queries that exceeded a specified execution time.
+The execution time does not include I/O operations like talking with the client, sending the reply and so forth, but just the time needed to actually execute the command (this is the only stage of command execution where the thread is blocked and can not serve other requests in the meantime).
+
+A new entry is added to the slow log whenever a command exceeds the execution time threshold defined by the `slowlog-log-slower-than` configuration directive.
+The maximum number of entries in the slow log is governed by the `slowlog-max-len` configuration directive.
+
+By default the command returns latest ten entries in the log. The optional `count` argument limits the number of returned entries, so the command returns at most up to `count` entries, the special number -1 means return all entries.
+
+Each entry from the slow log is comprised of the following six values:
+
+1. A unique progressive identifier for every slow log entry.
+2. The unix timestamp at which the logged command was processed.
+3. The amount of time needed for its execution, in microseconds.
+4. The array composing the arguments of the command.
+5. Client IP address and port.
+6. Client name if set via the [`CLIENT SETNAME`]({{< relref "/commands/client-setname" >}}) command.
+
+The entry's unique ID can be used in order to avoid processing slow log entries multiple times (for instance you may have a script sending you an email alert for every new slow log entry).
+The ID is never reset in the course of the Redis server execution, only a server
+restart will reset it.
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of keys to retrieve.
+description: Atomically returns the string values of one or more keys.
+group: string
+hidden: false
+hints:
+- request_policy:multi_shard
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: MGET
+since: 1.0.0
+summary: Atomically returns the string values of one or more keys.
+syntax_fmt: MGET key [key ...]
+syntax_str: ''
+title: MGET
+---
+Returns the values of all specified keys.
+For every key that does not hold a string value or does not exist, the special
+value `nil` is returned.
+Because of this, the operation never fails.
+
+## Examples
+
+{{% redis-cli %}}
+SET key1 "Hello"
+SET key2 "World"
+MGET key1 key2 nonexisting
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@fast'
+- '@connection'
+arguments:
+- display_text: index
+  name: index
+  type: integer
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+- fast
+complexity: O(1)
+description: Changes the selected database.
+group: connection
+hidden: false
+linkTitle: SELECT
+since: 1.0.0
+summary: Changes the selected database.
+syntax_fmt: SELECT index
+syntax_str: ''
+title: SELECT
+---
+Select the Redis logical database having the specified zero-based numeric index.
+New connections always use the database 0.
+
+Selectable Redis databases are a form of namespacing: all databases are still persisted in the same RDB / AOF file. However different databases can have keys with the same name, and commands like [`FLUSHDB`]({{< relref "/commands/flushdb" >}}), [`SWAPDB`]({{< relref "/commands/swapdb" >}}) or [`RANDOMKEY`]({{< relref "/commands/randomkey" >}}) work on specific databases.
+
+In practical terms, Redis databases should be used to separate different keys belonging to the same application (if needed), and not to use a single Redis instance for multiple unrelated applications.
+
+When using Redis Cluster, the `SELECT` command cannot be used, since Redis Cluster only supports database zero. In the case of a Redis Cluster, having multiple databases would be useless and an unnecessary source of complexity. Commands operating atomically on a single database would not be possible with the Redis Cluster design and goals.
+
+Since the currently selected database is a property of the connection, clients should track the currently selected database and re-select it on reconnection. While there is no command in order to query the selected database in the current connection, the [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) output shows, for each client, the currently selected database.
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: cursor
+  name: cursor
+  type: integer
+- display_text: pattern
+  name: pattern
+  optional: true
+  token: MATCH
+  type: pattern
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for every call. O(N) for a complete iteration, including enough command
+  calls for the cursor to return back to 0. N is the number of elements inside the
+  collection.
+description: Iterates over members of a set.
+group: set
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SSCAN
+since: 2.8.0
+summary: Iterates over members of a set.
+syntax_fmt: "SSCAN key cursor [MATCH\_pattern] [COUNT\_count]"
+syntax_str: "cursor [MATCH\_pattern] [COUNT\_count]"
+title: SSCAN
+---
+See [`SCAN`]({{< relref "/commands/scan" >}}) for `SSCAN` documentation.
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- arguments:
+  - display_text: left
+    name: left
+    token: LEFT
+    type: pure-token
+  - display_text: right
+    name: right
+    token: RIGHT
+    type: pure-token
+  name: where
+  type: oneof
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- movablekeys
+complexity: O(N+M) where N is the number of provided keys and M is the number of elements
+  returned.
+description: Returns multiple elements from a list after removing them. Deletes the
+  list if the last element was popped.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: LMPOP
+since: 7.0.0
+summary: Returns multiple elements from a list after removing them. Deletes the list
+  if the last element was popped.
+syntax_fmt: "LMPOP numkeys key [key ...] <LEFT | RIGHT> [COUNT\_count]"
+syntax_str: "key [key ...] <LEFT | RIGHT> [COUNT\_count]"
+title: LMPOP
+---
+Pops one or more elements from the first non-empty list key from the list of provided key names.
+
+`LMPOP` and [`BLMPOP`]({{< relref "/commands/blmpop" >}}) are similar to the following, more limited, commands:
+
+- [`LPOP`]({{< relref "/commands/lpop" >}}) or [`RPOP`]({{< relref "/commands/rpop" >}}) which take only one key, and can return multiple elements.
+- [`BLPOP`]({{< relref "/commands/blpop" >}}) or [`BRPOP`]({{< relref "/commands/brpop" >}}) which take multiple keys, but return only one element from just one key.
+
+See [`BLMPOP`]({{< relref "/commands/blmpop" >}}) for the blocking variant of this command.
+
+Elements are popped from either the left or right of the first non-empty list based on the passed argument.
+The number of returned elements is limited to the lower between the non-empty list's length, and the count argument (which defaults to 1).
+
+## Examples
+
+{{% redis-cli %}}
+LMPOP 2 non1 non2 LEFT COUNT 10
+LPUSH mylist "one" "two" "three" "four" "five"
+LMPOP 1 mylist LEFT
+LRANGE mylist 0 -1
+LMPOP 1 mylist RIGHT COUNT 10
+LPUSH mylist "one" "two" "three" "four" "five"
+LPUSH mylist2 "a" "b" "c" "d" "e"
+LMPOP 2 mylist mylist2 right count 3
+LRANGE mylist 0 -1
+LMPOP 2 mylist mylist2 right count 5
+LMPOP 2 mylist mylist2 right count 10
+EXISTS mylist mylist2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: timeout
+  name: timeout
+  type: double
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- arguments:
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: where
+  type: oneof
+- display_text: count
+  name: count
+  optional: true
+  token: COUNT
+  type: integer
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+- movablekeys
+complexity: O(K) + O(M*log(N)) where K is the number of provided keys, N being the
+  number of elements in the sorted set, and M being the number of elements popped.
+description: Removes and returns a member by score from one or more sorted sets. Blocks
+  until a member is available otherwise. Deletes the sorted set if the last element
+  was popped.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: BZMPOP
+since: 7.0.0
+summary: Removes and returns a member by score from one or more sorted sets. Blocks
+  until a member is available otherwise. Deletes the sorted set if the last element
+  was popped.
+syntax_fmt: "BZMPOP timeout numkeys key [key ...] <MIN | MAX> [COUNT\_count]"
+syntax_str: "numkeys key [key ...] <MIN | MAX> [COUNT\_count]"
+title: BZMPOP
+---
+`BZMPOP` is the blocking variant of [`ZMPOP`]({{< relref "/commands/zmpop" >}}).
+
+When any of the sorted sets contains elements, this command behaves exactly like [`ZMPOP`]({{< relref "/commands/zmpop" >}}).
+When used inside a [`MULTI`]({{< relref "/commands/multi" >}})/[`EXEC`]({{< relref "/commands/exec" >}}) block, this command behaves exactly like [`ZMPOP`]({{< relref "/commands/zmpop" >}}).
+When all sorted sets are empty, Redis will block the connection until another client adds members to one of the keys or until the `timeout` (a double value specifying the maximum number of seconds to block) elapses.
+A `timeout` of zero can be used to block indefinitely.
+
+See [`ZMPOP`]({{< relref "/commands/zmpop" >}}) for more information.
+---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: from_timestamp
+  type: integer
+- name: to_timestamp
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of data points that will be removed
+description: Delete all samples between two timestamps for a given time series
+group: timeseries
+hidden: false
+linkTitle: TS.DEL
+module: TimeSeries
+since: 1.6.0
+stack_path: docs/data-types/timeseries
+summary: Delete all samples between two timestamps for a given time series
+syntax: 'TS.DEL key fromTimestamp toTimestamp
+
+  '
+syntax_fmt: TS.DEL key from_timestamp to_timestamp
+syntax_str: from_timestamp to_timestamp
+title: TS.DEL
+---
+
+Delete all samples between two timestamps for a given time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<details open><summary><code>fromTimestamp</code></summary> 
+
+is start timestamp for the range deletion.
+</details>
+
+<details open><summary><code>toTimestamp</code></summary>
+
+is end timestamp for the range deletion.
+
+The given timestamp interval is closed (inclusive), meaning that samples whose timestamp eqauls the `fromTimestamp` or `toTimestamp` are also deleted.
+
+<note><b>Notes:</b>
+  
+- If fromTimestamp is older than the retention period compared to the maximum existing timestamp, the deletion is discarded and an error is returned.
+- When deleting a sample from a time series for which compaction rules are defined:
+  - If all the original samples for an affected compaction bucket are available, the compacted value is recalculated based on the remaining original samples, or removed if all original samples within the compaction bucket  were deleted.
+  - If original samples for an affected compaction bucket were expired, the deletion is discarded and an error is returned.
+- Explicitly deleting samples from a compacted time series may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples. That being said, it is safe to explicitly delete samples from a compacted time series beyond the retention period of the original time series.
+
+</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the number of samples that were deleted
+- [] on error (invalid arguments, wrong key type, etc.), when `timestamp` is older than the retention period compared to the maximum existing timestamp, or when an affected compaction bucket cannot be recalculated
+
+## Examples 
+
+<details open><summary><b>Delete range of data points</b></summary>
+
+Create time series for temperature in Tel Aviv and Jerusalem, then add different temperature samples.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+127.0.0.1:6379> TS.CREATE temp:JLM LABELS type temp location JLM
+OK
+127.0.0.1:6379> TS.MADD temp:TLV 1000 30 temp:TLV 1010 35 temp:TLV 1020 9999 temp:TLV 1030 40
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+4) (integer) 1030
+127.0.0.1:6379> TS.MADD temp:JLM 1005 30 temp:JLM 1015 35 temp:JLM 1025 9999 temp:JLM 1035 40
+1) (integer) 1005
+2) (integer) 1015
+3) (integer) 1025
+4) (integer) 1035
+{{< / highlight >}}
+
+Delete the range of data points for temperature in Tel Aviv.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.DEL temp:TLV 1000 1030
+(integer) 4
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.ADD`]({{< relref "commands/ts.add/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: MODULE HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: MODULE HELP
+syntax_str: ''
+title: MODULE HELP
+---
+The `MODULE HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- display_text: command
+  name: command
+  type: string
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the number of arguments to the command
+description: Extracts the key names from an arbitrary command.
+group: server
+hidden: false
+linkTitle: COMMAND GETKEYS
+since: 2.8.13
+summary: Extracts the key names from an arbitrary command.
+syntax_fmt: COMMAND GETKEYS command [arg [arg ...]]
+syntax_str: '[arg [arg ...]]'
+title: COMMAND GETKEYS
+---
+Returns [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of keys from a full Redis command.
+
+`COMMAND GETKEYS` is a helper command to let you find the keys
+from a full Redis command.
+
+[`COMMAND`]({{< relref "/commands/command" >}}) provides information on how to find the key names of each command (see `firstkey`, [key specifications]({{< relref "develop/reference/key-specs#logical-operation-flags" >}}), and `movablekeys`),
+but in some cases it's not possible to find keys of certain commands and then the entire command must be parsed to discover some / all key names.
+You can use `COMMAND GETKEYS` or [`COMMAND GETKEYSANDFLAGS`]({{< relref "/commands/command-getkeysandflags" >}}) to discover key names directly from how Redis parses the commands.
+
+## Examples
+
+{{% redis-cli %}}
+COMMAND GETKEYS MSET a b c d e f
+COMMAND GETKEYS EVAL "not consulted" 3 key1 key2 key3 arg1 arg2 arg3 argN
+COMMAND GETKEYS SORT mylist ALPHA STORE outlist
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@tdigest'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- arguments:
+  - name: value
+    type: double
+  multiple: true
+  name: values
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) , where N is the number of samples to add
+description: Adds one or more observations to a t-digest sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.ADD
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Adds one or more observations to a t-digest sketch
+syntax_fmt: TDIGEST.ADD key value [value ...]
+syntax_str: value [value ...]
+title: TDIGEST.ADD
+---
+Adds one or more observations to a t-digest sketch.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>value</code></summary> 
+is value of an observation (floating-point).
+</details>
+
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.ADD t 1 2 3
+OK
+{{< / highlight >}}
+
+{{< highlight bash >}}
+redis> TDIGEST.ADD t string
+(error) ERR T-Digest: error parsing val parameter
+{{< / highlight >}}
+---
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(log(N)) for each element added, where N is the number of elements in the vector set.
+description: Add a new element to a vector set, or update its vector if it already exists.
+group: vector_set
+hidden: false
+linkTitle: VADD
+since: 8.0.0
+summary: Add a new element to a vector set, or update its vector if it already exists.
+syntax_fmt: "VADD key [REDUCE dim] (FP32 | VALUES num) vector element [CAS] [NOQUANT | Q8 | BIN]\n  [EF build-exploration-factor] [SETATTR attributes] [M numlinks]"
+title: VADD
+bannerText: Vector set is a new data type that is currently in preview and may be subject to change.
+---
+
+Add a new element into the vector set specified by `key`. The vector can be provided as 32-bit floating point (`FP32`) blob of values, or as floating point numbers as strings, prefixed by the number of elements (3 in the example below):
+
+```
+VADD mykey VALUES 3 0.1 1.2 0.5 my-element
+```
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the name of the key that will hold the vector set data.
+</details>
+
+<details open>
+<summary><code>FP32 vector or VALUES num vector</code></summary>
+
+either a 32-bit floating point (FP32) blob of values or `num` floating point numbers as strings.
+</details>
+
+<details open>
+<summary><code>element</code></summary>
+
+is the name of the element that is being added to the vector set.
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>REDUCE dim</code></summary>
+
+implements random projection to reduce the dimensionality of the vector. The projection matrix is saved and reloaded along with the vector set. Please note that the REDUCE option must be passed immediately before the vector. For example,
+
+```
+VADD mykey REDUCE 50 VALUES ...
+```
+</details>
+
+<details open>
+<summary><code>CAS</code></summary>
+
+performs the operation partially using threads, in a check-and-set style. The neighbor candidates collection, which is slow, is performed in the background, while the command is executed in the main thread.
+</details>
+
+<details open>
+<summary><code>NOQUANT</code></summary>
+
+in the first VADD call for a given key, NOQUANT forces the vector to be created without int8 quantization, which is otherwise the default.
+</details>
+
+<details open>
+<summary><code>BIN</code></summary>
+
+forces the vector to use binary quantization instead of int8. This is much faster and uses less memory, but impacts the recall quality.
+</details>
+
+<details open>
+<summary><code>Q8</code></summary>
+
+forces the vector to use signed 8-bit quantization. This is the default, and the option only exists to make sure to check at insertion time that the vector set is of the same format.
+</details>
+
+{{< note >}}
+`NOQUANT`, `Q8`, and `BIN` are mutually exclusive.
+
+{{< /note >}}
+
+<details open>
+<summary><code>EF build-exploration-factor</code></summary>
+
+plays a role in the effort made to find good candidates when connecting the new node to the existing Hierarchical Navigable Small World (HNSW) graph. The default is 200. Using a larger value may help in achieving a better recall. To improve the recall it is also possible to increase EF during VSIM searches.
+</details>
+
+<details open>
+<summary><code>SETATTR attributes</code></summary>
+
+associates attributes in the form of a JavaScript object to the newly created entry or updates the attributes (if they already exist).
+It is the same as calling the VSETATTR command separately.
+</details>
+
+<details open>
+<summary><code>M numlinks</code></summary>
+
+is the maximum number of connections that each node of the graph will have with other nodes. The default is 16. More connections means more memory, but provides for more efficient graph exploration. Nodes at layer zero (every node exists at least at layer zero) have `M * 2` connections, while the other layers only have `M` connections. For example, setting `M` to `64` will use at least 1024 bytes of memory for layer zero. That's `M * 2` connections times 8 bytes (pointers), or `128 * 8 = 1024`. For higher layers, consider the following:
+
+- Each node appears in ~1.33 layers on average (empirical observation from HNSW papers), which works out to be 0.33 higher layers per node.
+- Each of those higher layers has `M = 64` connections.
+
+So, the additional amount of memory is approximately `0.33 × 64 × 8 ≈ 169.6` bytes per node, bringing the total memory to ~1193 bytes.
+
+If you don't have a recall quality problem, the default is acceptable, and uses a minimal amount of memory.
+</details>
+
+## Related topics
+
+- [Vector sets]({{< relref "/develop/data-types/vector-sets" >}})---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- display_text: command
+  name: command
+  type: string
+- display_text: arg
+  multiple: true
+  name: arg
+  optional: true
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(N) where N is the number of arguments to the command
+description: Extracts the key names and access flags for an arbitrary command.
+group: server
+hidden: false
+linkTitle: COMMAND GETKEYSANDFLAGS
+since: 7.0.0
+summary: Extracts the key names and access flags for an arbitrary command.
+syntax_fmt: COMMAND GETKEYSANDFLAGS command [arg [arg ...]]
+syntax_str: '[arg [arg ...]]'
+title: COMMAND GETKEYSANDFLAGS
+---
+Returns [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of keys from a full Redis command and their usage flags.
+
+`COMMAND GETKEYSANDFLAGS` is a helper command to let you find the keys from a full Redis command together with flags indicating what each key is used for.
+
+[`COMMAND`]({{< relref "/commands/command" >}}) provides information on how to find the key names of each command (see `firstkey`, [key specifications]({{< relref "develop/reference/key-specs#logical-operation-flags" >}}), and `movablekeys`),
+but in some cases it's not possible to find keys of certain commands and then the entire command must be parsed to discover some / all key names.
+You can use [`COMMAND GETKEYS`]({{< relref "/commands/command-getkeys" >}}) or `COMMAND GETKEYSANDFLAGS` to discover key names directly from how Redis parses the commands.
+
+Refer to [key specifications]({{< relref "develop/reference/key-specs#logical-operation-flags" >}}) for information about the meaning of the key flags.
+
+## Examples
+
+{{% redis-cli %}}
+COMMAND GETKEYS MSET a b c d e f
+COMMAND GETKEYS EVAL "not consulted" 3 key1 key2 key3 arg1 arg2 arg3 argN
+COMMAND GETKEYSANDFLAGS LMOVE mylist1 mylist2 left left
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: value
+  name: value
+  type: string
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  name: condition
+  optional: true
+  since: 2.6.12
+  type: oneof
+- display_text: get
+  name: get
+  optional: true
+  since: 6.2.0
+  token: GET
+  type: pure-token
+- arguments:
+  - display_text: seconds
+    name: seconds
+    since: 2.6.12
+    token: EX
+    type: integer
+  - display_text: milliseconds
+    name: milliseconds
+    since: 2.6.12
+    token: PX
+    type: integer
+  - display_text: unix-time-seconds
+    name: unix-time-seconds
+    since: 6.2.0
+    token: EXAT
+    type: unix-time
+  - display_text: unix-time-milliseconds
+    name: unix-time-milliseconds
+    since: 6.2.0
+    token: PXAT
+    type: unix-time
+  - display_text: keepttl
+    name: keepttl
+    since: 6.0.0
+    token: KEEPTTL
+    type: pure-token
+  name: expiration
+  optional: true
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+description: Sets the string value of a key, ignoring its type. The key is created
+  if it doesn't exist.
+group: string
+hidden: false
+history:
+- - 2.6.12
+  - Added the `EX`, `PX`, `NX` and `XX` options.
+- - 6.0.0
+  - Added the `KEEPTTL` option.
+- - 6.2.0
+  - Added the `GET`, `EXAT` and `PXAT` option.
+- - 7.0.0
+  - Allowed the `NX` and `GET` options to be used together.
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  notes: RW and ACCESS due to the optional `GET` argument
+  update: true
+  variable_flags: true
+linkTitle: SET
+since: 1.0.0
+summary: Sets the string value of a key, ignoring its type. The key is created if
+  it doesn't exist.
+syntax_fmt: "SET key value [NX | XX] [GET] [EX\_seconds | PX\_milliseconds |\n  EXAT\_\
+  unix-time-seconds | PXAT\_unix-time-milliseconds | KEEPTTL]"
+syntax_str: "value [NX | XX] [GET] [EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds\
+  \ | PXAT\_unix-time-milliseconds | KEEPTTL]"
+title: SET
+---
+Set `key` to hold the string `value`.
+If `key` already holds a value, it is overwritten, regardless of its type.
+Any previous time to live associated with the key is discarded on successful `SET` operation.
+
+## Options
+
+The `SET` command supports a set of options that modify its behavior:
+
+* `EX` *seconds* -- Set the specified expire time, in seconds (a positive integer).
+* `PX` *milliseconds* -- Set the specified expire time, in milliseconds (a positive integer).
+* `EXAT` *timestamp-seconds* -- Set the specified Unix time at which the key will expire, in seconds (a positive integer).
+* `PXAT` *timestamp-milliseconds* -- Set the specified Unix time at which the key will expire, in milliseconds (a positive integer).
+* `NX` -- Only set the key if it does not already exist.
+* `XX` -- Only set the key if it already exists.
+* `KEEPTTL` -- Retain the time to live associated with the key.
+* `GET` -- Return the old string stored at key, or nil if key did not exist. An error is returned and `SET` aborted if the value stored at key is not a string.
+
+Note: Since the `SET` command options can replace [`SETNX`]({{< relref "/commands/setnx" >}}), [`SETEX`]({{< relref "/commands/setex" >}}), [`PSETEX`]({{< relref "/commands/psetex" >}}), [`GETSET`]({{< relref "/commands/getset" >}}), it is possible that in future versions of Redis these commands will be deprecated and finally removed.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+GET mykey
+
+SET anotherkey "will expire in a minute" EX 60
+{{% /redis-cli %}}
+
+
+### Code examples
+
+{{< clients-example set_and_get />}}
+
+## Patterns
+
+**Note:** The following pattern is discouraged in favor of [the Redlock algorithm]({{< relref "/develop/use/patterns/distributed-locks" >}}) which is only a bit more complex to implement, but offers better guarantees and is fault tolerant.
+
+The command `SET resource-name anystring NX EX max-lock-time` is a simple way to implement a locking system with Redis.
+
+A client can acquire the lock if the above command returns `OK` (or retry after some time if the command returns Nil), and remove the lock just using [`DEL`]({{< relref "/commands/del" >}}).
+
+The lock will be auto-released after the expire time is reached.
+
+It is possible to make this system more robust modifying the unlock schema as follows:
+
+* Instead of setting a fixed string, set a non-guessable large random string, called token.
+* Instead of releasing the lock with [`DEL`]({{< relref "/commands/del" >}}), send a script that only removes the key if the value matches.
+
+This avoids that a client will try to release the lock after the expire time deleting the key created by another client that acquired the lock later.
+
+An example of unlock script would be similar to the following:
+
+    if redis.call("get",KEYS[1]) == ARGV[1]
+    then
+        return redis.call("del",KEYS[1])
+    else
+        return 0
+    end
+
+The script should be called with `EVAL ...script... 1 resource-name token-value`
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: username
+  multiple: true
+  name: username
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1) amortized time considering the typical user.
+description: Deletes ACL users, and terminates their connections.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: ACL DELUSER
+since: 6.0.0
+summary: Deletes ACL users, and terminates their connections.
+syntax_fmt: ACL DELUSER username [username ...]
+syntax_str: ''
+title: ACL DELUSER
+---
+Delete all the specified ACL users and terminate all the connections that are
+authenticated with such users. Note: the special `default` user cannot be
+removed from the system, this is the default user that every new connection
+is authenticated with. The list of users may include usernames that do not
+exist, in such case no operation is performed for the non existing users.
+
+## Examples
+
+```
+> ACL DELUSER antirez
+1
+```
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+- no_multi
+description: An internal command used in replication.
+group: server
+hidden: false
+linkTitle: SYNC
+since: 1.0.0
+summary: An internal command used in replication.
+syntax_fmt: SYNC
+syntax_str: ''
+title: SYNC
+---
+Initiates a replication stream from the master.
+
+The `SYNC` command is called by Redis replicas for initiating a replication
+stream from the master. It has been replaced in newer versions of Redis by
+ [`PSYNC`]({{< relref "/commands/psync" >}}).
+
+For more information about replication in Redis please check the
+[replication page][tr].
+
+[tr]: /operate/oss_and_stack/management/replication
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns information and statistics on the index
+group: search
+hidden: false
+linkTitle: FT.INFO
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Returns information and statistics on the index
+syntax: FT.INFO index
+syntax_fmt: FT.INFO index
+syntax_str: ''
+title: FT.INFO
+---
+
+Returns information and statistics about a given index.
+
+## Required arguments
+
+`index`
+<br />
+is the name of the given index. You must first create the index using [`FT.CREATE`]({{< relref "commands/ft.create/" >}}).
+
+## RESP reply
+
+`FT.INFO` returns an array reply with pairs of keys and values.
+
+## Returned values
+
+### General
+
+| Return field name | Definition |
+|:---               |:---        |
+| `index_name` | The index name that was defined when index was created. |
+| `index_options` | The index options selected during `FT.CREATE` such as `FILTER {filter}`, `LANGUAGE {default_lang}`, etc. |
+| `index_definition` | Includes `key_type`, hash or JSON; `prefixes`, if any; and `default_score`. |
+| `attributes` | The index schema field names, types, and attributes. |
+| `num_docs` | The number of documents. |
+| `max_doc_id` | The maximum document ID. |
+| `num_terms` | The number of distinct terms. |
+| `num_records` | The total number of records. |
+
+### Various size statistics
+
+| Statistic | Definition |
+|:---       |:---        |
+| `inverted_sz_mb` | The memory used by the inverted index, which is the core data structure used for searching in RediSearch. The size is given in megabytes. |
+| `vector_index_sz_mb` | The memory used by the vector index, which stores any vectors associated with each document. |
+| `total_inverted_index_blocks` | The total number of blocks in the inverted index. |
+| `offset_vectors_sz_mb` | The memory used by the offset vectors, which store positional information for terms in documents. |
+| `doc_table_size_mb` | The memory used by the document table, which contains metadata about each document in the index. |
+| `sortable_values_size_mb` | The memory used by sortable values, which are values associated with documents and used for sorting purposes. |
+| `key_table_size_mb` | The memory used by the key table, which stores the mapping between document IDs and Redis keys. |
+| `geoshapes_sz_mb` | The memory used by GEO-related fields. |
+| `records_per_doc_avg` | The average number of records (including deletions) per document. |
+| `bytes_per_record_avg` | The average size of each record in bytes. |
+| `offsets_per_term_avg` | The average number of offsets (position information) per term. |
+| `offset_bits_per_record_avg` | The average number of bits used for offsets per record. |
+
+### Indexing-related statistics
+
+| Statistic | Definition |
+|:---       |:---        |
+| `hash_indexing_failures` | The number of failures encountered during indexing. |
+| `total_indexing_time` | The total time taken for indexing in seconds. |
+| `indexing` | Indicates whether the index is currently being generated. |
+| `percent_indexed` | The percentage of the index that has been successfully generated (1 means 100%). |
+| `number_of_uses` | The number of times the index has been used. |
+| `cleaning` | The index deletion flag. A value of `1` indicates index deletion is in progress. |
+
+### Garbage collection statistics
+
+| Statistic | Definition |
+|:---       |:---        |
+| `bytes_collected` | The number of bytes collected during garbage collection. |
+| `total_ms_run` | The total time in milliseconds spent on garbage collection. |
+| `total_cycles` | The total number of garbage collection cycles. |
+| `average_cycle_time_ms` | The average time in milliseconds for each garbage collection cycle. The value `nan` indicates that the average cycle time is not available. |
+| `last_run_time_ms` | The time in milliseconds taken by the last garbage collection run. |
+
+The next two GC-related fields are relevant in scenarios where simultaneous changes occurred in the same memory area for both the parent process and the child process, resulting in the parent discarding these changes.
+
+| Statistic | Definition |
+|:---       |:---        |
+| `gc_numeric_trees_missed` | The number of numeric tree nodes whose changes were discarded due to splitting by the parent process during garbage collection. |
+| `gc_blocks_denied` | The number of blocks whose changes were discarded (skipped) because they were modified by the parent process during the garbage collection. Notably, as inverted index blocks are append-only, only the last block of an inverted index can be skipped. |
+
+### Cursor statistics
+
+| Statistic | Definition |
+|:---       |:---        |
+| `global_idle` | The number of idle cursors in the system. |
+| `global_total` | The total number of cursors in the system. |
+| `index_capacity` | The maximum number of cursors allowed per index. |
+| `index_total` | The total number of cursors open on the index. |
+
+### Other statistics
+
+- Dialect statistics: the number of times the index was searched using each DIALECT, 1 - 4.
+- Index error statistics, including `indexing failures`, `last indexing error`, and `last indexing error key`.
+- Field statistics, including `indexing failures`, `last indexing error`, and `last indexing error key` for each schema field.
+
+## Example
+
+<details open>
+<summary><b>Return statistics about an index</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> ft.info idx:bicycle
+ 1) index_name
+ 2) idx:bicycle
+ 3) index_options
+ 4) (empty array)
+ 5) index_definition
+ 6) 1) key_type
+    2) JSON
+    3) prefixes
+    4) 1) bicycle:
+    5) default_score
+    6) "1"
+ 7) attributes
+ 8) 1) 1) identifier
+       2) $.pickup_zone
+       3) attribute
+       4) pickup_zone
+       5) type
+       6) GEOSHAPE
+       7) coord_system
+       8) SPHERICAL
+    2) 1) identifier
+       2) $.store_location
+       3) attribute
+       4) store_location
+       5) type
+       6) GEO
+    3) 1) identifier
+       2) $.brand
+       3) attribute
+       4) brand
+       5) type
+       6) TEXT
+       7) WEIGHT
+       8) "1"
+    4) 1) identifier
+       2) $.model
+       3) attribute
+       4) model
+       5) type
+       6) TEXT
+       7) WEIGHT
+       8) "1"
+    5) 1) identifier
+       2) $.description
+       3) attribute
+       4) description
+       5) type
+       6) TEXT
+       7) WEIGHT
+       8) "1"
+    6) 1) identifier
+       2) $.price
+       3) attribute
+       4) price
+       5) type
+       6) NUMERIC
+    7) 1) identifier
+       2) $.condition
+       3) attribute
+       4) condition
+       5) type
+       6) TAG
+       7) SEPARATOR
+       8) ,
+ 9) num_docs
+10) "10"
+11) max_doc_id
+12) "10"
+13) num_terms
+14) "546"
+15) num_records
+16) "692"
+17) inverted_sz_mb
+18) "0.003993034362792969"
+19) vector_index_sz_mb
+20) "0"
+21) total_inverted_index_blocks
+22) "551"
+23) offset_vectors_sz_mb
+24) "7.047653198242188e-4"
+25) doc_table_size_mb
+26) "7.152557373046875e-4"
+27) sortable_values_size_mb
+28) "0"
+29) key_table_size_mb
+30) "3.0422210693359375e-4"
+31) geoshapes_sz_mb
+32) "0.00426483154296875"
+33) records_per_doc_avg
+34) "69.19999694824219"
+35) bytes_per_record_avg
+36) "6.0505781173706055"
+37) offsets_per_term_avg
+38) "1.0679190158843994"
+39) offset_bits_per_record_avg
+40) "8"
+41) hash_indexing_failures
+42) "0"
+43) total_indexing_time
+44) "4.539999961853027"
+45) indexing
+46) "0"
+47) percent_indexed
+48) "1"
+49) number_of_uses
+50) (integer) 1
+51) cleaning
+52) (integer) 0
+53) gc_stats
+54)  1) bytes_collected
+     2) "0"
+     3) total_ms_run
+     4) "0"
+     5) total_cycles
+     6) "0"
+     7) average_cycle_time_ms
+     8) "nan"
+     9) last_run_time_ms
+    10) "0"
+    11) gc_numeric_trees_missed
+    12) "0"
+    13) gc_blocks_denied
+    14) "0"
+55) cursor_stats
+56) 1) global_idle
+    2) (integer) 0
+    3) global_total
+    4) (integer) 0
+    5) index_capacity
+    6) (integer) 128
+    7) index_total
+    8) (integer) 0
+57) dialect_stats
+58) 1) dialect_1
+    2) (integer) 0
+    3) dialect_2
+    4) (integer) 0
+    5) dialect_3
+    6) (integer) 0
+    7) dialect_4
+    8) (integer) 0
+59) Index Errors
+60) 1) indexing failures
+    2) (integer) 0
+    3) last indexing error
+    4) N/A
+    5) last indexing error key
+    6) "N/A"
+61) field statistics
+62) 1) 1) identifier
+       2) $.pickup_zone
+       3) attribute
+       4) pickup_zone
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    2) 1) identifier
+       2) $.store_location
+       3) attribute
+       4) store_location
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    3) 1) identifier
+       2) $.brand
+       3) attribute
+       4) brand
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    4) 1) identifier
+       2) $.model
+       3) attribute
+       4) model
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    5) 1) identifier
+       2) $.description
+       3) attribute
+       4) description
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    6) 1) identifier
+       2) $.price
+       3) attribute
+       4) price
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+    7) 1) identifier
+       2) $.condition
+       3) attribute
+       4) condition
+       5) Index Errors
+       6) 1) indexing failures
+          2) (integer) 0
+          3) last indexing error
+          4) N/A
+          5) last indexing error key
+          6) "N/A"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CREATE`]({{< relref "commands/ft.create/" >}}) | [`FT.SEARCH`]({{< relref "commands/ft.search/" >}})
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@cuckoo'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: iterator
+  type: integer
+- name: data
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n), where n is the capacity
+description: Restores a filter previously saved using SCANDUMP
+group: cf
+hidden: false
+linkTitle: CF.LOADCHUNK
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Restores a filter previously saved using SCANDUMP
+syntax_fmt: CF.LOADCHUNK key iterator data
+syntax_str: iterator data
+title: CF.LOADCHUNK
+---
+Restores a cuckoo filter previously saved using [`CF.SCANDUMP`]({{< relref "commands/cf.scandump/" >}}).
+
+See the [`CF.SCANDUMP`]({{< relref "commands/cf.scandump/" >}}) command for example usage.
+
+<note><b>Notes</b>
+
+- This command overwrites the cuckoo filter stored under `key`.
+- Make sure that the cuckoo filter is not changed between invocations.
+
+</note>
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter to restore.
+</details>
+
+<details open><summary><code>iterator</code></summary>
+
+Iterator value associated with `data` (returned by [`CF.SCANDUMP`]({{< relref "commands/cf.scandump/" >}}))
+</details>
+
+<details open><summary><code>data</code></summary>
+
+Current data chunk (returned by [`CF.SCANDUMP`]({{< relref "commands/cf.scandump/" >}}))
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly
+- [] on error (invalid arguments, wrong key type, wrong data, etc.)
+
+## Examples
+
+See [`CF.SCANDUMP`]({{< relref "commands/cf.scandump/" >}}) for an example.
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+- '@dangerous'
+arguments:
+- display_text: index1
+  name: index1
+  type: integer
+- display_text: index2
+  name: index2
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the count of clients watching or blocking on keys from
+  both databases.
+description: Swaps two Redis databases.
+group: server
+hidden: false
+linkTitle: SWAPDB
+since: 4.0.0
+summary: Swaps two Redis databases.
+syntax_fmt: SWAPDB index1 index2
+syntax_str: index2
+title: SWAPDB
+---
+This command swaps two Redis databases, so that immediately all the
+clients connected to a given database will see the data of the other database, and
+the other way around. Example:
+
+    SWAPDB 0 1
+
+This will swap database 0 with database 1. All the clients connected with database 0 will immediately see the new data, exactly like all the clients connected with database 1 will see the data that was formerly of database 0.
+
+## Examples
+
+```
+SWAPDB 0 1
+```
+---
+acl_categories:
+- '@tdigest'
+- '@write'
+arguments:
+- name: key
+  type: key
+- name: compression
+  optional: true
+  token: COMPRESSION
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Allocates memory and initializes a new t-digest sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.CREATE
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Allocates memory and initializes a new t-digest sketch
+syntax_fmt: "TDIGEST.CREATE key [COMPRESSION\_compression]"
+syntax_str: "[COMPRESSION\_compression]"
+title: TDIGEST.CREATE
+---
+Allocates memory and initializes a new t-digest sketch.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+is key name for this new t-digest sketch.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>COMPRESSION compression</code></summary> 
+
+is a controllable tradeoff between accuracy and memory consumption. 100 is a common value for normal uses. 1000 is more accurate. If no value is passed by default the compression will be 100. For more information on scaling of accuracy versus the compression parameter see [_The t-digest: Efficient estimates of distributions_](https://www.sciencedirect.com/science/article/pii/S2665963820300403).
+
+</details>
+  
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 100
+OK
+{{< / highlight >}}
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns a list of the consumer groups of a stream.
+group: stream
+hidden: false
+history:
+- - 7.0.0
+  - Added the `entries-read` and `lag` fields
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XINFO GROUPS
+since: 5.0.0
+summary: Returns a list of the consumer groups of a stream.
+syntax_fmt: XINFO GROUPS key
+syntax_str: ''
+title: XINFO GROUPS
+---
+This command returns the list of all consumer groups of the stream stored at `<key>`.
+
+By default, only the following information is provided for each of the groups:
+
+* **name**: the consumer group's name
+* **consumers**: the number of consumers in the group
+* **pending**: the length of the group's pending entries list (PEL), which are messages that were delivered but are yet to be acknowledged
+* **last-delivered-id**: the ID of the last entry delivered to the group's consumers
+* **entries-read**: the logical "read counter" of the last entry delivered to the group's consumers
+* **lag**: the number of entries in the stream that are still waiting to be delivered to the group's consumers, or a NULL when that number can't be determined.
+
+### Consumer group lag
+
+The lag of a given consumer group is the number of entries in the range between the group's `entries_read` and the stream's `entries_added`.
+Put differently, it is the number of entries that are yet to be delivered to the group's consumers.
+
+The values and trends of this metric are helpful in making scaling decisions about the consumer group.
+You can address high lag values by adding more consumers to the group, whereas low values may indicate that you can remove consumers from the group to scale it down.
+
+Redis reports the lag of a consumer group by keeping two counters: the number of all entries added to the stream and the number of logical reads made by the consumer group.
+The lag is the difference between these two.
+
+The stream's counter (the `entries_added` field of the [`XINFO STREAM`]({{< relref "/commands/xinfo-stream" >}}) command) is incremented by one with every [`XADD`]({{< relref "/commands/xadd" >}}) and counts all of the entries added to the stream during its lifetime.
+
+The consumer group's counter, `entries_read`, is the logical counter of entries the group had read.
+It is important to note that this counter is only a heuristic rather than an accurate counter, and therefore the use of the term "logical".
+The counter attempts to reflect the number of entries that the group **should have read** to get to its current `last-delivered-id`.
+The `entries_read` counter is accurate only in a perfect world, where a consumer group starts at the stream's first entry and processes all of its entries (i.e., no entries deleted before processing).
+
+There are two special cases in which this mechanism is unable to report the lag:
+
+1. A consumer group is created or set with an arbitrary last delivered ID (the [`XGROUP CREATE`]({{< relref "/commands/xgroup-create" >}}) and [`XGROUP SETID`]({{< relref "/commands/xgroup-setid" >}}) commands, respectively).
+    An arbitrary ID is any ID that isn't the ID of the stream's first entry, its last entry or the zero ("0-0") ID.
+2. One or more entries between the group's `last-delivered-id` and the stream's `last-generated-id` were deleted (with [`XDEL`]({{< relref "/commands/xdel" >}}) or a trimming operation).
+
+In both cases, the group's read counter is considered invalid, and the returned value is set to NULL to signal that the lag isn't currently available.
+
+However, the lag is only temporarily unavailable.
+It is restored automatically during regular operation as consumers keep processing messages.
+Once the consumer group delivers the last message in the stream to its members, it will be set with the correct logical read counter, and tracking its lag can be resumed.
+
+## Examples
+
+```
+> XINFO GROUPS mystream
+1)  1) "name"
+    2) "mygroup"
+    3) "consumers"
+    4) (integer) 2
+    5) "pending"
+    6) (integer) 2
+    7) "last-delivered-id"
+    8) "1638126030001-0"
+    9) "entries-read"
+   10) (integer) 2
+   11) "lag"
+   12) (integer) 0
+2)  1) "name"
+    2) "some-other-group"
+    3) "consumers"
+    4) (integer) 1
+    5) "pending"
+    6) (integer) 0
+    7) "last-delivered-id"
+    8) "1638126028070-0"
+    9) "entries-read"
+   10) (integer) 1
+   11) "lag"
+   12) (integer) 1
+```
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: count
+  name: count
+  optional: true
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(log(N)*M) with N being the number of elements in the sorted set, and
+  M being the number of elements popped.
+description: Returns the lowest-scoring members from a sorted set after removing them.
+  Deletes the sorted set if the last member was popped.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZPOPMIN
+since: 5.0.0
+summary: Returns the lowest-scoring members from a sorted set after removing them.
+  Deletes the sorted set if the last member was popped.
+syntax_fmt: ZPOPMIN key [count]
+syntax_str: '[count]'
+title: ZPOPMIN
+---
+Removes and returns up to `count` members with the lowest scores in the sorted
+set stored at `key`.
+
+When left unspecified, the default value for `count` is 1. Specifying a `count`
+value that is higher than the sorted set's cardinality will not produce an
+error. When returning multiple elements, the one with the lowest score will
+be the first, followed by the elements with greater scores.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZPOPMIN myzset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@set'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the total number of elements in all given sets.
+description: Returns the difference of multiple sets.
+group: set
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SDIFF
+since: 1.0.0
+summary: Returns the difference of multiple sets.
+syntax_fmt: SDIFF key [key ...]
+syntax_str: ''
+title: SDIFF
+---
+Returns the members of the set resulting from the difference between the first
+set and all the successive sets.
+
+For example:
+
+```
+key1 = {a,b,c,d}
+key2 = {c}
+key3 = {a,c,e}
+SDIFF key1 key2 key3 = {b,d}
+```
+
+Keys that do not exist are considered to be empty sets.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SDIFF key1 key2
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns the maximum observation value from a t-digest sketch
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.MAX
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns the maximum observation value from a t-digest sketch
+syntax_fmt: TDIGEST.MAX key
+syntax_str: ''
+title: TDIGEST.MAX
+---
+Returns the maximum observation value from a t-digest sketch.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) of maximum observation value from a sketch. The result is always accurate. 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t
+OK
+redis> TDIGEST.MAX t
+"nan"
+redis> TDIGEST.ADD t 3 4 1 2 5
+OK
+redis>TDIGEST.MAX t
+"5"
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+arguments:
+- display_text: bits
+  name: bits
+  optional: true
+  type: integer
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Generates a pseudorandom, secure password that can be used to identify
+  ACL users.
+group: server
+hidden: false
+linkTitle: ACL GENPASS
+since: 6.0.0
+summary: Generates a pseudorandom, secure password that can be used to identify ACL
+  users.
+syntax_fmt: ACL GENPASS [bits]
+syntax_str: ''
+title: ACL GENPASS
+---
+ACL users need a solid password in order to authenticate to the server without
+security risks. Such password does not need to be remembered by humans, but
+only by computers, so it can be very long and strong (unguessable by an
+external attacker). The `ACL GENPASS` command generates a password starting
+from /dev/urandom if available, otherwise (in systems without /dev/urandom) it
+uses a weaker system that is likely still better than picking a weak password
+by hand.
+
+By default (if /dev/urandom is available) the password is strong and
+can be used for other uses in the context of a Redis application, for
+instance in order to create unique session identifiers or other kind of
+unguessable and not colliding IDs. The password generation is also very cheap
+because we don't really ask /dev/urandom for bits at every execution. At
+startup Redis creates a seed using /dev/urandom, then it will use SHA256
+in counter mode, with HMAC-SHA256(seed,counter) as primitive, in order to
+create more random bytes as needed. This means that the application developer
+should be feel free to abuse `ACL GENPASS` to create as many secure
+pseudorandom strings as needed.
+
+The command output is a hexadecimal representation of a binary string.
+By default it emits 256 bits (so 64 hex characters). The user can provide
+an argument in form of number of bits to emit from 1 to 1024 to change
+the output length. Note that the number of bits provided is always
+rounded to the next multiple of 4. So for instance asking for just 1
+bit password will result in 4 bits to be emitted, in the form of a single
+hex character.
+
+## Examples
+
+```
+> ACL GENPASS
+"dd721260bfe1b3d9601e7fbab36de6d04e2e67b0ef1c53de59d45950db0dd3cc"
+
+> ACL GENPASS 32
+"355ef3dd"
+
+> ACL GENPASS 5
+"90"
+```
+---
+acl_categories:
+- '@write'
+- '@slow'
+- '@scripting'
+arguments:
+- display_text: serialized-value
+  name: serialized-value
+  type: string
+- arguments:
+  - display_text: flush
+    name: flush
+    token: FLUSH
+    type: pure-token
+  - display_text: append
+    name: append
+    token: APPEND
+    type: pure-token
+  - display_text: replace
+    name: replace
+    token: REPLACE
+    type: pure-token
+  name: policy
+  optional: true
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- noscript
+complexity: O(N) where N is the number of functions on the payload
+description: Restores all libraries from a payload.
+group: scripting
+hidden: false
+hints:
+- request_policy:all_shards
+- response_policy:all_succeeded
+linkTitle: FUNCTION RESTORE
+since: 7.0.0
+summary: Restores all libraries from a payload.
+syntax_fmt: FUNCTION RESTORE serialized-value [FLUSH | APPEND | REPLACE]
+syntax_str: '[FLUSH | APPEND | REPLACE]'
+title: FUNCTION RESTORE
+---
+Restore libraries from the serialized payload.
+
+You can use the optional _policy_ argument to provide a policy for handling existing libraries.
+The following policies are allowed:
+
+* **APPEND:** appends the restored libraries to the existing libraries and aborts on collision. 
+  This is the default policy.
+* **FLUSH:** deletes all existing libraries before restoring the payload.
+* **REPLACE:** appends the restored libraries to the existing libraries, replacing any existing ones in case of name collisions. Note that this policy doesn't prevent function name collisions, only libraries.
+
+For more information please refer to [Introduction to Redis Functions]({{< relref "/develop/interact/programmability/functions-intro" >}}).
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the expiration time of a key as a Unix milliseconds timestamp.
+group: generic
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: PEXPIRETIME
+since: 7.0.0
+summary: Returns the expiration time of a key as a Unix milliseconds timestamp.
+syntax_fmt: PEXPIRETIME key
+syntax_str: ''
+title: PEXPIRETIME
+---
+`PEXPIRETIME` has the same semantic as [`EXPIRETIME`]({{< relref "/commands/expiretime" >}}), but returns the absolute Unix expiration timestamp in milliseconds instead of seconds.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+PEXPIREAT mykey 33177117420000
+PEXPIRETIME mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Removes the expiration time for each specified field
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HPERSIST
+since: 7.4.0
+summary: Removes the expiration time for each specified field
+syntax_fmt: "HPERSIST key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HPERSIST
+---
+Remove the existing expiration on a hash key's field(s), turning the field(s) from _volatile_ (a field
+with expiration set) to _persistent_ (a field that will never expire as no TTL (time to live)
+is associated).
+
+## Examples
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer 2)
+redis> HEXPIRE mykey 300 FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 283
+2) (integer) 283
+redis> HPERSIST mykey FIELDS 1 field2
+1) (integer) 1
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 268
+2) (integer) -1
+```
+
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: fnx
+    name: fnx
+    token: FNX
+    type: pure-token
+  - display_text: fxx
+    name: fxx
+    token: FXX
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: seconds
+    name: seconds
+    token: EX
+    type: integer
+  - display_text: milliseconds
+    name: milliseconds
+    token: PX
+    type: integer
+  - display_text: unix-time-seconds
+    name: unix-time-seconds
+    token: EXAT
+    type: unix-time
+  - display_text: unix-time-milliseconds
+    name: unix-time-milliseconds
+    token: PXAT
+    type: unix-time
+  - display_text: keepttl
+    name: keepttl
+    token: KEEPTTL
+    type: pure-token
+  name: expiration
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - arguments:
+    - display_text: field
+      name: field
+      type: string
+    - display_text: value
+      name: value
+      type: string
+    multiple: true
+    name: data
+    type: block
+  name: fields
+  token: FIELDS
+  type: block
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of fields being set.
+description: Set the value of one or more fields of a given hash key, and optionally
+  set their expiration.
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HSETEX
+since: 8.0.0
+summary: Set the value of one or more fields of a given hash key, and optionally set
+  their expiration.
+syntax_fmt: "HSETEX key [FNX | FXX] [EX\_seconds | PX\_milliseconds |\n  EXAT\_unix-time-seconds\
+  \ | PXAT\_unix-time-milliseconds | KEEPTTL]\n  FIELDS\_numfields field value [field\
+  \ value ...]"
+syntax_str: "[FNX | FXX] [EX\_seconds | PX\_milliseconds | EXAT\_unix-time-seconds\
+  \ | PXAT\_unix-time-milliseconds | KEEPTTL] FIELDS\_numfields field value [field\
+  \ value ...]"
+title: HSETEX
+---
+
+Set the value of one or more fields of a given hash key, and optionally set their expiration time or time-to-live (TTL).
+
+## Options
+
+The `HSETEX` command supports a set of options:
+
+* `FNX` -- Only set the fields if none of them already exist.
+* `FXX` -- Only set the fields if all of them already exist.
+* `EX seconds` -- Set the specified expiration time in seconds.
+* `PX milliseconds` -- Set the specified expiration time in milliseconds.
+* `EXAT unix-time-seconds` -- Set the specified Unix time in seconds at which the fields will expire.
+* `PXAT unix-time-milliseconds` -- Set the specified Unix time in milliseconds at which the fields will expire.
+* `KEEPTTL` -- Retain the TTL associated with the fields.
+
+The `EX`, `PX`, `EXAT`, `PXAT`, and `KEEPTTL` options are mutually exclusive.
+
+## Example
+
+```
+redis> HSETEX mykey EXAT 1740470400 FIELDS 2 field1 "Hello" field2 "World"
+(integer) 1
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 55627
+2) (integer) 55627
+redis> HSETEX mykey FNX EX 60 FIELDS 2 field1 "Hello" field2 "World"
+(integer) 0
+redis> HSETEX mykey FXX EX 60 KEEPTTL FIELDS 2 field1 "hello" field2 "world"
+(error) ERR Only one of EX, PX, EXAT, PXAT or KEEPTTL arguments can be specified
+redis> HSETEX mykey FXX KEEPTTL FIELDS 2 field1 "hello" field2 "world"
+(integer) 1
+redis> HTTL mykey FIELDS 2 field1 field2
+1) (integer) 55481
+2) (integer) 55481
+```
+---
+acl_categories:
+- '@admin'
+- '@search'
+arguments:
+- name: option
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Help description of runtime configuration options
+group: search
+hidden: true
+linkTitle: FT.CONFIG HELP
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Help description of runtime configuration options
+syntax: 'FT.CONFIG HELP option
+
+  '
+syntax_fmt: FT.CONFIG HELP option
+syntax_str: ''
+title: FT.CONFIG HELP
+---
+
+Describe configuration options
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>option</code></summary> 
+
+is name of the configuration option, or '*' for all. 
+</details>
+
+## Return
+
+FT.CONFIG HELP returns an array reply of the configuration name and value.
+
+## Examples
+
+<details open>
+<summary><b>Get configuration details</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CONFIG HELP TIMEOUT
+1) 1) TIMEOUT
+   2) Description
+   3) Query (search) timeout
+   4) Value
+   5) "42"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CONFIG SET`]({{< relref "commands/ft.config-set/" >}}) | [`FT.CONFIG GET`]({{< relref "commands/ft.config-get/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@write'
+- '@set'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(N) where N is the total number of elements in all given sets.
+description: Stores the difference of multiple sets in a key.
+group: set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -1
+      limit: 0
+    type: range
+linkTitle: SDIFFSTORE
+since: 1.0.0
+summary: Stores the difference of multiple sets in a key.
+syntax_fmt: SDIFFSTORE destination key [key ...]
+syntax_str: key [key ...]
+title: SDIFFSTORE
+---
+This command is equal to [`SDIFF`]({{< relref "/commands/sdiff" >}}), but instead of returning the resulting set, it
+is stored in `destination`.
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+SADD key1 "a"
+SADD key1 "b"
+SADD key1 "c"
+SADD key2 "c"
+SADD key2 "d"
+SADD key2 "e"
+SDIFFSTORE key key1 key2
+SMEMBERS key
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - arguments:
+    - display_text: host
+      name: host
+      type: string
+    - display_text: port
+      name: port
+      type: integer
+    name: host-port
+    type: block
+  - arguments:
+    - display_text: 'no'
+      name: 'no'
+      token: 'NO'
+      type: pure-token
+    - display_text: one
+      name: one
+      token: ONE
+      type: pure-token
+    name: no-one
+    type: block
+  name: args
+  type: oneof
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- stale
+- no_async_loading
+complexity: O(1)
+deprecated_since: 5.0.0
+description: Sets a Redis server as a replica of another, or promotes it to being
+  a master.
+doc_flags:
+- deprecated
+group: server
+hidden: false
+linkTitle: SLAVEOF
+replaced_by: '[`REPLICAOF`]({{< relref "/commands/replicaof" >}})'
+since: 1.0.0
+summary: Sets a Redis server as a replica of another, or promotes it to being a master.
+syntax_fmt: SLAVEOF <host port | NO ONE>
+syntax_str: ''
+title: SLAVEOF
+---
+**A note about the word slave used in this man page and command name**: starting with Redis version 5, if not for backward compatibility, the Redis project no longer uses the word slave. Please use the new command [`REPLICAOF`]({{< relref "/commands/replicaof" >}}). The command `SLAVEOF` will continue to work for backward compatibility.
+
+The `SLAVEOF` command can change the replication settings of a replica on the fly.
+If a Redis server is already acting as replica, the command `SLAVEOF` NO ONE will
+turn off the replication, turning the Redis server into a MASTER.
+In the proper form `SLAVEOF` hostname port will make the server a replica of
+another server listening at the specified hostname and port.
+
+If a server is already a replica of some master, `SLAVEOF` hostname port will stop
+the replication against the old server and start the synchronization against the
+new one, discarding the old dataset.
+
+The form `SLAVEOF` NO ONE will stop replication, turning the server into a
+MASTER, but will not discard the replication.
+So, if the old master stops working, it is possible to turn the replica into a
+master and set the application to use this new master in read/write.
+Later when the other Redis server is fixed, it can be reconfigured to work as a
+replica.
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Returns the length of the JSON String at path in key
+group: json
+hidden: false
+linkTitle: JSON.STRLEN
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the length of the JSON String at path in key
+syntax_fmt: JSON.STRLEN key [path]
+syntax_str: '[path]'
+title: JSON.STRLEN
+---
+Report the length of the JSON String at `path` in `key`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`, if not provided. Returns null if the `key` or `path` do not exist.
+</details>
+
+## Return
+
+JSON.STRLEN returns by recursive descent an array of integer replies for each path, the string's length, or `nil`, if the matching JSON value is not a string.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":"foo", "nested": {"a": "hello"}, "nested2": {"a": 31}}'
+OK
+redis> JSON.STRLEN doc $..a
+1) (integer) 3
+2) (integer) 5
+3) (nil)
+{{< / highlight >}}
+
+## See also
+
+[`JSON.ARRLEN`]({{< relref "commands/json.arrlen/" >}}) | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: destination
+  key_spec_index: 0
+  name: destination
+  type: key
+- display_text: numkeys
+  name: numkeys
+  type: integer
+- display_text: key
+  key_spec_index: 1
+  multiple: true
+  name: key
+  type: key
+- display_text: weight
+  multiple: true
+  name: weight
+  optional: true
+  token: WEIGHTS
+  type: integer
+- arguments:
+  - display_text: sum
+    name: sum
+    token: SUM
+    type: pure-token
+  - display_text: min
+    name: min
+    token: MIN
+    type: pure-token
+  - display_text: max
+    name: max
+    token: MAX
+    type: pure-token
+  name: aggregate
+  optional: true
+  token: AGGREGATE
+  type: oneof
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- movablekeys
+complexity: O(N*K)+O(M*log(M)) worst case with N being the smallest input sorted set,
+  K being the number of input sorted sets and M being the number of elements in the
+  resulting sorted set.
+description: Stores the intersect of multiple sorted sets in a key.
+group: sorted-set
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      firstkey: 1
+      keynumidx: 0
+      keystep: 1
+    type: keynum
+linkTitle: ZINTERSTORE
+since: 2.0.0
+summary: Stores the intersect of multiple sorted sets in a key.
+syntax_fmt: "ZINTERSTORE destination numkeys key [key ...] [WEIGHTS\_weight\n  [weight\
+  \ ...]] [AGGREGATE\_<SUM | MIN | MAX>]"
+syntax_str: "numkeys key [key ...] [WEIGHTS\_weight [weight ...]] [AGGREGATE\_<SUM\
+  \ | MIN | MAX>]"
+title: ZINTERSTORE
+---
+Computes the intersection of `numkeys` sorted sets given by the specified keys,
+and stores the result in `destination`.
+It is mandatory to provide the number of input keys (`numkeys`) before passing
+the input keys and the other (optional) arguments.
+
+By default, the resulting score of an element is the sum of its scores in the
+sorted sets where it exists.
+Because intersection requires an element to be a member of every given sorted
+set, this results in the score of every element in the resulting sorted set to
+be equal to the number of input sorted sets.
+
+For a description of the `WEIGHTS` and `AGGREGATE` options, see [`ZUNIONSTORE`]({{< relref "/commands/zunionstore" >}}).
+
+If `destination` already exists, it is overwritten.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD zset1 1 "one"
+ZADD zset1 2 "two"
+ZADD zset2 1 "one"
+ZADD zset2 2 "two"
+ZADD zset2 3 "three"
+ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3
+ZRANGE out 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@fast'
+- '@blocking'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: timeout
+  name: timeout
+  type: double
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+- fast
+complexity: O(log(N)) with N being the number of elements in the sorted set.
+description: Removes and returns the member with the highest score from one or more
+  sorted sets. Blocks until a member available otherwise.  Deletes the sorted set
+  if the last element was popped.
+group: sorted-set
+hidden: false
+history:
+- - 6.0.0
+  - '`timeout` is interpreted as a double instead of an integer.'
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -2
+      limit: 0
+    type: range
+linkTitle: BZPOPMAX
+since: 5.0.0
+summary: Removes and returns the member with the highest score from one or more sorted
+  sets. Blocks until a member available otherwise.  Deletes the sorted set if the
+  last element was popped.
+syntax_fmt: BZPOPMAX key [key ...] timeout
+syntax_str: timeout
+title: BZPOPMAX
+---
+`BZPOPMAX` is the blocking variant of the sorted set [`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) primitive.
+
+It is the blocking version because it blocks the connection when there are no
+members to pop from any of the given sorted sets.
+A member with the highest score is popped from first sorted set that is
+non-empty, with the given keys being checked in the order that they are given.
+
+The `timeout` argument is interpreted as a double value specifying the maximum
+number of seconds to block. A timeout of zero can be used to block indefinitely.
+
+See the [BZPOPMIN documentation][cb] for the exact semantics, since `BZPOPMAX`
+is identical to [`BZPOPMIN`]({{< relref "/commands/bzpopmin" >}}) with the only difference being that it pops members
+with the highest scores instead of popping the ones with the lowest scores.
+
+[cb]: /commands/bzpopmin
+
+## Examples
+
+```
+redis> DEL zset1 zset2
+(integer) 0
+redis> ZADD zset1 0 a 1 b 2 c
+(integer) 3
+redis> BZPOPMAX zset1 zset2 0
+1) "zset1"
+2) "c"
+3) "2"
+```
+---
+acl_categories:
+- '@cuckoo'
+- '@read'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Returns information about a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.INFO
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Returns information about a Cuckoo Filter
+syntax_fmt: CF.INFO key
+syntax_str: ''
+title: CF.INFO
+---
+Returns information about a cuckoo filter.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) with argument name ([Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})) and value ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}})) pairs
+- [] on error (invalid arguments, key does not exist, wrong key type, and so on)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.INFO cf
+ 1) Size
+ 2) (integer) 1080
+ 3) Number of buckets
+ 4) (integer) 512
+ 5) Number of filter
+ 6) (integer) 1
+ 7) Number of items inserted
+ 8) (integer) 0
+ 9) Number of items deleted
+10) (integer) 0
+11) Bucket size
+12) (integer) 2
+13) Expansion rate
+14) (integer) 1
+15) Max iteration
+16) (integer) 20
+{{< / highlight >}}
+---
+acl_categories:
+- '@tdigest'
+- '@read'
+arguments:
+- name: key
+  type: key
+- multiple: true
+  name: value
+  type: double
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) where N is the number of values specified.
+description: Returns, for each input value, an estimation of the fraction (floating-point)
+  of (observations smaller than the given value + half the observations equal to the
+  given value)
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.CDF
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: Returns, for each input value, an estimation of the fraction (floating-point)
+  of (observations smaller than the given value + half the observations equal to the
+  given value)
+syntax_fmt: TDIGEST.CDF key value [value ...]
+syntax_str: value [value ...]
+title: TDIGEST.CDF
+---
+Returns, for each input value, an estimation of the fraction (floating-point) of (observations smaller than the given value + half the observations equal to the given value).
+
+Multiple fractions can be retrieved in a single call.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+<details open><summary><code>value</code></summary>
+is value for which the CDF (Cumulative Distribution Function) should be retrieved.
+</details>
+
+## Return value
+
+[Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) - the command returns an array of floating-points populated with fraction_1, fraction_2, ..., fraction_N. 
+
+All values are 'nan' if the sketch is empty.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.CREATE t COMPRESSION 1000
+OK
+redis> TDIGEST.ADD t 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
+OK
+redis> TDIGEST.CDF t 0 1 2 3 4 5 6
+1) "0"
+2) "0.033333333333333333"
+3) "0.13333333333333333"
+4) "0.29999999999999999"
+5) "0.53333333333333333"
+6) "0.83333333333333337"
+7) "1"
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns the client ID to which the connection's tracking notifications
+  are redirected.
+group: connection
+hidden: false
+linkTitle: CLIENT GETREDIR
+since: 6.0.0
+summary: Returns the client ID to which the connection's tracking notifications are
+  redirected.
+syntax_fmt: CLIENT GETREDIR
+syntax_str: ''
+title: CLIENT GETREDIR
+---
+This command returns the client ID we are redirecting our
+[tracking]({{< relref "/develop/clients/client-side-caching#tracking" >}}) notifications to. We set a client
+to redirect to when using [`CLIENT TRACKING`]({{< relref "/commands/client-tracking" >}}) to enable tracking. However in
+order to avoid forcing client libraries implementations to remember the
+ID notifications are redirected to, this command exists in order to improve
+introspection and allow clients to check later if redirection is active
+and towards which client ID.
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+- '@blocking'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  multiple: true
+  name: key
+  type: key
+- display_text: timeout
+  name: timeout
+  type: double
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- blocking
+complexity: O(N) where N is the number of provided keys.
+description: Removes and returns the last element in a list. Blocks until an element
+  is available otherwise. Deletes the list if the last element was popped.
+group: list
+hidden: false
+history:
+- - 6.0.0
+  - '`timeout` is interpreted as a double instead of an integer.'
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: -2
+      limit: 0
+    type: range
+linkTitle: BRPOP
+since: 2.0.0
+summary: Removes and returns the last element in a list. Blocks until an element is
+  available otherwise. Deletes the list if the last element was popped.
+syntax_fmt: BRPOP key [key ...] timeout
+syntax_str: timeout
+title: BRPOP
+---
+`BRPOP` is a blocking list pop primitive.
+It is the blocking version of [`RPOP`]({{< relref "/commands/rpop" >}}) because it blocks the connection when there
+are no elements to pop from any of the given lists.
+An element is popped from the tail of the first list that is non-empty, with the
+given keys being checked in the order that they are given.
+
+See the [BLPOP documentation][cb] for the exact semantics, since `BRPOP` is
+identical to [`BLPOP`]({{< relref "/commands/blpop" >}}) with the only difference being that it pops elements from
+the tail of a list instead of popping from the head.
+
+[cb]: /commands/blpop
+
+## Examples
+
+```
+redis> DEL list1 list2
+(integer) 0
+redis> RPUSH list1 a b c
+(integer) 3
+redis> BRPOP list1 list2 0
+1) "list1"
+2) "c"
+```
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Outputs a memory problems report.
+group: server
+hidden: false
+hints:
+- nondeterministic_output
+- request_policy:all_shards
+- response_policy:special
+linkTitle: MEMORY DOCTOR
+since: 4.0.0
+summary: Outputs a memory problems report.
+syntax_fmt: MEMORY DOCTOR
+syntax_str: ''
+title: MEMORY DOCTOR
+---
+The `MEMORY DOCTOR` command reports about different memory-related issues that
+the Redis server experiences, and advises about possible remedies.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- no_async_loading
+- no_multi
+complexity: O(N) where N is the total number of keys in all databases
+description: Synchronously saves the database(s) to disk.
+group: server
+hidden: false
+linkTitle: SAVE
+since: 1.0.0
+summary: Synchronously saves the database(s) to disk.
+syntax_fmt: SAVE
+syntax_str: ''
+title: SAVE
+---
+The `SAVE` commands performs a **synchronous** save of the dataset producing a
+_point in time_ snapshot of all the data inside the Redis instance, in the form
+of an RDB file.
+
+You almost never want to call `SAVE` in production environments where it will
+block all the other clients.
+Instead usually [`BGSAVE`]({{< relref "/commands/bgsave" >}}) is used.
+However in case of issues preventing Redis to create the background saving child
+(for instance errors in the fork(2) system call), the `SAVE` command can be a
+good last resort to perform the dump of the latest dataset.
+
+See the [persistence documentation]({{< relref "/operate/oss_and_stack/management/persistence" >}}) for detailed information.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: hard
+    name: hard
+    token: HARD
+    type: pure-token
+  - display_text: soft
+    name: soft
+    token: SOFT
+    type: pure-token
+  name: reset-type
+  optional: true
+  type: oneof
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- stale
+complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL
+  as a side effect.
+description: Resets a node.
+group: cluster
+hidden: false
+linkTitle: CLUSTER RESET
+since: 3.0.0
+summary: Resets a node.
+syntax_fmt: CLUSTER RESET [HARD | SOFT]
+syntax_str: ''
+title: CLUSTER RESET
+---
+Reset a Redis Cluster node, in a more or less drastic way depending on the
+reset type, that can be **hard** or **soft**. Note that this command
+**does not work for masters if they hold one or more keys**, in that case
+to completely reset a master node keys must be removed first, e.g. by using [`FLUSHALL`]({{< relref "/commands/flushall" >}}) first,
+and then `CLUSTER RESET`.
+
+Effects on the node:
+
+1. All the other nodes in the cluster are forgotten.
+2. All the assigned / open slots are reset, so the slots-to-nodes mapping is totally cleared.
+3. If the node is a replica it is turned into an (empty) master. Its dataset is flushed, so at the end the node will be an empty master.
+4. **Hard reset only**: a new Node ID is generated.
+5. **Hard reset only**: `currentEpoch` and `configEpoch` vars are set to 0.
+6. The new configuration is persisted on disk in the node cluster configuration file.
+
+This command is mainly useful to re-provision a Redis Cluster node
+in order to be used in the context of a new, different cluster. The command
+is also extensively used by the Redis Cluster testing framework in order to
+reset the state of the cluster every time a new test unit is executed.
+
+If no reset type is specified, the default is **soft**.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arguments:
+- arguments:
+  - display_text: host
+    name: host
+    type: string
+  - display_text: port
+    name: port
+    type: integer
+  - display_text: force
+    name: force
+    optional: true
+    token: FORCE
+    type: pure-token
+  name: target
+  optional: true
+  token: TO
+  type: block
+- display_text: abort
+  name: abort
+  optional: true
+  token: ABORT
+  type: pure-token
+- display_text: milliseconds
+  name: milliseconds
+  optional: true
+  token: TIMEOUT
+  type: integer
+arity: -1
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- stale
+complexity: O(1)
+description: Starts a coordinated failover from a server to one of its replicas.
+group: server
+hidden: false
+linkTitle: FAILOVER
+since: 6.2.0
+summary: Starts a coordinated failover from a server to one of its replicas.
+syntax_fmt: "FAILOVER [TO\_host port [FORCE]] [ABORT] [TIMEOUT\_milliseconds]"
+syntax_str: "[ABORT] [TIMEOUT\_milliseconds]"
+title: FAILOVER
+---
+This command will start a coordinated failover between the currently-connected-to master and one of its replicas.
+The failover is not synchronous, instead a background task will handle coordinating the failover. 
+It is designed to limit data loss and unavailability of the cluster during the failover.
+This command is analogous to the [`CLUSTER FAILOVER`]({{< relref "/commands/cluster-failover" >}}) command for non-clustered Redis and is similar to the failover support provided by sentinel.
+
+The specific details of the default failover flow are as follows:
+
+1. The master will internally start a `CLIENT PAUSE WRITE`, which will pause incoming writes and prevent the accumulation of new data in the replication stream.
+2. The master will monitor its replicas, waiting for a replica to indicate that it has fully consumed the replication stream. If the master has multiple replicas, it will only wait for the first replica to catch up.
+3. The master will then demote itself to a replica. This is done to prevent any dual master scenarios. NOTE: The master will not discard its data, so it will be able to rollback if the replica rejects the failover request in the next step.
+4. The previous master will send a special PSYNC request to the target replica, `PSYNC FAILOVER`, instructing the target replica to become a master.
+5. Once the previous master receives acknowledgement the `PSYNC FAILOVER` was accepted it will unpause its clients. If the PSYNC request is rejected, the master will abort the failover and return to normal.
+
+The field `master_failover_state` in `INFO replication` can be used to track the current state of the failover, which has the following values:
+
+* `no-failover`: There is no ongoing coordinated failover.
+* `waiting-for-sync`: The master is waiting for the replica to catch up to its replication offset.
+* `failover-in-progress`: The master has demoted itself, and is attempting to hand off ownership to a target replica.
+
+If the previous master had additional replicas attached to it, they will continue replicating from it as chained replicas. You will need to manually execute a [`REPLICAOF`]({{< relref "/commands/replicaof" >}}) on these replicas to start replicating directly from the new master.
+
+## Optional arguments
+The following optional arguments exist to modify the behavior of the failover flow:
+
+* `TIMEOUT` *milliseconds* -- This option allows specifying a maximum time a master will wait in the `waiting-for-sync` state before aborting the failover attempt and rolling back.
+This is intended to set an upper bound on the write outage the Redis cluster can experience.
+Failovers typically happen in less than a second, but could take longer if there is a large amount of write traffic or the replica is already behind in consuming the replication stream. 
+If this value is not specified, the timeout can be considered to be "infinite".
+
+* `TO` *HOST* *PORT* -- This option allows designating a specific replica, by its host and port, to failover to. The master will wait specifically for this replica to catch up to its replication offset, and then failover to it.
+
+* `FORCE` -- If both the `TIMEOUT` and `TO` options are set, the force flag can also be used to designate that once the timeout has elapsed, the master should failover to the target replica instead of rolling back.
+This can be used for a best-effort attempt at a failover without data loss, but limiting write outage.
+
+NOTE: The master will always rollback if the `PSYNC FAILOVER` request is rejected by the target replica. 
+
+## Failover abort
+
+The failover command is intended to be safe from data loss and corruption, but can encounter some scenarios it can not automatically remediate from and may get stuck. 
+For this purpose, the `FAILOVER ABORT` command exists, which will abort an ongoing failover and return the master to its normal state. 
+The command has no side effects if issued in the `waiting-for-sync` state but can introduce multi-master scenarios in the `failover-in-progress` state. 
+If a multi-master scenario is encountered, you will need to manually identify which master has the latest data and designate it as the master and have the other replicas.
+
+NOTE: [`REPLICAOF`]({{< relref "/commands/replicaof" >}}) is disabled while a failover is in progress, this is to prevent unintended interactions with the failover that might cause data loss.
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  type: string
+- name: value
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M+N) when path is evaluated to a single value where M is the size of
+  the original value (if it exists) and N is the size of the new value, O(M+N) when
+  path is evaluated to multiple values where M is the size of the key and N is the
+  size of the new value * the number of original values in the key
+description: Merges a given JSON value into matching paths. Consequently, JSON values
+  at matching paths are updated, deleted, or expanded with new children
+group: json
+hidden: false
+linkTitle: JSON.MERGE
+module: JSON
+since: 2.6.0
+stack_path: docs/data-types/json
+summary: Merges a given JSON value into matching paths. Consequently, JSON values
+  at matching paths are updated, deleted, or expanded with new children
+syntax_fmt: JSON.MERGE key path value
+syntax_str: path value
+title: JSON.MERGE
+---
+Merge a given JSON value into matching paths. Consequently, JSON values at matching paths are updated, deleted, or expanded with new children.
+
+This command complies with [RFC7396](https://datatracker.ietf.org/doc/html/rfc7396) Json Merge Patch
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is the key to merge into.
+</details>
+
+<details open><summary><code>path</code></summary>
+
+specifies the JSONPath. For non-existing keys the `path` must be `$`. For existing keys, for each matched `path`, the value that matches the `path` is merged with the JSON `value`. For existing keys, when the path exists, except for the last element, a new child is added with the JSON `value`.
+
+</details>
+
+<details open><summary><code>value</code></summary>
+
+is the JSON value to merge with at the specified path. Merging is done according to the following rules per JSON value in the `value` argument while considering the corresponding original value if it exists:
+*   merging an existing object key with a `null` value deletes the key
+*   merging an existing object key with non-null value updates the value
+*   merging a non-existing object key adds the key and value
+*   merging an existing array with any merged value, replaces the entire array with the value
+</details>
+
+## Return value
+
+JSON.MERGE returns a simple string reply: `OK` if executed correctly or `error` if fails to set the new values
+
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+JSON.MERGE provides four different behaviors to merge changes on a given key: create a non-existent path, update an existing path with a new value, delete an existing path, or replace an array with a new array
+
+<details open>
+<summary><b>Create a non-existent path-value</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2}'
+OK
+redis> JSON.MERGE doc $.b '8'
+OK
+redis> JSON.GET doc $
+"[{\"a\":2,\"b\":8}]"
+{{< / highlight >}}
+
+</details>
+
+<details open>
+<summary><b>Replace an existing value</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2}'
+OK
+redis> JSON.MERGE doc $.a '3'
+OK
+redis> JSON.GET doc $
+"[{\"a\":3}]"
+{{< / highlight >}}
+
+</details>
+
+<details open>
+<summary><b>Delete an existing value</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":2}'
+OK
+redis> JSON.MERGE doc $ '{"a":null}'
+OK
+redis> JSON.GET doc $
+"[{}]"
+{{< / highlight >}}
+
+</details>
+
+<details open>
+<summary><b>Replace an Array</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":[2,4,6,8]}'
+OK
+redis> JSON.MERGE doc $.a '[10,12]'
+OK
+redis> JSON.GET doc $
+"[{\"a\":[10,12]}]"
+{{< / highlight >}}
+
+</details>
+
+
+<details open>
+<summary><b>Merge changes in multi-paths</b></summary>
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"f1": {"a":1}, "f2":{"a":2}}'
+OK
+redis> JSON.GET doc
+"{\"f1\":{\"a\":1},\"f2\":{\"a\":2}}"
+redis> JSON.MERGE doc $ '{"f1": null, "f2":{"a":3, "b":4}, "f3":[2,4,6]}'
+OK
+redis> JSON.GET doc
+"{\"f2\":{\"a\":3,\"b\":4},\"f3\":[2,4,6]}"
+{{< / highlight >}}
+
+</details>
+
+## See also
+
+[`JSON.GET`]({{< relref "commands/json.get/" >}}) | [`JSON.MGET`]({{< relref "commands/json.mget/" >}}) | [`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.MSET`]({{< relref "commands/json.mset/" >}})
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@json'
+- '@read'
+- '@slow'
+arguments:
+- multiple: true
+  name: key
+  type: key
+- name: path
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M*N) when path is evaluated to a single value where M is the number
+  of keys and N is the size of the value, O(N1+N2+...+Nm) when path is evaluated to
+  multiple values where m is the number of keys and Ni is the size of the i-th key
+description: Returns the values at a path from one or more keys
+group: json
+hidden: false
+linkTitle: JSON.MGET
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Returns the values at a path from one or more keys
+syntax_fmt: JSON.MGET key [key ...] path
+syntax_str: path
+title: JSON.MGET
+---
+Return the values at `path` from multiple `key` arguments
+
+{{% warning %}}
+When cluster mode is enabled, all specified keys must reside on the same [hash slot](https://redis.io/docs/latest/operate/oss_and_stack/reference/cluster-spec/#key-distribution-model).
+
+When the database has more than one shard, and the specified keys reside in different shards, Redis will not report a CROSSSLOT error (to avoid breaking changes) and the results may be partial.
+
+
+{{% /warning %}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to parse. Returns `null` for nonexistent keys.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Returns `null` for nonexistent paths.
+
+</details>
+
+## Return
+
+JSON.MGET returns an array of bulk string replies specified as the JSON serialization of the value at each key's path.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Return the values at <code>path</code> from multiple <code>key</code> arguments</b></summary>
+
+Create two JSON documents.
+
+{{< highlight bash >}}
+redis> JSON.SET doc1 $ '{"a":1, "b": 2, "nested": {"a": 3}, "c": null}'
+OK
+redis> JSON.SET doc2 $ '{"a":4, "b": 5, "nested": {"a": 6}, "c": null}'
+OK
+{{< / highlight >}}
+
+Get values from all arguments in the documents.
+
+{{< highlight bash >}}
+redis> JSON.MGET doc1 doc2 $..a
+1) "[1,3]"
+2) "[4,6]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.GET`]({{< relref "commands/json.get/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+---
+acl_categories:
+- '@write'
+- '@hyperloglog'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  multiple: true
+  name: element
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) to add every element.
+description: Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.
+group: hyperloglog
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: PFADD
+since: 2.8.9
+summary: Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.
+syntax_fmt: PFADD key [element [element ...]]
+syntax_str: '[element [element ...]]'
+title: PFADD
+---
+Adds all the element arguments to the HyperLogLog data structure stored at the variable name specified as first argument.
+
+As a side effect of this command the HyperLogLog internals may be updated to reflect a different estimation of the number of unique items added so far (the cardinality of the set).
+
+If the approximated cardinality estimated by the HyperLogLog changed after executing the command, `PFADD` returns 1, otherwise 0 is returned. The command automatically creates an empty HyperLogLog structure (that is, a Redis String of a specified length and with a given encoding) if the specified key does not exist.
+
+To call the command without elements but just the variable name is valid, this will result into no operation performed if the variable already exists, or just the creation of the data structure if the key does not exist (in the latter case 1 is returned).
+
+For an introduction to HyperLogLog data structure check the [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) command page.
+
+## Examples
+
+{{% redis-cli %}}
+PFADD hll a b c d e f g
+PFCOUNT hll
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Persists the effective configuration to file.
+group: server
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: CONFIG REWRITE
+since: 2.8.0
+summary: Persists the effective configuration to file.
+syntax_fmt: CONFIG REWRITE
+syntax_str: ''
+title: CONFIG REWRITE
+---
+The `CONFIG REWRITE` command rewrites the `redis.conf` file the server was started with, applying the minimal changes needed to make it reflect the configuration currently used by the server, which may be different compared to the original one because of the use of the [`CONFIG SET`]({{< relref "/commands/config-set" >}}) command.
+
+The rewrite is performed in a very conservative way:
+
+* Comments and the overall structure of the original redis.conf are preserved as much as possible.
+* If an option already exists in the old redis.conf file, it will be rewritten at the same position (line number).
+* If an option was not already present, but it is set to its default value, it is not added by the rewrite process.
+* If an option was not already present, but it is set to a non-default value, it is appended at the end of the file.
+* Non used lines are blanked. For instance if you used to have multiple `save` directives, but the current configuration has fewer or none as you disabled RDB persistence, all the lines will be blanked.
+
+CONFIG REWRITE is also able to rewrite the configuration file from scratch if the original one no longer exists for some reason. However if the server was started without a configuration file at all, the CONFIG REWRITE will just return an error.
+
+## Atomic rewrite process
+
+In order to make sure the redis.conf file is always consistent, that is, on errors or crashes you always end with the old file, or the new one, the rewrite is performed with a single `write(2)` call that has enough content to be at least as big as the old file. Sometimes additional padding in the form of comments is added in order to make sure the resulting file is big enough, and later the file gets truncated to remove the padding at the end.
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Show helpful text about the different subcommands
+group: server
+hidden: true
+linkTitle: SLOWLOG HELP
+since: 6.2.0
+summary: Show helpful text about the different subcommands
+syntax_fmt: SLOWLOG HELP
+syntax_str: ''
+title: SLOWLOG HELP
+---
+The `SLOWLOG HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@write'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: min
+  name: min
+  type: double
+- display_text: max
+  name: max
+  type: double
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements removed by the operation.
+description: Removes members in a sorted set within a range of scores. Deletes the
+  sorted set if all members were removed.
+group: sorted-set
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREMRANGEBYSCORE
+since: 1.2.0
+summary: Removes members in a sorted set within a range of scores. Deletes the sorted
+  set if all members were removed.
+syntax_fmt: ZREMRANGEBYSCORE key min max
+syntax_str: min max
+title: ZREMRANGEBYSCORE
+---
+Removes all elements in the sorted set stored at `key` with a score between
+`min` and `max` (inclusive).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 1 "one"
+ZADD myzset 2 "two"
+ZADD myzset 3 "three"
+ZREMRANGEBYSCORE myzset -inf (2
+ZRANGE myzset 0 -1 WITHSCORES
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@slow'
+- '@dangerous'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: ttl
+  name: ttl
+  type: integer
+- display_text: serialized-value
+  name: serialized-value
+  type: string
+- display_text: replace
+  name: replace
+  optional: true
+  since: 3.0.0
+  token: REPLACE
+  type: pure-token
+- display_text: absttl
+  name: absttl
+  optional: true
+  since: 5.0.0
+  token: ABSTTL
+  type: pure-token
+- display_text: seconds
+  name: seconds
+  optional: true
+  since: 5.0.0
+  token: IDLETIME
+  type: integer
+- display_text: frequency
+  name: frequency
+  optional: true
+  since: 5.0.0
+  token: FREQ
+  type: integer
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1) to create the new key and additional O(N*M) to reconstruct the serialized
+  value, where N is the number of Redis objects composing the value and M their average
+  size. For small string values the time complexity is thus O(1)+O(1*M) where M is
+  small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N))
+  because inserting values into sorted sets is O(log(N)).
+description: Creates a key from the serialized representation of a value.
+group: generic
+hidden: false
+history:
+- - 3.0.0
+  - Added the `REPLACE` modifier.
+- - 5.0.0
+  - Added the `ABSTTL` modifier.
+- - 5.0.0
+  - Added the `IDLETIME` and `FREQ` options.
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: RESTORE
+since: 2.6.0
+summary: Creates a key from the serialized representation of a value.
+syntax_fmt: "RESTORE key ttl serialized-value [REPLACE] [ABSTTL]\n  [IDLETIME\_seconds]\
+  \ [FREQ\_frequency]"
+syntax_str: "ttl serialized-value [REPLACE] [ABSTTL] [IDLETIME\_seconds] [FREQ\_frequency]"
+title: RESTORE
+---
+Create a key associated with a value that is obtained by deserializing the
+provided serialized value (obtained via [`DUMP`]({{< relref "/commands/dump" >}})).
+
+If `ttl` is 0 the key is created without any expire, otherwise the specified
+expire time (in milliseconds) is set.
+
+If the `ABSTTL` modifier was used, `ttl` should represent an absolute
+[Unix timestamp][hewowu] (in milliseconds) in which the key will expire.
+
+[hewowu]: http://en.wikipedia.org/wiki/Unix_time
+
+For eviction purposes, you may use the `IDLETIME` or `FREQ` modifiers. See
+[`OBJECT`]({{< relref "/commands/object" >}}) for more information.
+
+`RESTORE` will return a "Target key name is busy" error when `key` already
+exists unless you use the `REPLACE` modifier.
+
+`RESTORE` checks the RDB version and data checksum.
+If they don't match an error is returned.
+
+## Examples
+
+```
+redis> DEL mykey
+0
+redis> RESTORE mykey 0 "\n\x17\x17\x00\x00\x00\x12\x00\x00\x00\x03\x00\
+                        x00\xc0\x01\x00\x04\xc0\x02\x00\x04\xc0\x03\x00\
+                        xff\x04\x00u#<\xc0;.\xe9\xdd"
+OK
+redis> TYPE mykey
+list
+redis> LRANGE mykey 0 -1
+1) "1"
+2) "2"
+3) "3"
+```
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: unix-time-seconds
+  name: unix-time-seconds
+  type: unix-time
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  since: 7.0.0
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Sets the expiration time of a key to a Unix timestamp.
+group: generic
+hidden: false
+history:
+- - 7.0.0
+  - 'Added options: `NX`, `XX`, `GT` and `LT`.'
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: EXPIREAT
+since: 1.2.0
+summary: Sets the expiration time of a key to a Unix timestamp.
+syntax_fmt: EXPIREAT key unix-time-seconds [NX | XX | GT | LT]
+syntax_str: unix-time-seconds [NX | XX | GT | LT]
+title: EXPIREAT
+---
+`EXPIREAT` has the same effect and semantic as [`EXPIRE`]({{< relref "/commands/expire" >}}), but instead of
+specifying the number of seconds representing the TTL (time to live), it takes
+an absolute [Unix timestamp][hewowu] (seconds since January 1, 1970). A
+timestamp in the past will delete the key immediately.
+
+[hewowu]: http://en.wikipedia.org/wiki/Unix_time
+
+Please for the specific semantics of the command refer to the documentation of
+[`EXPIRE`]({{< relref "/commands/expire" >}}).
+
+## Background
+
+`EXPIREAT` was introduced in order to convert relative timeouts to absolute
+timeouts for the AOF persistence mode.
+Of course, it can be used directly to specify that a given key should expire at
+a given time in the future.
+
+## Options
+
+The `EXPIREAT` command supports a set of options:
+
+* `NX` -- Set expiry only when the key has no expiry
+* `XX` -- Set expiry only when the key has an existing expiry
+* `GT` -- Set expiry only when the new expiry is greater than current one
+* `LT` -- Set expiry only when the new expiry is less than current one
+
+A non-volatile key is treated as an infinite TTL for the purpose of `GT` and `LT`.
+The `GT`, `LT` and `NX` options are mutually exclusive.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXISTS mykey
+EXPIREAT mykey 1293840000
+EXISTS mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: count
+    name: count
+    type: integer
+  - display_text: withscores
+    name: withscores
+    optional: true
+    token: WITHSCORES
+    type: pure-token
+  name: options
+  optional: true
+  type: block
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the number of members returned
+description: Returns one or more random members from a sorted set.
+group: sorted-set
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANDMEMBER
+since: 6.2.0
+summary: Returns one or more random members from a sorted set.
+syntax_fmt: ZRANDMEMBER key [count [WITHSCORES]]
+syntax_str: '[count [WITHSCORES]]'
+title: ZRANDMEMBER
+---
+When called with just the `key` argument, return a random element from the sorted set value stored at `key`.
+
+If the provided `count` argument is positive, return an array of **distinct elements**.
+The array's length is either `count` or the sorted set's cardinality ([`ZCARD`]({{< relref "/commands/zcard" >}})), whichever is lower.
+
+If called with a negative `count`, the behavior changes and the command is allowed to return the **same element multiple times**.
+In this case, the number of returned elements is the absolute value of the specified `count`.
+
+The optional `WITHSCORES` modifier changes the reply so it includes the respective scores of the randomly selected elements from the sorted set.
+
+## Examples
+
+{{% redis-cli %}}
+ZADD dadi 1 uno 2 due 3 tre 4 quattro 5 cinque 6 sei
+ZRANDMEMBER dadi
+ZRANDMEMBER dadi
+ZRANDMEMBER dadi -5 WITHSCORES
+{{% /redis-cli %}}
+
+
+## Specification of the behavior when count is passed
+
+When the `count` argument is a positive value this command behaves as follows:
+
+* No repeated elements are returned.
+* If `count` is bigger than the cardinality of the sorted set, the command will only return the whole sorted set without additional elements.
+* The order of elements in the reply is not truly random, so it is up to the client to shuffle them if needed.
+
+When the `count` is a negative value, the behavior changes as follows:
+
+* Repeating elements are possible.
+* Exactly `count` elements, or an empty array if the sorted set is empty (non-existing key), are always returned.
+* The order of elements in the reply is truly random.
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - arguments:
+    - display_text: maxlen
+      name: maxlen
+      token: MAXLEN
+      type: pure-token
+    - display_text: minid
+      name: minid
+      since: 6.2.0
+      token: MINID
+      type: pure-token
+    name: strategy
+    type: oneof
+  - arguments:
+    - display_text: equal
+      name: equal
+      token: '='
+      type: pure-token
+    - display_text: approximately
+      name: approximately
+      token: '~'
+      type: pure-token
+    name: operator
+    optional: true
+    type: oneof
+  - display_text: threshold
+    name: threshold
+    type: string
+  - display_text: count
+    name: count
+    optional: true
+    since: 6.2.0
+    token: LIMIT
+    type: integer
+  name: trim
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N), with N being the number of evicted entries. Constant times are very
+  small however, since entries are organized in macro nodes containing multiple entries
+  that can be released with a single deallocation.
+description: Deletes messages from the beginning of a stream.
+group: stream
+hidden: false
+hints:
+- nondeterministic_output
+history:
+- - 6.2.0
+  - Added the `MINID` trimming strategy and the `LIMIT` option.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XTRIM
+since: 5.0.0
+summary: Deletes messages from the beginning of a stream.
+syntax_fmt: "XTRIM key <MAXLEN | MINID> [= | ~] threshold [LIMIT\_count]"
+syntax_str: "<MAXLEN | MINID> [= | ~] threshold [LIMIT\_count]"
+title: XTRIM
+---
+`XTRIM` trims the stream by evicting older entries (entries with lower IDs) if needed.
+
+Trimming the stream can be done using one of these strategies:
+
+* `MAXLEN`: Evicts entries as long as the stream's length exceeds the specified `threshold`, where `threshold` is a positive integer.
+* `MINID`: Evicts entries with IDs lower than `threshold`, where `threshold` is a stream ID.
+
+For example, this will trim the stream to exactly the latest 1000 items:
+
+```
+XTRIM mystream MAXLEN 1000
+```
+
+Whereas in this example, all entries that have an ID lower than 649085820-0 will be evicted:
+
+```
+XTRIM mystream MINID 649085820
+```
+
+By default, or when provided with the optional `=` argument, the command performs exact trimming.
+
+Depending on the strategy, exact trimming means:
+
+* `MAXLEN`: the trimmed stream's length will be exactly the minimum between its original length and the specified `threshold`.
+* `MINID`: the oldest ID in the stream will be exactly the maximum between its original oldest ID and the specified `threshold`.
+
+Nearly exact trimming
+---
+
+Because exact trimming may require additional effort from the Redis server, the optional `~` argument can be provided to make it more efficient.
+
+For example:
+
+```
+XTRIM mystream MAXLEN ~ 1000
+```
+
+The `~` argument between the `MAXLEN` strategy and the `threshold` means that the user is requesting to trim the stream so its length is **at least** the `threshold`, but possibly slightly more.
+In this case, Redis will stop trimming early when performance can be gained (for example, when a whole macro node in the data structure can't be removed).
+This makes trimming much more efficient, and it is usually what you want, although after trimming, the stream may have few tens of additional entries over the `threshold`.
+
+Another way to control the amount of work done by the command when using the `~`, is the `LIMIT` clause. 
+When used, it specifies the maximal `count` of entries that will be evicted.
+When `LIMIT` and `count` aren't specified, the default value of 100 * the number of entries in a macro node will be implicitly used as the `count`.
+Specifying the value 0 as `count` disables the limiting mechanism entirely.
+
+## Examples
+
+{{% redis-cli %}}
+XADD mystream * field1 A field2 B field3 C field4 D
+XTRIM mystream MAXLEN 2
+XRANGE mystream - +
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(N) where N is the size of the hash.
+description: Returns all values in a hash.
+group: hash
+hidden: false
+hints:
+- nondeterministic_output_order
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HVALS
+since: 2.0.0
+summary: Returns all values in a hash.
+syntax_fmt: HVALS key
+syntax_str: ''
+title: HVALS
+---
+Returns all values in the hash stored at `key`.
+
+## Examples
+
+{{< clients-example cmds_hash hvals >}}
+redis> HSET myhash field1 "Hello"
+(integer) 1
+redis> HSET myhash field2 "World"
+(integer) 1
+redis> HVALS myhash
+1) "Hello"
+2) "World"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+HSET myhash field1 "Hello"
+HSET myhash field2 "World"
+HVALS myhash
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the length of a string value.
+group: string
+hidden: false
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: STRLEN
+since: 2.2.0
+summary: Returns the length of a string value.
+syntax_fmt: STRLEN key
+syntax_str: ''
+title: STRLEN
+---
+Returns the length of the string value stored at `key`.
+An error is returned when `key` holds a non-string value.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello world"
+STRLEN mykey
+STRLEN nonexisting
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: decrement
+  name: decrement
+  type: integer
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: Decrements a number from the integer value of a key. Uses 0 as initial
+  value if the key doesn't exist.
+group: string
+hidden: false
+key_specs:
+- RW: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: DECRBY
+since: 1.0.0
+summary: Decrements a number from the integer value of a key. Uses 0 as initial value
+  if the key doesn't exist.
+syntax_fmt: DECRBY key decrement
+syntax_str: decrement
+title: DECRBY
+---
+The `DECRBY` command reduces the value stored at the specified `key` by the specified `decrement`.
+If the key does not exist, it is initialized with a value of `0` before performing the operation.
+If the key's value is not of the correct type or cannot be represented as an integer, an error is returned.
+This operation is limited to 64-bit signed integers.
+
+See [`INCR`]({{< relref "/commands/incr" >}}) for extra information on increment/decrement operations.
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "10"
+DECRBY mykey 3
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: last-id
+  name: last-id
+  type: string
+- display_text: entries-added
+  name: entries-added
+  optional: true
+  since: 7.0.0
+  token: ENTRIESADDED
+  type: integer
+- display_text: max-deleted-id
+  name: max-deleted-id
+  optional: true
+  since: 7.0.0
+  token: MAXDELETEDID
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1)
+description: An internal command for replicating stream values.
+group: stream
+hidden: false
+history:
+- - 7.0.0
+  - Added the `entries_added` and `max_deleted_entry_id` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: XSETID
+since: 5.0.0
+summary: An internal command for replicating stream values.
+syntax_fmt: "XSETID key last-id [ENTRIESADDED\_entries-added]\n  [MAXDELETEDID\_max-deleted-id]"
+syntax_str: "last-id [ENTRIESADDED\_entries-added] [MAXDELETEDID\_max-deleted-id]"
+title: XSETID
+---
+The `XSETID` command is an internal command.
+It is used by a Redis master to replicate the last delivered ID of streams.---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: unix-time-milliseconds
+  name: unix-time-milliseconds
+  type: unix-time
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Set expiration for hash fields using an absolute Unix timestamp (milliseconds)
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HPEXPIREAT
+since: 7.4.0
+summary: Set expiry for hash field using an absolute Unix timestamp (milliseconds)
+syntax_fmt: "HPEXPIREAT key unix-time-milliseconds [NX | XX | GT | LT]\n  FIELDS\_\
+  numfields field [field ...]"
+syntax_str: "unix-time-milliseconds [NX | XX | GT | LT] FIELDS\_numfields field [field\
+  \ ...]"
+title: HPEXPIREAT
+---
+`HPEXPIREAT` has the same effect and semantics as [`HEXPIREAT`]({{< relref "/commands/hexpireat" >}}), but the Unix time at
+which the field will expire is specified in milliseconds since Unix epoch instead of seconds.
+
+## Options
+
+The `HPEXPIREAT` command supports a set of options:
+
+* `NX` -- For each specified field, set expiration only when the field has no expiration.
+* `XX` -- For each specified field, set expiration only when the field has an existing expiration.
+* `GT` -- For each specified field, set expiration only when the new expiration is greater than current one.
+* `LT` -- For each specified field, set expiration only when the new expiration is less than current one.
+
+A non-volatile key is treated as an infinite TTL for the purposes of `GT` and `LT`.
+The `NX`, `XX`, `GT`, and `LT` options are mutually exclusive.
+
+## Example
+
+```
+redis> HSET mykey field1 "hello" field2 "world"
+(integer 2)
+redis> HPEXPIREAT mykey 1715704971000 FIELDS 2 field1 field2
+1) (integer) 1
+2) (integer) 1
+redis> HPTTL mykey FIELDS 2 field1 field2
+1) (integer) 303340
+2) (integer) 303340
+```
+
+---
+acl_categories:
+- '@keyspace'
+- '@write'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1)
+description: Removes the expiration time of a key.
+group: generic
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: PERSIST
+since: 2.2.0
+summary: Removes the expiration time of a key.
+syntax_fmt: PERSIST key
+syntax_str: ''
+title: PERSIST
+---
+Remove the existing timeout on `key`, turning the key from _volatile_ (a key
+with an expire set) to _persistent_ (a key that will never expire as no timeout
+is associated).
+
+## Examples
+
+{{% redis-cli %}}
+SET mykey "Hello"
+EXPIRE mykey 10
+TTL mykey
+PERSIST mykey
+TTL mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for client connection commands.
+group: connection
+hidden: true
+linkTitle: CLIENT
+since: 2.4.0
+summary: A container for client connection commands.
+syntax_fmt: CLIENT
+syntax_str: ''
+title: CLIENT
+---
+This is a container command for client connection commands.
+
+To see the list of available commands you can call [`CLIENT HELP`]({{< relref "/commands/client-help" >}}).---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  deleted value, O(N) when path is evaluated to multiple values, where N is the size
+  of the key
+description: Deletes a value
+group: json
+hidden: false
+linkTitle: JSON.DEL
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Deletes a value
+syntax_fmt: JSON.DEL key [path]
+syntax_str: '[path]'
+title: JSON.DEL
+---
+Delete a value
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`. Nonexisting paths are ignored.
+
+{{% alert title="Note" color="warning" %}}
+ 
+Deleting an object's root is equivalent to deleting the key from Redis.
+
+{{% /alert %}}
+</details>
+
+## Return
+
+JSON.DEL returns an integer reply specified as the number of paths deleted (0 or more).
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}).
+
+## Examples
+
+<details open>
+<summary><b>Delete a value</b></summary>
+
+Create a JSON document.
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a": 1, "nested": {"a": 2, "b": 3}}'
+OK
+{{< / highlight >}}
+
+Delete specified values.
+
+{{< highlight bash >}}
+redis> JSON.DEL doc $..a
+(integer) 2
+{{< / highlight >}}
+
+Get the updated document.
+
+{{< highlight bash >}}
+redis> JSON.GET doc $
+"[{\"nested\":{\"b\":3}}]"
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`JSON.SET`]({{< relref "commands/json.set/" >}}) | [`JSON.ARRLEN`]({{< relref "commands/json.arrlen/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+
+
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns information about the connection.
+group: connection
+hidden: false
+hints:
+- nondeterministic_output
+linkTitle: CLIENT INFO
+since: 6.2.0
+summary: Returns information about the connection.
+syntax_fmt: CLIENT INFO
+syntax_str: ''
+title: CLIENT INFO
+---
+The command returns information and statistics about the current client connection in a mostly human readable format.
+
+The reply format is identical to that of [`CLIENT LIST`]({{< relref "/commands/client-list" >}}), and the content consists only of information about the current client.
+
+## Examples
+
+{{% redis-cli %}}
+CLIENT INFO
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) Where N is the number of paused clients
+description: Resumes processing commands from paused clients.
+group: connection
+hidden: false
+linkTitle: CLIENT UNPAUSE
+since: 6.2.0
+summary: Resumes processing commands from paused clients.
+syntax_fmt: CLIENT UNPAUSE
+syntax_str: ''
+title: CLIENT UNPAUSE
+---
+`CLIENT UNPAUSE` is used to resume command processing for all clients that were paused by [`CLIENT PAUSE`]({{< relref "/commands/client-pause" >}}).
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+- name: value
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1) when path is evaluated to a single value, O(N) when path is evaluated
+  to multiple values, where N is the size of the key
+description: Appends a string to a JSON string value at path
+group: json
+hidden: false
+linkTitle: JSON.STRAPPEND
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Appends a string to a JSON string value at path
+syntax_fmt: JSON.STRAPPEND key [path] value
+syntax_str: '[path] value'
+title: JSON.STRAPPEND
+---
+Append the `json-string` values to the string at `path`
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key to modify.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is value to append to one or more strings. 
+
+{{% alert title="About using strings with JSON commands" color="warning" %}}
+To specify a string as an array value to append, wrap the quoted string with an additional set of single quotes. Example: `'"silver"'`. For more detailed use, see [Examples](#examples).
+{{% /alert %}}
+</details>
+
+## Optional arguments
+
+<details open><summary><code>path</code></summary> 
+
+is JSONPath to specify. Default is root `$`.
+</details>
+
+## Return value 
+
+JSON.STRAPPEND returns an array of integer replies for each path, the string's new length, or `nil`, if the matching JSON value is not a string.
+For more information about replies, see [Redis serialization protocol specification]({{< relref "/develop/reference/protocol-spec" >}}). 
+
+## Examples
+
+{{< highlight bash >}}
+redis> JSON.SET doc $ '{"a":"foo", "nested": {"a": "hello"}, "nested2": {"a": 31}}'
+OK
+redis> JSON.STRAPPEND doc $..a '"baz"'
+1) (integer) 6
+2) (integer) 8
+3) (nil)
+redis> JSON.GET doc $
+"[{\"a\":\"foobaz\",\"nested\":{\"a\":\"hellobaz\"},\"nested2\":{\"a\":31}}]"
+{{< / highlight >}}
+
+## See also
+
+`JSON.ARRAPEND` | [`JSON.ARRINSERT`]({{< relref "commands/json.arrinsert/" >}}) 
+
+## Related topics
+
+* [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+* [Index and search JSON documents]({{< relref "/develop/interact/search-and-query/indexing/" >}})
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+- '@connection'
+arguments:
+- arguments:
+  - deprecated_since: 2.8.12
+    display_text: ip:port
+    name: old-format
+    type: string
+  - arguments:
+    - display_text: client-id
+      name: client-id
+      optional: true
+      since: 2.8.12
+      token: ID
+      type: integer
+    - arguments:
+      - display_text: normal
+        name: normal
+        token: NORMAL
+        type: pure-token
+      - display_text: master
+        name: master
+        since: 3.2.0
+        token: MASTER
+        type: pure-token
+      - display_text: slave
+        name: slave
+        token: SLAVE
+        type: pure-token
+      - display_text: replica
+        name: replica
+        since: 5.0.0
+        token: REPLICA
+        type: pure-token
+      - display_text: pubsub
+        name: pubsub
+        token: PUBSUB
+        type: pure-token
+      name: client-type
+      optional: true
+      since: 2.8.12
+      token: TYPE
+      type: oneof
+    - display_text: username
+      name: username
+      optional: true
+      token: USER
+      type: string
+    - display_text: ip:port
+      name: addr
+      optional: true
+      token: ADDR
+      type: string
+    - display_text: ip:port
+      name: laddr
+      optional: true
+      since: 6.2.0
+      token: LADDR
+      type: string
+    - arguments:
+      - display_text: 'yes'
+        name: 'yes'
+        token: 'YES'
+        type: pure-token
+      - display_text: 'no'
+        name: 'no'
+        token: 'NO'
+        type: pure-token
+      name: skipme
+      optional: true
+      token: SKIPME
+      type: oneof
+    - display_text: maxage
+      name: maxage
+      optional: true
+      since: 7.4.0
+      token: MAXAGE
+      type: integer
+    multiple: true
+    name: new-format
+    type: oneof
+  name: filter
+  type: oneof
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of client connections
+description: Terminates open connections.
+group: connection
+hidden: false
+history:
+- - 2.8.12
+  - Added new filter format.
+- - 2.8.12
+  - '`ID` option.'
+- - 3.2.0
+  - Added `master` type in for `TYPE` option.
+- - 5.0.0
+  - Replaced `slave` `TYPE` with `replica`. `slave` still supported for backward compatibility.
+- - 6.2.0
+  - '`LADDR` option.'
+- - 7.4.0
+  - '`MAXAGE` option.'
+linkTitle: CLIENT KILL
+since: 2.4.0
+summary: Terminates open connections.
+syntax_fmt: "CLIENT KILL <ip:port | <[ID\_client-id] | [TYPE\_<NORMAL | MASTER |\n\
+  \  SLAVE | REPLICA | PUBSUB>] | [USER\_username] | [ADDR\_ip:port] |\n  [LADDR\_\
+  ip:port] | [SKIPME\_<YES | NO>] | [MAXAGE\_maxage]\n  [[ID\_client-id] | [TYPE\_\
+  <NORMAL | MASTER | SLAVE | REPLICA |\n  PUBSUB>] | [USER\_username] | [ADDR\_ip:port]\
+  \ | [LADDR\_ip:port] |\n  [SKIPME\_<YES | NO>] | [MAXAGE\_maxage] ...]>>"
+syntax_str: ''
+title: CLIENT KILL
+---
+The `CLIENT KILL` command closes a given client connection. This command support two formats, the old format:
+
+    CLIENT KILL addr:port
+
+The `ip:port` should match a line returned by the [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) command (`addr` field).
+
+The new format:
+
+    CLIENT KILL <filter> <value> ... ... <filter> <value>
+
+With the new form it is possible to kill clients by different attributes
+instead of killing just by address. The following filters are available:
+
+* `CLIENT KILL ADDR ip:port`. This is exactly the same as the old three-arguments behavior.
+* `CLIENT KILL LADDR ip:port`. Kill all clients connected to specified local (bind) address.
+* `CLIENT KILL ID client-id`. Allows to kill a client by its unique `ID` field. Client `ID`'s are retrieved using the [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) command.
+* `CLIENT KILL TYPE type`, where *type* is one of `normal`, `master`, `replica` and `pubsub`. This closes the connections of **all the clients** in the specified class. Note that clients blocked into the [`MONITOR`]({{< relref "/commands/monitor" >}}) command are considered to belong to the `normal` class.
+* `CLIENT KILL USER username`. Closes all the connections that are authenticated with the specified [ACL]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) username, however it returns an error if the username does not map to an existing ACL user.
+* `CLIENT KILL SKIPME yes/no`. By default this option is set to `yes`, that is, the client calling the command will not get killed, however setting this option to `no` will have the effect of also killing the client calling the command.
+* `CLIENT KILL MAXAGE maxage`. Closes all the connections that are older than the specified age, in seconds. Added in Redis v7.4.
+
+It is possible to provide multiple filters at the same time. The command will handle multiple filters via logical AND. For example:
+
+    CLIENT KILL addr 127.0.0.1:12345 type pubsub
+
+is valid and will kill only a pubsub client with the specified address. This format containing multiple filters is rarely useful currently.
+
+When the new form is used the command no longer returns `OK` or an error, but instead the number of killed clients, that may be zero.
+
+## CLIENT KILL and Redis Sentinel
+
+Recent versions of Redis Sentinel (Redis 2.8.12 or greater) use CLIENT KILL
+in order to kill clients when an instance is reconfigured, in order to
+force clients to perform the handshake with one Sentinel again and update
+its configuration.
+
+## Notes
+
+Due to the single-threaded nature of Redis, it is not possible to
+kill a client connection while it is executing a command. From
+the client point of view, the connection can never be closed
+in the middle of the execution of a command. However, the client
+will notice the connection has been closed only when the
+next command is sent (and results in network error).
+---
+acl_categories:
+- '@write'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: seconds
+  name: seconds
+  type: integer
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  - display_text: gt
+    name: gt
+    token: GT
+    type: pure-token
+  - display_text: lt
+    name: lt
+    token: LT
+    type: pure-token
+  name: condition
+  optional: true
+  type: oneof
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -6
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Set expiration for hash fields using relative time to expire (seconds)
+group: hash
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: HEXPIRE
+since: 7.4.0
+summary: Set expiry for hash field using relative time to expire (seconds)
+syntax_fmt: "HEXPIRE key seconds [NX | XX | GT | LT] FIELDS\_numfields field\n  [field\
+  \ ...]"
+syntax_str: "seconds [NX | XX | GT | LT] FIELDS\_numfields field [field ...]"
+title: HEXPIRE
+---
+Set an expiration (TTL or time to live) on one or more fields of a given hash key. You must specify at least one field.
+Field(s) will automatically be deleted from the hash key when their TTLs expire.
+
+Field expirations will only be cleared by commands that delete or overwrite the
+contents of the hash fields, including [`HDEL`]({{< relref "/commands/hdel" >}}) and [`HSET`]({{< relref "/commands/hset" >}})
+commands.
+This means that all the operations that conceptually _alter_ the value stored at a hash key's field without replacing it with a new one will leave the TTL untouched.
+
+You can clear the TTL using the [`HPERSIST`]({{< relref "/commands/hpersist" >}}) command, which turns the hash field back into a persistent field.
+
+Note that calling `HEXPIRE`/[`HPEXPIRE`]({{< relref "/commands/hpexpire" >}}) with a zero TTL or
+[`HEXPIREAT`]({{< relref "/commands/hexpireat" >}})/[`HPEXPIREAT`]({{< relref "/commands/hpexpireat" >}}) with a time in the past will result in the hash field being deleted.
+
+## Options
+
+The `HEXPIRE` command supports a set of options:
+
+* `NX` -- For each specified field, set expiration only when the field has no expiration.
+* `XX` -- For each specified field, set expiration only when the field has an existing expiration.
+* `GT` -- For each specified field, set expiration only when the new expiration is greater than current one.
+* `LT` -- For each specified field, set expiration only when the new expiration is less than current one.
+
+A non-volatile field is treated as an infinite TTL for the purpose of `GT` and `LT`.
+The `NX`, `XX`, `GT`, and `LT` options are mutually exclusive.
+
+## Refreshing expires
+
+You can call `HEXPIRE` using as argument a field that already has an
+existing TTL set.
+In this case, the time to live is _updated_ to the new value.
+
+## Example
+
+```
+redis> HEXPIRE no-key 20 NX FIELDS 2 field1 field2
+(nil)
+redis> HSET mykey field1 "hello" field2 "world"
+(integer 2)
+redis> HEXPIRE mykey 10 FIELDS 3 field1 field2 field3
+1) (integer) 1
+2) (integer) 1
+3) (integer) -2
+redis> HGETALL mykey
+(empty array)
+```
+
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(N) where N is the number of members to be removed.
+description: Removes one or more members from a set. Deletes the set if the last member
+  was removed.
+group: set
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple `member` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: SREM
+since: 1.0.0
+summary: Removes one or more members from a set. Deletes the set if the last member
+  was removed.
+syntax_fmt: SREM key member [member ...]
+syntax_str: member [member ...]
+title: SREM
+---
+Remove the specified members from the set stored at `key`.
+Specified members that are not a member of this set are ignored.
+If `key` does not exist, it is treated as an empty set and this command returns
+`0`.
+
+An error is returned when the value stored at `key` is not a set.
+
+## Examples
+
+{{% redis-cli %}}
+SADD myset "one"
+SADD myset "two"
+SADD myset "three"
+SREM myset "one"
+SREM myset "four"
+SMEMBERS myset
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: cluster
+hidden: true
+linkTitle: CLUSTER HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: CLUSTER HELP
+syntax_str: ''
+title: CLUSTER HELP
+---
+The `CLUSTER HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for Access List Control commands.
+group: server
+hidden: true
+linkTitle: ACL
+since: 6.0.0
+summary: A container for Access List Control commands.
+syntax_fmt: ACL
+syntax_str: ''
+title: ACL
+---
+This is a container command for [Access Control List]({{< relref "/operate/oss_and_stack/management/security/acl" >}}) commands.
+
+To see the list of available commands you can call [`ACL HELP`]({{< relref "/commands/acl-help" >}}).
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: server
+hidden: true
+linkTitle: COMMAND HELP
+since: 5.0.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: COMMAND HELP
+syntax_str: ''
+title: COMMAND HELP
+---
+The `COMMAND HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@tdigest'
+- '@write'
+- '@fast'
+arguments:
+- name: key
+  type: key
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: 'Resets a t-digest sketch: empty the sketch and re-initializes it.'
+group: tdigest
+hidden: false
+linkTitle: TDIGEST.RESET
+module: Bloom
+since: 2.4.0
+stack_path: docs/data-types/probabilistic
+summary: 'Resets a t-digest sketch: empty the sketch and re-initializes it.'
+syntax_fmt: TDIGEST.RESET key
+syntax_str: ''
+title: TDIGEST.RESET
+---
+Resets a t-digest sketch: empty the sketch and re-initializes it.
+
+## Required arguments
+<details open><summary><code>key</code></summary>
+is key name for an existing t-digest sketch.
+</details>
+
+## Return value
+
+[Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}}) - `OK` if executed correctly, or [] otherwise.
+
+## Examples
+
+{{< highlight bash >}}
+redis> TDIGEST.RESET t
+OK
+{{< / highlight >}}
+---
+acl_categories:
+- '@slow'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: Depends on subcommand.
+description: A container for stream introspection commands.
+group: stream
+hidden: true
+linkTitle: XINFO
+since: 5.0.0
+summary: A container for stream introspection commands.
+syntax_fmt: XINFO
+syntax_str: ''
+title: XINFO
+---
+This is a container command for stream introspection commands.
+
+To see the list of available commands you can call [`XINFO HELP`]({{< relref "/commands/xinfo-help" >}}).
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: field
+  name: field
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(1)
+description: Returns the value of a field in a hash.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HGET
+since: 2.0.0
+summary: Returns the value of a field in a hash.
+syntax_fmt: HGET key field
+syntax_str: field
+title: HGET
+---
+Returns the value associated with `field` in the hash stored at `key`.
+
+## Examples
+
+{{< clients-example cmds_hash hget >}}
+> HSET myhash field1 "foo"
+(integer) 1
+> HGET myhash field1
+"foo"
+> HGET myhash field2
+(nil)
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+HSET myhash field1 "foo"
+HGET myhash field1
+HGET myhash field2
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@read'
+- '@hash'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: numfields
+    name: numfields
+    type: integer
+  - display_text: field
+    multiple: true
+    name: field
+    type: string
+  name: fields
+  token: FIELDS
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+- fast
+complexity: O(N) where N is the number of specified fields
+description: Returns the TTL in milliseconds of a hash field.
+group: hash
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: HPTTL
+since: 7.4.0
+summary: Returns the TTL in milliseconds of a hash field.
+syntax_fmt: "HPTTL key FIELDS\_numfields field [field ...]"
+syntax_str: "FIELDS\_numfields field [field ...]"
+title: HPTTL
+---
+Like [`HTTL`]({{< relref "/commands/httl" >}}), this command returns the remaining TTL (time to live) of a field that has an
+expiration set, but in milliseconds instead of seconds.
+
+## Example
+
+```
+redis> HPTTL no-key FIELDS 3 field1 field2 field3
+(nil)
+redis> HSET mykey field1 "hello" field2 "world"
+(integer) 2
+redis> HEXPIRE mykey 300 FIELDS 2 field1 field3
+1) (integer) 1
+2) (integer) -2
+redis> HPTTL mykey FIELDS 3 field1 field2 field3
+1) (integer) 292202
+2) (integer) -1
+3) (integer) -2
+```
+
+---
+acl_categories:
+- '@timeseries'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: fromTimestamp
+  type: string
+- name: toTimestamp
+  type: string
+- name: LATEST
+  optional: true
+  since: 1.8.0
+  type: string
+- multiple: true
+  name: Timestamp
+  optional: true
+  token: FILTER_BY_TS
+  type: integer
+- arguments:
+  - name: FILTER_BY_VALUE
+    token: FILTER_BY_VALUE
+    type: pure-token
+  - name: min
+    type: double
+  - name: max
+    type: double
+  name: fbv
+  optional: true
+  type: block
+- name: count
+  optional: true
+  token: COUNT
+  type: integer
+- arguments:
+  - name: value
+    optional: true
+    token: ALIGN
+    type: integer
+  - arguments:
+    - name: avg
+      token: AVG
+      type: pure-token
+    - name: first
+      token: FIRST
+      type: pure-token
+    - name: last
+      token: LAST
+      type: pure-token
+    - name: min
+      token: MIN
+      type: pure-token
+    - name: max
+      token: MAX
+      type: pure-token
+    - name: sum
+      token: SUM
+      type: pure-token
+    - name: range
+      token: RANGE
+      type: pure-token
+    - name: count
+      token: COUNT
+      type: pure-token
+    - name: std.p
+      token: STD.P
+      type: pure-token
+    - name: std.s
+      token: STD.S
+      type: pure-token
+    - name: var.p
+      token: VAR.P
+      type: pure-token
+    - name: var.s
+      token: VAR.S
+      type: pure-token
+    - name: twa
+      since: 1.8.0
+      token: TWA
+      type: pure-token
+    name: aggregator
+    token: AGGREGATION
+    type: oneof
+  - name: bucketDuration
+    type: integer
+  - name: buckettimestamp
+    optional: true
+    since: 1.8.0
+    token: BUCKETTIMESTAMP
+    type: pure-token
+  - name: empty
+    optional: true
+    since: 1.8.0
+    token: EMPTY
+    type: pure-token
+  name: aggregation
+  optional: true
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n/m+k) where n = Number of data points, m = Chunk size (data points
+  per chunk), k = Number of data points that are in the requested range
+description: Query a range in reverse direction
+group: timeseries
+hidden: false
+linkTitle: TS.REVRANGE
+module: TimeSeries
+since: 1.4.0
+stack_path: docs/data-types/timeseries
+summary: Query a range in reverse direction
+syntax: "TS.REVRANGE key fromTimestamp toTimestamp\n  [LATEST]\n  [FILTER_BY_TS ts...]\n\
+  \  [FILTER_BY_VALUE min max]\n  [COUNT count]\n  [[ALIGN align] AGGREGATION aggregator\
+  \ bucketDuration [BUCKETTIMESTAMP bt] [EMPTY]]\n"
+syntax_fmt: "TS.REVRANGE key fromTimestamp toTimestamp [LATEST]\n  [FILTER_BY_TS\_\
+  Timestamp [Timestamp ...]] [FILTER_BY_VALUE min max]\n  [COUNT\_count] [[ALIGN\_\
+  value] AGGREGATION\_<AVG | FIRST | LAST | MIN\n  | MAX | SUM | RANGE | COUNT | STD.P\
+  \ | STD.S | VAR.P | VAR.S | TWA>\n  bucketDuration [BUCKETTIMESTAMP] [EMPTY]]"
+syntax_str: "fromTimestamp toTimestamp [LATEST] [FILTER_BY_TS\_Timestamp [Timestamp\
+  \ ...]] [FILTER_BY_VALUE min max] [COUNT\_count] [[ALIGN\_value] AGGREGATION\_<AVG\
+  \ | FIRST | LAST | MIN | MAX | SUM | RANGE | COUNT | STD.P | STD.S | VAR.P | VAR.S\
+  \ | TWA> bucketDuration [BUCKETTIMESTAMP] [EMPTY]]"
+title: TS.REVRANGE
+---
+
+Query a range in reverse direction
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>key</code></summary>
+
+is the key name for the time series.
+</details>
+
+<details open>
+<summary><code>fromTimestamp</code></summary>
+
+is start timestamp for the range query (integer Unix timestamp in milliseconds) or `-` to denote the timestamp of the earliest sample in the time series.
+</details>
+
+<details open>
+<summary><code>toTimestamp</code></summary>
+
+is end timestamp for the range query (integer Unix timestamp in milliseconds) or `+` to denote the timestamp of the latest sample in the time series.
+
+<note><b>Note:</b>  When the time series is a compaction, the last compacted value may aggregate raw values with timestamp beyond `toTimestamp`. That is because `toTimestamp` limits only the timestamp of the compacted value, which is the start time of the raw bucket that was compacted.</note>
+
+</details>
+
+## Optional arguments
+
+<details open>
+<summary><code>LATEST</code> (since RedisTimeSeries v1.8)</summary>
+
+is used when a time series is a compaction. With `LATEST`, TS.REVRANGE also reports the compacted value of the latest, possibly partial, bucket, given that this bucket's start time falls within `[fromTimestamp, toTimestamp]`. Without `LATEST`, TS.REVRANGE does not report the latest, possibly partial, bucket. When a time series is not a compaction, `LATEST` is ignored.
+  
+The data in the latest bucket of a compaction is possibly partial. A bucket is _closed_ and compacted only upon arrival of a new sample that _opens_ a new _latest_ bucket. There are cases, however, when the compacted value of the latest, possibly partial, bucket is also required. In such a case, use `LATEST`.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_TS ts...</code> (since RedisTimeSeries v1.6)</summary>
+
+filters samples by a list of specific timestamps. A sample passes the filter if its exact timestamp is specified and falls within `[fromTimestamp, toTimestamp]`.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>FILTER_BY_VALUE min max</code> (since RedisTimeSeries v1.6)</summary>
+
+filters samples by minimum and maximum values.
+
+When used together with `AGGREGATION`: samples are filtered before being aggregated.
+</details>
+
+<details open>
+<summary><code>COUNT count</code></summary>
+
+When used without `AGGREGATION`: limits the number of reported samples.
+
+When used together with `AGGREGATION`: limits the number of reported buckets.
+</details>
+
+<details open>
+<summary><code>ALIGN align</code> (since RedisTimeSeries v1.6)</summary>
+
+is a time bucket alignment control for `AGGREGATION`. It controls the time bucket timestamps by changing the reference timestamp on which a bucket is defined. 
+Values include:
+   
+ - `start` or `-`: The reference timestamp will be the query start interval time (`fromTimestamp`) which can't be `-`
+ - `end` or `+`: The reference timestamp will be the query end interval time (`toTimestamp`) which can't be `+`
+ - A specific timestamp: align the reference timestamp to a specific time
+   
+<note><b>NOTE:</b> When not provided, alignment is set to `0`.</note>
+
+</details>
+
+<details open>
+<summary><code>AGGREGATION aggregator bucketDuration</code></summary>
+aggregates samples into time buckets, where:
+
+  - `aggregator` takes one of the following aggregation types:
+
+    | `aggregator` | Description                                                                    |
+    | ------------ | ------------------------------------------------------------------------------ |
+    | `avg`        | Arithmetic mean of all values                                                  |
+    | `sum`        | Sum of all values                                                              |
+    | `min`        | Minimum value                                                                  |
+    | `max`        | Maximum value                                                                  |
+    | `range`      | Difference between the maximum and the minimum value                           |
+    | `count`      | Number of values                                                               |
+    | `first`      | Value with lowest timestamp in the bucket                                      |
+    | `last`       | Value with highest timestamp in the bucket                                     |
+    | `std.p`      | Population standard deviation of the values                                    |
+    | `std.s`      | Sample standard deviation of the values                                        |
+    | `var.p`      | Population variance of the values                                              |
+    | `var.s`      | Sample variance of the values                                                  |
+    | `twa`        | Time-weighted average over the bucket's timeframe (since RedisTimeSeries v1.8) |
+
+  - `bucketDuration` is duration of each bucket, in milliseconds.
+  
+  Without `ALIGN`, bucket start times are multiples of `bucketDuration`.
+  
+  With `ALIGN align`, bucket start times are multiples of `bucketDuration` with remainder `align % bucketDuration`.
+  
+  The first bucket start time is less than or equal to `fromTimestamp`.  
+</details>
+
+<details open>
+<summary><code>[BUCKETTIMESTAMP bt]</code> (since RedisTimeSeries v1.8)</summary>
+
+controls how bucket timestamps are reported.
+
+| `bt`             | Timestamp reported for each bucket                            |
+| ---------------- | ------------------------------------------------------------- |
+| `-` or `start`   | the bucket's start time (default)                             |
+| `+` or `end`     | the bucket's end time                                         |
+| `~` or `mid`     | the bucket's mid time (rounded down if not an integer)        |
+</details>
+
+<details open>
+<summary><code>[EMPTY]</code> (since RedisTimeSeries v1.8)</summary>
+is a flag, which, when specified, reports aggregations also for empty buckets.
+
+| `aggregator`         | Value reported for each empty bucket |
+| -------------------- | ------------------------------------ |
+| `sum`, `count`       | `0`                                  |
+| `last`               | The value of the last sample before the bucket's start. `NaN` when no such sample. |
+| `twa`                | Average value over the bucket's timeframe based on linear interpolation of the last sample before the bucket's start and the first sample after the bucket's end. `NaN` when no such samples. |
+| `min`, `max`, `range`, `avg`, `first`, `std.p`, `std.s` | `NaN` |
+
+Regardless of the values of `fromTimestamp` and `toTimestamp`, no data is reported for buckets that end before the earliest sample or begin after the latest sample in the time series.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of ([Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), [Simple string reply]({{< relref "/develop/reference/protocol-spec#simple-strings" >}})) pairs representing (timestamp, value(double))
+- [] (e.g., on invalid filter value)
+
+## Complexity
+
+TS.REVRANGE complexity can be improved in the future by using binary search to find the start of the range, which makes this `O(Log(n/m)+k*m)`.
+But, because `m` is small, you can disregard it and look at the operation as `O(Log(n)+k)`.
+
+## Examples
+
+<details open>
+<summary><b>Filter results by timestamp or sample value</b></summary>
+
+Consider a metric where acceptable values are between -100 and 100, and the value 9999 is used as an indication of bad measurement.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE temp:TLV LABELS type temp location TLV
+OK
+127.0.0.1:6379> TS.MADD temp:TLV 1000 30 temp:TLV 1010 35 temp:TLV 1020 9999 temp:TLV 1030 40
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+4) (integer) 1030
+{{< / highlight >}}
+
+Now, retrieve all values except out-of-range values.
+
+{{< highlight bash >}}
+TS.REVRANGE temp:TLV - + FILTER_BY_VALUE -100 100
+1) 1) (integer) 1030
+   2) 40
+2) 1) (integer) 1010
+   2) 35
+3) 1) (integer) 1000
+   2) 30
+{{< / highlight >}}
+
+Now, retrieve the average value, while ignoring out-of-range values.
+
+{{< highlight bash >}}
+TS.REVRANGE temp:TLV - + FILTER_BY_VALUE -100 100 AGGREGATION avg 1000
+1) 1) (integer) 1000
+   2) 35
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Align aggregation buckets</b></summary>
+
+To demonstrate alignment, let’s create a stock and add prices at three different timestamps.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.CREATE stock:A LABELS type stock name A
+OK
+127.0.0.1:6379> TS.MADD stock:A 1000 100 stock:A 1010 110 stock:A 1020 120
+1) (integer) 1000
+2) (integer) 1010
+3) (integer) 1020
+127.0.0.1:6379> TS.MADD stock:A 2000 200 stock:A 2010 210 stock:A 2020 220
+1) (integer) 2000
+2) (integer) 2010
+3) (integer) 2020
+127.0.0.1:6379> TS.MADD stock:A 3000 300 stock:A 3010 310 stock:A 3020 320
+1) (integer) 3000
+2) (integer) 3010
+3) (integer) 3020
+{{< / highlight >}}
+
+Next, aggregate without using `ALIGN`, defaulting to alignment 0.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.REVRANGE stock:A - + AGGREGATION min 20
+1) 1) (integer) 3020
+   2) 320
+2) 1) (integer) 3000
+   2) 300
+3) 1) (integer) 2020
+   2) 220
+4) 1) (integer) 2000
+   2) 200
+5) 1) (integer) 1020
+   2) 120
+6) 1) (integer) 1000
+   2) 100
+{{< / highlight >}}
+
+And now set `ALIGN` to 10 to have a bucket start at time 10, and align all the buckets with a 20 milliseconds duration.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.REVRANGE stock:A - + ALIGN 10 AGGREGATION min 20
+1) 1) (integer) 3010
+   2) 310
+2) 1) (integer) 2990
+   2) 300
+3) 1) (integer) 2010
+   2) 210
+4) 1) (integer) 1990
+   2) 200
+5) 1) (integer) 1010
+   2) 110
+6) 1) (integer) 990
+   2) 100
+{{< / highlight >}}
+
+When the start timestamp for the range query is explicitly stated (not `-`), you can set ALIGN to that time by setting align to `-` or to `start`.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.REVRANGE stock:A 5 + ALIGN - AGGREGATION min 20
+1) 1) (integer) 3005
+   2) 310
+2) 1) (integer) 2985
+   2) 300
+3) 1) (integer) 2005
+   2) 210
+4) 1) (integer) 1985
+   2) 200
+5) 1) (integer) 1005
+   2) 110
+6) 1) (integer) 985
+   2) 100
+{{< / highlight >}}
+
+Similarly, when the end timestamp for the range query is explicitly stated, you can set ALIGN to that time by setting align to `+` or to `end`.
+</details>
+
+## See also
+
+[`TS.RANGE`]({{< relref "commands/ts.range/" >}}) | [`TS.MRANGE`]({{< relref "commands/ts.mrange/" >}}) | [`TS.MREVRANGE`]({{< relref "commands/ts.mrevrange/" >}})
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@read'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: full
+    name: full
+    token: FULL
+    type: pure-token
+  - display_text: count
+    name: count
+    optional: true
+    token: COUNT
+    type: integer
+  name: full-block
+  optional: true
+  type: block
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns information about a stream.
+group: stream
+hidden: false
+history:
+- - 6.0.0
+  - Added the `FULL` modifier.
+- - 7.0.0
+  - Added the `max-deleted-entry-id`, `entries-added`, `recorded-first-entry-id`,
+    `entries-read` and `lag` fields
+- - 7.2.0
+  - Added the `active-time` field, and changed the meaning of `seen-time`.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: XINFO STREAM
+since: 5.0.0
+summary: Returns information about a stream.
+syntax_fmt: "XINFO STREAM key [FULL [COUNT\_count]]"
+syntax_str: "[FULL [COUNT\_count]]"
+title: XINFO STREAM
+---
+This command returns information about the stream stored at `<key>`.
+
+The informative details provided by this command are:
+
+* **length**: the number of entries in the stream (see [`XLEN`]({{< relref "/commands/xlen" >}}))
+* **radix-tree-keys**: the number of keys in the underlying radix data structure
+* **radix-tree-nodes**: the number of nodes in the underlying radix data structure
+* **groups**: the number of consumer groups defined for the stream
+* **last-generated-id**: the ID of the least-recently entry that was added to the stream
+* **max-deleted-entry-id**: the maximal entry ID that was deleted from the stream
+* **entries-added**: the count of all entries added to the stream during its lifetime
+* **first-entry**: the ID and field-value tuples of the first entry in the stream
+* **last-entry**: the ID and field-value tuples of the last entry in the stream
+
+### The `FULL` modifier
+
+The optional `FULL` modifier provides a more verbose reply.
+When provided, the `FULL` reply includes an **entries** array that consists of the stream entries (ID and field-value tuples) in ascending order.
+Furthermore, **groups** is also an array, and for each of the consumer groups it consists of the information reported by [`XINFO GROUPS`]({{< relref "/commands/xinfo-groups" >}}) and [`XINFO CONSUMERS`]({{< relref "/commands/xinfo-consumers" >}}).
+
+The following information is provided for each of the groups:
+
+* **name**: the consumer group's name
+* **last-delivered-id**: the ID of the last entry delivered to the group's consumers
+* **entries-read**: the logical "read counter" of the last entry delivered to the group's consumers
+* **lag**: the number of entries in the stream that are still waiting to be delivered to the group's consumers, or a NULL when that number can't be determined.
+* **pel-count**: the length of the group's pending entries list (PEL), which are messages that were delivered but are yet to be acknowledged
+* **pending**: an array with pending entries information (see below)
+* **consumers**: an array with consumers information (see below)
+
+The following information is provided for each pending entry:
+
+1. The ID of the message.
+2. The name of the consumer that fetched the message and has still to acknowledge it. We call it the current *owner* of the message.
+3. The UNIX timestamp of when the message was delivered to this consumer.
+4. The number of times this message was delivered.
+
+The following information is provided for each consumer:
+
+* **name**: the consumer's name
+* **seen-time**: the UNIX timestamp of the last attempted interaction (Examples: [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), [`XCLAIM`]({{< relref "/commands/xclaim" >}}), [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}))
+* **active-time**: the UNIX timestamp of the last successful interaction (Examples: [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) that actually read some entries into the PEL, [`XCLAIM`]({{< relref "/commands/xclaim" >}})/[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) that actually claimed some entries)
+* **pel-count**: the number of entries in the PEL: pending messages for the consumer, which are messages that were delivered but are yet to be acknowledged
+* **pending**: an array with pending entries information, has the same structure as described above, except the consumer name is omitted (redundant, since anyway we are in a specific consumer context)
+
+Note that before Redis 7.2.0, **seen-time** used to denote the last successful interaction.
+In 7.2.0, **active-time** was added and **seen-time** was changed to denote the last attempted interaction.
+
+The `COUNT` option can be used to limit the number of stream and PEL entries that are returned (The first `<count>` entries are returned).
+The default `COUNT` is 10 and a `COUNT` of 0 means that all entries will be returned (execution time may be long if the stream has a lot of entries).
+
+## Examples
+
+Default reply:
+
+```
+> XINFO STREAM mystream
+ 1) "length"
+ 2) (integer) 2
+ 3) "radix-tree-keys"
+ 4) (integer) 1
+ 5) "radix-tree-nodes"
+ 6) (integer) 2
+ 7) "last-generated-id"
+ 8) "1638125141232-0"
+ 9) "max-deleted-entry-id"
+10) "0-0"
+11) "entries-added"
+12) (integer) 2
+13) "recorded-first-entry-id"
+14) "1719505260513-0"
+15) "groups"
+16) (integer) 1
+17) "first-entry"
+18) 1) "1638125133432-0"
+    2) 1) "message"
+       2) "apple"
+19) "last-entry"
+20) 1) "1638125141232-0"
+    2) 1) "message"
+       2) "banana"
+```
+
+Full reply:
+
+```
+> XADD mystream * foo bar
+"1638125133432-0"
+> XADD mystream * foo bar2
+"1638125141232-0"
+> XGROUP CREATE mystream mygroup 0-0
+OK
+> XREADGROUP GROUP mygroup Alice COUNT 1 STREAMS mystream >
+1) 1) "mystream"
+   2) 1) 1) "1638125133432-0"
+         2) 1) "foo"
+            2) "bar"
+> XINFO STREAM mystream FULL
+ 1) "length"
+ 2) (integer) 2
+ 3) "radix-tree-keys"
+ 4) (integer) 1
+ 5) "radix-tree-nodes"
+ 6) (integer) 2
+ 7) "last-generated-id"
+ 8) "1638125141232-0"
+ 9) "max-deleted-entry-id"
+10) "0-0"
+11) "entries-added"
+12) (integer) 2
+13) "recorded-first-entry-id"
+14) "1719505260513-0"
+15) "entries"
+16) 1) 1) "1638125133432-0"
+       2) 1) "foo"
+          2) "bar"
+    2) 1) "1638125141232-0"
+       2) 1) "foo"
+          2) "bar2"
+17) "groups"
+18) 1)  1) "name"
+        2) "mygroup"
+        3) "last-delivered-id"
+        4) "1638125133432-0"
+        5) "entries-read"
+        6) (integer) 1
+        7) "lag"
+        8) (integer) 1
+        9) "pel-count"
+       10) (integer) 1
+       11) "pending"
+       12) 1) 1) "1638125133432-0"
+              2) "Alice"
+              3) (integer) 1638125153423
+              4) (integer) 1
+       13) "consumers"
+       14) 1) 1) "name"
+              2) "Alice"
+              3) "seen-time"
+              4) (integer) 1638125133422
+              5) "active-time"
+              6) (integer) 1638125133432
+              7) "pel-count"
+              8) (integer) 1
+              9) "pending"
+              10) 1) 1) "1638125133432-0"
+                     2) (integer) 1638125133432
+                     3) (integer) 1
+```
+---
+acl_categories:
+- '@write'
+- '@stream'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- display_text: id
+  multiple: true
+  name: id
+  type: string
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- fast
+complexity: O(1) for each message ID processed.
+description: Returns the number of messages that were successfully acknowledged by
+  the consumer group member of a stream.
+group: stream
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: XACK
+since: 5.0.0
+summary: Returns the number of messages that were successfully acknowledged by the
+  consumer group member of a stream.
+syntax_fmt: XACK key group id [id ...]
+syntax_str: group id [id ...]
+title: XACK
+---
+The `XACK` command removes one or multiple messages from the
+*Pending Entries List* (PEL) of a stream consumer group. A message is pending,
+and as such stored inside the PEL, when it was delivered to some consumer,
+normally as a side effect of calling [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}), or when a consumer took
+ownership of a message calling [`XCLAIM`]({{< relref "/commands/xclaim" >}}). The pending message was delivered to
+some consumer but the server is yet not sure it was processed at least once.
+So new calls to [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) to grab the messages history for a consumer
+(for instance using an ID of 0), will return such message.
+Similarly the pending message will be listed by the [`XPENDING`]({{< relref "/commands/xpending" >}}) command,
+that inspects the PEL.
+
+Once a consumer *successfully* processes a message, it should call `XACK`
+so that such message does not get processed again, and as a side effect,
+the PEL entry about this message is also purged, releasing memory from the
+Redis server.
+
+## Examples
+
+```
+redis> XACK mystream mygroup 1526569495631-0
+(integer) 1
+```
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  multiple: true
+  name: element
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each element added, so O(N) to add N elements when the command
+  is called with multiple arguments.
+description: Prepends one or more elements to a list only when the list exists.
+group: list
+hidden: false
+history:
+- - 4.0.0
+  - Accepts multiple `element` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: LPUSHX
+since: 2.2.0
+summary: Prepends one or more elements to a list only when the list exists.
+syntax_fmt: LPUSHX key element [element ...]
+syntax_str: element [element ...]
+title: LPUSHX
+---
+Inserts specified values at the head of the list stored at `key`, only if `key`
+already exists and holds a list.
+In contrary to [`LPUSH`]({{< relref "/commands/lpush" >}}), no operation will be performed when `key` does not yet
+exist.
+
+## Examples
+
+{{% redis-cli %}}
+LPUSH mylist "World"
+LPUSHX mylist "Hello"
+LPUSHX myotherlist "Hello"
+LRANGE mylist 0 -1
+LRANGE myotherlist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Returns information about server-assisted client-side caching for the
+  connection.
+group: connection
+hidden: false
+linkTitle: CLIENT TRACKINGINFO
+since: 6.2.0
+summary: Returns information about server-assisted client-side caching for the connection.
+syntax_fmt: CLIENT TRACKINGINFO
+syntax_str: ''
+title: CLIENT TRACKINGINFO
+---
+The command returns information about the current client connection's use of the [server assisted client side caching]({{< relref "/develop/clients/client-side-caching" >}}) feature.
+
+Here's the list of tracking information sections and their respective values:
+
+* **flags**: A list of tracking flags used by the connection. The flags and their meanings are as follows:
+  * `off`: The connection isn't using server assisted client side caching.
+  * `on`: Server assisted client side caching is enabled for the connection.
+  * `bcast`: The client uses broadcasting mode.
+  * `optin`: The client does not cache keys by default.
+  * `optout`: The client caches keys by default.
+  * `caching-yes`: The next command will cache keys (exists only together with `optin`).
+  * `caching-no`: The next command won't cache keys (exists only together with `optout`).
+  * `noloop`: The client isn't notified about keys modified by itself.
+  * `broken_redirect`: The client ID used for redirection isn't valid anymore.
+* **redirect**: The client ID used for notifications redirection, 0 for self-redirection, or -1 when none.
+* **prefixes**: A list of key prefixes for which notifications are sent to the client.
+---
+acl_categories:
+- '@keyspace'
+- '@read'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1)
+description: Returns the time since the last access to a Redis object.
+group: generic
+hidden: false
+hints:
+- nondeterministic_output
+key_specs:
+- RO: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: OBJECT IDLETIME
+since: 2.2.3
+summary: Returns the time since the last access to a Redis object.
+syntax_fmt: OBJECT IDLETIME key
+syntax_str: ''
+title: OBJECT IDLETIME
+---
+This command returns the time in seconds since the last access to the value stored at `<key>`.
+
+The command is only available when the `maxmemory-policy` configuration directive is not set to one of the LFU policies.
+---
+acl_categories:
+- '@cuckoo'
+- '@read'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: item
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(k), where k is the number of sub-filters
+description: Checks whether one or more items exist in a Cuckoo Filter
+group: cf
+hidden: false
+linkTitle: CF.EXISTS
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Checks whether one or more items exist in a Cuckoo Filter
+syntax_fmt: CF.EXISTS key item
+syntax_str: item
+title: CF.EXISTS
+---
+Determines whether a given item was added to a cuckoo filter.
+
+This command is similar to [`CF.MEXISTS`]({{< relref "commands/cf.mexists/" >}}), except that only one item can be checked.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a cuckoo filter.
+
+</details>
+
+<details open><summary><code>item</code></summary>
+
+is an item to check.
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}), where `1` means that, with high probability, `item` had already been added to the filter, and `0` means that `key` does not exist or that `item` had not been added to the filter. See note in [`CF.DEL`]({{< relref "commands/cf.del/" >}}).
+- [] on error (invalid arguments, wrong key type, and so on)
+
+## Examples
+
+{{< highlight bash >}}
+redis> CF.ADD cf item1
+(integer) 1
+redis> CF.EXISTS cf item1
+(integer) 1
+redis> CF.EXISTS cf item2
+(integer) 0
+{{< / highlight >}}
+---
+acl_categories:
+- '@search'
+arguments:
+- name: index
+  type: string
+- arguments:
+  - name: hash
+    token: HASH
+    type: pure-token
+  - name: json
+    token: JSON
+    type: pure-token
+  name: data_type
+  optional: true
+  token: 'ON'
+  type: oneof
+- arguments:
+  - name: count
+    token: PREFIX
+    type: integer
+  - multiple: true
+    name: prefix
+    type: string
+  name: prefix
+  optional: true
+  type: block
+- name: filter
+  optional: true
+  token: FILTER
+  type: string
+- name: default_lang
+  optional: true
+  token: LANGUAGE
+  type: string
+- name: lang_attribute
+  optional: true
+  token: LANGUAGE_FIELD
+  type: string
+- name: default_score
+  optional: true
+  token: SCORE
+  type: double
+- name: score_attribute
+  optional: true
+  token: SCORE_FIELD
+  type: string
+- name: payload_attribute
+  optional: true
+  token: PAYLOAD_FIELD
+  type: string
+- name: maxtextfields
+  optional: true
+  token: MAXTEXTFIELDS
+  type: pure-token
+- name: seconds
+  optional: true
+  token: TEMPORARY
+  type: double
+- name: nooffsets
+  optional: true
+  token: NOOFFSETS
+  type: pure-token
+- name: nohl
+  optional: true
+  token: NOHL
+  type: pure-token
+- name: nofields
+  optional: true
+  token: NOFIELDS
+  type: pure-token
+- name: nofreqs
+  optional: true
+  token: NOFREQS
+  type: pure-token
+- arguments:
+  - name: count
+    type: integer
+  - multiple: true
+    name: stopword
+    optional: true
+    type: string
+  name: stopwords
+  optional: true
+  token: STOPWORDS
+  type: block
+- name: skipinitialscan
+  optional: true
+  token: SKIPINITIALSCAN
+  type: pure-token
+- name: schema
+  token: SCHEMA
+  type: pure-token
+- arguments:
+  - name: field_name
+    type: string
+  - name: alias
+    optional: true
+    token: AS
+    type: string
+  - arguments:
+    - name: text
+      token: TEXT
+      type: pure-token
+    - name: tag
+      token: TAG
+      type: pure-token
+    - name: numeric
+      token: NUMERIC
+      type: pure-token
+    - name: geo
+      token: GEO
+      type: pure-token
+    - name: vector
+      token: VECTOR
+      type: pure-token
+    name: field_type
+    type: oneof
+  - name: withsuffixtrie
+    optional: true
+    token: WITHSUFFIXTRIE
+    type: pure-token
+  - name: indexempty
+    optional: true
+    token: INDEXEMPTY
+    type: pure-token
+  - arguments:
+    - name: sortable
+      token: SORTABLE
+      type: pure-token
+    - name: UNF
+      optional: true
+      token: UNF
+      type: pure-token
+    name: sortable
+    optional: true
+    type: block
+  - name: noindex
+    optional: true
+    token: NOINDEX
+    type: pure-token
+  multiple: true
+  name: field
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(K) at creation where K is the number of fields, O(N) if scanning the
+  keyspace is triggered, where N is the number of keys in the keyspace
+description: Creates an index with the given spec
+group: search
+hidden: false
+history:
+- - 2.0.0
+  - Added `PAYLOAD_FIELD` argument for backward support of `FT.SEARCH` deprecated
+    `WITHPAYLOADS` argument
+- - 2.0.0
+  - Deprecated `PAYLOAD_FIELD` argument
+linkTitle: FT.CREATE
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Creates an index with the given spec
+syntax: "FT.CREATE index \n  [ON HASH | JSON] \n  [PREFIX count prefix [prefix ...]]\
+  \ \n  [FILTER {filter}]\n  [LANGUAGE default_lang] \n  [LANGUAGE_FIELD lang_attribute]\
+  \ \n  [SCORE default_score] \n  [SCORE_FIELD score_attribute] \n  [PAYLOAD_FIELD\
+  \ payload_attribute] \n  [MAXTEXTFIELDS] \n  [TEMPORARY seconds] \n  [NOOFFSETS]\
+  \ \n  [NOHL] \n  [NOFIELDS] \n  [NOFREQS] \n  [STOPWORDS count [stopword ...]] \n\
+  \  [SKIPINITIALSCAN]\n  SCHEMA field_name [AS alias] TEXT | TAG | NUMERIC | GEO\
+  \ | VECTOR | GEOSHAPE [ SORTABLE [UNF]] \n  [NOINDEX] [ field_name [AS alias] TEXT\
+  \ | TAG | NUMERIC | GEO | VECTOR | GEOSHAPE [ SORTABLE [UNF]] [NOINDEX] ...]\n"
+syntax_fmt: "FT.CREATE index [ON\_<HASH | JSON>] [PREFIX\_count prefix [prefix\n \
+  \ ...]] [FILTER\_filter] [LANGUAGE\_default_lang]\n  [LANGUAGE_FIELD\_lang_attribute]\
+  \ [SCORE\_default_score]\n  [SCORE_FIELD\_score_attribute] [PAYLOAD_FIELD\_payload_attribute]\n\
+  \  [MAXTEXTFIELDS] [TEMPORARY\_seconds] [NOOFFSETS] [NOHL] [NOFIELDS]\n  [NOFREQS]\
+  \ [STOPWORDS\_count [stopword [stopword ...]]]\n  [SKIPINITIALSCAN] SCHEMA field_name\
+  \ [AS\_alias] <TEXT | TAG |\n  NUMERIC | GEO | VECTOR> [WITHSUFFIXTRIE] [SORTABLE\
+  \ [UNF]]\n  [NOINDEX] [field_name [AS\_alias] <TEXT | TAG | NUMERIC | GEO |\n  VECTOR>\
+  \ [WITHSUFFIXTRIE] [SORTABLE [UNF]] [NOINDEX] ...]"
+syntax_str: "[ON\_<HASH | JSON>] [PREFIX\_count prefix [prefix ...]] [FILTER\_filter]\
+  \ [LANGUAGE\_default_lang] [LANGUAGE_FIELD\_lang_attribute] [SCORE\_default_score]\
+  \ [SCORE_FIELD\_score_attribute] [PAYLOAD_FIELD\_payload_attribute] [MAXTEXTFIELDS]\
+  \ [TEMPORARY\_seconds] [NOOFFSETS] [NOHL] [NOFIELDS] [NOFREQS] [STOPWORDS\_count\
+  \ [stopword [stopword ...]]] [SKIPINITIALSCAN] SCHEMA field_name [AS\_alias] <TEXT\
+  \ | TAG | NUMERIC | GEO | VECTOR> [WITHSUFFIXTRIE] [SORTABLE [UNF]] [NOINDEX] [field_name\
+  \ [AS\_alias] <TEXT | TAG | NUMERIC | GEO | VECTOR> [WITHSUFFIXTRIE] [SORTABLE [UNF]]\
+  \ [NOINDEX] ...]"
+title: FT.CREATE
+---
+
+## Description
+
+Create an index with the given specification. For usage, see [Examples](#examples).
+
+## Required arguments
+
+<a name="index"></a><details open>
+<summary><code>index</code></summary>
+
+is index name to create.
+If such index already exists, returns an error reply `(error) Index already exists`.
+</details>
+
+<a name="SCHEMA"></a><details open>
+<summary><code>SCHEMA {identifier} AS {attribute} {attribute type} {options...</code></summary> 
+
+after the SCHEMA keyword, declares which fields to index:
+
+ - `{identifier}` for hashes, is a field name within the hash.
+      For JSON, the identifier is a JSON Path expression.
+
+ - `AS {attribute}` defines the attribute associated to the identifier. For example, you can use this feature to alias a complex JSONPath expression with more memorable (and easier to type) name.
+
+ Field types are:
+
+ - `TEXT` - Allows full-text search queries against the value in this attribute.
+
+ - `TAG` - Allows exact-match queries, such as categories or primary keys, against the value in this attribute. For more information, see [Tag Fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/tags" >}}).
+
+ - `NUMERIC` - Allows numeric range queries against the value in this attribute. See [query syntax docs]({{< relref "/develop/interact/search-and-query/query/" >}}) for details on how to use numeric ranges.
+
+ - `GEO` - Allows radius range queries against the value (point) in this attribute. The value of the attribute must be a string containing a longitude (first) and latitude separated by a comma.
+
+ - `VECTOR` - Allows vector queries against the value in this attribute. This requires [query dialect 2]({{< relref "/develop/interact/search-and-query/advanced-concepts/dialects#dialect-2" >}}) or above (introduced in [RediSearch v2.4](https://github.com/RediSearch/RediSearch/releases/tag/v2.4.3)). For more information, see [Vector Fields]({{< relref "/develop/interact/search-and-query/advanced-concepts/vectors" >}}).
+
+ - `GEOSHAPE`- Allows polygon queries against the value in this attribute. The value of the attribute must follow a [WKT notation](https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) list of 2D points representing the polygon edges `POLYGON((x1 y1, x2 y2, ...)` separated by a comma. A `GEOSHAPE` field type can be followed by one of the following coordinate systems:
+   - `SPHERICAL` for Geographic longitude and latitude coordinates
+   - `FLAT` for Cartesian X Y coordinates
+  
+    The default coordinate system is `SPHERICAL`.
+    
+    Currently `GEOSHAPE` doesn't support JSON multi-value and `SORTABLE` option.
+
+ Field options are:
+
+ - `SORTABLE` - `NUMERIC`, `TAG`, `TEXT`, or `GEO` attributes can have an optional **SORTABLE** argument. As the user [sorts the results by the value of this attribute]({{< relref "/develop/interact/search-and-query/advanced-concepts/sorting" >}}), the results are available with very low latency. Note that his adds memory overhead, so consider not declaring it on large text attributes. You can sort an attribute without the `SORTABLE` option, but the latency is not as good as with `SORTABLE`.
+
+ - `UNF` - By default, for hashes (not with JSON) `SORTABLE` applies a normalization to the indexed value (characters set to lowercase, removal of diacritics). When using the unnormalized form (UNF), you can disable the normalization and keep the original form of the value. With JSON, `UNF` is implicit with `SORTABLE` (normalization is disabled).
+
+ - `NOSTEM` - Text attributes can have the NOSTEM argument that disables stemming when indexing its values. This may be ideal for things like proper names.
+
+ - `NOINDEX` - Attributes can have the `NOINDEX` option, which means they will not be indexed. This is useful in conjunction with `SORTABLE`, to create attributes whose update using PARTIAL will not cause full reindexing of the document. If an attribute has NOINDEX and doesn't have SORTABLE, it will just be ignored by the index.
+
+ - `PHONETIC {matcher}` - Declaring a text attribute as `PHONETIC` will perform phonetic matching on it in searches by default. The obligatory {matcher} argument specifies the phonetic algorithm and language used. The following matchers are supported:
+
+   - `dm:en` - Double metaphone for English
+   - `dm:fr` - Double metaphone for French
+   - `dm:pt` - Double metaphone for Portuguese
+   - `dm:es` - Double metaphone for Spanish
+
+   For more information, see [Phonetic Matching]({{< relref "/develop/interact/search-and-query/advanced-concepts/phonetic_matching" >}}).
+
+  - `WEIGHT {weight}` for `TEXT` attributes, declares the importance of this attribute when calculating result accuracy. This is a multiplication factor, and defaults to 1 if not specified.
+
+  - `SEPARATOR {sep}` for `TAG` attributes, indicates how the text contained in the attribute is to be split into individual tags. The default is `,`. The value must be a single character.
+
+  - `CASESENSITIVE` for `TAG` attributes, keeps the original letter cases of the tags. If not specified, the characters are converted to lowercase.
+
+  - `WITHSUFFIXTRIE` for `TEXT` and `TAG` attributes, keeps a suffix trie with all terms which match the suffix. It is used to optimize `contains` (*foo*) and `suffix` (*foo) queries. Otherwise, a brute-force search on the trie is performed. If suffix trie exists for some fields, these queries will be disabled for other fields.
+
+  - `INDEXEMPTY` for `TEXT` and `TAG` attributes, introduced in v2.10, allows you to index and search for empty strings. By default, empty strings are not indexed. 
+
+  - `INDEXMISSING` for all field types, introduced in v2.10, allows you to search for missing values, that is, documents that do not contain a specific field. Note the difference between a field with an empty value and a document with a missing value. By default, missing values are not indexed.
+
+</details>
+
+## Optional arguments
+
+<a name="ON"></a><details open>
+<summary><code>ON {data_type}</code></summary>
+
+currently supports HASH (default) and JSON. To index JSON, you must have the [RedisJSON]({{< relref "/develop/data-types/json/" >}}) module installed.
+</details>
+
+<a name="PREFIX"></a><details open>
+<summary><code>PREFIX {count} {prefix}</code></summary> 
+
+tells the index which keys it should index. You can add several prefixes to index. Because the argument is optional, the default is `*` (all keys).
+</details>
+
+<a name="FILTER"></a><details open>
+<summary><code>FILTER {filter}</code></summary> 
+
+is a filter expression with the full RediSearch aggregation expression language. It is possible to use `@__key` to access the key that was just added/changed. A field can be used to set field name by passing `'FILTER @indexName=="myindexname"'`.
+</details>
+
+<a name="LANGUAGE"></a><details open>
+<summary><code>LANGUAGE {default_lang}</code></summary> 
+
+if set, indicates the default language for documents in the index. Default is English.
+</details>
+
+<a name="LANGUAGE_FIELD"></a><details open>
+<summary><code>LANGUAGE_FIELD {lang_attribute}</code></summary> 
+
+is a document attribute set as the document language.
+
+A stemmer is used for the supplied language during indexing. If an unsupported language is sent, the command returns an error. The supported languages are Arabic, Basque, Catalan, Danish, Dutch, English, Finnish, French, German, Greek, Hungarian,
+Indonesian, Irish, Italian, Lithuanian, Nepali, Norwegian, Portuguese, Romanian, Russian,
+Spanish, Swedish, Tamil, Turkish, and Chinese.
+
+When adding Chinese language documents, set `LANGUAGE chinese` for the indexer to properly tokenize the terms. If you use the default language, then search terms are extracted based on punctuation characters and whitespace. The Chinese language tokenizer makes use of a segmentation algorithm (via [Friso](https://github.com/lionsoul2014/friso)), which segments text and checks it against a predefined dictionary. See [Stemming]({{< relref "/develop/interact/search-and-query/advanced-concepts/stemming" >}}) for more information.
+</details>
+
+<a name="SCORE"></a><details open>
+<summary><code>SCORE {default_score}</code></summary> 
+
+is default score for documents in the index. Default score is 1.0.
+</details>
+
+<a name="SCORE_FIELD"></a><details open>
+<summary><code>SCORE_FIELD {score_attribute}</code></summary> 
+
+is document attribute that you use as the document rank based on the user ranking. Ranking must be between 0.0 and 1.0. If not set, the default score is 1.
+</details>
+
+<a name="PAYLOAD_FIELD"></a><details open>
+<summary><code>PAYLOAD_FIELD {payload_attribute}</code></summary> 
+
+is document attribute that you use as a binary safe payload string to the document that can be evaluated at query time by a custom scoring function or retrieved to the client.
+</details>
+
+<a name="MAXTEXTFIELDS"></a><details open>
+<summary><code>MAXTEXTFIELDS</code></summary> 
+
+forces RediSearch to encode indexes as if there were more than 32 text attributes, which allows you to add additional attributes (beyond 32) using [`FT.ALTER`]({{< relref "commands/ft.alter/" >}}). For efficiency, RediSearch encodes indexes differently if they are created with less than 32 text attributes.
+</details>
+
+<a name="NOOFFSETS"></a><details open>
+<summary><code>NOOFFSETS</code></summary> 
+
+does not store term offsets for documents. It saves memory, but does not allow exact searches or highlighting. It implies `NOHL`.
+</details>
+
+<a name="TEMPORARY"></a><details open>
+<summary><code>TEMPORARY {seconds}</code></summary> 
+
+creates a lightweight temporary index that expires after a specified period of inactivity, in seconds. The internal idle timer is reset whenever the index is searched or added to. Because such indexes are lightweight, you can create thousands of such indexes without negative performance implications and, therefore, you should consider using `SKIPINITIALSCAN` to avoid costly scanning.
+
+{{% alert title="Warning" color="warning" %}}
+ 
+When temporary indexes expire, they drop all the records associated with them.
+[`FT.DROPINDEX`]({{< relref "commands/ft.dropindex/" >}}) was introduced with a default of not deleting docs and a `DD` flag that enforced deletion.
+However, for temporary indexes, documents are deleted along with the index.
+Historically, RediSearch used an FT.ADD command, which made a connection between the document and the index. Then, FT.DROP, also a hystoric command, deleted documents by default.
+In version 2.x, RediSearch indexes hashes and JSONs, and the dependency between the index and documents no longer exists. 
+
+{{% /alert %}}
+
+</details>
+
+<a name="NOHL"></a><details open>
+<summary><code>NOHL</code></summary> 
+
+conserves storage space and memory by disabling highlighting support. If set, the corresponding byte offsets for term positions are not stored. `NOHL` is also implied by `NOOFFSETS`.
+</details>
+
+<a name="NOFIELDS"></a><details open>
+<summary><code>NOFIELDS</code></summary> 
+
+does not store attribute bits for each term. It saves memory, but it does not allow
+  filtering by specific attributes.
+</details>
+
+<a name="NOFREQS"></a><details open>
+<summary><code>NOFREQS</code></summary> 
+
+avoids saving the term frequencies in the index. It saves memory, but does not allow sorting based on the frequencies of a given term within the document.
+</details>
+
+<a name="STOPWORDS"></a><details open>
+<summary><code>STOPWORDS {count}</code></summary> 
+
+sets the index with a custom stopword list, to be ignored during indexing and search time. `{count}` is the number of stopwords, followed by a list of stopword arguments exactly the length of `{count}`.
+
+If not set, FT.CREATE takes the default list of stopwords. If `{count}` is set to 0, the index does not have stopwords.
+</details>
+
+<a name="SKIPINITIALSCAN"></a><details open>
+<summary><code>SKIPINITIALSCAN</code></summary> 
+
+if set, does not scan and index.
+</details>
+        
+<note><b>Notes:</b>
+
+ - **Attribute number limits:** RediSearch supports up to 1024 attributes per schema, out of which at most 128 can be TEXT attributes. On 32 bit builds, at most 64 attributes can be TEXT attributes. The more attributes you have, the larger your index, as each additional 8 attributes require one extra byte per index record to encode. You can always use the `NOFIELDS` option and not encode attribute information into the index, for saving space, if you do not need filtering by text attributes. This will still allow filtering by numeric and geo attributes.
+ - **Running in clustered databases:** When having several indices in a clustered database, you need to make sure the documents you want to index reside on the same shard as the index. You can achieve this by having your documents tagged by the index name.
+    
+   {{< highlight bash >}}
+   127.0.0.1:6379> HSET doc:1{idx} ...
+   127.0.0.1:6379> FT.CREATE idx ... PREFIX 1 doc: ...
+   {{< / highlight >}}
+
+   When Running RediSearch in a clustered database, you can span the index across shards using [RSCoordinator](https://github.com/RedisLabsModules/RSCoordinator). In this case the above does not apply.
+
+</note>
+
+## Return
+
+FT.CREATE returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Create an index</b></summary>
+
+Create an index that stores the title, publication date, and categories of blog post hashes whose keys start with `blog:post:` (for example, `blog:post:1`).
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE idx ON HASH PREFIX 1 blog:post: SCHEMA title TEXT SORTABLE published_at NUMERIC SORTABLE category TAG SORTABLE
+OK
+{{< / highlight >}}
+
+Index the `sku` attribute from a hash as both a `TAG` and as `TEXT`:
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE idx ON HASH PREFIX 1 blog:post: SCHEMA sku AS sku_text TEXT sku AS sku_tag TAG SORTABLE
+{{< / highlight >}}
+
+Index two different hashes, one containing author data and one containing books, in the same index:
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE author-books-idx ON HASH PREFIX 2 author:details: book:details: SCHEMA
+author_id TAG SORTABLE author_ids TAG title TEXT name TEXT
+{{< / highlight >}}
+
+In this example, keys for author data use the key pattern `author:details:<id>` while keys for book data use the pattern `book:details:<id>`.
+
+Index authors whose names start with G.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE g-authors-idx ON HASH PREFIX 1 author:details FILTER 'startswith(@name, "G")' SCHEMA name TEXT
+{{< / highlight >}}
+
+Index only books that have a subtitle.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE subtitled-books-idx ON HASH PREFIX 1 book:details FILTER '@subtitle != ""' SCHEMA title TEXT
+{{< / highlight >}}
+
+Index books that have a "categories" attribute where each category is separated by a `;` character.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE books-idx ON HASH PREFIX 1 book:details SCHEMA title TEXT categories TAG SEPARATOR ";"
+{{< / highlight >}}
+</details>
+
+<details open>
+<summary><b>Index a JSON document using a JSON Path expression</b></summary>
+
+The following example uses data similar to the hash examples above but uses JSON instead.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CREATE idx ON JSON SCHEMA $.title AS title TEXT $.categories AS categories TAG
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.ALTER`]({{< relref "commands/ft.alter/" >}}) | [`FT.DROPINDEX`]({{< relref "commands/ft.dropindex/" >}}) 
+
+## Related topics
+
+- [RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+- [RedisJSON]({{< relref "/develop/data-types/json/" >}})
+- [Friso](https://github.com/lionsoul2014/friso)
+- [Stemming]({{< relref "/develop/interact/search-and-query/advanced-concepts/stemming" >}})
+- [Phonetic Matching]({{< relref "/develop/interact/search-and-query/advanced-concepts/phonetic_matching" >}})
+- [RSCoordinator](https://github.com/RedisLabsModules/RSCoordinator)
+---
+acl_categories:
+- '@write'
+- '@set'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each element added, so O(N) to add N elements when the command
+  is called with multiple arguments.
+description: Adds one or more members to a set. Creates the key if it doesn't exist.
+group: set
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple `member` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: SADD
+since: 1.0.0
+summary: Adds one or more members to a set. Creates the key if it doesn't exist.
+syntax_fmt: SADD key member [member ...]
+syntax_str: member [member ...]
+title: SADD
+---
+Add the specified members to the set stored at `key`.
+Specified members that are already a member of this set are ignored.
+If `key` does not exist, a new set is created before adding the specified
+members.
+
+An error is returned when the value stored at `key` is not a set.
+
+## Examples
+
+{{< clients-example cmds_set sadd >}}
+redis> SADD myset "Hello" "World"
+(integer) 2
+redis> SADD myset "World"
+(integer) 0
+redis> SMEMBERS myset
+1) "Hello"
+2) "World"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+SADD myset "Hello" "World"
+SADD myset "World"
+SMEMBERS myset
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@slow'
+- '@connection'
+arguments:
+- display_text: connection-name
+  name: connection-name
+  type: string
+arity: 3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- noscript
+- loading
+- stale
+complexity: O(1)
+description: Sets the connection name.
+group: connection
+hidden: false
+hints:
+- request_policy:all_nodes
+- response_policy:all_succeeded
+linkTitle: CLIENT SETNAME
+since: 2.6.9
+summary: Sets the connection name.
+syntax_fmt: CLIENT SETNAME connection-name
+syntax_str: ''
+title: CLIENT SETNAME
+---
+The `CLIENT SETNAME` command assigns a name to the current connection.
+
+The assigned name is displayed in the output of [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) so that it is possible to identify the client that performed a given connection.
+
+For instance when Redis is used in order to implement a queue, producers and consumers of messages may want to set the name of the connection according to their role.
+
+There is no limit to the length of the name that can be assigned if not the usual limits of the Redis string type (512 MB). However it is not possible to use spaces in the connection name as this would violate the format of the [`CLIENT LIST`]({{< relref "/commands/client-list" >}}) reply.
+
+It is possible to entirely remove the connection name setting it to the empty string, that is not a valid connection name since it serves to this specific purpose.
+
+The connection name can be inspected using [`CLIENT GETNAME`]({{< relref "/commands/client-getname" >}}).
+
+Every new connection starts without an assigned name.
+
+Tip: setting names to connections is a good way to debug connection leaks due to bugs in the application using Redis.
+---
+acl_categories:
+- '@write'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- arguments:
+  - display_text: nx
+    name: nx
+    token: NX
+    type: pure-token
+  - display_text: xx
+    name: xx
+    token: XX
+    type: pure-token
+  name: condition
+  optional: true
+  since: 6.2.0
+  type: oneof
+- display_text: change
+  name: change
+  optional: true
+  since: 6.2.0
+  token: CH
+  type: pure-token
+- arguments:
+  - display_text: longitude
+    name: longitude
+    type: double
+  - display_text: latitude
+    name: latitude
+    type: double
+  - display_text: member
+    name: member
+    type: string
+  multiple: true
+  name: data
+  type: block
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(log(N)) for each item added, where N is the number of elements in the
+  sorted set.
+description: Adds one or more members to a geospatial index. The key is created if
+  it doesn't exist.
+group: geo
+hidden: false
+history:
+- - 6.2.0
+  - Added the `CH`, `NX` and `XX` options.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: GEOADD
+since: 3.2.0
+summary: Adds one or more members to a geospatial index. The key is created if it
+  doesn't exist.
+syntax_fmt: "GEOADD key [NX | XX] [CH] longitude latitude member [longitude\n  latitude\
+  \ member ...]"
+syntax_str: '[NX | XX] [CH] longitude latitude member [longitude latitude member ...]'
+title: GEOADD
+---
+Adds the specified geospatial items (longitude, latitude, name) to the specified key. Data is stored into the key as a sorted set, in a way that makes it possible to query the items with the [`GEOSEARCH`]({{< relref "/commands/geosearch" >}}) command.
+
+The command takes arguments in the standard format x,y so the longitude must be specified before the latitude. There are limits to the coordinates that can be indexed: areas very near to the poles are not indexable.
+
+The exact limits, as specified by EPSG:900913 / EPSG:3785 / OSGEO:41001 are the following:
+
+* Valid longitudes are from -180 to 180 degrees.
+* Valid latitudes are from -85.05112878 to 85.05112878 degrees.
+
+The command will report an error when the user attempts to index coordinates outside the specified ranges.
+
+**Note:** there is no **GEODEL** command because you can use [`ZREM`]({{< relref "/commands/zrem" >}}) to remove elements. The Geo index structure is just a sorted set.
+
+## GEOADD options
+
+`GEOADD` also provides the following options:
+
+* **XX**: Only update elements that already exist. Never add elements.
+* **NX**: Don't update already existing elements. Always add new elements.
+* **CH**: Modify the return value from the number of new elements added, to the total number of elements changed (CH is an abbreviation of *changed*). Changed elements are **new elements added** and elements already existing for which **the coordinates was updated**. So elements specified in the command line having the same score as they had in the past are not counted. Note: normally, the return value of `GEOADD` only counts the number of new elements added.
+
+Note: The **XX** and **NX** options are mutually exclusive.
+
+How does it work?
+---
+
+The way the sorted set is populated is using a technique called
+[Geohash](https://en.wikipedia.org/wiki/Geohash). Latitude and Longitude
+bits are interleaved to form a unique 52-bit integer. We know
+that a sorted set double score can represent a 52-bit integer without losing
+precision.
+
+This format allows for bounding box and radius querying by checking the 1+8 areas needed to cover the whole shape and discarding elements outside it. The areas are checked by calculating the range of the box covered, removing enough bits from the less significant part of the sorted set score, and computing the score range to query in the sorted set for each area.
+
+What Earth model does it use?
+---
+
+The model assumes that the Earth is a sphere since it uses the Haversine formula to calculate distance. This formula is only an approximation when applied to the Earth, which is not a perfect sphere.
+The introduced errors are not an issue when used, for example, by social networks and similar applications requiring this type of querying. 
+However, in the worst case, the error may be up to 0.5%, so you may want to consider other systems for error-critical applications.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEODIST Sicily Palermo Catania
+GEORADIUS Sicily 15 37 100 km
+GEORADIUS Sicily 15 37 200 km
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@write'
+- '@list'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: integer
+- display_text: stop
+  name: stop
+  type: integer
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(N) where N is the number of elements to be removed by the operation.
+description: Removes elements from both ends a list. Deletes the list if all elements
+  were trimmed.
+group: list
+hidden: false
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  delete: true
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: LTRIM
+since: 1.0.0
+summary: Removes elements from both ends a list. Deletes the list if all elements
+  were trimmed.
+syntax_fmt: LTRIM key start stop
+syntax_str: start stop
+title: LTRIM
+---
+Trim an existing list so that it will contain only the specified range of
+elements specified.
+Both `start` and `stop` are zero-based indexes, where `0` is the first element
+of the list (the head), `1` the next element and so on.
+
+For example: `LTRIM foobar 0 2` will modify the list stored at `foobar` so that
+only the first three elements of the list will remain.
+
+`start` and `end` can also be negative numbers indicating offsets from the end
+of the list, where `-1` is the last element of the list, `-2` the penultimate
+element and so on.
+
+Out of range indexes will not produce an error: if `start` is larger than the
+end of the list, or `start > end`, the result will be an empty list (which
+causes `key` to be removed).
+If `end` is larger than the end of the list, Redis will treat it like the last
+element of the list.
+
+A common use of `LTRIM` is together with [`LPUSH`]({{< relref "/commands/lpush" >}}) / [`RPUSH`]({{< relref "/commands/rpush" >}}).
+For example:
+
+```
+LPUSH mylist someelement
+LTRIM mylist 0 99
+```
+
+This pair of commands will push a new element on the list, while making sure
+that the list will not grow larger than 100 elements.
+This is very useful when using Redis to store logs for example.
+It is important to note that when used in this way `LTRIM` is an O(1) operation
+because in the average case just one element is removed from the tail of the
+list.
+
+## Examples
+
+{{% redis-cli %}}
+RPUSH mylist "one"
+RPUSH mylist "two"
+RPUSH mylist "three"
+LTRIM mylist 1 -1
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@search'
+arguments:
+- name: alias
+  type: string
+- name: index
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Adds or updates an alias to the index
+group: search
+hidden: false
+linkTitle: FT.ALIASUPDATE
+module: Search
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Adds or updates an alias to the index
+syntax: 'FT.ALIASUPDATE alias index
+
+  '
+syntax_fmt: FT.ALIASUPDATE alias index
+syntax_str: index
+title: FT.ALIASUPDATE
+---
+
+Add an alias to an index. If the alias is already associated with another
+index, FT.ALIASUPDATE removes the alias association with the previous index.
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>alias index</code></summary>
+
+is alias to be added to an index.
+</details>
+
+## Return
+
+FT.ALIASUPDATE returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Update an index alias</b></summary>
+
+Update the alias of an index.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.ALIASUPDATE alias idx
+OK
+{{< / highlight >}}
+
+## See also
+
+[`FT.ALIASADD`]({{< relref "commands/ft.aliasadd/" >}}) | [`FT.ALIASDEL`]({{< relref "commands/ft.aliasdel/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@timeseries'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: timestamp
+  type: string
+- name: value
+  type: double
+- name: retentionPeriod
+  optional: true
+  token: RETENTION
+  type: integer
+- arguments:
+  - name: uncompressed
+    token: UNCOMPRESSED
+    type: pure-token
+  - name: compressed
+    token: COMPRESSED
+    type: pure-token
+  name: enc
+  optional: true
+  token: ENCODING
+  type: oneof
+- name: size
+  optional: true
+  token: CHUNK_SIZE
+  type: integer
+- arguments:
+  - name: block
+    token: BLOCK
+    type: pure-token
+  - name: first
+    token: FIRST
+    type: pure-token
+  - name: last
+    token: LAST
+    type: pure-token
+  - name: min
+    token: MIN
+    type: pure-token
+  - name: max
+    token: MAX
+    type: pure-token
+  - name: sum
+    token: SUM
+    type: pure-token
+  name: policy
+  optional: true
+  token: DUPLICATE_POLICY
+  type: oneof
+- name: policy_ovr
+  optional: true
+  token: ON_DUPLICATE
+  type: oneof
+- arguments:
+  - name: label
+    type: string
+  - name: value
+    type: string
+  multiple: true
+  name: labels
+  optional: true
+  token: LABELS
+  type: block
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(M) when M is the amount of compaction rules or O(1) with no compaction
+description: Append a sample to a time series
+group: timeseries
+hidden: false
+linkTitle: TS.ADD
+module: TimeSeries
+since: 1.0.0
+stack_path: docs/data-types/timeseries
+summary: Append a sample to a time series
+syntax: "TS.ADD key timestamp value \n  [RETENTION retentionPeriod] \n  [ENCODING\
+  \ <COMPRESSED|UNCOMPRESSED>] \n  [CHUNK_SIZE size] \n  [DUPLICATE_POLICY policy] \n  [ON_DUPLICATE policy_ovr] \n\
+  \  [IGNORE ignoreMaxTimediff ignoreMaxValDiff] \n\
+  \  [LABELS [label value ...]]\n"
+syntax_fmt: "TS.ADD key timestamp value [RETENTION\_retentionPeriod]\n  [ENCODING\_\
+  <COMPRESSED | UNCOMPRESSED>] [CHUNK_SIZE\_size]\n  [DUPLICATE_POLICY\_policy] \n  [ON_DUPLICATE\_<BLOCK | FIRST\
+  \ | LAST | MIN | MAX | SUM>]\n  [IGNORE ignoreMaxTimediff ignoreMaxValDiff]\n  [LABELS\ [label value ...]]"
+syntax_str: "timestamp value [RETENTION\_retentionPeriod] [ENCODING\_<COMPRESSED\
+  \ | UNCOMPRESSED>] [CHUNK_SIZE\_size] [DUPLICATE_POLICY\_policy] [ON_DUPLICATE\_<BLOCK | FIRST | LAST | MIN |\
+  \ MAX | SUM>] [LABELS\ [label value ...]]"
+title: TS.ADD
+---
+
+Append a sample to a time series
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open><summary><code>key</code></summary> 
+
+is key name for the time series.
+</details>
+
+<details open><summary><code>timestamp</code></summary> 
+
+is Unix time (integer, in milliseconds) specifying the sample timestamp or `*` to set the sample timestamp to the Unix time of the server's clock.
+
+Unix time is the number of milliseconds that have elapsed since 00:00:00 UTC on 1 January 1970, the Unix epoch, without adjustments made due to leap seconds.
+</details>
+
+<details open><summary><code>value</code></summary> 
+
+is (double) numeric data value of the sample. The double number should follow [RFC 7159](https://tools.ietf.org/html/rfc7159) (JSON standard). In particular, the parser rejects overly large values that do not fit in binary64. It does not accept NaN or infinite values.
+</details>
+
+<note><b>Notes:</b>
+- When specified key does not exist, a new time series is created.
+
+  if a [COMPACTION_POLICY]({{< relref "develop/data-types/timeseries/configuration#compaction_policy" >}}) configuration parameter is defined, compacted time series would be created as well.
+
+- If `timestamp` is older than the retention period compared to the maximum existing timestamp, the sample is discarded and an error is returned.
+- When adding a sample to a time series for which compaction rules are defined:
+  - If all the original samples for an affected aggregated time bucket are available, the compacted value is recalculated based on the reported sample and the original samples.
+  - If only a part of the original samples for an affected aggregated time bucket is available due to trimming caused in accordance with the time series RETENTION policy, the compacted value is recalculated based on the reported sample and the available original samples.
+  - If the original samples for an affected aggregated time bucket are not available due to trimming caused in accordance with the time series RETENTION policy, the compacted value bucket is not updated.
+- Explicitly adding samples to a compacted time series (using `TS.ADD`, [`TS.MADD`]({{< relref "commands/ts.madd/" >}}), [`TS.INCRBY`]({{< relref "commands/ts.incrby/" >}}), or [`TS.DECRBY`]({{< relref "commands/ts.decrby/" >}})) may result in inconsistencies between the raw and the compacted data. The compaction process may override such samples.
+</note>
+
+## Optional arguments
+
+The following arguments are optional because they can be set by [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+
+<details open><summary><code>RETENTION retentionPeriod</code></summary> 
+ 
+is maximum retention period, compared to the maximum existing timestamp, in milliseconds.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `RETENTION` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+    
+<details open><summary><code>ENCODING enc</code></summary> 
+
+specifies the series sample encoding format.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `ENCODING` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>CHUNK_SIZE size</code></summary>
+  
+is memory size, in bytes, allocated for each data chunk.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `CHUNK_SIZE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>DUPLICATE_POLICY policy</code></summary>
+
+is policy for handling insertion ([`TS.ADD`]({{< relref "commands/ts.add/" >}}) and [`TS.MADD`]({{< relref "commands/ts.madd/" >}})) of multiple samples with identical timestamps.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `DUPLICATE_POLICY` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<details open><summary><code>ON_DUPLICATE policy_ovr</code></summary> 
+
+is overwrite key and database configuration for [DUPLICATE_POLICY]({{< relref "develop/data-types/timeseries/configuration#duplicate_policy" >}}), the policy for handling samples with identical timestamps.
+This override is effective only for this single command and does not set the time series duplication policy (which can be set with [`TS.ALTER`]({{< relref "commands/ts.alter/" >}})).
+
+`policy_ovr` can be one of the following values:
+  - `BLOCK`: ignore any newly reported value and reply with an error
+  - `FIRST`: ignore any newly reported value
+  - `LAST`: override with the newly reported value
+  - `MIN`: only override if the value is lower than the existing value
+  - `MAX`: only override if the value is higher than the existing value
+  - `SUM`: If a previous sample exists, add the new sample to it so that the updated value is set to (previous + new). If no previous sample exists, the value is set to the new value.
+
+This argument has no effect when a new time series is created by this command.
+</details>
+
+<details open><summary><code>IGNORE ignoreMaxTimediff ignoreMaxValDiff</code></summary> 
+
+is the policy for handling duplicate samples. A new sample is considered a duplicate and is ignored if the following conditions are met:
+
+  - The time series is not a compaction;
+  - The time series' `DUPLICATE_POLICY` IS `LAST`;
+  - The sample is added in-order (`timestamp ≥ max_timestamp`);
+  - The difference of the current timestamp from the previous timestamp (`timestamp - max_timestamp`) is less than or equal to `IGNORE_MAX_TIME_DIFF`;
+  - The absolute value difference of the current value from the value at the previous maximum timestamp (`abs(value - value_at_max_timestamp`) is less than or equal to `IGNORE_MAX_VAL_DIFF`.
+ 
+where `max_timestamp` is the timestamp of the sample with the largest timestamp in the time series, and `value_at_max_timestamp` is the value at `max_timestamp`.
+
+When not specified: set to the global [IGNORE_MAX_TIME_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}) and [IGNORE_MAX_VAL_DIFF]({{< relref "develop/data-types/timeseries/configuration#ignore_max_time_diff-and-ignore_max_val_diff" >}}), which are, by default, both set to 0.
+
+These parameters are used when creating a new time series to set the per-key parameters, and are ignored when called with an existing time series (the existing per-key configuration parameters is used).
+
+</details>
+
+<details open><summary><code>LABELS {label value}...</code></summary> 
+
+is set of label-value pairs that represent metadata labels of the time series.
+
+Use it only if you are creating a new time series. It is ignored if you are adding samples to an existing time series. See `LABELS` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}}).
+</details>
+
+<note><b>Notes:</b>
+- You can use this command to create a new time series and add data to it in a single command.
+  `RETENTION`, `ENCODING`, `CHUNK_SIZE`, `DUPLICATE_POLICY`, `IGNORE`, and `LABELS` are used only when creating a new time series, and ignored when adding samples to an existing time series.
+- Setting `RETENTION` and `LABELS` introduces additional time complexity.
+</note>
+
+## Return value
+
+Returns one of these replies:
+
+- [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) - the timestamp of the upserted sample. If the sample is ignored (See `IGNORE` in [`TS.CREATE`]({{< relref "commands/ts.create/" >}})), the reply will be the largest timestamp in the time series.
+- [] on error (invalid arguments, wrong key type, etc.), when duplication policy is `BLOCK`, or when `timestamp` is older than the retention period compared to the maximum existing timestamp
+
+## Complexity
+
+If a compaction rule exists on a time series, the performance of `TS.ADD` can be reduced.
+The complexity of `TS.ADD` is always `O(M)`, where `M` is the number of compaction rules or `O(1)` with no compaction.
+
+## Examples
+
+<details open><summary><b>Append a sample to a temperature time series</b></summary>
+
+Create a temperature time series, set its retention to 1 year, and append a sample.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD temperature:3:11 1548149183000 27 RETENTION 31536000000
+(integer) 1548149183000
+{{< / highlight >}}
+
+<note><b>Note:</b> If a time series with such a name already exists, the sample is added, but the retention does not change.</note>
+
+Add a sample to the time series, setting the sample's timestamp to the current Unix time of the server's clock.
+
+{{< highlight bash >}}
+127.0.0.1:6379> TS.ADD temperature:3:11 * 30
+(integer) 1662042954573
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`TS.CREATE`]({{< relref "commands/ts.create/" >}}) 
+
+## Related topics
+
+[RedisTimeSeries]({{< relref "/develop/data-types/timeseries/" >}})
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: max
+  name: max
+  type: string
+- display_text: min
+  name: min
+  type: string
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  token: LIMIT
+  type: block
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements being returned. If M is constant (e.g. always asking for
+  the first 10 elements with LIMIT), you can consider it O(log(N)).
+deprecated_since: 6.2.0
+description: Returns members in a sorted set within a lexicographical range in reverse
+  order.
+doc_flags:
+- deprecated
+group: sorted-set
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZREVRANGEBYLEX
+replaced_by: '[`ZRANGE`]({{< relref "/commands/zrange" >}}) with the `REV` and `BYLEX`
+  arguments'
+since: 2.8.9
+summary: Returns members in a sorted set within a lexicographical range in reverse
+  order.
+syntax_fmt: "ZREVRANGEBYLEX key max min [LIMIT\_offset count]"
+syntax_str: "max min [LIMIT\_offset count]"
+title: ZREVRANGEBYLEX
+---
+When all the elements in a sorted set are inserted with the same score, in order to force lexicographical ordering, this command returns all the elements in the sorted set at `key` with a value between `max` and `min`.
+
+Apart from the reversed ordering, `ZREVRANGEBYLEX` is similar to [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}).
+
+## Examples
+
+{{% redis-cli %}}
+ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g
+ZREVRANGEBYLEX myzset [c -
+ZREVRANGEBYLEX myzset (c -
+ZREVRANGEBYLEX myzset (g [aaa
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@keyspace'
+- '@slow'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- loading
+- stale
+complexity: O(1)
+description: Returns helpful text about the different subcommands.
+group: generic
+hidden: true
+linkTitle: OBJECT HELP
+since: 6.2.0
+summary: Returns helpful text about the different subcommands.
+syntax_fmt: OBJECT HELP
+syntax_str: ''
+title: OBJECT HELP
+---
+The `OBJECT HELP` command returns a helpful text describing the different subcommands.
+---
+acl_categories:
+- '@read'
+- '@search'
+arguments:
+- name: index
+  type: string
+- name: cursor_id
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+description: Deletes a cursor
+group: search
+hidden: false
+linkTitle: FT.CURSOR DEL
+module: Search
+since: 1.1.0
+stack_path: docs/interact/search-and-query
+summary: Deletes a cursor
+syntax: 'FT.CURSOR DEL index cursor_id
+
+  '
+syntax_fmt: FT.CURSOR DEL index cursor_id
+syntax_str: cursor_id
+title: FT.CURSOR DEL
+---
+
+Delete a cursor
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>index</code></summary>
+
+is index name.
+</details>
+
+<details open>
+<summary><code>cursor_id</code></summary>
+
+is id of the cursor.
+</details>
+
+## Returns
+
+FT.CURSOR DEL returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Delete a cursor</b></summary>
+
+{{< highlight bash >}}
+redis> FT.CURSOR DEL idx 342459320
+OK
+{{< / highlight >}}
+
+Check that the cursor is deleted.
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CURSOR DEL idx 342459320
+(error) Cursor does not exist
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CURSOR READ`]({{< relref "commands/ft.cursor-read/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})---
+acl_categories:
+- '@pubsub'
+- '@slow'
+arguments:
+- display_text: pattern
+  multiple: true
+  name: pattern
+  type: pattern
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- pubsub
+- noscript
+- loading
+- stale
+complexity: O(N) where N is the number of patterns to subscribe to.
+description: Listens for messages published to channels that match one or more patterns.
+group: pubsub
+hidden: false
+linkTitle: PSUBSCRIBE
+since: 2.0.0
+summary: Listens for messages published to channels that match one or more patterns.
+syntax_fmt: PSUBSCRIBE pattern [pattern ...]
+syntax_str: ''
+title: PSUBSCRIBE
+---
+Subscribes the client to the given patterns.
+
+Supported glob-style patterns:
+
+* `h?llo` subscribes to `hello`, `hallo` and `hxllo`
+* `h*llo` subscribes to `hllo` and `heeeello`
+* `h[ae]llo` subscribes to `hello` and `hallo,` but not `hillo`
+
+Use `\` to escape special characters if you want to match them verbatim.
+
+Once the client enters the subscribed state it is not supposed to issue any other commands, except for additional [`SUBSCRIBE`]({{< relref "/commands/subscribe" >}}), [`SSUBSCRIBE`]({{< relref "/commands/ssubscribe" >}}), `PSUBSCRIBE`, [`UNSUBSCRIBE`]({{< relref "/commands/unsubscribe" >}}), [`SUNSUBSCRIBE`]({{< relref "/commands/sunsubscribe" >}}), [`PUNSUBSCRIBE`]({{< relref "/commands/punsubscribe" >}}), [`PING`]({{< relref "/commands/ping" >}}), [`RESET`]({{< relref "/commands/reset" >}}) and [`QUIT`]({{< relref "/commands/quit" >}}) commands.
+However, if RESP3 is used (see [`HELLO`]({{< relref "/commands/hello" >}})) it is possible for a client to issue any commands while in subscribed state.
+
+For more information, see [Pub/sub]({{< relref "/develop/interact/pubsub" >}}).
+
+## Behavior change history
+
+*   `>= 6.2.0`: [`RESET`]({{< relref "/commands/reset" >}}) can be called to exit subscribed state.
+---
+acl_categories:
+- '@write'
+- '@string'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: milliseconds
+  name: milliseconds
+  type: integer
+- display_text: value
+  name: value
+  type: string
+arity: 4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+complexity: O(1)
+deprecated_since: 2.6.12
+description: Sets both string value and expiration time in milliseconds of a key.
+  The key is created if it doesn't exist.
+doc_flags:
+- deprecated
+group: string
+hidden: false
+key_specs:
+- OW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: PSETEX
+replaced_by: '[`SET`]({{< relref "/commands/set" >}}) with the `PX` argument'
+since: 2.6.0
+summary: Sets both string value and expiration time in milliseconds of a key. The
+  key is created if it doesn't exist.
+syntax_fmt: PSETEX key milliseconds value
+syntax_str: milliseconds value
+title: PSETEX
+---
+`PSETEX` works exactly like [`SETEX`]({{< relref "/commands/setex" >}}) with the sole difference that the expire
+time is specified in milliseconds instead of seconds.
+
+## Examples
+
+{{% redis-cli %}}
+PSETEX mykey 1000 "Hello"
+PTTL mykey
+GET mykey
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@read'
+- '@sortedset'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: start
+  name: start
+  type: string
+- display_text: stop
+  name: stop
+  type: string
+- arguments:
+  - display_text: byscore
+    name: byscore
+    token: BYSCORE
+    type: pure-token
+  - display_text: bylex
+    name: bylex
+    token: BYLEX
+    type: pure-token
+  name: sortby
+  optional: true
+  since: 6.2.0
+  type: oneof
+- display_text: rev
+  name: rev
+  optional: true
+  since: 6.2.0
+  token: REV
+  type: pure-token
+- arguments:
+  - display_text: offset
+    name: offset
+    type: integer
+  - display_text: count
+    name: count
+    type: integer
+  name: limit
+  optional: true
+  since: 6.2.0
+  token: LIMIT
+  type: block
+- display_text: withscores
+  name: withscores
+  optional: true
+  token: WITHSCORES
+  type: pure-token
+arity: -4
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(log(N)+M) with N being the number of elements in the sorted set and
+  M the number of elements returned.
+description: Returns members in a sorted set within a range of indexes.
+group: sorted-set
+hidden: false
+history:
+- - 6.2.0
+  - Added the `REV`, `BYSCORE`, `BYLEX` and `LIMIT` options.
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: ZRANGE
+since: 1.2.0
+summary: Returns members in a sorted set within a range of indexes.
+syntax_fmt: "ZRANGE key start stop [BYSCORE | BYLEX] [REV] [LIMIT\_offset count]\n\
+  \  [WITHSCORES]"
+syntax_str: "start stop [BYSCORE | BYLEX] [REV] [LIMIT\_offset count] [WITHSCORES]"
+title: ZRANGE
+---
+Returns the specified range of elements in the sorted set stored at `<key>`.
+
+`ZRANGE` can perform different types of range queries: by index (rank), by the score, or by lexicographical order.
+
+Starting with Redis 6.2.0, this command can replace the following commands: [`ZREVRANGE`]({{< relref "/commands/zrevrange" >}}), [`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}}), [`ZREVRANGEBYSCORE`]({{< relref "/commands/zrevrangebyscore" >}}), [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) and [`ZREVRANGEBYLEX`]({{< relref "/commands/zrevrangebylex" >}}).
+
+## Common behavior and options
+
+The order of elements is from the lowest to the highest score. Elements with the same score are ordered lexicographically.
+
+The optional `REV` argument reverses the ordering, so elements are ordered from highest to lowest score, and score ties are resolved by reverse lexicographical ordering.
+
+The optional `LIMIT` argument can be used to obtain a sub-range from the matching elements (similar to _SELECT LIMIT offset, count_ in SQL).
+A negative `<count>` returns all elements from the `<offset>`. Keep in mind that if `<offset>` is large, the sorted set needs to be traversed for `<offset>` elements before getting to the elements to return, which can add up to O(N) time complexity.
+
+The optional `WITHSCORES` argument supplements the command's reply with the scores of elements returned. The returned list contains `value1,score1,...,valueN,scoreN` instead of `value1,...,valueN`. Client libraries are free to return a more appropriate data type (suggestion: an array with (value, score) arrays/tuples).
+
+## Index ranges
+
+By default, the command performs an index range query. The `<start>` and `<stop>` arguments represent zero-based indexes, where `0` is the first element, `1` is the next element, and so on. These arguments specify an **inclusive range**, so for example, `ZRANGE myzset 0 1` will return both the first and the second element of the sorted set.
+
+The indexes can also be negative numbers indicating offsets from the end of the sorted set, with `-1` being the last element of the sorted set, `-2` the penultimate element, and so on.
+
+Out of range indexes do not produce an error.
+
+If `<start>` is greater than either the end index of the sorted set or `<stop>`, an empty list is returned.
+
+If `<stop>` is greater than the end index of the sorted set, Redis will use the last element of the sorted set.
+
+## Score ranges
+
+When the `BYSCORE` option is provided, the command behaves like [`ZRANGEBYSCORE`]({{< relref "/commands/zrangebyscore" >}}) and returns the range of elements from the sorted set having scores equal or between `<start>` and `<stop>`.
+
+`<start>` and `<stop>` can be `-inf` and `+inf`, denoting the negative and positive infinities, respectively. This means that you are not required to know the highest or lowest score in the sorted set to get all elements from or up to a certain score.
+
+By default, the score intervals specified by `<start>` and `<stop>` are closed (inclusive).
+It is possible to specify an open interval (exclusive) by prefixing the score
+with the character `(`.
+
+For example:
+
+```
+ZRANGE zset (1 5 BYSCORE
+```
+
+Will return all elements with `1 < score <= 5` while:
+
+```
+ZRANGE zset (5 (10 BYSCORE
+```
+
+Will return all the elements with `5 < score < 10` (5 and 10 excluded).
+
+## Reverse ranges
+
+Using the `REV` option reverses the sorted set, with index 0 as the element with the highest score.
+
+By default, `<start>` must be less than or equal to `<stop>` to return anything.
+However, if the `BYSCORE`, or `BYLEX` options are selected, the `<start>` is the highest score to consider, and `<stop>` is the lowest score to consider, therefore `<start>` must be greater than or equal to `<stop>` in order to return anything.
+
+For example:
+
+```
+ZRANGE zset 5 10 REV
+```
+
+Will return the elements between index 5 and 10 in the reversed index.
+
+```
+ZRANGE zset 10 5 REV BYSCORE
+```
+
+Will return all elements with scores less than 10 and greater than 5.
+
+## Lexicographical ranges
+
+When the `BYLEX` option is used, the command behaves like [`ZRANGEBYLEX`]({{< relref "/commands/zrangebylex" >}}) and returns the range of elements from the sorted set between the `<start>` and `<stop>` lexicographical closed range intervals.
+
+Note that lexicographical ordering relies on all elements having the same score. The reply is unspecified when the elements have different scores.
+
+Valid `<start>` and `<stop>` must start with `(` or `[`, in order to specify
+whether the range interval is exclusive or inclusive, respectively.
+
+The special values of `+` or `-` for `<start>` and `<stop>` mean positive and negative infinite strings, respectively, so for instance the command `ZRANGE myzset - + BYLEX` is guaranteed to return all the elements in the sorted set, providing that all the elements have the same score.
+
+The `REV` options reverses the order of the `<start>` and `<stop>` elements, where `<start>` must be lexicographically greater than `<stop>` to produce a non-empty result.
+
+### Lexicographical comparison of strings
+
+Strings are compared as a binary array of bytes. Because of how the ASCII character set is specified, this means that usually this also have the effect of comparing normal ASCII characters in an obvious dictionary way. However, this is not true if non-plain ASCII strings are used (for example, utf8 strings).
+
+However, the user can apply a transformation to the encoded string so that the first part of the element inserted in the sorted set will compare as the user requires for the specific application. For example, if I want to
+add strings that will be compared in a case-insensitive way, but I still
+want to retrieve the real case when querying, I can add strings in the
+following way:
+
+    ZADD autocomplete 0 foo:Foo 0 bar:BAR 0 zap:zap
+
+Because of the first *normalized* part in every element (before the colon character), we are forcing a given comparison. However, after the range is queried using `ZRANGE ... BYLEX`, the application can display to the user the second part of the string, after the colon.
+
+The binary nature of the comparison allows to use sorted sets as a general purpose index, for example, the first part of the element can be a 64-bit big-endian number. Since big-endian numbers have the most significant bytes in the initial positions, the binary comparison will match the numerical comparison of the numbers. This can be used in order to implement range queries on 64-bit values. As in the example below, after the first 8 bytes, we can store the value of the element we are indexing.
+
+## Examples
+
+{{< clients-example cmds_sorted_set zrange1 >}}
+> ZADD myzset 1 "one" 2 "two" 3 "three"
+(integer) 3
+> ZRANGE myzset 0 -1
+1) "one"
+2) "two"
+3) "three"
+> ZRANGE myzset 2 3
+1) "three"
+> ZRANGE myzset -2 -1
+1) "two"
+2) "three"
+{{< /clients-example >}}
+
+The following example using `WITHSCORES` shows how the command returns always an array, but this time, populated with *element_1*, *score_1*, *element_2*, *score_2*, ..., *element_N*, *score_N*.
+
+{{< clients-example cmds_sorted_set zrange2 >}}
+> ZADD myzset 1 "one" 2 "two" 3 "three"
+(integer) 3
+> ZRANGE myzset 0 1 WITHSCORES
+1) "one"
+2) "1"
+3) "two"
+4) "2"
+{{< /clients-example >}}
+
+This example shows how to query the sorted set by score, excluding the value `1` and up to infinity, returning only the second element of the result:
+
+{{< clients-example cmds_sorted_set zrange3 >}}
+> ZADD myzset 1 "one" 2 "two" 3 "three"
+(integer) 3
+> ZRANGE myzset (1 +inf BYSCORE LIMIT 1 1
+1) "three"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+ZADD myzset 1 "one" 2 "two" 3 "three"
+ZRANGE myzset 0 -1
+ZRANGE myzset 2 3
+ZRANGE myzset -2 -1
+{{% /redis-cli %}}---
+acl_categories:
+- '@read'
+- '@geo'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: member
+  multiple: true
+  name: member
+  optional: true
+  type: string
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- readonly
+complexity: O(1) for each member requested.
+description: Returns the longitude and latitude of members from a geospatial index.
+group: geo
+hidden: false
+key_specs:
+- RO: true
+  access: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+linkTitle: GEOPOS
+since: 3.2.0
+summary: Returns the longitude and latitude of members from a geospatial index.
+syntax_fmt: GEOPOS key [member [member ...]]
+syntax_str: '[member [member ...]]'
+title: GEOPOS
+---
+Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at *key*.
+
+Given a sorted set representing a geospatial index, populated using the [`GEOADD`]({{< relref "/commands/geoadd" >}}) command, it is often useful to obtain back the coordinates of specified members. When the geospatial index is populated via [`GEOADD`]({{< relref "/commands/geoadd" >}}) the coordinates are converted into a 52 bit geohash, so the coordinates returned may not be exactly the ones used in order to add the elements, but small errors may be introduced.
+
+The command can accept a variable number of arguments so it always returns an array of positions even when a single element is specified.
+
+## Examples
+
+{{% redis-cli %}}
+GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
+GEOPOS Sicily Palermo Catania NonExisting
+{{% /redis-cli %}}
+
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: -2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- noscript
+- loading
+- stale
+complexity: Depends on subcommand.
+description: A container for debugging commands.
+doc_flags:
+- syscmd
+group: server
+hidden: true
+linkTitle: DEBUG
+since: 1.0.0
+summary: A container for debugging commands.
+syntax_fmt: DEBUG
+syntax_str: ''
+title: DEBUG
+---
+The `DEBUG` command is an internal command.
+It is meant to be used for developing and testing Redis.---
+acl_categories:
+- '@write'
+- '@list'
+- '@fast'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: element
+  multiple: true
+  name: element
+  type: string
+arity: -3
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+- denyoom
+- fast
+complexity: O(1) for each element added, so O(N) to add N elements when the command
+  is called with multiple arguments.
+description: Prepends one or more elements to a list. Creates the key if it doesn't
+  exist.
+group: list
+hidden: false
+history:
+- - 2.4.0
+  - Accepts multiple `element` arguments.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 1
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  insert: true
+linkTitle: LPUSH
+since: 1.0.0
+summary: Prepends one or more elements to a list. Creates the key if it doesn't exist.
+syntax_fmt: LPUSH key element [element ...]
+syntax_str: element [element ...]
+title: LPUSH
+---
+Insert all the specified values at the head of the list stored at `key`.
+If `key` does not exist, it is created as empty list before performing the push
+operations.
+When `key` holds a value that is not a list, an error is returned.
+
+It is possible to push multiple elements using a single command call just
+specifying multiple arguments at the end of the command.
+Elements are inserted one after the other to the head of the list, from the
+leftmost element to the rightmost element.
+So for instance the command `LPUSH mylist a b c` will result into a list
+containing `c` as first element, `b` as second element and `a` as third element.
+
+## Examples
+{{< clients-example cmds_list lpush >}}
+redis> LPUSH mylist "world"
+(integer) 1
+redis> LPUSH mylist "hello"
+(integer) 2
+redis> LRANGE mylist 0 -1
+1) "hello"
+2) "world"
+{{< /clients-example >}}
+
+Give these commands a try in the interactive console:
+
+{{% redis-cli %}}
+LPUSH mylist "world"
+LPUSH mylist "hello"
+LRANGE mylist 0 -1
+{{% /redis-cli %}}
+---
+acl_categories:
+- '@admin'
+- '@search'
+arguments:
+- name: option
+  type: string
+- name: value
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(1)
+deprecated_since: 8.0.0
+description: Sets runtime configuration options
+doc_flags:
+- deprecated
+group: search
+hidden: false
+linkTitle: FT.CONFIG SET
+module: Search
+replaced_by: '[`CONFIG SET`]({{< relref "/commands/config-set" >}})'
+since: 1.0.0
+stack_path: docs/interact/search-and-query
+summary: Sets runtime configuration options
+syntax: FT.CONFIG SET option value
+syntax_fmt: FT.CONFIG SET option value
+syntax_str: value
+title: FT.CONFIG SET
+---
+
+Set the value of a RediSearch configuration parameter.
+
+Values set using `FT.CONFIG SET` are not persisted after server restart.
+
+RediSearch configuration parameters are detailed in [Configuration parameters]({{< relref "/develop/interact/search-and-query/administration/configuration" >}}).
+
+{{% alert title="Note" color="warning" %}}
+As detailed in the link above, not all RediSearch configuration parameters can be set at runtime.
+{{% /alert %}}
+
+[Examples](#examples)
+
+## Required arguments
+
+<details open>
+<summary><code>option</code></summary> 
+
+is name of the configuration option, or '*' for all. 
+</details>
+
+<details open>
+<summary><code>value</code></summary> 
+
+is value of the configuration option. 
+</details>
+
+## Return
+
+FT.CONFIG SET returns a simple string reply `OK` if executed correctly, or an error reply otherwise.
+
+## Examples
+
+<details open>
+<summary><b>Set runtime configuration options</b></summary>
+
+{{< highlight bash >}}
+127.0.0.1:6379> FT.CONFIG SET TIMEOUT 42
+OK
+{{< / highlight >}}
+</details>
+
+## See also
+
+[`FT.CONFIG GET`]({{< relref "commands/ft.config-get/" >}}) | [`FT.CONFIG HELP`]({{< relref "commands/ft.config-help/" >}}) 
+
+## Related topics
+
+[RediSearch]({{< relref "/develop/interact/search-and-query/" >}})
+---
+acl_categories:
+- '@bloom'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: iterator
+  type: integer
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(n), where n is the capacity
+description: Begins an incremental save of the bloom filter
+group: bf
+hidden: false
+linkTitle: BF.SCANDUMP
+module: Bloom
+since: 1.0.0
+stack_path: docs/data-types/probabilistic
+summary: Begins an incremental save of the bloom filter
+syntax_fmt: BF.SCANDUMP key iterator
+syntax_str: iterator
+title: BF.SCANDUMP
+---
+Begins an incremental save of the Bloom filter.
+
+This command is useful for large Bloom filters that cannot fit into the [`DUMP`]({{< relref "/commands/dump" >}}) and [`RESTORE`]({{< relref "/commands/restore" >}}) model.
+
+The first time this command is called, the value of `iter` should be 0. 
+
+This command returns successive `(iter, data)` pairs until `(0, NULL)` to indicate completion.
+
+## Required arguments
+
+<details open><summary><code>key</code></summary>
+
+is key name for a Bloom filter to save.
+</details>
+
+<details open><summary><code>iterator</code></summary>
+
+Iterator value; either 0 or the iterator from a previous invocation of this command
+</details>
+
+## Return value
+
+Returns one of these replies:
+
+- [Array reply]({{< relref "/develop/reference/protocol-spec#arrays" >}}) of [Integer reply]({{< relref "/develop/reference/protocol-spec#integers" >}}) (_Iterator_) and [] (_Data_). 
+
+  The Iterator is passed as input to the next invocation of `BF.SCANDUMP`. If _Iterator_ is 0, then it means iteration has completed.
+
+  The iterator-data pair should also be passed to [`BF.LOADCHUNK`]({{< relref "commands/bf.loadchunk/" >}}) when restoring the filter.
+
+- [] on error (invalid arguments, key not found, wrong key type, etc.)
+
+## Examples
+
+{{< highlight bash >}}
+redis> BF.RESERVE bf 0.1 10
+OK
+redis> BF.ADD bf item1
+1) (integer) 1
+redis> BF.SCANDUMP bf 0
+1) (integer) 1
+2) "\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x9a\x99\x99\x99\x99\x99\xa9?J\xf7\xd4\x9e\xde\xf0\x18@\x05\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00"
+redis> BF.SCANDUMP bf 1
+1) (integer) 9
+2) "\x01\b\x00\x80\x00\x04 \x00"
+redis> BF.SCANDUMP bf 9
+1) (integer) 0
+2) ""
+redis> DEL bf
+(integer) 1
+redis> BF.LOADCHUNK bf 1 "\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x9a\x99\x99\x99\x99\x99\xa9?J\xf7\xd4\x9e\xde\xf0\x18@\x05\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00"
+OK
+redis> BF.LOADCHUNK bf 9 "\x01\b\x00\x80\x00\x04 \x00"
+OK
+redis> BF.EXISTS bf item1
+(integer) 1
+{{< / highlight >}}
+
+Python code:
+{{< highlight bash >}}
+chunks = []
+iter = 0
+while True:
+    iter, data = BF.SCANDUMP(key, iter)
+    if iter == 0:
+        break
+    else:
+        chunks.append([iter, data])
+
+# Load it back
+for chunk in chunks:
+    iter, data = chunk
+    BF.LOADCHUNK(key, iter, data)
+{{< / highlight >}}
+---
+acl_categories:
+- '@json'
+- '@write'
+- '@slow'
+arguments:
+- name: key
+  type: key
+- name: path
+  optional: true
+  type: string
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+complexity: O(N) when path is evaluated to a single value where N is the size of the
+  deleted value, O(N) when path is evaluated to multiple values, where N is the size
+  of the key
+description: Deletes a value
+group: json
+hidden: false
+linkTitle: JSON.FORGET
+module: JSON
+since: 1.0.0
+stack_path: docs/data-types/json
+summary: Deletes a value
+syntax_fmt: JSON.FORGET key [path]
+syntax_str: '[path]'
+title: JSON.FORGET
+---
+See [`JSON.DEL`]({{< relref "commands/json.del/" >}}).---
+acl_categories:
+- '@write'
+- '@stream'
+- '@slow'
+arguments:
+- display_text: key
+  key_spec_index: 0
+  name: key
+  type: key
+- display_text: group
+  name: group
+  type: string
+- arguments:
+  - display_text: id
+    name: id
+    type: string
+  - display_text: new-id
+    name: new-id
+    token: $
+    type: pure-token
+  name: id-selector
+  type: oneof
+- display_text: entries-read
+  name: entriesread
+  optional: true
+  token: ENTRIESREAD
+  type: integer
+arity: -5
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- write
+complexity: O(1)
+description: Sets the last-delivered ID of a consumer group.
+group: stream
+hidden: false
+history:
+- - 7.0.0
+  - Added the optional `entries_read` argument.
+key_specs:
+- RW: true
+  begin_search:
+    spec:
+      index: 2
+    type: index
+  find_keys:
+    spec:
+      keystep: 1
+      lastkey: 0
+      limit: 0
+    type: range
+  update: true
+linkTitle: XGROUP SETID
+since: 5.0.0
+summary: Sets the last-delivered ID of a consumer group.
+syntax_fmt: "XGROUP SETID key group <id | $> [ENTRIESREAD\_entries-read]"
+syntax_str: "group <id | $> [ENTRIESREAD\_entries-read]"
+title: XGROUP SETID
+---
+Set the **last delivered ID** for a consumer group.
+
+Normally, a consumer group's last delivered ID is set when the group is created with [`XGROUP CREATE`]({{< relref "/commands/xgroup-create" >}}).
+The `XGROUP SETID` command allows modifying the group's last delivered ID, without having to delete and recreate the group.
+For instance if you want the consumers in a consumer group to re-process all the messages in a stream, you may want to set its next ID to 0:
+
+    XGROUP SETID mystream mygroup 0
+
+The optional `entries_read` argument can be specified to enable consumer group lag tracking for an arbitrary ID.
+An arbitrary ID is any ID that isn't the ID of the stream's first entry, its last entry or the zero ("0-0") ID.
+This can be useful you know exactly how many entries are between the arbitrary ID (excluding it) and the stream's last entry.
+In such cases, the `entries_read` can be set to the stream's `entries_added` subtracted with the number of entries.
+---
+acl_categories:
+- '@admin'
+- '@slow'
+- '@dangerous'
+arity: 2
+categories:
+- docs
+- develop
+- stack
+- oss
+- rs
+- rc
+- oss
+- kubernetes
+- clients
+command_flags:
+- admin
+- stale
+- no_async_loading
+complexity: O(1)
+description: Forces a node to save the cluster configuration to disk.
+group: cluster
+hidden: false
+linkTitle: CLUSTER SAVECONFIG
+since: 3.0.0
+summary: Forces a node to save the cluster configuration to disk.
+syntax_fmt: CLUSTER SAVECONFIG
+syntax_str: ''
+title: CLUSTER SAVECONFIG
+---
+Forces a node to save the `nodes.conf` configuration on disk. Before to return
+the command calls `fsync(2)` in order to make sure the configuration is
+flushed on the computer disk.
+
+This command is mainly used in the event a `nodes.conf` node state file
+gets lost / deleted for some reason, and we want to generate it again from
+scratch. It can also be useful in case of mundane alterations of a node cluster
+configuration via the [`CLUSTER`]({{< relref "/commands/cluster" >}}) command in order to ensure the new configuration
+is persisted on disk, however all the commands should normally be able to
+auto schedule to persist the configuration on disk when it is important
+to do so for the correctness of the system in the event of a restart.
+RDI only supports versions of Kubernetes and OpenShift that have
+not yet reached end-of-life (EOL). See the
+[Kubernetes](https://kubernetes.io/releases/) and
+[OpenShift](https://access.redhat.com/support/policy/updates/openshift)
+lifecycle pages for the latest updates.
+If you have not already added a business address to your account, you must enter one. Redis uses your business address for communication, invoicing, and tax purposes.
+
+{{<image filename="images/rc/billing-add-first-card.png" width="80%" alt="The Add credit card screen before a business address has already been added." >}}
+
+If you already have a business address, you don't need to enter one here. See [Account settings]({{< relref "/operate/rc/accounts/account-settings" >}}) to learn how to update your business address.
+
+{{<image filename="images/rc/billing-add-credit-card.png" width="80%" alt="The Add credit card screen after a business address has already been added." >}}
+
+If the card's billing address is the same as your account's business address, select **Same as business address** to fill the billing address with your business address details.* **CPU**: A minimum of 4 CPU cores. You should consider adding
+  2-6 extra cores on top of this if your dataset is big and you want to ingest the
+  baseline snapshot as fast as possible.
+* **RAM**: 8GB 
+* **Disk**: On top of the OS footprint,
+  RDI requires 20GB in the `/var` folder and 1GB in the `/opt` folder (to
+  store the log files). This allows space for upgrades.
+* **Network interface**: 10GB or more.1. Verify the `admission-tls` secret exists.
+
+    ```sh
+    kubectl get secret admission-tls
+    ```
+  
+    The output should look similar to
+  
+    ```sh
+    NAME            TYPE     DATA   AGE
+    admission-tls   Opaque   2      2m43s
+    ```
+
+1. Save the certificate to a local environment variable.
+
+    ```sh
+    CERT=`kubectl get secret admission-tls -o jsonpath='{.data.cert}'`
+    ```
+
+1. Create a Kubernetes validating webhook, replacing `<namespace>` with the namespace where the REC was installed.
+
+    The `webhook.yaml` template can be found in [redis-enterprise-k8s-docs/admission](https://github.com/RedisLabs/redis-enterprise-k8s-docs/tree/master/admission)
+
+    ```sh
+    sed 's/OPERATOR_NAMESPACE/<namespace>/g' webhook.yaml | kubectl create -f -
+    ```
+
+1. Create a patch file for the Kubernetes validating webhook.
+
+    ```sh
+    cat > modified-webhook.yaml <<EOF
+    webhooks:
+    - name: redisenterprise.admission.redislabs
+      clientConfig:
+       caBundle: $CERT
+    EOF
+    ```
+
+1. Patch the webhook with the certificate.
+
+    ```sh
+    kubectl patch ValidatingWebhookConfiguration \
+        redis-enterprise-admission --patch "$(cat modified-webhook.yaml)"
+    ```
+
+Redis Enterprise Software is supported on several operating systems, cloud environments, and virtual environments.
+
+## Supported platforms
+
+<span title="Check mark icon">&#x2705;</span> Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules.
+
+<span title="Warning icon" class="font-serif">:warning:</span> Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release.
+
+| Redis Software<br />major versions | 7.8 | 7.4 | 7.2 | 6.4 | 6.2 |
+|---------------------------------|:-----:|:-----:|:-----:|:-----:|:-----:|
+| **Release date** | Nov 2024 | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 |
+| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after<br />next major release | Nov 2026 | Feb 2026 | Aug 2025 | Feb 2025 |
+| **Platforms** | | | | | |
+| RHEL 9 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – | – | – |
+| RHEL 9<br />FIPS mode<sup>[5](#table-note-5)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| RHEL 8 &<br />compatible distros<sup>[1](#table-note-1)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| RHEL 7 &<br />compatible distros<sup>[1](#table-note-1)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 22.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | – | – | – | – |
+| Ubuntu 20.04<sup>[2](#table-note-2)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Ubuntu 18.04<sup>[2](#table-note-2)</sup> | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Ubuntu 16.04<sup>[2](#table-note-2)</sup> | – | – | <span title="Deprecated" class="font-serif">:warning:</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Amazon Linux 2 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | – |
+| Amazon Linux 1 | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Kubernetes<sup>[3](#table-note-3)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| Docker<sup>[4](#table-note-4)</sup> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+
+1. <a name="table-note-1"></a>The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported.
+
+2. <a name="table-note-2"></a>The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments.
+
+3. <a name="table-note-3"></a>See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution.
+
+4. <a name="table-note-4"></a>[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only.
+
+5. <a name="table-note-5"></a>Supported only if [FIPS was enabled during RHEL installation](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/9/html/security_hardening/switching-rhel-to-fips-mode_security-hardening#proc_installing-the-system-with-fips-mode-enabled_switching-rhel-to-fips-mode) to ensure FIPS compliance.
+
+The following table shows which Redis Enterprise Software version first tested and added support for each RHEL version:
+
+| RHEL version | Redis Enterprise version |
+|--------------|--------------------------|
+| 8.4 | 6.2.8 |
+| 8.5 | 6.2.10 |
+| 8.6 | 6.2.10 |
+| 8.7 | 6.4.2 |
+| 8.8 | 6.4.2 |
+| 8.9 | 7.2.4 |
+| 9.3 | 7.4.2 |
+| 9.5 | 7.8.2 |
+
+## Operating system compatibility policy
+
+Redis maintains a list of [supported operating systems](#supported-platforms) for each major version of Redis Enterprise Software and the specific OS versions tested with Redis Enterprise releases. Because the list is updated as new OS versions are introduced and old ones become obsolete, we encourage you to check the list and plan upgrades accordingly. We also suggest you keep Redis Enterprise and corresponding supported OS versions up to date.
+
+We thoroughly test the most recent minor version of each supported major OS to ensure the best compatibility and performance with every Redis Enterprise release. This process helps detect and address potential compatibility issues early on.
+
+Due to the vast array of minor updates and variations across operating systems, we cannot test compatibility with every minor OS version and each Redis Enterprise version. However, because OS vendors each have an Application Binary Interface (ABI) they support and avoid breaking, except to address severe security issues, newer minor OS versions are generally expected to work correctly. We will add a note to this document if specific OS minor versions have significant ABI or dependency changes. An earlier OS minor version also might work, although it is not guaranteed.
+
+Despite our rigorous testing, we recommend users test their Redis applications with any new OS update before deploying it in a production environment. This additional testing layer can help identify any unique issues in your setup.
+
+### Red Hat Enterprise Linux (RHEL) 
+
+Red Hat has a well-defined lifecycle for support. For details, see [Red Hat Enterprise Linux Life Cycle](https://access.redhat.com/support/policy/updates/errata#RHEL8_and_9_Life_Cycle).
+
+Redis supports and tests RHEL 8 and 9 minor releases and extended update support timeframes. However, none of the longer Red Hat support cycles, such as SAP and EEUS, are supported.
+
+We only support what the vendor supports in accordance with their policies. When Red Hat no longer supports a particular release, it is no longer supported by Redis as well. If future Redis Enterprise releases will not support a major RHEL version, the release notes and the [supported platforms](#supported-platforms) table will include deprecation warnings.
+
+### RHEL clones and equivalent Enterprise OS 
+
+The [supported platforms](#supported-platforms) table lists the versions of Red Hat Enterprise Linux (RHEL) that Redis supports. This support extends to the ABI and package compatibility with RHEL of the same version.
+
+The RHEL-compatible distributions CentOS, CentOS Stream, Alma Linux, Rocky Linux, and Oracle Linux running the Red Hat Compatible Kernel (RHCK) are supported if they provide full RHEL compatibility. If Redis identifies or questions some incompatibility from a clone, you might be asked to test on another clone or RHEL directly.
+
+## Operating system limitations
+
+### TLS 1.0 and TLS 1.1
+
+Redis Enterprise Software version 6.2.8 removed support for TLS 1.0 and TLS 1.1 on Red Hat Enterprise Linux 8 (RHEL 8) because that operating system [does not enable support](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/security_hardening/using-the-system-wide-cryptographic-policies_security-hardening) for these versions by default.  
+
+### Ubuntu 20 rejects SHA1 certificates
+
+With Ubuntu 20.04, you cannot use the SHA1 hash algorithm because [OpenSSL's security level is set to 2 by default](https://manpages.ubuntu.com/manpages/focal/man3/SSL_CTX_set_security_level.3ssl.html#notes). As a result, the operating system rejects SHA1 certificates, even if you enable the `mtls_allow_weak_hashing` option.
+
+To avoid issues with SHA1 certificates, replace them with new certificates that use SHA-256. Note that certificates provided by Redis Enterprise Software use SHA-256.
+
+### Upgrade RHEL when using modules
+
+RHEL 7 clusters cannot be directly upgraded to RHEL 8 when hosting databases using modules, due to binary differences in modules between the two operating systems. Instead, you need to create a new cluster on RHEL 8 and then migrate existing data from your RHEL 7 cluster. This does not apply to clusters that do not use modules.
+
+This limitation is fixed for clusters using Redis Enterprise Software version 7.2.4 and later.
+
+### Modules cannot load in Oracle Linux 7 & 8
+
+Databases hosted on Oracle Linux 7 & 8 cannot load modules.
+
+As a temporary workaround, you can change the node's `os_name` in the Cluster Configuration Store (CCS):
+
+```sh
+ccs-cli hset node:<ID> os_name rhel
+```
+
+This limitation was fixed in [Redis Enterprise Software version 7.2.4-64]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-64" >}}).
+
+### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2
+
+Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries.
+
+This issue will be fixed in a future maintenance release.
+
+### RedisGraph prevents upgrade to RHEL 9 
+
+You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9.
+
+## Virtualization platforms
+
+Redis Enterprise Software is compatible with VMware and other similar virtualization platforms. Make sure to do the following:
+
+- Configure your memory, CPU, network, and storage settings to allow for optimal Redis Enterprise performance.
+- Pin each Redis Enterprise shard to a specific ESX or ESXi host by setting the appropriate affinity rules.
+- If you must manually migrate a virtual machine to another host, follow the best practices for [shard maintenance]({{<relref "/operate/rs/clusters/maintenance-mode">}}) and contact support if you have questions.
+- Turn off VMware VMotion because Redis Enterprise is not compatible with VMotion.
+- Don't use snapshots because Redis Enterprise cluster manages states dynamically, so a snapshot might not have the correct node and cluster states.
+1. In your web browser, open the admin console of the cluster that you want to connect to in order to create the { { < field "db_type"  > } }.
+
+<!-- When shortcodes can run in embeds, fix field shrotcode above. -->
+
+    By default, the address is: `https://<RS_address>:8443`
+
+1. In **databases**, click {{< image filename="/images/rs/icon_add.png#no-click" alt="Add" >}}.
+
+    If you do not have any databases on the node, you are prompted to create a database.| heading 1 | heading 2 | heading 3 |
+| :-----| :-----: |-----: |
+| cell 1x1  | cell 1x2  | cell 1x3  |
+| cell 2x1  | cell 2x2  | cell 2x3  |
+
+{{< expand "Example Shortcode" >}}
+Inside an embedded markdown file.
+{{< /expand >}}  
+
+{{< tip >}}Another example of shortcode inside an embedded file.{{< /tip >}}---
+{}
+---
+Select the **Cost report** button to download a report of all shard costs in CSV format.
+
+{{<image filename="images/rc/button-cost-report-download.png" width=150px alt="The cost report download button." >}}
+
+The report gives a breakdown of all your Redis billing unit costs, per subscription and database, by month. Subscriptions under the minimum subscription price are broken down into actual billing unit prices and the difference from minimum price.
+The following tables include the v1 metrics available to Prometheus.
+
+## Database metrics
+
+| Metric | Description |
+| ------ | :------ |
+| bdb_avg_latency | Average latency of operations on the database (seconds); returned only when there is traffic |
+| bdb_avg_latency_max | Highest value of average latency of operations on the database (seconds); returned only when there is traffic |
+| bdb_avg_read_latency | Average latency of read operations (seconds); returned only when there is traffic |
+| bdb_avg_read_latency_max | Highest value of average latency of read operations (seconds); returned only when there is traffic |
+| bdb_avg_write_latency | Average latency of write operations (seconds); returned only when there is traffic |
+| bdb_avg_write_latency_max | Highest value of average latency of write operations (seconds); returned only when there is traffic |
+| bdb_bigstore_shard_count | Shard count by database and by storage engine (driver - rocksdb / speedb); Only for databases with Auto Tiering enabled |
+| bdb_conns | Number of client connections to the database |
+| bdb_egress_bytes | Rate of outgoing network traffic from the database (bytes/sec) |
+| bdb_egress_bytes_max | Highest value of the rate of outgoing network traffic from the database (bytes/sec) |
+| bdb_evicted_objects | Rate of key evictions from database (evictions/sec) |
+| bdb_evicted_objects_max | Highest value of the rate of key evictions from database (evictions/sec) |
+| bdb_expired_objects | Rate keys expired in database (expirations/sec) |
+| bdb_expired_objects_max | Highest value of the rate keys expired in database (expirations/sec) |
+| bdb_fork_cpu_system | % cores utilization in system mode for all Redis shard fork child processes of this database |
+| bdb_fork_cpu_system_max | Highest value of % cores utilization in system mode for all Redis shard fork child processes of this database |
+| bdb_fork_cpu_user | % cores utilization in user mode for all Redis shard fork child processes of this database |
+| bdb_fork_cpu_user_max | Highest value of % cores utilization in user mode for all Redis shard fork child processes of this database |
+| bdb_ingress_bytes | Rate of incoming network traffic to the database (bytes/sec) |
+| bdb_ingress_bytes_max | Highest value of the rate of incoming network traffic to the database (bytes/sec) |
+| bdb_instantaneous_ops_per_sec | Request rate handled by all shards of database (ops/sec) |
+| bdb_main_thread_cpu_system | % cores utilization in system mode for all Redis shard main threads of this database |
+| bdb_main_thread_cpu_system_max | Highest value of % cores utilization in system mode for all Redis shard main threads of this database |
+| bdb_main_thread_cpu_user | % cores utilization in user mode for all Redis shard main threads of this database |
+| bdb_main_thread_cpu_user_max | Highest value of % cores utilization in user mode for all Redis shard main threads of this database |
+| bdb_mem_frag_ratio | RAM fragmentation ratio (RSS / allocated RAM) |
+| bdb_mem_size_lua | Redis lua scripting heap size (bytes) |
+| bdb_memory_limit | Configured RAM limit for the database |
+| bdb_monitor_sessions_count | Number of clients connected in monitor mode to the database |
+| bdb_no_of_keys | Number of keys in database |
+| bdb_other_req | Rate of other (non read/write) requests on the database (ops/sec) |
+| bdb_other_req_max | Highest value of the rate of other (non read/write) requests on the database (ops/sec) |
+| bdb_other_res | Rate of other (non read/write) responses on the database (ops/sec) |
+| bdb_other_res_max | Highest value of the rate of other (non read/write) responses on the database (ops/sec) |
+| bdb_pubsub_channels | Count the pub/sub channels with subscribed clients |
+| bdb_pubsub_channels_max | Highest value of count the pub/sub channels with subscribed clients |
+| bdb_pubsub_patterns | Count the pub/sub patterns with subscribed clients |
+| bdb_pubsub_patterns_max | Highest value of count the pub/sub patterns with subscribed clients |
+| bdb_read_hits | Rate of read operations accessing an existing key (ops/sec) |
+| bdb_read_hits_max | Highest value of the rate of read operations accessing an existing key (ops/sec) |
+| bdb_read_misses | Rate of read operations accessing a non-existing key (ops/sec) |
+| bdb_read_misses_max | Highest value of the rate of read operations accessing a non-existing key (ops/sec) |
+| bdb_read_req | Rate of read requests on the database (ops/sec) |
+| bdb_read_req_max | Highest value of the rate of read requests on the database (ops/sec) |
+| bdb_read_res | Rate of read responses on the database (ops/sec) |
+| bdb_read_res_max | Highest value of the rate of read responses on the database (ops/sec) |
+| bdb_shard_cpu_system | % cores utilization in system mode for all redis shard processes of this database |
+| bdb_shard_cpu_system_max | Highest value of % cores utilization in system mode for all Redis shard processes of this database |
+| bdb_shard_cpu_user | % cores utilization in user mode for the redis shard process |
+| bdb_shard_cpu_user_max | Highest value of % cores utilization in user mode for the Redis shard process |
+| bdb_shards_used | Used shard count by database and by shard type (ram / flash) |
+| bdb_total_connections_received | Rate of new client connections to the database (connections/sec) |
+| bdb_total_connections_received_max | Highest value of the rate of new client connections to the database (connections/sec) |
+| bdb_total_req | Rate of all requests on the database (ops/sec) |
+| bdb_total_req_max | Highest value of the rate of all requests on the database (ops/sec) |
+| bdb_total_res | Rate of all responses on the database (ops/sec) |
+| bdb_total_res_max | Highest value of the rate of all responses on the database (ops/sec) |
+| bdb_up | Database is up and running |
+| bdb_used_memory | Memory used by the database (in BigRedis this includes flash) (bytes) |
+| bdb_write_hits | Rate of write operations accessing an existing key (ops/sec) |
+| bdb_write_hits_max | Highest value of the rate of write operations accessing an existing key (ops/sec) |
+| bdb_write_misses | Rate of write operations accessing a non-existing key (ops/sec) |
+| bdb_write_misses_max | Highest value of the rate of write operations accessing a non-existing key (ops/sec) |
+| bdb_write_req | Rate of write requests on the database (ops/sec) |
+| bdb_write_req_max | Highest value of the rate of write requests on the database (ops/sec) |
+| bdb_write_res | Rate of write responses on the database (ops/sec) |
+| bdb_write_res_max | Highest value of the rate of write responses on the database (ops/sec) |
+| no_of_expires | Current number of volatile keys in the database |
+
+## Node metrics
+
+| Metric | Description |
+| ------ | :------ |
+| node_available_flash | Available flash in the node (bytes) |
+| node_available_flash_no_overbooking | Available flash in the node (bytes), without taking into account overbooking |
+| node_available_memory | Amount of free memory in the node (bytes) that is available for database provisioning |
+| node_available_memory_no_overbooking | Available ram in the node (bytes) without taking into account overbooking |
+| node_avg_latency | Average latency of requests handled by endpoints on the node in milliseconds; returned only when there is traffic |
+| node_bigstore_free | Sum of free space of back-end flash (used by flash database's BigRedis) on all cluster nodes (bytes); returned only when BigRedis is enabled |
+| node_bigstore_iops | Rate of i/o operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| node_bigstore_kv_ops | Rate of value read/write operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| node_bigstore_throughput | Throughput i/o operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (bytes/sec); returned only when BigRedis is enabled |
+| node_cert_expiration_seconds | Certificate expiration (in seconds) per given node; read more about [certificates in Redis Enterprise]({{< relref "/operate/rs/security/certificates" >}}) and [monitoring certificates]({{< relref "/operate/rs/security/certificates/monitor-certificates" >}}) |
+| node_conns | Number of clients connected to endpoints on node |
+| node_cpu_idle | CPU idle time portion (0-1, multiply by 100 to get percent) |
+| node_cpu_idle_max | Highest value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| node_cpu_idle_median | Average value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| node_cpu_idle_min | Lowest value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| node_cpu_system | CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| node_cpu_system_max | Highest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| node_cpu_system_median | Average value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| node_cpu_system_min | Lowest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| node_cpu_user | CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| node_cpu_user_max | Highest value of CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| node_cpu_user_median | Average value of CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| node_cpu_user_min | Lowest value of CPU time portion spent by users-pace processes (0-1, multiply by 100 to get percent) |
+| node_cur_aof_rewrites | Number of aof rewrites that are currently performed by shards on this node |
+| node_egress_bytes | Rate of outgoing network traffic to node (bytes/sec) |
+| node_egress_bytes_max | Highest value of the rate of outgoing network traffic to node (bytes/sec) |
+| node_egress_bytes_median | Average value of the rate of outgoing network traffic to node (bytes/sec) |
+| node_egress_bytes_min | Lowest value of the rate of outgoing network traffic to node (bytes/sec) |
+| node_ephemeral_storage_avail | Disk space available to RLEC processes on configured ephemeral disk (bytes) |
+| node_ephemeral_storage_free | Free disk space on configured ephemeral disk (bytes) |
+| node_free_memory | Free memory in the node (bytes) |
+| node_ingress_bytes | Rate of incoming network traffic to node (bytes/sec) |
+| node_ingress_bytes_max | Highest value of the rate of incoming network traffic to node (bytes/sec) |
+| node_ingress_bytes_median | Average value of the rate of incoming network traffic to node (bytes/sec) |
+| node_ingress_bytes_min | Lowest value of the rate of incoming network traffic to node (bytes/sec) |
+| node_persistent_storage_avail | Disk space available to RLEC processes on configured persistent disk (bytes) |
+| node_persistent_storage_free | Free disk space on configured persistent disk (bytes) |
+| node_provisional_flash | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash and provision and migration thresholds (bytes) |
+| node_provisional_flash_no_overbooking | Amount of flash available for new shards on this node, without taking into account overbooking, max Redis servers, reserved flash and provision and migration thresholds (bytes) |
+| node_provisional_memory | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases |
+| node_provisional_memory_no_overbooking | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases, without taking into account overbooking |
+| node_total_req | Request rate handled by endpoints on node (ops/sec) |
+| node_up | Node is part of the cluster and is connected |
+
+## Cluster metrics
+
+| Metric | Description |
+| ------ | :------ |
+| cluster_shards_limit | Total shard limit by the license by shard type (ram / flash) |
+
+
+## Proxy metrics
+
+| Metric | Description |
+| ------ | :------ |
+| listener_acc_latency | Accumulative latency (sum of the latencies) of all types of commands on the database. For the average latency, divide this value by listener_total_res |
+| listener_acc_latency_max | Highest value of accumulative latency of all types of commands on the database |
+| listener_acc_other_latency | Accumulative latency (sum of the latencies) of commands that are the type "other" on the database. For the average latency, divide this value by listener_other_res |
+| listener_acc_other_latency_max | Highest value of accumulative latency of commands that are the type "other" on the database |
+| listener_acc_read_latency | Accumulative latency (sum of the latencies) of commands that are the type "read" on the database. For the average latency, divide this value by listener_read_res |
+| listener_acc_read_latency_max | Highest value of accumulative latency of commands that are the type "read" on the database |
+| listener_acc_write_latency | Accumulative latency (sum of the latencies) of commands that are the type "write" on the database. For the average latency, divide this value by listener_write_res |
+| listener_acc_write_latency_max | Highest value of accumulative latency of commands that are the type "write" on the database |
+| listener_auth_cmds | Number of memcached AUTH commands sent to the database |
+| listener_auth_cmds_max | Highest value of the number of memcached AUTH commands sent to the database |
+| listener_auth_errors | Number of error responses to memcached AUTH commands  |
+| listener_auth_errors_max | Highest value of the number of error responses to memcached AUTH commands  |
+| listener_cmd_flush | Number of memcached FLUSH_ALL commands sent to the database |
+| listener_cmd_flush_max | Highest value of the number of memcached FLUSH_ALL commands sent to the database |
+| listener_cmd_get | Number of memcached GET commands sent to the database |
+| listener_cmd_get_max | Highest value of the number of memcached GET commands sent to the database |
+| listener_cmd_set | Number of memcached SET commands sent to the database |
+| listener_cmd_set_max | Highest value of the number of memcached SET commands sent to the database |
+| listener_cmd_touch | Number of memcached TOUCH commands sent to the database |
+| listener_cmd_touch_max | Highest value of the number of memcached TOUCH commands sent to the database |
+| listener_conns | Number of clients connected to the endpoint |
+| listener_egress_bytes | Rate of outgoing network traffic to the endpoint (bytes/sec) |
+| listener_egress_bytes_max | Highest value of the rate of outgoing network traffic to the endpoint (bytes/sec) |
+| listener_ingress_bytes | Rate of incoming network traffic to the endpoint (bytes/sec) |
+| listener_ingress_bytes_max | Highest value of the rate of incoming network traffic to the endpoint (bytes/sec) |
+| listener_last_req_time | Time of last command sent to the database |
+| listener_last_res_time | Time of last response sent from the database |
+| listener_max_connections_exceeded | Number of times the Number of clients connected to the database at the same time has exeeded the max limit |
+| listener_max_connections_exceeded_max | Highest value of the number of times the Number of clients connected to the database at the same time has exeeded the max limit |
+| listener_monitor_sessions_count | Number of client connected in monitor mode to the endpoint |
+| listener_other_req | Rate of other (non read/write) requests on the endpoint (ops/sec) |
+| listener_other_req_max | Highest value of the rate of other (non read/write) requests on the endpoint (ops/sec) |
+| listener_other_res | Rate of other (non read/write) responses on the endpoint (ops/sec) |
+| listener_other_res_max | Highest value of the rate of other (non read/write) responses on the endpoint (ops/sec) |
+| listener_other_started_res | Number of responses sent from the database of type "other" |
+| listener_other_started_res_max | Highest value of the number of responses sent from the database of type "other" |
+| listener_read_req | Rate of read requests on the endpoint (ops/sec) |
+| listener_read_req_max | Highest value of the rate of read requests on the endpoint (ops/sec) |
+| listener_read_res | Rate of read responses on the endpoint (ops/sec) |
+| listener_read_res_max | Highest value of the rate of read responses on the endpoint (ops/sec) |
+| listener_read_started_res | Number of responses sent from the database of type "read" |
+| listener_read_started_res_max | Highest value of the number of responses sent from the database of type "read" |
+| listener_total_connections_received | Rate of new client connections to the endpoint (connections/sec) |
+| listener_total_connections_received_max | Highest value of the rate of new client connections to the endpoint (connections/sec) |
+| listener_total_req | Request rate handled by the endpoint (ops/sec) |
+| listener_total_req_max | Highest value of the rate of all requests on the endpoint (ops/sec) |
+| listener_total_res | Rate of all responses on the endpoint (ops/sec) |
+| listener_total_res_max | Highest value of the rate of all responses on the endpoint (ops/sec) |
+| listener_total_started_res | Number of responses sent from the database of all types |
+| listener_total_started_res_max | Highest value of the number of responses sent from the database of all types |
+| listener_write_req | Rate of write requests on the endpoint (ops/sec) |
+| listener_write_req_max | Highest value of the rate of write requests on the endpoint (ops/sec) |
+| listener_write_res | Rate of write responses on the endpoint (ops/sec) |
+| listener_write_res_max | Highest value of the rate of write responses on the endpoint (ops/sec) |
+| listener_write_started_res | Number of responses sent from the database of type "write" |
+| listener_write_started_res_max | Highest value of the number of responses sent from the database of type "write" |
+
+## Replication metrics
+
+| Metric | Description |
+| ------ | :------ |
+| bdb_replicaof_syncer_ingress_bytes | Rate of compressed incoming network traffic to a Replica Of database (bytes/sec) |
+| bdb_replicaof_syncer_ingress_bytes_decompressed | Rate of decompressed incoming network traffic to a Replica Of database (bytes/sec) |
+| bdb_replicaof_syncer_local_ingress_lag_time | Lag time between the source and the destination for Replica Of traffic (ms) |
+| bdb_replicaof_syncer_status | Syncer status for Replica Of traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |
+| bdb_crdt_syncer_ingress_bytes | Rate of compressed incoming network traffic to CRDB (bytes/sec) |
+| bdb_crdt_syncer_ingress_bytes_decompressed | Rate of decompressed incoming network traffic to CRDB (bytes/sec) |
+| bdb_crdt_syncer_local_ingress_lag_time | Lag time between the source and the destination (ms) for CRDB traffic |
+| bdb_crdt_syncer_status | Syncer status for CRDB traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |
+
+## Shard metrics
+
+| Metric | Description |
+| ------ | :------ |
+| redis_active_defrag_running | Automatic memory defragmentation current aggressiveness (% cpu) |
+| redis_allocator_active | Total used memory, including external fragmentation |
+| redis_allocator_allocated | Total allocated memory |
+| redis_allocator_resident | Total resident memory (RSS) |
+| redis_aof_last_cow_size | Last AOFR, CopyOnWrite memory |
+| redis_aof_rewrite_in_progress | The number of simultaneous AOF rewrites that are in progress |
+| redis_aof_rewrites | Number of AOF rewrites this process executed |
+| redis_aof_delayed_fsync | Number of times an AOF fsync caused delays in the Redis main thread (inducing latency); this can indicate that the disk is slow or overloaded |
+| redis_blocked_clients | Count the clients waiting on a blocking call |
+| redis_connected_clients | Number of client connections to the specific shard |
+| redis_connected_slaves | Number of connected replicas |
+| redis_db0_avg_ttl | Average TTL of all volatile keys |
+| redis_db0_expires | Total count of volatile keys |
+| redis_db0_keys | Total key count |
+| redis_evicted_keys | Keys evicted so far (since restart) |
+| redis_expire_cycle_cpu_milliseconds | The cumulative amount of time spent on active expiry cycles |
+| redis_expired_keys | Keys expired so far (since restart) |
+| redis_forwarding_state | Shard forwarding state (on or off) |
+| redis_keys_trimmed | The number of keys that were trimmed in the current or last resharding process |
+| redis_keyspace_read_hits | Number of read operations accessing an existing keyspace |
+| redis_keyspace_read_misses | Number of read operations accessing an non-existing keyspace |
+| redis_keyspace_write_hits | Number of write operations accessing an existing keyspace |
+| redis_keyspace_write_misses | Number of write operations accessing an non-existing keyspace |
+| redis_master_link_status | Indicates if the replica is connected to its master |
+| redis_master_repl_offset | Number of bytes sent to replicas by the shard; calculate the throughput for a time period by comparing the value at different times |
+| redis_master_sync_in_progress | The primary shard is synchronizing (1 true; 0 false) |
+| redis_max_process_mem | Current memory limit configured by redis_mgr according to node free memory |
+| redis_maxmemory | Current memory limit configured by redis_mgr according to database memory limits |
+| redis_mem_aof_buffer | Current size of AOF buffer |
+| redis_mem_clients_normal | Current memory used for input and output buffers of non-replica clients |
+| redis_mem_clients_slaves | Current memory used for input and output buffers of replica clients |
+| redis_mem_fragmentation_ratio | Memory fragmentation ratio (1.3 means 30% overhead) |
+| redis_mem_not_counted_for_evict | Portion of used_memory (in bytes) that's not counted for eviction and OOM error |
+| redis_mem_replication_backlog | Size of replication backlog |
+| redis_module_fork_in_progress | A binary value that indicates if there is an active fork spawned by a module (1) or not (0) |
+| redis_process_cpu_system_seconds_total | Shard process system CPU time spent in seconds |
+| redis_process_cpu_usage_percent | Shard process cpu usage precentage |
+| redis_process_cpu_user_seconds_total | Shard user CPU time spent in seconds |
+| redis_process_main_thread_cpu_system_seconds_total | Shard main thread system CPU time spent in seconds |
+| redis_process_main_thread_cpu_user_seconds_total | Shard main thread user CPU time spent in seconds |
+| redis_process_max_fds | Shard maximum number of open file descriptors |
+| redis_process_open_fds | Shard number of open file descriptors |
+| redis_process_resident_memory_bytes | Shard resident memory size in bytes |
+| redis_process_start_time_seconds | Shard start time of the process since unix epoch in seconds |
+| redis_process_virtual_memory_bytes | Shard virtual memory in bytes |
+| redis_rdb_bgsave_in_progress | Indication if bgsave is currently in progress |
+| redis_rdb_last_cow_size | Last bgsave (or SYNC fork) used CopyOnWrite memory |
+| redis_rdb_saves | Total count of bgsaves since process was restarted (including replica fullsync and persistence) |
+| redis_repl_touch_bytes | Number of bytes sent to replicas as TOUCH commands by the shard as a result of a READ command that was processed; calculate the throughput for a time period by comparing the value at different times |
+| redis_total_commands_processed | Number of commands processed by the shard; calculate the number of commands for a time period by comparing the value at different times |
+| redis_total_connections_received | Number of connections received by the shard; calculate the number of connections for a time period by comparing the value at different times |
+| redis_total_net_input_bytes | Number of bytes received by the shard; calculate the throughput for a time period by comparing the value at different times |
+| redis_total_net_output_bytes | Number of bytes sent by the shard; calculate the throughput for a time period by comparing the value at different times |
+| redis_up | Shard is up and running |
+| redis_used_memory | Memory used by shard (in BigRedis this includes flash) (bytes) |
+If port 53 is in use, the installation fails. This issue can occur in default installations of certain operating systems in which `systemd-resolved` (DNS server) is running.
+
+To prevent this issue, change the system configuration to make this port available before installation.
+
+1. Edit `/etc/systemd/resolved.conf`: 
+
+    ```sh
+    sudo vi /etc/systemd/resolved.conf
+    ```
+
+1. Add `DNSStubListener=no` as the last line in the file and save the file.
+
+1. Rename the current `/etc/resolv.conf` file:
+
+    ```sh
+    sudo mv /etc/resolv.conf /etc/resolv.conf.orig
+    ```
+
+1. Create a symbolic link for `/etc/resolv.conf`:
+
+    ```sh
+    sudo ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf
+    ```
+
+    {{< note >}}
+You might encounter a temporary name resolution error (`sudo: unable to resolve host {hostname}: Temporary failure in name resolution`), which should be fixed when you restart `systemd-resolved` in the next step.
+    {{< /note >}}
+
+2. Restart the DNS service:
+
+    ```sh
+    sudo service systemd-resolved restart
+    ```
+3. Select your Redis use case. There are four pre-defined use cases:
+
+    {{<image filename="images/rc/create-database-redis-use-cases.png" alt="The Redis Use case panel">}}
+
+    - **Cache**: Stores short-term or volatile data. Can be used for session management, semantic cache, session store, and other uses where data is short-lived.
+    - **Database**: Stores durable and consistent data. Can be used for document databases, feature storage, gaming leaderboards, durable caches, and other uses where your data needs to be highly available and persistent.
+    - **Vector search**: Manages and manipulates vector data. Can be used for Generative AI, recommendation systems, visual search, and other uses where you can search and query your data.
+    - **Custom**: If your Redis use case doesn't match any of the other use cases, you can choose this option to customize all of your settings.
+
+    Select the use case that best matches your Redis use case. You can always change the settings later. ## Give it a try
+
+After you load RedisGraph, you can interact with it using redis-cli.
+
+Here we'll quickly create a small graph representing a subset of motorcycle riders and teams
+taking part in the MotoGP league. Once created, we'll start querying our data.
+
+### With `redis-cli`
+
+Connect to redis.
+
+```sh
+$ redis-cli -p 12543
+127.0.0.1:12543>
+```
+
+Run these commands:
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'}), (:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'}), (:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})"
+1) (empty list or set)
+2) 1) Labels added: 2
+   2) Nodes created: 6
+   3) Properties set: 6
+   4) Relationships created: 3
+   5) "Query internal execution time: 0.399000 milliseconds"
+```
+
+Now that our MotoGP graph is created, we can start asking questions. For example:
+Who's riding for team Yamaha?
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team) WHERE t.name = 'Yamaha' RETURN r,t"
+1) 1) 1) "r.name"
+      2) "t.name"
+   2) 1) "Valentino Rossi"
+      2) "Yamaha"
+2) 1) "Query internal execution time: 0.122000 milliseconds"
+```
+
+How many riders represent team Ducati?
+
+```sh
+127.0.0.1:12543> GRAPH.QUERY MotoGP "MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)"
+1) 1) 1) "count(r)"
+   2) 1) "1.000000"
+2) 1) "Query internal execution time: 0.129000 milliseconds"
+```
+If you've enabled the database's [CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist" >}}), you must also [add the VPC peered IP addresses to the CIDR allow list]({{< relref "/operate/rc/security/cidr-whitelist#define-cidr-allow-list" >}}) to connect to the database via the private endpoint.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]({{< relref "/operate/rs/networking/port-configurations" >}}).| Database | Versions | AWS RDS  Versions | GCP SQL Versions |
+| :-- | :-- | :-- | :-- |
+| Oracle | 12c, 19c, 21c | 19c, 21c | - |
+| MariaDB | 10.5, 11.4.3 | 10.4 to 10.11, 11.4.3 | - |
+| MySQL | 5.7, 8.0.x, 8.2 | 8.0.x | 8.0 |
+| PostgreSQL | 10, 11, 12, 13, 14, 15, 16  | 11, 12, 13, 14, 15, 16 | 15 |
+| SQL Server | 2017, 2019, 2022 | 2016, 2017, 2019, 2022 | 2019 |
+| AlloyDB for PostgreSQL | 14.2, 15.7 | - | 14.2, 15.7 |
+| AWS Aurora/PostgreSQL | 15 | 15 | - |To enable TLS for Replica Of cluster connections:
+
+1. For each cluster hosting a replica:
+
+    1. Go to **Cluster > Security > Certificates**.
+
+    1. Expand the **Replica Of and Active-Active authentication (Syncer certificate)** section.
+
+        {{<image filename="images/rs/screenshots/cluster/security-syncer-cert.png"  alt="Syncer certificate for Replica Of and Active-Active authentication.">}}
+    
+    1. Download or copy the syncer certificate.
+
+1. From the **Security** tab of the Replica Of source database, select **Edit**.
+
+1. In the **TLS - Transport Layer Security for secure connections** section, make sure the checkbox is selected.
+
+1. In the **Apply TLS for** section, select **Between databases only**.
+
+1. Select **Mutual TLS (Client authentication)**.
+
+    {{<image filename="images/rs/screenshots/databases/security-tls-replica-of.png"  alt="Replica Of TLS authentication configuration.">}}
+
+1. Select **+ Add certificate**, paste or upload the syncer certificate, then select **Done**.
+
+    Repeat this process, adding the syncer certificate for each cluster hosting a replica of this database.
+
+1. _(Optional)_ To require TLS for client connections, change **Apply TLS for** to **Clients and databases + Between databases** and add client certificates.
+
+1. Select **Save**.* RHEL 8 or 9
+* Ubuntu 20.04, 22.04, or 24.04Select **Version upgrade** to request to upgrade your subscription and databases if there is a later version available.
+
+{{<image filename="images/rc/button-version-upgrade.png" width=150px alt="Version upgrade button." >}}
+
+Select the version to upgrade your databases from the list and select **Upgrade** to submit the upgrade request.
+
+{{<image filename="images/rc/version-upgrade-request.png" width=80% alt="Version upgrade request list with version 7.4 selected." >}}
+
+The upgrade will start one week from your request, according to your subscription's [maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}). 
+
+Review the [7.2 breaking changes]({{< relref "/operate/rc/changelog/2023/june-2023#redis-72-breaking-changes" >}}) or [7.4 breaking changes]({{< relref "/operate/rc/changelog/july-2024#redis-74-breaking-changes" >}}) before you request to upgrade.Each subscription plan (except for our free plans) enables multiple dedicated databases, each running in a dedicated process and in a non-blocking manner.
+
+A 1GB plan for example, enables 16 [dedicated databases](https://redislabs.com/blog/benchmark-shared-vs-dedicated-redis-instances).To make sure that Redis Enterprise Software (RS) servers can pass necessary communications between them,
+we recommend that all RS servers have all of the ports listed here open
+between them.
+
+By default, the cluster assigns ports in the range of 10,000 - 19,999
+to database endpoints. If you assign a specific port for a database when
+you create it, even outside of this range, the cluster only verifies
+that the assigned port is not already in use. You must manually
+update your firewall with the port for that new database endpoint.
+
+## Ports and port ranges used by Redis Enterprise Software
+
+| Protocol | Port | Connection Source | Description |
+|------------|-----------------|-----------------|-----------------|
+| ICMP | * | Internal | For connectivity checking between nodes |
+| TCP | 1968 | Internal | Proxy traffic |
+| TCP | 3333, 3334, 3335, 3336, 3337, 3338, 3339, 36379, 36380 | Internal | Cluster traffic |
+| TCP | 8001 | Internal, External | Traffic from application to RS [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}) |
+| TCP | 8002, 8004 | Internal | System health monitoring |
+| TCP | 8443 | Internal, External | Secure (HTTPS) access to the management web UI |
+| TCP | 8444, 9080 | Internal | For nginx <-> cnm_http/cm traffic |
+| TCP | 9081 | Internal, Active-Active | For Active-Active management |
+| TCP | 8070, 8071 | Internal, External | For metrics exported and managed by nginx |
+| TCP | 9443 (Recommended), [8080](#turning-off-http-support) | Internal, External, Active-Active | REST API traffic, including cluster management and node bootstrap |
+| TCP | 10000-19999 | Internal, External, Active-Active | Database traffic |
+| TCP | 20000-29999 | Internal | Database shard traffic |
+| UDP | 53, 5353 | Internal, External | DNS/mDNS traffic |
+
+Connection sources are:
+
+- Internal - The traffic is from other cluster nodes
+- External - The traffic is from client applications or external monitoring resources
+- Active-Active - The traffic is from clusters that host Active-Active databases
+
+## Changing the management web UI port
+
+If for any reason you want to use a custom port for the RS Web UI
+instead of the default port (8443), you can change the port. Before you
+change the RS Web UI port, make sure that the new port is not in
+use by another process.
+
+{{< note >}}
+After you change the RS Web UI port, when you add a new node to the
+cluster you must connect to the web UI with the custom port number:
+
+`https://newnode.mycluster.example.com:`**`<nonstandard-port-number>`**
+{{% /note %}}
+
+To change the default port for the RS Web UI, on any node in the cluster run:
+
+```sh
+rladmin cluster config cm_port <new-port>
+```
+
+## Disabling HTTP support for API endpoints
+
+To harden deployments, you can disable the HTTP support for API endpoints that is supported by default.
+Before you disable HTTP support, make sure that you migrate any scripts or proxy configurations that use HTTP to the encrypted API endpoint
+to prevent broken connections.
+After you disable HTTP support, traffic sent to the unencrypted API endpoint is blocked.
+
+To disable HTTP support for API endpoints, run:
+
+```sh
+rladmin cluster config http_support disabled
+```
+To do this:
+
+1. In the [Redis Cloud console](https://cloud.redis.io/), sign in to the account you would like to associate with your marketplace account. 
+
+1. Select **Billing & Payments > Payment Methods**.
+
+1. Select **Add Marketplace account**.
+
+    {{<image filename="images/rc/add-marketplace-account.png" width="300px" alt="The Add marketplace account button." >}}
+
+1. Select the marketplace account you want to connect and confirm that it will pay for your Redis Cloud resources going forward.
+
+1. Select **Connect account**.
+
+    {{<image filename="images/rc/button-connect-account.png" width="150px" alt="The Connect account button." >}}
+
+Your marketplace account is now connected to your Redis Cloud account. If you would like to disconnect your marketplace account from your Redis Cloud account, select **Disconnect**.
+
+{{<image filename="images/rc/button-marketplace-disconnect.png" width="100px" alt="The disconnect account button." >}}OSS Cluster API reduces access times and latency with near-linear scalability.
+The OSS Cluster API provides a simple mechanism for Redis clients to know the cluster topology.
+
+Clients must first connect to the master node to get the cluster topology,
+and then they connect directly to the Redis proxy on each node that hosts a master shard.
+
+{{< note >}}
+You must use a client that supports the cluster API to connect to a database
+that has the cluster API enabled.
+{{< /note >}}
+## Command differences
+
+Some JSON commands work differently for Active-Active databases.
+
+### `JSON.CLEAR`
+
+[`JSON.CLEAR`]({{< relref "commands/json.clear" >}}) resets JSON arrays and objects. It supports concurrent updates to JSON documents from different instances in an Active-Active database and allows the results to be merged.
+```yaml
+# The minimal Role and ClusterRole required for running the log collector in 'restricted' mode.
+# The roles should be bound to the user executing the log collector, in each of the namespaces to be collected.
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: redis-enterprise-log-collector
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  - pods/log
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - ""
+  resources:
+  - pods/exec
+  verbs:
+  - create
+- apiGroups:
+  - ""
+  resources:
+  - events
+  - services
+  - endpoints
+  - configmaps
+  - secrets
+  - resourcequotas
+  - limitranges
+  - persistentvolumeclaims
+  - replicationcontrollers
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - apps
+  resources:
+  - deployments
+  - daemonsets
+  - replicasets
+  - statefulsets
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - batch
+  resources:
+  - cronjobs
+  - jobs
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - roles
+  - rolebindings
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - autoscaling
+  resources:
+  - horizontalpodautoscalers
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - policy
+  resources:
+  - poddisruptionbudgets
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - app.redislabs.com
+  resources:
+  - "*"
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - networking.k8s.io
+  resources:
+  - ingresses
+  - networkpolicies
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - route.openshift.io
+  resources:
+  - routes
+  verbs:
+  - get
+  - list
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: redis-enterprise-log-collector
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - persistentvolumes
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - ""
+  resources:
+  - namespaces
+  verbs:
+  - get
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - clusterroles
+  - clusterrolebindings
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - apiextensions.k8s.io
+  resources:
+  - customresourcedefinitions
+  resourceNames:
+  - redisenterpriseclusters.app.redislabs.com
+  - redisenterprisedatabases.app.redislabs.com
+  - redisenterpriseremoteclusters.app.redislabs.com
+  - redisenterpriseactiveactivedatabases.app.redislabs.com
+  verbs:
+  - list
+  - get
+- apiGroups:
+  - admissionregistration.k8s.io
+  resources:
+  - validatingwebhookconfigurations
+  verbs:
+  - list
+  - get
+```
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseActiveActiveDatabase
+metadata:
+  name: reaadb
+  labels:
+    app: redis-enterprise
+spec:
+  participatingClusters:
+    # Participating cluster pointing to RERC named: 'new-york-1'.
+    - name: new-york-1
+
+    # Participating cluster pointing to RERC named: 'boston-1'.
+    - name: boston-1
+```
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+  labels:
+    app: redis-enterprise
+spec:
+  # The number of Redis Enterprise nodes in the clusters.
+  nodes: 3
+
+  persistentSpec:
+    # Whether to enable persistent storage for the Redis Enterprise nodes.
+    enabled: true
+
+    # The size of the persistent volume for each Redis Enterprise node.
+    volumeSize: 20Gi
+
+  # The resources allocated to each Redis Enterprise node.
+  redisEnterpriseNodeResources:
+    requests:
+      cpu: 2
+      memory: 4Gi
+    limits:
+      cpu: 2
+      memory: 4Gi
+```
+```yaml
+kind: RoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: NAMESPACE_OF_SERVICE_ACCOUNT
+- kind: ServiceAccount
+  name: NAME_OF_REC_SERVICE_ACCOUNT  # service account of the REC, usually the same as the name of the custom resource
+  namespace: NAMESPACE_OF_SERVICE_ACCOUNT
+roleRef:
+  kind: Role
+  name: redb-role
+  apiGroup: rbac.authorization.k8s.io
+```
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: redis-enterprise-operator
+subjects:
+  - kind: ServiceAccount
+    name: redis-enterprise-operator
+```
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  namespace: NAMESPACE_OF_SERVICE_ACCOUNT
+  name: redis-enterprise-operator
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator
+  apiGroup: rbac.authorization.k8s.io
+```
+```yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: admission
+  labels:
+    app: redis-enterprise
+spec:
+  ports:
+    - port: 443
+      protocol: TCP
+      targetPort: 8443
+  selector:
+    name: redis-enterprise-operator
+```
+```yaml
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator-consumer-ns
+  labels:
+    app: redis-enterprise
+subjects:
+- kind: ServiceAccount
+  name: redis-enterprise-operator
+  namespace: NAMESPACE_OF_SERVICE_ACCOUNT
+roleRef:
+  kind: ClusterRole
+  name: redis-enterprise-operator-consumer-ns
+  apiGroup: rbac.authorization.k8s.io
+```
+```yaml
+kind: Role
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redb-role
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups:
+      - app.redislabs.com
+    resources: ["redisenterprisedatabases",
+                "redisenterprisedatabases/status",
+                "redisenterprisedatabases/finalizers",
+                "redisenterpriseactiveactivedatabases",
+                "redisenterpriseactiveactivedatabases/status",
+                "redisenterpriseactiveactivedatabases/finalizers"]
+    verbs: ["delete", "get", "list", "patch", "create", "update", "watch"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["update", "get", "watch", "create", "patch", "list"]
+  - apiGroups: [""]
+    resources: ["endpoints"]
+    verbs: ["get", "list", "watch"]
+  - apiGroups: [""]
+    resources: ["events"]
+    verbs: ["create", "patch"]
+  - apiGroups: [""]
+    resources: ["services"]
+    verbs: ["get", "list", "update", "patch", "create", "delete", "watch"]
+```
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: redis-enterprise-operator-consumer-ns
+  labels:
+    app: redis-enterprise
+rules:
+  - apiGroups: [""]
+    resources: ["namespaces"]
+    verbs: ["list", "watch"]
+```
+```yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: admission
+  labels:
+    app: redis-enterprise
+spec:
+  ports:
+    - port: 443
+      protocol: TCP
+      targetPort: 8443
+  selector:
+    name: redis-enterprise-operator
+```
+```yaml
+apiVersion: admissionregistration.k8s.io/v1
+kind: ValidatingWebhookConfiguration
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-admission
+webhooks:
+  - admissionReviewVersions:
+      - v1beta1
+    clientConfig:
+      service:
+        name: admission
+        path: /admission
+        namespace: OPERATOR_NAMESPACE
+      caBundle: "" # Fill in with BASE64 encoded signed cert
+    failurePolicy: Fail
+    matchPolicy: Exact
+    name: redisenterprise.admission.redislabs
+    rules:
+      - apiGroups:
+          - app.redislabs.com
+        apiVersions:
+          - v1alpha1
+        operations:
+          - CREATE
+          - UPDATE
+        resources:
+          - redisenterprisedatabases
+          - redisenterpriseactiveactivedatabases
+          - redisenterpriseremoteclusters
+    sideEffects: None
+    timeoutSeconds: 30
+```
+```yaml
+apiVersion: app.redislabs.com/v1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rec
+  labels:
+    app: redis-enterprise
+spec:
+  # The number of Redis Enterprise nodes in the clusters.
+  nodes: 3
+
+  persistentSpec:
+    # Whether to enable persistent storage for the Redis Enterprise nodes.
+    enabled: true
+
+    # The size of the persistent volume for each Redis Enterprise node.
+    volumeSize: 20Gi
+
+  # The resources allocated to each Redis Enterprise node.
+  redisEnterpriseNodeResources:
+    requests:
+      cpu: 2
+      memory: 4Gi
+    limits:
+      cpu: 2
+      memory: 4Gi
+  redisEnterpriseImageSpec:
+    repository: registry.connect.redhat.com/redislabs/redis-enterprise
+    versionTag: 7.22.0-28
+  redisEnterpriseServicesRiggerImageSpec:
+    repository: registry.connect.redhat.com/redislabs/services-manager
+  bootstrapperImageSpec:
+    repository: registry.connect.redhat.com/redislabs/redis-enterprise-operator
+```
+```yaml
+apiVersion: security.openshift.io/v1
+kind: SecurityContextConstraints
+metadata:
+  name: redis-enterprise-scc-v2
+  annotations:
+    kubernetes.io/description: redis-enterprise-scc-v2 is the minimal SCC needed to run Redis Enterprise nodes on Kubernetes with automatic FD limit adjustment enabled. It provides the same features as restricted-v2 SCC, but allows pods to enable the SYS_RESOURCE capability, which is required by Redis Enterprise nodes to manage file descriptor limits and OOM scores for database shards. Additionally, it requires pods to run as UID/GID 1001, which are the UID/GID used within the Redis Enterprise node containers.
+allowedCapabilities:
+  - SYS_RESOURCE
+allowHostDirVolumePlugin: false
+allowHostIPC: false
+allowHostNetwork: false
+allowHostPID: false
+allowHostPorts: false
+allowPrivilegeEscalation: true
+allowPrivilegedContainer: false
+readOnlyRootFilesystem: false
+runAsUser:
+  type: MustRunAs
+  uid: 1001
+fsGroup:
+  type: MustRunAs
+  ranges:
+    - min: 1001
+      max: 1001
+seLinuxContext:
+  type: MustRunAs
+seccompProfiles:
+  - runtime/default
+supplementalGroups:
+  type: RunAsAny
+```
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+rules:
+  - apiGroups:
+      - rbac.authorization.k8s.io
+      - ""
+    resources:
+      - roles
+      - serviceaccounts
+      - rolebindings
+    verbs:
+      - create
+      - get
+      - update
+      - patch
+      - delete
+  - apiGroups:
+      - app.redislabs.com
+    resources:
+      - "*"
+    verbs:
+      - delete
+      - get
+      - list
+      - patch
+      - create
+      - update
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - secrets
+    verbs:
+      - update
+      - get
+      - create
+      - patch
+      - delete
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - endpoints
+    verbs:
+      - get
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - events
+    verbs:
+      - create
+      - patch
+  - apiGroups:
+      - apps
+    resources:
+      - deployments
+      - statefulsets
+      - replicasets
+    verbs:
+      - create
+      - delete
+      - get
+      - patch
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - batch
+    resources:
+      - cronjobs
+    verbs:
+      - create
+      - delete
+      - get
+      - patch
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - policy
+    resources:
+      - poddisruptionbudgets
+    verbs:
+      - create
+      - delete
+      - get
+      - list
+      - watch
+      - update
+  - apiGroups:
+      - ""
+    resources:
+      - configmaps
+    verbs:
+      - create
+      - delete
+      - get
+      - update
+      - watch
+      - list
+  - apiGroups:
+      - ""
+    resources:
+      - persistentvolumeclaims
+    verbs:
+      - create
+      - delete
+      - get
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - pods
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - delete
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - services
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - create
+      - delete
+      - watch
+  - apiGroups:
+      - networking.k8s.io
+    resources:
+      - ingresses
+    verbs:
+      - create
+      - patch
+      - delete
+      - list
+      - update
+      - get
+      - watch
+  - apiGroups:
+      - networking.istio.io
+    resources:
+      - gateways
+      - virtualservices
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - create
+      - delete
+      - watch
+  - apiGroups:
+      - route.openshift.io
+    resources:
+      - routes
+      - routes/custom-host
+    verbs:
+      - create
+      - delete
+      - get
+      - list
+      - patch
+      - update
+      - watch
+  - apiGroups:
+      - security.openshift.io
+    resourceNames:
+      - nonroot-v2
+    resources:
+      - securitycontextconstraints
+    verbs:
+      - use
+```
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseCluster
+metadata:
+  name: rack-aware-cluster
+  labels:
+    app: redis-enterprise
+spec:
+  nodes: 3
+  rackAwarenessNodeLabel: topology.kubernetes.io/zone
+```
+```yaml
+kind: ClusterRole
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+  name: redis-enterprise-operator
+rules:
+  # needed for rack awareness
+  - apiGroups: [""]
+    resources: ["nodes"]
+    verbs: ["list", "get", "watch"]
+```
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseRemoteCluster
+metadata:
+  name: new-york-1
+  labels:
+    app: redis-enterprise
+spec:
+  # The name of the REC that the RERC is pointing at.
+  recName: rec
+
+  # The namespace of the REC that the RERC is pointing at.
+  recNamespace: ns1
+
+  # The URL of the cluster, will be used for the active-active database URL.
+  apiFqdnUrl: testapi-new-york-1-ns1.redislabs.com
+
+  # The database URL suffix, will be used for the active-active
+  # database replication endpoint and replication endpoint SNI.
+  dbFqdnSuffix: -example-new-york-1-ns1.redislabs.com
+
+  # The name of the secret containing cluster credentials.
+  # Needs to be formatted as: "redis-enterprise-<RERC name>"
+  secretName: redis-enterprise-new-york-1
+```
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: redis-enterprise-operator
+subjects:
+  - kind: ServiceAccount
+    name: redis-enterprise-operator
+```
+```yaml
+apiVersion: app.redislabs.com/v1alpha1
+kind: RedisEnterpriseDatabase
+metadata:
+  name: redb
+  labels:
+    app: redis-enterprise
+spec:
+  # Memory size of the database.
+  memorySize: 256MB
+
+  # Number of shards in the database.
+  shardCount: 1
+
+  # Determines whether replication will be enabled for the database.
+  replication: false
+```
+```yaml
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+```
+```yaml
+# The minimal Role and ClusterRole required for running the log collector in 'all' mode.
+# The roles should be bound to the user executing the log collector, in each of the namespaces to be collected.
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: redis-enterprise-log-collector
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  - pods/log
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - ""
+  resources:
+  - pods/exec
+  verbs:
+  - create
+- apiGroups:
+  - ""
+  resources:
+  - events
+  - services
+  - endpoints
+  - configmaps
+  - secrets
+  - resourcequotas
+  - limitranges
+  - persistentvolumeclaims
+  - replicationcontrollers
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - apps
+  resources:
+  - deployments
+  - daemonsets
+  - replicasets
+  - statefulsets
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - batch
+  resources:
+  - cronjobs
+  - jobs
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - roles
+  - rolebindings
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - autoscaling
+  resources:
+  - horizontalpodautoscalers
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - policy
+  resources:
+  - poddisruptionbudgets
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - app.redislabs.com
+  resources:
+  - "*"
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - networking.k8s.io
+  resources:
+  - ingresses
+  - networkpolicies
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - route.openshift.io
+  resources:
+  - routes
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - operators.coreos.com
+  resources:
+  - clusterserviceversions
+  - subscriptions
+  - installplans
+  - catalogsources
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - networking.istio.io
+  resources:
+  - gateways
+  - virtualservices
+  verbs:
+  - get
+  - list
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: redis-enterprise-log-collector
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - nodes
+  - persistentvolumes
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - ""
+  resources:
+  - namespaces
+  verbs:
+  - get
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - clusterroles
+  - clusterrolebindings
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - apiextensions.k8s.io
+  resources:
+  - customresourcedefinitions
+  resourceNames:
+  - redisenterpriseclusters.app.redislabs.com
+  - redisenterprisedatabases.app.redislabs.com
+  - redisenterpriseremoteclusters.app.redislabs.com
+  - redisenterpriseactiveactivedatabases.app.redislabs.com
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - admissionregistration.k8s.io
+  resources:
+  - validatingwebhookconfigurations
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - storage.k8s.io
+  resources:
+  - volumeattachments
+  - storageclasses
+  verbs:
+  - get
+  - list
+- apiGroups:
+  - certificates.k8s.io
+  resources:
+  - certificatesigningrequests
+  verbs:
+  - get
+  - list
+```
+```yaml
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+rules:
+  - apiGroups:
+      - rbac.authorization.k8s.io
+      - ""
+    resources:
+      - roles
+      - serviceaccounts
+      - rolebindings
+    verbs:
+      - create
+      - get
+      - update
+      - patch
+      - delete
+  - apiGroups:
+      - app.redislabs.com
+    resources:
+      - "*"
+    verbs:
+      - delete
+      - get
+      - list
+      - patch
+      - create
+      - update
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - secrets
+    verbs:
+      - update
+      - get
+      - create
+      - patch
+      - delete
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - endpoints
+    verbs:
+      - get
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - events
+    verbs:
+      - create
+      - patch
+  - apiGroups:
+      - apps
+    resources:
+      - deployments
+      - statefulsets
+      - replicasets
+    verbs:
+      - create
+      - delete
+      - get
+      - patch
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - batch
+    resources:
+      - cronjobs
+    verbs:
+      - create
+      - delete
+      - get
+      - patch
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - policy
+    resources:
+      - poddisruptionbudgets
+    verbs:
+      - create
+      - delete
+      - get
+      - list
+      - watch
+      - update
+  - apiGroups:
+      - ""
+    resources:
+      - configmaps
+    verbs:
+      - create
+      - delete
+      - get
+      - update
+      - watch
+      - list
+  - apiGroups:
+      - ""
+    resources:
+      - persistentvolumeclaims
+    verbs:
+      - create
+      - delete
+      - get
+      - update
+      - list
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - pods
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - delete
+      - watch
+  - apiGroups:
+      - ""
+    resources:
+      - services
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - create
+      - delete
+      - watch
+  - apiGroups:
+      - networking.k8s.io
+    resources:
+      - ingresses
+    verbs:
+      - create
+      - patch
+      - delete
+      - list
+      - update
+      - get
+      - watch
+  - apiGroups:
+      - networking.istio.io
+    resources:
+      - gateways
+      - virtualservices
+    verbs:
+      - get
+      - list
+      - update
+      - patch
+      - create
+      - delete
+      - watch
+```
+```yaml
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  labels:
+    app: redis-enterprise
+  name: redis-enterprise-operator
+```
+## Billing Unit types
+
+The Redis Billing Unit types associated with your Pro subscription depend on your database memory size and throughput requirements.  
+
+| Billing unit type | Capacity (Memory/Throughput) |
+|:------------|:----------|
+| Pico | 100MB / 100 ops/sec |
+| Nano | 500MB / 500 ops/sec |
+| Micro | 1GB / 1K ops/sec |
+| High-throughput | 2.5GB / 25K ops/sec |
+| Small | 12.5GB / 12.5K ops/sec |
+| Large | 25GB  / 25K ops/sec |
+| Very large<sup>[1](#table-note-1)</sup> | 50GB / 5K ops/sec |
+| XLarge<sup>[2](#table-note-2)</sup> | 50GB / 10K ops/sec |
+
+1. <a name="table-note-1" style="display: block; height: 80px; margin-top: -80px;"></a>Used for databases with Auto Tiering before Redis 7.2.
+
+2. <a name="table-note-2" style="display: block; height: 80px; margin-top: -80px;"></a>Used for hosted databases with Auto Tiering for Redis 7.2 and later.
+
+Prices vary according to the cloud provider and region.  Minimum prices apply.## Database metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| <span class="break-all">bdb_avg_latency</span> | <span class="break-all">`(sum by (db)(irate(endpoint_read_requests_latency_histogram_sum{db=""$db""}[1m]) + irate(endpoint_write_requests_latency_histogram_sum{db=""$db""}[1m]) + irate(endpoint_other_requests_latency_histogram_sum{db=""$db""}[1m])))/(sum by (db)(irate(endpoint_read_requests{db=""$db""}[1m]) + irate(endpoint_write_requests{db=""$db""}[1m]) + irate(endpoint_other_requests{db=""$db""}[1m])))/1000000`</span> | Average latency of operations on the database (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_avg_latency_max</span> | <span class="break-all">`avg(histogram_quantile(1, sum by (le, db) (irate(endpoint_read_requests_latency_histogram_bucket{db=""$db""}[1m]) + irate(endpoint_write_requests_latency_histogram_bucket{db=""$db""}[1m]) + irate(endpoint_other_requests_latency_histogram_bucket{db=""$db""}[1m])))) / 1000000`</span> | Highest value of average latency of operations on the database (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_avg_read_latency</span> | <span class="break-all">`(sum(irate(endpoint_read_requests_latency_histogram_sum{db=""$db""}[1m]))/sum(irate(endpoint_read_requests{db=""$db""}[1m])))/1000000`</span> | Average latency of read operations (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_avg_read_latency_max</span></span> | <span class="break-all">`histogram_quantile(1, sum by (le) (irate(endpoint_read_requests_latency_histogram_bucket{db=""$db""}[1m]))) / 1000000`</span> | Highest value of average latency of read operations (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_avg_write_latency</span> | <span class="break-all">`(sum(irate(endpoint_write_requests_latency_histogram_sum{db=""$db""}[1m]))/sum(irate(endpoint_write_requests{db=""$db""}[1m])))/1000000`</span> | Average latency of write operations (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_avg_write_latency_max</span> | <span class="break-all">`histogram_quantile(1, sum by (le) (irate(endpoint_write_requests_latency_histogram_bucket{db=""$db""}[1m]))) / 1000000`</span> | Highest value of average latency of write operations (seconds); returned only when there is traffic |
+| <span class="break-all">bdb_bigstore_shard_count</span> | <span class="break-all">`sum((sum(label_replace(label_replace(namedprocess_namegroup_thread_count{groupname=~"redis-\d+", threadname=~"(speedb\|rocksdb).*"}, "redis", "$1", "groupname", "redis-(\d+)"), "driver", "$1", "threadname", "(speedb\|rocksdb).*")) by (redis, driver) > bool 0) * on (redis) group_left(db) redis_server_up) by (db, driver)`</span> | Shard count by database and by storage engine (driver - rocksdb / speedb); Only for databases with Auto Tiering enabled |
+| <span class="break-all">bdb_conns</span> | <span class="break-all">`sum by (db) (endpoint_client_connections{cluster=""$cluster"", db=""$db""} - endpoint_client_disconnections{cluster=""$cluster"", db=""$db""})`</span> | Number of client connections to database |
+| <span class="break-all">bdb_egress_bytes</span> | <span class="break-all">`sum by(db) (irate(endpoint_egress{db="$db"}[1m]))`</span> | Rate of outgoing network traffic from the database (bytes/sec) |
+| <span class="break-all">bdb_egress_bytes_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_egress{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of outgoing network traffic from the database (bytes/sec) |
+| <span class="break-all">bdb_evicted_objects</span> | <span class="break-all">`sum by (db) (irate(redis_server_evicted_keys{role="master"}[1m]))`</span> | Rate of key evictions from database (evictions/sec) |
+| <span class="break-all">bdb_evicted_objects_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_evicted_keys{role="master"}[1m]))`</span> | Highest value of the rate of key evictions from database (evictions/sec) |
+| <span class="break-all">bdb_expired_objects</span> | <span class="break-all">`sum by (db) (irate(redis_server_expired_keys{role="master"}[1m]))`</span> | Rate keys expired in database (expirations/sec) |
+| <span class="break-all">bdb_expired_objects_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_expired_keys{role="master"}[1m]))`</span> | Highest value of the rate keys expired in database (expirations/sec) |
+| <span class="break-all">bdb_fork_cpu_system</span> | <span class="break-all">`sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system"}[1m]))`</span> | % cores utilization in system mode for all Redis shard fork child processes of this database |
+| <span class="break-all">bdb_fork_cpu_system_max</span> | <span class="break-all">`sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system"}[1m]))`</span> | Highest value of % cores utilization in system mode for all Redis shard fork child processes of this database |
+| <span class="break-all">bdb_fork_cpu_user</span> | <span class="break-all">`sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user"}[1m]))`</span> | % cores utilization in user mode for all Redis shard fork child processes of this database |
+| <span class="break-all">bdb_fork_cpu_user_max</span> | <span class="break-all">`sum by (db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user"}[1m]))`</span> | Highest value of % cores utilization in user mode for all Redis shard fork child processes of this database |
+| <span class="break-all">bdb_ingress_bytes</span> | <span class="break-all">`sum by(db) (irate(endpoint_ingress{db="$db"}[1m]))`</span> | Rate of incoming network traffic to database (bytes/sec) |
+| <span class="break-all">bdb_ingress_bytes_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_ingress{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of incoming network traffic to database (bytes/sec) |
+| <span class="break-all">bdb_instantaneous_ops_per_sec</span></span> | <span class="break-all">`sum by(db) (redis_server_instantaneous_ops_per_sec)`</span> | Request rate handled by all shards of database (ops/sec) |
+| <span class="break-all">bdb_main_thread_cpu_system</span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system", threadname=~"redis-server.*"}[1m]))`</span> | % cores utilization in system mode for all Redis shard main threads of this database |
+| <span class="break-all">bdb_main_thread_cpu_system_max</span></span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system", threadname=~"redis-server.*"}[1m]))`</span> | Highest value of % cores utilization in system mode for all Redis shard main threads of this database |
+| <span class="break-all">bdb_main_thread_cpu_user</span> | <span class="break-all">`sum by(irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user", threadname=~"redis-server.*"}[1m]))`</span> | % cores utilization in user mode for all Redis shard main threads of this database |
+| <span class="break-all">bdb_main_thread_cpu_user_max</span></span> | <span class="break-all">`sum by(irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user", threadname=~"redis-server.*"}[1m]))`</span> | Highest value of % cores utilization in user mode for all Redis shard main threads of this database |
+| <span class="break-all">bdb_mem_frag_ratio</span> | <span class="break-all">`avg(redis_server_mem_fragmentation_ratio)`</span> | RAM fragmentation ratio (RSS / allocated RAM) |
+| <span class="break-all">bdb_mem_size_lua</span> | <span class="break-all">`sum by(db) (redis_server_used_memory_lua)`</span> | Redis lua scripting heap size (bytes) |
+| <span class="break-all">bdb_memory_limit</span> | <span class="break-all">`sum by(db) (redis_server_maxmemory)`</span> | Configured RAM limit for the database |
+| <span class="break-all">bdb_monitor_sessions_count</span> | <span class="break-all">`sum by(db) (endpoint_monitor_sessions_count)`</span> | Number of clients connected in monitor mode to the database |
+| <span class="break-all">bdb_no_of_keys</span> | <span class="break-all">`sum by (db) (redis_server_db_keys{role="master"})`</span> | Number of keys in database |
+| <span class="break-all">bdb_other_req</span> | <span class="break-all">`sum by(db) (irate(endpoint_other_requests{db="$db"}[1m]))`</span> | Rate of other (non read/write) requests on the database (ops/sec) |
+| <span class="break-all">bdb_other_req_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_other_requests{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of other (non read/write) requests on the database (ops/sec) |
+| <span class="break-all">bdb_other_res</span> | <span class="break-all">`sum by(db) (irate(endpoint_other_responses{db="$db"}[1m]))`</span> | Rate of other (non read/write) responses on the database (ops/sec) |
+| <span class="break-all">bdb_other_res_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_other_responses{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of other (non read/write) responses on the database (ops/sec) |
+| <span class="break-all">bdb_pubsub_channels</span> | <span class="break-all">`sum by(db) (redis_server_pubsub_channels)`</span> | Count the pub/sub channels with subscribed clients |
+| <span class="break-all">bdb_pubsub_channels_max</span> | <span class="break-all">`sum by(db) (redis_server_pubsub_channels)`</span> | Highest value of count the pub/sub channels with subscribed clients |
+| <span class="break-all">bdb_pubsub_patterns</span> | <span class="break-all">`sum by(db) (redis_server_pubsub_patterns)`</span> | Count the pub/sub patterns with subscribed clients |
+| <span class="break-all">bdb_pubsub_patterns_max</span></span> | <span class="break-all">`sum by(db) (redis_server_pubsub_patterns)`</span> | Highest value of count the pub/sub patterns with subscribed clients |
+| <span class="break-all">bdb_read_hits</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_read_hits{role="master"}[1m]))`</span> | Rate of read operations accessing an existing key (ops/sec) |
+| <span class="break-all">bdb_read_hits_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_read_hits{role="master"}[1m]))`</span> | Highest value of the rate of read operations accessing an existing key (ops/sec) |
+| <span class="break-all">bdb_read_misses</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_read_misses{role="master"}[1m]))`</span> | Rate of read operations accessing a non-existing key (ops/sec) |
+| <span class="break-all">bdb_read_misses_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_read_misses{role="master"}[1m]))`</span> | Highest value of the rate of read operations accessing a non-existing key (ops/sec) |
+| <span class="break-all">bdb_read_req</span> | <span class="break-all">`sum by (db) (irate(endpoint_read_requests{db="$db"}[1m]))`</span> | Rate of read requests on the database (ops/sec) |
+| <span class="break-all">bdb_read_req_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_read_requests{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of read requests on the database (ops/sec) |
+| <span class="break-all">bdb_read_res</span> | <span class="break-all">`sum by (db) (irate(endpoint_read_responses{"$db"}[1m]))`</span> | Rate of read responses on the database (ops/sec) |
+| <span class="break-all">bdb_read_res_max</span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_read_responses{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of read responses on the database (ops/sec) |
+| <span class="break-all">bdb_shard_cpu_system</span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system", role="master"}[1m]))`</span> | % cores utilization in system mode for all Redis shard processes of this database |
+| <span class="break-all">bdb_shard_cpu_system_max<span></span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="system", role="master"}[1m]))`</span> | Highest value of % cores utilization in system mode for all Redis shard processes of this database |
+| <span class="break-all">bdb_shard_cpu_user</span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user", role="master"}[1m]))`</span> | % cores utilization in user mode for the Redis shard process |
+| <span class="break-all">bdb_shard_cpu_user_max</span> | <span class="break-all">`sum by(db) (irate(namedprocess_namegroup_thread_cpu_seconds_total{mode="user", role="master"}[1m]))`</span> | Highest value of % cores utilization in user mode for the Redis shard process |
+| <span class="break-all">bdb_shards_used</span> | <span class="break-all">`sum((sum(label_replace(label_replace(label_replace(namedprocess_namegroup_thread_count{groupname=~"redis-\d+"}, "redis", "$1", "groupname", "redis-(\d+)"), "shard_type", "flash", "threadname", "(bigstore).*"), "shard_type", "ram", "shard_type", "")) by (redis, shard_type) > bool 0) * on (redis) group_left(db) redis_server_up) by (db, shard_type)`</span> | Used shard count by database and by shard type (ram / flash) |
+| <span class="break-all">bdb_total_connections_received</span> | <span class="break-all">`sum by(db) (irate(endpoint_client_connections{db="$db"}[1m]))`</span> | Rate of new client connections to database (connections/sec) |
+| <span class="break-all">bdb_total_connections_received_max<span></span> | <span class="break-all">`max_over_time (sum by(db) (irate(endpoint_client_connections{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of new client connections to database (connections/sec) |
+| <span class="break-all">bdb_total_req</span> | <span class="break-all">`sum by (db) (irate(endpoint_read_requests{db=""$db""}[1m]) + irate(endpoint_write_requests{db=""$db""}[1m]) + irate(endpoint_other_requests{db=""$db""}[1m]))`</span> | Rate of all requests on the database (ops/sec) |
+| <span class="break-all">bdb_total_req_max</span> | <span class="break-all">`max_over_time(sum by (db) (irate(endpoint_read_requests{db=""$db""}[1m]) + irate(endpoint_write_requests{db=""$db""}[1m]) + irate(endpoint_other_requests{db=""$db""}[1m])) [$__range:])`</span> | Highest value of the rate of all requests on the database (ops/sec) |
+| <span class="break-all">bdb_total_res</span> | <span class="break-all">`sum by (db) (irate(endpoint_read_responses{db=""$db""}[1m]) + irate(endpoint_write_responses{db=""$db""}[1m]) + irate(endpoint_other_responses{db=""$db""}[1m]))`</span> | Rate of all responses on the database (ops/sec) |
+| <span class="break-all">bdb_total_res_max</span> | <span class="break-all">`max_over_time(sum by (db) (irate(endpoint_read_responses{db=""$db""}[1m]) + irate(endpoint_write_responses{db=""$db""}[1m]) + irate(endpoint_other_responses{db=""$db""}[1m])) [$__range:])`</span> | Highest value of the rate of all responses on the database (ops/sec) |
+| <span class="break-all">bdb_up</span> | <span class="break-all">`min by(db) (redis_up)`</span> | Database is up and running |
+| <span class="break-all">bdb_used_memory</span> | <span class="break-all">`sum by (db) (redis_server_used_memory)`</span> | Memory used by database (in BigRedis this includes flash) (bytes) |
+| <span class="break-all">bdb_write_hits</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_write_hits{role="master"}[1m]))`</span> | Rate of write operations accessing an existing key (ops/sec) |
+| <span class="break-all">bdb_write_hits_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_write_hits{role="master"}[1m]))`</span> | Highest value of the rate of write operations accessing an existing key (ops/sec) |
+| <span class="break-all">bdb_write_misses</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_write_misses{role="master"}[1m]))`</span> | Rate of write operations accessing a non-existing key (ops/sec) |
+| <span class="break-all">bdb_write_misses_max</span> | <span class="break-all">`sum by (db) (irate(redis_server_keyspace_write_misses{role="master"}[1m]))`</span> | Highest value of the rate of write operations accessing a non-existing key (ops/sec) |
+| <span class="break-all">bdb_write_req</span> | <span class="break-all">`sum by (db) (irate(endpoint_write_requests{db="$db"}[1m]))`</span> | Rate of write requests on the database (ops/sec) |
+| <span class="break-all">bdb_write_req_max</span> | <span class="break-all">`max_over_time(sum by (db) (irate(endpoint_write_requests{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of write requests on the database (ops/sec) |
+| <span class="break-all">bdb_write_res</span> | <span class="break-all">`sum by(db) (irate(endpoint_write_responses{db="$db"}[1m]))`</span> | Rate of write responses on the database (ops/sec) |
+| <span class="break-all">bdb_write_res_max</span> | <span class="break-all">`max_over_time(sum by (db) (irate(endpoint_write_responses{db="$db"}[1m]))[$__range:])`</span> | Highest value of the rate of write responses on the database (ops/sec) |
+| no_of_expires</span> | <span class="break-all">`sum by(db) (redis_server_db_expires{role="master"})`</span> | Current number of volatile keys in the database |
+
+## Node metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| <span class="break-all">node_available_flash</span> | <span class="break-all">`node_available_flash_bytes`</span> | Available flash in the node (bytes) |
+| <span class="break-all">node_available_flash_no_overbooking</span> | <span class="break-all">`node_available_flash_no_overbooking_bytes`</span> | Available flash in the node (bytes), without taking into account overbooking |
+| <span class="break-all">node_available_memory</span> | <span class="break-all">`node_available_memory_bytes`</span> | Amount of free memory in the node (bytes) that is available for database provisioning |
+| <span class="break-all">node_available_memory_no_overbooking</span> | <span class="break-all">`node_available_memory_no_overbooking_bytes`</span> | Available RAM in the node (bytes) without taking into account overbooking |
+| <span class="break-all">node_avg_latency</span> | <span class="break-all">`sum by (proxy) (irate(endpoint_acc_latency[1m])) / sum by (proxy) (irate(endpoint_total_started_res[1m]))`</span> | Average latency of requests handled by endpoints on the node in milliseconds; returned only when there is traffic |
+| <span class="break-all">node_bigstore_free</span> | <span class="break-all">`node_bigstore_free_bytes`</span> | Sum of free space of back-end flash (used by flash database's [BigRedis]) on all cluster nodes (bytes); returned only when BigRedis is enabled |
+| <span class="break-all">node_bigstore_iops</span> | <span class="break-all">`node_flash_reads_total + node_flash_writes_total`</span> | Rate of I/O operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| <span class="break-all">node_bigstore_kv_ops</span> | <span class="break-all">`sum by (node) (irate(redis_server_big_io_dels[1m]) + irate(redis_server_big_io_reads[1m]) + irate(redis_server_big_io_writes[1m]))`</span> | Rate of value read/write operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (ops/sec); returned only when BigRedis is enabled |
+| <span class="break-all">node_bigstore_throughput</span> | <span class="break-all">`sum by (node) (irate(redis_server_big_io_read_bytes[1m]) + irate(redis_server_big_io_write_bytes[1m]))`</span> | Throughput I/O operations against back-end flash for all shards which are part of a flash-based database (BigRedis) in the cluster (bytes/sec); returned only when BigRedis is enabled |
+| <span class="break-all">node_cert_expiration_seconds</span> | <span class="break-all">`node_cert_expires_in_seconds`</span> | Certificate expiration (in seconds) per given node; read more about [certificates in Redis Enterprise]({{< relref "/operate/rs/security/certificates" >}}) and [monitoring certificates]({{< relref "/operate/rs/security/certificates/monitor-certificates" >}}) |
+| <span class="break-all">node_conns</span> | <span class="break-all">`sum by (node) (endpoint_client_connections)`</span> | Number of clients connected to endpoints on node |
+| <span class="break-all">node_cpu_idle</span> | <span class="break-all">`avg by (node) (irate(node_cpu_seconds_total{mode="idle"}[1m]))`</span> | CPU idle time portion (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_idle_max</span> | <span class="break-all">N/A</span> | Highest value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_idle_median</span> | <span class="break-all">N/A</span> | Average value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_idle_min</span> | <span class="break-all">N/A</span> | Lowest value of CPU idle time portion (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_system</span> | <span class="break-all">`avg by (node) (irate(node_cpu_seconds_total{mode="system"}[1m]))`</span> | CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_system_max</span> | <span class="break-all">N/A</span> | Highest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_system_median</span> | <span class="break-all">N/A</span> | Average value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_system_min</span> | <span class="break-all">N/A</span> | Lowest value of CPU time portion spent in the kernel (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_user</span> | <span class="break-all">`avg by (node) (irate(node_cpu_seconds_total{mode="user"}[1m]))`</span> | CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_user_max</span> | <span class="break-all">N/A</span> | Highest value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_user_median</span> | <span class="break-all">N/A</span> | Average value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cpu_user_min</span> | <span class="break-all">N/A</span> | Lowest value of CPU time portion spent by user-space processes (0-1, multiply by 100 to get percent) |
+| <span class="break-all">node_cur_aof_rewrites</span> | <span class="break-all">`sum by (cluster, node) (redis_server_aof_rewrite_in_progress)`</span> | Number of AOF rewrites that are currently performed by shards on this node |
+| <span class="break-all">node_egress_bytes</span> | <span class="break-all">`irate(node_network_transmit_bytes_total{device="<interface>"}[1m])`</span> | Rate of outgoing network traffic to node (bytes/sec) |
+| <span class="break-all">node_egress_bytes_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of outgoing network traffic to node (bytes/sec) |
+| <span class="break-all">node_egress_bytes_median</span> | <span class="break-all">N/A</span> | Average value of the rate of outgoing network traffic to node (bytes/sec) |
+| <span class="break-all">node_egress_bytes_min</span> | <span class="break-all">N/A</span> | Lowest value of the rate of outgoing network traffic to node (bytes/sec) |
+| <span class="break-all">node_ephemeral_storage_avail</span> | <span class="break-all">`node_ephemeral_storage_avail_bytes`</span> | Disk space available to RLEC processes on configured ephemeral disk (bytes) |
+| <span class="break-all">node_ephemeral_storage_free</span> | <span class="break-all">`node_ephemeral_storage_free_bytes`</span> | Free disk space on configured ephemeral disk (bytes) |
+| <span class="break-all">node_free_memory</span> | <span class="break-all">`node_memory_MemFree_bytes`</span> | Free memory in the node (bytes) |
+| <span class="break-all">node_ingress_bytes</span> | <span class="break-all">`irate(node_network_receive_bytes_total{device="<interface>"}[1m])`</span> | Rate of incoming network traffic to node (bytes/sec) |
+| <span class="break-all">node_ingress_bytes_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of incoming network traffic to node (bytes/sec) |
+| <span class="break-all">node_ingress_bytes_median</span> | <span class="break-all">N/A</span> | Average value of the rate of incoming network traffic to node (bytes/sec) |
+| <span class="break-all">node_ingress_bytes_min</span> | <span class="break-all">N/A</span> | Lowest value of the rate of incoming network traffic to node (bytes/sec) |
+| <span class="break-all">node_persistent_storage_avail</span> | <span class="break-all">`node_persistent_storage_avail_bytes`</span> | Disk space available to RLEC processes on configured persistent disk (bytes) |
+| <span class="break-all">node_persistent_storage_free</span> | <span class="break-all">`node_persistent_storage_free_bytes`</span> | Free disk space on configured persistent disk (bytes) |
+| <span class="break-all">node_provisional_flash</span> | <span class="break-all">`node_provisional_flash_bytes`</span> | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| <span class="break-all">node_provisional_flash_no_overbooking</span> | <span class="break-all">`node_provisional_flash_no_overbooking_bytes`</span> | Amount of flash available for new shards on this node, without taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| <span class="break-all">node_provisional_memory</span> | <span class="break-all">`node_provisional_memory_bytes`</span> | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases |
+| <span class="break-all">node_provisional_memory_no_overbooking</span> | <span class="break-all">`node_provisional_memory_no_overbooking_bytes`</span> | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases, without taking into account overbooking |
+| <span class="break-all">node_total_req</span> | <span class="break-all">`sum by (cluster, node) (irate(endpoint_total_req[1m]))`</span> | Request rate handled by endpoints on node (ops/sec) |
+| <span class="break-all">node_up</span> | <span class="break-all">`node_metrics_up`</span> | Node is part of the cluster and is connected |
+
+## Cluster metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| cluster_shards_limit | `license_shards_limit` | Total shard limit by the license by shard type (ram / flash) |
+
+## Proxy metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| <span class="break-all">listener_acc_latency</span> | <span class="break-all">N/A</span> | Accumulative latency (sum of the latencies) of all types of commands on the database. For the average latency, divide this value by listener_total_res |
+| <span class="break-all">listener_acc_latency_max</span> | <span class="break-all">N/A</span> | Highest value of accumulative latency of all types of commands on the database |
+| <span class="break-all">listener_acc_other_latency</span> | <span class="break-all">N/A</span> | Accumulative latency (sum of the latencies) of commands that are a type "other" on the database. For the average latency, divide this value by listener_other_res |
+| <span class="break-all">listener_acc_other_latency_max</span> | <span class="break-all">N/A</span> | Highest value of accumulative latency of commands that are a type "other" on the database |
+| <span class="break-all">listener_acc_read_latency</span> | <span class="break-all">N/A</span> | Accumulative latency (sum of the latencies) of commands that are a type "read" on the database. For the average latency, divide this value by listener_read_res |
+| <span class="break-all">listener_acc_read_latency_max</span> | <span class="break-all">N/A</span> | Highest value of accumulative latency of commands that are a type "read" on the database |
+| <span class="break-all">listener_acc_write_latency</span> | <span class="break-all">N/A</span> | Accumulative latency (sum of the latencies) of commands that are a type "write" on the database. For the average latency, divide this value by listener_write_res |
+| <span class="break-all">listener_acc_write_latency_max</span> | <span class="break-all">N/A</span> | Highest value of accumulative latency of commands that are a type "write" on the database |
+| <span class="break-all">listener_auth_cmds</span> | <span class="break-all">N/A</span> | Number of memcached AUTH commands sent to the database |
+| <span class="break-all">listener_auth_cmds_max</span> | <span class="break-all">N/A</span> | Highest value of the number of memcached AUTH commands sent to the database |
+| <span class="break-all">listener_auth_errors</span> | <span class="break-all">N/A</span> | Number of error responses to memcached AUTH commands |
+| <span class="break-all">listener_auth_errors_max</span> | <span class="break-all">N/A</span> | Highest value of the number of error responses to memcached AUTH commands |
+| <span class="break-all">listener_cmd_flush</span> | <span class="break-all">N/A</span> | Number of memcached FLUSH_ALL commands sent to the database |
+| <span class="break-all">listener_cmd_flush_max</span> | <span class="break-all">N/A</span> | Highest value of the number of memcached FLUSH_ALL commands sent to the database |
+| <span class="break-all">listener_cmd_get</span> | <span class="break-all">N/A</span> | Number of memcached GET commands sent to the database |
+| <span class="break-all">listener_cmd_get_max</span> | <span class="break-all">N/A</span> | Highest value of the number of memcached GET commands sent to the database |
+| <span class="break-all">listener_cmd_set</span> | <span class="break-all">N/A</span> | Number of memcached SET commands sent to the database |
+| <span class="break-all">listener_cmd_set_max</span> | <span class="break-all">N/A</span> | Highest value of the number of memcached SET commands sent to the database |
+| <span class="break-all">listener_cmd_touch</span> | <span class="break-all">N/A</span> | Number of memcached TOUCH commands sent to the database |
+| <span class="break-all">listener_cmd_touch_max</span> | <span class="break-all">N/A</span> | Highest value of the number of memcached TOUCH commands sent to the database |
+| <span class="break-all">listener_conns</span> | <span class="break-all">N/A</span> | Number of clients connected to the endpoint |
+| <span class="break-all">listener_egress_bytes</span> | <span class="break-all">N/A</span> | Rate of outgoing network traffic to the endpoint (bytes/sec) |
+| <span class="break-all">listener_egress_bytes_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of outgoing network traffic to the endpoint (bytes/sec) |
+| <span class="break-all">listener_ingress_bytes</span> | <span class="break-all">N/A</span> | Rate of incoming network traffic to the endpoint (bytes/sec) |
+| <span class="break-all">listener_ingress_bytes_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of incoming network traffic to the endpoint (bytes/sec) |
+| <span class="break-all">listener_last_req_time</span> | <span class="break-all">N/A</span> | Time of last command sent to the database |
+| <span class="break-all">listener_last_res_time</span> | <span class="break-all">N/A</span> | Time of last response sent from the database |
+| <span class="break-all">listener_max_connections_exceeded</span> | <span class="break-all">`irate(endpoint_maximal_connections_exceeded[1m])`</span> | Number of times the number of clients connected to the database at the same time has exceeded the max limit |
+| <span class="break-all">listener_max_connections_exceeded_max</span> | <span class="break-all">N/A</span> | Highest value of the number of times the number of clients connected to the database at the same time has exceeded the max limit |
+| <span class="break-all">listener_monitor_sessions_count</span> | <span class="break-all">N/A</span> | Number of clients connected in monitor mode to the endpoint |
+| <span class="break-all">listener_other_req</span> | <span class="break-all">N/A</span> | Rate of other (non-read/write) requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_other_req_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of other (non-read/write) requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_other_res</span> | <span class="break-all">N/A</span> | Rate of other (non-read/write) responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_other_res_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of other (non-read/write) responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_other_started_res</span> | <span class="break-all">N/A</span> | Number of responses sent from the database of type "other" |
+| <span class="break-all">listener_other_started_res_max</span> | <span class="break-all">N/A</span> | Highest value of the number of responses sent from the database of type "other" |
+| <span class="break-all">listener_read_req</span> | <span class="break-all">`irate(endpoint_read_requests[1m])`</span> | Rate of read requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_read_req_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of read requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_read_res</span> | <span class="break-all">`irate(endpoint_read_responses[1m])`</span> | Rate of read responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_read_res_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of read responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_read_started_res</span> | <span class="break-all">N/A</span> | Number of responses sent from the database of type "read" |
+| <span class="break-all">listener_read_started_res_max</span> | <span class="break-all">N/A</span> | Highest value of the number of responses sent from the database of type "read" |
+| <span class="break-all">listener_total_connections_received</span> | <span class="break-all">`irate(endpoint_total_connections_received[1m])`</span> | Rate of new client connections to the endpoint (connections/sec) |
+| <span class="break-all">listener_total_connections_received_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of new client connections to the endpoint (connections/sec) |
+| <span class="break-all">listener_total_req</span> | <span class="break-all">N/A</span> | Request rate handled by the endpoint (ops/sec) |
+| <span class="break-all">listener_total_req_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of all requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_total_res</span> | <span class="break-all">N/A</span> | Rate of all responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_total_res_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of all responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_total_started_res</span> | <span class="break-all">N/A</span> | Number of responses sent from the database of all types |
+| <span class="break-all">listener_total_started_res_max</span> | <span class="break-all">N/A</span> | Highest value of the number of responses sent from the database of all types |
+| <span class="break-all">listener_write_req</span> | <span class="break-all">`irate(endpoint_write_requests[1m])`</span> | Rate of write requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_write_req_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of write requests on the endpoint (ops/sec) |
+| <span class="break-all">listener_write_res</span> | <span class="break-all">`irate(endpoint_write_responses[1m])`</span> | Rate of write responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_write_res_max</span> | <span class="break-all">N/A</span> | Highest value of the rate of write responses on the endpoint (ops/sec) |
+| <span class="break-all">listener_write_started_res</span> | <span class="break-all">N/A</span> | Number of responses sent from the database of type "write" |
+| <span class="break-all">listener_write_started_res_max</span> | <span class="break-all">N/A</span> | Highest value of the number of responses sent from the database of type "write" |
+
+## Replication metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| <span class="break-all">bdb_replicaof_syncer_ingress_bytes</span> | <span class="break-all">`rate(replica_src_ingress_bytes[1m])`</span> | Rate of compressed incoming network traffic to a Replica Of database (bytes/sec) |
+| <span class="break-all">bdb_replicaof_syncer_ingress_bytes_decompressed</span> | <span class="break-all">`rate(replica_src_ingress_bytes_decompressed[1m])`</span> | Rate of decompressed incoming network traffic to a Replica Of database (bytes/sec) |
+| <span class="break-all">bdb_replicaof_syncer_local_ingress_lag_time</span> | <span class="break-all">`database_syncer_lag_ms{syncer_type="replicaof"}`</span> | Lag time between the source and the destination for Replica Of traffic (ms) |
+| <span class="break-all">bdb_replicaof_syncer_status</span> | <span class="break-all">`database_syncer_current_status{syncer_type="replicaof"}`</span> | Syncer status for Replica Of traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |
+| <span class="break-all">bdb_crdt_syncer_ingress_bytes</span> | <span class="break-all">`rate(crdt_src_ingress_bytes[1m])`</span> | Rate of compressed incoming network traffic to CRDB (bytes/sec) |
+| <span class="break-all">bdb_crdt_syncer_ingress_bytes_decompressed</span> | <span class="break-all">`rate(crdt_src_ingress_bytes_decompressed[1m])`</span> | Rate of decompressed incoming network traffic to CRDB (bytes/sec) |
+| <span class="break-all">bdb_crdt_syncer_local_ingress_lag_time</span> | <span class="break-all">`database_syncer_lag_ms{syncer_type="crdt"}`</span> | Lag time between the source and the destination (ms) for CRDB traffic |
+| <span class="break-all">bdb_crdt_syncer_status</span> | <span class="break-all">`database_syncer_current_status{syncer_type="crdt"}`</span> | Syncer status for CRDB traffic; 0 = in-sync, 1 = syncing, 2 = out of sync |
+
+## Shard metrics
+
+| V1&nbsp;metric | Equivalent V2 PromQL | Description |
+| --------- | :------------------- | :---------- |
+| <span class="break-all">redis_active_defrag_running</span> | <span class="break-all">`redis_server_active_defrag_running`</span> | Automatic memory defragmentation current aggressiveness (% cpu) |
+| <span class="break-all">redis_allocator_active</span> | <span class="break-all">`redis_server_allocator_active`</span> | Total used memory, including external fragmentation |
+| <span class="break-all">redis_allocator_allocated</span> | <span class="break-all">`redis_server_allocator_allocated`</span> | Total allocated memory |
+| <span class="break-all">redis_allocator_resident</span> | <span class="break-all">`redis_server_allocator_resident`</span> | Total resident memory (RSS) |
+| <span class="break-all">redis_aof_last_cow_size</span> | <span class="break-all">`redis_server_aof_last_cow_size`</span> | Last AOFR, CopyOnWrite memory |
+| <span class="break-all">redis_aof_rewrite_in_progress</span> | <span class="break-all">`redis_server_aof_rewrite_in_progress`</span> | The number of simultaneous AOF rewrites that are in progress |
+| <span class="break-all">redis_aof_rewrites</span> | <span class="break-all">`redis_server_aof_rewrites`</span> | Number of AOF rewrites this process executed |
+| <span class="break-all">redis_aof_delayed_fsync</span> | <span class="break-all">`redis_server_aof_delayed_fsync`</span> | Number of times an AOF fsync caused delays in the main Redis thread (inducing latency); this can indicate that the disk is slow or overloaded |
+| <span class="break-all">redis_blocked_clients</span> | <span class="break-all">`redis_server_blocked_clients`</span> | Count the clients waiting on a blocking call |
+| <span class="break-all">redis_connected_clients</span> | <span class="break-all">`redis_server_connected_clients`</span> | Number of client connections to the specific shard |
+| <span class="break-all">redis_connected_slaves</span> | <span class="break-all">`redis_server_connected_slaves`</span> | Number of connected replicas |
+| <span class="break-all">redis_db0_avg_ttl</span> | <span class="break-all">`redis_server_db0_avg_ttl`</span> | Average TTL of all volatile keys |
+| <span class="break-all">redis_db0_expires</span> | <span class="break-all">`redis_server_expired_keys`</span> | Total count of volatile keys |
+| <span class="break-all">redis_db0_keys</span> | <span class="break-all">`redis_server_db0_keys`</span> | Total key count |
+| <span class="break-all">redis_evicted_keys</span> | <span class="break-all">`redis_server_evicted_keys`</span> | Keys evicted so far (since restart) |
+| <span class="break-all">redis_expire_cycle_cpu_milliseconds</span> | <span class="break-all">`redis_server_expire_cycle_cpu_milliseconds`</span> | The cumulative amount of time spent on active expiry cycles |
+| <span class="break-all">redis_expired_keys</span> | <span class="break-all">`redis_server_expired_keys`</span> | Keys expired so far (since restart) |
+| <span class="break-all">redis_forwarding_state</span> | <span class="break-all">`redis_server_forwarding_state`</span> | Shard forwarding state (on or off) |
+| <span class="break-all">redis_keys_trimmed</span> | <span class="break-all">`redis_server_keys_trimmed`</span> | The number of keys that were trimmed in the current or last resharding process |
+| <span class="break-all">redis_keyspace_read_hits</span> | <span class="break-all">`redis_server_keyspace_read_hits`</span> | Number of read operations accessing an existing keyspace |
+| <span class="break-all">redis_keyspace_read_misses</span> | <span class="break-all">`redis_server_keyspace_read_misses`</span> | Number of read operations accessing a non-existing keyspace |
+| <span class="break-all">redis_keyspace_write_hits</span> | <span class="break-all">`redis_server_keyspace_write_hits`</span> | Number of write operations accessing an existing keyspace |
+| <span class="break-all">redis_keyspace_write_misses</span> | <span class="break-all">`redis_server_keyspace_write_misses`</span> | Number of write operations accessing a non-existing keyspace |
+| <span class="break-all">redis_master_link_status</span> | <span class="break-all">`redis_server_master_link_status`</span> | Indicates if the replica is connected to its master |
+| <span class="break-all">redis_master_repl_offset</span> | <span class="break-all">`redis_server_master_repl_offset`</span> | Number of bytes sent to replicas by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_master_sync_in_progress</span> | <span class="break-all">`redis_server_master_sync_in_progress`</span> | The master shard is synchronizing (1 true; 0 false) |
+| <span class="break-all">redis_max_process_mem</span> | <span class="break-all">`redis_server_max_process_mem`</span> | Current memory limit configured by redis_mgr according to node free memory |
+| <span class="break-all">redis_maxmemory</span> | <span class="break-all">`redis_server_maxmemory`</span> | Current memory limit configured by redis_mgr according to database memory limits |
+| <span class="break-all">redis_mem_aof_buffer</span> | <span class="break-all">`redis_server_mem_aof_buffer`</span> | Current size of AOF buffer |
+| <span class="break-all">redis_mem_clients_normal</span> | <span class="break-all">`redis_server_mem_clients_normal`</span> | Current memory used for input and output buffers of non-replica clients |
+| <span class="break-all">redis_mem_clients_slaves</span> | <span class="break-all">`redis_server_mem_clients_slaves`</span> | Current memory used for input and output buffers of replica clients |
+| <span class="break-all">redis_mem_fragmentation_ratio</span> | <span class="break-all">`redis_server_mem_fragmentation_ratio`</span> | Memory fragmentation ratio (1.3 means 30% overhead) |
+| <span class="break-all">redis_mem_not_counted_for_evict</span> | <span class="break-all">`redis_server_mem_not_counted_for_evict`</span> | Portion of used_memory (in bytes) that's not counted for eviction and OOM error |
+| <span class="break-all">redis_mem_replication_backlog</span> | <span class="break-all">`redis_server_mem_replication_backlog`</span> | Size of replication backlog |
+| <span class="break-all">redis_module_fork_in_progress</span> | <span class="break-all">`redis_server_module_fork_in_progress`</span> | A binary value that indicates if there is an active fork spawned by a module (1) or not (0) |
+| <span class="break-all">redis_process_cpu_system_seconds_total</span> | <span class="break-all">`namedprocess_namegroup_cpu_seconds_total{mode="system"}`</span> | Shard process system CPU time spent in seconds |
+| <span class="break-all">redis_process_cpu_usage_percent</span> | <span class="break-all">`namedprocess_namegroup_cpu_seconds_total{mode=~"system\|user"}`</span> | Shard process CPU usage percentage |
+| <span class="break-all">redis_process_cpu_user_seconds_total</span> | <span class="break-all">`namedprocess_namegroup_cpu_seconds_total{mode="user"}`</span> | Shard user CPU time spent in seconds |
+| <span class="break-all">redis_process_main_thread_cpu_system_seconds_total</span> | <span class="break-all">`namedprocess_namegroup_thread_cpu_seconds_total{mode="system",threadname="redis-server"}`</span> | Shard main thread system CPU time spent in seconds |
+| <span class="break-all">redis_process_main_thread_cpu_user_seconds_total</span> | <span class="break-all">`namedprocess_namegroup_thread_cpu_seconds_total{mode="user",threadname="redis-server"}`</span> | Shard main thread user CPU time spent in seconds |
+| <span class="break-all">redis_process_max_fds</span> | <span class="break-all">`max(namedprocess_namegroup_open_filedesc)`</span> | Shard maximum number of open file descriptors |
+| <span class="break-all">redis_process_open_fds</span> | <span class="break-all">`namedprocess_namegroup_open_filedesc`</span> | Shard number of open file descriptors |
+| <span class="break-all">redis_process_resident_memory_bytes</span> | <span class="break-all">`namedprocess_namegroup_memory_bytes{memtype="resident"}`</span> | Shard resident memory size in bytes |
+| <span class="break-all">redis_process_start_time_seconds</span> | <span class="break-all">`namedprocess_namegroup_oldest_start_time_seconds`</span> | Shard start time of the process since unix epoch in seconds |
+| <span class="break-all">redis_process_virtual_memory_bytes</span> | <span class="break-all">`namedprocess_namegroup_memory_bytes{memtype="virtual"}`</span> | Shard virtual memory in bytes |
+| <span class="break-all">redis_rdb_bgsave_in_progress</span> | <span class="break-all">`redis_server_rdb_bgsave_in_progress`</span> | Indication if bgsave is currently in progress |
+| <span class="break-all">redis_rdb_last_cow_size</span> | <span class="break-all">`redis_server_rdb_last_cow_size`</span> | Last bgsave (or SYNC fork) used CopyOnWrite memory |
+| <span class="break-all">redis_rdb_saves</span> | <span class="break-all">`redis_server_rdb_saves`</span> | Total count of bgsaves since the process was restarted (including replica fullsync and persistence) |
+| <span class="break-all">redis_repl_touch_bytes</span> | <span class="break-all">`redis_server_repl_touch_bytes`</span> | Number of bytes sent to replicas as TOUCH commands by the shard as a result of a READ command that was processed; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_total_commands_processed</span> | <span class="break-all">`redis_server_total_commands_processed`</span> | Number of commands processed by the shard; calculate the number of commands for a time period by comparing the value at different times |
+| <span class="break-all">redis_total_connections_received</span> | <span class="break-all">`redis_server_total_connections_received`</span> | Number of connections received by the shard; calculate the number of connections for a time period by comparing the value at different times |
+| <span class="break-all">redis_total_net_input_bytes</span> | <span class="break-all">`redis_server_total_net_input_bytes`</span> | Number of bytes received by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_total_net_output_bytes</span> | <span class="break-all">`redis_server_total_net_output_bytes`</span> | Number of bytes sent by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_up</span> | <span class="break-all">`redis_server_up`</span> | Shard is up and running |
+| <span class="break-all">redis_used_memory</span> | <span class="break-all">`redis_server_used_memory`</span> | Memory used by shard (in BigRedis this includes flash) (bytes) |
+The number of databases is unlimited. The limiting factor is the
+available memory in the cluster, and the number of shards in the
+subscription.
+
+Note that the impact of the specific database configuration on the 
+number of shards it consumes. For example:
+
+- Enabling database replication, without enabling database clustering, 
+  creates two shards: a master shard and a replica shard.
+- Enabling database clustering creates as many database shards as you 
+  configure.
+- Enabling both database replication and database clustering creates 
+  double the number of database shards you configure.If you cannot activate the database because of a memory limitation,
+make sure that Docker has at least 4 GB of memory allocated in the **Advanced** section of Docker **Settings**.
+1. On the **Databases** screen, select **Quick database**.
+
+    {{<image filename="images/rs/screenshots/databases/db-screen.png" alt="Select Quick database on the Databases screen." >}}
+
+1. Enter 12000 for the **Port**.
+
+    If port 12000 is not available, enter any available port number between 10000 to 19999 or leave it blank to let the cluster assign a port number for you. You will use this port number to connect to the database.
+
+    {{<image filename="images/rs/screenshots/databases/quick-db-7-8-2.png" alt="Create a quick database." >}}
+
+1. Select **Create** to create your database.
+
+When you see **Database active** appear on the database configuration screen, the database is activated and ready for you to use.
+
+{{<image filename="images/rs/icons/db-active-icon.png" width="150px" alt="Database active icon." >}}
+
+
+You now have a Redis database!## Conflict resolution rules
+
+With Active-Active databases, it's possible for two different instances to try to run write operations on the same data at the same time. If this happens, conflicts can arise when the replicas attempt to sync these changes with each other. Conflict resolution rules determine how the database handles conflicting operations.
+
+There are two types of conflict resolution:
+
+1. Merge:
+
+    - The operations are associative.
+
+    - Merges the results of both operations.
+
+1. Win over:
+
+    - The operations are not associative.
+
+    - One operation wins the conflict and sets the value.
+
+    - Ignores the losing operation.
+
+The following conflict resolution rules show how Active-Active databases resolve conflicts for various JSON commands.
+
+### Assign different types to a key
+
+**Conflict**
+
+Two instances concurrently assign values of different types to the same key within a JSON document.
+
+For example:
+
+Instance 1 assigns an object to a key within a JSON document.
+
+Instance 2 assigns an array to the same key.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+The instance with the smaller ID wins, so the key becomes an object in the given example.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | Set the same key to an object or an array | JSON.SET doc $.a '{}' | JSON.SET doc $.a '[]' |
+| t2 | Add data to the object and array | <nobr>JSON.SET doc  $.a.x '“y”'</nobr> <br /><br /> Result: <br /> {"a": {"x": "y"}} | <nobr>JSON.SET doc $.a '["z"]'</nobr> <br /><br /> Result: <br /> {“a”: ["z"]} |
+| t3 | Active-Active synchronization | – Sync – | – Sync – |
+| t4 | Instance 1 wins | JSON.GET doc $ <br /><br /> Result: <br /> {"a": {"x": "y"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"a": {"x": "y"}} |
+
+### Create versus create
+
+**Conflict**
+
+Two instances concurrently use `JSON.SET` to assign a new JSON document to the same key.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+The instance with the smaller ID wins.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | Create a new JSON document | <nobr>JSON.SET doc $ '{"field": "a"}'</nobr> | <nobr>JSON.SET doc $ '{"field": "b"}'</nobr> |
+| t2 | Active-Active synchronization | – Sync – | – Sync – |
+| t3 | Instance 1 wins | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "a"} | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "a"} |
+
+### Create versus update
+
+**Conflict**
+
+Instance 1 creates a new document and assigns it to an existing key with `JSON.SET`.
+
+Instance 2 updates the existing content of the same key with `JSON.SET`.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+The operation that creates a new document wins.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br />  {"field1": "value1"} | JSON.GET doc $ <br /><br /> Result: <br />  {"field1": "value1"} |
+| t2 | Instance 1 creates a new document; instance 2 updates the existing document | <nobr>JSON.SET doc $ '{"field2": "value2"}'</nobr> | <nobr>JSON.SET doc $.field1 '[1, 2, 3]'</nobr> |
+| t3 | Active-Active synchronization | – Sync – | – Sync – |
+| t4 | Instance 1 wins | JSON.GET doc . <br /><br /> Result: <br /> {"field2": "value2"} | JSON.GET doc . <br /><br /> Result: <br /> {"field2": "value2"} |
+
+### Delete versus create
+
+**Conflict**
+
+Instance 1 deletes a JSON document with `JSON.DEL`.
+
+Instance 2 uses `JSON.SET` to create a new JSON document and assign it to the key deleted by instance 1.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+Document creation wins over deletion.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> {"field1": "value1"} | JSON.GET doc $ <br /><br /> Result: <br /> {"field1": "value1"} |
+| t2 | Instance 1 deletes the document; instance 2 creates a new document | JSON.DEL doc | <nobr>JSON.SET doc $ '{"field1": "value2"}'</nobr> |
+| t3 | Active-Active synchronization | – Sync – | – Sync – |
+| t4 | Instance 2 wins | JSON.GET doc $ <br /><br /> Result: <br /> <nobr>{"field1": "value2"}</nobr> | JSON.GET doc $ <br /><br /> Result: <br /> {"field1": "value2"} |
+
+### Delete versus update
+
+**Conflict**
+
+Instance 1 deletes a JSON document with `JSON.DEL`.
+
+Instance 2 updates the content of the same document with `JSON.SET`.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+Document deletion wins over updates.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> <nobr>{"field1": "value1"}</nobr> | JSON.GET doc $ <br /><br /> Result: <br /> {"field1": "value1"} |
+| t2 | Instance 1 deletes the document; instance 2 updates it | JSON.DEL doc | <nobr>JSON.SET doc $.field1 '[1, 2, 3]'</nobr> |
+| t3 | Active-Active synchronization | – Sync – | – Sync – |
+| t4 | Instance 1 wins | JSON.GET doc $ <br /><br /> Result: <br /> (nil) | JSON.GET doc $ <br /><br /> Result: <br /> (nil) |
+
+### Update versus update
+
+**Conflict**
+
+Instance 1 updates a field inside a JSON document with `JSON.SET`.
+
+Instance 2 updates the same field with a different value.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+The instance with the smallest ID wins.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "a"} | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "a"} |
+| t2 | Update the same field with different data | <nobr>JSON.SET doc $.field "b"</nobr> | <nobr>JSON.SET doc $.field "c"</nobr> |
+| t3 | Active-Active synchronization | – Sync – | – Sync – |
+| t4 | Instance 1 wins | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "b"} | JSON.GET doc $ <br /><br /> Result: <br /> {"field": "b"} |
+
+### Update versus clear
+
+The version of RedisJSON prior to v2.2 has two different ways to reset the content of a JSON object:
+
+- Assign a new empty JSON object:
+    
+    ```sh
+    JSON.SET doc $.colors '{}'
+    ```
+
+    If you use this method, it cannot be merged with a concurrent update.
+
+- For each key, remove it with `JSON.DEL`:
+
+    ```sh
+    JSON.DEL doc $.colors.blue
+    ```
+
+    With this method, it can merge the reset with concurrent updates.
+
+As of RedisJSON v2.2, you can use the `JSON.CLEAR` command to reset the JSON document without removing each key manually. This method also lets concurrent updates be merged.
+
+#### Assign an empty object
+
+**Conflict**
+
+Instance 1 adds "red" to the existing "colors" object with `JSON.SET`.
+
+Instance 2 assigns a new empty object for "colors".
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+Document creation wins over the update, so the result will be an empty object.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff"}} |
+| t2 | Instance 1 adds a new color; instance 2 resets colors to an empty object | <nobr>JSON.SET doc $.colors.red ‘#ff0000’</nobr> | JSON.SET doc $.colors ‘{}’ |
+| t3 | Instance 2 adds a new color |  | <nobr>JSON.SET doc $.colors.green ‘#00ff00’</nobr> |
+| t4 |  | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff", "red": "#ff0000"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"green": "#00ff00"}} |
+| t5 | Active-Active synchronization | – Sync – | – Sync – |
+| t6 | Instance 2 wins | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"green": "#00ff00"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"green": "#00ff00"}} |
+
+#### Use `JSON.CLEAR`
+
+**Conflict**
+
+Instance 1 adds "red" to the existing "colors" object with `JSON.SET`.
+
+Instance 2 clears the "colors" object with `JSON.CLEAR` and adds "green" to "colors".
+
+**Resolution type**
+
+Merge
+
+**Resolution rule**
+
+Merges the results of all operations.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff"}} |
+| t2 | Instance 1 adds a new color; instance 2 resets the colors | <nobr>JSON.SET doc $.colors.red ‘#ff0000’</nobr> | JSON.CLEAR doc $.colors |
+| t3 |  | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"blue": "#0000ff", "red": "#ff0000"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {}} |
+| t4 | Instance 2 adds a new color |  | <nobr>JSON.SET doc $.colors.green ‘#00ff00’</nobr> |
+| t5 |  |  | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"green": "#00ff00"}} |
+| t6 | Active-Active synchronization | – Sync – | – Sync – |
+| t7 | Merges the results of both instances | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"red": "#ff0000", "green": "#00ff00"}} | JSON.GET doc $ <br /><br /> Result: <br /> {"colors": {"red": "#ff0000", "green": "#00ff00"}} |
+
+### Update versus update array
+
+**Conflict**
+
+Two instances update the same existing array with different content.
+
+**Resolution type**
+
+Merge
+
+**Resolution rule**
+
+Merges the results of all operations on the array. Preserves the original element order from each instance.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> '["a", "b", "c"]' | JSON.GET doc $ <br /><br /> Result: <br /> '["a", "b", "c"]' |
+| t2 | Instance 1 removes an array element; instance 2 adds one | JSON.ARRPOP doc $ 1 <br /><br /> Result: <br /> ["a", "c"] | <nobr>JSON.ARRINSERT doc $ 0 ‘“y”’</nobr> <br /><br /> Result: <br /> ["y", "a", "b", "c"] |
+| t3 | Both instances add another element to the array | <nobr>JSON.ARRINSERT doc $ 1 ‘“x”’</nobr> <br /><br /> Result: <br /> ["a", "x", "c"] | <nobr>JSON.ARRINSERT doc $ 2 ‘“z”’</nobr> <br /><br /> Result: <br /> ["y", "a", "z", "b", "c"] |
+| t4 | Active-Active synchronization | – Sync – | – Sync – |
+| t5 | Merge results from both instances | JSON.GET doc $ <br /><br /> Result: <br /> ["y", "a", "x", "z", "c"] | JSON.GET doc $ <br /><br /> Result: <br /> ["y", "a", "x", "z", "c"] |
+
+### Update versus delete array element
+
+**Conflict**
+
+Instance 1 removes an element from a JSON array with `JSON.ARRPOP`.
+
+Instance 2 updates the same element that instance 1 removes.
+
+**Resolution type**
+
+Win over
+
+**Resolution rule**
+
+Deletion wins over updates.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> {“todo”: [{“title”: “buy milk”, “done”: false}]} | JSON.GET doc $ <br /><br /> Result: <br /> {“todo”: [{“title”: “buy milk”, “done”: false}]} |
+| t2 | Instance 1 removes an array element; instance 2 updates the same element | <nobr>JSON.ARRPOP doc $.todo 0</nobr> | <nobr>JSON.SET doc '$.todo[0]["done"]' 'true'’</nobr> |
+| t3 |  | JSON.GET doc $ <br /><br /> Result: <br /> {“todo”: []} | JSON.GET doc $ <br /><br /> Result: <br /> [{“title”: “buy milk”, “done”: true}]} |
+| t4 | Active-Active synchronization | – Sync – | – Sync – |
+| t5 | Instance 1 wins | JSON.GET doc $ <br /><br /> Result: <br /> doc = {“todo”: []} | JSON.GET doc $ <br /><br /> Result: <br /> doc = {“todo”: []} |
+
+### Update versus update object
+
+**Conflict**
+
+Both instances update the same existing object with different content.
+
+**Resolution type**
+
+Merge
+
+**Resolution rule**
+
+Merges the results of all operations on the object.
+
+**Example**
+
+| Time  | Description | Instance 1 | Instance 2 |
+| :---: | :--- | :--- | :--- |
+| t1 | The document exists on both instances | JSON.GET doc $ <br /><br /> Result: <br /> '{"grocery": []}' | JSON.GET doc $ <br /><br /> Result: <br /> '{"grocery": []}' |
+| t2 | Add new elements to the array | <nobr>JSON.ARRAPPEND doc $.grocery ‘“eggs”’</nobr> | JSON.ARRAPPEND doc $.grocery ‘“milk”’ |
+| t3 | Add new elements to the array | JSON.ARRAPPEND doc $.grocery ‘“ham”’ | <nobr>JSON.ARRAPPEND doc $.grocery ‘“flour”’</nobr> |
+| t4 |  | JSON.GET doc $ <br /><br /> Result: <br /> {"grocery":["eggs", "ham"]} | JSON.GET doc $ <br /><br /> Result: <br /> {"grocery":["milk", "flour"]} |
+| t5 | Active-Active synchronization | – Sync – | – Sync – |
+| t6 | Merges the results from both instances | JSON.GET doc . <br /><br /> Result: <br /> {"grocery":["eggs","ham","milk", "flour"]} | JSON.GET doc . <br /><br /> Result: <br /> {"grocery":["eggs","ham","milk", "flour" ]} |
+Yes we are. Not only are we are the home of Redis, but most of the core engineers on Redis Open Source also work here.  We contribute extensively to the Redis Open Source project. As a rule, we adhere to Redis Open Source specifications and make every effort to update our service with its latest versions.
+
+That said, the following Redis features are not applicable in the context of our service:
+
+- Shared databases aren’t supported in our service given their potential negative impact on performance. We recommend using dedicated databases instead ([read this post for more information](https://redislabs.com/blog/benchmark-shared-vs-dedicated-redis-instances/)). Therefore, the following commands are blocked and show an error when used:
+    - [MOVE](http://redis.io/commands/move)
+    - [SELECT](http://redis.io/commands/select)
+- Data persistence and backups are managed from the service’s web interface, so the following commands are blocked:
+    - [BGREWRITEAOF](http://redis.io/commands/BGREWRITEAOF)
+    - [BGSAVE](http://redis.io/commands/bgsave)
+    - [LASTSAVE](http://redis.io/commands/LASTSAVE)
+    - [SAVE](http://redis.io/commands/SAVE)
+- Since replication is managed automatically by the service and since it could present a security risk, the following commands are blocked:
+    - [MIGRATE](http://redis.io/commands/MIGRATE)
+    - [REPLCONF](http://redis.io/commands/REPLCONF)
+    - [SLAVEOF](http://redis.io/commands/SLAVEOF)
+    - [SYNC](http://redis.io/commands/SYNC)/[PSYNC](http://redis.io/commands/PSYNC)
+- Redis Enterprise clustering technology is different than the Redis Open Source Cluster and supports clustering in a seamless manner that works with all standard Redis clients. As a result, [all Cluster related commands](http://redis.io/commands#cluster) are blocked and show an error when used.
+- Redis Enterprise clustering technology allows [multiple active proxies](http://docs.redislabs.com/latest/rs/databases/configure/proxy-policy.md). As a result, the CLIENT ID command cannot guarantee incremental IDs between clients who connect to different nodes under multi proxy policies.
+- Commands that aren’t relevant for a hosted Redis service are blocked:
+    - [CONFIG RESETSTAT](http://redis.io/commands/CONFIG-RESETSTAT)
+    - [DEBUG OBJECT](http://redis.io/commands/DEBUG-OBJECT)/[SEGFAULT](http://redis.io/commands/DEBUG-SEGFAULT)
+    - [OBJECT](http://redis.io/commands/OBJECT)
+    - [SHUTDOWN](http://redis.io/commands/SHUTDOWN)
+    - [CLIENT PAUSE](http://redis.io/commands/CLIENT-PAUSE)
+    - [COMMAND INFO](http://redis.io/commands/COMMAND-INFO)
+    - [COMMAND COUNT](http://redis.io/commands/COMMAND-COUNT)
+    - [COMMAND GETKEYS](http://redis.io/commands/COMMAND-GETKEYS)
+    - [LATENCY LATEST](http://redis.io/commands/LATENCY-LATEST)
+    - [LATENCY HISTORY](http://redis.io/commands/LATENCY-HISTORY)
+    - [LATENCY RESET](http://redis.io/commands/LATENCY-RESET)
+    - [LATENCY GRAPH](http://redis.io/commands/LATENCY-GRAPH)
+    - [LATENCY DOCTOR](http://redis.io/commands/LATENCY-DOCTOR)
+    - [MEMORY STATS]({{< relref "/commands/memory-stats" >}}
+    - [MEMORY DOCTOR]({{< relref "/commands/memory-doctor" >}}
+    - [MEMORY MALLOC-STATS]({{< relref "/commands/memory-malloc-stats" >}}
+    - [MEMORY PURGE]({{< relref "/commands/memory-purge" >}}
+    - [MODULE LOAD]({{< relref "/commands/module-load" >}}
+    - [MODULE UNLOAD]({{< relref "/commands/module-unload" >}}
+    - [MODULE LIST]({{< relref "/commands/module-list" >}}
+- Additionally, only a subset of Redis’ configuration settings (via CONFIG GET/SET) is applicable to Redis Cloud. Attempts to get or set a configuration parameter that isn’t included in the following list show an error when used:
+    - hash-max-ziplist-entries
+    - hash-max-ziplist-value
+    - list-max-ziplist-entries
+    - list-max-ziplist-value
+    - notify-keyspace-events
+    - set-max-intset-entries
+    - slowlog-log-slower-than (value must be larger than 1000)
+    - slowlog-max-len (value must be between 128 and 1024)
+    - zset-max-ziplist-entries
+    - zset-max-ziplist-value
+- Lastly, unlike Redis’ 512MB limit, the maximum size of key names in our service is 64KB (key values, however, can have sizes up to 512MB).
+
+## Introduction
+
+This document provides observability and monitoring guidance for developers running applications
+that connect to Redis Enterprise. In particular, this guide focuses on the systems
+and resources that are most likely to impact the performance of your application.
+
+The screenshot below shows a dashboard with relevant statistics for a node:
+{{< image filename="/images/node_summary.png" alt="Dashboard showing relevant statistics for a Node" >}}
+
+To effectively monitor a Redis Enterprise cluster you need to observe
+core cluster resources and key database performance indicators as described in the following sections for this guide.
+
+Core cluster resources include:
+
+* Memory utilization
+* CPU utilization
+* Database connections
+* Network traffic
+* Synchronization
+
+Key database performance indicators include:
+
+* Latency
+* Cache hit rate
+* Key eviction rate
+* Proxy Performance
+
+Dashboard showing an overview of cluster metrics:
+{{< image filename="/images/cluster_overview.png" alt="Dashboard showing an overview of cluster metrics" >}}
+
+In addition to manually monitoring these resources and indicators, it is best practice to set up alerts.
+
+## Core cluster resource monitoring
+
+Redis Enterprise version 7.8.2 introduces a preview of the new metrics stream engine that exposes the v2 Prometheus scraping endpoint at `https://<IP>:8070/v2`. This new engine exports all time-series metrics to external monitoring tools such as Grafana, DataDog, NewRelic, and Dynatrace using Prometheus.
+
+The new engine enables real-time monitoring, including full monitoring during maintenance operations, providing full visibility into performance during events such as shards' failovers and scaling operations. See [Monitoring with metrics and alerts]({{<relref "/operate/rs/monitoring/">}}) for more details.
+
+If you are already using the existing scraping endpoint for integration, follow [this guide]({{<relref "/operate/rs/references/metrics/prometheus-metrics-v1-to-v2">}}) to transition and try the new engine. You can scrape both existing and new endpoints simultaneously, which lets you create advanced dashboards and transition smoothly.
+
+### Memory
+
+Every Redis Enterprise database has a maximum configured memory limit to ensure isolation
+in a multi-database cluster.
+
+| Metric name | Definition | Unit |
+| ------ | ------ | :------ |
+| Memory usage percentage metric | Percentage of used memory relative to the configured memory limit for a given database | Percentage |
+
+Dashboard displaying high-level cluster metrics - [Cluster Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/cluster_dashboard_v9-11.json)
+{{< image filename="/images/playbook_used-memory.png" alt="Dashboard displaying high-level cluster metrics" >}}
+
+### Thresholds
+
+The appropriate memory threshold depends on how the application is using Redis.
+
+* Caching workloads, which permit Redis to evict keys, can safely use 100% of available memory.
+* Non-caching workloads do not permit key eviction and should be closely monitored as soon as memory usage reaches 80%.
+
+### Caching workloads
+
+For applications using Redis solely as a cache, you can safely let the memory usage
+reach 100% as long as you have an [eviction policy](https://redis.io/blog/cache-eviction-strategies/) in place. This will ensure
+that Redis can evict keys while continuing to accept new writes.
+
+**Note:** Eviction will increase write command latency as Redis has to cleanup the memory/objects before accepting a new write to prevent OOM when memory usage is at 100%.
+
+While your Redis database is using 100% of available memory in a caching context,
+it's still important to monitor performance. The key performance indicators include:
+
+* Latency
+* Cache hit ratio
+* Evicted keys
+
+### Read latency
+
+**Latency** has two important definitions, depending on context:
+
+* In the context of Redis itself, latency is **the time it takes for Redis
+to respond to a request**. The [Latency](#latency) section below provides a broader discussion of this metric.
+
+
+
+* In the context of your application, Latency is **the time it takes for the application
+to process a request**. This will include the time it takes to execute both reads and writes
+to Redis, as well as calls to other databases and services. Note that its possible for
+Redis to report low latency while the application is experiencing high latency.
+This may indicate a low cache hit ratio, ultimately caused by insufficient memory.
+
+You need to monitor both application-level and Redis-level latency to diagnose
+caching performance issues in production.
+
+### Cache hit ratio and eviction
+
+**Cache hit ratio** is the percentage of read requests that Redis serves successfully.
+**Eviction rate** is the rate at which Redis evicts keys from the cache. These metrics
+are sometimes inversely correlated: a high eviction rate may cause a low cache hit ratio if too many frequently-used keys are being evicted.
+
+If the Redis server is empty, the hit ratio will be 0%. As the application runs and the fills the cache,
+the hit ratio will increase.
+
+**When the entire cached working set fits in memory**, the cache hit ratio will reach close to 100%
+while the percent of used memory will remain below 100%.
+
+**When the working set cannot fit in memory**, the eviction policy will start to evict keys.
+It is important to choose a policy that generally evicts rarely-used keys to keep the cache hit ratio as high as possible.
+
+In both cases, keys will may be manually invalidated by the application or evicted through
+the uses of TTLs (time-to-live) and an eviction policy.
+
+The ideal cache hit ratio depends on the application, but generally, the ratio should be greater than 50%.
+Low hit ratios coupled with high numbers of object evictions may indicate that your cache is too small.
+This can cause thrashing on the application side, a scenario where the cache is constantly being invalidated.
+
+This means that when your Redis database is using 100% of available memory, you need
+to measure the rate of
+[key evictions]({{< relref "/operate/rs/references/metrics/database-operations#evicted-objectssec" >}}).
+
+An acceptable rate of key evictions depends on the total number of keys in the database
+and the measure of application-level latency. If application latency is high,
+check to see that key evictions have not increased.
+
+### Eviction policies
+
+| Name | 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 |
+|volatile-lru | Removes least recently used keys with the expire field set to true. |
+|volatile-lfu | Removes least frequently used keys with the expire field set to true. |
+|allkeys-random | Randomly removes keys to make space for the new data added. |
+|volatile-random | Randomly removes keys with expire field set to true. |
+|volatile-ttl | Removes keys with expire field set to true and the shortest remaining time-to-live (TTL) value. |
+
+
+### Eviction policy guidelines
+
+* Use the allkeys-lru policy when you expect a power-law distribution in the popularity of your requests. That is, you expect a subset of elements will be accessed far more often than the rest. This is a good policy to choose if you are unsure.
+
+* Use the allkeys-random if you have a cyclic access where all the keys are scanned continuously, or when you expect the distribution to be uniform.
+
+* Use the volatile-ttl if you want to be able to provide hints to Redis about what are good candidates for expiration by using different TTL values when you create your cache objects.
+
+The volatile-lru and volatile-random policies are mainly useful when you want to use a single instance for both caching and to have a set of persistent keys. However it is usually a better idea to run two Redis instances to solve such a problem.
+
+**Note:** Setting an expire value to a key costs memory, so using a policy like allkeys-lru is more memory efficient because there is no need for an expire configuration for the key to be evicted under memory pressure.
+
+### Non-caching workloads
+
+If no eviction policy is enabled, then Redis will stop accepting writes when memory usage reaches 100%.
+Therefore, for non-caching workloads, it is best practice to configure an alert at 80% memory usage.
+After your database reaches this 80% threshold, you should closely review the rate of memory usage growth.
+
+### Troubleshooting
+
+|Issue | Possible causes | Remediation |
+| ------ | ------ | :------ |
+|Redis memory usage has reached 100% |This may indicate an insufficient Redis memory limit for your application's workload | For non-caching workloads (where eviction is unacceptable), immediately increase the memory limit for the database. You can accomplish this through the Redis Enterprise console or its API. Alternatively, you can contact Redis support to assist. For caching workloads, you need to monitor performance closely. Confirm that you have an [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}) in place. If your application's performance starts to degrade, you may need to increase the memory limit, as described above. |
+|Redis has stopped accepting writes | Memory is at 100% and no eviction policy is in place | Increase the database's total amount of memory. If this is for a caching workload, consider enabling an [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}). In addition, you may want to determine whether the application can set a reasonable TTL (time-to-live) on some or all of the data being written to Redis. |
+|Cache hit ratio is steadily decreasing | The application's working set size may be steadily increasing. Alternatively, the application may be misconfigured (for example, generating more than one unique cache key per cached item.) | If the working set size is increasing, consider increasing the memory limit for the database. If the application is misconfigured, review the application's cache key generation logic. |
+
+
+
+## CPU
+
+Redis Enterprise provides several CPU metrics:
+
+| Metric name | Definition | Unit |
+| ------ | ------ | :------ |
+| Shard CPU | CPU time portion spent by database shards as a percentage | up to 100% per shard |
+| Proxy CPU | CPU time portion spent by the cluster's proxy(s) as a percentage | 100% per proxy thread |
+| Node CPU (User and System) | CPU time portion spent by all user-space and kernel-level processesas a Percentage | 100% per node CPU |
+
+
+To understand CPU metrics, it's worth recalling how a Redis Enterprise cluster is organized.
+A cluster consists of one or more nodes. Each node is a VM (or cloud compute instance) or
+a bare-metal server.
+
+A database is a set of processes, known as shards, deployed across the nodes of a cluster.
+
+In the dashboard, shard CPU is the CPU utilization of the processes that make up the database.
+When diagnosing performance issues, start by looking at shard CPU.
+
+Dashboard displaying CPU usage - [Database Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/database_dashboard_v9-11.json)
+{{< image filename="/images/playbook_database-cpu-shard.png" alt="Dashboard displaying CPU usage" >}}
+
+### Thresholds
+
+In general, we define high CPU as any CPU utilization above 80% of total capacity.
+
+Shard CPU should remain below 80%. Shards are single-threaded, so a shard CPU of 100% means that the shard is fully utilized.
+
+Display showing Proxy CPU usage - [Proxy Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/proxy_dashboard_v9-11.json)
+{{< image filename="/images/playbook_proxy-cpu-usage.png" alt="Display showing Proxy CPU usage" >}}
+
+Proxy CPU should remain below 80% of total capacity.
+The proxy is a multi-threaded process that handles client connections and forwards requests to the appropriate shard.
+Because the total number of proxy threads is configurable, the proxy CPU may exceed 100%.
+A proxy configured with 6 threads can reach 600% CPU utilization, so in this case,
+keeping utilization below 80% means keeping the total proxy CPU usage below 480%.
+
+Dashboard displaying an ensemble of Node CPU usage data - [Node Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/node_dashboard_v9-11.json)
+{{< image filename="/images/node_cpu.png" alt="Dashboard displaying an ensemble of Node CPU usage data" >}}
+
+Node CPU should also remain below 80% of total capacity. As with the proxy, the node CPU is variable depending
+on the CPU capacity of the node. You will need to calibrate your alerting based on the number of cores in your nodes.
+
+### Troubleshooting
+
+High CPU utilization has multiple possible causes. Common causes include an under-provisioned cluster,
+excess inefficient Redis operations, and hot master shards.
+
+
+| Issue | Possible causes | Remediation 
+| ------ | ------ | :------ |
+|High CPU utilization across all shards of a database | This usually indicates that the database is under-provisioned in terms of number of shards. A secondary cause may be that the application is running too many inefficient Redis operations. | You can detect slow Redis operations by enabling the slow log in the Redis Enterprise UI. First, rule out inefficient Redis operations as the cause of the high CPU utilization. The Latency section below includes a broader discussion of this metric in the context of your application. If inefficient Redis operations are not the cause, then increase the number of shards in the database. |
+|High CPU utilization on a single shard, with the remaining shards having low CPU utilization | This usually indicates a master shard with at least one hot key. Hot keys are keys that are accessed extremely frequently (for example, more than 1000 times per second). | Hot key issues generally cannot be resolved by increasing the number of shards. To resolve this issue, see the section on Hot keys below. |
+| High Proxy CPU | There are several possible causes of high proxy CPU. First, review the behavior of connections to the database. Frequent cycling of connections, especially with TLS is enabled, can cause high proxy CPU utilization. This is especially true when you see more than 100 connections per second per thread. Such behavior is almost always a sign of a misbehaving application. Review the total number of operations per second against the cluster. If you see more than 50k operations per second per thread, you may need to increase the number of proxy threads. | In the case of high connection cycling, review the application's connection behavior. In the case of high operations per second, [increase the number of proxy threads]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-proxy" >}}). |
+|High Node CPU | You will typically detect high shard or proxy CPU utilization before you detect high node CPU utilization. Use the remediation steps above to address high shard and proxy CPU utilization. In spite of this, if you see high node CPU utilization, you may need to increase the number of nodes in the cluster. | Consider increasing the number of nodes in the cluster and the rebalancing the shards across the new nodes. This is a complex operation and you should do it with the help of Redis support. |
+|High System CPU | Most of the issues above will reflect user-space CPU utilization. However, if you see high system CPU utilization, this may indicate a problem at the network or storage level. | Review network bytes in and network bytes out to rule out any unexpected spikes in network traffic. You may need perform some deeper network diagnostics to identify the cause of the high system CPU utilization. For example, with high rates of packet loss, you may need to review network configurations or even the network hardware. |
+
+## Connections
+
+The Redis Enterprise database dashboard indicates the total number of connections to the database.
+
+You should monitor this connection count metric with both a minimum and maximum number of connections in mind.
+Based on the number of application instances connecting to Redis (and whether your application uses [connection pooling]({{< relref "/develop/clients/pools-and-muxing" >}})),
+you should have a rough idea of the minimum and maximum number of connections you expect to see for any given database.
+This number should remain relatively constant over time.
+
+### Troubleshooting
+
+| Issue | Possible causes | Remediation |
+| ------ | ------ | :------ |
+|Fewer connections to Redis than expected |The application may not be connecting to the correct Redis database. There may be a network partition between the application and the Redis database. | Confirm that the application can successfully connect to Redis. This may require consulting the application logs or the application's connection configuration. | 
+|Connection count continues to grow over time | Your application may not be releasing connections. The most common of such a connection leak is a manually implemented connection pool or a connection pool that is not properly configured. | Review the application's connection configuration |
+|Erratic connection counts (for example, spikes and drops) | Application misbehavior ([thundering herds](https://en.wikipedia.org/wiki/Thundering_herd_problem), connection cycling, or networking issues) | Review the application logs and network traffic to determine the cause of the erratic connection counts. |
+
+
+Dashboard displaying connections - [Database Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/database_dashboard_v9-11.json)
+{{< image filename="/images/playbook_database-used-connections.png" alt="Dashboard displaying connections" >}}
+
+### Network ingress/egress
+
+The network ingress/egress panel shows the amount of data being sent to and received from the database.
+Large spikes in network traffic can indicate that the cluster is under-provisioned or that
+the application is reading and/or writing unusually [large keys](#large-keys). A correlation between high network traffic
+and high CPU utilization may indicate a large key scenario.
+
+#### Unbalanced database endpoint
+
+One possible cause of network traffic spikes is that the database endpoint is not located on the same node as the master shards. In addition to added network latency, if data plane internode encryption is enabled, CPU consumption can increase as well.
+
+One solution is to use the optimal shard placement and proxy policy to ensure endpoints are collocated on nodes hosting master shards. If you need to restore balance (for example, after node failure) you can manually failover shard(s) with the `rladmin` cli tool.
+
+Extreme network traffic utilization may approach the limits of the underlying network infrastructure.
+In this case, the only remediation is to add more nodes to the cluster and scale the database's shards across them.
+
+## Synchronization
+
+In Redis Enterprise, geographically-distributed synchronization is based on Conflict-free replicated data types (CRDT) technology.
+The Redis Enterprise implementation of CRDT is called an Active-Active database (formerly known as CRDB).
+With Active-Active databases, applications can read and write to the same data set from different geographical locations seamlessly and with low latency, without changing the way the application connects to the database.
+
+An Active-Active architecture is a data resiliency architecture that distributes the database information over multiple data centers using independent and geographically distributed clusters and nodes.
+It is a network of separate processing nodes, each having access to a common replicated database such that all nodes can participate in a common application ensuring local low latency with each region being able to run in isolation.
+
+To achieve consistency between participating clusters, Redis Active-Active synchronization uses a process called the syncer.
+
+The syncer keeps a replication backlog, which stores changes to the dataset that the syncer sends to other participating clusters.
+The syncer uses partial syncs to keep replicas up to date with changes, or a full sync in the event a replica or primary is lost.
+
+Dashboard displaying connection metrics between zones - [Synchronization Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/synchronization_dashboard_v9-11.json)
+{{< image filename="/images/playbook_network-connectivity.png" alt="Dashboard displaying connection metrics between zones" >}}
+
+CRDT provides three fundamental benefits over other geo-distributed solutions:
+
+* It offers local latency on read and write operations, regardless of the number of geo-replicated regions and their distance from each other.
+* It enables seamless conflict resolution (“conflict-free”) for simple and complex data types like those of Redis core.
+* Even if most of the geo-replicated regions in a CRDT database (for example, 3 out of 5) are down, the remaining geo-replicated regions are uninterrupted and can continue to handle read and write operations, ensuring business continuity.
+
+## Database performance indicators
+
+There are several key performance indicators that report your database's performance against your application's workload:
+
+* Latency
+* Cache hit rate
+* Key eviction rate
+
+### Latency
+
+Latency is **the time it takes for Redis to respond to a request**.
+Redis Enterprise measures latency from the first byte received by the proxy to the last byte sent in the command's response.
+
+An adequately provisioned Redis database running efficient Redis operations will report an average latency below 1 millisecond. In fact, it's common to measure
+latency in terms of microseconds. Businesses regularly achieve, and sometimes require, average latencies of 400-600
+microseconds.
+
+Dashboard display of latency metrics - [Database Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/database_dashboard_v9-11.json)
+{{< image filename="/images/playbook_database-cluster-latency.png" alt="Dashboard display of latency metrics" >}}
+
+The metrics distinguish between read and write latency. Understanding whether high latency is due
+to read or writes can help you to isolate the underlying issue.
+
+Note that these latency metrics do not include network round trip time or application-level serialization,
+which is why it's essential to measure request latency at the application, as well.
+
+Display showing a noticeable spike in latency
+{{< image filename="/images/latency_spike.png" alt="Display showing a noticeable spike in latency" >}}
+
+### Troubleshooting
+
+Here are some possible causes of high database latency. Note that high database latency is just one of the reasons
+why application latency might be high. Application latency can be caused by a variety of factors, including
+a low cache hit rate.
+
+| Issue | Possible causes | Remediation |
+| ------ | ------ | :------ |
+|Slow database operations | Confirm that there are no excessive slow operations in the Redis slow log. | If possible, reduce the number of slow operations being sent to the database. <br/>If this not possible, consider increasing the number of shards in the database. |
+|Increased traffic to the database | Review the network traffic and the database operations per second chart to determine if increased traffic is causing the latency. | If the database is underprovisioned due to increased traffic, consider increasing the number of shards in the database. |
+|Insufficient CPU | Check to see if the CPU utilization is increasing. | Confirm that slow operations are not causing the high CPU utilization. If the high CPU utilization is due to increased load, consider adding shards to the database. |
+
+## Cache hit rate
+
+**Cache hit rate** is the percentage of all read operations that return a response. **Note:** Cache hit rate is a composite statistic that is computed by dividing the number of read hits by the total number of read operations.
+When an application tries to read a key that exists, this is known as a **cache hit**.
+Alternatively, when an application tries to read a key that does not exist, this is knows as a **cache miss**.
+
+For caching workloads, the cache hit rate should generally be above 50%, although
+the exact ideal cache hit rate can vary greatly depending on the application and depending on whether the cache
+is already populated.
+
+Dashboard showing the cache hit ratio along with read/write misses - [Database Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/database_dashboard_v9-11.json)
+{{< image filename="/images/playbook_cache-hit.png" alt="Dashboard showing the cache hit ratio along with read/write misses" >}}
+
+**Note:** Redis Enterprise actually reports four different cache hit / miss metrics.
+These are defined as follows:
+
+| Metric name | Definition | 
+| ------ | :------ |
+| bdb_read_hits | The number of successful read operations |
+| bdb_read_misses | The number of read operations returning null |
+| bdb_write_hits | The number of write operations against existing keys |
+| bdb_write_misses | The number of write operations that create new keys |
+
+### Troubleshooting
+
+Cache hit rate is usually only relevant for caching workloads. Eviction will begin after the database approaches its maximum memory capacity.
+
+A high or increasing rate of evictions will negatively affect database latency, especially
+if the rate of necessary key evictions exceeds the rate of new key insertions.
+
+See the [Cache hit ratio and eviction](#cache-hit-ratio-and-eviction) section for tips on troubleshooting cache hit rate.
+
+## Key eviction rate
+
+They **key eviction rate** is rate at which objects are being evicted from the database.
+See [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}) for a discussion of key eviction and its relationship with memory usage.
+
+Dashboard displaying object evictions - [Database Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/classic/database_dashboard_v9-11.json)
+{{< image filename="/images/playbook_eviction-expiration.png" alt="Dashboard displaying object evictions">}}
+
+## Proxy performance
+
+Redis Enterprise Software provides high-performance data access through a proxy process that manages and optimizes access to shards within the 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
+
+
+| Policy | Description |
+| ------ | :------ |
+|Single | There is only a single proxy that is bound to the database. This is the default database configuration and preferable in most use cases. |
+|All Master Shards | There are multiple proxies that are bound to the database, one on each node that hosts a database master shard. This mode fits most use cases that require multiple proxies. |
+|All Nodes | There are multiple proxies that are bound to the database, one on each node in the cluster, regardless of whether or not there is a shard from this database on the node. This mode should be used only in special cases, such as using a load balancer. |
+
+Dashboard displaying proxy thread activity - [Proxy Thread Dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/cloud/basic/redis-cloud-proxy-dashboard_v9-11.json)
+{{< image filename="/images/proxy-thread-dashboard.png" alt="Dashboard displaying proxy thread activity" >}}
+
+If you need to, you can tune the number of proxy threads using the [`rladmin tune proxy`]({{< relref "/operate/rs/references/cli-utilities/rladmin/tune#tune-proxy" >}}) command to make the proxy use more CPU cores.
+Cores used by the proxy won't be available for Redis, therefore we need to take into account the number of Redis nodes on the host and the total number of available cores.
+
+The command has a few parameters you can use to set a new number of proxy cores:
+
+* `id|all` - you can either tune a specific proxy by its id, or all proxies.
+
+* `mode` - determines whether or not the proxy can automatically adjust the number of threads depending on load.
+
+* `threads` and `max_threads` - determine the initial number of threads created on startup, and the maximum number of threads allowed.
+
+* `scale_threshold` - determines the CPU utilization threshold that triggers spawning new threads. This CPU utilization level needs to be maintained for at least scale_duration seconds before automatic scaling is performed.
+
+The following table indicates ideal proxy thread counts for the specified environments.
+
+
+| Total Cores | Redis (ROR) | Redis on Flash (ROF) |
+| ------ | ------ | :------ |
+|1|1|1 |
+|4|3|3 |
+|8|5|3 |
+|12|8|4 |
+|16|10|5 |
+|32|24|10 |
+|64/96|32|20 |
+|128|32|32 |
+
+
+## Data access anti-patterns
+
+There are three data access patterns that can limit the performance of your Redis database:
+
+* Slow operations
+* Hot keys
+* Large keys
+
+This section defines each of these patterns and describes how to diagnose and mitigate them.
+
+## Slow operations
+
+**Slow operations** are operations that take longer than a few milliseconds to complete.
+
+Not all Redis operations are equally efficient.
+The most efficient Redis operations are O(1) operations; that is, they have a constant time complexity.
+Example of such operations include [GET]({{< relref "/commands/get" >}}),
+[SET]({{< relref "/commands/set" >}}), [SADD]({{< relref "/commands/sadd" >}}),
+and [HSET]({{< relref "/commands/hset" >}}).
+
+These constant time operations are unlikely to cause high CPU utilization. **Note:** Even so,
+it's still possible for a high rate of constant time operations to overwhelm an underprovisioned database.
+
+Other Redis operations exhibit greater levels of time complexity.
+O(n) (linear time) operations are more likely to cause high CPU utilization.
+Examples include [HGETALL]({{< relref "/commands/hgetall" >}}), [SMEMBERS]({{< relref "/commands/smembers" >}}),
+and [LREM]({{< relref "/commands/lrem" >}}).
+These operations are not necessarily problematic, but they can be if executed against data structures holding
+a large number of elements (for example, a list with 1 million elements).
+
+However, the [KEYS]({{< relref "/commands/keys" >}}) command should almost never be run against a
+production system, since returning a list of all keys in a large Redis database can cause significant slowdowns
+and block other operations. If you need to scan the keyspace, especially in a production cluster, always use the
+[SCAN]({{< relref "/commands/scan" >}}) command instead.
+
+### Troubleshooting
+
+The best way to discover slow operations is to view the slow log.
+The slow log is available in the Redis Enterprise and Redis Cloud consoles:
+* [Redis Enterprise slow log docs]({{< relref "/operate/rs/clusters/logging/redis-slow-log" >}})
+* [Redis Cloud slow log docs]({{< relref "/operate/rc/databases/view-edit-database#other-actions-and-info" >}})
+
+Redis Cloud dashboard showing slow database operations
+{{< image filename="/images/slow_log.png" alt="Redis Cloud dashboard showing slow database operations" >}}
+
+| Issue | Remediation |
+| ------ | :------ |
+|The KEYS command shows up in the slow log |Find the application that issues the KEYS command and replace it with a SCAN command. In an emergency situation, you can [alter the ACLs for the database user]({{< relref "/operate/rs/security/access-control/redis-acl-overview" >}}) so that Redis will reject the KEYS command altogether. |
+|The slow log shows a significant number of slow, O(n) operations | If these operations are being issued against large data structures, then the application may need to be refactored to use more efficient Redis commands. |
+|The slow logs contains only O(1) commands, and these commands are taking several milliseconds or more to complete |This likely indicates that the database is underprovisioned. Consider increasing the number of shards and/or nodes. |
+
+
+## Hot keys
+
+A **hot key** is a key that is accessed extremely frequently (for example, thousands of times a second or more).
+
+Each key in Redis belongs to one, and only one, shard.
+For this reason, a hot key can cause high CPU utilization on that one shard,
+which can increase latency for all other operations.
+
+### Troubleshooting
+
+You may suspect that you have a hot key if you see high CPU utilization on a single shard.
+There are two main way to identify hot keys: using the Redis CLI and sampling the operations against Redis.
+
+To use the Redis CLI to identify hot keys:
+
+1. First confirm that you have enough available memory to enable an eviction policy.
+2. Next, enable the LFU (least-frequently used) eviction policy on the database.
+3. Finally, run `redis-cli --hotkeys`
+
+You may also identify hot keys by sampling the operations against Redis.
+You can use do this by running the [MONITOR]({{< relref "/commands/monitor" >}}) command
+against the high CPU shard. Because this is a potentially high-impact operation, you should only
+use this technique as a secondary option. For mission-critical databases, consider
+contacting Redis support for assistance.
+
+### Remediation
+
+After you discover a hot key, you need to find a way to reduce the number of operations against it.
+This means getting an understanding of the application's access pattern and the reasons for such frequent access.
+
+If the hot key operations are read-only, consider implementing an application-local cache so
+that fewer read requests are sent to Redis. For example, even a local cache that expires every 5 seconds
+can entirely eliminate a hot key issue.
+
+## Large keys
+
+**Large keys** are keys that are hundreds of kilobytes or larger.
+High network traffic and high CPU utilization can be caused by large keys.
+
+### Troubleshooting
+
+To identify large keys, you can sample the keyspace using the Redis CLI.
+
+Run `redis-cli --memkeys` against your database to sample the keyspace in real time
+and potentially identify the largest keys in your database.
+
+### Remediation
+
+Addressing a large key issue requires understanding why the application is creating large keys in the first place.
+As such, it's difficult to provide general advice to solving this issue. Resolution often requires a change
+to the application's data model or the way it interacts with Redis.
+
+## Alerting
+
+The Redis Enterprise observability package includes [a suite of alerts and their associated tests for use with Prometheus](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana#alerts). **Note:** Not all the alerts are appropriate for all environments; for example, installations that do not use persistence have no need for storage alerts.
+
+The alerts are packaged with [a series of tests](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/tests)
+that validate the individual triggers. You can use these tests to validate your modifications to these alerts for specific environments and use cases.
+
+To use these alerts, install [Prometheus Alertmanager](https://prometheus.io/docs/alerting/latest/configuration/).
+For a comprehensive guide to alerting with Prometheus and Grafana,
+see the [Grafana blog post on the subject](https://grafana.com/blog/2020/02/25/step-by-step-guide-to-setting-up-prometheus-alertmanager-with-slack-pagerduty-and-gmail/).
+
+## Configure Prometheus
+
+To configure Prometheus for alerting, open the `prometheus.yml` configuration file.
+
+Uncomment the `Alertmanager` section of the file.
+The following configuration starts Alertmanager and instructs it to listen on its default port of 9093.
+
+```
+# Alertmanager configuration
+alerting:
+  alertmanagers:
+    - static_configs:
+        - targets:
+          - alertmanager:9093
+```
+
+The Rule file section of the config file instructs Alertmanager to read specific rules files.
+If you pasted the `alerts.yml` file into `/etc/prometheus` then the following configuration would be required.
+
+```
+# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
+rule_files:
+  - "error_rules.yml"
+  - "alerts.yml"
+```
+
+After you've done this, restart Prometheus.
+
+The built-in configuration, `error_rules.yml`, has a single alert: Critical Connection Exception.
+If you open the Prometheus console, by default located at port 9090, and select the Alert tab,
+you will see this alert, as well as the alerts in any other file you have included as a rules file.
+
+{{< image filename="/images/playbook_prometheus-alerts.png" alt="prometheus alerts image" >}}
+
+The following is a list of alerts contained in the `alerts.yml` file. There are several points to consider:
+
+- Not all Redis Enterprise deployments export all metrics
+- Most metrics only alert if the specified trigger persists for a given duration
+
+## List of alerts
+
+| Description | Trigger |
+| ------ | :------ |
+|Average latency has reached a warning level | round(bdb_avg_latency * 1000) > 1 |
+|Average latency has reached a critical level indicating system degradation | round(bdb_avg_latency * 1000) > 4 |
+|Absence of any connection indicates improper configuration or firewall issue | bdb_conns < 1 |
+|A flood of connections has occurred that will impact normal operations | bdb_conns > 64000 |
+|Absence of any requests indicates improperly configured clients | bdb_total_req < 1 |
+|Excessive number of client requests indicates configuration and/or programmatic issues | bdb_total_req > 1000000 |
+|The database in question will soon be unable to accept new data | round((bdb_used_memory/bdb_memory_limit) * 100) > 98 |
+|The database in question will be unable to accept new data in two hours | round((bdb_used_memory/bdb_memory_limit) ** 100) < 98 and (predict_linear(bdb_used_memory[15m], 2 ** 3600) / bdb_memory_limit) > 0.3 and round(predict_linear(bdb_used_memory[15m], 2 * 3600)/bdb_memory_limit) > 0.98 |
+|Database read operations are failing to find entries more than 50% of the time | (100 * bdb_read_hits)/(bdb_read_hits + bdb_read_misses) < 50 |
+|In situations where TTL values are not set this indicates a problem | bdb_evicted_objects > 1 |
+|Replication between nodes is not in a satisfactory state | bdb_replicaof_syncer_status > 0 |
+|Record synchronization between nodes is not in a satisfactory state | bdb_crdt_syncer_status > 0 |
+|The amount by which replication lags behind events is worrisome | bdb_replicaof_syncer_local_ingress_lag_time > 500 |
+|The amount by which object replication lags behind events is worrisome | bdb_crdt_syncer_local_ingress_lag_time > 500 |
+|The number of active nodes is less than expected | count(node_up) != 3 |
+|Persistent storage will soon be exhausted | round((node_persistent_storage_free/node_persistent_storage_avail) * 100) <= 5 |
+|Ephemeral storage will soon be exhausted | round((node_ephemeral_storage_free/node_ephemeral_storage_avail) * 100) <= 5 |
+|The node in question is close to running out of memory | round((node_available_memory/node_free_memory) * 100) <= 15 |
+|The node in question has exceeded expected levels of CPU usage | round((1 - node_cpu_idle) * 100) >= 80 |
+|The shard in question is not reachable | redis_up == 0 |
+|The master shard is not reachable | floor(redis_master_link_status{role="slave"}) < 1 |
+|The shard in question has exceeded expected levels of CPU usage | redis_process_cpu_usage_percent >= 80 |
+|The master shard has exceeded expected levels of CPU usage | redis_process_cpu_usage_percent{role="master"} > 0.75 and redis_process_cpu_usage_percent{role="master"} > on (bdb) group_left() (avg by (bdb)(redis_process_cpu_usage_percent{role="master"}) + on(bdb) 1.2 * stddev by (bdb) (redis_process_cpu_usage_percent{role="master"})) |
+|The shard in question has an unhealthily high level of connections | redis_connected_clients > 500 |
+
+## Appendix A: Grafana Dashboards
+
+Grafana dashboards are available for Redis Enterprise Software and Redis Cloud deployments.
+
+These dashboards come in three styles, which may be used together to provide
+a full picture of your deployment.
+
+1. Classic dashboards provide detailed information about the cluster, nodes, and individual databases.
+2. Basic dashboards provide a high-level overviews of the various cluster components.
+3. Extended dashboards. These require a third-party library to perform ReST calls.
+
+There are also two workflow dashboards for Redis Enterprise software that provide drill-down functionality.
+
+### Software
+- [Basic](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/software/basic)
+- [Extended](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/software/extended)
+- [Classic](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/software/classic)
+
+### Workflow
+- [Database](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/workflow/databases)
+- [Node](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/workflow/nodes)
+
+### Cloud
+- [Basic](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/cloud/basic)
+- [Extended](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana/dashboards/grafana_v9-11/cloud/extended)
+
+**Note:** - The 'workflow' dashboards are intended to be used as a package. Therefore they should all be installed, as they contain links to the other dashboards in the group permitting rapid navigation between the overview and the drill-down views.
+By default, Redis Enterprise Software deployments use DNS to communicate between nodes.  You can also use the [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}}), which uses IP addresses to connect and complies with the [Redis Sentinel API]({{< relref "/operate/oss_and_stack/management/sentinel" >}}) supported by Redis Open Source.
+
+Each node in a Redis Enterprise cluster includes a small DNS server to manage internal functions, such as high availability, automatic failover, automatic migration, and so on.
+Nodes should only run the DNS server included with the software.  Running additional DNS servers can lead to unexpected behavior.
+
+## Cluster name and connection management
+
+Whether you're administering Redis Enterprise Software or accessing databases, there are two ways to connect:
+
+- URL-based connections - URL-based connections use DNS to resolve the fully qualified cluster domain name (FQDN).  This means that DNS records might need to be updated when topology changes, such as adding (or removing) nodes from the cluster.  
+
+    Because apps and other clients connections rely on the URL (rather than the address), they do not need to be modified when topology changes.  
+
+- IP-based connections - IP-based connections do not require DNS setup, as they rely on the underlying TCP/IP addresses.  As long as topology changes do not change the address of the cluster nodes, no configuration changes are needed, DNS or otherwise.  
+
+    However, changes to IP addresses (or changes to IP address access) impact all connections to the node, including apps and clients.  IP address changes can therefore be unpredictable or time-consuming.
+
+## URL-based connections
+
+The fully qualified domain name (FQDN) is the unique cluster identifier that enables clients to connect to the different components of Redis Enterprise Software.
+The FQDN is a crucial component of the high-availability mechanism because it's used internally to enable and implement automatic and transparent failover of nodes, databases shards, and endpoints.
+
+{{< note >}}
+Setting the cluster's FQDN is a one-time operation, one that cannot be changed after being set.
+{{< /note >}}
+
+The FQDN must always comply with the IETF's [RFC 952](https://datatracker.ietf.org/doc/html/rfc952) standard
+and section 2.1 of the [RFC 1123](https://datatracker.ietf.org/doc/html/rfc1123) standard.
+
+## Identify the cluster
+
+To identify the cluster, either use DNS to define a fully qualified domain name or use the IP addresses of each node.  
+
+### Define domain using DNS
+
+Use DNS if you:
+
+- have your own domain
+- want to integrate the cluster into that domain
+- can access and update the DNS records for that domain
+
+1. Make sure that the cluster and at least one node (preferably all nodes) in the cluster
+    are correctly configured in the DNS with the appropriate NS entries.
+
+    For example:
+
+    - Your domain is: `mydomain.com`
+    - You would like to name the Redis Enterprise Software cluster `mycluster`
+    - You have three nodes in the cluster:
+        - node1 (IP address 1.1.1.1)
+        - node2 (2.2.2.2)
+        - node3 (3.3.3.3)
+
+1. In the FQDN field, enter the value `mycluster.mydomain.com`
+    and add the following records in the DNS table for `mydomain.com`:
+
+    ``` sh
+    mycluster.mydomain.com        NS  node1.mycluster.mydomain.com
+                                      node2.mycluster.mydomain.com
+                                      node3.mycluster.mydomain.com 
+    
+    node1.mycluster.mydomain.com  A   1.1.1.1
+    
+    node2.mycluster.mydomain.com  A   2.2.2.2
+    
+    node3.mycluster.mydomain.com  A   3.3.3.3
+    ```
+
+### Zero-configuration using mDNS {#zeroconfiguration-using-mdns-development-option-only}
+
+Development and test environments can use [Multicast DNS](https://en.wikipedia.org/wiki/Multicast_DNS) (mDNS), a zero-configuration service designed for small networks.  Production environments should _not_ use mDNS.
+
+mDNS is a standard protocol that provides DNS-like name resolution and service discovery capabilities
+to machines on local networks with minimal to no configuration.
+
+Before adopting mDNS, verify that it's supported by each client you wish to use to connect to your Redis databases.  Also make sure that your network infrastructure permits mDNS/multi-casting between clients and cluster nodes.
+
+Configuring the cluster to support mDNS requires you to assign the cluster a `.local` name.
+
+For example, if you want to name the Redis Enterprise Software cluster `rediscluster`, specify the FQDN name as `rediscluster.local`.
+
+When using the DNS or mDNS option, failover can be done transparently and the DNS is updated automatically to point to the IP address of the new primary node.
+
+## IP-based connections
+
+When you use the IP-based connection option, the FQDN does not need to have any special format
+because clients use IP addresses instead of hostnames to access the databases so you are free to choose whatever name you want.
+Using the IP-based connection option does not require any DNS configuration either.
+
+To administer the cluster you do need to know the IP address of at least one of the nodes in the cluster.
+Once you have the IP address, you can simply connect to port number 8443 (for example: <https://10.0.0.12:8443>).
+However, as the topology of the cluster changes and node with the given IP address is removed,
+you need to remember the IP address of another node participating in this cluster to connect to the admin console and manage the cluster.
+
+Applications connecting to Redis Software databases have the same constraints.
+When using the IP-based connection method, you can use the [Discovery Service]({{< relref "/operate/rs/databases/durability-ha/discovery-service" >}})
+to discover the database endpoint for a given database name as long as you have an IP address for at least one of the nodes in the cluster.
+The API used for discovery service is compliant with the Redis Sentinel API.
+
+To test your connection, try pinging the service.  For help, see [Connect to your database]({{< relref "/operate/rs/databases/connect/test-client-connectivity" >}}).
+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:
+
+| Item | Description | Minimum requirements | Recommended |
+|------------|-----------------|------------|-----------------|
+| Nodes per cluster | You can install on one node but many features require at least two nodes. | 1 node | >= 2 nodes |
+| RAM per node | The amount of RAM for each node. | 4GB | >= 10GB |
+| Storage per node | The amount of storage space for each node. | 10GB | >= 20GB |
+
+## Production environment
+
+We recommend these hardware requirements for production systems or for development systems that are designed to demonstrate production use cases:
+
+| Item | Description | Minimum requirements | Recommended |
+|------------|-----------------|------------|-----------------|
+| Nodes<sup>[1](#table-note-1)</sup> per cluster | At least three nodes are required to support a reliable, highly available deployment that handles process failure, node failure, and network split events in a consistent manner. | 3 nodes | >= 3 nodes (Must be an odd number of nodes) |
+| Cores<sup>[2](#table-note-2)</sup> per node | Redis Enterprise Software is based on a multi-tenant architecture and can run multiple Redis processes (or shards) on the same core without significant performance degradation. | 2 cores | >=8 cores |
+| RAM<sup>[3](#table-note-3)</sup> per node | Defining your RAM size must be part of the capacity planning for your Redis usage. | 8GB | >=32GB |
+| Ephemeral storage | Used for storing [replication files (RDB format) and cluster log files]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}). | RAM x 2 | >= RAM x 4 |
+| Persistent storage<sup>[4](#table-note-4)</sup> | Used for storing [snapshot (RDB format) and AOF files]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) over a persistent storage media, such as AWS Elastic Block Storage (EBS) or Azure Data Disk. | RAM x 3 | In-memory >= RAM x 4 (except for [extreme 'write' scenarios]({{< relref "/operate/rs/clusters/optimize/disk-sizing-heavy-write-scenarios" >}}))<br /><br /> [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) >= (RAM + Flash) x 4. |
+| Network<sup>[5](#table-note-5)</sup> | We recommend using multiple NICs per node where each NIC is >1Gbps, but Redis Enterprise Software can also run over a single 1Gbps interface network used for processing application requests, inter-cluster communication, and storage access. | 1G | >=10G |
+| Local disk for [Auto Tiering]({{< relref "/operate/rs/databases/auto-tiering/" >}}) | used to to extend databases DRAM capacity with solid state drives (SSDs). Flash memory must be locally attached. [Read more]({{< relref "/operate/rs/databases/auto-tiering/" >}}) | (RAM+Flash) x 1.6 | (RAM+Flash) x 2.5 |
+
+
+Additional considerations:
+
+1. <a name="table-note-1"></a>Nodes per cluster:
+
+    - Clusters with more than 35 nodes are not supported. Please contact the Redis support team for assistance if your sizing calls for deploying a larger number of nodes.
+
+    - Quorum nodes also must comply with the above minimal hardware requirements.
+    
+    - To ensure synchronization and consistency, Active-Active deployments with three-node clusters should not use quorum nodes. Because quorum nodes do not store data shards, they cannot support replication. In case of a node failure, replica shards aren't available for Active-Active synchronization.
+
+2. <a name="table-note-2"></a>Cores:
+
+    - When the CPU load reaches a certain level, Redis Enterprise Software sends an alert to the operator.  
+
+    - If your application is designed to put a lot of load on your Redis database, make sure that you have at least one available core for each shard of your database.
+
+    - If some of the cluster nodes are utilizing more than 80% of the CPU, consider migrating busy resources to less busy nodes.
+
+    - If all the cluster nodes are utilizing over 80% of the CPU, highly consider scaling out the cluster by [adding a node]({{< relref "/operate/rs/clusters/add-node" >}}).
+
+3. <a name="table-note-3"></a> RAM:
+
+    - Redis uses a relatively large number of buffers, which enable replica communication, client communication, pub/sub commands, and more.  As a result, you should ensure that 30% of the RAM is available on each node at any given time.
+
+    - If one or more cluster nodes utilizes more than 65% of the RAM, consider migrating resources to less active nodes.
+
+    - If all cluster nodes are utilizing more than 70% of available RAM, highly consider [adding a node]({{< relref "/operate/rs/clusters/add-node" >}}).
+
+    - Do not run any other memory-intensive processes on the Redis Enterprise Software node.
+
+4. <a name="table-note-4"></a>Persistent storage:
+
+    - If no databases on the cluster have [persistence]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}) enabled, minimum persistent storage is RAM x 1.1 and the recommended persistent storage is RAM x 2. Persistent storage is essential because Redis Enterprise also uses it to maintain the cluster and database health, configurations, recovery procedures, and more.
+  
+5. <a name="table-note-5"></a>Network:
+
+    - Only static IP addresses are supported to ensure nodes remain part of the cluster after a reboot.
+
+
+You can use Prometheus and Grafana to collect and visualize your Redis Enterprise Software metrics.
+
+Metrics are exposed at the cluster, node, database, shard, and proxy levels.
+
+
+- [Prometheus](https://prometheus.io/) is an open source systems monitoring and alerting toolkit that aggregates metrics from different sources.
+- [Grafana](https://grafana.com/) is an open source metrics visualization tool that processes Prometheus data.
+
+You can use Prometheus and Grafana to:
+- Collect and display metrics not available in the admin console
+
+- Set up automatic alerts for node or cluster events
+
+- Display Redis Enterprise Software metrics alongside data from other systems
+
+{{<image filename="images/rs/grafana-prometheus.png" alt="Graphic showing how Prometheus and Grafana collect and display data from a Redis Enterprise Cluster. Prometheus collects metrics from the Redis Enterprise cluster, and Grafana queries those metrics for visualization.">}}
+
+In each cluster, the metrics_exporter process exposes Prometheus metrics on port 8070.
+Redis Enterprise version 7.8.2 introduces a preview of the new metrics stream engine that exposes the v2 Prometheus scraping endpoint at `https://<IP>:8070/v2`.
+
+## Quick start
+
+To get started with Prometheus and Grafana:
+
+1. Create a directory called 'prometheus' on your local machine.
+
+1. Within that directory, create a configuration file called `prometheus.yml`.
+1. Add the following contents to the configuration file and replace `<cluster_name>` with your Redis Enterprise cluster's FQDN:
+
+    {{< note >}}
+
+We recommend running Prometheus in Docker only for development and testing.
+
+    {{< /note >}}
+
+    ```yml
+    global:
+      scrape_interval: 15s
+      evaluation_interval: 15s
+
+    # Attach these labels to any time series or alerts when communicating with
+    # external systems (federation, remote storage, Alertmanager).
+      external_labels:
+        monitor: "prometheus-stack-monitor"
+
+    # Load and evaluate rules in this file every 'evaluation_interval' seconds.
+    #rule_files:
+    # - "first.rules"
+    # - "second.rules"
+
+    scrape_configs:
+    # scrape Prometheus itself
+      - job_name: prometheus
+        scrape_interval: 10s
+        scrape_timeout: 5s
+        static_configs:
+          - targets: ["localhost:9090"]
+
+    # scrape Redis Enterprise
+      - job_name: redis-enterprise
+        scrape_interval: 30s
+        scrape_timeout: 30s
+        metrics_path: /  # For v2, use /v2
+        scheme: https
+        tls_config:
+          insecure_skip_verify: true
+        static_configs:
+          - targets: ["<cluster_name>:8070"]
+    ```
+
+1. Set up your Prometheus and Grafana servers.
+    To set up Prometheus and Grafana on Docker:
+    1. Create a _docker-compose.yml_ file:
+
+        ```yml
+        version: '3'
+        services:
+            prometheus-server:
+                image: prom/prometheus
+                ports:
+                    - 9090:9090
+                volumes:
+                    - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
+
+            grafana-ui:
+                image: grafana/grafana
+                ports:
+                    - 3000:3000
+                environment:
+                    - GF_SECURITY_ADMIN_PASSWORD=secret
+                links:
+                    - prometheus-server:prometheus
+        ```
+
+    1. To start the containers, run:
+
+        ```sh
+        $ docker compose up -d
+        ```
+
+    1. To check that all of the containers are up, run: `docker ps`
+    1. In your browser, sign in to Prometheus at http://localhost:9090 to make sure the server is running.
+    1. Select **Status** and then **Targets** to check that Prometheus is collecting data from your Redis Enterprise cluster.
+
+        {{<image filename="images/rs/prometheus-target.png" alt="The Redis Enterprise target showing that Prometheus is connected to the Redis Enterprise Cluster.">}}
+
+        If Prometheus is connected to the cluster, you can type **node_up** in the Expression field on the Prometheus home page to see the cluster metrics.
+
+1. Configure the Grafana datasource:
+    1. Sign in to Grafana. If you installed Grafana locally, go to http://localhost:3000 and sign in with:
+
+        - Username: admin
+        - Password: secret
+
+    1. In the Grafana configuration menu, select **Data Sources**.
+
+    1. Select **Add data source**.
+
+    1. Select **Prometheus** from the list of data source types.
+
+        {{<image filename="images/rs/prometheus-datasource.png" alt="The Prometheus data source in the list of data sources on Grafana.">}}
+
+    1. Enter the Prometheus configuration information:
+
+        - Name: `redis-enterprise`
+        - URL: `http://<your prometheus server name>:9090`
+
+        {{<image filename="images/rs/prometheus-connection.png" alt="The Prometheus connection form in Grafana.">}}
+
+    {{< note >}}
+
+- If the network port is not accessible to the Grafana server, select the **Browser** option from the Access menu.
+- In a testing environment, you can select **Skip TLS verification**.
+
+    {{< /note >}}
+
+1. Add dashboards for cluster, database, node, and shard metrics.
+    To add preconfigured dashboards:
+    1. In the Grafana dashboards menu, select **Manage**.
+    1. Click **Import**.
+    1. Upload one or more [Grafana dashboards](#grafana-dashboards-for-redis-enterprise).
+
+### Grafana dashboards for Redis Enterprise
+
+Redis publishes four preconfigured dashboards for Redis Enterprise and Grafana:
+
+* The [cluster status dashboard](https://grafana.com/grafana/dashboards/18405-cluster-status-dashboard/) provides an overview of your Redis Enterprise clusters.
+* The [database status dashboard](https://grafana.com/grafana/dashboards/18408-database-status-dashboard/) displays specific database metrics, including latency, memory usage, ops/second, and key count.
+* The [node metrics dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/basic/redis-software-node-dashboard_v9-11.json) provides metrics for each of the nodes hosting your cluster.
+* The [shard metrics dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/basic/redis-software-shard-dashboard_v9-11.json) displays metrics for the individual Redis processes running on your cluster nodes
+* The [Active-Active dashboard](https://github.com/redis-field-engineering/redis-enterprise-observability/blob/main/grafana/dashboards/grafana_v9-11/software/basic/redis-software-active-active-dashboard_v9-11.json) displays metrics specific to [Active-Active databases]({{< relref "/operate/rs/databases/active-active" >}}).
+
+These dashboards are open source. For additional dashboard options, or to file an issue, see the [Redis Enterprise observability Github repository](https://github.com/redis-field-engineering/redis-enterprise-observability/tree/main/grafana).
+
+For more information about configuring Grafana dashboards, see the [Grafana documentation](https://grafana.com/docs/).
+---
+{}
+---
+Applying ACLs to the database is an asynchronous operation. You may notice a delay before an ACL is fully applied to the database. ### Redis 7.0 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.
+
+To check your Redis database version (`redis_version`), you can use the admin console or run the [`INFO`]({{< relref "/commands/info" >}}) command with [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+Open source Redis version 7.0 introduces the following potentially breaking changes to Redis Enterprise:
+
+#### Programmability
+
+-  Lua scripts no longer have access to the `print()` function ([#10651](https://github.com/redis/redis/pull/10651)) - The `print`  function was removed from Lua because it can potentially cause the Redis processes to get stuck (if no one reads from stdout). Users should use redis.log. An alternative is to override the  `print`  implementation and print the message to the log file.  
+
+- Block [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) and [`PUBLISH`]({{< relref "/commands/publish" >}}) in read-only scripts (*_RO commands,  `no-writes`) ([#10744](https://github.com/redis/redis/pull/10744)) - Consider `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`; meaning:
+  - They can never be used in scripts with shebang (`#!`) and no `no-writes` flag
+  - They are blocked in `EVAL_RO` and `_RO` variants, (even in scripts without shebang (`#!`) flags)
+  - Allow `no-write` scripts in EVAL (not just in EVAL_RO), even during `CLIENT PAUSE WRITE` 
+
+- Hide the `may_replicate` flag from the [`COMMAND`]({{< relref "/commands/command" >}}) command response  ([#10744](https://github.com/redis/redis/pull/10744)) - As part of the change to treat `may_replicate` commands `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`, the `may_replicate` flag has been removed from the `COMMAND` response.
+
+#### Error handling
+
+- Rephrased some error responses about invalid commands or arguments ([#10612](https://github.com/redis/redis/pull/10612)) - 
+  - Error response for unknown command introduced a case change (`Unknown` to `unknown`)
+  - Errors for module commands extended to cover subcommands, updated syntax to match Redis Server syntax
+  - Arity errors for module commands introduce a case change (`Wrong` to `wrong`); will consider full command name
+
+- Corrected error codes returned from [`EVAL`]({{< relref "/commands/eval" >}}) scripts ([#10218](https://github.com/redis/redis/pull/10218), [#10329](https://github.com/redis/redis/pull/10329)). 
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: config set maxmemory 1
+    2: +OK
+    3: eval "return redis.call('set','x','y')" 0
+  - 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: OOM command not allowed when used memory > 'maxmemory'.
+    5: eval "return redis.pcall('set','x','y')" 0
+  - 6: -@user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 6: -OOM command not allowed when used memory > 'maxmemory'.
+    7: eval "return redis.call('select',99)" 0
+    8: -ERR Error running script (call to 4ad5abfc50bbccb484223905f9a16f09cd043ba8): @user_script:1: ERR DB index is out of range
+    9: eval "return redis.pcall('select',99)" 0
+   10: -ERR DB index is out of range
+   11: eval_ro "return redis.call('set','x','y')" 0
+  -12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: Write commands are not allowed from read-only scripts.
+  +12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: ERR Write commands are not allowed from read-only scripts.
+   13: eval_ro "return redis.pcall('set','x','y')" 0
+  -14: -@user_script: 1: Write commands are not allowed from read-only scripts.
+  +14: -ERR Write commands are not allowed from read-only scripts.
+  ```
+
+- [`ZPOPMIN`]({{< relref "/commands/zpopmin" >}})/[`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) used to produce wrong replies when count is 0 with non-zset  [#9711](https://github.com/redis/redis/pull/9711)):
+  -  `ZPOPMIN`/`ZPOPMAX` used to produce an `(empty array)` when `key` was not a sorted set and the optional `count` argument was set to `0` and now produces a `WRONGTYPE` error response instead.
+  -  The optional `count` argument must be positive. A negative value produces a `value is out of range` error.
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: zadd myzset 1 "one"
+    2: (integer) 1
+    3: zadd myzset 2 "two"
+    4: (integer) 1
+    5: zadd myzset 3 "three"
+    6: (integer) 1
+    7: zpopmin myzset -1
+  - 8: (empty array)
+  + 8: (error) ERR value is out of range, must be positive
+    9: 127.0.0.1:6379> set foo bar
+   10: OK
+   11: zpopmin foo 0
+  -12: (empty array)
+  +12: (error) WRONGTYPE Operation against a key holding the wrong kind of value
+  ```
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) with count against a nonexistent list returns a null array instead of `(nil)`([#10095](https://github.com/redis/redis/pull/10095)). This change was backported to 6.2.
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) used to produce `(nil)` when count is 0, now produces a null array ([#9692](https://github.com/redis/redis/pull/9692)). This change was backported to 6.2.
+
+- [`XCLAIM`]({{< relref "/commands/xclaim" >}})/[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) skips deleted entries instead of replying with `nil` and deletes them from the pending entry list ([#10227](https://github.com/redis/redis/pull/10227)) - `XCLAIM`/`XAUTOCLAIM` now behaves in the following way:
+  - If you try to claim a deleted entry, it is deleted from the pending entry list (PEL) where it is found (as well as the group PEL). Therefore, such an entry is not claimed, just cleared from PEL (because it doesn't exist in the stream anyway).
+  - Because deleted entries are not claimed, `X[AUTO]CLAIM` does not return "nil" instead of an entry.
+  - Added an array of all the deleted stream IDs to `XAUTOCLAIM` response.
+
+####  ACLs
+
+- [`ACL GETUSER`]({{< relref "/commands/acl-getuser" >}}) reply now uses ACL syntax for `keys` and `channels` ([#9974](https://github.com/redis/redis/pull/9974)). `ACL GETUSER` now uses the ACL DSL (Domain Specific Language) for keys and channels. 
+
+  These examples show changes in behavior:
+  ```diff
+    1: acl setuser foo off resetchannels &channel1 -@all +get
+    2: OK
+    3: acl getuser foo
+    4: 1) "flags"
+    5: 2) 1) "off"
+    6: 3) "passwords"
+    7: 4) (empty array)
+    8: 5) "commands"
+    9: 6) "-@all +get"
+   10: 7) "keys"
+  -11: 8) (empty array)
+  +11: 8) ""
+   12: 9)"channels"
+  -13 10) 1) "channel1"
+  +13 10) "&channel1"
+  ```
+
+- [`SORT`]({{< relref "/commands/sort" >}})/[`SORT_RO`]({{< relref "/commands/sort_ro" >}}) commands reject key access patterns in `GET` and `BY` if the ACL doesn't grant the command full keyspace access ([#10340](https://github.com/redis/redis/pull/10340)) - The `sort` and `sort_ro` commands can access external keys via `GET` and `BY`. In order to make sure the user cannot violate the authorization ACL rules, Redis 7 will reject external keys access patterns unless ACL allows `SORT` full access to all keys.
+For backwards compatibility, `SORT` with `GET`/`BY` keeps working, but if ACL has restrictions to certain keys, the use of these features will result in a permission denied error.
+
+  These examples show changes in behavior:
+
+  ```
+  USER FOO (+sort ~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since ~* provides full key access
+  ```
+
+  ```
+  USER FOO (+sort %R~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since %R~* provides full key READ access**
+  ```
+
+  ```
+  USER FOO (+sort %W~* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since $W~* only provides full key WRITE access
+  ```
+
+  ```
+  USER FOO (+sort ~v* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since ~v* only provides partial key access
+  ```
+
+- Fix ACL category for [`SELECT`]({{< relref "/commands/select" >}}), [`WAIT`]({{< relref "/commands/wait" >}}, [`ROLE`]({{< relref "/commands/role" >}}) [`LASTSAVE`]({{< relref "/commands/lastsave" >}}, [`READONLY`]({{< relref "/commands/readonly" >}}, [`READWRITE`]({{< relref "/commands/readwrite" >}}, [`ASKING`]({{< relref "/commands/asking">}})  ([#9208](https://github.com/redis/redis/pull/9208)):
+  - `SELECT` and `WAIT` have been recategorized from `@keyspace` to `@connection`  
+  - `ROLE`, `LASTSAVE` have been categorized as  `@admin`  and  `@dangerous`
+  -  `ASKING`, `READONLY`, `READWRITE` have also been assigned the  `@connection`  category and  removed from `@keyspace`
+  - Command categories are explained in [ACL documentation]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories)
+
+#### Command introspection, stats, and configuration
+
+- [`COMMAND`]({{< relref "/commands/command" >}}) reply drops `random` and `sort-for-scripts` flags, which are now part of [command tips]({{< relref "/develop/reference/command-tips" >}}) ([#10104](https://github.com/redis/redis/pull/10104)) - The `random` flag was replaced with the `nondeterministic_output` tip; the `sort-for-scripts` flag was replaced by the ` nondeterministic_output_order` tip
+
+- [`INFO`]({{< relref "/commands/info" >}}) `commandstats` now shows the stats per sub-command ([#9504](https://github.com/redis/redis/pull/9504))
+For example, while previous versions would provide a single entry for all command usage, in Redis 7, each sub command is reported separately:
+
+  - Redis 6.2:
+  
+    ```
+    cmdstat_acl:calls=4,usec=279,usec_per_call=69.75,rejected_calls=0,failed_calls=2
+    ```
+
+  - Redis 7:
+  
+    ```  
+    cmdstat_acl|list:calls=1,usec=4994,usec_per_call=4994.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|setuser:calls=2,usec=16409,usec_per_call=8204.50,rejected_calls=0,failed_calls=0
+    cmdstat_acl|deluser:calls=1,usec=774,usec_per_call=774.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|getuser:calls=1,usec=6044,usec_per_call=6044.00,rejected_calls=0,failed_calls=0
+    ```
+
+- [`CONFIG REWRITE`]({{< relref "/commands/config-rewrite" >}}), [`CONFIG RESETSTAT`]({{< relref "/commands/config-resetstat" >}}, and most [`CONFIG SET`]({{< relref "/commands/config-set" >}}commands are now allowed during loading ([#9878](https://github.com/redis/redis/pull/9878))
+| Command | Supported |
+|:--------|:----------|
+| [ACL CAT]({{< relref "/commands/acl-cat" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> 
+| [ACL DELUSER]({{< relref "/commands/acl-deluser" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL DRYRUN]({{< relref "/commands/acl-dryrun" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> 
+| [ACL GENPASS]({{< relref "/commands/acl-genpass" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL GETUSER]({{< relref "/commands/acl-getuser" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> 
+| [ACL HELP]({{< relref "/commands/acl-help" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> 
+| [ACL LIST]({{< relref "/commands/acl-list" >}}) | <span title="Supported">&#x2705; Supported</span> | <span title="Supported">&#x2705; Supported</span> 
+| [ACL LOAD]({{< relref "/commands/acl-load" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL LOG]({{< relref "/commands/acl-log" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL SAVE]({{< relref "/commands/acl-save" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL SETUSER]({{< relref "/commands/acl-setuser" >}}) | <span title="Not supported">&#x274c; Not supported</span>| <span title="Not supported">&#x274c; Not supported</span>|  |
+| [ACL USERS]({{< relref "/commands/acl-users" >}}) | <span title="Supported">&#x2705; Supported</span> |
+| [ACL WHOAMI]({{< relref "/commands/acl-whoami" >}}) | <span title="Supported">&#x2705; Supported</span> |
+Before creating a Redis Cloud database, you need to [create an account]({{< relref "/operate/rc/rc-quickstart" >}}).
+
+To create a database in your Redis Cloud account:
+
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io).
+
+2. Select the **New database** button.
+
+    {{<image filename="images/rc/button-database-new.png" alt="The New Database button creates a new database." width="120px">}}
+
+    This displays the **Create database** screen. [Versions 6.4.2 and later]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/" >}}) uses a new `ValidatingWebhookConfiguration` resource to replace `redb-admission`. To use newer releases, delete the old webhook resource and apply the new file.
+
+1. Delete the existing `ValidatingWebhookConfiguration` on the Kubernetes cluster (named `redb-admission`).
+
+        ```sh
+        kubectl delete ValidatingWebhookConfiguration redb-admission
+        ```
+
+1. Apply the resource from the new file.
+
+        ```sh
+        kubectl apply -f deploy/admission/webhook.yaml
+        ```
+        There are two known limitations for the version of Redis 7.2 that is packaged with Redis Enterprise.
+
+- Using [`XREADGROUP BLOCK`]({{< relref "/commands/xreadgroup" >}}) with `>` to return all new streams will cause the Redis database to freeze until the shard is restarted ([#12031](https://github.com/redis/redis/pull/12301))
+
+- Because a rejected command does not record the duration for command stats, an error will appear after it is reprocessed that will cause the Redis database to freeze until the shard is restarted ([#12247](https://github.com/redis/redis/pull/12247))To reset a user password from the CLI, run:
+
+`rladmin cluster reset_password <username>`
+
+You are asked to enter and confirm the new password.### 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.
+
+Confirm your Redis database version (`redis_version`) using the admin console or run the following [`INFO`]({{< relref "/commands/info" >}}) command via [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+#### Breaking changes from version 6.2
+
+Upgrading to open source Redis version 7.2 from version 6.2 introduces the following potentially breaking changes to Redis Enterprise.
+
+##### Programmability
+
+-  Lua scripts no longer have access to the `print()` function ([#10651](https://github.com/redis/redis/pull/10651)) - The `print`  function was removed from Lua because it can potentially cause the Redis processes to get stuck (if no one reads from stdout). Users should use redis.log. An alternative is to override the  `print`  implementation and print the message to the log file.  
+
+- Block [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) and [`PUBLISH`]({{< relref "/commands/publish" >}}) in read-only scripts (*_RO commands,  `no-writes`) ([#10744](https://github.com/redis/redis/pull/10744)) - Consider `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`; meaning:
+  - They can never be used in scripts with shebang (`#!`) and no `no-writes` flag
+  - They are blocked in `EVAL_RO` and `_RO` variants, (even in scripts without shebang (`#!`) flags)
+  - Allow `no-write` scripts in EVAL (not just in EVAL_RO), even during `CLIENT PAUSE WRITE` 
+
+- Hide the `may_replicate` flag from the [`COMMAND`]({{< relref "/commands/command" >}}) command response  ([#10744](https://github.com/redis/redis/pull/10744)) - As part of the change to treat `may_replicate` commands `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`, the `may_replicate` flag has been removed from the `COMMAND` response.
+
+- Time sampling is now frozen during command execution and scripts ([#10300](https://github.com/redis/redis/pull/10300)). While a command or script is running, the keys used by the command or script will not expire. This breaks any script that uses a loop to wait for a key to expire. 
+
+- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/interact/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). 
+
+##### Error handling
+
+- Rephrased some error responses about invalid commands or arguments ([#10612](https://github.com/redis/redis/pull/10612)) - 
+  - Error response for unknown command introduced a case change (`Unknown` to `unknown`)
+  - Errors for module commands extended to cover subcommands, updated syntax to match Redis Server syntax
+  - Arity errors for module commands introduce a case change (`Wrong` to `wrong`); will consider full command name
+
+- Corrected error codes returned from [`EVAL`]({{< relref "/commands/eval" >}}) scripts ([#10218](https://github.com/redis/redis/pull/10218), [#10329](https://github.com/redis/redis/pull/10329)). 
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: config set maxmemory 1
+    2: +OK
+    3: eval "return redis.call('set','x','y')" 0
+  - 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: OOM command not allowed when used memory > 'maxmemory'.
+    5: eval "return redis.pcall('set','x','y')" 0
+  - 6: -@user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 6: -OOM command not allowed when used memory > 'maxmemory'.
+    7: eval "return redis.call('select',99)" 0
+    8: -ERR Error running script (call to 4ad5abfc50bbccb484223905f9a16f09cd043ba8): @user_script:1: ERR DB index is out of range
+    9: eval "return redis.pcall('select',99)" 0
+   10: -ERR DB index is out of range
+   11: eval_ro "return redis.call('set','x','y')" 0
+  -12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: Write commands are not allowed from read-only scripts.
+  +12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: ERR Write commands are not allowed from read-only scripts.
+   13: eval_ro "return redis.pcall('set','x','y')" 0
+  -14: -@user_script: 1: Write commands are not allowed from read-only scripts.
+  +14: -ERR Write commands are not allowed from read-only scripts.
+  ```
+
+- [`ZPOPMIN`]({{< relref "/commands/zpopmin" >}})/[`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) used to produce wrong replies when count is 0 with non-zset  [#9711](https://github.com/redis/redis/pull/9711)):
+  -  `ZPOPMIN`/`ZPOPMAX` used to produce an `(empty array)` when `key` was not a sorted set and the optional `count` argument was set to `0` and now produces a `WRONGTYPE` error response instead.
+  -  The optional `count` argument must be positive. A negative value produces a `value is out of range` error.
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: zadd myzset 1 "one"
+    2: (integer) 1
+    3: zadd myzset 2 "two"
+    4: (integer) 1
+    5: zadd myzset 3 "three"
+    6: (integer) 1
+    7: zpopmin myzset -1
+  - 8: (empty array)
+  + 8: (error) ERR value is out of range, must be positive
+    9: 127.0.0.1:6379> set foo bar
+   10: OK
+   11: zpopmin foo 0
+  -12: (empty array)
+  +12: (error) WRONGTYPE Operation against a key holding the wrong kind of value
+  ```
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) with count against a nonexistent list returns a null array instead of `(nil)`([#10095](https://github.com/redis/redis/pull/10095)). This change was backported to 6.2.
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) used to produce `(nil)` when count is 0, now produces a null array ([#9692](https://github.com/redis/redis/pull/9692)). This change was backported to 6.2.
+
+- [`XCLAIM`]({{< relref "/commands/xclaim" >}})/[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) skips deleted entries instead of replying with `nil` and deletes them from the pending entry list ([#10227](https://github.com/redis/redis/pull/10227)) - `XCLAIM`/`XAUTOCLAIM` now behaves in the following way:
+  - If you try to claim a deleted entry, it is deleted from the pending entry list (PEL) where it is found (as well as the group PEL). Therefore, such an entry is not claimed, just cleared from PEL (because it doesn't exist in the stream anyway).
+  - Because deleted entries are not claimed, `X[AUTO]CLAIM` does not return "nil" instead of an entry.
+  - Added an array of all the deleted stream IDs to `XAUTOCLAIM` response.
+
+- A blocked stream command that is released when a key no longer exists returns a different error code ([#11012](https://github.com/redis/redis/pull/11012)).
+    - For newly unblocked streams, lists, and zsets, the old implementation returned `UNBLOCKED` when the stream key was deleted or overwritten with a different type. Now, errors will be the same as if the command was processed after the effect.
+
+- ACL errors have been unified across Redis. ([#11160](https://github.com/redis/redis/pull/11160))
+    - When using [RedisModule_Call]({{< relref "/develop/reference/modules/modules-api-ref" >}}#redismodule_call) module API function, ACL errors return `-NOPERM` instead of `-ERR`
+
+- [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) and [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) create a consumer regardless of whether it was able to perform reading or claiming ([#11012](https://github.com/redis/redis/pull/11012)).
+
+- Any float that is Not a Number will return `nan` ([#11597](https://github.com/redis/redis/pull/11597)).
+
+#####  ACLs
+
+- [`ACL GETUSER`]({{< relref "/commands/acl-getuser" >}}) reply now uses ACL syntax for `keys` and `channels` ([#9974](https://github.com/redis/redis/pull/9974)). `ACL GETUSER` now uses the ACL DSL (Domain Specific Language) for keys and channels. 
+
+  These examples show changes in behavior:
+  ```diff
+    1: acl setuser foo off resetchannels &channel1 -@all +get
+    2: OK
+    3: acl getuser foo
+    4: 1) "flags"
+    5: 2) 1) "off"
+    6: 3) "passwords"
+    7: 4) (empty array)
+    8: 5) "commands"
+    9: 6) "-@all +get"
+   10: 7) "keys"
+  -11: 8) (empty array)
+  +11: 8) ""
+   12: 9)"channels"
+  -13 10) 1) "channel1"
+  +13 10) "&channel1"
+  ```
+
+- [`SORT`]({{< relref "/commands/sort" >}})/[`SORT_RO`]({{< relref "/commands/sort_ro" >}}) commands reject key access patterns in `GET` and `BY` if the ACL doesn't grant the command full keyspace access ([#10340](https://github.com/redis/redis/pull/10340)) - The `sort` and `sort_ro` commands can access external keys via `GET` and `BY`. In order to make sure the user cannot violate the authorization ACL rules, Redis 7 will reject external keys access patterns unless ACL allows `SORT` full access to all keys.
+For backwards compatibility, `SORT` with `GET`/`BY` keeps working, but if ACL has restrictions to certain keys, the use of these features will result in a permission denied error.
+
+  These examples show changes in behavior:
+
+  ```
+  USER FOO (+sort ~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since ~* provides full key access
+  ```
+
+  ```
+  USER FOO (+sort %R~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since %R~* provides full key READ access**
+  ```
+
+  ```
+  USER FOO (+sort %W~* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since $W~* only provides full key WRITE access
+  ```
+
+  ```
+  USER FOO (+sort ~v* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since ~v* only provides partial key access
+  ```
+
+- Fix ACL category for [`SELECT`]({{< relref "/commands/select" >}}), [`WAIT`]({{< relref "/commands/wait" >}}, [`ROLE`]({{< relref "/commands/role" >}}) [`LASTSAVE`]({{< relref "/commands/lastsave" >}}, [`READONLY`]({{< relref "/commands/readonly" >}}, [`READWRITE`]({{< relref "/commands/readwrite" >}}, [`ASKING`]({{< relref "/commands/asking" >}}, [#9208](https://github.com/redis/redis/pull/9208)):
+  - `SELECT` and `WAIT` have been recategorized from `@keyspace` to `@connection`  
+  - `ROLE`, `LASTSAVE` have been categorized as  `@admin`  and  `@dangerous`
+  -  `ASKING`, `READONLY`, `READWRITE` have also been assigned the  `@connection`  category and  removed from `@keyspace`
+  - Command categories are explained in [ACL documentation]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories)
+
+  - When a blocked client is being unblocked, checks for ACLs and OOM condition checks are now re-evaluated ([#11012](https://github.com/redis/redis/pull/11012)).
+    - If the ACL rules have changed since the command was executed, the command might fail after the client is unblocked.
+
+##### Command introspection, stats, and configuration
+
+- [`COMMAND`]({{< relref "/commands/command" >}}) reply drops `random` and `sort-for-scripts` flags, which are now part of [command tips]({{< relref "/develop/reference/command-tips" >}}) ([#10104](https://github.com/redis/redis/pull/10104)) - The `random` flag was replaced with the `nondeterministic_output` tip; the `sort-for-scripts` flag was replaced by the ` nondeterministic_output_order` tip
+
+- [`INFO`]({{< relref "/commands/info" >}}) `commandstats` now shows the stats per sub-command ([#9504](https://github.com/redis/redis/pull/9504))
+For example, while previous versions would provide a single entry for all command usage, in Redis 7, each sub command is reported separately:
+
+  - Redis 6.2:
+  
+    ```
+    cmdstat_acl:calls=4,usec=279,usec_per_call=69.75,rejected_calls=0,failed_calls=2
+    ```
+
+  - Redis 7:
+  
+    ```  
+    cmdstat_acl|list:calls=1,usec=4994,usec_per_call=4994.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|setuser:calls=2,usec=16409,usec_per_call=8204.50,rejected_calls=0,failed_calls=0
+    cmdstat_acl|deluser:calls=1,usec=774,usec_per_call=774.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|getuser:calls=1,usec=6044,usec_per_call=6044.00,rejected_calls=0,failed_calls=0
+    ```
+
+- [`CONFIG REWRITE`]({{< relref "/commands/config-rewrite" >}}), [`CONFIG RESETSTAT`]({{< relref "/commands/config-resetstat" >}}), and most [`CONFIG SET`]({{< relref "/commands/config-set" >}}) commands are now allowed during loading ([#9878](https://github.com/redis/redis/pull/9878))
+
+- When running [`XINFO CONSUMERS`]({{< relref "/commands/xinfo-consumers" >}}), the `idle` time now shows the number of milliseconds that have passed since the last attempted interaction, and the `inactive` time shows the number of milliseconds since the last successful interaction ([#11099](https://github.com/redis/redis/pull/11099))
+    - Previously, `idle` time showed the number of milliseconds that passed since the last successful interaction and there was no `inactive` time.
+
+- Command stats are only updated when the command executes ([#11012](https://github.com/redis/redis/pull/11012)).
+    - Previously, the command stats were updated even if a command was blocked. The command stats are now updated only if and when the command is executed.
+### 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.
+
+Confirm your Redis database version (`redis_version`) using the admin console or run the following [`INFO`]({{< relref "/commands/info" >}}) command via [`redis-cli`]({{< relref "/operate/rs/references/cli-utilities/redis-cli" >}}):
+
+```sh
+$ redis-cli -p <port> INFO
+"# Server
+redis_version:7.0.8
+..."
+```
+
+#### Breaking changes from version 7.0
+
+Upgrading to Redis version 7.2 from version 7.0 introduces the following potentially breaking changes to Redis Enterprise:
+
+##### Programmability
+
+- Time sampling is now frozen during command execution and scripts ([#10300](https://github.com/redis/redis/pull/10300)). While a command or script is running, the keys used by the command or script will not expire. This breaks any script that uses a loop to wait for a key to expire. 
+
+- Blocked commands in scripts now work the same way as when they are used in [transactions]({{< relref "/develop/interact/transactions" >}}) ([#11568](https://github.com/redis/redis/pull/11568)). 
+
+##### Error handling
+
+- A blocked stream command that is released when a key no longer exists returns a different error code ([#11012](https://github.com/redis/redis/pull/11012)).
+    - For newly unblocked streams, lists, and zsets, the old implementation returned `UNBLOCKED` when the stream key was deleted or overwritten with a different type. Now, errors will be the same as if the command was processed after the effect.
+
+- ACL errors have been unified across Redis. ([#11160](https://github.com/redis/redis/pull/11160))
+    - When using [RedisModule_Call]({{< relref "/develop/reference/modules/modules-api-ref" >}}#redismodule_call) module API function, ACL errors return `-NOPERM` instead of `-ERR`
+
+- [`XREADGROUP`]({{< relref "/commands/xreadgroup" >}}) and [`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) create a consumer regardless of whether it was able to perform reading or claiming ([#11012](https://github.com/redis/redis/pull/11012)).
+
+- Any float that is Not a Number will return `nan` ([#11597](https://github.com/redis/redis/pull/11597)).
+
+##### ACLs
+
+- When a blocked client is being unblocked, checks for ACLs and OOM condition checks are now re-evaluated ([#11012](https://github.com/redis/redis/pull/11012)).
+    - If the ACL rules have changed since the command was executed, the command might fail after the client is unblocked.
+
+##### Command introspection, stats, and configuration
+
+- When running [`XINFO CONSUMERS`]({{< relref "/commands/xinfo-consumers" >}}), the `idle` time now shows the number of milliseconds that have passed since the last attempted interaction, and the `inactive` time shows the number of milliseconds since the last successful interaction ([#11099](https://github.com/redis/redis/pull/11099))
+    - Previously, `idle` time showed the number of milliseconds that passed since the last successful interaction and there was no `inactive` time.
+
+- Command stats are only updated when the command executes ([#11012](https://github.com/redis/redis/pull/11012)).
+    - Previously, the command stats were updated even if a command was blocked. The command stats are now updated only if and when the command is executed.
+
+#### Breaking changes from version 6.2
+
+Upgrading to open source Redis version 7.2 from version 6.2 introduces the following potentially breaking changes to Redis Enterprise.
+
+All [breaking changes from version 7.0](#breaking-changes-from-version-70) also apply to Redis version 6.2.
+
+##### Programmability
+
+-  Lua scripts no longer have access to the `print()` function ([#10651](https://github.com/redis/redis/pull/10651)) - The `print`  function was removed from Lua because it can potentially cause the Redis processes to get stuck (if no one reads from stdout). Users should use redis.log. An alternative is to override the  `print`  implementation and print the message to the log file.  
+
+- Block [`PFCOUNT`]({{< relref "/commands/pfcount" >}}) and [`PUBLISH`]({{< relref "/commands/publish" >}}) in read-only scripts (*_RO commands,  `no-writes`) ([#10744](https://github.com/redis/redis/pull/10744)) - Consider `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`; meaning:
+  - They can never be used in scripts with shebang (`#!`) and no `no-writes` flag
+  - They are blocked in `EVAL_RO` and `_RO` variants, (even in scripts without shebang (`#!`) flags)
+  - Allow `no-write` scripts in EVAL (not just in EVAL_RO), even during `CLIENT PAUSE WRITE` 
+
+- Hide the `may_replicate` flag from the [`COMMAND`]({{< relref "/commands/command" >}}) command response  ([#10744](https://github.com/redis/redis/pull/10744)) - As part of the change to treat `may_replicate` commands `PFCOUNT` and `PUBLISH` as write commands in scripts, in addition to `EVAL`, the `may_replicate` flag has been removed from the `COMMAND` response.
+
+##### Error handling
+
+- Rephrased some error responses about invalid commands or arguments ([#10612](https://github.com/redis/redis/pull/10612)) - 
+  - Error response for unknown command introduced a case change (`Unknown` to `unknown`)
+  - Errors for module commands extended to cover subcommands, updated syntax to match Redis Server syntax
+  - Arity errors for module commands introduce a case change (`Wrong` to `wrong`); will consider full command name
+
+- Corrected error codes returned from [`EVAL`]({{< relref "/commands/eval" >}}) scripts ([#10218](https://github.com/redis/redis/pull/10218), [#10329](https://github.com/redis/redis/pull/10329)). 
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: config set maxmemory 1
+    2: +OK
+    3: eval "return redis.call('set','x','y')" 0
+  - 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 4: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: OOM command not allowed when used memory > 'maxmemory'.
+    5: eval "return redis.pcall('set','x','y')" 0
+  - 6: -@user_script: 1: -OOM command not allowed when used memory > 'maxmemory'.
+  + 6: -OOM command not allowed when used memory > 'maxmemory'.
+    7: eval "return redis.call('select',99)" 0
+    8: -ERR Error running script (call to 4ad5abfc50bbccb484223905f9a16f09cd043ba8): @user_script:1: ERR DB index is out of range
+    9: eval "return redis.pcall('select',99)" 0
+   10: -ERR DB index is out of range
+   11: eval_ro "return redis.call('set','x','y')" 0
+  -12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: @user_script: 1: Write commands are not allowed from read-only scripts.
+  +12: -ERR Error running script (call to 71e6319f97b0fe8bdfa1c5df3ce4489946dda479): @user_script:1: ERR Write commands are not allowed from read-only scripts.
+   13: eval_ro "return redis.pcall('set','x','y')" 0
+  -14: -@user_script: 1: Write commands are not allowed from read-only scripts.
+  +14: -ERR Write commands are not allowed from read-only scripts.
+  ```
+
+- [`ZPOPMIN`]({{< relref "/commands/zpopmin" >}})/[`ZPOPMAX`]({{< relref "/commands/zpopmax" >}}) used to produce wrong replies when count is 0 with non-zset  [#9711](https://github.com/redis/redis/pull/9711)):
+  -  `ZPOPMIN`/`ZPOPMAX` used to produce an `(empty array)` when `key` was not a sorted set and the optional `count` argument was set to `0` and now produces a `WRONGTYPE` error response instead.
+  -  The optional `count` argument must be positive. A negative value produces a `value is out of range` error.
+
+  These examples show changes in behavior:
+
+  ```diff
+    1: zadd myzset 1 "one"
+    2: (integer) 1
+    3: zadd myzset 2 "two"
+    4: (integer) 1
+    5: zadd myzset 3 "three"
+    6: (integer) 1
+    7: zpopmin myzset -1
+  - 8: (empty array)
+  + 8: (error) ERR value is out of range, must be positive
+    9: 127.0.0.1:6379> set foo bar
+   10: OK
+   11: zpopmin foo 0
+  -12: (empty array)
+  +12: (error) WRONGTYPE Operation against a key holding the wrong kind of value
+  ```
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) with count against a nonexistent list returns a null array instead of `(nil)`([#10095](https://github.com/redis/redis/pull/10095)). This change was backported to 6.2.
+
+- [`LPOP`]({{< relref "/commands/lpop" >}})/[`RPOP`]({{< relref "/commands/rpop" >}}) used to produce `(nil)` when count is 0, now produces a null array ([#9692](https://github.com/redis/redis/pull/9692)). This change was backported to 6.2.
+
+- [`XCLAIM`]({{< relref "/commands/xclaim" >}})/[`XAUTOCLAIM`]({{< relref "/commands/xautoclaim" >}}) skips deleted entries instead of replying with `nil` and deletes them from the pending entry list ([#10227](https://github.com/redis/redis/pull/10227)) - `XCLAIM`/`XAUTOCLAIM` now behaves in the following way:
+  - If you try to claim a deleted entry, it is deleted from the pending entry list (PEL) where it is found (as well as the group PEL). Therefore, such an entry is not claimed, just cleared from PEL (because it doesn't exist in the stream anyway).
+  - Because deleted entries are not claimed, `X[AUTO]CLAIM` does not return "nil" instead of an entry.
+  - Added an array of all the deleted stream IDs to `XAUTOCLAIM` response.
+
+#####  ACLs
+
+- [`ACL GETUSER`]({{< relref "/commands/acl-getuser" >}}) reply now uses ACL syntax for `keys` and `channels` ([#9974](https://github.com/redis/redis/pull/9974)). `ACL GETUSER` now uses the ACL DSL (Domain Specific Language) for keys and channels. 
+
+  These examples show changes in behavior:
+  ```diff
+    1: acl setuser foo off resetchannels &channel1 -@all +get
+    2: OK
+    3: acl getuser foo
+    4: 1) "flags"
+    5: 2) 1) "off"
+    6: 3) "passwords"
+    7: 4) (empty array)
+    8: 5) "commands"
+    9: 6) "-@all +get"
+   10: 7) "keys"
+  -11: 8) (empty array)
+  +11: 8) ""
+   12: 9)"channels"
+  -13 10) 1) "channel1"
+  +13 10) "&channel1"
+  ```
+
+- [`SORT`]({{< relref "/commands/sort" >}})/[`SORT_RO`]({{< relref "/commands/sort_ro" >}}) commands reject key access patterns in `GET` and `BY` if the ACL doesn't grant the command full keyspace access ([#10340](https://github.com/redis/redis/pull/10340)) - The `sort` and `sort_ro` commands can access external keys via `GET` and `BY`. In order to make sure the user cannot violate the authorization ACL rules, Redis 7 will reject external keys access patterns unless ACL allows `SORT` full access to all keys.
+For backwards compatibility, `SORT` with `GET`/`BY` keeps working, but if ACL has restrictions to certain keys, the use of these features will result in a permission denied error.
+
+  These examples show changes in behavior:
+
+  ```
+  USER FOO (+sort ~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since ~* provides full key access
+  ```
+
+  ```
+  USER FOO (+sort %R~* ~mylist) 
+  #FOO> sort mylist by w* get v*  - is O.K since %R~* provides full key READ access**
+  ```
+
+  ```
+  USER FOO (+sort %W~* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since $W~* only provides full key WRITE access
+  ```
+
+  ```
+  USER FOO (+sort ~v* ~mylist)
+  #FOO> sort mylist by w* get v*  - will now fail since ~v* only provides partial key access
+  ```
+
+- Fix ACL category for [`SELECT`]({{< relref "/commands/select" >}}), [`WAIT`]({{< relref "/commands/wait" >}}, [`ROLE`]({{< relref "/commands/role" >}}, [`LASTSAVE`]({{< relref "/commands/lastsave" >}}, [`READONLY`]({{< relref "/commands/readonly" >}}, [`READWRITE`]({{< relref "/commands/readwrite" >}}, [`ASKING`]({{< relref "/commands/asking" >}}) ([#9208](https://github.com/redis/redis/pull/9208)):
+  - `SELECT` and `WAIT` have been recategorized from `@keyspace` to `@connection`  
+  - `ROLE`, `LASTSAVE` have been categorized as  `@admin`  and  `@dangerous`
+  -  `ASKING`, `READONLY`, `READWRITE` have also been assigned the  `@connection`  category and  removed from `@keyspace`
+  - Command categories are explained in [ACL documentation]({{< relref "/operate/oss_and_stack/management/security/acl" >}}#command-categories)
+
+##### Command introspection, stats, and configuration
+
+- [`COMMAND`]({{< relref "/commands/command" >}}) reply drops `random` and `sort-for-scripts` flags, which are now part of [command tips]({{< relref "/develop/reference/command-tips" >}}) ([#10104](https://github.com/redis/redis/pull/10104)) - The `random` flag was replaced with the `nondeterministic_output` tip; the `sort-for-scripts` flag was replaced by the ` nondeterministic_output_order` tip
+
+- [`INFO`]({{< relref "/commands/info" >}}) `commandstats` now shows the stats per sub-command ([#9504](https://github.com/redis/redis/pull/9504))
+For example, while previous versions would provide a single entry for all command usage, in Redis 7, each sub command is reported separately:
+
+  - Redis 6.2:
+  
+    ```
+    cmdstat_acl:calls=4,usec=279,usec_per_call=69.75,rejected_calls=0,failed_calls=2
+    ```
+
+  - Redis 7:
+  
+    ```  
+    cmdstat_acl|list:calls=1,usec=4994,usec_per_call=4994.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|setuser:calls=2,usec=16409,usec_per_call=8204.50,rejected_calls=0,failed_calls=0
+    cmdstat_acl|deluser:calls=1,usec=774,usec_per_call=774.00,rejected_calls=0,failed_calls=0
+    cmdstat_acl|getuser:calls=1,usec=6044,usec_per_call=6044.00,rejected_calls=0,failed_calls=0
+    ```
+
+- [`CONFIG REWRITE`]({{< relref "/commands/config-rewrite" >}}), [`CONFIG RESETSTAT`]({{< relref "/commands/config-resetstat" >}}, and most [`CONFIG SET`]({{< relref "/commands/config-set" >}}commands are now allowed during loading ([#9878](https://github.com/redis/redis/pull/9878))
+
+1. In a browser, go to `https://<name-or-IP-address-of-the-machine-with-Redis-Enterprise-Software-installed>:8443` to access the Cluster Manager UI. If you use a browser on the host machine, you can also access the Cluster Manager UI at `https://localhost:8443`.
+
+    The cluster generates self-signed TLS certificates to secure the connection. Because these self-signed certificates are unknown to the browser, you must accept them before you proceed.
+
+    If the server does not show the sign-in screen, try again after a few minutes.
+
+1. Select **Create new cluster**.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/create-cluster.png" alt="When you first install Redis Enterprise Software, you need to set up a cluster." >}}
+
+2. Enter an email and password for the administrator account, then select **Next** to proceed to cluster setup.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/admin-credentials.png" alt="Set the credentials for your admin user." >}}
+
+    You can also use these credentials to connect to the [REST API]({{< relref "/operate/rs/references/rest-api" >}}).
+
+3. Enter your cluster license key if you have one. Otherwise, a trial version is installed.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/cluster-license-key.png" alt="Enter your cluster license key if you have one." >}}
+
+4. In the **Configuration** section, enter a cluster FQDN such as `cluster.local`, then select **Next**.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/config-cluster.png" alt="Configure the cluster FQDN." >}}
+
+    {{< warning >}}
+If the FQDN is `cluster.local`, you cannot configure DNS. You cannot change the FQDN after cluster creation.
+    {{< /warning >}}
+
+1. On the node setup screen, select **Create cluster** to accept the defaults.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/node-settings.png" alt="Configure the node specific settings." >}}
+
+6. Select **OK** to acknowledge the replacement of the HTTPS TLS certificate on the node.  If you receive a browser warning, you can proceed safely.
+
+    {{<image filename="images/rs/screenshots/cluster/setup/https-page-refresh-modal.png" alt="Modal shown when a page refresh is needed because the certificates have been updated." >}}
+1. On the **Databases** screen, select **Quick database**.
+
+    {{<image filename="images/rs/screenshots/databases/db-screen.png" alt="Select Quick database on the Databases screen." >}}
+
+1. Enter 12000 for the **Port**.
+
+    If port 12000 is not available, enter any available port number between 10000 to 19999 or leave it blank to let the cluster assign a port number for you. You will use this port number to connect to the database.
+
+    {{<image filename="images/rs/screenshots/databases/quick-db.png" alt="Create a quick database." >}}
+
+1. Select **Create** to create your database.
+
+When you see **Database active** appear on the database configuration screen, the database is activated and ready for you to use.
+
+{{<image filename="images/rs/icons/db-active-icon.png" width="150px" alt="Database active icon." >}}
+
+
+You now have a Redis database!To avoid port collision, update `/etc/sysctl.conf` to include:
+
+``` sh
+net.ipv4.ip_local_port_range = 30000 65535
+```
+You can select the tag's **Key** and **Value** from the suggestions, or you can enter your own.
+
+{{<image filename="images/rc/tags-new-tag.png" alt="The New tag fields." >}}
+
+A valid tag must follow these guidelines:
+- Tag keys must be between 1 and 64 characters long, and values must be at least 1 character long.
+- Tags can only have lowercase letters, numbers, spaces, and these special characters: `-`, `_`, `.`, `+`, `@`, and `:`.
+
+After you add your first tag, you can:
+
+- Select the **Key** or **Value** field of an existing tag and enter new text to edit it.
+
+- Select **Delete** next to a tag to delete it.
+
+    {{<image filename="images/rc/icon-delete-teal.png" width="36px" alt="Delete button." >}}
+
+- Select **Add additional tag** to add another tag.
+
+    {{<image filename="images/rc/tags-button-add-additional-tag.png" alt="The Add additional tag button." width="200px" >}}## Supported upgrade paths
+
+<span title="Check mark icon">&#x2705;</span> Supported – You can upgrade directly from the current Redis Software cluster version.
+
+<span title="X icon">:x:</span> Not supported – You cannot upgrade directly from the current Redis Software cluster version. You must first upgrade to a supported intermediate version.
+
+| Current Redis Software cluster version | Upgrade to Redis Software 6.2.x | Upgrade to Redis Software 6.4.x | Upgrade to Redis Software 7.2.x | Upgrade to Redis Software 7.4.x |  Upgrade to Redis Software 7.8.x |
+|:-----------------------:|:----------------:|:----------------:|:----------------:|:----------------:|:----------------:|
+| 6.0.x | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Not supported">:x:</span> | <span title="Not supported">:x:</span> |
+| 6.2.4<br />6.2.8 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Not supported">:x:</span> |
+| 6.2.10<br />6.2.12<br />6.2.18 | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 6.4.x | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |  <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 7.2.x | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+| 7.4.x | – | – | – | <span title="Supported">&#x2705;</span> | <span title="Supported">&#x2705;</span> |
+Redis has enhanced Redis Open Source with a technology layer that encapsulates Redis Open Source, while fully supporting all its commands, data structures and modules. It adds exceptional flexibility, stable high performance and unmatched resilience, as well as multiple deployment choices (public and private clouds, on-premises, hybrid, RAM-Flash combination), topology (active-active, active-passive, active-replica) and support for very large dataset sizes. This enhanced and exponentially more powerful database platform is Redis Enterprise.
+
+Learn more about [Redis Enterprise](https://redislabs.com/why-redis/redis-enterprise/).## Database metrics
+
+| Metric | Type | Description |
+| :-------- | :--- | :---------- |
+| <span class="break-all">endpoint_client_connections</span> | counter | Number of client connection establishment events |
+| <span class="break-all">endpoint_client_disconnections</span> | counter | Number of client disconnections initiated by the client |
+| <span class="break-all">endpoint_client_connection_expired</span> | counter | Total number of client connections with expired TTL (Time To Live) |
+| <span class="break-all">endpoint_client_establishment_failures</span> | counter | Number of client connections that failed to establish properly |
+| <span class="break-all">endpoint_client_expiration_refresh</span> | counter | Number of expiration time changes of clients |
+| <span class="break-all">endpoint_client_tracking_off_requests</span> | counter | Total number of `CLIENT TRACKING OFF` requests |
+| <span class="break-all">endpoint_client_tracking_on_requests</span> | counter | Total number of `CLIENT TRACKING ON` requests |
+| <span class="break-all">endpoint_disconnected_cba_client</span> | counter | Number of certificate-based clients disconnected |
+| <span class="break-all">endpoint_disconnected_ldap_client</span> | counter | Number of LDAP clients disconnected |
+| <span class="break-all">endpoint_disconnected_user_password_client</span> | counter | Number of user&password clients disconnected |
+| <span class="break-all">endpoint_disposed_commands_after_client_caching</span> | counter | Total number of client caching commands that were disposed due to misuse |
+| <span class="break-all">endpoint_egress</span> | counter | Number of egress bytes |
+| <span class="break-all">endpoint_egress_pending</span> | counter | Number of send-pending bytes |
+| <span class="break-all">endpoint_egress_pending_discarded</span> | counter | Number of send-pending bytes that were discarded due to disconnection |
+| <span class="break-all">endpoint_failed_cba_authentication</span> | counter | Number of clients that failed certificate-based authentication |
+| <span class="break-all">endpoint_failed_ldap_authentication</span> | counter | Number of clients that failed LDAP authentication |
+| <span class="break-all">endpoint_failed_user_password_authentication</span> | counter | Number of clients that failed user password authentication |
+| <span class="break-all">endpoint_ingress</span> | counter | Number of ingress bytes |
+| <span class="break-all">endpoint_longest_pipeline_histogram</span> | counter | Tracks the distribution of longest observed pipeline lengths, where a pipeline is a sequence of client commands sent without waiting for responses. |
+| <span class="break-all">endpoint_other_requests</span> | counter | Number of other requests |
+| <span class="break-all">endpoint_other_requests_latency_histogram</span> | histogram | Latency (in µs) histogram of other commands |
+| <span class="break-all">endpoint_other_requests_latency_histogram_bucket</span> | histogram | Latency histograms for commands other than read or write commands. Can be used to represent different latency percentiles.<br />p99.9 example:<br /><span class="break-all">`histogram_quantile(0.999, sum(rate(endpoint_other_requests_latency_histogram_bucket{cluster="$cluster", db="$db"}[$__rate_interval]) ) by (le, db))`</span> |
+| <span class="break-all">endpoint_other_responses</span> | counter | Number of other responses |
+| <span class="break-all">endpoint_proxy_disconnections</span> | counter | Number of client disconnections initiated by the proxy |
+| <span class="break-all">endpoint_read_requests</span> | counter | Number of read requests |
+| <span class="break-all">endpoint_read_requests_latency_histogram</span> | histogram | Latency (in µs) histogram of read commands |
+| <span class="break-all">endpoint_read_requests_latency_histogram_bucket</span> | histogram | Latency histograms for read commands. Can be used to represent different latency percentiles.<br />p99.9 example:<br /><span class="break-all">`histogram_quantile(0.999, sum(rate(endpoint_read_requests_latency_histogram_bucket{cluster="$cluster", db="$db"}[$__rate_interval]) ) by (le, db))`</span> |
+| <span class="break-all">endpoint_read_responses</span> | counter | Number of read responses |
+| <span class="break-all">endpoint_successful_cba_authentication</span> | counter | Number of clients that successfully authenticated with certificate-based authentication |
+| <span class="break-all">endpoint_successful_ldap_authentication</span> | counter | Number of clients that successfully authenticated with LDAP |
+| <span class="break-all">endpoint_successful_user_password_authentication</span> | counter | Number of clients that successfully authenticated with user&password |
+| <span class="break-all">endpoint_write_requests</span> | counter | Number of write requests |
+| <span class="break-all">endpoint_write_requests_latency_histogram</span> | histogram | Latency (in µs) histogram of write commands |
+| <span class="break-all">endpoint_write_requests_latency_histogram_bucket</span> | histogram | Latency histograms for write commands. Can be used to represent different latency percentiles.<br />p99.9 example:<br /><span class="break-all">`histogram_quantile(0.999, sum(rate(endpoint_write_requests_latency_histogram_bucket{cluster="$cluster", db="$db"}[$__rate_interval]) ) by (le, db))`</span> |
+| <span class="break-all">endpoint_write_responses</span> | counter | Number of write responses |
+
+## Node metrics
+
+| Metric | Type |Description |
+| :-------- | :--- | :---------- |
+| <span class="break-all">node_available_flash_bytes</span> | gauge | Available flash in the node (bytes) |
+| <span class="break-all">node_available_flash_no_overbooking_bytes</span> | gauge | Available flash in the node (bytes), without taking into account overbooking |
+| <span class="break-all">node_available_memory_bytes</span> | gauge | Amount of free memory in the node (bytes) that is available for database provisioning |
+| <span class="break-all">node_available_memory_no_overbooking_bytes</span> | gauge | Available RAM in the node (bytes) without taking into account overbooking |
+| <span class="break-all">node_bigstore_free_bytes</span> | gauge | Sum of free space of back-end flash (used by flash database's [BigRedis]) on all cluster nodes (bytes); returned only when BigRedis is enabled |
+| <span class="break-all">node_cert_expires_in_seconds</span> | gauge | Certificate expiration (in seconds) per given node; read more about [certificates in Redis Enterprise]({{< relref "/operate/rs/security/certificates" >}}) and [monitoring certificates]({{< relref "/operate/rs/security/certificates/monitor-certificates" >}}) |
+| <span class="break-all">node_ephemeral_storage_avail_bytes</span> | gauge | Disk space available to RLEC processes on configured ephemeral disk (bytes) |
+| <span class="break-all">node_ephemeral_storage_free_bytes</span> | gauge | Free disk space on configured ephemeral disk (bytes) |
+| <span class="break-all">node_memory_MemFree_bytes</span> | gauge | Free memory in the node (bytes) |
+| <span class="break-all">node_persistent_storage_avail_bytes</span> | gauge | Disk space available to RLEC processes on configured persistent disk (bytes) |
+| <span class="break-all">node_persistent_storage_free_bytes</span> | gauge | Free disk space on configured persistent disk (bytes) |
+| <span class="break-all">node_provisional_flash_bytes</span> | gauge | Amount of flash available for new shards on this node, taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| <span class="break-all">node_provisional_flash_no_overbooking_bytes</span> | gauge | Amount of flash available for new shards on this node, without taking into account overbooking, max Redis servers, reserved flash, and provision and migration thresholds (bytes) |
+| <span class="break-all">node_provisional_memory_bytes</span> | gauge | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases |
+| <span class="break-all">node_provisional_memory_no_overbooking_bytes</span> | gauge | Amount of RAM that is available for provisioning to databases out of the total RAM allocated for databases, without taking into account overbooking |
+| <span class="break-all">node_metrics_up</span> | gauge | Node is part of the cluster and is connected |
+
+## Cluster metrics
+
+| Metric | Type | Description |
+| :-------- | :--- | :---------- |
+| <span class="break-all">generation{cluster_wd=<node_uid>}</span> | gauge| Generation number of the specific cluster_wd|
+| <span class="break-all">has_qourum{cluster_wd=<node_uid>, has_witness_disk=BOOL}</span> | gauge| Has_qourum = 1<br />No quorum = 0 |
+| <span class="break-all">is_primary{cluster_wd=<node_uid>}</span> | gauge| primary = 1<br />secondary = 0 |
+| <span class="break-all">license_shards_limit</span> | gauge | Total shard limit by the license by shard type (ram / flash) |
+| <span class="break-all">total_live_nodes_count{cluster_wd=<node_uid>}</span> | gauge| Number of live nodes|
+| <span class="break-all">total_node_count{cluster_wd=<node_uid>}</span> | gauge| Number of nodes |
+| <span class="break-all">total_primary_selection_ended{cluster_wd=<node_uid>}</span> | counter | Monotonic counter for each selection process that ended |
+| <span class="break-all">total_primary_selections{cluster_wd=<node_uid>}</span> | counter | Monotonic counter for each selection process that started|
+
+## Replication metrics
+
+| Metric | Type | Description |
+| :-------- | :--- | :---------- |
+| <span class="break-all">database_syncer_config</span> | gauge | Used as a placeholder for configuration labels |
+| <span class="break-all">database_syncer_current_status</span> | gauge | Syncer status for traffic; 0 = in-sync, 2 = out of sync |
+| <span class="break-all">database_syncer_dst_connectivity_state</span> | gauge | Destination connectivity state |
+| <span class="break-all">database_syncer_dst_connectivity_state_ms</span> | gauge | Destination connectivity state duration |
+| <span class="break-all">database_syncer_dst_lag</span> | gauge | Lag in milliseconds between the syncer and the destination |
+| <span class="break-all">database_syncer_dst_repl_offset</span> | gauge | Offset of the last command acknowledged |
+| <span class="break-all">database_syncer_flush_counter</span> | gauge | Number of destination flushes |
+| <span class="break-all">database_syncer_ingress_bytes</span> | gauge | Number of bytes read from source shard |
+| <span class="break-all">database_syncer_ingress_bytes_decompressed</span> | gauge | Number of bytes read from source shard |
+| <span class="break-all">database_syncer_internal_state</span> | gauge | Internal state of the syncer |
+| <span class="break-all">database_syncer_lag_ms</span> | gauge | Lag time between the source and the destination for traffic in milliseconds |
+| <span class="break-all">database_syncer_rdb_size</span> | gauge | The source's RDB size in bytes to be transferred during the syncing phase |
+| <span class="break-all">database_syncer_rdb_transferred</span> | gauge | Number of bytes transferred from the source's RDB during the syncing phase |
+| <span class="break-all">database_syncer_src_connectivity_state</span> | gauge | Source connectivity state |
+| <span class="break-all">database_syncer_src_connectivity_state_ms</span> | gauge | Source connectivity state duration |
+| <span class="break-all">database_syncer_src_repl_offset</span> | gauge | Last known source offset |
+| <span class="break-all">database_syncer_state</span> | gauge | Internal state of the shard syncer |
+| <span class="break-all">database_syncer_syncer_repl_offset</span> | gauge | Offset of the last command handled by the syncer |
+| <span class="break-all">database_syncer_total_requests</span> | gauge | Number of destination writes |
+| <span class="break-all">database_syncer_total_responses</span> | gauge | Number of destination writes acknowledged |
+
+## Shard metrics
+
+| Metric | Description |
+| :-------- | :---------- |
+| <span class="break-all">redis_server_active_defrag_running</span> | Automatic memory defragmentation current aggressiveness (% cpu) |
+| <span class="break-all">redis_server_allocator_active</span> | Total used memory, including external fragmentation |
+| <span class="break-all">redis_server_allocator_allocated</span> | Total allocated memory |
+| <span class="break-all">redis_server_allocator_resident</span> | Total resident memory (RSS) |
+| <span class="break-all">redis_server_aof_last_cow_size</span> | Last AOFR, CopyOnWrite memory |
+| <span class="break-all">redis_server_aof_rewrite_in_progress</span> | The number of simultaneous AOF rewrites that are in progress |
+| <span class="break-all">redis_server_aof_rewrites</span> | Number of AOF rewrites this process executed |
+| <span class="break-all">redis_server_aof_delayed_fsync</span> | Number of times an AOF fsync caused delays in the main Redis thread (inducing latency); this can indicate that the disk is slow or overloaded |
+| <span class="break-all">redis_server_blocked_clients</span> | Count the clients waiting on a blocking call |
+| <span class="break-all">redis_server_connected_clients</span> | Number of client connections to the specific shard |
+| <span class="break-all">redis_server_connected_slaves</span> | Number of connected replicas |
+| <span class="break-all">redis_server_db0_avg_ttl</span> | Average TTL of all volatile keys |
+| <span class="break-all">redis_server_expired_keys</span> | Total count of volatile keys |
+| <span class="break-all">redis_server_db0_keys</span> | Total key count |
+| <span class="break-all">redis_server_evicted_keys</span> | Keys evicted so far (since restart) |
+| <span class="break-all">redis_server_expire_cycle_cpu_milliseconds</span> | The cumulative amount of time spent on active expiry cycles |
+| <span class="break-all">redis_server_expired_keys</span> | Keys expired so far (since restart) |
+| <span class="break-all">redis_server_forwarding_state</span> | Shard forwarding state (on or off) |
+| <span class="break-all">redis_server_keys_trimmed</span> | The number of keys that were trimmed in the current or last resharding process |
+| <span class="break-all">redis_server_keyspace_read_hits</span> | Number of read operations accessing an existing keyspace |
+| <span class="break-all">redis_server_keyspace_read_misses</span> | Number of read operations accessing a non-existing keyspace |
+| <span class="break-all">redis_server_keyspace_write_hits</span> | Number of write operations accessing an existing keyspace |
+| <span class="break-all">redis_server_keyspace_write_misses</span> | Number of write operations accessing a non-existing keyspace |
+| <span class="break-all">redis_server_master_link_status</span> | Indicates if the replica is connected to its master |
+| <span class="break-all">redis_server_master_repl_offset</span> | Number of bytes sent to replicas by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_master_sync_in_progress</span> | The primary shard is synchronizing (1 true; 0 false) |
+| <span class="break-all">redis_server_max_process_mem</span> | Current memory limit configured by redis_mgr according to node free memory |
+| <span class="break-all">redis_server_maxmemory</span> | Current memory limit configured by redis_mgr according to database memory limits |
+| <span class="break-all">redis_server_mem_aof_buffer</span> | Current size of AOF buffer |
+| <span class="break-all">redis_server_mem_clients_normal</span> | Current memory used for input and output buffers of non-replica clients |
+| <span class="break-all">redis_server_mem_clients_slaves</span> | Current memory used for input and output buffers of replica clients |
+| <span class="break-all">redis_server_mem_fragmentation_ratio</span> | Memory fragmentation ratio (1.3 means 30% overhead) |
+| <span class="break-all">redis_server_mem_not_counted_for_evict</span> | Portion of used_memory (in bytes) that's not counted for eviction and OOM error |
+| <span class="break-all">redis_server_mem_replication_backlog</span> | Size of replication backlog |
+| <span class="break-all">redis_server_module_fork_in_progress</span> | A binary value that indicates if there is an active fork spawned by a module (1) or not (0) |
+| <span class="break-all">namedprocess_namegroup_cpu_seconds_total</span> | Shard process CPU usage in seconds |
+| <span class="break-all">namedprocess_namegroup_thread_cpu_seconds_total</span> | Shard main thread CPU time spent in seconds |
+| <span class="break-all">namedprocess_namegroup_open_filedesc</span> | Shard number of open file descriptors |
+| <span class="break-all">namedprocess_namegroup_memory_bytes</span> | Shard memory size in bytes |
+| <span class="break-all">namedprocess_namegroup_oldest_start_time_seconds</span> | Shard start time of the process since unix epoch in seconds |
+| <span class="break-all">redis_server_rdb_bgsave_in_progress</span> | Indication if bgsave is currently in progress |
+| <span class="break-all">redis_server_rdb_last_cow_size</span> | Last bgsave (or SYNC fork) used CopyOnWrite memory |
+| <span class="break-all">redis_server_rdb_saves</span> | Total count of bgsaves since the process was restarted (including replica fullsync and persistence) |
+| <span class="break-all">redis_server_repl_touch_bytes</span> | Number of bytes sent to replicas as TOUCH commands by the shard as a result of a READ command that was processed; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_total_commands_processed</span> | Number of commands processed by the shard; calculate the number of commands for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_total_connections_received</span> | Number of connections received by the shard; calculate the number of connections for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_total_net_input_bytes</span> | Number of bytes received by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_total_net_output_bytes</span> | Number of bytes sent by the shard; calculate the throughput for a time period by comparing the value at different times |
+| <span class="break-all">redis_server_up</span> | Shard is up and running |
+| <span class="break-all">redis_server_used_memory</span> | Memory used by shard (in BigRedis this includes flash) (bytes) |
+| <span class="break-all">redis_server_search_gc_bytes_collected</span> | The total amount of memory freed by the garbage collectors from indexes in the shard's memory in bytes. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_bytes_collected</span> | The total amount of memory freed by the garbage collectors from indexes in the shard's memory in bytes. Deprecated in 8.0 (renamed redis_server_search_gc_bytes_collected), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_gc_marked_deleted_vectors</span> | The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_marked_deleted_vectors</span> | The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. Deprecated in 8.0 (renamed redis_server_search_gc_marked_deleted_vectors), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_gc_total_cycles</span> | The total number of garbage collection cycles executed. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_total_cycles</span> | The total number of garbage collection cycles executed. Deprecated in 8.0 (renamed redis_server_search_gc_total_cycles), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_gc_total_docs_not_collected_by_gc</span> | The number of documents marked as deleted, whose memory has not yet been freed by the garbage collector. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_total_docs_not_collected_by_gc</span> | The number of documents marked as deleted, whose memory has not yet been freed by the garbage collector. Deprecated in 8.0 (renamed redis_server_search_gc_total_docs_not_collected_by_gc), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_gc_total_ms_run</span> | The total duration of all garbage collection cycles in the shard, measured in milliseconds. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_total_ms_run</span> | The total duration of all garbage collection cycles in the shard, measured in milliseconds. Deprecated in 8.0 (renamed redis_server_search_gc_total_ms_run), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_cursors_internal_idle</span> | The total number of coordinator cursors that are currently holding pending results in the shard. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_cursors_user_idle</span> | The total number of cursors that were explicitly requested by users, that are currently holding pending results in the shard. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_global_idle</span> | The total number of user and internal cursors currently holding pending results in the shard. Deprecated in 8.0 (split into redis_server_search_cursors_internal_idle and redis_server_search_cursors_user_idle), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_cursors_internal_active</span> | The total number of coordinator cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_cursors_user_active</span> | The total number of user cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. <sup>[3](#tnote-3)</sup> |
+| <span class="break-all">redis_server_search_global_total</span> | The total number of user and internal cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. Deprecated in 8.0 (split into redis_server_search_cursors_internal_active and redis_server_search_cursors_user_active), but still available in older versions. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_number_of_indexes</span> | Total number of indexes in the shard <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_number_of_active_indexes</span> | The total number of indexes running a background indexing and/or background query processing operation. Background indexing refers to vector ingestion process, or in-progress background indexer. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_number_of_active_indexes_running_queries</span> | Total count of indexes currently running a background query process. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_number_of_active_indexes_indexing</span> | Total count of indexes currently undergoing a background indexing process. Background indexing refers to vector ingestion process, or in-progress background indexer. This metric is limited by the number of WORKER threads allocated for writing operations + the number of indexes. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_active_write_threads</span> | Total count of background write (indexing) processes currently running in the shard. Background indexing refers to vector ingestion process, or in-progress background indexer. This metric is limited by the number of threads allocated for writing operations. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_text_Text</span> | The total number of `TEXT` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_text_Sortable</span> | The total number of `SORTABLE TEXT` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_text_NoIndex</span> | The total number of `NOINDEX TEXT` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_numeric_Numeric</span> | The total number of `NUMERIC` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_numeric_Sortable</span> | The total number of `SORTABLE NUMERIC` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_numeric_NoIndex</span> | The total number of `NOINDEX NUMERIC` fields across all indexes in the shard, which are used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_tag_Tag</span> | The total number of `TAG` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_tag_Sortable</span> | The total number of `SORTABLE TAG` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_tag_NoIndex</span> | The total number of `NOINDEX TAG` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_tag_CaseSensitive</span> | The total number of `CASESENSITIVE TAG` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_geo_Geo</span> | The total number of `GEO` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_geo_Sortable</span> | The total number of `SORTABLE GEO` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_geo_NoIndex</span> | The total number of `NOINDEX GEO` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_vector_Vector</span> | The total number of `VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_vector_Flat</span> | The total number of `FLAT VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_vector_HNSW</span> | The total number of `HNSW VECTOR` fields across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_fields_geoshape_Geoshape</span> | The total number of `GEOSHAPE` fields across all indexes in the shard. <sup>[2](#tnote-2)</sup> |
+| <span class="break-all">redis_server_search_fields_geoshape_Sortable</span> | The total number of `SORTABLE GEOSHAPE` fields across all indexes in the shard. This field appears only if its value is larger than 0. <sup>[2](#tnote-2)</sup> |
+| <span class="break-all">redis_server_search_fields_geoshape_NoIndex</span> | The total number of `NOINDEX GEOSHAPE` fields across all indexes in the shard; i.e., used for sorting only but not indexed. This field appears only if its value is larger than 0. <sup>[2](#tnote-2)</sup> |
+| <span class="break-all">redis_server_search_fields_<field>_IndexErrors</span> | The total number of indexing failures caused by attempts to index a document containing `<field>` field. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_used_memory_indexes</span> | The total memory allocated by all indexes in the shard in bytes. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_smallest_memory_index</span> | The memory usage of the index with the smallest memory usage in the shard in bytes. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_largest_memory_index</span> | The memory usage of the index with the largest memory usage in the shard in bytes. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_indexing_time</span> | The total time spent on indexing operations, excluding the background indexing of vectors in the `HNSW` graph. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_used_memory_vector_index</span> | The total memory usage of all vector indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_global_idle</span> | The total number of user and internal cursors currently holding pending results in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_global_total</span> | The total number of user and internal cursors in the shard, either holding pending results or actively executing `FT.CURSOR READ`. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_bytes_collected</span> | The total amount of memory freed by the garbage collectors from indexes in the shard memory in bytes. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_cycles</span> | The total number of garbage collection cycles executed <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_ms_run</span> | The total duration of all garbage collection cycles in the shard, measured in milliseconds. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_docs_not_collected_by_gc</span> | The number of documents marked as deleted whose memory has not yet been freed by the garbage collector. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_marked_deleted_vectors</span> | The number of vectors marked as deleted in the vector indexes that have not yet been cleaned. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_queries_processed</span> | The total number of successful query executions (When using cursors, not counting reading from existing cursors) in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_query_commands</span> | The total number of successful query command executions (including `FT.SEARCH`, `FT.AGGREGATE`, and `FT.CURSOR READ`). <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_query_execution_time_ms</span> | The cumulative execution time of all query commands, including `FT.SEARCH`, `FT.AGGREGATE`, and `FT.CURSOR READ`, measured in ms. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_total_active_queries</span> | The total number of background queries currently being executed in the shard, excluding `FT.CURSOR READ`. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_errors_indexing_failures</span> | The total number of indexing failures recorded across all indexes in the shard. <sup>[1](#tnote-1)</sup> |
+| <span class="break-all">redis_server_search_errors_for_index_with_max_failures</span> | The number of indexing failures in the index with the highest count of failures. <sup>[1](#tnote-1)</sup> |
+
+1. <a name="tnote-1"></a> Available since RediSearch 2.6.
+2. <a name="tnote-2"></a> Available since RediSearch 2.8.
+3. <a name="tnote-3"></a> Available since RediSearch 8.0.* [Redis-py](https://github.com/andymccurdy/redis-py) (Python redis client)
+* [HiRedis](https://github.com/redis/hiredis) (C redis client)
+* [Jedis](https://github.com/xetorthio/jedis) (Java redis client)
+* [Ioredis](https://github.com/luin/ioredis) (NodeJS redis client)
+
+If you need to use another client, consider using [Sentinel Tunnel](https://github.com/RedisLabs/sentinel_tunnel)
+to discover the current Redis master with Sentinel and create a TCP tunnel between a local port on the client and the master.
+### Migration guides for certain clients
+
+If you are using [Go-Redis](https://redis.uptrace.dev/) v9 or [Lettuce](https://redis.github.io/lettuce/) v6+, which by default switch to the RESP3 protocol, and you are running Redis Stack commands, please make sure the protocol version is pinned to RESP2 prior to upgrading to Redis version 7.2.
+
+#### Go-Redis
+
+For applications using Go-Redis v9 and later, ensure that you have Go-Redis v9.0.5 or newer and pin the protocol version as shown below:
+
+```go
+client := redis.NewClient(&redis.Options{
+    Addr:     "<database_endpoint>",
+    Protocol: 2, // Pin the protocol version
+})
+```
+
+No actions are required for applications using Go-Redis v8 or earlier.
+
+#### Lettuce
+
+To pin the protocol version, use the snippet below:
+
+```java
+import io.lettuce.core.*;
+import io.lettuce.core.api.*;
+import io.lettuce.core.protocol.ProtocolVersion;
+
+// ...
+RedisClient client = RedisClient.create("<database_endpoint>");
+client.setOptions(ClientOptions.builder()
+        .protocolVersion(ProtocolVersion.RESP2) // Pin the protocol version 	
+        .build());
+// ...
+```
+
+If you are using [LettuceMod](https://github.com/redis-developer/lettucemod/), you need to upgrade to [v3.6.0](https://github.com/redis-developer/lettucemod/releases/tag/v3.6.0).Redis contributes extensively to the Redis project and uses it inside of Redis Enterprise Software and Redis Cloud. As a rule, we adhere to the project's specifications and update both products with the latest version of Redis.
+
+## Redis commands
+
+See [Compatibility with Redis commands]({{< relref "/operate/rs/references/compatibility/commands" >}}) to learn which Redis commands are compatible with Redis Enterprise Software and Redis Cloud.
+
+## Configuration settings
+
+[Compatibility with Redis configuration settings]({{< relref "/operate/rs/references/compatibility/config-settings" >}}) lists the Redis configuration settings supported by Redis Enterprise Software and Redis Cloud.
+
+## Redis clients
+
+You can use any standard [Redis client]({{< relref "/develop/clients" >}}) with Redis Enterprise Software and Redis Cloud.* Redis Enterprise v6.4 or greater for the cluster.
+* For production, 250MB RAM with one primary and one replica is recommended, but for the
+  quickstart or for development, 125MB and a single shard is sufficient.
+* If you are deploying RDI for a production environment then secure this database with a password
+  and TLS.
+* Set the database's
+  [eviction policy]({{< relref "/operate/rs/databases/memory-performance/eviction-policy" >}}) to `noeviction`. Note that you can't set this using
+  [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}),
+  so you must either do it using the admin UI or with the following
+  [REST API]({{< relref "/operate/rs/references/rest-api" >}})
+  command:
+
+  ```bash
+  curl -v -k -d '{"eviction_policy": "noeviction"}' \
+    -u '<USERNAME>:<PASSWORD>' \
+    -H "Content-Type: application/json" \
+    -X PUT https://<CLUSTER_FQDN>:9443/v1/bdbs/<BDB_UID>
+  ```
+* Set the database's
+  [data persistence]({{< relref "/operate/rs/databases/configure/database-persistence" >}})
+  to AOF - fsync every 1 sec. Note that you can't set this using
+  [`rladmin`]({{< relref "/operate/rs/references/cli-utilities/rladmin" >}}),
+  so you must either do it using the admin UI or with the following
+  [REST API]({{< relref "/operate/rs/references/rest-api" >}})
+  commands:
+
+  ```bash
+  curl -v -k -d '{"data_persistence":"aof"}' \
+    -u '<USERNAME>:<PASSWORD>' \
+    -H "Content-Type: application/json" 
+    -X PUT https://<CLUSTER_FQDN>:9443/v1/bdbs/<BDB_UID>
+  curl -v -k -d '{"aof_policy":"appendfsync-every-sec"}' \
+    -u '<USERNAME>:<PASSWORD>' \
+    -H "Content-Type: application/json" \
+    -X PUT https://<CLUSTER_FQDN>:9443/v1/bdbs/<BDB_UID>
+  ```
+* **Ensure that the RDI database is not clustered.** RDI will not work correctly if the
+  RDI database is clustered, but it is OK for the target database to be clustered.
+To encrypt Replica Of synchronization traffic, you must also [configure encryption for the replica database]({{< relref "/operate/rs/databases/import-export/replica-of/create#configure-tls-on-replica-database" >}}) (the destination).
+
+### Encrypt source synchronization traffic
+
+To enable TLS for Replica Of communication only on the source database:
+
+1. In **databases**, either:
+    - Create a new database.
+    - Select a database to configure and then select **Edit**.
+
+1. Enable **TLS**.
+
+    {{< image filename="/images/rs/database-tls-config.png" alt="Database TLS Configuration" >}}
+
+1. Select the communication that you want to secure:
+
+    - For a new database - **Require TLS for Replica Of communications only** is
+    selected by default.
+
+    - For an existing database that is configured to **Require TLS for all
+    communications** - Select **Require TLS for Replica Of communications only**.
+
+    By default, client authentication is enforced.  This means you must enter the syncer certificates
+    of the clusters hosting the replicas (the destination databases).
+
+1. To enter the syncer certificates:
+
+    1. Copy the syncer certificates for each cluster with a destination database:
+    
+        1. Sign in to the cluster.
+        1. Go to **Settings**.
+        1. In the syncer certificates box, copy the full text of the certificate to the Clipboard.
+
+    1. Select the **Add** button to open the certificate dialog.  
+    {{< image filename="/images/rs/icon_add.png#no-click" alt="Add button" >}} 
+
+        {{< image filename="/images/rs/database-tls-replica-certs.png" alt="Database TLS Configuration" >}}
+
+    1. Enter the copied certificate text into the text box below the **Enforce client authentication** checkbox.
+
+    1. Use the **Save** button to save the certificates.  
+    {{< image filename="/images/rs/icon_save.png#no-click" alt="Save button" >}}
+
+    You can also clear **Enforce client authentication** so that all clusters or
+    clients can connect to your database without authentication.
+
+    To encrypt Replica Of synchronization traffic, you must also [configure encryption for the replica database]({{< relref "/operate/rs/databases/import-export/replica-of/create#configure-tls-on-replica-database" >}}) (the destination).
+
+### Encrypt all source communication
+
+To enable TLS for Replica Of and client communication on the source database:
+
+1. From the **Databases** menu of the admin console, either:
+
+    - Create a new database.
+
+    - Select an existing database and then select the **Edit** button.
+
+1. Enable **TLS** and select **Require TLS for all communications**.
+
+    {{< image filename="/images/rs/database-tls-all.png" alt="database-tls-all" >}}
+
+    By default, client authentication is enforced so you must enter the syncer
+    certificates of the clusters that host the destination databases.
+
+    You also need to add the certificates of the clients that connect to the database.
+
+1. To enter the syncer and client certificates:
+
+    1. Copy the entire text of the syncer and client certificates.
+
+        For each cluster with a destination database:
+
+        1. Sign in to the cluster.
+        1. Go to **Settings**.
+        1. In the syncer certificates box, copy the full text of the certificate to the Clipboard.
+
+    1. Use the **Add** button to open the certificate dialog.  
+    {{< image filename="/images/rs/icon_add.png#no-click" alt="Add button" >}}
+
+        {{< image filename="/images/rs/database-tls-replica-certs.png" alt="Database TLS Configuration" >}}
+
+    1. Enter the copied certificate text into the text box below the **Enforce client authentication** checkbox.
+    1. Use the **Save** button to save your changes.  
+    {{< image filename="/images/rs/icon_save.png#no-click" alt="Save button" >}} 
+
+    You can also clear the **Enforce client authentication** checkbox to allow 
+    client connections without authentication.
+As of January 2024, new and upgraded Redis Cloud Essentials subscriptions are limited to one database per subscription. If you have a Redis Cloud Essentials subscription created before January 2024, you can add databases up to the previous plan limit. If you choose to upgrade your plan, you can keep your databases, but you will need to create a new subscription to add another database.### FTP server
+
+Before you choose to backup to an FTP server, make sure that:
+
+- The RS cluster has network connectivity to the FTP server.
+- The user that you specify in the FTP server location has read and write priviledges.
+
+To backup to an FTP server, enter the FTP server location in the format:
+
+```sh
+ftp://user:password@host<:custom_port>/path/
+```
+
+For example: `ftp://username:password@10.1.1.1/home/backups/`
+
+### SFTP server
+
+Before you choose to backup to an SFTP server, make sure that:
+
+- The RS cluster has network connectivity to the SFTP server.
+- The user that you specify in the SFTP server location has read and write priviledges.
+- The RS server and SFTP server have the correct TLS certificates. You can select either:
+    - **Use the cluster auto generated key** - Go to **settings** and copy the **Cluster SSH Public Key**
+        to the SFTP server.
+    - **Use a custom key** - Generate a TLS key pair for the SFTP server, copy the private key to
+        the **SSH Private Key** box, and copy the public key to the location required by the SFTP server.
+
+To backup to an SFTP server, enter the SFTP server location in the format:
+
+```sh
+sftp://user:password@host:<:custom_port>/path/
+```
+
+For example: `sftp://username:password@10.1.1.1/home/backups/`
+
+### AWS S3
+
+Before you choose to backup to Amazon AWS S3, make sure that you have:
+
+- Storage location path in the format: `s3://bucketname/path/`
+- Access key ID
+- Secret access key
+
+You can also connect to a storage service that uses the S3 protocol but is not hosted by Amazon AWS.
+The storage service must have a valid SSL certificate.
+To connect to an S3-compatible storage location, run: `rladmin cluster config s3_url <url>`
+
+### Local mount point
+
+Before you choose to backup to a local mount point, make sure that:
+
+- The node has network connectivity to the destination server of the mount point.
+- The `redislabs:redislabs` user has read and write priviledges on the local mount point
+and on the destination server.
+- The backup location has enough disk space for your backup files. The backup files
+are saved with filenames that include the timestamp so that backup files are not overwritten.
+
+To backup to a local mount point for a node:
+
+1. On each node in the cluster, create the mount point:
+    1. Connect to the terminal of the RS server that the node is running on.
+    1. Mount the remote storage to a local mount point.
+
+        For example:
+
+        ```sh
+        sudo mount -t nfs 192.168.10.204:/DataVolume/Public /mnt/Public
+        ```
+
+1. In the path for the backup location, enter the mount point.
+
+    For example: `/mnt/Public`
+
+### Azure Blob Storage
+
+Before you choose to backup to Azure Blob Storage, make sure that you have:
+
+- Storage location path in the format: `/container_name/[path/]/`
+- Account name
+- An authentication token, either an account key or an Azure [shared access signature](https://docs.microsoft.com/en-us/rest/api/storageservices/delegate-access-with-shared-access-signature) (SAS).
+
+Azure SAS support requires Redis Software version 6.0.20.  To learn more about Azure SAS, see [Grant limited access to Azure Storage resources using shared access signatures](https://docs.microsoft.com/en-us/azure/storage/common/storage-sas-overview).
+
+### Google Cloud Storage
+
+Before you choose to backup to Google Cloud Storage, make sure that you have:
+
+- Storage location path in the format: `/bucket_name/[path/]/`
+- Client ID
+- Client email
+- Private key ID
+- Private key
+
+{{< note >}}
+
+You can find the client and key details in your service account in the Google Cloud console (**API & Services** > **Credentials** > **Create Credentials**).
+
+- Make sure that the service account has the `Storage Legacy Bucket Writer` permission on the target bucket.
+- Make sure that the bucket doesn't use a retention policy because it can interfere with the process.
+- The format of the private key from the downloaded JSON is in a single string where new lines are marked with `\n` characters.
+    When you paste the key into the RS admin console, replace each `\n` character with a new line.
+
+{{< /note >}}
+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]({{< relref "/operate/rs/clusters/configure/rack-zone-awareness" >}})
+- Memory available to host the database when fully populated
+
+The shard placement policies are:
+
+- `dense` - Place as many shards as possible on the smallest number of nodes to reduce the latency between the proxy and the database shards;
+    Recommended for Redis on RAM databases to optimize memory resources
+- `sparse` - Spread the shards across as many nodes in the cluster as possible to spread the traffic across cluster nodes;
+    Recommended for databases with Auto Tiering enabled to optimize disk resources
+
+When you create a Redis Enterprise Software cluster, the default shard placement policy (`dense`) is assigned to all databases that you create on the cluster.
+
+You can:
+
+- Change the default shard placement policy for the cluster to `sparse` so that the cluster applies that policy to all databases that you create
+- Change the shard placement policy for each database after the database is createdSelect **Opt-in to 7.2** to request to upgrade your subscription and databases to Redis 7.2 (*Redis 6.2 and earlier only*).
+
+{{<image filename="images/rc/button-opt-in-to-72.png" width=150px alt="Opt-in to 7.2 button." >}}
+
+The upgrade will start one week from your request, according to [maintenance windows]({{< relref "/operate/rc/subscriptions/maintenance/set-maintenance-windows" >}}). 
+
+Redis 7.2 introduces several changes to existing Redis commands; see the list of [breaking changes]({{< relref "/operate/rc/changelog/2023/june-2023#redis-72-breaking-changes" >}}) for more details.---
+description: Get started with Redis Open Source
+hideListLinks: true
+linkTitle: Open Source
+title: Open Source
+type: develop
+---
+Redis is an [in-memory data store]({{< relref "/develop/get-started/data-store" >}}) used by millions of developers as a cache, [vector database]({{< relref "/develop/get-started/vector-database" >}}), [document database]({{< relref "/develop/get-started/document-database" >}}), [streaming engine]({{< relref "/develop/data-types/streams" >}}), and message broker. Redis has built-in replication and different levels of [on-disk persistence]({{< relref "/operate/oss_and_stack/management/persistence" >}}). It supports complex [data types]({{< relref "/develop/data-types/" >}}) (for example, strings, hashes, lists, sets, sorted sets, and JSON), with atomic operations defined on those data types.
+
+You can install Redis from source or from an executable/distribution for your OS.
+
+* Install Redis on Linux using [APT]({{< relref "/operate/oss_and_stack/install/install-stack/apt" >}}), [RPM]({{< relref "/operate/oss_and_stack/install/install-stack/rpm" >}}), or [Snap]({{< relref "/operate/oss_and_stack/install/install-stack/snap" >}})
+* [Install Redis on macOS]({{< relref "/operate/oss_and_stack/install/install-stack/homebrew" >}})
+* [Run Redis on Windows using Docker]({{< relref "/operate/oss_and_stack/install/install-stack/windows" >}})
+* [Run Redis on Docker]({{< relref "/operate/oss_and_stack/install/install-stack/docker" >}})
+* [Install Redis from Source]({{< relref "/operate/oss_and_stack/install/build-stack" >}})
+* [Install Redis with Redis Stack and Redis Insight]({{< relref "/operate/oss_and_stack/install/archive/install-stack" >}})
+
+## Use cases
+
+The following quick start guides will show you how to use Redis for the following specific purposes:
+
+- [Data structure store]({{< relref "/develop/get-started/data-store" >}})
+- [Document database]({{< relref "/develop/get-started/document-database" >}})
+- [Vector database]({{< relref "/develop/get-started/vector-database" >}})
+- [AI agents and chatbots]({{< relref "/develop/get-started/redis-in-ai" >}})
+- [Retrieval Augmented Generation (RAG) with Redis]({{< relref "/develop/get-started/rag" >}})
+
+## Data integration tools, libraries, and frameworks
+- [Client API libraries]({{< relref "/develop/clients" >}})
+- [Redis Data Integration]({{< relref "/integrate/redis-data-integration/" >}})
+- [Redis vector library for Python]({{< relref "/integrate/redisvl/" >}})
+- [Redis Cloud with Amazon Bedrock]({{< relref "/integrate/amazon-bedrock/" >}})
+- [Object-mapping for .NET]({{< relref "/integrate/redisom-for-net/" >}})
+- [Spring Data Redis for Java]({{< relref "/integrate/spring-framework-cache/" >}})
+
+You can find a complete list of integrations on the [integrations and frameworks hub]({{< relref "/integrate/" >}}).
+
+To learn more, refer to the [develop with Redis]({{< relref "/develop/" >}}) documentation.
+
+## Deployment options
+
+You can deploy Redis with the following methods:
+
+- As a service by using [Redis Cloud]({{< relref "/operate/rc/" >}}), the fastest way to deploy Redis on your preferred cloud platform.
+- By installing [Redis Enterprise Software]({{< relref "/operate/rs/" >}}) in an on-premises data center or on Cloud infrastructure.
+- On a variety Kubernetes distributions by using the [Redis Enterprise operator for Kubernetes]({{< relref "/operate/kubernetes/" >}}).
+
+The following guides will help you to get started with your preferred deployment method.
+
+Get started with **[Redis Cloud]({{< relref "/operate/rc/" >}})** by creating a database:
+
+- The [Redis Cloud quick start]({{< relref "/operate/rc/rc-quickstart" >}}) helps you create a free database.  (Start here if you're new.)
+- [Create an Essentials database]({{< relref "/operate/rc/databases/create-database/create-essentials-database" >}}) with a memory limit up to 12 GB.
+- [Create a Pro database]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}) that suits your workload and offers seamless scaling.
+
+Install a **[Redis Enterprise Software]({{< relref "/operate/rs/" >}})** cluster:
+
+- [Redis Enterprise on Linux quick start]({{<relref "/operate/rs/installing-upgrading/quickstarts/redis-enterprise-software-quickstart" >}})
+- [Redis Enterprise on Docker quick start]({{<relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}})
+- [Get started with Redis Enterprise's Active-Active feature]({{<relref "/operate/rs/databases/active-active/get-started" >}})
+- [Install and upgrade Redis Enterprise]({{<relref "/operate/rs/installing-upgrading">}})
+
+Leverage **[Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/" >}})** to simply deploy a Redis Enterprise cluster on Kubernetes:
+
+- [Deploy Redis Enterprise for Kubernetes]({{< relref "/operate/kubernetes/deployment/quick-start" >}})
+- [Deploy Redis Enterprise for Kubernetes with OpenShift]({{< relref "/operate/kubernetes/deployment/openshift/" >}})
+
+To learn more, refer to the [Redis products]({{< relref "/operate/" >}}) documentation.
+
+## Provisioning and observability tools 
+
+- [Pulumi provider for Redis Cloud]({{< relref "/integrate/pulumi-provider-for-redis-cloud/" >}})
+- [Terraform provider for Redis Cloud]({{< relref "/integrate/terraform-provider-for-redis-cloud/" >}})
+- [Prometheus and Grafana with Redis Cloud]({{< relref "/integrate/prometheus-with-redis-cloud" >}})
+- [Prometheus and Grafana with Redis Enterprise]({{< relref "/integrate/prometheus-with-redis-enterprise/" >}})
+
+You can find a complete list of integrations on the [libraries and tools hub]({{< relref "/integrate/" >}}).
+
+